diff --git a/vendor/golang.org/x/tools/.gitattributes b/vendor/golang.org/x/tools/.gitattributes
new file mode 100644
index 0000000..d2f212e
--- /dev/null
+++ b/vendor/golang.org/x/tools/.gitattributes
@@ -0,0 +1,10 @@
+# Treat all files in this repo as binary, with no git magic updating
+# line endings. Windows users contributing to Go will need to use a
+# modern version of git and editors capable of LF line endings.
+#
+# We'll prevent accidental CRLF line endings from entering the repo
+# via the git-review gofmt checks.
+#
+# See golang.org/issue/9281
+
+* -text
diff --git a/vendor/golang.org/x/tools/.gitignore b/vendor/golang.org/x/tools/.gitignore
new file mode 100644
index 0000000..5a9d62e
--- /dev/null
+++ b/vendor/golang.org/x/tools/.gitignore
@@ -0,0 +1,2 @@
+# Add no patterns to .gitignore except for files generated by the build.
+last-change
diff --git a/vendor/golang.org/x/tools/AUTHORS b/vendor/golang.org/x/tools/AUTHORS
new file mode 100644
index 0000000..15167cd
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/CONTRIBUTING.md b/vendor/golang.org/x/tools/CONTRIBUTING.md
new file mode 100644
index 0000000..88dff59
--- /dev/null
+++ b/vendor/golang.org/x/tools/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to Go
+
+Go is an open source project.
+
+It is the work of hundreds of contributors. We appreciate your help!
+
+
+## Filing issues
+
+When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
+
+1. What version of Go are you using (`go version`)?
+2. What operating system and processor architecture are you using?
+3. What did you do?
+4. What did you expect to see?
+5. What did you see instead?
+
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.
+
+## Contributing code
+
+Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
+before sending patches.
+
+**We do not accept GitHub pull requests**
+(we use [Gerrit](https://code.google.com/p/gerrit/) instead for code review).
+
+Unless otherwise noted, the Go source files are distributed under
+the BSD-style license found in the LICENSE file.
+
diff --git a/vendor/golang.org/x/tools/CONTRIBUTORS b/vendor/golang.org/x/tools/CONTRIBUTORS
new file mode 100644
index 0000000..1c4577e
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/README.md b/vendor/golang.org/x/tools/README.md
new file mode 100644
index 0000000..20be9e1
--- /dev/null
+++ b/vendor/golang.org/x/tools/README.md
@@ -0,0 +1,27 @@
+# Go Tools
+
+This subrepository holds the source for various packages and tools that support
+the Go programming language.
+
+Some of the tools, `godoc` and `vet` for example, are included in binary Go
+distributions.
+
+Others, including the Go `guru` and the test coverage tool, can be fetched with
+`go get`.
+
+Packages include a type-checker for Go and an implementation of the
+Static Single Assignment form (SSA) representation for Go programs.
+
+## Download/Install
+
+The easiest way to install is to run `go get -u golang.org/x/tools/...`. You can
+also manually git clone the repository to `$GOPATH/src/golang.org/x/tools`.
+
+## Report Issues / Send Patches
+
+This repository uses Gerrit for code changes. To learn how to submit changes to
+this repository, see https://golang.org/doc/contribute.html.
+
+The main issue tracker for the tools repository is located at
+https://github.com/golang/go/issues. Prefix your issue with "x/tools/(your
+subdir):" in the subject line, so it is easy to find.
diff --git a/vendor/golang.org/x/tools/benchmark/parse/parse.go b/vendor/golang.org/x/tools/benchmark/parse/parse.go
new file mode 100644
index 0000000..b37e6f0
--- /dev/null
+++ b/vendor/golang.org/x/tools/benchmark/parse/parse.go
@@ -0,0 +1,131 @@
+// 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 parse provides support for parsing benchmark results as
+// generated by 'go test -bench'.
+package parse // import "golang.org/x/tools/benchmark/parse"
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// Flags used by Benchmark.Measured to indicate
+// which measurements a Benchmark contains.
+const (
+	NsPerOp = 1 << iota
+	MBPerS
+	AllocedBytesPerOp
+	AllocsPerOp
+)
+
+// Benchmark is one run of a single benchmark.
+type Benchmark struct {
+	Name              string  // benchmark name
+	N                 int     // number of iterations
+	NsPerOp           float64 // nanoseconds per iteration
+	AllocedBytesPerOp uint64  // bytes allocated per iteration
+	AllocsPerOp       uint64  // allocs per iteration
+	MBPerS            float64 // MB processed per second
+	Measured          int     // which measurements were recorded
+	Ord               int     // ordinal position within a benchmark run
+}
+
+// ParseLine extracts a Benchmark from a single line of testing.B
+// output.
+func ParseLine(line string) (*Benchmark, error) {
+	fields := strings.Fields(line)
+
+	// Two required, positional fields: Name and iterations.
+	if len(fields) < 2 {
+		return nil, fmt.Errorf("two fields required, have %d", len(fields))
+	}
+	if !strings.HasPrefix(fields[0], "Benchmark") {
+		return nil, fmt.Errorf(`first field does not start with "Benchmark"`)
+	}
+	n, err := strconv.Atoi(fields[1])
+	if err != nil {
+		return nil, err
+	}
+	b := &Benchmark{Name: fields[0], N: n}
+
+	// Parse any remaining pairs of fields; we've parsed one pair already.
+	for i := 1; i < len(fields)/2; i++ {
+		b.parseMeasurement(fields[i*2], fields[i*2+1])
+	}
+	return b, nil
+}
+
+func (b *Benchmark) parseMeasurement(quant string, unit string) {
+	switch unit {
+	case "ns/op":
+		if f, err := strconv.ParseFloat(quant, 64); err == nil {
+			b.NsPerOp = f
+			b.Measured |= NsPerOp
+		}
+	case "MB/s":
+		if f, err := strconv.ParseFloat(quant, 64); err == nil {
+			b.MBPerS = f
+			b.Measured |= MBPerS
+		}
+	case "B/op":
+		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
+			b.AllocedBytesPerOp = i
+			b.Measured |= AllocedBytesPerOp
+		}
+	case "allocs/op":
+		if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
+			b.AllocsPerOp = i
+			b.Measured |= AllocsPerOp
+		}
+	}
+}
+
+func (b *Benchmark) String() string {
+	buf := new(bytes.Buffer)
+	fmt.Fprintf(buf, "%s %d", b.Name, b.N)
+	if (b.Measured & NsPerOp) != 0 {
+		fmt.Fprintf(buf, " %.2f ns/op", b.NsPerOp)
+	}
+	if (b.Measured & MBPerS) != 0 {
+		fmt.Fprintf(buf, " %.2f MB/s", b.MBPerS)
+	}
+	if (b.Measured & AllocedBytesPerOp) != 0 {
+		fmt.Fprintf(buf, " %d B/op", b.AllocedBytesPerOp)
+	}
+	if (b.Measured & AllocsPerOp) != 0 {
+		fmt.Fprintf(buf, " %d allocs/op", b.AllocsPerOp)
+	}
+	return buf.String()
+}
+
+// Set is a collection of benchmarks from one
+// testing.B run, keyed by name to facilitate comparison.
+type Set map[string][]*Benchmark
+
+// ParseSet extracts a Set from testing.B output.
+// ParseSet preserves the order of benchmarks that have identical
+// names.
+func ParseSet(r io.Reader) (Set, error) {
+	bb := make(Set)
+	scan := bufio.NewScanner(r)
+	ord := 0
+	for scan.Scan() {
+		if b, err := ParseLine(scan.Text()); err == nil {
+			b.Ord = ord
+			ord++
+			bb[b.Name] = append(bb[b.Name], b)
+		}
+	}
+
+	if err := scan.Err(); err != nil {
+		return nil, err
+	}
+
+	return bb, nil
+}
diff --git a/vendor/golang.org/x/tools/benchmark/parse/parse_test.go b/vendor/golang.org/x/tools/benchmark/parse/parse_test.go
new file mode 100644
index 0000000..06db848
--- /dev/null
+++ b/vendor/golang.org/x/tools/benchmark/parse/parse_test.go
@@ -0,0 +1,154 @@
+// 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 parse
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestParseLine(t *testing.T) {
+	cases := []struct {
+		line string
+		want *Benchmark
+		err  bool // expect an error
+	}{
+		{
+			line: "BenchmarkEncrypt	100000000	        19.6 ns/op",
+			want: &Benchmark{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6,
+				Measured: NsPerOp,
+			},
+		},
+		{
+			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s",
+			want: &Benchmark{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77,
+				Measured: NsPerOp | MBPerS,
+			},
+		},
+		{
+			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77",
+			want: &Benchmark{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6,
+				Measured: NsPerOp,
+			},
+		},
+		{
+			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s	       5 allocs/op",
+			want: &Benchmark{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocsPerOp: 5,
+				Measured: NsPerOp | MBPerS | AllocsPerOp,
+			},
+		},
+		{
+			line: "BenchmarkEncrypt	100000000	        19.6 ns/op	 817.77 MB/s	       3 B/op	       5 allocs/op",
+			want: &Benchmark{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocedBytesPerOp: 3, AllocsPerOp: 5,
+				Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
+			},
+		},
+		// error handling cases
+		{
+			line: "BenchPress	100	        19.6 ns/op", // non-benchmark
+			err: true,
+		},
+		{
+			line: "BenchmarkEncrypt	lots	        19.6 ns/op", // non-int iterations
+			err: true,
+		},
+		{
+			line: "BenchmarkBridge	100000000	        19.6 smoots", // unknown unit
+			want: &Benchmark{
+				Name: "BenchmarkBridge",
+				N:    100000000,
+			},
+		},
+		{
+			line: "PASS",
+			err:  true,
+		},
+	}
+
+	for _, tt := range cases {
+		have, err := ParseLine(tt.line)
+		if tt.err && err == nil {
+			t.Errorf("parsing line %q should have failed", tt.line)
+			continue
+		}
+		if !reflect.DeepEqual(have, tt.want) {
+			t.Errorf("parsed line %q incorrectly, want %v have %v", tt.line, tt.want, have)
+		}
+	}
+}
+
+func TestParseSet(t *testing.T) {
+	// Test two things:
+	// 1. The noise that can accompany testing.B output gets ignored.
+	// 2. Benchmarks with the same name have their order preserved.
+	in := `
+		?   	crypto	[no test files]
+		PASS
+				pem_decrypt_test.go:17: test 4. %!s(x509.PEMCipher=5)
+			... [output truncated]
+
+		BenchmarkEncrypt	100000000	        19.6 ns/op
+		BenchmarkEncrypt	 5000000	       517 ns/op
+		=== RUN TestChunk
+		--- PASS: TestChunk (0.00 seconds)
+		--- SKIP: TestLinuxSendfile (0.00 seconds)
+			fs_test.go:716: skipping; linux-only test
+		BenchmarkReadRequestApachebench	 1000000	      2960 ns/op	  27.70 MB/s	     839 B/op	       9 allocs/op
+		BenchmarkClientServerParallel64	   50000	     59192 ns/op	    7028 B/op	      60 allocs/op
+		ok  	net/http	95.783s
+	`
+
+	want := Set{
+		"BenchmarkReadRequestApachebench": []*Benchmark{
+			{
+				Name: "BenchmarkReadRequestApachebench",
+				N:    1000000, NsPerOp: 2960, MBPerS: 27.70, AllocedBytesPerOp: 839, AllocsPerOp: 9,
+				Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
+				Ord:      2,
+			},
+		},
+		"BenchmarkClientServerParallel64": []*Benchmark{
+			{
+				Name: "BenchmarkClientServerParallel64",
+				N:    50000, NsPerOp: 59192, AllocedBytesPerOp: 7028, AllocsPerOp: 60,
+				Measured: NsPerOp | AllocedBytesPerOp | AllocsPerOp,
+				Ord:      3,
+			},
+		},
+		"BenchmarkEncrypt": []*Benchmark{
+			{
+				Name: "BenchmarkEncrypt",
+				N:    100000000, NsPerOp: 19.6,
+				Measured: NsPerOp,
+				Ord:      0,
+			},
+			{
+				Name: "BenchmarkEncrypt",
+				N:    5000000, NsPerOp: 517,
+				Measured: NsPerOp,
+				Ord:      1,
+			},
+		},
+	}
+
+	have, err := ParseSet(strings.NewReader(in))
+	if err != nil {
+		t.Fatalf("unexpected err during ParseSet: %v", err)
+	}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("parsed bench set incorrectly, want %v have %v", want, have)
+	}
+}
diff --git a/vendor/golang.org/x/tools/blog/atom/atom.go b/vendor/golang.org/x/tools/blog/atom/atom.go
new file mode 100644
index 0000000..542c50e
--- /dev/null
+++ b/vendor/golang.org/x/tools/blog/atom/atom.go
@@ -0,0 +1,61 @@
+// Copyright 2009 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.
+
+// Adapted from encoding/xml/read_test.go.
+
+// Package atom defines XML data structures for an Atom feed.
+package atom // import "golang.org/x/tools/blog/atom"
+
+import (
+	"encoding/xml"
+	"time"
+)
+
+type Feed struct {
+	XMLName xml.Name `xml:"http://www.w3.org/2005/Atom feed"`
+	Title   string   `xml:"title"`
+	ID      string   `xml:"id"`
+	Link    []Link   `xml:"link"`
+	Updated TimeStr  `xml:"updated"`
+	Author  *Person  `xml:"author"`
+	Entry   []*Entry `xml:"entry"`
+}
+
+type Entry struct {
+	Title     string  `xml:"title"`
+	ID        string  `xml:"id"`
+	Link      []Link  `xml:"link"`
+	Published TimeStr `xml:"published"`
+	Updated   TimeStr `xml:"updated"`
+	Author    *Person `xml:"author"`
+	Summary   *Text   `xml:"summary"`
+	Content   *Text   `xml:"content"`
+}
+
+type Link struct {
+	Rel      string `xml:"rel,attr,omitempty"`
+	Href     string `xml:"href,attr"`
+	Type     string `xml:"type,attr,omitempty"`
+	HrefLang string `xml:"hreflang,attr,omitempty"`
+	Title    string `xml:"title,attr,omitempty"`
+	Length   uint   `xml:"length,attr,omitempty"`
+}
+
+type Person struct {
+	Name     string `xml:"name"`
+	URI      string `xml:"uri,omitempty"`
+	Email    string `xml:"email,omitempty"`
+	InnerXML string `xml:",innerxml"`
+}
+
+type Text struct {
+	Type string `xml:"type,attr"`
+	Body string `xml:",chardata"`
+}
+
+type TimeStr string
+
+func Time(t time.Time) TimeStr {
+	return TimeStr(t.Format("2006-01-02T15:04:05-07:00"))
+}
diff --git a/vendor/golang.org/x/tools/blog/blog.go b/vendor/golang.org/x/tools/blog/blog.go
new file mode 100644
index 0000000..4055b1b
--- /dev/null
+++ b/vendor/golang.org/x/tools/blog/blog.go
@@ -0,0 +1,437 @@
+// 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 blog implements a web server for articles written in present format.
+package blog // import "golang.org/x/tools/blog"
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"html/template"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/blog/atom"
+	"golang.org/x/tools/present"
+)
+
+var validJSONPFunc = regexp.MustCompile(`(?i)^[a-z_][a-z0-9_.]*$`)
+
+// Config specifies Server configuration values.
+type Config struct {
+	ContentPath  string // Relative or absolute location of article files and related content.
+	TemplatePath string // Relative or absolute location of template files.
+
+	BaseURL  string // Absolute base URL (for permalinks; no trailing slash).
+	BasePath string // Base URL path relative to server root (no trailing slash).
+	GodocURL string // The base URL of godoc (for menu bar; no trailing slash).
+	Hostname string // Server host name, used for rendering ATOM feeds.
+
+	HomeArticles int    // Articles to display on the home page.
+	FeedArticles int    // Articles to include in Atom and JSON feeds.
+	FeedTitle    string // The title of the Atom XML feed
+
+	PlayEnabled bool
+}
+
+// Doc represents an article adorned with presentation data.
+type Doc struct {
+	*present.Doc
+	Permalink string        // Canonical URL for this document.
+	Path      string        // Path relative to server root (including base).
+	HTML      template.HTML // rendered article
+
+	Related      []*Doc
+	Newer, Older *Doc
+}
+
+// Server implements an http.Handler that serves blog articles.
+type Server struct {
+	cfg      Config
+	docs     []*Doc
+	tags     []string
+	docPaths map[string]*Doc // key is path without BasePath.
+	docTags  map[string][]*Doc
+	template struct {
+		home, index, article, doc *template.Template
+	}
+	atomFeed []byte // pre-rendered Atom feed
+	jsonFeed []byte // pre-rendered JSON feed
+	content  http.Handler
+}
+
+// NewServer constructs a new Server using the specified config.
+func NewServer(cfg Config) (*Server, error) {
+	present.PlayEnabled = cfg.PlayEnabled
+
+	if notExist(cfg.TemplatePath) {
+		return nil, fmt.Errorf("template directory not found: %s", cfg.TemplatePath)
+	}
+	root := filepath.Join(cfg.TemplatePath, "root.tmpl")
+	parse := func(name string) (*template.Template, error) {
+		path := filepath.Join(cfg.TemplatePath, name)
+		if notExist(path) {
+			return nil, fmt.Errorf("template %s was not found in %s", name, cfg.TemplatePath)
+		}
+		t := template.New("").Funcs(funcMap)
+		return t.ParseFiles(root, path)
+	}
+
+	s := &Server{cfg: cfg}
+
+	// Parse templates.
+	var err error
+	s.template.home, err = parse("home.tmpl")
+	if err != nil {
+		return nil, err
+	}
+	s.template.index, err = parse("index.tmpl")
+	if err != nil {
+		return nil, err
+	}
+	s.template.article, err = parse("article.tmpl")
+	if err != nil {
+		return nil, err
+	}
+	p := present.Template().Funcs(funcMap)
+	s.template.doc, err = p.ParseFiles(filepath.Join(cfg.TemplatePath, "doc.tmpl"))
+	if err != nil {
+		return nil, err
+	}
+
+	// Load content.
+	err = s.loadDocs(filepath.Clean(cfg.ContentPath))
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.renderAtomFeed()
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.renderJSONFeed()
+	if err != nil {
+		return nil, err
+	}
+
+	// Set up content file server.
+	s.content = http.StripPrefix(s.cfg.BasePath, http.FileServer(http.Dir(cfg.ContentPath)))
+
+	return s, nil
+}
+
+var funcMap = template.FuncMap{
+	"sectioned": sectioned,
+	"authors":   authors,
+}
+
+// sectioned returns true if the provided Doc contains more than one section.
+// This is used to control whether to display the table of contents and headings.
+func sectioned(d *present.Doc) bool {
+	return len(d.Sections) > 1
+}
+
+// authors returns a comma-separated list of author names.
+func authors(authors []present.Author) string {
+	var b bytes.Buffer
+	last := len(authors) - 1
+	for i, a := range authors {
+		if i > 0 {
+			if i == last {
+				b.WriteString(" and ")
+			} else {
+				b.WriteString(", ")
+			}
+		}
+		b.WriteString(authorName(a))
+	}
+	return b.String()
+}
+
+// authorName returns the first line of the Author text: the author's name.
+func authorName(a present.Author) string {
+	el := a.TextElem()
+	if len(el) == 0 {
+		return ""
+	}
+	text, ok := el[0].(present.Text)
+	if !ok || len(text.Lines) == 0 {
+		return ""
+	}
+	return text.Lines[0]
+}
+
+// loadDocs reads all content from the provided file system root, renders all
+// the articles it finds, adds them to the Server's docs field, computes the
+// denormalized docPaths, docTags, and tags fields, and populates the various
+// helper fields (Next, Previous, Related) for each Doc.
+func (s *Server) loadDocs(root string) error {
+	// Read content into docs field.
+	const ext = ".article"
+	fn := func(p string, info os.FileInfo, err error) error {
+		if filepath.Ext(p) != ext {
+			return nil
+		}
+		f, err := os.Open(p)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		d, err := present.Parse(f, p, 0)
+		if err != nil {
+			return err
+		}
+		html := new(bytes.Buffer)
+		err = d.Render(html, s.template.doc)
+		if err != nil {
+			return err
+		}
+		p = p[len(root) : len(p)-len(ext)] // trim root and extension
+		p = filepath.ToSlash(p)
+		s.docs = append(s.docs, &Doc{
+			Doc:       d,
+			Path:      s.cfg.BasePath + p,
+			Permalink: s.cfg.BaseURL + p,
+			HTML:      template.HTML(html.String()),
+		})
+		return nil
+	}
+	err := filepath.Walk(root, fn)
+	if err != nil {
+		return err
+	}
+	sort.Sort(docsByTime(s.docs))
+
+	// Pull out doc paths and tags and put in reverse-associating maps.
+	s.docPaths = make(map[string]*Doc)
+	s.docTags = make(map[string][]*Doc)
+	for _, d := range s.docs {
+		s.docPaths[strings.TrimPrefix(d.Path, s.cfg.BasePath)] = d
+		for _, t := range d.Tags {
+			s.docTags[t] = append(s.docTags[t], d)
+		}
+	}
+
+	// Pull out unique sorted list of tags.
+	for t := range s.docTags {
+		s.tags = append(s.tags, t)
+	}
+	sort.Strings(s.tags)
+
+	// Set up presentation-related fields, Newer, Older, and Related.
+	for _, doc := range s.docs {
+		// Newer, Older: docs adjacent to doc
+		for i := range s.docs {
+			if s.docs[i] != doc {
+				continue
+			}
+			if i > 0 {
+				doc.Newer = s.docs[i-1]
+			}
+			if i+1 < len(s.docs) {
+				doc.Older = s.docs[i+1]
+			}
+			break
+		}
+
+		// Related: all docs that share tags with doc.
+		related := make(map[*Doc]bool)
+		for _, t := range doc.Tags {
+			for _, d := range s.docTags[t] {
+				if d != doc {
+					related[d] = true
+				}
+			}
+		}
+		for d := range related {
+			doc.Related = append(doc.Related, d)
+		}
+		sort.Sort(docsByTime(doc.Related))
+	}
+
+	return nil
+}
+
+// renderAtomFeed generates an XML Atom feed and stores it in the Server's
+// atomFeed field.
+func (s *Server) renderAtomFeed() error {
+	var updated time.Time
+	if len(s.docs) > 0 {
+		updated = s.docs[0].Time
+	}
+	feed := atom.Feed{
+		Title:   s.cfg.FeedTitle,
+		ID:      "tag:" + s.cfg.Hostname + ",2013:" + s.cfg.Hostname,
+		Updated: atom.Time(updated),
+		Link: []atom.Link{{
+			Rel:  "self",
+			Href: s.cfg.BaseURL + "/feed.atom",
+		}},
+	}
+	for i, doc := range s.docs {
+		if i >= s.cfg.FeedArticles {
+			break
+		}
+		e := &atom.Entry{
+			Title: doc.Title,
+			ID:    feed.ID + doc.Path,
+			Link: []atom.Link{{
+				Rel:  "alternate",
+				Href: doc.Permalink,
+			}},
+			Published: atom.Time(doc.Time),
+			Updated:   atom.Time(doc.Time),
+			Summary: &atom.Text{
+				Type: "html",
+				Body: summary(doc),
+			},
+			Content: &atom.Text{
+				Type: "html",
+				Body: string(doc.HTML),
+			},
+			Author: &atom.Person{
+				Name: authors(doc.Authors),
+			},
+		}
+		feed.Entry = append(feed.Entry, e)
+	}
+	data, err := xml.Marshal(&feed)
+	if err != nil {
+		return err
+	}
+	s.atomFeed = data
+	return nil
+}
+
+type jsonItem struct {
+	Title   string
+	Link    string
+	Time    time.Time
+	Summary string
+	Content string
+	Author  string
+}
+
+// renderJSONFeed generates a JSON feed and stores it in the Server's jsonFeed
+// field.
+func (s *Server) renderJSONFeed() error {
+	var feed []jsonItem
+	for i, doc := range s.docs {
+		if i >= s.cfg.FeedArticles {
+			break
+		}
+		item := jsonItem{
+			Title:   doc.Title,
+			Link:    doc.Permalink,
+			Time:    doc.Time,
+			Summary: summary(doc),
+			Content: string(doc.HTML),
+			Author:  authors(doc.Authors),
+		}
+		feed = append(feed, item)
+	}
+	data, err := json.Marshal(feed)
+	if err != nil {
+		return err
+	}
+	s.jsonFeed = data
+	return nil
+}
+
+// summary returns the first paragraph of text from the provided Doc.
+func summary(d *Doc) string {
+	if len(d.Sections) == 0 {
+		return ""
+	}
+	for _, elem := range d.Sections[0].Elem {
+		text, ok := elem.(present.Text)
+		if !ok || text.Pre {
+			// skip everything but non-text elements
+			continue
+		}
+		var buf bytes.Buffer
+		for _, s := range text.Lines {
+			buf.WriteString(string(present.Style(s)))
+			buf.WriteByte('\n')
+		}
+		return buf.String()
+	}
+	return ""
+}
+
+// rootData encapsulates data destined for the root template.
+type rootData struct {
+	Doc      *Doc
+	BasePath string
+	GodocURL string
+	Data     interface{}
+}
+
+// ServeHTTP serves the front, index, and article pages
+// as well as the ATOM and JSON feeds.
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	var (
+		d = rootData{BasePath: s.cfg.BasePath, GodocURL: s.cfg.GodocURL}
+		t *template.Template
+	)
+	switch p := strings.TrimPrefix(r.URL.Path, s.cfg.BasePath); p {
+	case "/":
+		d.Data = s.docs
+		if len(s.docs) > s.cfg.HomeArticles {
+			d.Data = s.docs[:s.cfg.HomeArticles]
+		}
+		t = s.template.home
+	case "/index":
+		d.Data = s.docs
+		t = s.template.index
+	case "/feed.atom", "/feeds/posts/default":
+		w.Header().Set("Content-type", "application/atom+xml; charset=utf-8")
+		w.Write(s.atomFeed)
+		return
+	case "/.json":
+		if p := r.FormValue("jsonp"); validJSONPFunc.MatchString(p) {
+			w.Header().Set("Content-type", "application/javascript; charset=utf-8")
+			fmt.Fprintf(w, "%v(%s)", p, s.jsonFeed)
+			return
+		}
+		w.Header().Set("Content-type", "application/json; charset=utf-8")
+		w.Write(s.jsonFeed)
+		return
+	default:
+		doc, ok := s.docPaths[p]
+		if !ok {
+			// Not a doc; try to just serve static content.
+			s.content.ServeHTTP(w, r)
+			return
+		}
+		d.Doc = doc
+		t = s.template.article
+	}
+	err := t.ExecuteTemplate(w, "root", d)
+	if err != nil {
+		log.Println(err)
+	}
+}
+
+// docsByTime implements sort.Interface, sorting Docs by their Time field.
+type docsByTime []*Doc
+
+func (s docsByTime) Len() int           { return len(s) }
+func (s docsByTime) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s docsByTime) Less(i, j int) bool { return s[i].Time.After(s[j].Time) }
+
+// notExist reports whether the path exists or not.
+func notExist(path string) bool {
+	_, err := os.Stat(path)
+	return os.IsNotExist(err)
+}
diff --git a/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp.go b/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp.go
new file mode 100644
index 0000000..32f3a1c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp.go
@@ -0,0 +1,184 @@
+// 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 (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"text/tabwriter"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+var (
+	changedOnly = flag.Bool("changed", false, "show only benchmarks that have changed")
+	magSort     = flag.Bool("mag", false, "sort benchmarks by magnitude of change")
+	best        = flag.Bool("best", false, "compare best times from old and new")
+)
+
+const usageFooter = `
+Each input file should be from:
+	go test -run=NONE -bench=. > [old,new].txt
+
+Benchcmp compares old and new for each benchmark.
+
+If -test.benchmem=true is added to the "go test" command
+benchcmp will also compare memory allocations.
+`
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "usage: %s old.txt new.txt\n\n", os.Args[0])
+		flag.PrintDefaults()
+		fmt.Fprint(os.Stderr, usageFooter)
+		os.Exit(2)
+	}
+	flag.Parse()
+	if flag.NArg() != 2 {
+		flag.Usage()
+	}
+
+	before := parseFile(flag.Arg(0))
+	after := parseFile(flag.Arg(1))
+
+	cmps, warnings := Correlate(before, after)
+
+	for _, warn := range warnings {
+		fmt.Fprintln(os.Stderr, warn)
+	}
+
+	if len(cmps) == 0 {
+		fatal("benchcmp: no repeated benchmarks")
+	}
+
+	w := new(tabwriter.Writer)
+	w.Init(os.Stdout, 0, 0, 5, ' ', 0)
+	defer w.Flush()
+
+	var header bool // Has the header has been displayed yet for a given block?
+
+	if *magSort {
+		sort.Sort(ByDeltaNsPerOp(cmps))
+	} else {
+		sort.Sort(ByParseOrder(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.NsPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaNsPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "benchmark\told ns/op\tnew ns/op\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", cmp.Name(), formatNs(cmp.Before.NsPerOp), formatNs(cmp.After.NsPerOp), delta.Percent())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaMBPerS(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.MBPerS) {
+			continue
+		}
+		if delta := cmp.DeltaMBPerS(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told MB/s\tnew MB/s\tspeedup\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%.2f\t%.2f\t%s\n", cmp.Name(), cmp.Before.MBPerS, cmp.After.MBPerS, delta.Multiple())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaAllocsPerOp(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.AllocsPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaAllocsPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told allocs\tnew allocs\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocsPerOp, cmp.After.AllocsPerOp, delta.Percent())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaAllocedBytesPerOp(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.AllocedBytesPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaAllocedBytesPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told bytes\tnew bytes\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocedBytesPerOp, cmp.After.AllocedBytesPerOp, cmp.DeltaAllocedBytesPerOp().Percent())
+		}
+	}
+}
+
+func fatal(msg interface{}) {
+	fmt.Fprintln(os.Stderr, msg)
+	os.Exit(1)
+}
+
+func parseFile(path string) parse.Set {
+	f, err := os.Open(path)
+	if err != nil {
+		fatal(err)
+	}
+	defer f.Close()
+	bb, err := parse.ParseSet(f)
+	if err != nil {
+		fatal(err)
+	}
+	if *best {
+		selectBest(bb)
+	}
+	return bb
+}
+
+func selectBest(bs parse.Set) {
+	for name, bb := range bs {
+		if len(bb) < 2 {
+			continue
+		}
+		ord := bb[0].Ord
+		best := bb[0]
+		for _, b := range bb {
+			if b.NsPerOp < best.NsPerOp {
+				b.Ord = ord
+				best = b
+			}
+		}
+		bs[name] = []*parse.Benchmark{best}
+	}
+}
+
+// formatNs formats ns measurements to expose a useful amount of
+// precision. It mirrors the ns precision logic of testing.B.
+func formatNs(ns float64) string {
+	prec := 0
+	switch {
+	case ns < 10:
+		prec = 2
+	case ns < 100:
+		prec = 1
+	}
+	return strconv.FormatFloat(ns, 'f', prec, 64)
+}
diff --git a/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp_test.go b/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp_test.go
new file mode 100644
index 0000000..2226079
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/benchcmp/benchcmp_test.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+func TestSelectBest(t *testing.T) {
+	have := parse.Set{
+		"Benchmark1": []*parse.Benchmark{
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 100, Measured: parse.NsPerOp,
+				Ord: 0,
+			},
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
+				Ord: 3,
+			},
+		},
+		"Benchmark2": []*parse.Benchmark{
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
+				Ord: 1,
+			},
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 500, Measured: parse.NsPerOp,
+				Ord: 2,
+			},
+		},
+	}
+
+	want := parse.Set{
+		"Benchmark1": []*parse.Benchmark{
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
+				Ord: 0,
+			},
+		},
+		"Benchmark2": []*parse.Benchmark{
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
+				Ord: 1,
+			},
+		},
+	}
+
+	selectBest(have)
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("filtered bench set incorrectly, want %v have %v", want, have)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/benchcmp/compare.go b/vendor/golang.org/x/tools/cmd/benchcmp/compare.go
new file mode 100644
index 0000000..c3f5e89
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/benchcmp/compare.go
@@ -0,0 +1,156 @@
+// 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"
+	"math"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+// BenchCmp is a pair of benchmarks.
+type BenchCmp struct {
+	Before *parse.Benchmark
+	After  *parse.Benchmark
+}
+
+// Correlate correlates benchmarks from two BenchSets.
+func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []string) {
+	cmps = make([]BenchCmp, 0, len(after))
+	for name, beforebb := range before {
+		afterbb := after[name]
+		if len(beforebb) != len(afterbb) {
+			warnings = append(warnings, fmt.Sprintf("ignoring %s: before has %d instances, after has %d", name, len(beforebb), len(afterbb)))
+			continue
+		}
+		for i, beforeb := range beforebb {
+			afterb := afterbb[i]
+			cmps = append(cmps, BenchCmp{beforeb, afterb})
+		}
+	}
+	return
+}
+
+func (c BenchCmp) Name() string           { return c.Before.Name }
+func (c BenchCmp) String() string         { return fmt.Sprintf("<%s, %s>", c.Before, c.After) }
+func (c BenchCmp) Measured(flag int) bool { return (c.Before.Measured & c.After.Measured & flag) != 0 }
+func (c BenchCmp) DeltaNsPerOp() Delta    { return Delta{c.Before.NsPerOp, c.After.NsPerOp} }
+func (c BenchCmp) DeltaMBPerS() Delta     { return Delta{c.Before.MBPerS, c.After.MBPerS} }
+func (c BenchCmp) DeltaAllocedBytesPerOp() Delta {
+	return Delta{float64(c.Before.AllocedBytesPerOp), float64(c.After.AllocedBytesPerOp)}
+}
+func (c BenchCmp) DeltaAllocsPerOp() Delta {
+	return Delta{float64(c.Before.AllocsPerOp), float64(c.After.AllocsPerOp)}
+}
+
+// Delta is the before and after value for a benchmark measurement.
+// Both must be non-negative.
+type Delta struct {
+	Before float64
+	After  float64
+}
+
+// mag calculates the magnitude of a change, regardless of the direction of
+// the change. mag is intended for sorting and has no independent meaning.
+func (d Delta) mag() float64 {
+	switch {
+	case d.Before != 0 && d.After != 0 && d.Before >= d.After:
+		return d.After / d.Before
+	case d.Before != 0 && d.After != 0 && d.Before < d.After:
+		return d.Before / d.After
+	case d.Before == 0 && d.After == 0:
+		return 1
+	default:
+		// 0 -> 1 or 1 -> 0
+		// These are significant changes and worth surfacing.
+		return math.Inf(1)
+	}
+}
+
+// Changed reports whether the benchmark quantities are different.
+func (d Delta) Changed() bool { return d.Before != d.After }
+
+// Float64 returns After / Before. If Before is 0, Float64 returns
+// 1 if After is also 0, and +Inf otherwise.
+func (d Delta) Float64() float64 {
+	switch {
+	case d.Before != 0:
+		return d.After / d.Before
+	case d.After == 0:
+		return 1
+	default:
+		return math.Inf(1)
+	}
+}
+
+// Percent formats a Delta as a percent change, ranging from -100% up.
+func (d Delta) Percent() string {
+	return fmt.Sprintf("%+.2f%%", 100*d.Float64()-100)
+}
+
+// Multiple formats a Delta as a multiplier, ranging from 0.00x up.
+func (d Delta) Multiple() string {
+	return fmt.Sprintf("%.2fx", d.Float64())
+}
+
+func (d Delta) String() string {
+	return fmt.Sprintf("Δ(%f, %f)", d.Before, d.After)
+}
+
+// ByParseOrder sorts BenchCmps to match the order in
+// which the Before benchmarks were presented to Parse.
+type ByParseOrder []BenchCmp
+
+func (x ByParseOrder) Len() int           { return len(x) }
+func (x ByParseOrder) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.Ord < x[j].Before.Ord }
+
+// lessByDelta provides lexicographic ordering:
+//   * largest delta by magnitude
+//   * alphabetic by name
+func lessByDelta(i, j BenchCmp, calcDelta func(BenchCmp) Delta) bool {
+	iDelta, jDelta := calcDelta(i).mag(), calcDelta(j).mag()
+	if iDelta != jDelta {
+		return iDelta < jDelta
+	}
+	return i.Name() < j.Name()
+}
+
+// ByDeltaNsPerOp sorts BenchCmps lexicographically by change
+// in ns/op, descending, then by benchmark name.
+type ByDeltaNsPerOp []BenchCmp
+
+func (x ByDeltaNsPerOp) Len() int           { return len(x) }
+func (x ByDeltaNsPerOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaNsPerOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaNsPerOp) }
+
+// ByDeltaMBPerS sorts BenchCmps lexicographically by change
+// in MB/s, descending, then by benchmark name.
+type ByDeltaMBPerS []BenchCmp
+
+func (x ByDeltaMBPerS) Len() int           { return len(x) }
+func (x ByDeltaMBPerS) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaMBPerS) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaMBPerS) }
+
+// ByDeltaAllocedBytesPerOp sorts BenchCmps lexicographically by change
+// in B/op, descending, then by benchmark name.
+type ByDeltaAllocedBytesPerOp []BenchCmp
+
+func (x ByDeltaAllocedBytesPerOp) Len() int      { return len(x) }
+func (x ByDeltaAllocedBytesPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaAllocedBytesPerOp) Less(i, j int) bool {
+	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocedBytesPerOp)
+}
+
+// ByDeltaAllocsPerOp sorts BenchCmps lexicographically by change
+// in allocs/op, descending, then by benchmark name.
+type ByDeltaAllocsPerOp []BenchCmp
+
+func (x ByDeltaAllocsPerOp) Len() int      { return len(x) }
+func (x ByDeltaAllocsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaAllocsPerOp) Less(i, j int) bool {
+	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocsPerOp)
+}
diff --git a/vendor/golang.org/x/tools/cmd/benchcmp/compare_test.go b/vendor/golang.org/x/tools/cmd/benchcmp/compare_test.go
new file mode 100644
index 0000000..3403796
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/benchcmp/compare_test.go
@@ -0,0 +1,133 @@
+// 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 (
+	"math"
+	"reflect"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+func TestDelta(t *testing.T) {
+	cases := []struct {
+		before  float64
+		after   float64
+		mag     float64
+		f       float64
+		changed bool
+		pct     string
+		mult    string
+	}{
+		{before: 1, after: 1, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
+		{before: 1, after: 2, mag: 0.5, f: 2, changed: true, pct: "+100.00%", mult: "2.00x"},
+		{before: 2, after: 1, mag: 0.5, f: 0.5, changed: true, pct: "-50.00%", mult: "0.50x"},
+		{before: 0, after: 0, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
+		{before: 1, after: 0, mag: math.Inf(1), f: 0, changed: true, pct: "-100.00%", mult: "0.00x"},
+		{before: 0, after: 1, mag: math.Inf(1), f: math.Inf(1), changed: true, pct: "+Inf%", mult: "+Infx"},
+	}
+	for _, tt := range cases {
+		d := Delta{tt.before, tt.after}
+		if want, have := tt.mag, d.mag(); want != have {
+			t.Errorf("%s.mag(): want %f have %f", d, want, have)
+		}
+		if want, have := tt.f, d.Float64(); want != have {
+			t.Errorf("%s.Float64(): want %f have %f", d, want, have)
+		}
+		if want, have := tt.changed, d.Changed(); want != have {
+			t.Errorf("%s.Changed(): want %t have %t", d, want, have)
+		}
+		if want, have := tt.pct, d.Percent(); want != have {
+			t.Errorf("%s.Percent(): want %q have %q", d, want, have)
+		}
+		if want, have := tt.mult, d.Multiple(); want != have {
+			t.Errorf("%s.Multiple(): want %q have %q", d, want, have)
+		}
+	}
+}
+
+func TestCorrelate(t *testing.T) {
+	// Benches that are going to be successfully correlated get N thus:
+	//   0x<counter><num benches><b = before | a = after>
+	// Read this: "<counter> of <num benches>, from <before|after>".
+	before := parse.Set{
+		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11b}},
+		"BenchmarkOneToNone": []*parse.Benchmark{{Name: "BenchmarkOneToNone"}},
+		"BenchmarkOneToTwo":  []*parse.Benchmark{{Name: "BenchmarkOneToTwo"}},
+		"BenchmarkTwoToOne": []*parse.Benchmark{
+			{Name: "BenchmarkTwoToOne"},
+			{Name: "BenchmarkTwoToOne"},
+		},
+		"BenchmarkTwoEach": []*parse.Benchmark{
+			{Name: "BenchmarkTwoEach", N: 0x12b},
+			{Name: "BenchmarkTwoEach", N: 0x22b},
+		},
+	}
+
+	after := parse.Set{
+		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11a}},
+		"BenchmarkNoneToOne": []*parse.Benchmark{{Name: "BenchmarkNoneToOne"}},
+		"BenchmarkTwoToOne":  []*parse.Benchmark{{Name: "BenchmarkTwoToOne"}},
+		"BenchmarkOneToTwo": []*parse.Benchmark{
+			{Name: "BenchmarkOneToTwo"},
+			{Name: "BenchmarkOneToTwo"},
+		},
+		"BenchmarkTwoEach": []*parse.Benchmark{
+			{Name: "BenchmarkTwoEach", N: 0x12a},
+			{Name: "BenchmarkTwoEach", N: 0x22a},
+		},
+	}
+
+	pairs, errs := Correlate(before, after)
+
+	// Fail to match: BenchmarkOneToNone, BenchmarkOneToTwo, BenchmarkTwoToOne.
+	// Correlate does not notice BenchmarkNoneToOne.
+	if len(errs) != 3 {
+		t.Errorf("Correlated expected 4 errors, got %d: %v", len(errs), errs)
+	}
+
+	// Want three correlated pairs: one BenchmarkOneEach, two BenchmarkTwoEach.
+	if len(pairs) != 3 {
+		t.Fatalf("Correlated expected 3 pairs, got %v", pairs)
+	}
+
+	for _, pair := range pairs {
+		if pair.Before.N&0xF != 0xb {
+			t.Errorf("unexpected Before in pair %s", pair)
+		}
+		if pair.After.N&0xF != 0xa {
+			t.Errorf("unexpected After in pair %s", pair)
+		}
+		if pair.Before.N>>4 != pair.After.N>>4 {
+			t.Errorf("mismatched pair %s", pair)
+		}
+	}
+}
+
+func TestBenchCmpSorting(t *testing.T) {
+	c := []BenchCmp{
+		{&parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 10, Ord: 3}, &parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 1}},
+		{&parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5, Ord: 1}, &parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5}},
+		{&parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5, Ord: 2}, &parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5}},
+		{&parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 10, Ord: 0}, &parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 11}},
+	}
+
+	// Test just one magnitude-based sort order; they are symmetric.
+	sort.Sort(ByDeltaNsPerOp(c))
+	want := []string{"BenchmarkMuchFaster", "BenchmarkSlower", "BenchmarkSameA", "BenchmarkSameB"}
+	have := []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("ByDeltaNsOp incorrect sorting: want %v have %v", want, have)
+	}
+
+	sort.Sort(ByParseOrder(c))
+	want = []string{"BenchmarkSlower", "BenchmarkSameB", "BenchmarkSameA", "BenchmarkMuchFaster"}
+	have = []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("ByParseOrder incorrect sorting: want %v have %v", want, have)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/benchcmp/doc.go b/vendor/golang.org/x/tools/cmd/benchcmp/doc.go
new file mode 100644
index 0000000..f5c7a36
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/benchcmp/doc.go
@@ -0,0 +1,37 @@
+// 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.
+
+/*
+
+The benchcmp command displays performance changes between benchmarks.
+
+Benchcmp parses the output of two 'go test' benchmark runs,
+correlates the results per benchmark, and displays the deltas.
+
+To measure the performance impact of a change, use 'go test'
+to run benchmarks before and after the change:
+
+	go test -run=NONE -bench=. ./... > old.txt
+	# make changes
+	go test -run=NONE -bench=. ./... > new.txt
+
+Then feed the benchmark results to benchcmp:
+
+	benchcmp old.txt new.txt
+
+Benchcmp will summarize and display the performance changes,
+in a format like this:
+
+	$ benchcmp old.txt new.txt
+	benchmark           old ns/op     new ns/op     delta
+	BenchmarkConcat     523           68.6          -86.88%
+
+	benchmark           old allocs     new allocs     delta
+	BenchmarkConcat     3              1              -66.67%
+
+	benchmark           old bytes     new bytes     delta
+	BenchmarkConcat     80            48            -40.00%
+
+*/
+package main // import "golang.org/x/tools/cmd/benchcmp"
diff --git a/vendor/golang.org/x/tools/cmd/bundle/.gitignore b/vendor/golang.org/x/tools/cmd/bundle/.gitignore
new file mode 100644
index 0000000..caaeb09
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/.gitignore
@@ -0,0 +1 @@
+testdata/out.got
diff --git a/vendor/golang.org/x/tools/cmd/bundle/main.go b/vendor/golang.org/x/tools/cmd/bundle/main.go
new file mode 100644
index 0000000..601da7f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/main.go
@@ -0,0 +1,468 @@
+// 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.
+
+// Bundle creates a single-source-file version of a source package
+// suitable for inclusion in a particular target package.
+//
+// Usage:
+//
+//	bundle [-o file] [-dst path] [-pkg name] [-prefix p] [-import old=new] <src>
+//
+// The src argument specifies the import path of the package to bundle.
+// The bundling of a directory of source files into a single source file
+// necessarily imposes a number of constraints.
+// The package being bundled must not use cgo; must not use conditional
+// file compilation, whether with build tags or system-specific file names
+// like code_amd64.go; must not depend on any special comments, which
+// may not be preserved; must not use any assembly sources;
+// must not use renaming imports; and must not use reflection-based APIs
+// that depend on the specific names of types or struct fields.
+//
+// By default, bundle writes the bundled code to standard output.
+// If the -o argument is given, bundle writes to the named file
+// and also includes a ``//go:generate'' comment giving the exact
+// command line used, for regenerating the file with ``go generate.''
+//
+// Bundle customizes its output for inclusion in a particular package, the destination package.
+// By default bundle assumes the destination is the package in the current directory,
+// but the destination package can be specified explicitly using the -dst option,
+// which takes an import path as its argument.
+// If the source package imports the destination package, bundle will remove
+// those imports and rewrite any references to use direct references to the
+// corresponding symbols.
+// Bundle also must write a package declaration in the output and must
+// choose a name to use in that declaration.
+// If the -package option is given, bundle uses that name.
+// Otherwise, if the -dst option is given, bundle uses the last
+// element of the destination import path.
+// Otherwise, by default bundle uses the package name found in the
+// package sources in the current directory.
+//
+// To avoid collisions, bundle inserts a prefix at the beginning of
+// every package-level const, func, type, and var identifier in src's code,
+// updating references accordingly. The default prefix is the package name
+// of the source package followed by an underscore. The -prefix option
+// specifies an alternate prefix.
+//
+// Occasionally it is necessary to rewrite imports during the bundling
+// process. The -import option, which may be repeated, specifies that
+// an import of "old" should be rewritten to import "new" instead.
+//
+// Example
+//
+// Bundle archive/zip for inclusion in cmd/dist:
+//
+//	cd $GOROOT/src/cmd/dist
+//	bundle -o zip.go archive/zip
+//
+// Bundle golang.org/x/net/http2 for inclusion in net/http,
+// prefixing all identifiers by "http2" instead of "http2_",
+// and rewriting the import "golang.org/x/net/http2/hpack"
+// to "internal/golang.org/x/net/http2/hpack":
+//
+//	cd $GOROOT/src/net/http
+//	bundle -o h2_bundle.go \
+//		-prefix http2 \
+//		-import golang.org/x/net/http2/hpack=internal/golang.org/x/net/http2/hpack \
+//		golang.org/x/net/http2
+//
+// Two ways to update the http2 bundle:
+//
+//	go generate net/http
+//
+//	cd $GOROOT/src/net/http
+//	go generate
+//
+// Update both bundles, restricting ``go generate'' to running bundle commands:
+//
+//	go generate -run bundle cmd/dist net/http
+//
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/loader"
+)
+
+var (
+	outputFile = flag.String("o", "", "write output to `file` (default standard output)")
+	dstPath    = flag.String("dst", "", "set destination import `path` (default taken from current directory)")
+	pkgName    = flag.String("pkg", "", "set destination package `name` (default taken from current directory)")
+	prefix     = flag.String("prefix", "", "set bundled identifier prefix to `p` (default source package name + \"_\")")
+	underscore = flag.Bool("underscore", false, "rewrite golang.org to golang_org in imports; temporary workaround for golang.org/issue/16333")
+
+	importMap = map[string]string{}
+)
+
+func init() {
+	flag.Var(flagFunc(addImportMap), "import", "rewrite import using `map`, of form old=new (can be repeated)")
+}
+
+func addImportMap(s string) {
+	if strings.Count(s, "=") != 1 {
+		log.Fatal("-import argument must be of the form old=new")
+	}
+	i := strings.Index(s, "=")
+	old, new := s[:i], s[i+1:]
+	if old == "" || new == "" {
+		log.Fatal("-import argument must be of the form old=new; old and new must be non-empty")
+	}
+	importMap[old] = new
+}
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "Usage: bundle [options] <src>\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetPrefix("bundle: ")
+	log.SetFlags(0)
+
+	flag.Usage = usage
+	flag.Parse()
+	args := flag.Args()
+	if len(args) != 1 {
+		usage()
+		os.Exit(2)
+	}
+
+	if *dstPath != "" {
+		if *pkgName == "" {
+			*pkgName = path.Base(*dstPath)
+		}
+	} else {
+		wd, _ := os.Getwd()
+		pkg, err := build.ImportDir(wd, 0)
+		if err != nil {
+			log.Fatalf("cannot find package in current directory: %v", err)
+		}
+		*dstPath = pkg.ImportPath
+		if *pkgName == "" {
+			*pkgName = pkg.Name
+		}
+	}
+
+	code, err := bundle(args[0], *dstPath, *pkgName, *prefix)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if *outputFile != "" {
+		err := ioutil.WriteFile(*outputFile, code, 0666)
+		if err != nil {
+			log.Fatal(err)
+		}
+	} else {
+		_, err := os.Stdout.Write(code)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+}
+
+// isStandardImportPath is copied from cmd/go in the standard library.
+func isStandardImportPath(path string) bool {
+	i := strings.Index(path, "/")
+	if i < 0 {
+		i = len(path)
+	}
+	elem := path[:i]
+	return !strings.Contains(elem, ".")
+}
+
+var ctxt = &build.Default
+
+func bundle(src, dst, dstpkg, prefix string) ([]byte, error) {
+	// Load the initial package.
+	conf := loader.Config{ParserMode: parser.ParseComments, Build: ctxt}
+	conf.TypeCheckFuncBodies = func(p string) bool { return p == src }
+	conf.Import(src)
+
+	lprog, err := conf.Load()
+	if err != nil {
+		return nil, err
+	}
+
+	// Because there was a single Import call and Load succeeded,
+	// InitialPackages is guaranteed to hold the sole requested package.
+	info := lprog.InitialPackages()[0]
+	if prefix == "" {
+		pkgName := info.Files[0].Name.Name
+		prefix = pkgName + "_"
+	}
+
+	objsToUpdate := make(map[types.Object]bool)
+	var rename func(from types.Object)
+	rename = func(from types.Object) {
+		if !objsToUpdate[from] {
+			objsToUpdate[from] = true
+
+			// Renaming a type that is used as an embedded field
+			// requires renaming the field too. e.g.
+			// 	type T int // if we rename this to U..
+			// 	var s struct {T}
+			// 	print(s.T) // ...this must change too
+			if _, ok := from.(*types.TypeName); ok {
+				for id, obj := range info.Uses {
+					if obj == from {
+						if field := info.Defs[id]; field != nil {
+							rename(field)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Rename each package-level object.
+	scope := info.Pkg.Scope()
+	for _, name := range scope.Names() {
+		rename(scope.Lookup(name))
+	}
+
+	var out bytes.Buffer
+
+	fmt.Fprintf(&out, "// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.\n")
+	if *outputFile != "" {
+		fmt.Fprintf(&out, "//go:generate bundle %s\n", strings.Join(os.Args[1:], " "))
+	} else {
+		fmt.Fprintf(&out, "//   $ bundle %s\n", strings.Join(os.Args[1:], " "))
+	}
+	fmt.Fprintf(&out, "\n")
+
+	// Concatenate package comments from all files...
+	for _, f := range info.Files {
+		if doc := f.Doc.Text(); strings.TrimSpace(doc) != "" {
+			for _, line := range strings.Split(doc, "\n") {
+				fmt.Fprintf(&out, "// %s\n", line)
+			}
+		}
+	}
+	// ...but don't let them become the actual package comment.
+	fmt.Fprintln(&out)
+
+	fmt.Fprintf(&out, "package %s\n\n", dstpkg)
+
+	// BUG(adonovan,shurcooL): bundle may generate incorrect code
+	// due to shadowing between identifiers and imported package names.
+	//
+	// The generated code will either fail to compile or
+	// (unlikely) compile successfully but have different behavior
+	// than the original package. The risk of this happening is higher
+	// when the original package has renamed imports (they're typically
+	// renamed in order to resolve a shadow inside that particular .go file).
+
+	// TODO(adonovan,shurcooL):
+	// - detect shadowing issues, and either return error or resolve them
+	// - preserve comments from the original import declarations.
+
+	// pkgStd and pkgExt are sets of printed import specs. This is done
+	// to deduplicate instances of the same import name and path.
+	var pkgStd = make(map[string]bool)
+	var pkgExt = make(map[string]bool)
+	for _, f := range info.Files {
+		for _, imp := range f.Imports {
+			path, err := strconv.Unquote(imp.Path.Value)
+			if err != nil {
+				log.Fatalf("invalid import path string: %v", err) // Shouldn't happen here since conf.Load succeeded.
+			}
+			if path == dst {
+				continue
+			}
+			if newPath, ok := importMap[path]; ok {
+				path = newPath
+			}
+
+			var name string
+			if imp.Name != nil {
+				name = imp.Name.Name
+			}
+			spec := fmt.Sprintf("%s %q", name, path)
+			if isStandardImportPath(path) {
+				pkgStd[spec] = true
+			} else {
+				if *underscore {
+					spec = strings.Replace(spec, "golang.org/", "golang_org/", 1)
+				}
+				pkgExt[spec] = true
+			}
+		}
+	}
+
+	// Print a single declaration that imports all necessary packages.
+	fmt.Fprintln(&out, "import (")
+	for p := range pkgStd {
+		fmt.Fprintf(&out, "\t%s\n", p)
+	}
+	if len(pkgExt) > 0 {
+		fmt.Fprintln(&out)
+	}
+	for p := range pkgExt {
+		fmt.Fprintf(&out, "\t%s\n", p)
+	}
+	fmt.Fprint(&out, ")\n\n")
+
+	// Modify and print each file.
+	for _, f := range info.Files {
+		// Update renamed identifiers.
+		for id, obj := range info.Defs {
+			if objsToUpdate[obj] {
+				id.Name = prefix + obj.Name()
+			}
+		}
+		for id, obj := range info.Uses {
+			if objsToUpdate[obj] {
+				id.Name = prefix + obj.Name()
+			}
+		}
+
+		// For each qualified identifier that refers to the
+		// destination package, remove the qualifier.
+		// The "@@@." strings are removed in postprocessing.
+		ast.Inspect(f, func(n ast.Node) bool {
+			if sel, ok := n.(*ast.SelectorExpr); ok {
+				if id, ok := sel.X.(*ast.Ident); ok {
+					if obj, ok := info.Uses[id].(*types.PkgName); ok {
+						if obj.Imported().Path() == dst {
+							id.Name = "@@@"
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		last := f.Package
+		if len(f.Imports) > 0 {
+			imp := f.Imports[len(f.Imports)-1]
+			last = imp.End()
+			if imp.Comment != nil {
+				if e := imp.Comment.End(); e > last {
+					last = e
+				}
+			}
+		}
+
+		// Pretty-print package-level declarations.
+		// but no package or import declarations.
+		var buf bytes.Buffer
+		for _, decl := range f.Decls {
+			if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
+				continue
+			}
+
+			beg, end := sourceRange(decl)
+
+			printComments(&out, f.Comments, last, beg)
+
+			buf.Reset()
+			format.Node(&buf, lprog.Fset, &printer.CommentedNode{Node: decl, Comments: f.Comments})
+			// Remove each "@@@." in the output.
+			// TODO(adonovan): not hygienic.
+			out.Write(bytes.Replace(buf.Bytes(), []byte("@@@."), nil, -1))
+
+			last = printSameLineComment(&out, f.Comments, lprog.Fset, end)
+
+			out.WriteString("\n\n")
+		}
+
+		printLastComments(&out, f.Comments, last)
+	}
+
+	// Now format the entire thing.
+	result, err := format.Source(out.Bytes())
+	if err != nil {
+		log.Fatalf("formatting failed: %v", err)
+	}
+
+	return result, nil
+}
+
+// sourceRange returns the [beg, end) interval of source code
+// belonging to decl (incl. associated comments).
+func sourceRange(decl ast.Decl) (beg, end token.Pos) {
+	beg = decl.Pos()
+	end = decl.End()
+
+	var doc, com *ast.CommentGroup
+
+	switch d := decl.(type) {
+	case *ast.GenDecl:
+		doc = d.Doc
+		if len(d.Specs) > 0 {
+			switch spec := d.Specs[len(d.Specs)-1].(type) {
+			case *ast.ValueSpec:
+				com = spec.Comment
+			case *ast.TypeSpec:
+				com = spec.Comment
+			}
+		}
+	case *ast.FuncDecl:
+		doc = d.Doc
+	}
+
+	if doc != nil {
+		beg = doc.Pos()
+	}
+	if com != nil && com.End() > end {
+		end = com.End()
+	}
+
+	return beg, end
+}
+
+func printComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos, end token.Pos) {
+	for _, cg := range comments {
+		if pos <= cg.Pos() && cg.Pos() < end {
+			for _, c := range cg.List {
+				fmt.Fprintln(out, c.Text)
+			}
+			fmt.Fprintln(out)
+		}
+	}
+}
+
+const infinity = 1 << 30
+
+func printLastComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos token.Pos) {
+	printComments(out, comments, pos, infinity)
+}
+
+func printSameLineComment(out *bytes.Buffer, comments []*ast.CommentGroup, fset *token.FileSet, pos token.Pos) token.Pos {
+	tf := fset.File(pos)
+	for _, cg := range comments {
+		if pos <= cg.Pos() && tf.Line(cg.Pos()) == tf.Line(pos) {
+			for _, c := range cg.List {
+				fmt.Fprintln(out, c.Text)
+			}
+			return cg.End()
+		}
+	}
+	return pos
+}
+
+type flagFunc func(string)
+
+func (f flagFunc) Set(s string) error {
+	f(s)
+	return nil
+}
+
+func (f flagFunc) String() string { return "" }
diff --git a/vendor/golang.org/x/tools/cmd/bundle/main_test.go b/vendor/golang.org/x/tools/cmd/bundle/main_test.go
new file mode 100644
index 0000000..b96f7d9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/main_test.go
@@ -0,0 +1,74 @@
+// 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 go1.9
+
+package main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"runtime"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestBundle(t *testing.T) {
+	load := func(name string) string {
+		data, err := ioutil.ReadFile(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return string(data)
+	}
+
+	ctxt = buildutil.FakeContext(map[string]map[string]string{
+		"initial": {
+			"a.go": load("testdata/src/initial/a.go"),
+			"b.go": load("testdata/src/initial/b.go"),
+			"c.go": load("testdata/src/initial/c.go"),
+		},
+		"domain.name/importdecl": {
+			"p.go": load("testdata/src/domain.name/importdecl/p.go"),
+		},
+		"fmt": {
+			"print.go": `package fmt; func Println(...interface{})`,
+		},
+	})
+
+	os.Args = os.Args[:1] // avoid e.g. -test=short in the output
+	out, err := bundle("initial", "github.com/dest", "dest", "prefix")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := string(out), load("testdata/out.golden"); got != want {
+		t.Errorf("-- got --\n%s\n-- want --\n%s\n-- diff --", got, want)
+
+		if err := ioutil.WriteFile("testdata/out.got", out, 0644); err != nil {
+			t.Fatal(err)
+		}
+		t.Log(diff("testdata/out.golden", "testdata/out.got"))
+	}
+}
+
+func diff(a, b string) string {
+	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)
+	}
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &out
+	cmd.Run() // nonzero exit is expected
+	if out.Len() == 0 {
+		return "(failed to compute diff)"
+	}
+	return out.String()
+}
diff --git a/vendor/golang.org/x/tools/cmd/bundle/testdata/out.golden b/vendor/golang.org/x/tools/cmd/bundle/testdata/out.golden
new file mode 100644
index 0000000..5260fdd
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/testdata/out.golden
@@ -0,0 +1,62 @@
+// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
+//   $ bundle
+
+// The package doc comment
+//
+
+package dest
+
+import (
+	"fmt"
+	. "fmt"
+	_ "fmt"
+	renamedfmt "fmt"
+	renamedfmt2 "fmt"
+
+	"domain.name/importdecl"
+)
+
+// init functions are not renamed
+func init() { prefixfoo() }
+
+// Type S.
+type prefixS struct {
+	prefixt
+	u int
+} /* multi-line
+comment
+*/
+
+// non-associated comment
+
+/*
+	non-associated comment2
+*/
+
+// Function bar.
+func prefixbar(s *prefixS) {
+	fmt.Println(s.prefixt, s.u) // comment inside function
+}
+
+// file-end comment
+
+type prefixt int // type1
+
+// const1
+const prefixc = 1 // const2
+
+func prefixfoo() {
+	fmt.Println(importdecl.F())
+}
+
+// zinit
+const (
+	prefixz1 = iota // z1
+	prefixz2        // z2
+) // zend
+
+func prefixbaz() {
+	renamedfmt.Println()
+	renamedfmt2.Println()
+	Println()
+}
diff --git a/vendor/golang.org/x/tools/cmd/bundle/testdata/src/domain.name/importdecl/p.go b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/domain.name/importdecl/p.go
new file mode 100644
index 0000000..36dfd15
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/domain.name/importdecl/p.go
@@ -0,0 +1,3 @@
+package importdecl
+
+func F() int { return 1 }
diff --git a/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/a.go b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/a.go
new file mode 100644
index 0000000..ded6c64
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/a.go
@@ -0,0 +1,27 @@
+package initial
+
+import "fmt" // this comment should not be visible
+
+// init functions are not renamed
+func init() { foo() }
+
+// Type S.
+type S struct {
+	t
+	u int
+} /* multi-line
+comment
+*/
+
+// non-associated comment
+
+/*
+	non-associated comment2
+*/
+
+// Function bar.
+func bar(s *S) {
+	fmt.Println(s.t, s.u) // comment inside function
+}
+
+// file-end comment
diff --git a/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/b.go b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/b.go
new file mode 100644
index 0000000..31d5cab
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/b.go
@@ -0,0 +1,23 @@
+// The package doc comment
+package initial
+
+import (
+	"fmt"
+
+	"domain.name/importdecl"
+)
+
+type t int // type1
+
+// const1
+const c = 1 // const2
+
+func foo() {
+	fmt.Println(importdecl.F())
+}
+
+// zinit
+const (
+	z1 = iota // z1
+	z2        // z2
+) // zend
diff --git a/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/c.go b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/c.go
new file mode 100644
index 0000000..6a9cbc6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/bundle/testdata/src/initial/c.go
@@ -0,0 +1,12 @@
+package initial
+
+import _ "fmt"
+import renamedfmt "fmt"
+import renamedfmt2 "fmt"
+import . "fmt"
+
+func baz() {
+	renamedfmt.Println()
+	renamedfmt2.Println()
+	Println()
+}
diff --git a/vendor/golang.org/x/tools/cmd/callgraph/main.go b/vendor/golang.org/x/tools/cmd/callgraph/main.go
new file mode 100644
index 0000000..8ef4597
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/callgraph/main.go
@@ -0,0 +1,361 @@
+// 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.
+
+// callgraph: a tool for reporting the call graph of a Go program.
+// See Usage for details, or run with -help.
+package main // import "golang.org/x/tools/cmd/callgraph"
+
+// TODO(adonovan):
+//
+// Features:
+// - restrict graph to a single package
+// - output
+//   - functions reachable from root (use digraph tool?)
+//   - unreachable functions (use digraph tool?)
+//   - dynamic (runtime) types
+//   - indexed output (numbered nodes)
+//   - JSON output
+//   - additional template fields:
+//     callee file/line/col
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/build"
+	"go/token"
+	"io"
+	"log"
+	"os"
+	"runtime"
+	"text/template"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/cha"
+	"golang.org/x/tools/go/callgraph/rta"
+	"golang.org/x/tools/go/callgraph/static"
+	"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"
+)
+
+// flags
+var (
+	algoFlag = flag.String("algo", "rta",
+		`Call graph construction algorithm (static, cha, rta, pta)`)
+
+	testFlag = flag.Bool("test", false,
+		"Loads test code (*_test.go) for imported packages")
+
+	formatFlag = flag.String("format",
+		"{{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}",
+		"A template expression specifying how to format an edge")
+
+	ptalogFlag = flag.String("ptalog", "",
+		"Location of the points-to analysis log file, or empty to disable logging.")
+)
+
+func init() {
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+}
+
+const Usage = `callgraph: display the the call graph of a Go program.
+
+Usage:
+
+  callgraph [-algo=static|cha|rta|pta] [-test] [-format=...] <args>...
+
+Flags:
+
+-algo      Specifies the call-graph construction algorithm, one of:
+
+            static      static calls only (unsound)
+            cha         Class Hierarchy Analysis
+            rta         Rapid Type Analysis
+            pta         inclusion-based Points-To Analysis
+
+           The algorithms are ordered by increasing precision in their
+           treatment of dynamic calls (and thus also computational cost).
+           RTA and PTA require a whole program (main or test), and
+           include only functions reachable from main.
+
+-test      Include the package's tests in the analysis.
+
+-format    Specifies the format in which each call graph edge is displayed.
+           One of:
+
+            digraph     output suitable for input to
+                        golang.org/x/tools/cmd/digraph.
+            graphviz    output in AT&T GraphViz (.dot) format.
+
+           All other values are interpreted using text/template syntax.
+           The default value is:
+
+            {{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}
+
+           The structure passed to the template is (effectively):
+
+                   type Edge struct {
+                           Caller      *ssa.Function // calling function
+                           Callee      *ssa.Function // called function
+
+                           // Call site:
+                           Filename    string // containing file
+                           Offset      int    // offset within file of '('
+                           Line        int    // line number
+                           Column      int    // column number of call
+                           Dynamic     string // "static" or "dynamic"
+                           Description string // e.g. "static method call"
+                   }
+
+           Caller and Callee are *ssa.Function values, which print as
+           "(*sync/atomic.Mutex).Lock", but other attributes may be
+           derived from them, e.g. Caller.Pkg.Pkg.Path yields the
+           import path of the enclosing package.  Consult the go/ssa
+           API documentation for details.
+
+` + loader.FromArgsUsage + `
+
+Examples:
+
+  Show the call graph of the trivial web server application:
+
+    callgraph -format digraph $GOROOT/src/net/http/triv.go
+
+  Same, but show only the packages of each function:
+
+    callgraph -format '{{.Caller.Pkg.Pkg.Path}} -> {{.Callee.Pkg.Pkg.Path}}' \
+      $GOROOT/src/net/http/triv.go | sort | uniq
+
+  Show functions that make dynamic calls into the 'fmt' test package,
+  using the pointer analysis algorithm:
+
+    callgraph -format='{{.Caller}} -{{.Dynamic}}-> {{.Callee}}' -test -algo=pta fmt |
+      sed -ne 's/-dynamic-/--/p' |
+      sed -ne 's/-->.*fmt_test.*$//p' | sort | uniq
+
+  Show all functions directly called by the callgraph tool's main function:
+
+    callgraph -format=digraph golang.org/x/tools/cmd/callgraph |
+      digraph succs golang.org/x/tools/cmd/callgraph.main
+`
+
+func init() {
+	// If $GOMAXPROCS isn't set, use the full capacity of the machine.
+	// For small machines, use at least 4 threads.
+	if os.Getenv("GOMAXPROCS") == "" {
+		n := runtime.NumCPU()
+		if n < 4 {
+			n = 4
+		}
+		runtime.GOMAXPROCS(n)
+	}
+}
+
+func main() {
+	flag.Parse()
+	if err := doCallgraph(&build.Default, *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
+		fmt.Fprintf(os.Stderr, "callgraph: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+var stdout io.Writer = os.Stdout
+
+func doCallgraph(ctxt *build.Context, algo, format string, tests bool, args []string) error {
+	conf := loader.Config{Build: ctxt}
+
+	if len(args) == 0 {
+		fmt.Fprintln(os.Stderr, Usage)
+		return nil
+	}
+
+	// Use the initial packages from the command line.
+	_, err := conf.FromArgs(args, tests)
+	if err != nil {
+		return err
+	}
+
+	// Load, parse and type-check the whole program.
+	iprog, err := conf.Load()
+	if err != nil {
+		return err
+	}
+
+	// Create and build SSA-form program representation.
+	prog := ssautil.CreateProgram(iprog, 0)
+	prog.Build()
+
+	// -- call graph construction ------------------------------------------
+
+	var cg *callgraph.Graph
+
+	switch algo {
+	case "static":
+		cg = static.CallGraph(prog)
+
+	case "cha":
+		cg = cha.CallGraph(prog)
+
+	case "pta":
+		// 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)
+					}
+				}()
+			}
+		}
+
+		mains, err := mainPackages(prog, tests)
+		if err != nil {
+			return err
+		}
+		config := &pointer.Config{
+			Mains:          mains,
+			BuildCallGraph: true,
+			Log:            ptalog,
+		}
+		ptares, err := pointer.Analyze(config)
+		if err != nil {
+			return err // internal error in pointer analysis
+		}
+		cg = ptares.CallGraph
+
+	case "rta":
+		mains, err := mainPackages(prog, tests)
+		if err != nil {
+			return err
+		}
+		var roots []*ssa.Function
+		for _, main := range mains {
+			roots = append(roots, main.Func("init"), main.Func("main"))
+		}
+		rtares := rta.Analyze(roots, true)
+		cg = rtares.CallGraph
+
+		// NB: RTA gives us Reachable and RuntimeTypes too.
+
+	default:
+		return fmt.Errorf("unknown algorithm: %s", algo)
+	}
+
+	cg.DeleteSyntheticNodes()
+
+	// -- output------------------------------------------------------------
+
+	var before, after string
+
+	// Pre-canned formats.
+	switch format {
+	case "digraph":
+		format = `{{printf "%q %q" .Caller .Callee}}`
+
+	case "graphviz":
+		before = "digraph callgraph {\n"
+		after = "}\n"
+		format = `  {{printf "%q" .Caller}} -> {{printf "%q" .Callee}}`
+	}
+
+	tmpl, err := template.New("-format").Parse(format)
+	if err != nil {
+		return fmt.Errorf("invalid -format template: %v", err)
+	}
+
+	// Allocate these once, outside the traversal.
+	var buf bytes.Buffer
+	data := Edge{fset: prog.Fset}
+
+	fmt.Fprint(stdout, before)
+	if err := callgraph.GraphVisitEdges(cg, func(edge *callgraph.Edge) error {
+		data.position.Offset = -1
+		data.edge = edge
+		data.Caller = edge.Caller.Func
+		data.Callee = edge.Callee.Func
+
+		buf.Reset()
+		if err := tmpl.Execute(&buf, &data); err != nil {
+			return err
+		}
+		stdout.Write(buf.Bytes())
+		if len := buf.Len(); len == 0 || buf.Bytes()[len-1] != '\n' {
+			fmt.Fprintln(stdout)
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+	fmt.Fprint(stdout, after)
+	return nil
+}
+
+// mainPackages returns the main packages to analyze.
+// Each resulting package is named "main" and has a main function.
+func mainPackages(prog *ssa.Program, tests bool) ([]*ssa.Package, error) {
+	pkgs := prog.AllPackages() // TODO(adonovan): use only initial packages
+
+	// If tests, create a "testmain" package for each test.
+	var mains []*ssa.Package
+	if tests {
+		for _, pkg := range pkgs {
+			if main := prog.CreateTestMainPackage(pkg); main != nil {
+				mains = append(mains, main)
+			}
+		}
+		if mains == nil {
+			return nil, fmt.Errorf("no tests")
+		}
+		return mains, nil
+	}
+
+	// Otherwise, use the main packages.
+	mains = append(mains, ssautil.MainPackages(pkgs)...)
+	if len(mains) == 0 {
+		return nil, fmt.Errorf("no main packages")
+	}
+	return mains, nil
+}
+
+type Edge struct {
+	Caller *ssa.Function
+	Callee *ssa.Function
+
+	edge     *callgraph.Edge
+	fset     *token.FileSet
+	position token.Position // initialized lazily
+}
+
+func (e *Edge) pos() *token.Position {
+	if e.position.Offset == -1 {
+		e.position = e.fset.Position(e.edge.Pos()) // called lazily
+	}
+	return &e.position
+}
+
+func (e *Edge) Filename() string { return e.pos().Filename }
+func (e *Edge) Column() int      { return e.pos().Column }
+func (e *Edge) Line() int        { return e.pos().Line }
+func (e *Edge) Offset() int      { return e.pos().Offset }
+
+func (e *Edge) Dynamic() string {
+	if e.edge.Site != nil && e.edge.Site.Common().StaticCallee() == nil {
+		return "dynamic"
+	}
+	return "static"
+}
+
+func (e *Edge) Description() string { return e.edge.Description() }
diff --git a/vendor/golang.org/x/tools/cmd/callgraph/main_test.go b/vendor/golang.org/x/tools/cmd/callgraph/main_test.go
new file mode 100644
index 0000000..c42f56d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/callgraph/main_test.go
@@ -0,0 +1,81 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/build"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestCallgraph(t *testing.T) {
+	ctxt := build.Default // copy
+	ctxt.GOPATH = "testdata"
+
+	const format = "{{.Caller}} --> {{.Callee}}"
+
+	for _, test := range []struct {
+		algo, format string
+		tests        bool
+		want         []string
+	}{
+		{"rta", format, false, []string{
+			// rta imprecisely shows cross product of {main,main2} x {C,D}
+			`pkg.main --> (pkg.C).f`,
+			`pkg.main --> (pkg.D).f`,
+			`pkg.main --> pkg.main2`,
+			`pkg.main2 --> (pkg.C).f`,
+			`pkg.main2 --> (pkg.D).f`,
+		}},
+		{"pta", format, false, []string{
+			// pta distinguishes main->C, main2->D.  Also has a root node.
+			`<root> --> pkg.init`,
+			`<root> --> pkg.main`,
+			`pkg.main --> (pkg.C).f`,
+			`pkg.main --> pkg.main2`,
+			`pkg.main2 --> (pkg.D).f`,
+		}},
+		// tests: main is not called.
+		{"rta", format, true, []string{
+			`pkg$testmain.init --> pkg.init`,
+			`pkg.Example --> (pkg.C).f`,
+		}},
+		{"pta", format, true, []string{
+			`<root> --> pkg$testmain.init`,
+			`<root> --> pkg.Example`,
+			`pkg$testmain.init --> pkg.init`,
+			`pkg.Example --> (pkg.C).f`,
+		}},
+	} {
+		stdout = new(bytes.Buffer)
+		if err := doCallgraph(&ctxt, test.algo, test.format, test.tests, []string{"pkg"}); err != nil {
+			t.Error(err)
+			continue
+		}
+
+		got := sortedLines(fmt.Sprint(stdout))
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("callgraph(%q, %q, %t):\ngot:\n%s\nwant:\n%s",
+				test.algo, test.format, test.tests,
+				strings.Join(got, "\n"),
+				strings.Join(test.want, "\n"))
+		}
+	}
+}
+
+func sortedLines(s string) []string {
+	s = strings.TrimSpace(s)
+	lines := strings.Split(s, "\n")
+	sort.Strings(lines)
+	return lines
+}
diff --git a/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg.go b/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg.go
new file mode 100644
index 0000000..b81c97f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg.go
@@ -0,0 +1,25 @@
+package main
+
+type I interface {
+	f()
+}
+
+type C int
+
+func (C) f() {}
+
+type D int
+
+func (D) f() {}
+
+func main() {
+	var i I = C(0)
+	i.f() // dynamic call
+
+	main2()
+}
+
+func main2() {
+	var i I = D(0)
+	i.f() // dynamic call
+}
diff --git a/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg_test.go b/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg_test.go
new file mode 100644
index 0000000..d624757
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/callgraph/testdata/src/pkg/pkg_test.go
@@ -0,0 +1,7 @@
+package main
+
+// Don't import "testing", it adds a lot of callgraph edges.
+
+func Example() {
+	C(0).f()
+}
diff --git a/vendor/golang.org/x/tools/cmd/compilebench/main.go b/vendor/golang.org/x/tools/cmd/compilebench/main.go
new file mode 100644
index 0000000..d2cd70b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/compilebench/main.go
@@ -0,0 +1,360 @@
+// 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.
+
+// Compilebench benchmarks the speed of the Go compiler.
+//
+// Usage:
+//
+//	compilebench [options]
+//
+// It times the compilation of various packages and prints results in
+// the format used by package testing (and expected by golang.org/x/perf/cmd/benchstat).
+//
+// The options are:
+//
+//	-alloc
+//		Report allocations.
+//
+//	-compile exe
+//		Use exe as the path to the cmd/compile binary.
+//
+//	-compileflags 'list'
+//		Pass the space-separated list of flags to the compilation.
+//
+//	-count n
+//		Run each benchmark n times (default 1).
+//
+//	-cpuprofile file
+//		Write a CPU profile of the compiler to file.
+//
+//	-memprofile file
+//		Write a memory profile of the compiler to file.
+//
+//	-memprofilerate rate
+//		Set runtime.MemProfileRate during compilation.
+//
+//	-obj
+//		Report object file statistics.
+//
+//  -pkg
+//		Benchmark compiling a single package.
+//
+//	-run regexp
+//		Only run benchmarks with names matching regexp.
+//
+// Although -cpuprofile and -memprofile are intended to write a
+// combined profile for all the executed benchmarks to file,
+// today they write only the profile for the last benchmark executed.
+//
+// The default memory profiling rate is one profile sample per 512 kB
+// allocated (see ``go doc runtime.MemProfileRate'').
+// Lowering the rate (for example, -memprofilerate 64000) produces
+// a more fine-grained and therefore accurate profile, but it also incurs
+// execution cost. For benchmark comparisons, never use timings
+// obtained with a low -memprofilerate option.
+//
+// Example
+//
+// Assuming the base version of the compiler has been saved with
+// ``toolstash save,'' this sequence compares the old and new compiler:
+//
+//	compilebench -count 10 -compile $(toolstash -n compile) >old.txt
+//	compilebench -count 10 >new.txt
+//	benchstat old.txt new.txt
+//
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var (
+	goroot   string
+	compiler string
+	runRE    *regexp.Regexp
+	is6g     bool
+)
+
+var (
+	flagGoCmd          = flag.String("go", "go", "path to \"go\" command")
+	flagAlloc          = flag.Bool("alloc", false, "report allocations")
+	flagObj            = flag.Bool("obj", false, "report object file stats")
+	flagCompiler       = flag.String("compile", "", "use `exe` as the cmd/compile binary")
+	flagCompilerFlags  = flag.String("compileflags", "", "additional `flags` to pass to compile")
+	flagRun            = flag.String("run", "", "run benchmarks matching `regexp`")
+	flagCount          = flag.Int("count", 1, "run benchmarks `n` times")
+	flagCpuprofile     = flag.String("cpuprofile", "", "write CPU profile to `file`")
+	flagMemprofile     = flag.String("memprofile", "", "write memory profile to `file`")
+	flagMemprofilerate = flag.Int64("memprofilerate", -1, "set memory profile `rate`")
+	flagPackage        = flag.String("pkg", "", "if set, benchmark the package at path `pkg`")
+	flagShort          = flag.Bool("short", false, "skip long-running benchmarks")
+)
+
+var tests = []struct {
+	name string
+	dir  string
+	long bool
+}{
+	{"BenchmarkTemplate", "html/template", false},
+	{"BenchmarkUnicode", "unicode", false},
+	{"BenchmarkGoTypes", "go/types", false},
+	{"BenchmarkCompiler", "cmd/compile/internal/gc", false},
+	{"BenchmarkSSA", "cmd/compile/internal/ssa", false},
+	{"BenchmarkFlate", "compress/flate", false},
+	{"BenchmarkGoParser", "go/parser", false},
+	{"BenchmarkReflect", "reflect", false},
+	{"BenchmarkTar", "archive/tar", false},
+	{"BenchmarkXML", "encoding/xml", false},
+	{"BenchmarkStdCmd", "", true},
+	{"BenchmarkHelloSize", "", false},
+	{"BenchmarkCmdGoSize", "", true},
+}
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: compilebench [options]\n")
+	fmt.Fprintf(os.Stderr, "options:\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("compilebench: ")
+	flag.Usage = usage
+	flag.Parse()
+	if flag.NArg() != 0 {
+		usage()
+	}
+
+	s, err := exec.Command(*flagGoCmd, "env", "GOROOT").CombinedOutput()
+	if err != nil {
+		log.Fatalf("%s env GOROOT: %v", *flagGoCmd, err)
+	}
+	goroot = strings.TrimSpace(string(s))
+
+	compiler = *flagCompiler
+	if compiler == "" {
+		out, err := exec.Command(*flagGoCmd, "tool", "-n", "compile").CombinedOutput()
+		if err != nil {
+			out, err = exec.Command(*flagGoCmd, "tool", "-n", "6g").CombinedOutput()
+			is6g = true
+			if err != nil {
+				out, err = exec.Command(*flagGoCmd, "tool", "-n", "compile").CombinedOutput()
+				log.Fatalf("go tool -n compiler: %v\n%s", err, out)
+			}
+		}
+		compiler = strings.TrimSpace(string(out))
+	}
+
+	if *flagRun != "" {
+		r, err := regexp.Compile(*flagRun)
+		if err != nil {
+			log.Fatalf("invalid -run argument: %v", err)
+		}
+		runRE = r
+	}
+
+	for i := 0; i < *flagCount; i++ {
+		if *flagPackage != "" {
+			runBuild("BenchmarkPkg", *flagPackage, i)
+			continue
+		}
+		for _, tt := range tests {
+			if tt.long && *flagShort {
+				continue
+			}
+			if runRE == nil || runRE.MatchString(tt.name) {
+				runBuild(tt.name, tt.dir, i)
+			}
+		}
+	}
+}
+
+func runCmd(name string, cmd *exec.Cmd) {
+	start := time.Now()
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Printf("%v: %v\n%s", name, err, out)
+		return
+	}
+	fmt.Printf("%s 1 %d ns/op\n", name, time.Since(start).Nanoseconds())
+}
+
+func runStdCmd() {
+	args := []string{"build", "-a"}
+	if *flagCompilerFlags != "" {
+		args = append(args, "-gcflags", *flagCompilerFlags)
+	}
+	args = append(args, "std", "cmd")
+	cmd := exec.Command(*flagGoCmd, args...)
+	cmd.Dir = filepath.Join(goroot, "src")
+	runCmd("BenchmarkStdCmd", cmd)
+}
+
+// path is either a path to a file ("$GOROOT/test/helloworld.go") or a package path ("cmd/go").
+func runSize(name, path string) {
+	cmd := exec.Command(*flagGoCmd, "build", "-o", "_compilebenchout_", path)
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		log.Print(err)
+		return
+	}
+	defer os.Remove("_compilebenchout_")
+	info, err := os.Stat("_compilebenchout_")
+	if err != nil {
+		log.Print(err)
+		return
+	}
+	out, err := exec.Command("size", "_compilebenchout_").CombinedOutput()
+	if err != nil {
+		log.Printf("size: %v\n%s", err, out)
+		return
+	}
+	lines := strings.Split(string(out), "\n")
+	if len(lines) < 2 {
+		log.Printf("not enough output from size: %s", out)
+		return
+	}
+	f := strings.Fields(lines[1])
+	if strings.HasPrefix(lines[0], "__TEXT") && len(f) >= 2 { // OS X
+		fmt.Printf("%s 1 %s text-bytes %s data-bytes %v exe-bytes\n", name, f[0], f[1], info.Size())
+	} else if strings.Contains(lines[0], "bss") && len(f) >= 3 {
+		fmt.Printf("%s 1 %s text-bytes %s data-bytes %s bss-bytes %v exe-bytes\n", name, f[0], f[1], f[2], info.Size())
+	}
+}
+
+func runBuild(name, dir string, count int) {
+	switch name {
+	case "BenchmarkStdCmd":
+		runStdCmd()
+		return
+	case "BenchmarkCmdGoSize":
+		runSize("BenchmarkCmdGoSize", "cmd/go")
+		return
+	case "BenchmarkHelloSize":
+		runSize("BenchmarkHelloSize", filepath.Join(goroot, "test/helloworld.go"))
+		return
+	}
+
+	pkg, err := build.Import(dir, ".", 0)
+	if err != nil {
+		log.Print(err)
+		return
+	}
+	args := []string{"-o", "_compilebench_.o"}
+	if is6g {
+		*flagMemprofilerate = -1
+		*flagAlloc = false
+		*flagCpuprofile = ""
+		*flagMemprofile = ""
+	}
+	if *flagMemprofilerate >= 0 {
+		args = append(args, "-memprofilerate", fmt.Sprint(*flagMemprofilerate))
+	}
+	args = append(args, strings.Fields(*flagCompilerFlags)...)
+	if *flagAlloc || *flagCpuprofile != "" || *flagMemprofile != "" {
+		if *flagAlloc || *flagMemprofile != "" {
+			args = append(args, "-memprofile", "_compilebench_.memprof")
+		}
+		if *flagCpuprofile != "" {
+			args = append(args, "-cpuprofile", "_compilebench_.cpuprof")
+		}
+	}
+	args = append(args, pkg.GoFiles...)
+	cmd := exec.Command(compiler, args...)
+	cmd.Dir = pkg.Dir
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	start := time.Now()
+	err = cmd.Run()
+	if err != nil {
+		log.Printf("%v: %v", name, err)
+		return
+	}
+	end := time.Now()
+
+	var allocs, allocbytes int64
+	if *flagAlloc || *flagMemprofile != "" {
+		out, err := ioutil.ReadFile(pkg.Dir + "/_compilebench_.memprof")
+		if err != nil {
+			log.Print("cannot find memory profile after compilation")
+		}
+		for _, line := range strings.Split(string(out), "\n") {
+			f := strings.Fields(line)
+			if len(f) < 4 || f[0] != "#" || f[2] != "=" {
+				continue
+			}
+			val, err := strconv.ParseInt(f[3], 0, 64)
+			if err != nil {
+				continue
+			}
+			switch f[1] {
+			case "TotalAlloc":
+				allocbytes = val
+			case "Mallocs":
+				allocs = val
+			}
+		}
+
+		if *flagMemprofile != "" {
+			if err := ioutil.WriteFile(*flagMemprofile, out, 0666); err != nil {
+				log.Print(err)
+			}
+		}
+		os.Remove(pkg.Dir + "/_compilebench_.memprof")
+	}
+
+	if *flagCpuprofile != "" {
+		out, err := ioutil.ReadFile(pkg.Dir + "/_compilebench_.cpuprof")
+		if err != nil {
+			log.Print(err)
+		}
+		outpath := *flagCpuprofile
+		if *flagCount != 1 {
+			outpath = fmt.Sprintf("%s_%d", outpath, count)
+		}
+		if err := ioutil.WriteFile(outpath, out, 0666); err != nil {
+			log.Print(err)
+		}
+		os.Remove(pkg.Dir + "/_compilebench_.cpuprof")
+	}
+
+	wallns := end.Sub(start).Nanoseconds()
+	userns := cmd.ProcessState.UserTime().Nanoseconds()
+
+	fmt.Printf("%s 1 %d ns/op %d user-ns/op", name, wallns, userns)
+	if *flagAlloc {
+		fmt.Printf(" %d B/op %d allocs/op", allocbytes, allocs)
+	}
+
+	opath := pkg.Dir + "/_compilebench_.o"
+	if *flagObj {
+		// TODO(josharian): object files are big; just read enough to find what we seek.
+		data, err := ioutil.ReadFile(opath)
+		if err != nil {
+			log.Print(err)
+		}
+		// Find start of export data.
+		i := bytes.Index(data, []byte("\n$$B\n")) + len("\n$$B\n")
+		// Count bytes to end of export data.
+		nexport := bytes.Index(data[i:], []byte("\n$$\n"))
+		fmt.Printf(" %d object-bytes %d export-bytes", len(data), nexport)
+	}
+	fmt.Println()
+
+	os.Remove(opath)
+}
diff --git a/vendor/golang.org/x/tools/cmd/cover/README b/vendor/golang.org/x/tools/cmd/cover/README
new file mode 100644
index 0000000..ff9523d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/README
@@ -0,0 +1,2 @@
+NOTE: For Go releases 1.5 and later, this tool lives in the
+standard repository. The code here is not maintained.
diff --git a/vendor/golang.org/x/tools/cmd/cover/cover.go b/vendor/golang.org/x/tools/cmd/cover/cover.go
new file mode 100644
index 0000000..e093364
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/cover.go
@@ -0,0 +1,722 @@
+// 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"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const usageMessage = "" +
+	`Usage of 'go tool cover':
+Given a coverage profile produced by 'go test':
+	go test -coverprofile=c.out
+
+Open a web browser displaying annotated source code:
+	go tool cover -html=c.out
+
+Write out an HTML file instead of launching a web browser:
+	go tool cover -html=c.out -o coverage.html
+
+Display coverage percentages to stdout for each function:
+	go tool cover -func=c.out
+
+Finally, to generate modified source code with coverage annotations
+(what go test -cover does):
+	go tool cover -mode=set -var=CoverageVariableName program.go
+`
+
+func usage() {
+	fmt.Fprintln(os.Stderr, usageMessage)
+	fmt.Fprintln(os.Stderr, "Flags:")
+	flag.PrintDefaults()
+	fmt.Fprintln(os.Stderr, "\n  Only one of -html, -func, or -mode may be set.")
+	os.Exit(2)
+}
+
+var (
+	mode    = flag.String("mode", "", "coverage mode: set, count, atomic")
+	varVar  = flag.String("var", "GoCover", "name of coverage variable to generate")
+	output  = flag.String("o", "", "file for output; default: stdout")
+	htmlOut = flag.String("html", "", "generate HTML representation of coverage profile")
+	funcOut = flag.String("func", "", "output coverage profile information for each function")
+)
+
+var profile string // The profile to read; the value of -html or -func
+
+var counterStmt func(*File, ast.Expr) ast.Stmt
+
+const (
+	atomicPackagePath = "sync/atomic"
+	atomicPackageName = "_cover_atomic_"
+)
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	// Usage information when no arguments.
+	if flag.NFlag() == 0 && flag.NArg() == 0 {
+		flag.Usage()
+	}
+
+	err := parseFlags()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, `For usage information, run "go tool cover -help"`)
+		os.Exit(2)
+	}
+
+	// Generate coverage-annotated source.
+	if *mode != "" {
+		annotate(flag.Arg(0))
+		return
+	}
+
+	// Output HTML or function coverage information.
+	if *htmlOut != "" {
+		err = htmlOutput(profile, *output)
+	} else {
+		err = funcOutput(profile, *output)
+	}
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "cover: %v\n", err)
+		os.Exit(2)
+	}
+}
+
+// parseFlags sets the profile and counterStmt globals and performs validations.
+func parseFlags() error {
+	profile = *htmlOut
+	if *funcOut != "" {
+		if profile != "" {
+			return fmt.Errorf("too many options")
+		}
+		profile = *funcOut
+	}
+
+	// Must either display a profile or rewrite Go source.
+	if (profile == "") == (*mode == "") {
+		return fmt.Errorf("too many options")
+	}
+
+	if *mode != "" {
+		switch *mode {
+		case "set":
+			counterStmt = setCounterStmt
+		case "count":
+			counterStmt = incCounterStmt
+		case "atomic":
+			counterStmt = atomicCounterStmt
+		default:
+			return fmt.Errorf("unknown -mode %v", *mode)
+		}
+
+		if flag.NArg() == 0 {
+			return fmt.Errorf("missing source file")
+		} else if flag.NArg() == 1 {
+			return nil
+		}
+	} else if flag.NArg() == 0 {
+		return nil
+	}
+	return fmt.Errorf("too many arguments")
+}
+
+// Block represents the information about a basic block to be recorded in the analysis.
+// Note: Our definition of basic block is based on control structures; we don't break
+// apart && and ||. We could but it doesn't seem important enough to bother.
+type Block struct {
+	startByte token.Pos
+	endByte   token.Pos
+	numStmt   int
+}
+
+// File is a wrapper for the state of a file used in the parser.
+// The basic parse tree walker is a method of this type.
+type File struct {
+	fset      *token.FileSet
+	name      string // Name of file.
+	astFile   *ast.File
+	blocks    []Block
+	atomicPkg string // Package name for "sync/atomic" in this file.
+}
+
+// Visit implements the ast.Visitor interface.
+func (f *File) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case *ast.BlockStmt:
+		// If it's a switch or select, the body is a list of case clauses; don't tag the block itself.
+		if len(n.List) > 0 {
+			switch n.List[0].(type) {
+			case *ast.CaseClause: // switch
+				for _, n := range n.List {
+					clause := n.(*ast.CaseClause)
+					clause.Body = f.addCounters(clause.Pos(), clause.End(), clause.Body, false)
+				}
+				return f
+			case *ast.CommClause: // select
+				for _, n := range n.List {
+					clause := n.(*ast.CommClause)
+					clause.Body = f.addCounters(clause.Pos(), clause.End(), clause.Body, false)
+				}
+				return f
+			}
+		}
+		n.List = f.addCounters(n.Lbrace, n.Rbrace+1, n.List, true) // +1 to step past closing brace.
+	case *ast.IfStmt:
+		ast.Walk(f, n.Body)
+		if n.Else == nil {
+			return nil
+		}
+		// The elses are special, because if we have
+		//	if x {
+		//	} else if y {
+		//	}
+		// we want to cover the "if y". To do this, we need a place to drop the counter,
+		// so we add a hidden block:
+		//	if x {
+		//	} else {
+		//		if y {
+		//		}
+		//	}
+		switch stmt := n.Else.(type) {
+		case *ast.IfStmt:
+			block := &ast.BlockStmt{
+				Lbrace: n.Body.End(), // Start at end of the "if" block so the covered part looks like it starts at the "else".
+				List:   []ast.Stmt{stmt},
+				Rbrace: stmt.End(),
+			}
+			n.Else = block
+		case *ast.BlockStmt:
+			stmt.Lbrace = n.Body.End() // Start at end of the "if" block so the covered part looks like it starts at the "else".
+		default:
+			panic("unexpected node type in if")
+		}
+		ast.Walk(f, n.Else)
+		return nil
+	case *ast.SelectStmt:
+		// Don't annotate an empty select - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			return nil
+		}
+	case *ast.SwitchStmt:
+		// Don't annotate an empty switch - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			return nil
+		}
+	case *ast.TypeSwitchStmt:
+		// Don't annotate an empty type switch - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			return nil
+		}
+	}
+	return f
+}
+
+// unquote returns the unquoted string.
+func unquote(s string) string {
+	t, err := strconv.Unquote(s)
+	if err != nil {
+		log.Fatalf("cover: improperly quoted string %q\n", s)
+	}
+	return t
+}
+
+// addImport adds an import for the specified path, if one does not already exist, and returns
+// the local package name.
+func (f *File) addImport(path string) string {
+	// Does the package already import it?
+	for _, s := range f.astFile.Imports {
+		if unquote(s.Path.Value) == path {
+			if s.Name != nil {
+				return s.Name.Name
+			}
+			return filepath.Base(path)
+		}
+	}
+	newImport := &ast.ImportSpec{
+		Name: ast.NewIdent(atomicPackageName),
+		Path: &ast.BasicLit{
+			Kind:  token.STRING,
+			Value: fmt.Sprintf("%q", path),
+		},
+	}
+	impDecl := &ast.GenDecl{
+		Tok: token.IMPORT,
+		Specs: []ast.Spec{
+			newImport,
+		},
+	}
+	// Make the new import the first Decl in the file.
+	astFile := f.astFile
+	astFile.Decls = append(astFile.Decls, nil)
+	copy(astFile.Decls[1:], astFile.Decls[0:])
+	astFile.Decls[0] = impDecl
+	astFile.Imports = append(astFile.Imports, newImport)
+
+	// Now refer to the package, just in case it ends up unused.
+	// That is, append to the end of the file the declaration
+	//	var _ = _cover_atomic_.AddUint32
+	reference := &ast.GenDecl{
+		Tok: token.VAR,
+		Specs: []ast.Spec{
+			&ast.ValueSpec{
+				Names: []*ast.Ident{
+					ast.NewIdent("_"),
+				},
+				Values: []ast.Expr{
+					&ast.SelectorExpr{
+						X:   ast.NewIdent(atomicPackageName),
+						Sel: ast.NewIdent("AddUint32"),
+					},
+				},
+			},
+		},
+	}
+	astFile.Decls = append(astFile.Decls, reference)
+	return atomicPackageName
+}
+
+var slashslash = []byte("//")
+
+// initialComments returns the prefix of content containing only
+// whitespace and line comments.  Any +build directives must appear
+// within this region.  This approach is more reliable than using
+// go/printer to print a modified AST containing comments.
+//
+func initialComments(content []byte) []byte {
+	// Derived from go/build.Context.shouldBuild.
+	end := 0
+	p := content
+	for len(p) > 0 {
+		line := p
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, p = line[:i], p[i+1:]
+		} else {
+			p = p[len(p):]
+		}
+		line = bytes.TrimSpace(line)
+		if len(line) == 0 { // Blank line.
+			end = len(content) - len(p)
+			continue
+		}
+		if !bytes.HasPrefix(line, slashslash) { // Not comment line.
+			break
+		}
+	}
+	return content[:end]
+}
+
+func annotate(name string) {
+	fset := token.NewFileSet()
+	content, err := ioutil.ReadFile(name)
+	if err != nil {
+		log.Fatalf("cover: %s: %s", name, err)
+	}
+	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
+	if err != nil {
+		log.Fatalf("cover: %s: %s", name, err)
+	}
+	parsedFile.Comments = trimComments(parsedFile, fset)
+
+	file := &File{
+		fset:    fset,
+		name:    name,
+		astFile: parsedFile,
+	}
+	if *mode == "atomic" {
+		file.atomicPkg = file.addImport(atomicPackagePath)
+	}
+	ast.Walk(file, file.astFile)
+	fd := os.Stdout
+	if *output != "" {
+		var err error
+		fd, err = os.Create(*output)
+		if err != nil {
+			log.Fatalf("cover: %s", err)
+		}
+	}
+	fd.Write(initialComments(content)) // Retain '// +build' directives.
+	file.print(fd)
+	// After printing the source tree, add some declarations for the counters etc.
+	// We could do this by adding to the tree, but it's easier just to print the text.
+	file.addVariables(fd)
+}
+
+// trimComments drops all but the //go: comments, some of which are semantically important.
+// We drop all others because they can appear in places that cause our counters
+// to appear in syntactically incorrect places. //go: appears at the beginning of
+// the line and is syntactically safe.
+func trimComments(file *ast.File, fset *token.FileSet) []*ast.CommentGroup {
+	var comments []*ast.CommentGroup
+	for _, group := range file.Comments {
+		var list []*ast.Comment
+		for _, comment := range group.List {
+			if strings.HasPrefix(comment.Text, "//go:") && fset.Position(comment.Slash).Column == 1 {
+				list = append(list, comment)
+			}
+		}
+		if list != nil {
+			comments = append(comments, &ast.CommentGroup{List: list})
+		}
+	}
+	return comments
+}
+
+func (f *File) print(w io.Writer) {
+	printer.Fprint(w, f.fset, f.astFile)
+}
+
+// intLiteral returns an ast.BasicLit representing the integer value.
+func (f *File) intLiteral(i int) *ast.BasicLit {
+	node := &ast.BasicLit{
+		Kind:  token.INT,
+		Value: fmt.Sprint(i),
+	}
+	return node
+}
+
+// index returns an ast.BasicLit representing the number of counters present.
+func (f *File) index() *ast.BasicLit {
+	return f.intLiteral(len(f.blocks))
+}
+
+// setCounterStmt returns the expression: __count[23] = 1.
+func setCounterStmt(f *File, counter ast.Expr) ast.Stmt {
+	return &ast.AssignStmt{
+		Lhs: []ast.Expr{counter},
+		Tok: token.ASSIGN,
+		Rhs: []ast.Expr{f.intLiteral(1)},
+	}
+}
+
+// incCounterStmt returns the expression: __count[23]++.
+func incCounterStmt(f *File, counter ast.Expr) ast.Stmt {
+	return &ast.IncDecStmt{
+		X:   counter,
+		Tok: token.INC,
+	}
+}
+
+// atomicCounterStmt returns the expression: atomic.AddUint32(&__count[23], 1)
+func atomicCounterStmt(f *File, counter ast.Expr) ast.Stmt {
+	return &ast.ExprStmt{
+		X: &ast.CallExpr{
+			Fun: &ast.SelectorExpr{
+				X:   ast.NewIdent(f.atomicPkg),
+				Sel: ast.NewIdent("AddUint32"),
+			},
+			Args: []ast.Expr{&ast.UnaryExpr{
+				Op: token.AND,
+				X:  counter,
+			},
+				f.intLiteral(1),
+			},
+		},
+	}
+}
+
+// newCounter creates a new counter expression of the appropriate form.
+func (f *File) newCounter(start, end token.Pos, numStmt int) ast.Stmt {
+	counter := &ast.IndexExpr{
+		X: &ast.SelectorExpr{
+			X:   ast.NewIdent(*varVar),
+			Sel: ast.NewIdent("Count"),
+		},
+		Index: f.index(),
+	}
+	stmt := counterStmt(f, counter)
+	f.blocks = append(f.blocks, Block{start, end, numStmt})
+	return stmt
+}
+
+// addCounters takes a list of statements and adds counters to the beginning of
+// each basic block at the top level of that list. For instance, given
+//
+//	S1
+//	if cond {
+//		S2
+// 	}
+//	S3
+//
+// counters will be added before S1 and before S3. The block containing S2
+// will be visited in a separate call.
+// TODO: Nested simple blocks get unnecessary (but correct) counters
+func (f *File) addCounters(pos, blockEnd token.Pos, list []ast.Stmt, extendToClosingBrace bool) []ast.Stmt {
+	// Special case: make sure we add a counter to an empty block. Can't do this below
+	// or we will add a counter to an empty statement list after, say, a return statement.
+	if len(list) == 0 {
+		return []ast.Stmt{f.newCounter(pos, blockEnd, 0)}
+	}
+	// We have a block (statement list), but it may have several basic blocks due to the
+	// appearance of statements that affect the flow of control.
+	var newList []ast.Stmt
+	for {
+		// Find first statement that affects flow of control (break, continue, if, etc.).
+		// It will be the last statement of this basic block.
+		var last int
+		end := blockEnd
+		for last = 0; last < len(list); last++ {
+			end = f.statementBoundary(list[last])
+			if f.endsBasicSourceBlock(list[last]) {
+				extendToClosingBrace = false // Block is broken up now.
+				last++
+				break
+			}
+		}
+		if extendToClosingBrace {
+			end = blockEnd
+		}
+		if pos != end { // Can have no source to cover if e.g. blocks abut.
+			newList = append(newList, f.newCounter(pos, end, last))
+		}
+		newList = append(newList, list[0:last]...)
+		list = list[last:]
+		if len(list) == 0 {
+			break
+		}
+		pos = list[0].Pos()
+	}
+	return newList
+}
+
+// hasFuncLiteral reports the existence and position of the first func literal
+// in the node, if any. If a func literal appears, it usually marks the termination
+// of a basic block because the function body is itself a block.
+// Therefore we draw a line at the start of the body of the first function literal we find.
+// TODO: what if there's more than one? Probably doesn't matter much.
+func hasFuncLiteral(n ast.Node) (bool, token.Pos) {
+	if n == nil {
+		return false, 0
+	}
+	var literal funcLitFinder
+	ast.Walk(&literal, n)
+	return literal.found(), token.Pos(literal)
+}
+
+// statementBoundary finds the location in s that terminates the current basic
+// block in the source.
+func (f *File) statementBoundary(s ast.Stmt) token.Pos {
+	// Control flow statements are easy.
+	switch s := s.(type) {
+	case *ast.BlockStmt:
+		// Treat blocks like basic blocks to avoid overlapping counters.
+		return s.Lbrace
+	case *ast.IfStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Cond)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.ForStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Cond)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Post)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.LabeledStmt:
+		return f.statementBoundary(s.Stmt)
+	case *ast.RangeStmt:
+		found, pos := hasFuncLiteral(s.X)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.SwitchStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Tag)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.SelectStmt:
+		return s.Body.Lbrace
+	case *ast.TypeSwitchStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	}
+	// If not a control flow statement, it is a declaration, expression, call, etc. and it may have a function literal.
+	// If it does, that's tricky because we want to exclude the body of the function from this block.
+	// Draw a line at the start of the body of the first function literal we find.
+	// TODO: what if there's more than one? Probably doesn't matter much.
+	found, pos := hasFuncLiteral(s)
+	if found {
+		return pos
+	}
+	return s.End()
+}
+
+// endsBasicSourceBlock reports whether s changes the flow of control: break, if, etc.,
+// or if it's just problematic, for instance contains a function literal, which will complicate
+// accounting due to the block-within-an expression.
+func (f *File) endsBasicSourceBlock(s ast.Stmt) bool {
+	switch s := s.(type) {
+	case *ast.BlockStmt:
+		// Treat blocks like basic blocks to avoid overlapping counters.
+		return true
+	case *ast.BranchStmt:
+		return true
+	case *ast.ForStmt:
+		return true
+	case *ast.IfStmt:
+		return true
+	case *ast.LabeledStmt:
+		return f.endsBasicSourceBlock(s.Stmt)
+	case *ast.RangeStmt:
+		return true
+	case *ast.SwitchStmt:
+		return true
+	case *ast.SelectStmt:
+		return true
+	case *ast.TypeSwitchStmt:
+		return true
+	case *ast.ExprStmt:
+		// Calls to panic change the flow.
+		// We really should verify that "panic" is the predefined function,
+		// but without type checking we can't and the likelihood of it being
+		// an actual problem is vanishingly small.
+		if call, ok := s.X.(*ast.CallExpr); ok {
+			if ident, ok := call.Fun.(*ast.Ident); ok && ident.Name == "panic" && len(call.Args) == 1 {
+				return true
+			}
+		}
+	}
+	found, _ := hasFuncLiteral(s)
+	return found
+}
+
+// funcLitFinder implements the ast.Visitor pattern to find the location of any
+// function literal in a subtree.
+type funcLitFinder token.Pos
+
+func (f *funcLitFinder) Visit(node ast.Node) (w ast.Visitor) {
+	if f.found() {
+		return nil // Prune search.
+	}
+	switch n := node.(type) {
+	case *ast.FuncLit:
+		*f = funcLitFinder(n.Body.Lbrace)
+		return nil // Prune search.
+	}
+	return f
+}
+
+func (f *funcLitFinder) found() bool {
+	return token.Pos(*f) != token.NoPos
+}
+
+// Sort interface for []block1; used for self-check in addVariables.
+
+type block1 struct {
+	Block
+	index int
+}
+
+type blockSlice []block1
+
+func (b blockSlice) Len() int           { return len(b) }
+func (b blockSlice) Less(i, j int) bool { return b[i].startByte < b[j].startByte }
+func (b blockSlice) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+
+// offset translates a token position into a 0-indexed byte offset.
+func (f *File) offset(pos token.Pos) int {
+	return f.fset.Position(pos).Offset
+}
+
+// addVariables adds to the end of the file the declarations to set up the counter and position variables.
+func (f *File) addVariables(w io.Writer) {
+	// Self-check: Verify that the instrumented basic blocks are disjoint.
+	t := make([]block1, len(f.blocks))
+	for i := range f.blocks {
+		t[i].Block = f.blocks[i]
+		t[i].index = i
+	}
+	sort.Sort(blockSlice(t))
+	for i := 1; i < len(t); i++ {
+		if t[i-1].endByte > t[i].startByte {
+			fmt.Fprintf(os.Stderr, "cover: internal error: block %d overlaps block %d\n", t[i-1].index, t[i].index)
+			// Note: error message is in byte positions, not token positions.
+			fmt.Fprintf(os.Stderr, "\t%s:#%d,#%d %s:#%d,#%d\n",
+				f.name, f.offset(t[i-1].startByte), f.offset(t[i-1].endByte),
+				f.name, f.offset(t[i].startByte), f.offset(t[i].endByte))
+		}
+	}
+
+	// Declare the coverage struct as a package-level variable.
+	fmt.Fprintf(w, "\nvar %s = struct {\n", *varVar)
+	fmt.Fprintf(w, "\tCount     [%d]uint32\n", len(f.blocks))
+	fmt.Fprintf(w, "\tPos       [3 * %d]uint32\n", len(f.blocks))
+	fmt.Fprintf(w, "\tNumStmt   [%d]uint16\n", len(f.blocks))
+	fmt.Fprintf(w, "} {\n")
+
+	// Initialize the position array field.
+	fmt.Fprintf(w, "\tPos: [3 * %d]uint32{\n", len(f.blocks))
+
+	// A nice long list of positions. Each position is encoded as follows to reduce size:
+	// - 32-bit starting line number
+	// - 32-bit ending line number
+	// - (16 bit ending column number << 16) | (16-bit starting column number).
+	for i, block := range f.blocks {
+		start := f.fset.Position(block.startByte)
+		end := f.fset.Position(block.endByte)
+		fmt.Fprintf(w, "\t\t%d, %d, %#x, // [%d]\n", start.Line, end.Line, (end.Column&0xFFFF)<<16|(start.Column&0xFFFF), i)
+	}
+
+	// Close the position array.
+	fmt.Fprintf(w, "\t},\n")
+
+	// Initialize the position array field.
+	fmt.Fprintf(w, "\tNumStmt: [%d]uint16{\n", len(f.blocks))
+
+	// A nice long list of statements-per-block, so we can give a conventional
+	// valuation of "percent covered". To save space, it's a 16-bit number, so we
+	// clamp it if it overflows - won't matter in practice.
+	for i, block := range f.blocks {
+		n := block.numStmt
+		if n > 1<<16-1 {
+			n = 1<<16 - 1
+		}
+		fmt.Fprintf(w, "\t\t%d, // %d\n", n, i)
+	}
+
+	// Close the statements-per-block array.
+	fmt.Fprintf(w, "\t},\n")
+
+	// Close the struct initialization.
+	fmt.Fprintf(w, "}\n")
+}
diff --git a/vendor/golang.org/x/tools/cmd/cover/cover_test.go b/vendor/golang.org/x/tools/cmd/cover/cover_test.go
new file mode 100644
index 0000000..a18778b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/cover_test.go
@@ -0,0 +1,94 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package main_test
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+const (
+	// Data directory, also the package directory for the test.
+	testdata = "testdata"
+
+	// Binaries we compile.
+	testcover = "./testcover.exe"
+)
+
+var (
+	// Files we use.
+	testMain    = filepath.Join(testdata, "main.go")
+	testTest    = filepath.Join(testdata, "test.go")
+	coverInput  = filepath.Join(testdata, "test_line.go")
+	coverOutput = filepath.Join(testdata, "test_cover.go")
+)
+
+var debug = false // Keeps the rewritten files around if set.
+
+// Run this shell script, but do it in Go so it can be run by "go test".
+//
+//	replace the word LINE with the line number < testdata/test.go > testdata/test_line.go
+// 	go build -o ./testcover
+// 	./testcover -mode=count -var=CoverTest -o ./testdata/test_cover.go testdata/test_line.go
+//	go run ./testdata/main.go ./testdata/test.go
+//
+func TestCover(t *testing.T) {
+	// Read in the test file (testTest) and write it, with LINEs specified, to coverInput.
+	file, err := ioutil.ReadFile(testTest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := bytes.Split(file, []byte("\n"))
+	for i, line := range lines {
+		lines[i] = bytes.Replace(line, []byte("LINE"), []byte(fmt.Sprint(i+1)), -1)
+	}
+	err = ioutil.WriteFile(coverInput, bytes.Join(lines, []byte("\n")), 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// defer removal of test_line.go
+	if !debug {
+		defer os.Remove(coverInput)
+	}
+
+	// go build -o testcover
+	cmd := exec.Command("go", "build", "-o", testcover)
+	run(cmd, t)
+
+	// defer removal of testcover
+	defer os.Remove(testcover)
+
+	// ./testcover -mode=count -var=coverTest -o ./testdata/test_cover.go testdata/test_line.go
+	cmd = exec.Command(testcover, "-mode=count", "-var=coverTest", "-o", coverOutput, coverInput)
+	run(cmd, t)
+
+	// defer removal of ./testdata/test_cover.go
+	if !debug {
+		defer os.Remove(coverOutput)
+	}
+
+	// go run ./testdata/main.go ./testdata/test.go
+	cmd = exec.Command("go", "run", testMain, coverOutput)
+	run(cmd, t)
+}
+
+func run(c *exec.Cmd, t *testing.T) {
+	c.Stdout = os.Stdout
+	c.Stderr = os.Stderr
+	err := c.Run()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/cover/doc.go b/vendor/golang.org/x/tools/cmd/cover/doc.go
new file mode 100644
index 0000000..b74d5b3
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/doc.go
@@ -0,0 +1,27 @@
+// 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.
+
+/*
+Cover is a program for analyzing the coverage profiles generated by
+'go test -coverprofile=cover.out'.
+
+Cover is also used by 'go test -cover' to rewrite the source code with
+annotations to track which parts of each function are executed.
+It operates on one Go source file at a time, computing approximate
+basic block information by studying the source. It is thus more portable
+than binary-rewriting coverage tools, but also a little less capable.
+For instance, it does not probe inside && and || expressions, and can
+be mildly confused by single statements with multiple function literals.
+
+For usage information, please see:
+	go help testflag
+	go tool cover -help
+
+No longer maintained:
+
+For Go releases 1.5 and later, this tool lives in the
+standard repository. The code here is not maintained.
+
+*/
+package main // import "golang.org/x/tools/cmd/cover"
diff --git a/vendor/golang.org/x/tools/cmd/cover/func.go b/vendor/golang.org/x/tools/cmd/cover/func.go
new file mode 100644
index 0000000..41d9fce
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/func.go
@@ -0,0 +1,166 @@
+// 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.
+
+// This file implements the visitor that computes the (line, column)-(line-column) range for each function.
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"text/tabwriter"
+
+	"golang.org/x/tools/cover"
+)
+
+// funcOutput takes two file names as arguments, a coverage profile to read as input and an output
+// file to write ("" means to write to standard output). The function reads the profile and produces
+// as output the coverage data broken down by function, like this:
+//
+//	fmt/format.go:30:	init			100.0%
+//	fmt/format.go:57:	clearflags		100.0%
+//	...
+//	fmt/scan.go:1046:	doScan			100.0%
+//	fmt/scan.go:1075:	advance			96.2%
+//	fmt/scan.go:1119:	doScanf			96.8%
+//	total:		(statements)			91.9%
+
+func funcOutput(profile, outputFile string) error {
+	profiles, err := cover.ParseProfiles(profile)
+	if err != nil {
+		return err
+	}
+
+	var out *bufio.Writer
+	if outputFile == "" {
+		out = bufio.NewWriter(os.Stdout)
+	} else {
+		fd, err := os.Create(outputFile)
+		if err != nil {
+			return err
+		}
+		defer fd.Close()
+		out = bufio.NewWriter(fd)
+	}
+	defer out.Flush()
+
+	tabber := tabwriter.NewWriter(out, 1, 8, 1, '\t', 0)
+	defer tabber.Flush()
+
+	var total, covered int64
+	for _, profile := range profiles {
+		fn := profile.FileName
+		file, err := findFile(fn)
+		if err != nil {
+			return err
+		}
+		funcs, err := findFuncs(file)
+		if err != nil {
+			return err
+		}
+		// Now match up functions and profile blocks.
+		for _, f := range funcs {
+			c, t := f.coverage(profile)
+			fmt.Fprintf(tabber, "%s:%d:\t%s\t%.1f%%\n", fn, f.startLine, f.name, 100.0*float64(c)/float64(t))
+			total += t
+			covered += c
+		}
+	}
+	fmt.Fprintf(tabber, "total:\t(statements)\t%.1f%%\n", 100.0*float64(covered)/float64(total))
+
+	return nil
+}
+
+// findFuncs parses the file and returns a slice of FuncExtent descriptors.
+func findFuncs(name string) ([]*FuncExtent, error) {
+	fset := token.NewFileSet()
+	parsedFile, err := parser.ParseFile(fset, name, nil, 0)
+	if err != nil {
+		return nil, err
+	}
+	visitor := &FuncVisitor{
+		fset:    fset,
+		name:    name,
+		astFile: parsedFile,
+	}
+	ast.Walk(visitor, visitor.astFile)
+	return visitor.funcs, nil
+}
+
+// FuncExtent describes a function's extent in the source by file and position.
+type FuncExtent struct {
+	name      string
+	startLine int
+	startCol  int
+	endLine   int
+	endCol    int
+}
+
+// FuncVisitor implements the visitor that builds the function position list for a file.
+type FuncVisitor struct {
+	fset    *token.FileSet
+	name    string // Name of file.
+	astFile *ast.File
+	funcs   []*FuncExtent
+}
+
+// Visit implements the ast.Visitor interface.
+func (v *FuncVisitor) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case *ast.FuncDecl:
+		start := v.fset.Position(n.Pos())
+		end := v.fset.Position(n.End())
+		fe := &FuncExtent{
+			name:      n.Name.Name,
+			startLine: start.Line,
+			startCol:  start.Column,
+			endLine:   end.Line,
+			endCol:    end.Column,
+		}
+		v.funcs = append(v.funcs, fe)
+	}
+	return v
+}
+
+// coverage returns the fraction of the statements in the function that were covered, as a numerator and denominator.
+func (f *FuncExtent) coverage(profile *cover.Profile) (num, den int64) {
+	// We could avoid making this n^2 overall by doing a single scan and annotating the functions,
+	// but the sizes of the data structures is never very large and the scan is almost instantaneous.
+	var covered, total int64
+	// The blocks are sorted, so we can stop counting as soon as we reach the end of the relevant block.
+	for _, b := range profile.Blocks {
+		if b.StartLine > f.endLine || (b.StartLine == f.endLine && b.StartCol >= f.endCol) {
+			// Past the end of the function.
+			break
+		}
+		if b.EndLine < f.startLine || (b.EndLine == f.startLine && b.EndCol <= f.startCol) {
+			// Before the beginning of the function
+			continue
+		}
+		total += int64(b.NumStmt)
+		if b.Count > 0 {
+			covered += int64(b.NumStmt)
+		}
+	}
+	if total == 0 {
+		total = 1 // Avoid zero denominator.
+	}
+	return covered, total
+}
+
+// findFile finds the location of the named file in GOROOT, GOPATH etc.
+func findFile(file string) (string, error) {
+	dir, file := filepath.Split(file)
+	pkg, err := build.Import(dir, ".", build.FindOnly)
+	if err != nil {
+		return "", fmt.Errorf("can't find %q: %v", file, err)
+	}
+	return filepath.Join(pkg.Dir, file), nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/cover/html.go b/vendor/golang.org/x/tools/cmd/cover/html.go
new file mode 100644
index 0000000..ef50e2b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/html.go
@@ -0,0 +1,284 @@
+// 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 (
+	"bufio"
+	"bytes"
+	"fmt"
+	"html/template"
+	"io"
+	"io/ioutil"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"golang.org/x/tools/cover"
+)
+
+// htmlOutput reads the profile data from profile and generates an HTML
+// coverage report, writing it to outfile. If outfile is empty,
+// it writes the report to a temporary file and opens it in a web browser.
+func htmlOutput(profile, outfile string) error {
+	profiles, err := cover.ParseProfiles(profile)
+	if err != nil {
+		return err
+	}
+
+	var d templateData
+
+	for _, profile := range profiles {
+		fn := profile.FileName
+		if profile.Mode == "set" {
+			d.Set = true
+		}
+		file, err := findFile(fn)
+		if err != nil {
+			return err
+		}
+		src, err := ioutil.ReadFile(file)
+		if err != nil {
+			return fmt.Errorf("can't read %q: %v", fn, err)
+		}
+		var buf bytes.Buffer
+		err = htmlGen(&buf, src, profile.Boundaries(src))
+		if err != nil {
+			return err
+		}
+		d.Files = append(d.Files, &templateFile{
+			Name:     fn,
+			Body:     template.HTML(buf.String()),
+			Coverage: percentCovered(profile),
+		})
+	}
+
+	var out *os.File
+	if outfile == "" {
+		var dir string
+		dir, err = ioutil.TempDir("", "cover")
+		if err != nil {
+			return err
+		}
+		out, err = os.Create(filepath.Join(dir, "coverage.html"))
+	} else {
+		out, err = os.Create(outfile)
+	}
+	if err != nil {
+		return err
+	}
+	err = htmlTemplate.Execute(out, d)
+	if err == nil {
+		err = out.Close()
+	}
+	if err != nil {
+		return err
+	}
+
+	if outfile == "" {
+		if !startBrowser("file://" + out.Name()) {
+			fmt.Fprintf(os.Stderr, "HTML output written to %s\n", out.Name())
+		}
+	}
+
+	return nil
+}
+
+// percentCovered returns, as a percentage, the fraction of the statements in
+// the profile covered by the test run.
+// In effect, it reports the coverage of a given source file.
+func percentCovered(p *cover.Profile) float64 {
+	var total, covered int64
+	for _, b := range p.Blocks {
+		total += int64(b.NumStmt)
+		if b.Count > 0 {
+			covered += int64(b.NumStmt)
+		}
+	}
+	if total == 0 {
+		return 0
+	}
+	return float64(covered) / float64(total) * 100
+}
+
+// htmlGen generates an HTML coverage report with the provided filename,
+// source code, and tokens, and writes it to the given Writer.
+func htmlGen(w io.Writer, src []byte, boundaries []cover.Boundary) error {
+	dst := bufio.NewWriter(w)
+	for i := range src {
+		for len(boundaries) > 0 && boundaries[0].Offset == i {
+			b := boundaries[0]
+			if b.Start {
+				n := 0
+				if b.Count > 0 {
+					n = int(math.Floor(b.Norm*9)) + 1
+				}
+				fmt.Fprintf(dst, `<span class="cov%v" title="%v">`, n, b.Count)
+			} else {
+				dst.WriteString("</span>")
+			}
+			boundaries = boundaries[1:]
+		}
+		switch b := src[i]; b {
+		case '>':
+			dst.WriteString("&gt;")
+		case '<':
+			dst.WriteString("&lt;")
+		case '&':
+			dst.WriteString("&amp;")
+		case '\t':
+			dst.WriteString("        ")
+		default:
+			dst.WriteByte(b)
+		}
+	}
+	return dst.Flush()
+}
+
+// startBrowser tries to open the URL in a browser
+// and reports whether it succeeds.
+func startBrowser(url string) bool {
+	// try to start the browser
+	var args []string
+	switch runtime.GOOS {
+	case "darwin":
+		args = []string{"open"}
+	case "windows":
+		args = []string{"cmd", "/c", "start"}
+	default:
+		args = []string{"xdg-open"}
+	}
+	cmd := exec.Command(args[0], append(args[1:], url)...)
+	return cmd.Start() == nil
+}
+
+// rgb returns an rgb value for the specified coverage value
+// between 0 (no coverage) and 10 (max coverage).
+func rgb(n int) string {
+	if n == 0 {
+		return "rgb(192, 0, 0)" // Red
+	}
+	// Gradient from gray to green.
+	r := 128 - 12*(n-1)
+	g := 128 + 12*(n-1)
+	b := 128 + 3*(n-1)
+	return fmt.Sprintf("rgb(%v, %v, %v)", r, g, b)
+}
+
+// colors generates the CSS rules for coverage colors.
+func colors() template.CSS {
+	var buf bytes.Buffer
+	for i := 0; i < 11; i++ {
+		fmt.Fprintf(&buf, ".cov%v { color: %v }\n", i, rgb(i))
+	}
+	return template.CSS(buf.String())
+}
+
+var htmlTemplate = template.Must(template.New("html").Funcs(template.FuncMap{
+	"colors": colors,
+}).Parse(tmplHTML))
+
+type templateData struct {
+	Files []*templateFile
+	Set   bool
+}
+
+type templateFile struct {
+	Name     string
+	Body     template.HTML
+	Coverage float64
+}
+
+const tmplHTML = `
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+		<style>
+			body {
+				background: black;
+				color: rgb(80, 80, 80);
+			}
+			body, pre, #legend span {
+				font-family: Menlo, monospace;
+				font-weight: bold;
+			}
+			#topbar {
+				background: black;
+				position: fixed;
+				top: 0; left: 0; right: 0;
+				height: 42px;
+				border-bottom: 1px solid rgb(80, 80, 80);
+			}
+			#content {
+				margin-top: 50px;
+			}
+			#nav, #legend {
+				float: left;
+				margin-left: 10px;
+			}
+			#legend {
+				margin-top: 12px;
+			}
+			#nav {
+				margin-top: 10px;
+			}
+			#legend span {
+				margin: 0 5px;
+			}
+			{{colors}}
+		</style>
+	</head>
+	<body>
+		<div id="topbar">
+			<div id="nav">
+				<select id="files">
+				{{range $i, $f := .Files}}
+				<option value="file{{$i}}">{{$f.Name}} ({{printf "%.1f" $f.Coverage}}%)</option>
+				{{end}}
+				</select>
+			</div>
+			<div id="legend">
+				<span>not tracked</span>
+			{{if .Set}}
+				<span class="cov0">not covered</span>
+				<span class="cov8">covered</span>
+			{{else}}
+				<span class="cov0">no coverage</span>
+				<span class="cov1">low coverage</span>
+				<span class="cov2">*</span>
+				<span class="cov3">*</span>
+				<span class="cov4">*</span>
+				<span class="cov5">*</span>
+				<span class="cov6">*</span>
+				<span class="cov7">*</span>
+				<span class="cov8">*</span>
+				<span class="cov9">*</span>
+				<span class="cov10">high coverage</span>
+			{{end}}
+			</div>
+		</div>
+		<div id="content">
+		{{range $i, $f := .Files}}
+		<pre class="file" id="file{{$i}}" {{if $i}}style="display: none"{{end}}>{{$f.Body}}</pre>
+		{{end}}
+		</div>
+	</body>
+	<script>
+	(function() {
+		var files = document.getElementById('files');
+		var visible = document.getElementById('file0');
+		files.addEventListener('change', onChange, false);
+		function onChange() {
+			visible.style.display = 'none';
+			visible = document.getElementById(files.value);
+			visible.style.display = 'block';
+			window.scrollTo(0, 0);
+		}
+	})();
+	</script>
+</html>
+`
diff --git a/vendor/golang.org/x/tools/cmd/cover/testdata/main.go b/vendor/golang.org/x/tools/cmd/cover/testdata/main.go
new file mode 100644
index 0000000..6ed39c4
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/testdata/main.go
@@ -0,0 +1,112 @@
+// 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.
+
+// Test runner for coverage test. This file is not coverage-annotated; test.go is.
+// It knows the coverage counter is called "coverTest".
+
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	testAll()
+	verify()
+}
+
+type block struct {
+	count uint32
+	line  uint32
+}
+
+var counters = make(map[block]bool)
+
+// check records the location and expected value for a counter.
+func check(line, count uint32) {
+	b := block{
+		count,
+		line,
+	}
+	counters[b] = true
+}
+
+// checkVal is a version of check that returns its extra argument,
+// so it can be used in conditionals.
+func checkVal(line, count uint32, val int) int {
+	b := block{
+		count,
+		line,
+	}
+	counters[b] = true
+	return val
+}
+
+var PASS = true
+
+// verify checks the expected counts against the actual. It runs after the test has completed.
+func verify() {
+	for b := range counters {
+		got, index := count(b.line)
+		if b.count == anything && got != 0 {
+			got = anything
+		}
+		if got != b.count {
+			fmt.Fprintf(os.Stderr, "test_go:%d expected count %d got %d [counter %d]\n", b.line, b.count, got, index)
+			PASS = false
+		}
+	}
+	verifyPanic()
+	if !PASS {
+		fmt.Fprintf(os.Stderr, "FAIL\n")
+		os.Exit(2)
+	}
+}
+
+// verifyPanic is a special check for the known counter that should be
+// after the panic call in testPanic.
+func verifyPanic() {
+	if coverTest.Count[panicIndex-1] != 1 {
+		// Sanity check for test before panic.
+		fmt.Fprintf(os.Stderr, "bad before panic")
+		PASS = false
+	}
+	if coverTest.Count[panicIndex] != 0 {
+		fmt.Fprintf(os.Stderr, "bad at panic: %d should be 0\n", coverTest.Count[panicIndex])
+		PASS = false
+	}
+	if coverTest.Count[panicIndex+1] != 1 {
+		fmt.Fprintf(os.Stderr, "bad after panic")
+		PASS = false
+	}
+}
+
+// count returns the count and index for the counter at the specified line.
+func count(line uint32) (uint32, int) {
+	// Linear search is fine. Choose perfect fit over approximate.
+	// We can have a closing brace for a range on the same line as a condition for an "else if"
+	// and we don't want that brace to steal the count for the condition on the "if".
+	// Therefore we test for a perfect (lo==line && hi==line) match, but if we can't
+	// find that we take the first imperfect match.
+	index := -1
+	indexLo := uint32(1e9)
+	for i := range coverTest.Count {
+		lo, hi := coverTest.Pos[3*i], coverTest.Pos[3*i+1]
+		if lo == line && line == hi {
+			return coverTest.Count[i], i
+		}
+		// Choose the earliest match (the counters are in unpredictable order).
+		if lo <= line && line <= hi && indexLo > lo {
+			index = i
+			indexLo = lo
+		}
+	}
+	if index == -1 {
+		fmt.Fprintln(os.Stderr, "cover_test: no counter for line", line)
+		PASS = false
+		return 0, 0
+	}
+	return coverTest.Count[index], index
+}
diff --git a/vendor/golang.org/x/tools/cmd/cover/testdata/test.go b/vendor/golang.org/x/tools/cmd/cover/testdata/test.go
new file mode 100644
index 0000000..9013950
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/cover/testdata/test.go
@@ -0,0 +1,218 @@
+// 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.
+
+// This program is processed by the cover command, and then testAll is called.
+// The test driver in main.go can then compare the coverage statistics with expectation.
+
+// The word LINE is replaced by the line number in this file. When the file is executed,
+// the coverage processing has changed the line numbers, so we can't use runtime.Caller.
+
+package main
+
+const anything = 1e9 // Just some unlikely value that means "we got here, don't care how often"
+
+func testAll() {
+	testSimple()
+	testBlockRun()
+	testIf()
+	testFor()
+	testRange()
+	testSwitch()
+	testTypeSwitch()
+	testSelect1()
+	testSelect2()
+	testPanic()
+	testEmptySwitches()
+}
+
+// The indexes of the counters in testPanic are known to main.go
+const panicIndex = 3
+
+// This test appears first because the index of its counters is known to main.go
+func testPanic() {
+	defer func() {
+		recover()
+	}()
+	check(LINE, 1)
+	panic("should not get next line")
+	check(LINE, 0) // this is GoCover.Count[panicIndex]
+	// The next counter is in testSimple and it will be non-zero.
+	// If the panic above does not trigger a counter, the test will fail
+	// because GoCover.Count[panicIndex] will be the one in testSimple.
+}
+
+func testSimple() {
+	check(LINE, 1)
+}
+
+func testIf() {
+	if true {
+		check(LINE, 1)
+	} else {
+		check(LINE, 0)
+	}
+	if false {
+		check(LINE, 0)
+	} else {
+		check(LINE, 1)
+	}
+	for i := 0; i < 3; i++ {
+		if checkVal(LINE, 3, i) <= 2 {
+			check(LINE, 3)
+		}
+		if checkVal(LINE, 3, i) <= 1 {
+			check(LINE, 2)
+		}
+		if checkVal(LINE, 3, i) <= 0 {
+			check(LINE, 1)
+		}
+	}
+	for i := 0; i < 3; i++ {
+		if checkVal(LINE, 3, i) <= 1 {
+			check(LINE, 2)
+		} else {
+			check(LINE, 1)
+		}
+	}
+	for i := 0; i < 3; i++ {
+		if checkVal(LINE, 3, i) <= 0 {
+			check(LINE, 1)
+		} else if checkVal(LINE, 2, i) <= 1 {
+			check(LINE, 1)
+		} else if checkVal(LINE, 1, i) <= 2 {
+			check(LINE, 1)
+		} else if checkVal(LINE, 0, i) <= 3 {
+			check(LINE, 0)
+		}
+	}
+	if func(a, b int) bool { return a < b }(3, 4) {
+		check(LINE, 1)
+	}
+}
+
+func testFor() {
+	for i := 0; i < 10; func() { i++; check(LINE, 10) }() {
+		check(LINE, 10)
+	}
+}
+
+func testRange() {
+	for _, f := range []func(){
+		func() { check(LINE, 1) },
+	} {
+		f()
+		check(LINE, 1)
+	}
+}
+
+func testBlockRun() {
+	check(LINE, 1)
+	{
+		check(LINE, 1)
+	}
+	{
+		check(LINE, 1)
+	}
+	check(LINE, 1)
+	{
+		check(LINE, 1)
+	}
+	{
+		check(LINE, 1)
+	}
+	check(LINE, 1)
+}
+
+func testSwitch() {
+	for i := 0; i < 5; func() { i++; check(LINE, 5) }() {
+		switch i {
+		case 0:
+			check(LINE, 1)
+		case 1:
+			check(LINE, 1)
+		case 2:
+			check(LINE, 1)
+		default:
+			check(LINE, 2)
+		}
+	}
+}
+
+func testTypeSwitch() {
+	var x = []interface{}{1, 2.0, "hi"}
+	for _, v := range x {
+		switch func() { check(LINE, 3) }(); v.(type) {
+		case int:
+			check(LINE, 1)
+		case float64:
+			check(LINE, 1)
+		case string:
+			check(LINE, 1)
+		case complex128:
+			check(LINE, 0)
+		default:
+			check(LINE, 0)
+		}
+	}
+}
+
+func testSelect1() {
+	c := make(chan int)
+	go func() {
+		for i := 0; i < 1000; i++ {
+			c <- i
+		}
+	}()
+	for {
+		select {
+		case <-c:
+			check(LINE, anything)
+		case <-c:
+			check(LINE, anything)
+		default:
+			check(LINE, 1)
+			return
+		}
+	}
+}
+
+func testSelect2() {
+	c1 := make(chan int, 1000)
+	c2 := make(chan int, 1000)
+	for i := 0; i < 1000; i++ {
+		c1 <- i
+		c2 <- i
+	}
+	for {
+		select {
+		case <-c1:
+			check(LINE, 1000)
+		case <-c2:
+			check(LINE, 1000)
+		default:
+			check(LINE, 1)
+			return
+		}
+	}
+}
+
+// Empty control statements created syntax errors. This function
+// is here just to be sure that those are handled correctly now.
+func testEmptySwitches() {
+	check(LINE, 1)
+	switch 3 {
+	}
+	check(LINE, 1)
+	switch i := (interface{})(3).(int); i {
+	}
+	check(LINE, 1)
+	c := make(chan int)
+	go func() {
+		check(LINE, 1)
+		c <- 1
+		select {}
+	}()
+	<-c
+	check(LINE, 1)
+}
diff --git a/vendor/golang.org/x/tools/cmd/digraph/digraph.go b/vendor/golang.org/x/tools/cmd/digraph/digraph.go
new file mode 100644
index 0000000..3ad2950
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/digraph/digraph.go
@@ -0,0 +1,540 @@
+// The digraph command performs queries over unlabelled directed graphs
+// represented in text form.  It is intended to integrate nicely with
+// typical UNIX command pipelines.
+//
+// Since directed graphs (import graphs, reference graphs, call graphs,
+// etc) often arise during software tool development and debugging, this
+// command is included in the go.tools repository.
+//
+// TODO(adonovan):
+// - support input files other than stdin
+// - suport alternative formats (AT&T GraphViz, CSV, etc),
+//   a comment syntax, etc.
+// - allow queries to nest, like Blaze query language.
+//
+package main // import "golang.org/x/tools/cmd/digraph"
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"strconv"
+	"unicode"
+	"unicode/utf8"
+)
+
+const Usage = `digraph: queries over directed graphs in text form.
+
+Graph format:
+
+  Each line contains zero or more words.  Words are separated by
+  unquoted whitespace; words may contain Go-style double-quoted portions,
+  allowing spaces and other characters to be expressed.
+
+  Each field declares a node, and if there are more than one,
+  an edge from the first to each subsequent one.
+  The graph is provided on the standard input.
+
+  For instance, the following (acyclic) graph specifies a partial order
+  among the subtasks of getting dressed:
+
+	% cat clothes.txt
+	socks shoes
+	"boxer shorts" pants
+	pants belt shoes
+	shirt tie sweater
+	sweater jacket
+	hat
+
+  The line "shirt tie sweater" indicates the two edges shirt -> tie and
+  shirt -> sweater, not shirt -> tie -> sweater.
+
+Supported queries:
+
+  nodes
+	the set of all nodes
+  degree
+	the in-degree and out-degree of each node.
+  preds <label> ...
+	the set of immediate predecessors of the specified nodes
+  succs <label> ...
+	the set of immediate successors of the specified nodes
+  forward <label> ...
+	the set of nodes transitively reachable from the specified nodes
+  reverse <label> ...
+	the set of nodes that transitively reach the specified nodes
+  somepath <label> <label>
+	the list of nodes on some arbitrary path from the first node to the second
+  allpaths <label> <label>
+	the set of nodes on all paths from the first node to the second
+  sccs
+	all strongly connected components (one per line)
+  scc <label>
+	the set of nodes nodes strongly connected to the specified one
+
+Example usage:
+
+   Show the transitive closure of imports of the digraph tool itself:
+   % go list -f '{{.ImportPath}}{{.Imports}}' ... | tr '[]' '  ' |
+         digraph forward golang.org/x/tools/cmd/digraph
+
+   Show which clothes (see above) must be donned before a jacket:
+   %  digraph reverse jacket <clothes.txt
+
+`
+
+func main() {
+	flag.Parse()
+
+	args := flag.Args()
+	if len(args) == 0 {
+		fmt.Println(Usage)
+		return
+	}
+
+	if err := digraph(args[0], args[1:]); err != nil {
+		fmt.Fprintf(os.Stderr, "digraph: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+type nodelist []string
+
+func (l nodelist) println(sep string) {
+	for i, label := range l {
+		if i > 0 {
+			fmt.Fprint(stdout, sep)
+		}
+		fmt.Fprint(stdout, label)
+	}
+	fmt.Fprintln(stdout)
+}
+
+type nodeset map[string]bool
+
+func (s nodeset) sort() nodelist {
+	labels := make(nodelist, len(s))
+	var i int
+	for label := range s {
+		labels[i] = label
+		i++
+	}
+	sort.Strings(labels)
+	return labels
+}
+
+func (s nodeset) addAll(x nodeset) {
+	for label := range x {
+		s[label] = true
+	}
+}
+
+// A graph maps nodes to the non-nil set of their immediate successors.
+type graph map[string]nodeset
+
+func (g graph) addNode(label string) nodeset {
+	edges := g[label]
+	if edges == nil {
+		edges = make(nodeset)
+		g[label] = edges
+	}
+	return edges
+}
+
+func (g graph) addEdges(from string, to ...string) {
+	edges := g.addNode(from)
+	for _, to := range to {
+		g.addNode(to)
+		edges[to] = true
+	}
+}
+
+func (g graph) reachableFrom(roots nodeset) nodeset {
+	seen := make(nodeset)
+	var visit func(label string)
+	visit = func(label string) {
+		if !seen[label] {
+			seen[label] = true
+			for e := range g[label] {
+				visit(e)
+			}
+		}
+	}
+	for root := range roots {
+		visit(root)
+	}
+	return seen
+}
+
+func (g graph) transpose() graph {
+	rev := make(graph)
+	for label, edges := range g {
+		rev.addNode(label)
+		for succ := range edges {
+			rev.addEdges(succ, label)
+		}
+	}
+	return rev
+}
+
+func (g graph) sccs() []nodeset {
+	// Kosaraju's algorithm---Tarjan is overkill here.
+
+	// Forward pass.
+	S := make(nodelist, 0, len(g)) // postorder stack
+	seen := make(nodeset)
+	var visit func(label string)
+	visit = func(label string) {
+		if !seen[label] {
+			seen[label] = true
+			for e := range g[label] {
+				visit(e)
+			}
+			S = append(S, label)
+		}
+	}
+	for label := range g {
+		visit(label)
+	}
+
+	// Reverse pass.
+	rev := g.transpose()
+	var scc nodeset
+	seen = make(nodeset)
+	var rvisit func(label string)
+	rvisit = func(label string) {
+		if !seen[label] {
+			seen[label] = true
+			scc[label] = true
+			for e := range rev[label] {
+				rvisit(e)
+			}
+		}
+	}
+	var sccs []nodeset
+	for len(S) > 0 {
+		top := S[len(S)-1]
+		S = S[:len(S)-1] // pop
+		if !seen[top] {
+			scc = make(nodeset)
+			rvisit(top)
+			sccs = append(sccs, scc)
+		}
+	}
+	return sccs
+}
+
+func parse(rd io.Reader) (graph, error) {
+	g := make(graph)
+
+	var linenum int
+	in := bufio.NewScanner(rd)
+	for in.Scan() {
+		linenum++
+		// Split into words, honoring double-quotes per Go spec.
+		words, err := split(in.Text())
+		if err != nil {
+			return nil, fmt.Errorf("at line %d: %v", linenum, err)
+		}
+		if len(words) > 0 {
+			g.addEdges(words[0], words[1:]...)
+		}
+	}
+	if err := in.Err(); err != nil {
+		return nil, err
+	}
+	return g, nil
+}
+
+var stdin io.Reader = os.Stdin
+var stdout io.Writer = os.Stdout
+
+func digraph(cmd string, args []string) error {
+	// Parse the input graph.
+	g, err := parse(stdin)
+	if err != nil {
+		return err
+	}
+
+	// Parse the command line.
+	switch cmd {
+	case "nodes":
+		if len(args) != 0 {
+			return fmt.Errorf("usage: digraph nodes")
+		}
+		nodes := make(nodeset)
+		for label := range g {
+			nodes[label] = true
+		}
+		nodes.sort().println("\n")
+
+	case "degree":
+		if len(args) != 0 {
+			return fmt.Errorf("usage: digraph degree")
+		}
+		nodes := make(nodeset)
+		for label := range g {
+			nodes[label] = true
+		}
+		rev := g.transpose()
+		for _, label := range nodes.sort() {
+			fmt.Fprintf(stdout, "%d\t%d\t%s\n", len(rev[label]), len(g[label]), label)
+		}
+
+	case "succs", "preds":
+		if len(args) == 0 {
+			return fmt.Errorf("usage: digraph %s <label> ...", cmd)
+		}
+		g := g
+		if cmd == "preds" {
+			g = g.transpose()
+		}
+		result := make(nodeset)
+		for _, root := range args {
+			edges := g[root]
+			if edges == nil {
+				return fmt.Errorf("no such node %q", root)
+			}
+			result.addAll(edges)
+		}
+		result.sort().println("\n")
+
+	case "forward", "reverse":
+		if len(args) == 0 {
+			return fmt.Errorf("usage: digraph %s <label> ...", cmd)
+		}
+		roots := make(nodeset)
+		for _, root := range args {
+			if g[root] == nil {
+				return fmt.Errorf("no such node %q", root)
+			}
+			roots[root] = true
+		}
+		g := g
+		if cmd == "reverse" {
+			g = g.transpose()
+		}
+		g.reachableFrom(roots).sort().println("\n")
+
+	case "somepath":
+		if len(args) != 2 {
+			return fmt.Errorf("usage: digraph somepath <from> <to>")
+		}
+		from, to := args[0], args[1]
+		if g[from] == nil {
+			return fmt.Errorf("no such 'from' node %q", from)
+		}
+		if g[to] == nil {
+			return fmt.Errorf("no such 'to' node %q", to)
+		}
+
+		seen := make(nodeset)
+		var visit func(path nodelist, label string) bool
+		visit = func(path nodelist, label string) bool {
+			if !seen[label] {
+				seen[label] = true
+				if label == to {
+					append(path, label).println("\n")
+					return true // unwind
+				}
+				for e := range g[label] {
+					if visit(append(path, label), e) {
+						return true
+					}
+				}
+			}
+			return false
+		}
+		if !visit(make(nodelist, 0, 100), from) {
+			return fmt.Errorf("no path from %q to %q", args[0], args[1])
+		}
+
+	case "allpaths":
+		if len(args) != 2 {
+			return fmt.Errorf("usage: digraph allpaths <from> <to>")
+		}
+		from, to := args[0], args[1]
+		if g[from] == nil {
+			return fmt.Errorf("no such 'from' node %q", from)
+		}
+		if g[to] == nil {
+			return fmt.Errorf("no such 'to' node %q", to)
+		}
+
+		seen := make(nodeset) // value of seen[x] indicates whether x is on some path to 'to'
+		var visit func(label string) bool
+		visit = func(label string) bool {
+			reachesTo, ok := seen[label]
+			if !ok {
+				reachesTo = label == to
+
+				seen[label] = reachesTo
+				for e := range g[label] {
+					if visit(e) {
+						reachesTo = true
+					}
+				}
+				seen[label] = reachesTo
+			}
+			return reachesTo
+		}
+		if !visit(from) {
+			return fmt.Errorf("no path from %q to %q", from, to)
+		}
+		for label, reachesTo := range seen {
+			if !reachesTo {
+				delete(seen, label)
+			}
+		}
+		seen.sort().println("\n")
+
+	case "sccs":
+		if len(args) != 0 {
+			return fmt.Errorf("usage: digraph sccs")
+		}
+		for _, scc := range g.sccs() {
+			scc.sort().println(" ")
+		}
+
+	case "scc":
+		if len(args) != 1 {
+			return fmt.Errorf("usage: digraph scc <label>")
+		}
+		label := args[0]
+		if g[label] == nil {
+			return fmt.Errorf("no such node %q", label)
+		}
+		for _, scc := range g.sccs() {
+			if scc[label] {
+				scc.sort().println("\n")
+				break
+			}
+		}
+
+	default:
+		return fmt.Errorf("no such command %q", cmd)
+	}
+
+	return nil
+}
+
+// -- Utilities --------------------------------------------------------
+
+// split splits a line into words, which are generally separated by
+// spaces, but Go-style double-quoted string literals are also supported.
+// (This approximates the behaviour of the Bourne shell.)
+//
+//   `one "two three"` -> ["one" "two three"]
+//   `a"\n"b` -> ["a\nb"]
+//
+func split(line string) ([]string, error) {
+	var (
+		words   []string
+		inWord  bool
+		current bytes.Buffer
+	)
+
+	for len(line) > 0 {
+		r, size := utf8.DecodeRuneInString(line)
+		if unicode.IsSpace(r) {
+			if inWord {
+				words = append(words, current.String())
+				current.Reset()
+				inWord = false
+			}
+		} else if r == '"' {
+			var ok bool
+			size, ok = quotedLength(line)
+			if !ok {
+				return nil, errors.New("invalid quotation")
+			}
+			s, err := strconv.Unquote(line[:size])
+			if err != nil {
+				return nil, err
+			}
+			current.WriteString(s)
+			inWord = true
+		} else {
+			current.WriteRune(r)
+			inWord = true
+		}
+		line = line[size:]
+	}
+	if inWord {
+		words = append(words, current.String())
+	}
+	return words, nil
+}
+
+// quotedLength returns the length in bytes of the prefix of input that
+// contain a possibly-valid double-quoted Go string literal.
+//
+// On success, n is at least two (""); input[:n] may be passed to
+// strconv.Unquote to interpret its value, and input[n:] contains the
+// rest of the input.
+//
+// On failure, quotedLength returns false, and the entire input can be
+// passed to strconv.Unquote if an informative error message is desired.
+//
+// quotedLength does not and need not detect all errors, such as
+// invalid hex or octal escape sequences, since it assumes
+// strconv.Unquote will be applied to the prefix.  It guarantees only
+// that if there is a prefix of input containing a valid string literal,
+// its length is returned.
+//
+// TODO(adonovan): move this into a strconv-like utility package.
+//
+func quotedLength(input string) (n int, ok bool) {
+	var offset int
+
+	// next returns the rune at offset, or -1 on EOF.
+	// offset advances to just after that rune.
+	next := func() rune {
+		if offset < len(input) {
+			r, size := utf8.DecodeRuneInString(input[offset:])
+			offset += size
+			return r
+		}
+		return -1
+	}
+
+	if next() != '"' {
+		return // error: not a quotation
+	}
+
+	for {
+		r := next()
+		if r == '\n' || r < 0 {
+			return // error: string literal not terminated
+		}
+		if r == '"' {
+			return offset, true // success
+		}
+		if r == '\\' {
+			var skip int
+			switch next() {
+			case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '"':
+				skip = 0
+			case '0', '1', '2', '3', '4', '5', '6', '7':
+				skip = 2
+			case 'x':
+				skip = 2
+			case 'u':
+				skip = 4
+			case 'U':
+				skip = 8
+			default:
+				return // error: invalid escape
+			}
+
+			for i := 0; i < skip; i++ {
+				next()
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/digraph/digraph_test.go b/vendor/golang.org/x/tools/cmd/digraph/digraph_test.go
new file mode 100644
index 0000000..0c90304
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/digraph/digraph_test.go
@@ -0,0 +1,121 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDigraph(t *testing.T) {
+	const g1 = `
+socks shoes
+shorts pants
+pants belt shoes
+shirt tie sweater
+sweater jacket
+hat
+`
+
+	const g2 = `
+a b c
+b d
+c d
+d c
+`
+
+	for _, test := range []struct {
+		input string
+		cmd   string
+		args  []string
+		want  string
+	}{
+		{g1, "nodes", nil, "belt\nhat\njacket\npants\nshirt\nshoes\nshorts\nsocks\nsweater\ntie\n"},
+		{g1, "reverse", []string{"jacket"}, "jacket\nshirt\nsweater\n"},
+		{g1, "forward", []string{"socks"}, "shoes\nsocks\n"},
+		{g1, "forward", []string{"socks", "sweater"}, "jacket\nshoes\nsocks\nsweater\n"},
+
+		{g2, "allpaths", []string{"a", "d"}, "a\nb\nc\nd\n"},
+
+		{g2, "sccs", nil, "a\nb\nc d\n"},
+		{g2, "scc", []string{"d"}, "c\nd\n"},
+		{g2, "succs", []string{"a"}, "b\nc\n"},
+		{g2, "preds", []string{"c"}, "a\nd\n"},
+		{g2, "preds", []string{"c", "d"}, "a\nb\nc\nd\n"},
+	} {
+		stdin = strings.NewReader(test.input)
+		stdout = new(bytes.Buffer)
+		if err := digraph(test.cmd, test.args); err != nil {
+			t.Error(err)
+			continue
+		}
+
+		got := stdout.(fmt.Stringer).String()
+		if got != test.want {
+			t.Errorf("digraph(%s, %s) = %q, want %q", test.cmd, test.args, got, test.want)
+		}
+	}
+
+	// TODO(adonovan):
+	// - test somepath (it's nondeterministic).
+	// - test errors
+}
+
+func TestSplit(t *testing.T) {
+	for _, test := range []struct {
+		line string
+		want []string
+	}{
+		{`one "2a 2b" three`, []string{"one", "2a 2b", "three"}},
+		{`one tw"\n\x0a\u000a\012"o three`, []string{"one", "tw\n\n\n\no", "three"}},
+	} {
+		got, err := split(test.line)
+		if err != nil {
+			t.Errorf("split(%s) failed: %v", test.line, err)
+		}
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("split(%s) = %v, want %v", test.line, got, test.want)
+		}
+	}
+}
+
+func TestQuotedLength(t *testing.T) {
+	for _, test := range []struct {
+		input string
+		want  int
+	}{
+		{`"abc"`, 5},
+		{`"abc"def`, 5},
+		{`"abc\"d"ef`, 8}, // "abc\"d" is consumed, ef is residue
+		{`"\012\n\x0a\u000a\U0000000a"`, 28},
+		{"\"\xff\"", 3}, // bad UTF-8 is ok
+		{`"\xff"`, 6},   // hex escape for bad UTF-8 is ok
+	} {
+		got, ok := quotedLength(test.input)
+		if !ok {
+			got = 0
+		}
+		if got != test.want {
+			t.Errorf("quotedLength(%s) = %d, want %d", test.input, got, test.want)
+		}
+	}
+
+	// errors
+	for _, input := range []string{
+		``,            // not a quotation
+		`a`,           // not a quotation
+		`'a'`,         // not a quotation
+		`"a`,          // not terminated
+		`"\0"`,        // short octal escape
+		`"\x1"`,       // short hex escape
+		`"\u000"`,     // short \u escape
+		`"\U0000000"`, // short \U escape
+		`"\k"`,        // invalid escape
+		"\"ab\nc\"",   // newline
+	} {
+		if n, ok := quotedLength(input); ok {
+			t.Errorf("quotedLength(%s) = %d, want !ok", input, n)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/eg/eg.go b/vendor/golang.org/x/tools/cmd/eg/eg.go
new file mode 100644
index 0000000..18b0f09
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/eg/eg.go
@@ -0,0 +1,150 @@
+// The eg command performs example-based refactoring.
+// For documentation, run the command, or see Help in
+// golang.org/x/tools/refactor/eg.
+package main // import "golang.org/x/tools/cmd/eg"
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"strings"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/refactor/eg"
+)
+
+var (
+	beforeeditFlag = flag.String("beforeedit", "", "A command to exec before each file is edited (e.g. chmod, checkout).  Whitespace delimits argument words.  The string '{}' is replaced by the file name.")
+	helpFlag       = flag.Bool("help", false, "show detailed help message")
+	templateFlag   = flag.String("t", "", "template.go file specifying the refactoring")
+	transitiveFlag = flag.Bool("transitive", false, "apply refactoring to all dependencies too")
+	writeFlag      = flag.Bool("w", false, "rewrite input files in place (by default, the results are printed to standard output)")
+	verboseFlag    = flag.Bool("v", false, "show verbose matcher diagnostics")
+)
+
+func init() {
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+}
+
+const usage = `eg: an example-based refactoring tool.
+
+Usage: eg -t template.go [-w] [-transitive] <args>...
+
+-help            show detailed help message
+-t template.go	 specifies the template file (use -help to see explanation)
+-w          	 causes files to be re-written in place.
+-transitive 	 causes all dependencies to be refactored too.
+-v               show verbose matcher diagnostics
+-beforeedit cmd  a command to exec before each file is modified.
+                 "{}" represents the name of the file.
+` + loader.FromArgsUsage
+
+func main() {
+	if err := doMain(); err != nil {
+		fmt.Fprintf(os.Stderr, "eg: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+func doMain() error {
+	flag.Parse()
+	args := flag.Args()
+
+	if *helpFlag {
+		fmt.Fprint(os.Stderr, eg.Help)
+		os.Exit(2)
+	}
+
+	if len(args) == 0 {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
+
+	if *templateFlag == "" {
+		return fmt.Errorf("no -t template.go file specified")
+	}
+
+	conf := loader.Config{
+		Fset:       token.NewFileSet(),
+		ParserMode: parser.ParseComments,
+	}
+
+	// The first Created package is the template.
+	conf.CreateFromFilenames("template", *templateFlag)
+
+	if _, err := conf.FromArgs(args, true); err != nil {
+		return err
+	}
+
+	// Load, parse and type-check the whole program.
+	iprog, err := conf.Load()
+	if err != nil {
+		return err
+	}
+
+	// Analyze the template.
+	template := iprog.Created[0]
+	xform, err := eg.NewTransformer(iprog.Fset, template.Pkg, template.Files[0], &template.Info, *verboseFlag)
+	if err != nil {
+		return err
+	}
+
+	// Apply it to the input packages.
+	var pkgs []*loader.PackageInfo
+	if *transitiveFlag {
+		for _, info := range iprog.AllPackages {
+			pkgs = append(pkgs, info)
+		}
+	} else {
+		pkgs = iprog.InitialPackages()
+	}
+	var hadErrors bool
+	for _, pkg := range pkgs {
+		if pkg == template {
+			continue
+		}
+		for _, file := range pkg.Files {
+			n := xform.Transform(&pkg.Info, pkg.Pkg, file)
+			if n == 0 {
+				continue
+			}
+			filename := iprog.Fset.File(file.Pos()).Name()
+			fmt.Fprintf(os.Stderr, "=== %s (%d matches)\n", filename, n)
+			if *writeFlag {
+				// Run the before-edit command (e.g. "chmod +w",  "checkout") if any.
+				if *beforeeditFlag != "" {
+					args := strings.Fields(*beforeeditFlag)
+					// Replace "{}" with the filename, like find(1).
+					for i := range args {
+						if i > 0 {
+							args[i] = strings.Replace(args[i], "{}", filename, -1)
+						}
+					}
+					cmd := exec.Command(args[0], args[1:]...)
+					cmd.Stdout = os.Stdout
+					cmd.Stderr = os.Stderr
+					if err := cmd.Run(); err != nil {
+						fmt.Fprintf(os.Stderr, "Warning: edit hook %q failed (%s)\n",
+							args, err)
+					}
+				}
+				if err := eg.WriteAST(iprog.Fset, filename, file); err != nil {
+					fmt.Fprintf(os.Stderr, "eg: %s\n", err)
+					hadErrors = true
+				}
+			} else {
+				format.Node(os.Stdout, iprog.Fset, file)
+			}
+		}
+	}
+	if hadErrors {
+		os.Exit(1)
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/main.go b/vendor/golang.org/x/tools/cmd/fiximports/main.go
new file mode 100644
index 0000000..365a261
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/main.go
@@ -0,0 +1,511 @@
+// 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.
+
+// The fiximports command fixes import declarations to use the canonical
+// import path for packages that have an "import comment" as defined by
+// https://golang.org/s/go14customimport.
+//
+//
+// Background
+//
+// The Go 1 custom import path mechanism lets the maintainer of a
+// package give it a stable name by which clients may import and "go
+// get" it, independent of the underlying version control system (such
+// as Git) or server (such as github.com) that hosts it.  Requests for
+// the custom name are redirected to the underlying name.  This allows
+// packages to be migrated from one underlying server or system to
+// another without breaking existing clients.
+//
+// Because this redirect mechanism creates aliases for existing
+// packages, it's possible for a single program to import the same
+// package by its canonical name and by an alias.  The resulting
+// executable will contain two copies of the package, which is wasteful
+// at best and incorrect at worst.
+//
+// To avoid this, "go build" reports an error if it encounters a special
+// comment like the one below, and if the import path in the comment
+// does not match the path of the enclosing package relative to
+// GOPATH/src:
+//
+//      $ grep ^package $GOPATH/src/github.com/bob/vanity/foo/foo.go
+// 	package foo // import "vanity.com/foo"
+//
+// The error from "go build" indicates that the package canonically
+// known as "vanity.com/foo" is locally installed under the
+// non-canonical name "github.com/bob/vanity/foo".
+//
+//
+// Usage
+//
+// When a package that you depend on introduces a custom import comment,
+// and your workspace imports it by the non-canonical name, your build
+// will stop working as soon as you update your copy of that package
+// using "go get -u".
+//
+// The purpose of the fiximports tool is to fix up all imports of the
+// non-canonical path within a Go workspace, replacing them with imports
+// of the canonical path.  Following a run of fiximports, the workspace
+// will no longer depend on the non-canonical copy of the package, so it
+// should be safe to delete.  It may be necessary to run "go get -u"
+// again to ensure that the package is locally installed under its
+// canonical path, if it was not already.
+//
+// The fiximports tool operates locally; it does not make HTTP requests
+// and does not discover new custom import comments.  It only operates
+// on non-canonical packages present in your workspace.
+//
+// The -baddomains flag is a list of domain names that should always be
+// considered non-canonical.  You can use this if you wish to make sure
+// that you no longer have any dependencies on packages from that
+// domain, even those that do not yet provide a canical import path
+// comment.  For example, the default value of -baddomains includes the
+// moribund code hosting site code.google.com, so fiximports will report
+// an error for each import of a package from this domain remaining
+// after canonicalization.
+//
+// To see the changes fiximports would make without applying them, use
+// the -n flag.
+//
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// flags
+var (
+	dryrun     = flag.Bool("n", false, "dry run: show changes, but don't apply them")
+	badDomains = flag.String("baddomains", "code.google.com",
+		"a comma-separated list of domains from which packages should not be imported")
+	replaceFlag = flag.String("replace", "",
+		"a comma-separated list of noncanonical=canonical pairs of package paths.  If both items in a pair end with '...', they are treated as path prefixes.")
+)
+
+// seams for testing
+var (
+	stderr    io.Writer = os.Stderr
+	writeFile           = ioutil.WriteFile
+)
+
+const usage = `fiximports: rewrite import paths to use canonical package names.
+
+Usage: fiximports [-n] package...
+
+The package... arguments specify a list of packages
+in the style of the go tool; see "go help packages".
+Hint: use "all" or "..." to match the entire workspace.
+
+For details, see http://godoc.org/golang.org/x/tools/cmd/fiximports.
+
+Flags:
+  -n:	       dry run: show changes, but don't apply them
+  -baddomains  a comma-separated list of domains from which packages
+               should not be imported
+`
+
+func main() {
+	flag.Parse()
+
+	if len(flag.Args()) == 0 {
+		fmt.Fprintf(stderr, usage)
+		os.Exit(1)
+	}
+	if !fiximports(flag.Args()...) {
+		os.Exit(1)
+	}
+}
+
+type canonicalName struct{ path, name string }
+
+// fiximports fixes imports in the specified packages.
+// Invariant: a false result implies an error was already printed.
+func fiximports(packages ...string) bool {
+	// importedBy is the transpose of the package import graph.
+	importedBy := make(map[string]map[*build.Package]bool)
+
+	// addEdge adds an edge to the import graph.
+	addEdge := func(from *build.Package, to string) {
+		if to == "C" || to == "unsafe" {
+			return // fake
+		}
+		pkgs := importedBy[to]
+		if pkgs == nil {
+			pkgs = make(map[*build.Package]bool)
+			importedBy[to] = pkgs
+		}
+		pkgs[from] = true
+	}
+
+	// List metadata for all packages in the workspace.
+	pkgs, err := list("...")
+	if err != nil {
+		fmt.Fprintf(stderr, "importfix: %v\n", err)
+		return false
+	}
+
+	// packageName maps each package's path to its name.
+	packageName := make(map[string]string)
+	for _, p := range pkgs {
+		packageName[p.ImportPath] = p.Package.Name
+	}
+
+	// canonical maps each non-canonical package path to
+	// its canonical path and name.
+	// A present nil value indicates that the canonical package
+	// is unknown: hosted on a bad domain with no redirect.
+	canonical := make(map[string]canonicalName)
+	domains := strings.Split(*badDomains, ",")
+
+	type replaceItem struct {
+		old, new    string
+		matchPrefix bool
+	}
+	var replace []replaceItem
+	for _, pair := range strings.Split(*replaceFlag, ",") {
+		if pair == "" {
+			continue
+		}
+		words := strings.Split(pair, "=")
+		if len(words) != 2 {
+			fmt.Fprintf(stderr, "importfix: -replace: %q is not of the form \"canonical=noncanonical\".\n", pair)
+			return false
+		}
+		replace = append(replace, replaceItem{
+			old: strings.TrimSuffix(words[0], "..."),
+			new: strings.TrimSuffix(words[1], "..."),
+			matchPrefix: strings.HasSuffix(words[0], "...") &&
+				strings.HasSuffix(words[1], "..."),
+		})
+	}
+
+	// Find non-canonical packages and populate importedBy graph.
+	for _, p := range pkgs {
+		if p.Error != nil {
+			msg := p.Error.Err
+			if strings.Contains(msg, "code in directory") &&
+				strings.Contains(msg, "expects import") {
+				// don't show the very errors we're trying to fix
+			} else {
+				fmt.Fprintln(stderr, msg)
+			}
+		}
+
+		for _, imp := range p.Imports {
+			addEdge(&p.Package, imp)
+		}
+		for _, imp := range p.TestImports {
+			addEdge(&p.Package, imp)
+		}
+		for _, imp := range p.XTestImports {
+			addEdge(&p.Package, imp)
+		}
+
+		// Does package have an explicit import comment?
+		if p.ImportComment != "" {
+			if p.ImportComment != p.ImportPath {
+				canonical[p.ImportPath] = canonicalName{
+					path: p.Package.ImportComment,
+					name: p.Package.Name,
+				}
+			}
+		} else {
+			// Is package matched by a -replace item?
+			var newPath string
+			for _, item := range replace {
+				if item.matchPrefix {
+					if strings.HasPrefix(p.ImportPath, item.old) {
+						newPath = item.new + p.ImportPath[len(item.old):]
+						break
+					}
+				} else if p.ImportPath == item.old {
+					newPath = item.new
+					break
+				}
+			}
+			if newPath != "" {
+				newName := packageName[newPath]
+				if newName == "" {
+					newName = filepath.Base(newPath) // a guess
+				}
+				canonical[p.ImportPath] = canonicalName{
+					path: newPath,
+					name: newName,
+				}
+				continue
+			}
+
+			// Is package matched by a -baddomains item?
+			for _, domain := range domains {
+				slash := strings.Index(p.ImportPath, "/")
+				if slash < 0 {
+					continue // no slash: standard package
+				}
+				if p.ImportPath[:slash] == domain {
+					// Package comes from bad domain and has no import comment.
+					// Report an error each time this package is imported.
+					canonical[p.ImportPath] = canonicalName{}
+
+					// TODO(adonovan): should we make an HTTP request to
+					// see if there's an HTTP redirect, a "go-import" meta tag,
+					// or an import comment in the the latest revision?
+					// It would duplicate a lot of logic from "go get".
+				}
+				break
+			}
+		}
+	}
+
+	// Find all clients (direct importers) of canonical packages.
+	// These are the packages that need fixing up.
+	clients := make(map[*build.Package]bool)
+	for path := range canonical {
+		for client := range importedBy[path] {
+			clients[client] = true
+		}
+	}
+
+	// Restrict rewrites to the set of packages specified by the user.
+	if len(packages) == 1 && (packages[0] == "all" || packages[0] == "...") {
+		// no restriction
+	} else {
+		pkgs, err := list(packages...)
+		if err != nil {
+			fmt.Fprintf(stderr, "importfix: %v\n", err)
+			return false
+		}
+		seen := make(map[string]bool)
+		for _, p := range pkgs {
+			seen[p.ImportPath] = true
+		}
+		for client := range clients {
+			if !seen[client.ImportPath] {
+				delete(clients, client)
+			}
+		}
+	}
+
+	// Rewrite selected client packages.
+	ok := true
+	for client := range clients {
+		if !rewritePackage(client, canonical) {
+			ok = false
+
+			// There were errors.
+			// Show direct and indirect imports of client.
+			seen := make(map[string]bool)
+			var direct, indirect []string
+			for p := range importedBy[client.ImportPath] {
+				direct = append(direct, p.ImportPath)
+				seen[p.ImportPath] = true
+			}
+
+			var visit func(path string)
+			visit = func(path string) {
+				for q := range importedBy[path] {
+					qpath := q.ImportPath
+					if !seen[qpath] {
+						seen[qpath] = true
+						indirect = append(indirect, qpath)
+						visit(qpath)
+					}
+				}
+			}
+
+			if direct != nil {
+				fmt.Fprintf(stderr, "\timported directly by:\n")
+				sort.Strings(direct)
+				for _, path := range direct {
+					fmt.Fprintf(stderr, "\t\t%s\n", path)
+					visit(path)
+				}
+
+				if indirect != nil {
+					fmt.Fprintf(stderr, "\timported indirectly by:\n")
+					sort.Strings(indirect)
+					for _, path := range indirect {
+						fmt.Fprintf(stderr, "\t\t%s\n", path)
+					}
+				}
+			}
+		}
+	}
+
+	return ok
+}
+
+// Invariant: false result => error already printed.
+func rewritePackage(client *build.Package, canonical map[string]canonicalName) bool {
+	ok := true
+
+	used := make(map[string]bool)
+	var filenames []string
+	filenames = append(filenames, client.GoFiles...)
+	filenames = append(filenames, client.TestGoFiles...)
+	filenames = append(filenames, client.XTestGoFiles...)
+	var first bool
+	for _, filename := range filenames {
+		if !first {
+			first = true
+			fmt.Fprintf(stderr, "%s\n", client.ImportPath)
+		}
+		err := rewriteFile(filepath.Join(client.Dir, filename), canonical, used)
+		if err != nil {
+			fmt.Fprintf(stderr, "\tERROR: %v\n", err)
+			ok = false
+		}
+	}
+
+	// Show which imports were renamed in this package.
+	var keys []string
+	for key := range used {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		if p := canonical[key]; p.path != "" {
+			fmt.Fprintf(stderr, "\tfixed: %s -> %s\n", key, p.path)
+		} else {
+			fmt.Fprintf(stderr, "\tERROR: %s has no import comment\n", key)
+			ok = false
+		}
+	}
+
+	return ok
+}
+
+// rewrite reads, modifies, and writes filename, replacing all imports
+// of packages P in canonical by canonical[P].
+// It records in used which canonical packages were imported.
+// used[P]=="" indicates that P was imported but its canonical path is unknown.
+func rewriteFile(filename string, canonical map[string]canonicalName, used map[string]bool) error {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+	if err != nil {
+		return err
+	}
+	var changed bool
+	for _, imp := range f.Imports {
+		impPath, err := strconv.Unquote(imp.Path.Value)
+		if err != nil {
+			log.Printf("%s: bad import spec %q: %v",
+				fset.Position(imp.Pos()), imp.Path.Value, err)
+			continue
+		}
+		canon, ok := canonical[impPath]
+		if !ok {
+			continue // import path is canonical
+		}
+
+		used[impPath] = true
+
+		if canon.path == "" {
+			// The canonical path is unknown (a -baddomain).
+			// Show the offending import.
+			// TODO(adonovan): should we show the actual source text?
+			fmt.Fprintf(stderr, "\t%s:%d: import %q\n",
+				shortPath(filename),
+				fset.Position(imp.Pos()).Line, impPath)
+			continue
+		}
+
+		changed = true
+
+		imp.Path.Value = strconv.Quote(canon.path)
+
+		// Add a renaming import if necessary.
+		//
+		// This is a guess at best.  We can't see whether a 'go
+		// get' of the canonical import path would have the same
+		// name or not.  Assume it's the last segment.
+		newBase := path.Base(canon.path)
+		if imp.Name == nil && newBase != canon.name {
+			imp.Name = &ast.Ident{Name: canon.name}
+		}
+	}
+
+	if changed && !*dryrun {
+		var buf bytes.Buffer
+		if err := format.Node(&buf, fset, f); err != nil {
+			return fmt.Errorf("%s: couldn't format file: %v", filename, err)
+		}
+		return writeFile(filename, buf.Bytes(), 0644)
+	}
+
+	return nil
+}
+
+// listPackage is a copy of cmd/go/list.Package.
+// It has more fields than build.Package and we need some of them.
+type listPackage struct {
+	build.Package
+	Error *packageError // error loading package
+}
+
+// A packageError describes an error loading information about a package.
+type packageError struct {
+	ImportStack []string // shortest path from package named on command line to this one
+	Pos         string   // position of error
+	Err         string   // the error itself
+}
+
+// list runs 'go list' with the specified arguments and returns the
+// metadata for matching packages.
+func list(args ...string) ([]*listPackage, error) {
+	cmd := exec.Command("go", append([]string{"list", "-e", "-json"}, args...)...)
+	cmd.Stdout = new(bytes.Buffer)
+	cmd.Stderr = stderr
+	if err := cmd.Run(); err != nil {
+		return nil, err
+	}
+
+	dec := json.NewDecoder(cmd.Stdout.(io.Reader))
+	var pkgs []*listPackage
+	for {
+		var p listPackage
+		if err := dec.Decode(&p); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		pkgs = append(pkgs, &p)
+	}
+	return pkgs, nil
+}
+
+var cwd string
+
+func init() {
+	var err error
+	cwd, err = os.Getwd()
+	if err != nil {
+		log.Fatalf("os.Getwd: %v", err)
+	}
+}
+
+// shortPath returns an absolute or relative name for path, whatever is shorter.
+// Plundered from $GOROOT/src/cmd/go/build.go.
+func shortPath(path string) string {
+	if rel, err := filepath.Rel(cwd, path); err == nil && len(rel) < len(path) {
+		return rel
+	}
+	return path
+}
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/main_test.go b/vendor/golang.org/x/tools/cmd/fiximports/main_test.go
new file mode 100644
index 0000000..75319a0
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/main_test.go
@@ -0,0 +1,243 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// TODO(adonovan):
+// - test introduction of renaming imports.
+// - test induced failures of rewriteFile.
+
+// Guide to the test packages:
+//
+// new.com/one		-- canonical name for old.com/one
+// old.com/one		-- non-canonical; has import comment "new.com/one"
+// old.com/bad		-- has a parse error
+// fruit.io/orange	\
+// fruit.io/banana	 } orange -> pear -> banana -> titanic.biz/bar
+// fruit.io/pear	/
+// titanic.biz/bar	-- domain is sinking; package has jumped ship to new.com/bar
+// titanic.biz/foo	-- domain is sinking but package has no import comment yet
+
+func TestFixImports(t *testing.T) {
+	gopath := filepath.Join(cwd, "testdata")
+	if err := os.Setenv("GOPATH", gopath); err != nil {
+		t.Fatalf("os.Setenv: %v", err)
+	}
+	defer func() {
+		stderr = os.Stderr
+		*badDomains = "code.google.com"
+		*replaceFlag = ""
+	}()
+
+	for i, test := range []struct {
+		packages    []string // packages to rewrite, "go list" syntax
+		badDomains  string   // -baddomains flag
+		replaceFlag string   // -replace flag
+		wantOK      bool
+		wantStderr  string
+		wantRewrite map[string]string
+	}{
+		// #0. No errors.
+		{
+			packages:   []string{"all"},
+			badDomains: "code.google.com",
+			wantOK:     true,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+fruit.io/banana
+	fixed: old.com/one -> new.com/one
+	fixed: titanic.biz/bar -> new.com/bar
+`,
+			wantRewrite: map[string]string{
+				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
+
+import (
+	_ "new.com/bar"
+	_ "new.com/one"
+	_ "titanic.biz/foo"
+)`,
+			},
+		},
+		// #1. No packages needed rewriting.
+		{
+			packages:   []string{"titanic.biz/...", "old.com/...", "new.com/..."},
+			badDomains: "code.google.com",
+			wantOK:     true,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+`,
+		},
+		// #2. Some packages without import comments matched bad domains.
+		{
+			packages:   []string{"all"},
+			badDomains: "titanic.biz",
+			wantOK:     false,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+fruit.io/banana
+	testdata/src/fruit.io/banana/banana.go:6: import "titanic.biz/foo"
+	fixed: old.com/one -> new.com/one
+	fixed: titanic.biz/bar -> new.com/bar
+	ERROR: titanic.biz/foo has no import comment
+	imported directly by:
+		fruit.io/pear
+	imported indirectly by:
+		fruit.io/orange
+`,
+			wantRewrite: map[string]string{
+				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
+
+import (
+	_ "new.com/bar"
+	_ "new.com/one"
+	_ "titanic.biz/foo"
+)`,
+			},
+		},
+		// #3. The -replace flag lets user supply missing import comments.
+		{
+			packages:    []string{"all"},
+			replaceFlag: "titanic.biz/foo=new.com/foo",
+			wantOK:      true,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+fruit.io/banana
+	fixed: old.com/one -> new.com/one
+	fixed: titanic.biz/bar -> new.com/bar
+	fixed: titanic.biz/foo -> new.com/foo
+`,
+			wantRewrite: map[string]string{
+				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
+
+import (
+	_ "new.com/bar"
+	_ "new.com/foo"
+	_ "new.com/one"
+)`,
+			},
+		},
+		// #4. The -replace flag supports wildcards.
+		//     An explicit import comment takes precedence.
+		{
+			packages:    []string{"all"},
+			replaceFlag: "titanic.biz/...=new.com/...",
+			wantOK:      true,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+fruit.io/banana
+	fixed: old.com/one -> new.com/one
+	fixed: titanic.biz/bar -> new.com/bar
+	fixed: titanic.biz/foo -> new.com/foo
+`,
+			wantRewrite: map[string]string{
+				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
+
+import (
+	_ "new.com/bar"
+	_ "new.com/foo"
+	_ "new.com/one"
+)`,
+			},
+		},
+		// #5. The -replace flag trumps -baddomains.
+		{
+			packages:    []string{"all"},
+			badDomains:  "titanic.biz",
+			replaceFlag: "titanic.biz/foo=new.com/foo",
+			wantOK:      true,
+			wantStderr: `
+testdata/src/old.com/bad/bad.go:2:43: expected 'package', found 'EOF'
+fruit.io/banana
+	fixed: old.com/one -> new.com/one
+	fixed: titanic.biz/bar -> new.com/bar
+	fixed: titanic.biz/foo -> new.com/foo
+`,
+			wantRewrite: map[string]string{
+				"$GOPATH/src/fruit.io/banana/banana.go": `package banana
+
+import (
+	_ "new.com/bar"
+	_ "new.com/foo"
+	_ "new.com/one"
+)`,
+			},
+		},
+	} {
+		*badDomains = test.badDomains
+		*replaceFlag = test.replaceFlag
+
+		stderr = new(bytes.Buffer)
+		gotRewrite := make(map[string]string)
+		writeFile = func(filename string, content []byte, mode os.FileMode) error {
+			filename = strings.Replace(filename, gopath, "$GOPATH", 1)
+			filename = filepath.ToSlash(filename)
+			gotRewrite[filename] = string(bytes.TrimSpace(content))
+			return nil
+		}
+
+		if runtime.GOOS == "windows" {
+			test.wantStderr = strings.Replace(test.wantStderr, `testdata/src/old.com/bad/bad.go`, `testdata\src\old.com\bad\bad.go`, -1)
+			test.wantStderr = strings.Replace(test.wantStderr, `testdata/src/fruit.io/banana/banana.go`, `testdata\src\fruit.io\banana\banana.go`, -1)
+		}
+
+		// Check status code.
+		if fiximports(test.packages...) != test.wantOK {
+			t.Errorf("#%d. fiximports() = %t", i, !test.wantOK)
+		}
+
+		// Compare stderr output.
+		if got := stderr.(*bytes.Buffer).String(); got != test.wantStderr {
+			if strings.Contains(got, "vendor/golang_org/x/text/unicode/norm") {
+				t.Skip("skipping known-broken test; see golang.org/issue/17417")
+			}
+			t.Errorf("#%d. stderr: got <<%s>>, want <<%s>>",
+				i, stderr, test.wantStderr)
+		}
+
+		// Compare rewrites.
+		for k, v := range gotRewrite {
+			if test.wantRewrite[k] != v {
+				t.Errorf("#%d. rewrite[%s] = <<%s>>, want <<%s>>",
+					i, k, v, test.wantRewrite[k])
+			}
+			delete(test.wantRewrite, k)
+		}
+		for k, v := range test.wantRewrite {
+			t.Errorf("#%d. rewrite[%s] missing, want <<%s>>", i, k, v)
+		}
+	}
+}
+
+// TestDryRun tests that the -n flag suppresses calls to writeFile.
+func TestDryRun(t *testing.T) {
+	gopath := filepath.Join(cwd, "testdata")
+	if err := os.Setenv("GOPATH", gopath); err != nil {
+		t.Fatalf("os.Setenv: %v", err)
+	}
+
+	*dryrun = true
+	defer func() { *dryrun = false }() // restore
+	stderr = new(bytes.Buffer)
+	writeFile = func(filename string, content []byte, mode os.FileMode) error {
+		t.Fatalf("writeFile(%s) called in dryrun mode", filename)
+		return nil
+	}
+
+	if !fiximports("all") {
+		t.Fatalf("fiximports failed: %s", stderr)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/banana/banana.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/banana/banana.go
new file mode 100644
index 0000000..04e0242
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/banana/banana.go
@@ -0,0 +1,7 @@
+package banana
+
+import (
+	_ "old.com/one"
+	_ "titanic.biz/bar"
+	_ "titanic.biz/foo"
+)
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/orange/orange.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/orange/orange.go
new file mode 100644
index 0000000..ae65daa
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/orange/orange.go
@@ -0,0 +1,3 @@
+package orange
+
+import _ "fruit.io/pear"
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/pear/pear.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/pear/pear.go
new file mode 100644
index 0000000..de92df0
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/fruit.io/pear/pear.go
@@ -0,0 +1,3 @@
+package pear
+
+import _ "fruit.io/banana"
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/new.com/one/one.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/new.com/one/one.go
new file mode 100644
index 0000000..a8c5e83
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/new.com/one/one.go
@@ -0,0 +1 @@
+package one // import "new.com/one"
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/bad/bad.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/bad/bad.go
new file mode 100644
index 0000000..a1a3d1a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/bad/bad.go
@@ -0,0 +1,2 @@
+// This ill-formed Go source file is here to ensure the tool is robust
+// against bad packages in the workspace.
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/one/one.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/one/one.go
new file mode 100644
index 0000000..a8c5e83
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/old.com/one/one.go
@@ -0,0 +1 @@
+package one // import "new.com/one"
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/bar/bar.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/bar/bar.go
new file mode 100644
index 0000000..cc720bc
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/bar/bar.go
@@ -0,0 +1,2 @@
+// This package is moving to new.com too.
+package bar // import "new.com/bar"
diff --git a/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/foo/foo.go b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/foo/foo.go
new file mode 100644
index 0000000..145c31b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/fiximports/testdata/src/titanic.biz/foo/foo.go
@@ -0,0 +1,2 @@
+// This package hasn't jumped ship yet.
+package foo
diff --git a/vendor/golang.org/x/tools/cmd/getgo/.dockerignore b/vendor/golang.org/x/tools/cmd/getgo/.dockerignore
new file mode 100644
index 0000000..2b87ad9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/.dockerignore
@@ -0,0 +1,5 @@
+.git
+.dockerignore
+LICENSE
+README.md
+.gitignore
diff --git a/vendor/golang.org/x/tools/cmd/getgo/.gitignore b/vendor/golang.org/x/tools/cmd/getgo/.gitignore
new file mode 100644
index 0000000..d4984ab
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/.gitignore
@@ -0,0 +1,3 @@
+build
+testgetgo
+getgo
diff --git a/vendor/golang.org/x/tools/cmd/getgo/Dockerfile b/vendor/golang.org/x/tools/cmd/getgo/Dockerfile
new file mode 100644
index 0000000..78fd956
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/Dockerfile
@@ -0,0 +1,20 @@
+FROM golang:latest
+
+ENV SHELL /bin/bash
+ENV HOME /root
+WORKDIR $HOME
+
+COPY . /go/src/golang.org/x/tools/cmd/getgo
+
+RUN ( \
+		cd /go/src/golang.org/x/tools/cmd/getgo \
+		&& go build \
+		&& mv getgo /usr/local/bin/getgo \
+	)
+
+# undo the adding of GOPATH to env for testing
+ENV PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+ENV GOPATH ""
+
+# delete /go and /usr/local/go for testing
+RUN rm -rf /go /usr/local/go
diff --git a/vendor/golang.org/x/tools/cmd/getgo/LICENSE b/vendor/golang.org/x/tools/cmd/getgo/LICENSE
new file mode 100644
index 0000000..32017f8
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/cmd/getgo/README.md b/vendor/golang.org/x/tools/cmd/getgo/README.md
new file mode 100644
index 0000000..e62a6c2
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/README.md
@@ -0,0 +1,71 @@
+# getgo
+
+A proof-of-concept command-line installer for Go.
+
+This installer is designed to both install Go as well as do the initial configuration
+of setting up the right environment variables and paths.
+
+It will install the Go distribution (tools & stdlib) to "/.go" inside your home directory by default.
+
+It will setup "$HOME/go" as your GOPATH.
+This is where third party libraries and apps will be installed as well as where you will write your Go code.
+
+If Go is already installed via this installer it will upgrade it to the latest version of Go.
+
+Currently the installer supports Windows, \*nix and macOS on x86 & x64.
+It supports Bash and Zsh on all of these platforms as well as powershell & cmd.exe on Windows.
+
+## Usage
+
+Windows Powershell/cmd.exe:
+
+`(New-Object System.Net.WebClient).DownloadFile('https://get.golang.org/installer.exe', 'installer.exe'); Start-Process -Wait -NonewWindow installer.exe; Remove-Item installer.exe`
+
+Shell (Linux/macOS/Windows):
+
+`curl -LO https://get.golang.org/$(uname)/go_installer && chmod +x go_installer && ./go_installer && rm go_installer`
+
+## To Do
+
+* Check if Go is already installed (via a different method) and update it in place or at least notify the user
+* Lots of testing. It's only had limited testing so far.
+* Add support for additional shells.
+
+## Development instructions
+
+### Testing
+
+There are integration tests in [`main_test.go`](main_test.go). Please add more
+tests there.
+
+#### On unix/linux with the Dockerfile
+
+The Dockerfile automatically builds the binary, moves it to
+`/usr/local/bin/getgo` and then unsets `$GOPATH` and removes all `$GOPATH` from
+`$PATH`.
+
+```bash
+$ docker build --rm --force-rm -t getgo .
+...
+$ docker run --rm -it getgo bash
+root@78425260fad0:~# getgo -v
+Welcome to the Go installer!
+Downloading Go version go1.8.3 to /usr/local/go
+This may take a bit of time...
+Adding "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin" to /root/.bashrc
+Downloaded!
+Setting up GOPATH
+Adding "export GOPATH=/root/go" to /root/.bashrc
+Adding "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/root/go/bin" to /root/.bashrc
+GOPATH has been setup!
+root@78425260fad0:~# which go
+/usr/local/go/bin/go
+root@78425260fad0:~# echo $GOPATH
+/root/go
+root@78425260fad0:~# echo $PATH
+/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin:/root/go/bin
+```
+
+## Release instructions
+
+To upload a new release of getgo, run `./make.bash && ./upload.bash`.
diff --git a/vendor/golang.org/x/tools/cmd/getgo/download.go b/vendor/golang.org/x/tools/cmd/getgo/download.go
new file mode 100644
index 0000000..383cb3d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/download.go
@@ -0,0 +1,184 @@
+// 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 !plan9
+
+package main
+
+import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	currentVersionURL = "https://golang.org/VERSION?m=text"
+	downloadURLPrefix = "https://dl.google.com/go"
+)
+
+// downloadGoVersion downloads and upacks the specific go version to dest/go.
+func downloadGoVersion(version, ops, arch, dest string) error {
+	suffix := "tar.gz"
+	if ops == "windows" {
+		suffix = "zip"
+	}
+	uri := fmt.Sprintf("%s/%s.%s-%s.%s", downloadURLPrefix, version, ops, arch, suffix)
+
+	verbosef("Downloading %s", uri)
+
+	req, err := http.NewRequest("GET", uri, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Add("User-Agent", fmt.Sprintf("golang.org-getgo/%s", version))
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("Downloading Go from %s failed: %v", uri, err)
+	}
+	if resp.StatusCode > 299 {
+		return fmt.Errorf("Downloading Go from %s failed with HTTP status %s", uri, resp.Status)
+	}
+	defer resp.Body.Close()
+
+	tmpf, err := ioutil.TempFile("", "go")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(tmpf.Name())
+
+	h := sha256.New()
+
+	w := io.MultiWriter(tmpf, h)
+	if _, err := io.Copy(w, resp.Body); err != nil {
+		return err
+	}
+
+	verbosef("Downloading SHA %s.sha256", uri)
+
+	sresp, err := http.Get(uri + ".sha256")
+	if err != nil {
+		return fmt.Errorf("Downloading Go sha256 from %s.sha256 failed: %v", uri, err)
+	}
+	defer sresp.Body.Close()
+	if sresp.StatusCode > 299 {
+		return fmt.Errorf("Downloading Go sha256 from %s.sha256 failed with HTTP status %s", uri, sresp.Status)
+	}
+
+	shasum, err := ioutil.ReadAll(sresp.Body)
+	if err != nil {
+		return err
+	}
+
+	// Check the shasum.
+	sum := fmt.Sprintf("%x", h.Sum(nil))
+	if sum != string(shasum) {
+		return fmt.Errorf("Shasum mismatch %s vs. %s", sum, string(shasum))
+	}
+
+	unpackFunc := unpackTar
+	if ops == "windows" {
+		unpackFunc = unpackZip
+	}
+	if err := unpackFunc(tmpf.Name(), dest); err != nil {
+		return fmt.Errorf("Unpacking Go to %s failed: %v", dest, err)
+	}
+	return nil
+}
+
+func unpack(dest, name string, fi os.FileInfo, r io.Reader) error {
+	if strings.HasPrefix(name, "go/") {
+		name = name[len("go/"):]
+	}
+
+	path := filepath.Join(dest, name)
+	if fi.IsDir() {
+		return os.MkdirAll(path, fi.Mode())
+	}
+
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fi.Mode())
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	_, err = io.Copy(f, r)
+	return err
+}
+
+func unpackTar(src, dest string) error {
+	r, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	archive, err := gzip.NewReader(r)
+	if err != nil {
+		return err
+	}
+	defer archive.Close()
+
+	tarReader := tar.NewReader(archive)
+
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+
+		if err := unpack(dest, header.Name, header.FileInfo(), tarReader); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func unpackZip(src, dest string) error {
+	zr, err := zip.OpenReader(src)
+	if err != nil {
+		return err
+	}
+
+	for _, f := range zr.File {
+		fr, err := f.Open()
+		if err != nil {
+			return err
+		}
+		if err := unpack(dest, f.Name, f.FileInfo(), fr); err != nil {
+			return err
+		}
+		fr.Close()
+	}
+
+	return nil
+}
+
+func getLatestGoVersion() (string, error) {
+	resp, err := http.Get(currentVersionURL)
+	if err != nil {
+		return "", fmt.Errorf("Getting current Go version failed: %v", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode > 299 {
+		b, _ := ioutil.ReadAll(io.LimitReader(resp.Body, 1024))
+		return "", fmt.Errorf("Could not get current Go version: HTTP %d: %q", resp.StatusCode, b)
+	}
+	version, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(version)), nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/download_test.go b/vendor/golang.org/x/tools/cmd/getgo/download_test.go
new file mode 100644
index 0000000..5a5cc29
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/download_test.go
@@ -0,0 +1,36 @@
+// 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 !plan9
+
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestDownloadGoVersion(t *testing.T) {
+	if testing.Short() {
+		t.Skipf("Skipping download in short mode")
+	}
+
+	tmpd, err := ioutil.TempDir("", "go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpd)
+
+	if err := downloadGoVersion("go1.8.1", "linux", "amd64", filepath.Join(tmpd, "go")); err != nil {
+		t.Fatal(err)
+	}
+
+	// Ensure the VERSION file exists.
+	vf := filepath.Join(tmpd, "go", "VERSION")
+	if _, err := os.Stat(vf); os.IsNotExist(err) {
+		t.Fatalf("file %s does not exist and should", vf)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/main.go b/vendor/golang.org/x/tools/cmd/getgo/main.go
new file mode 100644
index 0000000..a92ae48
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/main.go
@@ -0,0 +1,117 @@
+// 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 !plan9
+
+// The getgo command installs Go to the user's system.
+package main
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+var (
+	interactive = flag.Bool("i", false, "Interactive mode, prompt for inputs.")
+	verbose     = flag.Bool("v", false, "Verbose.")
+	setupOnly   = flag.Bool("skip-dl", false, "Don't download - only set up environment variables")
+	goVersion   = flag.String("version", "", `Version of Go to install (e.g. "1.8.3"). If empty, uses the latest version.`)
+
+	version = "devel"
+)
+
+var exitCleanly error = errors.New("exit cleanly sentinel value")
+
+func main() {
+	flag.Parse()
+	if *goVersion != "" && !strings.HasPrefix(*goVersion, "go") {
+		*goVersion = "go" + *goVersion
+	}
+
+	ctx := context.Background()
+
+	verbosef("version " + version)
+
+	runStep := func(s step) {
+		err := s(ctx)
+		if err == exitCleanly {
+			os.Exit(0)
+		}
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(2)
+		}
+	}
+
+	if !*setupOnly {
+		runStep(welcome)
+		runStep(checkOthers)
+		runStep(chooseVersion)
+		runStep(downloadGo)
+	}
+
+	runStep(setupGOPATH)
+}
+
+func verbosef(format string, v ...interface{}) {
+	if !*verbose {
+		return
+	}
+
+	fmt.Printf(format+"\n", v...)
+}
+
+func prompt(ctx context.Context, query, defaultAnswer string) (string, error) {
+	if !*interactive {
+		return defaultAnswer, nil
+	}
+
+	fmt.Printf("%s [%s]: ", query, defaultAnswer)
+
+	type result struct {
+		answer string
+		err    error
+	}
+	ch := make(chan result, 1)
+	go func() {
+		s := bufio.NewScanner(os.Stdin)
+		if !s.Scan() {
+			ch <- result{"", s.Err()}
+			return
+		}
+		answer := s.Text()
+		if answer == "" {
+			answer = defaultAnswer
+		}
+		ch <- result{answer, nil}
+	}()
+
+	select {
+	case r := <-ch:
+		return r.answer, r.err
+	case <-ctx.Done():
+		return "", ctx.Err()
+	}
+}
+
+func runCommand(ctx context.Context, prog string, args ...string) ([]byte, error) {
+	verbosef("Running command: %s %v", prog, args)
+
+	cmd := exec.CommandContext(ctx, prog, args...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("running cmd '%s %s' failed: %s err: %v", prog, strings.Join(args, " "), string(out), err)
+	}
+	if out != nil && err == nil && len(out) != 0 {
+		verbosef("%s", out)
+	}
+
+	return out, nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/main_test.go b/vendor/golang.org/x/tools/cmd/getgo/main_test.go
new file mode 100644
index 0000000..e430895
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/main_test.go
@@ -0,0 +1,173 @@
+// 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 !plan9
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"runtime"
+	"testing"
+)
+
+const (
+	testbin = "testgetgo"
+)
+
+var (
+	exeSuffix string // ".exe" on Windows
+)
+
+func init() {
+	if runtime.GOOS == "windows" {
+		exeSuffix = ".exe"
+	}
+}
+
+// TestMain creates a getgo command for testing purposes and
+// deletes it after the tests have been run.
+func TestMain(m *testing.M) {
+	if os.Getenv("GOGET_INTEGRATION") == "" {
+		fmt.Fprintln(os.Stderr, "main_test: Skipping integration tests with GOGET_INTEGRATION unset")
+		return
+	}
+
+	args := []string{"build", "-tags", testbin, "-o", testbin + exeSuffix}
+	out, err := exec.Command("go", args...).CombinedOutput()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "building %s failed: %v\n%s", testbin, err, out)
+		os.Exit(2)
+	}
+
+	// Don't let these environment variables confuse the test.
+	os.Unsetenv("GOBIN")
+	os.Unsetenv("GOPATH")
+	os.Unsetenv("GIT_ALLOW_PROTOCOL")
+	os.Unsetenv("PATH")
+
+	r := m.Run()
+
+	os.Remove(testbin + exeSuffix)
+
+	os.Exit(r)
+}
+
+func createTmpHome(t *testing.T) string {
+	tmpd, err := ioutil.TempDir("", "testgetgo")
+	if err != nil {
+		t.Fatalf("creating test tempdir failed: %v", err)
+	}
+
+	os.Setenv("HOME", tmpd)
+	return tmpd
+}
+
+// doRun runs the test getgo command, recording stdout and stderr and
+// returning exit status.
+func doRun(t *testing.T, args ...string) error {
+	var stdout, stderr bytes.Buffer
+	t.Logf("running %s %v", testbin, args)
+	cmd := exec.Command("./"+testbin+exeSuffix, args...)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	cmd.Env = os.Environ()
+	status := cmd.Run()
+	if stdout.Len() > 0 {
+		t.Log("standard output:")
+		t.Log(stdout.String())
+	}
+	if stderr.Len() > 0 {
+		t.Log("standard error:")
+		t.Log(stderr.String())
+	}
+	return status
+}
+
+func TestCommandVerbose(t *testing.T) {
+	tmpd := createTmpHome(t)
+	defer os.RemoveAll(tmpd)
+
+	err := doRun(t, "-v")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// make sure things are in path
+	shellConfig, err := shellConfigFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := ioutil.ReadFile(shellConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	home, err := getHomeDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := fmt.Sprintf(`
+export PATH=$PATH:%s/.go/bin
+
+export GOPATH=%s/go
+
+export PATH=$PATH:%s/go/bin
+`, home, home, home)
+
+	if string(b) != expected {
+		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
+	}
+}
+
+func TestCommandPathExists(t *testing.T) {
+	tmpd := createTmpHome(t)
+	defer os.RemoveAll(tmpd)
+
+	// run once
+	err := doRun(t, "-skip-dl")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// make sure things are in path
+	shellConfig, err := shellConfigFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := ioutil.ReadFile(shellConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	home, err := getHomeDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := fmt.Sprintf(`
+export GOPATH=%s/go
+
+export PATH=$PATH:%s/go/bin
+`, home, home)
+
+	if string(b) != expected {
+		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
+	}
+
+	// run twice
+	if err := doRun(t, "-skip-dl"); err != nil {
+		t.Fatal(err)
+	}
+
+	b, err = ioutil.ReadFile(shellConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(b) != expected {
+		t.Fatalf("%s expected %q, got %q", shellConfig, expected, string(b))
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/make.bash b/vendor/golang.org/x/tools/cmd/getgo/make.bash
new file mode 100644
index 0000000..cbc3685
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/make.bash
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# 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.
+
+set -e -o -x
+
+LDFLAGS="-X main.version=$(git describe --always --dirty='*')"
+
+GOOS=windows GOARCH=386 go build -o build/installer.exe    -ldflags="$LDFLAGS"
+GOOS=linux GOARCH=386   go build -o build/installer_linux  -ldflags="$LDFLAGS"
+GOOS=darwin GOARCH=386  go build -o build/installer_darwin -ldflags="$LDFLAGS"
diff --git a/vendor/golang.org/x/tools/cmd/getgo/path.go b/vendor/golang.org/x/tools/cmd/getgo/path.go
new file mode 100644
index 0000000..52e0462
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/path.go
@@ -0,0 +1,155 @@
+// 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 !plan9
+
+package main
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+const (
+	bashConfig = ".bash_profile"
+	zshConfig  = ".zshrc"
+)
+
+// appendToPATH adds the given path to the PATH environment variable and
+// persists it for future sessions.
+func appendToPATH(value string) error {
+	if isInPATH(value) {
+		return nil
+	}
+	return persistEnvVar("PATH", pathVar+envSeparator+value)
+}
+
+func isInPATH(dir string) bool {
+	p := os.Getenv("PATH")
+
+	paths := strings.Split(p, envSeparator)
+	for _, d := range paths {
+		if d == dir {
+			return true
+		}
+	}
+
+	return false
+}
+
+func getHomeDir() (string, error) {
+	home := os.Getenv(homeKey)
+	if home != "" {
+		return home, nil
+	}
+
+	u, err := user.Current()
+	if err != nil {
+		return "", err
+	}
+	return u.HomeDir, nil
+}
+
+func checkStringExistsFile(filename, value string) (bool, error) {
+	file, err := os.OpenFile(filename, os.O_RDONLY, 0600)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line == value {
+			return true, nil
+		}
+	}
+
+	return false, scanner.Err()
+}
+
+func appendToFile(filename, value string) error {
+	verbosef("Adding %q to %s", value, filename)
+
+	ok, err := checkStringExistsFile(filename, value)
+	if err != nil {
+		return err
+	}
+	if ok {
+		// Nothing to do.
+		return nil
+	}
+
+	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	_, err = f.WriteString(lineEnding + value + lineEnding)
+	return err
+}
+
+func isShell(name string) bool {
+	return strings.Contains(currentShell(), name)
+}
+
+// persistEnvVarWindows sets an environment variable in the Windows
+// registry.
+func persistEnvVarWindows(name, value string) error {
+	_, err := runCommand(context.Background(), "powershell", "-command",
+		fmt.Sprintf(`[Environment]::SetEnvironmentVariable("%s", "%s", "User")`, name, value))
+	return err
+}
+
+func persistEnvVar(name, value string) error {
+	if runtime.GOOS == "windows" {
+		if err := persistEnvVarWindows(name, value); err != nil {
+			return err
+		}
+
+		if isShell("cmd.exe") || isShell("powershell.exe") {
+			return os.Setenv(strings.ToUpper(name), value)
+		}
+		// User is in bash, zsh, etc.
+		// Also set the environment variable in their shell config.
+	}
+
+	rc, err := shellConfigFile()
+	if err != nil {
+		return err
+	}
+
+	line := fmt.Sprintf("export %s=%s", strings.ToUpper(name), value)
+	if err := appendToFile(rc, line); err != nil {
+		return err
+	}
+
+	return os.Setenv(strings.ToUpper(name), value)
+}
+
+func shellConfigFile() (string, error) {
+	home, err := getHomeDir()
+	if err != nil {
+		return "", err
+	}
+
+	switch {
+	case isShell("bash"):
+		return filepath.Join(home, bashConfig), nil
+	case isShell("zsh"):
+		return filepath.Join(home, zshConfig), nil
+	default:
+		return "", fmt.Errorf("%q is not a supported shell", currentShell())
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/path_test.go b/vendor/golang.org/x/tools/cmd/getgo/path_test.go
new file mode 100644
index 0000000..5355c6e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/path_test.go
@@ -0,0 +1,58 @@
+// 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 !plan9
+
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAppendPath(t *testing.T) {
+	tmpd, err := ioutil.TempDir("", "go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpd)
+
+	if err := os.Setenv("HOME", tmpd); err != nil {
+		t.Fatal(err)
+	}
+
+	GOPATH := os.Getenv("GOPATH")
+	if err := appendToPATH(filepath.Join(GOPATH, "bin")); err != nil {
+		t.Fatal(err)
+	}
+
+	shellConfig, err := shellConfigFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := ioutil.ReadFile(shellConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := "export PATH=" + pathVar + envSeparator + filepath.Join(GOPATH, "bin")
+	if strings.TrimSpace(string(b)) != expected {
+		t.Fatalf("expected: %q, got %q", expected, strings.TrimSpace(string(b)))
+	}
+
+	// Check that appendToPATH is idempotent.
+	if err := appendToPATH(filepath.Join(GOPATH, "bin")); err != nil {
+		t.Fatal(err)
+	}
+	b, err = ioutil.ReadFile(shellConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.TrimSpace(string(b)) != expected {
+		t.Fatalf("expected: %q, got %q", expected, strings.TrimSpace(string(b)))
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/server/README.md b/vendor/golang.org/x/tools/cmd/getgo/server/README.md
new file mode 100644
index 0000000..0cf629d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/server/README.md
@@ -0,0 +1,7 @@
+# getgo server
+
+## Deployment
+
+```
+gcloud app deploy --promote --project golang-org
+```
diff --git a/vendor/golang.org/x/tools/cmd/getgo/server/app.yaml b/vendor/golang.org/x/tools/cmd/getgo/server/app.yaml
new file mode 100644
index 0000000..0502c4e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/server/app.yaml
@@ -0,0 +1,7 @@
+runtime: go
+service: get
+api_version: go1
+
+handlers:
+- url: /.*
+  script: _go_app
diff --git a/vendor/golang.org/x/tools/cmd/getgo/server/main.go b/vendor/golang.org/x/tools/cmd/getgo/server/main.go
new file mode 100644
index 0000000..9679b3b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/server/main.go
@@ -0,0 +1,61 @@
+// 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.
+
+// Command server serves get.golang.org, redirecting users to the appropriate
+// getgo installer based on the request path.
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+const (
+	base             = "https://dl.google.com/go/getgo/"
+	windowsInstaller = base + "installer.exe"
+	linuxInstaller   = base + "installer_linux"
+	macInstaller     = base + "installer_darwin"
+)
+
+// substring-based redirects.
+var stringMatch = map[string]string{
+	// via uname, from bash
+	"MINGW":  windowsInstaller, // Reported as MINGW64_NT-10.0 in git bash
+	"Linux":  linuxInstaller,
+	"Darwin": macInstaller,
+}
+
+func init() {
+	http.HandleFunc("/", handler)
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	if containsIgnoreCase(r.URL.Path, "installer.exe") {
+		// cache bust
+		http.Redirect(w, r, windowsInstaller+cacheBust(), http.StatusFound)
+		return
+	}
+
+	for match, redirect := range stringMatch {
+		if containsIgnoreCase(r.URL.Path, match) {
+			http.Redirect(w, r, redirect, http.StatusFound)
+			return
+		}
+	}
+
+	http.NotFound(w, r)
+}
+
+func containsIgnoreCase(s, substr string) bool {
+	return strings.Contains(
+		strings.ToLower(s),
+		strings.ToLower(substr),
+	)
+}
+
+func cacheBust() string {
+	return fmt.Sprintf("?%d", time.Now().Nanosecond())
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/steps.go b/vendor/golang.org/x/tools/cmd/getgo/steps.go
new file mode 100644
index 0000000..41c57d2
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/steps.go
@@ -0,0 +1,133 @@
+// 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 !plan9
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+type step func(context.Context) error
+
+func welcome(ctx context.Context) error {
+	fmt.Println("Welcome to the Go installer!")
+	answer, err := prompt(ctx, "Would you like to install Go? Y/n", "Y")
+	if err != nil {
+		return err
+	}
+	if strings.ToLower(answer) != "y" {
+		fmt.Println("Exiting install.")
+		return exitCleanly
+	}
+
+	return nil
+}
+
+func checkOthers(ctx context.Context) error {
+	// TODO: if go is currently installed install new version over that
+	path, err := whichGo(ctx)
+	if err != nil {
+		fmt.Printf("Cannot check if Go is already installed:\n%v\n", err)
+	}
+	if path == "" {
+		return nil
+	}
+	if path != installPath {
+		fmt.Printf("Go is already installed at %v; remove it from your PATH.\n", path)
+	}
+	return nil
+}
+
+func chooseVersion(ctx context.Context) error {
+	if *goVersion != "" {
+		return nil
+	}
+
+	var err error
+	*goVersion, err = getLatestGoVersion()
+	if err != nil {
+		return err
+	}
+
+	answer, err := prompt(ctx, fmt.Sprintf("The latest Go version is %s, install that? Y/n", *goVersion), "Y")
+	if err != nil {
+		return err
+	}
+
+	if strings.ToLower(answer) != "y" {
+		// TODO: handle passing a version
+		fmt.Println("Aborting install.")
+		return exitCleanly
+	}
+
+	return nil
+}
+
+func downloadGo(ctx context.Context) error {
+	answer, err := prompt(ctx, fmt.Sprintf("Download Go version %s to %s? Y/n", *goVersion, installPath), "Y")
+	if err != nil {
+		return err
+	}
+
+	if strings.ToLower(answer) != "y" {
+		fmt.Println("Aborting install.")
+		return exitCleanly
+	}
+
+	fmt.Printf("Downloading Go version %s to %s\n", *goVersion, installPath)
+	fmt.Println("This may take a bit of time...")
+
+	if err := downloadGoVersion(*goVersion, runtime.GOOS, arch, installPath); err != nil {
+		return err
+	}
+
+	if err := appendToPATH(filepath.Join(installPath, "bin")); err != nil {
+		return err
+	}
+
+	fmt.Println("Downloaded!")
+	return nil
+}
+
+func setupGOPATH(ctx context.Context) error {
+	answer, err := prompt(ctx, "Would you like us to setup your GOPATH? Y/n", "Y")
+	if err != nil {
+		return err
+	}
+
+	if strings.ToLower(answer) != "y" {
+		fmt.Println("Exiting and not setting up GOPATH.")
+		return exitCleanly
+	}
+
+	fmt.Println("Setting up GOPATH")
+	home, err := getHomeDir()
+	if err != nil {
+		return err
+	}
+
+	gopath := os.Getenv("GOPATH")
+	if gopath == "" {
+		// set $GOPATH
+		gopath = filepath.Join(home, "go")
+		if err := persistEnvVar("GOPATH", gopath); err != nil {
+			return err
+		}
+		fmt.Println("GOPATH has been set up!")
+	} else {
+		verbosef("GOPATH is already set to %s", gopath)
+	}
+
+	if err := appendToPATH(filepath.Join(gopath, "bin")); err != nil {
+		return err
+	}
+	return persistEnvChangesForSession()
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/system.go b/vendor/golang.org/x/tools/cmd/getgo/system.go
new file mode 100644
index 0000000..07d6f85
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/system.go
@@ -0,0 +1,38 @@
+// 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 !plan9
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"os/exec"
+	"runtime"
+	"strings"
+)
+
+// arch contains either amd64 or 386.
+var arch = func() string {
+	cmd := exec.Command("uname", "-m") // "x86_64"
+	if runtime.GOOS == "windows" {
+		cmd = exec.Command("powershell", "-command", "(Get-WmiObject -Class Win32_ComputerSystem).SystemType") // "x64-based PC"
+	}
+
+	out, err := cmd.Output()
+	if err != nil {
+		// a sensible default?
+		return "amd64"
+	}
+	if bytes.Contains(out, []byte("64")) {
+		return "amd64"
+	}
+	return "386"
+}()
+
+func findGo(ctx context.Context, cmd string) (string, error) {
+	out, err := exec.CommandContext(ctx, cmd, "go").CombinedOutput()
+	return strings.TrimSpace(string(out)), err
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/system_unix.go b/vendor/golang.org/x/tools/cmd/getgo/system_unix.go
new file mode 100644
index 0000000..d2405c5
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/system_unix.go
@@ -0,0 +1,55 @@
+// 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 darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+const (
+	envSeparator = ":"
+	homeKey      = "HOME"
+	lineEnding   = "\n"
+	pathVar      = "$PATH"
+)
+
+var installPath = func() string {
+	home, err := getHomeDir()
+	if err != nil {
+		return "/usr/local/go"
+	}
+
+	return filepath.Join(home, ".go")
+}()
+
+func whichGo(ctx context.Context) (string, error) {
+	return findGo(ctx, "which")
+}
+
+func isWindowsXP() bool {
+	return false
+}
+
+func currentShell() string {
+	return os.Getenv("SHELL")
+}
+
+func persistEnvChangesForSession() error {
+	shellConfig, err := shellConfigFile()
+	if err != nil {
+		return err
+	}
+	fmt.Println()
+	fmt.Printf("One more thing! Run `source %s` to persist the\n", shellConfig)
+	fmt.Println("new environment variables to your current session, or open a")
+	fmt.Println("new shell prompt.")
+
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/system_windows.go b/vendor/golang.org/x/tools/cmd/getgo/system_windows.go
new file mode 100644
index 0000000..d8a6191
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/system_windows.go
@@ -0,0 +1,86 @@
+// 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 windows
+
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	envSeparator = ";"
+	homeKey      = "USERPROFILE"
+	lineEnding   = "/r/n"
+	pathVar      = "$env:Path"
+)
+
+var installPath = `c:\go`
+
+func isWindowsXP() bool {
+	v, err := syscall.GetVersion()
+	if err != nil {
+		log.Fatalf("GetVersion failed: %v", err)
+	}
+	major := byte(v)
+	return major < 6
+}
+
+func whichGo(ctx context.Context) (string, error) {
+	return findGo(ctx, "where")
+}
+
+// currentShell reports the current shell.
+// It might be "powershell.exe", "cmd.exe" or any of the *nix shells.
+//
+// Returns empty string if the shell is unknown.
+func currentShell() string {
+	shell := os.Getenv("SHELL")
+	if shell != "" {
+		return shell
+	}
+
+	pid := os.Getppid()
+	pe, err := getProcessEntry(pid)
+	if err != nil {
+		verbosef("getting shell from process entry failed: %v", err)
+		return ""
+	}
+
+	return syscall.UTF16ToString(pe.ExeFile[:])
+}
+
+func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) {
+	// From https://go.googlesource.com/go/+/go1.8.3/src/syscall/syscall_windows.go#941
+	snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0)
+	if err != nil {
+		return nil, err
+	}
+	defer syscall.CloseHandle(snapshot)
+
+	var procEntry syscall.ProcessEntry32
+	procEntry.Size = uint32(unsafe.Sizeof(procEntry))
+	if err = syscall.Process32First(snapshot, &procEntry); err != nil {
+		return nil, err
+	}
+
+	for {
+		if procEntry.ProcessID == uint32(pid) {
+			return &procEntry, nil
+		}
+
+		if err := syscall.Process32Next(snapshot, &procEntry); err != nil {
+			return nil, err
+		}
+	}
+}
+
+func persistEnvChangesForSession() error {
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/getgo/upload.bash b/vendor/golang.org/x/tools/cmd/getgo/upload.bash
new file mode 100644
index 0000000..f52bb23
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/getgo/upload.bash
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# 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.
+
+if ! command -v gsutil 2>&1 > /dev/null; then
+  echo "Install gsutil:"
+  echo
+  echo "   https://cloud.google.com/storage/docs/gsutil_install#sdk-install"
+fi
+
+if [ ! -d build ]; then
+  echo "Run make.bash first"
+fi
+
+set -e -o -x
+
+gsutil -m cp -a public-read build/* gs://golang/getgo
diff --git a/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib.go b/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib.go
new file mode 100644
index 0000000..7c65746
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib.go
@@ -0,0 +1,289 @@
+// 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.
+
+// The go-contrib-init command helps new Go contributors get their development
+// environment set up for the Go contribution process.
+//
+// It aims to be a complement or alternative to https://golang.org/doc/contribute.html.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+)
+
+var (
+	repo = flag.String("repo", detectrepo(), "Which go repo you want to contribute to. Use \"go\" for the core, or e.g. \"net\" for golang.org/x/net/*")
+	dry  = flag.Bool("dry-run", false, "Fail with problems instead of trying to fix things.")
+)
+
+func main() {
+	log.SetFlags(0)
+	flag.Parse()
+
+	checkCLA()
+	checkGoroot()
+	checkWorkingDir()
+	checkGitOrigin()
+	checkGitCodeReview()
+	fmt.Print("All good. Happy hacking!\n" +
+		"Remember to squash your revised commits and preserve the magic Change-Id lines.\n" +
+		"Next steps: https://golang.org/doc/contribute.html#commit_changes\n")
+}
+
+func detectrepo() string {
+	wd, err := os.Getwd()
+	if err != nil {
+		return "go"
+	}
+
+	for _, path := range filepath.SplitList(build.Default.GOPATH) {
+		rightdir := filepath.Join(path, "src", "golang.org", "x") + string(os.PathSeparator)
+		if strings.HasPrefix(wd, rightdir) {
+			tail := wd[len(rightdir):]
+			end := strings.Index(tail, string(os.PathSeparator))
+			if end > 0 {
+				repo := tail[:end]
+				return repo
+			}
+		}
+	}
+
+	return "go"
+}
+
+var googleSourceRx = regexp.MustCompile(`(?m)^(go|go-review)?\.googlesource.com\b`)
+
+func checkCLA() {
+	slurp, err := ioutil.ReadFile(cookiesFile())
+	if err != nil && !os.IsNotExist(err) {
+		log.Fatal(err)
+	}
+	if googleSourceRx.Match(slurp) {
+		// Probably good.
+		return
+	}
+	log.Fatal("Your .gitcookies file isn't configured.\n" +
+		"Next steps:\n" +
+		"  * Submit a CLA (https://golang.org/doc/contribute.html#cla) if not done\n" +
+		"  * Go to https://go.googlesource.com/ and click \"Generate Password\" at the top,\n" +
+		"    then follow instructions.\n" +
+		"  * Run go-contrib-init again.\n")
+}
+
+func expandUser(s string) string {
+	env := "HOME"
+	if runtime.GOOS == "windows" {
+		env = "USERPROFILE"
+	} else if runtime.GOOS == "plan9" {
+		env = "home"
+	}
+	home := os.Getenv(env)
+	if home == "" {
+		return s
+	}
+
+	if len(s) >= 2 && s[0] == '~' && os.IsPathSeparator(s[1]) {
+		if runtime.GOOS == "windows" {
+			s = filepath.ToSlash(filepath.Join(home, s[2:]))
+		} else {
+			s = filepath.Join(home, s[2:])
+		}
+	}
+	return os.Expand(s, func(env string) string {
+		if env == "HOME" {
+			return home
+		}
+		return os.Getenv(env)
+	})
+}
+
+func cookiesFile() string {
+	out, _ := exec.Command("git", "config", "http.cookiefile").Output()
+	if s := strings.TrimSpace(string(out)); s != "" {
+		if strings.HasPrefix(s, "~") {
+			s = expandUser(s)
+		}
+		return s
+	}
+	if runtime.GOOS == "windows" {
+		return filepath.Join(os.Getenv("USERPROFILE"), ".gitcookies")
+	}
+	return filepath.Join(os.Getenv("HOME"), ".gitcookies")
+}
+
+func checkGoroot() {
+	v := os.Getenv("GOROOT")
+	if v == "" {
+		return
+	}
+	if *repo == "go" {
+		if strings.HasPrefix(v, "/usr/") {
+			log.Fatalf("Your GOROOT environment variable is set to %q\n"+
+				"This is almost certainly not what you want. Either unset\n"+
+				"your GOROOT or set it to the path of your development version\n"+
+				"of Go.", v)
+		}
+		slurp, err := ioutil.ReadFile(filepath.Join(v, "VERSION"))
+		if err == nil {
+			slurp = bytes.TrimSpace(slurp)
+			log.Fatalf("Your GOROOT environment variable is set to %q\n"+
+				"But that path is to a binary release of Go, with VERSION file %q.\n"+
+				"You should hack on Go in a fresh checkout of Go. Fix or unset your GOROOT.\n",
+				v, slurp)
+		}
+	}
+}
+
+func checkWorkingDir() {
+	wd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if *repo == "go" {
+		if inGoPath(wd) {
+			log.Fatalf(`You can't work on Go from within your GOPATH. Please checkout Go outside of your GOPATH
+
+Current directory: %s
+GOPATH: %s
+`, wd, os.Getenv("GOPATH"))
+		}
+		return
+	}
+
+	gopath := firstGoPath()
+	if gopath == "" {
+		log.Fatal("Your GOPATH is not set, please set it")
+	}
+
+	rightdir := filepath.Join(gopath, "src", "golang.org", "x", *repo)
+	if !strings.HasPrefix(wd, rightdir) {
+		dirExists, err := exists(rightdir)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !dirExists {
+			log.Fatalf("The repo you want to work on is currently not on your system.\n"+
+				"Run %q to obtain this repo\n"+
+				"then go to the directory %q\n",
+				"go get -d golang.org/x/"+*repo, rightdir)
+		}
+		log.Fatalf("Your current directory is:%q\n"+
+			"Working on golang/x/%v requires you be in %q\n",
+			wd, *repo, rightdir)
+	}
+}
+
+func firstGoPath() string {
+	list := filepath.SplitList(build.Default.GOPATH)
+	if len(list) < 1 {
+		return ""
+	}
+	return list[0]
+}
+
+func exists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return true, err
+}
+
+func inGoPath(wd string) bool {
+	if os.Getenv("GOPATH") == "" {
+		return false
+	}
+
+	for _, path := range filepath.SplitList(os.Getenv("GOPATH")) {
+		if strings.HasPrefix(wd, filepath.Join(path, "src")) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// mostly check that they didn't clone from github
+func checkGitOrigin() {
+	if _, err := exec.LookPath("git"); err != nil {
+		log.Fatalf("You don't appear to have git installed. Do that.")
+	}
+	wantRemote := "https://go.googlesource.com/" + *repo
+	remotes, err := exec.Command("git", "remote", "-v").Output()
+	if err != nil {
+		msg := cmdErr(err)
+		if strings.Contains(msg, "Not a git repository") {
+			log.Fatalf("Your current directory is not in a git checkout of %s", wantRemote)
+		}
+		log.Fatalf("Error running git remote -v: %v", msg)
+	}
+	matches := 0
+	for _, line := range strings.Split(string(remotes), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "origin") {
+			continue
+		}
+		if !strings.Contains(line, wantRemote) {
+			curRemote := strings.Fields(strings.TrimPrefix(line, "origin"))[0]
+			// TODO: if not in dryRun mode, just fix it?
+			log.Fatalf("Current directory's git was cloned from %q; origin should be %q", curRemote, wantRemote)
+		}
+		matches++
+	}
+	if matches == 0 {
+		log.Fatalf("git remote -v output didn't contain expected %q. Got:\n%s", wantRemote, remotes)
+	}
+}
+
+func cmdErr(err error) string {
+	if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
+		return fmt.Sprintf("%s: %s", err, ee.Stderr)
+	}
+	return fmt.Sprint(err)
+}
+
+func checkGitCodeReview() {
+	if _, err := exec.LookPath("git-codereview"); err != nil {
+		if *dry {
+			log.Fatalf("You don't appear to have git-codereview tool. While this is technically optional,\n" +
+				"almost all Go contributors use it. Our documentation and this tool assume it is used.\n" +
+				"To install it, run:\n\n\t$ go get golang.org/x/review/git-codereview\n\n(Then run go-contrib-init again)")
+		}
+		err := exec.Command("go", "get", "golang.org/x/review/git-codereview").Run()
+		if err != nil {
+			log.Fatalf("Error running go get golang.org/x/review/git-codereview: %v", cmdErr(err))
+		}
+		log.Printf("Installed git-codereview (ran `go get golang.org/x/review/git-codereview`)")
+	}
+	missing := false
+	for _, cmd := range []string{"change", "gofmt", "mail", "pending", "submit", "sync"} {
+		v, _ := exec.Command("git", "config", "alias."+cmd).Output()
+		if strings.Contains(string(v), "codereview") {
+			continue
+		}
+		if *dry {
+			log.Printf("Missing alias. Run:\n\t$ git config alias.%s \"codereview %s\"", cmd, cmd)
+			missing = true
+		} else {
+			err := exec.Command("git", "config", "alias."+cmd, "codereview "+cmd).Run()
+			if err != nil {
+				log.Fatalf("Error setting alias.%s: %v", cmd, cmdErr(err))
+			}
+		}
+	}
+	if missing {
+		log.Fatalf("Missing aliases. (While optional, this tool assumes you use them.)")
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib_test.go b/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib_test.go
new file mode 100644
index 0000000..c151f02
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/go-contrib-init/contrib_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestExpandUser(t *testing.T) {
+	env := "HOME"
+	if runtime.GOOS == "windows" {
+		env = "USERPROFILE"
+	} else if runtime.GOOS == "plan9" {
+		env = "home"
+	}
+
+	oldenv := os.Getenv(env)
+	os.Setenv(env, "/home/gopher")
+	defer os.Setenv(env, oldenv)
+
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{input: "~/foo", want: "/home/gopher/foo"},
+		{input: "${HOME}/foo", want: "/home/gopher/foo"},
+		{input: "/~/foo", want: "/~/foo"},
+	}
+	for _, tt := range tests {
+		got := expandUser(tt.input)
+		if got != tt.want {
+			t.Fatalf("want %q, but %q", tt.want, got)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/doc.go b/vendor/golang.org/x/tools/cmd/godex/doc.go
new file mode 100644
index 0000000..ceb7c2f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/doc.go
@@ -0,0 +1,69 @@
+// 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.
+
+// The godex command prints (dumps) exported information of packages
+// or selected package objects.
+//
+// In contrast to godoc, godex extracts this information from compiled
+// object files. Hence the exported data is truly what a compiler will
+// see, at the cost of missing commentary.
+//
+// Usage: godex [flags] {path[.name]}
+//
+// Each argument must be a (possibly partial) package path, optionally
+// followed by a dot and the name of a package object:
+//
+//	godex math
+//	godex math.Sin
+//	godex math.Sin fmt.Printf
+//	godex go/types
+//
+// godex automatically tries all possible package path prefixes if only a
+// partial package path is given. For instance, for the path "go/types",
+// godex prepends "golang.org/x/tools".
+//
+// The prefixes are computed by searching the directories specified by
+// the GOROOT and GOPATH environment variables (and by excluding the
+// build OS- and architecture-specific directory names from the path).
+// The search order is depth-first and alphabetic; for a partial path
+// "foo", a package "a/foo" is found before "b/foo".
+//
+// Absolute and relative paths may be provided, which disable automatic
+// prefix generation:
+//
+//	godex $GOROOT/pkg/darwin_amd64/sort
+//	godex ./sort
+//
+// All but the last path element may contain dots; a dot in the last path
+// element separates the package path from the package object name. If the
+// last path element contains a dot, terminate the argument with another
+// dot (indicating an empty object name). For instance, the path for a
+// package foo.bar would be specified as in:
+//
+//	godex foo.bar.
+//
+// The flags are:
+//
+//	-s=""
+//		only consider packages from src, where src is one of the supported compilers
+//	-v=false
+//		verbose mode
+//
+// The following sources (-s arguments) are supported:
+//
+//	gc
+//		gc-generated object files
+//	gccgo
+//		gccgo-generated object files
+//	gccgo-new
+//		gccgo-generated object files using a condensed format (experimental)
+//	source
+//		(uncompiled) source code (not yet implemented)
+//
+// If no -s argument is provided, godex will try to find a matching source.
+//
+package main // import "golang.org/x/tools/cmd/godex"
+
+// BUG(gri): support for -s=source is not yet implemented
+// BUG(gri): gccgo-importing appears to have occasional problems stalling godex; try -s=gc as work-around
diff --git a/vendor/golang.org/x/tools/cmd/godex/gc.go b/vendor/golang.org/x/tools/cmd/godex/gc.go
new file mode 100644
index 0000000..95eba65
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/gc.go
@@ -0,0 +1,13 @@
+// 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 access to gc-generated export data.
+
+package main
+
+import "go/importer"
+
+func init() {
+	register("gc", importer.For("gc", nil))
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/gccgo.go b/vendor/golang.org/x/tools/cmd/godex/gccgo.go
new file mode 100644
index 0000000..7644998
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/gccgo.go
@@ -0,0 +1,34 @@
+// 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 access to gccgo-generated export data.
+
+package main
+
+import (
+	"go/importer"
+	"go/types"
+)
+
+func init() {
+	register("gccgo", importer.For("gccgo", nil))
+}
+
+// Print the extra gccgo compiler data for this package, if it exists.
+func (p *printer) printGccgoExtra(pkg *types.Package) {
+	// Disabled for now.
+	// TODO(gri) address this at some point.
+
+	// if initdata, ok := initmap[pkg]; ok {
+	// 	p.printf("/*\npriority %d\n", initdata.Priority)
+
+	// 	p.printDecl("init", len(initdata.Inits), func() {
+	// 		for _, init := range initdata.Inits {
+	// 			p.printf("%s %s %d\n", init.Name, init.InitFunc, init.Priority)
+	// 		}
+	// 	})
+
+	// 	p.print("*/\n")
+	// }
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/godex.go b/vendor/golang.org/x/tools/cmd/godex/godex.go
new file mode 100644
index 0000000..a222ed6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/godex.go
@@ -0,0 +1,211 @@
+// 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 (
+	"errors"
+	"flag"
+	"fmt"
+	"go/build"
+	"go/types"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var (
+	source  = flag.String("s", "", "only consider packages from src, where src is one of the supported compilers")
+	verbose = flag.Bool("v", false, "verbose mode")
+)
+
+// lists of registered sources and corresponding importers
+var (
+	sources      []string
+	importers    []types.Importer
+	importFailed = errors.New("import failed")
+)
+
+func usage() {
+	fmt.Fprintln(os.Stderr, "usage: godex [flags] {path|qualifiedIdent}")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func report(msg string) {
+	fmt.Fprintln(os.Stderr, "error: "+msg)
+	os.Exit(2)
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	if flag.NArg() == 0 {
+		report("no package name, path, or file provided")
+	}
+
+	var imp types.Importer = new(tryImporters)
+	if *source != "" {
+		imp = lookup(*source)
+		if imp == nil {
+			report("source (-s argument) must be one of: " + strings.Join(sources, ", "))
+		}
+	}
+
+	for _, arg := range flag.Args() {
+		path, name := splitPathIdent(arg)
+		logf("\tprocessing %q: path = %q, name = %s\n", arg, path, name)
+
+		// generate possible package path prefixes
+		// (at the moment we do this for each argument - should probably cache the generated prefixes)
+		prefixes := make(chan string)
+		go genPrefixes(prefixes, !filepath.IsAbs(path) && !build.IsLocalImport(path))
+
+		// import package
+		pkg, err := tryPrefixes(prefixes, path, imp)
+		if err != nil {
+			logf("\t=> ignoring %q: %s\n", path, err)
+			continue
+		}
+
+		// filter objects if needed
+		var filter func(types.Object) bool
+		if name != "" {
+			filter = func(obj types.Object) bool {
+				// TODO(gri) perhaps use regular expression matching here?
+				return obj.Name() == name
+			}
+		}
+
+		// print contents
+		print(os.Stdout, pkg, filter)
+	}
+}
+
+func logf(format string, args ...interface{}) {
+	if *verbose {
+		fmt.Fprintf(os.Stderr, format, args...)
+	}
+}
+
+// splitPathIdent splits a path.name argument into its components.
+// All but the last path element may contain dots.
+func splitPathIdent(arg string) (path, name string) {
+	if i := strings.LastIndex(arg, "."); i >= 0 {
+		if j := strings.LastIndex(arg, "/"); j < i {
+			// '.' is not part of path
+			path = arg[:i]
+			name = arg[i+1:]
+			return
+		}
+	}
+	path = arg
+	return
+}
+
+// tryPrefixes tries to import the package given by (the possibly partial) path using the given importer imp
+// by prepending all possible prefixes to path. It returns with the first package that it could import, or
+// with an error.
+func tryPrefixes(prefixes chan string, path string, imp types.Importer) (pkg *types.Package, err error) {
+	for prefix := range prefixes {
+		actual := path
+		if prefix == "" {
+			// don't use filepath.Join as it will sanitize the path and remove
+			// a leading dot and then the path is not recognized as a relative
+			// package path by the importers anymore
+			logf("\ttrying no prefix\n")
+		} else {
+			actual = filepath.Join(prefix, path)
+			logf("\ttrying prefix %q\n", prefix)
+		}
+		pkg, err = imp.Import(actual)
+		if err == nil {
+			break
+		}
+		logf("\t=> importing %q failed: %s\n", actual, err)
+	}
+	return
+}
+
+// tryImporters is an importer that tries all registered importers
+// successively until one of them succeeds or all of them failed.
+type tryImporters struct{}
+
+func (t *tryImporters) Import(path string) (pkg *types.Package, err error) {
+	for i, imp := range importers {
+		logf("\t\ttrying %s import\n", sources[i])
+		pkg, err = imp.Import(path)
+		if err == nil {
+			break
+		}
+		logf("\t\t=> %s import failed: %s\n", sources[i], err)
+	}
+	return
+}
+
+type protector struct {
+	imp types.Importer
+}
+
+func (p *protector) Import(path string) (pkg *types.Package, err error) {
+	defer func() {
+		if recover() != nil {
+			pkg = nil
+			err = importFailed
+		}
+	}()
+	return p.imp.Import(path)
+}
+
+// protect protects an importer imp from panics and returns the protected importer.
+func protect(imp types.Importer) types.Importer {
+	return &protector{imp}
+}
+
+// register registers an importer imp for a given source src.
+func register(src string, imp types.Importer) {
+	if lookup(src) != nil {
+		panic(src + " importer already registered")
+	}
+	sources = append(sources, src)
+	importers = append(importers, protect(imp))
+}
+
+// lookup returns the importer imp for a given source src.
+func lookup(src string) types.Importer {
+	for i, s := range sources {
+		if s == src {
+			return importers[i]
+		}
+	}
+	return nil
+}
+
+func genPrefixes(out chan string, all bool) {
+	out <- ""
+	if all {
+		platform := build.Default.GOOS + "_" + build.Default.GOARCH
+		dirnames := append([]string{build.Default.GOROOT}, filepath.SplitList(build.Default.GOPATH)...)
+		for _, dirname := range dirnames {
+			walkDir(filepath.Join(dirname, "pkg", platform), "", out)
+		}
+	}
+	close(out)
+}
+
+func walkDir(dirname, prefix string, out chan string) {
+	fiList, err := ioutil.ReadDir(dirname)
+	if err != nil {
+		return
+	}
+	for _, fi := range fiList {
+		if fi.IsDir() && !strings.HasPrefix(fi.Name(), ".") {
+			prefix := filepath.Join(prefix, fi.Name())
+			out <- prefix
+			walkDir(filepath.Join(dirname, fi.Name()), prefix, out)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/isAlias18.go b/vendor/golang.org/x/tools/cmd/godex/isAlias18.go
new file mode 100644
index 0000000..cab1292
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/isAlias18.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.9
+
+package main
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return false // there are no type aliases before Go 1.9
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/isAlias19.go b/vendor/golang.org/x/tools/cmd/godex/isAlias19.go
new file mode 100644
index 0000000..6ebdd42
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/isAlias19.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.9
+
+package main
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return obj.IsAlias()
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/print.go b/vendor/golang.org/x/tools/cmd/godex/print.go
new file mode 100644
index 0000000..adce864
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/print.go
@@ -0,0 +1,373 @@
+// 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 (
+	"bytes"
+	"fmt"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"math/big"
+)
+
+// TODO(gri) use tabwriter for alignment?
+
+func print(w io.Writer, pkg *types.Package, filter func(types.Object) bool) {
+	var p printer
+	p.pkg = pkg
+	p.printPackage(pkg, filter)
+	p.printGccgoExtra(pkg)
+	io.Copy(w, &p.buf)
+}
+
+type printer struct {
+	pkg    *types.Package
+	buf    bytes.Buffer
+	indent int  // current indentation level
+	last   byte // last byte written
+}
+
+func (p *printer) print(s string) {
+	// Write the string one byte at a time. We care about the presence of
+	// newlines for indentation which we will see even in the presence of
+	// (non-corrupted) Unicode; no need to read one rune at a time.
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if ch != '\n' && p.last == '\n' {
+			// Note: This could lead to a range overflow for very large
+			// indentations, but it's extremely unlikely to happen for
+			// non-pathological code.
+			p.buf.WriteString("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"[:p.indent])
+		}
+		p.buf.WriteByte(ch)
+		p.last = ch
+	}
+}
+
+func (p *printer) printf(format string, args ...interface{}) {
+	p.print(fmt.Sprintf(format, args...))
+}
+
+// methodsFor returns the named type and corresponding methods if the type
+// denoted by obj is not an interface and has methods. Otherwise it returns
+// the zero value.
+func methodsFor(obj *types.TypeName) (*types.Named, []*types.Selection) {
+	named, _ := obj.Type().(*types.Named)
+	if named == nil {
+		// A type name's type can also be the
+		// exported basic type unsafe.Pointer.
+		return nil, nil
+	}
+	if _, ok := named.Underlying().(*types.Interface); ok {
+		// ignore interfaces
+		return nil, nil
+	}
+	methods := combinedMethodSet(named)
+	if len(methods) == 0 {
+		return nil, nil
+	}
+	return named, methods
+}
+
+func (p *printer) printPackage(pkg *types.Package, filter func(types.Object) bool) {
+	// collect objects by kind
+	var (
+		consts   []*types.Const
+		typem    []*types.Named    // non-interface types with methods
+		typez    []*types.TypeName // interfaces or types without methods
+		vars     []*types.Var
+		funcs    []*types.Func
+		builtins []*types.Builtin
+		methods  = make(map[*types.Named][]*types.Selection) // method sets for named types
+	)
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj.Exported() {
+			// collect top-level exported and possibly filtered objects
+			if filter == nil || filter(obj) {
+				switch obj := obj.(type) {
+				case *types.Const:
+					consts = append(consts, obj)
+				case *types.TypeName:
+					// group into types with methods and types without
+					if named, m := methodsFor(obj); named != nil {
+						typem = append(typem, named)
+						methods[named] = m
+					} else {
+						typez = append(typez, obj)
+					}
+				case *types.Var:
+					vars = append(vars, obj)
+				case *types.Func:
+					funcs = append(funcs, obj)
+				case *types.Builtin:
+					// for unsafe.Sizeof, etc.
+					builtins = append(builtins, obj)
+				}
+			}
+		} else if filter == nil {
+			// no filtering: collect top-level unexported types with methods
+			if obj, _ := obj.(*types.TypeName); obj != nil {
+				// see case *types.TypeName above
+				if named, m := methodsFor(obj); named != nil {
+					typem = append(typem, named)
+					methods[named] = m
+				}
+			}
+		}
+	}
+
+	p.printf("package %s  // %q\n", pkg.Name(), pkg.Path())
+
+	p.printDecl("const", len(consts), func() {
+		for _, obj := range consts {
+			p.printObj(obj)
+			p.print("\n")
+		}
+	})
+
+	p.printDecl("var", len(vars), func() {
+		for _, obj := range vars {
+			p.printObj(obj)
+			p.print("\n")
+		}
+	})
+
+	p.printDecl("type", len(typez), func() {
+		for _, obj := range typez {
+			p.printf("%s ", obj.Name())
+			typ := obj.Type()
+			if isAlias(obj) {
+				p.print("= ")
+				p.writeType(p.pkg, typ)
+			} else {
+				p.writeType(p.pkg, typ.Underlying())
+			}
+			p.print("\n")
+		}
+	})
+
+	// non-interface types with methods
+	for _, named := range typem {
+		first := true
+		if obj := named.Obj(); obj.Exported() {
+			if first {
+				p.print("\n")
+				first = false
+			}
+			p.printf("type %s ", obj.Name())
+			p.writeType(p.pkg, named.Underlying())
+			p.print("\n")
+		}
+		for _, m := range methods[named] {
+			if obj := m.Obj(); obj.Exported() {
+				if first {
+					p.print("\n")
+					first = false
+				}
+				p.printFunc(m.Recv(), obj.(*types.Func))
+				p.print("\n")
+			}
+		}
+	}
+
+	if len(funcs) > 0 {
+		p.print("\n")
+		for _, obj := range funcs {
+			p.printFunc(nil, obj)
+			p.print("\n")
+		}
+	}
+
+	// TODO(gri) better handling of builtins (package unsafe only)
+	if len(builtins) > 0 {
+		p.print("\n")
+		for _, obj := range builtins {
+			p.printf("func %s() // builtin\n", obj.Name())
+		}
+	}
+
+	p.print("\n")
+}
+
+func (p *printer) printDecl(keyword string, n int, printGroup func()) {
+	switch n {
+	case 0:
+		// nothing to do
+	case 1:
+		p.printf("\n%s ", keyword)
+		printGroup()
+	default:
+		p.printf("\n%s (\n", keyword)
+		p.indent++
+		printGroup()
+		p.indent--
+		p.print(")\n")
+	}
+}
+
+// absInt returns the absolute value of v as a *big.Int.
+// v must be a numeric value.
+func absInt(v exact.Value) *big.Int {
+	// compute big-endian representation of v
+	b := exact.Bytes(v) // little-endian
+	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
+		b[i], b[j] = b[j], b[i]
+	}
+	return new(big.Int).SetBytes(b)
+}
+
+var (
+	one = big.NewRat(1, 1)
+	ten = big.NewRat(10, 1)
+)
+
+// floatString returns the string representation for a
+// numeric value v in normalized floating-point format.
+func floatString(v exact.Value) string {
+	if exact.Sign(v) == 0 {
+		return "0.0"
+	}
+	// x != 0
+
+	// convert |v| into a big.Rat x
+	x := new(big.Rat).SetFrac(absInt(exact.Num(v)), absInt(exact.Denom(v)))
+
+	// normalize x and determine exponent e
+	// (This is not very efficient, but also not speed-critical.)
+	var e int
+	for x.Cmp(ten) >= 0 {
+		x.Quo(x, ten)
+		e++
+	}
+	for x.Cmp(one) < 0 {
+		x.Mul(x, ten)
+		e--
+	}
+
+	// TODO(gri) Values such as 1/2 are easier to read in form 0.5
+	// rather than 5.0e-1. Similarly, 1.0e1 is easier to read as
+	// 10.0. Fine-tune best exponent range for readability.
+
+	s := x.FloatString(100) // good-enough precision
+
+	// trim trailing 0's
+	i := len(s)
+	for i > 0 && s[i-1] == '0' {
+		i--
+	}
+	s = s[:i]
+
+	// add a 0 if the number ends in decimal point
+	if len(s) > 0 && s[len(s)-1] == '.' {
+		s += "0"
+	}
+
+	// add exponent and sign
+	if e != 0 {
+		s += fmt.Sprintf("e%+d", e)
+	}
+	if exact.Sign(v) < 0 {
+		s = "-" + s
+	}
+
+	// TODO(gri) If v is a "small" fraction (i.e., numerator and denominator
+	// are just a small number of decimal digits), add the exact fraction as
+	// a comment. For instance: 3.3333...e-1 /* = 1/3 */
+
+	return s
+}
+
+// valString returns the string representation for the value v.
+// Setting floatFmt forces an integer value to be formatted in
+// normalized floating-point format.
+// TODO(gri) Move this code into package exact.
+func valString(v exact.Value, floatFmt bool) string {
+	switch v.Kind() {
+	case exact.Int:
+		if floatFmt {
+			return floatString(v)
+		}
+	case exact.Float:
+		return floatString(v)
+	case exact.Complex:
+		re := exact.Real(v)
+		im := exact.Imag(v)
+		var s string
+		if exact.Sign(re) != 0 {
+			s = floatString(re)
+			if exact.Sign(im) >= 0 {
+				s += " + "
+			} else {
+				s += " - "
+				im = exact.UnaryOp(token.SUB, im, 0) // negate im
+			}
+		}
+		// im != 0, otherwise v would be exact.Int or exact.Float
+		return s + floatString(im) + "i"
+	}
+	return v.String()
+}
+
+func (p *printer) printObj(obj types.Object) {
+	p.print(obj.Name())
+
+	typ, basic := obj.Type().Underlying().(*types.Basic)
+	if basic && typ.Info()&types.IsUntyped != 0 {
+		// don't write untyped types
+	} else {
+		p.print(" ")
+		p.writeType(p.pkg, obj.Type())
+	}
+
+	if obj, ok := obj.(*types.Const); ok {
+		floatFmt := basic && typ.Info()&(types.IsFloat|types.IsComplex) != 0
+		p.print(" = ")
+		p.print(valString(obj.Val(), floatFmt))
+	}
+}
+
+func (p *printer) printFunc(recvType types.Type, obj *types.Func) {
+	p.print("func ")
+	sig := obj.Type().(*types.Signature)
+	if recvType != nil {
+		p.print("(")
+		p.writeType(p.pkg, recvType)
+		p.print(") ")
+	}
+	p.print(obj.Name())
+	p.writeSignature(p.pkg, sig)
+}
+
+// combinedMethodSet returns the method set for a named type T
+// merged with all the methods of *T that have different names than
+// the methods of T.
+//
+// combinedMethodSet is analogous to types/typeutil.IntuitiveMethodSet
+// but doesn't require a MethodSetCache.
+// TODO(gri) If this functionality doesn't change over time, consider
+// just calling IntuitiveMethodSet eventually.
+func combinedMethodSet(T *types.Named) []*types.Selection {
+	// method set for T
+	mset := types.NewMethodSet(T)
+	var res []*types.Selection
+	for i, n := 0, mset.Len(); i < n; i++ {
+		res = append(res, mset.At(i))
+	}
+
+	// add all *T methods with names different from T methods
+	pmset := types.NewMethodSet(types.NewPointer(T))
+	for i, n := 0, pmset.Len(); i < n; i++ {
+		pm := pmset.At(i)
+		if obj := pm.Obj(); mset.Lookup(obj.Pkg(), obj.Name()) == nil {
+			res = append(res, pm)
+		}
+	}
+
+	return res
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/source.go b/vendor/golang.org/x/tools/cmd/godex/source.go
new file mode 100644
index 0000000..85235e9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/source.go
@@ -0,0 +1,19 @@
+// 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 access to export data from source.
+
+package main
+
+import "go/types"
+
+func init() {
+	register("source", sourceImporter{})
+}
+
+type sourceImporter struct{}
+
+func (sourceImporter) Import(path string) (*types.Package, error) {
+	panic("unimplemented")
+}
diff --git a/vendor/golang.org/x/tools/cmd/godex/writetype.go b/vendor/golang.org/x/tools/cmd/godex/writetype.go
new file mode 100644
index 0000000..dd17f90
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godex/writetype.go
@@ -0,0 +1,242 @@
+// 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 writing of types. The functionality is lifted
+// directly from go/types, but now contains various modifications for
+// nicer output.
+//
+// TODO(gri) back-port once we have a fixed interface and once the
+// go/types API is not frozen anymore for the 1.3 release; and remove
+// this implementation if possible.
+
+package main
+
+import "go/types"
+
+func (p *printer) writeType(this *types.Package, typ types.Type) {
+	p.writeTypeInternal(this, typ, make([]types.Type, 8))
+}
+
+// From go/types - leave for now to ease back-porting this code.
+const GcCompatibilityMode = false
+
+func (p *printer) writeTypeInternal(this *types.Package, typ types.Type, visited []types.Type) {
+	// Theoretically, this is a quadratic lookup algorithm, but in
+	// practice deeply nested composite types with unnamed component
+	// types are uncommon. This code is likely more efficient than
+	// using a map.
+	for _, t := range visited {
+		if t == typ {
+			p.printf("○%T", typ) // cycle to typ
+			return
+		}
+	}
+	visited = append(visited, typ)
+
+	switch t := typ.(type) {
+	case nil:
+		p.print("<nil>")
+
+	case *types.Basic:
+		if t.Kind() == types.UnsafePointer {
+			p.print("unsafe.")
+		}
+		if GcCompatibilityMode {
+			// forget the alias names
+			switch t.Kind() {
+			case types.Byte:
+				t = types.Typ[types.Uint8]
+			case types.Rune:
+				t = types.Typ[types.Int32]
+			}
+		}
+		p.print(t.Name())
+
+	case *types.Array:
+		p.printf("[%d]", t.Len())
+		p.writeTypeInternal(this, t.Elem(), visited)
+
+	case *types.Slice:
+		p.print("[]")
+		p.writeTypeInternal(this, t.Elem(), visited)
+
+	case *types.Struct:
+		n := t.NumFields()
+		if n == 0 {
+			p.print("struct{}")
+			return
+		}
+
+		p.print("struct {\n")
+		p.indent++
+		for i := 0; i < n; i++ {
+			f := t.Field(i)
+			if !f.Anonymous() {
+				p.printf("%s ", f.Name())
+			}
+			p.writeTypeInternal(this, f.Type(), visited)
+			if tag := t.Tag(i); tag != "" {
+				p.printf(" %q", tag)
+			}
+			p.print("\n")
+		}
+		p.indent--
+		p.print("}")
+
+	case *types.Pointer:
+		p.print("*")
+		p.writeTypeInternal(this, t.Elem(), visited)
+
+	case *types.Tuple:
+		p.writeTuple(this, t, false, visited)
+
+	case *types.Signature:
+		p.print("func")
+		p.writeSignatureInternal(this, t, visited)
+
+	case *types.Interface:
+		// We write the source-level methods and embedded types rather
+		// than the actual method set since resolved method signatures
+		// may have non-printable cycles if parameters have anonymous
+		// interface types that (directly or indirectly) embed the
+		// current interface. For instance, consider the result type
+		// of m:
+		//
+		//     type T interface{
+		//         m() interface{ T }
+		//     }
+		//
+		n := t.NumMethods()
+		if n == 0 {
+			p.print("interface{}")
+			return
+		}
+
+		p.print("interface {\n")
+		p.indent++
+		if GcCompatibilityMode {
+			// print flattened interface
+			// (useful to compare against gc-generated interfaces)
+			for i := 0; i < n; i++ {
+				m := t.Method(i)
+				p.print(m.Name())
+				p.writeSignatureInternal(this, m.Type().(*types.Signature), visited)
+				p.print("\n")
+			}
+		} else {
+			// print explicit interface methods and embedded types
+			for i, n := 0, t.NumExplicitMethods(); i < n; i++ {
+				m := t.ExplicitMethod(i)
+				p.print(m.Name())
+				p.writeSignatureInternal(this, m.Type().(*types.Signature), visited)
+				p.print("\n")
+			}
+			for i, n := 0, t.NumEmbeddeds(); i < n; i++ {
+				typ := t.Embedded(i)
+				p.writeTypeInternal(this, typ, visited)
+				p.print("\n")
+			}
+		}
+		p.indent--
+		p.print("}")
+
+	case *types.Map:
+		p.print("map[")
+		p.writeTypeInternal(this, t.Key(), visited)
+		p.print("]")
+		p.writeTypeInternal(this, t.Elem(), visited)
+
+	case *types.Chan:
+		var s string
+		var parens bool
+		switch t.Dir() {
+		case types.SendRecv:
+			s = "chan "
+			// chan (<-chan T) requires parentheses
+			if c, _ := t.Elem().(*types.Chan); c != nil && c.Dir() == types.RecvOnly {
+				parens = true
+			}
+		case types.SendOnly:
+			s = "chan<- "
+		case types.RecvOnly:
+			s = "<-chan "
+		default:
+			panic("unreachable")
+		}
+		p.print(s)
+		if parens {
+			p.print("(")
+		}
+		p.writeTypeInternal(this, t.Elem(), visited)
+		if parens {
+			p.print(")")
+		}
+
+	case *types.Named:
+		s := "<Named w/o object>"
+		if obj := t.Obj(); obj != nil {
+			if pkg := obj.Pkg(); pkg != nil {
+				if pkg != this {
+					p.print(pkg.Path())
+					p.print(".")
+				}
+				// TODO(gri): function-local named types should be displayed
+				// differently from named types at package level to avoid
+				// ambiguity.
+			}
+			s = obj.Name()
+		}
+		p.print(s)
+
+	default:
+		// For externally defined implementations of Type.
+		p.print(t.String())
+	}
+}
+
+func (p *printer) writeTuple(this *types.Package, tup *types.Tuple, variadic bool, visited []types.Type) {
+	p.print("(")
+	for i, n := 0, tup.Len(); i < n; i++ {
+		if i > 0 {
+			p.print(", ")
+		}
+		v := tup.At(i)
+		if name := v.Name(); name != "" {
+			p.print(name)
+			p.print(" ")
+		}
+		typ := v.Type()
+		if variadic && i == n-1 {
+			p.print("...")
+			typ = typ.(*types.Slice).Elem()
+		}
+		p.writeTypeInternal(this, typ, visited)
+	}
+	p.print(")")
+}
+
+func (p *printer) writeSignature(this *types.Package, sig *types.Signature) {
+	p.writeSignatureInternal(this, sig, make([]types.Type, 8))
+}
+
+func (p *printer) writeSignatureInternal(this *types.Package, sig *types.Signature, visited []types.Type) {
+	p.writeTuple(this, sig.Params(), sig.Variadic(), visited)
+
+	res := sig.Results()
+	n := res.Len()
+	if n == 0 {
+		// no result
+		return
+	}
+
+	p.print(" ")
+	if n == 1 && res.At(0).Name() == "" {
+		// single unnamed result
+		p.writeTypeInternal(this, res.At(0).Type(), visited)
+		return
+	}
+
+	// multiple or named result(s)
+	p.writeTuple(this, res, false, visited)
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/README.godoc-app b/vendor/golang.org/x/tools/cmd/godoc/README.godoc-app
new file mode 100644
index 0000000..50a0516
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/README.godoc-app
@@ -0,0 +1,56 @@
+godoc on appengine
+------------------
+
+Prerequisites
+-------------
+
+* Go appengine SDK
+  https://developers.google.com/appengine/downloads#Google_App_Engine_SDK_for_Go
+
+* Go sources at tip under $GOROOT
+
+* Godoc sources at tip inside $GOPATH
+  (go get -d golang.org/x/tools/cmd/godoc)
+
+
+Directory structure
+-------------------
+
+* Let $APPDIR be the directory containing the app engine files.
+  (e.g., $APPDIR=$HOME/godoc-app)
+
+* $APPDIR contains the following entries (this may change depending on
+  app-engine release and version of godoc):
+
+	app.yaml
+	golang.org/x/tools/cmd/godoc
+	godoc.zip
+	index.split.*
+
+* The app.yaml file is set up per app engine documentation.
+  For instance:
+
+	application: godoc-app
+	version: 1
+	runtime: go
+	api_version: go1
+
+	handlers:
+	- url: /.*
+	  script: _go_app
+
+
+Configuring and running godoc
+-----------------------------
+
+To configure godoc, run
+
+	bash setup-godoc-app.bash
+
+to prepare an $APPDIR as described above. See the script for details on usage.
+
+To run godoc locally, using the App Engine development server, run
+
+	<path to go_appengine>/dev_appserver.py $APPDIR
+
+godoc should come up at http://localhost:8080 .
diff --git a/vendor/golang.org/x/tools/cmd/godoc/appinit.go b/vendor/golang.org/x/tools/cmd/godoc/appinit.go
new file mode 100644
index 0000000..0c83df9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/appinit.go
@@ -0,0 +1,82 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package main
+
+// This file replaces main.go when running godoc under app-engine.
+// See README.godoc-app for details.
+
+import (
+	"archive/zip"
+	"log"
+	"net/http"
+	"path"
+	"regexp"
+
+	"golang.org/x/tools/godoc"
+	"golang.org/x/tools/godoc/dl"
+	"golang.org/x/tools/godoc/proxy"
+	"golang.org/x/tools/godoc/short"
+	"golang.org/x/tools/godoc/static"
+	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/godoc/vfs/mapfs"
+	"golang.org/x/tools/godoc/vfs/zipfs"
+
+	"google.golang.org/appengine"
+)
+
+func init() {
+	enforceHosts = !appengine.IsDevAppServer()
+	playEnabled = true
+
+	log.Println("initializing godoc ...")
+	log.Printf(".zip file   = %s", zipFilename)
+	log.Printf(".zip GOROOT = %s", zipGoroot)
+	log.Printf("index files = %s", indexFilenames)
+
+	goroot := path.Join("/", zipGoroot) // fsHttp paths are relative to '/'
+
+	// read .zip file and set up file systems
+	const zipfile = zipFilename
+	rc, err := zip.OpenReader(zipfile)
+	if err != nil {
+		log.Fatalf("%s: %s\n", zipfile, err)
+	}
+	// rc is never closed (app running forever)
+	fs.Bind("/", zipfs.New(rc, zipFilename), goroot, vfs.BindReplace)
+	fs.Bind("/lib/godoc", mapfs.New(static.Files), "/", vfs.BindReplace)
+
+	corpus := godoc.NewCorpus(fs)
+	corpus.Verbose = false
+	corpus.MaxResults = 10000 // matches flag default in main.go
+	corpus.IndexEnabled = true
+	corpus.IndexFiles = indexFilenames
+	if err := corpus.Init(); err != nil {
+		log.Fatal(err)
+	}
+	corpus.IndexDirectory = indexDirectoryDefault
+	go corpus.RunIndexer()
+
+	pres = godoc.NewPresentation(corpus)
+	pres.TabWidth = 8
+	pres.ShowPlayground = true
+	pres.ShowExamples = true
+	pres.DeclLinks = true
+	pres.NotesRx = regexp.MustCompile("BUG")
+
+	readTemplates(pres, true)
+
+	mux := registerHandlers(pres)
+	dl.RegisterHandlers(mux)
+	short.RegisterHandlers(mux)
+
+	// Register /compile and /share handlers against the default serve mux
+	// so that other app modules can make plain HTTP requests to those
+	// hosts. (For reasons, HTTPS communication between modules is broken.)
+	proxy.RegisterHandlers(http.DefaultServeMux)
+
+	log.Println("godoc initialization complete")
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/autocert.go b/vendor/golang.org/x/tools/cmd/godoc/autocert.go
new file mode 100644
index 0000000..9fc3a8f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/autocert.go
@@ -0,0 +1,77 @@
+// 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 autocert
+
+// This file adds automatic TLS certificate support (using
+// golang.org/x/crypto/acme/autocert), conditional on the use of the
+// autocert build tag. It sets the serveAutoCertHook func variable
+// non-nil. It is used by main.go.
+//
+// TODO: make this the default? We're in the Go 1.8 freeze now, so
+// this is too invasive to be default, but we want it for
+// https://beta.golang.org/
+
+package main
+
+import (
+	"crypto/tls"
+	"flag"
+	"net"
+	"net/http"
+	"time"
+
+	"golang.org/x/crypto/acme/autocert"
+	"golang.org/x/net/http2"
+)
+
+var (
+	autoCertDirFlag  = flag.String("autocert_cache_dir", "/var/cache/autocert", "Directory to cache TLS certs")
+	autoCertHostFlag = flag.String("autocert_hostname", "", "optional hostname to require in autocert SNI requests")
+)
+
+func init() {
+	serveAutoCertHook = serveAutoCert
+}
+
+func serveAutoCert(h http.Handler) error {
+	m := autocert.Manager{
+		Cache:  autocert.DirCache(*autoCertDirFlag),
+		Prompt: autocert.AcceptTOS,
+	}
+	if *autoCertHostFlag != "" {
+		m.HostPolicy = autocert.HostWhitelist(*autoCertHostFlag)
+	}
+	srv := &http.Server{
+		Handler: h,
+		TLSConfig: &tls.Config{
+			GetCertificate: m.GetCertificate,
+		},
+		IdleTimeout: 60 * time.Second,
+	}
+	http2.ConfigureServer(srv, &http2.Server{})
+	ln, err := net.Listen("tcp", ":443")
+	if err != nil {
+		return err
+	}
+	return srv.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, srv.TLSConfig))
+}
+
+// tcpKeepAliveListener sets TCP keep-alive timeouts on accepted
+// connections. It's used by ListenAndServe and ListenAndServeTLS so
+// dead TCP connections (e.g. closing laptop mid-download) eventually
+// go away.
+type tcpKeepAliveListener struct {
+	*net.TCPListener
+}
+
+func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
+	tc, err := ln.AcceptTCP()
+	if err != nil {
+		return
+	}
+	tc.SetKeepAlive(true)
+	tc.SetKeepAlivePeriod(3 * time.Minute)
+	return tc, nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/blog.go b/vendor/golang.org/x/tools/cmd/godoc/blog.go
new file mode 100644
index 0000000..dec4732
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/blog.go
@@ -0,0 +1,81 @@
+// 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/build"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/blog"
+	"golang.org/x/tools/godoc/redirect"
+)
+
+const (
+	blogRepo = "golang.org/x/blog"
+	blogURL  = "http://blog.golang.org/"
+	blogPath = "/blog/"
+)
+
+var (
+	blogServer   http.Handler // set by blogInit
+	blogInitOnce sync.Once
+	playEnabled  bool
+)
+
+func init() {
+	// Initialize blog only when first accessed.
+	http.HandleFunc(blogPath, func(w http.ResponseWriter, r *http.Request) {
+		blogInitOnce.Do(blogInit)
+		blogServer.ServeHTTP(w, r)
+	})
+}
+
+func blogInit() {
+	// Binary distributions will include the blog content in "/blog".
+	root := filepath.Join(runtime.GOROOT(), "blog")
+
+	// Prefer content from go.blog repository if present.
+	if pkg, err := build.Import(blogRepo, "", build.FindOnly); err == nil {
+		root = pkg.Dir
+	}
+
+	// If content is not available fall back to redirect.
+	if fi, err := os.Stat(root); err != nil || !fi.IsDir() {
+		fmt.Fprintf(os.Stderr, "Blog content not available locally. "+
+			"To install, run \n\tgo get %v\n", blogRepo)
+		blogServer = http.HandlerFunc(blogRedirectHandler)
+		return
+	}
+
+	s, err := blog.NewServer(blog.Config{
+		BaseURL:      blogPath,
+		BasePath:     strings.TrimSuffix(blogPath, "/"),
+		ContentPath:  filepath.Join(root, "content"),
+		TemplatePath: filepath.Join(root, "template"),
+		HomeArticles: 5,
+		PlayEnabled:  playEnabled,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+	blogServer = s
+}
+
+func blogRedirectHandler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path == blogPath {
+		http.Redirect(w, r, blogURL, http.StatusFound)
+		return
+	}
+	blogPrefixHandler.ServeHTTP(w, r)
+}
+
+var blogPrefixHandler = redirect.PrefixHandler(blogPath, blogURL)
diff --git a/vendor/golang.org/x/tools/cmd/godoc/codewalk.go b/vendor/golang.org/x/tools/cmd/godoc/codewalk.go
new file mode 100644
index 0000000..e3bf5cd
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/codewalk.go
@@ -0,0 +1,523 @@
+// Copyright 2010 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.
+
+// The /doc/codewalk/ tree is synthesized from codewalk descriptions,
+// files named $GOROOT/doc/codewalk/*.xml.
+// For an example and a description of the format, see
+// http://golang.org/doc/codewalk/codewalk or run godoc -http=:6060
+// and see http://localhost:6060/doc/codewalk/codewalk .
+// That page is itself a codewalk; the source code for it is
+// $GOROOT/doc/codewalk/codewalk.xml.
+
+package main
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	pathpkg "path"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"text/template"
+	"unicode/utf8"
+
+	"golang.org/x/tools/godoc"
+	"golang.org/x/tools/godoc/vfs"
+)
+
+var codewalkHTML, codewalkdirHTML *template.Template
+
+// Handler for /doc/codewalk/ and below.
+func codewalk(w http.ResponseWriter, r *http.Request) {
+	relpath := r.URL.Path[len("/doc/codewalk/"):]
+	abspath := r.URL.Path
+
+	r.ParseForm()
+	if f := r.FormValue("fileprint"); f != "" {
+		codewalkFileprint(w, r, f)
+		return
+	}
+
+	// If directory exists, serve list of code walks.
+	dir, err := fs.Lstat(abspath)
+	if err == nil && dir.IsDir() {
+		codewalkDir(w, r, relpath, abspath)
+		return
+	}
+
+	// If file exists, serve using standard file server.
+	if err == nil {
+		pres.ServeFile(w, r)
+		return
+	}
+
+	// Otherwise append .xml and hope to find
+	// a codewalk description, but before trim
+	// the trailing /.
+	abspath = strings.TrimRight(abspath, "/")
+	cw, err := loadCodewalk(abspath + ".xml")
+	if err != nil {
+		log.Print(err)
+		pres.ServeError(w, r, relpath, err)
+		return
+	}
+
+	// Canonicalize the path and redirect if changed
+	if redir(w, r) {
+		return
+	}
+
+	pres.ServePage(w, godoc.Page{
+		Title:    "Codewalk: " + cw.Title,
+		Tabtitle: cw.Title,
+		Body:     applyTemplate(codewalkHTML, "codewalk", cw),
+	})
+}
+
+func redir(w http.ResponseWriter, r *http.Request) (redirected bool) {
+	canonical := pathpkg.Clean(r.URL.Path)
+	if !strings.HasSuffix(canonical, "/") {
+		canonical += "/"
+	}
+	if r.URL.Path != canonical {
+		url := *r.URL
+		url.Path = canonical
+		http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+		redirected = true
+	}
+	return
+}
+
+func applyTemplate(t *template.Template, name string, data interface{}) []byte {
+	var buf bytes.Buffer
+	if err := t.Execute(&buf, data); err != nil {
+		log.Printf("%s.Execute: %s", name, err)
+	}
+	return buf.Bytes()
+}
+
+// A Codewalk represents a single codewalk read from an XML file.
+type Codewalk struct {
+	Title string      `xml:"title,attr"`
+	File  []string    `xml:"file"`
+	Step  []*Codestep `xml:"step"`
+}
+
+// A Codestep is a single step in a codewalk.
+type Codestep struct {
+	// Filled in from XML
+	Src   string `xml:"src,attr"`
+	Title string `xml:"title,attr"`
+	XML   string `xml:",innerxml"`
+
+	// Derived from Src; not in XML.
+	Err    error
+	File   string
+	Lo     int
+	LoByte int
+	Hi     int
+	HiByte int
+	Data   []byte
+}
+
+// String method for printing in template.
+// Formats file address nicely.
+func (st *Codestep) String() string {
+	s := st.File
+	if st.Lo != 0 || st.Hi != 0 {
+		s += fmt.Sprintf(":%d", st.Lo)
+		if st.Lo != st.Hi {
+			s += fmt.Sprintf(",%d", st.Hi)
+		}
+	}
+	return s
+}
+
+// loadCodewalk reads a codewalk from the named XML file.
+func loadCodewalk(filename string) (*Codewalk, error) {
+	f, err := fs.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	cw := new(Codewalk)
+	d := xml.NewDecoder(f)
+	d.Entity = xml.HTMLEntity
+	err = d.Decode(cw)
+	if err != nil {
+		return nil, &os.PathError{Op: "parsing", Path: filename, Err: err}
+	}
+
+	// Compute file list, evaluate line numbers for addresses.
+	m := make(map[string]bool)
+	for _, st := range cw.Step {
+		i := strings.Index(st.Src, ":")
+		if i < 0 {
+			i = len(st.Src)
+		}
+		filename := st.Src[0:i]
+		data, err := vfs.ReadFile(fs, filename)
+		if err != nil {
+			st.Err = err
+			continue
+		}
+		if i < len(st.Src) {
+			lo, hi, err := addrToByteRange(st.Src[i+1:], 0, data)
+			if err != nil {
+				st.Err = err
+				continue
+			}
+			// Expand match to line boundaries.
+			for lo > 0 && data[lo-1] != '\n' {
+				lo--
+			}
+			for hi < len(data) && (hi == 0 || data[hi-1] != '\n') {
+				hi++
+			}
+			st.Lo = byteToLine(data, lo)
+			st.Hi = byteToLine(data, hi-1)
+		}
+		st.Data = data
+		st.File = filename
+		m[filename] = true
+	}
+
+	// Make list of files
+	cw.File = make([]string, len(m))
+	i := 0
+	for f := range m {
+		cw.File[i] = f
+		i++
+	}
+	sort.Strings(cw.File)
+
+	return cw, nil
+}
+
+// codewalkDir serves the codewalk directory listing.
+// It scans the directory for subdirectories or files named *.xml
+// and prepares a table.
+func codewalkDir(w http.ResponseWriter, r *http.Request, relpath, abspath string) {
+	type elem struct {
+		Name  string
+		Title string
+	}
+
+	dir, err := fs.ReadDir(abspath)
+	if err != nil {
+		log.Print(err)
+		pres.ServeError(w, r, relpath, err)
+		return
+	}
+	var v []interface{}
+	for _, fi := range dir {
+		name := fi.Name()
+		if fi.IsDir() {
+			v = append(v, &elem{name + "/", ""})
+		} else if strings.HasSuffix(name, ".xml") {
+			cw, err := loadCodewalk(abspath + "/" + name)
+			if err != nil {
+				continue
+			}
+			v = append(v, &elem{name[0 : len(name)-len(".xml")], cw.Title})
+		}
+	}
+
+	pres.ServePage(w, godoc.Page{
+		Title: "Codewalks",
+		Body:  applyTemplate(codewalkdirHTML, "codewalkdir", v),
+	})
+}
+
+// codewalkFileprint serves requests with ?fileprint=f&lo=lo&hi=hi.
+// The filename f has already been retrieved and is passed as an argument.
+// Lo and hi are the numbers of the first and last line to highlight
+// in the response.  This format is used for the middle window pane
+// of the codewalk pages.  It is a separate iframe and does not get
+// the usual godoc HTML wrapper.
+func codewalkFileprint(w http.ResponseWriter, r *http.Request, f string) {
+	abspath := f
+	data, err := vfs.ReadFile(fs, abspath)
+	if err != nil {
+		log.Print(err)
+		pres.ServeError(w, r, f, err)
+		return
+	}
+	lo, _ := strconv.Atoi(r.FormValue("lo"))
+	hi, _ := strconv.Atoi(r.FormValue("hi"))
+	if hi < lo {
+		hi = lo
+	}
+	lo = lineToByte(data, lo)
+	hi = lineToByte(data, hi+1)
+
+	// Put the mark 4 lines before lo, so that the iframe
+	// shows a few lines of context before the highlighted
+	// section.
+	n := 4
+	mark := lo
+	for ; mark > 0 && n > 0; mark-- {
+		if data[mark-1] == '\n' {
+			if n--; n == 0 {
+				break
+			}
+		}
+	}
+
+	io.WriteString(w, `<style type="text/css">@import "/doc/codewalk/codewalk.css";</style><pre>`)
+	template.HTMLEscape(w, data[0:mark])
+	io.WriteString(w, "<a name='mark'></a>")
+	template.HTMLEscape(w, data[mark:lo])
+	if lo < hi {
+		io.WriteString(w, "<div class='codewalkhighlight'>")
+		template.HTMLEscape(w, data[lo:hi])
+		io.WriteString(w, "</div>")
+	}
+	template.HTMLEscape(w, data[hi:])
+	io.WriteString(w, "</pre>")
+}
+
+// addrToByte evaluates the given address starting at offset start in data.
+// It returns the lo and hi byte offset of the matched region within data.
+// See http://plan9.bell-labs.com/sys/doc/sam/sam.html Table II
+// for details on the syntax.
+func addrToByteRange(addr string, start int, data []byte) (lo, hi int, err error) {
+	var (
+		dir        byte
+		prevc      byte
+		charOffset bool
+	)
+	lo = start
+	hi = start
+	for addr != "" && err == nil {
+		c := addr[0]
+		switch c {
+		default:
+			err = errors.New("invalid address syntax near " + string(c))
+		case ',':
+			if len(addr) == 1 {
+				hi = len(data)
+			} else {
+				_, hi, err = addrToByteRange(addr[1:], hi, data)
+			}
+			return
+
+		case '+', '-':
+			if prevc == '+' || prevc == '-' {
+				lo, hi, err = addrNumber(data, lo, hi, prevc, 1, charOffset)
+			}
+			dir = c
+
+		case '$':
+			lo = len(data)
+			hi = len(data)
+			if len(addr) > 1 {
+				dir = '+'
+			}
+
+		case '#':
+			charOffset = true
+
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			var i int
+			for i = 1; i < len(addr); i++ {
+				if addr[i] < '0' || addr[i] > '9' {
+					break
+				}
+			}
+			var n int
+			n, err = strconv.Atoi(addr[0:i])
+			if err != nil {
+				break
+			}
+			lo, hi, err = addrNumber(data, lo, hi, dir, n, charOffset)
+			dir = 0
+			charOffset = false
+			prevc = c
+			addr = addr[i:]
+			continue
+
+		case '/':
+			var i, j int
+		Regexp:
+			for i = 1; i < len(addr); i++ {
+				switch addr[i] {
+				case '\\':
+					i++
+				case '/':
+					j = i + 1
+					break Regexp
+				}
+			}
+			if j == 0 {
+				j = i
+			}
+			pattern := addr[1:i]
+			lo, hi, err = addrRegexp(data, lo, hi, dir, pattern)
+			prevc = c
+			addr = addr[j:]
+			continue
+		}
+		prevc = c
+		addr = addr[1:]
+	}
+
+	if err == nil && dir != 0 {
+		lo, hi, err = addrNumber(data, lo, hi, dir, 1, charOffset)
+	}
+	if err != nil {
+		return 0, 0, err
+	}
+	return lo, hi, nil
+}
+
+// addrNumber applies the given dir, n, and charOffset to the address lo, hi.
+// dir is '+' or '-', n is the count, and charOffset is true if the syntax
+// used was #n.  Applying +n (or +#n) means to advance n lines
+// (or characters) after hi.  Applying -n (or -#n) means to back up n lines
+// (or characters) before lo.
+// The return value is the new lo, hi.
+func addrNumber(data []byte, lo, hi int, dir byte, n int, charOffset bool) (int, int, error) {
+	switch dir {
+	case 0:
+		lo = 0
+		hi = 0
+		fallthrough
+
+	case '+':
+		if charOffset {
+			pos := hi
+			for ; n > 0 && pos < len(data); n-- {
+				_, size := utf8.DecodeRune(data[pos:])
+				pos += size
+			}
+			if n == 0 {
+				return pos, pos, nil
+			}
+			break
+		}
+		// find next beginning of line
+		if hi > 0 {
+			for hi < len(data) && data[hi-1] != '\n' {
+				hi++
+			}
+		}
+		lo = hi
+		if n == 0 {
+			return lo, hi, nil
+		}
+		for ; hi < len(data); hi++ {
+			if data[hi] != '\n' {
+				continue
+			}
+			switch n--; n {
+			case 1:
+				lo = hi + 1
+			case 0:
+				return lo, hi + 1, nil
+			}
+		}
+
+	case '-':
+		if charOffset {
+			// Scan backward for bytes that are not UTF-8 continuation bytes.
+			pos := lo
+			for ; pos > 0 && n > 0; pos-- {
+				if data[pos]&0xc0 != 0x80 {
+					n--
+				}
+			}
+			if n == 0 {
+				return pos, pos, nil
+			}
+			break
+		}
+		// find earlier beginning of line
+		for lo > 0 && data[lo-1] != '\n' {
+			lo--
+		}
+		hi = lo
+		if n == 0 {
+			return lo, hi, nil
+		}
+		for ; lo >= 0; lo-- {
+			if lo > 0 && data[lo-1] != '\n' {
+				continue
+			}
+			switch n--; n {
+			case 1:
+				hi = lo
+			case 0:
+				return lo, hi, nil
+			}
+		}
+	}
+
+	return 0, 0, errors.New("address out of range")
+}
+
+// addrRegexp searches for pattern in the given direction starting at lo, hi.
+// The direction dir is '+' (search forward from hi) or '-' (search backward from lo).
+// Backward searches are unimplemented.
+func addrRegexp(data []byte, lo, hi int, dir byte, pattern string) (int, int, error) {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return 0, 0, err
+	}
+	if dir == '-' {
+		// Could implement reverse search using binary search
+		// through file, but that seems like overkill.
+		return 0, 0, errors.New("reverse search not implemented")
+	}
+	m := re.FindIndex(data[hi:])
+	if len(m) > 0 {
+		m[0] += hi
+		m[1] += hi
+	} else if hi > 0 {
+		// No match.  Wrap to beginning of data.
+		m = re.FindIndex(data)
+	}
+	if len(m) == 0 {
+		return 0, 0, errors.New("no match for " + pattern)
+	}
+	return m[0], m[1], nil
+}
+
+// lineToByte returns the byte index of the first byte of line n.
+// Line numbers begin at 1.
+func lineToByte(data []byte, n int) int {
+	if n <= 1 {
+		return 0
+	}
+	n--
+	for i, c := range data {
+		if c == '\n' {
+			if n--; n == 0 {
+				return i + 1
+			}
+		}
+	}
+	return len(data)
+}
+
+// byteToLine returns the number of the line containing the byte at index i.
+func byteToLine(data []byte, i int) int {
+	l := 1
+	for j, c := range data {
+		if j == i {
+			return l
+		}
+		if c == '\n' {
+			l++
+		}
+	}
+	return l
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/dl.go b/vendor/golang.org/x/tools/cmd/godoc/dl.go
new file mode 100644
index 0000000..40e6658
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/dl.go
@@ -0,0 +1,16 @@
+// 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.
+
+// +build !appengine
+
+package main
+
+import "net/http"
+
+// Register a redirect handler for /dl/ to the golang.org download page.
+// This file will not be included when deploying godoc to golang.org.
+
+func init() {
+	http.Handle("/dl/", http.RedirectHandler("https://golang.org/dl/", http.StatusFound))
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/doc.go b/vendor/golang.org/x/tools/cmd/godoc/doc.go
new file mode 100644
index 0000000..e756093
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/doc.go
@@ -0,0 +1,153 @@
+// Copyright 2009 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.
+
+/*
+
+Godoc extracts and generates documentation for Go programs.
+
+It has two modes.
+
+Without the -http flag, it runs in command-line mode and prints plain text
+documentation to standard output and exits. If both a library package and
+a command with the same name exists, using the prefix cmd/ will force
+documentation on the command rather than the library package. If the -src
+flag is specified, godoc prints the exported interface of a package in Go
+source form, or the implementation of a specific exported language entity:
+
+	godoc fmt                # documentation for package fmt
+	godoc fmt Printf         # documentation for fmt.Printf
+	godoc cmd/go             # force documentation for the go command
+	godoc -src fmt           # fmt package interface in Go source form
+	godoc -src fmt Printf    # implementation of fmt.Printf
+
+In command-line mode, the -q flag enables search queries against a godoc running
+as a webserver. If no explicit server address is specified with the -server flag,
+godoc first tries localhost:6060 and then http://golang.org.
+
+	godoc -q Reader
+	godoc -q math.Sin
+	godoc -server=:6060 -q sin
+
+With the -http flag, it runs as a web server and presents the documentation as a
+web page.
+
+	godoc -http=:6060
+
+Usage:
+
+	godoc [flag] package [name ...]
+
+The flags are:
+
+	-v
+		verbose mode
+	-q
+		arguments are considered search queries: a legal query is a
+		single identifier (such as ToLower) or a qualified identifier
+		(such as math.Sin)
+	-src
+		print (exported) source in command-line mode
+	-tabwidth=4
+		width of tabs in units of spaces
+	-timestamps=true
+		show timestamps with directory listings
+	-index
+		enable identifier and full text search index
+		(no search box is shown if -index is not set)
+	-index_files=""
+		glob pattern specifying index files; if not empty,
+		the index is read from these files in sorted order
+	-index_throttle=0.75
+		index throttle value; a value of 0 means no time is allocated
+		to the indexer (the indexer will never finish), a value of 1.0
+		means that index creation is running at full throttle (other
+		goroutines may get no time while the index is built)
+	-links=true:
+		link identifiers to their declarations
+	-write_index=false
+		write index to a file; the file name must be specified with
+		-index_files
+	-maxresults=10000
+		maximum number of full text search results shown
+		(no full text index is built if maxresults <= 0)
+	-notes="BUG"
+		regular expression matching note markers to show
+		(e.g., "BUG|TODO", ".*")
+	-html
+		print HTML in command-line mode
+	-goroot=$GOROOT
+		Go root directory
+	-http=addr
+		HTTP service address (e.g., '127.0.0.1:6060' or just ':6060')
+	-server=addr
+		webserver address for command line searches
+	-analysis=type,pointer
+		comma-separated list of analyses to perform
+		"type": display identifier resolution, type info, method sets,
+			'implements', and static callees
+		"pointer": display channel peers, callers and dynamic callees
+			(significantly slower)
+		See http://golang.org/lib/godoc/analysis/help.html for details.
+	-templates=""
+		directory containing alternate template files; if set,
+		the directory may provide alternative template files
+		for the files in $GOROOT/lib/godoc
+	-url=path
+		print to standard output the data that would be served by
+		an HTTP request for path
+	-zip=""
+		zip file providing the file system to serve; disabled if empty
+
+By default, godoc looks at the packages it finds via $GOROOT and $GOPATH (if set).
+This behavior can be altered by providing an alternative $GOROOT with the -goroot
+flag.
+
+When godoc runs as a web server and -index is set, a search index is maintained.
+The index is created at startup.
+
+The index contains both identifier and full text search information (searchable
+via regular expressions). The maximum number of full text search results shown
+can be set with the -maxresults flag; if set to 0, no full text results are
+shown, and only an identifier index but no full text search index is created.
+
+By default, godoc uses the system's GOOS/GOARCH; in command-line mode you can
+set the GOOS/GOARCH environment variables to get output for the system specified.
+If -http was specified you can provide the URL parameters "GOOS" and "GOARCH"
+to set the output on the web page.
+
+The presentation mode of web pages served by godoc can be controlled with the
+"m" URL parameter; it accepts a comma-separated list of flag names as value:
+
+	all	show documentation for all declarations, not just the exported ones
+	methods	show all embedded methods, not just those of unexported anonymous fields
+	src	show the original source code rather then the extracted documentation
+	text	present the page in textual (command-line) form rather than HTML
+	flat	present flat (not indented) directory listings using full paths
+
+For instance, http://golang.org/pkg/math/big/?m=all,text shows the documentation
+for all (not just the exported) declarations of package big, in textual form (as
+it would appear when using godoc from the command line: "godoc -src math/big .*").
+
+By default, godoc serves files from the file system of the underlying OS.
+Instead, a .zip file may be provided via the -zip flag, which contains
+the file system to serve. The file paths stored in the .zip file must use
+slash ('/') as path separator; and they must be unrooted. $GOROOT (or -goroot)
+must be set to the .zip file directory path containing the Go root directory.
+For instance, for a .zip file created by the command:
+
+	zip -r go.zip $HOME/go
+
+one may run godoc as follows:
+
+	godoc -http=:6060 -zip=go.zip -goroot=$HOME/go
+
+Godoc documentation is converted to HTML or to text using the go/doc package;
+see http://golang.org/pkg/go/doc/#ToHTML for the exact rules.
+Godoc also shows example code that is runnable by the testing package;
+see http://golang.org/pkg/testing/#hdr-Examples for the conventions.
+See "Godoc: documenting Go code" for how to write good comments for godoc:
+http://golang.org/doc/articles/godoc_documenting_go_code.html
+
+*/
+package main // import "golang.org/x/tools/cmd/godoc"
diff --git a/vendor/golang.org/x/tools/cmd/godoc/godoc19_test.go b/vendor/golang.org/x/tools/cmd/godoc/godoc19_test.go
new file mode 100644
index 0000000..655a623
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/godoc19_test.go
@@ -0,0 +1,9 @@
+// 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_test
+
+func init() { isGo19 = true }
diff --git a/vendor/golang.org/x/tools/cmd/godoc/godoc_test.go b/vendor/golang.org/x/tools/cmd/godoc/godoc_test.go
new file mode 100644
index 0000000..a2552d9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/godoc_test.go
@@ -0,0 +1,489 @@
+// 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_test
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// buildGodoc builds the godoc executable.
+// It returns its path, and a cleanup function.
+//
+// TODO(adonovan): opt: do this at most once, and do the cleanup
+// exactly once.  How though?  There's no atexit.
+func buildGodoc(t *testing.T) (bin string, cleanup func()) {
+	if runtime.GOARCH == "arm" {
+		t.Skip("skipping test on arm platforms; too slow")
+	}
+	tmp, err := ioutil.TempDir("", "godoc-regtest-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		if cleanup == nil { // probably, go build failed.
+			os.RemoveAll(tmp)
+		}
+	}()
+
+	bin = filepath.Join(tmp, "godoc")
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+	cmd := exec.Command("go", "build", "-o", bin)
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("Building godoc: %v", err)
+	}
+
+	return bin, func() { os.RemoveAll(tmp) }
+}
+
+var isGo19 bool // godoc19_test.go sets it to true.
+
+// Basic regression test for godoc command-line tool.
+func TestCLI(t *testing.T) {
+	bin, cleanup := buildGodoc(t)
+	defer cleanup()
+
+	// condStr returns s if cond is true, otherwise empty string.
+	condStr := func(cond bool, s string) string {
+		if !cond {
+			return ""
+		}
+		return s
+	}
+
+	tests := []struct {
+		args      []string
+		matches   []string // regular expressions
+		dontmatch []string // regular expressions
+	}{
+		{
+			args: []string{"fmt"},
+			matches: []string{
+				`import "fmt"`,
+				`Package fmt implements formatted I/O`,
+			},
+		},
+		{
+			args: []string{"io", "WriteString"},
+			matches: []string{
+				`func WriteString\(`,
+				`WriteString writes the contents of the string s to w`,
+			},
+		},
+		{
+			args: []string{"nonexistingpkg"},
+			matches: []string{
+				`cannot find package` +
+					// TODO: Remove this when support for Go 1.8 is dropped.
+					condStr(!isGo19,
+						// For Go 1.8 and older, because it doesn't have CL 33158 change applied to go/build.
+						// The last pattern (does not e) is for plan9:
+						// http://build.golang.org/log/2d8e5e14ed365bfa434b37ec0338cd9e6f8dd9bf
+						`|no such file or directory|does not exist|cannot find the file|(?:' does not e)`),
+			},
+		},
+		{
+			args: []string{"fmt", "NonexistentSymbol"},
+			matches: []string{
+				`No match found\.`,
+			},
+		},
+		{
+			args: []string{"-src", "syscall", "Open"},
+			matches: []string{
+				`func Open\(`,
+			},
+			dontmatch: []string{
+				`No match found\.`,
+			},
+		},
+	}
+	for _, test := range tests {
+		cmd := exec.Command(bin, test.args...)
+		cmd.Args[0] = "godoc"
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Errorf("Running with args %#v: %v", test.args, err)
+			continue
+		}
+		for _, pat := range test.matches {
+			re := regexp.MustCompile(pat)
+			if !re.Match(out) {
+				t.Errorf("godoc %v =\n%s\nwanted /%v/", strings.Join(test.args, " "), out, pat)
+			}
+		}
+		for _, pat := range test.dontmatch {
+			re := regexp.MustCompile(pat)
+			if re.Match(out) {
+				t.Errorf("godoc %v =\n%s\ndid not want /%v/", strings.Join(test.args, " "), out, pat)
+			}
+		}
+	}
+}
+
+func serverAddress(t *testing.T) string {
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		ln, err = net.Listen("tcp6", "[::1]:0")
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln.Close()
+	return ln.Addr().String()
+}
+
+func waitForServerReady(t *testing.T, addr string) {
+	waitForServer(t,
+		fmt.Sprintf("http://%v/", addr),
+		"The Go Programming Language",
+		15*time.Second,
+		false)
+}
+
+func waitForSearchReady(t *testing.T, addr string) {
+	waitForServer(t,
+		fmt.Sprintf("http://%v/search?q=FALLTHROUGH", addr),
+		"The list of tokens.",
+		2*time.Minute,
+		false)
+}
+
+func waitUntilScanComplete(t *testing.T, addr string) {
+	waitForServer(t,
+		fmt.Sprintf("http://%v/pkg", addr),
+		"Scan is not yet complete",
+		2*time.Minute,
+		true,
+	)
+	// setting reverse as true, which means this waits
+	// until the string is not returned in the response anymore
+}
+
+const pollInterval = 200 * time.Millisecond
+
+func waitForServer(t *testing.T, url, match string, timeout time.Duration, reverse bool) {
+	// "health check" duplicated from x/tools/cmd/tipgodoc/tip.go
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		time.Sleep(pollInterval)
+		res, err := http.Get(url)
+		if err != nil {
+			continue
+		}
+		rbody, err := ioutil.ReadAll(res.Body)
+		res.Body.Close()
+		if err == nil && res.StatusCode == http.StatusOK {
+			if bytes.Contains(rbody, []byte(match)) && !reverse {
+				return
+			}
+			if !bytes.Contains(rbody, []byte(match)) && reverse {
+				return
+			}
+		}
+	}
+	t.Fatalf("Server failed to respond in %v", timeout)
+}
+
+func killAndWait(cmd *exec.Cmd) {
+	cmd.Process.Kill()
+	cmd.Wait()
+}
+
+// Basic integration test for godoc HTTP interface.
+func TestWeb(t *testing.T) {
+	testWeb(t, false)
+}
+
+// Basic integration test for godoc HTTP interface.
+func TestWebIndex(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in -short mode")
+	}
+	testWeb(t, true)
+}
+
+// Basic integration test for godoc HTTP interface.
+func testWeb(t *testing.T, withIndex bool) {
+	if runtime.GOOS == "plan9" {
+		t.Skip("skipping on plan9; files to start up quickly enough")
+	}
+	bin, cleanup := buildGodoc(t)
+	defer cleanup()
+	addr := serverAddress(t)
+	args := []string{fmt.Sprintf("-http=%s", addr)}
+	if withIndex {
+		args = append(args, "-index", "-index_interval=-1s")
+	}
+	cmd := exec.Command(bin, args...)
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	cmd.Args[0] = "godoc"
+	cmd.Env = godocEnv()
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("failed to start godoc: %s", err)
+	}
+	defer killAndWait(cmd)
+
+	if withIndex {
+		waitForSearchReady(t, addr)
+	} else {
+		waitForServerReady(t, addr)
+		waitUntilScanComplete(t, addr)
+	}
+
+	tests := []struct {
+		path      string
+		match     []string
+		dontmatch []string
+		needIndex bool
+	}{
+		{
+			path:  "/",
+			match: []string{"Go is an open source programming language"},
+		},
+		{
+			path:  "/pkg/fmt/",
+			match: []string{"Package fmt implements formatted I/O"},
+		},
+		{
+			path:  "/src/fmt/",
+			match: []string{"scan_test.go"},
+		},
+		{
+			path:  "/src/fmt/print.go",
+			match: []string{"// Println formats using"},
+		},
+		{
+			path: "/pkg",
+			match: []string{
+				"Standard library",
+				"Package fmt implements formatted I/O",
+			},
+			dontmatch: []string{
+				"internal/syscall",
+				"cmd/gc",
+			},
+		},
+		{
+			path: "/pkg/?m=all",
+			match: []string{
+				"Standard library",
+				"Package fmt implements formatted I/O",
+				"internal/syscall/?m=all",
+			},
+			dontmatch: []string{
+				"cmd/gc",
+			},
+		},
+		{
+			path: "/search?q=ListenAndServe",
+			match: []string{
+				"/src",
+			},
+			dontmatch: []string{
+				"/pkg/bootstrap",
+			},
+			needIndex: true,
+		},
+		{
+			path: "/pkg/strings/",
+			match: []string{
+				`href="/src/strings/strings.go"`,
+			},
+		},
+		{
+			path: "/cmd/compile/internal/amd64/",
+			match: []string{
+				`href="/src/cmd/compile/internal/amd64/ssa.go"`,
+			},
+		},
+	}
+	for _, test := range tests {
+		if test.needIndex && !withIndex {
+			continue
+		}
+		url := fmt.Sprintf("http://%s%s", addr, test.path)
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Errorf("GET %s failed: %s", url, err)
+			continue
+		}
+		body, err := ioutil.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			t.Errorf("GET %s: failed to read body: %s (response: %v)", url, err, resp)
+		}
+		isErr := false
+		for _, substr := range test.match {
+			if !bytes.Contains(body, []byte(substr)) {
+				t.Errorf("GET %s: wanted substring %q in body", url, substr)
+				isErr = true
+			}
+		}
+		for _, substr := range test.dontmatch {
+			if bytes.Contains(body, []byte(substr)) {
+				t.Errorf("GET %s: didn't want substring %q in body", url, substr)
+				isErr = true
+			}
+		}
+		if isErr {
+			t.Errorf("GET %s: got:\n%s", url, body)
+		}
+	}
+}
+
+// Basic integration test for godoc -analysis=type (via HTTP interface).
+func TestTypeAnalysis(t *testing.T) {
+	if runtime.GOOS == "plan9" {
+		t.Skip("skipping test on plan9 (issue #11974)") // see comment re: Plan 9 below
+	}
+
+	// Write a fake GOROOT/GOPATH.
+	tmpdir, err := ioutil.TempDir("", "godoc-analysis")
+	if err != nil {
+		t.Fatalf("ioutil.TempDir failed: %s", err)
+	}
+	defer os.RemoveAll(tmpdir)
+	for _, f := range []struct{ file, content string }{
+		{"goroot/src/lib/lib.go", `
+package lib
+type T struct{}
+const C = 3
+var V T
+func (T) F() int { return C }
+`},
+		{"gopath/src/app/main.go", `
+package main
+import "lib"
+func main() { print(lib.V) }
+`},
+	} {
+		file := filepath.Join(tmpdir, f.file)
+		if err := os.MkdirAll(filepath.Dir(file), 0755); err != nil {
+			t.Fatalf("MkdirAll(%s) failed: %s", filepath.Dir(file), err)
+		}
+		if err := ioutil.WriteFile(file, []byte(f.content), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// Start the server.
+	bin, cleanup := buildGodoc(t)
+	defer cleanup()
+	addr := serverAddress(t)
+	cmd := exec.Command(bin, fmt.Sprintf("-http=%s", addr), "-analysis=type")
+	cmd.Env = append(cmd.Env, fmt.Sprintf("GOROOT=%s", filepath.Join(tmpdir, "goroot")))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("GOPATH=%s", filepath.Join(tmpdir, "gopath")))
+	for _, e := range os.Environ() {
+		if strings.HasPrefix(e, "GOROOT=") || strings.HasPrefix(e, "GOPATH=") {
+			continue
+		}
+		cmd.Env = append(cmd.Env, e)
+	}
+	cmd.Stdout = os.Stderr
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmd.Args[0] = "godoc"
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("failed to start godoc: %s", err)
+	}
+	defer killAndWait(cmd)
+	waitForServerReady(t, addr)
+
+	// Wait for type analysis to complete.
+	reader := bufio.NewReader(stderr)
+	for {
+		s, err := reader.ReadString('\n') // on Plan 9 this fails
+		if err != nil {
+			t.Fatal(err)
+		}
+		fmt.Fprint(os.Stderr, s)
+		if strings.Contains(s, "Type analysis complete.") {
+			break
+		}
+	}
+	go io.Copy(os.Stderr, reader)
+
+	t0 := time.Now()
+
+	// Make an HTTP request and check for a regular expression match.
+	// The patterns are very crude checks that basic type information
+	// has been annotated onto the source view.
+tryagain:
+	for _, test := range []struct{ url, pattern string }{
+		{"/src/lib/lib.go", "L2.*package .*Package docs for lib.*/lib"},
+		{"/src/lib/lib.go", "L3.*type .*type info for T.*struct"},
+		{"/src/lib/lib.go", "L5.*var V .*type T struct"},
+		{"/src/lib/lib.go", "L6.*func .*type T struct.*T.*return .*const C untyped int.*C"},
+
+		{"/src/app/main.go", "L2.*package .*Package docs for app"},
+		{"/src/app/main.go", "L3.*import .*Package docs for lib.*lib"},
+		{"/src/app/main.go", "L4.*func main.*package lib.*lib.*var lib.V lib.T.*V"},
+	} {
+		url := fmt.Sprintf("http://%s%s", addr, test.url)
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Errorf("GET %s failed: %s", url, err)
+			continue
+		}
+		body, err := ioutil.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			t.Errorf("GET %s: failed to read body: %s (response: %v)", url, err, resp)
+			continue
+		}
+
+		if !bytes.Contains(body, []byte("Static analysis features")) {
+			// Type analysis results usually become available within
+			// ~4ms after godoc startup (for this input on my machine).
+			if elapsed := time.Since(t0); elapsed > 500*time.Millisecond {
+				t.Fatalf("type analysis results still unavailable after %s", elapsed)
+			}
+			time.Sleep(10 * time.Millisecond)
+			goto tryagain
+		}
+
+		match, err := regexp.Match(test.pattern, body)
+		if err != nil {
+			t.Errorf("regexp.Match(%q) failed: %s", test.pattern, err)
+			continue
+		}
+		if !match {
+			// This is a really ugly failure message.
+			t.Errorf("GET %s: body doesn't match %q, got:\n%s",
+				url, test.pattern, string(body))
+		}
+	}
+}
+
+// godocEnv returns the process environment without the GOPATH variable.
+// (We don't want the indexer looking at the local workspace during tests.)
+func godocEnv() (env []string) {
+	for _, v := range os.Environ() {
+		if strings.HasPrefix(v, "GOPATH=") {
+			continue
+		}
+		env = append(env, v)
+	}
+	return
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/handlers.go b/vendor/golang.org/x/tools/cmd/godoc/handlers.go
new file mode 100644
index 0000000..6691ed7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/handlers.go
@@ -0,0 +1,148 @@
+// Copyright 2010 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.
+
+// The /doc/codewalk/ tree is synthesized from codewalk descriptions,
+// files named $GOROOT/doc/codewalk/*.xml.
+// For an example and a description of the format, see
+// http://golang.org/doc/codewalk/codewalk or run godoc -http=:6060
+// and see http://localhost:6060/doc/codewalk/codewalk .
+// That page is itself a codewalk; the source code for it is
+// $GOROOT/doc/codewalk/codewalk.xml.
+
+package main
+
+import (
+	"encoding/json"
+	"go/format"
+	"log"
+	"net/http"
+	"strings"
+	"text/template"
+
+	"golang.org/x/tools/godoc"
+	"golang.org/x/tools/godoc/redirect"
+	"golang.org/x/tools/godoc/vfs"
+)
+
+var (
+	pres *godoc.Presentation
+	fs   = vfs.NameSpace{}
+)
+
+var enforceHosts = false // set true in production on app engine
+
+// hostEnforcerHandler redirects requests to "http://foo.golang.org/bar"
+// to "https://golang.org/bar".
+// It permits requests to the host "godoc-test.golang.org" for testing and
+// golang.google.cn for Chinese users.
+type hostEnforcerHandler struct {
+	h http.Handler
+}
+
+func (h hostEnforcerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if !enforceHosts {
+		h.h.ServeHTTP(w, r)
+		return
+	}
+	if r.TLS == nil || !h.validHost(r.Host) {
+		r.URL.Scheme = "https"
+		if h.validHost(r.Host) {
+			r.URL.Host = r.Host
+		} else {
+			r.URL.Host = "golang.org"
+		}
+		http.Redirect(w, r, r.URL.String(), http.StatusFound)
+		return
+	}
+	w.Header().Set("Strict-Transport-Security", "max-age=31536000; preload")
+	h.h.ServeHTTP(w, r)
+}
+
+func (h hostEnforcerHandler) validHost(host string) bool {
+	switch strings.ToLower(host) {
+	case "golang.org", "godoc-test.golang.org", "golang.google.cn":
+		return true
+	}
+	return false
+}
+
+func registerHandlers(pres *godoc.Presentation) *http.ServeMux {
+	if pres == nil {
+		panic("nil Presentation")
+	}
+	mux := http.NewServeMux()
+	mux.HandleFunc("/doc/codewalk/", codewalk)
+	mux.Handle("/doc/play/", pres.FileServer())
+	mux.Handle("/robots.txt", pres.FileServer())
+	mux.Handle("/", pres)
+	mux.Handle("/pkg/C/", redirect.Handler("/cmd/cgo/"))
+	mux.HandleFunc("/fmt", fmtHandler)
+	redirect.Register(mux)
+
+	http.Handle("/", hostEnforcerHandler{mux})
+
+	return mux
+}
+
+func readTemplate(name string) *template.Template {
+	if pres == nil {
+		panic("no global Presentation set yet")
+	}
+	path := "lib/godoc/" + name
+
+	// use underlying file system fs to read the template file
+	// (cannot use template ParseFile functions directly)
+	data, err := vfs.ReadFile(fs, path)
+	if err != nil {
+		log.Fatal("readTemplate: ", err)
+	}
+	// be explicit with errors (for app engine use)
+	t, err := template.New(name).Funcs(pres.FuncMap()).Parse(string(data))
+	if err != nil {
+		log.Fatal("readTemplate: ", err)
+	}
+	return t
+}
+
+func readTemplates(p *godoc.Presentation, html bool) {
+	p.PackageText = readTemplate("package.txt")
+	p.SearchText = readTemplate("search.txt")
+
+	if html || p.HTMLMode {
+		codewalkHTML = readTemplate("codewalk.html")
+		codewalkdirHTML = readTemplate("codewalkdir.html")
+		p.CallGraphHTML = readTemplate("callgraph.html")
+		p.DirlistHTML = readTemplate("dirlist.html")
+		p.ErrorHTML = readTemplate("error.html")
+		p.ExampleHTML = readTemplate("example.html")
+		p.GodocHTML = readTemplate("godoc.html")
+		p.ImplementsHTML = readTemplate("implements.html")
+		p.MethodSetHTML = readTemplate("methodset.html")
+		p.PackageHTML = readTemplate("package.html")
+		p.SearchHTML = readTemplate("search.html")
+		p.SearchDocHTML = readTemplate("searchdoc.html")
+		p.SearchCodeHTML = readTemplate("searchcode.html")
+		p.SearchTxtHTML = readTemplate("searchtxt.html")
+		p.SearchDescXML = readTemplate("opensearch.xml")
+	}
+}
+
+type fmtResponse struct {
+	Body  string
+	Error string
+}
+
+// fmtHandler takes a Go program in its "body" form value, formats it with
+// standard gofmt formatting, and writes a fmtResponse as a JSON object.
+func fmtHandler(w http.ResponseWriter, r *http.Request) {
+	resp := new(fmtResponse)
+	body, err := format.Source([]byte(r.FormValue("body")))
+	if err != nil {
+		resp.Error = err.Error()
+	} else {
+		resp.Body = string(body)
+	}
+	w.Header().Set("Content-type", "application/json; charset=utf-8")
+	json.NewEncoder(w).Encode(resp)
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/index.go b/vendor/golang.org/x/tools/cmd/godoc/index.go
new file mode 100644
index 0000000..f84b29a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/index.go
@@ -0,0 +1,11 @@
+// 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 main
+
+import "strings"
+
+func indexDirectoryDefault(dir string) bool {
+	return dir != "/pkg" && !strings.HasPrefix(dir, "/pkg/")
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/main.go b/vendor/golang.org/x/tools/cmd/godoc/main.go
new file mode 100644
index 0000000..901e992
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/main.go
@@ -0,0 +1,357 @@
+// Copyright 2009 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.
+
+// godoc: Go Documentation Server
+
+// Web server tree:
+//
+//	http://godoc/		main landing page
+//	http://godoc/doc/	serve from $GOROOT/doc - spec, mem, etc.
+//	http://godoc/src/	serve files from $GOROOT/src; .go gets pretty-printed
+//	http://godoc/cmd/	serve documentation about commands
+//	http://godoc/pkg/	serve documentation about packages
+//				(idea is if you say import "compress/zlib", you go to
+//				http://godoc/pkg/compress/zlib)
+//
+// Command-line interface:
+//
+//	godoc packagepath [name ...]
+//
+//	godoc compress/zlib
+//		- prints doc for package compress/zlib
+//	godoc crypto/block Cipher NewCMAC
+//		- prints doc for Cipher and NewCMAC in package crypto/block
+
+// +build !appengine
+
+package main
+
+import (
+	"archive/zip"
+	_ "expvar" // to serve /debug/vars
+	"flag"
+	"fmt"
+	"go/build"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	_ "net/http/pprof" // to serve /debug/pprof/*
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+
+	"golang.org/x/tools/godoc"
+	"golang.org/x/tools/godoc/analysis"
+	"golang.org/x/tools/godoc/static"
+	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/godoc/vfs/gatefs"
+	"golang.org/x/tools/godoc/vfs/mapfs"
+	"golang.org/x/tools/godoc/vfs/zipfs"
+)
+
+const defaultAddr = ":6060" // default webserver address
+
+var (
+	// file system to serve
+	// (with e.g.: zip -r go.zip $GOROOT -i \*.go -i \*.html -i \*.css -i \*.js -i \*.txt -i \*.c -i \*.h -i \*.s -i \*.png -i \*.jpg -i \*.sh -i favicon.ico)
+	zipfile = flag.String("zip", "", "zip file providing the file system to serve; disabled if empty")
+
+	// file-based index
+	writeIndex = flag.Bool("write_index", false, "write index to a file; the file name must be specified with -index_files")
+
+	analysisFlag = flag.String("analysis", "", `comma-separated list of analyses to perform (supported: type, pointer). See http://golang.org/lib/godoc/analysis/help.html`)
+
+	// network
+	httpAddr   = flag.String("http", "", "HTTP service address (e.g., '"+defaultAddr+"')")
+	serverAddr = flag.String("server", "", "webserver address for command line searches")
+
+	// layout control
+	html    = flag.Bool("html", false, "print HTML in command-line mode")
+	srcMode = flag.Bool("src", false, "print (exported) source in command-line mode")
+	urlFlag = flag.String("url", "", "print HTML for named URL")
+
+	// command-line searches
+	query = flag.Bool("q", false, "arguments are considered search queries")
+
+	verbose = flag.Bool("v", false, "verbose mode")
+
+	// file system roots
+	// TODO(gri) consider the invariant that goroot always end in '/'
+	goroot = flag.String("goroot", runtime.GOROOT(), "Go root directory")
+
+	// layout control
+	tabWidth       = flag.Int("tabwidth", 4, "tab width")
+	showTimestamps = flag.Bool("timestamps", false, "show timestamps with directory listings")
+	templateDir    = flag.String("templates", "", "load templates/JS/CSS from disk in this directory")
+	showPlayground = flag.Bool("play", false, "enable playground in web interface")
+	showExamples   = flag.Bool("ex", false, "show examples in command line mode")
+	declLinks      = flag.Bool("links", true, "link identifiers to their declarations")
+
+	// search index
+	indexEnabled  = flag.Bool("index", false, "enable search index")
+	indexFiles    = flag.String("index_files", "", "glob pattern specifying index files; if not empty, the index is read from these files in sorted order")
+	indexInterval = flag.Duration("index_interval", 0, "interval of indexing; 0 for default (5m), negative to only index once at startup")
+	maxResults    = flag.Int("maxresults", 10000, "maximum number of full text search results shown")
+	indexThrottle = flag.Float64("index_throttle", 0.75, "index throttle value; 0.0 = no time allocated, 1.0 = full throttle")
+
+	// source code notes
+	notesRx = flag.String("notes", "BUG", "regular expression matching note markers to show")
+)
+
+func usage() {
+	fmt.Fprintf(os.Stderr,
+		"usage: godoc package [name ...]\n"+
+			"	godoc -http="+defaultAddr+"\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func loggingHandler(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		log.Printf("%s\t%s", req.RemoteAddr, req.URL)
+		h.ServeHTTP(w, req)
+	})
+}
+
+func handleURLFlag() {
+	// Try up to 10 fetches, following redirects.
+	urlstr := *urlFlag
+	for i := 0; i < 10; i++ {
+		// Prepare request.
+		u, err := url.Parse(urlstr)
+		if err != nil {
+			log.Fatal(err)
+		}
+		req := &http.Request{
+			URL: u,
+		}
+
+		// Invoke default HTTP handler to serve request
+		// to our buffering httpWriter.
+		w := httptest.NewRecorder()
+		http.DefaultServeMux.ServeHTTP(w, req)
+
+		// Return data, error, or follow redirect.
+		switch w.Code {
+		case 200: // ok
+			os.Stdout.Write(w.Body.Bytes())
+			return
+		case 301, 302, 303, 307: // redirect
+			redirect := w.HeaderMap.Get("Location")
+			if redirect == "" {
+				log.Fatalf("HTTP %d without Location header", w.Code)
+			}
+			urlstr = redirect
+		default:
+			log.Fatalf("HTTP error %d", w.Code)
+		}
+	}
+	log.Fatalf("too many redirects")
+}
+
+func initCorpus(corpus *godoc.Corpus) {
+	err := corpus.Init()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	playEnabled = *showPlayground
+
+	// Check usage: server and no args.
+	if (*httpAddr != "" || *urlFlag != "") && (flag.NArg() > 0) {
+		fmt.Fprintln(os.Stderr, "can't use -http with args.")
+		usage()
+	}
+
+	// Check usage: command line args or index creation mode.
+	if (*httpAddr != "" || *urlFlag != "") != (flag.NArg() == 0) && !*writeIndex {
+		fmt.Fprintln(os.Stderr, "missing args.")
+		usage()
+	}
+
+	var fsGate chan bool
+	fsGate = make(chan bool, 20)
+
+	// Determine file system to use.
+	if *zipfile == "" {
+		// use file system of underlying OS
+		rootfs := gatefs.New(vfs.OS(*goroot), fsGate)
+		fs.Bind("/", rootfs, "/", vfs.BindReplace)
+	} else {
+		// use file system specified via .zip file (path separator must be '/')
+		rc, err := zip.OpenReader(*zipfile)
+		if err != nil {
+			log.Fatalf("%s: %s\n", *zipfile, err)
+		}
+		defer rc.Close() // be nice (e.g., -writeIndex mode)
+		fs.Bind("/", zipfs.New(rc, *zipfile), *goroot, vfs.BindReplace)
+	}
+	if *templateDir != "" {
+		fs.Bind("/lib/godoc", vfs.OS(*templateDir), "/", vfs.BindBefore)
+	} else {
+		fs.Bind("/lib/godoc", mapfs.New(static.Files), "/", vfs.BindReplace)
+	}
+
+	// Bind $GOPATH trees into Go root.
+	for _, p := range filepath.SplitList(build.Default.GOPATH) {
+		fs.Bind("/src", gatefs.New(vfs.OS(p), fsGate), "/src", vfs.BindAfter)
+	}
+
+	httpMode := *httpAddr != ""
+
+	var typeAnalysis, pointerAnalysis bool
+	if *analysisFlag != "" {
+		for _, a := range strings.Split(*analysisFlag, ",") {
+			switch a {
+			case "type":
+				typeAnalysis = true
+			case "pointer":
+				pointerAnalysis = true
+			default:
+				log.Fatalf("unknown analysis: %s", a)
+			}
+		}
+	}
+
+	corpus := godoc.NewCorpus(fs)
+	corpus.Verbose = *verbose
+	corpus.MaxResults = *maxResults
+	corpus.IndexEnabled = *indexEnabled && httpMode
+	if *maxResults == 0 {
+		corpus.IndexFullText = false
+	}
+	corpus.IndexFiles = *indexFiles
+	corpus.IndexDirectory = indexDirectoryDefault
+	corpus.IndexThrottle = *indexThrottle
+	corpus.IndexInterval = *indexInterval
+	if *writeIndex {
+		corpus.IndexThrottle = 1.0
+		corpus.IndexEnabled = true
+	}
+	if *writeIndex || httpMode || *urlFlag != "" {
+		if httpMode {
+			go initCorpus(corpus)
+		} else {
+			initCorpus(corpus)
+		}
+	}
+
+	pres = godoc.NewPresentation(corpus)
+	pres.TabWidth = *tabWidth
+	pres.ShowTimestamps = *showTimestamps
+	pres.ShowPlayground = *showPlayground
+	pres.ShowExamples = *showExamples
+	pres.DeclLinks = *declLinks
+	pres.SrcMode = *srcMode
+	pres.HTMLMode = *html
+	if *notesRx != "" {
+		pres.NotesRx = regexp.MustCompile(*notesRx)
+	}
+
+	readTemplates(pres, httpMode || *urlFlag != "")
+	registerHandlers(pres)
+
+	if *writeIndex {
+		// Write search index and exit.
+		if *indexFiles == "" {
+			log.Fatal("no index file specified")
+		}
+
+		log.Println("initialize file systems")
+		*verbose = true // want to see what happens
+
+		corpus.UpdateIndex()
+
+		log.Println("writing index file", *indexFiles)
+		f, err := os.Create(*indexFiles)
+		if err != nil {
+			log.Fatal(err)
+		}
+		index, _ := corpus.CurrentIndex()
+		_, err = index.WriteTo(f)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Println("done")
+		return
+	}
+
+	// Print content that would be served at the URL *urlFlag.
+	if *urlFlag != "" {
+		handleURLFlag()
+		return
+	}
+
+	if httpMode {
+		// HTTP server mode.
+		var handler http.Handler = http.DefaultServeMux
+		if *verbose {
+			log.Printf("Go Documentation Server")
+			log.Printf("version = %s", runtime.Version())
+			log.Printf("address = %s", *httpAddr)
+			log.Printf("goroot = %s", *goroot)
+			log.Printf("tabwidth = %d", *tabWidth)
+			switch {
+			case !*indexEnabled:
+				log.Print("search index disabled")
+			case *maxResults > 0:
+				log.Printf("full text index enabled (maxresults = %d)", *maxResults)
+			default:
+				log.Print("identifier search index enabled")
+			}
+			fs.Fprint(os.Stderr)
+			handler = loggingHandler(handler)
+		}
+
+		// Initialize search index.
+		if *indexEnabled {
+			go corpus.RunIndexer()
+		}
+
+		// Start type/pointer analysis.
+		if typeAnalysis || pointerAnalysis {
+			go analysis.Run(pointerAnalysis, &corpus.Analysis)
+		}
+
+		if serveAutoCertHook != nil {
+			go func() {
+				if err := serveAutoCertHook(handler); err != nil {
+					log.Fatalf("ListenAndServe TLS: %v", err)
+				}
+			}()
+		}
+
+		// Start http server.
+		if *verbose {
+			log.Println("starting HTTP server")
+		}
+		if err := http.ListenAndServe(*httpAddr, handler); err != nil {
+			log.Fatalf("ListenAndServe %s: %v", *httpAddr, err)
+		}
+
+		return
+	}
+
+	if *query {
+		handleRemoteSearch()
+		return
+	}
+
+	if err := godoc.CommandLine(os.Stdout, fs, pres, flag.Args()); err != nil {
+		log.Print(err)
+	}
+}
+
+// serveAutoCertHook if non-nil specifies a function to listen on port 443.
+// See autocert.go.
+var serveAutoCertHook func(http.Handler) error
diff --git a/vendor/golang.org/x/tools/cmd/godoc/play.go b/vendor/golang.org/x/tools/cmd/godoc/play.go
new file mode 100644
index 0000000..02f477d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/play.go
@@ -0,0 +1,11 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package main
+
+// This package registers "/compile" and "/share" handlers
+// that redirect to the golang.org playground.
+import _ "golang.org/x/tools/playground"
diff --git a/vendor/golang.org/x/tools/cmd/godoc/remotesearch.go b/vendor/golang.org/x/tools/cmd/godoc/remotesearch.go
new file mode 100644
index 0000000..f01d5c7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/remotesearch.go
@@ -0,0 +1,72 @@
+// Copyright 2009 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
+
+package main
+
+import (
+	"errors"
+	"flag"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+)
+
+func handleRemoteSearch() {
+	// Command-line queries.
+	for i := 0; i < flag.NArg(); i++ {
+		res, err := remoteSearch(flag.Arg(i))
+		if err != nil {
+			log.Fatalf("remoteSearch: %s", err)
+		}
+		io.Copy(os.Stdout, res.Body)
+	}
+	return
+}
+
+// remoteSearchURL returns the search URL for a given query as needed by
+// remoteSearch. If html is set, an html result is requested; otherwise
+// the result is in textual form.
+// Adjust this function as necessary if modeNames or FormValue parameters
+// change.
+func remoteSearchURL(query string, html bool) string {
+	s := "/search?m=text&q="
+	if html {
+		s = "/search?q="
+	}
+	return s + url.QueryEscape(query)
+}
+
+func remoteSearch(query string) (res *http.Response, err error) {
+	// list of addresses to try
+	var addrs []string
+	if *serverAddr != "" {
+		// explicit server address - only try this one
+		addrs = []string{*serverAddr}
+	} else {
+		addrs = []string{
+			defaultAddr,
+			"golang.org",
+		}
+	}
+
+	// remote search
+	search := remoteSearchURL(query, *html)
+	for _, addr := range addrs {
+		url := "http://" + addr + search
+		res, err = http.Get(url)
+		if err == nil && res.StatusCode == http.StatusOK {
+			break
+		}
+	}
+
+	if err == nil && res.StatusCode != http.StatusOK {
+		err = errors.New(res.Status)
+	}
+
+	return
+}
diff --git a/vendor/golang.org/x/tools/cmd/godoc/setup-godoc-app.bash b/vendor/golang.org/x/tools/cmd/godoc/setup-godoc-app.bash
new file mode 100644
index 0000000..f227738
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/setup-godoc-app.bash
@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+
+# Copyright 2011 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# This script creates a complete godoc app in $APPDIR.
+# It copies the cmd/godoc and src/go/... sources from GOROOT,
+# synthesizes an app.yaml file, and creates the .zip, index, and
+# configuration files.
+#
+# If an argument is provided it is assumed to be the app-engine godoc directory.
+# Without an argument, $APPDIR is used instead. If GOROOT is not set, "go env"
+# is consulted to find the $GOROOT.
+#
+# The script creates a .zip file representing the $GOROOT file system
+# and computes the correspondig search index files. These files are then
+# copied to $APPDIR. A corresponding godoc configuration file is created
+# in $APPDIR/appconfig.go.
+
+ZIPFILE=godoc.zip
+INDEXFILE=godoc.index
+SPLITFILES=index.split.
+GODOC=golang.org/x/tools/cmd/godoc
+CONFIGFILE=$GODOC/appconfig.go
+
+error() {
+	echo "error: $1"
+	exit 2
+}
+
+getArgs() {
+	if [ -z $APPENGINE_SDK ]; then
+		error "APPENGINE_SDK environment variable not set"
+	fi
+	if [ ! -x $APPENGINE_SDK/goapp ]; then
+		error "couldn't find goapp command in $APPENGINE_SDK"
+	fi
+	if [ -z $GOROOT ]; then
+		GOROOT=$(go env GOROOT)
+		echo "GOROOT not set explicitly, using go env value instead"
+	fi
+	if [ -z $APPDIR ]; then
+		if [ $# == 0 ]; then
+			error "APPDIR not set, and no argument provided"
+		fi
+		APPDIR=$1
+		echo "APPDIR not set, using argument instead"
+	fi
+
+	# safety checks
+	if [ ! -d $GOROOT ]; then
+		error "$GOROOT is not a directory"
+	fi
+	if [ -e $APPDIR ]; then
+		error "$APPDIR exists; check and remove it before trying again"
+	fi
+
+	# reporting
+	echo "GOROOT = $GOROOT"
+	echo "APPDIR = $APPDIR"
+}
+
+fetchGodoc() {
+	echo "*** Fetching godoc (if not already in GOPATH)"
+	unset GOBIN
+	go=$APPENGINE_SDK/goapp
+	$go get -d -tags appengine $GODOC
+	mkdir -p $APPDIR/$GODOC
+	cp $(find $($go list -f '{{.Dir}}' $GODOC) -mindepth 1 -maxdepth 1 -type f) $APPDIR/$GODOC/
+}
+
+makeAppYaml() {
+	echo "*** make $APPDIR/app.yaml"
+	cat > $APPDIR/app.yaml <<EOF
+application: godoc
+version: 1
+runtime: go
+api_version: go1
+
+handlers:
+- url: /.*
+  script: _go_app
+EOF
+}
+
+makeZipfile() {
+	echo "*** make $APPDIR/$ZIPFILE"
+	zip -q -r $APPDIR/$ZIPFILE $GOROOT/*
+}
+
+makeIndexfile() {
+	echo "*** make $APPDIR/$INDEXFILE"
+	GOPATH= godoc -write_index -index_files=$APPDIR/$INDEXFILE -zip=$APPDIR/$ZIPFILE
+}
+
+splitIndexfile() {
+	echo "*** split $APPDIR/$INDEXFILE"
+	split -b8m $APPDIR/$INDEXFILE $APPDIR/$SPLITFILES
+}
+
+makeConfigfile() {
+	echo "*** make $APPDIR/$CONFIGFILE"
+	cat > $APPDIR/$CONFIGFILE <<EOF
+package main
+
+// GENERATED FILE - DO NOT MODIFY BY HAND.
+// (generated by golang.org/x/tools/cmd/godoc/setup-godoc-app.bash)
+
+const (
+	// .zip filename
+	zipFilename = "$ZIPFILE"
+
+	// goroot directory in .zip file
+	zipGoroot = "$GOROOT"
+
+	// glob pattern describing search index files
+	// (if empty, the index is built at run-time)
+	indexFilenames = "$SPLITFILES*"
+)
+EOF
+}
+
+getArgs "$@"
+set -e
+mkdir $APPDIR
+fetchGodoc
+makeAppYaml
+makeZipfile
+makeIndexfile
+splitIndexfile
+makeConfigfile
+
+echo "*** setup complete"
diff --git a/vendor/golang.org/x/tools/cmd/godoc/x.go b/vendor/golang.org/x/tools/cmd/godoc/x.go
new file mode 100644
index 0000000..a350850
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/godoc/x.go
@@ -0,0 +1,92 @@
+// 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.
+
+// This file contains the handlers that serve go-import redirects for Go
+// sub-repositories. It specifies the mapping from import paths like
+// "golang.org/x/tools" to the actual repository locations.
+
+package main
+
+import (
+	"html/template"
+	"log"
+	"net/http"
+	"strings"
+)
+
+const xPrefix = "/x/"
+
+type xRepo struct {
+	URL, VCS string
+}
+
+var xMap = map[string]xRepo{
+	"codereview": {"https://code.google.com/p/go.codereview", "hg"},
+
+	"arch":       {"https://go.googlesource.com/arch", "git"},
+	"benchmarks": {"https://go.googlesource.com/benchmarks", "git"},
+	"blog":       {"https://go.googlesource.com/blog", "git"},
+	"build":      {"https://go.googlesource.com/build", "git"},
+	"crypto":     {"https://go.googlesource.com/crypto", "git"},
+	"debug":      {"https://go.googlesource.com/debug", "git"},
+	"exp":        {"https://go.googlesource.com/exp", "git"},
+	"image":      {"https://go.googlesource.com/image", "git"},
+	"lint":       {"https://go.googlesource.com/lint", "git"},
+	"mobile":     {"https://go.googlesource.com/mobile", "git"},
+	"net":        {"https://go.googlesource.com/net", "git"},
+	"oauth2":     {"https://go.googlesource.com/oauth2", "git"},
+	"perf":       {"https://go.googlesource.com/perf", "git"},
+	"playground": {"https://go.googlesource.com/playground", "git"},
+	"review":     {"https://go.googlesource.com/review", "git"},
+	"sync":       {"https://go.googlesource.com/sync", "git"},
+	"sys":        {"https://go.googlesource.com/sys", "git"},
+	"talks":      {"https://go.googlesource.com/talks", "git"},
+	"term":       {"https://go.googlesource.com/term", "git"},
+	"text":       {"https://go.googlesource.com/text", "git"},
+	"time":       {"https://go.googlesource.com/time", "git"},
+	"tools":      {"https://go.googlesource.com/tools", "git"},
+	"tour":       {"https://go.googlesource.com/tour", "git"},
+	"vgo":        {"https://go.googlesource.com/vgo", "git"},
+}
+
+func init() {
+	http.HandleFunc(xPrefix, xHandler)
+}
+
+func xHandler(w http.ResponseWriter, r *http.Request) {
+	head, tail := strings.TrimPrefix(r.URL.Path, xPrefix), ""
+	if i := strings.Index(head, "/"); i != -1 {
+		head, tail = head[:i], head[i:]
+	}
+	if head == "" {
+		http.Redirect(w, r, "https://godoc.org/-/subrepo", http.StatusTemporaryRedirect)
+		return
+	}
+	repo, ok := xMap[head]
+	if !ok {
+		http.NotFound(w, r)
+		return
+	}
+	data := struct {
+		Prefix, Head, Tail string
+		Repo               xRepo
+	}{xPrefix, head, tail, repo}
+	if err := xTemplate.Execute(w, data); err != nil {
+		log.Println("xHandler:", err)
+	}
+}
+
+var xTemplate = template.Must(template.New("x").Parse(`<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="golang.org{{.Prefix}}{{.Head}} {{.Repo.VCS}} {{.Repo.URL}}">
+<meta name="go-source" content="golang.org{{.Prefix}}{{.Head}} https://github.com/golang/{{.Head}}/ https://github.com/golang/{{.Head}}/tree/master{/dir} https://github.com/golang/{{.Head}}/blob/master{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://godoc.org/golang.org{{.Prefix}}{{.Head}}{{.Tail}}">
+</head>
+<body>
+Nothing to see here; <a href="https://godoc.org/golang.org{{.Prefix}}{{.Head}}{{.Tail}}">move along</a>.
+</body>
+</html>
+`))
diff --git a/vendor/golang.org/x/tools/cmd/goimports/doc.go b/vendor/golang.org/x/tools/cmd/goimports/doc.go
new file mode 100644
index 0000000..f5ca3a0
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goimports/doc.go
@@ -0,0 +1,45 @@
+/*
+
+Command goimports updates your Go import lines,
+adding missing ones and removing unreferenced ones.
+
+     $ go get golang.org/x/tools/cmd/goimports
+
+In addition to fixing imports, goimports also formats
+your code in the same style as gofmt so it can be used
+as a replacement for your editor's gofmt-on-save hook.
+
+For emacs, make sure you have the latest go-mode.el:
+   https://github.com/dominikh/go-mode.el
+Then in your .emacs file:
+   (setq gofmt-command "goimports")
+   (add-to-list 'load-path "/home/you/somewhere/emacs/")
+   (require 'go-mode-autoloads)
+   (add-hook 'before-save-hook 'gofmt-before-save)
+
+For vim, set "gofmt_command" to "goimports":
+    https://golang.org/change/39c724dd7f252
+    https://golang.org/wiki/IDEsAndTextEditorPlugins
+    etc
+
+For GoSublime, follow the steps described here:
+    http://michaelwhatcott.com/gosublime-goimports/
+
+For other editors, you probably know what to do.
+
+To exclude directories in your $GOPATH from being scanned for Go
+files, goimports respects a configuration file at
+$GOPATH/src/.goimportsignore which may contain blank lines, comment
+lines (beginning with '#'), or lines naming a directory relative to
+the configuration file to ignore when scanning. No globbing or regex
+patterns are allowed. Use the "-v" verbose flag to verify it's
+working and see what goimports is doing.
+
+File bugs or feature requests at:
+
+    https://golang.org/issues/new?title=x/tools/cmd/goimports:+
+
+Happy hacking!
+
+*/
+package main // import "golang.org/x/tools/cmd/goimports"
diff --git a/vendor/golang.org/x/tools/cmd/goimports/goimports.go b/vendor/golang.org/x/tools/cmd/goimports/goimports.go
new file mode 100644
index 0000000..0ce85c9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goimports/goimports.go
@@ -0,0 +1,369 @@
+// 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 (
+	"bufio"
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/scanner"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+	"strings"
+
+	"golang.org/x/tools/imports"
+)
+
+var (
+	// main operation modes
+	list    = flag.Bool("l", false, "list files whose formatting differs from goimport's")
+	write   = flag.Bool("w", false, "write result to (source) file instead of stdout")
+	doDiff  = flag.Bool("d", false, "display diffs instead of rewriting files")
+	srcdir  = flag.String("srcdir", "", "choose imports as if source code is from `dir`. When operating on a single file, dir may instead be the complete file name.")
+	verbose bool // verbose logging
+
+	cpuProfile     = flag.String("cpuprofile", "", "CPU profile output")
+	memProfile     = flag.String("memprofile", "", "memory profile output")
+	memProfileRate = flag.Int("memrate", 0, "if > 0, sets runtime.MemProfileRate")
+
+	options = &imports.Options{
+		TabWidth:  8,
+		TabIndent: true,
+		Comments:  true,
+		Fragment:  true,
+	}
+	exitCode = 0
+)
+
+func init() {
+	flag.BoolVar(&options.AllErrors, "e", false, "report all errors (not just the first 10 on different lines)")
+	flag.StringVar(&imports.LocalPrefix, "local", "", "put imports beginning with this string after 3rd-party packages; comma-separated list")
+}
+
+func report(err error) {
+	scanner.PrintError(os.Stderr, err)
+	exitCode = 2
+}
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: goimports [flags] [path ...]\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func isGoFile(f os.FileInfo) bool {
+	// ignore non-Go files
+	name := f.Name()
+	return !f.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go")
+}
+
+// argumentType is which mode goimports was invoked as.
+type argumentType int
+
+const (
+	// fromStdin means the user is piping their source into goimports.
+	fromStdin argumentType = iota
+
+	// singleArg is the common case from editors, when goimports is run on
+	// a single file.
+	singleArg
+
+	// multipleArg is when the user ran "goimports file1.go file2.go"
+	// or ran goimports on a directory tree.
+	multipleArg
+)
+
+func processFile(filename string, in io.Reader, out io.Writer, argType argumentType) error {
+	opt := options
+	if argType == fromStdin {
+		nopt := *options
+		nopt.Fragment = true
+		opt = &nopt
+	}
+
+	if in == nil {
+		f, err := os.Open(filename)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		in = f
+	}
+
+	src, err := ioutil.ReadAll(in)
+	if err != nil {
+		return err
+	}
+
+	target := filename
+	if *srcdir != "" {
+		// Determine whether the provided -srcdirc is a directory or file
+		// and then use it to override the target.
+		//
+		// See https://github.com/dominikh/go-mode.el/issues/146
+		if isFile(*srcdir) {
+			if argType == multipleArg {
+				return errors.New("-srcdir value can't be a file when passing multiple arguments or when walking directories")
+			}
+			target = *srcdir
+		} else if argType == singleArg && strings.HasSuffix(*srcdir, ".go") && !isDir(*srcdir) {
+			// For a file which doesn't exist on disk yet, but might shortly.
+			// e.g. user in editor opens $DIR/newfile.go and newfile.go doesn't yet exist on disk.
+			// The goimports on-save hook writes the buffer to a temp file
+			// first and runs goimports before the actual save to newfile.go.
+			// The editor's buffer is named "newfile.go" so that is passed to goimports as:
+			//      goimports -srcdir=/gopath/src/pkg/newfile.go /tmp/gofmtXXXXXXXX.go
+			// and then the editor reloads the result from the tmp file and writes
+			// it to newfile.go.
+			target = *srcdir
+		} else {
+			// Pretend that file is from *srcdir in order to decide
+			// visible imports correctly.
+			target = filepath.Join(*srcdir, filepath.Base(filename))
+		}
+	}
+
+	res, err := imports.Process(target, src, opt)
+	if err != nil {
+		return err
+	}
+
+	if !bytes.Equal(src, res) {
+		// formatting has changed
+		if *list {
+			fmt.Fprintln(out, filename)
+		}
+		if *write {
+			if argType == fromStdin {
+				// filename is "<standard input>"
+				return errors.New("can't use -w on stdin")
+			}
+			err = ioutil.WriteFile(filename, res, 0)
+			if err != nil {
+				return err
+			}
+		}
+		if *doDiff {
+			if argType == fromStdin {
+				filename = "stdin.go" // because <standard input>.orig looks silly
+			}
+			data, err := diff(src, res, filename)
+			if err != nil {
+				return fmt.Errorf("computing diff: %s", err)
+			}
+			fmt.Printf("diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
+			out.Write(data)
+		}
+	}
+
+	if !*list && !*write && !*doDiff {
+		_, err = out.Write(res)
+	}
+
+	return err
+}
+
+func visitFile(path string, f os.FileInfo, err error) error {
+	if err == nil && isGoFile(f) {
+		err = processFile(path, nil, os.Stdout, multipleArg)
+	}
+	if err != nil {
+		report(err)
+	}
+	return nil
+}
+
+func walkDir(path string) {
+	filepath.Walk(path, visitFile)
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	// call gofmtMain in a separate function
+	// so that it can use defer and have them
+	// run before the exit.
+	gofmtMain()
+	os.Exit(exitCode)
+}
+
+// parseFlags parses command line flags and returns the paths to process.
+// It's a var so that custom implementations can replace it in other files.
+var parseFlags = func() []string {
+	flag.BoolVar(&verbose, "v", false, "verbose logging")
+
+	flag.Parse()
+	return flag.Args()
+}
+
+func bufferedFileWriter(dest string) (w io.Writer, close func()) {
+	f, err := os.Create(dest)
+	if err != nil {
+		log.Fatal(err)
+	}
+	bw := bufio.NewWriter(f)
+	return bw, func() {
+		if err := bw.Flush(); err != nil {
+			log.Fatalf("error flushing %v: %v", dest, err)
+		}
+		if err := f.Close(); err != nil {
+			log.Fatal(err)
+		}
+	}
+}
+
+func gofmtMain() {
+	flag.Usage = usage
+	paths := parseFlags()
+
+	if *cpuProfile != "" {
+		bw, flush := bufferedFileWriter(*cpuProfile)
+		pprof.StartCPUProfile(bw)
+		defer flush()
+		defer pprof.StopCPUProfile()
+	}
+	// doTrace is a conditionally compiled wrapper around runtime/trace. It is
+	// used to allow goimports to compile under gccgo, which does not support
+	// runtime/trace. See https://golang.org/issue/15544.
+	defer doTrace()()
+	if *memProfileRate > 0 {
+		runtime.MemProfileRate = *memProfileRate
+		bw, flush := bufferedFileWriter(*memProfile)
+		defer func() {
+			runtime.GC() // materialize all statistics
+			if err := pprof.WriteHeapProfile(bw); err != nil {
+				log.Fatal(err)
+			}
+			flush()
+		}()
+	}
+
+	if verbose {
+		log.SetFlags(log.LstdFlags | log.Lmicroseconds)
+		imports.Debug = true
+	}
+	if options.TabWidth < 0 {
+		fmt.Fprintf(os.Stderr, "negative tabwidth %d\n", options.TabWidth)
+		exitCode = 2
+		return
+	}
+
+	if len(paths) == 0 {
+		if err := processFile("<standard input>", os.Stdin, os.Stdout, fromStdin); err != nil {
+			report(err)
+		}
+		return
+	}
+
+	argType := singleArg
+	if len(paths) > 1 {
+		argType = multipleArg
+	}
+
+	for _, path := range paths {
+		switch dir, err := os.Stat(path); {
+		case err != nil:
+			report(err)
+		case dir.IsDir():
+			walkDir(path)
+		default:
+			if err := processFile(path, nil, os.Stdout, argType); err != nil {
+				report(err)
+			}
+		}
+	}
+}
+
+func writeTempFile(dir, prefix string, data []byte) (string, error) {
+	file, err := ioutil.TempFile(dir, prefix)
+	if err != nil {
+		return "", err
+	}
+	_, err = file.Write(data)
+	if err1 := file.Close(); err == nil {
+		err = err1
+	}
+	if err != nil {
+		os.Remove(file.Name())
+		return "", err
+	}
+	return file.Name(), nil
+}
+
+func diff(b1, b2 []byte, filename string) (data []byte, err error) {
+	f1, err := writeTempFile("", "gofmt", b1)
+	if err != nil {
+		return
+	}
+	defer os.Remove(f1)
+
+	f2, err := writeTempFile("", "gofmt", b2)
+	if err != nil {
+		return
+	}
+	defer os.Remove(f2)
+
+	cmd := "diff"
+	if runtime.GOOS == "plan9" {
+		cmd = "/bin/ape/diff"
+	}
+
+	data, err = exec.Command(cmd, "-u", f1, f2).CombinedOutput()
+	if len(data) > 0 {
+		// diff exits with a non-zero status when the files don't match.
+		// Ignore that failure as long as we get output.
+		return replaceTempFilename(data, filename)
+	}
+	return
+}
+
+// replaceTempFilename replaces temporary filenames in diff with actual one.
+//
+// --- /tmp/gofmt316145376	2017-02-03 19:13:00.280468375 -0500
+// +++ /tmp/gofmt617882815	2017-02-03 19:13:00.280468375 -0500
+// ...
+// ->
+// --- path/to/file.go.orig	2017-02-03 19:13:00.280468375 -0500
+// +++ path/to/file.go	2017-02-03 19:13:00.280468375 -0500
+// ...
+func replaceTempFilename(diff []byte, filename string) ([]byte, error) {
+	bs := bytes.SplitN(diff, []byte{'\n'}, 3)
+	if len(bs) < 3 {
+		return nil, fmt.Errorf("got unexpected diff for %s", filename)
+	}
+	// Preserve timestamps.
+	var t0, t1 []byte
+	if i := bytes.LastIndexByte(bs[0], '\t'); i != -1 {
+		t0 = bs[0][i:]
+	}
+	if i := bytes.LastIndexByte(bs[1], '\t'); i != -1 {
+		t1 = bs[1][i:]
+	}
+	// Always print filepath with slash separator.
+	f := filepath.ToSlash(filename)
+	bs[0] = []byte(fmt.Sprintf("--- %s%s", f+".orig", t0))
+	bs[1] = []byte(fmt.Sprintf("+++ %s%s", f, t1))
+	return bytes.Join(bs, []byte{'\n'}), nil
+}
+
+// isFile reports whether name is a file.
+func isFile(name string) bool {
+	fi, err := os.Stat(name)
+	return err == nil && fi.Mode().IsRegular()
+}
+
+// isDir reports whether name is a directory.
+func isDir(name string) bool {
+	fi, err := os.Stat(name)
+	return err == nil && fi.IsDir()
+}
diff --git a/vendor/golang.org/x/tools/cmd/goimports/goimports_gc.go b/vendor/golang.org/x/tools/cmd/goimports/goimports_gc.go
new file mode 100644
index 0000000..21d867e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goimports/goimports_gc.go
@@ -0,0 +1,26 @@
+// 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 gc
+
+package main
+
+import (
+	"flag"
+	"runtime/trace"
+)
+
+var traceProfile = flag.String("trace", "", "trace profile output")
+
+func doTrace() func() {
+	if *traceProfile != "" {
+		bw, flush := bufferedFileWriter(*traceProfile)
+		trace.Start(bw)
+		return func() {
+			flush()
+			trace.Stop()
+		}
+	}
+	return func() {}
+}
diff --git a/vendor/golang.org/x/tools/cmd/goimports/goimports_not_gc.go b/vendor/golang.org/x/tools/cmd/goimports/goimports_not_gc.go
new file mode 100644
index 0000000..f5531ce
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goimports/goimports_not_gc.go
@@ -0,0 +1,11 @@
+// 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 !gc
+
+package main
+
+func doTrace() func() {
+	return func() {}
+}
diff --git a/vendor/golang.org/x/tools/cmd/gomvpkg/main.go b/vendor/golang.org/x/tools/cmd/gomvpkg/main.go
new file mode 100644
index 0000000..959b84e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gomvpkg/main.go
@@ -0,0 +1,94 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// licence that can be found in the LICENSE file.
+
+// The gomvpkg command moves go packages, updating import declarations.
+// See the -help message or Usage constant for details.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"os"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/refactor/rename"
+)
+
+var (
+	fromFlag     = flag.String("from", "", "Import path of package to be moved")
+	toFlag       = flag.String("to", "", "Destination import path for package")
+	vcsMvCmdFlag = flag.String("vcs_mv_cmd", "", `A template for the version control system's "move directory" command, e.g. "git mv {{.Src}} {{.Dst}}`)
+	helpFlag     = flag.Bool("help", false, "show usage message")
+)
+
+func init() {
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+}
+
+const Usage = `gomvpkg: moves a package, updating import declarations
+
+Usage:
+
+ gomvpkg -from <path> -to <path> [-vcs_mv_cmd <template>]
+
+Flags:
+
+-from        specifies the import path of the package to be moved
+
+-to          specifies the destination import path
+
+-vcs_mv_cmd  specifies a shell command to inform the version control system of a
+             directory move.  The argument is a template using the syntax of the
+             text/template package. It has two fields: Src and Dst, the absolute
+             paths of the directories.
+
+             For example: "git mv {{.Src}} {{.Dst}}"
+
+gomvpkg determines the set of packages that might be affected, including all
+packages importing the 'from' package and any of its subpackages. It will move
+the 'from' package and all its subpackages to the destination path and update all
+imports of those packages to point to its new import path.
+
+gomvpkg rejects moves in which a package already exists at the destination import
+path, or in which a directory already exists at the location the package would be
+moved to.
+
+gomvpkg will not always be able to rename imports when a package's name is changed.
+Import statements may want further cleanup.
+
+gomvpkg's behavior is not defined if any of the packages to be moved are
+imported using dot imports.
+
+Examples:
+
+% gomvpkg -from myproject/foo -to myproject/bar
+
+  Move the package with import path "myproject/foo" to the new path
+  "myproject/bar".
+
+% gomvpkg -from myproject/foo -to myproject/bar -vcs_mv_cmd "git mv {{.Src}} {{.Dst}}"
+
+  Move the package with import path "myproject/foo" to the new path
+  "myproject/bar" using "git mv" to execute the directory move.
+`
+
+func main() {
+	flag.Parse()
+
+	if len(flag.Args()) > 0 {
+		fmt.Fprintln(os.Stderr, "gomvpkg: surplus arguments.")
+		os.Exit(1)
+	}
+
+	if *helpFlag || *fromFlag == "" || *toFlag == "" {
+		fmt.Println(Usage)
+		return
+	}
+
+	if err := rename.Move(&build.Default, *fromFlag, *toFlag, *vcsMvCmdFlag); err != nil {
+		fmt.Fprintf(os.Stderr, "gomvpkg: %s.\n", err)
+		os.Exit(1)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/gorename/cgo_test.go b/vendor/golang.org/x/tools/cmd/gorename/cgo_test.go
new file mode 100644
index 0000000..fd07553
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gorename/cgo_test.go
@@ -0,0 +1,11 @@
+// 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 cgo
+
+package main_test
+
+func init() {
+	haveCGO = true
+}
diff --git a/vendor/golang.org/x/tools/cmd/gorename/gorename_test.go b/vendor/golang.org/x/tools/cmd/gorename/gorename_test.go
new file mode 100644
index 0000000..b778cb6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gorename/gorename_test.go
@@ -0,0 +1,380 @@
+// 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 main_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var haveCGO bool
+
+type test struct {
+	offset, from, to string // specify the arguments
+	fileSpecified    bool   // true if the offset or from args specify a specific file
+	pkgs             map[string][]string
+	wantErr          bool
+	wantOut          string              // a substring expected to be in the output
+	packages         map[string][]string // a map of the package name to the files contained within, which will be numbered by i.go where i is the index
+}
+
+// Test that renaming that would modify cgo files will produce an error and not modify the file.
+func TestGeneratedFiles(t *testing.T) {
+	if !haveCGO {
+		t.Skipf("skipping test: no cgo")
+	}
+
+	tmp, bin, cleanup := buildGorename(t)
+	defer cleanup()
+
+	srcDir := filepath.Join(tmp, "src")
+	err := os.Mkdir(srcDir, os.ModePerm)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var env = []string{fmt.Sprintf("GOPATH=%s", tmp)}
+	for _, envVar := range os.Environ() {
+		if !strings.HasPrefix(envVar, "GOPATH=") {
+			env = append(env, envVar)
+		}
+	}
+
+	// Testing renaming in packages that include cgo files:
+	for iter, renameTest := range []test{
+		{
+			// Test: variable not used in any cgo file -> no error
+			from: `"mytest"::f`, to: "g",
+			packages: map[string][]string{
+				"mytest": []string{`package mytest; func f() {}`,
+					`package mytest
+// #include <stdio.h>
+import "C"
+
+func z() {C.puts(nil)}`},
+			},
+			wantErr: false,
+			wantOut: "Renamed 1 occurrence in 1 file in 1 package.",
+		}, {
+			// Test: to name used in cgo file -> rename error
+			from: `"mytest"::f`, to: "g",
+			packages: map[string][]string{
+				"mytest": []string{`package mytest; func f() {}`,
+					`package mytest
+// #include <stdio.h>
+import "C"
+
+func g() {C.puts(nil)}`},
+			},
+			wantErr: true,
+			wantOut: "conflicts with func in same block",
+		},
+		{
+			// Test: from name in package in cgo file -> error
+			from: `"mytest"::f`, to: "g",
+			packages: map[string][]string{
+				"mytest": []string{`package mytest
+
+// #include <stdio.h>
+import "C"
+
+func f() { C.puts(nil); }
+`},
+			},
+			wantErr: true,
+			wantOut: "gorename: refusing to modify generated file containing DO NOT EDIT marker:",
+		}, {
+			// Test: from name in cgo file -> error
+			from: filepath.Join("mytest", "0.go") + `::f`, to: "g",
+			fileSpecified: true,
+			packages: map[string][]string{
+				"mytest": []string{`package mytest
+
+// #include <stdio.h>
+import "C"
+
+func f() { C.puts(nil); }
+`},
+			},
+			wantErr: true,
+			wantOut: "gorename: refusing to modify generated file containing DO NOT EDIT marker:",
+		}, {
+			// Test: offset in cgo file -> identifier in cgo error
+			offset: filepath.Join("main", "0.go") + `:#78`, to: "bar",
+			fileSpecified: true,
+			wantErr:       true,
+			packages: map[string][]string{
+				"main": {`package main
+
+// #include <unistd.h>
+import "C"
+import "fmt"
+
+func main() {
+	foo := 1
+	C.close(2)
+	fmt.Println(foo)
+}
+`},
+			},
+			wantOut: "cannot rename identifiers in generated file containing DO NOT EDIT marker:",
+		}, {
+			// Test: from identifier appears in cgo file in another package -> error
+			from: `"test"::Foo`, to: "Bar",
+			packages: map[string][]string{
+				"test": []string{
+					`package test
+
+func Foo(x int) (int){
+	return x * 2
+}
+`,
+				},
+				"main": []string{
+					`package main
+
+import "test"
+import "fmt"
+// #include <unistd.h>
+import "C"
+
+func fun() {
+	x := test.Foo(3)
+	C.close(3)
+	fmt.Println(x)
+}
+`,
+				},
+			},
+			wantErr: true,
+			wantOut: "gorename: refusing to modify generated file containing DO NOT EDIT marker:",
+		}, {
+			// Test: from identifier doesn't appear in cgo file that includes modified package -> rename successful
+			from: `"test".Foo::x`, to: "y",
+			packages: map[string][]string{
+				"test": []string{
+					`package test
+
+func Foo(x int) (int){
+	return x * 2
+}
+`,
+				},
+				"main": []string{
+					`package main
+import "test"
+import "fmt"
+// #include <unistd.h>
+import "C"
+
+func fun() {
+	x := test.Foo(3)
+	C.close(3)
+	fmt.Println(x)
+}
+`,
+				},
+			},
+			wantErr: false,
+			wantOut: "Renamed 2 occurrences in 1 file in 1 package.",
+		}, {
+			// Test: from name appears in cgo file in same package -> error
+			from: `"mytest"::f`, to: "g",
+			packages: map[string][]string{
+				"mytest": []string{`package mytest; func f() {}`,
+					`package mytest
+// #include <stdio.h>
+import "C"
+
+func z() {C.puts(nil); f()}`,
+					`package mytest
+// #include <unistd.h>
+import "C"
+
+func foo() {C.close(3); f()}`,
+				},
+			},
+			wantErr: true,
+			wantOut: "gorename: refusing to modify generated files containing DO NOT EDIT marker:",
+		}, {
+			// Test: from name in file, identifier not used in cgo file -> rename successful
+			from: filepath.Join("mytest", "0.go") + `::f`, to: "g",
+			fileSpecified: true,
+			packages: map[string][]string{
+				"mytest": []string{`package mytest; func f() {}`,
+					`package mytest
+// #include <stdio.h>
+import "C"
+
+func z() {C.puts(nil)}`},
+			},
+			wantErr: false,
+			wantOut: "Renamed 1 occurrence in 1 file in 1 package.",
+		}, {
+			// Test: from identifier imported to another package but does not modify cgo file -> rename successful
+			from: `"test".Foo`, to: "Bar",
+			packages: map[string][]string{
+				"test": []string{
+					`package test
+
+func Foo(x int) (int){
+	return x * 2
+}
+`,
+				},
+				"main": []string{
+					`package main
+// #include <unistd.h>
+import "C"
+
+func fun() {
+	C.close(3)
+}
+`,
+					`package main
+import "test"
+import "fmt"
+func g() { fmt.Println(test.Foo(3)) }
+`,
+				},
+			},
+			wantErr: false,
+			wantOut: "Renamed 2 occurrences in 2 files in 2 packages.",
+		},
+	} {
+		// Write the test files
+		testCleanup := setUpPackages(t, srcDir, renameTest.packages)
+
+		// Set up arguments
+		var args []string
+
+		var arg, val string
+		if renameTest.offset != "" {
+			arg, val = "-offset", renameTest.offset
+		} else {
+			arg, val = "-from", renameTest.from
+		}
+
+		prefix := fmt.Sprintf("%d: %s %q -to %q", iter, arg, val, renameTest.to)
+
+		if renameTest.fileSpecified {
+			// add the src dir to the value of the argument
+			val = filepath.Join(srcDir, val)
+		}
+
+		args = append(args, arg, val, "-to", renameTest.to)
+
+		// Run command
+		cmd := exec.Command(bin, args...)
+		cmd.Args[0] = "gorename"
+		cmd.Env = env
+
+		// Check the output
+		out, err := cmd.CombinedOutput()
+		// errors should result in no changes to files
+		if err != nil {
+			if !renameTest.wantErr {
+				t.Errorf("%s: received unexpected error %s", prefix, err)
+			}
+			// Compare output
+			if ok := strings.Contains(string(out), renameTest.wantOut); !ok {
+				t.Errorf("%s: unexpected command output: %s (want: %s)", prefix, out, renameTest.wantOut)
+			}
+			// Check that no files were modified
+			if modified := modifiedFiles(t, srcDir, renameTest.packages); len(modified) != 0 {
+				t.Errorf("%s: files unexpectedly modified: %s", prefix, modified)
+			}
+
+		} else {
+			if !renameTest.wantErr {
+				if ok := strings.Contains(string(out), renameTest.wantOut); !ok {
+					t.Errorf("%s: unexpected command output: %s (want: %s)", prefix, out, renameTest.wantOut)
+				}
+			} else {
+				t.Errorf("%s: command succeeded unexpectedly, output: %s", prefix, out)
+			}
+		}
+		testCleanup()
+	}
+}
+
+// buildGorename builds the gorename executable.
+// It returns its path, and a cleanup function.
+func buildGorename(t *testing.T) (tmp, bin string, cleanup func()) {
+
+	tmp, err := ioutil.TempDir("", "gorename-regtest-")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer func() {
+		if cleanup == nil { // probably, go build failed.
+			os.RemoveAll(tmp)
+		}
+	}()
+
+	bin = filepath.Join(tmp, "gorename")
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+	cmd := exec.Command("go", "build", "-o", bin)
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("Building gorename: %v", err)
+	}
+	return tmp, bin, func() { os.RemoveAll(tmp) }
+}
+
+// setUpPackages sets up the files in a temporary directory provided by arguments.
+func setUpPackages(t *testing.T, dir string, packages map[string][]string) (cleanup func()) {
+	var pkgDirs []string
+
+	for pkgName, files := range packages {
+		// Create a directory for the package.
+		pkgDir := filepath.Join(dir, pkgName)
+		pkgDirs = append(pkgDirs, pkgDir)
+
+		if err := os.Mkdir(pkgDir, os.ModePerm); err != nil {
+			t.Fatal(err)
+		}
+		// Write the packages files
+		for i, val := range files {
+			file := filepath.Join(pkgDir, strconv.Itoa(i)+".go")
+			if err := ioutil.WriteFile(file, []byte(val), os.ModePerm); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	return func() {
+		for _, dir := range pkgDirs {
+			os.RemoveAll(dir)
+		}
+	}
+}
+
+// modifiedFiles returns a list of files that were renamed (without the prefix dir).
+func modifiedFiles(t *testing.T, dir string, packages map[string][]string) (results []string) {
+
+	for pkgName, files := range packages {
+		pkgDir := filepath.Join(dir, pkgName)
+
+		for i, val := range files {
+			file := filepath.Join(pkgDir, strconv.Itoa(i)+".go")
+			// read file contents and compare to val
+			if contents, err := ioutil.ReadFile(file); err != nil {
+				t.Fatalf("File missing: %s", err)
+			} else if string(contents) != val {
+				results = append(results, strings.TrimPrefix(dir, file))
+			}
+		}
+	}
+	return results
+}
diff --git a/vendor/golang.org/x/tools/cmd/gorename/main.go b/vendor/golang.org/x/tools/cmd/gorename/main.go
new file mode 100644
index 0000000..b1b895c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gorename/main.go
@@ -0,0 +1,55 @@
+// The gorename command performs precise type-safe renaming of
+// identifiers in Go source code.
+//
+// Run with -help for usage information, or view the Usage constant in
+// package golang.org/x/tools/refactor/rename, which contains most of
+// the implementation.
+//
+package main // import "golang.org/x/tools/cmd/gorename"
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"log"
+	"os"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/refactor/rename"
+)
+
+var (
+	offsetFlag = flag.String("offset", "", "file and byte offset of identifier to be renamed, e.g. 'file.go:#123'.  For use by editors.")
+	fromFlag   = flag.String("from", "", "identifier to be renamed; see -help for formats")
+	toFlag     = flag.String("to", "", "new name for identifier")
+	helpFlag   = flag.Bool("help", false, "show usage message")
+)
+
+func init() {
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+	flag.BoolVar(&rename.Force, "force", false, "proceed, even if conflicts were reported")
+	flag.BoolVar(&rename.Verbose, "v", false, "print verbose information")
+	flag.BoolVar(&rename.Diff, "d", false, "display diffs instead of rewriting files")
+	flag.StringVar(&rename.DiffCmd, "diffcmd", "diff", "diff command invoked when using -d")
+}
+
+func main() {
+	log.SetPrefix("gorename: ")
+	log.SetFlags(0)
+	flag.Parse()
+	if len(flag.Args()) > 0 {
+		log.Fatal("surplus arguments")
+	}
+
+	if *helpFlag || (*offsetFlag == "" && *fromFlag == "" && *toFlag == "") {
+		fmt.Println(rename.Usage)
+		return
+	}
+
+	if err := rename.Main(&build.Default, *offsetFlag, *fromFlag, *toFlag); err != nil {
+		if err != rename.ConflictError {
+			log.Fatal(err)
+		}
+		os.Exit(1)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/gotype/gotype.go b/vendor/golang.org/x/tools/cmd/gotype/gotype.go
new file mode 100644
index 0000000..ed88e63
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gotype/gotype.go
@@ -0,0 +1,341 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// gotype.go is a copy of the original source maintained
+// in $GOROOT/src/go/types/gotype.go, but with the call
+// to types.SizesFor factored out so we can provide a local
+// implementation when compiling against Go 1.8 and earlier.
+//
+// This code is here for the sole purpose of satisfying historic
+// references to this location, and for making gotype accessible
+// via 'go get'.
+//
+// Do NOT make changes to this version as they will not be maintained
+// (and possibly overwritten). Any changes should be made to the original
+// and then ported to here.
+
+/*
+The gotype command, like the front-end of a Go compiler, parses and
+type-checks a single Go package. Errors are reported if the analysis
+fails; otherwise gotype is quiet (unless -v is set).
+
+Without a list of paths, gotype reads from standard input, which
+must provide a single Go source file defining a complete package.
+
+With a single directory argument, gotype checks the Go files in
+that directory, comprising a single package. Use -t to include the
+(in-package) _test.go files. Use -x to type check only external
+test files.
+
+Otherwise, each path must be the filename of a Go file belonging
+to the same package.
+
+Imports are processed by importing directly from the source of
+imported packages (default), or by importing from compiled and
+installed packages (by setting -c to the respective compiler).
+
+The -c flag must be set to a compiler ("gc", "gccgo") when type-
+checking packages containing imports with relative import paths
+(import "./mypkg") because the source importer cannot know which
+files to include for such packages.
+
+Usage:
+	gotype [flags] [path...]
+
+The flags are:
+	-t
+		include local test files in a directory (ignored if -x is provided)
+	-x
+		consider only external test files in a directory
+	-e
+		report all errors (not just the first 10)
+	-v
+		verbose mode
+	-c
+		compiler used for installed packages (gc, gccgo, or source); default: source
+
+Flags controlling additional output:
+	-ast
+		print AST (forces -seq)
+	-trace
+		print parse trace (forces -seq)
+	-comments
+		parse comments (ignored unless -ast or -trace is provided)
+
+Examples:
+
+To check the files a.go, b.go, and c.go:
+
+	gotype a.go b.go c.go
+
+To check an entire package including (in-package) tests in the directory dir and print the processed files:
+
+	gotype -t -v dir
+
+To check the external test package (if any) in the current directory, based on installed packages compiled with
+cmd/compile:
+
+	gotype -c=gc -x .
+
+To verify the output of a pipe:
+
+	echo "package foo" | gotype
+
+*/
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/importer"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+var (
+	// main operation modes
+	testFiles  = flag.Bool("t", false, "include in-package test files in a directory")
+	xtestFiles = flag.Bool("x", false, "consider only external test files in a directory")
+	allErrors  = flag.Bool("e", false, "report all errors, not just the first 10")
+	verbose    = flag.Bool("v", false, "verbose mode")
+	compiler   = flag.String("c", defaultCompiler, "compiler used for installed packages (gc, gccgo, or source)")
+
+	// additional output control
+	printAST      = flag.Bool("ast", false, "print AST (forces -seq)")
+	printTrace    = flag.Bool("trace", false, "print parse trace (forces -seq)")
+	parseComments = flag.Bool("comments", false, "parse comments (ignored unless -ast or -trace is provided)")
+)
+
+var (
+	fset       = token.NewFileSet()
+	errorCount = 0
+	sequential = false
+	parserMode parser.Mode
+)
+
+func initParserMode() {
+	if *allErrors {
+		parserMode |= parser.AllErrors
+	}
+	if *printAST {
+		sequential = true
+	}
+	if *printTrace {
+		parserMode |= parser.Trace
+		sequential = true
+	}
+	if *parseComments && (*printAST || *printTrace) {
+		parserMode |= parser.ParseComments
+	}
+}
+
+const usageString = `usage: gotype [flags] [path ...]
+
+The gotype command, like the front-end of a Go compiler, parses and
+type-checks a single Go package. Errors are reported if the analysis
+fails; otherwise gotype is quiet (unless -v is set).
+
+Without a list of paths, gotype reads from standard input, which
+must provide a single Go source file defining a complete package.
+
+With a single directory argument, gotype checks the Go files in
+that directory, comprising a single package. Use -t to include the
+(in-package) _test.go files. Use -x to type check only external
+test files.
+
+Otherwise, each path must be the filename of a Go file belonging
+to the same package.
+
+Imports are processed by importing directly from the source of
+imported packages (default), or by importing from compiled and
+installed packages (by setting -c to the respective compiler).
+
+The -c flag must be set to a compiler ("gc", "gccgo") when type-
+checking packages containing imports with relative import paths
+(import "./mypkg") because the source importer cannot know which
+files to include for such packages.
+`
+
+func usage() {
+	fmt.Fprintln(os.Stderr, usageString)
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func report(err error) {
+	scanner.PrintError(os.Stderr, err)
+	if list, ok := err.(scanner.ErrorList); ok {
+		errorCount += len(list)
+		return
+	}
+	errorCount++
+}
+
+// parse may be called concurrently
+func parse(filename string, src interface{}) (*ast.File, error) {
+	if *verbose {
+		fmt.Println(filename)
+	}
+	file, err := parser.ParseFile(fset, filename, src, parserMode) // ok to access fset concurrently
+	if *printAST {
+		ast.Print(fset, file)
+	}
+	return file, err
+}
+
+func parseStdin() (*ast.File, error) {
+	src, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		return nil, err
+	}
+	return parse("<standard input>", src)
+}
+
+func parseFiles(dir string, filenames []string) ([]*ast.File, error) {
+	files := make([]*ast.File, len(filenames))
+	errors := make([]error, len(filenames))
+
+	var wg sync.WaitGroup
+	for i, filename := range filenames {
+		wg.Add(1)
+		go func(i int, filepath string) {
+			defer wg.Done()
+			files[i], errors[i] = parse(filepath, nil)
+		}(i, filepath.Join(dir, filename))
+		if sequential {
+			wg.Wait()
+		}
+	}
+	wg.Wait()
+
+	// if there are errors, return the first one for deterministic results
+	for _, err := range errors {
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return files, nil
+}
+
+func parseDir(dir string) ([]*ast.File, error) {
+	ctxt := build.Default
+	pkginfo, err := ctxt.ImportDir(dir, 0)
+	if _, nogo := err.(*build.NoGoError); err != nil && !nogo {
+		return nil, err
+	}
+
+	if *xtestFiles {
+		return parseFiles(dir, pkginfo.XTestGoFiles)
+	}
+
+	filenames := append(pkginfo.GoFiles, pkginfo.CgoFiles...)
+	if *testFiles {
+		filenames = append(filenames, pkginfo.TestGoFiles...)
+	}
+	return parseFiles(dir, filenames)
+}
+
+func getPkgFiles(args []string) ([]*ast.File, error) {
+	if len(args) == 0 {
+		// stdin
+		file, err := parseStdin()
+		if err != nil {
+			return nil, err
+		}
+		return []*ast.File{file}, nil
+	}
+
+	if len(args) == 1 {
+		// possibly a directory
+		path := args[0]
+		info, err := os.Stat(path)
+		if err != nil {
+			return nil, err
+		}
+		if info.IsDir() {
+			return parseDir(path)
+		}
+	}
+
+	// list of files
+	return parseFiles("", args)
+}
+
+func checkPkgFiles(files []*ast.File) {
+	type bailout struct{}
+
+	// if checkPkgFiles is called multiple times, set up conf only once
+	conf := types.Config{
+		FakeImportC: true,
+		Error: func(err error) {
+			if !*allErrors && errorCount >= 10 {
+				panic(bailout{})
+			}
+			report(err)
+		},
+		Importer: importer.For(*compiler, nil),
+		Sizes:    SizesFor(build.Default.Compiler, build.Default.GOARCH),
+	}
+
+	defer func() {
+		switch p := recover().(type) {
+		case nil, bailout:
+			// normal return or early exit
+		default:
+			// re-panic
+			panic(p)
+		}
+	}()
+
+	const path = "pkg" // any non-empty string will do for now
+	conf.Check(path, fset, files, nil)
+}
+
+func printStats(d time.Duration) {
+	fileCount := 0
+	lineCount := 0
+	fset.Iterate(func(f *token.File) bool {
+		fileCount++
+		lineCount += f.LineCount()
+		return true
+	})
+
+	fmt.Printf(
+		"%s (%d files, %d lines, %d lines/s)\n",
+		d, fileCount, lineCount, int64(float64(lineCount)/d.Seconds()),
+	)
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+	initParserMode()
+
+	start := time.Now()
+
+	files, err := getPkgFiles(flag.Args())
+	if err != nil {
+		report(err)
+		os.Exit(2)
+	}
+
+	checkPkgFiles(files)
+	if errorCount > 0 {
+		os.Exit(2)
+	}
+
+	if *verbose {
+		printStats(time.Since(start))
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/gotype/sizesFor18.go b/vendor/golang.org/x/tools/cmd/gotype/sizesFor18.go
new file mode 100644
index 0000000..94e8176
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gotype/sizesFor18.go
@@ -0,0 +1,40 @@
+// 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
+
+// This file contains a copy of the implementation of types.SizesFor
+// since this function is not available in go/types before Go 1.9.
+
+package main
+
+import "go/types"
+
+const defaultCompiler = "gc"
+
+var gcArchSizes = map[string]*types.StdSizes{
+	"386":      {4, 4},
+	"arm":      {4, 4},
+	"arm64":    {8, 8},
+	"amd64":    {8, 8},
+	"amd64p32": {4, 8},
+	"mips":     {4, 4},
+	"mipsle":   {4, 4},
+	"mips64":   {8, 8},
+	"mips64le": {8, 8},
+	"ppc64":    {8, 8},
+	"ppc64le":  {8, 8},
+	"s390x":    {8, 8},
+}
+
+func SizesFor(compiler, arch string) types.Sizes {
+	if compiler != "gc" {
+		return nil
+	}
+	s, ok := gcArchSizes[arch]
+	if !ok {
+		return nil
+	}
+	return s
+}
diff --git a/vendor/golang.org/x/tools/cmd/gotype/sizesFor19.go b/vendor/golang.org/x/tools/cmd/gotype/sizesFor19.go
new file mode 100644
index 0000000..9e0b481
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/gotype/sizesFor19.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"
+
+const defaultCompiler = "source"
+
+func SizesFor(compiler, arch string) types.Sizes {
+	return types.SizesFor(compiler, arch)
+}
diff --git a/vendor/golang.org/x/tools/cmd/goyacc/doc.go b/vendor/golang.org/x/tools/cmd/goyacc/doc.go
new file mode 100644
index 0000000..03ffee7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goyacc/doc.go
@@ -0,0 +1,70 @@
+// Copyright 2009 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.
+
+/*
+
+Goyacc is a version of yacc for Go.
+It is written in Go and generates parsers written in Go.
+
+Usage:
+
+	goyacc args...
+
+It is largely transliterated from the Inferno version written in Limbo
+which in turn was largely transliterated from the Plan 9 version
+written in C and documented at
+
+	https://9p.io/magic/man2html/1/yacc
+
+Adepts of the original yacc will have no trouble adapting to this
+form of the tool.
+
+The directory $GOPATH/src/golang.org/x/tools/cmd/goyacc/testdata/expr
+is a yacc program for a very simple expression parser. See expr.y and
+main.go in that directory for examples of how to write and build
+goyacc programs.
+
+The generated parser is reentrant. The parsing function yyParse expects
+to be given an argument that conforms to the following interface:
+
+	type yyLexer interface {
+		Lex(lval *yySymType) int
+		Error(e string)
+	}
+
+Lex should return the token identifier, and place other token
+information in lval (which replaces the usual yylval).
+Error is equivalent to yyerror in the original yacc.
+
+Code inside the grammar actions may refer to the variable yylex,
+which holds the yyLexer passed to yyParse.
+
+Clients that need to understand more about the parser state can
+create the parser separately from invoking it. The function yyNewParser
+returns a yyParser conforming to the following interface:
+
+	type yyParser interface {
+		Parse(yyLex) int
+		Lookahead() int
+	}
+
+Parse runs the parser; the top-level call yyParse(yylex) is equivalent
+to yyNewParser().Parse(yylex).
+
+Lookahead can be called during grammar actions to read (but not consume)
+the value of the current lookahead token, as returned by yylex.Lex.
+If there is no current lookahead token (because the parser has not called Lex
+or has consumed the token returned by the most recent call to Lex),
+Lookahead returns -1. Calling Lookahead is equivalent to reading
+yychar from within in a grammar action.
+
+Multiple grammars compiled into a single program should be placed in
+distinct packages.  If that is impossible, the "-p prefix" flag to
+goyacc sets the prefix, by default yy, that begins the names of
+symbols, including types, the parser, and the lexer, generated and
+referenced by yacc's generated code.  Setting it to distinct values
+allows multiple grammars to be placed in a single package.
+
+*/
+package main
diff --git a/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/README b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/README
new file mode 100644
index 0000000..302ef57
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/README
@@ -0,0 +1,20 @@
+This directory contains a simple program demonstrating how to use
+the Go version of yacc.
+
+To build it:
+
+	$ go generate
+	$ go build
+
+or
+
+	$ go generate
+	$ go run expr.go
+
+The file main.go contains the "go generate" command to run yacc to
+create expr.go from expr.y. It also has the package doc comment,
+as godoc will not scan the .y file.
+
+The actual implementation is in expr.y.
+
+The program is not installed in the binary distributions of Go.
diff --git a/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/expr.y b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/expr.y
new file mode 100644
index 0000000..ba4a1b2
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/expr.y
@@ -0,0 +1,202 @@
+// 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.
+
+// This is an example of a goyacc program.
+// To build it:
+// goyacc -p "expr" expr.y (produces y.go)
+// go build -o expr y.go
+// expr
+// > <type an expression>
+
+%{
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"math/big"
+	"os"
+	"unicode/utf8"
+)
+
+%}
+
+%union {
+	num *big.Rat
+}
+
+%type	<num>	expr expr1 expr2 expr3
+
+%token '+' '-' '*' '/' '(' ')'
+
+%token	<num>	NUM
+
+%%
+
+top:
+	expr
+	{
+		if $1.IsInt() {
+			fmt.Println($1.Num().String())
+		} else {
+			fmt.Println($1.String())
+		}
+	}
+
+expr:
+	expr1
+|	'+' expr
+	{
+		$$ = $2
+	}
+|	'-' expr
+	{
+		$$ = $2.Neg($2)
+	}
+
+expr1:
+	expr2
+|	expr1 '+' expr2
+	{
+		$$ = $1.Add($1, $3)
+	}
+|	expr1 '-' expr2
+	{
+		$$ = $1.Sub($1, $3)
+	}
+
+expr2:
+	expr3
+|	expr2 '*' expr3
+	{
+		$$ = $1.Mul($1, $3)
+	}
+|	expr2 '/' expr3
+	{
+		$$ = $1.Quo($1, $3)
+	}
+
+expr3:
+	NUM
+|	'(' expr ')'
+	{
+		$$ = $2
+	}
+
+
+%%
+
+// The parser expects the lexer to return 0 on EOF.  Give it a name
+// for clarity.
+const eof = 0
+
+// The parser uses the type <prefix>Lex as a lexer. It must provide
+// the methods Lex(*<prefix>SymType) int and Error(string).
+type exprLex struct {
+	line []byte
+	peek rune
+}
+
+// The parser calls this method to get each new token. This
+// implementation returns operators and NUM.
+func (x *exprLex) Lex(yylval *exprSymType) int {
+	for {
+		c := x.next()
+		switch c {
+		case eof:
+			return eof
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			return x.num(c, yylval)
+		case '+', '-', '*', '/', '(', ')':
+			return int(c)
+
+		// Recognize Unicode multiplication and division
+		// symbols, returning what the parser expects.
+		case '×':
+			return '*'
+		case '÷':
+			return '/'
+
+		case ' ', '\t', '\n', '\r':
+		default:
+			log.Printf("unrecognized character %q", c)
+		}
+	}
+}
+
+// Lex a number.
+func (x *exprLex) num(c rune, yylval *exprSymType) int {
+	add := func(b *bytes.Buffer, c rune) {
+		if _, err := b.WriteRune(c); err != nil {
+			log.Fatalf("WriteRune: %s", err)
+		}
+	}
+	var b bytes.Buffer
+	add(&b, c)
+	L: for {
+		c = x.next()
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', 'e', 'E':
+			add(&b, c)
+		default:
+			break L
+		}
+	}
+	if c != eof {
+		x.peek = c
+	}
+	yylval.num = &big.Rat{}
+	_, ok := yylval.num.SetString(b.String())
+	if !ok {
+		log.Printf("bad number %q", b.String())
+		return eof
+	}
+	return NUM
+}
+
+// Return the next rune for the lexer.
+func (x *exprLex) next() rune {
+	if x.peek != eof {
+		r := x.peek
+		x.peek = eof
+		return r
+	}
+	if len(x.line) == 0 {
+		return eof
+	}
+	c, size := utf8.DecodeRune(x.line)
+	x.line = x.line[size:]
+	if c == utf8.RuneError && size == 1 {
+		log.Print("invalid utf8")
+		return x.next()
+	}
+	return c
+}
+
+// The parser calls this method on a parse error.
+func (x *exprLex) Error(s string) {
+	log.Printf("parse error: %s", s)
+}
+
+func main() {
+	in := bufio.NewReader(os.Stdin)
+	for {
+		if _, err := os.Stdout.WriteString("> "); err != nil {
+			log.Fatalf("WriteString: %s", err)
+		}
+		line, err := in.ReadBytes('\n')
+		if err == io.EOF {
+			return
+		}
+		if err != nil {
+			log.Fatalf("ReadBytes: %s", err)
+		}
+
+		exprParse(&exprLex{line: line})
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/main.go b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/main.go
new file mode 100644
index 0000000..22e3543
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goyacc/testdata/expr/main.go
@@ -0,0 +1,14 @@
+// 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 holds the go generate command to run yacc on the grammar in expr.y.
+// To build expr:
+//	% go generate
+//	% go build
+
+//go:generate goyacc -o expr.go -p "expr" expr.y
+
+// Expr is a simple expression evaluator that serves as a working example of
+// how to use Go's yacc implementation.
+package main
diff --git a/vendor/golang.org/x/tools/cmd/goyacc/yacc.go b/vendor/golang.org/x/tools/cmd/goyacc/yacc.go
new file mode 100644
index 0000000..062bc47
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/goyacc/yacc.go
@@ -0,0 +1,3591 @@
+/*
+Derived from Inferno's utils/iyacc/yacc.c
+http://code.google.com/p/inferno-os/source/browse/utils/iyacc/yacc.c
+
+This copyright NOTICE applies to all files in this directory and
+subdirectories, unless another copyright notice appears in a given
+file or subdirectory.  If you take substantial code from this software to use in
+other programs, you must somehow include with it an appropriate
+copyright notice that includes the copyright notice and the other
+notices below.  It is fine (and often tidier) to do that in a separate
+file such as NOTICE, LICENCE or COPYING.
+
+	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+	Portions Copyright © 1997-1999 Vita Nuova Limited
+	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+	Portions Copyright © 2004,2006 Bruce Ellis
+	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+	Portions Copyright © 2009 The Go Authors. All rights reserved.
+
+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.
+*/
+
+package main
+
+// yacc
+// major difference is lack of stem ("y" variable)
+//
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// the following are adjustable
+// according to memory size
+const (
+	ACTSIZE  = 120000
+	NSTATES  = 8000
+	TEMPSIZE = 8000
+
+	SYMINC   = 50  // increase for non-term or term
+	RULEINC  = 50  // increase for max rule length prodptr[i]
+	PRODINC  = 100 // increase for productions     prodptr
+	WSETINC  = 50  // increase for working sets    wsets
+	STATEINC = 200 // increase for states          statemem
+
+	PRIVATE = 0xE000 // unicode private use
+
+	// relationships which must hold:
+	//	TEMPSIZE >= NTERMS + NNONTERM + 1;
+	//	TEMPSIZE >= NSTATES;
+	//
+
+	NTBASE     = 010000
+	ERRCODE    = 8190
+	ACCEPTCODE = 8191
+	YYLEXUNK   = 3
+	TOKSTART   = 4 //index of first defined token
+)
+
+// no, left, right, binary assoc.
+const (
+	NOASC = iota
+	LASC
+	RASC
+	BASC
+)
+
+// flags for state generation
+const (
+	DONE = iota
+	MUSTDO
+	MUSTLOOKAHEAD
+)
+
+// flags for a rule having an action, and being reduced
+const (
+	ACTFLAG = 1 << (iota + 2)
+	REDFLAG
+)
+
+// output parser flags
+const yyFlag = -1000
+
+// parse tokens
+const (
+	IDENTIFIER = PRIVATE + iota
+	MARK
+	TERM
+	LEFT
+	RIGHT
+	BINARY
+	PREC
+	LCURLY
+	IDENTCOLON
+	NUMBER
+	START
+	TYPEDEF
+	TYPENAME
+	UNION
+	ERROR
+)
+
+const ENDFILE = 0
+const EMPTY = 1
+const WHOKNOWS = 0
+const OK = 1
+const NOMORE = -1000
+
+// macros for getting associativity and precedence levels
+func ASSOC(i int) int { return i & 3 }
+
+func PLEVEL(i int) int { return (i >> 4) & 077 }
+
+func TYPE(i int) int { return (i >> 10) & 077 }
+
+// macros for setting associativity and precedence levels
+func SETASC(i, j int) int { return i | j }
+
+func SETPLEV(i, j int) int { return i | (j << 4) }
+
+func SETTYPE(i, j int) int { return i | (j << 10) }
+
+// I/O descriptors
+var finput *bufio.Reader // input file
+var stderr *bufio.Writer
+var ftable *bufio.Writer    // y.go file
+var fcode = &bytes.Buffer{} // saved code
+var foutput *bufio.Writer   // y.output file
+
+var fmtImported bool // output file has recorded an import of "fmt"
+
+var oflag string  // -o [y.go]		- y.go file
+var vflag string  // -v [y.output]	- y.output file
+var lflag bool    // -l			- disable line directives
+var prefix string // name prefix for identifiers, default yy
+
+func init() {
+	flag.StringVar(&oflag, "o", "y.go", "parser output")
+	flag.StringVar(&prefix, "p", "yy", "name prefix to use in generated code")
+	flag.StringVar(&vflag, "v", "y.output", "create parsing tables")
+	flag.BoolVar(&lflag, "l", false, "disable line directives")
+}
+
+var initialstacksize = 16
+
+// communication variables between various I/O routines
+var infile string  // input file name
+var numbval int    // value of an input number
+var tokname string // input token name, slop for runes and 0
+var tokflag = false
+
+// structure declarations
+type Lkset []int
+
+type Pitem struct {
+	prod   []int
+	off    int // offset within the production
+	first  int // first term or non-term in item
+	prodno int // production number for sorting
+}
+
+type Item struct {
+	pitem Pitem
+	look  Lkset
+}
+
+type Symb struct {
+	name    string
+	noconst bool
+	value   int
+}
+
+type Wset struct {
+	pitem Pitem
+	flag  int
+	ws    Lkset
+}
+
+// storage of types
+var ntypes int                     // number of types defined
+var typeset = make(map[int]string) // pointers to type tags
+
+// token information
+
+var ntokens = 0 // number of tokens
+var tokset []Symb
+var toklev []int // vector with the precedence of the terminals
+
+// nonterminal information
+
+var nnonter = -1 // the number of nonterminals
+var nontrst []Symb
+var start int // start symbol
+
+// state information
+
+var nstate = 0                      // number of states
+var pstate = make([]int, NSTATES+2) // index into statemem to the descriptions of the states
+var statemem []Item
+var tystate = make([]int, NSTATES) // contains type information about the states
+var tstates []int                  // states generated by terminal gotos
+var ntstates []int                 // states generated by nonterminal gotos
+var mstates = make([]int, NSTATES) // chain of overflows of term/nonterm generation lists
+var lastred int                    // number of last reduction of a state
+var defact = make([]int, NSTATES)  // default actions of states
+
+// lookahead set information
+
+var nolook = 0  // flag to turn off lookahead computations
+var tbitset = 0 // size of lookahead sets
+var clset Lkset // temporary storage for lookahead computations
+
+// working set information
+
+var wsets []Wset
+var cwp int
+
+// storage for action table
+
+var amem []int                   // action table storage
+var memp int                     // next free action table position
+var indgo = make([]int, NSTATES) // index to the stored goto table
+
+// temporary vector, indexable by states, terms, or ntokens
+
+var temp1 = make([]int, TEMPSIZE) // temporary storage, indexed by terms + ntokens or states
+var lineno = 1                    // current input line number
+var fatfl = 1                     // if on, error is fatal
+var nerrors = 0                   // number of errors
+
+// assigned token type values
+
+var extval = 0
+
+// grammar rule information
+
+var nprod = 1      // number of productions
+var prdptr [][]int // pointers to descriptions of productions
+var levprd []int   // precedence levels for the productions
+var rlines []int   // line number for this rule
+
+// statistics collection variables
+
+var zzgoent = 0
+var zzgobest = 0
+var zzacent = 0
+var zzexcp = 0
+var zzclose = 0
+var zzrrconf = 0
+var zzsrconf = 0
+var zzstate = 0
+
+// optimizer arrays
+
+var yypgo [][]int
+var optst [][]int
+var ggreed []int
+var pgo []int
+
+var maxspr int // maximum spread of any entry
+var maxoff int // maximum offset into a array
+var maxa int
+
+// storage for information about the nonterminals
+
+var pres [][][]int // vector of pointers to productions yielding each nonterminal
+var pfirst []Lkset
+var pempty []int // vector of nonterminals nontrivially deriving e
+
+// random stuff picked out from between functions
+
+var indebug = 0 // debugging flag for cpfir
+var pidebug = 0 // debugging flag for putitem
+var gsdebug = 0 // debugging flag for stagen
+var cldebug = 0 // debugging flag for closure
+var pkdebug = 0 // debugging flag for apack
+var g2debug = 0 // debugging for go2gen
+var adb = 0     // debugging for callopt
+
+type Resrv struct {
+	name  string
+	value int
+}
+
+var resrv = []Resrv{
+	{"binary", BINARY},
+	{"left", LEFT},
+	{"nonassoc", BINARY},
+	{"prec", PREC},
+	{"right", RIGHT},
+	{"start", START},
+	{"term", TERM},
+	{"token", TERM},
+	{"type", TYPEDEF},
+	{"union", UNION},
+	{"struct", UNION},
+	{"error", ERROR},
+}
+
+type Error struct {
+	lineno int
+	tokens []string
+	msg    string
+}
+
+var errors []Error
+
+type Row struct {
+	actions       []int
+	defaultAction int
+}
+
+var stateTable []Row
+
+var zznewstate = 0
+
+const EOF = -1
+
+func main() {
+
+	setup() // initialize and read productions
+
+	tbitset = (ntokens + 32) / 32
+	cpres()  // make table of which productions yield a given nonterminal
+	cempty() // make a table of which nonterminals can match the empty string
+	cpfir()  // make a table of firsts of nonterminals
+
+	stagen() // generate the states
+
+	yypgo = make([][]int, nnonter+1)
+	optst = make([][]int, nstate)
+	output() // write the states and the tables
+	go2out()
+
+	hideprod()
+	summary()
+
+	callopt()
+
+	others()
+
+	exit(0)
+}
+
+func setup() {
+	var j, ty int
+
+	stderr = bufio.NewWriter(os.Stderr)
+	foutput = nil
+
+	flag.Parse()
+	if flag.NArg() != 1 {
+		usage()
+	}
+	if initialstacksize < 1 {
+		// never set so cannot happen
+		fmt.Fprintf(stderr, "yacc: stack size too small\n")
+		usage()
+	}
+	yaccpar = strings.Replace(yaccpartext, "$$", prefix, -1)
+	openup()
+
+	defin(0, "$end")
+	extval = PRIVATE // tokens start in unicode 'private use'
+	defin(0, "error")
+	defin(1, "$accept")
+	defin(0, "$unk")
+	i := 0
+
+	t := gettok()
+
+outer:
+	for {
+		switch t {
+		default:
+			errorf("syntax error tok=%v", t-PRIVATE)
+
+		case MARK, ENDFILE:
+			break outer
+
+		case ';':
+			// Do nothing.
+
+		case START:
+			t = gettok()
+			if t != IDENTIFIER {
+				errorf("bad %%start construction")
+			}
+			start = chfind(1, tokname)
+
+		case ERROR:
+			lno := lineno
+			var tokens []string
+			for {
+				t := gettok()
+				if t == ':' {
+					break
+				}
+				if t != IDENTIFIER && t != IDENTCOLON {
+					errorf("bad syntax in %%error")
+				}
+				tokens = append(tokens, tokname)
+				if t == IDENTCOLON {
+					break
+				}
+			}
+			if gettok() != IDENTIFIER {
+				errorf("bad syntax in %%error")
+			}
+			errors = append(errors, Error{lno, tokens, tokname})
+
+		case TYPEDEF:
+			t = gettok()
+			if t != TYPENAME {
+				errorf("bad syntax in %%type")
+			}
+			ty = numbval
+			for {
+				t = gettok()
+				switch t {
+				case IDENTIFIER:
+					t = chfind(1, tokname)
+					if t < NTBASE {
+						j = TYPE(toklev[t])
+						if j != 0 && j != ty {
+							errorf("type redeclaration of token %s",
+								tokset[t].name)
+						} else {
+							toklev[t] = SETTYPE(toklev[t], ty)
+						}
+					} else {
+						j = nontrst[t-NTBASE].value
+						if j != 0 && j != ty {
+							errorf("type redeclaration of nonterminal %v",
+								nontrst[t-NTBASE].name)
+						} else {
+							nontrst[t-NTBASE].value = ty
+						}
+					}
+					continue
+
+				case ',':
+					continue
+				}
+				break
+			}
+			continue
+
+		case UNION:
+			cpyunion()
+
+		case LEFT, BINARY, RIGHT, TERM:
+			// nonzero means new prec. and assoc.
+			lev := t - TERM
+			if lev != 0 {
+				i++
+			}
+			ty = 0
+
+			// get identifiers so defined
+			t = gettok()
+
+			// there is a type defined
+			if t == TYPENAME {
+				ty = numbval
+				t = gettok()
+			}
+			for {
+				switch t {
+				case ',':
+					t = gettok()
+					continue
+
+				case ';':
+					// Do nothing.
+
+				case IDENTIFIER:
+					j = chfind(0, tokname)
+					if j >= NTBASE {
+						errorf("%v defined earlier as nonterminal", tokname)
+					}
+					if lev != 0 {
+						if ASSOC(toklev[j]) != 0 {
+							errorf("redeclaration of precedence of %v", tokname)
+						}
+						toklev[j] = SETASC(toklev[j], lev)
+						toklev[j] = SETPLEV(toklev[j], i)
+					}
+					if ty != 0 {
+						if TYPE(toklev[j]) != 0 {
+							errorf("redeclaration of type of %v", tokname)
+						}
+						toklev[j] = SETTYPE(toklev[j], ty)
+					}
+					t = gettok()
+					if t == NUMBER {
+						tokset[j].value = numbval
+						t = gettok()
+					}
+
+					continue
+				}
+				break
+			}
+			continue
+
+		case LCURLY:
+			cpycode()
+		}
+		t = gettok()
+	}
+
+	if t == ENDFILE {
+		errorf("unexpected EOF before %%")
+	}
+
+	fmt.Fprintf(fcode, "switch %snt {\n", prefix)
+
+	moreprod()
+	prdptr[0] = []int{NTBASE, start, 1, 0}
+
+	nprod = 1
+	curprod := make([]int, RULEINC)
+	t = gettok()
+	if t != IDENTCOLON {
+		errorf("bad syntax on first rule")
+	}
+
+	if start == 0 {
+		prdptr[0][1] = chfind(1, tokname)
+	}
+
+	// read rules
+	// put into prdptr array in the format
+	// target
+	// followed by id's of terminals and non-terminals
+	// followed by -nprod
+
+	for t != MARK && t != ENDFILE {
+		mem := 0
+
+		// process a rule
+		rlines[nprod] = lineno
+		ruleline := lineno
+		if t == '|' {
+			curprod[mem] = prdptr[nprod-1][0]
+			mem++
+		} else if t == IDENTCOLON {
+			curprod[mem] = chfind(1, tokname)
+			if curprod[mem] < NTBASE {
+				lerrorf(ruleline, "token illegal on LHS of grammar rule")
+			}
+			mem++
+		} else {
+			lerrorf(ruleline, "illegal rule: missing semicolon or | ?")
+		}
+
+		// read rule body
+		t = gettok()
+		for {
+			for t == IDENTIFIER {
+				curprod[mem] = chfind(1, tokname)
+				if curprod[mem] < NTBASE {
+					levprd[nprod] = toklev[curprod[mem]]
+				}
+				mem++
+				if mem >= len(curprod) {
+					ncurprod := make([]int, mem+RULEINC)
+					copy(ncurprod, curprod)
+					curprod = ncurprod
+				}
+				t = gettok()
+			}
+			if t == PREC {
+				if gettok() != IDENTIFIER {
+					lerrorf(ruleline, "illegal %%prec syntax")
+				}
+				j = chfind(2, tokname)
+				if j >= NTBASE {
+					lerrorf(ruleline, "nonterminal "+nontrst[j-NTBASE].name+" illegal after %%prec")
+				}
+				levprd[nprod] = toklev[j]
+				t = gettok()
+			}
+			if t != '=' {
+				break
+			}
+			levprd[nprod] |= ACTFLAG
+			fmt.Fprintf(fcode, "\n\tcase %v:", nprod)
+			fmt.Fprintf(fcode, "\n\t\t%sDollar = %sS[%spt-%v:%spt+1]", prefix, prefix, prefix, mem-1, prefix)
+			cpyact(curprod, mem)
+
+			// action within rule...
+			t = gettok()
+			if t == IDENTIFIER {
+				// make it a nonterminal
+				j = chfind(1, fmt.Sprintf("$$%v", nprod))
+
+				//
+				// the current rule will become rule number nprod+1
+				// enter null production for action
+				//
+				prdptr[nprod] = make([]int, 2)
+				prdptr[nprod][0] = j
+				prdptr[nprod][1] = -nprod
+
+				// update the production information
+				nprod++
+				moreprod()
+				levprd[nprod] = levprd[nprod-1] & ^ACTFLAG
+				levprd[nprod-1] = ACTFLAG
+				rlines[nprod] = lineno
+
+				// make the action appear in the original rule
+				curprod[mem] = j
+				mem++
+				if mem >= len(curprod) {
+					ncurprod := make([]int, mem+RULEINC)
+					copy(ncurprod, curprod)
+					curprod = ncurprod
+				}
+			}
+		}
+
+		for t == ';' {
+			t = gettok()
+		}
+		curprod[mem] = -nprod
+		mem++
+
+		// check that default action is reasonable
+		if ntypes != 0 && (levprd[nprod]&ACTFLAG) == 0 &&
+			nontrst[curprod[0]-NTBASE].value != 0 {
+			// no explicit action, LHS has value
+			tempty := curprod[1]
+			if tempty < 0 {
+				lerrorf(ruleline, "must return a value, since LHS has a type")
+			}
+			if tempty >= NTBASE {
+				tempty = nontrst[tempty-NTBASE].value
+			} else {
+				tempty = TYPE(toklev[tempty])
+			}
+			if tempty != nontrst[curprod[0]-NTBASE].value {
+				lerrorf(ruleline, "default action causes potential type clash")
+			}
+		}
+		moreprod()
+		prdptr[nprod] = make([]int, mem)
+		copy(prdptr[nprod], curprod)
+		nprod++
+		moreprod()
+		levprd[nprod] = 0
+	}
+
+	if TEMPSIZE < ntokens+nnonter+1 {
+		errorf("too many tokens (%d) or non-terminals (%d)", ntokens, nnonter)
+	}
+
+	//
+	// end of all rules
+	// dump out the prefix code
+	//
+
+	fmt.Fprintf(fcode, "\n\t}")
+
+	// put out non-literal terminals
+	for i := TOKSTART; i <= ntokens; i++ {
+		// non-literals
+		if !tokset[i].noconst {
+			fmt.Fprintf(ftable, "const %v = %v\n", tokset[i].name, tokset[i].value)
+		}
+	}
+
+	// put out names of tokens
+	ftable.WriteRune('\n')
+	fmt.Fprintf(ftable, "var %sToknames = [...]string{\n", prefix)
+	for i := 1; i <= ntokens; i++ {
+		fmt.Fprintf(ftable, "\t%q,\n", tokset[i].name)
+	}
+	fmt.Fprintf(ftable, "}\n")
+
+	// put out names of states.
+	// commented out to avoid a huge table just for debugging.
+	// re-enable to have the names in the binary.
+	fmt.Fprintf(ftable, "var %sStatenames = [...]string{", prefix)
+	//	for i:=TOKSTART; i<=ntokens; i++ {
+	//		fmt.Fprintf(ftable, "\t%q,\n", tokset[i].name);
+	//	}
+	fmt.Fprintf(ftable, "}\n")
+
+	ftable.WriteRune('\n')
+	fmt.Fprintf(ftable, "const %sEofCode = 1\n", prefix)
+	fmt.Fprintf(ftable, "const %sErrCode = 2\n", prefix)
+	fmt.Fprintf(ftable, "const %sInitialStackSize = %v\n", prefix, initialstacksize)
+
+	//
+	// copy any postfix code
+	//
+	if t == MARK {
+		if !lflag {
+			fmt.Fprintf(ftable, "\n//line %v:%v\n", infile, lineno)
+		}
+		for {
+			c := getrune(finput)
+			if c == EOF {
+				break
+			}
+			ftable.WriteRune(c)
+		}
+	}
+}
+
+//
+// allocate enough room to hold another production
+//
+func moreprod() {
+	n := len(prdptr)
+	if nprod >= n {
+		nn := n + PRODINC
+		aprod := make([][]int, nn)
+		alevprd := make([]int, nn)
+		arlines := make([]int, nn)
+
+		copy(aprod, prdptr)
+		copy(alevprd, levprd)
+		copy(arlines, rlines)
+
+		prdptr = aprod
+		levprd = alevprd
+		rlines = arlines
+	}
+}
+
+//
+// define s to be a terminal if nt==0
+// or a nonterminal if nt==1
+//
+func defin(nt int, s string) int {
+	val := 0
+	if nt != 0 {
+		nnonter++
+		if nnonter >= len(nontrst) {
+			anontrst := make([]Symb, nnonter+SYMINC)
+			copy(anontrst, nontrst)
+			nontrst = anontrst
+		}
+		nontrst[nnonter] = Symb{name: s}
+		return NTBASE + nnonter
+	}
+
+	// must be a token
+	ntokens++
+	if ntokens >= len(tokset) {
+		nn := ntokens + SYMINC
+		atokset := make([]Symb, nn)
+		atoklev := make([]int, nn)
+
+		copy(atoklev, toklev)
+		copy(atokset, tokset)
+
+		tokset = atokset
+		toklev = atoklev
+	}
+	tokset[ntokens].name = s
+	toklev[ntokens] = 0
+
+	// establish value for token
+	// single character literal
+	if s[0] == '\'' || s[0] == '"' {
+		q, err := strconv.Unquote(s)
+		if err != nil {
+			errorf("invalid token: %s", err)
+		}
+		rq := []rune(q)
+		if len(rq) != 1 {
+			errorf("character token too long: %s", s)
+		}
+		val = int(rq[0])
+		if val == 0 {
+			errorf("token value 0 is illegal")
+		}
+		tokset[ntokens].noconst = true
+	} else {
+		val = extval
+		extval++
+		if s[0] == '$' {
+			tokset[ntokens].noconst = true
+		}
+	}
+
+	tokset[ntokens].value = val
+	return ntokens
+}
+
+var peekline = 0
+
+func gettok() int {
+	var i int
+	var match, c rune
+
+	tokname = ""
+	for {
+		lineno += peekline
+		peekline = 0
+		c = getrune(finput)
+		for c == ' ' || c == '\n' || c == '\t' || c == '\v' || c == '\r' {
+			if c == '\n' {
+				lineno++
+			}
+			c = getrune(finput)
+		}
+
+		// skip comment -- fix
+		if c != '/' {
+			break
+		}
+		lineno += skipcom()
+	}
+
+	switch c {
+	case EOF:
+		if tokflag {
+			fmt.Printf(">>> ENDFILE %v\n", lineno)
+		}
+		return ENDFILE
+
+	case '{':
+		ungetrune(finput, c)
+		if tokflag {
+			fmt.Printf(">>> ={ %v\n", lineno)
+		}
+		return '='
+
+	case '<':
+		// get, and look up, a type name (union member name)
+		c = getrune(finput)
+		for c != '>' && c != EOF && c != '\n' {
+			tokname += string(c)
+			c = getrune(finput)
+		}
+
+		if c != '>' {
+			errorf("unterminated < ... > clause")
+		}
+
+		for i = 1; i <= ntypes; i++ {
+			if typeset[i] == tokname {
+				numbval = i
+				if tokflag {
+					fmt.Printf(">>> TYPENAME old <%v> %v\n", tokname, lineno)
+				}
+				return TYPENAME
+			}
+		}
+		ntypes++
+		numbval = ntypes
+		typeset[numbval] = tokname
+		if tokflag {
+			fmt.Printf(">>> TYPENAME new <%v> %v\n", tokname, lineno)
+		}
+		return TYPENAME
+
+	case '"', '\'':
+		match = c
+		tokname = string(c)
+		for {
+			c = getrune(finput)
+			if c == '\n' || c == EOF {
+				errorf("illegal or missing ' or \"")
+			}
+			if c == '\\' {
+				tokname += string('\\')
+				c = getrune(finput)
+			} else if c == match {
+				if tokflag {
+					fmt.Printf(">>> IDENTIFIER \"%v\" %v\n", tokname, lineno)
+				}
+				tokname += string(c)
+				return IDENTIFIER
+			}
+			tokname += string(c)
+		}
+
+	case '%':
+		c = getrune(finput)
+		switch c {
+		case '%':
+			if tokflag {
+				fmt.Printf(">>> MARK %%%% %v\n", lineno)
+			}
+			return MARK
+		case '=':
+			if tokflag {
+				fmt.Printf(">>> PREC %%= %v\n", lineno)
+			}
+			return PREC
+		case '{':
+			if tokflag {
+				fmt.Printf(">>> LCURLY %%{ %v\n", lineno)
+			}
+			return LCURLY
+		}
+
+		getword(c)
+		// find a reserved word
+		for i := range resrv {
+			if tokname == resrv[i].name {
+				if tokflag {
+					fmt.Printf(">>> %%%v %v %v\n", tokname,
+						resrv[i].value-PRIVATE, lineno)
+				}
+				return resrv[i].value
+			}
+		}
+		errorf("invalid escape, or illegal reserved word: %v", tokname)
+
+	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		numbval = int(c - '0')
+		for {
+			c = getrune(finput)
+			if !isdigit(c) {
+				break
+			}
+			numbval = numbval*10 + int(c-'0')
+		}
+		ungetrune(finput, c)
+		if tokflag {
+			fmt.Printf(">>> NUMBER %v %v\n", numbval, lineno)
+		}
+		return NUMBER
+
+	default:
+		if isword(c) || c == '.' || c == '$' {
+			getword(c)
+			break
+		}
+		if tokflag {
+			fmt.Printf(">>> OPERATOR %v %v\n", string(c), lineno)
+		}
+		return int(c)
+	}
+
+	// look ahead to distinguish IDENTIFIER from IDENTCOLON
+	c = getrune(finput)
+	for c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\r' || c == '/' {
+		if c == '\n' {
+			peekline++
+		}
+		// look for comments
+		if c == '/' {
+			peekline += skipcom()
+		}
+		c = getrune(finput)
+	}
+	if c == ':' {
+		if tokflag {
+			fmt.Printf(">>> IDENTCOLON %v: %v\n", tokname, lineno)
+		}
+		return IDENTCOLON
+	}
+
+	ungetrune(finput, c)
+	if tokflag {
+		fmt.Printf(">>> IDENTIFIER %v %v\n", tokname, lineno)
+	}
+	return IDENTIFIER
+}
+
+func getword(c rune) {
+	tokname = ""
+	for isword(c) || isdigit(c) || c == '.' || c == '$' {
+		tokname += string(c)
+		c = getrune(finput)
+	}
+	ungetrune(finput, c)
+}
+
+//
+// determine the type of a symbol
+//
+func fdtype(t int) int {
+	var v int
+	var s string
+
+	if t >= NTBASE {
+		v = nontrst[t-NTBASE].value
+		s = nontrst[t-NTBASE].name
+	} else {
+		v = TYPE(toklev[t])
+		s = tokset[t].name
+	}
+	if v <= 0 {
+		errorf("must specify type for %v", s)
+	}
+	return v
+}
+
+func chfind(t int, s string) int {
+	if s[0] == '"' || s[0] == '\'' {
+		t = 0
+	}
+	for i := 0; i <= ntokens; i++ {
+		if s == tokset[i].name {
+			return i
+		}
+	}
+	for i := 0; i <= nnonter; i++ {
+		if s == nontrst[i].name {
+			return NTBASE + i
+		}
+	}
+
+	// cannot find name
+	if t > 1 {
+		errorf("%v should have been defined earlier", s)
+	}
+	return defin(t, s)
+}
+
+//
+// copy the union declaration to the output, and the define file if present
+//
+func cpyunion() {
+
+	if !lflag {
+		fmt.Fprintf(ftable, "\n//line %v:%v\n", infile, lineno)
+	}
+	fmt.Fprintf(ftable, "type %sSymType struct", prefix)
+
+	level := 0
+
+out:
+	for {
+		c := getrune(finput)
+		if c == EOF {
+			errorf("EOF encountered while processing %%union")
+		}
+		ftable.WriteRune(c)
+		switch c {
+		case '\n':
+			lineno++
+		case '{':
+			if level == 0 {
+				fmt.Fprintf(ftable, "\n\tyys int")
+			}
+			level++
+		case '}':
+			level--
+			if level == 0 {
+				break out
+			}
+		}
+	}
+	fmt.Fprintf(ftable, "\n\n")
+}
+
+//
+// saves code between %{ and %}
+// adds an import for __fmt__ the first time
+//
+func cpycode() {
+	lno := lineno
+
+	c := getrune(finput)
+	if c == '\n' {
+		c = getrune(finput)
+		lineno++
+	}
+	if !lflag {
+		fmt.Fprintf(ftable, "\n//line %v:%v\n", infile, lineno)
+	}
+	// accumulate until %}
+	code := make([]rune, 0, 1024)
+	for c != EOF {
+		if c == '%' {
+			c = getrune(finput)
+			if c == '}' {
+				emitcode(code, lno+1)
+				return
+			}
+			code = append(code, '%')
+		}
+		code = append(code, c)
+		if c == '\n' {
+			lineno++
+		}
+		c = getrune(finput)
+	}
+	lineno = lno
+	errorf("eof before %%}")
+}
+
+//
+// emits code saved up from between %{ and %}
+// called by cpycode
+// adds an import for __yyfmt__ after the package clause
+//
+func emitcode(code []rune, lineno int) {
+	for i, line := range lines(code) {
+		writecode(line)
+		if !fmtImported && isPackageClause(line) {
+			fmt.Fprintln(ftable, `import __yyfmt__ "fmt"`)
+			if !lflag {
+				fmt.Fprintf(ftable, "//line %v:%v\n\t\t", infile, lineno+i)
+			}
+			fmtImported = true
+		}
+	}
+}
+
+//
+// does this line look like a package clause?  not perfect: might be confused by early comments.
+//
+func isPackageClause(line []rune) bool {
+	line = skipspace(line)
+
+	// must be big enough.
+	if len(line) < len("package X\n") {
+		return false
+	}
+
+	// must start with "package"
+	for i, r := range []rune("package") {
+		if line[i] != r {
+			return false
+		}
+	}
+	line = skipspace(line[len("package"):])
+
+	// must have another identifier.
+	if len(line) == 0 || (!unicode.IsLetter(line[0]) && line[0] != '_') {
+		return false
+	}
+	for len(line) > 0 {
+		if !unicode.IsLetter(line[0]) && !unicode.IsDigit(line[0]) && line[0] != '_' {
+			break
+		}
+		line = line[1:]
+	}
+	line = skipspace(line)
+
+	// eol, newline, or comment must follow
+	if len(line) == 0 {
+		return true
+	}
+	if line[0] == '\r' || line[0] == '\n' {
+		return true
+	}
+	if len(line) >= 2 {
+		return line[0] == '/' && (line[1] == '/' || line[1] == '*')
+	}
+	return false
+}
+
+//
+// skip initial spaces
+//
+func skipspace(line []rune) []rune {
+	for len(line) > 0 {
+		if line[0] != ' ' && line[0] != '\t' {
+			break
+		}
+		line = line[1:]
+	}
+	return line
+}
+
+//
+// break code into lines
+//
+func lines(code []rune) [][]rune {
+	l := make([][]rune, 0, 100)
+	for len(code) > 0 {
+		// one line per loop
+		var i int
+		for i = range code {
+			if code[i] == '\n' {
+				break
+			}
+		}
+		l = append(l, code[:i+1])
+		code = code[i+1:]
+	}
+	return l
+}
+
+//
+// writes code to ftable
+//
+func writecode(code []rune) {
+	for _, r := range code {
+		ftable.WriteRune(r)
+	}
+}
+
+//
+// skip over comments
+// skipcom is called after reading a '/'
+//
+func skipcom() int {
+	c := getrune(finput)
+	if c == '/' {
+		for c != EOF {
+			if c == '\n' {
+				return 1
+			}
+			c = getrune(finput)
+		}
+		errorf("EOF inside comment")
+		return 0
+	}
+	if c != '*' {
+		errorf("illegal comment")
+	}
+
+	nl := 0 // lines skipped
+	c = getrune(finput)
+
+l1:
+	switch c {
+	case '*':
+		c = getrune(finput)
+		if c == '/' {
+			break
+		}
+		goto l1
+
+	case '\n':
+		nl++
+		fallthrough
+
+	default:
+		c = getrune(finput)
+		goto l1
+	}
+	return nl
+}
+
+//
+// copy action to the next ; or closing }
+//
+func cpyact(curprod []int, max int) {
+
+	if !lflag {
+		fmt.Fprintf(fcode, "\n\t\t//line %v:%v", infile, lineno)
+	}
+	fmt.Fprint(fcode, "\n\t\t")
+
+	lno := lineno
+	brac := 0
+
+loop:
+	for {
+		c := getrune(finput)
+
+	swt:
+		switch c {
+		case ';':
+			if brac == 0 {
+				fcode.WriteRune(c)
+				return
+			}
+
+		case '{':
+			brac++
+
+		case '$':
+			s := 1
+			tok := -1
+			c = getrune(finput)
+
+			// type description
+			if c == '<' {
+				ungetrune(finput, c)
+				if gettok() != TYPENAME {
+					errorf("bad syntax on $<ident> clause")
+				}
+				tok = numbval
+				c = getrune(finput)
+			}
+			if c == '$' {
+				fmt.Fprintf(fcode, "%sVAL", prefix)
+
+				// put out the proper tag...
+				if ntypes != 0 {
+					if tok < 0 {
+						tok = fdtype(curprod[0])
+					}
+					fmt.Fprintf(fcode, ".%v", typeset[tok])
+				}
+				continue loop
+			}
+			if c == '-' {
+				s = -s
+				c = getrune(finput)
+			}
+			j := 0
+			if isdigit(c) {
+				for isdigit(c) {
+					j = j*10 + int(c-'0')
+					c = getrune(finput)
+				}
+				ungetrune(finput, c)
+				j = j * s
+				if j >= max {
+					errorf("Illegal use of $%v", j)
+				}
+			} else if isword(c) || c == '.' {
+				// look for $name
+				ungetrune(finput, c)
+				if gettok() != IDENTIFIER {
+					errorf("$ must be followed by an identifier")
+				}
+				tokn := chfind(2, tokname)
+				fnd := -1
+				c = getrune(finput)
+				if c != '@' {
+					ungetrune(finput, c)
+				} else if gettok() != NUMBER {
+					errorf("@ must be followed by number")
+				} else {
+					fnd = numbval
+				}
+				for j = 1; j < max; j++ {
+					if tokn == curprod[j] {
+						fnd--
+						if fnd <= 0 {
+							break
+						}
+					}
+				}
+				if j >= max {
+					errorf("$name or $name@number not found")
+				}
+			} else {
+				fcode.WriteRune('$')
+				if s < 0 {
+					fcode.WriteRune('-')
+				}
+				ungetrune(finput, c)
+				continue loop
+			}
+			fmt.Fprintf(fcode, "%sDollar[%v]", prefix, j)
+
+			// put out the proper tag
+			if ntypes != 0 {
+				if j <= 0 && tok < 0 {
+					errorf("must specify type of $%v", j)
+				}
+				if tok < 0 {
+					tok = fdtype(curprod[j])
+				}
+				fmt.Fprintf(fcode, ".%v", typeset[tok])
+			}
+			continue loop
+
+		case '}':
+			brac--
+			if brac != 0 {
+				break
+			}
+			fcode.WriteRune(c)
+			return
+
+		case '/':
+			nc := getrune(finput)
+			if nc != '/' && nc != '*' {
+				ungetrune(finput, nc)
+				break
+			}
+			// a comment
+			fcode.WriteRune(c)
+			fcode.WriteRune(nc)
+			c = getrune(finput)
+			for c != EOF {
+				switch {
+				case c == '\n':
+					lineno++
+					if nc == '/' { // end of // comment
+						break swt
+					}
+				case c == '*' && nc == '*': // end of /* comment?
+					nnc := getrune(finput)
+					if nnc == '/' {
+						fcode.WriteRune('*')
+						fcode.WriteRune('/')
+						c = getrune(finput)
+						break swt
+					}
+					ungetrune(finput, nnc)
+				}
+				fcode.WriteRune(c)
+				c = getrune(finput)
+			}
+			errorf("EOF inside comment")
+
+		case '\'', '"':
+			// character string or constant
+			match := c
+			fcode.WriteRune(c)
+			c = getrune(finput)
+			for c != EOF {
+				if c == '\\' {
+					fcode.WriteRune(c)
+					c = getrune(finput)
+					if c == '\n' {
+						lineno++
+					}
+				} else if c == match {
+					break swt
+				}
+				if c == '\n' {
+					errorf("newline in string or char const")
+				}
+				fcode.WriteRune(c)
+				c = getrune(finput)
+			}
+			errorf("EOF in string or character constant")
+
+		case EOF:
+			lineno = lno
+			errorf("action does not terminate")
+
+		case '\n':
+			fmt.Fprint(fcode, "\n\t")
+			lineno++
+			continue loop
+		}
+
+		fcode.WriteRune(c)
+	}
+}
+
+func openup() {
+	infile = flag.Arg(0)
+	finput = open(infile)
+	if finput == nil {
+		errorf("cannot open %v", infile)
+	}
+
+	foutput = nil
+	if vflag != "" {
+		foutput = create(vflag)
+		if foutput == nil {
+			errorf("can't create file %v", vflag)
+		}
+	}
+
+	ftable = nil
+	if oflag == "" {
+		oflag = "y.go"
+	}
+	ftable = create(oflag)
+	if ftable == nil {
+		errorf("can't create file %v", oflag)
+	}
+
+}
+
+//
+// return a pointer to the name of symbol i
+//
+func symnam(i int) string {
+	var s string
+
+	if i >= NTBASE {
+		s = nontrst[i-NTBASE].name
+	} else {
+		s = tokset[i].name
+	}
+	return s
+}
+
+//
+// set elements 0 through n-1 to c
+//
+func aryfil(v []int, n, c int) {
+	for i := 0; i < n; i++ {
+		v[i] = c
+	}
+}
+
+//
+// compute an array with the beginnings of productions yielding given nonterminals
+// The array pres points to these lists
+// the array pyield has the lists: the total size is only NPROD+1
+//
+func cpres() {
+	pres = make([][][]int, nnonter+1)
+	curres := make([][]int, nprod)
+
+	if false {
+		for j := 0; j <= nnonter; j++ {
+			fmt.Printf("nnonter[%v] = %v\n", j, nontrst[j].name)
+		}
+		for j := 0; j < nprod; j++ {
+			fmt.Printf("prdptr[%v][0] = %v+NTBASE\n", j, prdptr[j][0]-NTBASE)
+		}
+	}
+
+	fatfl = 0 // make undefined symbols nonfatal
+	for i := 0; i <= nnonter; i++ {
+		n := 0
+		c := i + NTBASE
+		for j := 0; j < nprod; j++ {
+			if prdptr[j][0] == c {
+				curres[n] = prdptr[j][1:]
+				n++
+			}
+		}
+		if n == 0 {
+			errorf("nonterminal %v not defined", nontrst[i].name)
+			continue
+		}
+		pres[i] = make([][]int, n)
+		copy(pres[i], curres)
+	}
+	fatfl = 1
+	if nerrors != 0 {
+		summary()
+		exit(1)
+	}
+}
+
+//
+// mark nonterminals which derive the empty string
+// also, look for nonterminals which don't derive any token strings
+//
+func cempty() {
+	var i, p, np int
+	var prd []int
+
+	pempty = make([]int, nnonter+1)
+
+	// first, use the array pempty to detect productions that can never be reduced
+	// set pempty to WHONOWS
+	aryfil(pempty, nnonter+1, WHOKNOWS)
+
+	// now, look at productions, marking nonterminals which derive something
+more:
+	for {
+		for i = 0; i < nprod; i++ {
+			prd = prdptr[i]
+			if pempty[prd[0]-NTBASE] != 0 {
+				continue
+			}
+			np = len(prd) - 1
+			for p = 1; p < np; p++ {
+				if prd[p] >= NTBASE && pempty[prd[p]-NTBASE] == WHOKNOWS {
+					break
+				}
+			}
+			// production can be derived
+			if p == np {
+				pempty[prd[0]-NTBASE] = OK
+				continue more
+			}
+		}
+		break
+	}
+
+	// now, look at the nonterminals, to see if they are all OK
+	for i = 0; i <= nnonter; i++ {
+		// the added production rises or falls as the start symbol ...
+		if i == 0 {
+			continue
+		}
+		if pempty[i] != OK {
+			fatfl = 0
+			errorf("nonterminal " + nontrst[i].name + " never derives any token string")
+		}
+	}
+
+	if nerrors != 0 {
+		summary()
+		exit(1)
+	}
+
+	// now, compute the pempty array, to see which nonterminals derive the empty string
+	// set pempty to WHOKNOWS
+	aryfil(pempty, nnonter+1, WHOKNOWS)
+
+	// loop as long as we keep finding empty nonterminals
+
+again:
+	for {
+	next:
+		for i = 1; i < nprod; i++ {
+			// not known to be empty
+			prd = prdptr[i]
+			if pempty[prd[0]-NTBASE] != WHOKNOWS {
+				continue
+			}
+			np = len(prd) - 1
+			for p = 1; p < np; p++ {
+				if prd[p] < NTBASE || pempty[prd[p]-NTBASE] != EMPTY {
+					continue next
+				}
+			}
+
+			// we have a nontrivially empty nonterminal
+			pempty[prd[0]-NTBASE] = EMPTY
+
+			// got one ... try for another
+			continue again
+		}
+		return
+	}
+}
+
+//
+// compute an array with the first of nonterminals
+//
+func cpfir() {
+	var s, n, p, np, ch, i int
+	var curres [][]int
+	var prd []int
+
+	wsets = make([]Wset, nnonter+WSETINC)
+	pfirst = make([]Lkset, nnonter+1)
+	for i = 0; i <= nnonter; i++ {
+		wsets[i].ws = mkset()
+		pfirst[i] = mkset()
+		curres = pres[i]
+		n = len(curres)
+
+		// initially fill the sets
+		for s = 0; s < n; s++ {
+			prd = curres[s]
+			np = len(prd) - 1
+			for p = 0; p < np; p++ {
+				ch = prd[p]
+				if ch < NTBASE {
+					setbit(pfirst[i], ch)
+					break
+				}
+				if pempty[ch-NTBASE] == 0 {
+					break
+				}
+			}
+		}
+	}
+
+	// now, reflect transitivity
+	changes := 1
+	for changes != 0 {
+		changes = 0
+		for i = 0; i <= nnonter; i++ {
+			curres = pres[i]
+			n = len(curres)
+			for s = 0; s < n; s++ {
+				prd = curres[s]
+				np = len(prd) - 1
+				for p = 0; p < np; p++ {
+					ch = prd[p] - NTBASE
+					if ch < 0 {
+						break
+					}
+					changes |= setunion(pfirst[i], pfirst[ch])
+					if pempty[ch] == 0 {
+						break
+					}
+				}
+			}
+		}
+	}
+
+	if indebug == 0 {
+		return
+	}
+	if foutput != nil {
+		for i = 0; i <= nnonter; i++ {
+			fmt.Fprintf(foutput, "\n%v: %v %v\n",
+				nontrst[i].name, pfirst[i], pempty[i])
+		}
+	}
+}
+
+//
+// generate the states
+//
+func stagen() {
+	// initialize
+	nstate = 0
+	tstates = make([]int, ntokens+1)  // states generated by terminal gotos
+	ntstates = make([]int, nnonter+1) // states generated by nonterminal gotos
+	amem = make([]int, ACTSIZE)
+	memp = 0
+
+	clset = mkset()
+	pstate[0] = 0
+	pstate[1] = 0
+	aryfil(clset, tbitset, 0)
+	putitem(Pitem{prdptr[0], 0, 0, 0}, clset)
+	tystate[0] = MUSTDO
+	nstate = 1
+	pstate[2] = pstate[1]
+
+	//
+	// now, the main state generation loop
+	// first pass generates all of the states
+	// later passes fix up lookahead
+	// could be sped up a lot by remembering
+	// results of the first pass rather than recomputing
+	//
+	first := 1
+	for more := 1; more != 0; first = 0 {
+		more = 0
+		for i := 0; i < nstate; i++ {
+			if tystate[i] != MUSTDO {
+				continue
+			}
+
+			tystate[i] = DONE
+			aryfil(temp1, nnonter+1, 0)
+
+			// take state i, close it, and do gotos
+			closure(i)
+
+			// generate goto's
+			for p := 0; p < cwp; p++ {
+				pi := wsets[p]
+				if pi.flag != 0 {
+					continue
+				}
+				wsets[p].flag = 1
+				c := pi.pitem.first
+				if c <= 1 {
+					if pstate[i+1]-pstate[i] <= p {
+						tystate[i] = MUSTLOOKAHEAD
+					}
+					continue
+				}
+
+				// do a goto on c
+				putitem(wsets[p].pitem, wsets[p].ws)
+				for q := p + 1; q < cwp; q++ {
+					// this item contributes to the goto
+					if c == wsets[q].pitem.first {
+						putitem(wsets[q].pitem, wsets[q].ws)
+						wsets[q].flag = 1
+					}
+				}
+
+				if c < NTBASE {
+					state(c) // register new state
+				} else {
+					temp1[c-NTBASE] = state(c)
+				}
+			}
+
+			if gsdebug != 0 && foutput != nil {
+				fmt.Fprintf(foutput, "%v: ", i)
+				for j := 0; j <= nnonter; j++ {
+					if temp1[j] != 0 {
+						fmt.Fprintf(foutput, "%v %v,", nontrst[j].name, temp1[j])
+					}
+				}
+				fmt.Fprintf(foutput, "\n")
+			}
+
+			if first != 0 {
+				indgo[i] = apack(temp1[1:], nnonter-1) - 1
+			}
+
+			more++
+		}
+	}
+}
+
+//
+// generate the closure of state i
+//
+func closure(i int) {
+	zzclose++
+
+	// first, copy kernel of state i to wsets
+	cwp = 0
+	q := pstate[i+1]
+	for p := pstate[i]; p < q; p++ {
+		wsets[cwp].pitem = statemem[p].pitem
+		wsets[cwp].flag = 1 // this item must get closed
+		copy(wsets[cwp].ws, statemem[p].look)
+		cwp++
+	}
+
+	// now, go through the loop, closing each item
+	work := 1
+	for work != 0 {
+		work = 0
+		for u := 0; u < cwp; u++ {
+			if wsets[u].flag == 0 {
+				continue
+			}
+
+			// dot is before c
+			c := wsets[u].pitem.first
+			if c < NTBASE {
+				wsets[u].flag = 0
+				// only interesting case is where . is before nonterminal
+				continue
+			}
+
+			// compute the lookahead
+			aryfil(clset, tbitset, 0)
+
+			// find items involving c
+			for v := u; v < cwp; v++ {
+				if wsets[v].flag != 1 || wsets[v].pitem.first != c {
+					continue
+				}
+				pi := wsets[v].pitem.prod
+				ipi := wsets[v].pitem.off + 1
+
+				wsets[v].flag = 0
+				if nolook != 0 {
+					continue
+				}
+
+				ch := pi[ipi]
+				ipi++
+				for ch > 0 {
+					// terminal symbol
+					if ch < NTBASE {
+						setbit(clset, ch)
+						break
+					}
+
+					// nonterminal symbol
+					setunion(clset, pfirst[ch-NTBASE])
+					if pempty[ch-NTBASE] == 0 {
+						break
+					}
+					ch = pi[ipi]
+					ipi++
+				}
+				if ch <= 0 {
+					setunion(clset, wsets[v].ws)
+				}
+			}
+
+			//
+			// now loop over productions derived from c
+			//
+			curres := pres[c-NTBASE]
+			n := len(curres)
+
+		nexts:
+			// initially fill the sets
+			for s := 0; s < n; s++ {
+				prd := curres[s]
+
+				//
+				// put these items into the closure
+				// is the item there
+				//
+				for v := 0; v < cwp; v++ {
+					// yes, it is there
+					if wsets[v].pitem.off == 0 &&
+						aryeq(wsets[v].pitem.prod, prd) != 0 {
+						if nolook == 0 &&
+							setunion(wsets[v].ws, clset) != 0 {
+							wsets[v].flag = 1
+							work = 1
+						}
+						continue nexts
+					}
+				}
+
+				//  not there; make a new entry
+				if cwp >= len(wsets) {
+					awsets := make([]Wset, cwp+WSETINC)
+					copy(awsets, wsets)
+					wsets = awsets
+				}
+				wsets[cwp].pitem = Pitem{prd, 0, prd[0], -prd[len(prd)-1]}
+				wsets[cwp].flag = 1
+				wsets[cwp].ws = mkset()
+				if nolook == 0 {
+					work = 1
+					copy(wsets[cwp].ws, clset)
+				}
+				cwp++
+			}
+		}
+	}
+
+	// have computed closure; flags are reset; return
+	if cldebug != 0 && foutput != nil {
+		fmt.Fprintf(foutput, "\nState %v, nolook = %v\n", i, nolook)
+		for u := 0; u < cwp; u++ {
+			if wsets[u].flag != 0 {
+				fmt.Fprintf(foutput, "flag set\n")
+			}
+			wsets[u].flag = 0
+			fmt.Fprintf(foutput, "\t%v", writem(wsets[u].pitem))
+			prlook(wsets[u].ws)
+			fmt.Fprintf(foutput, "\n")
+		}
+	}
+}
+
+//
+// sorts last state,and sees if it equals earlier ones. returns state number
+//
+func state(c int) int {
+	zzstate++
+	p1 := pstate[nstate]
+	p2 := pstate[nstate+1]
+	if p1 == p2 {
+		return 0 // null state
+	}
+
+	// sort the items
+	var k, l int
+	for k = p1 + 1; k < p2; k++ { // make k the biggest
+		for l = k; l > p1; l-- {
+			if statemem[l].pitem.prodno < statemem[l-1].pitem.prodno ||
+				statemem[l].pitem.prodno == statemem[l-1].pitem.prodno &&
+					statemem[l].pitem.off < statemem[l-1].pitem.off {
+				s := statemem[l]
+				statemem[l] = statemem[l-1]
+				statemem[l-1] = s
+			} else {
+				break
+			}
+		}
+	}
+
+	size1 := p2 - p1 // size of state
+
+	var i int
+	if c >= NTBASE {
+		i = ntstates[c-NTBASE]
+	} else {
+		i = tstates[c]
+	}
+
+look:
+	for ; i != 0; i = mstates[i] {
+		// get ith state
+		q1 := pstate[i]
+		q2 := pstate[i+1]
+		size2 := q2 - q1
+		if size1 != size2 {
+			continue
+		}
+		k = p1
+		for l = q1; l < q2; l++ {
+			if aryeq(statemem[l].pitem.prod, statemem[k].pitem.prod) == 0 ||
+				statemem[l].pitem.off != statemem[k].pitem.off {
+				continue look
+			}
+			k++
+		}
+
+		// found it
+		pstate[nstate+1] = pstate[nstate] // delete last state
+
+		// fix up lookaheads
+		if nolook != 0 {
+			return i
+		}
+		k = p1
+		for l = q1; l < q2; l++ {
+			if setunion(statemem[l].look, statemem[k].look) != 0 {
+				tystate[i] = MUSTDO
+			}
+			k++
+		}
+		return i
+	}
+
+	// state is new
+	zznewstate++
+	if nolook != 0 {
+		errorf("yacc state/nolook error")
+	}
+	pstate[nstate+2] = p2
+	if nstate+1 >= NSTATES {
+		errorf("too many states")
+	}
+	if c >= NTBASE {
+		mstates[nstate] = ntstates[c-NTBASE]
+		ntstates[c-NTBASE] = nstate
+	} else {
+		mstates[nstate] = tstates[c]
+		tstates[c] = nstate
+	}
+	tystate[nstate] = MUSTDO
+	nstate++
+	return nstate - 1
+}
+
+func putitem(p Pitem, set Lkset) {
+	p.off++
+	p.first = p.prod[p.off]
+
+	if pidebug != 0 && foutput != nil {
+		fmt.Fprintf(foutput, "putitem(%v), state %v\n", writem(p), nstate)
+	}
+	j := pstate[nstate+1]
+	if j >= len(statemem) {
+		asm := make([]Item, j+STATEINC)
+		copy(asm, statemem)
+		statemem = asm
+	}
+	statemem[j].pitem = p
+	if nolook == 0 {
+		s := mkset()
+		copy(s, set)
+		statemem[j].look = s
+	}
+	j++
+	pstate[nstate+1] = j
+}
+
+//
+// creates output string for item pointed to by pp
+//
+func writem(pp Pitem) string {
+	var i int
+
+	p := pp.prod
+	q := chcopy(nontrst[prdptr[pp.prodno][0]-NTBASE].name) + ": "
+	npi := pp.off
+
+	pi := aryeq(p, prdptr[pp.prodno])
+
+	for {
+		c := ' '
+		if pi == npi {
+			c = '.'
+		}
+		q += string(c)
+
+		i = p[pi]
+		pi++
+		if i <= 0 {
+			break
+		}
+		q += chcopy(symnam(i))
+	}
+
+	// an item calling for a reduction
+	i = p[npi]
+	if i < 0 {
+		q += fmt.Sprintf("    (%v)", -i)
+	}
+
+	return q
+}
+
+//
+// pack state i from temp1 into amem
+//
+func apack(p []int, n int) int {
+	//
+	// we don't need to worry about checking because
+	// we will only look at entries known to be there...
+	// eliminate leading and trailing 0's
+	//
+	off := 0
+	pp := 0
+	for ; pp <= n && p[pp] == 0; pp++ {
+		off--
+	}
+
+	// no actions
+	if pp > n {
+		return 0
+	}
+	for ; n > pp && p[n] == 0; n-- {
+	}
+	p = p[pp : n+1]
+
+	// now, find a place for the elements from p to q, inclusive
+	r := len(amem) - len(p)
+
+nextk:
+	for rr := 0; rr <= r; rr++ {
+		qq := rr
+		for pp = 0; pp < len(p); pp++ {
+			if p[pp] != 0 {
+				if p[pp] != amem[qq] && amem[qq] != 0 {
+					continue nextk
+				}
+			}
+			qq++
+		}
+
+		// we have found an acceptable k
+		if pkdebug != 0 && foutput != nil {
+			fmt.Fprintf(foutput, "off = %v, k = %v\n", off+rr, rr)
+		}
+		qq = rr
+		for pp = 0; pp < len(p); pp++ {
+			if p[pp] != 0 {
+				if qq > memp {
+					memp = qq
+				}
+				amem[qq] = p[pp]
+			}
+			qq++
+		}
+		if pkdebug != 0 && foutput != nil {
+			for pp = 0; pp <= memp; pp += 10 {
+				fmt.Fprintf(foutput, "\n")
+				for qq = pp; qq <= pp+9; qq++ {
+					fmt.Fprintf(foutput, "%v ", amem[qq])
+				}
+				fmt.Fprintf(foutput, "\n")
+			}
+		}
+		return off + rr
+	}
+	errorf("no space in action table")
+	return 0
+}
+
+//
+// print the output for the states
+//
+func output() {
+	var c, u, v int
+
+	if !lflag {
+		fmt.Fprintf(ftable, "\n//line yacctab:1")
+	}
+	fmt.Fprintf(ftable, "\nvar %sExca = [...]int{\n", prefix)
+
+	if len(errors) > 0 {
+		stateTable = make([]Row, nstate)
+	}
+
+	noset := mkset()
+
+	// output the stuff for state i
+	for i := 0; i < nstate; i++ {
+		nolook = 0
+		if tystate[i] != MUSTLOOKAHEAD {
+			nolook = 1
+		}
+		closure(i)
+
+		// output actions
+		nolook = 1
+		aryfil(temp1, ntokens+nnonter+1, 0)
+		for u = 0; u < cwp; u++ {
+			c = wsets[u].pitem.first
+			if c > 1 && c < NTBASE && temp1[c] == 0 {
+				for v = u; v < cwp; v++ {
+					if c == wsets[v].pitem.first {
+						putitem(wsets[v].pitem, noset)
+					}
+				}
+				temp1[c] = state(c)
+			} else if c > NTBASE {
+				c -= NTBASE
+				if temp1[c+ntokens] == 0 {
+					temp1[c+ntokens] = amem[indgo[i]+c]
+				}
+			}
+		}
+		if i == 1 {
+			temp1[1] = ACCEPTCODE
+		}
+
+		// now, we have the shifts; look at the reductions
+		lastred = 0
+		for u = 0; u < cwp; u++ {
+			c = wsets[u].pitem.first
+
+			// reduction
+			if c > 0 {
+				continue
+			}
+			lastred = -c
+			us := wsets[u].ws
+			for k := 0; k <= ntokens; k++ {
+				if bitset(us, k) == 0 {
+					continue
+				}
+				if temp1[k] == 0 {
+					temp1[k] = c
+				} else if temp1[k] < 0 { // reduce/reduce conflict
+					if foutput != nil {
+						fmt.Fprintf(foutput,
+							"\n %v: reduce/reduce conflict  (red'ns "+
+								"%v and %v) on %v",
+							i, -temp1[k], lastred, symnam(k))
+					}
+					if -temp1[k] > lastred {
+						temp1[k] = -lastred
+					}
+					zzrrconf++
+				} else {
+					// potential shift/reduce conflict
+					precftn(lastred, k, i)
+				}
+			}
+		}
+		wract(i)
+	}
+
+	fmt.Fprintf(ftable, "}\n")
+	ftable.WriteRune('\n')
+	fmt.Fprintf(ftable, "const %sPrivate = %v\n", prefix, PRIVATE)
+}
+
+//
+// decide a shift/reduce conflict by precedence.
+// r is a rule number, t a token number
+// the conflict is in state s
+// temp1[t] is changed to reflect the action
+//
+func precftn(r, t, s int) {
+	action := NOASC
+
+	lp := levprd[r]
+	lt := toklev[t]
+	if PLEVEL(lt) == 0 || PLEVEL(lp) == 0 {
+		// conflict
+		if foutput != nil {
+			fmt.Fprintf(foutput,
+				"\n%v: shift/reduce conflict (shift %v(%v), red'n %v(%v)) on %v",
+				s, temp1[t], PLEVEL(lt), r, PLEVEL(lp), symnam(t))
+		}
+		zzsrconf++
+		return
+	}
+	if PLEVEL(lt) == PLEVEL(lp) {
+		action = ASSOC(lt)
+	} else if PLEVEL(lt) > PLEVEL(lp) {
+		action = RASC // shift
+	} else {
+		action = LASC
+	} // reduce
+	switch action {
+	case BASC: // error action
+		temp1[t] = ERRCODE
+	case LASC: // reduce
+		temp1[t] = -r
+	}
+}
+
+//
+// output state i
+// temp1 has the actions, lastred the default
+//
+func wract(i int) {
+	var p, p1 int
+
+	// find the best choice for lastred
+	lastred = 0
+	ntimes := 0
+	for j := 0; j <= ntokens; j++ {
+		if temp1[j] >= 0 {
+			continue
+		}
+		if temp1[j]+lastred == 0 {
+			continue
+		}
+		// count the number of appearances of temp1[j]
+		count := 0
+		tred := -temp1[j]
+		levprd[tred] |= REDFLAG
+		for p = 0; p <= ntokens; p++ {
+			if temp1[p]+tred == 0 {
+				count++
+			}
+		}
+		if count > ntimes {
+			lastred = tred
+			ntimes = count
+		}
+	}
+
+	//
+	// for error recovery, arrange that, if there is a shift on the
+	// error recovery token, `error', that the default be the error action
+	//
+	if temp1[2] > 0 {
+		lastred = 0
+	}
+
+	// clear out entries in temp1 which equal lastred
+	// count entries in optst table
+	n := 0
+	for p = 0; p <= ntokens; p++ {
+		p1 = temp1[p]
+		if p1+lastred == 0 {
+			temp1[p] = 0
+			p1 = 0
+		}
+		if p1 > 0 && p1 != ACCEPTCODE && p1 != ERRCODE {
+			n++
+		}
+	}
+
+	wrstate(i)
+	defact[i] = lastred
+	flag := 0
+	os := make([]int, n*2)
+	n = 0
+	for p = 0; p <= ntokens; p++ {
+		p1 = temp1[p]
+		if p1 != 0 {
+			if p1 < 0 {
+				p1 = -p1
+			} else if p1 == ACCEPTCODE {
+				p1 = -1
+			} else if p1 == ERRCODE {
+				p1 = 0
+			} else {
+				os[n] = p
+				n++
+				os[n] = p1
+				n++
+				zzacent++
+				continue
+			}
+			if flag == 0 {
+				fmt.Fprintf(ftable, "\t-1, %v,\n", i)
+			}
+			flag++
+			fmt.Fprintf(ftable, "\t%v, %v,\n", p, p1)
+			zzexcp++
+		}
+	}
+	if flag != 0 {
+		defact[i] = -2
+		fmt.Fprintf(ftable, "\t-2, %v,\n", lastred)
+	}
+	optst[i] = os
+}
+
+//
+// writes state i
+//
+func wrstate(i int) {
+	var j0, j1, u int
+	var pp, qq int
+
+	if len(errors) > 0 {
+		actions := append([]int(nil), temp1...)
+		defaultAction := ERRCODE
+		if lastred != 0 {
+			defaultAction = -lastred
+		}
+		stateTable[i] = Row{actions, defaultAction}
+	}
+
+	if foutput == nil {
+		return
+	}
+	fmt.Fprintf(foutput, "\nstate %v\n", i)
+	qq = pstate[i+1]
+	for pp = pstate[i]; pp < qq; pp++ {
+		fmt.Fprintf(foutput, "\t%v\n", writem(statemem[pp].pitem))
+	}
+	if tystate[i] == MUSTLOOKAHEAD {
+		// print out empty productions in closure
+		for u = pstate[i+1] - pstate[i]; u < cwp; u++ {
+			if wsets[u].pitem.first < 0 {
+				fmt.Fprintf(foutput, "\t%v\n", writem(wsets[u].pitem))
+			}
+		}
+	}
+
+	// check for state equal to another
+	for j0 = 0; j0 <= ntokens; j0++ {
+		j1 = temp1[j0]
+		if j1 != 0 {
+			fmt.Fprintf(foutput, "\n\t%v  ", symnam(j0))
+
+			// shift, error, or accept
+			if j1 > 0 {
+				if j1 == ACCEPTCODE {
+					fmt.Fprintf(foutput, "accept")
+				} else if j1 == ERRCODE {
+					fmt.Fprintf(foutput, "error")
+				} else {
+					fmt.Fprintf(foutput, "shift %v", j1)
+				}
+			} else {
+				fmt.Fprintf(foutput, "reduce %v (src line %v)", -j1, rlines[-j1])
+			}
+		}
+	}
+
+	// output the final production
+	if lastred != 0 {
+		fmt.Fprintf(foutput, "\n\t.  reduce %v (src line %v)\n\n",
+			lastred, rlines[lastred])
+	} else {
+		fmt.Fprintf(foutput, "\n\t.  error\n\n")
+	}
+
+	// now, output nonterminal actions
+	j1 = ntokens
+	for j0 = 1; j0 <= nnonter; j0++ {
+		j1++
+		if temp1[j1] != 0 {
+			fmt.Fprintf(foutput, "\t%v  goto %v\n", symnam(j0+NTBASE), temp1[j1])
+		}
+	}
+}
+
+//
+// output the gotos for the nontermninals
+//
+func go2out() {
+	for i := 1; i <= nnonter; i++ {
+		go2gen(i)
+
+		// find the best one to make default
+		best := -1
+		times := 0
+
+		// is j the most frequent
+		for j := 0; j < nstate; j++ {
+			if tystate[j] == 0 {
+				continue
+			}
+			if tystate[j] == best {
+				continue
+			}
+
+			// is tystate[j] the most frequent
+			count := 0
+			cbest := tystate[j]
+			for k := j; k < nstate; k++ {
+				if tystate[k] == cbest {
+					count++
+				}
+			}
+			if count > times {
+				best = cbest
+				times = count
+			}
+		}
+
+		// best is now the default entry
+		zzgobest += times - 1
+		n := 0
+		for j := 0; j < nstate; j++ {
+			if tystate[j] != 0 && tystate[j] != best {
+				n++
+			}
+		}
+		goent := make([]int, 2*n+1)
+		n = 0
+		for j := 0; j < nstate; j++ {
+			if tystate[j] != 0 && tystate[j] != best {
+				goent[n] = j
+				n++
+				goent[n] = tystate[j]
+				n++
+				zzgoent++
+			}
+		}
+
+		// now, the default
+		if best == -1 {
+			best = 0
+		}
+
+		zzgoent++
+		goent[n] = best
+		yypgo[i] = goent
+	}
+}
+
+//
+// output the gotos for nonterminal c
+//
+func go2gen(c int) {
+	var i, cc, p, q int
+
+	// first, find nonterminals with gotos on c
+	aryfil(temp1, nnonter+1, 0)
+	temp1[c] = 1
+	work := 1
+	for work != 0 {
+		work = 0
+		for i = 0; i < nprod; i++ {
+			// cc is a nonterminal with a goto on c
+			cc = prdptr[i][1] - NTBASE
+			if cc >= 0 && temp1[cc] != 0 {
+				// thus, the left side of production i does too
+				cc = prdptr[i][0] - NTBASE
+				if temp1[cc] == 0 {
+					work = 1
+					temp1[cc] = 1
+				}
+			}
+		}
+	}
+
+	// now, we have temp1[c] = 1 if a goto on c in closure of cc
+	if g2debug != 0 && foutput != nil {
+		fmt.Fprintf(foutput, "%v: gotos on ", nontrst[c].name)
+		for i = 0; i <= nnonter; i++ {
+			if temp1[i] != 0 {
+				fmt.Fprintf(foutput, "%v ", nontrst[i].name)
+			}
+		}
+		fmt.Fprintf(foutput, "\n")
+	}
+
+	// now, go through and put gotos into tystate
+	aryfil(tystate, nstate, 0)
+	for i = 0; i < nstate; i++ {
+		q = pstate[i+1]
+		for p = pstate[i]; p < q; p++ {
+			cc = statemem[p].pitem.first
+			if cc >= NTBASE {
+				// goto on c is possible
+				if temp1[cc-NTBASE] != 0 {
+					tystate[i] = amem[indgo[i]+c]
+					break
+				}
+			}
+		}
+	}
+}
+
+//
+// in order to free up the mem and amem arrays for the optimizer,
+// and still be able to output yyr1, etc., after the sizes of
+// the action array is known, we hide the nonterminals
+// derived by productions in levprd.
+//
+func hideprod() {
+	nred := 0
+	levprd[0] = 0
+	for i := 1; i < nprod; i++ {
+		if (levprd[i] & REDFLAG) == 0 {
+			if foutput != nil {
+				fmt.Fprintf(foutput, "Rule not reduced: %v\n",
+					writem(Pitem{prdptr[i], 0, 0, i}))
+			}
+			fmt.Printf("rule %v never reduced\n", writem(Pitem{prdptr[i], 0, 0, i}))
+			nred++
+		}
+		levprd[i] = prdptr[i][0] - NTBASE
+	}
+	if nred != 0 {
+		fmt.Printf("%v rules never reduced\n", nred)
+	}
+}
+
+func callopt() {
+	var j, k, p, q, i int
+	var v []int
+
+	pgo = make([]int, nnonter+1)
+	pgo[0] = 0
+	maxoff = 0
+	maxspr = 0
+	for i = 0; i < nstate; i++ {
+		k = 32000
+		j = 0
+		v = optst[i]
+		q = len(v)
+		for p = 0; p < q; p += 2 {
+			if v[p] > j {
+				j = v[p]
+			}
+			if v[p] < k {
+				k = v[p]
+			}
+		}
+
+		// nontrivial situation
+		if k <= j {
+			// j is now the range
+			//			j -= k;			// call scj
+			if k > maxoff {
+				maxoff = k
+			}
+		}
+		tystate[i] = q + 2*j
+		if j > maxspr {
+			maxspr = j
+		}
+	}
+
+	// initialize ggreed table
+	ggreed = make([]int, nnonter+1)
+	for i = 1; i <= nnonter; i++ {
+		ggreed[i] = 1
+		j = 0
+
+		// minimum entry index is always 0
+		v = yypgo[i]
+		q = len(v) - 1
+		for p = 0; p < q; p += 2 {
+			ggreed[i] += 2
+			if v[p] > j {
+				j = v[p]
+			}
+		}
+		ggreed[i] = ggreed[i] + 2*j
+		if j > maxoff {
+			maxoff = j
+		}
+	}
+
+	// now, prepare to put the shift actions into the amem array
+	for i = 0; i < ACTSIZE; i++ {
+		amem[i] = 0
+	}
+	maxa = 0
+	for i = 0; i < nstate; i++ {
+		if tystate[i] == 0 && adb > 1 {
+			fmt.Fprintf(ftable, "State %v: null\n", i)
+		}
+		indgo[i] = yyFlag
+	}
+
+	i = nxti()
+	for i != NOMORE {
+		if i >= 0 {
+			stin(i)
+		} else {
+			gin(-i)
+		}
+		i = nxti()
+	}
+
+	// print amem array
+	if adb > 2 {
+		for p = 0; p <= maxa; p += 10 {
+			fmt.Fprintf(ftable, "%v  ", p)
+			for i = 0; i < 10; i++ {
+				fmt.Fprintf(ftable, "%v  ", amem[p+i])
+			}
+			ftable.WriteRune('\n')
+		}
+	}
+
+	aoutput()
+	osummary()
+}
+
+//
+// finds the next i
+//
+func nxti() int {
+	max := 0
+	maxi := 0
+	for i := 1; i <= nnonter; i++ {
+		if ggreed[i] >= max {
+			max = ggreed[i]
+			maxi = -i
+		}
+	}
+	for i := 0; i < nstate; i++ {
+		if tystate[i] >= max {
+			max = tystate[i]
+			maxi = i
+		}
+	}
+	if max == 0 {
+		return NOMORE
+	}
+	return maxi
+}
+
+func gin(i int) {
+	var s int
+
+	// enter gotos on nonterminal i into array amem
+	ggreed[i] = 0
+
+	q := yypgo[i]
+	nq := len(q) - 1
+
+	// now, find amem place for it
+nextgp:
+	for p := 0; p < ACTSIZE; p++ {
+		if amem[p] != 0 {
+			continue
+		}
+		for r := 0; r < nq; r += 2 {
+			s = p + q[r] + 1
+			if s > maxa {
+				maxa = s
+				if maxa >= ACTSIZE {
+					errorf("a array overflow")
+				}
+			}
+			if amem[s] != 0 {
+				continue nextgp
+			}
+		}
+
+		// we have found amem spot
+		amem[p] = q[nq]
+		if p > maxa {
+			maxa = p
+		}
+		for r := 0; r < nq; r += 2 {
+			s = p + q[r] + 1
+			amem[s] = q[r+1]
+		}
+		pgo[i] = p
+		if adb > 1 {
+			fmt.Fprintf(ftable, "Nonterminal %v, entry at %v\n", i, pgo[i])
+		}
+		return
+	}
+	errorf("cannot place goto %v\n", i)
+}
+
+func stin(i int) {
+	var s int
+
+	tystate[i] = 0
+
+	// enter state i into the amem array
+	q := optst[i]
+	nq := len(q)
+
+nextn:
+	// find an acceptable place
+	for n := -maxoff; n < ACTSIZE; n++ {
+		flag := 0
+		for r := 0; r < nq; r += 2 {
+			s = q[r] + n
+			if s < 0 || s > ACTSIZE {
+				continue nextn
+			}
+			if amem[s] == 0 {
+				flag++
+			} else if amem[s] != q[r+1] {
+				continue nextn
+			}
+		}
+
+		// check the position equals another only if the states are identical
+		for j := 0; j < nstate; j++ {
+			if indgo[j] == n {
+
+				// we have some disagreement
+				if flag != 0 {
+					continue nextn
+				}
+				if nq == len(optst[j]) {
+
+					// states are equal
+					indgo[i] = n
+					if adb > 1 {
+						fmt.Fprintf(ftable, "State %v: entry at"+
+							"%v equals state %v\n",
+							i, n, j)
+					}
+					return
+				}
+
+				// we have some disagreement
+				continue nextn
+			}
+		}
+
+		for r := 0; r < nq; r += 2 {
+			s = q[r] + n
+			if s > maxa {
+				maxa = s
+			}
+			if amem[s] != 0 && amem[s] != q[r+1] {
+				errorf("clobber of a array, pos'n %v, by %v", s, q[r+1])
+			}
+			amem[s] = q[r+1]
+		}
+		indgo[i] = n
+		if adb > 1 {
+			fmt.Fprintf(ftable, "State %v: entry at %v\n", i, indgo[i])
+		}
+		return
+	}
+	errorf("Error; failure to place state %v", i)
+}
+
+//
+// this version is for limbo
+// write out the optimized parser
+//
+func aoutput() {
+	ftable.WriteRune('\n')
+	fmt.Fprintf(ftable, "const %sLast = %v\n\n", prefix, maxa+1)
+	arout("Act", amem, maxa+1)
+	arout("Pact", indgo, nstate)
+	arout("Pgo", pgo, nnonter+1)
+}
+
+//
+// put out other arrays, copy the parsers
+//
+func others() {
+	var i, j int
+
+	arout("R1", levprd, nprod)
+	aryfil(temp1, nprod, 0)
+
+	//
+	//yyr2 is the number of rules for each production
+	//
+	for i = 1; i < nprod; i++ {
+		temp1[i] = len(prdptr[i]) - 2
+	}
+	arout("R2", temp1, nprod)
+
+	aryfil(temp1, nstate, -1000)
+	for i = 0; i <= ntokens; i++ {
+		for j := tstates[i]; j != 0; j = mstates[j] {
+			temp1[j] = i
+		}
+	}
+	for i = 0; i <= nnonter; i++ {
+		for j = ntstates[i]; j != 0; j = mstates[j] {
+			temp1[j] = -i
+		}
+	}
+	arout("Chk", temp1, nstate)
+	arout("Def", defact, nstate)
+
+	// put out token translation tables
+	// table 1 has 0-256
+	aryfil(temp1, 256, 0)
+	c := 0
+	for i = 1; i <= ntokens; i++ {
+		j = tokset[i].value
+		if j >= 0 && j < 256 {
+			if temp1[j] != 0 {
+				fmt.Print("yacc bug -- cannot have 2 different Ts with same value\n")
+				fmt.Printf("	%s and %s\n", tokset[i].name, tokset[temp1[j]].name)
+				nerrors++
+			}
+			temp1[j] = i
+			if j > c {
+				c = j
+			}
+		}
+	}
+	for i = 0; i <= c; i++ {
+		if temp1[i] == 0 {
+			temp1[i] = YYLEXUNK
+		}
+	}
+	arout("Tok1", temp1, c+1)
+
+	// table 2 has PRIVATE-PRIVATE+256
+	aryfil(temp1, 256, 0)
+	c = 0
+	for i = 1; i <= ntokens; i++ {
+		j = tokset[i].value - PRIVATE
+		if j >= 0 && j < 256 {
+			if temp1[j] != 0 {
+				fmt.Print("yacc bug -- cannot have 2 different Ts with same value\n")
+				fmt.Printf("	%s and %s\n", tokset[i].name, tokset[temp1[j]].name)
+				nerrors++
+			}
+			temp1[j] = i
+			if j > c {
+				c = j
+			}
+		}
+	}
+	arout("Tok2", temp1, c+1)
+
+	// table 3 has everything else
+	fmt.Fprintf(ftable, "var %sTok3 = [...]int{\n\t", prefix)
+	c = 0
+	for i = 1; i <= ntokens; i++ {
+		j = tokset[i].value
+		if j >= 0 && j < 256 {
+			continue
+		}
+		if j >= PRIVATE && j < 256+PRIVATE {
+			continue
+		}
+
+		if c%5 != 0 {
+			ftable.WriteRune(' ')
+		}
+		fmt.Fprintf(ftable, "%d, %d,", j, i)
+		c++
+		if c%5 == 0 {
+			fmt.Fprint(ftable, "\n\t")
+		}
+	}
+	if c%5 != 0 {
+		ftable.WriteRune(' ')
+	}
+	fmt.Fprintf(ftable, "%d,\n}\n", 0)
+
+	// Custom error messages.
+	fmt.Fprintf(ftable, "\n")
+	fmt.Fprintf(ftable, "var %sErrorMessages = [...]struct {\n", prefix)
+	fmt.Fprintf(ftable, "\tstate int\n")
+	fmt.Fprintf(ftable, "\ttoken int\n")
+	fmt.Fprintf(ftable, "\tmsg   string\n")
+	fmt.Fprintf(ftable, "}{\n")
+	for _, error := range errors {
+		lineno = error.lineno
+		state, token := runMachine(error.tokens)
+		fmt.Fprintf(ftable, "\t{%v, %v, %s},\n", state, token, error.msg)
+	}
+	fmt.Fprintf(ftable, "}\n")
+
+	// copy parser text
+	ch := getrune(finput)
+	for ch != EOF {
+		ftable.WriteRune(ch)
+		ch = getrune(finput)
+	}
+
+	// copy yaccpar
+	if !lflag {
+		fmt.Fprintf(ftable, "\n//line yaccpar:1\n")
+	}
+
+	parts := strings.SplitN(yaccpar, prefix+"run()", 2)
+	fmt.Fprintf(ftable, "%v", parts[0])
+	ftable.Write(fcode.Bytes())
+	fmt.Fprintf(ftable, "%v", parts[1])
+}
+
+func runMachine(tokens []string) (state, token int) {
+	var stack []int
+	i := 0
+	token = -1
+
+Loop:
+	if token < 0 {
+		token = chfind(2, tokens[i])
+		i++
+	}
+
+	row := stateTable[state]
+
+	c := token
+	if token >= NTBASE {
+		c = token - NTBASE + ntokens
+	}
+	action := row.actions[c]
+	if action == 0 {
+		action = row.defaultAction
+	}
+
+	switch {
+	case action == ACCEPTCODE:
+		errorf("tokens are accepted")
+		return
+	case action == ERRCODE:
+		if token >= NTBASE {
+			errorf("error at non-terminal token %s", symnam(token))
+		}
+		return
+	case action > 0:
+		// Shift to state action.
+		stack = append(stack, state)
+		state = action
+		token = -1
+		goto Loop
+	default:
+		// Reduce by production -action.
+		prod := prdptr[-action]
+		if rhsLen := len(prod) - 2; rhsLen > 0 {
+			n := len(stack) - rhsLen
+			state = stack[n]
+			stack = stack[:n]
+		}
+		if token >= 0 {
+			i--
+		}
+		token = prod[0]
+		goto Loop
+	}
+}
+
+func arout(s string, v []int, n int) {
+	s = prefix + s
+	fmt.Fprintf(ftable, "var %v = [...]int{\n", s)
+	for i := 0; i < n; i++ {
+		if i%10 == 0 {
+			fmt.Fprintf(ftable, "\n\t")
+		} else {
+			ftable.WriteRune(' ')
+		}
+		fmt.Fprintf(ftable, "%d,", v[i])
+	}
+	fmt.Fprintf(ftable, "\n}\n")
+}
+
+//
+// output the summary on y.output
+//
+func summary() {
+	if foutput != nil {
+		fmt.Fprintf(foutput, "\n%v terminals, %v nonterminals\n", ntokens, nnonter+1)
+		fmt.Fprintf(foutput, "%v grammar rules, %v/%v states\n", nprod, nstate, NSTATES)
+		fmt.Fprintf(foutput, "%v shift/reduce, %v reduce/reduce conflicts reported\n", zzsrconf, zzrrconf)
+		fmt.Fprintf(foutput, "%v working sets used\n", len(wsets))
+		fmt.Fprintf(foutput, "memory: parser %v/%v\n", memp, ACTSIZE)
+		fmt.Fprintf(foutput, "%v extra closures\n", zzclose-2*nstate)
+		fmt.Fprintf(foutput, "%v shift entries, %v exceptions\n", zzacent, zzexcp)
+		fmt.Fprintf(foutput, "%v goto entries\n", zzgoent)
+		fmt.Fprintf(foutput, "%v entries saved by goto default\n", zzgobest)
+	}
+	if zzsrconf != 0 || zzrrconf != 0 {
+		fmt.Printf("\nconflicts: ")
+		if zzsrconf != 0 {
+			fmt.Printf("%v shift/reduce", zzsrconf)
+		}
+		if zzsrconf != 0 && zzrrconf != 0 {
+			fmt.Printf(", ")
+		}
+		if zzrrconf != 0 {
+			fmt.Printf("%v reduce/reduce", zzrrconf)
+		}
+		fmt.Printf("\n")
+	}
+}
+
+//
+// write optimizer summary
+//
+func osummary() {
+	if foutput == nil {
+		return
+	}
+	i := 0
+	for p := maxa; p >= 0; p-- {
+		if amem[p] == 0 {
+			i++
+		}
+	}
+
+	fmt.Fprintf(foutput, "Optimizer space used: output %v/%v\n", maxa+1, ACTSIZE)
+	fmt.Fprintf(foutput, "%v table entries, %v zero\n", maxa+1, i)
+	fmt.Fprintf(foutput, "maximum spread: %v, maximum offset: %v\n", maxspr, maxoff)
+}
+
+//
+// copies and protects "'s in q
+//
+func chcopy(q string) string {
+	s := ""
+	i := 0
+	j := 0
+	for i = 0; i < len(q); i++ {
+		if q[i] == '"' {
+			s += q[j:i] + "\\"
+			j = i
+		}
+	}
+	return s + q[j:i]
+}
+
+func usage() {
+	fmt.Fprintf(stderr, "usage: yacc [-o output] [-v parsetable] input\n")
+	exit(1)
+}
+
+func bitset(set Lkset, bit int) int { return set[bit>>5] & (1 << uint(bit&31)) }
+
+func setbit(set Lkset, bit int) { set[bit>>5] |= (1 << uint(bit&31)) }
+
+func mkset() Lkset { return make([]int, tbitset) }
+
+//
+// set a to the union of a and b
+// return 1 if b is not a subset of a, 0 otherwise
+//
+func setunion(a, b []int) int {
+	sub := 0
+	for i := 0; i < tbitset; i++ {
+		x := a[i]
+		y := x | b[i]
+		a[i] = y
+		if y != x {
+			sub = 1
+		}
+	}
+	return sub
+}
+
+func prlook(p Lkset) {
+	if p == nil {
+		fmt.Fprintf(foutput, "\tNULL")
+		return
+	}
+	fmt.Fprintf(foutput, " { ")
+	for j := 0; j <= ntokens; j++ {
+		if bitset(p, j) != 0 {
+			fmt.Fprintf(foutput, "%v ", symnam(j))
+		}
+	}
+	fmt.Fprintf(foutput, "}")
+}
+
+//
+// utility routines
+//
+var peekrune rune
+
+func isdigit(c rune) bool { return c >= '0' && c <= '9' }
+
+func isword(c rune) bool {
+	return c >= 0xa0 || c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+//
+// return 1 if 2 arrays are equal
+// return 0 if not equal
+//
+func aryeq(a []int, b []int) int {
+	n := len(a)
+	if len(b) != n {
+		return 0
+	}
+	for ll := 0; ll < n; ll++ {
+		if a[ll] != b[ll] {
+			return 0
+		}
+	}
+	return 1
+}
+
+func getrune(f *bufio.Reader) rune {
+	var r rune
+
+	if peekrune != 0 {
+		if peekrune == EOF {
+			return EOF
+		}
+		r = peekrune
+		peekrune = 0
+		return r
+	}
+
+	c, n, err := f.ReadRune()
+	if n == 0 {
+		return EOF
+	}
+	if err != nil {
+		errorf("read error: %v", err)
+	}
+	//fmt.Printf("rune = %v n=%v\n", string(c), n);
+	return c
+}
+
+func ungetrune(f *bufio.Reader, c rune) {
+	if f != finput {
+		panic("ungetc - not finput")
+	}
+	if peekrune != 0 {
+		panic("ungetc - 2nd unget")
+	}
+	peekrune = c
+}
+
+func open(s string) *bufio.Reader {
+	fi, err := os.Open(s)
+	if err != nil {
+		errorf("error opening %v: %v", s, err)
+	}
+	//fmt.Printf("open %v\n", s);
+	return bufio.NewReader(fi)
+}
+
+func create(s string) *bufio.Writer {
+	fo, err := os.Create(s)
+	if err != nil {
+		errorf("error creating %v: %v", s, err)
+	}
+	//fmt.Printf("create %v mode %v\n", s);
+	return bufio.NewWriter(fo)
+}
+
+//
+// write out error comment
+//
+func lerrorf(lineno int, s string, v ...interface{}) {
+	nerrors++
+	fmt.Fprintf(stderr, s, v...)
+	fmt.Fprintf(stderr, ": %v:%v\n", infile, lineno)
+	if fatfl != 0 {
+		summary()
+		exit(1)
+	}
+}
+
+func errorf(s string, v ...interface{}) {
+	lerrorf(lineno, s, v...)
+}
+
+func exit(status int) {
+	if ftable != nil {
+		ftable.Flush()
+		ftable = nil
+		gofmt()
+	}
+	if foutput != nil {
+		foutput.Flush()
+		foutput = nil
+	}
+	if stderr != nil {
+		stderr.Flush()
+		stderr = nil
+	}
+	os.Exit(status)
+}
+
+func gofmt() {
+	src, err := ioutil.ReadFile(oflag)
+	if err != nil {
+		return
+	}
+	src, err = format.Source(src)
+	if err != nil {
+		return
+	}
+	ioutil.WriteFile(oflag, src, 0666)
+}
+
+var yaccpar string // will be processed version of yaccpartext: s/$$/prefix/g
+var yaccpartext = `
+/*	parser for yacc output	*/
+
+var (
+	$$Debug        = 0
+	$$ErrorVerbose = false
+)
+
+type $$Lexer interface {
+	Lex(lval *$$SymType) int
+	Error(s string)
+}
+
+type $$Parser interface {
+	Parse($$Lexer) int
+	Lookahead() int
+}
+
+type $$ParserImpl struct {
+	lval  $$SymType
+	stack [$$InitialStackSize]$$SymType
+	char  int
+}
+
+func (p *$$ParserImpl) Lookahead() int {
+	return p.char
+}
+
+func $$NewParser() $$Parser {
+	return &$$ParserImpl{}
+}
+
+const $$Flag = -1000
+
+func $$Tokname(c int) string {
+	if c >= 1 && c-1 < len($$Toknames) {
+		if $$Toknames[c-1] != "" {
+			return $$Toknames[c-1]
+		}
+	}
+	return __yyfmt__.Sprintf("tok-%v", c)
+}
+
+func $$Statname(s int) string {
+	if s >= 0 && s < len($$Statenames) {
+		if $$Statenames[s] != "" {
+			return $$Statenames[s]
+		}
+	}
+	return __yyfmt__.Sprintf("state-%v", s)
+}
+
+func $$ErrorMessage(state, lookAhead int) string {
+	const TOKSTART = 4
+
+	if !$$ErrorVerbose {
+		return "syntax error"
+	}
+
+	for _, e := range $$ErrorMessages {
+		if e.state == state && e.token == lookAhead {
+			return "syntax error: " + e.msg
+		}
+	}
+
+	res := "syntax error: unexpected " + $$Tokname(lookAhead)
+
+	// To match Bison, suggest at most four expected tokens.
+	expected := make([]int, 0, 4)
+
+	// Look for shiftable tokens.
+	base := $$Pact[state]
+	for tok := TOKSTART; tok-1 < len($$Toknames); tok++ {
+		if n := base + tok; n >= 0 && n < $$Last && $$Chk[$$Act[n]] == tok {
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+	}
+
+	if $$Def[state] == -2 {
+		i := 0
+		for $$Exca[i] != -1 || $$Exca[i+1] != state {
+			i += 2
+		}
+
+		// Look for tokens that we accept or reduce.
+		for i += 2; $$Exca[i] >= 0; i += 2 {
+			tok := $$Exca[i]
+			if tok < TOKSTART || $$Exca[i+1] == 0 {
+				continue
+			}
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+
+		// If the default action is to accept or reduce, give up.
+		if $$Exca[i+1] != 0 {
+			return res
+		}
+	}
+
+	for i, tok := range expected {
+		if i == 0 {
+			res += ", expecting "
+		} else {
+			res += " or "
+		}
+		res += $$Tokname(tok)
+	}
+	return res
+}
+
+func $$lex1(lex $$Lexer, lval *$$SymType) (char, token int) {
+	token = 0
+	char = lex.Lex(lval)
+	if char <= 0 {
+		token = $$Tok1[0]
+		goto out
+	}
+	if char < len($$Tok1) {
+		token = $$Tok1[char]
+		goto out
+	}
+	if char >= $$Private {
+		if char < $$Private+len($$Tok2) {
+			token = $$Tok2[char-$$Private]
+			goto out
+		}
+	}
+	for i := 0; i < len($$Tok3); i += 2 {
+		token = $$Tok3[i+0]
+		if token == char {
+			token = $$Tok3[i+1]
+			goto out
+		}
+	}
+
+out:
+	if token == 0 {
+		token = $$Tok2[1] /* unknown char */
+	}
+	if $$Debug >= 3 {
+		__yyfmt__.Printf("lex %s(%d)\n", $$Tokname(token), uint(char))
+	}
+	return char, token
+}
+
+func $$Parse($$lex $$Lexer) int {
+	return $$NewParser().Parse($$lex)
+}
+
+func ($$rcvr *$$ParserImpl) Parse($$lex $$Lexer) int {
+	var $$n int
+	var $$VAL $$SymType
+	var $$Dollar []$$SymType
+	_ = $$Dollar // silence set and not used
+	$$S := $$rcvr.stack[:]
+
+	Nerrs := 0   /* number of errors */
+	Errflag := 0 /* error recovery flag */
+	$$state := 0
+	$$rcvr.char = -1
+	$$token := -1 // $$rcvr.char translated into internal numbering
+	defer func() {
+		// Make sure we report no lookahead when not parsing.
+		$$state = -1
+		$$rcvr.char = -1
+		$$token = -1
+	}()
+	$$p := -1
+	goto $$stack
+
+ret0:
+	return 0
+
+ret1:
+	return 1
+
+$$stack:
+	/* put a state and value onto the stack */
+	if $$Debug >= 4 {
+		__yyfmt__.Printf("char %v in %v\n", $$Tokname($$token), $$Statname($$state))
+	}
+
+	$$p++
+	if $$p >= len($$S) {
+		nyys := make([]$$SymType, len($$S)*2)
+		copy(nyys, $$S)
+		$$S = nyys
+	}
+	$$S[$$p] = $$VAL
+	$$S[$$p].yys = $$state
+
+$$newstate:
+	$$n = $$Pact[$$state]
+	if $$n <= $$Flag {
+		goto $$default /* simple state */
+	}
+	if $$rcvr.char < 0 {
+		$$rcvr.char, $$token = $$lex1($$lex, &$$rcvr.lval)
+	}
+	$$n += $$token
+	if $$n < 0 || $$n >= $$Last {
+		goto $$default
+	}
+	$$n = $$Act[$$n]
+	if $$Chk[$$n] == $$token { /* valid shift */
+		$$rcvr.char = -1
+		$$token = -1
+		$$VAL = $$rcvr.lval
+		$$state = $$n
+		if Errflag > 0 {
+			Errflag--
+		}
+		goto $$stack
+	}
+
+$$default:
+	/* default state action */
+	$$n = $$Def[$$state]
+	if $$n == -2 {
+		if $$rcvr.char < 0 {
+			$$rcvr.char, $$token = $$lex1($$lex, &$$rcvr.lval)
+		}
+
+		/* look through exception table */
+		xi := 0
+		for {
+			if $$Exca[xi+0] == -1 && $$Exca[xi+1] == $$state {
+				break
+			}
+			xi += 2
+		}
+		for xi += 2; ; xi += 2 {
+			$$n = $$Exca[xi+0]
+			if $$n < 0 || $$n == $$token {
+				break
+			}
+		}
+		$$n = $$Exca[xi+1]
+		if $$n < 0 {
+			goto ret0
+		}
+	}
+	if $$n == 0 {
+		/* error ... attempt to resume parsing */
+		switch Errflag {
+		case 0: /* brand new error */
+			$$lex.Error($$ErrorMessage($$state, $$token))
+			Nerrs++
+			if $$Debug >= 1 {
+				__yyfmt__.Printf("%s", $$Statname($$state))
+				__yyfmt__.Printf(" saw %s\n", $$Tokname($$token))
+			}
+			fallthrough
+
+		case 1, 2: /* incompletely recovered error ... try again */
+			Errflag = 3
+
+			/* find a state where "error" is a legal shift action */
+			for $$p >= 0 {
+				$$n = $$Pact[$$S[$$p].yys] + $$ErrCode
+				if $$n >= 0 && $$n < $$Last {
+					$$state = $$Act[$$n] /* simulate a shift of "error" */
+					if $$Chk[$$state] == $$ErrCode {
+						goto $$stack
+					}
+				}
+
+				/* the current p has no shift on "error", pop stack */
+				if $$Debug >= 2 {
+					__yyfmt__.Printf("error recovery pops state %d\n", $$S[$$p].yys)
+				}
+				$$p--
+			}
+			/* there is no state on the stack with an error shift ... abort */
+			goto ret1
+
+		case 3: /* no shift yet; clobber input char */
+			if $$Debug >= 2 {
+				__yyfmt__.Printf("error recovery discards %s\n", $$Tokname($$token))
+			}
+			if $$token == $$EofCode {
+				goto ret1
+			}
+			$$rcvr.char = -1
+			$$token = -1
+			goto $$newstate /* try again in the same state */
+		}
+	}
+
+	/* reduction by production $$n */
+	if $$Debug >= 2 {
+		__yyfmt__.Printf("reduce %v in:\n\t%v\n", $$n, $$Statname($$state))
+	}
+
+	$$nt := $$n
+	$$pt := $$p
+	_ = $$pt // guard against "declared and not used"
+
+	$$p -= $$R2[$$n]
+	// $$p is now the index of $0. Perform the default action. Iff the
+	// reduced production is ε, $1 is possibly out of range.
+	if $$p+1 >= len($$S) {
+		nyys := make([]$$SymType, len($$S)*2)
+		copy(nyys, $$S)
+		$$S = nyys
+	}
+	$$VAL = $$S[$$p+1]
+
+	/* consult goto table to find next state */
+	$$n = $$R1[$$n]
+	$$g := $$Pgo[$$n]
+	$$j := $$g + $$S[$$p].yys + 1
+
+	if $$j >= $$Last {
+		$$state = $$Act[$$g]
+	} else {
+		$$state = $$Act[$$j]
+		if $$Chk[$$state] != -$$n {
+			$$state = $$Act[$$g]
+		}
+	}
+	// dummy call; replaced with literal code
+	$$run()
+	goto $$stack /* stack new state and value */
+}
+`
diff --git a/vendor/golang.org/x/tools/oracle/callees.go b/vendor/golang.org/x/tools/cmd/guru/callees.go
similarity index 84%
rename from vendor/golang.org/x/tools/oracle/callees.go
rename to vendor/golang.org/x/tools/cmd/guru/callees.go
index 56e45e1..7ab1dba 100644
--- a/vendor/golang.org/x/tools/oracle/callees.go
+++ b/vendor/golang.org/x/tools/cmd/guru/callees.go
@@ -2,20 +2,20 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // Callees reports the possible callees of the function call site
@@ -28,11 +28,10 @@ func callees(q *Query) error {
 	}
 
 	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
+	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
 	if err != nil {
@@ -69,10 +68,10 @@ func callees(q *Query) error {
 			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.result = &calleesTypesResult{
+			q.Output(lprog.Fset, &calleesTypesResult{
 				site:   e,
 				callee: obj,
-			}
+			})
 			return nil
 		}
 	case *ast.SelectorExpr:
@@ -83,20 +82,25 @@ func callees(q *Query) error {
 			// or to top level function.
 			callee := qpos.info.Uses[funexpr.Sel]
 			if obj, ok := callee.(*types.Func); ok {
-				q.result = &calleesTypesResult{
+				q.Output(lprog.Fset, &calleesTypesResult{
 					site:   e,
 					callee: obj,
-				}
+				})
 				return nil
 			}
 		} else if sel.Kind() == types.MethodVal {
-			recvtype := sel.Recv()
+			// 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.result = &calleesTypesResult{
+				q.Output(lprog.Fset, &calleesTypesResult{
 					site:   e,
-					callee: sel.Obj().(*types.Func),
-				}
+					callee: method,
+				})
 				return nil
 			}
 		}
@@ -115,7 +119,7 @@ func callees(q *Query) error {
 	}
 
 	// Defer SSA construction till after errors are reported.
-	prog.BuildAll()
+	prog.Build()
 
 	// Ascertain calling function and call site.
 	callerFn := ssa.EnclosingFunction(pkg, qpos.path)
@@ -134,10 +138,10 @@ func callees(q *Query) error {
 		return err
 	}
 
-	q.result = &calleesSSAResult{
+	q.Output(lprog.Fset, &calleesSSAResult{
 		site:  site,
 		funcs: funcs,
-	}
+	})
 	return nil
 }
 
@@ -199,7 +203,7 @@ type calleesTypesResult struct {
 	callee *types.Func
 }
 
-func (r *calleesSSAResult) display(printf printfFunc) {
+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())
@@ -211,37 +215,37 @@ func (r *calleesSSAResult) display(printf printfFunc) {
 	}
 }
 
-func (r *calleesSSAResult) toSerial(res *serial.Result, fset *token.FileSet) {
+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.CalleesItem{
+		j.Callees = append(j.Callees, &serial.Callee{
 			Name: callee.String(),
 			Pos:  fset.Position(callee.Pos()).String(),
 		})
 	}
-	res.Callees = j
+	return toJSON(j)
 }
 
-func (r *calleesTypesResult) display(printf printfFunc) {
+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) toSerial(res *serial.Result, fset *token.FileSet) {
+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.CalleesItem{
-		&serial.CalleesItem{
+	j.Callees = []*serial.Callee{
+		{
 			Name: r.callee.FullName(),
 			Pos:  fset.Position(r.callee.Pos()).String(),
 		},
 	}
-	res.Callees = j
+	return toJSON(j)
 }
 
 // NB: byFuncPos is not deterministic across packages since it depends on load order.
diff --git a/vendor/golang.org/x/tools/cmd/guru/callers.go b/vendor/golang.org/x/tools/cmd/guru/callers.go
new file mode 100644
index 0000000..e51b6e5
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/oracle/callstack.go b/vendor/golang.org/x/tools/cmd/guru/callstack.go
similarity index 70%
rename from vendor/golang.org/x/tools/oracle/callstack.go
rename to vendor/golang.org/x/tools/cmd/guru/callstack.go
index 6f04b60..f1ca6a6 100644
--- a/vendor/golang.org/x/tools/oracle/callstack.go
+++ b/vendor/golang.org/x/tools/cmd/guru/callstack.go
@@ -2,17 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // Callstack displays an arbitrary path from a root of the callgraph
@@ -34,7 +35,7 @@ func callstack(q *Query) error {
 	}
 
 	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
+	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}
@@ -61,31 +62,45 @@ func callstack(q *Query) error {
 	}
 
 	// Defer SSA construction till after errors are reported.
-	prog.BuildAll()
+	prog.Build()
 
 	target := ssa.EnclosingFunction(pkg, qpos.path)
 	if target == nil {
 		return fmt.Errorf("no SSA function built for this location (dead code?)")
 	}
 
-	// Run the pointer analysis and build the complete call graph.
-	ptaConfig.BuildCallGraph = true
-	cg := ptrAnalysis(ptaConfig).CallGraph
-	cg.DeleteSyntheticNodes()
-
-	// Search for an arbitrary path from a root to the target function.
+	var callpath []*callgraph.Edge
 	isEnd := func(n *callgraph.Node) bool { return n.Func == target }
-	callpath := callgraph.PathSearch(cg.Root, isEnd)
-	if callpath != nil {
-		callpath = callpath[1:] // remove synthetic edge from <root>
+
+	// 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
+		}
 	}
 
-	q.Fset = fset
-	q.result = &callstackResult{
+	// 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
 }
 
@@ -95,7 +110,7 @@ type callstackResult struct {
 	callpath []*callgraph.Edge
 }
 
-func (r *callstackResult) display(printf printfFunc) {
+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)
@@ -108,7 +123,7 @@ func (r *callstackResult) display(printf printfFunc) {
 	}
 }
 
-func (r *callstackResult) toSerial(res *serial.Result, fset *token.FileSet) {
+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]
@@ -118,9 +133,9 @@ func (r *callstackResult) toSerial(res *serial.Result, fset *token.FileSet) {
 			Desc:   edge.Description(),
 		})
 	}
-	res.Callstack = &serial.CallStack{
+	return toJSON(&serial.CallStack{
 		Pos:     fset.Position(r.target.Pos()).String(),
 		Target:  r.target.String(),
 		Callers: callers,
-	}
+	})
 }
diff --git a/vendor/golang.org/x/tools/cmd/guru/definition.go b/vendor/golang.org/x/tools/cmd/guru/definition.go
new file mode 100644
index 0000000..46d4806
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/oracle/describe.go b/vendor/golang.org/x/tools/cmd/guru/describe.go
similarity index 72%
rename from vendor/golang.org/x/tools/oracle/describe.go
rename to vendor/golang.org/x/tools/cmd/guru/describe.go
index ea1c5ec..dd32911 100644
--- a/vendor/golang.org/x/tools/oracle/describe.go
+++ b/vendor/golang.org/x/tools/cmd/guru/describe.go
@@ -2,36 +2,36 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+package main
 
 import (
 	"bytes"
 	"fmt"
 	"go/ast"
+	exact "go/constant"
 	"go/token"
-	"log"
+	"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/exact"
 	"golang.org/x/tools/go/loader"
-	"golang.org/x/tools/go/types"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // 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 and method set (for an expression or type expression)
+// - 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 {
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
 		return err
 	}
 
@@ -40,7 +40,6 @@ func describe(q *Query) error {
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, true) // (need exact pos)
 	if err != nil {
@@ -52,43 +51,48 @@ func describe(q *Query) error {
 			astutil.NodeDescription(qpos.path[0]), pathToString(qpos.path))
 	}
 
+	var qr QueryResult
 	path, action := findInterestingNode(qpos.info, qpos.path)
 	switch action {
 	case actionExpr:
-		q.result, err = describeValue(qpos, path)
+		qr, err = describeValue(qpos, path)
 
 	case actionType:
-		q.result, err = describeType(qpos, path)
+		qr, err = describeType(qpos, path)
 
 	case actionPackage:
-		q.result, err = describePackage(qpos, path)
+		qr, err = describePackage(qpos, path)
 
 	case actionStmt:
-		q.result, err = describeStmt(qpos, path)
+		qr, err = describeStmt(qpos, path)
 
 	case actionUnknown:
-		q.result = &describeUnknownResult{path[0]}
+		qr = &describeUnknownResult{path[0]}
 
 	default:
 		panic(action) // unreachable
 	}
-	return err
+	if err != nil {
+		return err
+	}
+	q.Output(lprog.Fset, qr)
+	return nil
 }
 
 type describeUnknownResult struct {
 	node ast.Node
 }
 
-func (r *describeUnknownResult) display(printf printfFunc) {
+func (r *describeUnknownResult) PrintPlain(printf printfFunc) {
 	// Nothing much to say about misc syntax.
 	printf(r.node, "%s", astutil.NodeDescription(r.node))
 }
 
-func (r *describeUnknownResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	res.Describe = &serial.Describe{
+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
@@ -278,14 +282,12 @@ func findInterestingNode(pkginfo *loader.PackageInfo, path []ast.Node) ([]ast.No
 				return path, actionPackage
 
 			case *ast.ImportSpec:
-				// TODO(adonovan): fix: why no package object? go/types bug?
 				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.
-				log.Printf("unknown reference %s in %T\n", n, path[1])
 				return path, actionUnknown
 			}
 
@@ -326,7 +328,13 @@ func describeValue(qpos *queryPos, path []ast.Node) (*describeValueResult, error
 	}
 
 	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,
@@ -334,6 +342,8 @@ func describeValue(qpos *queryPos, path []ast.Node) (*describeValueResult, error
 		typ:      typ,
 		constVal: constVal,
 		obj:      obj,
+		methods:  accessibleMethods(typ, qpos.info.Pkg),
+		fields:   accessibleFields(typ, qpos.info.Pkg),
 	}, nil
 }
 
@@ -343,12 +353,14 @@ type describeValueResult struct {
 	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) display(printf printfFunc) {
+func (r *describeValueResult) PrintPlain(printf printfFunc) {
 	var prefix, suffix string
 	if r.constVal != nil {
-		suffix = fmt.Sprintf(" of constant value %s", r.constVal)
+		suffix = fmt.Sprintf(" of value %s", r.constVal)
 	}
 	switch obj := r.obj.(type) {
 	case *types.Func:
@@ -383,9 +395,12 @@ func (r *describeValueResult) display(printf printfFunc) {
 			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) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *describeValueResult) JSON(fset *token.FileSet) []byte {
 	var value, objpos string
 	if r.constVal != nil {
 		value = r.constVal.String()
@@ -394,7 +409,7 @@ func (r *describeValueResult) toSerial(res *serial.Result, fset *token.FileSet)
 		objpos = fset.Position(r.obj.Pos()).String()
 	}
 
-	res.Describe = &serial.Describe{
+	return toJSON(&serial.Describe{
 		Desc:   astutil.NodeDescription(r.expr),
 		Pos:    fset.Position(r.expr.Pos()).String(),
 		Detail: "value",
@@ -403,54 +418,53 @@ func (r *describeValueResult) toSerial(res *serial.Result, fset *token.FileSet)
 			Value:  value,
 			ObjPos: objpos,
 		},
-	}
+	})
 }
 
 // ---- TYPE ------------------------------------------------------------
 
 func describeType(qpos *queryPos, path []ast.Node) (*describeTypeResult, error) {
 	var description string
-	var t types.Type
+	var typ types.Type
 	switch n := path[0].(type) {
 	case *ast.Ident:
-		t = qpos.info.TypeOf(n)
-		switch t := t.(type) {
-		case *types.Basic:
+		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 "
-
-		case *types.Named:
-			isDef := t.Obj().Pos() == n.Pos() // see caveats at isDef above
-			if isDef {
-				description = "definition of "
-			} else {
-				description = "reference to "
-			}
+		} else {
+			description = "reference to " // (Named type)
 		}
 
 	case ast.Expr:
-		t = qpos.info.TypeOf(n)
+		typ = qpos.info.TypeOf(n)
 
 	default:
 		// Unreachable?
 		return nil, fmt.Errorf("unexpected AST for type: %T", n)
 	}
 
-	description = description + "type " + qpos.typeString(t)
+	description = description + "type " + qpos.typeString(typ)
 
 	// Show sizes for structs and named types (it's fairly obvious for others).
-	switch t.(type) {
+	switch typ.(type) {
 	case *types.Named, *types.Struct:
-		szs := types.StdSizes{8, 8} // assume amd64
+		szs := types.StdSizes{WordSize: 8, MaxAlign: 8} // assume amd64
 		description = fmt.Sprintf("%s (size %d, align %d)", description,
-			szs.Sizeof(t), szs.Alignof(t))
+			szs.Sizeof(typ), szs.Alignof(typ))
 	}
 
 	return &describeTypeResult{
 		qpos:        qpos,
 		node:        path[0],
 		description: description,
-		typ:         t,
-		methods:     accessibleMethods(t, qpos.info.Pkg),
+		typ:         typ,
+		methods:     accessibleMethods(typ, qpos.info.Pkg),
+		fields:      accessibleFields(typ, qpos.info.Pkg),
 	}, nil
 }
 
@@ -460,40 +474,85 @@ type describeTypeResult struct {
 	description string
 	typ         types.Type
 	methods     []*types.Selection
+	fields      []describeField
 }
 
-func (r *describeTypeResult) display(printf printfFunc) {
+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()))
 	}
 
-	// Print the method set, if the type kind is capable of bearing methods.
-	switch r.typ.(type) {
-	case *types.Interface, *types.Struct, *types.Named:
-		if len(r.methods) > 0 {
-			printf(r.node, "Method set:")
-			for _, meth := range r.methods {
-				// TODO(adonovan): print these relative
-				// to the owning package, not the
-				// query package.
-				printf(meth.Obj(), "\t%s", r.qpos.selectionString(meth))
-			}
-		} else {
+	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) toSerial(res *serial.Result, fset *token.FileSet) {
+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()
 	}
-	res.Describe = &serial.Describe{
+	return toJSON(&serial.Describe{
 		Desc:   r.description,
 		Pos:    fset.Position(r.node.Pos()).String(),
 		Detail: "type",
@@ -503,7 +562,7 @@ func (r *describeTypeResult) toSerial(res *serial.Result, fset *token.FileSet) {
 			NameDef: nameDef,
 			Methods: methodsToSerial(r.qpos.info.Pkg, r.methods, fset),
 		},
-	}
+	})
 }
 
 // ---- PACKAGE ------------------------------------------------------------
@@ -513,11 +572,15 @@ func describePackage(qpos *queryPos, path []ast.Node) (*describePackageResult, e
 	var pkg *types.Package
 	switch n := path[0].(type) {
 	case *ast.ImportSpec:
-		var pkgname *types.PkgName
+		var obj types.Object
 		if n.Name != nil {
-			pkgname = qpos.info.Defs[n.Name].(*types.PkgName)
-		} else if p := qpos.info.Implicits[n]; p != nil {
-			pkgname = p.(*types.PkgName)
+			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())
@@ -576,7 +639,7 @@ type describeMember struct {
 	methods []*types.Selection // in types.MethodSet order
 }
 
-func (r *describePackageResult) display(printf printfFunc) {
+func (r *describePackageResult) PrintPlain(printf printfFunc) {
 	printf(r.node, "%s", r.description)
 
 	// Compute max width of name "column".
@@ -601,29 +664,35 @@ func formatMember(obj types.Object, maxname int) string {
 	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().String())
+		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.
-		var abbrev string
-		switch t := obj.Type().Underlying().(type) {
+		switch typ := typ.(type) {
 		case *types.Interface:
-			if t.NumMethods() > 1 {
-				abbrev = "interface{...}"
+			if typ.NumMethods() > 1 {
+				typestr = "interface{...}"
 			}
 		case *types.Struct:
-			if t.NumFields() > 1 {
-				abbrev = "struct{...}"
+			if typ.NumFields() > 1 {
+				typestr = "struct{...}"
 			}
 		}
-		if abbrev == "" {
-			fmt.Fprintf(&buf, " %s", types.TypeString(obj.Type().Underlying(), qualifier))
-		} else {
-			fmt.Fprintf(&buf, " %s", abbrev)
+		if typestr == "" {
+			typestr = types.TypeString(typ, qualifier)
 		}
+		buf.WriteString(typestr)
 
 	case *types.Var:
 		fmt.Fprintf(&buf, " %s", types.TypeString(obj.Type(), qualifier))
@@ -631,27 +700,33 @@ func formatMember(obj types.Object, maxname int) string {
 	return buf.String()
 }
 
-func (r *describePackageResult) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *describePackageResult) JSON(fset *token.FileSet) []byte {
 	var members []*serial.DescribeMember
 	for _, mem := range r.members {
-		typ := mem.obj.Type()
+		obj := mem.obj
+		typ := obj.Type()
 		var val string
-		switch mem := mem.obj.(type) {
+		var alias string
+		switch obj := obj.(type) {
 		case *types.Const:
-			val = mem.Val().String()
+			val = obj.Val().String()
 		case *types.TypeName:
-			typ = typ.Underlying()
+			if isAlias(obj) {
+				alias = "= " // kludgy
+			} else {
+				typ = typ.Underlying()
+			}
 		}
 		members = append(members, &serial.DescribeMember{
-			Name:    mem.obj.Name(),
-			Type:    typ.String(),
+			Name:    obj.Name(),
+			Type:    alias + typ.String(),
 			Value:   val,
-			Pos:     fset.Position(mem.obj.Pos()).String(),
-			Kind:    tokenOf(mem.obj),
+			Pos:     fset.Position(obj.Pos()).String(),
+			Kind:    tokenOf(obj),
 			Methods: methodsToSerial(r.pkg, mem.methods, fset),
 		})
 	}
-	res.Describe = &serial.Describe{
+	return toJSON(&serial.Describe{
 		Desc:   r.description,
 		Pos:    fset.Position(r.node.Pos()).String(),
 		Detail: "package",
@@ -659,7 +734,7 @@ func (r *describePackageResult) toSerial(res *serial.Result, fset *token.FileSet
 			Path:    r.pkg.Path(),
 			Members: members,
 		},
-	}
+	})
 }
 
 func tokenOf(o types.Object) string {
@@ -674,6 +749,12 @@ func tokenOf(o types.Object) string {
 		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)
 }
@@ -703,16 +784,16 @@ type describeStmtResult struct {
 	description string
 }
 
-func (r *describeStmtResult) display(printf printfFunc) {
+func (r *describeStmtResult) PrintPlain(printf printfFunc) {
 	printf(r.node, "%s", r.description)
 }
 
-func (r *describeStmtResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	res.Describe = &serial.Describe{
+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 -------------------
@@ -742,6 +823,61 @@ func accessibleMethods(t types.Type, from *types.Package) []*types.Selection {
 	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
 }
diff --git a/vendor/golang.org/x/tools/oracle/freevars.go b/vendor/golang.org/x/tools/cmd/guru/freevars.go
similarity index 88%
rename from vendor/golang.org/x/tools/oracle/freevars.go
rename to vendor/golang.org/x/tools/cmd/guru/freevars.go
index 400a118..a36d1f8 100644
--- a/vendor/golang.org/x/tools/oracle/freevars.go
+++ b/vendor/golang.org/x/tools/cmd/guru/freevars.go
@@ -2,18 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // freevars displays the lexical (not package-level) free variables of
@@ -33,7 +33,7 @@ func freevars(q *Query) error {
 	lconf := loader.Config{Build: q.Build}
 	allowErrors(&lconf)
 
-	if err := importQueryPackage(q.Pos, &lconf); err != nil {
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
 		return err
 	}
 
@@ -42,7 +42,6 @@ func freevars(q *Query) error {
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, false)
 	if err != nil {
@@ -156,10 +155,10 @@ func freevars(q *Query) error {
 	}
 	sort.Sort(byRef(refs))
 
-	q.result = &freevarsResult{
+	q.Output(lprog.Fset, &freevarsResult{
 		qpos: qpos,
 		refs: refs,
-	}
+	})
 	return nil
 }
 
@@ -175,7 +174,7 @@ type freevarsRef struct {
 	obj  types.Object
 }
 
-func (r *freevarsResult) display(printf printfFunc) {
+func (r *freevarsResult) PrintPlain(printf printfFunc) {
 	if len(r.refs) == 0 {
 		printf(r.qpos, "No free identifiers.")
 	} else {
@@ -184,7 +183,7 @@ func (r *freevarsResult) display(printf printfFunc) {
 		for _, ref := range r.refs {
 			// Avoid printing "type T T".
 			var typstr string
-			if ref.kind != "type" {
+			if ref.kind != "type" && ref.kind != "label" {
 				typstr = " " + types.TypeString(ref.typ, qualifier)
 			}
 			printf(ref.obj, "%s %s%s", ref.kind, ref.ref, typstr)
@@ -192,18 +191,20 @@ func (r *freevarsResult) display(printf printfFunc) {
 	}
 }
 
-func (r *freevarsResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	var refs []*serial.FreeVar
-	for _, ref := range r.refs {
-		refs = append(refs,
-			&serial.FreeVar{
-				Pos:  fset.Position(ref.obj.Pos()).String(),
-				Kind: ref.kind,
-				Ref:  ref.ref,
-				Type: ref.typ.String(),
-			})
+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(),
+		}))
 	}
-	res.Freevars = refs
+	return buf.Bytes()
 }
 
 // -------- utils --------
diff --git a/vendor/golang.org/x/tools/oracle/oracle.go b/vendor/golang.org/x/tools/cmd/guru/guru.go
similarity index 61%
rename from vendor/golang.org/x/tools/oracle/oracle.go
rename to vendor/golang.org/x/tools/cmd/guru/guru.go
index 544cfa4..af3a27d 100644
--- a/vendor/golang.org/x/tools/oracle/oracle.go
+++ b/vendor/golang.org/x/tools/cmd/guru/guru.go
@@ -2,16 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package oracle contains the implementation of the oracle tool whose
-// command-line is provided by golang.org/x/tools/cmd/oracle.
-//
-// http://golang.org/s/oracle-design
-// http://golang.org/s/oracle-user-manual
-//
-package oracle // import "golang.org/x/tools/oracle"
-
-// This file defines oracle.Query, the entry point for the oracle tool.
-// The actual executable is defined in cmd/oracle.
+package main
 
 // TODO(adonovan): new queries
 // - show all statements that may update the selected lvalue
@@ -20,28 +11,36 @@ package oracle // import "golang.org/x/tools/oracle"
 //   (&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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 type printfFunc func(pos interface{}, format string, args ...interface{})
 
-// queryResult is the interface of each query-specific result type.
-type queryResult interface {
-	toSerial(res *serial.Result, fset *token.FileSet)
-	display(printf printfFunc)
+// 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:
@@ -66,14 +65,8 @@ func (qpos *queryPos) objectString(obj types.Object) string {
 	return types.ObjectString(obj, types.RelativeTo(qpos.info.Pkg))
 }
 
-// SelectionString prints selection sel relative to the query position.
-func (qpos *queryPos) selectionString(sel *types.Selection) string {
-	return types.SelectionString(sel, types.RelativeTo(qpos.info.Pkg))
-}
-
-// A Query specifies a single oracle query.
+// A Query specifies a single guru query.
 type Query struct {
-	Mode  string         // query mode ("callers", etc)
 	Pos   string         // query position
 	Build *build.Context // package loading configuration
 
@@ -82,32 +75,13 @@ type Query struct {
 	PTALog     io.Writer // (optional) pointer-analysis log file
 	Reflection bool      // model reflection soundly (currently slow).
 
-	// Populated during Run()
-	Fset   *token.FileSet
-	result queryResult
+	// result-printing function
+	Output func(*token.FileSet, QueryResult)
 }
 
-// Serial returns an instance of serial.Result, which implements the
-// {xml,json}.Marshaler interfaces so that query results can be
-// serialized as JSON or XML.
-//
-func (q *Query) Serial() *serial.Result {
-	resj := &serial.Result{Mode: q.Mode}
-	q.result.toSerial(resj, q.Fset)
-	return resj
-}
-
-// WriteTo writes the oracle query result res to out in a compiler diagnostic format.
-func (q *Query) WriteTo(out io.Writer) {
-	printf := func(pos interface{}, format string, args ...interface{}) {
-		fprintf(out, q.Fset, pos, format, args...)
-	}
-	q.result.display(printf)
-}
-
-// Run runs an oracle query and populates its Fset and Result.
-func Run(q *Query) error {
-	switch q.Mode {
+// 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":
@@ -133,49 +107,36 @@ func Run(q *Query) error {
 	case "what":
 		return what(q)
 	default:
-		return fmt.Errorf("invalid mode: %q", q.Mode)
+		return fmt.Errorf("invalid mode: %q", mode)
 	}
 }
 
 func setPTAScope(lconf *loader.Config, scope []string) error {
-	if len(scope) == 0 {
+	pkgs := buildutil.ExpandPatterns(lconf.Build, scope)
+	if len(pkgs) == 0 {
 		return fmt.Errorf("no packages specified for pointer analysis scope")
 	}
-
-	// Determine initial packages for PTA.
-	args, err := lconf.FromArgs(scope, true)
-	if err != nil {
-		return err
-	}
-	if len(args) > 0 {
-		return fmt.Errorf("surplus arguments: %q", args)
-	}
+	// 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) {
-	// TODO(adonovan): the body of this function is essentially
-	// duplicated in all go/pointer clients.  Refactor.
-
 	// For each initial package (specified on the command line),
 	// if it has a main function, analyze that,
 	// otherwise analyze its tests, if any.
-	var testPkgs, mains []*ssa.Package
+	var mains []*ssa.Package
 	for _, info := range lprog.InitialPackages() {
-		initialPkg := prog.Package(info.Pkg)
+		p := prog.Package(info.Pkg)
 
 		// Add package to the pointer analysis scope.
-		if initialPkg.Func("main") != nil {
-			mains = append(mains, initialPkg)
-		} else {
-			testPkgs = append(testPkgs, initialPkg)
-		}
-	}
-	if testPkgs != nil {
-		if p := prog.CreateTestMainPackage(testPkgs...); p != nil {
+		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 {
@@ -190,50 +151,50 @@ func setupPTA(prog *ssa.Program, lprog *loader.Program, ptaLog io.Writer, reflec
 
 // importQueryPackage finds the package P containing the
 // query position and tells conf to import it.
-func importQueryPackage(pos string, conf *loader.Config) error {
-	fqpos, err := fastQueryPos(pos)
+// 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
+		return "", err // bad query
 	}
 	filename := fqpos.fset.File(fqpos.start).Name()
 
-	// This will not work for ad-hoc packages
-	// such as $GOROOT/src/net/http/triv.go.
-	// TODO(adonovan): ensure we report a clear error.
 	_, importPath, err := guessImportPath(filename, conf.Build)
 	if err != nil {
-		return err // can't find GOPATH dir
-	}
-	if importPath == "" {
-		return fmt.Errorf("can't guess import path from %s", filename)
-	}
+		// 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
+		}
 
-	// Check that it's possible to load the queried package.
-	// (e.g. oracle 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:
-		return fmt.Errorf("package %q doesn't contain file %s",
-			importPath, filename)
+		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 nil
+	return importPath, nil
 }
 
 // pkgContainsFile reports whether file was among the packages Go
@@ -255,12 +216,26 @@ func pkgContainsFile(bp *build.Package, filename string) byte {
 // this is appropriate for queries that allow fairly arbitrary syntax,
 // e.g. "describe".
 //
-func parseQueryPos(lprog *loader.Program, posFlag string, needExact bool) (*queryPos, error) {
-	filename, startOffset, endOffset, err := parsePosFlag(posFlag)
+func parseQueryPos(lprog *loader.Program, pos string, needExact bool) (*queryPos, error) {
+	filename, startOffset, endOffset, err := parsePos(pos)
 	if err != nil {
 		return nil, err
 	}
-	start, end, err := findQueryPos(lprog.Fset, filename, startOffset, endOffset)
+
+	// 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
 	}
@@ -276,6 +251,53 @@ func parseQueryPos(lprog *loader.Program, posFlag string, needExact bool) (*quer
 
 // ---------- 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) {
@@ -321,7 +343,6 @@ func deref(typ types.Type) types.Type {
 //
 // The output format is is compatible with the 'gnu'
 // compilation-error-regexp in Emacs' compilation mode.
-// TODO(adonovan): support other editors.
 //
 func fprintf(w io.Writer, fset *token.FileSet, pos interface{}, format string, args ...interface{}) {
 	var start, end token.Pos
@@ -332,6 +353,14 @@ func fprintf(w io.Writer, fset *token.FileSet, pos interface{}, format string, a
 	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
 	}:
@@ -362,3 +391,11 @@ func fprintf(w io.Writer, fset *token.FileSet, pos interface{}, format string, a
 	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/vendor/golang.org/x/tools/cmd/guru/guru_test.go b/vendor/golang.org/x/tools/cmd/guru/guru_test.go
new file mode 100644
index 0000000..3432255
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/guru_test.go
@@ -0,0 +1,329 @@
+// 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_test
+
+// This file defines a test framework for guru queries.
+//
+// The files beneath testdata/src/main contain Go programs containing
+// query annotations of the form:
+//
+//   @verb id "select"
+//
+// where verb is the query mode (e.g. "callers"), id is a unique name
+// for this query, and "select" is a regular expression matching the
+// substring of the current line that is the query's input selection.
+//
+// The expected output for each query is provided in the accompanying
+// .golden file.
+//
+// (Location information is not included because it's too fragile to
+// display as text.  TODO(adonovan): think about how we can test its
+// correctness, since it is critical information.)
+//
+// Run this test with:
+// 	% go test golang.org/x/tools/cmd/guru -update
+// to update the golden files.
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	guru "golang.org/x/tools/cmd/guru"
+)
+
+var updateFlag = flag.Bool("update", false, "Update the golden files.")
+
+type query struct {
+	id       string         // unique id
+	verb     string         // query mode, e.g. "callees"
+	posn     token.Position // query position
+	filename string
+	queryPos string // query position in command-line syntax
+}
+
+func parseRegexp(text string) (*regexp.Regexp, error) {
+	pattern, err := strconv.Unquote(text)
+	if err != nil {
+		return nil, fmt.Errorf("can't unquote %s", text)
+	}
+	return regexp.Compile(pattern)
+}
+
+// parseQueries parses and returns the queries in the named file.
+func parseQueries(t *testing.T, filename string) []*query {
+	filedata, err := ioutil.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Parse the file once to discover the test queries.
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, filename, filedata, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	lines := bytes.Split(filedata, []byte("\n"))
+
+	var queries []*query
+	queriesById := make(map[string]*query)
+
+	// Find all annotations of these forms:
+	expectRe := regexp.MustCompile(`@([a-z]+)\s+(\S+)\s+(\".*)$`) // @verb id "regexp"
+	for _, c := range f.Comments {
+		text := strings.TrimSpace(c.Text())
+		if text == "" || text[0] != '@' {
+			continue
+		}
+		posn := fset.Position(c.Pos())
+
+		// @verb id "regexp"
+		match := expectRe.FindStringSubmatch(text)
+		if match == nil {
+			t.Errorf("%s: ill-formed query: %s", posn, text)
+			continue
+		}
+
+		id := match[2]
+		if prev, ok := queriesById[id]; ok {
+			t.Errorf("%s: duplicate id %s", posn, id)
+			t.Errorf("%s: previously used here", prev.posn)
+			continue
+		}
+
+		q := &query{
+			id:       id,
+			verb:     match[1],
+			filename: filename,
+			posn:     posn,
+		}
+
+		if match[3] != `"nopos"` {
+			selectRe, err := parseRegexp(match[3])
+			if err != nil {
+				t.Errorf("%s: %s", posn, err)
+				continue
+			}
+
+			// Find text of the current line, sans query.
+			// (Queries must be // not /**/ comments.)
+			line := lines[posn.Line-1][:posn.Column-1]
+
+			// Apply regexp to current line to find input selection.
+			loc := selectRe.FindIndex(line)
+			if loc == nil {
+				t.Errorf("%s: selection pattern %s doesn't match line %q",
+					posn, match[3], string(line))
+				continue
+			}
+
+			// Assumes ASCII. TODO(adonovan): test on UTF-8.
+			linestart := posn.Offset - (posn.Column - 1)
+
+			// Compute the file offsets.
+			q.queryPos = fmt.Sprintf("%s:#%d,#%d",
+				filename, linestart+loc[0], linestart+loc[1])
+		}
+
+		queries = append(queries, q)
+		queriesById[id] = q
+	}
+
+	// Return the slice, not map, for deterministic iteration.
+	return queries
+}
+
+// doQuery poses query q to the guru and writes its response and
+// error (if any) to out.
+func doQuery(out io.Writer, q *query, json bool) {
+	fmt.Fprintf(out, "-------- @%s %s --------\n", q.verb, q.id)
+
+	var buildContext = build.Default
+	buildContext.GOPATH = "testdata"
+	pkg := filepath.Dir(strings.TrimPrefix(q.filename, "testdata/src/"))
+
+	gopathAbs, _ := filepath.Abs(buildContext.GOPATH)
+
+	var outputMu sync.Mutex // guards outputs
+	var outputs []string    // JSON objects or lines of text
+	outputFn := func(fset *token.FileSet, qr guru.QueryResult) {
+		outputMu.Lock()
+		defer outputMu.Unlock()
+		if json {
+			jsonstr := string(qr.JSON(fset))
+			// Sanitize any absolute filenames that creep in.
+			jsonstr = strings.Replace(jsonstr, gopathAbs, "$GOPATH", -1)
+			outputs = append(outputs, jsonstr)
+		} else {
+			// suppress position information
+			qr.PrintPlain(func(_ interface{}, format string, args ...interface{}) {
+				outputs = append(outputs, fmt.Sprintf(format, args...))
+			})
+		}
+	}
+
+	query := guru.Query{
+		Pos:        q.queryPos,
+		Build:      &buildContext,
+		Scope:      []string{pkg},
+		Reflection: true,
+		Output:     outputFn,
+	}
+
+	if err := guru.Run(q.verb, &query); err != nil {
+		fmt.Fprintf(out, "\nError: %s\n", err)
+		return
+	}
+
+	// In a "referrers" query, references are sorted within each
+	// package but packages are visited in arbitrary order,
+	// so for determinism we sort them.  Line 0 is a caption.
+	if q.verb == "referrers" {
+		sort.Strings(outputs[1:])
+	}
+
+	for _, output := range outputs {
+		fmt.Fprintf(out, "%s\n", output)
+	}
+
+	if !json {
+		io.WriteString(out, "\n")
+	}
+}
+
+func TestGuru(t *testing.T) {
+	switch runtime.GOOS {
+	case "android":
+		t.Skipf("skipping test on %q (no testdata dir)", runtime.GOOS)
+	case "windows":
+		t.Skipf("skipping test on %q (no /usr/bin/diff)", runtime.GOOS)
+	}
+
+	for _, filename := range []string{
+		"testdata/src/alias/alias.go", // iff guru.HasAlias (go1.9)
+		"testdata/src/calls/main.go",
+		"testdata/src/describe/main.go",
+		"testdata/src/describe/main19.go", // iff go1.9
+		"testdata/src/freevars/main.go",
+		"testdata/src/implements/main.go",
+		"testdata/src/implements-methods/main.go",
+		"testdata/src/imports/main.go",
+		"testdata/src/peers/main.go",
+		"testdata/src/pointsto/main.go",
+		"testdata/src/referrers/main.go",
+		"testdata/src/reflection/main.go",
+		"testdata/src/what/main.go",
+		"testdata/src/whicherrs/main.go",
+		"testdata/src/softerrs/main.go",
+		// JSON:
+		// TODO(adonovan): most of these are very similar; combine them.
+		"testdata/src/calls-json/main.go",
+		"testdata/src/peers-json/main.go",
+		"testdata/src/definition-json/main.go",
+		"testdata/src/definition-json/main19.go",
+		"testdata/src/describe-json/main.go",
+		"testdata/src/implements-json/main.go",
+		"testdata/src/implements-methods-json/main.go",
+		"testdata/src/pointsto-json/main.go",
+		"testdata/src/referrers-json/main.go",
+		"testdata/src/what-json/main.go",
+	} {
+		if filename == "testdata/src/referrers/main.go" && runtime.GOOS == "plan9" {
+			// Disable this test on plan9 since it expects a particular
+			// wording for a "no such file or directory" error.
+			continue
+		}
+		if filename == "testdata/src/alias/alias.go" && !guru.HasAlias {
+			continue
+		}
+		if strings.HasSuffix(filename, "19.go") && !contains(build.Default.ReleaseTags, "go1.9") {
+			// TODO(adonovan): recombine the 'describe' and 'definition'
+			// tests once we drop support for go1.8.
+			continue
+		}
+
+		json := strings.Contains(filename, "-json/")
+		queries := parseQueries(t, filename)
+		golden := filename + "lden"
+		got := filename + "t"
+		gotfh, err := os.Create(got)
+		if err != nil {
+			t.Errorf("Create(%s) failed: %s", got, err)
+			continue
+		}
+		defer os.Remove(got)
+		defer gotfh.Close()
+
+		// Run the guru on each query, redirecting its output
+		// and error (if any) to the foo.got file.
+		for _, q := range queries {
+			doQuery(gotfh, q, json)
+		}
+
+		// Compare foo.got with foo.golden.
+		var cmd *exec.Cmd
+		switch runtime.GOOS {
+		case "plan9":
+			cmd = exec.Command("/bin/diff", "-c", golden, got)
+		default:
+			cmd = exec.Command("/usr/bin/diff", "-u", golden, got)
+		}
+		buf := new(bytes.Buffer)
+		cmd.Stdout = buf
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			t.Errorf("Guru tests for %s failed: %s.\n%s\n",
+				filename, err, buf)
+
+			if *updateFlag {
+				t.Logf("Updating %s...", golden)
+				if err := exec.Command("/bin/cp", got, golden).Run(); err != nil {
+					t.Errorf("Update failed: %s", err)
+				}
+			}
+		}
+	}
+}
+
+func contains(haystack []string, needle string) bool {
+	for _, x := range haystack {
+		if needle == x {
+			return true
+		}
+	}
+	return false
+}
+
+func TestIssue14684(t *testing.T) {
+	var buildContext = build.Default
+	buildContext.GOPATH = "testdata"
+	query := guru.Query{
+		Pos:   "testdata/src/README.txt:#1",
+		Build: &buildContext,
+	}
+	err := guru.Run("freevars", &query)
+	if err == nil {
+		t.Fatal("guru query succeeded unexpectedly")
+	}
+	if got, want := err.Error(), "testdata/src/README.txt is not a Go source file"; got != want {
+		t.Errorf("query error was %q, want %q", got, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/oracle/implements.go b/vendor/golang.org/x/tools/cmd/guru/implements.go
similarity index 82%
rename from vendor/golang.org/x/tools/oracle/implements.go
rename to vendor/golang.org/x/tools/cmd/guru/implements.go
index 3155ca2..2d89b2d 100644
--- a/vendor/golang.org/x/tools/oracle/implements.go
+++ b/vendor/golang.org/x/tools/cmd/guru/implements.go
@@ -2,24 +2,25 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/oracle/serial"
+	"golang.org/x/tools/refactor/importgraph"
 )
 
 // Implements displays the "implements" relation as it pertains to the
-// selected type within a single package.
+// 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.
@@ -28,16 +29,40 @@ func implements(q *Query) error {
 	lconf := loader.Config{Build: q.Build}
 	allowErrors(&lconf)
 
-	if err := importQueryPackage(q.Pos, &lconf); err != nil {
+	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
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, false)
 	if err != nil {
@@ -63,28 +88,34 @@ func implements(q *Query) error {
 				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("no type or method here")
+		return fmt.Errorf("not a type, method, or value")
 	}
 
 	// Find all named types, even local types (which can have
-	// methods via promotion) and the built-in "error".
-	//
-	// TODO(adonovan): include all packages in PTA scope too?
-	// i.e. don't reduceScope?
-	//
-	var allNamed []types.Type
+	// 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 {
-				allNamed = append(allNamed, obj.Type())
+			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())
+	allNamed = append(allNamed, types.Universe.Lookup("error").Type().(*types.Named))
 
 	var msets typeutil.MethodSetCache
 
@@ -157,9 +188,9 @@ func implements(q *Query) error {
 		}
 	}
 
-	q.result = &implementsResult{
+	q.Output(lprog.Fset, &implementsResult{
 		qpos, T, pos, to, from, fromPtr, method, toMethod, fromMethod, fromPtrMethod,
-	}
+	})
 	return nil
 }
 
@@ -179,7 +210,7 @@ type implementsResult struct {
 	fromPtrMethod []*types.Selection // method of type fromPtrMethod[i], if any
 }
 
-func (r *implementsResult) display(printf printfFunc) {
+func (r *implementsResult) PrintPlain(printf printfFunc) {
 	relation := "is implemented by"
 
 	meth := func(sel *types.Selection) {
@@ -276,8 +307,15 @@ func (r *implementsResult) display(printf printfFunc) {
 	}
 }
 
-func (r *implementsResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	res.Implements = &serial.Implements{
+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),
@@ -285,13 +323,9 @@ func (r *implementsResult) toSerial(res *serial.Result, fset *token.FileSet) {
 		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),
-	}
-	if r.method != nil {
-		res.Implements.Method = &serial.DescribeMethod{
-			Name: r.qpos.objectString(r.method),
-			Pos:  fset.Position(r.method.Pos()).String(),
-		}
-	}
+		Method:                  method,
+	})
+
 }
 
 func makeImplementsTypes(tt []types.Type, fset *token.FileSet) []serial.ImplementsType {
diff --git a/vendor/golang.org/x/tools/cmd/guru/isAlias18.go b/vendor/golang.org/x/tools/cmd/guru/isAlias18.go
new file mode 100644
index 0000000..6a2a4c0
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/cmd/guru/isAlias19.go b/vendor/golang.org/x/tools/cmd/guru/isAlias19.go
new file mode 100644
index 0000000..25096ab
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/cmd/guru/main.go b/vendor/golang.org/x/tools/cmd/guru/main.go
new file mode 100644
index 0000000..761828a
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/oracle/peers.go b/vendor/golang.org/x/tools/cmd/guru/peers.go
similarity index 94%
rename from vendor/golang.org/x/tools/oracle/peers.go
rename to vendor/golang.org/x/tools/cmd/guru/peers.go
index 9c2a497..6e138bf 100644
--- a/vendor/golang.org/x/tools/oracle/peers.go
+++ b/vendor/golang.org/x/tools/cmd/guru/peers.go
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // peers enumerates, for a given channel send (or receive) operation,
@@ -31,11 +31,10 @@ func peers(q *Query) error {
 	}
 
 	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
+	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, false)
 	if err != nil {
@@ -55,7 +54,7 @@ func peers(q *Query) error {
 	}
 
 	// Defer SSA construction till after errors are reported.
-	prog.BuildAll()
+	prog.Build()
 
 	var queryOp chanOp // the originating send or receive operation
 	var ops []chanOp   // all sends/receives of opposite direction
@@ -127,14 +126,14 @@ func peers(q *Query) error {
 	sort.Sort(byPos(receives))
 	sort.Sort(byPos(closes))
 
-	q.result = &peersResult{
+	q.Output(lprog.Fset, &peersResult{
 		queryPos:  opPos,
 		queryType: queryType,
 		makes:     makes,
 		sends:     sends,
 		receives:  receives,
 		closes:    closes,
-	}
+	})
 	return nil
 }
 
@@ -195,13 +194,14 @@ func chanOps(instr ssa.Instruction) []chanOp {
 	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) display(printf printfFunc) {
+func (r *peersResult) PrintPlain(printf printfFunc) {
 	if len(r.makes) == 0 {
 		printf(r.queryPos, "This channel can't point to anything.")
 		return
@@ -221,7 +221,7 @@ func (r *peersResult) display(printf printfFunc) {
 	}
 }
 
-func (r *peersResult) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *peersResult) JSON(fset *token.FileSet) []byte {
 	peers := &serial.Peers{
 		Pos:  fset.Position(r.queryPos).String(),
 		Type: r.queryType.String(),
@@ -238,7 +238,7 @@ func (r *peersResult) toSerial(res *serial.Result, fset *token.FileSet) {
 	for _, clos := range r.closes {
 		peers.Closes = append(peers.Closes, fset.Position(clos).String())
 	}
-	res.Peers = peers
+	return toJSON(peers)
 }
 
 // -------- utils --------
diff --git a/vendor/golang.org/x/tools/oracle/pointsto.go b/vendor/golang.org/x/tools/cmd/guru/pointsto.go
similarity index 96%
rename from vendor/golang.org/x/tools/oracle/pointsto.go
rename to vendor/golang.org/x/tools/cmd/guru/pointsto.go
index d366dd3..782277f 100644
--- a/vendor/golang.org/x/tools/oracle/pointsto.go
+++ b/vendor/golang.org/x/tools/cmd/guru/pointsto.go
@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // pointsto runs the pointer analysis on the selected expression,
@@ -34,11 +34,10 @@ func pointsto(q *Query) error {
 	}
 
 	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
+	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
 	if err != nil {
@@ -95,7 +94,7 @@ func pointsto(q *Query) error {
 	}
 
 	// Defer SSA construction till after errors are reported.
-	prog.BuildAll()
+	prog.Build()
 
 	// Run the pointer analysis.
 	ptrs, err := runPTA(ptaConfig, value, isAddr)
@@ -103,11 +102,11 @@ func pointsto(q *Query) error {
 		return err // e.g. analytically unreachable
 	}
 
-	q.result = &pointstoResult{
+	q.Output(lprog.Fset, &pointstoResult{
 		qpos: qpos,
 		typ:  typ,
 		ptrs: ptrs,
-	}
+	})
 	return nil
 }
 
@@ -209,7 +208,7 @@ type pointstoResult struct {
 	ptrs []pointerResult // pointer info (typ is concrete => len==1)
 }
 
-func (r *pointstoResult) display(printf printfFunc) {
+func (r *pointstoResult) PrintPlain(printf printfFunc) {
 	if pointer.CanHaveDynamicTypes(r.typ) {
 		// Show concrete types for interface, reflect.Type or
 		// reflect.Value expression.
@@ -244,7 +243,7 @@ func (r *pointstoResult) display(printf printfFunc) {
 	}
 }
 
-func (r *pointstoResult) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *pointstoResult) JSON(fset *token.FileSet) []byte {
 	var pts []serial.PointsTo
 	for _, ptr := range r.ptrs {
 		var namePos string
@@ -264,7 +263,7 @@ func (r *pointstoResult) toSerial(res *serial.Result, fset *token.FileSet) {
 			Labels:  labels,
 		})
 	}
-	res.PointsTo = pts
+	return toJSON(pts)
 }
 
 type byTypeString []pointerResult
diff --git a/vendor/golang.org/x/tools/oracle/pos.go b/vendor/golang.org/x/tools/cmd/guru/pos.go
similarity index 52%
rename from vendor/golang.org/x/tools/oracle/pos.go
rename to vendor/golang.org/x/tools/cmd/guru/pos.go
index 3c706f3..2e659fe 100644
--- a/vendor/golang.org/x/tools/oracle/pos.go
+++ b/vendor/golang.org/x/tools/cmd/guru/pos.go
@@ -1,9 +1,14 @@
-package oracle
+// 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"
@@ -12,6 +17,7 @@ import (
 	"strings"
 
 	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/buildutil"
 )
 
 // parseOctothorpDecimal returns the numeric value if s matches "#%d",
@@ -25,63 +31,48 @@ func parseOctothorpDecimal(s string) int {
 	return -1
 }
 
-// parsePosFlag parses a string of the form "file:pos" or
+// 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 parsePosFlag(posFlag string) (filename string, startOffset, endOffset int, err error) {
-	if posFlag == "" {
-		err = fmt.Errorf("no source position specified (-pos flag)")
+func parsePos(pos string) (filename string, startOffset, endOffset int, err error) {
+	if pos == "" {
+		err = fmt.Errorf("no source position specified")
 		return
 	}
 
-	colon := strings.LastIndex(posFlag, ":")
+	colon := strings.LastIndex(pos, ":")
 	if colon < 0 {
-		err = fmt.Errorf("invalid source position -pos=%q", posFlag)
+		err = fmt.Errorf("bad position syntax %q", pos)
 		return
 	}
-	filename, offset := posFlag[:colon], posFlag[colon+1:]
+	filename, offset := pos[:colon], pos[colon+1:]
 	startOffset = -1
 	endOffset = -1
-	if hyphen := strings.Index(offset, ","); hyphen < 0 {
+	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[:hyphen])
-		endOffset = parseOctothorpDecimal(offset[hyphen+1:])
+		startOffset = parseOctothorpDecimal(offset[:comma])
+		endOffset = parseOctothorpDecimal(offset[comma+1:])
 	}
 	if startOffset < 0 || endOffset < 0 {
-		err = fmt.Errorf("invalid -pos offset %q", offset)
+		err = fmt.Errorf("invalid offset %q in query position", offset)
 		return
 	}
 	return
 }
 
-// findQueryPos searches fset for filename and 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.
+// 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 findQueryPos(fset *token.FileSet, filename string, startOffset, endOffset int) (start, end token.Pos, err error) {
-	var file *token.File
-	fset.Iterate(func(f *token.File) bool {
-		if sameFile(filename, f.Name()) {
-			// (f.Name() is absolute)
-			file = f
-			return false // done
-		}
-		return true // continue
-	})
-	if file == nil {
-		err = fmt.Errorf("couldn't find file containing position")
-		return
-	}
-
+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() {
@@ -115,21 +106,29 @@ func sameFile(x, y string) bool {
 	return false
 }
 
-// fastQueryPos parses the -pos flag and returns a QueryPos.
-// It parses only a single file, and does not run the type checker.
-func fastQueryPos(posFlag string) (*queryPos, error) {
-	filename, startOffset, endOffset, err := parsePosFlag(posFlag)
+// 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()
-	f, err := parser.ParseFile(fset, filename, nil, 0)
-	if err != nil {
+	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 := findQueryPos(fset, filename, startOffset, endOffset)
+	start, end, err := fileOffsetToPos(fset.File(f.Pos()), startOffset, endOffset)
 	if err != nil {
 		return nil, err
 	}
diff --git a/vendor/golang.org/x/tools/cmd/guru/referrers.go b/vendor/golang.org/x/tools/cmd/guru/referrers.go
new file mode 100644
index 0000000..d6b9df9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/referrers.go
@@ -0,0 +1,522 @@
+// 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/token"
+	"go/types"
+	"io"
+	"log"
+	"sort"
+	"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/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/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())
+	}
+
+	// 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 interface method, we must load
+	// any package that transitively imports P.
+	if global, pkglevel := classify(obj); global {
+		// 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, pkglevel)
+	}
+
+	q.Output(fset, &referrersInitialResult{
+		qinfo: qpos.info,
+		obj:   obj,
+	})
+
+	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 at the specified source position.  Its defining package is defpkg,
+// and the query package is qpkg.  isPkgLevel indicates whether the object
+// is defined at package-level.
+func globalReferrers(q *Query, qpkg, defpkg string, objposn token.Position, isPkgLevel bool) 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.
+	var users map[string]bool
+	if isPkgLevel {
+		users = rev[defpkg] // direct importers
+		if users == nil {
+			users = make(map[string]bool)
+		}
+		users[defpkg] = true // plus the defining package itself
+	} else {
+		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
+		qinfo *loader.PackageInfo // info for qpkg
+	)
+
+	// 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)
+				}
+
+				// Object found.
+				qinfo = info
+				q.Output(fset, &referrersInitialResult{
+					qinfo: qinfo,
+					obj:   qobj,
+				})
+			}
+			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
+}
+
+// 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)
+				<-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.
+func readFile(ctxt *build.Context, filename string) ([]byte, error) {
+	rc, err := buildutil.OpenFile(ctxt, filename)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	var buf 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/vendor/golang.org/x/tools/oracle/serial/serial.go b/vendor/golang.org/x/tools/cmd/guru/serial/serial.go
similarity index 81%
rename from vendor/golang.org/x/tools/oracle/serial/serial.go
rename to vendor/golang.org/x/tools/cmd/guru/serial/serial.go
index 65f0822..9528797 100644
--- a/vendor/golang.org/x/tools/oracle/serial/serial.go
+++ b/vendor/golang.org/x/tools/cmd/guru/serial/serial.go
@@ -2,17 +2,30 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package serial defines the oracle's schema for structured data
-// serialization using JSON, XML, etc.
-package serial
-
-// All 'pos' strings are of the form "file:line:col".
-// TODO(adonovan): improve performance by sharing filename strings.
-// TODO(adonovan): improve precision by providing the start/end
-// interval when available.
+// Package serial defines the guru's schema for -json output.
 //
-// TODO(adonovan): consider richer encodings of types, functions,
-// methods, etc.
+// 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.
@@ -25,13 +38,22 @@ type Peers struct {
 	Closes   []string `json:"closes,omitempty"`   // locations of aliased close(ch) ops
 }
 
-// A Referrers is the result of a 'referrers' query.
-type Referrers struct {
-	Pos    string   `json:"pos"`              // location of the query reference
-	ObjPos string   `json:"objpos,omitempty"` // location of the definition
-	Desc   string   `json:"desc"`             // description of the denoted object
-	Refs   []string `json:"refs,omitempty"`   // locations of all references
-}
+// 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 {
@@ -39,20 +61,21 @@ type Definition struct {
 	Desc   string `json:"desc"`             // description of the denoted object
 }
 
-type CalleesItem struct {
-	Name string `json:"name"` // full name of called function
-	Pos  string `json:"pos"`  // location of called function
-}
-
 // 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 []*CalleesItem `json:"callees,omitempty"` // set of possible call targets
-}
+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.)
@@ -130,6 +153,8 @@ type What struct {
 	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.
@@ -232,27 +257,3 @@ type WhichErrsType struct {
 	Type     string `json:"type,omitempty"`
 	Position string `json:"position,omitempty"`
 }
-
-// A Result is the common result of any oracle query.
-// It contains a query-specific result element.
-//
-// TODO(adonovan): perhaps include other info such as: analysis scope,
-// raw query position, stack of ast nodes, query package, etc.
-type Result struct {
-	Mode string `json:"mode"` // mode of the query
-
-	// Exactly one of the following fields is populated:
-	// the one specified by 'mode'.
-	Callees    *Callees    `json:"callees,omitempty"`
-	Callers    []Caller    `json:"callers,omitempty"`
-	Callstack  *CallStack  `json:"callstack,omitempty"`
-	Definition *Definition `json:"definition,omitempty"`
-	Describe   *Describe   `json:"describe,omitempty"`
-	Freevars   []*FreeVar  `json:"freevars,omitempty"`
-	Implements *Implements `json:"implements,omitempty"`
-	Peers      *Peers      `json:"peers,omitempty"`
-	PointsTo   []PointsTo  `json:"pointsto,omitempty"`
-	Referrers  *Referrers  `json:"referrers,omitempty"`
-	What       *What       `json:"what,omitempty"`
-	WhichErrs  *WhichErrs  `json:"whicherrs,omitempty"`
-}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/README.txt b/vendor/golang.org/x/tools/cmd/guru/testdata/src/README.txt
new file mode 100644
index 0000000..34fc41a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/README.txt
@@ -0,0 +1,2 @@
+This is not a Go source file.
+Used by TestIssue14684.
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.go
new file mode 100644
index 0000000..42e1d29
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.go
@@ -0,0 +1,23 @@
+// Tests of Go 1.9 type aliases.
+// See go.tools/guru/guru_test.go for explanation.
+// See alias.golden for expected query results.
+
+package alias // @describe describe-pkg "alias"
+
+type I interface { // @implements implements-I "I"
+	f()
+}
+
+type N int
+
+func (N) f() {}
+
+type M = N // @describe describe-def-M "M"
+var m M    // @describe describe-ref-M "M"
+
+type O N // @describe describe-O "O"
+
+type P = struct{ N } // @describe describe-P "N"
+
+type U = undefined // @describe describe-U "U"
+type _ = undefined // @describe describe-undefined "undefined"
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.golden
new file mode 100644
index 0000000..b5ba46e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/alias/alias.golden
@@ -0,0 +1,47 @@
+-------- @describe describe-pkg --------
+definition of package "alias"
+	type  I interface{f()}
+		method (I) f()
+	type  M = N
+		method (N) f()
+	type  N int
+		method (N) f()
+	type  O int
+	type  P = struct{N}
+		method (struct{N}) f()
+	type  U = invalid type
+	var   m N
+
+-------- @implements implements-I --------
+interface type I
+	is implemented by basic type N
+
+-------- @describe describe-def-M --------
+alias of type N (size 8, align 8)
+defined as int
+Methods:
+	method (N) f()
+
+-------- @describe describe-ref-M --------
+alias of type N (size 8, align 8)
+defined as int
+Methods:
+	method (N) f()
+
+-------- @describe describe-O --------
+definition of type O (size 8, align 8)
+No methods.
+
+-------- @describe describe-P --------
+type struct{N} (size 8, align 8)
+Methods:
+	method (struct{N}) f()
+Fields:
+	N N
+
+-------- @describe describe-U --------
+alias of type invalid type
+
+-------- @describe describe-undefined --------
+identifier
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.go
new file mode 100644
index 0000000..9d58ed1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.go
@@ -0,0 +1,16 @@
+package main
+
+// Tests of call-graph queries, -format=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See calls-json.golden for expected query results.
+
+func call(f func()) {
+	f() // @callees @callees-f "f"
+}
+
+func main() {
+	call(func() {
+		// @callers callers-main.anon "^"
+		// @callstack callstack-main.anon "^"
+	})
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.golden
new file mode 100644
index 0000000..27dc509
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls-json/main.golden
@@ -0,0 +1,28 @@
+-------- @callees @callees-f --------
+{
+	"pos": "testdata/src/calls-json/main.go:8:3",
+	"desc": "dynamic function call",
+	"callees": [
+		{
+			"name": "calls-json.main$1",
+			"pos": "testdata/src/calls-json/main.go:12:7"
+		}
+	]
+}
+-------- @callstack callstack-main.anon --------
+{
+	"pos": "testdata/src/calls-json/main.go:12:7",
+	"target": "calls-json.main$1",
+	"callers": [
+		{
+			"pos": "testdata/src/calls-json/main.go:8:3",
+			"desc": "dynamic function call",
+			"caller": "calls-json.call"
+		},
+		{
+			"pos": "testdata/src/calls-json/main.go:12:6",
+			"desc": "static function call",
+			"caller": "calls-json.main"
+		}
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.go
new file mode 100644
index 0000000..a208914
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+	"fmt"
+)
+
+// Tests of call-graph queries.
+// See go.tools/guru/guru_test.go for explanation.
+// See calls.golden for expected query results.
+
+func A(x *int) { // @pointsto pointsto-A-x "x"
+	// @callers callers-A "^"
+	// @callstack callstack-A "^"
+}
+
+func B(x *int) { // @pointsto pointsto-B-x "x"
+	// @callers callers-B "^"
+}
+
+func foo() {
+}
+
+// apply is not (yet) treated context-sensitively.
+func apply(f func(x *int), x *int) {
+	f(x) // @callees callees-apply "f"
+	// @callers callers-apply "^"
+}
+
+// store *is* treated context-sensitively,
+// so the points-to sets for pc, pd are precise.
+func store(ptr **int, value *int) {
+	*ptr = value
+	// @callers callers-store "^"
+}
+
+func call(f func() *int) {
+	// Result points to anon function.
+	f() // @pointsto pointsto-result-f "f"
+
+	// Target of call is anon function.
+	f() // @callees callees-main.call-f "f"
+
+	// @callers callers-main.call "^"
+}
+
+func main() {
+	var a, b int
+	go apply(A, &a) // @callees callees-main-apply1 "app"
+	defer apply(B, &b)
+
+	var c, d int
+	var pc, pd *int // @pointsto pointsto-pc "pc"
+	store(&pc, &c)
+	store(&pd, &d)
+	_ = pd // @pointsto pointsto-pd "pd"
+
+	call(func() *int {
+		// We are called twice from main.call
+		// @callers callers-main.anon "^"
+		return &a
+	})
+
+	// Errors
+	_ = "no function call here"   // @callees callees-err-no-call "no"
+	print("builtin")              // @callees callees-err-builtin "builtin"
+	_ = string("type conversion") // @callees callees-err-conversion "str"
+	call(nil)                     // @callees callees-err-bad-selection "call\\(nil"
+	if false {
+		main() // @callees callees-err-deadcode1 "main"
+	}
+	var nilFunc func()
+	nilFunc() // @callees callees-err-nil-func "nilFunc"
+	var i interface {
+		f()
+	}
+	i.f() // @callees callees-err-nil-interface "i.f"
+
+	i = new(myint)
+	i.f() // @callees callees-not-a-wrapper "f"
+
+	// statically dispatched calls. Handled specially by callees, so test that they work.
+	foo()         // @callees callees-static-call "foo"
+	fmt.Println() // @callees callees-qualified-call "Println"
+	m := new(method)
+	m.f() // @callees callees-static-method-call "f"
+	g := new(embeddedIface)
+	g.iface = m
+	g.f() // @callees callees-implicit-selection-method-call "f"
+}
+
+type myint int
+
+func (myint) f() {
+	// @callers callers-not-a-wrapper "^"
+}
+
+type method int
+
+func (method) f() {
+}
+
+type embeddedIface struct {
+	iface
+}
+
+type iface interface {
+	f()
+}
+
+var dynamic = func() {}
+
+func deadcode() {
+	main() // @callees callees-err-deadcode2 "main"
+	// @callers callers-err-deadcode "^"
+	// @callstack callstack-err-deadcode "^"
+
+	// Within dead code, dynamic calls have no callees.
+	dynamic() // @callees callees-err-deadcode3 "dynamic"
+}
+
+// This code belongs to init.
+var global = 123 // @callers callers-global "global"
+
+// The package initializer may be called by other packages' inits, or
+// in this case, the root of the callgraph.  The source-level init functions
+// are in turn called by it.
+func init() {
+	// @callstack callstack-init "^"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.golden
new file mode 100644
index 0000000..ab68e95
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/calls/main.golden
@@ -0,0 +1,125 @@
+-------- @pointsto pointsto-A-x --------
+this *int may point to these objects:
+	a
+	b
+
+-------- @callstack callstack-A --------
+Found a call path from root to calls.A
+calls.A
+dynamic function call from calls.apply
+concurrent static function call from calls.main
+
+-------- @pointsto pointsto-B-x --------
+this *int may point to these objects:
+	a
+	b
+
+-------- @callers callers-B --------
+calls.B is called from these 1 sites:
+	dynamic function call from calls.apply
+
+-------- @callees callees-apply --------
+this dynamic function call dispatches to:
+	calls.A
+	calls.B
+
+-------- @callers callers-apply --------
+calls.apply is called from these 2 sites:
+	concurrent static function call from calls.main
+	deferred static function call from calls.main
+
+-------- @callers callers-store --------
+calls.store is called from these 2 sites:
+	static function call from calls.main
+	static function call from calls.main
+
+-------- @pointsto pointsto-result-f --------
+this func() *int may point to these objects:
+	calls.main$1
+
+-------- @callees callees-main.call-f --------
+this dynamic function call dispatches to:
+	calls.main$1
+
+-------- @callers callers-main.call --------
+calls.call is called from these 2 sites:
+	static function call from calls.main
+	static function call from calls.main
+
+-------- @callees callees-main-apply1 --------
+this static function call dispatches to:
+	calls.apply
+
+-------- @pointsto pointsto-pc --------
+this *int may point to these objects:
+	c
+
+-------- @pointsto pointsto-pd --------
+this *int may point to these objects:
+	d
+
+-------- @callees callees-err-no-call --------
+
+Error: there is no function call here
+-------- @callees callees-err-builtin --------
+
+Error: this is a call to the built-in 'print' operator
+-------- @callees callees-err-conversion --------
+
+Error: this is a type conversion, not a function call
+-------- @callees callees-err-bad-selection --------
+
+Error: ambiguous selection within function call (or conversion)
+-------- @callees callees-err-deadcode1 --------
+this static function call dispatches to:
+	calls.main
+
+-------- @callees callees-err-nil-func --------
+dynamic function call on nil value
+
+-------- @callees callees-err-nil-interface --------
+dynamic method call on nil value
+
+-------- @callees callees-not-a-wrapper --------
+this dynamic method call dispatches to:
+	(calls.myint).f
+
+-------- @callees callees-static-call --------
+this static function call dispatches to:
+	calls.foo
+
+-------- @callees callees-qualified-call --------
+this static function call dispatches to:
+	fmt.Println
+
+-------- @callees callees-static-method-call --------
+this static function call dispatches to:
+	(calls.method).f
+
+-------- @callees callees-implicit-selection-method-call --------
+this dynamic method call dispatches to:
+	(calls.method).f
+
+-------- @callers callers-not-a-wrapper --------
+(calls.myint).f is called from these 1 sites:
+	dynamic method call from calls.main
+
+-------- @callees callees-err-deadcode2 --------
+this static function call dispatches to:
+	calls.main
+
+-------- @callstack callstack-err-deadcode --------
+calls.deadcode is unreachable in this analysis scope
+
+-------- @callees callees-err-deadcode3 --------
+
+Error: this call site is unreachable in this analysis
+-------- @callers callers-global --------
+calls.init is called from these 1 sites:
+the root of the call graph
+
+-------- @callstack callstack-init --------
+Found a call path from root to calls.init#1
+calls.init#1
+static function call from calls.init
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.go
new file mode 100644
index 0000000..6408404
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.go
@@ -0,0 +1,66 @@
+package definition
+
+// Tests of 'definition' query, -json output.
+// See golang.org/x/tools/cmd/guru/guru_test.go for explanation.
+// See main.golden for expected query results.
+
+// TODO(adonovan): test: selection of member of same package defined in another file.
+
+import (
+	"lib"
+	lib2 "lib"
+)
+
+func main() {
+	var _ int // @definition builtin "int"
+
+	var _ undef           // @definition lexical-undef "undef"
+	var x lib.T           // @definition lexical-pkgname "lib"
+	f()                   // @definition lexical-func "f"
+	print(x)              // @definition lexical-var "x"
+	if x := ""; x == "" { // @definition lexical-shadowing "x"
+	}
+
+	var _ lib.Type     // @definition qualified-type "Type"
+	var _ lib.Func     // @definition qualified-func "Func"
+	var _ lib.Var      // @definition qualified-var "Var"
+	var _ lib.Const    // @definition qualified-const "Const"
+	var _ lib2.Type    // @definition qualified-type-renaming "Type"
+	var _ lib.Nonesuch // @definition qualified-nomember "Nonesuch"
+
+	var u U
+	print(u.field) // @definition select-field "field"
+	u.method()     // @definition select-method "method"
+}
+
+func f()
+
+type T struct{ field int }
+
+func (T) method()
+
+type U struct{ T }
+
+type V1 struct {
+	W // @definition embedded-other-file "W"
+}
+
+type V2 struct {
+	*W // @definition embedded-other-file-pointer "W"
+}
+
+type V3 struct {
+	int // @definition embedded-basic "int"
+}
+
+type V4 struct {
+	*int // @definition embedded-basic-pointer "int"
+}
+
+type V5 struct {
+	lib.Type // @definition embedded-other-pkg "Type"
+}
+
+type V6 struct {
+	T // @definition embedded-same-file "T"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.golden
new file mode 100644
index 0000000..af0a687
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main.golden
@@ -0,0 +1,90 @@
+-------- @definition builtin --------
+
+Error: int is built in
+-------- @definition lexical-undef --------
+
+Error: no object for identifier
+-------- @definition lexical-pkgname --------
+{
+	"objpos": "testdata/src/definition-json/main.go:10:2",
+	"desc": "package lib"
+}
+-------- @definition lexical-func --------
+{
+	"objpos": "$GOPATH/src/definition-json/main.go:36:6",
+	"desc": "func f"
+}
+-------- @definition lexical-var --------
+{
+	"objpos": "$GOPATH/src/definition-json/main.go:18:6",
+	"desc": "var x"
+}
+-------- @definition lexical-shadowing --------
+{
+	"objpos": "$GOPATH/src/definition-json/main.go:21:5",
+	"desc": "var x"
+}
+-------- @definition qualified-type --------
+{
+	"objpos": "testdata/src/lib/lib.go:3:6",
+	"desc": "type lib.Type"
+}
+-------- @definition qualified-func --------
+{
+	"objpos": "testdata/src/lib/lib.go:9:6",
+	"desc": "func lib.Func"
+}
+-------- @definition qualified-var --------
+{
+	"objpos": "testdata/src/lib/lib.go:14:5",
+	"desc": "var lib.Var"
+}
+-------- @definition qualified-const --------
+{
+	"objpos": "testdata/src/lib/lib.go:12:7",
+	"desc": "const lib.Const"
+}
+-------- @definition qualified-type-renaming --------
+{
+	"objpos": "testdata/src/lib/lib.go:3:6",
+	"desc": "type lib.Type"
+}
+-------- @definition qualified-nomember --------
+
+Error: couldn't find declaration of Nonesuch in "lib"
+-------- @definition select-field --------
+{
+	"objpos": "testdata/src/definition-json/main.go:38:16",
+	"desc": "field field int"
+}
+-------- @definition select-method --------
+{
+	"objpos": "testdata/src/definition-json/main.go:40:10",
+	"desc": "func (T).method()"
+}
+-------- @definition embedded-other-file --------
+{
+	"objpos": "testdata/src/definition-json/type.go:3:6",
+	"desc": "type W int"
+}
+-------- @definition embedded-other-file-pointer --------
+{
+	"objpos": "testdata/src/definition-json/type.go:3:6",
+	"desc": "type W int"
+}
+-------- @definition embedded-basic --------
+
+Error: int is built in
+-------- @definition embedded-basic-pointer --------
+
+Error: int is built in
+-------- @definition embedded-other-pkg --------
+{
+	"objpos": "testdata/src/lib/lib.go:3:6",
+	"desc": "type lib.Type"
+}
+-------- @definition embedded-same-file --------
+{
+	"objpos": "$GOPATH/src/definition-json/main.go:38:6",
+	"desc": "type T"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.go
new file mode 100644
index 0000000..9f047c3
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.go
@@ -0,0 +1,5 @@
+package definition
+
+import "nosuchpkg"
+
+var _ nosuchpkg.T // @definition qualified-nopkg "nosuchpkg"
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.golden
new file mode 100644
index 0000000..3281aa5
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/main19.golden
@@ -0,0 +1,5 @@
+-------- @definition qualified-nopkg --------
+{
+	"objpos": "testdata/src/definition-json/main19.go:3:8",
+	"desc": "package nosuchpkg"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/type.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/type.go
new file mode 100644
index 0000000..a574bf3
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/definition-json/type.go
@@ -0,0 +1,3 @@
+package definition
+
+type W int
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.go
new file mode 100644
index 0000000..549dd8a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.go
@@ -0,0 +1,29 @@
+package describe // @describe pkgdecl "describe"
+
+// Tests of 'describe' query, -format=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See describe-json.golden for expected query results.
+
+func main() {
+	var s struct{ x [3]int }
+	p := &s.x[0] // @describe desc-val-p "p"
+	_ = p
+
+	var i I = C(0)
+	if i == nil {
+		i = new(D)
+	}
+	print(i) // @describe desc-val-i "\\bi\\b"
+
+	go main() // @describe desc-stmt "go"
+}
+
+type I interface {
+	f()
+}
+
+type C int // @describe desc-type-C "C"
+type D struct{}
+
+func (c C) f()  {}
+func (d *D) f() {}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.golden
new file mode 100644
index 0000000..5806e0c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe-json/main.golden
@@ -0,0 +1,96 @@
+-------- @describe pkgdecl --------
+{
+	"desc": "definition of package \"describe-json\"",
+	"pos": "testdata/src/describe-json/main.go:1:9",
+	"detail": "package",
+	"package": {
+		"path": "describe-json",
+		"members": [
+			{
+				"name": "C",
+				"type": "int",
+				"pos": "testdata/src/describe-json/main.go:25:6",
+				"kind": "type",
+				"methods": [
+					{
+						"name": "method (C) f()",
+						"pos": "testdata/src/describe-json/main.go:28:12"
+					}
+				]
+			},
+			{
+				"name": "D",
+				"type": "struct{}",
+				"pos": "testdata/src/describe-json/main.go:26:6",
+				"kind": "type",
+				"methods": [
+					{
+						"name": "method (*D) f()",
+						"pos": "testdata/src/describe-json/main.go:29:13"
+					}
+				]
+			},
+			{
+				"name": "I",
+				"type": "interface{f()}",
+				"pos": "testdata/src/describe-json/main.go:21:6",
+				"kind": "type",
+				"methods": [
+					{
+						"name": "method (I) f()",
+						"pos": "testdata/src/describe-json/main.go:22:2"
+					}
+				]
+			},
+			{
+				"name": "main",
+				"type": "func()",
+				"pos": "testdata/src/describe-json/main.go:7:6",
+				"kind": "func"
+			}
+		]
+	}
+}
+-------- @describe desc-val-p --------
+{
+	"desc": "identifier",
+	"pos": "testdata/src/describe-json/main.go:9:2",
+	"detail": "value",
+	"value": {
+		"type": "*int",
+		"objpos": "testdata/src/describe-json/main.go:9:2"
+	}
+}
+-------- @describe desc-val-i --------
+{
+	"desc": "identifier",
+	"pos": "testdata/src/describe-json/main.go:16:8",
+	"detail": "value",
+	"value": {
+		"type": "I",
+		"objpos": "testdata/src/describe-json/main.go:12:6"
+	}
+}
+-------- @describe desc-stmt --------
+{
+	"desc": "go statement",
+	"pos": "testdata/src/describe-json/main.go:18:2",
+	"detail": "unknown"
+}
+-------- @describe desc-type-C --------
+{
+	"desc": "definition of type C (size 8, align 8)",
+	"pos": "testdata/src/describe-json/main.go:25:6",
+	"detail": "type",
+	"type": {
+		"type": "C",
+		"namepos": "testdata/src/describe-json/main.go:25:6",
+		"namedef": "int",
+		"methods": [
+			{
+				"name": "method (C) f()",
+				"pos": "testdata/src/describe-json/main.go:28:12"
+			}
+		]
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.go
new file mode 100644
index 0000000..c6c5349
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.go
@@ -0,0 +1,102 @@
+package describe // @describe pkgdecl "describe"
+
+// Tests of 'describe' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See describe.golden for expected query results.
+
+// TODO(adonovan): more coverage of the (extensive) logic.
+
+import (
+	"lib"
+	_ "unsafe" // @describe unsafe "unsafe"
+)
+
+type cake float64 // @describe type-ref-builtin "float64"
+
+const c = iota // @describe const-ref-iota "iota"
+
+const pi = 3.141     // @describe const-def-pi "pi"
+const pie = cake(pi) // @describe const-def-pie "pie"
+const _ = pi         // @describe const-ref-pi "pi"
+
+var global = new(string) // NB: ssa.Global is indirect, i.e. **string
+
+func main() { // @describe func-def-main "main"
+	// func objects
+	_ = main   // @describe func-ref-main "main"
+	_ = (*C).f // @describe func-ref-*C.f "..C..f"
+	_ = D.f    // @describe func-ref-D.f "D.f"
+	_ = I.f    // @describe func-ref-I.f "I.f"
+	var d D    // @describe type-D "D"
+	var i I    // @describe type-I "I"
+	_ = d.f    // @describe func-ref-d.f "d.f"
+	_ = i.f    // @describe func-ref-i.f "i.f"
+
+	var dptr *D // @describe ptr-with-nonptr-methods "dptr"
+	_ = dptr
+
+	// var objects
+	anon := func() {
+		_ = d // @describe ref-lexical-d "d"
+	}
+	_ = anon   // @describe ref-anon "anon"
+	_ = global // @describe ref-global "global"
+
+	// SSA affords some local flow sensitivity.
+	var a, b int
+	var x = &a // @describe var-def-x-1 "x"
+	_ = x      // @describe var-ref-x-1 "x"
+	x = &b     // @describe var-def-x-2 "x"
+	_ = x      // @describe var-ref-x-2 "x"
+
+	i = new(C) // @describe var-ref-i-C "i"
+	if i != nil {
+		i = D{} // @describe var-ref-i-D "i"
+	}
+	print(i) // @describe var-ref-i "\\bi\\b"
+
+	// const objects
+	const localpi = 3.141     // @describe const-local-pi "localpi"
+	const localpie = cake(pi) // @describe const-local-pie "localpie"
+	const _ = localpi         // @describe const-ref-localpi "localpi"
+
+	// type objects
+	type T int      // @describe type-def-T "T"
+	var three T = 3 // @describe type-ref-T "T"
+	_ = three
+
+	print(1 + 2*3)        // @describe const-expr " 2.3"
+	print(real(1+2i) - 3) // @describe const-expr2 "real.*3"
+
+	m := map[string]*int{"a": &a}
+	mapval, _ := m["a"] // @describe map-lookup,ok "m..a.."
+	_ = mapval          // @describe mapval "mapval"
+	_ = m               // @describe m "m"
+
+	defer main() // @describe defer-stmt "defer"
+	go main()    // @describe go-stmt "go"
+
+	panic(3) // @describe builtin-ref-panic "panic"
+
+	var a2 int // @describe var-decl-stmt "var a2 int"
+	_ = a2
+	var _ int // @describe var-decl-stmt2 "var _ int"
+	var _ int // @describe var-def-blank "_"
+
+	var _ lib.Outer // @describe lib-outer "Outer"
+
+	unknown() // @describe call-unknown "\\("
+}
+
+type I interface { // @describe def-iface-I "I"
+	f() // @describe def-imethod-I.f "f"
+}
+
+type C int
+type D struct {
+	Field        int
+	AnotherField string
+}
+
+func (c *C) f() {}
+func (d D) f()  {}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.golden
new file mode 100644
index 0000000..724643d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main.golden
@@ -0,0 +1,212 @@
+-------- @describe pkgdecl --------
+definition of package "describe"
+	type  C      int
+		method (*C) f()
+	type  D      struct{...}
+		method (D) f()
+	type  I      interface{f()}
+		method (I) f()
+	const c      untyped int = 0
+	type  cake   float64
+	var   global *string
+	func  main   func()
+	const pi     untyped float = 3.141
+	const pie    cake = 3.141
+
+-------- @describe unsafe --------
+import of package "unsafe"
+	builtin Alignof 
+	builtin Offsetof
+	type  Pointer  unsafe.Pointer
+	builtin Sizeof  
+
+-------- @describe type-ref-builtin --------
+reference to built-in type float64
+
+-------- @describe const-ref-iota --------
+reference to const iota untyped int of value 0
+
+-------- @describe const-def-pi --------
+definition of const pi untyped float of value 3.141
+
+-------- @describe const-def-pie --------
+definition of const pie cake of value 3.141
+
+-------- @describe const-ref-pi --------
+reference to const pi untyped float of value 3.141
+defined here
+
+-------- @describe func-def-main --------
+definition of func main()
+
+-------- @describe func-ref-main --------
+reference to func main()
+defined here
+
+-------- @describe func-ref-*C.f --------
+reference to method func (*C).f()
+defined here
+
+-------- @describe func-ref-D.f --------
+reference to method func (D).f()
+defined here
+
+-------- @describe func-ref-I.f --------
+reference to interface method func (I).f()
+defined here
+
+-------- @describe type-D --------
+reference to type D (size 24, align 8)
+defined as struct{Field int; AnotherField string}
+Methods:
+	method (D) f()
+Fields:
+	Field        int
+	AnotherField string
+
+-------- @describe type-I --------
+reference to type I (size 16, align 8)
+defined as interface{f()}
+Methods:
+	method (I) f()
+
+-------- @describe func-ref-d.f --------
+reference to method func (D).f()
+defined here
+
+-------- @describe func-ref-i.f --------
+reference to interface method func (I).f()
+defined here
+
+-------- @describe ptr-with-nonptr-methods --------
+definition of var dptr *D
+Methods:
+	method (*D) f()
+Fields:
+	Field        int
+	AnotherField string
+
+-------- @describe ref-lexical-d --------
+reference to var d D
+defined here
+Methods:
+	method (D) f()
+Fields:
+	Field        int
+	AnotherField string
+
+-------- @describe ref-anon --------
+reference to var anon func()
+defined here
+
+-------- @describe ref-global --------
+reference to var global *string
+defined here
+
+-------- @describe var-def-x-1 --------
+definition of var x *int
+
+-------- @describe var-ref-x-1 --------
+reference to var x *int
+defined here
+
+-------- @describe var-def-x-2 --------
+reference to var x *int
+defined here
+
+-------- @describe var-ref-x-2 --------
+reference to var x *int
+defined here
+
+-------- @describe var-ref-i-C --------
+reference to var i I
+defined here
+Methods:
+	method (I) f()
+
+-------- @describe var-ref-i-D --------
+reference to var i I
+defined here
+Methods:
+	method (I) f()
+
+-------- @describe var-ref-i --------
+reference to var i I
+defined here
+Methods:
+	method (I) f()
+
+-------- @describe const-local-pi --------
+definition of const localpi untyped float of value 3.141
+
+-------- @describe const-local-pie --------
+definition of const localpie cake of value 3.141
+
+-------- @describe const-ref-localpi --------
+reference to const localpi untyped float of value 3.141
+defined here
+
+-------- @describe type-def-T --------
+definition of type T (size 8, align 8)
+No methods.
+
+-------- @describe type-ref-T --------
+reference to type T (size 8, align 8)
+defined as int
+No methods.
+
+-------- @describe const-expr --------
+binary * operation of value 6
+
+-------- @describe const-expr2 --------
+binary - operation of value -2
+
+-------- @describe map-lookup,ok --------
+index expression of type (*int, bool)
+
+-------- @describe mapval --------
+reference to var mapval *int
+defined here
+
+-------- @describe m --------
+reference to var m map[string]*int
+defined here
+
+-------- @describe defer-stmt --------
+defer statement
+
+-------- @describe go-stmt --------
+go statement
+
+-------- @describe builtin-ref-panic --------
+function call (or conversion) of type ()
+
+-------- @describe var-decl-stmt --------
+definition of var a2 int
+
+-------- @describe var-decl-stmt2 --------
+definition of var _ int
+
+-------- @describe var-def-blank --------
+definition of var _ int
+
+-------- @describe lib-outer --------
+reference to type lib.Outer (size 56, align 8)
+defined as struct{A int; b int; lib.inner}
+No methods.
+Fields:
+	A                 int
+	inner.C           bool
+	inner.recursive.E bool
+
+-------- @describe call-unknown --------
+function call of type invalid type
+
+-------- @describe def-iface-I --------
+definition of type I (size 16, align 8)
+Methods:
+	method (I) f()
+
+-------- @describe def-imethod-I.f --------
+definition of interface method func (I).f()
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.go
new file mode 100644
index 0000000..2068f8c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.go
@@ -0,0 +1,13 @@
+package describe
+
+// The behavior of "describe" on a non-existent import changed
+// when go/types started returning fake packages, so this test
+// is executed only under go1.9.
+
+import (
+	"nosuchpkg"            // @describe badimport1 "nosuchpkg"
+	nosuchpkg2 "nosuchpkg" // @describe badimport2 "nosuchpkg2"
+)
+
+var _ nosuchpkg.T
+var _ nosuchpkg2.T
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.golden
new file mode 100644
index 0000000..005e30b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/describe/main19.golden
@@ -0,0 +1,6 @@
+-------- @describe badimport1 --------
+import of package "nosuchpkg"
+
+-------- @describe badimport2 --------
+reference to package "nosuchpkg"
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.go
new file mode 100644
index 0000000..c6aa08d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.go
@@ -0,0 +1,40 @@
+package main
+
+// Tests of 'freevars' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See freevars.golden for expected query results.
+
+// TODO(adonovan): it's hard to test this query in a single line of gofmt'd code.
+
+type T struct {
+	a, b int
+}
+
+type S struct {
+	x int
+	t T
+}
+
+func f(int) {}
+
+func main() {
+	type C int
+	x := 1
+	const exp = 6
+	if y := 2; x+y+int(C(3)) != exp { // @freevars fv1 "if.*{"
+		panic("expected 6")
+	}
+
+	var s S
+
+	for x, y := range "foo" {
+		println(s.x + s.t.a + s.t.b + x + int(y)) // @freevars fv2 "print.*y."
+	}
+
+	f(x) // @freevars fv3 "f.x."
+
+loop: // @freevars fv-def-label "loop:"
+	for {
+		break loop // @freevars fv-ref-label "break loop"
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.golden
new file mode 100644
index 0000000..a3bc0c9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/freevars/main.golden
@@ -0,0 +1,25 @@
+-------- @freevars fv1 --------
+Free identifiers:
+type C
+const exp int
+var x int
+
+-------- @freevars fv2 --------
+Free identifiers:
+var s.t.a int
+var s.t.b int
+var s.x int
+var x int
+var y rune
+
+-------- @freevars fv3 --------
+Free identifiers:
+var x int
+
+-------- @freevars fv-def-label --------
+No free identifiers.
+
+-------- @freevars fv-ref-label --------
+Free identifiers:
+label loop
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.go
new file mode 100644
index 0000000..e18a373
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.go
@@ -0,0 +1,27 @@
+package main
+
+// Tests of 'implements' query, -output=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See implements.golden for expected query results.
+
+func main() {
+}
+
+type E interface{} // @implements E "E"
+
+type F interface { // @implements F "F"
+	f()
+}
+
+type FG interface { // @implements FG "FG"
+	f()
+	g() []int // @implements slice "..int"
+}
+
+type C int // @implements C "C"
+type D struct{}
+
+func (c *C) f() {} // @implements starC ".C"
+func (d D) f()  {} // @implements D "D"
+
+func (d *D) g() []int { return nil } // @implements starD ".D"
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.golden
new file mode 100644
index 0000000..ce18c1c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-json/main.golden
@@ -0,0 +1,135 @@
+-------- @implements E --------
+{
+	"type": {
+		"name": "implements-json.E",
+		"pos": "testdata/src/implements-json/main.go:10:6",
+		"kind": "interface"
+	}
+}
+-------- @implements F --------
+{
+	"type": {
+		"name": "implements-json.F",
+		"pos": "testdata/src/implements-json/main.go:12:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "*implements-json.C",
+			"pos": "testdata/src/implements-json/main.go:21:6",
+			"kind": "pointer"
+		},
+		{
+			"name": "implements-json.D",
+			"pos": "testdata/src/implements-json/main.go:22:6",
+			"kind": "struct"
+		},
+		{
+			"name": "implements-json.FG",
+			"pos": "testdata/src/implements-json/main.go:16:6",
+			"kind": "interface"
+		}
+	]
+}
+-------- @implements FG --------
+{
+	"type": {
+		"name": "implements-json.FG",
+		"pos": "testdata/src/implements-json/main.go:16:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "*implements-json.D",
+			"pos": "testdata/src/implements-json/main.go:22:6",
+			"kind": "pointer"
+		}
+	],
+	"from": [
+		{
+			"name": "implements-json.F",
+			"pos": "testdata/src/implements-json/main.go:12:6",
+			"kind": "interface"
+		}
+	]
+}
+-------- @implements slice --------
+{
+	"type": {
+		"name": "[]int",
+		"pos": "-",
+		"kind": "slice"
+	}
+}
+-------- @implements C --------
+{
+	"type": {
+		"name": "implements-json.C",
+		"pos": "testdata/src/implements-json/main.go:21:6",
+		"kind": "basic"
+	},
+	"fromptr": [
+		{
+			"name": "implements-json.F",
+			"pos": "testdata/src/implements-json/main.go:12:6",
+			"kind": "interface"
+		}
+	]
+}
+-------- @implements starC --------
+{
+	"type": {
+		"name": "*implements-json.C",
+		"pos": "testdata/src/implements-json/main.go:21:6",
+		"kind": "pointer"
+	},
+	"from": [
+		{
+			"name": "implements-json.F",
+			"pos": "testdata/src/implements-json/main.go:12:6",
+			"kind": "interface"
+		}
+	]
+}
+-------- @implements D --------
+{
+	"type": {
+		"name": "implements-json.D",
+		"pos": "testdata/src/implements-json/main.go:22:6",
+		"kind": "struct"
+	},
+	"from": [
+		{
+			"name": "implements-json.F",
+			"pos": "testdata/src/implements-json/main.go:12:6",
+			"kind": "interface"
+		}
+	],
+	"fromptr": [
+		{
+			"name": "implements-json.FG",
+			"pos": "testdata/src/implements-json/main.go:16:6",
+			"kind": "interface"
+		}
+	]
+}
+-------- @implements starD --------
+{
+	"type": {
+		"name": "*implements-json.D",
+		"pos": "testdata/src/implements-json/main.go:22:6",
+		"kind": "pointer"
+	},
+	"from": [
+		{
+			"name": "implements-json.F",
+			"pos": "testdata/src/implements-json/main.go:12:6",
+			"kind": "interface"
+		},
+		{
+			"name": "implements-json.FG",
+			"pos": "testdata/src/implements-json/main.go:16:6",
+			"kind": "interface"
+		}
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.go
new file mode 100644
index 0000000..646276d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.go
@@ -0,0 +1,37 @@
+package main
+
+// Tests of 'implements' query applied to methods, -output=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See implements-methods.golden for expected query results.
+
+import _ "lib"
+
+func main() {
+}
+
+type F interface {
+	f() // @implements F.f "f"
+}
+
+type FG interface {
+	f()       // @implements FG.f "f"
+	g() []int // @implements FG.g "g"
+}
+
+type C int
+type D struct{}
+
+func (c *C) f() {} // @implements *C.f "f"
+func (d D) f()  {} // @implements D.f "f"
+
+func (d *D) g() []int { return nil } // @implements *D.g "g"
+
+type sorter []int
+
+func (sorter) Len() int           { return 0 } // @implements Len "Len"
+func (sorter) Less(i, j int) bool { return false }
+func (sorter) Swap(i, j int)      {}
+
+type I interface {
+	Method(*int) *int // @implements I.Method "Method"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.golden
new file mode 100644
index 0000000..137261b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods-json/main.golden
@@ -0,0 +1,266 @@
+-------- @implements F.f --------
+{
+	"type": {
+		"name": "implements-methods-json.F",
+		"pos": "testdata/src/implements-methods-json/main.go:12:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "*implements-methods-json.C",
+			"pos": "testdata/src/implements-methods-json/main.go:21:6",
+			"kind": "pointer"
+		},
+		{
+			"name": "implements-methods-json.D",
+			"pos": "testdata/src/implements-methods-json/main.go:22:6",
+			"kind": "struct"
+		},
+		{
+			"name": "implements-methods-json.FG",
+			"pos": "testdata/src/implements-methods-json/main.go:16:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (F).f()",
+		"pos": "testdata/src/implements-methods-json/main.go:13:2"
+	},
+	"to_method": [
+		{
+			"name": "method (*C) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:24:13"
+		},
+		{
+			"name": "method (D) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:25:12"
+		},
+		{
+			"name": "method (FG) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:17:2"
+		}
+	]
+}
+-------- @implements FG.f --------
+{
+	"type": {
+		"name": "implements-methods-json.FG",
+		"pos": "testdata/src/implements-methods-json/main.go:16:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "*implements-methods-json.D",
+			"pos": "testdata/src/implements-methods-json/main.go:22:6",
+			"kind": "pointer"
+		}
+	],
+	"from": [
+		{
+			"name": "implements-methods-json.F",
+			"pos": "testdata/src/implements-methods-json/main.go:12:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (FG).f()",
+		"pos": "testdata/src/implements-methods-json/main.go:17:2"
+	},
+	"to_method": [
+		{
+			"name": "method (*D) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:25:12"
+		}
+	],
+	"from_method": [
+		{
+			"name": "method (F) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:13:2"
+		}
+	]
+}
+-------- @implements FG.g --------
+{
+	"type": {
+		"name": "implements-methods-json.FG",
+		"pos": "testdata/src/implements-methods-json/main.go:16:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "*implements-methods-json.D",
+			"pos": "testdata/src/implements-methods-json/main.go:22:6",
+			"kind": "pointer"
+		}
+	],
+	"from": [
+		{
+			"name": "implements-methods-json.F",
+			"pos": "testdata/src/implements-methods-json/main.go:12:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (FG).g() []int",
+		"pos": "testdata/src/implements-methods-json/main.go:18:2"
+	},
+	"to_method": [
+		{
+			"name": "method (*D) g() []int",
+			"pos": "testdata/src/implements-methods-json/main.go:27:13"
+		}
+	],
+	"from_method": [
+		{
+			"name": "",
+			"pos": ""
+		}
+	]
+}
+-------- @implements *C.f --------
+{
+	"type": {
+		"name": "*implements-methods-json.C",
+		"pos": "testdata/src/implements-methods-json/main.go:21:6",
+		"kind": "pointer"
+	},
+	"from": [
+		{
+			"name": "implements-methods-json.F",
+			"pos": "testdata/src/implements-methods-json/main.go:12:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (*C).f()",
+		"pos": "testdata/src/implements-methods-json/main.go:24:13"
+	},
+	"from_method": [
+		{
+			"name": "method (F) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:13:2"
+		}
+	]
+}
+-------- @implements D.f --------
+{
+	"type": {
+		"name": "implements-methods-json.D",
+		"pos": "testdata/src/implements-methods-json/main.go:22:6",
+		"kind": "struct"
+	},
+	"from": [
+		{
+			"name": "implements-methods-json.F",
+			"pos": "testdata/src/implements-methods-json/main.go:12:6",
+			"kind": "interface"
+		}
+	],
+	"fromptr": [
+		{
+			"name": "implements-methods-json.FG",
+			"pos": "testdata/src/implements-methods-json/main.go:16:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (D).f()",
+		"pos": "testdata/src/implements-methods-json/main.go:25:12"
+	},
+	"from_method": [
+		{
+			"name": "method (F) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:13:2"
+		}
+	],
+	"fromptr_method": [
+		{
+			"name": "method (FG) f()",
+			"pos": "testdata/src/implements-methods-json/main.go:17:2"
+		}
+	]
+}
+-------- @implements *D.g --------
+{
+	"type": {
+		"name": "*implements-methods-json.D",
+		"pos": "testdata/src/implements-methods-json/main.go:22:6",
+		"kind": "pointer"
+	},
+	"from": [
+		{
+			"name": "implements-methods-json.F",
+			"pos": "testdata/src/implements-methods-json/main.go:12:6",
+			"kind": "interface"
+		},
+		{
+			"name": "implements-methods-json.FG",
+			"pos": "testdata/src/implements-methods-json/main.go:16:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (*D).g() []int",
+		"pos": "testdata/src/implements-methods-json/main.go:27:13"
+	},
+	"from_method": [
+		{
+			"name": "",
+			"pos": ""
+		},
+		{
+			"name": "method (FG) g() []int",
+			"pos": "testdata/src/implements-methods-json/main.go:18:2"
+		}
+	]
+}
+-------- @implements Len --------
+{
+	"type": {
+		"name": "implements-methods-json.sorter",
+		"pos": "testdata/src/implements-methods-json/main.go:29:6",
+		"kind": "slice"
+	},
+	"from": [
+		{
+			"name": "lib.Sorter",
+			"pos": "testdata/src/lib/lib.go:16:6",
+			"kind": "interface"
+		}
+	],
+	"method": {
+		"name": "func (sorter).Len() int",
+		"pos": "testdata/src/implements-methods-json/main.go:31:15"
+	},
+	"from_method": [
+		{
+			"name": "method (lib.Sorter) Len() int",
+			"pos": "testdata/src/lib/lib.go:17:2"
+		}
+	]
+}
+-------- @implements I.Method --------
+{
+	"type": {
+		"name": "implements-methods-json.I",
+		"pos": "testdata/src/implements-methods-json/main.go:35:6",
+		"kind": "interface"
+	},
+	"to": [
+		{
+			"name": "lib.Type",
+			"pos": "testdata/src/lib/lib.go:3:6",
+			"kind": "basic"
+		}
+	],
+	"method": {
+		"name": "func (I).Method(*int) *int",
+		"pos": "testdata/src/implements-methods-json/main.go:36:2"
+	},
+	"to_method": [
+		{
+			"name": "method (lib.Type) Method(x *int) *int",
+			"pos": "testdata/src/lib/lib.go:5:13"
+		}
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.go
new file mode 100644
index 0000000..757be44
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.go
@@ -0,0 +1,37 @@
+package main
+
+// Tests of 'implements' query applied to methods.
+// See go.tools/guru/guru_test.go for explanation.
+// See implements-methods.golden for expected query results.
+
+import _ "lib"
+
+func main() {
+}
+
+type F interface {
+	f() // @implements F.f "f"
+}
+
+type FG interface {
+	f()       // @implements FG.f "f"
+	g() []int // @implements FG.g "g"
+}
+
+type C int
+type D struct{}
+
+func (c *C) f() {} // @implements *C.f "f"
+func (d D) f()  {} // @implements D.f "f"
+
+func (d *D) g() []int { return nil } // @implements *D.g "g"
+
+type sorter []int
+
+func (sorter) Len() int           { return 0 } // @implements Len "Len"
+func (sorter) Less(i, j int) bool { return false }
+func (sorter) Swap(i, j int)      {}
+
+type I interface {
+	Method(*int) *int // @implements I.Method "Method"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.golden
new file mode 100644
index 0000000..bd591e8
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements-methods/main.golden
@@ -0,0 +1,37 @@
+-------- @implements F.f --------
+abstract method func (F).f()
+	is implemented by method (*C).f
+	is implemented by method (D).f
+	is implemented by method (FG).f
+
+-------- @implements FG.f --------
+abstract method func (FG).f()
+	is implemented by method (*D).f
+	implements method (F).f
+
+-------- @implements FG.g --------
+abstract method func (FG).g() []int
+	is implemented by method (*D).g
+
+-------- @implements *C.f --------
+concrete method func (*C).f()
+	implements method (F).f
+
+-------- @implements D.f --------
+concrete method func (D).f()
+	implements method (F).f
+concrete method func (D).f()
+	implements method (FG).f
+
+-------- @implements *D.g --------
+concrete method func (*D).g() []int
+	implements method (FG).g
+
+-------- @implements Len --------
+concrete method func (sorter).Len() int
+	implements method (lib.Sorter).Len
+
+-------- @implements I.Method --------
+abstract method func (I).Method(*int) *int
+	is implemented by method (lib.Type).Method
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.go
new file mode 100644
index 0000000..fea9006
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.go
@@ -0,0 +1,44 @@
+package main
+
+// Tests of 'implements' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See implements.golden for expected query results.
+
+import _ "lib"
+
+func main() {
+}
+
+type E interface{} // @implements E "E"
+
+type F interface { // @implements F "F"
+	f()
+}
+
+type FG interface { // @implements FG "FG"
+	f()
+	g() []int // @implements slice "..int"
+}
+
+type C int // @implements C "C"
+type D struct{}
+
+func (c *C) f() {} // @implements starC ".C"
+func (d D) f()  {} // @implements D "D"
+
+func (d *D) g() []int { return nil } // @implements starD ".D"
+
+type sorter []int // @implements sorter "sorter"
+
+func (sorter) Len() int           { return 0 }
+func (sorter) Less(i, j int) bool { return false }
+func (sorter) Swap(i, j int)      {}
+
+type I interface { // @implements I "I"
+	Method(*int) *int
+}
+
+func _() {
+	var d D
+	_ = d // @implements var_d "d"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.golden
new file mode 100644
index 0000000..1077c98
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/implements/main.golden
@@ -0,0 +1,50 @@
+-------- @implements E --------
+empty interface type E
+
+-------- @implements F --------
+interface type F
+	is implemented by pointer type *C
+	is implemented by struct type D
+	is implemented by interface type FG
+
+-------- @implements FG --------
+interface type FG
+	is implemented by pointer type *D
+	implements F
+
+-------- @implements slice --------
+slice type []int implements only interface{}
+
+-------- @implements C --------
+pointer type *C
+	implements F
+
+-------- @implements starC --------
+pointer type *C
+	implements F
+
+-------- @implements D --------
+struct type D
+	implements F
+pointer type *D
+	implements FG
+
+-------- @implements starD --------
+pointer type *D
+	implements F
+	implements FG
+
+-------- @implements sorter --------
+slice type sorter
+	implements lib.Sorter
+
+-------- @implements I --------
+interface type I
+	is implemented by basic type lib.Type
+
+-------- @implements var_d --------
+struct type D
+	implements F
+pointer type *D
+	implements FG
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.go
new file mode 100644
index 0000000..9fe2b71
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"lib"        // @describe ref-pkg-import "lib"
+	"lib/sublib" // @describe ref-pkg-import2 "sublib"
+)
+
+// Tests that import another package.  (To make the tests run quickly,
+// we avoid using imports in all the other tests.  Remember, each
+// query causes parsing and typechecking of the whole program.)
+//
+// See go.tools/guru/guru_test.go for explanation.
+// See imports.golden for expected query results.
+
+var a int
+
+func main() {
+	const c = lib.Const // @describe ref-const "Const"
+	lib.Func()          // @describe ref-func "Func"
+	lib.Var++           // @describe ref-var "Var"
+	var t lib.Type      // @describe ref-type "Type"
+	p := t.Method(&a)   // @describe ref-method "Method"
+
+	print(*p + 1) // @pointsto p "p "
+
+	var _ lib.Type // @describe ref-pkg "lib"
+
+	_ = sublib.C
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.golden
new file mode 100644
index 0000000..1e12217
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/imports/main.golden
@@ -0,0 +1,56 @@
+-------- @describe ref-pkg-import --------
+import of package "lib"
+	const Const  untyped int = 3
+	func  Func   func()
+	type  Outer  struct{...}
+	type  Sorter interface{...}
+		method (Sorter) Len() int
+		method (Sorter) Less(i int, j int) bool
+		method (Sorter) Swap(i int, j int)
+	type  Type   int
+		method (Type) Method(x *int) *int
+	var   Var    int
+
+-------- @describe ref-pkg-import2 --------
+import of package "lib/sublib"
+	const C untyped int = 0
+
+-------- @describe ref-const --------
+reference to const lib.Const untyped int of value 3
+defined here
+
+-------- @describe ref-func --------
+reference to func lib.Func()
+defined here
+
+-------- @describe ref-var --------
+reference to var lib.Var int
+defined here
+
+-------- @describe ref-type --------
+reference to type lib.Type (size 8, align 8)
+defined as int
+Methods:
+	method (Type) Method(x *int) *int
+
+-------- @describe ref-method --------
+reference to method func (lib.Type).Method(x *int) *int
+defined here
+
+-------- @pointsto p --------
+this *int may point to these objects:
+	imports.a
+
+-------- @describe ref-pkg --------
+reference to package "lib"
+	const Const  untyped int = 3
+	func  Func   func()
+	type  Outer  struct{...}
+	type  Sorter interface{...}
+		method (Sorter) Len() int
+		method (Sorter) Less(i int, j int) bool
+		method (Sorter) Swap(i int, j int)
+	type  Type   int
+		method (Type) Method(x *int) *int
+	var   Var    int
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/lib.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/lib.go
new file mode 100644
index 0000000..742cdbf
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/lib.go
@@ -0,0 +1,37 @@
+package lib
+
+type Type int
+
+func (Type) Method(x *int) *int {
+	return x
+}
+
+func Func() {
+}
+
+const Const = 3
+
+var Var = 0
+
+type Sorter interface {
+	Len() int
+	Less(i, j int) bool
+	Swap(i, j int)
+}
+
+type Outer struct {
+	A int
+	b int
+	inner
+}
+
+type inner struct {
+	C bool
+	d string
+	recursive
+}
+
+type recursive struct {
+	E bool
+	*inner
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/sublib/sublib.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/sublib/sublib.go
new file mode 100644
index 0000000..33c6498
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/lib/sublib/sublib.go
@@ -0,0 +1,3 @@
+package sublib
+
+const C = 0
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/main/multi.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/main/multi.go
new file mode 100644
index 0000000..8c650cd
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/main/multi.go
@@ -0,0 +1,13 @@
+package main
+
+func g(x int) {
+}
+
+func f() {
+	x := 1
+	g(x) // "g(x)" is the selection for multiple queries
+}
+
+func main() {
+	f()
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.go
new file mode 100644
index 0000000..ef63992
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.go
@@ -0,0 +1,13 @@
+package main
+
+// Tests of channel 'peers' query, -format=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See peers-json.golden for expected query results.
+
+func main() {
+	chA := make(chan *int)
+	<-chA
+	select {
+	case <-chA: // @peers peer-recv-chA "<-"
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.golden
new file mode 100644
index 0000000..50d5716
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers-json/main.golden
@@ -0,0 +1,12 @@
+-------- @peers peer-recv-chA --------
+{
+	"pos": "testdata/src/peers-json/main.go:11:7",
+	"type": "chan *int",
+	"allocs": [
+		"testdata/src/peers-json/main.go:8:13"
+	],
+	"receives": [
+		"testdata/src/peers-json/main.go:9:2",
+		"testdata/src/peers-json/main.go:11:7"
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.go
new file mode 100644
index 0000000..40ee205
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.go
@@ -0,0 +1,52 @@
+package main
+
+// Tests of channel 'peers' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See peers.golden for expected query results.
+
+var a2 int
+
+func main() {
+	chA := make(chan *int)
+	a1 := 1
+	chA <- &a1
+
+	chA2 := make(chan *int, 2)
+	if a2 == 0 {
+		chA = chA2
+	}
+
+	chB := make(chan *int)
+	b := 3
+	chB <- &b
+
+	<-chA  // @pointsto pointsto-chA "chA"
+	<-chA2 // @pointsto pointsto-chA2 "chA2"
+	<-chB  // @pointsto pointsto-chB "chB"
+
+	select {
+	case rA := <-chA: // @peers peer-recv-chA "<-"
+		_ = rA // @pointsto pointsto-rA "rA"
+	case rB := <-chB: // @peers peer-recv-chB "<-"
+		_ = rB // @pointsto pointsto-rB "rB"
+
+	case <-chA: // @peers peer-recv-chA' "<-"
+
+	case chA2 <- &a2: // @peers peer-send-chA' "<-"
+	}
+
+	for range chA {
+	}
+
+	close(chA) // @peers peer-close-chA "chA"
+
+	chC := make(chan *int)
+	(close)(chC) // @peers peer-close-chC "chC"
+
+	close := func(ch chan *int) chan *int {
+		return ch
+	}
+
+	close(chC) <- &b // @peers peer-send-chC "chC"
+	<-close(chC)     // @peers peer-recv-chC "chC"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.golden
new file mode 100644
index 0000000..f97e672
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/peers/main.golden
@@ -0,0 +1,100 @@
+-------- @pointsto pointsto-chA --------
+this chan *int may point to these objects:
+	makechan
+	makechan
+
+-------- @pointsto pointsto-chA2 --------
+this chan *int may point to these objects:
+	makechan
+
+-------- @pointsto pointsto-chB --------
+this chan *int may point to these objects:
+	makechan
+
+-------- @peers peer-recv-chA --------
+This channel of type chan *int may be:
+	allocated here
+	allocated here
+	sent to, here
+	sent to, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	closed, here
+
+-------- @pointsto pointsto-rA --------
+this *int may point to these objects:
+	peers.a2
+	a1
+
+-------- @peers peer-recv-chB --------
+This channel of type chan *int may be:
+	allocated here
+	sent to, here
+	received from, here
+	received from, here
+
+-------- @pointsto pointsto-rB --------
+this *int may point to these objects:
+	b
+
+-------- @peers peer-recv-chA' --------
+This channel of type chan *int may be:
+	allocated here
+	allocated here
+	sent to, here
+	sent to, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	closed, here
+
+-------- @peers peer-send-chA' --------
+This channel of type chan *int may be:
+	allocated here
+	sent to, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	closed, here
+
+-------- @peers peer-close-chA --------
+This channel of type chan *int may be:
+	allocated here
+	allocated here
+	sent to, here
+	sent to, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	received from, here
+	closed, here
+
+-------- @peers peer-close-chC --------
+This channel of type chan *int may be:
+	allocated here
+	sent to, here
+	received from, here
+	closed, here
+
+-------- @peers peer-send-chC --------
+This channel of type chan *int may be:
+	allocated here
+	sent to, here
+	received from, here
+	closed, here
+
+-------- @peers peer-recv-chC --------
+This channel of type chan *int may be:
+	allocated here
+	sent to, here
+	received from, here
+	closed, here
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.go
new file mode 100644
index 0000000..0a9f318
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.go
@@ -0,0 +1,27 @@
+package main
+
+// Tests of 'pointsto' queries, -format=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See pointsto-json.golden for expected query results.
+
+func main() { //
+	var s struct{ x [3]int }
+	p := &s.x[0] // @pointsto val-p "p"
+	_ = p
+
+	var i I = C(0)
+	if i == nil {
+		i = new(D)
+	}
+	print(i) // @pointsto val-i "\\bi\\b"
+}
+
+type I interface {
+	f()
+}
+
+type C int
+type D struct{}
+
+func (c C) f()  {}
+func (d *D) f() {}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.golden
new file mode 100644
index 0000000..06a2204
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto-json/main.golden
@@ -0,0 +1,29 @@
+-------- @pointsto val-p --------
+[
+	{
+		"type": "*int",
+		"labels": [
+			{
+				"pos": "testdata/src/pointsto-json/main.go:8:6",
+				"desc": "s.x[*]"
+			}
+		]
+	}
+]
+-------- @pointsto val-i --------
+[
+	{
+		"type": "*D",
+		"namepos": "testdata/src/pointsto-json/main.go:24:6",
+		"labels": [
+			{
+				"pos": "testdata/src/pointsto-json/main.go:14:10",
+				"desc": "new"
+			}
+		]
+	},
+	{
+		"type": "C",
+		"namepos": "testdata/src/pointsto-json/main.go:23:6"
+	}
+]
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.go
new file mode 100644
index 0000000..c4ba2e2
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.go
@@ -0,0 +1,75 @@
+package main
+
+// Tests of 'pointsto' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See pointsto.golden for expected query results.
+
+const pi = 3.141 // @pointsto const "pi"
+
+var global = new(string) // NB: ssa.Global is indirect, i.e. **string
+
+func main() {
+	livecode()
+
+	// func objects
+	_ = main   // @pointsto func-ref-main "main"
+	_ = (*C).f // @pointsto func-ref-*C.f "..C..f"
+	_ = D.f    // @pointsto func-ref-D.f "D.f"
+	_ = I.f    // @pointsto func-ref-I.f "I.f"
+	var d D
+	var i I
+	_ = d.f // @pointsto func-ref-d.f "d.f"
+	_ = i.f // @pointsto func-ref-i.f "i.f"
+
+	// var objects
+	anon := func() {
+		_ = d.f // @pointsto ref-lexical-d.f "d.f"
+	}
+	_ = anon   // @pointsto ref-anon "anon"
+	_ = global // @pointsto ref-global "global"
+
+	// SSA affords some local flow sensitivity.
+	var a, b int
+	var x = &a // @pointsto var-def-x-1 "x"
+	_ = x      // @pointsto var-ref-x-1 "x"
+	x = &b     // @pointsto var-def-x-2 "x"
+	_ = x      // @pointsto var-ref-x-2 "x"
+
+	i = new(C) // @pointsto var-ref-i-C "i"
+	if i != nil {
+		i = D{} // @pointsto var-ref-i-D "i"
+	}
+	print(i) // @pointsto var-ref-i "\\bi\\b"
+
+	m := map[string]*int{"a": &a}
+	mapval, _ := m["a"] // @pointsto map-lookup,ok "m..a.."
+	_ = mapval          // @pointsto mapval "mapval"
+	_ = m               // @pointsto m "m"
+
+	if false {
+		panic(3) // @pointsto builtin-panic "panic"
+	}
+
+	// NB: s.f is addressable per (*ssa.Program).VarValue,
+	// but our query concerns the object, not its address.
+	s := struct{ f interface{} }{f: make(chan bool)}
+	print(s.f) // @pointsto var-ref-s-f "s.f"
+}
+
+func livecode() {} // @pointsto func-live "livecode"
+
+func deadcode() { // @pointsto func-dead "deadcode"
+	// Pointer analysis can't run on dead code.
+	var b = new(int) // @pointsto b "b"
+	_ = b
+}
+
+type I interface {
+	f()
+}
+
+type C int
+type D struct{}
+
+func (c *C) f() {}
+func (d D) f()  {}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.golden
new file mode 100644
index 0000000..7b12b2a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/pointsto/main.golden
@@ -0,0 +1,96 @@
+-------- @pointsto const --------
+
+Error: pointer analysis wants an expression of reference type; got untyped float
+-------- @pointsto func-ref-main --------
+this func() may point to these objects:
+	pointsto.main
+
+-------- @pointsto func-ref-*C.f --------
+this func() may point to these objects:
+	(*pointsto.C).f
+
+-------- @pointsto func-ref-D.f --------
+this func() may point to these objects:
+	(pointsto.D).f
+
+-------- @pointsto func-ref-I.f --------
+
+Error: func (pointsto.I).f() is an interface method
+-------- @pointsto func-ref-d.f --------
+this func() may point to these objects:
+	(pointsto.D).f
+
+-------- @pointsto func-ref-i.f --------
+
+Error: func (pointsto.I).f() is an interface method
+-------- @pointsto ref-lexical-d.f --------
+this func() may point to these objects:
+	(pointsto.D).f
+
+-------- @pointsto ref-anon --------
+this func() may point to these objects:
+	pointsto.main$1
+
+-------- @pointsto ref-global --------
+this *string may point to these objects:
+	new
+
+-------- @pointsto var-def-x-1 --------
+this *int may point to these objects:
+	a
+
+-------- @pointsto var-ref-x-1 --------
+this *int may point to these objects:
+	a
+
+-------- @pointsto var-def-x-2 --------
+this *int may point to these objects:
+	b
+
+-------- @pointsto var-ref-x-2 --------
+this *int may point to these objects:
+	b
+
+-------- @pointsto var-ref-i-C --------
+this I may contain these dynamic types:
+	*C, may point to:
+		new
+
+-------- @pointsto var-ref-i-D --------
+this I may contain these dynamic types:
+	D
+
+-------- @pointsto var-ref-i --------
+this I may contain these dynamic types:
+	*C, may point to:
+		new
+	D
+
+-------- @pointsto map-lookup,ok --------
+
+Error: pointer analysis wants an expression of reference type; got (*int, bool)
+-------- @pointsto mapval --------
+this *int may point to these objects:
+	a
+
+-------- @pointsto m --------
+this map[string]*int may point to these objects:
+	makemap
+
+-------- @pointsto builtin-panic --------
+
+Error: pointer analysis wants an expression of reference type; got ()
+-------- @pointsto var-ref-s-f --------
+this interface{} may contain these dynamic types:
+	chan bool, may point to:
+		makechan
+
+-------- @pointsto func-live --------
+
+Error: pointer analysis did not find expression (dead code?)
+-------- @pointsto func-dead --------
+
+Error: pointer analysis did not find expression (dead code?)
+-------- @pointsto b --------
+
+Error: pointer analysis did not find expression (dead code?)
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.go
new file mode 100644
index 0000000..0fd2342
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.go
@@ -0,0 +1,24 @@
+package main
+
+// Tests of 'referrers' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See referrers.golden for expected query results.
+
+import "lib"
+
+type s struct {
+	f int
+}
+
+func main() {
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	_ = v.Method               // @referrers ref-method "Method"
+	_ = v.Method
+	v++ //@referrers ref-local "v"
+	v++
+
+	_ = s{}.f // @referrers ref-field "f"
+
+	var s2 s
+	s2.f = 1
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.golden
new file mode 100644
index 0000000..7bda141
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers-json/main.golden
@@ -0,0 +1,234 @@
+-------- @referrers ref-package --------
+{
+	"desc": "package lib"
+}
+{
+	"package": "definition-json",
+	"refs": [
+		{
+			"pos": "testdata/src/definition-json/main.go:18:8",
+			"text": "\tvar x lib.T           // @definition lexical-pkgname \"lib\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:24:8",
+			"text": "\tvar _ lib.Type     // @definition qualified-type \"Type\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:25:8",
+			"text": "\tvar _ lib.Func     // @definition qualified-func \"Func\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:26:8",
+			"text": "\tvar _ lib.Var      // @definition qualified-var \"Var\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:27:8",
+			"text": "\tvar _ lib.Const    // @definition qualified-const \"Const\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:28:8",
+			"text": "\tvar _ lib2.Type    // @definition qualified-type-renaming \"Type\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:29:8",
+			"text": "\tvar _ lib.Nonesuch // @definition qualified-nomember \"Nonesuch\""
+		},
+		{
+			"pos": "testdata/src/definition-json/main.go:61:2",
+			"text": "\tlib.Type // @definition embedded-other-pkg \"Type\""
+		}
+	]
+}
+{
+	"package": "describe",
+	"refs": [
+		{
+			"pos": "testdata/src/describe/main.go:86:8",
+			"text": "\tvar _ lib.Outer // @describe lib-outer \"Outer\""
+		}
+	]
+}
+{
+	"package": "imports",
+	"refs": [
+		{
+			"pos": "testdata/src/imports/main.go:18:12",
+			"text": "\tconst c = lib.Const // @describe ref-const \"Const\""
+		},
+		{
+			"pos": "testdata/src/imports/main.go:19:2",
+			"text": "\tlib.Func()          // @describe ref-func \"Func\""
+		},
+		{
+			"pos": "testdata/src/imports/main.go:20:2",
+			"text": "\tlib.Var++           // @describe ref-var \"Var\""
+		},
+		{
+			"pos": "testdata/src/imports/main.go:21:8",
+			"text": "\tvar t lib.Type      // @describe ref-type \"Type\""
+		},
+		{
+			"pos": "testdata/src/imports/main.go:26:8",
+			"text": "\tvar _ lib.Type // @describe ref-pkg \"lib\""
+		}
+	]
+}
+{
+	"package": "referrers",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/int_test.go:7:7",
+			"text": "\t_ = (lib.Type).Method // ref from internal test package"
+		}
+	]
+}
+{
+	"package": "referrers",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/main.go:16:8",
+			"text": "\tvar v lib.Type = lib.Const // @referrers ref-package \"lib\""
+		},
+		{
+			"pos": "testdata/src/referrers/main.go:16:19",
+			"text": "\tvar v lib.Type = lib.Const // @referrers ref-package \"lib\""
+		}
+	]
+}
+{
+	"package": "referrers-json",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers-json/main.go:14:8",
+			"text": "\tvar v lib.Type = lib.Const // @referrers ref-package \"lib\""
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:14:19",
+			"text": "\tvar v lib.Type = lib.Const // @referrers ref-package \"lib\""
+		}
+	]
+}
+{
+	"package": "referrers_test",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/ext_test.go:10:7",
+			"text": "\t_ = (lib.Type).Method // ref from external test package"
+		}
+	]
+}
+{
+	"package": "what-json",
+	"refs": [
+		{
+			"pos": "testdata/src/what-json/main.go:13:7",
+			"text": "var _ lib.Var // @what pkg \"lib\""
+		},
+		{
+			"pos": "testdata/src/what-json/main.go:14:8",
+			"text": "type _ lib.T"
+		}
+	]
+}
+-------- @referrers ref-method --------
+{
+	"objpos": "testdata/src/lib/lib.go:5:13",
+	"desc": "func (lib.Type).Method(x *int) *int"
+}
+{
+	"package": "imports",
+	"refs": [
+		{
+			"pos": "testdata/src/imports/main.go:22:9",
+			"text": "\tp := t.Method(\u0026a)   // @describe ref-method \"Method\""
+		}
+	]
+}
+{
+	"package": "referrers",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/int_test.go:7:17",
+			"text": "\t_ = (lib.Type).Method // ref from internal test package"
+		}
+	]
+}
+{
+	"package": "referrers",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/main.go:17:8",
+			"text": "\t_ = v.Method               // @referrers ref-method \"Method\""
+		},
+		{
+			"pos": "testdata/src/referrers/main.go:18:8",
+			"text": "\t_ = v.Method"
+		}
+	]
+}
+{
+	"package": "referrers-json",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers-json/main.go:15:8",
+			"text": "\t_ = v.Method               // @referrers ref-method \"Method\""
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:16:8",
+			"text": "\t_ = v.Method"
+		}
+	]
+}
+{
+	"package": "referrers_test",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers/ext_test.go:10:17",
+			"text": "\t_ = (lib.Type).Method // ref from external test package"
+		}
+	]
+}
+-------- @referrers ref-local --------
+{
+	"objpos": "testdata/src/referrers-json/main.go:14:6",
+	"desc": "var v lib.Type"
+}
+{
+	"package": "referrers-json",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers-json/main.go:15:6",
+			"text": "\t_ = v.Method               // @referrers ref-method \"Method\""
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:16:6",
+			"text": "\t_ = v.Method"
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:17:2",
+			"text": "\tv++ //@referrers ref-local \"v\""
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:18:2",
+			"text": "\tv++"
+		}
+	]
+}
+-------- @referrers ref-field --------
+{
+	"objpos": "testdata/src/referrers-json/main.go:10:2",
+	"desc": "field f int"
+}
+{
+	"package": "referrers-json",
+	"refs": [
+		{
+			"pos": "testdata/src/referrers-json/main.go:20:10",
+			"text": "\t_ = s{}.f // @referrers ref-field \"f\""
+		},
+		{
+			"pos": "testdata/src/referrers-json/main.go:23:5",
+			"text": "\ts2.f = 1"
+		}
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/ext_test.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/ext_test.go
new file mode 100644
index 0000000..35e3199
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/ext_test.go
@@ -0,0 +1,12 @@
+package main_test
+
+import (
+	"lib"
+	renamed "referrers" // package has name "main", path "referrers", local name "renamed"
+)
+
+func _() {
+	// This reference should be found by the ref-method query.
+	_ = (lib.Type).Method // ref from external test package
+	var _ renamed.T
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/int_test.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/int_test.go
new file mode 100644
index 0000000..9102cd6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/int_test.go
@@ -0,0 +1,8 @@
+package main
+
+import "lib"
+
+func _() {
+	// This reference should be found by the ref-method query.
+	_ = (lib.Type).Method // ref from internal test package
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.go
new file mode 100644
index 0000000..1fc80ea
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.go
@@ -0,0 +1,34 @@
+package main // @referrers package-decl "main"
+
+// Tests of 'referrers' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See referrers.golden for expected query results.
+
+import "lib"
+
+type s struct { // @referrers type " s "
+	f int
+}
+
+type T int
+
+func main() {
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	_ = v.Method               // @referrers ref-method "Method"
+	_ = v.Method
+	v++ //@referrers ref-local "v"
+	v++
+
+	_ = s{}.f // @referrers ref-field "f"
+
+	var s2 s
+	s2.f = 1
+}
+
+// Test //line directives:
+
+type U int // @referrers ref-type-U "U"
+
+//line nosuchfile.y:123
+var u1 U
+var u2 U
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.golden
new file mode 100644
index 0000000..230e95e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/referrers/main.golden
@@ -0,0 +1,60 @@
+-------- @referrers package-decl --------
+references to package main ("referrers")
+	var _ renamed.T
+
+-------- @referrers type --------
+references to type s struct{f int}
+	_ = s{}.f // @referrers ref-field "f"
+	var s2 s
+
+-------- @referrers ref-package --------
+references to package lib
+	_ = (lib.Type).Method // ref from external test package
+	_ = (lib.Type).Method // ref from internal test package
+	const c = lib.Const // @describe ref-const "Const"
+	lib.Func()          // @describe ref-func "Func"
+	lib.Type // @definition embedded-other-pkg "Type"
+	lib.Var++           // @describe ref-var "Var"
+	var _ lib.Const    // @definition qualified-const "Const"
+	var _ lib.Func     // @definition qualified-func "Func"
+	var _ lib.Nonesuch // @definition qualified-nomember "Nonesuch"
+	var _ lib.Outer // @describe lib-outer "Outer"
+	var _ lib.Type     // @definition qualified-type "Type"
+	var _ lib.Type // @describe ref-pkg "lib"
+	var _ lib.Var      // @definition qualified-var "Var"
+	var _ lib2.Type    // @definition qualified-type-renaming "Type"
+	var t lib.Type      // @describe ref-type "Type"
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	var v lib.Type = lib.Const // @referrers ref-package "lib"
+	var x lib.T           // @definition lexical-pkgname "lib"
+type _ lib.T
+var _ lib.Var // @what pkg "lib"
+
+-------- @referrers ref-method --------
+references to func (Type).Method(x *int) *int
+	_ = (lib.Type).Method // ref from external test package
+	_ = (lib.Type).Method // ref from internal test package
+	_ = v.Method
+	_ = v.Method
+	_ = v.Method               // @referrers ref-method "Method"
+	_ = v.Method               // @referrers ref-method "Method"
+	p := t.Method(&a)   // @describe ref-method "Method"
+
+-------- @referrers ref-local --------
+references to var v lib.Type
+	_ = v.Method
+	_ = v.Method               // @referrers ref-method "Method"
+	v++
+	v++ //@referrers ref-local "v"
+
+-------- @referrers ref-field --------
+references to field f int
+	_ = s{}.f // @referrers ref-field "f"
+	s2.f = 1
+
+-------- @referrers ref-type-U --------
+references to type U int
+open testdata/src/referrers/nosuchfile.y: no such file or directory (+ 1 more refs in this file)
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.go
new file mode 100644
index 0000000..392643b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.go
@@ -0,0 +1,30 @@
+package main
+
+// This is a test of 'pointsto', but we split it into a separate file
+// so that pointsto.go doesn't have to import "reflect" each time.
+
+import "reflect"
+
+var a int
+var b bool
+
+func main() {
+	m := make(map[*int]*bool)
+	m[&a] = &b
+
+	mrv := reflect.ValueOf(m)
+	if a > 0 {
+		mrv = reflect.ValueOf(&b)
+	}
+	if a > 0 {
+		mrv = reflect.ValueOf(&a)
+	}
+
+	_ = mrv                  // @pointsto mrv "mrv"
+	p1 := mrv.Interface()    // @pointsto p1 "p1"
+	p2 := mrv.MapKeys()      // @pointsto p2 "p2"
+	p3 := p2[0]              // @pointsto p3 "p3"
+	p4 := reflect.TypeOf(p1) // @pointsto p4 "p4"
+
+	_, _, _, _ = p1, p2, p3, p4
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.golden
new file mode 100644
index 0000000..4782132
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/reflection/main.golden
@@ -0,0 +1,34 @@
+-------- @pointsto mrv --------
+this reflect.Value may contain these dynamic types:
+	*bool, may point to:
+		reflection.b
+	*int, may point to:
+		reflection.a
+	map[*int]*bool, may point to:
+		makemap
+
+-------- @pointsto p1 --------
+this interface{} may contain these dynamic types:
+	*bool, may point to:
+		reflection.b
+	*int, may point to:
+		reflection.a
+	map[*int]*bool, may point to:
+		makemap
+
+-------- @pointsto p2 --------
+this []reflect.Value may point to these objects:
+	<alloc in (reflect.Value).MapKeys>
+
+-------- @pointsto p3 --------
+this reflect.Value may contain these dynamic types:
+	*int, may point to:
+		reflection.a
+
+-------- @pointsto p4 --------
+this reflect.Type may contain these dynamic types:
+	*reflect.rtype, may point to:
+		*bool
+		*int
+		map[*int]*bool
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.go
new file mode 100644
index 0000000..f7254b8
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.go
@@ -0,0 +1,15 @@
+package main
+
+// Tests of various queries on a program containing only "soft" errors.
+// See go.tools/guru/guru_test.go for explanation.
+// See main.golden for expected query results.
+
+func _() {
+	var i int // "unused var" is a soft error
+}
+
+func f() {} // @callers softerrs-callers-f "f"
+
+func main() {
+	f() // @describe softerrs-describe-f "f"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.golden
new file mode 100644
index 0000000..ae95f46
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/softerrs/main.golden
@@ -0,0 +1,8 @@
+-------- @callers softerrs-callers-f --------
+softerrs.f is called from these 1 sites:
+	static function call from softerrs.main
+
+-------- @describe softerrs-describe-f --------
+reference to func f()
+defined here
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.go
new file mode 100644
index 0000000..27177ff
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.go
@@ -0,0 +1,14 @@
+package main
+
+import "lib"
+
+// Tests of 'what' queries, -format=json.
+// See go.tools/guru/guru_test.go for explanation.
+// See what-json.golden for expected query results.
+
+func main() {
+	f() // @what call "f"
+}
+
+var _ lib.Var // @what pkg "lib"
+type _ lib.T
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.golden
new file mode 100644
index 0000000..320c52b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what-json/main.golden
@@ -0,0 +1,95 @@
+-------- @what call --------
+{
+	"enclosing": [
+		{
+			"desc": "identifier",
+			"start": 189,
+			"end": 190
+		},
+		{
+			"desc": "function call",
+			"start": 189,
+			"end": 192
+		},
+		{
+			"desc": "expression statement",
+			"start": 189,
+			"end": 192
+		},
+		{
+			"desc": "block",
+			"start": 186,
+			"end": 212
+		},
+		{
+			"desc": "function declaration",
+			"start": 174,
+			"end": 212
+		},
+		{
+			"desc": "source file",
+			"start": 0,
+			"end": 259
+		}
+	],
+	"modes": [
+		"callees",
+		"callers",
+		"callstack",
+		"definition",
+		"describe",
+		"freevars",
+		"implements",
+		"pointsto",
+		"referrers",
+		"whicherrs"
+	],
+	"srcdir": "testdata/src",
+	"importpath": "what-json"
+}
+-------- @what pkg --------
+{
+	"enclosing": [
+		{
+			"desc": "identifier",
+			"start": 220,
+			"end": 223
+		},
+		{
+			"desc": "selector",
+			"start": 220,
+			"end": 227
+		},
+		{
+			"desc": "value specification",
+			"start": 218,
+			"end": 227
+		},
+		{
+			"desc": "variable declaration",
+			"start": 214,
+			"end": 227
+		},
+		{
+			"desc": "source file",
+			"start": 0,
+			"end": 259
+		}
+	],
+	"modes": [
+		"definition",
+		"describe",
+		"freevars",
+		"implements",
+		"pointsto",
+		"referrers",
+		"whicherrs"
+	],
+	"srcdir": "testdata/src",
+	"importpath": "what-json",
+	"object": "lib",
+	"sameids": [
+		"$GOPATH/src/what-json/main.go:13:7",
+		"$GOPATH/src/what-json/main.go:14:8"
+	]
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.go
new file mode 100644
index 0000000..9e6a8b9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.go
@@ -0,0 +1,11 @@
+package main // @what pkgdecl "main"
+
+// Tests of 'what' queries.
+// See go.tools/guru/guru_test.go for explanation.
+// See what.golden for expected query results.
+
+func main() {
+	f()             // @what call "f"
+	var ch chan int // @what var "var"
+	<-ch            // @what recv "ch"
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.golden
new file mode 100644
index 0000000..f113e2f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/what/main.golden
@@ -0,0 +1,41 @@
+-------- @what pkgdecl --------
+identifier
+source file
+modes: [definition describe freevars implements pointsto referrers whicherrs]
+srcdir: testdata/src
+import path: what
+
+-------- @what call --------
+identifier
+function call
+expression statement
+block
+function declaration
+source file
+modes: [callees callers callstack definition describe freevars implements pointsto referrers whicherrs]
+srcdir: testdata/src
+import path: what
+
+-------- @what var --------
+variable declaration
+variable declaration statement
+block
+function declaration
+source file
+modes: [callers callstack describe freevars pointsto whicherrs]
+srcdir: testdata/src
+import path: what
+
+-------- @what recv --------
+identifier
+unary <- operation
+expression statement
+block
+function declaration
+source file
+modes: [callers callstack definition describe freevars implements peers pointsto referrers whicherrs]
+srcdir: testdata/src
+import path: what
+ch
+ch
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.go b/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.go
new file mode 100644
index 0000000..d1613c5
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.go
@@ -0,0 +1,32 @@
+package main
+
+type errType string
+
+const constErr errType = "blah"
+
+func (et errType) Error() string {
+	return string(et)
+}
+
+var errVar error = errType("foo")
+
+func genErr(i int) error {
+	switch i {
+	case 0:
+		return constErr
+	case 1:
+		return errVar
+	default:
+		return nil
+	}
+}
+
+func unreachable() {
+	err := errVar // @whicherrs func-dead "err"
+	_ = err
+}
+
+func main() {
+	err := genErr(0) // @whicherrs localerrs "err"
+	_ = err
+}
diff --git a/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.golden b/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.golden
new file mode 100644
index 0000000..3484752
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/testdata/src/whicherrs/main.golden
@@ -0,0 +1,11 @@
+-------- @whicherrs func-dead --------
+
+Error: pointer analysis did not find expression (dead code?)
+-------- @whicherrs localerrs --------
+this error may point to these globals:
+	errVar
+this error may contain these constants:
+	constErr
+this error may contain these dynamic types:
+	errType
+
diff --git a/vendor/golang.org/x/tools/cmd/guru/unit_test.go b/vendor/golang.org/x/tools/cmd/guru/unit_test.go
new file mode 100644
index 0000000..699e6a1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/guru/unit_test.go
@@ -0,0 +1,105 @@
+// 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/build"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Unit tests for internal guru functions
+
+func TestIssue17515(t *testing.T) {
+	// Tests handling of symlinks in function guessImportPath
+	// If we have Go code inside $HOME/go/src and create a symlink $HOME/src to it
+	// there are 4 possible cases that need to be tested:
+	// (1) absolute & absolute: GOPATH=$HOME/go/src file=$HOME/go/src/test/test.go
+	// (2) absolute & symlink:  GOPATH=$HOME/go/src file=$HOME/src/test/test.go
+	// (3) symlink & symlink:   GOPATH=$HOME/src file=$HOME/src/test/test.go
+	// (4) symlink & absolute:  GOPATH=$HOME/src file= $HOME/go/src/test/test.go
+
+	// Create a temporary home directory under /tmp
+	home, err := ioutil.TempDir(os.TempDir(), "home")
+	if err != nil {
+		t.Errorf("Unable to create a temporary directory in %s", os.TempDir())
+	}
+
+	defer os.RemoveAll(home)
+
+	// create filepath /tmp/home/go/src/test/test.go
+	if err = os.MkdirAll(home+"/go/src/test", 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	var buildContext = build.Default
+
+	// Success test cases
+	type SuccessTest struct {
+		gopath, filename, wantSrcdir string
+	}
+
+	successTests := []SuccessTest{
+		{home + "/go", home + "/go/src/test/test.go", filepath.FromSlash(home + "/go/src")},
+	}
+
+	// Add symlink cases if not on Windows, Plan 9
+	if runtime.GOOS != "windows" && runtime.GOOS != "plan9" {
+		// symlink between /tmp/home/go/src and /tmp/home/src
+		if err := os.Symlink(home+"/go/src", home+"/src"); err != nil {
+			t.Fatal(err)
+		}
+
+		successTests = append(successTests, []SuccessTest{
+			{home + "/go", home + "/src/test/test.go", filepath.FromSlash(home + "/go/src")},
+			{home, home + "/go/src/test/test.go", filepath.FromSlash(home + "/src")},
+			{home, home + "/src/test/test.go", filepath.FromSlash(home + "/src")},
+		}...)
+	}
+
+	for _, test := range successTests {
+		buildContext.GOPATH = test.gopath
+		srcdir, importPath, err := guessImportPath(test.filename, &buildContext)
+		if srcdir != test.wantSrcdir || importPath != "test" || err != nil {
+			t.Errorf("guessImportPath(%q, %q) = %q, %q, %q; want %q, %q, %q",
+				test.filename, test.gopath, srcdir, importPath, err, test.wantSrcdir, "test", "nil")
+		}
+	}
+	// Function to format expected error message
+	errFormat := func(fpath string) string {
+		return fmt.Sprintf("can't evaluate symlinks of %s", fpath)
+	}
+
+	// Failure test cases
+	type FailTest struct {
+		gopath, filename, wantErr string
+	}
+
+	failTests := []FailTest{
+		{home + "/go", home + "/go/src/fake/test.go", errFormat(filepath.FromSlash(home + "/go/src/fake"))},
+	}
+
+	if runtime.GOOS != "windows" && runtime.GOOS != "plan9" {
+		failTests = append(failTests, []FailTest{
+			{home + "/go", home + "/src/fake/test.go", errFormat(filepath.FromSlash(home + "/src/fake"))},
+			{home, home + "/src/fake/test.go", errFormat(filepath.FromSlash(home + "/src/fake"))},
+			{home, home + "/go/src/fake/test.go", errFormat(filepath.FromSlash(home + "/go/src/fake"))},
+		}...)
+	}
+
+	for _, test := range failTests {
+		buildContext.GOPATH = test.gopath
+		srcdir, importPath, err := guessImportPath(test.filename, &buildContext)
+		if !strings.HasPrefix(fmt.Sprint(err), test.wantErr) {
+			t.Errorf("guessImportPath(%q, %q) = %q, %q, %q; want %q, %q, %q",
+				test.filename, test.gopath, srcdir, importPath, err, "", "", test.wantErr)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/oracle/what.go b/vendor/golang.org/x/tools/cmd/guru/what.go
similarity index 58%
rename from vendor/golang.org/x/tools/oracle/what.go
rename to vendor/golang.org/x/tools/cmd/guru/what.go
index 5a5c0cf..fabc3e8 100644
--- a/vendor/golang.org/x/tools/oracle/what.go
+++ b/vendor/golang.org/x/tools/cmd/guru/what.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+package main
 
 import (
 	"fmt"
@@ -14,8 +14,8 @@ import (
 	"sort"
 	"strings"
 
+	"golang.org/x/tools/cmd/guru/serial"
 	"golang.org/x/tools/go/ast/astutil"
-	"golang.org/x/tools/oracle/serial"
 )
 
 // what reports all the information about the query selection that can be
@@ -25,14 +25,13 @@ import (
 // the selected location.
 //
 func what(q *Query) error {
-	qpos, err := fastQueryPos(q.Pos)
+	qpos, err := fastQueryPos(q.Build, q.Pos)
 	if err != nil {
 		return err
 	}
-	q.Fset = qpos.fset
 
 	// (ignore errors)
-	srcdir, importPath, _ := guessImportPath(q.Fset.File(qpos.start).Name(), q.Build)
+	srcdir, importPath, _ := guessImportPath(qpos.fset.File(qpos.start).Name(), q.Build)
 
 	// Determine which query modes are applicable to the selection.
 	enable := map[string]bool{
@@ -75,7 +74,7 @@ func what(q *Query) error {
 			}
 		}
 
-		// For pointsto, we approximate findInterestingNode.
+		// For pointsto and whicherrs, we approximate findInterestingNode.
 		if _, ok := enable["pointsto"]; !ok {
 			switch n.(type) {
 			case ast.Stmt,
@@ -85,10 +84,14 @@ func what(q *Query) error {
 				*ast.InterfaceType,
 				*ast.MapType,
 				*ast.ChanType:
-				enable["pointsto"] = false // not an expr
+				// not an expression
+				enable["pointsto"] = false
+				enable["whicherrs"] = false
 
 			case ast.Expr, ast.Decl, *ast.ValueSpec:
-				enable["pointsto"] = true // an expr, maybe
+				// an expression, maybe
+				enable["pointsto"] = true
+				enable["whicherrs"] = true
 
 			default:
 				// Comment, Field, KeyValueExpr, etc: ascend.
@@ -110,12 +113,53 @@ func what(q *Query) error {
 	}
 	sort.Strings(modes)
 
-	q.result = &whatResult{
+	// 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
 }
 
@@ -129,11 +173,16 @@ func what(q *Query) error {
 func guessImportPath(filename string, buildContext *build.Context) (srcdir, importPath string, err error) {
 	absFile, err := filepath.Abs(filename)
 	if err != nil {
-		err = fmt.Errorf("can't form absolute path of %s", filename)
-		return
+		return "", "", fmt.Errorf("can't form absolute path of %s: %v", filename, err)
 	}
-	absFileDir := segments(filepath.Dir(absFile))
 
+	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() {
@@ -141,21 +190,31 @@ func guessImportPath(filename string, buildContext *build.Context) (srcdir, impo
 		if err != nil {
 			continue // e.g. non-existent dir on $GOPATH
 		}
-		d := prefixLen(segments(absDir), absFileDir)
+		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(absFileDir[len(absFileDir)-minD:], string(os.PathSeparator))
+			importPath = strings.Join(segmentedAbsFileDir[len(segmentedAbsFileDir)-minD:], string(os.PathSeparator))
 		}
 	}
 	if srcdir == "" {
-		err = fmt.Errorf("directory %s is not beneath any of these GOROOT/GOPATH directories: %s",
+		return "", "", fmt.Errorf("directory %s is not beneath any of these GOROOT/GOPATH directories: %s",
 			filepath.Dir(absFile), strings.Join(buildContext.SrcDirs(), ", "))
 	}
-	return
+	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 {
@@ -181,18 +240,23 @@ type whatResult struct {
 	modes      []string
 	srcdir     string
 	importPath string
+	object     string
+	sameids    []token.Pos
 }
 
-func (r *whatResult) display(printf printfFunc) {
+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) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *whatResult) JSON(fset *token.FileSet) []byte {
 	var enclosing []serial.SyntaxNode
 	for _, n := range r.path {
 		enclosing = append(enclosing, serial.SyntaxNode{
@@ -201,10 +265,18 @@ func (r *whatResult) toSerial(res *serial.Result, fset *token.FileSet) {
 			End:         fset.Position(n.End()).Offset,
 		})
 	}
-	res.What = &serial.What{
+
+	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/vendor/golang.org/x/tools/oracle/whicherrs.go b/vendor/golang.org/x/tools/cmd/guru/whicherrs.go
similarity index 93%
rename from vendor/golang.org/x/tools/oracle/whicherrs.go
rename to vendor/golang.org/x/tools/cmd/guru/whicherrs.go
index aaa6068..3a81bf5 100644
--- a/vendor/golang.org/x/tools/oracle/whicherrs.go
+++ b/vendor/golang.org/x/tools/cmd/guru/whicherrs.go
@@ -2,20 +2,21 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package oracle
+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"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
 )
 
 var builtinErrorType = types.Universe.Lookup("error").Type()
@@ -36,11 +37,10 @@ func whicherrs(q *Query) error {
 	}
 
 	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
+	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}
-	q.Fset = lprog.Fset
 
 	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
 	if err != nil {
@@ -91,7 +91,7 @@ func whicherrs(q *Query) error {
 	}
 
 	// Defer SSA construction till after errors are reported.
-	prog.BuildAll()
+	prog.Build()
 
 	globals := findVisibleErrs(prog, qpos)
 	constants := findVisibleConsts(prog, qpos)
@@ -141,6 +141,9 @@ func whicherrs(q *Query) error {
 
 	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 {
@@ -178,11 +181,9 @@ func whicherrs(q *Query) error {
 		// typeswitch or assert to. This means finding out
 		// if the type pointed to can be seen by us.
 		//
-		// For the purposes of this analysis, the type is always
-		// either a Named type or a pointer to one.
-		// There are cases where error can be implemented
-		// by unnamed types, but in that case, we can't assert to
-		// it, so we don't care about it for this analysis.
+		// 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:
@@ -205,7 +206,7 @@ func whicherrs(q *Query) error {
 	sort.Sort(membersByPosAndString(res.consts))
 	sort.Sort(sorterrorType(res.types))
 
-	q.result = res
+	q.Output(lprog.Fset, res)
 	return nil
 }
 
@@ -286,7 +287,7 @@ type whicherrsResult struct {
 	types   []*errorType
 }
 
-func (r *whicherrsResult) display(printf printfFunc) {
+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 {
@@ -307,7 +308,7 @@ func (r *whicherrsResult) display(printf printfFunc) {
 	}
 }
 
-func (r *whicherrsResult) toSerial(res *serial.Result, fset *token.FileSet) {
+func (r *whicherrsResult) JSON(fset *token.FileSet) []byte {
 	we := &serial.WhichErrs{}
 	we.ErrPos = fset.Position(r.errpos).String()
 	for _, g := range r.globals {
@@ -322,5 +323,5 @@ func (r *whicherrsResult) toSerial(res *serial.Result, fset *token.FileSet) {
 		et.Position = fset.Position(t.obj.Pos()).String()
 		we.Types = append(we.Types, et)
 	}
-	res.WhichErrs = we
+	return toJSON(we)
 }
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/.clang-format b/vendor/golang.org/x/tools/cmd/heapview/client/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/.gitignore b/vendor/golang.org/x/tools/cmd/heapview/client/.gitignore
new file mode 100644
index 0000000..2ccbe46
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/.gitignore
@@ -0,0 +1 @@
+/node_modules/
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/README.md b/vendor/golang.org/x/tools/cmd/heapview/client/README.md
new file mode 100644
index 0000000..4cb2621
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/README.md
@@ -0,0 +1,45 @@
+# Go Heap Viewer Client
+
+This directory contains the client Typescript code for the Go
+heap viewer.
+
+## Typescript Tooling
+
+Below are instructions for downloading tooling and files to
+help make the development process more convenient. These tools
+are not required for contributing or running the heap viewer-
+they are just meant as development aids.
+
+## Node and NPM
+
+We use npm to manage the dependencies for these tools. There are
+a couple of ways of installing npm on your system, but we recommend
+using nvm.
+
+Run the following command to install nvm:
+
+    [shell]$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
+
+or see the instructions on [the nvm github page](github.com/creationix/nvm)
+for alternative methods. This will put the nvm tool in your home directory
+and edit your path to add nvm, node and other tools you install using them.
+Once nvm is installed, use
+
+    [shell]$ nvm install node
+
+then
+
+    [shell]$ nvm use node
+
+to install node.js.
+
+Once node is installed, you can install typescript using
+
+    [shell]$ npm install -g typescript
+
+Finally, import type definitions into this project by running
+
+    [shell]$ npm install
+
+in this directory. They will be imported into the node_packages directory
+and be automatically available to the Typescript compiler.
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/main.ts b/vendor/golang.org/x/tools/cmd/heapview/client/main.ts
new file mode 100644
index 0000000..fe3985c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/main.ts
@@ -0,0 +1,195 @@
+// 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.
+
+/**
+ * An enum of types of actions that might be requested
+ * by the app.
+ */
+enum Action {
+  TOGGLE_SIDEBAR,  // Toggle the sidebar.
+  NAVIGATE_ABOUT,  // Go to the about page.
+}
+
+const TITLE = 'Go Heap Viewer';
+
+/**
+ * A type of event that signals to the AppElement controller
+ * that something shoud be done. For the most part, the structure
+ * of the app will be that elements' state will mostly be controlled
+ * by parent elements. Elements will issue actions that the AppElement
+ * will handle, and the app will be re-rendered down the DOM
+ * hierarchy.
+ */
+class ActionEvent extends Event {
+  static readonly EVENT_TYPE = 'action-event'
+  constructor(public readonly action: Action) { super(ActionEvent.EVENT_TYPE); }
+}
+
+/**
+ * A hamburger menu element. Triggers a TOGGLE_SIDE action to toggle the
+ * sidebar.
+ */
+export class HamburgerElement extends HTMLElement {
+  static readonly NAME = 'heap-hamburger';
+
+  createdCallback() {
+    this.appendChild(document.createTextNode('☰'));
+    this.onclick =
+        () => { this.dispatchEvent(new ActionEvent(Action.TOGGLE_SIDEBAR)) };
+  }
+}
+document.registerElement(HamburgerElement.NAME, HamburgerElement);
+
+/**
+ * A heading for the page with a hamburger menu and a title.
+ */
+export class HeadingElement extends HTMLElement {
+  static readonly NAME = 'heap-heading';
+
+  createdCallback() {
+    this.style.display = 'block';
+    this.style.backgroundColor = '#2196F3';
+    this.style.webkitUserSelect = 'none';
+    this.style.cursor = 'default';
+    this.style.color = '#FFFFFF';
+    this.style.padding = '10px';
+
+    const div = document.createElement('div');
+    div.style.margin = '0px';
+    div.style.fontSize = '2em';
+    div.appendChild(document.createElement(HamburgerElement.NAME));
+    div.appendChild(document.createTextNode(' ' + TITLE));
+    this.appendChild(div);
+  }
+}
+document.registerElement(HeadingElement.NAME, HeadingElement);
+
+/**
+ * A sidebar that has navigation for the app.
+ */
+export class SidebarElement extends HTMLElement {
+  static readonly NAME = 'heap-sidebar';
+
+  createdCallback() {
+    this.style.display = 'none';
+    this.style.backgroundColor = '#9E9E9E';
+    this.style.width = '15em';
+
+    const aboutButton = document.createElement('button');
+    aboutButton.innerText = 'about';
+    aboutButton.onclick =
+        () => { this.dispatchEvent(new ActionEvent(Action.NAVIGATE_ABOUT)) };
+    this.appendChild(aboutButton);
+  }
+
+  toggle() {
+    this.style.display = this.style.display === 'none' ? 'block' : 'none';
+  }
+}
+document.registerElement(SidebarElement.NAME, SidebarElement);
+
+/**
+ * A Container for the main content in the app.
+ * TODO(matloob): Implement main content.
+ */
+export class MainContentElement extends HTMLElement {
+  static readonly NAME = 'heap-container';
+
+  attachedCallback() {
+    this.style.backgroundColor = '#E0E0E0';
+    this.style.height = '100%';
+    this.style.flex = '1';
+  }
+}
+document.registerElement(MainContentElement.NAME, MainContentElement);
+
+/**
+ * A container and controller for the whole app.
+ * Contains the heading, side drawer and main panel.
+ */
+class AppElement extends HTMLElement {
+  static readonly NAME = 'heap-app';
+  private sidebar: SidebarElement;
+  private mainContent: MainContentElement;
+
+  attachedCallback() {
+    document.title = TITLE;
+
+    this.addEventListener(
+        ActionEvent.EVENT_TYPE, e => this.handleAction(e as ActionEvent),
+        /* capture */ true);
+
+    this.render();
+  }
+
+  render() {
+    this.style.display = 'block';
+    this.style.height = '100vh';
+    this.style.width = '100vw';
+    this.appendChild(document.createElement(HeadingElement.NAME));
+
+    const bodyDiv = document.createElement('div');
+    bodyDiv.style.height = '100%';
+    bodyDiv.style.display = 'flex';
+    this.sidebar =
+        document.createElement(SidebarElement.NAME) as SidebarElement;
+    bodyDiv.appendChild(this.sidebar);
+    this.mainContent =
+        document.createElement(MainContentElement.NAME) as MainContentElement;
+    bodyDiv.appendChild(this.mainContent);
+    this.appendChild(bodyDiv);
+
+    this.renderRoute();
+  }
+
+  renderRoute() {
+    this.mainContent.innerHTML = ''
+    switch (window.location.pathname) {
+      case '/about':
+        this.mainContent.appendChild(
+            document.createElement(AboutPageElement.NAME));
+        break;
+    }
+  }
+
+  handleAction(event: ActionEvent) {
+    switch (event.action) {
+      case Action.TOGGLE_SIDEBAR:
+        this.sidebar.toggle();
+        break;
+      case Action.NAVIGATE_ABOUT:
+        window.history.pushState({}, '', '/about');
+        this.renderRoute();
+        break;
+    }
+  }
+}
+document.registerElement(AppElement.NAME, AppElement);
+
+/**
+ * An about page.
+ */
+class AboutPageElement extends HTMLElement {
+  static readonly NAME = 'heap-about';
+
+  createdCallback() { this.textContent = TITLE; }
+}
+document.registerElement(AboutPageElement.NAME, AboutPageElement);
+
+/**
+ * Resets body's margin and padding, and sets font.
+ */
+function clearStyle(document: Document) {
+  const styleElement = document.createElement('style') as HTMLStyleElement;
+  document.head.appendChild(styleElement);
+  const styleSheet = styleElement.sheet as CSSStyleSheet;
+  styleSheet.insertRule(
+      '* {font-family: Roboto,Helvetica; box-sizing: border-box}', 0);
+  styleSheet.insertRule('body {margin: 0px; padding:0px}', 0);
+}
+
+export function main() {
+  clearStyle(document);
+  document.body.appendChild(document.createElement(AppElement.NAME));
+}
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/main_test.ts b/vendor/golang.org/x/tools/cmd/heapview/client/main_test.ts
new file mode 100644
index 0000000..a208653
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/main_test.ts
@@ -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.
+
+import {HamburgerElement, HeadingElement, SidebarElement, main} from './main';
+
+describe('main', () => {
+  it('sets the document\'s title', () => {
+    main();
+    expect(document.title).toBe('Go Heap Viewer');
+  });
+
+  it('has a heading', () => {
+    main();
+    expect(document.querySelector(HeadingElement.NAME)).toBeDefined();
+  });
+
+  it('has a sidebar', () => {
+    main();
+    const hamburger = document.querySelector(HamburgerElement.NAME);
+    const sidebar =
+        document.querySelector(SidebarElement.NAME) as SidebarElement;
+    expect(sidebar.style.display).toBe('none');
+
+    // Click on the hamburger. Sidebar should then be visible.
+    hamburger.dispatchEvent(new Event('click'));
+    expect(sidebar.style.display).toBe('block');
+  })
+});
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/package.json b/vendor/golang.org/x/tools/cmd/heapview/client/package.json
new file mode 100644
index 0000000..b2febe8
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/package.json
@@ -0,0 +1,35 @@
+{
+  "//": [
+    "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.",
+
+    "This file exists to help import typescript typings",
+    "for web features used in this project. Neither the",
+    "typings nor node or npm are required to do development",
+    "on the code in this project.",
+
+    "If you do have npm installed, use the `npm i` command",
+    "in this directory to install the typings."
+  ],
+  "private": true,
+  "name": "@golangtools/heapview",
+  "version": "0.0.0",
+  "devDependencies": {
+    "@types/webcomponents.js": "latest",
+    "@types/whatwg-fetch": "latest",
+    "@types/jasmine": "latest",
+
+    "jasmine-core": "latest",
+    "karma": "latest",
+    "karma-jasmine": "latest",
+    "karma-chrome-launcher": "latest",
+
+    "clang-format": "latest"
+  },
+  "scripts": {
+    "test": "karma start testing/karma.conf.js",
+    "format": "find . | grep '\\(test_main\\.js\\|\\.ts\\)$' | xargs clang-format -i",
+    "lint": "tslint --project ."
+  }
+}
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/testing/karma.conf.js b/vendor/golang.org/x/tools/cmd/heapview/client/testing/karma.conf.js
new file mode 100644
index 0000000..acaf9d5
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/testing/karma.conf.js
@@ -0,0 +1,22 @@
+// 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.
+
+module.exports = config => {
+    config.set({
+        frameworks: ['jasmine'],
+        basePath: '../../../..',
+        files: [
+            'third_party/webcomponents/customelements.js',
+            'third_party/typescript/typescript.js',
+            'third_party/moduleloader/moduleloader.js',
+            'cmd/heapview/client/testing/test_main.js',
+            {pattern: 'cmd/heapview/client/**/*.ts', included: false},
+        ],
+        browsers: ['Chrome'],
+        plugins: [
+            'karma-jasmine',
+            'karma-chrome-launcher'
+        ],
+    })
+}
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/testing/test_main.js b/vendor/golang.org/x/tools/cmd/heapview/client/testing/test_main.js
new file mode 100644
index 0000000..6c2afd7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/testing/test_main.js
@@ -0,0 +1,32 @@
+// 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.
+
+// Configure module loader.
+System.transpiler = 'typescript'
+System.typescriptOptions = {
+  target: ts.ScriptTarget.ES2015
+};
+System.locate = (load) => load.name + '.ts';
+
+// Determine set of test files.
+var tests = [];
+for (var file in window.__karma__.files) {
+  if (window.__karma__.files.hasOwnProperty(file)) {
+    if (/_test\.ts$/.test(file)) {
+      tests.push(file.slice(0, -3));
+    }
+  }
+}
+
+// Steal loaded callback so we can block until we're
+// done loading all test modules.
+var loadedCallback = window.__karma__.loaded.bind(window.__karma__);
+window.__karma__.loaded = () => {};
+
+// Load all test modules, and then call loadedCallback.
+var promises = [];
+for (var i = 0; i < tests.length; i++) {
+  promises.push(System.import(tests[i]));
+}
+Promise.all(promises).then(loadedCallback);
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/tsconfig.json b/vendor/golang.org/x/tools/cmd/heapview/client/tsconfig.json
new file mode 100644
index 0000000..14c38a1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/tsconfig.json
@@ -0,0 +1,16 @@
+// 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.
+
+// This file contains configuration for the Typescript
+// compiler if you're running it locally for typechecking
+// and other tooling. The Typescript compiler is
+// not necessary to do development on this project.
+
+{
+  "compilerOptions": {
+    "noEmit": true,
+    "strictNullChecks": true,
+    "target": "es2015"
+  }
+}
diff --git a/vendor/golang.org/x/tools/cmd/heapview/client/tslint.json b/vendor/golang.org/x/tools/cmd/heapview/client/tslint.json
new file mode 100644
index 0000000..a0f2d15
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/client/tslint.json
@@ -0,0 +1,40 @@
+// 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.
+
+// This tslint file is based on a configuration used at
+// Google.
+
+{
+  "rules": {
+    "class-name": true,
+    "forin": true,
+    "interface-name": [true, "never-prefix"],
+    "jsdoc-format": true,
+    "label-position": true,
+    "label-undefined": true,
+    "new-parens": true,
+    "no-angle-bracket-type-assertion": true,
+    "no-construct": true,
+    "no-debugger": true,
+    "no-namespace": [true, "allow-declarations"],
+    "no-reference": true,
+    "no-require-imports": true,
+    "no-unused-expression": true,
+    "no-unused-variable": true,
+    "no-use-before-declare": true,
+    "no-var-keyword": true,
+    "semicolon": [true, "always"],
+    "switch-default": true,
+    "triple-equals": [true, "allow-null-check"],
+    "use-isnan": true,
+    "variable-name": [
+      true,
+      "check-format",
+      "ban-keywords",
+      "allow-leading-underscore",
+      "allow-trailing-underscore",
+      "allow-pascal-case"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile.go b/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile.go
new file mode 100644
index 0000000..78445a9
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile.go
@@ -0,0 +1,145 @@
+// 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 darwin linux
+
+package core
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"syscall"
+)
+
+var errMmapClosed = errors.New("mmap: closed")
+
+// mmapFile wraps a memory-mapped file.
+type mmapFile struct {
+	data     []byte
+	pos      uint64
+	writable bool
+}
+
+// mmapOpen opens the named file for reading.
+// If writable is true, the file is also open for writing.
+func mmapOpen(filename string, writable bool) (*mmapFile, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	st, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	size := st.Size()
+	if size == 0 {
+		return &mmapFile{data: []byte{}}, nil
+	}
+	if size < 0 {
+		return nil, fmt.Errorf("mmap: file %q has negative size: %d", filename, size)
+	}
+	if size != int64(int(size)) {
+		return nil, fmt.Errorf("mmap: file %q is too large", filename)
+	}
+
+	prot := syscall.PROT_READ
+	if writable {
+		prot |= syscall.PROT_WRITE
+	}
+	data, err := syscall.Mmap(int(f.Fd()), 0, int(size), prot, syscall.MAP_SHARED)
+	if err != nil {
+		return nil, err
+	}
+	return &mmapFile{data: data, writable: writable}, nil
+}
+
+// Size returns the size of the mapped file.
+func (f *mmapFile) Size() uint64 {
+	return uint64(len(f.data))
+}
+
+// Pos returns the current file pointer.
+func (f *mmapFile) Pos() uint64 {
+	return f.pos
+}
+
+// SeekTo sets the current file pointer relative to the start of the file.
+func (f *mmapFile) SeekTo(offset uint64) {
+	f.pos = offset
+}
+
+// Read implements io.Reader.
+func (f *mmapFile) Read(p []byte) (int, error) {
+	if f.data == nil {
+		return 0, errMmapClosed
+	}
+	if f.pos >= f.Size() {
+		return 0, io.EOF
+	}
+	n := copy(p, f.data[f.pos:])
+	f.pos += uint64(n)
+	if n < len(p) {
+		return n, io.EOF
+	}
+	return n, nil
+}
+
+// ReadByte implements io.ByteReader.
+func (f *mmapFile) ReadByte() (byte, error) {
+	if f.data == nil {
+		return 0, errMmapClosed
+	}
+	if f.pos >= f.Size() {
+		return 0, io.EOF
+	}
+	b := f.data[f.pos]
+	f.pos++
+	return b, nil
+}
+
+// ReadSlice returns a slice of size n that points directly at the
+// underlying mapped file. There is no copying. Fails if it cannot
+// read at least n bytes.
+func (f *mmapFile) ReadSlice(n uint64) ([]byte, error) {
+	if f.data == nil {
+		return nil, errMmapClosed
+	}
+	if f.pos+n >= f.Size() {
+		return nil, io.EOF
+	}
+	first := f.pos
+	f.pos += n
+	return f.data[first:f.pos:f.pos], nil
+}
+
+// ReadSliceAt is like ReadSlice, but reads from a specific offset.
+// The file pointer is not used or advanced.
+func (f *mmapFile) ReadSliceAt(offset, n uint64) ([]byte, error) {
+	if f.data == nil {
+		return nil, errMmapClosed
+	}
+	if f.Size() < offset {
+		return nil, fmt.Errorf("mmap: out-of-bounds ReadSliceAt offset %d, size is %d", offset, f.Size())
+	}
+	if offset+n >= f.Size() {
+		return nil, io.EOF
+	}
+	end := offset + n
+	return f.data[offset:end:end], nil
+}
+
+// Close closes the file.
+func (f *mmapFile) Close() error {
+	if f.data == nil {
+		return nil
+	}
+	err := syscall.Munmap(f.data)
+	f.data = nil
+	f.pos = 0
+	return err
+}
diff --git a/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile_other.go b/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile_other.go
new file mode 100644
index 0000000..181f842
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/internal/core/mmapfile_other.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 !darwin,!linux
+
+package core
+
+// TODO(matloob): perhaps use the more portable golang.org/x/exp/mmap
+// instead of the mmap code in mmapfile.go.
+
+type mmapFile struct{}
+
+func (m *mmapFile) Close() error { return nil }
diff --git a/vendor/golang.org/x/tools/cmd/heapview/internal/core/raw.go b/vendor/golang.org/x/tools/cmd/heapview/internal/core/raw.go
new file mode 100644
index 0000000..febed0f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/internal/core/raw.go
@@ -0,0 +1,308 @@
+// 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 core provides functions for reading core dumps
+// and examining their contained heaps.
+package core
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"runtime"
+	"sort"
+)
+
+// RawDump provides raw access to the heap records in a core file.
+// The raw records in this file are described by other structs named Raw{*}.
+// All []byte slices are direct references to the underlying mmap'd file.
+// These references will become invalid as soon as the RawDump is closed.
+type RawDump struct {
+	Params   *RawParams
+	MemStats *runtime.MemStats
+
+	HeapObjects    []RawSegment // heap objects sorted by Addr, low-to-high
+	GlobalSegments []RawSegment // data, bss, and noptrbss segments
+
+	OSThreads   []*RawOSThread
+	Goroutines  []*RawGoroutine
+	StackFrames []*RawStackFrame
+	OtherRoots  []*RawOtherRoot
+	Finalizers  []*RawFinalizer
+	Defers      []*RawDefer
+	Panics      []*RawPanic
+
+	TypeFromItab map[uint64]uint64   // map from itab address to the type address that itab represents
+	TypeFromAddr map[uint64]*RawType // map from RawType.Addr to RawType
+
+	MemProfMap   map[uint64]*RawMemProfEntry
+	AllocSamples []*RawAllocSample
+
+	fmap *mmapFile
+}
+
+// RawParams holds metadata about the program that generated the dump.
+type RawParams struct {
+	// Info about the memory space
+
+	ByteOrder binary.ByteOrder // byte order of all memory in this dump
+	PtrSize   uint64           // in bytes
+	HeapStart uint64           // heap start address
+	HeapEnd   uint64           // heap end address (this is the last byte in the heap + 1)
+
+	// Info about the program that generated this heapdump
+
+	GoArch       string // GOARCH of the runtime library that generated this dump
+	GoExperiment string // GOEXPERIMENT of the toolchain that build the runtime library
+	NCPU         uint64 // number of physical cpus available to the program
+}
+
+// RawSegment represents a segment of memory.
+type RawSegment struct {
+	Addr      uint64       // base address of the segment
+	Data      []byte       // data for this segment
+	PtrFields RawPtrFields // offsets of ptr fields within this segment
+}
+
+// RawPtrFields represents a pointer field.
+type RawPtrFields struct {
+	encoded          []byte // list of uvarint-encoded offsets, or nil if none
+	startOff, endOff uint64 // decoded offsets are translated and clipped to [startOff,endOff)
+}
+
+// RawOSThread represents an OS thread.
+type RawOSThread struct {
+	MAddr  uint64 // address of the OS thread descriptor (M)
+	GoID   uint64 // go's internal ID for the thread
+	ProcID uint64 // kernel's ID for the thread
+}
+
+// RawGoroutine represents a goroutine structure.
+type RawGoroutine struct {
+	GAddr        uint64 // address of the goroutine descriptor
+	SP           uint64 // current stack pointer (lowest address in the currently running frame)
+	GoID         uint64 // goroutine ID
+	GoPC         uint64 // PC of the go statement that created this goroutine
+	Status       uint64
+	IsSystem     bool   // true if started by the system
+	IsBackground bool   // always false in go1.7
+	WaitSince    uint64 // time the goroutine started waiting, in nanoseconds since the Unix epoch
+	WaitReason   string
+	CtxtAddr     uint64 // address of the scheduling ctxt
+	MAddr        uint64 // address of the OS thread descriptor (M)
+	TopDeferAddr uint64 // address of the top defer record
+	TopPanicAddr uint64 // address of the top panic record
+}
+
+// RawStackFrame represents a stack frame.
+type RawStackFrame struct {
+	Name     string
+	Depth    uint64     // 0 = bottom of stack (currently running frame)
+	CalleeSP uint64     // stack pointer of the child frame (or 0 for the bottom-most frame)
+	EntryPC  uint64     // entry PC for the function
+	PC       uint64     // current PC being executed
+	NextPC   uint64     // for callers, where the function resumes (if anywhere) after the callee is done
+	Segment  RawSegment // local vars (Segment.Addr is the stack pointer, i.e., lowest address in the frame)
+}
+
+// RawOtherRoot represents the other roots not in RawDump's other fields.
+type RawOtherRoot struct {
+	Description string
+	Addr        uint64 // address pointed to by this root
+}
+
+// RawFinalizer represents a finalizer.
+type RawFinalizer struct {
+	IsQueued      bool   // if true, the object is unreachable and the finalizer is ready to run
+	ObjAddr       uint64 // address of the object to finalize
+	ObjTypeAddr   uint64 // address of the descriptor for typeof(obj)
+	FnAddr        uint64 // function to be run (a FuncVal*)
+	FnArgTypeAddr uint64 // address of the descriptor for the type of the function argument
+	FnPC          uint64 // PC of finalizer entry point
+}
+
+// RawDefer represents a defer.
+type RawDefer struct {
+	Addr     uint64 // address of the defer record
+	GAddr    uint64 // address of the containing goroutine's descriptor
+	ArgP     uint64 // stack pointer giving the args for defer (TODO: is this right?)
+	PC       uint64 // PC of the defer instruction
+	FnAddr   uint64 // function to be run (a FuncVal*)
+	FnPC     uint64 // PC of the defered function's entry point
+	LinkAddr uint64 // address of the next defer record in this chain
+}
+
+// RawPanic represents a panic.
+type RawPanic struct {
+	Addr        uint64 // address of the panic record
+	GAddr       uint64 // address of the containing goroutine's descriptor
+	ArgTypeAddr uint64 // type of the panic arg
+	ArgAddr     uint64 // address of the panic arg
+	DeferAddr   uint64 // address of the defer record that is currently running
+	LinkAddr    uint64 // address of the next panic record in this chain
+}
+
+// RawType repesents the Go runtime's representation of a type.
+type RawType struct {
+	Addr uint64 // address of the type descriptor
+	Size uint64 // in bytes
+	Name string // not necessarily unique
+	// If true, this type is equivalent to a single pointer, so ifaces can store
+	// this type directly in the data field (without indirection).
+	DirectIFace bool
+}
+
+// RawMemProfEntry represents a memory profiler entry.
+type RawMemProfEntry struct {
+	Size      uint64            // size of the allocated object
+	NumAllocs uint64            // number of allocations
+	NumFrees  uint64            // number of frees
+	Stacks    []RawMemProfFrame // call stacks
+}
+
+// RawMemProfFrame represents a memory profiler frame.
+type RawMemProfFrame struct {
+	Func []byte // string left as []byte reference to save memory
+	File []byte // string left as []byte reference to save memory
+	Line uint64
+}
+
+// RawAllocSample represents a memory profiler allocation sample.
+type RawAllocSample struct {
+	Addr uint64           // address of object
+	Prof *RawMemProfEntry // record of allocation site
+}
+
+// Close closes the file.
+func (r *RawDump) Close() error {
+	return r.fmap.Close()
+}
+
+// FindSegment returns the segment that contains the given address, or
+// nil of no segment contains the address.
+func (r *RawDump) FindSegment(addr uint64) *RawSegment {
+	// Binary search for an upper-bound heap object, then check
+	// if the previous object contains addr.
+	k := sort.Search(len(r.HeapObjects), func(k int) bool {
+		return addr < r.HeapObjects[k].Addr
+	})
+	k--
+	if k >= 0 && r.HeapObjects[k].Contains(addr) {
+		return &r.HeapObjects[k]
+	}
+
+	// Check all global segments.
+	for k := range r.GlobalSegments {
+		if r.GlobalSegments[k].Contains(addr) {
+			return &r.GlobalSegments[k]
+		}
+	}
+
+	// NB: Stack-local vars are technically allocated in the heap, since stack frames are
+	// allocated in the heap space, however, stack frames don't show up in r.HeapObjects.
+	for _, f := range r.StackFrames {
+		if f.Segment.Contains(addr) {
+			return &f.Segment
+		}
+	}
+
+	return nil
+}
+
+// Contains returns true if the segment contains the given address.
+func (r RawSegment) Contains(addr uint64) bool {
+	return r.Addr <= addr && addr < r.Addr+r.Size()
+}
+
+// ContainsRange returns true if the segment contains the range [addr, addr+size).
+func (r RawSegment) ContainsRange(addr, size uint64) bool {
+	if !r.Contains(addr) {
+		return false
+	}
+	if size > 0 && !r.Contains(addr+size-1) {
+		return false
+	}
+	return true
+}
+
+// Size returns the size of the segment in bytes.
+func (r RawSegment) Size() uint64 {
+	return uint64(len(r.Data))
+}
+
+// Slice takes a slice of the given segment. Panics if [offset,offset+size)
+// is out-of-bounds. The resulting RawSegment.PtrOffsets will clipped and
+// translated into the new segment.
+func (r RawSegment) Slice(offset, size uint64) *RawSegment {
+	if offset+size > uint64(len(r.Data)) {
+		panic(fmt.Errorf("slice(%d,%d) out-of-bounds of segment @%x sz=%d", offset, size, r.Addr, len(r.Data)))
+	}
+	return &RawSegment{
+		Addr: r.Addr + offset,
+		Data: r.Data[offset : offset+size : offset+size],
+		PtrFields: RawPtrFields{
+			encoded:  r.PtrFields.encoded,
+			startOff: r.PtrFields.startOff + offset,
+			endOff:   r.PtrFields.startOff + offset + size,
+		},
+	}
+}
+
+// Offsets decodes the list of ptr field offsets.
+func (r RawPtrFields) Offsets() []uint64 {
+	if r.encoded == nil {
+		return nil
+	}
+
+	// NB: This should never fail since we already decoded the varints once
+	// when parsing the file originally. Hence we panic on failure.
+	reader := bytes.NewReader(r.encoded)
+	readUint64 := func() uint64 {
+		x, err := binary.ReadUvarint(reader)
+		if err != nil {
+			panic(fmt.Errorf("unexpected failure decoding uvarint: %v", err))
+		}
+		return x
+	}
+
+	var out []uint64
+	for {
+		k := readUint64()
+		switch k {
+		case 0: // end
+			return out
+		case 1: // ptr
+			x := readUint64()
+			if r.startOff <= x && x < r.endOff {
+				out = append(out, x-r.startOff)
+			}
+		default:
+			panic(fmt.Errorf("unexpected FieldKind %d", k))
+		}
+	}
+}
+
+// ReadPtr decodes a ptr from the given byte slice.
+func (r *RawParams) ReadPtr(b []byte) uint64 {
+	switch r.PtrSize {
+	case 4:
+		return uint64(r.ByteOrder.Uint32(b))
+	case 8:
+		return r.ByteOrder.Uint64(b)
+	default:
+		panic(fmt.Errorf("unsupported PtrSize=%d", r.PtrSize))
+	}
+}
+
+// WritePtr encodes a ptr into the given byte slice.
+func (r *RawParams) WritePtr(b []byte, addr uint64) {
+	switch r.PtrSize {
+	case 4:
+		r.ByteOrder.PutUint32(b, uint32(addr))
+	case 8:
+		r.ByteOrder.PutUint64(b, addr)
+	default:
+		panic(fmt.Errorf("unsupported PtrSize=%d", r.PtrSize))
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/heapview/main.go b/vendor/golang.org/x/tools/cmd/heapview/main.go
new file mode 100644
index 0000000..6dac12e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/heapview/main.go
@@ -0,0 +1,83 @@
+// 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.
+
+// heapview is a tool for viewing Go heap dumps.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+var host = flag.String("host", "", "host addr to listen on")
+var port = flag.Int("port", 8080, "service port")
+
+var index = `<!DOCTYPE html>
+<script src="js/customelements.js"></script>
+<script src="js/typescript.js"></script>
+<script src="js/moduleloader.js"></script>
+<script>
+  System.transpiler = 'typescript';
+  System.typescriptOptions = {target: ts.ScriptTarget.ES2015};
+  System.locate = (load) => load.name + '.ts';
+</script>
+<script type="module">
+  import {main} from './client/main';
+  main();
+</script>
+`
+
+func toolsDir() string {
+	p, err := build.Import("golang.org/x/tools", "", build.FindOnly)
+	if err != nil {
+		log.Println("error: can't find client files:", err)
+		os.Exit(1)
+	}
+	return p.Dir
+}
+
+var parseFlags = func() {
+	flag.Parse()
+}
+
+var addHandlers = func() {
+	toolsDir := toolsDir()
+
+	// Directly serve typescript code in client directory for development.
+	http.Handle("/client/", http.StripPrefix("/client",
+		http.FileServer(http.Dir(filepath.Join(toolsDir, "cmd/heapview/client")))))
+
+	// Serve typescript.js and moduleloader.js for development.
+	http.HandleFunc("/js/typescript.js", func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, filepath.Join(toolsDir, "third_party/typescript/typescript.js"))
+	})
+	http.HandleFunc("/js/moduleloader.js", func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, filepath.Join(toolsDir, "third_party/moduleloader/moduleloader.js"))
+	})
+	http.HandleFunc("/js/customelements.js", func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, filepath.Join(toolsDir, "third_party/webcomponents/customelements.js"))
+	})
+
+	// Serve index.html using html string above.
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html")
+		io.WriteString(w, index)
+	})
+}
+
+var listenAndServe = func() error {
+	return http.ListenAndServe(fmt.Sprintf("%s:%d", *host, *port), nil)
+}
+
+func main() {
+	parseFlags()
+	addHandlers()
+	log.Fatal(listenAndServe())
+}
diff --git a/vendor/golang.org/x/tools/cmd/html2article/conv.go b/vendor/golang.org/x/tools/cmd/html2article/conv.go
new file mode 100644
index 0000000..4ef4f6c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/html2article/conv.go
@@ -0,0 +1,331 @@
+// 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.
+
+// This program takes an HTML file and outputs a corresponding article file in
+// present format. See: golang.org/x/tools/present
+package main // import "golang.org/x/tools/cmd/html2article"
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net/url"
+	"os"
+	"regexp"
+	"strings"
+
+	"golang.org/x/net/html"
+	"golang.org/x/net/html/atom"
+)
+
+func main() {
+	flag.Parse()
+
+	err := convert(os.Stdout, os.Stdin)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func convert(w io.Writer, r io.Reader) error {
+	root, err := html.Parse(r)
+	if err != nil {
+		return err
+	}
+
+	style := find(root, isTag(atom.Style))
+	if err := parseStyles(style); err != nil {
+		log.Printf("couldn't parse all styles: %v", err)
+	}
+
+	body := find(root, isTag(atom.Body))
+	if body == nil {
+		return errors.New("couldn't find body")
+	}
+	article := limitNewlineRuns(makeHeadings(strings.TrimSpace(text(body))))
+	_, err = fmt.Fprintf(w, "Title\n\n%s", article)
+	return err
+}
+
+type Style string
+
+const (
+	Bold   Style = "*"
+	Italic Style = "_"
+	Code   Style = "`"
+)
+
+var cssRules = make(map[string]Style)
+
+func parseStyles(style *html.Node) error {
+	if style == nil || style.FirstChild == nil {
+		return errors.New("couldn't find styles")
+	}
+
+	styles := style.FirstChild.Data
+	readUntil := func(end rune) (string, bool) {
+		i := strings.IndexRune(styles, end)
+		if i < 0 {
+			return "", false
+		}
+		s := styles[:i]
+		styles = styles[i:]
+		return s, true
+	}
+
+	for {
+		sel, ok := readUntil('{')
+		if !ok && sel == "" {
+			break
+		} else if !ok {
+			return fmt.Errorf("could not parse selector %q", styles)
+		}
+
+		value, ok := readUntil('}')
+		if !ok {
+			return fmt.Errorf("couldn't parse style body for %s", sel)
+		}
+		switch {
+		case strings.Contains(value, "italic"):
+			cssRules[sel] = Italic
+		case strings.Contains(value, "bold"):
+			cssRules[sel] = Bold
+		case strings.Contains(value, "Consolas") || strings.Contains(value, "Courier New"):
+			cssRules[sel] = Code
+		}
+	}
+	return nil
+}
+
+var newlineRun = regexp.MustCompile(`\n\n+`)
+
+func limitNewlineRuns(s string) string {
+	return newlineRun.ReplaceAllString(s, "\n\n")
+}
+
+func makeHeadings(body string) string {
+	buf := new(bytes.Buffer)
+	lines := strings.Split(body, "\n")
+	for i, s := range lines {
+		if i == 0 && !isBoldTitle(s) {
+			buf.WriteString("* Introduction\n\n")
+		}
+		if isBoldTitle(s) {
+			s = strings.TrimSpace(strings.Replace(s, "*", " ", -1))
+			s = "* " + s
+		}
+		buf.WriteString(s)
+		buf.WriteByte('\n')
+	}
+	return buf.String()
+}
+
+func isBoldTitle(s string) bool {
+	return !strings.Contains(s, " ") &&
+		strings.HasPrefix(s, "*") &&
+		strings.HasSuffix(s, "*")
+}
+
+func indent(buf *bytes.Buffer, s string) {
+	for _, l := range strings.Split(s, "\n") {
+		if l != "" {
+			buf.WriteByte('\t')
+			buf.WriteString(l)
+		}
+		buf.WriteByte('\n')
+	}
+}
+
+func unwrap(buf *bytes.Buffer, s string) {
+	var cont bool
+	for _, l := range strings.Split(s, "\n") {
+		l = strings.TrimSpace(l)
+		if len(l) == 0 {
+			if cont {
+				buf.WriteByte('\n')
+				buf.WriteByte('\n')
+			}
+			cont = false
+		} else {
+			if cont {
+				buf.WriteByte(' ')
+			}
+			buf.WriteString(l)
+			cont = true
+		}
+	}
+}
+
+func text(n *html.Node) string {
+	var buf bytes.Buffer
+	walk(n, func(n *html.Node) bool {
+		switch n.Type {
+		case html.TextNode:
+			buf.WriteString(n.Data)
+			return false
+		case html.ElementNode:
+			// no-op
+		default:
+			return true
+		}
+		a := n.DataAtom
+		if a == atom.Span {
+			switch {
+			case hasStyle(Code)(n):
+				a = atom.Code
+			case hasStyle(Bold)(n):
+				a = atom.B
+			case hasStyle(Italic)(n):
+				a = atom.I
+			}
+		}
+		switch a {
+		case atom.Br:
+			buf.WriteByte('\n')
+		case atom.P:
+			unwrap(&buf, childText(n))
+			buf.WriteString("\n\n")
+		case atom.Li:
+			buf.WriteString("- ")
+			unwrap(&buf, childText(n))
+			buf.WriteByte('\n')
+		case atom.Pre:
+			indent(&buf, childText(n))
+			buf.WriteByte('\n')
+		case atom.A:
+			href, text := attr(n, "href"), childText(n)
+			// Skip links with no text.
+			if strings.TrimSpace(text) == "" {
+				break
+			}
+			// Don't emit empty links.
+			if strings.TrimSpace(href) == "" {
+				buf.WriteString(text)
+				break
+			}
+			// Use original url for Google Docs redirections.
+			if u, err := url.Parse(href); err != nil {
+				log.Printf("parsing url %q: %v", href, err)
+			} else if u.Host == "www.google.com" && u.Path == "/url" {
+				href = u.Query().Get("q")
+			}
+			fmt.Fprintf(&buf, "[[%s][%s]]", href, text)
+		case atom.Code:
+			buf.WriteString(highlight(n, "`"))
+		case atom.B:
+			buf.WriteString(highlight(n, "*"))
+		case atom.I:
+			buf.WriteString(highlight(n, "_"))
+		case atom.Img:
+			src := attr(n, "src")
+			fmt.Fprintf(&buf, ".image %s\n", src)
+		case atom.Iframe:
+			src, w, h := attr(n, "src"), attr(n, "width"), attr(n, "height")
+			fmt.Fprintf(&buf, "\n.iframe %s %s %s\n", src, h, w)
+		case atom.Param:
+			if attr(n, "name") == "movie" {
+				// Old style YouTube embed.
+				u := attr(n, "value")
+				u = strings.Replace(u, "/v/", "/embed/", 1)
+				if i := strings.Index(u, "&"); i >= 0 {
+					u = u[:i]
+				}
+				fmt.Fprintf(&buf, "\n.iframe %s 540 304\n", u)
+			}
+		case atom.Title:
+		default:
+			return true
+		}
+		return false
+	})
+	return buf.String()
+}
+
+func childText(node *html.Node) string {
+	var buf bytes.Buffer
+	for n := node.FirstChild; n != nil; n = n.NextSibling {
+		fmt.Fprint(&buf, text(n))
+	}
+	return buf.String()
+}
+
+func highlight(node *html.Node, char string) string {
+	t := strings.Replace(childText(node), " ", char, -1)
+	return fmt.Sprintf("%s%s%s", char, t, char)
+}
+
+type selector func(*html.Node) bool
+
+func isTag(a atom.Atom) selector {
+	return func(n *html.Node) bool {
+		return n.DataAtom == a
+	}
+}
+
+func hasClass(name string) selector {
+	return func(n *html.Node) bool {
+		for _, a := range n.Attr {
+			if a.Key == "class" {
+				for _, c := range strings.Fields(a.Val) {
+					if c == name {
+						return true
+					}
+				}
+			}
+		}
+		return false
+	}
+}
+
+func hasStyle(s Style) selector {
+	return func(n *html.Node) bool {
+		for rule, s2 := range cssRules {
+			if s2 != s {
+				continue
+			}
+			if strings.HasPrefix(rule, ".") && hasClass(rule[1:])(n) {
+				return true
+			}
+			if n.DataAtom.String() == rule {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+func attr(node *html.Node, key string) (value string) {
+	for _, attr := range node.Attr {
+		if attr.Key == key {
+			return attr.Val
+		}
+	}
+	return ""
+}
+
+func find(n *html.Node, fn selector) *html.Node {
+	var result *html.Node
+	walk(n, func(n *html.Node) bool {
+		if result != nil {
+			return false
+		}
+		if fn(n) {
+			result = n
+			return false
+		}
+		return true
+	})
+	return result
+}
+
+func walk(n *html.Node, fn selector) {
+	if fn(n) {
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c, fn)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/appengine.go b/vendor/golang.org/x/tools/cmd/present/appengine.go
new file mode 100644
index 0000000..1e39ce1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/appengine.go
@@ -0,0 +1,22 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package main
+
+import (
+	"mime"
+
+	"golang.org/x/tools/present"
+)
+
+func init() {
+	initTemplates("./present/")
+	present.PlayEnabled = true
+	initPlayground("./present/", nil)
+
+	// App Engine has no /etc/mime.types
+	mime.AddExtensionType(".svg", "image/svg+xml")
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/dir.go b/vendor/golang.org/x/tools/cmd/present/dir.go
new file mode 100644
index 0000000..19aec87
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/dir.go
@@ -0,0 +1,214 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"html/template"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"golang.org/x/tools/present"
+)
+
+func init() {
+	http.HandleFunc("/", dirHandler)
+}
+
+// dirHandler serves a directory listing for the requested path, rooted at basePath.
+func dirHandler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path == "/favicon.ico" {
+		http.Error(w, "not found", 404)
+		return
+	}
+	const base = "."
+	name := filepath.Join(base, r.URL.Path)
+	if isDoc(name) {
+		err := renderDoc(w, name)
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), 500)
+		}
+		return
+	}
+	if isDir, err := dirList(w, name); err != nil {
+		addr, _, e := net.SplitHostPort(r.RemoteAddr)
+		if e != nil {
+			addr = r.RemoteAddr
+		}
+		log.Printf("request from %s: %s", addr, err)
+		http.Error(w, err.Error(), 500)
+		return
+	} else if isDir {
+		return
+	}
+	http.FileServer(http.Dir(base)).ServeHTTP(w, r)
+}
+
+func isDoc(path string) bool {
+	_, ok := contentTemplate[filepath.Ext(path)]
+	return ok
+}
+
+var (
+	// dirListTemplate holds the front page template.
+	dirListTemplate *template.Template
+
+	// contentTemplate maps the presentable file extensions to the
+	// template to be executed.
+	contentTemplate map[string]*template.Template
+)
+
+func initTemplates(base string) error {
+	// Locate the template file.
+	actionTmpl := filepath.Join(base, "templates/action.tmpl")
+
+	contentTemplate = make(map[string]*template.Template)
+
+	for ext, contentTmpl := range map[string]string{
+		".slide":   "slides.tmpl",
+		".article": "article.tmpl",
+	} {
+		contentTmpl = filepath.Join(base, "templates", contentTmpl)
+
+		// Read and parse the input.
+		tmpl := present.Template()
+		tmpl = tmpl.Funcs(template.FuncMap{"playable": playable})
+		if _, err := tmpl.ParseFiles(actionTmpl, contentTmpl); err != nil {
+			return err
+		}
+		contentTemplate[ext] = tmpl
+	}
+
+	var err error
+	dirListTemplate, err = template.ParseFiles(filepath.Join(base, "templates/dir.tmpl"))
+	return err
+}
+
+// renderDoc reads the present file, gets its template representation,
+// and executes the template, sending output to w.
+func renderDoc(w io.Writer, docFile string) error {
+	// Read the input and build the doc structure.
+	doc, err := parse(docFile, 0)
+	if err != nil {
+		return err
+	}
+
+	// Find which template should be executed.
+	tmpl := contentTemplate[filepath.Ext(docFile)]
+
+	// Execute the template.
+	return doc.Render(w, tmpl)
+}
+
+func parse(name string, mode present.ParseMode) (*present.Doc, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return present.Parse(f, name, mode)
+}
+
+// dirList scans the given path and writes a directory listing to w.
+// It parses the first part of each .slide file it encounters to display the
+// presentation title in the listing.
+// If the given path is not a directory, it returns (isDir == false, err == nil)
+// and writes nothing to w.
+func dirList(w io.Writer, name string) (isDir bool, err error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+	fi, err := f.Stat()
+	if err != nil {
+		return false, err
+	}
+	if isDir = fi.IsDir(); !isDir {
+		return false, nil
+	}
+	fis, err := f.Readdir(0)
+	if err != nil {
+		return false, err
+	}
+	d := &dirListData{Path: name}
+	for _, fi := range fis {
+		// skip the golang.org directory
+		if name == "." && fi.Name() == "golang.org" {
+			continue
+		}
+		e := dirEntry{
+			Name: fi.Name(),
+			Path: filepath.ToSlash(filepath.Join(name, fi.Name())),
+		}
+		if fi.IsDir() && showDir(e.Name) {
+			d.Dirs = append(d.Dirs, e)
+			continue
+		}
+		if isDoc(e.Name) {
+			if p, err := parse(e.Path, present.TitlesOnly); err != nil {
+				log.Println(err)
+			} else {
+				e.Title = p.Title
+			}
+			switch filepath.Ext(e.Path) {
+			case ".article":
+				d.Articles = append(d.Articles, e)
+			case ".slide":
+				d.Slides = append(d.Slides, e)
+			}
+		} else if showFile(e.Name) {
+			d.Other = append(d.Other, e)
+		}
+	}
+	if d.Path == "." {
+		d.Path = ""
+	}
+	sort.Sort(d.Dirs)
+	sort.Sort(d.Slides)
+	sort.Sort(d.Articles)
+	sort.Sort(d.Other)
+	return true, dirListTemplate.Execute(w, d)
+}
+
+// showFile reports whether the given file should be displayed in the list.
+func showFile(n string) bool {
+	switch filepath.Ext(n) {
+	case ".pdf":
+	case ".html":
+	case ".go":
+	default:
+		return isDoc(n)
+	}
+	return true
+}
+
+// showDir reports whether the given directory should be displayed in the list.
+func showDir(n string) bool {
+	if len(n) > 0 && (n[0] == '.' || n[0] == '_') || n == "present" {
+		return false
+	}
+	return true
+}
+
+type dirListData struct {
+	Path                          string
+	Dirs, Slides, Articles, Other dirEntrySlice
+}
+
+type dirEntry struct {
+	Name, Path, Title string
+}
+
+type dirEntrySlice []dirEntry
+
+func (s dirEntrySlice) Len() int           { return len(s) }
+func (s dirEntrySlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s dirEntrySlice) Less(i, j int) bool { return s[i].Name < s[j].Name }
diff --git a/vendor/golang.org/x/tools/cmd/present/doc.go b/vendor/golang.org/x/tools/cmd/present/doc.go
new file mode 100644
index 0000000..fafe4c1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/doc.go
@@ -0,0 +1,57 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Present displays slide presentations and articles. It runs a web server that
+presents slide and article files from the current directory.
+
+It may be run as a stand-alone command or an App Engine app.
+
+Usage of present:
+  -base="": base path for slide template and static resources
+  -http="127.0.0.1:3999": HTTP service address (e.g., '127.0.0.1:3999')
+  -nacl=false: use Native Client environment playground (prevents non-Go code execution)
+  -notes=false: enable presenter notes (press 'N' from the browser to display them)
+  -orighost="": host component of web origin URL (e.g., 'localhost')
+  -play=true: enable playground (permit execution of arbitrary user code)
+
+The setup of the Go version of NaCl is documented at:
+https://golang.org/wiki/NativeClient
+
+To use with App Engine, copy the tools/cmd/present directory to the root of
+your application and create an app.yaml file similar to this:
+
+    application: [application]
+    version: [version]
+    runtime: go
+    api_version: go1
+
+    handlers:
+    - url: /favicon.ico
+      static_files: present/static/favicon.ico
+      upload: present/static/favicon.ico
+    - url: /static
+      static_dir: present/static
+      application_readable: true
+    - url: /.*
+      script: _go_app
+
+    # nobuild_files is a regexp that identifies which files to not build.  It
+    # is useful for embedding static assets like code snippets and preventing
+    # them from producing build errors for your project.
+    nobuild_files: [path regexp for talk materials]
+
+Present then can be tested in a local App Engine environment with
+
+    goapp serve
+
+Input files are named foo.extension, where "extension" defines the format of
+the generated output. The supported formats are:
+	.slide        // HTML5 slide presentation
+	.article      // article format, such as a blog post
+
+The present file format is documented by the present package:
+http://godoc.org/golang.org/x/tools/present
+*/
+package main // import "golang.org/x/tools/cmd/present"
diff --git a/vendor/golang.org/x/tools/cmd/present/local.go b/vendor/golang.org/x/tools/cmd/present/local.go
new file mode 100644
index 0000000..260cacb
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/local.go
@@ -0,0 +1,133 @@
+// 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.
+
+// +build !appengine
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"log"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+
+	"golang.org/x/tools/present"
+)
+
+const basePkg = "golang.org/x/tools/cmd/present"
+
+var (
+	httpAddr     = flag.String("http", "127.0.0.1:3999", "HTTP service address (e.g., '127.0.0.1:3999')")
+	originHost   = flag.String("orighost", "", "host component of web origin URL (e.g., 'localhost')")
+	basePath     = flag.String("base", "", "base path for slide template and static resources")
+	nativeClient = flag.Bool("nacl", false, "use Native Client environment playground (prevents non-Go code execution)")
+)
+
+func main() {
+	flag.BoolVar(&present.PlayEnabled, "play", true, "enable playground (permit execution of arbitrary user code)")
+	flag.BoolVar(&present.NotesEnabled, "notes", false, "enable presenter notes (press 'N' from the browser to display them)")
+	flag.Parse()
+
+	if *basePath == "" {
+		p, err := build.Default.Import(basePkg, "", build.FindOnly)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Couldn't find gopresent files: %v\n", err)
+			fmt.Fprintf(os.Stderr, basePathMessage, basePkg)
+			os.Exit(1)
+		}
+		*basePath = p.Dir
+	}
+	err := initTemplates(*basePath)
+	if err != nil {
+		log.Fatalf("Failed to parse templates: %v", err)
+	}
+
+	ln, err := net.Listen("tcp", *httpAddr)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer ln.Close()
+
+	_, port, err := net.SplitHostPort(ln.Addr().String())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	origin := &url.URL{Scheme: "http"}
+	if *originHost != "" {
+		origin.Host = net.JoinHostPort(*originHost, port)
+	} else if ln.Addr().(*net.TCPAddr).IP.IsUnspecified() {
+		name, _ := os.Hostname()
+		origin.Host = net.JoinHostPort(name, port)
+	} else {
+		reqHost, reqPort, err := net.SplitHostPort(*httpAddr)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if reqPort == "0" {
+			origin.Host = net.JoinHostPort(reqHost, port)
+		} else {
+			origin.Host = *httpAddr
+		}
+	}
+
+	initPlayground(*basePath, origin)
+	http.Handle("/static/", http.FileServer(http.Dir(*basePath)))
+
+	if !ln.Addr().(*net.TCPAddr).IP.IsLoopback() &&
+		present.PlayEnabled && !*nativeClient {
+		log.Print(localhostWarning)
+	}
+
+	log.Printf("Open your web browser and visit %s", origin.String())
+	if present.NotesEnabled {
+		log.Println("Notes are enabled, press 'N' from the browser to display them.")
+	}
+	log.Fatal(http.Serve(ln, nil))
+}
+
+func environ(vars ...string) []string {
+	env := os.Environ()
+	for _, r := range vars {
+		k := strings.SplitAfter(r, "=")[0]
+		var found bool
+		for i, v := range env {
+			if strings.HasPrefix(v, k) {
+				env[i] = r
+				found = true
+			}
+		}
+		if !found {
+			env = append(env, r)
+		}
+	}
+	return env
+}
+
+const basePathMessage = `
+By default, gopresent locates the slide template files and associated
+static content by looking for a %q package
+in your Go workspaces (GOPATH).
+
+You may use the -base flag to specify an alternate location.
+`
+
+const localhostWarning = `
+WARNING!  WARNING!  WARNING!
+
+The present server appears to be listening on an address that is not localhost.
+Anyone with access to this address and port will have access to this machine as
+the user running present.
+
+To avoid this message, listen on localhost or run with -play=false.
+
+If you don't understand this message, hit Control-C to terminate this process.
+
+WARNING!  WARNING!  WARNING!
+`
diff --git a/vendor/golang.org/x/tools/cmd/present/play.go b/vendor/golang.org/x/tools/cmd/present/play.go
new file mode 100644
index 0000000..831b99f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/play.go
@@ -0,0 +1,43 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path/filepath"
+	"time"
+
+	"golang.org/x/tools/godoc/static"
+)
+
+var scripts = []string{"jquery.js", "jquery-ui.js", "playground.js", "play.js"}
+
+// playScript registers an HTTP handler at /play.js that serves all the
+// scripts specified by the variable above, and appends a line that
+// initializes the playground with the specified transport.
+func playScript(root, transport string) {
+	modTime := time.Now()
+	var buf bytes.Buffer
+	for _, p := range scripts {
+		if s, ok := static.Files[p]; ok {
+			buf.WriteString(s)
+			continue
+		}
+		b, err := ioutil.ReadFile(filepath.Join(root, "static", p))
+		if err != nil {
+			panic(err)
+		}
+		buf.Write(b)
+	}
+	fmt.Fprintf(&buf, "\ninitPlayground(new %v());\n", transport)
+	b := buf.Bytes()
+	http.HandleFunc("/play.js", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-type", "application/javascript")
+		http.ServeContent(w, r, "", modTime, bytes.NewReader(b))
+	})
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/play_http.go b/vendor/golang.org/x/tools/cmd/present/play_http.go
new file mode 100644
index 0000000..02e7314
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/play_http.go
@@ -0,0 +1,23 @@
+// 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 appengine appenginevm
+
+package main
+
+import (
+	"net/url"
+
+	"golang.org/x/tools/present"
+
+	_ "golang.org/x/tools/playground"
+)
+
+func initPlayground(basepath string, origin *url.URL) {
+	playScript(basepath, "HTTPTransport")
+}
+
+func playable(c present.Code) bool {
+	return present.PlayEnabled && c.Play && c.Ext == ".go"
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/play_socket.go b/vendor/golang.org/x/tools/cmd/present/play_socket.go
new file mode 100644
index 0000000..df63eda
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/play_socket.go
@@ -0,0 +1,36 @@
+// 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 !appengine,!appenginevm
+
+package main
+
+import (
+	"net/http"
+	"net/url"
+	"runtime"
+
+	"golang.org/x/tools/playground/socket"
+	"golang.org/x/tools/present"
+)
+
+func initPlayground(basepath string, origin *url.URL) {
+	if present.PlayEnabled {
+		if *nativeClient {
+			socket.RunScripts = false
+			socket.Environ = func() []string {
+				if runtime.GOARCH == "amd64" {
+					return environ("GOOS=nacl", "GOARCH=amd64p32")
+				}
+				return environ("GOOS=nacl")
+			}
+		}
+		playScript(basepath, "SocketTransport")
+		http.Handle("/socket", socket.NewHandler(origin))
+	}
+}
+
+func playable(c present.Code) bool {
+	return present.PlayEnabled && c.Play
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/static/article.css b/vendor/golang.org/x/tools/cmd/present/static/article.css
new file mode 100644
index 0000000..7b30455
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/article.css
@@ -0,0 +1,161 @@
+body {
+	margin: 0;
+	font-family: Helvetica, Arial, sans-serif;
+	font-size: 16px;
+}
+pre,
+code {
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+pre {
+	line-height: 18px;
+	margin: 0;
+	padding: 0;
+}
+a {
+	color: #375EAB;
+	text-decoration: none;
+}
+a:hover {
+	text-decoration: underline;
+}
+p, ul, ol {
+	margin: 20px;
+}
+
+h1, h2, h3, h4 {
+	margin: 20px 0;
+	padding: 0;
+	color: #375EAB;
+	font-weight: bold;
+}
+h1 {
+	font-size: 18px;
+	padding: 2px 5px;
+}
+h2 {
+	font-size: 16px;
+}
+h3 {
+	font-size: 16px;
+}
+h3, h4 {
+	margin: 20px 5px;
+}
+h4 {
+	font-size: 16px;
+}
+
+div#heading {
+	margin: 0 0 10px 0;
+	padding: 21px 0;
+	font-size: 20px;
+	font-weight: bold;
+}
+
+div#heading .author {
+	padding-top: 10px;
+	font-size: 14px;
+	font-weight: normal;
+}
+
+div#topbar {
+}
+
+body {
+	text-align: center;
+}
+div#page {
+	width: 100%;
+}
+div#page > .container,
+div#topbar > .container {
+	text-align: left;
+	margin-left: auto;
+	margin-right: auto;
+	padding: 0 20px;
+	width: 900px;
+}
+div#page.wide > .container,
+div#topbar.wide > .container {
+	width: auto;
+}
+
+div#footer {
+	text-align: center;
+	color: #666;
+	font-size: 14px;
+	margin: 40px 0;
+}
+
+.author p {
+	margin: 0;
+	padding: 0 20px;
+}
+
+div.code,
+div.output {
+	margin: 20px 20px 20px 40px;
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+
+div.output {
+	padding: 10px;
+}
+
+div.code { background: white; }
+div.output { background: black; }
+div.output .stdout { color: #e6e6e6; }
+div.output .stderr { color: rgb(244, 74, 63); }
+div.output .system { color: rgb(255, 209, 77) }
+
+.buttons {
+	margin-left: 20px;
+}
+div.output .buttons {
+	margin-left: 0;
+	margin-bottom: 10px;
+}
+
+#toc {
+	float: right;
+	margin: 0px 10px;
+	padding: 10px;
+	border: 1px solid #e5ecf9; 
+	background-color: #eee;
+	box-shadow: 3px 3px 2px #888888;
+
+	max-width: 33%;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+
+#tochead {
+	font-weight: bold;
+	font-variant: small-caps;
+	font-size: 100%;
+	text-align: center;
+	padding-bottom: 5px;
+}
+
+#toc ul, #toc a {
+	list-style-type: none;
+	padding-left: 0px;
+	color: black;
+	margin: 0px;
+}
+
+ul.toc-inner a {
+	padding-left: 10px !important;
+}
+
+@media print {
+	.no-print, .no-print * {
+		display: none !important;
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/static/dir.css b/vendor/golang.org/x/tools/cmd/present/static/dir.css
new file mode 100644
index 0000000..97587e6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/dir.css
@@ -0,0 +1,186 @@
+/* copied from $GOROOT/doc/style.css */
+
+body {
+	margin: 0;
+	font-family: Helvetica, Arial, sans-serif;
+	font-size: 16px;
+}
+pre,
+code {
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+pre {
+	line-height: 18px;
+}
+pre .comment {
+	color: #375EAB;
+}
+pre .highlight,
+pre .highlight-comment,
+pre .selection-highlight,
+pre .selection-highlight-comment {
+	background: #FFFF00;
+}
+pre .selection,
+pre .selection-comment {
+	background: #FF9632;
+}
+pre .ln {
+	color: #999;
+}
+body {
+	color: #222;
+}
+a,
+.exampleHeading .text {
+	color: #375EAB;
+	text-decoration: none;
+}
+a:hover,
+.exampleHeading .text:hover {
+	text-decoration: underline;
+}
+p,
+pre,
+ul,
+ol {
+	margin: 20px;
+}
+pre {
+	background: #e9e9e9;
+	padding: 10px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+
+h1,
+h2,
+h3,
+h4,
+.rootHeading {
+	margin: 20px 0;
+	padding: 0;
+	color: #375EAB;
+	font-weight: bold;
+}
+h1 {
+	font-size: 24px;
+}
+h2 {
+	font-size: 20px;
+	background: #E0EBF5;
+	padding: 2px 5px;
+}
+h3 {
+	font-size: 20px;
+}
+h3,
+h4 {
+	margin: 20px 5px;
+}
+h4 {
+	font-size: 16px;
+}
+
+dl {
+	margin: 20px;
+}
+dd {
+	margin: 2px 20px;
+}
+dl,
+dd {
+	font-size: 14px;
+}
+div#nav table td {
+	vertical-align: top;
+}
+
+div#heading {
+	float: left;
+	margin: 0 0 10px 0;
+	padding: 21px 0;
+	font-size: 20px;
+	font-weight: normal;
+}
+div#heading a {
+	color: #222;
+	text-decoration: none;
+}
+
+div#topbar {
+	background: #E0EBF5;
+	height: 64px;
+}
+
+body {
+	text-align: center;
+}
+div#page,
+div#topbar > .container {
+	clear: both;
+	text-align: left;
+	margin-left: auto;
+	margin-right: auto;
+	padding: 0 20px;
+	width: 900px;
+}
+div#page.wide,
+div#topbar > .wide {
+	width: auto;
+}
+div#plusone {
+	float: right;
+}
+
+div#footer {
+	color: #666;
+	font-size: 14px;
+	margin: 40px 0;
+}
+
+div#menu > a,
+div#menu > input {
+	padding: 10px;
+
+	text-decoration: none;
+	font-size: 16px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+div#menu > a,
+div#menu > input {
+	border: 1px solid #375EAB;
+}
+div#menu > a {
+	color: white;
+	background: #375EAB;
+}
+
+div#menu {
+	float: right;
+	min-width: 590px;
+	padding: 10px 0;
+	text-align: right;
+}
+div#menu > a {
+	margin-right: 5px;
+	margin-bottom: 10px;
+
+	padding: 10px;
+}
+div#menu > input {
+	position: relative;
+	top: 1px;
+	width: 60px;
+	background: white;
+	color: #222;
+}
+div#menu > input.inactive {
+	color: #999;
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/static/dir.js b/vendor/golang.org/x/tools/cmd/present/static/dir.js
new file mode 100644
index 0000000..5b0c37e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/dir.js
@@ -0,0 +1,41 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// copied from $GOROOT/doc/godocs.js
+
+function bindEvent(el, e, fn) {
+  if (el.addEventListener){
+    el.addEventListener(e, fn, false);
+  } else if (el.attachEvent){
+    el.attachEvent('on'+e, fn);
+  }
+}
+
+function godocs_bindSearchEvents() {
+  var search = document.getElementById('search');
+  if (!search) {
+    // no search box (index disabled)
+    return;
+  }
+  function clearInactive() {
+    if (search.className == "inactive") {
+      search.value = "";
+      search.className = "";
+    }
+  }
+  function restoreInactive() {
+    if (search.value !== "") {
+      return;
+    }
+    if (search.type != "search") {
+      search.value = search.getAttribute("placeholder");
+    }
+    search.className = "inactive";
+  }
+  restoreInactive();
+  bindEvent(search, 'focus', clearInactive);
+  bindEvent(search, 'blur', restoreInactive);
+}
+
+bindEvent(window, 'load', godocs_bindSearchEvents);
diff --git a/vendor/golang.org/x/tools/cmd/present/static/favicon.ico b/vendor/golang.org/x/tools/cmd/present/static/favicon.ico
new file mode 100644
index 0000000..48854ff
Binary files /dev/null and b/vendor/golang.org/x/tools/cmd/present/static/favicon.ico differ
diff --git a/vendor/golang.org/x/tools/cmd/present/static/jquery-ui.js b/vendor/golang.org/x/tools/cmd/present/static/jquery-ui.js
new file mode 100644
index 0000000..f391938
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/jquery-ui.js
@@ -0,0 +1,6 @@
+/*! jQuery UI - v1.10.2 - 2013-03-20
+* http://jqueryui.com
+* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.resizable.js
+* Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
+
+(function(e,t){function i(t,i){var a,n,r,o=t.nodeName.toLowerCase();return"area"===o?(a=t.parentNode,n=a.name,t.href&&n&&"map"===a.nodeName.toLowerCase()?(r=e("img[usemap=#"+n+"]")[0],!!r&&s(r)):!1):(/input|select|textarea|button|object/.test(o)?!t.disabled:"a"===o?t.href||i:i)&&s(t)}function s(t){return e.expr.filters.visible(t)&&!e(t).parents().addBack().filter(function(){return"hidden"===e.css(this,"visibility")}).length}var a=0,n=/^ui-id-\d+$/;e.ui=e.ui||{},e.extend(e.ui,{version:"1.10.2",keyCode:{BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38}}),e.fn.extend({focus:function(t){return function(i,s){return"number"==typeof i?this.each(function(){var t=this;setTimeout(function(){e(t).focus(),s&&s.call(t)},i)}):t.apply(this,arguments)}}(e.fn.focus),scrollParent:function(){var t;return t=e.ui.ie&&/(static|relative)/.test(this.css("position"))||/absolute/.test(this.css("position"))?this.parents().filter(function(){return/(relative|absolute|fixed)/.test(e.css(this,"position"))&&/(auto|scroll)/.test(e.css(this,"overflow")+e.css(this,"overflow-y")+e.css(this,"overflow-x"))}).eq(0):this.parents().filter(function(){return/(auto|scroll)/.test(e.css(this,"overflow")+e.css(this,"overflow-y")+e.css(this,"overflow-x"))}).eq(0),/fixed/.test(this.css("position"))||!t.length?e(document):t},zIndex:function(i){if(i!==t)return this.css("zIndex",i);if(this.length)for(var s,a,n=e(this[0]);n.length&&n[0]!==document;){if(s=n.css("position"),("absolute"===s||"relative"===s||"fixed"===s)&&(a=parseInt(n.css("zIndex"),10),!isNaN(a)&&0!==a))return a;n=n.parent()}return 0},uniqueId:function(){return this.each(function(){this.id||(this.id="ui-id-"+ ++a)})},removeUniqueId:function(){return this.each(function(){n.test(this.id)&&e(this).removeAttr("id")})}}),e.extend(e.expr[":"],{data:e.expr.createPseudo?e.expr.createPseudo(function(t){return function(i){return!!e.data(i,t)}}):function(t,i,s){return!!e.data(t,s[3])},focusable:function(t){return i(t,!isNaN(e.attr(t,"tabindex")))},tabbable:function(t){var s=e.attr(t,"tabindex"),a=isNaN(s);return(a||s>=0)&&i(t,!a)}}),e("<a>").outerWidth(1).jquery||e.each(["Width","Height"],function(i,s){function a(t,i,s,a){return e.each(n,function(){i-=parseFloat(e.css(t,"padding"+this))||0,s&&(i-=parseFloat(e.css(t,"border"+this+"Width"))||0),a&&(i-=parseFloat(e.css(t,"margin"+this))||0)}),i}var n="Width"===s?["Left","Right"]:["Top","Bottom"],r=s.toLowerCase(),o={innerWidth:e.fn.innerWidth,innerHeight:e.fn.innerHeight,outerWidth:e.fn.outerWidth,outerHeight:e.fn.outerHeight};e.fn["inner"+s]=function(i){return i===t?o["inner"+s].call(this):this.each(function(){e(this).css(r,a(this,i)+"px")})},e.fn["outer"+s]=function(t,i){return"number"!=typeof t?o["outer"+s].call(this,t):this.each(function(){e(this).css(r,a(this,t,!0,i)+"px")})}}),e.fn.addBack||(e.fn.addBack=function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}),e("<a>").data("a-b","a").removeData("a-b").data("a-b")&&(e.fn.removeData=function(t){return function(i){return arguments.length?t.call(this,e.camelCase(i)):t.call(this)}}(e.fn.removeData)),e.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase()),e.support.selectstart="onselectstart"in document.createElement("div"),e.fn.extend({disableSelection:function(){return this.bind((e.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}}),e.extend(e.ui,{plugin:{add:function(t,i,s){var a,n=e.ui[t].prototype;for(a in s)n.plugins[a]=n.plugins[a]||[],n.plugins[a].push([i,s[a]])},call:function(e,t,i){var s,a=e.plugins[t];if(a&&e.element[0].parentNode&&11!==e.element[0].parentNode.nodeType)for(s=0;a.length>s;s++)e.options[a[s][0]]&&a[s][1].apply(e.element,i)}},hasScroll:function(t,i){if("hidden"===e(t).css("overflow"))return!1;var s=i&&"left"===i?"scrollLeft":"scrollTop",a=!1;return t[s]>0?!0:(t[s]=1,a=t[s]>0,t[s]=0,a)}})})(jQuery);(function(e,t){var i=0,s=Array.prototype.slice,n=e.cleanData;e.cleanData=function(t){for(var i,s=0;null!=(i=t[s]);s++)try{e(i).triggerHandler("remove")}catch(a){}n(t)},e.widget=function(i,s,n){var a,r,o,h,l={},u=i.split(".")[0];i=i.split(".")[1],a=u+"-"+i,n||(n=s,s=e.Widget),e.expr[":"][a.toLowerCase()]=function(t){return!!e.data(t,a)},e[u]=e[u]||{},r=e[u][i],o=e[u][i]=function(e,i){return this._createWidget?(arguments.length&&this._createWidget(e,i),t):new o(e,i)},e.extend(o,r,{version:n.version,_proto:e.extend({},n),_childConstructors:[]}),h=new s,h.options=e.widget.extend({},h.options),e.each(n,function(i,n){return e.isFunction(n)?(l[i]=function(){var e=function(){return s.prototype[i].apply(this,arguments)},t=function(e){return s.prototype[i].apply(this,e)};return function(){var i,s=this._super,a=this._superApply;return this._super=e,this._superApply=t,i=n.apply(this,arguments),this._super=s,this._superApply=a,i}}(),t):(l[i]=n,t)}),o.prototype=e.widget.extend(h,{widgetEventPrefix:r?h.widgetEventPrefix:i},l,{constructor:o,namespace:u,widgetName:i,widgetFullName:a}),r?(e.each(r._childConstructors,function(t,i){var s=i.prototype;e.widget(s.namespace+"."+s.widgetName,o,i._proto)}),delete r._childConstructors):s._childConstructors.push(o),e.widget.bridge(i,o)},e.widget.extend=function(i){for(var n,a,r=s.call(arguments,1),o=0,h=r.length;h>o;o++)for(n in r[o])a=r[o][n],r[o].hasOwnProperty(n)&&a!==t&&(i[n]=e.isPlainObject(a)?e.isPlainObject(i[n])?e.widget.extend({},i[n],a):e.widget.extend({},a):a);return i},e.widget.bridge=function(i,n){var a=n.prototype.widgetFullName||i;e.fn[i]=function(r){var o="string"==typeof r,h=s.call(arguments,1),l=this;return r=!o&&h.length?e.widget.extend.apply(null,[r].concat(h)):r,o?this.each(function(){var s,n=e.data(this,a);return n?e.isFunction(n[r])&&"_"!==r.charAt(0)?(s=n[r].apply(n,h),s!==n&&s!==t?(l=s&&s.jquery?l.pushStack(s.get()):s,!1):t):e.error("no such method '"+r+"' for "+i+" widget instance"):e.error("cannot call methods on "+i+" prior to initialization; "+"attempted to call method '"+r+"'")}):this.each(function(){var t=e.data(this,a);t?t.option(r||{})._init():e.data(this,a,new n(r,this))}),l}},e.Widget=function(){},e.Widget._childConstructors=[],e.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{disabled:!1,create:null},_createWidget:function(t,s){s=e(s||this.defaultElement||this)[0],this.element=e(s),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.options=e.widget.extend({},this.options,this._getCreateOptions(),t),this.bindings=e(),this.hoverable=e(),this.focusable=e(),s!==this&&(e.data(s,this.widgetFullName,this),this._on(!0,this.element,{remove:function(e){e.target===s&&this.destroy()}}),this.document=e(s.style?s.ownerDocument:s.document||s),this.window=e(this.document[0].defaultView||this.document[0].parentWindow)),this._create(),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:e.noop,_getCreateEventData:e.noop,_create:e.noop,_init:e.noop,destroy:function(){this._destroy(),this.element.unbind(this.eventNamespace).removeData(this.widgetName).removeData(this.widgetFullName).removeData(e.camelCase(this.widgetFullName)),this.widget().unbind(this.eventNamespace).removeAttr("aria-disabled").removeClass(this.widgetFullName+"-disabled "+"ui-state-disabled"),this.bindings.unbind(this.eventNamespace),this.hoverable.removeClass("ui-state-hover"),this.focusable.removeClass("ui-state-focus")},_destroy:e.noop,widget:function(){return this.element},option:function(i,s){var n,a,r,o=i;if(0===arguments.length)return e.widget.extend({},this.options);if("string"==typeof i)if(o={},n=i.split("."),i=n.shift(),n.length){for(a=o[i]=e.widget.extend({},this.options[i]),r=0;n.length-1>r;r++)a[n[r]]=a[n[r]]||{},a=a[n[r]];if(i=n.pop(),s===t)return a[i]===t?null:a[i];a[i]=s}else{if(s===t)return this.options[i]===t?null:this.options[i];o[i]=s}return this._setOptions(o),this},_setOptions:function(e){var t;for(t in e)this._setOption(t,e[t]);return this},_setOption:function(e,t){return this.options[e]=t,"disabled"===e&&(this.widget().toggleClass(this.widgetFullName+"-disabled ui-state-disabled",!!t).attr("aria-disabled",t),this.hoverable.removeClass("ui-state-hover"),this.focusable.removeClass("ui-state-focus")),this},enable:function(){return this._setOption("disabled",!1)},disable:function(){return this._setOption("disabled",!0)},_on:function(i,s,n){var a,r=this;"boolean"!=typeof i&&(n=s,s=i,i=!1),n?(s=a=e(s),this.bindings=this.bindings.add(s)):(n=s,s=this.element,a=this.widget()),e.each(n,function(n,o){function h(){return i||r.options.disabled!==!0&&!e(this).hasClass("ui-state-disabled")?("string"==typeof o?r[o]:o).apply(r,arguments):t}"string"!=typeof o&&(h.guid=o.guid=o.guid||h.guid||e.guid++);var l=n.match(/^(\w+)\s*(.*)$/),u=l[1]+r.eventNamespace,c=l[2];c?a.delegate(c,u,h):s.bind(u,h)})},_off:function(e,t){t=(t||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,e.unbind(t).undelegate(t)},_delay:function(e,t){function i(){return("string"==typeof e?s[e]:e).apply(s,arguments)}var s=this;return setTimeout(i,t||0)},_hoverable:function(t){this.hoverable=this.hoverable.add(t),this._on(t,{mouseenter:function(t){e(t.currentTarget).addClass("ui-state-hover")},mouseleave:function(t){e(t.currentTarget).removeClass("ui-state-hover")}})},_focusable:function(t){this.focusable=this.focusable.add(t),this._on(t,{focusin:function(t){e(t.currentTarget).addClass("ui-state-focus")},focusout:function(t){e(t.currentTarget).removeClass("ui-state-focus")}})},_trigger:function(t,i,s){var n,a,r=this.options[t];if(s=s||{},i=e.Event(i),i.type=(t===this.widgetEventPrefix?t:this.widgetEventPrefix+t).toLowerCase(),i.target=this.element[0],a=i.originalEvent)for(n in a)n in i||(i[n]=a[n]);return this.element.trigger(i,s),!(e.isFunction(r)&&r.apply(this.element[0],[i].concat(s))===!1||i.isDefaultPrevented())}},e.each({show:"fadeIn",hide:"fadeOut"},function(t,i){e.Widget.prototype["_"+t]=function(s,n,a){"string"==typeof n&&(n={effect:n});var r,o=n?n===!0||"number"==typeof n?i:n.effect||i:t;n=n||{},"number"==typeof n&&(n={duration:n}),r=!e.isEmptyObject(n),n.complete=a,n.delay&&s.delay(n.delay),r&&e.effects&&e.effects.effect[o]?s[t](n):o!==t&&s[o]?s[o](n.duration,n.easing,a):s.queue(function(i){e(this)[t](),a&&a.call(s[0]),i()})}})})(jQuery);(function(e){var t=!1;e(document).mouseup(function(){t=!1}),e.widget("ui.mouse",{version:"1.10.2",options:{cancel:"input,textarea,button,select,option",distance:1,delay:0},_mouseInit:function(){var t=this;this.element.bind("mousedown."+this.widgetName,function(e){return t._mouseDown(e)}).bind("click."+this.widgetName,function(i){return!0===e.data(i.target,t.widgetName+".preventClickEvent")?(e.removeData(i.target,t.widgetName+".preventClickEvent"),i.stopImmediatePropagation(),!1):undefined}),this.started=!1},_mouseDestroy:function(){this.element.unbind("."+this.widgetName),this._mouseMoveDelegate&&e(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(i){if(!t){this._mouseStarted&&this._mouseUp(i),this._mouseDownEvent=i;var s=this,n=1===i.which,a="string"==typeof this.options.cancel&&i.target.nodeName?e(i.target).closest(this.options.cancel).length:!1;return n&&!a&&this._mouseCapture(i)?(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout(function(){s.mouseDelayMet=!0},this.options.delay)),this._mouseDistanceMet(i)&&this._mouseDelayMet(i)&&(this._mouseStarted=this._mouseStart(i)!==!1,!this._mouseStarted)?(i.preventDefault(),!0):(!0===e.data(i.target,this.widgetName+".preventClickEvent")&&e.removeData(i.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(e){return s._mouseMove(e)},this._mouseUpDelegate=function(e){return s._mouseUp(e)},e(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate),i.preventDefault(),t=!0,!0)):!0}},_mouseMove:function(t){return e.ui.ie&&(!document.documentMode||9>document.documentMode)&&!t.button?this._mouseUp(t):this._mouseStarted?(this._mouseDrag(t),t.preventDefault()):(this._mouseDistanceMet(t)&&this._mouseDelayMet(t)&&(this._mouseStarted=this._mouseStart(this._mouseDownEvent,t)!==!1,this._mouseStarted?this._mouseDrag(t):this._mouseUp(t)),!this._mouseStarted)},_mouseUp:function(t){return e(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,t.target===this._mouseDownEvent.target&&e.data(t.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(t)),!1},_mouseDistanceMet:function(e){return Math.max(Math.abs(this._mouseDownEvent.pageX-e.pageX),Math.abs(this._mouseDownEvent.pageY-e.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}})})(jQuery);(function(e){function t(e){return parseInt(e,10)||0}function i(e){return!isNaN(parseInt(e,10))}e.widget("ui.resizable",e.ui.mouse,{version:"1.10.2",widgetEventPrefix:"resize",options:{alsoResize:!1,animate:!1,animateDuration:"slow",animateEasing:"swing",aspectRatio:!1,autoHide:!1,containment:!1,ghost:!1,grid:!1,handles:"e,s,se",helper:!1,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:90,resize:null,start:null,stop:null},_create:function(){var t,i,s,n,a,o=this,r=this.options;if(this.element.addClass("ui-resizable"),e.extend(this,{_aspectRatio:!!r.aspectRatio,aspectRatio:r.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:r.helper||r.ghost||r.animate?r.helper||"ui-resizable-helper":null}),this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)&&(this.element.wrap(e("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.data("ui-resizable")),this.elementIsWrapper=!0,this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")}),this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0}),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css({margin:this.originalElement.css("margin")}),this._proportionallyResize()),this.handles=r.handles||(e(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),t=this.handles.split(","),this.handles={},i=0;t.length>i;i++)s=e.trim(t[i]),a="ui-resizable-"+s,n=e("<div class='ui-resizable-handle "+a+"'></div>"),n.css({zIndex:r.zIndex}),"se"===s&&n.addClass("ui-icon ui-icon-gripsmall-diagonal-se"),this.handles[s]=".ui-resizable-"+s,this.element.append(n);this._renderAxis=function(t){var i,s,n,a;t=t||this.element;for(i in this.handles)this.handles[i].constructor===String&&(this.handles[i]=e(this.handles[i],this.element).show()),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)&&(s=e(this.handles[i],this.element),a=/sw|ne|nw|se|n|s/.test(i)?s.outerHeight():s.outerWidth(),n=["padding",/ne|nw|n/.test(i)?"Top":/se|sw|s/.test(i)?"Bottom":/^e$/.test(i)?"Right":"Left"].join(""),t.css(n,a),this._proportionallyResize()),e(this.handles[i]).length},this._renderAxis(this.element),this._handles=e(".ui-resizable-handle",this.element).disableSelection(),this._handles.mouseover(function(){o.resizing||(this.className&&(n=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),o.axis=n&&n[1]?n[1]:"se")}),r.autoHide&&(this._handles.hide(),e(this.element).addClass("ui-resizable-autohide").mouseenter(function(){r.disabled||(e(this).removeClass("ui-resizable-autohide"),o._handles.show())}).mouseleave(function(){r.disabled||o.resizing||(e(this).addClass("ui-resizable-autohide"),o._handles.hide())})),this._mouseInit()},_destroy:function(){this._mouseDestroy();var t,i=function(t){e(t).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};return this.elementIsWrapper&&(i(this.element),t=this.element,this.originalElement.css({position:t.css("position"),width:t.outerWidth(),height:t.outerHeight(),top:t.css("top"),left:t.css("left")}).insertAfter(t),t.remove()),this.originalElement.css("resize",this.originalResizeStyle),i(this.originalElement),this},_mouseCapture:function(t){var i,s,n=!1;for(i in this.handles)s=e(this.handles[i])[0],(s===t.target||e.contains(s,t.target))&&(n=!0);return!this.options.disabled&&n},_mouseStart:function(i){var s,n,a,o=this.options,r=this.element.position(),h=this.element;return this.resizing=!0,/absolute/.test(h.css("position"))?h.css({position:"absolute",top:h.css("top"),left:h.css("left")}):h.is(".ui-draggable")&&h.css({position:"absolute",top:r.top,left:r.left}),this._renderProxy(),s=t(this.helper.css("left")),n=t(this.helper.css("top")),o.containment&&(s+=e(o.containment).scrollLeft()||0,n+=e(o.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:s,top:n},this.size=this._helper?{width:h.outerWidth(),height:h.outerHeight()}:{width:h.width(),height:h.height()},this.originalSize=this._helper?{width:h.outerWidth(),height:h.outerHeight()}:{width:h.width(),height:h.height()},this.originalPosition={left:s,top:n},this.sizeDiff={width:h.outerWidth()-h.width(),height:h.outerHeight()-h.height()},this.originalMousePosition={left:i.pageX,top:i.pageY},this.aspectRatio="number"==typeof o.aspectRatio?o.aspectRatio:this.originalSize.width/this.originalSize.height||1,a=e(".ui-resizable-"+this.axis).css("cursor"),e("body").css("cursor","auto"===a?this.axis+"-resize":a),h.addClass("ui-resizable-resizing"),this._propagate("start",i),!0},_mouseDrag:function(t){var i,s=this.helper,n={},a=this.originalMousePosition,o=this.axis,r=this.position.top,h=this.position.left,l=this.size.width,u=this.size.height,c=t.pageX-a.left||0,d=t.pageY-a.top||0,p=this._change[o];return p?(i=p.apply(this,[t,c,d]),this._updateVirtualBoundaries(t.shiftKey),(this._aspectRatio||t.shiftKey)&&(i=this._updateRatio(i,t)),i=this._respectSize(i,t),this._updateCache(i),this._propagate("resize",t),this.position.top!==r&&(n.top=this.position.top+"px"),this.position.left!==h&&(n.left=this.position.left+"px"),this.size.width!==l&&(n.width=this.size.width+"px"),this.size.height!==u&&(n.height=this.size.height+"px"),s.css(n),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),e.isEmptyObject(n)||this._trigger("resize",t,this.ui()),!1):!1},_mouseStop:function(t){this.resizing=!1;var i,s,n,a,o,r,h,l=this.options,u=this;return this._helper&&(i=this._proportionallyResizeElements,s=i.length&&/textarea/i.test(i[0].nodeName),n=s&&e.ui.hasScroll(i[0],"left")?0:u.sizeDiff.height,a=s?0:u.sizeDiff.width,o={width:u.helper.width()-a,height:u.helper.height()-n},r=parseInt(u.element.css("left"),10)+(u.position.left-u.originalPosition.left)||null,h=parseInt(u.element.css("top"),10)+(u.position.top-u.originalPosition.top)||null,l.animate||this.element.css(e.extend(o,{top:h,left:r})),u.helper.height(u.size.height),u.helper.width(u.size.width),this._helper&&!l.animate&&this._proportionallyResize()),e("body").css("cursor","auto"),this.element.removeClass("ui-resizable-resizing"),this._propagate("stop",t),this._helper&&this.helper.remove(),!1},_updateVirtualBoundaries:function(e){var t,s,n,a,o,r=this.options;o={minWidth:i(r.minWidth)?r.minWidth:0,maxWidth:i(r.maxWidth)?r.maxWidth:1/0,minHeight:i(r.minHeight)?r.minHeight:0,maxHeight:i(r.maxHeight)?r.maxHeight:1/0},(this._aspectRatio||e)&&(t=o.minHeight*this.aspectRatio,n=o.minWidth/this.aspectRatio,s=o.maxHeight*this.aspectRatio,a=o.maxWidth/this.aspectRatio,t>o.minWidth&&(o.minWidth=t),n>o.minHeight&&(o.minHeight=n),o.maxWidth>s&&(o.maxWidth=s),o.maxHeight>a&&(o.maxHeight=a)),this._vBoundaries=o},_updateCache:function(e){this.offset=this.helper.offset(),i(e.left)&&(this.position.left=e.left),i(e.top)&&(this.position.top=e.top),i(e.height)&&(this.size.height=e.height),i(e.width)&&(this.size.width=e.width)},_updateRatio:function(e){var t=this.position,s=this.size,n=this.axis;return i(e.height)?e.width=e.height*this.aspectRatio:i(e.width)&&(e.height=e.width/this.aspectRatio),"sw"===n&&(e.left=t.left+(s.width-e.width),e.top=null),"nw"===n&&(e.top=t.top+(s.height-e.height),e.left=t.left+(s.width-e.width)),e},_respectSize:function(e){var t=this._vBoundaries,s=this.axis,n=i(e.width)&&t.maxWidth&&t.maxWidth<e.width,a=i(e.height)&&t.maxHeight&&t.maxHeight<e.height,o=i(e.width)&&t.minWidth&&t.minWidth>e.width,r=i(e.height)&&t.minHeight&&t.minHeight>e.height,h=this.originalPosition.left+this.originalSize.width,l=this.position.top+this.size.height,u=/sw|nw|w/.test(s),c=/nw|ne|n/.test(s);return o&&(e.width=t.minWidth),r&&(e.height=t.minHeight),n&&(e.width=t.maxWidth),a&&(e.height=t.maxHeight),o&&u&&(e.left=h-t.minWidth),n&&u&&(e.left=h-t.maxWidth),r&&c&&(e.top=l-t.minHeight),a&&c&&(e.top=l-t.maxHeight),e.width||e.height||e.left||!e.top?e.width||e.height||e.top||!e.left||(e.left=null):e.top=null,e},_proportionallyResize:function(){if(this._proportionallyResizeElements.length){var e,t,i,s,n,a=this.helper||this.element;for(e=0;this._proportionallyResizeElements.length>e;e++){if(n=this._proportionallyResizeElements[e],!this.borderDif)for(this.borderDif=[],i=[n.css("borderTopWidth"),n.css("borderRightWidth"),n.css("borderBottomWidth"),n.css("borderLeftWidth")],s=[n.css("paddingTop"),n.css("paddingRight"),n.css("paddingBottom"),n.css("paddingLeft")],t=0;i.length>t;t++)this.borderDif[t]=(parseInt(i[t],10)||0)+(parseInt(s[t],10)||0);n.css({height:a.height()-this.borderDif[0]-this.borderDif[2]||0,width:a.width()-this.borderDif[1]-this.borderDif[3]||0})}}},_renderProxy:function(){var t=this.element,i=this.options;this.elementOffset=t.offset(),this._helper?(this.helper=this.helper||e("<div style='overflow:hidden;'></div>"),this.helper.addClass(this._helper).css({width:this.element.outerWidth()-1,height:this.element.outerHeight()-1,position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++i.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element},_change:{e:function(e,t){return{width:this.originalSize.width+t}},w:function(e,t){var i=this.originalSize,s=this.originalPosition;return{left:s.left+t,width:i.width-t}},n:function(e,t,i){var s=this.originalSize,n=this.originalPosition;return{top:n.top+i,height:s.height-i}},s:function(e,t,i){return{height:this.originalSize.height+i}},se:function(t,i,s){return e.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[t,i,s]))},sw:function(t,i,s){return e.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[t,i,s]))},ne:function(t,i,s){return e.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[t,i,s]))},nw:function(t,i,s){return e.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[t,i,s]))}},_propagate:function(t,i){e.ui.plugin.call(this,t,[i,this.ui()]),"resize"!==t&&this._trigger(t,i,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),e.ui.plugin.add("resizable","animate",{stop:function(t){var i=e(this).data("ui-resizable"),s=i.options,n=i._proportionallyResizeElements,a=n.length&&/textarea/i.test(n[0].nodeName),o=a&&e.ui.hasScroll(n[0],"left")?0:i.sizeDiff.height,r=a?0:i.sizeDiff.width,h={width:i.size.width-r,height:i.size.height-o},l=parseInt(i.element.css("left"),10)+(i.position.left-i.originalPosition.left)||null,u=parseInt(i.element.css("top"),10)+(i.position.top-i.originalPosition.top)||null;i.element.animate(e.extend(h,u&&l?{top:u,left:l}:{}),{duration:s.animateDuration,easing:s.animateEasing,step:function(){var s={width:parseInt(i.element.css("width"),10),height:parseInt(i.element.css("height"),10),top:parseInt(i.element.css("top"),10),left:parseInt(i.element.css("left"),10)};n&&n.length&&e(n[0]).css({width:s.width,height:s.height}),i._updateCache(s),i._propagate("resize",t)}})}}),e.ui.plugin.add("resizable","containment",{start:function(){var i,s,n,a,o,r,h,l=e(this).data("ui-resizable"),u=l.options,c=l.element,d=u.containment,p=d instanceof e?d.get(0):/parent/.test(d)?c.parent().get(0):d;p&&(l.containerElement=e(p),/document/.test(d)||d===document?(l.containerOffset={left:0,top:0},l.containerPosition={left:0,top:0},l.parentData={element:e(document),left:0,top:0,width:e(document).width(),height:e(document).height()||document.body.parentNode.scrollHeight}):(i=e(p),s=[],e(["Top","Right","Left","Bottom"]).each(function(e,n){s[e]=t(i.css("padding"+n))}),l.containerOffset=i.offset(),l.containerPosition=i.position(),l.containerSize={height:i.innerHeight()-s[3],width:i.innerWidth()-s[1]},n=l.containerOffset,a=l.containerSize.height,o=l.containerSize.width,r=e.ui.hasScroll(p,"left")?p.scrollWidth:o,h=e.ui.hasScroll(p)?p.scrollHeight:a,l.parentData={element:p,left:n.left,top:n.top,width:r,height:h}))},resize:function(t){var i,s,n,a,o=e(this).data("ui-resizable"),r=o.options,h=o.containerOffset,l=o.position,u=o._aspectRatio||t.shiftKey,c={top:0,left:0},d=o.containerElement;d[0]!==document&&/static/.test(d.css("position"))&&(c=h),l.left<(o._helper?h.left:0)&&(o.size.width=o.size.width+(o._helper?o.position.left-h.left:o.position.left-c.left),u&&(o.size.height=o.size.width/o.aspectRatio),o.position.left=r.helper?h.left:0),l.top<(o._helper?h.top:0)&&(o.size.height=o.size.height+(o._helper?o.position.top-h.top:o.position.top),u&&(o.size.width=o.size.height*o.aspectRatio),o.position.top=o._helper?h.top:0),o.offset.left=o.parentData.left+o.position.left,o.offset.top=o.parentData.top+o.position.top,i=Math.abs((o._helper?o.offset.left-c.left:o.offset.left-c.left)+o.sizeDiff.width),s=Math.abs((o._helper?o.offset.top-c.top:o.offset.top-h.top)+o.sizeDiff.height),n=o.containerElement.get(0)===o.element.parent().get(0),a=/relative|absolute/.test(o.containerElement.css("position")),n&&a&&(i-=o.parentData.left),i+o.size.width>=o.parentData.width&&(o.size.width=o.parentData.width-i,u&&(o.size.height=o.size.width/o.aspectRatio)),s+o.size.height>=o.parentData.height&&(o.size.height=o.parentData.height-s,u&&(o.size.width=o.size.height*o.aspectRatio))},stop:function(){var t=e(this).data("ui-resizable"),i=t.options,s=t.containerOffset,n=t.containerPosition,a=t.containerElement,o=e(t.helper),r=o.offset(),h=o.outerWidth()-t.sizeDiff.width,l=o.outerHeight()-t.sizeDiff.height;t._helper&&!i.animate&&/relative/.test(a.css("position"))&&e(this).css({left:r.left-n.left-s.left,width:h,height:l}),t._helper&&!i.animate&&/static/.test(a.css("position"))&&e(this).css({left:r.left-n.left-s.left,width:h,height:l})}}),e.ui.plugin.add("resizable","alsoResize",{start:function(){var t=e(this).data("ui-resizable"),i=t.options,s=function(t){e(t).each(function(){var t=e(this);t.data("ui-resizable-alsoresize",{width:parseInt(t.width(),10),height:parseInt(t.height(),10),left:parseInt(t.css("left"),10),top:parseInt(t.css("top"),10)})})};"object"!=typeof i.alsoResize||i.alsoResize.parentNode?s(i.alsoResize):i.alsoResize.length?(i.alsoResize=i.alsoResize[0],s(i.alsoResize)):e.each(i.alsoResize,function(e){s(e)})},resize:function(t,i){var s=e(this).data("ui-resizable"),n=s.options,a=s.originalSize,o=s.originalPosition,r={height:s.size.height-a.height||0,width:s.size.width-a.width||0,top:s.position.top-o.top||0,left:s.position.left-o.left||0},h=function(t,s){e(t).each(function(){var t=e(this),n=e(this).data("ui-resizable-alsoresize"),a={},o=s&&s.length?s:t.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];e.each(o,function(e,t){var i=(n[t]||0)+(r[t]||0);i&&i>=0&&(a[t]=i||null)}),t.css(a)})};"object"!=typeof n.alsoResize||n.alsoResize.nodeType?h(n.alsoResize):e.each(n.alsoResize,function(e,t){h(e,t)})},stop:function(){e(this).removeData("resizable-alsoresize")}}),e.ui.plugin.add("resizable","ghost",{start:function(){var t=e(this).data("ui-resizable"),i=t.options,s=t.size;t.ghost=t.originalElement.clone(),t.ghost.css({opacity:.25,display:"block",position:"relative",height:s.height,width:s.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass("string"==typeof i.ghost?i.ghost:""),t.ghost.appendTo(t.helper)},resize:function(){var t=e(this).data("ui-resizable");t.ghost&&t.ghost.css({position:"relative",height:t.size.height,width:t.size.width})},stop:function(){var t=e(this).data("ui-resizable");t.ghost&&t.helper&&t.helper.get(0).removeChild(t.ghost.get(0))}}),e.ui.plugin.add("resizable","grid",{resize:function(){var t=e(this).data("ui-resizable"),i=t.options,s=t.size,n=t.originalSize,a=t.originalPosition,o=t.axis,r="number"==typeof i.grid?[i.grid,i.grid]:i.grid,h=r[0]||1,l=r[1]||1,u=Math.round((s.width-n.width)/h)*h,c=Math.round((s.height-n.height)/l)*l,d=n.width+u,p=n.height+c,f=i.maxWidth&&d>i.maxWidth,m=i.maxHeight&&p>i.maxHeight,g=i.minWidth&&i.minWidth>d,v=i.minHeight&&i.minHeight>p;i.grid=r,g&&(d+=h),v&&(p+=l),f&&(d-=h),m&&(p-=l),/^(se|s|e)$/.test(o)?(t.size.width=d,t.size.height=p):/^(ne)$/.test(o)?(t.size.width=d,t.size.height=p,t.position.top=a.top-c):/^(sw)$/.test(o)?(t.size.width=d,t.size.height=p,t.position.left=a.left-u):(t.size.width=d,t.size.height=p,t.position.top=a.top-c,t.position.left=a.left-u)}})})(jQuery);
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/cmd/present/static/notes.css b/vendor/golang.org/x/tools/cmd/present/static/notes.css
new file mode 100644
index 0000000..0b44583
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/notes.css
@@ -0,0 +1,32 @@
+p {
+  margin: 10px;
+}
+
+#presenter-slides {
+  display: block;
+  margin-top: -10px;
+  margin-left: -17px;
+  position: fixed;
+  border: 0;
+  width : 146%;
+  height: 750px;
+
+  transform: scale(0.7, 0.7);
+  transform-origin: top left;
+  -moz-transform: scale(0.7);
+  -moz-transform-origin: top left;
+  -o-transform: scale(0.7);
+  -o-transform-origin: top left;
+  -webkit-transform: scale(0.7);
+  -webkit-transform-origin: top left;
+}
+
+#presenter-notes {
+  margin-top: -180px;
+  font-family: 'Open Sans', Arial, sans-serif;
+  height: 30%;
+  width: 100%;
+  overflow: scroll;
+  position: fixed;
+  top: 706px;
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/static/notes.js b/vendor/golang.org/x/tools/cmd/present/static/notes.js
new file mode 100644
index 0000000..a19f21e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/notes.js
@@ -0,0 +1,161 @@
+// 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.
+
+// Store child window object which will display slides with notes
+var notesWindow = null;
+
+var isParentWindow = window.parent == window;
+
+// When parent window closes, clear storage and close child window
+if (isParentWindow) {
+  window.onbeforeunload = function() {
+    localStorage.clear();
+    if (notesWindow) notesWindow.close();
+  }
+};
+
+function toggleNotesWindow() {
+  if (!isParentWindow) return;
+  if (notesWindow) {
+    notesWindow.close();
+    notesWindow = null;
+    return;
+  }
+
+  initNotes();
+};
+
+function initNotes() {
+  notesWindow = window.open('', '', 'width=1000,height=700');
+  var w = notesWindow;
+  var slidesUrl = window.location.href;
+
+  var curSlide = parseInt(localStorage.getItem('destSlide'), 10);
+  var formattedNotes = '';
+  var section = sections[curSlide - 1];
+  // curSlide is 0 when initialized from the first page of slides.
+  // Check if section is valid before retrieving Notes.
+  if (section) {
+    formattedNotes = formatNotes(section.Notes);
+  } else if (curSlide == 0) {
+    formattedNotes = formatNotes(titleNotes);
+  }
+
+  // Hack to apply css. Requires existing html on notesWindow.
+  w.document.write("<div style='display:none;'></div>");
+
+  w.document.title = window.document.title;
+
+  var slides = w.document.createElement('iframe');
+  slides.id = 'presenter-slides';
+  slides.src = slidesUrl;
+  w.document.body.appendChild(slides);
+  // setTimeout needed for Firefox
+  setTimeout(function() {
+    slides.focus();
+  }, 100);
+
+  var notes = w.document.createElement('div');
+  notes.id = 'presenter-notes';
+  notes.innerHTML = formattedNotes;
+  w.document.body.appendChild(notes);
+
+  w.document.close();
+
+  function addPresenterNotesStyle() {
+    var el = w.document.createElement('link');
+    el.rel = 'stylesheet';
+    el.type = 'text/css';
+    el.href = PERMANENT_URL_PREFIX + 'notes.css';
+    w.document.body.appendChild(el);
+    w.document.querySelector('head').appendChild(el);
+  }
+
+  addPresenterNotesStyle();
+
+  // Add listener on notesWindow to update notes when triggered from
+  // parent window
+  w.addEventListener('storage', updateNotes, false);
+};
+
+function formatNotes(notes) {
+  var formattedNotes = '';
+  if (notes) {
+    for (var i = 0; i < notes.length; i++) {
+      formattedNotes = formattedNotes + '<p>' + notes[i] + '</p>';
+    }
+  }
+  return formattedNotes;
+};
+
+function updateNotes() {
+  // When triggered from parent window, notesWindow is null
+  // The storage event listener on notesWindow will update notes
+  if (!notesWindow) return;
+  var destSlide = parseInt(localStorage.getItem('destSlide'), 10);
+  var section = sections[destSlide - 1];
+  var el = notesWindow.document.getElementById('presenter-notes');
+
+  if (!el) return;
+
+  if (section && section.Notes) {
+    el.innerHTML = formatNotes(section.Notes);
+  } else if (destSlide == 0) {
+    el.innerHTML = formatNotes(titleNotes);
+  }  else {
+    el.innerHTML = '';
+  }
+};
+
+/* Playground syncing */
+
+// When presenter notes are enabled, playground click handlers are
+// stored here to sync click events on the correct playground
+var playgroundHandlers = {onRun: [], onKill: [], onClose: []};
+
+function updatePlay(e) {
+	var i = localStorage.getItem('play-index');
+
+	switch (e.key) {
+		case 'play-index':
+			return;
+		case 'play-action':
+			// Sync 'run', 'kill', 'close' actions
+			var action = localStorage.getItem('play-action');
+			playgroundHandlers[action][i](e);
+			return;
+		case 'play-code':
+			// Sync code editing
+			var play = document.querySelectorAll('div.playground')[i];
+			play.innerHTML = localStorage.getItem('play-code');
+			return;
+		case 'output-style':
+			// Sync resizing of playground output
+			var out = document.querySelectorAll('.output')[i];
+			out.style = localStorage.getItem('output-style');
+			return;
+	}
+};
+
+// Reset 'run', 'kill', 'close' storage items when synced
+// so that successive actions can be synced correctly
+function updatePlayStorage(action, index, e) {
+	localStorage.setItem('play-index', index);
+
+	if (localStorage.getItem('play-action') === action) {
+		// We're the receiving window, and the message has been received
+		localStorage.removeItem('play-action');
+	} else {
+		// We're the triggering window, send the message
+		localStorage.setItem('play-action', action);
+	}
+
+	if (action === 'onRun') {
+		if (localStorage.getItem('play-shiftKey') === 'true') {
+			localStorage.removeItem('play-shiftKey');
+		} else if (e.shiftKey) {
+			localStorage.setItem('play-shiftKey', e.shiftKey);
+		}
+	}
+};
diff --git a/vendor/golang.org/x/tools/cmd/present/static/slides.js b/vendor/golang.org/x/tools/cmd/present/static/slides.js
new file mode 100644
index 0000000..df10647
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/slides.js
@@ -0,0 +1,612 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+var PERMANENT_URL_PREFIX = '/static/';
+
+var SLIDE_CLASSES = ['far-past', 'past', 'current', 'next', 'far-next'];
+
+var PM_TOUCH_SENSITIVITY = 15;
+
+var curSlide;
+
+/* ---------------------------------------------------------------------- */
+/* classList polyfill by Eli Grey
+ * (http://purl.eligrey.com/github/classList.js/blob/master/classList.js) */
+
+if (typeof document !== 'undefined' && !('classList' in document.createElement('a'))) {
+
+(function (view) {
+
+var
+    classListProp = 'classList'
+  , protoProp = 'prototype'
+  , elemCtrProto = (view.HTMLElement || view.Element)[protoProp]
+  , objCtr = Object
+    strTrim = String[protoProp].trim || function () {
+    return this.replace(/^\s+|\s+$/g, '');
+  }
+  , arrIndexOf = Array[protoProp].indexOf || function (item) {
+    for (var i = 0, len = this.length; i < len; i++) {
+      if (i in this && this[i] === item) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  // Vendors: please allow content code to instantiate DOMExceptions
+  , DOMEx = function (type, message) {
+    this.name = type;
+    this.code = DOMException[type];
+    this.message = message;
+  }
+  , checkTokenAndGetIndex = function (classList, token) {
+    if (token === '') {
+      throw new DOMEx(
+          'SYNTAX_ERR'
+        , 'An invalid or illegal string was specified'
+      );
+    }
+    if (/\s/.test(token)) {
+      throw new DOMEx(
+          'INVALID_CHARACTER_ERR'
+        , 'String contains an invalid character'
+      );
+    }
+    return arrIndexOf.call(classList, token);
+  }
+  , ClassList = function (elem) {
+    var
+        trimmedClasses = strTrim.call(elem.className)
+      , classes = trimmedClasses ? trimmedClasses.split(/\s+/) : []
+    ;
+    for (var i = 0, len = classes.length; i < len; i++) {
+      this.push(classes[i]);
+    }
+    this._updateClassName = function () {
+      elem.className = this.toString();
+    };
+  }
+  , classListProto = ClassList[protoProp] = []
+  , classListGetter = function () {
+    return new ClassList(this);
+  }
+;
+// Most DOMException implementations don't allow calling DOMException's toString()
+// on non-DOMExceptions. Error's toString() is sufficient here.
+DOMEx[protoProp] = Error[protoProp];
+classListProto.item = function (i) {
+  return this[i] || null;
+};
+classListProto.contains = function (token) {
+  token += '';
+  return checkTokenAndGetIndex(this, token) !== -1;
+};
+classListProto.add = function (token) {
+  token += '';
+  if (checkTokenAndGetIndex(this, token) === -1) {
+    this.push(token);
+    this._updateClassName();
+  }
+};
+classListProto.remove = function (token) {
+  token += '';
+  var index = checkTokenAndGetIndex(this, token);
+  if (index !== -1) {
+    this.splice(index, 1);
+    this._updateClassName();
+  }
+};
+classListProto.toggle = function (token) {
+  token += '';
+  if (checkTokenAndGetIndex(this, token) === -1) {
+    this.add(token);
+  } else {
+    this.remove(token);
+  }
+};
+classListProto.toString = function () {
+  return this.join(' ');
+};
+
+if (objCtr.defineProperty) {
+  var classListPropDesc = {
+      get: classListGetter
+    , enumerable: true
+    , configurable: true
+  };
+  try {
+    objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
+  } catch (ex) { // IE 8 doesn't support enumerable:true
+    if (ex.number === -0x7FF5EC54) {
+      classListPropDesc.enumerable = false;
+      objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
+    }
+  }
+} else if (objCtr[protoProp].__defineGetter__) {
+  elemCtrProto.__defineGetter__(classListProp, classListGetter);
+}
+
+}(self));
+
+}
+/* ---------------------------------------------------------------------- */
+
+/* Slide movement */
+
+function hideHelpText() {
+  document.getElementById('help').style.display = 'none';
+};
+
+function getSlideEl(no) {
+  if ((no < 0) || (no >= slideEls.length)) {
+    return null;
+  } else {
+    return slideEls[no];
+  }
+};
+
+function updateSlideClass(slideNo, className) {
+  var el = getSlideEl(slideNo);
+
+  if (!el) {
+    return;
+  }
+
+  if (className) {
+    el.classList.add(className);
+  }
+
+  for (var i in SLIDE_CLASSES) {
+    if (className != SLIDE_CLASSES[i]) {
+      el.classList.remove(SLIDE_CLASSES[i]);
+    }
+  }
+};
+
+function updateSlides() {
+  if (window.trackPageview) window.trackPageview();
+
+  for (var i = 0; i < slideEls.length; i++) {
+    switch (i) {
+      case curSlide - 2:
+        updateSlideClass(i, 'far-past');
+        break;
+      case curSlide - 1:
+        updateSlideClass(i, 'past');
+        break;
+      case curSlide:
+        updateSlideClass(i, 'current');
+        break;
+      case curSlide + 1:
+        updateSlideClass(i, 'next');
+        break;
+      case curSlide + 2:
+        updateSlideClass(i, 'far-next');
+        break;
+      default:
+        updateSlideClass(i);
+        break;
+    }
+  }
+
+  triggerLeaveEvent(curSlide - 1);
+  triggerEnterEvent(curSlide);
+
+  window.setTimeout(function() {
+    // Hide after the slide
+    disableSlideFrames(curSlide - 2);
+  }, 301);
+
+  enableSlideFrames(curSlide - 1);
+  enableSlideFrames(curSlide + 2);
+
+  updateHash();
+};
+
+function prevSlide() {
+  hideHelpText();
+  if (curSlide > 0) {
+    curSlide--;
+
+    updateSlides();
+  }
+
+  if (notesEnabled) localStorage.setItem('destSlide', curSlide);
+};
+
+function nextSlide() {
+  hideHelpText();
+  if (curSlide < slideEls.length - 1) {
+    curSlide++;
+
+    updateSlides();
+  }
+
+  if (notesEnabled) localStorage.setItem('destSlide', curSlide);
+};
+
+/* Slide events */
+
+function triggerEnterEvent(no) {
+  var el = getSlideEl(no);
+  if (!el) {
+    return;
+  }
+
+  var onEnter = el.getAttribute('onslideenter');
+  if (onEnter) {
+    new Function(onEnter).call(el);
+  }
+
+  var evt = document.createEvent('Event');
+  evt.initEvent('slideenter', true, true);
+  evt.slideNumber = no + 1; // Make it readable
+
+  el.dispatchEvent(evt);
+};
+
+function triggerLeaveEvent(no) {
+  var el = getSlideEl(no);
+  if (!el) {
+    return;
+  }
+
+  var onLeave = el.getAttribute('onslideleave');
+  if (onLeave) {
+    new Function(onLeave).call(el);
+  }
+
+  var evt = document.createEvent('Event');
+  evt.initEvent('slideleave', true, true);
+  evt.slideNumber = no + 1; // Make it readable
+
+  el.dispatchEvent(evt);
+};
+
+/* Touch events */
+
+function handleTouchStart(event) {
+  if (event.touches.length == 1) {
+    touchDX = 0;
+    touchDY = 0;
+
+    touchStartX = event.touches[0].pageX;
+    touchStartY = event.touches[0].pageY;
+
+    document.body.addEventListener('touchmove', handleTouchMove, true);
+    document.body.addEventListener('touchend', handleTouchEnd, true);
+  }
+};
+
+function handleTouchMove(event) {
+  if (event.touches.length > 1) {
+    cancelTouch();
+  } else {
+    touchDX = event.touches[0].pageX - touchStartX;
+    touchDY = event.touches[0].pageY - touchStartY;
+    event.preventDefault();
+  }
+};
+
+function handleTouchEnd(event) {
+  var dx = Math.abs(touchDX);
+  var dy = Math.abs(touchDY);
+
+  if ((dx > PM_TOUCH_SENSITIVITY) && (dy < (dx * 2 / 3))) {
+    if (touchDX > 0) {
+      prevSlide();
+    } else {
+      nextSlide();
+    }
+  }
+
+  cancelTouch();
+};
+
+function cancelTouch() {
+  document.body.removeEventListener('touchmove', handleTouchMove, true);
+  document.body.removeEventListener('touchend', handleTouchEnd, true);
+};
+
+/* Preloading frames */
+
+function disableSlideFrames(no) {
+  var el = getSlideEl(no);
+  if (!el) {
+    return;
+  }
+
+  var frames = el.getElementsByTagName('iframe');
+  for (var i = 0, frame; frame = frames[i]; i++) {
+    disableFrame(frame);
+  }
+};
+
+function enableSlideFrames(no) {
+  var el = getSlideEl(no);
+  if (!el) {
+    return;
+  }
+
+  var frames = el.getElementsByTagName('iframe');
+  for (var i = 0, frame; frame = frames[i]; i++) {
+    enableFrame(frame);
+  }
+};
+
+function disableFrame(frame) {
+  frame.src = 'about:blank';
+};
+
+function enableFrame(frame) {
+  var src = frame._src;
+
+  if (frame.src != src && src != 'about:blank') {
+    frame.src = src;
+  }
+};
+
+function setupFrames() {
+  var frames = document.querySelectorAll('iframe');
+  for (var i = 0, frame; frame = frames[i]; i++) {
+    frame._src = frame.src;
+    disableFrame(frame);
+  }
+
+  enableSlideFrames(curSlide);
+  enableSlideFrames(curSlide + 1);
+  enableSlideFrames(curSlide + 2);
+};
+
+function setupInteraction() {
+  /* Clicking and tapping */
+
+  var el = document.createElement('div');
+  el.className = 'slide-area';
+  el.id = 'prev-slide-area';
+  el.addEventListener('click', prevSlide, false);
+  document.querySelector('section.slides').appendChild(el);
+
+  var el = document.createElement('div');
+  el.className = 'slide-area';
+  el.id = 'next-slide-area';
+  el.addEventListener('click', nextSlide, false);
+  document.querySelector('section.slides').appendChild(el);
+
+  /* Swiping */
+
+  document.body.addEventListener('touchstart', handleTouchStart, false);
+}
+
+/* Hash functions */
+
+function getCurSlideFromHash() {
+  var slideNo = parseInt(location.hash.substr(1));
+
+  if (slideNo) {
+    curSlide = slideNo - 1;
+  } else {
+    curSlide = 0;
+  }
+};
+
+function updateHash() {
+  location.replace('#' + (curSlide + 1));
+};
+
+/* Event listeners */
+
+function handleBodyKeyDown(event) {
+  // If we're in a code element, only handle pgup/down.
+  var inCode = event.target.classList.contains('code');
+
+  switch (event.keyCode) {
+    case 78: // 'N' opens presenter notes window
+      if (!inCode && notesEnabled) toggleNotesWindow();
+      break;
+    case 72: // 'H' hides the help text
+    case 27: // escape key
+      if (!inCode) hideHelpText();
+      break;
+
+    case 39: // right arrow
+    case 13: // Enter
+    case 32: // space
+      if (inCode) break;
+    case 34: // PgDn
+      nextSlide();
+      event.preventDefault();
+      break;
+
+    case 37: // left arrow
+    case 8: // Backspace
+      if (inCode) break;
+    case 33: // PgUp
+      prevSlide();
+      event.preventDefault();
+      break;
+
+    case 40: // down arrow
+      if (inCode) break;
+      nextSlide();
+      event.preventDefault();
+      break;
+
+    case 38: // up arrow
+      if (inCode) break;
+      prevSlide();
+      event.preventDefault();
+      break;
+  }
+};
+
+function scaleSmallViewports() {
+  var el = document.querySelector('.slides');
+  var transform = '';
+  var sWidthPx = 1250;
+  var sHeightPx = 750;
+  var sAspectRatio = sWidthPx / sHeightPx;
+  var wAspectRatio = window.innerWidth / window.innerHeight;
+
+  if (wAspectRatio <= sAspectRatio && window.innerWidth < sWidthPx) {
+    transform = 'scale(' + window.innerWidth / sWidthPx + ')';
+  } else if (window.innerHeight < sHeightPx) {
+    transform = 'scale(' + window.innerHeight / sHeightPx + ')';
+  }
+  el.style.transform = transform;
+}
+
+function addEventListeners() {
+  document.addEventListener('keydown', handleBodyKeyDown, false);
+  var resizeTimeout;
+  window.addEventListener('resize', function() {
+    // throttle resize events
+    window.clearTimeout(resizeTimeout);
+    resizeTimeout = window.setTimeout(function() {
+      resizeTimeout = null;
+      scaleSmallViewports();
+    }, 50);
+  });
+}
+
+/* Initialization */
+
+function addFontStyle() {
+  var el = document.createElement('link');
+  el.rel = 'stylesheet';
+  el.type = 'text/css';
+  el.href = '//fonts.googleapis.com/css?family=' +
+            'Open+Sans:regular,semibold,italic,italicsemibold|Droid+Sans+Mono';
+
+  document.body.appendChild(el);
+};
+
+function addGeneralStyle() {
+  var el = document.createElement('link');
+  el.rel = 'stylesheet';
+  el.type = 'text/css';
+  el.href = PERMANENT_URL_PREFIX + 'styles.css';
+  document.body.appendChild(el);
+
+  var el = document.createElement('meta');
+  el.name = 'viewport';
+  el.content = 'width=device-width,height=device-height,initial-scale=1';
+  document.querySelector('head').appendChild(el);
+
+  var el = document.createElement('meta');
+  el.name = 'apple-mobile-web-app-capable';
+  el.content = 'yes';
+  document.querySelector('head').appendChild(el);
+
+  scaleSmallViewports();
+};
+
+function handleDomLoaded() {
+  slideEls = document.querySelectorAll('section.slides > article');
+
+  setupFrames();
+
+  addFontStyle();
+  addGeneralStyle();
+  addEventListeners();
+
+  updateSlides();
+
+  setupInteraction();
+
+  if (window.location.hostname == 'localhost' || window.location.hostname == '127.0.0.1' || window.location.hostname == '::1') {
+    hideHelpText();
+  }
+
+  document.body.classList.add('loaded');
+
+  setupNotesSync();
+};
+
+function initialize() {
+  getCurSlideFromHash();
+
+  if (window['_DEBUG']) {
+    PERMANENT_URL_PREFIX = '../';
+  }
+
+  if (window['_DCL']) {
+    handleDomLoaded();
+  } else {
+    document.addEventListener('DOMContentLoaded', handleDomLoaded, false);
+  }
+}
+
+// If ?debug exists then load the script relative instead of absolute
+if (!window['_DEBUG'] && document.location.href.indexOf('?debug') !== -1) {
+  document.addEventListener('DOMContentLoaded', function() {
+    // Avoid missing the DomContentLoaded event
+    window['_DCL'] = true
+  }, false);
+
+  window['_DEBUG'] = true;
+  var script = document.createElement('script');
+  script.type = 'text/javascript';
+  script.src = '../slides.js';
+  var s = document.getElementsByTagName('script')[0];
+  s.parentNode.insertBefore(script, s);
+
+  // Remove this script
+  s.parentNode.removeChild(s);
+} else {
+  initialize();
+}
+
+/* Synchronize windows when notes are enabled */
+
+function setupNotesSync() {
+  if (!notesEnabled) return;
+
+  function setupPlayResizeSync() {
+    var out = document.getElementsByClassName('output');
+    for (var i = 0; i < out.length; i++) {
+      $(out[i]).bind('resize', function(event) {
+        if ($(event.target).hasClass('ui-resizable')) {
+          localStorage.setItem('play-index', i);
+          localStorage.setItem('output-style', out[i].style.cssText);
+        }
+      })
+    }
+  };
+  function setupPlayCodeSync() {
+    var play = document.querySelectorAll('div.playground');
+    for (var i = 0; i < play.length; i++) {
+      play[i].addEventListener('input', inputHandler, false);
+
+      function inputHandler(e) {
+        localStorage.setItem('play-index', i);
+        localStorage.setItem('play-code', e.target.innerHTML);
+      }
+    }
+  };
+
+  setupPlayCodeSync();
+  setupPlayResizeSync();
+  localStorage.setItem('destSlide', curSlide);
+  window.addEventListener('storage', updateOtherWindow, false);
+}
+
+// An update to local storage is caught only by the other window
+// The triggering window does not handle any sync actions
+function updateOtherWindow(e) {
+  // Ignore remove storage events which are not meant to update the other window
+  var isRemoveStorageEvent = !e.newValue;
+  if (isRemoveStorageEvent) return;
+
+  var destSlide = localStorage.getItem('destSlide');
+  while (destSlide > curSlide) {
+    nextSlide();
+  }
+  while (destSlide < curSlide) {
+    prevSlide();
+  }
+
+  updatePlay(e);
+  updateNotes();
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/static/styles.css b/vendor/golang.org/x/tools/cmd/present/static/styles.css
new file mode 100644
index 0000000..2d8d354
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/static/styles.css
@@ -0,0 +1,534 @@
+@media screen {
+  /* Framework */
+  html {
+    height: 100%;
+  }
+
+  body {
+    margin: 0;
+    padding: 0;
+
+    display: block !important;
+
+    height: 100%;
+    height: 100vh;
+
+    overflow: hidden;
+
+    background: rgb(215, 215, 215);
+    background: -o-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+    background: -moz-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+    background: -webkit-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+    background: -webkit-gradient(radial, 50% 50%, 0, 50% 50%, 500, from(rgb(240, 240, 240)), to(rgb(190, 190, 190)));
+
+    -webkit-font-smoothing: antialiased;
+  }
+
+  .slides {
+    width: 100%;
+    height: 100%;
+    left: 0;
+    top: 0;
+
+    position: absolute;
+
+    -webkit-transform: translate3d(0, 0, 0);
+  }
+
+  .slides > article {
+    display: block;
+
+    position: absolute;
+    overflow: hidden;
+
+    width: 900px;
+    height: 700px;
+
+    left: 50%;
+    top: 50%;
+
+    margin-left: -450px;
+    margin-top: -350px;
+
+    padding: 40px 60px;
+
+    box-sizing: border-box;
+    -o-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    -webkit-box-sizing: border-box;
+
+    border-radius: 10px;
+    -o-border-radius: 10px;
+    -moz-border-radius: 10px;
+    -webkit-border-radius: 10px;
+
+    background-color: white;
+
+    border: 1px solid rgba(0, 0, 0, .3);
+
+    transition: transform .3s ease-out;
+    -o-transition: -o-transform .3s ease-out;
+    -moz-transition: -moz-transform .3s ease-out;
+    -webkit-transition: -webkit-transform .3s ease-out;
+  }
+  .slides.layout-widescreen > article {
+    margin-left: -550px;
+    width: 1100px;
+  }
+  .slides.layout-faux-widescreen > article {
+    margin-left: -550px;
+    width: 1100px;
+
+    padding: 40px 160px;
+  }
+
+  .slides.layout-widescreen > article:not(.nobackground):not(.biglogo),
+  .slides.layout-faux-widescreen > article:not(.nobackground):not(.biglogo) {
+    background-position-x: 0, 840px;
+  }
+
+  /* Clickable/tappable areas */
+
+  .slide-area {
+    z-index: 1000;
+
+    position: absolute;
+    left: 0;
+    top: 0;
+    width: 150px;
+    height: 700px;
+
+    left: 50%;
+    top: 50%;
+
+    cursor: pointer;
+    margin-top: -350px;
+
+    tap-highlight-color: transparent;
+    -o-tap-highlight-color: transparent;
+    -moz-tap-highlight-color: transparent;
+    -webkit-tap-highlight-color: transparent;
+  }
+  #prev-slide-area {
+    margin-left: -550px;
+  }
+  #next-slide-area {
+    margin-left: 400px;
+  }
+  .slides.layout-widescreen #prev-slide-area,
+  .slides.layout-faux-widescreen #prev-slide-area {
+    margin-left: -650px;
+  }
+  .slides.layout-widescreen #next-slide-area,
+  .slides.layout-faux-widescreen #next-slide-area {
+    margin-left: 500px;
+  }
+
+  /* Slides */
+
+  .slides > article {
+    display: none;
+  }
+  .slides > article.far-past {
+    display: block;
+    transform: translate(-2040px);
+    -o-transform: translate(-2040px);
+    -moz-transform: translate(-2040px);
+    -webkit-transform: translate3d(-2040px, 0, 0);
+  }
+  .slides > article.past {
+    display: block;
+    transform: translate(-1020px);
+    -o-transform: translate(-1020px);
+    -moz-transform: translate(-1020px);
+    -webkit-transform: translate3d(-1020px, 0, 0);
+  }
+  .slides > article.current {
+    display: block;
+    transform: translate(0);
+    -o-transform: translate(0);
+    -moz-transform: translate(0);
+    -webkit-transform: translate3d(0, 0, 0);
+  }
+  .slides > article.next {
+    display: block;
+    transform: translate(1020px);
+    -o-transform: translate(1020px);
+    -moz-transform: translate(1020px);
+    -webkit-transform: translate3d(1020px, 0, 0);
+  }
+  .slides > article.far-next {
+    display: block;
+    transform: translate(2040px);
+    -o-transform: translate(2040px);
+    -moz-transform: translate(2040px);
+    -webkit-transform: translate3d(2040px, 0, 0);
+  }
+
+  .slides.layout-widescreen > article.far-past,
+  .slides.layout-faux-widescreen > article.far-past {
+    display: block;
+    transform: translate(-2260px);
+    -o-transform: translate(-2260px);
+    -moz-transform: translate(-2260px);
+    -webkit-transform: translate3d(-2260px, 0, 0);
+  }
+  .slides.layout-widescreen > article.past,
+  .slides.layout-faux-widescreen > article.past {
+    display: block;
+    transform: translate(-1130px);
+    -o-transform: translate(-1130px);
+    -moz-transform: translate(-1130px);
+    -webkit-transform: translate3d(-1130px, 0, 0);
+  }
+  .slides.layout-widescreen > article.current,
+  .slides.layout-faux-widescreen > article.current {
+    display: block;
+    transform: translate(0);
+    -o-transform: translate(0);
+    -moz-transform: translate(0);
+    -webkit-transform: translate3d(0, 0, 0);
+  }
+  .slides.layout-widescreen > article.next,
+  .slides.layout-faux-widescreen > article.next {
+    display: block;
+    transform: translate(1130px);
+    -o-transform: translate(1130px);
+    -moz-transform: translate(1130px);
+    -webkit-transform: translate3d(1130px, 0, 0);
+  }
+  .slides.layout-widescreen > article.far-next,
+  .slides.layout-faux-widescreen > article.far-next {
+    display: block;
+    transform: translate(2260px);
+    -o-transform: translate(2260px);
+    -moz-transform: translate(2260px);
+    -webkit-transform: translate3d(2260px, 0, 0);
+  }
+}
+
+@media print {
+  /* Set page layout */
+  @page {
+    size: A4 landscape;
+  }
+
+  body {
+    display: block !important;
+  }
+
+  .slides > article {
+    display: block;
+
+    position: relative;
+
+    page-break-inside: never;
+    page-break-after: always;
+
+    overflow: hidden;
+  }
+
+  h2 {
+    position: static !important;
+    margin-top: 400px !important;
+    margin-bottom: 100px !important;
+  }
+
+  div.code {
+    background: rgb(240, 240, 240);
+  }
+
+  /* Add explicit links */
+  a:link:after, a:visited:after {
+   content: " (" attr(href) ") ";
+   font-size: 50%;
+  }
+
+  #help {
+    display: none;
+    visibility: hidden;
+  }
+}
+
+/* Styles for slides */
+
+.slides > article {
+  font-family: 'Open Sans', Arial, sans-serif;
+
+  color: black;
+  text-shadow: 0 1px 1px rgba(0, 0, 0, .1);
+
+  font-size: 26px;
+  line-height: 36px;
+
+  letter-spacing: -1px;
+}
+
+b {
+  font-weight: 600;
+}
+
+a {
+  color: rgb(0, 102, 204);
+  text-decoration: none;
+}
+a:visited {
+  color: rgba(0, 102, 204, .75);
+}
+a:hover {
+  color: black;
+}
+
+p {
+  margin: 0;
+  padding: 0;
+
+  margin-top: 20px;
+}
+p:first-child {
+  margin-top: 0;
+}
+
+h1 {
+  font-size: 60px;
+  line-height: 60px;
+
+  padding: 0;
+  margin: 0;
+  margin-top: 200px;
+  margin-bottom: 5px;
+  padding-right: 40px;
+
+  font-weight: 600;
+
+  letter-spacing: -3px;
+
+  color: rgb(51, 51, 51);
+}
+
+h2 {
+  font-size: 45px;
+  line-height: 45px;
+
+  position: absolute;
+  bottom: 150px;
+
+  padding: 0;
+  margin: 0;
+  padding-right: 40px;
+
+  font-weight: 600;
+
+  letter-spacing: -2px;
+
+  color: rgb(51, 51, 51);
+}
+
+h3 {
+  font-size: 30px;
+  line-height: 36px;
+
+  padding: 0;
+  margin: 0;
+  padding-right: 40px;
+
+  font-weight: 600;
+
+  letter-spacing: -1px;
+
+  color: rgb(51, 51, 51);
+}
+
+ul {
+  margin: 0;
+  padding: 0;
+  margin-top: 20px;
+  margin-left: 1.5em;
+}
+li {
+  padding: 0;
+  margin: 0 0 .5em 0;
+}
+
+div.code {
+  padding: 5px 10px;
+  margin-top: 20px;
+  margin-bottom: 20px;
+  overflow: hidden;
+
+  background: rgb(240, 240, 240);
+  border: 1px solid rgb(224, 224, 224);
+}
+pre {
+  margin: 0;
+  padding: 0;
+
+  font-family: 'Droid Sans Mono', 'Courier New', monospace;
+  font-size: 18px;
+  line-height: 24px;
+  letter-spacing: -1px;
+
+  color: black;
+}
+
+pre.numbers span:before {
+  content: attr(num);
+  margin-right: 1em;
+  display: inline-block;
+}
+
+code {
+  font-size: 95%;
+  font-family: 'Droid Sans Mono', 'Courier New', monospace;
+
+  color: black;
+}
+
+article > .image,
+article > .video {
+  text-align: center;
+  margin-top: 40px;
+}
+
+article.background {
+  background-size: contain;
+  background-repeat: round;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 40px;
+}
+th {
+  font-weight: 600;
+  text-align: left;
+}
+td,
+th {
+  border: 1px solid rgb(224, 224, 224);
+  padding: 5px 10px;
+  vertical-align: top;
+}
+
+p.link {
+  margin-left: 20px;
+}
+
+/* Code */
+div.code {
+  outline: 0px solid transparent;
+}
+div.playground {
+  position: relative;
+}
+div.output {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  right: 40px;
+  bottom: 40px;
+  background: #202020;
+  padding: 5px 10px;
+  z-index: 2;
+
+  border-radius: 10px;
+  -o-border-radius: 10px;
+  -moz-border-radius: 10px;
+  -webkit-border-radius: 10px;
+
+}
+div.output pre {
+  margin: 0;
+  padding: 0;
+  background: none;
+  border: none;
+  width: 100%;
+  height: 100%;
+  overflow: auto;
+}
+div.output .stdout, div.output pre {
+  color: #e6e6e6;
+}
+div.output .stderr, div.output .error {
+  color: rgb(255, 200, 200);
+}
+div.output .system, div.output .exit {
+  color: rgb(255, 230, 120)
+}
+.buttons {
+  position: relative;
+  float: right;
+  top: -60px;
+  right: 10px;
+}
+div.output .buttons {
+  position: absolute;
+  float: none;
+  top: auto;
+  right: 5px;
+  bottom: 5px;
+}
+
+/* Presenter details */
+.presenter {
+  margin-top: 20px;
+}
+.presenter p,
+.presenter .link {
+  margin: 0;
+  font-size: 28px;
+  line-height: 1.2em;
+}
+
+/* Output resize details */
+.ui-resizable-handle {
+  position: absolute;
+}
+.ui-resizable-n {
+  cursor: n-resize;
+  height: 7px;
+  width: 100%;
+  top: -5px;
+  left: 0;
+}
+.ui-resizable-w {
+  cursor: w-resize;
+  width: 7px;
+  left: -5px;
+  top: 0;
+  height: 100%;
+}
+.ui-resizable-nw {
+  cursor: nw-resize;
+  width: 9px;
+  height: 9px;
+  left: -5px;
+  top: -5px;
+}
+iframe {
+  border: none;
+}
+figcaption {
+  color: #666;
+  text-align: center;
+  font-size: 0.75em;
+}
+
+#help {
+  font-family: 'Open Sans', Arial, sans-serif;
+  text-align: center;
+  color: white;
+  background: #000;
+  opacity: 0.5;
+  position: fixed;
+  bottom: 25px;
+  left: 50px;
+  right: 50px;
+  padding: 20px;
+
+  border-radius: 10px;
+  -o-border-radius: 10px;
+  -moz-border-radius: 10px;
+  -webkit-border-radius: 10px;
+}
diff --git a/vendor/golang.org/x/tools/cmd/present/templates/action.tmpl b/vendor/golang.org/x/tools/cmd/present/templates/action.tmpl
new file mode 100644
index 0000000..8bde042
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/templates/action.tmpl
@@ -0,0 +1,62 @@
+{/*
+This is the action template.
+It determines how the formatting actions are rendered.
+*/}
+
+{{define "section"}}
+  <h{{len .Number}} id="TOC_{{.FormattedNumber}}">{{.FormattedNumber}} {{.Title}}</h{{len .Number}}>
+  {{range .Elem}}{{elem $.Template .}}{{end}}
+{{end}}
+
+{{define "list"}}
+  <ul>
+  {{range .Bullet}}
+    <li>{{style .}}</li>
+  {{end}}
+  </ul>
+{{end}}
+
+{{define "text"}}
+  {{if .Pre}}
+  <div class="code"><pre>{{range .Lines}}{{.}}{{end}}</pre></div>
+  {{else}}
+  <p>
+    {{range $i, $l := .Lines}}{{if $i}}{{template "newline"}}
+    {{end}}{{style $l}}{{end}}
+  </p>
+  {{end}}
+{{end}}
+
+{{define "code"}}
+  <div class="code{{if playable .}} playground{{end}}" {{if .Edit}}contenteditable="true" spellcheck="false"{{end}}>{{.Text}}</div>
+{{end}}
+
+{{define "image"}}
+<div class="image">
+  <img src="{{.URL}}"{{with .Height}} height="{{.}}"{{end}}{{with .Width}} width="{{.}}"{{end}}>
+</div>
+{{end}}
+
+{{define "video"}}
+<div class="video">
+  <video {{with .Height}} height="{{.}}"{{end}}{{with .Width}} width="{{.}}"{{end}} controls>
+    <source src="{{.URL}}" type="{{.SourceType}}">
+  </video>
+</div>
+{{end}}
+
+{{define "background"}}
+<div class="background">
+  <img src="{{.URL}}">
+</div>
+{{end}}
+
+{{define "iframe"}}
+<iframe src="{{.URL}}"{{with .Height}} height="{{.}}"{{end}}{{with .Width}} width="{{.}}"{{end}}></iframe>
+{{end}}
+
+{{define "link"}}<p class="link"><a href="{{.URL}}" target="_blank">{{style .Label}}</a></p>{{end}}
+
+{{define "html"}}{{.HTML}}{{end}}
+
+{{define "caption"}}<figcaption>{{style .Text}}</figcaption>{{end}}
diff --git a/vendor/golang.org/x/tools/cmd/present/templates/article.tmpl b/vendor/golang.org/x/tools/cmd/present/templates/article.tmpl
new file mode 100644
index 0000000..0a223c6
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/templates/article.tmpl
@@ -0,0 +1,98 @@
+{/* This is the article template. It defines how articles are formatted. */}
+
+{{define "root"}}
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>{{.Title}}</title>
+    <link type="text/css" rel="stylesheet" href="/static/article.css">
+    <meta charset='utf-8'>
+    <script>
+      // Initialize Google Analytics tracking code on production site only.
+      if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+        var _gaq = _gaq || [];
+        _gaq.push(["_setAccount", "UA-11222381-6"]);
+        _gaq.push(["b._setAccount", "UA-49880327-6"]);
+        window.trackPageview = function() {
+          _gaq.push(["_trackPageview", location.pathname+location.hash]);
+          _gaq.push(["b._trackPageview", location.pathname+location.hash]);
+        };
+        window.trackPageview();
+        window.trackEvent = function(category, action, opt_label, opt_value, opt_noninteraction) {
+          _gaq.push(["_trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+          _gaq.push(["b._trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+        };
+      }
+    </script>
+  </head>
+
+  <body>
+    <div id="topbar" class="wide">
+      <div class="container">
+        <div id="heading">{{.Title}}
+          {{with .Subtitle}}{{.}}{{end}}
+          {{if .Authors}}
+            {{range .Authors}}
+              <div class="author">
+                {{range .Elem}}{{elem $.Template .}}{{end}}
+              </div>
+            {{end}}
+          {{end}}
+        </div>
+      </div>
+    </div>
+    <div id="page" class="wide">
+      <div class="container">
+        {{with .Sections}}
+          <div id="toc" class="no-print">
+            <div id="tochead">Contents</div>
+            {{template "TOC" .}}
+          </div>
+        {{end}}
+
+        {{range .Sections}}
+          {{elem $.Template .}}
+        {{end}}{{/* of Section block */}}
+
+      </div>
+    </div>
+
+    {{if .PlayEnabled}}
+    <script src='/play.js'></script>
+    {{end}}
+
+    <script>
+      (function() {
+        // Load Google Analytics tracking code on production site only.
+        if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+          var ga = document.createElement("script"); ga.type = "text/javascript"; ga.async = true;
+          ga.src = ("https:" == document.location.protocol ? "https://ssl" : "http://www") + ".google-analytics.com/ga.js";
+          var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ga, s);
+        }
+      })();
+    </script>
+  </body>
+</html>
+{{end}}
+
+{{define "TOC"}}
+  <ul class="toc-outer">
+  {{range .}}
+    <li><a href="#TOC_{{.FormattedNumber}}">{{.Title}}</a></li>
+    {{with .Sections}}{{template "TOC-Inner" .}}{{end}}
+  {{end}}
+  </ul>
+{{end}}
+
+{{define "TOC-Inner"}}
+  <ul class="toc-inner">
+  {{range .}}
+    <li><a href="#TOC_{{.FormattedNumber}}">{{.Title}}</a></li>
+    {{with .Sections}}{{template "TOC-Inner" .}}{{end}}
+  {{end}}
+  </ul>
+{{end}}
+
+{{define "newline"}}
+{{/* No automatic line break. Paragraphs are free-form. */}}
+{{end}}
diff --git a/vendor/golang.org/x/tools/cmd/present/templates/dir.tmpl b/vendor/golang.org/x/tools/cmd/present/templates/dir.tmpl
new file mode 100644
index 0000000..1732623
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/templates/dir.tmpl
@@ -0,0 +1,108 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <title>Talks - The Go Programming Language</title>
+  <link type="text/css" rel="stylesheet" href="/static/dir.css">
+  <script src="/static/dir.js"></script>
+  <script>
+    // Initialize Google Analytics tracking code on production site only.
+    if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+      var _gaq = _gaq || [];
+      _gaq.push(["_setAccount", "UA-11222381-6"]);
+      _gaq.push(["b._setAccount", "UA-49880327-6"]);
+      window.trackPageview = function() {
+        _gaq.push(["_trackPageview", location.pathname+location.hash]);
+        _gaq.push(["b._trackPageview", location.pathname+location.hash]);
+      };
+      window.trackPageview();
+      window.trackEvent = function(category, action, opt_label, opt_value, opt_noninteraction) {
+        _gaq.push(["_trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+        _gaq.push(["b._trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+      };
+    }
+  </script>
+</head>
+<body>
+
+<div id="topbar"><div class="container">
+
+<form method="GET" action="//golang.org/search">
+<div id="menu">
+<a href="http://golang.org/doc/">Documents</a>
+<a href="http://golang.org/ref">References</a>
+<a href="http://golang.org/pkg/">Packages</a>
+<a href="http://golang.org/project/">The Project</a>
+<a href="http://golang.org/help/">Help</a>
+<input type="text" id="search" name="q" class="inactive" value="Search">
+</div>
+<div id="heading"><a href="/">The Go Programming Language</a></div>
+</form>
+
+</div></div>
+
+<div id="page">
+
+  <h1>Go talks</h1>
+
+  {{with .Path}}<h2>{{.}}</h2>{{end}}
+
+  {{with .Articles}}
+  <h4>Articles:</h4>
+  <dl>
+  {{range .}}
+  <dd><a href="/{{.Path}}">{{.Name}}</a>: {{.Title}}</dd>
+  {{end}}
+  </dl>
+  {{end}}
+
+  {{with .Slides}}
+  <h4>Slide decks:</h4>
+  <dl>
+  {{range .}}
+  <dd><a href="/{{.Path}}">{{.Name}}</a>: {{.Title}}</dd>
+  {{end}}
+  </dl>
+  {{end}}
+
+  {{with .Other}}
+  <h4>Files:</h4>
+  <dl>
+  {{range .}}
+  <dd><a href="/{{.Path}}">{{.Name}}</a></dd>
+  {{end}}
+  </dl>
+  {{end}}
+
+  {{with .Dirs}}
+  <h4>Sub-directories:</h4>
+  <dl>
+  {{range .}}
+  <dd><a href="/{{.Path}}">{{.Name}}</a></dd>
+  {{end}}
+  </dl>
+  {{end}}
+
+</div>
+
+<div id="footer">
+Except as <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
+the content of this page is licensed under the
+Creative Commons Attribution 3.0 License,
+and code is licensed under a <a href="http://golang.org/LICENSE">BSD license</a>.<br>
+<a href="http://golang.org/doc/tos.html">Terms of Service</a> |
+<a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
+</div>
+
+<script>
+  (function() {
+    // Load Google Analytics tracking code on production site only.
+    if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+      var ga = document.createElement("script"); ga.type = "text/javascript"; ga.async = true;
+      ga.src = ("https:" == document.location.protocol ? "https://ssl" : "http://www") + ".google-analytics.com/ga.js";
+      var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ga, s);
+    }
+  })();
+</script>
+</body>
+</html>
diff --git a/vendor/golang.org/x/tools/cmd/present/templates/slides.tmpl b/vendor/golang.org/x/tools/cmd/present/templates/slides.tmpl
new file mode 100644
index 0000000..3748400
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/present/templates/slides.tmpl
@@ -0,0 +1,106 @@
+{/* This is the slide template. It defines how presentations are formatted. */}
+
+{{define "root"}}
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>{{.Title}}</title>
+    <meta charset='utf-8'>
+    <script>
+      var notesEnabled = {{.NotesEnabled}};
+    </script>
+    <script src='/static/slides.js'></script>
+
+    {{if .NotesEnabled}}
+    <script>
+      var sections = {{.Sections}};
+      var titleNotes = {{.TitleNotes}}
+    </script>
+    <script src='/static/notes.js'></script>
+    {{end}}
+
+    <script>
+      // Initialize Google Analytics tracking code on production site only.
+      if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+        var _gaq = _gaq || [];
+        _gaq.push(["_setAccount", "UA-11222381-6"]);
+        _gaq.push(["b._setAccount", "UA-49880327-6"]);
+        window.trackPageview = function() {
+          _gaq.push(["_trackPageview", location.pathname+location.hash]);
+          _gaq.push(["b._trackPageview", location.pathname+location.hash]);
+        };
+        window.trackPageview();
+        window.trackEvent = function(category, action, opt_label, opt_value, opt_noninteraction) {
+          _gaq.push(["_trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+          _gaq.push(["b._trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+        };
+      }
+    </script>
+  </head>
+
+  <body style='display: none'>
+
+    <section class='slides layout-widescreen'>
+
+      <article>
+        <h1>{{.Title}}</h1>
+        {{with .Subtitle}}<h3>{{.}}</h3>{{end}}
+        {{if not .Time.IsZero}}<h3>{{.Time.Format "2 January 2006"}}</h3>{{end}}
+        {{range .Authors}}
+          <div class="presenter">
+            {{range .TextElem}}{{elem $.Template .}}{{end}}
+          </div>
+        {{end}}
+      </article>
+
+  {{range $i, $s := .Sections}}
+  <!-- start of slide {{$s.Number}} -->
+      <article {{$s.HTMLAttributes}}>
+      {{if $s.Elem}}
+        <h3>{{$s.Title}}</h3>
+        {{range $s.Elem}}{{elem $.Template .}}{{end}}
+      {{else}}
+        <h2>{{$s.Title}}</h2>
+      {{end}}
+      </article>
+  <!-- end of slide {{$i}} -->
+  {{end}}{{/* of Slide block */}}
+
+      <article>
+        <h3>Thank you</h3>
+        {{range .Authors}}
+          <div class="presenter">
+            {{range .Elem}}{{elem $.Template .}}{{end}}
+          </div>
+        {{end}}
+      </article>
+
+    </section>
+
+    <div id="help">
+      Use the left and right arrow keys or click the left and right
+      edges of the page to navigate between slides.<br>
+      (Press 'H' or navigate to hide this message.)
+    </div>
+
+    {{if .PlayEnabled}}
+    <script src='/play.js'></script>
+    {{end}}
+
+    <script>
+      (function() {
+        // Load Google Analytics tracking code on production site only.
+        if (window["location"] && window["location"]["hostname"] == "talks.golang.org") {
+          var ga = document.createElement("script"); ga.type = "text/javascript"; ga.async = true;
+          ga.src = ("https:" == document.location.protocol ? "https://ssl" : "http://www") + ".google-analytics.com/ga.js";
+          var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ga, s);
+        }
+      })();
+    </script>
+  </body>
+</html>
+{{end}}
+
+{{define "newline"}}
+<br>
+{{end}}
diff --git a/vendor/golang.org/x/tools/cmd/ssadump/main.go b/vendor/golang.org/x/tools/cmd/ssadump/main.go
new file mode 100644
index 0000000..8c4dbd1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/ssadump/main.go
@@ -0,0 +1,180 @@
+// 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.
+
+// ssadump: a tool for displaying and interpreting the SSA form of Go programs.
+package main // import "golang.org/x/tools/cmd/ssadump"
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"go/types"
+	"os"
+	"runtime"
+	"runtime/pprof"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/interp"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// flags
+var (
+	mode = ssa.BuilderMode(0)
+
+	testFlag = flag.Bool("test", false, "Loads test code (*_test.go) for imported packages.")
+
+	runFlag = flag.Bool("run", false, "Invokes the SSA interpreter on the program.")
+
+	interpFlag = flag.String("interp", "", `Options controlling the SSA test interpreter.
+The value is a sequence of zero or more more of these letters:
+R	disable [R]ecover() from panic; show interpreter crash instead.
+T	[T]race execution of the program.  Best for single-threaded programs!
+`)
+
+	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+)
+
+func init() {
+	flag.Var(&mode, "build", ssa.BuilderModeDoc)
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+}
+
+const usage = `SSA builder and interpreter.
+Usage: ssadump [<flag> ...] <args> ...
+Use -help flag to display options.
+
+Examples:
+% ssadump -build=F hello.go              # dump SSA form of a single package
+% ssadump -build=F -test fmt             # dump SSA form of a package and its tests
+% ssadump -run -interp=T hello.go        # interpret a program, with tracing
+` + loader.FromArgsUsage +
+	`
+The -run flag causes ssadump to run the first package named main.
+
+Interpretation of the standard "testing" package is no longer supported.
+`
+
+func main() {
+	if err := doMain(); err != nil {
+		fmt.Fprintf(os.Stderr, "ssadump: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+func doMain() error {
+	flag.Parse()
+	args := flag.Args()
+
+	conf := loader.Config{Build: &build.Default}
+
+	// Choose types.Sizes from conf.Build.
+	var wordSize int64 = 8
+	switch conf.Build.GOARCH {
+	case "386", "arm":
+		wordSize = 4
+	}
+	conf.TypeChecker.Sizes = &types.StdSizes{
+		MaxAlign: 8,
+		WordSize: wordSize,
+	}
+
+	var interpMode interp.Mode
+	for _, c := range *interpFlag {
+		switch c {
+		case 'T':
+			interpMode |= interp.EnableTracing
+		case 'R':
+			interpMode |= interp.DisableRecover
+		default:
+			return fmt.Errorf("unknown -interp option: '%c'", c)
+		}
+	}
+
+	if len(args) == 0 {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
+
+	// Profiling support.
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
+	// Use the initial packages from the command line.
+	args, err := conf.FromArgs(args, *testFlag)
+	if err != nil {
+		return err
+	}
+
+	// The interpreter needs the runtime package.
+	if *runFlag {
+		conf.Import("runtime")
+	}
+
+	// Load, parse and type-check the whole program.
+	lprog, err := conf.Load()
+	if err != nil {
+		return err
+	}
+
+	// Create and build SSA-form program representation.
+	prog := ssautil.CreateProgram(lprog, mode)
+
+	// Build and display only the initial packages
+	// (and synthetic wrappers), unless -run is specified.
+	var initpkgs []*ssa.Package
+	for _, info := range lprog.InitialPackages() {
+		ssapkg := prog.Package(info.Pkg)
+		ssapkg.Build()
+		if info.Pkg.Path() != "runtime" {
+			initpkgs = append(initpkgs, ssapkg)
+		}
+	}
+
+	// Run the interpreter.
+	if *runFlag {
+		prog.Build()
+
+		var mains []*ssa.Package
+		if *testFlag {
+			// If -test, run the tests.
+			for _, pkg := range initpkgs {
+				if main := prog.CreateTestMainPackage(pkg); main != nil {
+					mains = append(mains, main)
+				}
+			}
+			if mains == nil {
+				return fmt.Errorf("no tests")
+			}
+		} else {
+			// Otherwise, run the main packages.
+			mains = ssautil.MainPackages(initpkgs)
+			if len(mains) == 0 {
+				return fmt.Errorf("no main package")
+			}
+		}
+
+		if runtime.GOARCH != build.Default.GOARCH {
+			return fmt.Errorf("cross-interpretation is not supported (target has GOARCH %s, interpreter has %s)",
+				build.Default.GOARCH, runtime.GOARCH)
+		}
+
+		for _, main := range mains {
+			if len(mains) > 1 {
+				fmt.Fprintf(os.Stderr, "Running: %s\n", main.Pkg.Path())
+			}
+			interp.Interpret(main, interpMode, conf.TypeChecker.Sizes, main.Pkg.Path(), args)
+		}
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/stress/stress.go b/vendor/golang.org/x/tools/cmd/stress/stress.go
new file mode 100644
index 0000000..ee68917
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stress/stress.go
@@ -0,0 +1,133 @@
+// 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 !plan9
+
+// The stress utility is intended for catching sporadic failures.
+// It runs a given process in parallel in a loop and collects any failures.
+// Usage:
+// 	$ stress ./fmt.test -test.run=TestSometing -test.cpu=10
+// You can also specify a number of parallel processes with -p flag;
+// instruct the utility to not kill hanged processes for gdb attach;
+// or specify the failure output you are looking for (if you want to
+// ignore some other sporadic failures).
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"syscall"
+	"time"
+)
+
+var (
+	flagP       = flag.Int("p", runtime.NumCPU(), "run `N` processes in parallel")
+	flagTimeout = flag.Duration("timeout", 10*time.Minute, "timeout each process after `duration`")
+	flagKill    = flag.Bool("kill", true, "kill timed out processes if true, otherwise just print pid (to attach with gdb)")
+	flagFailure = flag.String("failure", "", "fail only if output matches `regexp`")
+	flagIgnore  = flag.String("ignore", "", "ignore failure if output matches `regexp`")
+)
+
+func init() {
+	flag.Usage = func() {
+		os.Stderr.WriteString(`The stress utility is intended for catching sporadic failures.
+It runs a given process in parallel in a loop and collects any failures.
+Usage:
+
+	$ stress ./fmt.test -test.run=TestSometing -test.cpu=10
+
+`)
+		flag.PrintDefaults()
+	}
+}
+
+func main() {
+	flag.Parse()
+	if *flagP <= 0 || *flagTimeout <= 0 || len(flag.Args()) == 0 {
+		flag.Usage()
+		os.Exit(1)
+	}
+	var failureRe, ignoreRe *regexp.Regexp
+	if *flagFailure != "" {
+		var err error
+		if failureRe, err = regexp.Compile(*flagFailure); err != nil {
+			fmt.Println("bad failure regexp:", err)
+			os.Exit(1)
+		}
+	}
+	if *flagIgnore != "" {
+		var err error
+		if ignoreRe, err = regexp.Compile(*flagIgnore); err != nil {
+			fmt.Println("bad ignore regexp:", err)
+			os.Exit(1)
+		}
+	}
+	res := make(chan []byte)
+	for i := 0; i < *flagP; i++ {
+		go func() {
+			for {
+				cmd := exec.Command(flag.Args()[0], flag.Args()[1:]...)
+				done := make(chan bool)
+				if *flagTimeout > 0 {
+					go func() {
+						select {
+						case <-done:
+							return
+						case <-time.After(*flagTimeout):
+						}
+						if !*flagKill {
+							fmt.Printf("process %v timed out\n", cmd.Process.Pid)
+							return
+						}
+						cmd.Process.Signal(syscall.SIGABRT)
+						select {
+						case <-done:
+							return
+						case <-time.After(10 * time.Second):
+						}
+						cmd.Process.Kill()
+					}()
+				}
+				out, err := cmd.CombinedOutput()
+				close(done)
+				if err != nil && (failureRe == nil || failureRe.Match(out)) && (ignoreRe == nil || !ignoreRe.Match(out)) {
+					out = append(out, fmt.Sprintf("\n\nERROR: %v\n", err)...)
+				} else {
+					out = []byte{}
+				}
+				res <- out
+			}
+		}()
+	}
+	runs, fails := 0, 0
+	ticker := time.NewTicker(5 * time.Second).C
+	for {
+		select {
+		case out := <-res:
+			runs++
+			if len(out) == 0 {
+				continue
+			}
+			fails++
+			f, err := ioutil.TempFile("", "go-stress")
+			if err != nil {
+				fmt.Printf("failed to create temp file: %v\n", err)
+				os.Exit(1)
+			}
+			f.Write(out)
+			f.Close()
+			if len(out) > 2<<10 {
+				out = out[:2<<10]
+			}
+			fmt.Printf("\n%s\n%s\n", f.Name(), out)
+		case <-ticker:
+			fmt.Printf("%v runs so far, %v failures\n", runs, fails)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/endtoend_test.go b/vendor/golang.org/x/tools/cmd/stringer/endtoend_test.go
new file mode 100644
index 0000000..273f29b
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/endtoend_test.go
@@ -0,0 +1,111 @@
+// 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.
+
+// go command is not available on android
+
+// +build !android
+
+package main
+
+import (
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This file contains a test that compiles and runs each program in testdata
+// after generating the string method for its type. The rule is that for testdata/x.go
+// we run stringer -type X and then compile and run the program. The resulting
+// binary panics if the String method for X is not correct, including for error cases.
+
+func TestEndToEnd(t *testing.T) {
+	dir, err := ioutil.TempDir("", "stringer")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dir)
+	// Create stringer in temporary directory.
+	stringer := filepath.Join(dir, "stringer.exe")
+	err = run("go", "build", "-o", stringer)
+	if err != nil {
+		t.Fatalf("building stringer: %s", err)
+	}
+	// Read the testdata directory.
+	fd, err := os.Open("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer fd.Close()
+	names, err := fd.Readdirnames(-1)
+	if err != nil {
+		t.Fatalf("Readdirnames: %s", err)
+	}
+	// Generate, compile, and run the test programs.
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".go") {
+			t.Errorf("%s is not a Go file", name)
+			continue
+		}
+		if name == "cgo.go" && !build.Default.CgoEnabled {
+			t.Logf("cgo is not enabled for %s", name)
+			continue
+		}
+		// Names are known to be ASCII and long enough.
+		typeName := fmt.Sprintf("%c%s", name[0]+'A'-'a', name[1:len(name)-len(".go")])
+		stringerCompileAndRun(t, dir, stringer, typeName, name)
+	}
+}
+
+// stringerCompileAndRun runs stringer for the named file and compiles and
+// runs the target binary in directory dir. That binary will panic if the String method is incorrect.
+func stringerCompileAndRun(t *testing.T, dir, stringer, typeName, fileName string) {
+	t.Logf("run: %s %s\n", fileName, typeName)
+	source := filepath.Join(dir, fileName)
+	err := copy(source, filepath.Join("testdata", fileName))
+	if err != nil {
+		t.Fatalf("copying file to temporary directory: %s", err)
+	}
+	stringSource := filepath.Join(dir, typeName+"_string.go")
+	// Run stringer in temporary directory.
+	err = run(stringer, "-type", typeName, "-output", stringSource, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Run the binary in the temporary directory.
+	err = run("go", "run", stringSource, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+// copy copies the from file to the to file.
+func copy(to, from string) error {
+	toFd, err := os.Create(to)
+	if err != nil {
+		return err
+	}
+	defer toFd.Close()
+	fromFd, err := os.Open(from)
+	if err != nil {
+		return err
+	}
+	defer fromFd.Close()
+	_, err = io.Copy(toFd, fromFd)
+	return err
+}
+
+// run runs a single command and returns an error if it does not succeed.
+// os/exec should have this function, to be honest.
+func run(name string, arg ...string) error {
+	cmd := exec.Command(name, arg...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/golden_test.go b/vendor/golang.org/x/tools/cmd/stringer/golden_test.go
new file mode 100644
index 0000000..4ba7788
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/golden_test.go
@@ -0,0 +1,319 @@
+// 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 contains simple golden tests for various examples.
+// Besides validating the results when the implementation changes,
+// it provides a way to look at the generated code without having
+// to execute the print statements in one's head.
+
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+// Golden represents a test case.
+type Golden struct {
+	name        string
+	trimPrefix  string
+	lineComment bool
+	input       string // input; the package clause is provided when running the test.
+	output      string // exected output.
+}
+
+var golden = []Golden{
+	{"day", "", false, day_in, day_out},
+	{"offset", "", false, offset_in, offset_out},
+	{"gap", "", false, gap_in, gap_out},
+	{"num", "", false, num_in, num_out},
+	{"unum", "", false, unum_in, unum_out},
+	{"prime", "", false, prime_in, prime_out},
+	{"prefix", "Type", false, prefix_in, prefix_out},
+	{"tokens", "", true, tokens_in, tokens_out},
+}
+
+// Each example starts with "type XXX [u]int", with a single space separating them.
+
+// Simple test: enumeration of type int starting at 0.
+const day_in = `type Day int
+const (
+	Monday Day = iota
+	Tuesday
+	Wednesday
+	Thursday
+	Friday
+	Saturday
+	Sunday
+)
+`
+
+const day_out = `
+const _Day_name = "MondayTuesdayWednesdayThursdayFridaySaturdaySunday"
+
+var _Day_index = [...]uint8{0, 6, 13, 22, 30, 36, 44, 50}
+
+func (i Day) String() string {
+	if i < 0 || i >= Day(len(_Day_index)-1) {
+		return "Day(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _Day_name[_Day_index[i]:_Day_index[i+1]]
+}
+`
+
+// Enumeration with an offset.
+// Also includes a duplicate.
+const offset_in = `type Number int
+const (
+	_ Number = iota
+	One
+	Two
+	Three
+	AnotherOne = One  // Duplicate; note that AnotherOne doesn't appear below.
+)
+`
+
+const offset_out = `
+const _Number_name = "OneTwoThree"
+
+var _Number_index = [...]uint8{0, 3, 6, 11}
+
+func (i Number) String() string {
+	i -= 1
+	if i < 0 || i >= Number(len(_Number_index)-1) {
+		return "Number(" + strconv.FormatInt(int64(i+1), 10) + ")"
+	}
+	return _Number_name[_Number_index[i]:_Number_index[i+1]]
+}
+`
+
+// Gaps and an offset.
+const gap_in = `type Gap int
+const (
+	Two Gap = 2
+	Three Gap = 3
+	Five Gap = 5
+	Six Gap = 6
+	Seven Gap = 7
+	Eight Gap = 8
+	Nine Gap = 9
+	Eleven Gap = 11
+)
+`
+
+const gap_out = `
+const (
+	_Gap_name_0 = "TwoThree"
+	_Gap_name_1 = "FiveSixSevenEightNine"
+	_Gap_name_2 = "Eleven"
+)
+
+var (
+	_Gap_index_0 = [...]uint8{0, 3, 8}
+	_Gap_index_1 = [...]uint8{0, 4, 7, 12, 17, 21}
+)
+
+func (i Gap) String() string {
+	switch {
+	case 2 <= i && i <= 3:
+		i -= 2
+		return _Gap_name_0[_Gap_index_0[i]:_Gap_index_0[i+1]]
+	case 5 <= i && i <= 9:
+		i -= 5
+		return _Gap_name_1[_Gap_index_1[i]:_Gap_index_1[i+1]]
+	case i == 11:
+		return _Gap_name_2
+	default:
+		return "Gap(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}
+`
+
+// Signed integers spanning zero.
+const num_in = `type Num int
+const (
+	m_2 Num = -2 + iota
+	m_1
+	m0
+	m1
+	m2
+)
+`
+
+const num_out = `
+const _Num_name = "m_2m_1m0m1m2"
+
+var _Num_index = [...]uint8{0, 3, 6, 8, 10, 12}
+
+func (i Num) String() string {
+	i -= -2
+	if i < 0 || i >= Num(len(_Num_index)-1) {
+		return "Num(" + strconv.FormatInt(int64(i+-2), 10) + ")"
+	}
+	return _Num_name[_Num_index[i]:_Num_index[i+1]]
+}
+`
+
+// Unsigned integers spanning zero.
+const unum_in = `type Unum uint
+const (
+	m_2 Unum = iota + 253
+	m_1
+)
+
+const (
+	m0 Unum = iota
+	m1
+	m2
+)
+`
+
+const unum_out = `
+const (
+	_Unum_name_0 = "m0m1m2"
+	_Unum_name_1 = "m_2m_1"
+)
+
+var (
+	_Unum_index_0 = [...]uint8{0, 2, 4, 6}
+	_Unum_index_1 = [...]uint8{0, 3, 6}
+)
+
+func (i Unum) String() string {
+	switch {
+	case 0 <= i && i <= 2:
+		return _Unum_name_0[_Unum_index_0[i]:_Unum_index_0[i+1]]
+	case 253 <= i && i <= 254:
+		i -= 253
+		return _Unum_name_1[_Unum_index_1[i]:_Unum_index_1[i+1]]
+	default:
+		return "Unum(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}
+`
+
+// Enough gaps to trigger a map implementation of the method.
+// Also includes a duplicate to test that it doesn't cause problems
+const prime_in = `type Prime int
+const (
+	p2 Prime = 2
+	p3 Prime = 3
+	p5 Prime = 5
+	p7 Prime = 7
+	p77 Prime = 7 // Duplicate; note that p77 doesn't appear below.
+	p11 Prime = 11
+	p13 Prime = 13
+	p17 Prime = 17
+	p19 Prime = 19
+	p23 Prime = 23
+	p29 Prime = 29
+	p37 Prime = 31
+	p41 Prime = 41
+	p43 Prime = 43
+)
+`
+
+const prime_out = `
+const _Prime_name = "p2p3p5p7p11p13p17p19p23p29p37p41p43"
+
+var _Prime_map = map[Prime]string{
+	2:  _Prime_name[0:2],
+	3:  _Prime_name[2:4],
+	5:  _Prime_name[4:6],
+	7:  _Prime_name[6:8],
+	11: _Prime_name[8:11],
+	13: _Prime_name[11:14],
+	17: _Prime_name[14:17],
+	19: _Prime_name[17:20],
+	23: _Prime_name[20:23],
+	29: _Prime_name[23:26],
+	31: _Prime_name[26:29],
+	41: _Prime_name[29:32],
+	43: _Prime_name[32:35],
+}
+
+func (i Prime) String() string {
+	if str, ok := _Prime_map[i]; ok {
+		return str
+	}
+	return "Prime(" + strconv.FormatInt(int64(i), 10) + ")"
+}
+`
+
+const prefix_in = `type Type int
+const (
+	TypeInt Type = iota
+	TypeString
+	TypeFloat
+	TypeRune
+	TypeByte
+	TypeStruct
+	TypeSlice
+)
+`
+
+const prefix_out = `
+const _Type_name = "IntStringFloatRuneByteStructSlice"
+
+var _Type_index = [...]uint8{0, 3, 9, 14, 18, 22, 28, 33}
+
+func (i Type) String() string {
+	if i < 0 || i >= Type(len(_Type_index)-1) {
+		return "Type(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _Type_name[_Type_index[i]:_Type_index[i+1]]
+}
+`
+
+const tokens_in = `type Token int
+const (
+	And Token = iota // &
+	Or               // |
+	Add              // +
+	Sub              // -
+	Ident
+	Period // .
+
+	// not to be used
+	SingleBefore
+	// not to be used
+	BeforeAndInline // inline
+	InlineGeneral /* inline general */
+)
+`
+
+const tokens_out = `
+const _Token_name = "&|+-Ident.SingleBeforeinlineinline general"
+
+var _Token_index = [...]uint8{0, 1, 2, 3, 4, 9, 10, 22, 28, 42}
+
+func (i Token) String() string {
+	if i < 0 || i >= Token(len(_Token_index)-1) {
+		return "Token(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _Token_name[_Token_index[i]:_Token_index[i+1]]
+}
+`
+
+func TestGolden(t *testing.T) {
+	for _, test := range golden {
+		g := Generator{
+			trimPrefix:  test.trimPrefix,
+			lineComment: test.lineComment,
+		}
+		input := "package test\n" + test.input
+		file := test.name + ".go"
+		g.parsePackage(".", []string{file}, input)
+		// Extract the name and type of the constant from the first line.
+		tokens := strings.SplitN(test.input, " ", 3)
+		if len(tokens) != 3 {
+			t.Fatalf("%s: need type declaration on first line", test.name)
+		}
+		g.generate(tokens[1])
+		got := string(g.format())
+		if got != test.output {
+			t.Errorf("%s: got\n====\n%s====\nexpected\n====%s", test.name, got, test.output)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/importer18.go b/vendor/golang.org/x/tools/cmd/stringer/importer18.go
new file mode 100644
index 0000000..fd21873
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/importer18.go
@@ -0,0 +1,16 @@
+// 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/importer"
+	"go/types"
+)
+
+func defaultImporter() types.Importer {
+	return importer.Default()
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/importer19.go b/vendor/golang.org/x/tools/cmd/stringer/importer19.go
new file mode 100644
index 0000000..deddadb
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/importer19.go
@@ -0,0 +1,16 @@
+// 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/importer"
+	"go/types"
+)
+
+func defaultImporter() types.Importer {
+	return importer.For("source", nil)
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/stringer.go b/vendor/golang.org/x/tools/cmd/stringer/stringer.go
new file mode 100644
index 0000000..4b8d1ba
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/stringer.go
@@ -0,0 +1,655 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Stringer is a tool to automate the creation of methods that satisfy the fmt.Stringer
+// interface. Given the name of a (signed or unsigned) integer type T that has constants
+// defined, stringer will create a new self-contained Go source file implementing
+//	func (t T) String() string
+// The file is created in the same package and directory as the package that defines T.
+// It has helpful defaults designed for use with go generate.
+//
+// Stringer works best with constants that are consecutive values such as created using iota,
+// but creates good code regardless. In the future it might also provide custom support for
+// constant sets that are bit patterns.
+//
+// For example, given this snippet,
+//
+//	package painkiller
+//
+//	type Pill int
+//
+//	const (
+//		Placebo Pill = iota
+//		Aspirin
+//		Ibuprofen
+//		Paracetamol
+//		Acetaminophen = Paracetamol
+//	)
+//
+// running this command
+//
+//	stringer -type=Pill
+//
+// in the same directory will create the file pill_string.go, in package painkiller,
+// containing a definition of
+//
+//	func (Pill) String() string
+//
+// That method will translate the value of a Pill constant to the string representation
+// of the respective constant name, so that the call fmt.Print(painkiller.Aspirin) will
+// print the string "Aspirin".
+//
+// Typically this process would be run using go generate, like this:
+//
+//	//go:generate stringer -type=Pill
+//
+// If multiple constants have the same value, the lexically first matching name will
+// be used (in the example, Acetaminophen will print as "Paracetamol").
+//
+// With no arguments, it processes the package in the current directory.
+// Otherwise, the arguments must name a single directory holding a Go package
+// or a set of Go source files that represent a single Go package.
+//
+// The -type flag accepts a comma-separated list of types so a single run can
+// generate methods for multiple types. The default output file is t_string.go,
+// where t is the lower-cased name of the first type listed. It can be overridden
+// with the -output flag.
+//
+package main // import "golang.org/x/tools/cmd/stringer"
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/build"
+	exact "go/constant"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+var (
+	typeNames   = flag.String("type", "", "comma-separated list of type names; must be set")
+	output      = flag.String("output", "", "output file name; default srcdir/<type>_string.go")
+	trimprefix  = flag.String("trimprefix", "", "trim the `prefix` from the generated constant names")
+	linecomment = flag.Bool("linecomment", false, "use line comment text as printed text when present")
+)
+
+// Usage is a replacement usage function for the flags package.
+func Usage() {
+	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+	fmt.Fprintf(os.Stderr, "\tstringer [flags] -type T [directory]\n")
+	fmt.Fprintf(os.Stderr, "\tstringer [flags] -type T files... # Must be a single package\n")
+	fmt.Fprintf(os.Stderr, "For more information, see:\n")
+	fmt.Fprintf(os.Stderr, "\thttp://godoc.org/golang.org/x/tools/cmd/stringer\n")
+	fmt.Fprintf(os.Stderr, "Flags:\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("stringer: ")
+	flag.Usage = Usage
+	flag.Parse()
+	if len(*typeNames) == 0 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	types := strings.Split(*typeNames, ",")
+
+	// We accept either one directory or a list of files. Which do we have?
+	args := flag.Args()
+	if len(args) == 0 {
+		// Default: process whole package in current directory.
+		args = []string{"."}
+	}
+
+	// Parse the package once.
+	var dir string
+	g := Generator{
+		trimPrefix:  *trimprefix,
+		lineComment: *linecomment,
+	}
+	if len(args) == 1 && isDirectory(args[0]) {
+		dir = args[0]
+		g.parsePackageDir(args[0])
+	} else {
+		dir = filepath.Dir(args[0])
+		g.parsePackageFiles(args)
+	}
+
+	// Print the header and package clause.
+	g.Printf("// Code generated by \"stringer %s\"; DO NOT EDIT.\n", strings.Join(os.Args[1:], " "))
+	g.Printf("\n")
+	g.Printf("package %s", g.pkg.name)
+	g.Printf("\n")
+	g.Printf("import \"strconv\"\n") // Used by all methods.
+
+	// Run generate for each type.
+	for _, typeName := range types {
+		g.generate(typeName)
+	}
+
+	// Format the output.
+	src := g.format()
+
+	// Write to file.
+	outputName := *output
+	if outputName == "" {
+		baseName := fmt.Sprintf("%s_string.go", types[0])
+		outputName = filepath.Join(dir, strings.ToLower(baseName))
+	}
+	err := ioutil.WriteFile(outputName, src, 0644)
+	if err != nil {
+		log.Fatalf("writing output: %s", err)
+	}
+}
+
+// isDirectory reports whether the named file is a directory.
+func isDirectory(name string) bool {
+	info, err := os.Stat(name)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return info.IsDir()
+}
+
+// Generator holds the state of the analysis. Primarily used to buffer
+// the output for format.Source.
+type Generator struct {
+	buf bytes.Buffer // Accumulated output.
+	pkg *Package     // Package we are scanning.
+
+	trimPrefix  string
+	lineComment bool
+}
+
+func (g *Generator) Printf(format string, args ...interface{}) {
+	fmt.Fprintf(&g.buf, format, args...)
+}
+
+// File holds a single parsed file and associated data.
+type File struct {
+	pkg  *Package  // Package to which this file belongs.
+	file *ast.File // Parsed AST.
+	// These fields are reset for each type being generated.
+	typeName string  // Name of the constant type.
+	values   []Value // Accumulator for constant values of that type.
+
+	trimPrefix  string
+	lineComment bool
+}
+
+type Package struct {
+	dir      string
+	name     string
+	defs     map[*ast.Ident]types.Object
+	files    []*File
+	typesPkg *types.Package
+}
+
+// parsePackageDir parses the package residing in the directory.
+func (g *Generator) parsePackageDir(directory string) {
+	pkg, err := build.Default.ImportDir(directory, 0)
+	if err != nil {
+		log.Fatalf("cannot process directory %s: %s", directory, err)
+	}
+	var names []string
+	names = append(names, pkg.GoFiles...)
+	names = append(names, pkg.CgoFiles...)
+	// TODO: Need to think about constants in test files. Maybe write type_string_test.go
+	// in a separate pass? For later.
+	// names = append(names, pkg.TestGoFiles...) // These are also in the "foo" package.
+	names = append(names, pkg.SFiles...)
+	names = prefixDirectory(directory, names)
+	g.parsePackage(directory, names, nil)
+}
+
+// parsePackageFiles parses the package occupying the named files.
+func (g *Generator) parsePackageFiles(names []string) {
+	g.parsePackage(".", names, nil)
+}
+
+// prefixDirectory places the directory name on the beginning of each name in the list.
+func prefixDirectory(directory string, names []string) []string {
+	if directory == "." {
+		return names
+	}
+	ret := make([]string, len(names))
+	for i, name := range names {
+		ret[i] = filepath.Join(directory, name)
+	}
+	return ret
+}
+
+// parsePackage analyzes the single package constructed from the named files.
+// If text is non-nil, it is a string to be used instead of the content of the file,
+// to be used for testing. parsePackage exits if there is an error.
+func (g *Generator) parsePackage(directory string, names []string, text interface{}) {
+	var files []*File
+	var astFiles []*ast.File
+	g.pkg = new(Package)
+	fs := token.NewFileSet()
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".go") {
+			continue
+		}
+		parsedFile, err := parser.ParseFile(fs, name, text, parser.ParseComments)
+		if err != nil {
+			log.Fatalf("parsing package: %s: %s", name, err)
+		}
+		astFiles = append(astFiles, parsedFile)
+		files = append(files, &File{
+			file:        parsedFile,
+			pkg:         g.pkg,
+			trimPrefix:  g.trimPrefix,
+			lineComment: g.lineComment,
+		})
+	}
+	if len(astFiles) == 0 {
+		log.Fatalf("%s: no buildable Go files", directory)
+	}
+	g.pkg.name = astFiles[0].Name.Name
+	g.pkg.files = files
+	g.pkg.dir = directory
+	// Type check the package.
+	g.pkg.check(fs, astFiles)
+}
+
+// check type-checks the package. The package must be OK to proceed.
+func (pkg *Package) check(fs *token.FileSet, astFiles []*ast.File) {
+	pkg.defs = make(map[*ast.Ident]types.Object)
+	config := types.Config{Importer: defaultImporter(), FakeImportC: true}
+	info := &types.Info{
+		Defs: pkg.defs,
+	}
+	typesPkg, err := config.Check(pkg.dir, fs, astFiles, info)
+	if err != nil {
+		log.Fatalf("checking package: %s", err)
+	}
+	pkg.typesPkg = typesPkg
+}
+
+// generate produces the String method for the named type.
+func (g *Generator) generate(typeName string) {
+	values := make([]Value, 0, 100)
+	for _, file := range g.pkg.files {
+		// Set the state for this run of the walker.
+		file.typeName = typeName
+		file.values = nil
+		if file.file != nil {
+			ast.Inspect(file.file, file.genDecl)
+			values = append(values, file.values...)
+		}
+	}
+
+	if len(values) == 0 {
+		log.Fatalf("no values defined for type %s", typeName)
+	}
+	runs := splitIntoRuns(values)
+	// The decision of which pattern to use depends on the number of
+	// runs in the numbers. If there's only one, it's easy. For more than
+	// one, there's a tradeoff between complexity and size of the data
+	// and code vs. the simplicity of a map. A map takes more space,
+	// but so does the code. The decision here (crossover at 10) is
+	// arbitrary, but considers that for large numbers of runs the cost
+	// of the linear scan in the switch might become important, and
+	// rather than use yet another algorithm such as binary search,
+	// we punt and use a map. In any case, the likelihood of a map
+	// being necessary for any realistic example other than bitmasks
+	// is very low. And bitmasks probably deserve their own analysis,
+	// to be done some other day.
+	switch {
+	case len(runs) == 1:
+		g.buildOneRun(runs, typeName)
+	case len(runs) <= 10:
+		g.buildMultipleRuns(runs, typeName)
+	default:
+		g.buildMap(runs, typeName)
+	}
+}
+
+// splitIntoRuns breaks the values into runs of contiguous sequences.
+// For example, given 1,2,3,5,6,7 it returns {1,2,3},{5,6,7}.
+// The input slice is known to be non-empty.
+func splitIntoRuns(values []Value) [][]Value {
+	// We use stable sort so the lexically first name is chosen for equal elements.
+	sort.Stable(byValue(values))
+	// Remove duplicates. Stable sort has put the one we want to print first,
+	// so use that one. The String method won't care about which named constant
+	// was the argument, so the first name for the given value is the only one to keep.
+	// We need to do this because identical values would cause the switch or map
+	// to fail to compile.
+	j := 1
+	for i := 1; i < len(values); i++ {
+		if values[i].value != values[i-1].value {
+			values[j] = values[i]
+			j++
+		}
+	}
+	values = values[:j]
+	runs := make([][]Value, 0, 10)
+	for len(values) > 0 {
+		// One contiguous sequence per outer loop.
+		i := 1
+		for i < len(values) && values[i].value == values[i-1].value+1 {
+			i++
+		}
+		runs = append(runs, values[:i])
+		values = values[i:]
+	}
+	return runs
+}
+
+// format returns the gofmt-ed contents of the Generator's buffer.
+func (g *Generator) format() []byte {
+	src, err := format.Source(g.buf.Bytes())
+	if err != nil {
+		// Should never happen, but can arise when developing this code.
+		// The user can compile the output to see the error.
+		log.Printf("warning: internal error: invalid Go generated: %s", err)
+		log.Printf("warning: compile the package to analyze the error")
+		return g.buf.Bytes()
+	}
+	return src
+}
+
+// Value represents a declared constant.
+type Value struct {
+	name string // The name of the constant.
+	// The value is stored as a bit pattern alone. The boolean tells us
+	// whether to interpret it as an int64 or a uint64; the only place
+	// this matters is when sorting.
+	// Much of the time the str field is all we need; it is printed
+	// by Value.String.
+	value  uint64 // Will be converted to int64 when needed.
+	signed bool   // Whether the constant is a signed type.
+	str    string // The string representation given by the "go/exact" package.
+}
+
+func (v *Value) String() string {
+	return v.str
+}
+
+// byValue lets us sort the constants into increasing order.
+// We take care in the Less method to sort in signed or unsigned order,
+// as appropriate.
+type byValue []Value
+
+func (b byValue) Len() int      { return len(b) }
+func (b byValue) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b byValue) Less(i, j int) bool {
+	if b[i].signed {
+		return int64(b[i].value) < int64(b[j].value)
+	}
+	return b[i].value < b[j].value
+}
+
+// genDecl processes one declaration clause.
+func (f *File) genDecl(node ast.Node) bool {
+	decl, ok := node.(*ast.GenDecl)
+	if !ok || decl.Tok != token.CONST {
+		// We only care about const declarations.
+		return true
+	}
+	// The name of the type of the constants we are declaring.
+	// Can change if this is a multi-element declaration.
+	typ := ""
+	// Loop over the elements of the declaration. Each element is a ValueSpec:
+	// a list of names possibly followed by a type, possibly followed by values.
+	// If the type and value are both missing, we carry down the type (and value,
+	// but the "go/types" package takes care of that).
+	for _, spec := range decl.Specs {
+		vspec := spec.(*ast.ValueSpec) // Guaranteed to succeed as this is CONST.
+		if vspec.Type == nil && len(vspec.Values) > 0 {
+			// "X = 1". With no type but a value, the constant is untyped.
+			// Skip this vspec and reset the remembered type.
+			typ = ""
+			continue
+		}
+		if vspec.Type != nil {
+			// "X T". We have a type. Remember it.
+			ident, ok := vspec.Type.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			typ = ident.Name
+		}
+		if typ != f.typeName {
+			// This is not the type we're looking for.
+			continue
+		}
+		// We now have a list of names (from one line of source code) all being
+		// declared with the desired type.
+		// Grab their names and actual values and store them in f.values.
+		for _, name := range vspec.Names {
+			if name.Name == "_" {
+				continue
+			}
+			// This dance lets the type checker find the values for us. It's a
+			// bit tricky: look up the object declared by the name, find its
+			// types.Const, and extract its value.
+			obj, ok := f.pkg.defs[name]
+			if !ok {
+				log.Fatalf("no value for constant %s", name)
+			}
+			info := obj.Type().Underlying().(*types.Basic).Info()
+			if info&types.IsInteger == 0 {
+				log.Fatalf("can't handle non-integer constant type %s", typ)
+			}
+			value := obj.(*types.Const).Val() // Guaranteed to succeed as this is CONST.
+			if value.Kind() != exact.Int {
+				log.Fatalf("can't happen: constant is not an integer %s", name)
+			}
+			i64, isInt := exact.Int64Val(value)
+			u64, isUint := exact.Uint64Val(value)
+			if !isInt && !isUint {
+				log.Fatalf("internal error: value of %s is not an integer: %s", name, value.String())
+			}
+			if !isInt {
+				u64 = uint64(i64)
+			}
+			v := Value{
+				name:   name.Name,
+				value:  u64,
+				signed: info&types.IsUnsigned == 0,
+				str:    value.String(),
+			}
+			if c := vspec.Comment; f.lineComment && c != nil && len(c.List) == 1 {
+				v.name = strings.TrimSpace(c.Text())
+			}
+			v.name = strings.TrimPrefix(v.name, f.trimPrefix)
+			f.values = append(f.values, v)
+		}
+	}
+	return false
+}
+
+// Helpers
+
+// usize returns the number of bits of the smallest unsigned integer
+// type that will hold n. Used to create the smallest possible slice of
+// integers to use as indexes into the concatenated strings.
+func usize(n int) int {
+	switch {
+	case n < 1<<8:
+		return 8
+	case n < 1<<16:
+		return 16
+	default:
+		// 2^32 is enough constants for anyone.
+		return 32
+	}
+}
+
+// declareIndexAndNameVars declares the index slices and concatenated names
+// strings representing the runs of values.
+func (g *Generator) declareIndexAndNameVars(runs [][]Value, typeName string) {
+	var indexes, names []string
+	for i, run := range runs {
+		index, name := g.createIndexAndNameDecl(run, typeName, fmt.Sprintf("_%d", i))
+		if len(run) != 1 {
+			indexes = append(indexes, index)
+		}
+		names = append(names, name)
+	}
+	g.Printf("const (\n")
+	for _, name := range names {
+		g.Printf("\t%s\n", name)
+	}
+	g.Printf(")\n\n")
+
+	if len(indexes) > 0 {
+		g.Printf("var (")
+		for _, index := range indexes {
+			g.Printf("\t%s\n", index)
+		}
+		g.Printf(")\n\n")
+	}
+}
+
+// declareIndexAndNameVar is the single-run version of declareIndexAndNameVars
+func (g *Generator) declareIndexAndNameVar(run []Value, typeName string) {
+	index, name := g.createIndexAndNameDecl(run, typeName, "")
+	g.Printf("const %s\n", name)
+	g.Printf("var %s\n", index)
+}
+
+// createIndexAndNameDecl returns the pair of declarations for the run. The caller will add "const" and "var".
+func (g *Generator) createIndexAndNameDecl(run []Value, typeName string, suffix string) (string, string) {
+	b := new(bytes.Buffer)
+	indexes := make([]int, len(run))
+	for i := range run {
+		b.WriteString(run[i].name)
+		indexes[i] = b.Len()
+	}
+	nameConst := fmt.Sprintf("_%s_name%s = %q", typeName, suffix, b.String())
+	nameLen := b.Len()
+	b.Reset()
+	fmt.Fprintf(b, "_%s_index%s = [...]uint%d{0, ", typeName, suffix, usize(nameLen))
+	for i, v := range indexes {
+		if i > 0 {
+			fmt.Fprintf(b, ", ")
+		}
+		fmt.Fprintf(b, "%d", v)
+	}
+	fmt.Fprintf(b, "}")
+	return b.String(), nameConst
+}
+
+// declareNameVars declares the concatenated names string representing all the values in the runs.
+func (g *Generator) declareNameVars(runs [][]Value, typeName string, suffix string) {
+	g.Printf("const _%s_name%s = \"", typeName, suffix)
+	for _, run := range runs {
+		for i := range run {
+			g.Printf("%s", run[i].name)
+		}
+	}
+	g.Printf("\"\n")
+}
+
+// buildOneRun generates the variables and String method for a single run of contiguous values.
+func (g *Generator) buildOneRun(runs [][]Value, typeName string) {
+	values := runs[0]
+	g.Printf("\n")
+	g.declareIndexAndNameVar(values, typeName)
+	// The generated code is simple enough to write as a Printf format.
+	lessThanZero := ""
+	if values[0].signed {
+		lessThanZero = "i < 0 || "
+	}
+	if values[0].value == 0 { // Signed or unsigned, 0 is still 0.
+		g.Printf(stringOneRun, typeName, usize(len(values)), lessThanZero)
+	} else {
+		g.Printf(stringOneRunWithOffset, typeName, values[0].String(), usize(len(values)), lessThanZero)
+	}
+}
+
+// Arguments to format are:
+//	[1]: type name
+//	[2]: size of index element (8 for uint8 etc.)
+//	[3]: less than zero check (for signed types)
+const stringOneRun = `func (i %[1]s) String() string {
+	if %[3]si >= %[1]s(len(_%[1]s_index)-1) {
+		return "%[1]s(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _%[1]s_name[_%[1]s_index[i]:_%[1]s_index[i+1]]
+}
+`
+
+// Arguments to format are:
+//	[1]: type name
+//	[2]: lowest defined value for type, as a string
+//	[3]: size of index element (8 for uint8 etc.)
+//	[4]: less than zero check (for signed types)
+/*
+ */
+const stringOneRunWithOffset = `func (i %[1]s) String() string {
+	i -= %[2]s
+	if %[4]si >= %[1]s(len(_%[1]s_index)-1) {
+		return "%[1]s(" + strconv.FormatInt(int64(i + %[2]s), 10) + ")"
+	}
+	return _%[1]s_name[_%[1]s_index[i] : _%[1]s_index[i+1]]
+}
+`
+
+// buildMultipleRuns generates the variables and String method for multiple runs of contiguous values.
+// For this pattern, a single Printf format won't do.
+func (g *Generator) buildMultipleRuns(runs [][]Value, typeName string) {
+	g.Printf("\n")
+	g.declareIndexAndNameVars(runs, typeName)
+	g.Printf("func (i %s) String() string {\n", typeName)
+	g.Printf("\tswitch {\n")
+	for i, values := range runs {
+		if len(values) == 1 {
+			g.Printf("\tcase i == %s:\n", &values[0])
+			g.Printf("\t\treturn _%s_name_%d\n", typeName, i)
+			continue
+		}
+		g.Printf("\tcase %s <= i && i <= %s:\n", &values[0], &values[len(values)-1])
+		if values[0].value != 0 {
+			g.Printf("\t\ti -= %s\n", &values[0])
+		}
+		g.Printf("\t\treturn _%s_name_%d[_%s_index_%d[i]:_%s_index_%d[i+1]]\n",
+			typeName, i, typeName, i, typeName, i)
+	}
+	g.Printf("\tdefault:\n")
+	g.Printf("\t\treturn \"%s(\" + strconv.FormatInt(int64(i), 10) + \")\"\n", typeName)
+	g.Printf("\t}\n")
+	g.Printf("}\n")
+}
+
+// buildMap handles the case where the space is so sparse a map is a reasonable fallback.
+// It's a rare situation but has simple code.
+func (g *Generator) buildMap(runs [][]Value, typeName string) {
+	g.Printf("\n")
+	g.declareNameVars(runs, typeName, "")
+	g.Printf("\nvar _%s_map = map[%s]string{\n", typeName, typeName)
+	n := 0
+	for _, values := range runs {
+		for _, value := range values {
+			g.Printf("\t%s: _%s_name[%d:%d],\n", &value, typeName, n, n+len(value.name))
+			n += len(value.name)
+		}
+	}
+	g.Printf("}\n\n")
+	g.Printf(stringMap, typeName)
+}
+
+// Argument to format is the type name.
+const stringMap = `func (i %[1]s) String() string {
+	if str, ok := _%[1]s_map[i]; ok {
+		return str
+	}
+	return "%[1]s(" + strconv.FormatInt(int64(i), 10) + ")"
+}
+`
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/cgo.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/cgo.go
new file mode 100644
index 0000000..ef38f95
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/cgo.go
@@ -0,0 +1,32 @@
+// 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.
+
+// Import "C" shouldn't be imported.
+
+package main
+
+/*
+#define HELLO 1
+*/
+import "C"
+
+import "fmt"
+
+type Cgo uint32
+
+const (
+	// MustScanSubDirs indicates that events were coalesced hierarchically.
+	MustScanSubDirs Cgo = 1 << iota
+)
+
+func main() {
+	_ = C.HELLO
+	ck(MustScanSubDirs, "MustScanSubDirs")
+}
+
+func ck(day Cgo, str string) {
+	if fmt.Sprint(day) != str {
+		panic("cgo.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/day.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/day.go
new file mode 100644
index 0000000..35fa8dc
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/day.go
@@ -0,0 +1,39 @@
+// 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.
+
+// Simple test: enumeration of type int starting at 0.
+
+package main
+
+import "fmt"
+
+type Day int
+
+const (
+	Monday Day = iota
+	Tuesday
+	Wednesday
+	Thursday
+	Friday
+	Saturday
+	Sunday
+)
+
+func main() {
+	ck(Monday, "Monday")
+	ck(Tuesday, "Tuesday")
+	ck(Wednesday, "Wednesday")
+	ck(Thursday, "Thursday")
+	ck(Friday, "Friday")
+	ck(Saturday, "Saturday")
+	ck(Sunday, "Sunday")
+	ck(-127, "Day(-127)")
+	ck(127, "Day(127)")
+}
+
+func ck(day Day, str string) {
+	if fmt.Sprint(day) != str {
+		panic("day.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/gap.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/gap.go
new file mode 100644
index 0000000..bc8a90c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/gap.go
@@ -0,0 +1,44 @@
+// 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.
+
+// Gaps and an offset.
+
+package main
+
+import "fmt"
+
+type Gap int
+
+const (
+	Two    Gap = 2
+	Three  Gap = 3
+	Five   Gap = 5
+	Six    Gap = 6
+	Seven  Gap = 7
+	Eight  Gap = 8
+	Nine   Gap = 9
+	Eleven Gap = 11
+)
+
+func main() {
+	ck(0, "Gap(0)")
+	ck(1, "Gap(1)")
+	ck(Two, "Two")
+	ck(Three, "Three")
+	ck(4, "Gap(4)")
+	ck(Five, "Five")
+	ck(Six, "Six")
+	ck(Seven, "Seven")
+	ck(Eight, "Eight")
+	ck(Nine, "Nine")
+	ck(10, "Gap(10)")
+	ck(Eleven, "Eleven")
+	ck(12, "Gap(12)")
+}
+
+func ck(gap Gap, str string) {
+	if fmt.Sprint(gap) != str {
+		panic("gap.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/num.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/num.go
new file mode 100644
index 0000000..0d5ab10
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/num.go
@@ -0,0 +1,35 @@
+// 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.
+
+// Signed integers spanning zero.
+
+package main
+
+import "fmt"
+
+type Num int
+
+const (
+	m_2 Num = -2 + iota
+	m_1
+	m0
+	m1
+	m2
+)
+
+func main() {
+	ck(-3, "Num(-3)")
+	ck(m_2, "m_2")
+	ck(m_1, "m_1")
+	ck(m0, "m0")
+	ck(m1, "m1")
+	ck(m2, "m2")
+	ck(3, "Num(3)")
+}
+
+func ck(num Num, str string) {
+	if fmt.Sprint(num) != str {
+		panic("num.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/number.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/number.go
new file mode 100644
index 0000000..7f1c824
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/number.go
@@ -0,0 +1,34 @@
+// 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.
+
+// Enumeration with an offset.
+// Also includes a duplicate.
+
+package main
+
+import "fmt"
+
+type Number int
+
+const (
+	_ Number = iota
+	One
+	Two
+	Three
+	AnotherOne = One // Duplicate; note that AnotherOne doesn't appear below.
+)
+
+func main() {
+	ck(One, "One")
+	ck(Two, "Two")
+	ck(Three, "Three")
+	ck(AnotherOne, "One")
+	ck(127, "Number(127)")
+}
+
+func ck(num Number, str string) {
+	if fmt.Sprint(num) != str {
+		panic("number.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/prime.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/prime.go
new file mode 100644
index 0000000..f551a1a
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/prime.go
@@ -0,0 +1,56 @@
+// 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.
+
+// Enough gaps to trigger a map implementation of the method.
+// Also includes a duplicate to test that it doesn't cause problems
+
+package main
+
+import "fmt"
+
+type Prime int
+
+const (
+	p2  Prime = 2
+	p3  Prime = 3
+	p5  Prime = 5
+	p7  Prime = 7
+	p77 Prime = 7 // Duplicate; note that p77 doesn't appear below.
+	p11 Prime = 11
+	p13 Prime = 13
+	p17 Prime = 17
+	p19 Prime = 19
+	p23 Prime = 23
+	p29 Prime = 29
+	p37 Prime = 31
+	p41 Prime = 41
+	p43 Prime = 43
+)
+
+func main() {
+	ck(0, "Prime(0)")
+	ck(1, "Prime(1)")
+	ck(p2, "p2")
+	ck(p3, "p3")
+	ck(4, "Prime(4)")
+	ck(p5, "p5")
+	ck(p7, "p7")
+	ck(p77, "p7")
+	ck(p11, "p11")
+	ck(p13, "p13")
+	ck(p17, "p17")
+	ck(p19, "p19")
+	ck(p23, "p23")
+	ck(p29, "p29")
+	ck(p37, "p37")
+	ck(p41, "p41")
+	ck(p43, "p43")
+	ck(44, "Prime(44)")
+}
+
+func ck(prime Prime, str string) {
+	if fmt.Sprint(prime) != str {
+		panic("prime.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/unum.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/unum.go
new file mode 100644
index 0000000..2f8508f
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/unum.go
@@ -0,0 +1,38 @@
+// 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.
+
+// Unsigned integers spanning zero.
+
+package main
+
+import "fmt"
+
+type Unum uint8
+
+const (
+	m_2 Unum = iota + 253
+	m_1
+)
+
+const (
+	m0 Unum = iota
+	m1
+	m2
+)
+
+func main() {
+	ck(^Unum(0)-3, "Unum(252)")
+	ck(m_2, "m_2")
+	ck(m_1, "m_1")
+	ck(m0, "m0")
+	ck(m1, "m1")
+	ck(m2, "m2")
+	ck(3, "Unum(3)")
+}
+
+func ck(unum Unum, str string) {
+	if fmt.Sprint(unum) != str {
+		panic("unum.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/testdata/unum2.go b/vendor/golang.org/x/tools/cmd/stringer/testdata/unum2.go
new file mode 100644
index 0000000..edbbedf
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/testdata/unum2.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.
+
+// Unsigned integers - check maximum size
+
+package main
+
+import "fmt"
+
+type Unum2 uint8
+
+const (
+	Zero Unum2 = iota
+	One
+	Two
+)
+
+func main() {
+	ck(Zero, "Zero")
+	ck(One, "One")
+	ck(Two, "Two")
+	ck(3, "Unum2(3)")
+	ck(255, "Unum2(255)")
+}
+
+func ck(unum Unum2, str string) {
+	if fmt.Sprint(unum) != str {
+		panic("unum.go: " + str)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/stringer/util_test.go b/vendor/golang.org/x/tools/cmd/stringer/util_test.go
new file mode 100644
index 0000000..1aeba6e
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/util_test.go
@@ -0,0 +1,77 @@
+// 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 contains tests for some of the internal functions.
+
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+// Helpers to save typing in the test cases.
+type u []uint64
+type uu [][]uint64
+
+type SplitTest struct {
+	input  u
+	output uu
+	signed bool
+}
+
+var (
+	m2  = uint64(2)
+	m1  = uint64(1)
+	m0  = uint64(0)
+	m_1 = ^uint64(0)     // -1 when signed.
+	m_2 = ^uint64(0) - 1 // -2 when signed.
+)
+
+var splitTests = []SplitTest{
+	// No need for a test for the empty case; that's picked off before splitIntoRuns.
+	// Single value.
+	{u{1}, uu{u{1}}, false},
+	// Out of order.
+	{u{3, 2, 1}, uu{u{1, 2, 3}}, true},
+	// Out of order.
+	{u{3, 2, 1}, uu{u{1, 2, 3}}, false},
+	// A gap at the beginning.
+	{u{1, 33, 32, 31}, uu{u{1}, u{31, 32, 33}}, true},
+	// A gap in the middle, in mixed order.
+	{u{33, 7, 32, 31, 9, 8}, uu{u{7, 8, 9}, u{31, 32, 33}}, true},
+	// Gaps throughout
+	{u{33, 44, 1, 32, 45, 31}, uu{u{1}, u{31, 32, 33}, u{44, 45}}, true},
+	// Unsigned values spanning 0.
+	{u{m1, m0, m_1, m2, m_2}, uu{u{m0, m1, m2}, u{m_2, m_1}}, false},
+	// Signed values spanning 0
+	{u{m1, m0, m_1, m2, m_2}, uu{u{m_2, m_1, m0, m1, m2}}, true},
+}
+
+func TestSplitIntoRuns(t *testing.T) {
+Outer:
+	for n, test := range splitTests {
+		values := make([]Value, len(test.input))
+		for i, v := range test.input {
+			values[i] = Value{"", v, test.signed, fmt.Sprint(v)}
+		}
+		runs := splitIntoRuns(values)
+		if len(runs) != len(test.output) {
+			t.Errorf("#%d: %v: got %d runs; expected %d", n, test.input, len(runs), len(test.output))
+			continue
+		}
+		for i, run := range runs {
+			if len(run) != len(test.output[i]) {
+				t.Errorf("#%d: got %v; expected %v", n, runs, test.output)
+				continue Outer
+			}
+			for j, v := range run {
+				if v.value != test.output[i][j] {
+					t.Errorf("#%d: got %v; expected %v", n, runs, test.output)
+					continue Outer
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/tip/Dockerfile b/vendor/golang.org/x/tools/cmd/tip/Dockerfile
new file mode 100644
index 0000000..51cf6d3
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/Dockerfile
@@ -0,0 +1,143 @@
+FROM golang:1.9
+
+RUN apt-get update && apt-get install --no-install-recommends -y -q build-essential git
+
+# golang puts its go install here (weird but true)
+ENV GOROOT_BOOTSTRAP /usr/local/go
+
+# BEGIN deps (run `make update-deps` to update)
+
+# Repo cloud.google.com/go at 1d0c2da (2018-01-30)
+ENV REV=1d0c2da40456a9b47f5376165f275424acc15c09
+RUN go get -d cloud.google.com/go/compute/metadata `#and 6 other pkgs` &&\
+    (cd /go/src/cloud.google.com/go && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo github.com/golang/protobuf at 9255415 (2018-01-25)
+ENV REV=925541529c1fa6821df4e44ce2723319eb2be768
+RUN go get -d github.com/golang/protobuf/proto `#and 6 other pkgs` &&\
+    (cd /go/src/github.com/golang/protobuf && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo github.com/googleapis/gax-go at 317e000 (2017-09-15)
+ENV REV=317e0006254c44a0ac427cc52a0e083ff0b9622f
+RUN go get -d github.com/googleapis/gax-go &&\
+    (cd /go/src/github.com/googleapis/gax-go && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo golang.org/x/build at e879390 (2018-02-01)
+ENV REV=e8793909ba350594eea4c7c6bdb0f0d9a0d0f77a
+RUN go get -d golang.org/x/build/autocertcache &&\
+    (cd /go/src/golang.org/x/build && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo golang.org/x/crypto at 1875d0a (2018-01-27)
+ENV REV=1875d0a70c90e57f11972aefd42276df65e895b9
+RUN go get -d golang.org/x/crypto/acme `#and 2 other pkgs` &&\
+    (cd /go/src/golang.org/x/crypto && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo golang.org/x/net at 6d90978 (2018-02-01)
+ENV REV=6d90978dc4889d44e8cfbd04c05d17b5417823c7
+RUN go get -d golang.org/x/net/context `#and 8 other pkgs` &&\
+    (cd /go/src/golang.org/x/net && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo golang.org/x/oauth2 at 30785a2 (2018-01-04)
+ENV REV=30785a2c434e431ef7c507b54617d6a951d5f2b4
+RUN go get -d golang.org/x/oauth2 `#and 5 other pkgs` &&\
+    (cd /go/src/golang.org/x/oauth2 && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo golang.org/x/text at e19ae14 (2017-12-27)
+ENV REV=e19ae1496984b1c655b8044a65c0300a3c878dd3
+RUN go get -d golang.org/x/text/secure/bidirule `#and 4 other pkgs` &&\
+    (cd /go/src/golang.org/x/text && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo google.golang.org/api at 7d0e2d3 (2018-01-30)
+ENV REV=7d0e2d350555821bef5a5b8aecf0d12cc1def633
+RUN go get -d google.golang.org/api/gensupport `#and 9 other pkgs` &&\
+    (cd /go/src/google.golang.org/api && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo google.golang.org/genproto at 4eb30f4 (2018-01-25)
+ENV REV=4eb30f4778eed4c258ba66527a0d4f9ec8a36c45
+RUN go get -d google.golang.org/genproto/googleapis/api/annotations `#and 3 other pkgs` &&\
+    (cd /go/src/google.golang.org/genproto && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Repo google.golang.org/grpc at 0bd008f (2018-01-25)
+ENV REV=0bd008f5fadb62d228f12b18d016709e8139a7af
+RUN go get -d google.golang.org/grpc `#and 23 other pkgs` &&\
+    (cd /go/src/google.golang.org/grpc && (git cat-file -t $REV 2>/dev/null || git fetch -q origin $REV) && git reset --hard $REV)
+
+# Optimization to speed up iterative development, not necessary for correctness:
+RUN go install cloud.google.com/go/compute/metadata \
+	cloud.google.com/go/iam \
+	cloud.google.com/go/internal \
+	cloud.google.com/go/internal/optional \
+	cloud.google.com/go/internal/version \
+	cloud.google.com/go/storage \
+	github.com/golang/protobuf/proto \
+	github.com/golang/protobuf/protoc-gen-go/descriptor \
+	github.com/golang/protobuf/ptypes \
+	github.com/golang/protobuf/ptypes/any \
+	github.com/golang/protobuf/ptypes/duration \
+	github.com/golang/protobuf/ptypes/timestamp \
+	github.com/googleapis/gax-go \
+	golang.org/x/build/autocertcache \
+	golang.org/x/crypto/acme \
+	golang.org/x/crypto/acme/autocert \
+	golang.org/x/net/context \
+	golang.org/x/net/context/ctxhttp \
+	golang.org/x/net/http2 \
+	golang.org/x/net/http2/hpack \
+	golang.org/x/net/idna \
+	golang.org/x/net/internal/timeseries \
+	golang.org/x/net/lex/httplex \
+	golang.org/x/net/trace \
+	golang.org/x/oauth2 \
+	golang.org/x/oauth2/google \
+	golang.org/x/oauth2/internal \
+	golang.org/x/oauth2/jws \
+	golang.org/x/oauth2/jwt \
+	golang.org/x/text/secure/bidirule \
+	golang.org/x/text/transform \
+	golang.org/x/text/unicode/bidi \
+	golang.org/x/text/unicode/norm \
+	google.golang.org/api/gensupport \
+	google.golang.org/api/googleapi \
+	google.golang.org/api/googleapi/internal/uritemplates \
+	google.golang.org/api/googleapi/transport \
+	google.golang.org/api/internal \
+	google.golang.org/api/iterator \
+	google.golang.org/api/option \
+	google.golang.org/api/storage/v1 \
+	google.golang.org/api/transport/http \
+	google.golang.org/genproto/googleapis/api/annotations \
+	google.golang.org/genproto/googleapis/iam/v1 \
+	google.golang.org/genproto/googleapis/rpc/status \
+	google.golang.org/grpc \
+	google.golang.org/grpc/balancer \
+	google.golang.org/grpc/balancer/base \
+	google.golang.org/grpc/balancer/roundrobin \
+	google.golang.org/grpc/codes \
+	google.golang.org/grpc/connectivity \
+	google.golang.org/grpc/credentials \
+	google.golang.org/grpc/encoding \
+	google.golang.org/grpc/encoding/proto \
+	google.golang.org/grpc/grpclb/grpc_lb_v1/messages \
+	google.golang.org/grpc/grpclog \
+	google.golang.org/grpc/internal \
+	google.golang.org/grpc/keepalive \
+	google.golang.org/grpc/metadata \
+	google.golang.org/grpc/naming \
+	google.golang.org/grpc/peer \
+	google.golang.org/grpc/resolver \
+	google.golang.org/grpc/resolver/dns \
+	google.golang.org/grpc/resolver/passthrough \
+	google.golang.org/grpc/stats \
+	google.golang.org/grpc/status \
+	google.golang.org/grpc/tap \
+	google.golang.org/grpc/transport
+# END deps.
+
+# golang sets GOPATH=/go
+ADD . /go/src/tip
+RUN go install --tags=autocert tip
+ENTRYPOINT ["/go/bin/tip"]
+
+# We listen on 8080 (for historical reasons). The service.yaml maps public port 80 to 8080.
+# We also listen on 443 for LetsEncrypt TLS.
+EXPOSE 8080 443
diff --git a/vendor/golang.org/x/tools/cmd/tip/Makefile b/vendor/golang.org/x/tools/cmd/tip/Makefile
new file mode 100644
index 0000000..7902688
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/Makefile
@@ -0,0 +1,25 @@
+# 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.
+
+VERSION=v2
+
+.PHONY: usage
+
+usage:
+	echo "See Makefile"
+	exit 1
+
+update-deps:
+	go install golang.org/x/build/cmd/gitlock
+	gitlock --update=Dockerfile --ignore=NONE --tags=autocert golang.org/x/tools/cmd/tip
+
+docker-prod: Dockerfile
+	docker build -f Dockerfile --tag=gcr.io/symbolic-datum-552/tip:$(VERSION) .
+docker-dev: Dockerfile
+	docker build -f Dockerfile --tag=gcr.io/go-dashboard-dev/tip:$(VERSION) .
+
+push-prod: docker-prod
+	gcloud docker -- push gcr.io/symbolic-datum-552/tip:$(VERSION)
+push-dev: docker-dev
+	gcloud docker -- push gcr.io/go-dashboard-dev/tip:$(VERSION)
diff --git a/vendor/golang.org/x/tools/cmd/tip/README b/vendor/golang.org/x/tools/cmd/tip/README
new file mode 100644
index 0000000..b96c107
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/README
@@ -0,0 +1,32 @@
+============================================================
+Old instructions, only valid for talks.golang.org:
+============================================================
+
+1. Deploy the app.
+
+   To deploy tip.golang.org:
+       (See Kubernetes instruction below.)
+
+   To deploy talks.golang.org:
+       $ gcloud --project golang-org app deploy --no-promote talks.yaml
+
+2. Wait until the deployed version is serving requests.
+
+3. Go to the developer console and upgrade the default version.
+   https://console.developers.google.com/appengine/versions?project=golang-org&moduleId=tip
+
+4. Clean up any old versions (they continue to use at least one instance).
+
+============================================================
+New Kubernetes instructions, for tip.golang.org:
+============================================================
+
+Kubernetes instructions:
+
+ * build & push images (see Makefile for helpers)
+ * create/update resources:
+   - kubectl create -f tip-rc.yaml
+   - kubectl create -f tip-service.yaml
+
+TODO(bradfitz): flesh out these instructions as I gain experience
+with updating this over time. Also: move talks.golang.org to GKE too?
diff --git a/vendor/golang.org/x/tools/cmd/tip/cert.go b/vendor/golang.org/x/tools/cmd/tip/cert.go
new file mode 100644
index 0000000..f912cf3
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/cert.go
@@ -0,0 +1,63 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build autocert
+
+// This file contains autocert and cloud.google.com/go/storage
+// dependencies we want to hide by default from the Go build system,
+// which currently doesn't know how to fetch non-golang.org/x/*
+// dependencies. The Dockerfile builds the production binary
+// with this code using --tags=autocert.
+
+package main
+
+import (
+	"context"
+	"crypto/tls"
+	"log"
+	"net/http"
+
+	"cloud.google.com/go/storage"
+	"golang.org/x/build/autocertcache"
+	"golang.org/x/crypto/acme/autocert"
+)
+
+func init() {
+	runHTTPS = runHTTPSAutocert
+	certInit = certInitAutocert
+	wrapHTTPMux = wrapHTTPMuxAutocert
+}
+
+var autocertManager *autocert.Manager
+
+func certInitAutocert() {
+	var cache autocert.Cache
+	if b := *autoCertCacheBucket; b != "" {
+		sc, err := storage.NewClient(context.Background())
+		if err != nil {
+			log.Fatalf("storage.NewClient: %v", err)
+		}
+		cache = autocertcache.NewGoogleCloudStorageCache(sc, b)
+	}
+	autocertManager = &autocert.Manager{
+		Prompt:     autocert.AcceptTOS,
+		HostPolicy: autocert.HostWhitelist(*autoCertDomain),
+		Cache:      cache,
+	}
+}
+
+func runHTTPSAutocert(h http.Handler) error {
+	s := &http.Server{
+		Addr:    ":https",
+		Handler: h,
+		TLSConfig: &tls.Config{
+			GetCertificate: autocertManager.GetCertificate,
+		},
+	}
+	return s.ListenAndServeTLS("", "")
+}
+
+func wrapHTTPMuxAutocert(h http.Handler) http.Handler {
+	return autocertManager.HTTPHandler(h)
+}
diff --git a/vendor/golang.org/x/tools/cmd/tip/godoc.go b/vendor/golang.org/x/tools/cmd/tip/godoc.go
new file mode 100644
index 0000000..a01b8ca
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/godoc.go
@@ -0,0 +1,73 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+type godocBuilder struct {
+}
+
+func (b godocBuilder) Signature(heads map[string]string) string {
+	return fmt.Sprintf("go=%v/tools=%v", heads["go"], heads["tools"])
+}
+
+func (b godocBuilder) Init(dir, hostport string, heads map[string]string) (*exec.Cmd, error) {
+	goDir := filepath.Join(dir, "go")
+	toolsDir := filepath.Join(dir, "gopath/src/golang.org/x/tools")
+	if err := checkout(repoURL+"go", heads["go"], goDir); err != nil {
+		return nil, err
+	}
+	if err := checkout(repoURL+"tools", heads["tools"], toolsDir); err != nil {
+		return nil, err
+	}
+
+	make := exec.Command(filepath.Join(goDir, "src/make.bash"))
+	make.Dir = filepath.Join(goDir, "src")
+	if err := runErr(make); err != nil {
+		return nil, err
+	}
+	goBin := filepath.Join(goDir, "bin/go")
+	goPath := filepath.Join(dir, "gopath")
+	install := exec.Command(goBin, "install", "golang.org/x/tools/cmd/godoc")
+	install.Env = []string{
+		"GOROOT=" + goDir,
+		"GOPATH=" + goPath,
+		"GOROOT_BOOTSTRAP=" + os.Getenv("GOROOT_BOOTSTRAP"),
+	}
+	if err := runErr(install); err != nil {
+		return nil, err
+	}
+
+	godocBin := filepath.Join(goPath, "bin/godoc")
+	godoc := exec.Command(godocBin, "-http="+hostport, "-index", "-index_interval=-1s")
+	godoc.Env = []string{"GOROOT=" + goDir}
+	// TODO(adg): log this somewhere useful
+	godoc.Stdout = os.Stdout
+	godoc.Stderr = os.Stderr
+	if err := godoc.Start(); err != nil {
+		return nil, err
+	}
+	return godoc, nil
+}
+
+var indexingMsg = []byte("Indexing in progress: result may be inaccurate")
+
+func (b godocBuilder) HealthCheck(hostport string) error {
+	body, err := getOK(fmt.Sprintf("http://%v/search?q=FALLTHROUGH", hostport))
+	if err != nil {
+		return err
+	}
+	if bytes.Contains(body, indexingMsg) {
+		return errors.New("still indexing")
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/tip/godoc.yaml b/vendor/golang.org/x/tools/cmd/tip/godoc.yaml
new file mode 100644
index 0000000..64dbb7d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/godoc.yaml
@@ -0,0 +1,17 @@
+module: tip
+runtime: custom
+vm: true
+
+manual_scaling:
+  instances: 4
+
+env_variables:
+  TIP_BUILDER: 'godoc'
+
+health_check:
+  enable_health_check: True
+  check_interval_sec: 5
+  timeout_sec: 4
+  unhealthy_threshold: 2
+  healthy_threshold: 2
+  restart_threshold: 240
diff --git a/vendor/golang.org/x/tools/cmd/tip/talks.go b/vendor/golang.org/x/tools/cmd/tip/talks.go
new file mode 100644
index 0000000..a1a7a95
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/talks.go
@@ -0,0 +1,73 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+type talksBuilder struct {
+}
+
+func (b talksBuilder) Signature(heads map[string]string) string {
+	return heads["talks"]
+}
+
+const talksToolsRev = "8cab8a1319f0be9798e7fe78b15da75e5f94b2e9"
+
+func (b talksBuilder) Init(dir, hostport string, heads map[string]string) (*exec.Cmd, error) {
+	toolsDir := filepath.Join(dir, "gopath/src/golang.org/x/tools")
+	if err := checkout(repoURL+"tools", talksToolsRev, toolsDir); err != nil {
+		return nil, err
+	}
+	talksDir := filepath.Join(dir, "gopath/src/golang.org/x/talks")
+	if err := checkout(repoURL+"talks", heads["talks"], talksDir); err != nil {
+		return nil, err
+	}
+
+	goDir := os.Getenv("GOROOT_BOOTSTRAP")
+	if goDir == "" {
+		goDir = runtime.GOROOT()
+	}
+	goBin := filepath.Join(goDir, "bin/go")
+	goPath := filepath.Join(dir, "gopath")
+	presentPath := "golang.org/x/tools/cmd/present"
+	install := exec.Command(goBin, "install", "-tags=appenginevm", presentPath)
+	install.Env = []string{"GOROOT=" + goDir, "GOPATH=" + goPath}
+	if err := runErr(install); err != nil {
+		return nil, err
+	}
+
+	talksBin := filepath.Join(goPath, "bin/present")
+	presentSrc := filepath.Join(goPath, "src", presentPath)
+	present := exec.Command(talksBin, "-http="+hostport, "-base="+presentSrc)
+	present.Dir = talksDir
+	// TODO(adg): log this somewhere useful
+	present.Stdout = os.Stdout
+	present.Stderr = os.Stderr
+	if err := present.Start(); err != nil {
+		return nil, err
+	}
+	return present, nil
+}
+
+var talksMsg = []byte("Talks - The Go Programming Language")
+
+func (b talksBuilder) HealthCheck(hostport string) error {
+	body, err := getOK(fmt.Sprintf("http://%v/", hostport))
+	if err != nil {
+		return err
+	}
+	if !bytes.Contains(body, talksMsg) {
+		return errors.New("couldn't match string")
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/cmd/tip/talks.yaml b/vendor/golang.org/x/tools/cmd/tip/talks.yaml
new file mode 100644
index 0000000..24391a7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/talks.yaml
@@ -0,0 +1,12 @@
+service: talks
+runtime: custom
+env: flex
+
+manual_scaling:
+  instances: 1
+
+env_variables:
+  TIP_BUILDER: 'talks'
+
+health_check:
+  enable_health_check: False
diff --git a/vendor/golang.org/x/tools/cmd/tip/tip-rc.yaml b/vendor/golang.org/x/tools/cmd/tip/tip-rc.yaml
new file mode 100644
index 0000000..82af3b7
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/tip-rc.yaml
@@ -0,0 +1,40 @@
+apiVersion: v1
+kind: ReplicationController
+metadata:
+  name: tipgodoc
+spec:
+  replicas: 1
+  selector:
+    app: tipgodoc
+  template:
+    metadata:
+      name: tipgodoc
+      labels:
+        app: tipgodoc
+    spec:
+      volumes:
+      - name: cache-volume
+        emptyDir: {}
+      containers:
+      - name: gitmirror
+        image: gcr.io/symbolic-datum-552/tip:v2
+        imagePullPolicy: Always
+        command: ["/go/bin/tip", "--autocert=tip.golang.org", "--autocert-bucket=golang-tip-autocert"]
+        env:
+        - name: TMPDIR
+          value: /build
+        - name: TIP_BUILDER
+          value: godoc
+        volumeMounts:
+        - mountPath: /build
+          name: cache-volume
+        ports:
+        - containerPort: 8080
+        - containerPort: 443
+        resources:
+          requests:
+            cpu: "1"
+            memory: "2Gi"
+          limits:
+            cpu: "2"
+            memory: "4Gi"
diff --git a/vendor/golang.org/x/tools/cmd/tip/tip-service.yaml b/vendor/golang.org/x/tools/cmd/tip/tip-service.yaml
new file mode 100644
index 0000000..eeb2a1c
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/tip-service.yaml
@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: tipgodoc
+spec:
+  ports:
+    - port: 80
+      targetPort: 8080
+      name: http
+    - port: 443
+      targetPort: 443
+      name: https
+  selector:
+    app: tipgodoc
+  type: LoadBalancer
+  loadBalancerIP: 130.211.180.236
diff --git a/vendor/golang.org/x/tools/cmd/tip/tip.go b/vendor/golang.org/x/tools/cmd/tip/tip.go
new file mode 100644
index 0000000..91032dc
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/tip.go
@@ -0,0 +1,414 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Command tip is the tip.golang.org server,
+// serving the latest HEAD straight from the Git oven.
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+const (
+	repoURL      = "https://go.googlesource.com/"
+	metaURL      = "https://go.googlesource.com/?b=master&format=JSON"
+	startTimeout = 10 * time.Minute
+)
+
+var startTime = time.Now()
+
+var (
+	autoCertDomain      = flag.String("autocert", "", "if non-empty, listen on port 443 and serve a LetsEncrypt cert for this hostname")
+	autoCertCacheBucket = flag.String("autocert-bucket", "", "if non-empty, the Google Cloud Storage bucket in which to store the LetsEncrypt cache")
+)
+
+// Hooks that are set non-nil in cert.go if the "autocert" build tag
+// is used.
+var (
+	certInit    func()
+	runHTTPS    func(http.Handler) error
+	wrapHTTPMux func(http.Handler) http.Handler
+)
+
+func main() {
+	flag.Parse()
+
+	const k = "TIP_BUILDER"
+	var b Builder
+	switch os.Getenv(k) {
+	case "godoc":
+		b = godocBuilder{}
+	case "talks":
+		b = talksBuilder{}
+	default:
+		log.Fatalf("Unknown %v value: %q", k, os.Getenv(k))
+	}
+
+	if certInit != nil {
+		certInit()
+	}
+
+	p := &Proxy{builder: b}
+	go p.run()
+	mux := newServeMux(p)
+
+	log.Printf("Starting up tip server for builder %q", os.Getenv(k))
+
+	errc := make(chan error, 1)
+
+	go func() {
+		var httpMux http.Handler = mux
+		if wrapHTTPMux != nil {
+			httpMux = wrapHTTPMux(httpMux)
+		}
+		errc <- http.ListenAndServe(":8080", httpMux)
+	}()
+	if *autoCertDomain != "" {
+		if runHTTPS == nil {
+			errc <- errors.New("can't use --autocert without building binary with the autocert build tag")
+		} else {
+			go func() {
+				errc <- runHTTPS(mux)
+			}()
+		}
+		log.Printf("Listening on port 443 with LetsEncrypt support on domain %q", *autoCertDomain)
+	}
+	if err := <-errc; err != nil {
+		p.stop()
+		log.Fatal(err)
+	}
+}
+
+// Proxy implements the tip.golang.org server: a reverse-proxy
+// that builds and runs godoc instances showing the latest docs.
+type Proxy struct {
+	builder Builder
+
+	mu       sync.Mutex // protects the followin'
+	proxy    http.Handler
+	cur      string    // signature of gorepo+toolsrepo
+	cmd      *exec.Cmd // live godoc instance, or nil for none
+	side     string
+	hostport string // host and port of the live instance
+	err      error
+}
+
+type Builder interface {
+	Signature(heads map[string]string) string
+	Init(dir, hostport string, heads map[string]string) (*exec.Cmd, error)
+	HealthCheck(hostport string) error
+}
+
+func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path == "/_tipstatus" {
+		p.serveStatus(w, r)
+		return
+	}
+	p.mu.Lock()
+	proxy := p.proxy
+	err := p.err
+	p.mu.Unlock()
+	if proxy == nil {
+		s := "starting up"
+		if err != nil {
+			s = err.Error()
+		}
+		http.Error(w, s, http.StatusInternalServerError)
+		return
+	}
+	proxy.ServeHTTP(w, r)
+}
+
+func (p *Proxy) serveStatus(w http.ResponseWriter, r *http.Request) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	fmt.Fprintf(w, "side=%v\ncurrent=%v\nerror=%v\nuptime=%v\n", p.side, p.cur, p.err, int(time.Since(startTime).Seconds()))
+}
+
+func (p *Proxy) serveHealthCheck(w http.ResponseWriter, r *http.Request) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// NOTE: (App Engine only; not GKE) Status 502, 503, 504 are
+	// the only status codes that signify an unhealthy app.  So
+	// long as this handler returns one of those codes, this
+	// instance will not be sent any requests.
+	if p.proxy == nil {
+		log.Printf("Health check: not ready")
+		http.Error(w, "Not ready", http.StatusServiceUnavailable)
+		return
+	}
+
+	if err := p.builder.HealthCheck(p.hostport); err != nil {
+		log.Printf("Health check failed: %v", err)
+		http.Error(w, "Health check failed", http.StatusServiceUnavailable)
+		return
+	}
+	io.WriteString(w, "ok")
+}
+
+// run runs in its own goroutine.
+func (p *Proxy) run() {
+	p.side = "a"
+	for {
+		p.poll()
+		time.Sleep(30 * time.Second)
+	}
+}
+
+func (p *Proxy) stop() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if p.cmd != nil {
+		p.cmd.Process.Kill()
+	}
+}
+
+// poll runs from the run loop goroutine.
+func (p *Proxy) poll() {
+	heads := gerritMetaMap()
+	if heads == nil {
+		return
+	}
+
+	sig := p.builder.Signature(heads)
+
+	p.mu.Lock()
+	changes := sig != p.cur
+	curSide := p.side
+	p.cur = sig
+	p.mu.Unlock()
+
+	if !changes {
+		return
+	}
+
+	newSide := "b"
+	if curSide == "b" {
+		newSide = "a"
+	}
+
+	dir := filepath.Join(os.TempDir(), "tip", newSide)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		p.err = err
+		return
+	}
+	hostport := "localhost:8081"
+	if newSide == "b" {
+		hostport = "localhost:8082"
+	}
+	cmd, err := p.builder.Init(dir, hostport, heads)
+	if err != nil {
+		err = fmt.Errorf("builder.Init: %v", err)
+	} else {
+		go func() {
+			// TODO(adg,bradfitz): be smarter about dead processes
+			if err := cmd.Wait(); err != nil {
+				log.Printf("process in %v exited: %v", dir, err)
+			}
+		}()
+		err = waitReady(p.builder, hostport)
+		if err != nil {
+			cmd.Process.Kill()
+			err = fmt.Errorf("waitReady: %v", err)
+		}
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if err != nil {
+		log.Println(err)
+		p.err = err
+		return
+	}
+
+	u, err := url.Parse(fmt.Sprintf("http://%v/", hostport))
+	if err != nil {
+		err = fmt.Errorf("parsing hostport: %v", err)
+		log.Println(err)
+		p.err = err
+		return
+	}
+	p.proxy = httputil.NewSingleHostReverseProxy(u)
+	p.side = newSide
+	p.hostport = hostport
+	if p.cmd != nil {
+		p.cmd.Process.Kill()
+	}
+	p.cmd = cmd
+}
+
+func newServeMux(p *Proxy) http.Handler {
+	mux := http.NewServeMux()
+	mux.Handle("/", httpsOnlyHandler{p})
+	mux.HandleFunc("/_ah/health", p.serveHealthCheck)
+	return mux
+}
+
+func waitReady(b Builder, hostport string) error {
+	var err error
+	deadline := time.Now().Add(startTimeout)
+	for time.Now().Before(deadline) {
+		if err = b.HealthCheck(hostport); err == nil {
+			return nil
+		}
+		time.Sleep(time.Second)
+	}
+	return fmt.Errorf("timed out waiting for process at %v: %v", hostport, err)
+}
+
+func runErr(cmd *exec.Cmd) error {
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		if len(out) == 0 {
+			return err
+		}
+		return fmt.Errorf("%s\n%v", out, err)
+	}
+	return nil
+}
+
+func checkout(repo, hash, path string) error {
+	// Clone git repo if it doesn't exist.
+	if _, err := os.Stat(filepath.Join(path, ".git")); os.IsNotExist(err) {
+		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+			return fmt.Errorf("mkdir: %v", err)
+		}
+		if err := runErr(exec.Command("git", "clone", repo, path)); err != nil {
+			return fmt.Errorf("clone: %v", err)
+		}
+	} else if err != nil {
+		return fmt.Errorf("stat .git: %v", err)
+	}
+
+	// Pull down changes and update to hash.
+	cmd := exec.Command("git", "fetch")
+	cmd.Dir = path
+	if err := runErr(cmd); err != nil {
+		return fmt.Errorf("fetch: %v", err)
+	}
+	cmd = exec.Command("git", "reset", "--hard", hash)
+	cmd.Dir = path
+	if err := runErr(cmd); err != nil {
+		return fmt.Errorf("reset: %v", err)
+	}
+	cmd = exec.Command("git", "clean", "-d", "-f", "-x")
+	cmd.Dir = path
+	if err := runErr(cmd); err != nil {
+		return fmt.Errorf("clean: %v", err)
+	}
+	return nil
+}
+
+var timeoutClient = &http.Client{Timeout: 10 * time.Second}
+
+// gerritMetaMap returns the map from repo name (e.g. "go") to its
+// latest master hash.
+// The returned map is nil on any transient error.
+func gerritMetaMap() map[string]string {
+	res, err := timeoutClient.Get(metaURL)
+	if err != nil {
+		log.Printf("Error getting Gerrit meta map: %v", err)
+		return nil
+	}
+	defer res.Body.Close()
+	defer io.Copy(ioutil.Discard, res.Body) // ensure EOF for keep-alive
+	if res.StatusCode != 200 {
+		return nil
+	}
+	var meta map[string]struct {
+		Branches map[string]string
+	}
+	br := bufio.NewReader(res.Body)
+	// For security reasons or something, this URL starts with ")]}'\n" before
+	// the JSON object. So ignore that.
+	// Shawn Pearce says it's guaranteed to always be just one line, ending in '\n'.
+	for {
+		b, err := br.ReadByte()
+		if err != nil {
+			return nil
+		}
+		if b == '\n' {
+			break
+		}
+	}
+	if err := json.NewDecoder(br).Decode(&meta); err != nil {
+		log.Printf("JSON decoding error from %v: %s", metaURL, err)
+		return nil
+	}
+	m := map[string]string{}
+	for repo, v := range meta {
+		if master, ok := v.Branches["master"]; ok {
+			m[repo] = master
+		}
+	}
+	return m
+}
+
+func getOK(url string) (body []byte, err error) {
+	res, err := timeoutClient.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	body, err = ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+	return body, nil
+}
+
+// httpsOnlyHandler redirects requests to "http://example.com/foo?bar" to
+// "https://example.com/foo?bar". It should be used when the server is listening
+// for HTTP traffic behind a proxy that terminates TLS traffic, not when the Go
+// server is terminating TLS directly.
+type httpsOnlyHandler struct {
+	h http.Handler
+}
+
+// isProxiedReq checks whether the server is running behind a proxy that may be
+// terminating TLS.
+func isProxiedReq(r *http.Request) bool {
+	if _, ok := r.Header["X-Appengine-Https"]; ok {
+		return true
+	}
+	if _, ok := r.Header["X-Forwarded-Proto"]; ok {
+		return true
+	}
+	return false
+}
+
+func (h httpsOnlyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Header.Get("X-Appengine-Https") == "off" || r.Header.Get("X-Forwarded-Proto") == "http" ||
+		(!isProxiedReq(r) && r.TLS == nil) {
+		r.URL.Scheme = "https"
+		r.URL.Host = r.Host
+		http.Redirect(w, r, r.URL.String(), http.StatusFound)
+		return
+	}
+	if r.Header.Get("X-Appengine-Https") == "on" || r.Header.Get("X-Forwarded-Proto") == "https" ||
+		(!isProxiedReq(r) && r.TLS != nil) {
+		// Only set this header when we're actually in production.
+		w.Header().Set("Strict-Transport-Security", "max-age=31536000; preload")
+	}
+	h.h.ServeHTTP(w, r)
+}
diff --git a/vendor/golang.org/x/tools/cmd/tip/tip_test.go b/vendor/golang.org/x/tools/cmd/tip/tip_test.go
new file mode 100644
index 0000000..878954d
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/tip/tip_test.go
@@ -0,0 +1,25 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"net/http/httptest"
+	"testing"
+)
+
+func TestTipRedirects(t *testing.T) {
+	mux := newServeMux(&Proxy{builder: &godocBuilder{}})
+	req := httptest.NewRequest("GET", "http://example.com/foo?bar=baz", nil)
+	req.Header.Set("X-Forwarded-Proto", "http")
+	w := httptest.NewRecorder()
+	mux.ServeHTTP(w, req)
+	if w.Code != 302 {
+		t.Errorf("expected Code to be 302, got %d", w.Code)
+	}
+	want := "https://example.com/foo?bar=baz"
+	if loc := w.Header().Get("Location"); loc != want {
+		t.Errorf("Location header: got %s, want %s", loc, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/cmd/toolstash/buildall b/vendor/golang.org/x/tools/cmd/toolstash/buildall
new file mode 100644
index 0000000..40d88f5
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/toolstash/buildall
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# Usage: buildall [-e] [-nocmp] [-work]
+#
+# Builds everything (std) for every GOOS/GOARCH combination but installs nothing.
+#
+# By default, runs the builds with -toolexec 'toolstash -cmp', to test that the
+# toolchain is producing bit identical output to a previous known good toolchain.
+#
+# Options:
+#	-e: stop at first failure
+#	-nocmp: turn off toolstash -cmp; just check that ordinary builds succeed
+#	-work: pass -work to go command
+
+sete=false
+if [ "$1" = "-e" ]; then
+	sete=true
+	shift
+fi
+
+cmp=true
+if [ "$1" = "-nocmp" ]; then
+	cmp=false
+	shift
+fi
+
+work=""
+if [ "$1" = "-work" ]; then
+	work="-work"
+	shift
+fi
+
+cd $(go env GOROOT)/src
+go install cmd/compile cmd/link cmd/asm || exit 1
+pattern="$1"
+if [ "$pattern" = "" ]; then
+	pattern=.
+fi
+
+targets="$(go tool dist list; echo linux/386/387)"
+targets="$(echo "$targets" | tr '/' '-' | sort | egrep "$pattern" | egrep -v 'android-arm|darwin-arm')"
+
+# put linux, nacl first in the target list to get all the architectures up front.
+targets="$(echo "$targets" | egrep 'linux|nacl') $(echo "$targets" | egrep -v 'linux|nacl')"
+
+if [ "$sete" = true ]; then
+	set -e
+fi
+for target in $targets
+do
+	echo $target
+	export GOOS=$(echo $target | sed 's/-.*//')
+	export GOARCH=$(echo $target | sed 's/.*-//')
+	unset GO386
+	if [ "$GOARCH" = "387" ]; then
+		export GOARCH=386
+		export GO386=387
+	fi
+	if $cmp; then
+		if [ "$GOOS" = "android" ]; then
+			go build $work -a -toolexec 'toolstash -cmp' std
+		else
+			go build $work -a -toolexec 'toolstash -cmp' std cmd
+		fi
+	else
+		go build $work -a std
+	fi
+done
diff --git a/vendor/golang.org/x/tools/cmd/toolstash/cmp.go b/vendor/golang.org/x/tools/cmd/toolstash/cmp.go
new file mode 100644
index 0000000..f5974e1
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/toolstash/cmp.go
@@ -0,0 +1,157 @@
+// 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 main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	hexDumpRE = regexp.MustCompile(`^\t(0x[0-9a-f]{4,})(( ([0-9a-f]{2}|  )){16})  [ -\x7F]{1,16}\n`)
+	listingRE = regexp.MustCompile(`^\t(0x[0-9a-f]{4,}) ([0-9]{4,}) \(.*:[0-9]+\)\t`)
+)
+
+// okdiffs lists regular expressions for lines to consider minor mismatches.
+// If one of these regexps matches both of a pair of unequal lines, the mismatch
+// is reported but not treated as the one worth looking for.
+// For example, differences in the TEXT line are typically frame size
+// changes due to optimization decisions made in the body of the function.
+// Better to keep looking for the actual difference.
+// Similarly, forward jumps might have different offsets due to a
+// change in instruction encoding later on.
+// Better to find that change.
+var okdiffs = []*regexp.Regexp{
+	regexp.MustCompile(`\)	TEXT[ 	].*,\$`),
+	regexp.MustCompile(`\)	WORD[ 	].*,\$`),
+	regexp.MustCompile(`\)	(B|BR|JMP)	`),
+	regexp.MustCompile(`\)	FUNCDATA	`),
+	regexp.MustCompile(`\\(z|x00)`),
+	regexp.MustCompile(`\$\([0-9]\.[0-9]+e[+\-][0-9]+\)`),
+	regexp.MustCompile(`size=.*value=.*args=.*locals=`),
+}
+
+func compareLogs(outfile string) string {
+	f1, err := os.Open(outfile + ".log")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f1.Close()
+
+	f2, err := os.Open(outfile + ".stash.log")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f2.Close()
+
+	b1 := bufio.NewReader(f1)
+	b2 := bufio.NewReader(f2)
+
+	offset := int64(0)
+	textOffset := offset
+	textLineno := 0
+	lineno := 0
+	var line1, line2 string
+	var prefix bytes.Buffer
+Reading:
+	for {
+		var err1, err2 error
+		line1, err1 = b1.ReadString('\n')
+		line2, err2 = b2.ReadString('\n')
+		if strings.Contains(line1, ")\tTEXT\t") {
+			textOffset = offset
+			textLineno = lineno
+		}
+		offset += int64(len(line1))
+		lineno++
+		if err1 == io.EOF && err2 == io.EOF {
+			return "no differences in debugging output"
+		}
+
+		if lineno == 1 || line1 == line2 && err1 == nil && err2 == nil {
+			continue
+		}
+		// Lines are inconsistent. Worth stopping?
+		for _, re := range okdiffs {
+			if re.MatchString(line1) && re.MatchString(line2) {
+				fmt.Fprintf(&prefix, "inconsistent log line:\n%s:%d:\n\t%s\n%s:%d:\n\t%s\n\n",
+					f1.Name(), lineno, strings.TrimSuffix(line1, "\n"),
+					f2.Name(), lineno, strings.TrimSuffix(line2, "\n"))
+				continue Reading
+			}
+		}
+
+		if err1 != nil {
+			line1 = err1.Error()
+		}
+		if err2 != nil {
+			line2 = err2.Error()
+		}
+		break
+	}
+
+	msg := fmt.Sprintf("inconsistent log line:\n%s:%d:\n\t%s\n%s:%d:\n\t%s",
+		f1.Name(), lineno, strings.TrimSuffix(line1, "\n"),
+		f2.Name(), lineno, strings.TrimSuffix(line2, "\n"))
+
+	if m := hexDumpRE.FindStringSubmatch(line1); m != nil {
+		target, err := strconv.ParseUint(m[1], 0, 64)
+		if err != nil {
+			goto Skip
+		}
+
+		m2 := hexDumpRE.FindStringSubmatch(line2)
+		if m2 == nil {
+			goto Skip
+		}
+
+		fields1 := strings.Fields(m[2])
+		fields2 := strings.Fields(m2[2])
+		i := 0
+		for i < len(fields1) && i < len(fields2) && fields1[i] == fields2[i] {
+			i++
+		}
+		target += uint64(i)
+
+		f1.Seek(textOffset, 0)
+		b1 = bufio.NewReader(f1)
+		last := ""
+		lineno := textLineno
+		limitAddr := uint64(0)
+		lastAddr := uint64(0)
+		for {
+			line1, err1 := b1.ReadString('\n')
+			if err1 != nil {
+				break
+			}
+			lineno++
+			if m := listingRE.FindStringSubmatch(line1); m != nil {
+				addr, _ := strconv.ParseUint(m[1], 0, 64)
+				if addr > target {
+					limitAddr = addr
+					break
+				}
+				last = line1
+				lastAddr = addr
+			} else if hexDumpRE.FindStringSubmatch(line1) != nil {
+				break
+			}
+		}
+		if last != "" {
+			msg = fmt.Sprintf("assembly instruction at %#04x-%#04x:\n%s:%d\n\t%s\n\n%s",
+				lastAddr, limitAddr, f1.Name(), lineno-1, strings.TrimSuffix(last, "\n"), msg)
+		}
+	}
+Skip:
+
+	return prefix.String() + msg
+}
diff --git a/vendor/golang.org/x/tools/cmd/toolstash/main.go b/vendor/golang.org/x/tools/cmd/toolstash/main.go
new file mode 100644
index 0000000..da56361
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/toolstash/main.go
@@ -0,0 +1,637 @@
+// 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.
+
+// Toolstash provides a way to save, run, and restore a known good copy of the Go toolchain
+// and to compare the object files generated by two toolchains.
+//
+// Usage:
+//
+//	toolstash [-n] [-v] save [tool...]
+//	toolstash [-n] [-v] restore [tool...]
+//	toolstash [-n] [-v] [-t] go run x.go
+//	toolstash [-n] [-v] [-t] [-cmp] compile x.go
+//
+// The toolstash command manages a ``stashed'' copy of the Go toolchain
+// kept in $GOROOT/pkg/toolstash. In this case, the toolchain means the
+// tools available with the 'go tool' command as well as the go, godoc, and gofmt
+// binaries.
+//
+// The command ``toolstash save'', typically run when the toolchain is known to be working,
+// copies the toolchain from its installed location to the toolstash directory.
+// Its inverse, ``toolchain restore'', typically run when the toolchain is known to be broken,
+// copies the toolchain from the toolstash directory back to the installed locations.
+// If additional arguments are given, the save or restore applies only to the named tools.
+// Otherwise, it applies to all tools.
+//
+// Otherwise, toolstash's arguments should be a command line beginning with the
+// name of a toolchain binary, which may be a short name like compile or a complete path
+// to an installed binary. Toolstash runs the command line using the stashed
+// copy of the binary instead of the installed one.
+//
+// The -n flag causes toolstash to print the commands that would be executed
+// but not execute them. The combination -n -cmp shows the two commands
+// that would be compared and then exits successfully. A real -cmp run might
+// run additional commands for diagnosis of an output mismatch.
+//
+// The -v flag causes toolstash to print the commands being executed.
+//
+// The -t flag causes toolstash to print the time elapsed during while the
+// command ran.
+//
+// Comparing
+//
+// The -cmp flag causes toolstash to run both the installed and the stashed
+// copy of an assembler or compiler and check that they produce identical
+// object files. If not, toolstash reports the mismatch and exits with a failure status.
+// As part of reporting the mismatch, toolstash reinvokes the command with
+// the -S flag and identifies the first divergence in the assembly output.
+// If the command is a Go compiler, toolstash also determines whether the
+// difference is triggered by optimization passes.
+// On failure, toolstash leaves additional information in files named
+// similarly to the default output file. If the compilation would normally
+// produce a file x.6, the output from the stashed tool is left in x.6.stash
+// and the debugging traces are left in x.6.log and x.6.stash.log.
+//
+// The -cmp flag is a no-op when the command line is not invoking an
+// assembler or compiler.
+//
+// For example, when working on code cleanup that should not affect
+// compiler output, toolstash can be used to compare the old and new
+// compiler output:
+//
+//	toolstash save
+//	<edit compiler sources>
+//	go tool dist install cmd/compile # install compiler only
+//	toolstash -cmp compile x.go
+//
+// Go Command Integration
+//
+// The go command accepts a -toolexec flag that specifies a program
+// to use to run the build tools.
+//
+// To build with the stashed tools:
+//
+//	go build -toolexec toolstash x.go
+//
+// To build with the stashed go command and the stashed tools:
+//
+//	toolstash go build -toolexec toolstash x.go
+//
+// To verify that code cleanup in the compilers does not make any
+// changes to the objects being generated for the entire tree:
+//
+//	# Build working tree and save tools.
+//	./make.bash
+//	toolstash save
+//
+//	<edit compiler sources>
+//
+//	# Install new tools, but do not rebuild the rest of tree,
+//	# since the compilers might generate buggy code.
+//	go tool dist install cmd/compile
+//
+//	# Check that new tools behave identically to saved tools.
+//	go build -toolexec 'toolstash -cmp' -a std
+//
+//	# If not, restore, in order to keep working on Go code.
+//	toolstash restore
+//
+// Version Skew
+//
+// The Go tools write the current Go version to object files, and (outside
+// release branches) that version includes the hash and time stamp
+// of the most recent Git commit. Functionally equivalent
+// compilers built at different Git versions may produce object files that
+// differ only in the recorded version. Toolstash ignores version mismatches
+// when comparing object files, but the standard tools will refuse to compile
+// or link together packages with different object versions.
+//
+// For the full build in the final example above to work, both the stashed
+// and the installed tools must use the same version string.
+// One way to ensure this is not to commit any of the changes being
+// tested, so that the Git HEAD hash is the same for both builds.
+// A more robust way to force the tools to have the same version string
+// is to write a $GOROOT/VERSION file, which overrides the Git-based version
+// computation:
+//
+//	echo devel >$GOROOT/VERSION
+//
+// The version can be arbitrary text, but to pass all.bash's API check, it must
+// contain the substring ``devel''. The VERSION file must be created before
+// building either version of the toolchain.
+//
+package main // import "golang.org/x/tools/cmd/toolstash"
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+)
+
+var usageMessage = `usage: toolstash [-n] [-v] [-cmp] command line
+
+Examples:
+	toolstash save
+	toolstash restore
+	toolstash go run x.go
+	toolstash compile x.go
+	toolstash -cmp compile x.go
+
+For details, godoc golang.org/x/tools/cmd/toolstash
+`
+
+func usage() {
+	fmt.Fprint(os.Stderr, usageMessage)
+	os.Exit(2)
+}
+
+var (
+	goCmd   = flag.String("go", "go", "path to \"go\" command")
+	norun   = flag.Bool("n", false, "print but do not run commands")
+	verbose = flag.Bool("v", false, "print commands being run")
+	cmp     = flag.Bool("cmp", false, "compare tool object files")
+	timing  = flag.Bool("t", false, "print time commands take")
+)
+
+var (
+	cmd       []string
+	tool      string // name of tool: "go", "compile", etc
+	toolStash string // path to stashed tool
+
+	goroot   string
+	toolDir  string
+	stashDir string
+	binDir   string
+)
+
+func canCmp(name string, args []string) bool {
+	switch name {
+	case "asm", "compile", "link":
+		if len(args) == 1 && (args[0] == "-V" || strings.HasPrefix(args[0], "-V=")) {
+			// cmd/go uses "compile -V=full" to query the tool's build ID.
+			return false
+		}
+		return true
+	}
+	return len(name) == 2 && '0' <= name[0] && name[0] <= '9' && (name[1] == 'a' || name[1] == 'g' || name[1] == 'l')
+}
+
+var binTools = []string{"go", "godoc", "gofmt"}
+
+func isBinTool(name string) bool {
+	return strings.HasPrefix(name, "go")
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("toolstash: ")
+
+	flag.Usage = usage
+	flag.Parse()
+	cmd = flag.Args()
+
+	if len(cmd) < 1 {
+		usage()
+	}
+
+	s, err := exec.Command(*goCmd, "env", "GOROOT").CombinedOutput()
+	if err != nil {
+		log.Fatalf("%s env GOROOT: %v", *goCmd, err)
+	}
+	goroot = strings.TrimSpace(string(s))
+	toolDir = filepath.Join(goroot, fmt.Sprintf("pkg/tool/%s_%s", runtime.GOOS, runtime.GOARCH))
+	stashDir = filepath.Join(goroot, "pkg/toolstash")
+
+	binDir = os.Getenv("GOBIN")
+	if binDir == "" {
+		binDir = filepath.Join(goroot, "bin")
+	}
+
+	switch cmd[0] {
+	case "save":
+		save()
+		return
+
+	case "restore":
+		restore()
+		return
+	}
+
+	tool = cmd[0]
+	if i := strings.LastIndexAny(tool, `/\`); i >= 0 {
+		tool = tool[i+1:]
+	}
+
+	if !strings.HasPrefix(tool, "a.out") {
+		toolStash = filepath.Join(stashDir, tool)
+		if _, err := os.Stat(toolStash); err != nil {
+			log.Print(err)
+			os.Exit(2)
+		}
+
+		if *cmp && canCmp(tool, cmd[1:]) {
+			compareTool()
+			return
+		}
+		cmd[0] = toolStash
+	}
+
+	if *norun {
+		fmt.Printf("%s\n", strings.Join(cmd, " "))
+		return
+	}
+	if *verbose {
+		log.Print(strings.Join(cmd, " "))
+	}
+	xcmd := exec.Command(cmd[0], cmd[1:]...)
+	xcmd.Stdin = os.Stdin
+	xcmd.Stdout = os.Stdout
+	xcmd.Stderr = os.Stderr
+	err = xcmd.Run()
+	if err != nil {
+		log.Fatal(err)
+	}
+	os.Exit(0)
+}
+
+func compareTool() {
+	if !strings.Contains(cmd[0], "/") && !strings.Contains(cmd[0], `\`) {
+		cmd[0] = filepath.Join(toolDir, tool)
+	}
+
+	outfile, ok := cmpRun(false, cmd)
+	if ok {
+		os.Remove(outfile + ".stash")
+		return
+	}
+
+	extra := "-S"
+	switch {
+	default:
+		log.Fatalf("unknown tool %s", tool)
+
+	case tool == "compile" || strings.HasSuffix(tool, "g"): // compiler
+		useDashN := true
+		dashcIndex := -1
+		for i, s := range cmd {
+			if s == "-+" {
+				// Compiling runtime. Don't use -N.
+				useDashN = false
+			}
+			if strings.HasPrefix(s, "-c=") {
+				dashcIndex = i
+			}
+		}
+		cmdN := injectflags(cmd, nil, useDashN)
+		_, ok := cmpRun(false, cmdN)
+		if !ok {
+			if useDashN {
+				log.Printf("compiler output differs, with optimizers disabled (-N)")
+			} else {
+				log.Printf("compiler output differs")
+			}
+			if dashcIndex >= 0 {
+				cmd[dashcIndex] = "-c=1"
+			}
+			cmd = injectflags(cmd, []string{"-v", "-m=2"}, useDashN)
+			break
+		}
+		if dashcIndex >= 0 {
+			cmd[dashcIndex] = "-c=1"
+		}
+		cmd = injectflags(cmd, []string{"-v", "-m=2"}, false)
+		log.Printf("compiler output differs, only with optimizers enabled")
+
+	case tool == "asm" || strings.HasSuffix(tool, "a"): // assembler
+		log.Printf("assembler output differs")
+
+	case tool == "link" || strings.HasSuffix(tool, "l"): // linker
+		log.Printf("linker output differs")
+		extra = "-v=2"
+	}
+
+	cmdS := injectflags(cmd, []string{extra}, false)
+	outfile, _ = cmpRun(true, cmdS)
+
+	fmt.Fprintf(os.Stderr, "\n%s\n", compareLogs(outfile))
+	os.Exit(2)
+}
+
+func injectflags(cmd []string, extra []string, addDashN bool) []string {
+	x := []string{cmd[0]}
+	if addDashN {
+		x = append(x, "-N")
+	}
+	x = append(x, extra...)
+	x = append(x, cmd[1:]...)
+	return x
+}
+
+func cmpRun(keepLog bool, cmd []string) (outfile string, match bool) {
+	cmdStash := make([]string, len(cmd))
+	copy(cmdStash, cmd)
+	cmdStash[0] = toolStash
+	for i, arg := range cmdStash {
+		if arg == "-o" {
+			outfile = cmdStash[i+1]
+			cmdStash[i+1] += ".stash"
+			break
+		}
+		if strings.HasSuffix(arg, ".s") || strings.HasSuffix(arg, ".go") && '0' <= tool[0] && tool[0] <= '9' {
+			outfile = filepath.Base(arg[:strings.LastIndex(arg, ".")] + "." + tool[:1])
+			cmdStash = append([]string{cmdStash[0], "-o", outfile + ".stash"}, cmdStash[1:]...)
+			break
+		}
+	}
+
+	if outfile == "" {
+		log.Fatalf("cannot determine output file for command: %s", strings.Join(cmd, " "))
+	}
+
+	if *norun {
+		fmt.Printf("%s\n", strings.Join(cmd, " "))
+		fmt.Printf("%s\n", strings.Join(cmdStash, " "))
+		os.Exit(0)
+	}
+
+	out, err := runCmd(cmd, keepLog, outfile+".log")
+	if err != nil {
+		log.Printf("running: %s", strings.Join(cmd, " "))
+		os.Stderr.Write(out)
+		log.Fatal(err)
+	}
+
+	outStash, err := runCmd(cmdStash, keepLog, outfile+".stash.log")
+	if err != nil {
+		log.Printf("running: %s", strings.Join(cmdStash, " "))
+		log.Printf("installed tool succeeded but stashed tool failed.\n")
+		if len(out) > 0 {
+			log.Printf("installed tool output:")
+			os.Stderr.Write(out)
+		}
+		if len(outStash) > 0 {
+			log.Printf("stashed tool output:")
+			os.Stderr.Write(outStash)
+		}
+		log.Fatal(err)
+	}
+
+	return outfile, sameObject(outfile, outfile+".stash")
+}
+
+func sameObject(file1, file2 string) bool {
+	f1, err := os.Open(file1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f1.Close()
+
+	f2, err := os.Open(file2)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f2.Close()
+
+	b1 := bufio.NewReader(f1)
+	b2 := bufio.NewReader(f2)
+
+	// Go object files and archives contain lines of the form
+	//	go object <goos> <goarch> <version>
+	// By default, the version on development branches includes
+	// the Git hash and time stamp for the most recent commit.
+	// We allow the versions to differ.
+	if !skipVersion(b1, b2, file1, file2) {
+		return false
+	}
+
+	lastByte := byte(0)
+	for {
+		c1, err1 := b1.ReadByte()
+		c2, err2 := b2.ReadByte()
+		if err1 == io.EOF && err2 == io.EOF {
+			return true
+		}
+		if err1 != nil {
+			log.Fatalf("reading %s: %v", file1, err1)
+		}
+		if err2 != nil {
+			log.Fatalf("reading %s: %v", file2, err1)
+		}
+		if c1 != c2 {
+			return false
+		}
+		if lastByte == '`' && c1 == '\n' {
+			if !skipVersion(b1, b2, file1, file2) {
+				return false
+			}
+		}
+		lastByte = c1
+	}
+}
+
+func skipVersion(b1, b2 *bufio.Reader, file1, file2 string) bool {
+	// Consume "go object " prefix, if there.
+	prefix := "go object "
+	for i := 0; i < len(prefix); i++ {
+		c1, err1 := b1.ReadByte()
+		c2, err2 := b2.ReadByte()
+		if err1 == io.EOF && err2 == io.EOF {
+			return true
+		}
+		if err1 != nil {
+			log.Fatalf("reading %s: %v", file1, err1)
+		}
+		if err2 != nil {
+			log.Fatalf("reading %s: %v", file2, err1)
+		}
+		if c1 != c2 {
+			return false
+		}
+		if c1 != prefix[i] {
+			return true // matching bytes, just not a version
+		}
+	}
+
+	// Keep comparing until second space.
+	// Must continue to match.
+	// If we see a \n, it's not a version string after all.
+	for numSpace := 0; numSpace < 2; {
+		c1, err1 := b1.ReadByte()
+		c2, err2 := b2.ReadByte()
+		if err1 == io.EOF && err2 == io.EOF {
+			return true
+		}
+		if err1 != nil {
+			log.Fatalf("reading %s: %v", file1, err1)
+		}
+		if err2 != nil {
+			log.Fatalf("reading %s: %v", file2, err1)
+		}
+		if c1 != c2 {
+			return false
+		}
+		if c1 == '\n' {
+			return true
+		}
+		if c1 == ' ' {
+			numSpace++
+		}
+	}
+
+	// Have now seen 'go object goos goarch ' in both files.
+	// Now they're allowed to diverge, until the \n, which
+	// must be present.
+	for {
+		c1, err1 := b1.ReadByte()
+		if err1 == io.EOF {
+			log.Fatalf("reading %s: unexpected EOF", file1)
+		}
+		if err1 != nil {
+			log.Fatalf("reading %s: %v", file1, err1)
+		}
+		if c1 == '\n' {
+			break
+		}
+	}
+	for {
+		c2, err2 := b2.ReadByte()
+		if err2 == io.EOF {
+			log.Fatalf("reading %s: unexpected EOF", file2)
+		}
+		if err2 != nil {
+			log.Fatalf("reading %s: %v", file2, err2)
+		}
+		if c2 == '\n' {
+			break
+		}
+	}
+
+	// Consumed "matching" versions from both.
+	return true
+}
+
+func runCmd(cmd []string, keepLog bool, logName string) (output []byte, err error) {
+	if *verbose {
+		log.Print(strings.Join(cmd, " "))
+	}
+
+	if *timing {
+		t0 := time.Now()
+		defer func() {
+			log.Printf("%.3fs elapsed # %s\n", time.Since(t0).Seconds(), strings.Join(cmd, " "))
+		}()
+	}
+
+	xcmd := exec.Command(cmd[0], cmd[1:]...)
+	if !keepLog {
+		return xcmd.CombinedOutput()
+	}
+
+	f, err := os.Create(logName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Fprintf(f, "GOOS=%s GOARCH=%s %s\n", os.Getenv("GOOS"), os.Getenv("GOARCH"), strings.Join(cmd, " "))
+	xcmd.Stdout = f
+	xcmd.Stderr = f
+	defer f.Close()
+	return nil, xcmd.Run()
+}
+
+func save() {
+	if err := os.MkdirAll(stashDir, 0777); err != nil {
+		log.Fatal(err)
+	}
+
+	toolDir := filepath.Join(goroot, fmt.Sprintf("pkg/tool/%s_%s", runtime.GOOS, runtime.GOARCH))
+	files, err := ioutil.ReadDir(toolDir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, file := range files {
+		if shouldSave(file.Name()) && file.Mode().IsRegular() {
+			cp(filepath.Join(toolDir, file.Name()), filepath.Join(stashDir, file.Name()))
+		}
+	}
+
+	for _, name := range binTools {
+		if !shouldSave(name) {
+			continue
+		}
+		src := filepath.Join(binDir, name)
+		if _, err := os.Stat(src); err == nil {
+			cp(src, filepath.Join(stashDir, name))
+		}
+	}
+
+	checkShouldSave()
+}
+
+func restore() {
+	files, err := ioutil.ReadDir(stashDir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, file := range files {
+		if shouldSave(file.Name()) && file.Mode().IsRegular() {
+			targ := toolDir
+			if isBinTool(file.Name()) {
+				targ = binDir
+			}
+			cp(filepath.Join(stashDir, file.Name()), filepath.Join(targ, file.Name()))
+		}
+	}
+
+	checkShouldSave()
+}
+
+func shouldSave(name string) bool {
+	if len(cmd) == 1 {
+		return true
+	}
+	ok := false
+	for i, arg := range cmd {
+		if i > 0 && name == arg {
+			ok = true
+			cmd[i] = "DONE"
+		}
+	}
+	return ok
+}
+
+func checkShouldSave() {
+	var missing []string
+	for _, arg := range cmd[1:] {
+		if arg != "DONE" {
+			missing = append(missing, arg)
+		}
+	}
+	if len(missing) > 0 {
+		log.Fatalf("%s did not find tools: %s", cmd[0], strings.Join(missing, " "))
+	}
+}
+
+func cp(src, dst string) {
+	if *verbose {
+		fmt.Printf("cp %s %s\n", src, dst)
+	}
+	data, err := ioutil.ReadFile(src)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := ioutil.WriteFile(dst, data, 0777); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/codereview.cfg b/vendor/golang.org/x/tools/codereview.cfg
new file mode 100644
index 0000000..3f8b14b
--- /dev/null
+++ b/vendor/golang.org/x/tools/codereview.cfg
@@ -0,0 +1 @@
+issuerepo: golang/go
diff --git a/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.go b/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.go
new file mode 100644
index 0000000..99ea813
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.s b/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.s
new file mode 100644
index 0000000..05c3d6f
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo.go b/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo.go
new file mode 100644
index 0000000..82a8875
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo_c.c b/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo_c.c
new file mode 100644
index 0000000..08abb32
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/container/intsets/popcnt_generic.go b/vendor/golang.org/x/tools/container/intsets/popcnt_generic.go
new file mode 100644
index 0000000..3985a1d
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/container/intsets/sparse.go b/vendor/golang.org/x/tools/container/intsets/sparse.go
index 8847feb..5db01c1 100644
--- a/vendor/golang.org/x/tools/container/intsets/sparse.go
+++ b/vendor/golang.org/x/tools/container/intsets/sparse.go
@@ -21,10 +21,6 @@ package intsets // import "golang.org/x/tools/container/intsets"
 // The space usage would be proportional to Max(), not Len(), and the
 // implementation would be based upon big.Int.
 //
-// TODO(adonovan): experiment with making the root block indirect (nil
-// iff IsEmpty).  This would reduce the memory usage when empty and
-// might simplify the aliasing invariants.
-//
 // TODO(adonovan): opt: make UnionWith and Difference faster.
 // These are the hot-spots for go/pointer.
 
@@ -45,9 +41,10 @@ type Sparse struct {
 	// An uninitialized Sparse represents an empty set.
 	// An empty set may also be represented by
 	//  root.next == root.prev == &root.
-	// In a non-empty set, root.next points to the first block and
-	// root.prev to the last.
-	// root.offset and root.bits are unused.
+	//
+	// 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
 }
 
@@ -144,7 +141,6 @@ func (b *block) len() int {
 
 // 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.
@@ -161,7 +157,6 @@ func (b *block) max() int {
 // 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 {
@@ -175,6 +170,26 @@ func (b *block) min(take bool) int {
 	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)) {
@@ -204,14 +219,20 @@ func offsetAndBitIndex(x int) (int, uint) {
 
 // -- Sparse --------------------------------------------------------------
 
-// start returns the root's next block, which is the root block
-// (if s.IsEmpty()) or the first true block otherwise.
-// start has the side effect of ensuring that s is properly
-// initialized.
-//
-func (s *Sparse) start() *block {
+// 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 {
@@ -219,21 +240,45 @@ func (s *Sparse) start() *block {
 		// 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.
-		panic("A Sparse has been copied without (*Sparse).Copy()")
+		// 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)
 	}
+}
 
-	return root.next
+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.start() == &s.root
+	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.start(); b != &s.root; b = b.next {
+	for b := s.first(); b != &none; b = s.next(b) {
 		l += b.len()
 	}
 	return l
@@ -252,19 +297,34 @@ func (s *Sparse) Min() int {
 	if s.IsEmpty() {
 		return MaxInt
 	}
-	return s.root.next.min(false)
+	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 {
-	b := s.start()
-	for b != &s.root && b.offset <= offset {
+	for b := s.first(); b != &none && b.offset <= offset; b = s.next(b) {
 		if b.offset == offset {
 			return b
 		}
-		b = b.next
 	}
 	return nil
 }
@@ -272,26 +332,49 @@ func (s *Sparse) block(offset int) *block {
 // 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.start()
-	for b != &s.root && b.offset <= offset {
+
+	b := s.first()
+	for ; b != &none && b.offset <= offset; b = s.next(b) {
 		if b.offset == offset {
 			return b.insert(i)
 		}
-		b = b.next
 	}
 
 	// Insert new block before b.
-	new := &block{offset: offset}
-	new.next = b
-	new.prev = b.prev
-	new.prev.next = new
-	new.next.prev = new
+	new := s.insertBlockBefore(b)
+	new.offset = offset
 	return new.insert(i)
 }
 
-func (s *Sparse) removeBlock(b *block) {
-	b.prev.next = b.next
-	b.next.prev = b.prev
+// 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.
@@ -311,8 +394,11 @@ func (s *Sparse) Remove(x int) bool {
 
 // Clear removes all elements from the set s.
 func (s *Sparse) Clear() {
-	s.root.next = &s.root
-	s.root.prev = &s.root
+	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
@@ -325,13 +411,12 @@ func (s *Sparse) Clear() {
 // 	for worklist.TakeMin(&x) { use(x) }
 //
 func (s *Sparse) TakeMin(p *int) bool {
-	head := s.start()
-	if head == &s.root {
+	if s.IsEmpty() {
 		return false
 	}
-	*p = head.min(true)
-	if head.empty() {
-		s.removeBlock(head)
+	*p = s.root.min(true)
+	if s.root.empty() {
+		s.removeBlock(&s.root)
 	}
 	return true
 }
@@ -352,7 +437,7 @@ func (s *Sparse) Has(x int) bool {
 // natural control flow with continue/break/return.
 //
 func (s *Sparse) forEach(f func(int)) {
-	for b := s.start(); b != &s.root; b = b.next {
+	for b := s.first(); b != &none; b = s.next(b) {
 		b.forEach(f)
 	}
 }
@@ -363,22 +448,51 @@ func (s *Sparse) Copy(x *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	sb := s.start()
-	for xb != &x.root {
-		if sb == &s.root {
+	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 = xb.next
-		sb = sb.next
+		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
@@ -389,9 +503,13 @@ func (s *Sparse) insertBlockBefore(next *block) *block {
 
 // discardTail removes block b and all its successors from s.
 func (s *Sparse) discardTail(b *block) {
-	if b != &s.root {
-		b.prev.next = &s.root
-		s.root.prev = b.prev
+	if b != &none {
+		if b == &s.root {
+			s.Clear()
+		} else {
+			b.prev.next = &s.root
+			s.root.prev = b.prev
+		}
 	}
 }
 
@@ -401,16 +519,15 @@ func (s *Sparse) IntersectionWith(x *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	sb := s.start()
-	for xb != &x.root && sb != &s.root {
+	xb := x.first()
+	sb := s.first()
+	for xb != &none && sb != &none {
 		switch {
 		case xb.offset < sb.offset:
-			xb = xb.next
+			xb = x.next(xb)
 
 		case xb.offset > sb.offset:
-			sb = sb.next
-			s.removeBlock(sb.prev)
+			sb = s.removeBlock(sb)
 
 		default:
 			var sum word
@@ -420,12 +537,12 @@ func (s *Sparse) IntersectionWith(x *Sparse) {
 				sum |= r
 			}
 			if sum != 0 {
-				sb = sb.next
+				sb = s.next(sb)
 			} else {
 				// sb will be overwritten or removed
 			}
 
-			xb = xb.next
+			xb = x.next(xb)
 		}
 	}
 
@@ -446,20 +563,20 @@ func (s *Sparse) Intersection(x, y *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	yb := y.start()
-	sb := s.start()
-	for xb != &x.root && yb != &y.root {
+	xb := x.first()
+	yb := y.first()
+	sb := s.first()
+	for xb != &none && yb != &none {
 		switch {
 		case xb.offset < yb.offset:
-			xb = xb.next
+			xb = x.next(xb)
 			continue
 		case xb.offset > yb.offset:
-			yb = yb.next
+			yb = y.next(yb)
 			continue
 		}
 
-		if sb == &s.root {
+		if sb == &none {
 			sb = s.insertBlockBefore(sb)
 		}
 		sb.offset = xb.offset
@@ -471,13 +588,13 @@ func (s *Sparse) Intersection(x, y *Sparse) {
 			sum |= r
 		}
 		if sum != 0 {
-			sb = sb.next
+			sb = s.next(sb)
 		} else {
 			// sb will be overwritten or removed
 		}
 
-		xb = xb.next
-		yb = yb.next
+		xb = x.next(xb)
+		yb = y.next(yb)
 	}
 
 	s.discardTail(sb)
@@ -485,22 +602,22 @@ func (s *Sparse) Intersection(x, y *Sparse) {
 
 // Intersects reports whether s ∩ x ≠ ∅.
 func (s *Sparse) Intersects(x *Sparse) bool {
-	sb := s.start()
-	xb := x.start()
-	for sb != &s.root && xb != &x.root {
+	sb := s.first()
+	xb := x.first()
+	for sb != &none && xb != &none {
 		switch {
 		case xb.offset < sb.offset:
-			xb = xb.next
+			xb = x.next(xb)
 		case xb.offset > sb.offset:
-			sb = sb.next
+			sb = s.next(sb)
 		default:
 			for i := range sb.bits {
 				if sb.bits[i]&xb.bits[i] != 0 {
 					return true
 				}
 			}
-			sb = sb.next
-			xb = xb.next
+			sb = s.next(sb)
+			xb = x.next(xb)
 		}
 	}
 	return false
@@ -513,26 +630,26 @@ func (s *Sparse) UnionWith(x *Sparse) bool {
 	}
 
 	var changed bool
-	xb := x.start()
-	sb := s.start()
-	for xb != &x.root {
-		if sb != &s.root && sb.offset == xb.offset {
+	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 = xb.next
-		} else if sb == &s.root || sb.offset > xb.offset {
+			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 = xb.next
+			xb = x.next(xb)
 		}
-		sb = sb.next
+		sb = s.next(sb)
 	}
 	return changed
 }
@@ -551,33 +668,33 @@ func (s *Sparse) Union(x, y *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	yb := y.start()
-	sb := s.start()
-	for xb != &x.root || yb != &y.root {
-		if sb == &s.root {
+	xb := x.first()
+	yb := y.first()
+	sb := s.first()
+	for xb != &none || yb != &none {
+		if sb == &none {
 			sb = s.insertBlockBefore(sb)
 		}
 		switch {
-		case yb == &y.root || (xb != &x.root && xb.offset < yb.offset):
+		case yb == &none || (xb != &none && xb.offset < yb.offset):
 			sb.offset = xb.offset
 			sb.bits = xb.bits
-			xb = xb.next
+			xb = x.next(xb)
 
-		case xb == &x.root || (yb != &y.root && yb.offset < xb.offset):
+		case xb == &none || (yb != &none && yb.offset < xb.offset):
 			sb.offset = yb.offset
 			sb.bits = yb.bits
-			yb = yb.next
+			yb = y.next(yb)
 
 		default:
 			sb.offset = xb.offset
 			for i := range xb.bits {
 				sb.bits[i] = xb.bits[i] | yb.bits[i]
 			}
-			xb = xb.next
-			yb = yb.next
+			xb = x.next(xb)
+			yb = y.next(yb)
 		}
-		sb = sb.next
+		sb = s.next(sb)
 	}
 
 	s.discardTail(sb)
@@ -590,15 +707,15 @@ func (s *Sparse) DifferenceWith(x *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	sb := s.start()
-	for xb != &x.root && sb != &s.root {
+	xb := x.first()
+	sb := s.first()
+	for xb != &none && sb != &none {
 		switch {
 		case xb.offset > sb.offset:
-			sb = sb.next
+			sb = s.next(sb)
 
 		case xb.offset < sb.offset:
-			xb = xb.next
+			xb = x.next(xb)
 
 		default:
 			var sum word
@@ -607,12 +724,12 @@ func (s *Sparse) DifferenceWith(x *Sparse) {
 				sb.bits[i] = r
 				sum |= r
 			}
-			sb = sb.next
-			xb = xb.next
-
 			if sum == 0 {
-				s.removeBlock(sb.prev)
+				sb = s.removeBlock(sb)
+			} else {
+				sb = s.next(sb)
 			}
+			xb = x.next(xb)
 		}
 	}
 }
@@ -633,27 +750,27 @@ func (s *Sparse) Difference(x, y *Sparse) {
 		return
 	}
 
-	xb := x.start()
-	yb := y.start()
-	sb := s.start()
-	for xb != &x.root && yb != &y.root {
+	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 = yb.next
+			// y has block, x has &none
+			yb = y.next(yb)
 			continue
 		}
 
-		if sb == &s.root {
+		if sb == &none {
 			sb = s.insertBlockBefore(sb)
 		}
 		sb.offset = xb.offset
 
 		switch {
 		case xb.offset < yb.offset:
-			// x has block, y has none
+			// x has block, y has &none
 			sb.bits = xb.bits
 
-			sb = sb.next
+			sb = s.next(sb)
 
 		default:
 			// x and y have corresponding blocks
@@ -664,25 +781,25 @@ func (s *Sparse) Difference(x, y *Sparse) {
 				sum |= r
 			}
 			if sum != 0 {
-				sb = sb.next
+				sb = s.next(sb)
 			} else {
 				// sb will be overwritten or removed
 			}
 
-			yb = yb.next
+			yb = y.next(yb)
 		}
-		xb = xb.next
+		xb = x.next(xb)
 	}
 
-	for xb != &x.root {
-		if sb == &s.root {
+	for xb != &none {
+		if sb == &none {
 			sb = s.insertBlockBefore(sb)
 		}
 		sb.offset = xb.offset
 		sb.bits = xb.bits
-		sb = sb.next
+		sb = s.next(sb)
 
-		xb = xb.next
+		xb = x.next(xb)
 	}
 
 	s.discardTail(sb)
@@ -695,17 +812,17 @@ func (s *Sparse) SymmetricDifferenceWith(x *Sparse) {
 		return
 	}
 
-	sb := s.start()
-	xb := x.start()
-	for xb != &x.root && sb != &s.root {
+	sb := s.first()
+	xb := x.first()
+	for xb != &none && sb != &none {
 		switch {
 		case sb.offset < xb.offset:
-			sb = sb.next
+			sb = s.next(sb)
 		case xb.offset < sb.offset:
 			nb := s.insertBlockBefore(sb)
 			nb.offset = xb.offset
 			nb.bits = xb.bits
-			xb = xb.next
+			xb = x.next(xb)
 		default:
 			var sum word
 			for i := range sb.bits {
@@ -713,20 +830,21 @@ func (s *Sparse) SymmetricDifferenceWith(x *Sparse) {
 				sb.bits[i] = r
 				sum |= r
 			}
-			sb = sb.next
-			xb = xb.next
 			if sum == 0 {
-				s.removeBlock(sb.prev)
+				sb = s.removeBlock(sb)
+			} else {
+				sb = s.next(sb)
 			}
+			xb = x.next(xb)
 		}
 	}
 
-	for xb != &x.root { // append the tail of x to s
+	for xb != &none { // append the tail of x to s
 		sb = s.insertBlockBefore(sb)
 		sb.offset = xb.offset
 		sb.bits = xb.bits
-		sb = sb.next
-		xb = xb.next
+		sb = s.next(sb)
+		xb = x.next(xb)
 	}
 }
 
@@ -744,24 +862,24 @@ func (s *Sparse) SymmetricDifference(x, y *Sparse) {
 		return
 	}
 
-	sb := s.start()
-	xb := x.start()
-	yb := y.start()
-	for xb != &x.root && yb != &y.root {
-		if sb == &s.root {
+	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 = sb.next
-			yb = yb.next
+			sb = s.next(sb)
+			yb = y.next(yb)
 		case xb.offset < yb.offset:
 			sb.offset = xb.offset
 			sb.bits = xb.bits
-			sb = sb.next
-			xb = xb.next
+			sb = s.next(sb)
+			xb = x.next(xb)
 		default:
 			var sum word
 			for i := range sb.bits {
@@ -771,31 +889,31 @@ func (s *Sparse) SymmetricDifference(x, y *Sparse) {
 			}
 			if sum != 0 {
 				sb.offset = xb.offset
-				sb = sb.next
+				sb = s.next(sb)
 			}
-			xb = xb.next
-			yb = yb.next
+			xb = x.next(xb)
+			yb = y.next(yb)
 		}
 	}
 
-	for xb != &x.root { // append the tail of x to s
-		if sb == &s.root {
+	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 = sb.next
-		xb = xb.next
+		sb = s.next(sb)
+		xb = x.next(xb)
 	}
 
-	for yb != &y.root { // append the tail of y to s
-		if sb == &s.root {
+	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 = sb.next
-		yb = yb.next
+		sb = s.next(sb)
+		yb = y.next(yb)
 	}
 
 	s.discardTail(sb)
@@ -807,22 +925,22 @@ func (s *Sparse) SubsetOf(x *Sparse) bool {
 		return true
 	}
 
-	sb := s.start()
-	xb := x.start()
-	for sb != &s.root {
+	sb := s.first()
+	xb := x.first()
+	for sb != &none {
 		switch {
-		case xb == &x.root || xb.offset > sb.offset:
+		case xb == &none || xb.offset > sb.offset:
 			return false
 		case xb.offset < sb.offset:
-			xb = xb.next
+			xb = x.next(xb)
 		default:
 			for i := range sb.bits {
 				if sb.bits[i]&^xb.bits[i] != 0 {
 					return false
 				}
 			}
-			sb = sb.next
-			xb = xb.next
+			sb = s.next(sb)
+			xb = x.next(xb)
 		}
 	}
 	return true
@@ -833,13 +951,13 @@ func (s *Sparse) Equals(t *Sparse) bool {
 	if s == t {
 		return true
 	}
-	sb := s.start()
-	tb := t.start()
+	sb := s.first()
+	tb := t.first()
 	for {
 		switch {
-		case sb == &s.root && tb == &t.root:
+		case sb == &none && tb == &none:
 			return true
-		case sb == &s.root || tb == &t.root:
+		case sb == &none || tb == &none:
 			return false
 		case sb.offset != tb.offset:
 			return false
@@ -847,8 +965,8 @@ func (s *Sparse) Equals(t *Sparse) bool {
 			return false
 		}
 
-		sb = sb.next
-		tb = tb.next
+		sb = s.next(sb)
+		tb = t.next(tb)
 	}
 }
 
@@ -913,7 +1031,7 @@ func (s *Sparse) BitString() string {
 //
 func (s *Sparse) GoString() string {
 	var buf bytes.Buffer
-	for b := s.start(); b != &s.root; b = b.next {
+	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 {
@@ -937,13 +1055,18 @@ func (s *Sparse) AppendTo(slice []int) []int {
 
 // check returns an error if the representation invariants of s are violated.
 func (s *Sparse) check() error {
-	if !s.root.empty() {
-		return fmt.Errorf("non-empty root block")
+	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
 	}
-	if s.root.offset != 0 {
-		return fmt.Errorf("root block has non-zero offset %d", s.root.offset)
-	}
-	for b := s.start(); b != &s.root; b = b.next {
+	for b := s.first(); ; b = s.next(b) {
 		if b.offset%bitsPerBlock != 0 {
 			return fmt.Errorf("bad offset modulo: %d", b.offset)
 		}
@@ -956,11 +1079,12 @@ func (s *Sparse) check() error {
 		if b.next.prev != b {
 			return fmt.Errorf("bad next.prev link")
 		}
-		if b.prev != &s.root {
-			if b.offset <= b.prev.offset {
-				return fmt.Errorf("bad offset order: b.offset=%d, prev.offset=%d",
-					b.offset, b.prev.offset)
-			}
+		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/vendor/golang.org/x/tools/container/intsets/sparse_test.go b/vendor/golang.org/x/tools/container/intsets/sparse_test.go
new file mode 100644
index 0000000..e3ef9d3
--- /dev/null
+++ b/vendor/golang.org/x/tools/container/intsets/sparse_test.go
@@ -0,0 +1,710 @@
+// 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_test
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/container/intsets"
+)
+
+func TestBasics(t *testing.T) {
+	var s intsets.Sparse
+	if len := s.Len(); len != 0 {
+		t.Errorf("Len({}): got %d, want 0", len)
+	}
+	if s := s.String(); s != "{}" {
+		t.Errorf("String({}): got %q, want \"{}\"", s)
+	}
+	if s.Has(3) {
+		t.Errorf("Has(3): got true, want false")
+	}
+	if err := s.Check(); err != nil {
+		t.Error(err)
+	}
+
+	if !s.Insert(3) {
+		t.Errorf("Insert(3): got false, want true")
+	}
+	if max := s.Max(); max != 3 {
+		t.Errorf("Max: got %d, want 3", max)
+	}
+
+	if !s.Insert(435) {
+		t.Errorf("Insert(435): got false, want true")
+	}
+	if s := s.String(); s != "{3 435}" {
+		t.Errorf("String({3 435}): got %q, want \"{3 435}\"", s)
+	}
+	if max := s.Max(); max != 435 {
+		t.Errorf("Max: got %d, want 435", max)
+	}
+	if len := s.Len(); len != 2 {
+		t.Errorf("Len: got %d, want 2", len)
+	}
+
+	if !s.Remove(435) {
+		t.Errorf("Remove(435): got false, want true")
+	}
+	if s := s.String(); s != "{3}" {
+		t.Errorf("String({3}): got %q, want \"{3}\"", s)
+	}
+}
+
+// Insert, Len, IsEmpty, Hash, Clear, AppendTo.
+func TestMoreBasics(t *testing.T) {
+	set := new(intsets.Sparse)
+	set.Insert(456)
+	set.Insert(123)
+	set.Insert(789)
+	if set.Len() != 3 {
+		t.Errorf("%s.Len: got %d, want 3", set, set.Len())
+	}
+	if set.IsEmpty() {
+		t.Errorf("%s.IsEmpty: got true", set)
+	}
+	if !set.Has(123) {
+		t.Errorf("%s.Has(123): got false", set)
+	}
+	if set.Has(1234) {
+		t.Errorf("%s.Has(1234): got true", set)
+	}
+	got := set.AppendTo([]int{-1})
+	if want := []int{-1, 123, 456, 789}; fmt.Sprint(got) != fmt.Sprint(want) {
+		t.Errorf("%s.AppendTo: got %v, want %v", set, got, want)
+	}
+
+	set.Clear()
+
+	if set.Len() != 0 {
+		t.Errorf("Clear: got %d, want 0", set.Len())
+	}
+	if !set.IsEmpty() {
+		t.Errorf("IsEmpty: got false")
+	}
+	if set.Has(123) {
+		t.Errorf("%s.Has: got false", set)
+	}
+}
+
+func TestTakeMin(t *testing.T) {
+	var set intsets.Sparse
+	set.Insert(456)
+	set.Insert(123)
+	set.Insert(789)
+	set.Insert(-123)
+	var got int
+	for i, want := range []int{-123, 123, 456, 789} {
+		if !set.TakeMin(&got) || got != want {
+			t.Errorf("TakeMin #%d: got %d, want %d", i, got, want)
+		}
+	}
+	if set.TakeMin(&got) {
+		t.Errorf("%s.TakeMin returned true", &set)
+	}
+	if err := set.Check(); err != nil {
+		t.Fatalf("check: %s: %#v", err, &set)
+	}
+}
+
+func TestMinAndMax(t *testing.T) {
+	values := []int{0, 456, 123, 789, -123} // elt 0 => empty set
+	wantMax := []int{intsets.MinInt, 456, 456, 789, 789}
+	wantMin := []int{intsets.MaxInt, 456, 123, 123, -123}
+
+	var set intsets.Sparse
+	for i, x := range values {
+		if i != 0 {
+			set.Insert(x)
+		}
+		if got, want := set.Min(), wantMin[i]; got != want {
+			t.Errorf("Min #%d: got %d, want %d", i, got, want)
+		}
+		if got, want := set.Max(), wantMax[i]; got != want {
+			t.Errorf("Max #%d: got %d, want %d", i, got, want)
+		}
+	}
+
+	set.Insert(intsets.MinInt)
+	if got, want := set.Min(), intsets.MinInt; got != want {
+		t.Errorf("Min: got %d, want %d", got, want)
+	}
+
+	set.Insert(intsets.MaxInt)
+	if got, want := set.Max(), intsets.MaxInt; got != want {
+		t.Errorf("Max: got %d, want %d", got, want)
+	}
+}
+
+func TestEquals(t *testing.T) {
+	var setX intsets.Sparse
+	setX.Insert(456)
+	setX.Insert(123)
+	setX.Insert(789)
+
+	if !setX.Equals(&setX) {
+		t.Errorf("Equals(%s, %s): got false", &setX, &setX)
+	}
+
+	var setY intsets.Sparse
+	setY.Insert(789)
+	setY.Insert(456)
+	setY.Insert(123)
+
+	if !setX.Equals(&setY) {
+		t.Errorf("Equals(%s, %s): got false", &setX, &setY)
+	}
+
+	setY.Insert(1)
+	if setX.Equals(&setY) {
+		t.Errorf("Equals(%s, %s): got true", &setX, &setY)
+	}
+
+	var empty intsets.Sparse
+	if setX.Equals(&empty) {
+		t.Errorf("Equals(%s, %s): got true", &setX, &empty)
+	}
+
+	// Edge case: some block (with offset=0) appears in X but not Y.
+	setY.Remove(123)
+	if setX.Equals(&setY) {
+		t.Errorf("Equals(%s, %s): got true", &setX, &setY)
+	}
+}
+
+// A pset is a parallel implementation of a set using both an intsets.Sparse
+// and a built-in hash map.
+type pset struct {
+	hash map[int]bool
+	bits intsets.Sparse
+}
+
+func makePset() *pset {
+	return &pset{hash: make(map[int]bool)}
+}
+
+func (set *pset) add(n int) {
+	prev := len(set.hash)
+	set.hash[n] = true
+	grewA := len(set.hash) > prev
+
+	grewB := set.bits.Insert(n)
+
+	if grewA != grewB {
+		panic(fmt.Sprintf("add(%d): grewA=%t grewB=%t", n, grewA, grewB))
+	}
+}
+
+func (set *pset) remove(n int) {
+	prev := len(set.hash)
+	delete(set.hash, n)
+	shrankA := len(set.hash) < prev
+
+	shrankB := set.bits.Remove(n)
+
+	if shrankA != shrankB {
+		panic(fmt.Sprintf("remove(%d): shrankA=%t shrankB=%t", n, shrankA, shrankB))
+	}
+}
+
+func (set *pset) check(t *testing.T, msg string) {
+	var eltsA []int
+	for elt := range set.hash {
+		eltsA = append(eltsA, int(elt))
+	}
+	sort.Ints(eltsA)
+
+	eltsB := set.bits.AppendTo(nil)
+
+	if a, b := fmt.Sprint(eltsA), fmt.Sprint(eltsB); a != b {
+		t.Errorf("check(%s): hash=%s bits=%s (%s)", msg, a, b, &set.bits)
+	}
+
+	if err := set.bits.Check(); err != nil {
+		t.Fatalf("Check(%s): %s: %#v", msg, err, &set.bits)
+	}
+}
+
+// randomPset returns a parallel set of random size and elements.
+func randomPset(prng *rand.Rand, maxSize int) *pset {
+	set := makePset()
+	size := int(prng.Int()) % maxSize
+	for i := 0; i < size; i++ {
+		// TODO(adonovan): benchmark how performance varies
+		// with this sparsity parameter.
+		n := int(prng.Int()) % 10000
+		set.add(n)
+	}
+	return set
+}
+
+// TestRandomMutations performs the same random adds/removes on two
+// set implementations and ensures that they compute the same result.
+func TestRandomMutations(t *testing.T) {
+	const debug = false
+
+	set := makePset()
+	prng := rand.New(rand.NewSource(0))
+	for i := 0; i < 10000; i++ {
+		n := int(prng.Int())%2000 - 1000
+		if i%2 == 0 {
+			if debug {
+				log.Printf("add %d", n)
+			}
+			set.add(n)
+		} else {
+			if debug {
+				log.Printf("remove %d", n)
+			}
+			set.remove(n)
+		}
+		if debug {
+			set.check(t, "post mutation")
+		}
+	}
+	set.check(t, "final")
+	if debug {
+		log.Print(&set.bits)
+	}
+}
+
+func TestLowerBound(t *testing.T) {
+	// Use random sets of sizes from 0 to about 4000.
+	prng := rand.New(rand.NewSource(0))
+	for i := uint(0); i < 12; i++ {
+		x := randomPset(prng, 1<<i)
+		for j := 0; j < 10000; j++ {
+			found := intsets.MaxInt
+			for e := range x.hash {
+				if e >= j && e < found {
+					found = e
+				}
+			}
+			if res := x.bits.LowerBound(j); res != found {
+				t.Errorf("%s: LowerBound(%d)=%d, expected %d", &x.bits, j, res, found)
+			}
+		}
+	}
+}
+
+// TestSetOperations exercises classic set operations: ∩ , ∪, \.
+func TestSetOperations(t *testing.T) {
+	prng := rand.New(rand.NewSource(0))
+
+	// Use random sets of sizes from 0 to about 4000.
+	// For each operator, we test variations such as
+	// Z.op(X, Y), Z.op(X, Z) and Z.op(Z, Y) to exercise
+	// the degenerate cases of each method implementation.
+	for i := uint(0); i < 12; i++ {
+		X := randomPset(prng, 1<<i)
+		Y := randomPset(prng, 1<<i)
+
+		// TODO(adonovan): minimise dependencies between stanzas below.
+
+		// Copy(X)
+		C := makePset()
+		C.bits.Copy(&Y.bits) // no effect on result
+		C.bits.Copy(&X.bits)
+		C.hash = X.hash
+		C.check(t, "C.Copy(X)")
+		C.bits.Copy(&C.bits)
+		C.check(t, "C.Copy(C)")
+
+		// U.Union(X, Y)
+		U := makePset()
+		U.bits.Union(&X.bits, &Y.bits)
+		for n := range X.hash {
+			U.hash[n] = true
+		}
+		for n := range Y.hash {
+			U.hash[n] = true
+		}
+		U.check(t, "U.Union(X, Y)")
+
+		// U.Union(X, X)
+		U.bits.Union(&X.bits, &X.bits)
+		U.hash = X.hash
+		U.check(t, "U.Union(X, X)")
+
+		// U.Union(U, Y)
+		U = makePset()
+		U.bits.Copy(&X.bits)
+		U.bits.Union(&U.bits, &Y.bits)
+		for n := range X.hash {
+			U.hash[n] = true
+		}
+		for n := range Y.hash {
+			U.hash[n] = true
+		}
+		U.check(t, "U.Union(U, Y)")
+
+		// U.Union(X, U)
+		U.bits.Copy(&Y.bits)
+		U.bits.Union(&X.bits, &U.bits)
+		U.check(t, "U.Union(X, U)")
+
+		// U.UnionWith(U)
+		U.bits.UnionWith(&U.bits)
+		U.check(t, "U.UnionWith(U)")
+
+		// I.Intersection(X, Y)
+		I := makePset()
+		I.bits.Intersection(&X.bits, &Y.bits)
+		for n := range X.hash {
+			if Y.hash[n] {
+				I.hash[n] = true
+			}
+		}
+		I.check(t, "I.Intersection(X, Y)")
+
+		// I.Intersection(X, X)
+		I.bits.Intersection(&X.bits, &X.bits)
+		I.hash = X.hash
+		I.check(t, "I.Intersection(X, X)")
+
+		// I.Intersection(I, X)
+		I.bits.Intersection(&I.bits, &X.bits)
+		I.check(t, "I.Intersection(I, X)")
+
+		// I.Intersection(X, I)
+		I.bits.Intersection(&X.bits, &I.bits)
+		I.check(t, "I.Intersection(X, I)")
+
+		// I.Intersection(I, I)
+		I.bits.Intersection(&I.bits, &I.bits)
+		I.check(t, "I.Intersection(I, I)")
+
+		// D.Difference(X, Y)
+		D := makePset()
+		D.bits.Difference(&X.bits, &Y.bits)
+		for n := range X.hash {
+			if !Y.hash[n] {
+				D.hash[n] = true
+			}
+		}
+		D.check(t, "D.Difference(X, Y)")
+
+		// D.Difference(D, Y)
+		D.bits.Copy(&X.bits)
+		D.bits.Difference(&D.bits, &Y.bits)
+		D.check(t, "D.Difference(D, Y)")
+
+		// D.Difference(Y, D)
+		D.bits.Copy(&X.bits)
+		D.bits.Difference(&Y.bits, &D.bits)
+		D.hash = make(map[int]bool)
+		for n := range Y.hash {
+			if !X.hash[n] {
+				D.hash[n] = true
+			}
+		}
+		D.check(t, "D.Difference(Y, D)")
+
+		// D.Difference(X, X)
+		D.bits.Difference(&X.bits, &X.bits)
+		D.hash = nil
+		D.check(t, "D.Difference(X, X)")
+
+		// D.DifferenceWith(D)
+		D.bits.Copy(&X.bits)
+		D.bits.DifferenceWith(&D.bits)
+		D.check(t, "D.DifferenceWith(D)")
+
+		// SD.SymmetricDifference(X, Y)
+		SD := makePset()
+		SD.bits.SymmetricDifference(&X.bits, &Y.bits)
+		for n := range X.hash {
+			if !Y.hash[n] {
+				SD.hash[n] = true
+			}
+		}
+		for n := range Y.hash {
+			if !X.hash[n] {
+				SD.hash[n] = true
+			}
+		}
+		SD.check(t, "SD.SymmetricDifference(X, Y)")
+
+		// X.SymmetricDifferenceWith(Y)
+		SD.bits.Copy(&X.bits)
+		SD.bits.SymmetricDifferenceWith(&Y.bits)
+		SD.check(t, "X.SymmetricDifference(Y)")
+
+		// Y.SymmetricDifferenceWith(X)
+		SD.bits.Copy(&Y.bits)
+		SD.bits.SymmetricDifferenceWith(&X.bits)
+		SD.check(t, "Y.SymmetricDifference(X)")
+
+		// SD.SymmetricDifference(X, X)
+		SD.bits.SymmetricDifference(&X.bits, &X.bits)
+		SD.hash = nil
+		SD.check(t, "SD.SymmetricDifference(X, X)")
+
+		// SD.SymmetricDifference(X, Copy(X))
+		X2 := makePset()
+		X2.bits.Copy(&X.bits)
+		SD.bits.SymmetricDifference(&X.bits, &X2.bits)
+		SD.check(t, "SD.SymmetricDifference(X, Copy(X))")
+
+		// Copy(X).SymmetricDifferenceWith(X)
+		SD.bits.Copy(&X.bits)
+		SD.bits.SymmetricDifferenceWith(&X.bits)
+		SD.check(t, "Copy(X).SymmetricDifferenceWith(X)")
+	}
+}
+
+func TestIntersectionWith(t *testing.T) {
+	// Edge cases: the pairs (1,1), (1000,2000), (8000,4000)
+	// exercise the <, >, == cases in IntersectionWith that the
+	// TestSetOperations data is too dense to cover.
+	var X, Y intsets.Sparse
+	X.Insert(1)
+	X.Insert(1000)
+	X.Insert(8000)
+	Y.Insert(1)
+	Y.Insert(2000)
+	Y.Insert(4000)
+	X.IntersectionWith(&Y)
+	if got, want := X.String(), "{1}"; got != want {
+		t.Errorf("IntersectionWith: got %s, want %s", got, want)
+	}
+}
+
+func TestIntersects(t *testing.T) {
+	prng := rand.New(rand.NewSource(0))
+
+	for i := uint(0); i < 12; i++ {
+		X, Y := randomPset(prng, 1<<i), randomPset(prng, 1<<i)
+		x, y := &X.bits, &Y.bits
+
+		// test the slow way
+		var z intsets.Sparse
+		z.Copy(x)
+		z.IntersectionWith(y)
+
+		if got, want := x.Intersects(y), !z.IsEmpty(); got != want {
+			t.Errorf("Intersects(%s, %s): got %v, want %v (%s)", x, y, got, want, &z)
+		}
+
+		// make it false
+		a := x.AppendTo(nil)
+		for _, v := range a {
+			y.Remove(v)
+		}
+
+		if got, want := x.Intersects(y), false; got != want {
+			t.Errorf("Intersects: got %v, want %v", got, want)
+		}
+
+		// make it true
+		if x.IsEmpty() {
+			continue
+		}
+		i := prng.Intn(len(a))
+		y.Insert(a[i])
+
+		if got, want := x.Intersects(y), true; got != want {
+			t.Errorf("Intersects: got %v, want %v", got, want)
+		}
+	}
+}
+
+func TestSubsetOf(t *testing.T) {
+	prng := rand.New(rand.NewSource(0))
+
+	for i := uint(0); i < 12; i++ {
+		X, Y := randomPset(prng, 1<<i), randomPset(prng, 1<<i)
+		x, y := &X.bits, &Y.bits
+
+		// test the slow way
+		var z intsets.Sparse
+		z.Copy(x)
+		z.DifferenceWith(y)
+
+		if got, want := x.SubsetOf(y), z.IsEmpty(); got != want {
+			t.Errorf("SubsetOf: got %v, want %v", got, want)
+		}
+
+		// make it true
+		y.UnionWith(x)
+
+		if got, want := x.SubsetOf(y), true; got != want {
+			t.Errorf("SubsetOf: got %v, want %v", got, want)
+		}
+
+		// make it false
+		if x.IsEmpty() {
+			continue
+		}
+		a := x.AppendTo(nil)
+		i := prng.Intn(len(a))
+		y.Remove(a[i])
+
+		if got, want := x.SubsetOf(y), false; got != want {
+			t.Errorf("SubsetOf: got %v, want %v", got, want)
+		}
+	}
+}
+
+func TestBitString(t *testing.T) {
+	for _, test := range []struct {
+		input []int
+		want  string
+	}{
+		{nil, "0"},
+		{[]int{0}, "1"},
+		{[]int{0, 4, 5}, "110001"},
+		{[]int{0, 7, 177}, "1" + strings.Repeat("0", 169) + "10000001"},
+		{[]int{-3, 0, 4, 5}, "110001.001"},
+		{[]int{-3}, "0.001"},
+	} {
+		var set intsets.Sparse
+		for _, x := range test.input {
+			set.Insert(x)
+		}
+		if got := set.BitString(); got != test.want {
+			t.Errorf("BitString(%s) = %s, want %s", set.String(), got, test.want)
+		}
+	}
+}
+
+func TestFailFastOnShallowCopy(t *testing.T) {
+	var x intsets.Sparse
+	x.Insert(1)
+
+	y := x // shallow copy (breaks representation invariants)
+	defer func() {
+		got := fmt.Sprint(recover())
+		want := "interface conversion: interface {} is nil, not intsets.to_copy_a_sparse_you_must_call_its_Copy_method"
+		if got != want {
+			t.Errorf("shallow copy: recover() = %q, want %q", got, want)
+		}
+	}()
+	y.String() // panics
+	t.Error("didn't panic as expected")
+}
+
+// -- Benchmarks -------------------------------------------------------
+
+// TODO(adonovan):
+// - Add benchmarks of each method.
+// - Gather set distributions from pointer analysis.
+// - Measure memory usage.
+
+func benchmarkInsertProbeSparse(b *testing.B, size, spread int) {
+	prng := rand.New(rand.NewSource(0))
+	// Generate our insertions and probes beforehand (we don't want to benchmark
+	// the prng).
+	insert := make([]int, size)
+	probe := make([]int, size*2)
+	for i := range insert {
+		insert[i] = prng.Int() % spread
+	}
+	for i := range probe {
+		probe[i] = prng.Int() % spread
+	}
+
+	b.ResetTimer()
+	var x intsets.Sparse
+	for tries := 0; tries < b.N; tries++ {
+		x.Clear()
+		for _, n := range insert {
+			x.Insert(n)
+		}
+		hits := 0
+		for _, n := range probe {
+			if x.Has(n) {
+				hits++
+			}
+		}
+		// Use the variable so it doesn't get optimized away.
+		if hits > len(probe) {
+			b.Fatalf("%d hits, only %d probes", hits, len(probe))
+		}
+	}
+}
+
+func BenchmarkInsertProbeSparse_2_10(b *testing.B) {
+	benchmarkInsertProbeSparse(b, 2, 10)
+}
+
+func BenchmarkInsertProbeSparse_10_10(b *testing.B) {
+	benchmarkInsertProbeSparse(b, 10, 10)
+}
+
+func BenchmarkInsertProbeSparse_10_1000(b *testing.B) {
+	benchmarkInsertProbeSparse(b, 10, 1000)
+}
+
+func BenchmarkInsertProbeSparse_100_100(b *testing.B) {
+	benchmarkInsertProbeSparse(b, 100, 100)
+}
+
+func BenchmarkInsertProbeSparse_100_10000(b *testing.B) {
+	benchmarkInsertProbeSparse(b, 100, 1000)
+}
+
+func BenchmarkUnionDifferenceSparse(b *testing.B) {
+	prng := rand.New(rand.NewSource(0))
+	for tries := 0; tries < b.N; tries++ {
+		var x, y, z intsets.Sparse
+		for i := 0; i < 1000; i++ {
+			n := int(prng.Int()) % 100000
+			if i%2 == 0 {
+				x.Insert(n)
+			} else {
+				y.Insert(n)
+			}
+		}
+		z.Union(&x, &y)
+		z.Difference(&x, &y)
+	}
+}
+
+func BenchmarkUnionDifferenceHashTable(b *testing.B) {
+	prng := rand.New(rand.NewSource(0))
+	for tries := 0; tries < b.N; tries++ {
+		x, y, z := make(map[int]bool), make(map[int]bool), make(map[int]bool)
+		for i := 0; i < 1000; i++ {
+			n := int(prng.Int()) % 100000
+			if i%2 == 0 {
+				x[n] = true
+			} else {
+				y[n] = true
+			}
+		}
+		// union
+		for n := range x {
+			z[n] = true
+		}
+		for n := range y {
+			z[n] = true
+		}
+		// difference
+		z = make(map[int]bool)
+		for n := range y {
+			if !x[n] {
+				z[n] = true
+			}
+		}
+	}
+}
+
+func BenchmarkAppendTo(b *testing.B) {
+	prng := rand.New(rand.NewSource(0))
+	var x intsets.Sparse
+	for i := 0; i < 1000; i++ {
+		x.Insert(int(prng.Int()) % 10000)
+	}
+	var space [1000]int
+	for tries := 0; tries < b.N; tries++ {
+		x.AppendTo(space[:0])
+	}
+}
diff --git a/vendor/golang.org/x/tools/container/intsets/util.go b/vendor/golang.org/x/tools/container/intsets/util.go
index 76e682c..dd1db86 100644
--- a/vendor/golang.org/x/tools/container/intsets/util.go
+++ b/vendor/golang.org/x/tools/container/intsets/util.go
@@ -4,6 +4,16 @@
 
 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() {
@@ -18,8 +28,7 @@ func init() {
 	}
 }
 
-// popcount returns the population count (number of set bits) of x.
-func popcount(x word) int {
+func popcountTable(x word) int {
 	return int(a[byte(x>>(0*8))] +
 		a[byte(x>>(1*8))] +
 		a[byte(x>>(2*8))] +
diff --git a/vendor/golang.org/x/tools/container/intsets/util_test.go b/vendor/golang.org/x/tools/container/intsets/util_test.go
new file mode 100644
index 0000000..e4cc659
--- /dev/null
+++ b/vendor/golang.org/x/tools/container/intsets/util_test.go
@@ -0,0 +1,58 @@
+// 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
+
+import (
+	"math/rand"
+	"testing"
+)
+
+func TestNLZ(t *testing.T) {
+	// Test the platform-specific edge case.
+	// NB: v must be a var (not const) so that the word() conversion is dynamic.
+	// Otherwise the compiler will report an error.
+	v := uint64(0x0000801000000000)
+	n := nlz(word(v))
+	want := 32 // (on 32-bit)
+	if bitsPerWord == 64 {
+		want = 16
+	}
+	if n != want {
+		t.Errorf("%d-bit nlz(%d) = %d, want %d", bitsPerWord, v, n, want)
+	}
+}
+
+// Backdoor for testing.
+func (s *Sparse) Check() error { return s.check() }
+
+func dumbPopcount(x word) int {
+	var popcnt int
+	for i := uint(0); i < bitsPerWord; i++ {
+		if x&(1<<i) != 0 {
+			popcnt++
+		}
+	}
+	return popcnt
+}
+
+func TestPopcount(t *testing.T) {
+	for i := 0; i < 1e5; i++ {
+		x := word(rand.Uint32())
+		if bitsPerWord == 64 {
+			x = x | (word(rand.Uint32()) << 32)
+		}
+		want := dumbPopcount(x)
+		got := popcount(x)
+		if got != want {
+			t.Errorf("popcount(%d) = %d, want %d", x, got, want)
+		}
+	}
+}
+
+func BenchmarkPopcount(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		popcount(word(i))
+	}
+}
diff --git a/vendor/golang.org/x/tools/cover/profile.go b/vendor/golang.org/x/tools/cover/profile.go
new file mode 100644
index 0000000..b6c8120
--- /dev/null
+++ b/vendor/golang.org/x/tools/cover/profile.go
@@ -0,0 +1,213 @@
+// 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 cover provides support for parsing coverage profiles
+// generated by "go test -coverprofile=cover.out".
+package cover // import "golang.org/x/tools/cover"
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Profile represents the profiling data for a specific file.
+type Profile struct {
+	FileName string
+	Mode     string
+	Blocks   []ProfileBlock
+}
+
+// ProfileBlock represents a single block of profiling data.
+type ProfileBlock struct {
+	StartLine, StartCol int
+	EndLine, EndCol     int
+	NumStmt, Count      int
+}
+
+type byFileName []*Profile
+
+func (p byFileName) Len() int           { return len(p) }
+func (p byFileName) Less(i, j int) bool { return p[i].FileName < p[j].FileName }
+func (p byFileName) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+// ParseProfiles parses profile data in the specified file and returns a
+// Profile for each source file described therein.
+func ParseProfiles(fileName string) ([]*Profile, error) {
+	pf, err := os.Open(fileName)
+	if err != nil {
+		return nil, err
+	}
+	defer pf.Close()
+
+	files := make(map[string]*Profile)
+	buf := bufio.NewReader(pf)
+	// First line is "mode: foo", where foo is "set", "count", or "atomic".
+	// Rest of file is in the format
+	//	encoding/base64/base64.go:34.44,37.40 3 1
+	// where the fields are: name.go:line.column,line.column numberOfStatements count
+	s := bufio.NewScanner(buf)
+	mode := ""
+	for s.Scan() {
+		line := s.Text()
+		if mode == "" {
+			const p = "mode: "
+			if !strings.HasPrefix(line, p) || line == p {
+				return nil, fmt.Errorf("bad mode line: %v", line)
+			}
+			mode = line[len(p):]
+			continue
+		}
+		m := lineRe.FindStringSubmatch(line)
+		if m == nil {
+			return nil, fmt.Errorf("line %q doesn't match expected format: %v", line, lineRe)
+		}
+		fn := m[1]
+		p := files[fn]
+		if p == nil {
+			p = &Profile{
+				FileName: fn,
+				Mode:     mode,
+			}
+			files[fn] = p
+		}
+		p.Blocks = append(p.Blocks, ProfileBlock{
+			StartLine: toInt(m[2]),
+			StartCol:  toInt(m[3]),
+			EndLine:   toInt(m[4]),
+			EndCol:    toInt(m[5]),
+			NumStmt:   toInt(m[6]),
+			Count:     toInt(m[7]),
+		})
+	}
+	if err := s.Err(); err != nil {
+		return nil, err
+	}
+	for _, p := range files {
+		sort.Sort(blocksByStart(p.Blocks))
+		// Merge samples from the same location.
+		j := 1
+		for i := 1; i < len(p.Blocks); i++ {
+			b := p.Blocks[i]
+			last := p.Blocks[j-1]
+			if b.StartLine == last.StartLine &&
+				b.StartCol == last.StartCol &&
+				b.EndLine == last.EndLine &&
+				b.EndCol == last.EndCol {
+				if b.NumStmt != last.NumStmt {
+					return nil, fmt.Errorf("inconsistent NumStmt: changed from %d to %d", last.NumStmt, b.NumStmt)
+				}
+				if mode == "set" {
+					p.Blocks[j-1].Count |= b.Count
+				} else {
+					p.Blocks[j-1].Count += b.Count
+				}
+				continue
+			}
+			p.Blocks[j] = b
+			j++
+		}
+		p.Blocks = p.Blocks[:j]
+	}
+	// Generate a sorted slice.
+	profiles := make([]*Profile, 0, len(files))
+	for _, profile := range files {
+		profiles = append(profiles, profile)
+	}
+	sort.Sort(byFileName(profiles))
+	return profiles, nil
+}
+
+type blocksByStart []ProfileBlock
+
+func (b blocksByStart) Len() int      { return len(b) }
+func (b blocksByStart) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b blocksByStart) Less(i, j int) bool {
+	bi, bj := b[i], b[j]
+	return bi.StartLine < bj.StartLine || bi.StartLine == bj.StartLine && bi.StartCol < bj.StartCol
+}
+
+var lineRe = regexp.MustCompile(`^(.+):([0-9]+).([0-9]+),([0-9]+).([0-9]+) ([0-9]+) ([0-9]+)$`)
+
+func toInt(s string) int {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		panic(err)
+	}
+	return i
+}
+
+// Boundary represents the position in a source file of the beginning or end of a
+// block as reported by the coverage profile. In HTML mode, it will correspond to
+// the opening or closing of a <span> tag and will be used to colorize the source
+type Boundary struct {
+	Offset int     // Location as a byte offset in the source file.
+	Start  bool    // Is this the start of a block?
+	Count  int     // Event count from the cover profile.
+	Norm   float64 // Count normalized to [0..1].
+}
+
+// Boundaries returns a Profile as a set of Boundary objects within the provided src.
+func (p *Profile) Boundaries(src []byte) (boundaries []Boundary) {
+	// Find maximum count.
+	max := 0
+	for _, b := range p.Blocks {
+		if b.Count > max {
+			max = b.Count
+		}
+	}
+	// Divisor for normalization.
+	divisor := math.Log(float64(max))
+
+	// boundary returns a Boundary, populating the Norm field with a normalized Count.
+	boundary := func(offset int, start bool, count int) Boundary {
+		b := Boundary{Offset: offset, Start: start, Count: count}
+		if !start || count == 0 {
+			return b
+		}
+		if max <= 1 {
+			b.Norm = 0.8 // Profile is in"set" mode; we want a heat map. Use cov8 in the CSS.
+		} else if count > 0 {
+			b.Norm = math.Log(float64(count)) / divisor
+		}
+		return b
+	}
+
+	line, col := 1, 2 // TODO: Why is this 2?
+	for si, bi := 0, 0; si < len(src) && bi < len(p.Blocks); {
+		b := p.Blocks[bi]
+		if b.StartLine == line && b.StartCol == col {
+			boundaries = append(boundaries, boundary(si, true, b.Count))
+		}
+		if b.EndLine == line && b.EndCol == col || line > b.EndLine {
+			boundaries = append(boundaries, boundary(si, false, 0))
+			bi++
+			continue // Don't advance through src; maybe the next block starts here.
+		}
+		if src[si] == '\n' {
+			line++
+			col = 0
+		}
+		col++
+		si++
+	}
+	sort.Sort(boundariesByPos(boundaries))
+	return
+}
+
+type boundariesByPos []Boundary
+
+func (b boundariesByPos) Len() int      { return len(b) }
+func (b boundariesByPos) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b boundariesByPos) Less(i, j int) bool {
+	if b[i].Offset == b[j].Offset {
+		return !b[i].Start && b[j].Start
+	}
+	return b[i].Offset < b[j].Offset
+}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go b/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
index 2de739e..6b7052b 100644
--- a/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
+++ b/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
@@ -447,9 +447,8 @@ func childrenOf(n ast.Node) []ast.Node {
 	case *ast.ValueSpec:
 		// TODO(adonovan): ValueSpec.{Doc,Comment}?
 
-	default:
-		// Includes *ast.BadDecl, *ast.BadExpr, *ast.BadStmt.
-		panic(fmt.Sprintf("unexpected node type %T", n))
+	case *ast.BadDecl, *ast.BadExpr, *ast.BadStmt:
+		// nop
 	}
 
 	// TODO(adonovan): opt: merge the logic of ast.Inspect() into
@@ -510,7 +509,10 @@ func NodeDescription(n ast.Node) string {
 			return "fall-through statement"
 		}
 	case *ast.CallExpr:
-		return "function call (or conversion)"
+		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:
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/enclosing_test.go b/vendor/golang.org/x/tools/go/ast/astutil/enclosing_test.go
new file mode 100644
index 0000000..107f87c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/enclosing_test.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 astutil_test
+
+// This file defines tests of PathEnclosingInterval.
+
+// TODO(adonovan): exhaustive tests that run over the whole input
+// tree, not just handcrafted examples.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// 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()
+}
+
+// findInterval parses input and returns the [start, end) positions of
+// the first occurrence of substr in input.  f==nil indicates failure;
+// an error has already been reported in that case.
+//
+func findInterval(t *testing.T, fset *token.FileSet, input, substr string) (f *ast.File, start, end token.Pos) {
+	f, err := parser.ParseFile(fset, "<input>", input, 0)
+	if err != nil {
+		t.Errorf("parse error: %s", err)
+		return
+	}
+
+	i := strings.Index(input, substr)
+	if i < 0 {
+		t.Errorf("%q is not a substring of input", substr)
+		f = nil
+		return
+	}
+
+	filePos := fset.File(f.Package)
+	return f, filePos.Pos(i), filePos.Pos(i + len(substr))
+}
+
+// Common input for following tests.
+const input = `
+// Hello.
+package main
+import "fmt"
+func f() {}
+func main() {
+	z := (x + y) // add them
+        f() // NB: ExprStmt and its CallExpr have same Pos/End
+}
+`
+
+func TestPathEnclosingInterval_Exact(t *testing.T) {
+	// For the exact tests, we check that a substring is mapped to
+	// the canonical string for the node it denotes.
+	tests := []struct {
+		substr string // first occurrence of this string indicates interval
+		node   string // complete text of expected containing node
+	}{
+		{"package",
+			input[11 : len(input)-1]},
+		{"\npack",
+			input[11 : len(input)-1]},
+		{"main",
+			"main"},
+		{"import",
+			"import \"fmt\""},
+		{"\"fmt\"",
+			"\"fmt\""},
+		{"\nfunc f() {}\n",
+			"func f() {}"},
+		{"x ",
+			"x"},
+		{" y",
+			"y"},
+		{"z",
+			"z"},
+		{" + ",
+			"x + y"},
+		{" :=",
+			"z := (x + y)"},
+		{"x + y",
+			"x + y"},
+		{"(x + y)",
+			"(x + y)"},
+		{" (x + y) ",
+			"(x + y)"},
+		{" (x + y) // add",
+			"(x + y)"},
+		{"func",
+			"func f() {}"},
+		{"func f() {}",
+			"func f() {}"},
+		{"\nfun",
+			"func f() {}"},
+		{" f",
+			"f"},
+	}
+	for _, test := range tests {
+		f, start, end := findInterval(t, new(token.FileSet), input, test.substr)
+		if f == nil {
+			continue
+		}
+
+		path, exact := astutil.PathEnclosingInterval(f, start, end)
+		if !exact {
+			t.Errorf("PathEnclosingInterval(%q) not exact", test.substr)
+			continue
+		}
+
+		if len(path) == 0 {
+			if test.node != "" {
+				t.Errorf("PathEnclosingInterval(%q).path: got [], want %q",
+					test.substr, test.node)
+			}
+			continue
+		}
+
+		if got := input[path[0].Pos():path[0].End()]; got != test.node {
+			t.Errorf("PathEnclosingInterval(%q): got %q, want %q (path was %s)",
+				test.substr, got, test.node, pathToString(path))
+			continue
+		}
+	}
+}
+
+func TestPathEnclosingInterval_Paths(t *testing.T) {
+	// For these tests, we check only the path of the enclosing
+	// node, but not its complete text because it's often quite
+	// large when !exact.
+	tests := []struct {
+		substr string // first occurrence of this string indicates interval
+		path   string // the pathToString(),exact of the expected path
+	}{
+		{"// add",
+			"[BlockStmt FuncDecl File],false"},
+		{"(x + y",
+			"[ParenExpr AssignStmt BlockStmt FuncDecl File],false"},
+		{"x +",
+			"[BinaryExpr ParenExpr AssignStmt BlockStmt FuncDecl File],false"},
+		{"z := (x",
+			"[AssignStmt BlockStmt FuncDecl File],false"},
+		{"func f",
+			"[FuncDecl File],false"},
+		{"func f()",
+			"[FuncDecl File],false"},
+		{" f()",
+			"[FuncDecl File],false"},
+		{"() {}",
+			"[FuncDecl File],false"},
+		{"// Hello",
+			"[File],false"},
+		{" f",
+			"[Ident FuncDecl File],true"},
+		{"func ",
+			"[FuncDecl File],true"},
+		{"mai",
+			"[Ident File],true"},
+		{"f() // NB",
+			"[CallExpr ExprStmt BlockStmt FuncDecl File],true"},
+	}
+	for _, test := range tests {
+		f, start, end := findInterval(t, new(token.FileSet), input, test.substr)
+		if f == nil {
+			continue
+		}
+
+		path, exact := astutil.PathEnclosingInterval(f, start, end)
+		if got := fmt.Sprintf("%s,%v", pathToString(path), exact); got != test.path {
+			t.Errorf("PathEnclosingInterval(%q): got %q, want %q",
+				test.substr, got, test.path)
+			continue
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/imports.go b/vendor/golang.org/x/tools/go/ast/astutil/imports.go
index 7f9b162..83f196c 100644
--- a/vendor/golang.org/x/tools/go/ast/astutil/imports.go
+++ b/vendor/golang.org/x/tools/go/ast/astutil/imports.go
@@ -49,6 +49,8 @@ func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added
 		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)
@@ -65,15 +67,27 @@ func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added
 				impDecl = gen
 			}
 
-			// Compute longest shared prefix with imports in this group.
+			// 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)
-				n := matchLen(importPath(impspec), ipath)
-				if n > bestMatch {
+				p := importPath(impspec)
+				n := matchLen(p, ipath)
+				if n > bestMatch || (bestMatch == 0 && !seenAnyThirdParty && isThirdPartyPath) {
 					bestMatch = n
 					impDecl = gen
 					impIndex = j
 				}
+				seenAnyThirdParty = seenAnyThirdParty || isThirdParty(p)
 			}
 		}
 	}
@@ -117,9 +131,15 @@ func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added
 	impDecl.Specs[insertAt] = newImport
 	pos := impDecl.Pos()
 	if insertAt > 0 {
-		// 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 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
@@ -137,12 +157,53 @@ func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added
 	}
 
 	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++ {
@@ -154,6 +215,12 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 		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
 			}
@@ -173,7 +240,36 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 				i--
 				break
 			} else if len(gen.Specs) == 1 {
-				gen.Lparen = token.NoPos // drop parens
+				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)
@@ -186,7 +282,7 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 					// There was a blank line immediately preceding the deleted import,
 					// so there's no need to close the hole.
 					// Do nothing.
-				} else {
+				} else if line != fset.File(gen.Rparen).LineCount() {
 					// There was no blank line. Close the hole.
 					fset.File(gen.Rparen).MergeLine(line)
 				}
@@ -195,7 +291,7 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 		}
 	}
 
-	// Delete them from f.Imports.
+	// Delete imports from f.Imports.
 	for i := 0; i < len(f.Imports); i++ {
 		imp := f.Imports[i]
 		for j, del := range delspecs {
@@ -210,6 +306,21 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 		}
 	}
 
+	// 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))
 	}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/imports_test.go b/vendor/golang.org/x/tools/go/ast/astutil/imports_test.go
new file mode 100644
index 0000000..8bc3480
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/imports_test.go
@@ -0,0 +1,1818 @@
+// 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
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+var fset = token.NewFileSet()
+
+func parse(t *testing.T, name, in string) *ast.File {
+	file, err := parser.ParseFile(fset, name, in, parser.ParseComments)
+	if err != nil {
+		t.Fatalf("%s parse: %v", name, err)
+	}
+	return file
+}
+
+func print(t *testing.T, name string, f *ast.File) string {
+	var buf bytes.Buffer
+	if err := format.Node(&buf, fset, f); err != nil {
+		t.Fatalf("%s gofmt: %v", name, err)
+	}
+	return string(buf.Bytes())
+}
+
+type test struct {
+	name       string
+	renamedPkg string
+	pkg        string
+	in         string
+	out        string
+	broken     bool // known broken
+}
+
+var addTests = []test{
+	{
+		name: "leave os alone",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"os"
+)
+`,
+		out: `package main
+
+import (
+	"os"
+)
+`,
+	},
+	{
+		name: "import.1",
+		pkg:  "os",
+		in: `package main
+`,
+		out: `package main
+
+import "os"
+`,
+	},
+	{
+		name: "import.2",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+`,
+		out: `package main
+
+// Comment
+import "C"
+import "os"
+`,
+	},
+	{
+		name: "import.3",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"utf8"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.17",
+		pkg:  "x/y/z",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"a"
+	"b"
+
+	"x/w"
+
+	"d/f"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"a"
+	"b"
+
+	"x/w"
+	"x/y/z"
+
+	"d/f"
+)
+`,
+	},
+	{
+		name: "issue #19190",
+		pkg:  "x.org/y/z",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"bytes"
+	"os"
+
+	"d.com/f"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"bytes"
+	"os"
+
+	"d.com/f"
+	"x.org/y/z"
+)
+`,
+	},
+	{
+		name: "issue #19190 with existing grouped import packages",
+		pkg:  "x.org/y/z",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"bytes"
+	"os"
+
+	"c.com/f"
+	"d.com/f"
+
+	"y.com/a"
+	"y.com/b"
+	"y.com/c"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"bytes"
+	"os"
+
+	"c.com/f"
+	"d.com/f"
+	"x.org/y/z"
+
+	"y.com/a"
+	"y.com/b"
+	"y.com/c"
+)
+`,
+	},
+	{
+		name: "issue #19190 - match score is still respected",
+		pkg:  "y.org/c",
+		in: `package main
+
+import (
+	"x.org/a"
+
+	"y.org/b"
+)
+`,
+		out: `package main
+
+import (
+	"x.org/a"
+
+	"y.org/b"
+	"y.org/c"
+)
+`,
+	},
+	{
+		name: "import into singular group",
+		pkg:  "bytes",
+		in: `package main
+
+import "os"
+
+`,
+		out: `package main
+
+import (
+	"bytes"
+	"os"
+)
+`,
+	},
+	{
+		name: "import into singular group with comment",
+		pkg:  "bytes",
+		in: `package main
+
+import /* why */ /* comment here? */ "os"
+
+`,
+		out: `package main
+
+import /* why */ /* comment here? */ (
+	"bytes"
+	"os"
+)
+`,
+	},
+	{
+		name: "import into group with leading comment",
+		pkg:  "strings",
+		in: `package main
+
+import (
+	// comment before bytes
+	"bytes"
+	"os"
+)
+
+`,
+		out: `package main
+
+import (
+	// comment before bytes
+	"bytes"
+	"os"
+	"strings"
+)
+`,
+	},
+	{
+		name:       "",
+		renamedPkg: "fmtpkg",
+		pkg:        "fmt",
+		in: `package main
+
+import "os"
+
+`,
+		out: `package main
+
+import (
+	fmtpkg "fmt"
+	"os"
+)
+`,
+	},
+	{
+		name: "struct comment",
+		pkg:  "time",
+		in: `package main
+
+// This is a comment before a struct.
+type T struct {
+	t  time.Time
+}
+`,
+		out: `package main
+
+import "time"
+
+// This is a comment before a struct.
+type T struct {
+	t time.Time
+}
+`,
+	},
+	{
+		name: "issue 8729 import C",
+		pkg:  "time",
+		in: `package main
+
+import "C"
+
+// comment
+type T time.Time
+`,
+		out: `package main
+
+import "C"
+import "time"
+
+// comment
+type T time.Time
+`,
+	},
+	{
+		name: "issue 8729 empty import",
+		pkg:  "time",
+		in: `package main
+
+import ()
+
+// comment
+type T time.Time
+`,
+		out: `package main
+
+import "time"
+
+// comment
+type T time.Time
+`,
+	},
+	{
+		name: "issue 8729 comment on package line",
+		pkg:  "time",
+		in: `package main // comment
+
+type T time.Time
+`,
+		out: `package main // comment
+import "time"
+
+type T time.Time
+`,
+	},
+	{
+		name: "issue 8729 comment after package",
+		pkg:  "time",
+		in: `package main
+// comment
+
+type T time.Time
+`,
+		out: `package main
+
+import "time"
+
+// comment
+
+type T time.Time
+`,
+	},
+	{
+		name: "issue 8729 comment before and on package line",
+		pkg:  "time",
+		in: `// comment before
+package main // comment on
+
+type T time.Time
+`,
+		out: `// comment before
+package main // comment on
+import "time"
+
+type T time.Time
+`,
+	},
+
+	// Issue 9961: Match prefixes using path segments rather than bytes
+	{
+		name: "issue 9961",
+		pkg:  "regexp",
+		in: `package main
+
+import (
+	"flag"
+	"testing"
+
+	"rsc.io/p"
+)
+`,
+		out: `package main
+
+import (
+	"flag"
+	"regexp"
+	"testing"
+
+	"rsc.io/p"
+)
+`,
+	},
+	// Issue 10337: Preserve comment position
+	{
+		name: "issue 10337",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"bytes" // a
+	"log" // c
+)
+`,
+		out: `package main
+
+import (
+	"bytes" // a
+	"fmt"
+	"log" // c
+)
+`,
+	},
+	{
+		name: "issue 10337 new import at the start",
+		pkg:  "bytes",
+		in: `package main
+
+import (
+	"fmt" // b
+	"log" // c
+)
+`,
+		out: `package main
+
+import (
+	"bytes"
+	"fmt" // b
+	"log" // c
+)
+`,
+	},
+	{
+		name: "issue 10337 new import at the end",
+		pkg:  "log",
+		in: `package main
+
+import (
+	"bytes" // a
+	"fmt" // b
+)
+`,
+		out: `package main
+
+import (
+	"bytes" // a
+	"fmt"   // b
+	"log"
+)
+`,
+	},
+	// Issue 14075: Merge import declarations
+	{
+		name: "issue 14075",
+		pkg:  "bufio",
+		in: `package main
+
+import "bytes"
+import "fmt"
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+)
+`,
+	},
+	{
+		name: "issue 14075 update position",
+		pkg:  "bufio",
+		in: `package main
+
+import "bytes"
+import (
+	"fmt"
+)
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+)
+`,
+	},
+	{
+		name: `issue 14075 ignore import "C"`,
+		pkg:  "bufio",
+		in: `package main
+
+// Comment
+import "C"
+
+import "bytes"
+import "fmt"
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+)
+`,
+	},
+	{
+		name: `issue 14075 ignore adjacent import "C"`,
+		pkg:  "bufio",
+		in: `package main
+
+// Comment
+import "C"
+import "fmt"
+`,
+		out: `package main
+
+// Comment
+import "C"
+import (
+	"bufio"
+	"fmt"
+)
+`,
+	},
+	{
+		name: `issue 14075 ignore adjacent import "C" (without factored import)`,
+		pkg:  "bufio",
+		in: `package main
+
+// Comment
+import "C"
+import "fmt"
+`,
+		out: `package main
+
+// Comment
+import "C"
+import (
+	"bufio"
+	"fmt"
+)
+`,
+	},
+	{
+		name: `issue 14075 ignore single import "C"`,
+		pkg:  "bufio",
+		in: `package main
+
+// Comment
+import "C"
+`,
+		out: `package main
+
+// Comment
+import "C"
+import "bufio"
+`,
+	},
+	{
+		name: `issue 17212 several single-import lines with shared prefix ending in a slash`,
+		pkg:  "net/http",
+		in: `package main
+
+import "bufio"
+import "net/url"
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"net/http"
+	"net/url"
+)
+`,
+	},
+	{
+		name: `issue 17212 block imports lines with shared prefix ending in a slash`,
+		pkg:  "net/http",
+		in: `package main
+
+import (
+	"bufio"
+	"net/url"
+)
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"net/http"
+	"net/url"
+)
+`,
+	},
+	{
+		name: `issue 17213 many single-import lines`,
+		pkg:  "fmt",
+		in: `package main
+
+import "bufio"
+import "bytes"
+import "errors"
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+)
+`,
+	},
+}
+
+func TestAddImport(t *testing.T) {
+	for _, test := range addTests {
+		file := parse(t, test.name, test.in)
+		var before bytes.Buffer
+		ast.Fprint(&before, fset, file, nil)
+		AddNamedImport(fset, file, test.renamedPkg, test.pkg)
+		if got := print(t, test.name, file); got != test.out {
+			if test.broken {
+				t.Logf("%s is known broken:\ngot: %s\nwant: %s", test.name, got, test.out)
+			} else {
+				t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+			}
+			var after bytes.Buffer
+			ast.Fprint(&after, fset, file, nil)
+
+			t.Logf("AST before:\n%s\nAST after:\n%s\n", before.String(), after.String())
+		}
+	}
+}
+
+func TestDoubleAddImport(t *testing.T) {
+	file := parse(t, "doubleimport", "package main\n")
+	AddImport(fset, file, "os")
+	AddImport(fset, file, "bytes")
+	want := `package main
+
+import (
+	"bytes"
+	"os"
+)
+`
+	if got := print(t, "doubleimport", file); got != want {
+		t.Errorf("got: %s\nwant: %s", got, want)
+	}
+}
+
+func TestDoubleAddNamedImport(t *testing.T) {
+	file := parse(t, "doublenamedimport", "package main\n")
+	AddNamedImport(fset, file, "o", "os")
+	AddNamedImport(fset, file, "i", "io")
+	want := `package main
+
+import (
+	i "io"
+	o "os"
+)
+`
+	if got := print(t, "doublenamedimport", file); got != want {
+		t.Errorf("got: %s\nwant: %s", got, want)
+	}
+}
+
+// Part of issue 8729.
+func TestDoubleAddImportWithDeclComment(t *testing.T) {
+	file := parse(t, "doubleimport", `package main
+
+import (
+)
+
+// comment
+type I int
+`)
+	// The AddImport order here matters.
+	AddImport(fset, file, "golang.org/x/tools/go/ast/astutil")
+	AddImport(fset, file, "os")
+	want := `package main
+
+import (
+	"golang.org/x/tools/go/ast/astutil"
+	"os"
+)
+
+// comment
+type I int
+`
+	if got := print(t, "doubleimport_with_decl_comment", file); got != want {
+		t.Errorf("got: %s\nwant: %s", got, want)
+	}
+}
+
+var deleteTests = []test{
+	{
+		name: "import.4",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"os"
+)
+`,
+		out: `package main
+`,
+	},
+	{
+		name: "import.5",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+import "os"
+`,
+		out: `package main
+
+// Comment
+import "C"
+`,
+	},
+	{
+		name: "import.6",
+		pkg:  "os",
+		in: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+// Comment
+import "C"
+
+import (
+	"io"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.7",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	// a
+	"os"   // b
+	"utf8" // c
+)
+`,
+	},
+	{
+		name: "import.8",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	"io" // a
+	// b
+	"utf8" // c
+)
+`,
+	},
+	{
+		name: "import.9",
+		pkg:  "utf8",
+		in: `package main
+
+import (
+	"io"   // a
+	"os"   // b
+	"utf8" // c
+)
+`,
+		out: `package main
+
+import (
+	"io" // a
+	"os" // b
+	// c
+)
+`,
+	},
+	{
+		name: "import.10",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"os"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.11",
+		pkg:  "os",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"io"
+	"utf8"
+)
+`,
+	},
+	{
+		name: "import.12",
+		pkg:  "utf8",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8"
+)
+`,
+		out: `package main
+
+import (
+	"io"
+	"os"
+)
+`,
+	},
+	{
+		name: "handle.raw.quote.imports",
+		pkg:  "os",
+		in:   "package main\n\nimport `os`",
+		out: `package main
+`,
+	},
+	{
+		name: "import.13",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"fmt"
+
+	"io"
+	"os"
+	"utf8"
+
+	"go/format"
+)
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	"os"
+	"utf8"
+
+	"go/format"
+)
+`,
+	},
+	{
+		name: "import.14",
+		pkg:  "io",
+		in: `package main
+
+import (
+	"fmt" // a
+
+	"io"   // b
+	"os"   // c
+	"utf8" // d
+
+	"go/format" // e
+)
+`,
+		out: `package main
+
+import (
+	"fmt" // a
+
+	// b
+	"os"   // c
+	"utf8" // d
+
+	"go/format" // e
+)
+`,
+	},
+	{
+		name: "import.15",
+		pkg:  "double",
+		in: `package main
+
+import (
+	"double"
+	"double"
+)
+`,
+		out: `package main
+`,
+	},
+	{
+		name: "import.16",
+		pkg:  "bubble",
+		in: `package main
+
+import (
+	"toil"
+	"bubble"
+	"bubble"
+	"trouble"
+)
+`,
+		out: `package main
+
+import (
+	"toil"
+	"trouble"
+)
+`,
+	},
+	{
+		name: "import.17",
+		pkg:  "quad",
+		in: `package main
+
+import (
+	"quad"
+	"quad"
+)
+
+import (
+	"quad"
+	"quad"
+)
+`,
+		out: `package main
+`,
+	},
+	{
+		name:       "import.18",
+		renamedPkg: "x",
+		pkg:        "fmt",
+		in: `package main
+
+import (
+	"fmt"
+	x "fmt"
+)
+`,
+		out: `package main
+
+import (
+	"fmt"
+)
+`,
+	},
+	{
+		name:       "import.18",
+		renamedPkg: "x",
+		pkg:        "fmt",
+		in: `package main
+
+import x "fmt"
+import y "fmt"
+`,
+		out: `package main
+
+import y "fmt"
+`,
+	},
+	// Issue #15432, #18051
+	{
+		name: "import.19",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt"
+
+	// Some comment.
+	"io"
+)`,
+		out: `package main
+
+import (
+	// Some comment.
+	"io"
+)
+`,
+	},
+	{
+		name: "import.20",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt"
+
+	// Some
+	// comment.
+	"io"
+)`,
+		out: `package main
+
+import (
+	// Some
+	// comment.
+	"io"
+)
+`,
+	},
+	{
+		name: "import.21",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt"
+
+	/*
+		Some
+		comment.
+	*/
+	"io"
+)`,
+		out: `package main
+
+import (
+	/*
+		Some
+		comment.
+	*/
+	"io"
+)
+`,
+	},
+	{
+		name: "import.22",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	/* Some */
+	// comment.
+	"io"
+	"fmt"
+)`,
+		out: `package main
+
+import (
+	/* Some */
+	// comment.
+	"io"
+)
+`,
+	},
+	{
+		name: "import.23",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	// comment 1
+	"fmt"
+	// comment 2
+	"io"
+)`,
+		out: `package main
+
+import (
+	// comment 2
+	"io"
+)
+`,
+	},
+	{
+		name: "import.24",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt" // comment 1
+	"io" // comment 2
+)`,
+		out: `package main
+
+import (
+	"io" // comment 2
+)
+`,
+	},
+	{
+		name: "import.25",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt"
+	/* comment */ "io"
+)`,
+		out: `package main
+
+import (
+	/* comment */ "io"
+)
+`,
+	},
+	{
+		name: "import.26",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt"
+	"io" /* comment */
+)`,
+		out: `package main
+
+import (
+	"io" /* comment */
+)
+`,
+	},
+	{
+		name: "import.27",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	"fmt" /* comment */
+	"io"
+)`,
+		out: `package main
+
+import (
+	"io"
+)
+`,
+	},
+	{
+		name: "import.28",
+		pkg:  "fmt",
+		in: `package main
+
+import (
+	/* comment */  "fmt"
+	"io"
+)`,
+		out: `package main
+
+import (
+	"io"
+)
+`,
+	},
+	{
+		name: "import.29",
+		pkg:  "fmt",
+		in: `package main
+
+// comment 1
+import (
+	"fmt"
+	"io" // comment 2
+)`,
+		out: `package main
+
+// comment 1
+import (
+	"io" // comment 2
+)
+`,
+	},
+	{
+		name: "import.30",
+		pkg:  "fmt",
+		in: `package main
+
+// comment 1
+import (
+	"fmt" // comment 2
+	"io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	"io"
+)
+`,
+	},
+	{
+		name: "import.31",
+		pkg:  "fmt",
+		in: `package main
+
+// comment 1
+import (
+	"fmt"
+	/* comment 2 */ "io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	/* comment 2 */ "io"
+)
+`,
+	},
+	{
+		name:       "import.32",
+		pkg:        "fmt",
+		renamedPkg: "f",
+		in: `package main
+
+// comment 1
+import (
+	f "fmt"
+	/* comment 2 */ i "io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	/* comment 2 */ i "io"
+)
+`,
+	},
+	{
+		name:       "import.33",
+		pkg:        "fmt",
+		renamedPkg: "f",
+		in: `package main
+
+// comment 1
+import (
+	/* comment 2 */ f "fmt"
+	i "io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	i "io"
+)
+`,
+	},
+	{
+		name:       "import.34",
+		pkg:        "fmt",
+		renamedPkg: "f",
+		in: `package main
+
+// comment 1
+import (
+	f "fmt" /* comment 2 */
+	i "io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	i "io"
+)
+`,
+	},
+	{
+		name: "import.35",
+		pkg:  "fmt",
+		in: `package main
+
+// comment 1
+import (
+	"fmt"
+	// comment 2
+	"io"
+)`,
+		out: `package main
+
+// comment 1
+import (
+	// comment 2
+	"io"
+)
+`,
+	},
+	{
+		name: "import.36",
+		pkg:  "fmt",
+		in: `package main
+
+/* comment 1 */
+import (
+	"fmt"
+	/* comment 2 */
+	"io"
+)`,
+		out: `package main
+
+/* comment 1 */
+import (
+	/* comment 2 */
+	"io"
+)
+`,
+	},
+
+	// Issue 20229: MergeLine panic on weird input
+	{
+		name: "import.37",
+		pkg:  "io",
+		in: `package main
+import("_"
+"io")`,
+		out: `package main
+
+import (
+	"_"
+)
+`,
+	},
+}
+
+func TestDeleteImport(t *testing.T) {
+	for _, test := range deleteTests {
+		file := parse(t, test.name, test.in)
+		DeleteNamedImport(fset, file, test.renamedPkg, test.pkg)
+		if got := print(t, test.name, file); got != test.out {
+			t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+		}
+	}
+}
+
+type rewriteTest struct {
+	name   string
+	srcPkg string
+	dstPkg string
+	in     string
+	out    string
+}
+
+var rewriteTests = []rewriteTest{
+	{
+		name:   "import.13",
+		srcPkg: "utf8",
+		dstPkg: "encoding/utf8",
+		in: `package main
+
+import (
+	"io"
+	"os"
+	"utf8" // thanks ken
+)
+`,
+		out: `package main
+
+import (
+	"encoding/utf8" // thanks ken
+	"io"
+	"os"
+)
+`,
+	},
+	{
+		name:   "import.14",
+		srcPkg: "asn1",
+		dstPkg: "encoding/asn1",
+		in: `package main
+
+import (
+	"asn1"
+	"crypto"
+	"crypto/rsa"
+	_ "crypto/sha1"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"time"
+)
+
+var x = 1
+`,
+		out: `package main
+
+import (
+	"crypto"
+	"crypto/rsa"
+	_ "crypto/sha1"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"time"
+)
+
+var x = 1
+`,
+	},
+	{
+		name:   "import.15",
+		srcPkg: "url",
+		dstPkg: "net/url",
+		in: `package main
+
+import (
+	"bufio"
+	"net"
+	"path"
+	"url"
+)
+
+var x = 1 // comment on x, not on url
+`,
+		out: `package main
+
+import (
+	"bufio"
+	"net"
+	"net/url"
+	"path"
+)
+
+var x = 1 // comment on x, not on url
+`,
+	},
+	{
+		name:   "import.16",
+		srcPkg: "http",
+		dstPkg: "net/http",
+		in: `package main
+
+import (
+	"flag"
+	"http"
+	"log"
+	"text/template"
+)
+
+var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
+`,
+		out: `package main
+
+import (
+	"flag"
+	"log"
+	"net/http"
+	"text/template"
+)
+
+var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
+`,
+	},
+}
+
+func TestRewriteImport(t *testing.T) {
+	for _, test := range rewriteTests {
+		file := parse(t, test.name, test.in)
+		RewriteImport(fset, file, test.srcPkg, test.dstPkg)
+		if got := print(t, test.name, file); got != test.out {
+			t.Errorf("%s:\ngot: %s\nwant: %s", test.name, got, test.out)
+		}
+	}
+}
+
+var importsTests = []struct {
+	name string
+	in   string
+	want [][]string
+}{
+	{
+		name: "no packages",
+		in: `package foo
+`,
+		want: nil,
+	},
+	{
+		name: "one group",
+		in: `package foo
+
+import (
+	"fmt"
+	"testing"
+)
+`,
+		want: [][]string{{"fmt", "testing"}},
+	},
+	{
+		name: "four groups",
+		in: `package foo
+
+import "C"
+import (
+	"fmt"
+	"testing"
+
+	"appengine"
+
+	"myproject/mylib1"
+	"myproject/mylib2"
+)
+`,
+		want: [][]string{
+			{"C"},
+			{"fmt", "testing"},
+			{"appengine"},
+			{"myproject/mylib1", "myproject/mylib2"},
+		},
+	},
+	{
+		name: "multiple factored groups",
+		in: `package foo
+
+import (
+	"fmt"
+	"testing"
+
+	"appengine"
+)
+import (
+	"reflect"
+
+	"bytes"
+)
+`,
+		want: [][]string{
+			{"fmt", "testing"},
+			{"appengine"},
+			{"reflect"},
+			{"bytes"},
+		},
+	},
+}
+
+func unquote(s string) string {
+	res, err := strconv.Unquote(s)
+	if err != nil {
+		return "could_not_unquote"
+	}
+	return res
+}
+
+func TestImports(t *testing.T) {
+	fset := token.NewFileSet()
+	for _, test := range importsTests {
+		f, err := parser.ParseFile(fset, "test.go", test.in, 0)
+		if err != nil {
+			t.Errorf("%s: %v", test.name, err)
+			continue
+		}
+		var got [][]string
+		for _, group := range Imports(fset, f) {
+			var b []string
+			for _, spec := range group {
+				b = append(b, unquote(spec.Path.Value))
+			}
+			got = append(got, b)
+		}
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("Imports(%s)=%v, want %v", test.name, got, test.want)
+		}
+	}
+}
+
+var usesImportTests = []struct {
+	name string
+	path string
+	in   string
+	want bool
+}{
+	{
+		name: "no packages",
+		path: "io",
+		in: `package foo
+`,
+		want: false,
+	},
+	{
+		name: "import.1",
+		path: "io",
+		in: `package foo
+
+import "io"
+
+var _ io.Writer
+`,
+		want: true,
+	},
+	{
+		name: "import.2",
+		path: "io",
+		in: `package foo
+
+import "io"
+`,
+		want: false,
+	},
+	{
+		name: "import.3",
+		path: "io",
+		in: `package foo
+
+import "io"
+
+var io = 42
+`,
+		want: false,
+	},
+	{
+		name: "import.4",
+		path: "io",
+		in: `package foo
+
+import i "io"
+
+var _ i.Writer
+`,
+		want: true,
+	},
+	{
+		name: "import.5",
+		path: "io",
+		in: `package foo
+
+import i "io"
+`,
+		want: false,
+	},
+	{
+		name: "import.6",
+		path: "io",
+		in: `package foo
+
+import i "io"
+
+var i = 42
+var io = 42
+`,
+		want: false,
+	},
+	{
+		name: "import.7",
+		path: "encoding/json",
+		in: `package foo
+
+import "encoding/json"
+
+var _ json.Encoder
+`,
+		want: true,
+	},
+	{
+		name: "import.8",
+		path: "encoding/json",
+		in: `package foo
+
+import "encoding/json"
+`,
+		want: false,
+	},
+	{
+		name: "import.9",
+		path: "encoding/json",
+		in: `package foo
+
+import "encoding/json"
+
+var json = 42
+`,
+		want: false,
+	},
+	{
+		name: "import.10",
+		path: "encoding/json",
+		in: `package foo
+
+import j "encoding/json"
+
+var _ j.Encoder
+`,
+		want: true,
+	},
+	{
+		name: "import.11",
+		path: "encoding/json",
+		in: `package foo
+
+import j "encoding/json"
+`,
+		want: false,
+	},
+	{
+		name: "import.12",
+		path: "encoding/json",
+		in: `package foo
+
+import j "encoding/json"
+
+var j = 42
+var json = 42
+`,
+		want: false,
+	},
+	{
+		name: "import.13",
+		path: "io",
+		in: `package foo
+
+import _ "io"
+`,
+		want: true,
+	},
+	{
+		name: "import.14",
+		path: "io",
+		in: `package foo
+
+import . "io"
+`,
+		want: true,
+	},
+}
+
+func TestUsesImport(t *testing.T) {
+	fset := token.NewFileSet()
+	for _, test := range usesImportTests {
+		f, err := parser.ParseFile(fset, "test.go", test.in, 0)
+		if err != nil {
+			t.Errorf("%s: %v", test.name, err)
+			continue
+		}
+		got := UsesImport(f, test.path)
+		if got != test.want {
+			t.Errorf("UsesImport(%s)=%v, want %v", test.name, got, test.want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go b/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go
new file mode 100644
index 0000000..cf72ea9
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/ast/astutil/rewrite_test.go b/vendor/golang.org/x/tools/go/ast/astutil/rewrite_test.go
new file mode 100644
index 0000000..1c86970
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/rewrite_test.go
@@ -0,0 +1,248 @@
+// 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_test
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"testing"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+var rewriteTests = [...]struct {
+	name       string
+	orig, want string
+	pre, post  astutil.ApplyFunc
+}{
+	{name: "nop", orig: "package p\n", want: "package p\n"},
+
+	{name: "replace",
+		orig: `package p
+
+var x int
+`,
+		want: `package p
+
+var t T
+`,
+		post: func(c *astutil.Cursor) bool {
+			if _, ok := c.Node().(*ast.ValueSpec); ok {
+				c.Replace(valspec("t", "T"))
+				return false
+			}
+			return true
+		},
+	},
+
+	{name: "set doc strings",
+		orig: `package p
+
+const z = 0
+
+type T struct{}
+
+var x int
+`,
+		want: `package p
+// a foo is a foo
+const z = 0
+// a foo is a foo
+type T struct{}
+// a foo is a foo
+var x int
+`,
+		post: func(c *astutil.Cursor) bool {
+			if _, ok := c.Parent().(*ast.GenDecl); ok && c.Name() == "Doc" && c.Node() == nil {
+				c.Replace(&ast.CommentGroup{List: []*ast.Comment{{Text: "// a foo is a foo"}}})
+			}
+			return true
+		},
+	},
+
+	{name: "insert names",
+		orig: `package p
+
+const a = 1
+`,
+		want: `package p
+
+const a, b, c = 1, 2, 3
+`,
+		pre: func(c *astutil.Cursor) bool {
+			if _, ok := c.Parent().(*ast.ValueSpec); ok {
+				switch c.Name() {
+				case "Names":
+					c.InsertAfter(ast.NewIdent("c"))
+					c.InsertAfter(ast.NewIdent("b"))
+				case "Values":
+					c.InsertAfter(&ast.BasicLit{Kind: token.INT, Value: "3"})
+					c.InsertAfter(&ast.BasicLit{Kind: token.INT, Value: "2"})
+				}
+			}
+			return true
+		},
+	},
+
+	{name: "insert",
+		orig: `package p
+
+var (
+	x int
+	y int
+)
+`,
+		want: `package p
+
+var before1 int
+var before2 int
+
+var (
+	x int
+	y int
+)
+var after2 int
+var after1 int
+`,
+		pre: func(c *astutil.Cursor) bool {
+			if _, ok := c.Node().(*ast.GenDecl); ok {
+				c.InsertBefore(vardecl("before1", "int"))
+				c.InsertAfter(vardecl("after1", "int"))
+				c.InsertAfter(vardecl("after2", "int"))
+				c.InsertBefore(vardecl("before2", "int"))
+			}
+			return true
+		},
+	},
+
+	{name: "delete",
+		orig: `package p
+
+var x int
+var y int
+var z int
+`,
+		want: `package p
+
+var y int
+var z int
+`,
+		pre: func(c *astutil.Cursor) bool {
+			n := c.Node()
+			if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
+				c.Delete()
+			}
+			return true
+		},
+	},
+
+	{name: "insertafter-delete",
+		orig: `package p
+
+var x int
+var y int
+var z int
+`,
+		want: `package p
+
+var x1 int
+
+var y int
+var z int
+`,
+		pre: func(c *astutil.Cursor) bool {
+			n := c.Node()
+			if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
+				c.InsertAfter(vardecl("x1", "int"))
+				c.Delete()
+			}
+			return true
+		},
+	},
+
+	{name: "delete-insertafter",
+		orig: `package p
+
+var x int
+var y int
+var z int
+`,
+		want: `package p
+
+var y int
+var x1 int
+var z int
+`,
+		pre: func(c *astutil.Cursor) bool {
+			n := c.Node()
+			if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
+				c.Delete()
+				// The cursor is now effectively atop the 'var y int' node.
+				c.InsertAfter(vardecl("x1", "int"))
+			}
+			return true
+		},
+	},
+}
+
+func valspec(name, typ string) *ast.ValueSpec {
+	return &ast.ValueSpec{Names: []*ast.Ident{ast.NewIdent(name)},
+		Type: ast.NewIdent(typ),
+	}
+}
+
+func vardecl(name, typ string) *ast.GenDecl {
+	return &ast.GenDecl{
+		Tok:   token.VAR,
+		Specs: []ast.Spec{valspec(name, typ)},
+	}
+}
+
+func TestRewrite(t *testing.T) {
+	t.Run("*", func(t *testing.T) {
+		for _, test := range rewriteTests {
+			test := test
+			t.Run(test.name, func(t *testing.T) {
+				t.Parallel()
+				fset := token.NewFileSet()
+				f, err := parser.ParseFile(fset, test.name, test.orig, parser.ParseComments)
+				if err != nil {
+					t.Fatal(err)
+				}
+				n := astutil.Apply(f, test.pre, test.post)
+				var buf bytes.Buffer
+				if err := format.Node(&buf, fset, n); err != nil {
+					t.Fatal(err)
+				}
+				got := buf.String()
+				if got != test.want {
+					t.Errorf("got:\n\n%s\nwant:\n\n%s\n", got, test.want)
+				}
+			})
+		}
+	})
+}
+
+var sink ast.Node
+
+func BenchmarkRewrite(b *testing.B) {
+	for _, test := range rewriteTests {
+		b.Run(test.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				b.StopTimer()
+				fset := token.NewFileSet()
+				f, err := parser.ParseFile(fset, test.name, test.orig, parser.ParseComments)
+				if err != nil {
+					b.Fatal(err)
+				}
+				b.StartTimer()
+				sink = astutil.Apply(f, test.pre, test.post)
+			}
+		})
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/buildutil/allpackages.go b/vendor/golang.org/x/tools/go/buildutil/allpackages.go
index 0f909ee..c0cb03e 100644
--- a/vendor/golang.org/x/tools/go/buildutil/allpackages.go
+++ b/vendor/golang.org/x/tools/go/buildutil/allpackages.go
@@ -18,9 +18,10 @@ import (
 	"sync"
 )
 
-// AllPackages returns the import path of each Go package in any source
+// 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).
@@ -37,9 +38,10 @@ func AllPackages(ctxt *build.Context) []string {
 	return list
 }
 
-// ForEachPackage calls the found function with the import path of
+// 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.
@@ -48,10 +50,6 @@ func AllPackages(ctxt *build.Context) []string {
 // which must be concurrency-safe.
 //
 func ForEachPackage(ctxt *build.Context, found func(importPath string, err error)) {
-	// We use a counting semaphore to limit
-	// the number of parallel calls to ReadDir.
-	sema := make(chan bool, 20)
-
 	ch := make(chan item)
 
 	var wg sync.WaitGroup
@@ -59,7 +57,7 @@ func ForEachPackage(ctxt *build.Context, found func(importPath string, err error
 		root := root
 		wg.Add(1)
 		go func() {
-			allPackages(ctxt, sema, root, ch)
+			allPackages(ctxt, root, ch)
 			wg.Done()
 		}()
 	}
@@ -79,7 +77,11 @@ type item struct {
 	err        error // (optional)
 }
 
-func allPackages(ctxt *build.Context, sema chan bool, root string, ch chan<- item) {
+// 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
@@ -100,9 +102,9 @@ func allPackages(ctxt *build.Context, sema chan bool, root string, ch chan<- ite
 			return
 		}
 
-		sema <- true
+		ioLimit <- true
 		files, err := ReadDir(ctxt, dir)
-		<-sema
+		<-ioLimit
 		if pkg != "" || err != nil {
 			ch <- item{pkg, err}
 		}
@@ -121,3 +123,76 @@ func allPackages(ctxt *build.Context, sema chan bool, root string, ch chan<- ite
 	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/vendor/golang.org/x/tools/go/buildutil/allpackages_test.go b/vendor/golang.org/x/tools/go/buildutil/allpackages_test.go
new file mode 100644
index 0000000..0440ff2
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/buildutil/allpackages_test.go
@@ -0,0 +1,78 @@
+// 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.
+
+// Incomplete source tree on Android.
+
+// +build !android
+
+package buildutil_test
+
+import (
+	"go/build"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestAllPackages(t *testing.T) {
+	all := buildutil.AllPackages(&build.Default)
+
+	set := make(map[string]bool)
+	for _, pkg := range all {
+		set[pkg] = true
+	}
+
+	const wantAtLeast = 250
+	if len(all) < wantAtLeast {
+		t.Errorf("Found only %d packages, want at least %d", len(all), wantAtLeast)
+	}
+
+	for _, want := range []string{"fmt", "crypto/sha256", "golang.org/x/tools/go/buildutil"} {
+		if !set[want] {
+			t.Errorf("Package %q not found; got %s", want, all)
+		}
+	}
+}
+
+func TestExpandPatterns(t *testing.T) {
+	tree := make(map[string]map[string]string)
+	for _, pkg := range []string{
+		"encoding",
+		"encoding/xml",
+		"encoding/hex",
+		"encoding/json",
+		"fmt",
+	} {
+		tree[pkg] = make(map[string]string)
+	}
+	ctxt := buildutil.FakeContext(tree)
+
+	for _, test := range []struct {
+		patterns string
+		want     string
+	}{
+		{"", ""},
+		{"fmt", "fmt"},
+		{"nosuchpkg", "nosuchpkg"},
+		{"nosuchdir/...", ""},
+		{"...", "encoding encoding/hex encoding/json encoding/xml fmt"},
+		{"encoding/... -encoding/xml", "encoding encoding/hex encoding/json"},
+		{"... -encoding/...", "fmt"},
+		{"encoding", "encoding"},
+		{"encoding/", "encoding"},
+	} {
+		var pkgs []string
+		for pkg := range buildutil.ExpandPatterns(ctxt, strings.Fields(test.patterns)) {
+			pkgs = append(pkgs, pkg)
+		}
+		sort.Strings(pkgs)
+		got := strings.Join(pkgs, " ")
+		if got != test.want {
+			t.Errorf("ExpandPatterns(%s) = %s, want %s",
+				test.patterns, got, test.want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/buildutil/overlay.go b/vendor/golang.org/x/tools/go/buildutil/overlay.go
new file mode 100644
index 0000000..3f71c4f
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/buildutil/overlay_test.go b/vendor/golang.org/x/tools/go/buildutil/overlay_test.go
new file mode 100644
index 0000000..92e2258
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/buildutil/overlay_test.go
@@ -0,0 +1,70 @@
+package buildutil_test
+
+import (
+	"go/build"
+	"io/ioutil"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestParseOverlayArchive(t *testing.T) {
+	var tt = []struct {
+		in     string
+		out    map[string][]byte
+		hasErr bool
+	}{
+		{
+			"a.go\n5\n12345",
+			map[string][]byte{"a.go": []byte("12345")},
+			false,
+		},
+		{
+			"a.go\n5\n1234",
+			nil,
+			true,
+		},
+		{
+			"a.go\n5\n12345b.go\n4\n1234",
+			map[string][]byte{"a.go": []byte("12345"), "b.go": []byte("1234")},
+			false,
+		},
+	}
+
+	for _, test := range tt {
+		got, err := buildutil.ParseOverlayArchive(strings.NewReader(test.in))
+		if err == nil && test.hasErr {
+			t.Errorf("expected error for %q", test.in)
+		}
+		if err != nil && !test.hasErr {
+			t.Errorf("unexpected error %v for %q", err, test.in)
+		}
+		if !reflect.DeepEqual(got, test.out) {
+			t.Errorf("got %#v, want %#v", got, test.out)
+		}
+	}
+}
+
+func TestOverlay(t *testing.T) {
+	ctx := &build.Default
+	ov := map[string][]byte{
+		"/somewhere/a.go": []byte("file contents"),
+	}
+	names := []string{"/somewhere/a.go", "/somewhere//a.go"}
+	ctx = buildutil.OverlayContext(ctx, ov)
+	for _, name := range names {
+		f, err := buildutil.OpenFile(ctx, name)
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		b, err := ioutil.ReadAll(f)
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		if got, expected := string(b), string(ov["/somewhere/a.go"]); got != expected {
+			t.Errorf("read %q, expected %q", got, expected)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/buildutil/tags.go b/vendor/golang.org/x/tools/go/buildutil/tags.go
index 9735094..486606f 100644
--- a/vendor/golang.org/x/tools/go/buildutil/tags.go
+++ b/vendor/golang.org/x/tools/go/buildutil/tags.go
@@ -8,7 +8,7 @@ const TagsFlagDoc = "a list of `build tags` to consider satisfied during the bui
 	"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 interface that parses
+// 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.
 //
@@ -16,7 +16,7 @@ const TagsFlagDoc = "a list of `build tags` to consider satisfied during the bui
 // See $GOROOT/src/cmd/go/doc.go for description of 'go build -tags' flag.
 //
 // Example:
-//	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsDoc)
+// 	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
 type TagsFlag []string
 
 func (v *TagsFlag) Set(s string) error {
@@ -28,6 +28,8 @@ func (v *TagsFlag) Set(s string) error {
 	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.
diff --git a/vendor/golang.org/x/tools/go/buildutil/tags_test.go b/vendor/golang.org/x/tools/go/buildutil/tags_test.go
new file mode 100644
index 0000000..0fc2618
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/buildutil/tags_test.go
@@ -0,0 +1,28 @@
+package buildutil_test
+
+import (
+	"flag"
+	"go/build"
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestTags(t *testing.T) {
+	f := flag.NewFlagSet("TestTags", flag.PanicOnError)
+	var ctxt build.Context
+	f.Var((*buildutil.TagsFlag)(&ctxt.BuildTags), "tags", buildutil.TagsFlagDoc)
+	f.Parse([]string{"-tags", ` 'one'"two"	'three "four"'`, "rest"})
+
+	// BuildTags
+	want := []string{"one", "two", "three \"four\""}
+	if !reflect.DeepEqual(ctxt.BuildTags, want) {
+		t.Errorf("BuildTags = %q, want %q", ctxt.BuildTags, want)
+	}
+
+	// Args()
+	if want := []string{"rest"}; !reflect.DeepEqual(f.Args(), want) {
+		t.Errorf("f.Args() = %q, want %q", f.Args(), want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/buildutil/util.go b/vendor/golang.org/x/tools/go/buildutil/util.go
index 60eeae2..fc923d7 100644
--- a/vendor/golang.org/x/tools/go/buildutil/util.go
+++ b/vendor/golang.org/x/tools/go/buildutil/util.go
@@ -52,8 +52,6 @@ func ParseFile(fset *token.FileSet, ctxt *build.Context, displayPath func(string
 // The '...Files []string' fields of the resulting build.Package are not
 // populated (build.FindOnly mode).
 //
-// TODO(adonovan): call this from oracle when the tree thaws.
-//
 func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Package, error) {
 	if !IsAbsPath(ctxt, filename) {
 		filename = JoinPath(ctxt, dir, filename)
@@ -72,8 +70,7 @@ func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Packag
 	// We assume that no source root (GOPATH[i] or GOROOT) contains any other.
 	for _, srcdir := range ctxt.SrcDirs() {
 		srcdirSlash := filepath.ToSlash(srcdir) + "/"
-		if strings.HasPrefix(dirSlash, srcdirSlash) {
-			importPath := dirSlash[len(srcdirSlash) : len(dirSlash)-len("/")]
+		if importPath, ok := HasSubdir(ctxt, srcdirSlash, dirSlash); ok {
 			return ctxt.Import(importPath, dir, build.FindOnly)
 		}
 	}
@@ -85,7 +82,47 @@ func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Packag
 
 // (go/build.Context defines these as methods, but does not export them.)
 
-// TODO(adonovan): HasSubdir?
+// 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.
@@ -156,3 +193,20 @@ func SplitPathList(ctxt *build.Context, s string) []string {
 	}
 	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/vendor/golang.org/x/tools/go/buildutil/util_test.go b/vendor/golang.org/x/tools/go/buildutil/util_test.go
new file mode 100644
index 0000000..f7c26dd
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/buildutil/util_test.go
@@ -0,0 +1,81 @@
+// 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_test
+
+import (
+	"go/build"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestContainingPackage(t *testing.T) {
+	// unvirtualized:
+	goroot := runtime.GOROOT()
+	gopath := gopathContainingTools(t)
+
+	type Test struct {
+		gopath, filename, wantPkg string
+	}
+
+	tests := []Test{
+		{gopath, goroot + "/src/fmt/print.go", "fmt"},
+		{gopath, goroot + "/src/encoding/json/foo.go", "encoding/json"},
+		{gopath, goroot + "/src/encoding/missing/foo.go", "(not found)"},
+		{gopath, gopath + "/src/golang.org/x/tools/go/buildutil/util_test.go",
+			"golang.org/x/tools/go/buildutil"},
+	}
+
+	if runtime.GOOS != "windows" && runtime.GOOS != "plan9" {
+		// Make a symlink to gopath for test
+		tmp, err := ioutil.TempDir(os.TempDir(), "go")
+		if err != nil {
+			t.Errorf("Unable to create a temporary directory in %s", os.TempDir())
+		}
+
+		defer os.RemoveAll(tmp)
+
+		// symlink between $GOPATH/src and /tmp/go/src
+		// in order to test all possible symlink cases
+		if err := os.Symlink(gopath+"/src", tmp+"/src"); err != nil {
+			t.Fatal(err)
+		}
+		tests = append(tests, []Test{
+			{gopath, tmp + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+			{tmp, gopath + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+			{tmp, tmp + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+		}...)
+	}
+
+	for _, test := range tests {
+		var got string
+		var buildContext = build.Default
+		buildContext.GOPATH = test.gopath
+		bp, err := buildutil.ContainingPackage(&buildContext, ".", test.filename)
+		if err != nil {
+			got = "(not found)"
+		} else {
+			got = bp.ImportPath
+		}
+		if got != test.wantPkg {
+			t.Errorf("ContainingPackage(%q) = %s, want %s", test.filename, got, test.wantPkg)
+		}
+	}
+
+	// TODO(adonovan): test on virtualized GOPATH too.
+}
+
+// gopathContainingTools returns the path of the GOPATH workspace
+// with golang.org/x/tools, or fails the test if it can't locate it.
+func gopathContainingTools(t *testing.T) string {
+	p, err := build.Import("golang.org/x/tools", "", build.FindOnly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return p.Root
+}
diff --git a/vendor/golang.org/x/tools/go/buildutil/util_windows_test.go b/vendor/golang.org/x/tools/go/buildutil/util_windows_test.go
new file mode 100644
index 0000000..86fe9c7
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/buildutil/util_windows_test.go
@@ -0,0 +1,48 @@
+// 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 buildutil_test
+
+import (
+	"fmt"
+	"go/build"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func testContainingPackageCaseFold(file, want string) error {
+	bp, err := buildutil.ContainingPackage(&build.Default, ".", file)
+	if err != nil {
+		return err
+	}
+	if got := bp.ImportPath; got != want {
+		return fmt.Errorf("ContainingPackage(%q) = %s, want %s", file, got, want)
+	}
+	return nil
+}
+
+func TestContainingPackageCaseFold(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), `src\fmt\print.go`)
+	err := testContainingPackageCaseFold(path, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+	vol := filepath.VolumeName(path)
+	if len(vol) != 2 || vol[1] != ':' {
+		t.Fatalf("GOROOT path has unexpected volume name: %v", vol)
+	}
+	rest := path[len(vol):]
+	err = testContainingPackageCaseFold(strings.ToUpper(vol)+rest, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+	err = testContainingPackageCaseFold(strings.ToLower(vol)+rest, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/cha.go b/vendor/golang.org/x/tools/go/callgraph/cha/cha.go
new file mode 100644
index 0000000..215ff17
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/cha.go
@@ -0,0 +1,139 @@
+// 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 cha computes the call graph of a Go program using the Class
+// Hierarchy Analysis (CHA) algorithm.
+//
+// CHA was first described in "Optimization of Object-Oriented Programs
+// Using Static Class Hierarchy Analysis", Jeffrey Dean, David Grove,
+// and Craig Chambers, ECOOP'95.
+//
+// CHA is related to RTA (see go/callgraph/rta); the difference is that
+// CHA conservatively computes the entire "implements" relation between
+// interfaces and concrete types ahead of time, whereas RTA uses dynamic
+// programming to construct it on the fly as it encounters new functions
+// reachable from main.  CHA may thus include spurious call edges for
+// types that haven't been instantiated yet, or types that are never
+// instantiated.
+//
+// Since CHA conservatively assumes that all functions are address-taken
+// and all concrete types are put into interfaces, it is sound to run on
+// partial programs, such as libraries without a main or test function.
+//
+package cha // import "golang.org/x/tools/go/callgraph/cha"
+
+import (
+	"go/types"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// CallGraph computes the call graph of the specified program using the
+// Class Hierarchy Analysis algorithm.
+//
+func CallGraph(prog *ssa.Program) *callgraph.Graph {
+	cg := callgraph.New(nil) // TODO(adonovan) eliminate concept of rooted callgraph
+
+	allFuncs := ssautil.AllFunctions(prog)
+
+	// funcsBySig contains all functions, keyed by signature.  It is
+	// the effective set of address-taken functions used to resolve
+	// a dynamic call of a particular signature.
+	var funcsBySig typeutil.Map // value is []*ssa.Function
+
+	// methodsByName contains all methods,
+	// grouped by name for efficient lookup.
+	// (methodsById would be better but not every SSA method has a go/types ID.)
+	methodsByName := make(map[string][]*ssa.Function)
+
+	// An imethod represents an interface method I.m.
+	// (There's no go/types object for it;
+	// a *types.Func may be shared by many interfaces due to interface embedding.)
+	type imethod struct {
+		I  *types.Interface
+		id string
+	}
+	// methodsMemo records, for every abstract method call I.m on
+	// interface type I, the set of concrete methods C.m of all
+	// types C that satisfy interface I.
+	//
+	// Abstract methods may be shared by several interfaces,
+	// hence we must pass I explicitly, not guess from m.
+	//
+	// methodsMemo is just a cache, so it needn't be a typeutil.Map.
+	methodsMemo := make(map[imethod][]*ssa.Function)
+	lookupMethods := func(I *types.Interface, m *types.Func) []*ssa.Function {
+		id := m.Id()
+		methods, ok := methodsMemo[imethod{I, id}]
+		if !ok {
+			for _, f := range methodsByName[m.Name()] {
+				C := f.Signature.Recv().Type() // named or *named
+				if types.Implements(C, I) {
+					methods = append(methods, f)
+				}
+			}
+			methodsMemo[imethod{I, id}] = methods
+		}
+		return methods
+	}
+
+	for f := range allFuncs {
+		if f.Signature.Recv() == nil {
+			// Package initializers can never be address-taken.
+			if f.Name() == "init" && f.Synthetic == "package initializer" {
+				continue
+			}
+			funcs, _ := funcsBySig.At(f.Signature).([]*ssa.Function)
+			funcs = append(funcs, f)
+			funcsBySig.Set(f.Signature, funcs)
+		} else {
+			methodsByName[f.Name()] = append(methodsByName[f.Name()], f)
+		}
+	}
+
+	addEdge := func(fnode *callgraph.Node, site ssa.CallInstruction, g *ssa.Function) {
+		gnode := cg.CreateNode(g)
+		callgraph.AddEdge(fnode, site, gnode)
+	}
+
+	addEdges := func(fnode *callgraph.Node, site ssa.CallInstruction, callees []*ssa.Function) {
+		// Because every call to a highly polymorphic and
+		// frequently used abstract method such as
+		// (io.Writer).Write is assumed to call every concrete
+		// Write method in the program, the call graph can
+		// contain a lot of duplication.
+		//
+		// TODO(adonovan): opt: consider factoring the callgraph
+		// API so that the Callers component of each edge is a
+		// slice of nodes, not a singleton.
+		for _, g := range callees {
+			addEdge(fnode, site, g)
+		}
+	}
+
+	for f := range allFuncs {
+		fnode := cg.CreateNode(f)
+		for _, b := range f.Blocks {
+			for _, instr := range b.Instrs {
+				if site, ok := instr.(ssa.CallInstruction); ok {
+					call := site.Common()
+					if call.IsInvoke() {
+						tiface := call.Value.Type().Underlying().(*types.Interface)
+						addEdges(fnode, site, lookupMethods(tiface, call.Method))
+					} else if g := call.StaticCallee(); g != nil {
+						addEdge(fnode, site, g)
+					} else if _, ok := call.Value.(*ssa.Builtin); !ok {
+						callees, _ := funcsBySig.At(call.Signature()).([]*ssa.Function)
+						addEdges(fnode, site, callees)
+					}
+				}
+			}
+		}
+	}
+
+	return cg
+}
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/cha_test.go b/vendor/golang.org/x/tools/go/callgraph/cha/cha_test.go
new file mode 100644
index 0000000..cb2d585
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/cha_test.go
@@ -0,0 +1,111 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package cha_test
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/cha"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+var inputs = []string{
+	"testdata/func.go",
+	"testdata/iface.go",
+	"testdata/recv.go",
+	"testdata/issue23925.go",
+}
+
+func expectation(f *ast.File) (string, token.Pos) {
+	for _, c := range f.Comments {
+		text := strings.TrimSpace(c.Text())
+		if t := strings.TrimPrefix(text, "WANT:\n"); t != text {
+			return t, c.Pos()
+		}
+	}
+	return "", token.NoPos
+}
+
+// TestCHA runs CHA on each file in inputs, prints the dynamic edges of
+// the call graph, and compares it with the golden results embedded in
+// the WANT comment at the end of the file.
+//
+func TestCHA(t *testing.T) {
+	for _, filename := range inputs {
+		content, err := ioutil.ReadFile(filename)
+		if err != nil {
+			t.Errorf("couldn't read file '%s': %s", filename, err)
+			continue
+		}
+
+		conf := loader.Config{
+			ParserMode: parser.ParseComments,
+		}
+		f, err := conf.ParseFile(filename, content)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		want, pos := expectation(f)
+		if pos == token.NoPos {
+			t.Errorf("No WANT: comment in %s", filename)
+			continue
+		}
+
+		conf.CreateFromFiles("main", f)
+		iprog, err := conf.Load()
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		prog := ssautil.CreateProgram(iprog, 0)
+		mainPkg := prog.Package(iprog.Created[0].Pkg)
+		prog.Build()
+
+		cg := cha.CallGraph(prog)
+
+		if got := printGraph(cg, mainPkg.Pkg); got != want {
+			t.Errorf("%s: got:\n%s\nwant:\n%s",
+				prog.Fset.Position(pos), got, want)
+		}
+	}
+}
+
+func printGraph(cg *callgraph.Graph, from *types.Package) string {
+	var edges []string
+	callgraph.GraphVisitEdges(cg, func(e *callgraph.Edge) error {
+		if strings.Contains(e.Description(), "dynamic") {
+			edges = append(edges, fmt.Sprintf("%s --> %s",
+				e.Caller.Func.RelString(from),
+				e.Callee.Func.RelString(from)))
+		}
+		return nil
+	})
+	sort.Strings(edges)
+
+	var buf bytes.Buffer
+	buf.WriteString("Dynamic calls\n")
+	for _, edge := range edges {
+		fmt.Fprintf(&buf, "  %s\n", edge)
+	}
+	return strings.TrimSpace(buf.String())
+}
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/testdata/func.go b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/func.go
new file mode 100644
index 0000000..ad483f1
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/func.go
@@ -0,0 +1,23 @@
+//+build ignore
+
+package main
+
+// Test of dynamic function calls; no interfaces.
+
+func A(int) {}
+
+var (
+	B = func(int) {}
+	C = func(int) {}
+)
+
+func f() {
+	pfn := B
+	pfn(0) // calls A, B, C, even though A is not even address-taken
+}
+
+// WANT:
+// Dynamic calls
+//   f --> A
+//   f --> init$1
+//   f --> init$2
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/testdata/iface.go b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/iface.go
new file mode 100644
index 0000000..1622ec1
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/iface.go
@@ -0,0 +1,65 @@
+//+build ignore
+
+package main
+
+// Test of interface calls.  None of the concrete types are ever
+// instantiated or converted to interfaces.
+
+type I interface {
+	f()
+}
+
+type J interface {
+	f()
+	g()
+}
+
+type C int // implements I
+
+func (*C) f()
+
+type D int // implements I and J
+
+func (*D) f()
+func (*D) g()
+
+func one(i I, j J) {
+	i.f() // calls *C and *D
+}
+
+func two(i I, j J) {
+	j.f() // calls *D (but not *C, even though it defines method f)
+}
+
+func three(i I, j J) {
+	j.g() // calls *D
+}
+
+func four(i I, j J) {
+	Jf := J.f
+	if unknown {
+		Jf = nil // suppress SSA constant propagation
+	}
+	Jf(nil) // calls *D
+}
+
+func five(i I, j J) {
+	jf := j.f
+	if unknown {
+		jf = nil // suppress SSA constant propagation
+	}
+	jf() // calls *D
+}
+
+var unknown bool
+
+// WANT:
+// Dynamic calls
+//   (J).f$bound --> (*D).f
+//   (J).f$thunk --> (*D).f
+//   five --> (J).f$bound
+//   four --> (J).f$thunk
+//   one --> (*C).f
+//   one --> (*D).f
+//   three --> (*D).g
+//   two --> (*D).f
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/testdata/issue23925.go b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/issue23925.go
new file mode 100644
index 0000000..59eaf18
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/issue23925.go
@@ -0,0 +1,38 @@
+package main
+
+// Regression test for https://github.com/golang/go/issues/23925
+
+type stringFlagImpl string
+
+func (*stringFlagImpl) Set(s string) error { return nil }
+
+type boolFlagImpl bool
+
+func (*boolFlagImpl) Set(s string) error { return nil }
+func (*boolFlagImpl) extra()             {}
+
+// A copy of flag.boolFlag interface, without a dependency.
+// Must appear first, so that it becomes the owner of the Set methods.
+type boolFlag interface {
+	flagValue
+	extra()
+}
+
+// A copy of flag.Value, without adding a dependency.
+type flagValue interface {
+	Set(string) error
+}
+
+func main() {
+	var x flagValue = new(stringFlagImpl)
+	x.Set("")
+
+	var y boolFlag = new(boolFlagImpl)
+	y.Set("")
+}
+
+// WANT:
+// Dynamic calls
+//   main --> (*boolFlagImpl).Set
+//   main --> (*boolFlagImpl).Set
+//   main --> (*stringFlagImpl).Set
diff --git a/vendor/golang.org/x/tools/go/callgraph/cha/testdata/recv.go b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/recv.go
new file mode 100644
index 0000000..5ba48e9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/cha/testdata/recv.go
@@ -0,0 +1,37 @@
+//+build ignore
+
+package main
+
+type I interface {
+	f()
+}
+
+type J interface {
+	g()
+}
+
+type C int // C and *C implement I; *C implements J
+
+func (C) f()
+func (*C) g()
+
+type D int // *D implements I and J
+
+func (*D) f()
+func (*D) g()
+
+func f(i I) {
+	i.f() // calls C, *C, *D
+}
+
+func g(j J) {
+	j.g() // calls *C, *D
+}
+
+// WANT:
+// Dynamic calls
+//   f --> (*C).f
+//   f --> (*D).f
+//   f --> (C).f
+//   g --> (*C).g
+//   g --> (*D).g
diff --git a/vendor/golang.org/x/tools/go/callgraph/rta/rta.go b/vendor/golang.org/x/tools/go/callgraph/rta/rta.go
new file mode 100644
index 0000000..1a2dadf
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/rta/rta.go
@@ -0,0 +1,459 @@
+// 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.
+
+// This package provides Rapid Type Analysis (RTA) for Go, a fast
+// algorithm for call graph construction and discovery of reachable code
+// (and hence dead code) and runtime types.  The algorithm was first
+// described in:
+//
+// David F. Bacon and Peter F. Sweeney. 1996.
+// Fast static analysis of C++ virtual function calls. (OOPSLA '96)
+// http://doi.acm.org/10.1145/236337.236371
+//
+// The algorithm uses dynamic programming to tabulate the cross-product
+// of the set of known "address taken" functions with the set of known
+// dynamic calls of the same type.  As each new address-taken function
+// is discovered, call graph edges are added from each known callsite,
+// and as each new call site is discovered, call graph edges are added
+// from it to each known address-taken function.
+//
+// A similar approach is used for dynamic calls via interfaces: it
+// tabulates the cross-product of the set of known "runtime types",
+// i.e. types that may appear in an interface value, or be derived from
+// one via reflection, with the set of known "invoke"-mode dynamic
+// calls.  As each new "runtime type" is discovered, call edges are
+// added from the known call sites, and as each new call site is
+// discovered, call graph edges are added to each compatible
+// method.
+//
+// In addition, we must consider all exported methods of any runtime type
+// as reachable, since they may be called via reflection.
+//
+// Each time a newly added call edge causes a new function to become
+// reachable, the code of that function is analyzed for more call sites,
+// address-taken functions, and runtime types.  The process continues
+// until a fixed point is achieved.
+//
+// The resulting call graph is less precise than one produced by pointer
+// analysis, but the algorithm is much faster.  For example, running the
+// cmd/callgraph tool on its own source takes ~2.1s for RTA and ~5.4s
+// for points-to analysis.
+//
+package rta // import "golang.org/x/tools/go/callgraph/rta"
+
+// TODO(adonovan): test it by connecting it to the interpreter and
+// replacing all "unreachable" functions by a special intrinsic, and
+// ensure that that intrinsic is never called.
+
+import (
+	"fmt"
+	"go/types"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// A Result holds the results of Rapid Type Analysis, which includes the
+// set of reachable functions/methods, runtime types, and the call graph.
+//
+type Result struct {
+	// CallGraph is the discovered callgraph.
+	// It does not include edges for calls made via reflection.
+	CallGraph *callgraph.Graph
+
+	// Reachable contains the set of reachable functions and methods.
+	// This includes exported methods of runtime types, since
+	// they may be accessed via reflection.
+	// The value indicates whether the function is address-taken.
+	//
+	// (We wrap the bool in a struct to avoid inadvertent use of
+	// "if Reachable[f] {" to test for set membership.)
+	Reachable map[*ssa.Function]struct{ AddrTaken bool }
+
+	// RuntimeTypes contains the set of types that are needed at
+	// runtime, for interfaces or reflection.
+	//
+	// The value indicates whether the type is inaccessible to reflection.
+	// Consider:
+	// 	type A struct{B}
+	// 	fmt.Println(new(A))
+	// Types *A, A and B are accessible to reflection, but the unnamed
+	// type struct{B} is not.
+	RuntimeTypes typeutil.Map
+}
+
+// Working state of the RTA algorithm.
+type rta struct {
+	result *Result
+
+	prog *ssa.Program
+
+	worklist []*ssa.Function // list of functions to visit
+
+	// addrTakenFuncsBySig contains all address-taken *Functions, grouped by signature.
+	// Keys are *types.Signature, values are map[*ssa.Function]bool sets.
+	addrTakenFuncsBySig typeutil.Map
+
+	// dynCallSites contains all dynamic "call"-mode call sites, grouped by signature.
+	// Keys are *types.Signature, values are unordered []ssa.CallInstruction.
+	dynCallSites typeutil.Map
+
+	// invokeSites contains all "invoke"-mode call sites, grouped by interface.
+	// Keys are *types.Interface (never *types.Named),
+	// Values are unordered []ssa.CallInstruction sets.
+	invokeSites typeutil.Map
+
+	// The following two maps together define the subset of the
+	// m:n "implements" relation needed by the algorithm.
+
+	// concreteTypes maps each concrete type to the set of interfaces that it implements.
+	// Keys are types.Type, values are unordered []*types.Interface.
+	// Only concrete types used as MakeInterface operands are included.
+	concreteTypes typeutil.Map
+
+	// interfaceTypes maps each interface type to
+	// the set of concrete types that implement it.
+	// Keys are *types.Interface, values are unordered []types.Type.
+	// Only interfaces used in "invoke"-mode CallInstructions are included.
+	interfaceTypes typeutil.Map
+}
+
+// addReachable marks a function as potentially callable at run-time,
+// and ensures that it gets processed.
+func (r *rta) addReachable(f *ssa.Function, addrTaken bool) {
+	reachable := r.result.Reachable
+	n := len(reachable)
+	v := reachable[f]
+	if addrTaken {
+		v.AddrTaken = true
+	}
+	reachable[f] = v
+	if len(reachable) > n {
+		// First time seeing f.  Add it to the worklist.
+		r.worklist = append(r.worklist, f)
+	}
+}
+
+// addEdge adds the specified call graph edge, and marks it reachable.
+// addrTaken indicates whether to mark the callee as "address-taken".
+func (r *rta) addEdge(site ssa.CallInstruction, callee *ssa.Function, addrTaken bool) {
+	r.addReachable(callee, addrTaken)
+
+	if g := r.result.CallGraph; g != nil {
+		if site.Parent() == nil {
+			panic(site)
+		}
+		from := g.CreateNode(site.Parent())
+		to := g.CreateNode(callee)
+		callgraph.AddEdge(from, site, to)
+	}
+}
+
+// ---------- addrTakenFuncs × dynCallSites ----------
+
+// visitAddrTakenFunc is called each time we encounter an address-taken function f.
+func (r *rta) visitAddrTakenFunc(f *ssa.Function) {
+	// Create two-level map (Signature -> Function -> bool).
+	S := f.Signature
+	funcs, _ := r.addrTakenFuncsBySig.At(S).(map[*ssa.Function]bool)
+	if funcs == nil {
+		funcs = make(map[*ssa.Function]bool)
+		r.addrTakenFuncsBySig.Set(S, funcs)
+	}
+	if !funcs[f] {
+		// First time seeing f.
+		funcs[f] = true
+
+		// If we've seen any dyncalls of this type, mark it reachable,
+		// and add call graph edges.
+		sites, _ := r.dynCallSites.At(S).([]ssa.CallInstruction)
+		for _, site := range sites {
+			r.addEdge(site, f, true)
+		}
+	}
+}
+
+// visitDynCall is called each time we encounter a dynamic "call"-mode call.
+func (r *rta) visitDynCall(site ssa.CallInstruction) {
+	S := site.Common().Signature()
+
+	// Record the call site.
+	sites, _ := r.dynCallSites.At(S).([]ssa.CallInstruction)
+	r.dynCallSites.Set(S, append(sites, site))
+
+	// For each function of signature S that we know is address-taken,
+	// mark it reachable.  We'll add the callgraph edges later.
+	funcs, _ := r.addrTakenFuncsBySig.At(S).(map[*ssa.Function]bool)
+	for g := range funcs {
+		r.addEdge(site, g, true)
+	}
+}
+
+// ---------- concrete types × invoke sites ----------
+
+// addInvokeEdge is called for each new pair (site, C) in the matrix.
+func (r *rta) addInvokeEdge(site ssa.CallInstruction, C types.Type) {
+	// Ascertain the concrete method of C to be called.
+	imethod := site.Common().Method
+	cmethod := r.prog.MethodValue(r.prog.MethodSets.MethodSet(C).Lookup(imethod.Pkg(), imethod.Name()))
+	r.addEdge(site, cmethod, true)
+}
+
+// visitInvoke is called each time the algorithm encounters an "invoke"-mode call.
+func (r *rta) visitInvoke(site ssa.CallInstruction) {
+	I := site.Common().Value.Type().Underlying().(*types.Interface)
+
+	// Record the invoke site.
+	sites, _ := r.invokeSites.At(I).([]ssa.CallInstruction)
+	r.invokeSites.Set(I, append(sites, site))
+
+	// Add callgraph edge for each existing
+	// address-taken concrete type implementing I.
+	for _, C := range r.implementations(I) {
+		r.addInvokeEdge(site, C)
+	}
+}
+
+// ---------- main algorithm ----------
+
+// visitFunc processes function f.
+func (r *rta) visitFunc(f *ssa.Function) {
+	var space [32]*ssa.Value // preallocate space for common case
+
+	for _, b := range f.Blocks {
+		for _, instr := range b.Instrs {
+			rands := instr.Operands(space[:0])
+
+			switch instr := instr.(type) {
+			case ssa.CallInstruction:
+				call := instr.Common()
+				if call.IsInvoke() {
+					r.visitInvoke(instr)
+				} else if g := call.StaticCallee(); g != nil {
+					r.addEdge(instr, g, false)
+				} else if _, ok := call.Value.(*ssa.Builtin); !ok {
+					r.visitDynCall(instr)
+				}
+
+				// Ignore the call-position operand when
+				// looking for address-taken Functions.
+				// Hack: assume this is rands[0].
+				rands = rands[1:]
+
+			case *ssa.MakeInterface:
+				r.addRuntimeType(instr.X.Type(), false)
+			}
+
+			// Process all address-taken functions.
+			for _, op := range rands {
+				if g, ok := (*op).(*ssa.Function); ok {
+					r.visitAddrTakenFunc(g)
+				}
+			}
+		}
+	}
+}
+
+// Analyze performs Rapid Type Analysis, starting at the specified root
+// functions.  It returns nil if no roots were specified.
+//
+// If buildCallGraph is true, Result.CallGraph will contain a call
+// graph; otherwise, only the other fields (reachable functions) are
+// populated.
+//
+func Analyze(roots []*ssa.Function, buildCallGraph bool) *Result {
+	if len(roots) == 0 {
+		return nil
+	}
+
+	r := &rta{
+		result: &Result{Reachable: make(map[*ssa.Function]struct{ AddrTaken bool })},
+		prog:   roots[0].Prog,
+	}
+
+	if buildCallGraph {
+		// TODO(adonovan): change callgraph API to eliminate the
+		// notion of a distinguished root node.  Some callgraphs
+		// have many roots, or none.
+		r.result.CallGraph = callgraph.New(roots[0])
+	}
+
+	hasher := typeutil.MakeHasher()
+	r.result.RuntimeTypes.SetHasher(hasher)
+	r.addrTakenFuncsBySig.SetHasher(hasher)
+	r.dynCallSites.SetHasher(hasher)
+	r.invokeSites.SetHasher(hasher)
+	r.concreteTypes.SetHasher(hasher)
+	r.interfaceTypes.SetHasher(hasher)
+
+	// Visit functions, processing their instructions, and adding
+	// new functions to the worklist, until a fixed point is
+	// reached.
+	var shadow []*ssa.Function // for efficiency, we double-buffer the worklist
+	r.worklist = append(r.worklist, roots...)
+	for len(r.worklist) > 0 {
+		shadow, r.worklist = r.worklist, shadow[:0]
+		for _, f := range shadow {
+			r.visitFunc(f)
+		}
+	}
+	return r.result
+}
+
+// interfaces(C) returns all currently known interfaces implemented by C.
+func (r *rta) interfaces(C types.Type) []*types.Interface {
+	// Ascertain set of interfaces C implements
+	// and update 'implements' relation.
+	var ifaces []*types.Interface
+	r.interfaceTypes.Iterate(func(I types.Type, concs interface{}) {
+		if I := I.(*types.Interface); types.Implements(C, I) {
+			concs, _ := concs.([]types.Type)
+			r.interfaceTypes.Set(I, append(concs, C))
+			ifaces = append(ifaces, I)
+		}
+	})
+	r.concreteTypes.Set(C, ifaces)
+	return ifaces
+}
+
+// implementations(I) returns all currently known concrete types that implement I.
+func (r *rta) implementations(I *types.Interface) []types.Type {
+	var concs []types.Type
+	if v := r.interfaceTypes.At(I); v != nil {
+		concs = v.([]types.Type)
+	} else {
+		// First time seeing this interface.
+		// Update the 'implements' relation.
+		r.concreteTypes.Iterate(func(C types.Type, ifaces interface{}) {
+			if types.Implements(C, I) {
+				ifaces, _ := ifaces.([]*types.Interface)
+				r.concreteTypes.Set(C, append(ifaces, I))
+				concs = append(concs, C)
+			}
+		})
+		r.interfaceTypes.Set(I, concs)
+	}
+	return concs
+}
+
+// addRuntimeType is called for each concrete type that can be the
+// dynamic type of some interface or reflect.Value.
+// Adapted from needMethods in go/ssa/builder.go
+//
+func (r *rta) addRuntimeType(T types.Type, skip bool) {
+	if prev, ok := r.result.RuntimeTypes.At(T).(bool); ok {
+		if skip && !prev {
+			r.result.RuntimeTypes.Set(T, skip)
+		}
+		return
+	}
+	r.result.RuntimeTypes.Set(T, skip)
+
+	mset := r.prog.MethodSets.MethodSet(T)
+
+	if _, ok := T.Underlying().(*types.Interface); !ok {
+		// T is a new concrete type.
+		for i, n := 0, mset.Len(); i < n; i++ {
+			sel := mset.At(i)
+			m := sel.Obj()
+
+			if m.Exported() {
+				// Exported methods are always potentially callable via reflection.
+				r.addReachable(r.prog.MethodValue(sel), true)
+			}
+		}
+
+		// Add callgraph edge for each existing dynamic
+		// "invoke"-mode call via that interface.
+		for _, I := range r.interfaces(T) {
+			sites, _ := r.invokeSites.At(I).([]ssa.CallInstruction)
+			for _, site := range sites {
+				r.addInvokeEdge(site, T)
+			}
+		}
+	}
+
+	// Precondition: T is not a method signature (*Signature with Recv()!=nil).
+	// Recursive case: skip => don't call makeMethods(T).
+	// Each package maintains its own set of types it has visited.
+
+	var n *types.Named
+	switch T := T.(type) {
+	case *types.Named:
+		n = T
+	case *types.Pointer:
+		n, _ = T.Elem().(*types.Named)
+	}
+	if n != nil {
+		owner := n.Obj().Pkg()
+		if owner == nil {
+			return // built-in error type
+		}
+	}
+
+	// Recursion over signatures of each exported method.
+	for i := 0; i < mset.Len(); i++ {
+		if mset.At(i).Obj().Exported() {
+			sig := mset.At(i).Type().(*types.Signature)
+			r.addRuntimeType(sig.Params(), true)  // skip the Tuple itself
+			r.addRuntimeType(sig.Results(), true) // skip the Tuple itself
+		}
+	}
+
+	switch t := T.(type) {
+	case *types.Basic:
+		// nop
+
+	case *types.Interface:
+		// nop---handled by recursion over method set.
+
+	case *types.Pointer:
+		r.addRuntimeType(t.Elem(), false)
+
+	case *types.Slice:
+		r.addRuntimeType(t.Elem(), false)
+
+	case *types.Chan:
+		r.addRuntimeType(t.Elem(), false)
+
+	case *types.Map:
+		r.addRuntimeType(t.Key(), false)
+		r.addRuntimeType(t.Elem(), false)
+
+	case *types.Signature:
+		if t.Recv() != nil {
+			panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
+		}
+		r.addRuntimeType(t.Params(), true)  // skip the Tuple itself
+		r.addRuntimeType(t.Results(), true) // skip the Tuple itself
+
+	case *types.Named:
+		// A pointer-to-named type can be derived from a named
+		// type via reflection.  It may have methods too.
+		r.addRuntimeType(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.
+		r.addRuntimeType(t.Underlying(), true)
+
+	case *types.Array:
+		r.addRuntimeType(t.Elem(), false)
+
+	case *types.Struct:
+		for i, n := 0, t.NumFields(); i < n; i++ {
+			r.addRuntimeType(t.Field(i).Type(), false)
+		}
+
+	case *types.Tuple:
+		for i, n := 0, t.Len(); i < n; i++ {
+			r.addRuntimeType(t.At(i).Type(), false)
+		}
+
+	default:
+		panic(T)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/callgraph/rta/rta_test.go b/vendor/golang.org/x/tools/go/callgraph/rta/rta_test.go
new file mode 100644
index 0000000..28a00b3
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/rta/rta_test.go
@@ -0,0 +1,139 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package rta_test
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/rta"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+var inputs = []string{
+	"testdata/func.go",
+	"testdata/rtype.go",
+	"testdata/iface.go",
+}
+
+func expectation(f *ast.File) (string, token.Pos) {
+	for _, c := range f.Comments {
+		text := strings.TrimSpace(c.Text())
+		if t := strings.TrimPrefix(text, "WANT:\n"); t != text {
+			return t, c.Pos()
+		}
+	}
+	return "", token.NoPos
+}
+
+// TestRTA runs RTA on each file in inputs, prints the results, and
+// compares it with the golden results embedded in the WANT comment at
+// the end of the file.
+//
+// The results string consists of two parts: the set of dynamic call
+// edges, "f --> g", one per line, and the set of reachable functions,
+// one per line.  Each set is sorted.
+//
+func TestRTA(t *testing.T) {
+	for _, filename := range inputs {
+		content, err := ioutil.ReadFile(filename)
+		if err != nil {
+			t.Errorf("couldn't read file '%s': %s", filename, err)
+			continue
+		}
+
+		conf := loader.Config{
+			ParserMode: parser.ParseComments,
+		}
+		f, err := conf.ParseFile(filename, content)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		want, pos := expectation(f)
+		if pos == token.NoPos {
+			t.Errorf("No WANT: comment in %s", filename)
+			continue
+		}
+
+		conf.CreateFromFiles("main", f)
+		iprog, err := conf.Load()
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		prog := ssautil.CreateProgram(iprog, 0)
+		mainPkg := prog.Package(iprog.Created[0].Pkg)
+		prog.Build()
+
+		res := rta.Analyze([]*ssa.Function{
+			mainPkg.Func("main"),
+			mainPkg.Func("init"),
+		}, true)
+
+		if got := printResult(res, mainPkg.Pkg); got != want {
+			t.Errorf("%s: got:\n%s\nwant:\n%s",
+				prog.Fset.Position(pos), got, want)
+		}
+	}
+}
+
+func printResult(res *rta.Result, from *types.Package) string {
+	var buf bytes.Buffer
+
+	writeSorted := func(ss []string) {
+		sort.Strings(ss)
+		for _, s := range ss {
+			fmt.Fprintf(&buf, "  %s\n", s)
+		}
+	}
+
+	buf.WriteString("Dynamic calls\n")
+	var edges []string
+	callgraph.GraphVisitEdges(res.CallGraph, func(e *callgraph.Edge) error {
+		if strings.Contains(e.Description(), "dynamic") {
+			edges = append(edges, fmt.Sprintf("%s --> %s",
+				e.Caller.Func.RelString(from),
+				e.Callee.Func.RelString(from)))
+		}
+		return nil
+	})
+	writeSorted(edges)
+
+	buf.WriteString("Reachable functions\n")
+	var reachable []string
+	for f := range res.Reachable {
+		reachable = append(reachable, f.RelString(from))
+	}
+	writeSorted(reachable)
+
+	buf.WriteString("Reflect types\n")
+	var rtypes []string
+	res.RuntimeTypes.Iterate(func(key types.Type, value interface{}) {
+		if value == false { // accessible to reflection
+			rtypes = append(rtypes, types.TypeString(key, types.RelativeTo(from)))
+		}
+	})
+	writeSorted(rtypes)
+
+	return strings.TrimSpace(buf.String())
+}
diff --git a/vendor/golang.org/x/tools/go/callgraph/rta/testdata/func.go b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/func.go
new file mode 100644
index 0000000..968c73d
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/func.go
@@ -0,0 +1,37 @@
+//+build ignore
+
+package main
+
+// Test of dynamic function calls.
+// No interfaces, so no runtime/reflect types.
+
+func A1() {
+	A2(0)
+}
+
+func A2(int) {} // not address-taken
+
+func B() {} // unreachable
+
+var (
+	C = func(int) {}
+	D = func(int) {}
+)
+
+func main() {
+	A1()
+
+	pfn := C
+	pfn(0) // calls C and D but not A2 (same sig but not address-taken)
+}
+
+// WANT:
+// Dynamic calls
+//   main --> init$1
+//   main --> init$2
+// Reachable functions
+//   A1
+//   A2
+//   init$1
+//   init$2
+// Reflect types
diff --git a/vendor/golang.org/x/tools/go/callgraph/rta/testdata/iface.go b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/iface.go
new file mode 100644
index 0000000..c3ee570
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/iface.go
@@ -0,0 +1,79 @@
+//+build ignore
+
+package main
+
+// Test of interface calls.
+
+func use(interface{})
+
+type A byte // instantiated but not a reflect type
+
+func (A) f() {} // called directly
+func (A) F() {} // unreachable
+
+type B int // a reflect type
+
+func (*B) f() {} // reachable via interface invoke
+func (*B) F() {} // reachable: exported method of reflect type
+
+type B2 int // a reflect type, and *B2 also
+
+func (B2) f() {} // reachable via interface invoke
+func (B2) g() {} // reachable: exported method of reflect type
+
+type C string // not instantiated
+
+func (C) f() {} // unreachable
+func (C) F() {} // unreachable
+
+type D uint // instantiated only in dead code
+
+func (D) f() {} // unreachable
+func (D) F() {} // unreachable
+
+func main() {
+	A(0).f()
+
+	use(new(B))
+	use(B2(0))
+
+	var i interface {
+		f()
+	}
+	i.f() // calls (*B).f, (*B2).f and (B2.f)
+
+	live()
+}
+
+func live() {
+	var j interface {
+		f()
+		g()
+	}
+	j.f() // calls (B2).f and (*B2).f but not (*B).f (no g method).
+}
+
+func dead() {
+	use(D(0))
+}
+
+// WANT:
+// Dynamic calls
+//   live --> (*B2).f
+//   live --> (B2).f
+//   main --> (*B).f
+//   main --> (*B2).f
+//   main --> (B2).f
+// Reachable functions
+//   (*B).F
+//   (*B).f
+//   (*B2).f
+//   (A).f
+//   (B2).f
+//   live
+//   use
+// Reflect types
+//   *B
+//   *B2
+//   B
+//   B2
diff --git a/vendor/golang.org/x/tools/go/callgraph/rta/testdata/rtype.go b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/rtype.go
new file mode 100644
index 0000000..85414e5
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/rta/testdata/rtype.go
@@ -0,0 +1,35 @@
+//+build ignore
+
+package main
+
+// Test of runtime types (types for which descriptors are needed).
+
+func use(interface{})
+
+type A byte // neither A nor byte are runtime types
+
+type B struct{ x uint } // B and uint are runtime types, but not the struct
+
+func main() {
+	var x int // not a runtime type
+	print(x)
+
+	var y string // runtime type due to interface conversion
+	use(y)
+
+	use(struct{ uint64 }{}) // struct is a runtime type
+
+	use(new(B)) // *B is a runtime type
+}
+
+// WANT:
+// Dynamic calls
+// Reachable functions
+//   use
+// Reflect types
+//   *B
+//   B
+//   string
+//   struct{uint64}
+//   uint
+//   uint64
diff --git a/vendor/golang.org/x/tools/go/callgraph/static/static.go b/vendor/golang.org/x/tools/go/callgraph/static/static.go
new file mode 100644
index 0000000..709bb7b
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/callgraph/static/static_test.go b/vendor/golang.org/x/tools/go/callgraph/static/static_test.go
new file mode 100644
index 0000000..e1bfcd7
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/callgraph/static/static_test.go
@@ -0,0 +1,88 @@
+// 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 static_test
+
+import (
+	"fmt"
+	"go/parser"
+	"reflect"
+	"sort"
+	"testing"
+
+	"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/ssautil"
+)
+
+const input = `package P
+
+type C int
+func (C) f()
+
+type I interface{f()}
+
+func f() {
+	p := func() {}
+	g()
+	p() // SSA constant propagation => static
+
+	if unknown {
+		p = h
+	}
+	p() // dynamic
+
+	C(0).f()
+}
+
+func g() {
+	var i I = C(0)
+	i.f()
+}
+
+func h()
+
+var unknown bool
+`
+
+func TestStatic(t *testing.T) {
+	conf := loader.Config{ParserMode: parser.ParseComments}
+	f, err := conf.ParseFile("P.go", input)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	conf.CreateFromFiles("P", f)
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	P := iprog.Created[0].Pkg
+
+	prog := ssautil.CreateProgram(iprog, 0)
+	prog.Build()
+
+	cg := static.CallGraph(prog)
+
+	var edges []string
+	callgraph.GraphVisitEdges(cg, func(e *callgraph.Edge) error {
+		edges = append(edges, fmt.Sprintf("%s -> %s",
+			e.Caller.Func.RelString(P),
+			e.Callee.Func.RelString(P)))
+		return nil
+	})
+	sort.Strings(edges)
+
+	want := []string{
+		"(*C).f -> (C).f",
+		"f -> (C).f",
+		"f -> f$1",
+		"f -> g",
+	}
+	if !reflect.DeepEqual(edges, want) {
+		t.Errorf("Got edges %v, want %v", edges, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/exact/exact.go b/vendor/golang.org/x/tools/go/exact/exact.go
deleted file mode 100644
index 51c4906..0000000
--- a/vendor/golang.org/x/tools/go/exact/exact.go
+++ /dev/null
@@ -1,920 +0,0 @@
-// 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 exact implements Values representing untyped
-// Go constants and the corresponding operations. Values
-// and operations have unlimited precision.
-//
-// A special Unknown value may be used when a value
-// is unknown due to an error. Operations on unknown
-// values produce unknown values unless specified
-// otherwise.
-//
-package exact // import "golang.org/x/tools/go/exact"
-
-import (
-	"fmt"
-	"go/token"
-	"math/big"
-	"strconv"
-)
-
-// Kind specifies the kind of value represented by a Value.
-type Kind int
-
-// Implementation note: Kinds must be enumerated in
-// order of increasing "complexity" (used by match).
-
-const (
-	// unknown values
-	Unknown Kind = iota
-
-	// non-numeric values
-	Bool
-	String
-
-	// numeric values
-	Int
-	Float
-	Complex
-)
-
-// A Value represents a mathematically exact value of a given Kind.
-type Value interface {
-	// Kind returns the value kind; it is always the smallest
-	// kind in which the value can be represented exactly.
-	Kind() Kind
-
-	// String returns a human-readable form of the value.
-	String() string
-
-	// Prevent external implementations.
-	implementsValue()
-}
-
-// ----------------------------------------------------------------------------
-// Implementations
-
-type (
-	unknownVal struct{}
-	boolVal    bool
-	stringVal  string
-	int64Val   int64
-	intVal     struct{ val *big.Int }
-	floatVal   struct{ val *big.Rat }
-	complexVal struct{ re, im *big.Rat }
-)
-
-func (unknownVal) Kind() Kind { return Unknown }
-func (boolVal) Kind() Kind    { return Bool }
-func (stringVal) Kind() Kind  { return String }
-func (int64Val) Kind() Kind   { return Int }
-func (intVal) Kind() Kind     { return Int }
-func (floatVal) Kind() Kind   { return Float }
-func (complexVal) Kind() Kind { return Complex }
-
-func (unknownVal) String() string   { return "unknown" }
-func (x boolVal) String() string    { return fmt.Sprintf("%v", bool(x)) }
-func (x stringVal) String() string  { return strconv.Quote(string(x)) }
-func (x int64Val) String() string   { return strconv.FormatInt(int64(x), 10) }
-func (x intVal) String() string     { return x.val.String() }
-func (x floatVal) String() string   { return x.val.String() }
-func (x complexVal) String() string { return fmt.Sprintf("(%s + %si)", x.re, x.im) }
-
-func (unknownVal) implementsValue() {}
-func (boolVal) implementsValue()    {}
-func (stringVal) implementsValue()  {}
-func (int64Val) implementsValue()   {}
-func (intVal) implementsValue()     {}
-func (floatVal) implementsValue()   {}
-func (complexVal) implementsValue() {}
-
-// int64 bounds
-var (
-	minInt64 = big.NewInt(-1 << 63)
-	maxInt64 = big.NewInt(1<<63 - 1)
-)
-
-func normInt(x *big.Int) Value {
-	if minInt64.Cmp(x) <= 0 && x.Cmp(maxInt64) <= 0 {
-		return int64Val(x.Int64())
-	}
-	return intVal{x}
-}
-
-func normFloat(x *big.Rat) Value {
-	if x.IsInt() {
-		return normInt(x.Num())
-	}
-	return floatVal{x}
-}
-
-func normComplex(re, im *big.Rat) Value {
-	if im.Sign() == 0 {
-		return normFloat(re)
-	}
-	return complexVal{re, im}
-}
-
-// ----------------------------------------------------------------------------
-// Factories
-
-// MakeUnknown returns the Unknown value.
-func MakeUnknown() Value { return unknownVal{} }
-
-// MakeBool returns the Bool value for x.
-func MakeBool(b bool) Value { return boolVal(b) }
-
-// MakeString returns the String value for x.
-func MakeString(s string) Value { return stringVal(s) }
-
-// MakeInt64 returns the Int value for x.
-func MakeInt64(x int64) Value { return int64Val(x) }
-
-// MakeUint64 returns the Int value for x.
-func MakeUint64(x uint64) Value { return normInt(new(big.Int).SetUint64(x)) }
-
-// MakeFloat64 returns the numeric value for x.
-// If x is not finite, the result is unknown.
-func MakeFloat64(x float64) Value {
-	if f := new(big.Rat).SetFloat64(x); f != nil {
-		return normFloat(f)
-	}
-	return unknownVal{}
-}
-
-// MakeFromLiteral returns the corresponding integer, floating-point,
-// imaginary, character, or string value for a Go literal string. The
-// result is nil if the literal string is invalid.
-func MakeFromLiteral(lit string, tok token.Token) Value {
-	switch tok {
-	case token.INT:
-		if x, err := strconv.ParseInt(lit, 0, 64); err == nil {
-			return int64Val(x)
-		}
-		if x, ok := new(big.Int).SetString(lit, 0); ok {
-			return intVal{x}
-		}
-
-	case token.FLOAT:
-		if x, ok := new(big.Rat).SetString(lit); ok {
-			return normFloat(x)
-		}
-
-	case token.IMAG:
-		if n := len(lit); n > 0 && lit[n-1] == 'i' {
-			if im, ok := new(big.Rat).SetString(lit[0 : n-1]); ok {
-				return normComplex(big.NewRat(0, 1), im)
-			}
-		}
-
-	case token.CHAR:
-		if n := len(lit); n >= 2 {
-			if code, _, _, err := strconv.UnquoteChar(lit[1:n-1], '\''); err == nil {
-				return int64Val(code)
-			}
-		}
-
-	case token.STRING:
-		if s, err := strconv.Unquote(lit); err == nil {
-			return stringVal(s)
-		}
-	}
-
-	return nil
-}
-
-// ----------------------------------------------------------------------------
-// Accessors
-//
-// For unknown arguments the result is the zero value for the respective
-// accessor type, except for Sign, where the result is 1.
-
-// BoolVal returns the Go boolean value of x, which must be a Bool or an Unknown.
-// If x is Unknown, the result is false.
-func BoolVal(x Value) bool {
-	switch x := x.(type) {
-	case boolVal:
-		return bool(x)
-	case unknownVal:
-		return false
-	}
-	panic(fmt.Sprintf("%v not a Bool", x))
-}
-
-// StringVal returns the Go string value of x, which must be a String or an Unknown.
-// If x is Unknown, the result is "".
-func StringVal(x Value) string {
-	switch x := x.(type) {
-	case stringVal:
-		return string(x)
-	case unknownVal:
-		return ""
-	}
-	panic(fmt.Sprintf("%v not a String", x))
-}
-
-// Int64Val returns the Go int64 value of x and whether the result is exact;
-// x must be an Int or an Unknown. If the result is not exact, its value is undefined.
-// If x is Unknown, the result is (0, false).
-func Int64Val(x Value) (int64, bool) {
-	switch x := x.(type) {
-	case int64Val:
-		return int64(x), true
-	case intVal:
-		return x.val.Int64(), x.val.BitLen() <= 63
-	case unknownVal:
-		return 0, false
-	}
-	panic(fmt.Sprintf("%v not an Int", x))
-}
-
-// Uint64Val returns the Go uint64 value of x and whether the result is exact;
-// x must be an Int or an Unknown. If the result is not exact, its value is undefined.
-// If x is Unknown, the result is (0, false).
-func Uint64Val(x Value) (uint64, bool) {
-	switch x := x.(type) {
-	case int64Val:
-		return uint64(x), x >= 0
-	case intVal:
-		return x.val.Uint64(), x.val.Sign() >= 0 && x.val.BitLen() <= 64
-	case unknownVal:
-		return 0, false
-	}
-	panic(fmt.Sprintf("%v not an Int", x))
-}
-
-// Float32Val is like Float64Val but for float32 instead of float64.
-func Float32Val(x Value) (float32, bool) {
-	switch x := x.(type) {
-	case int64Val:
-		f := float32(x)
-		return f, int64Val(f) == x
-	case intVal:
-		return ratToFloat32(new(big.Rat).SetFrac(x.val, int1))
-	case floatVal:
-		return ratToFloat32(x.val)
-	case unknownVal:
-		return 0, false
-	}
-	panic(fmt.Sprintf("%v not a Float", x))
-}
-
-// Float64Val returns the nearest Go float64 value of x and whether the result is exact;
-// x must be numeric but not Complex, or Unknown. For values too small (too close to 0)
-// to represent as float64, Float64Val silently underflows to 0. The result sign always
-// matches the sign of x, even for 0.
-// If x is Unknown, the result is (0, false).
-func Float64Val(x Value) (float64, bool) {
-	switch x := x.(type) {
-	case int64Val:
-		f := float64(int64(x))
-		return f, int64Val(f) == x
-	case intVal:
-		return new(big.Rat).SetFrac(x.val, int1).Float64()
-	case floatVal:
-		return x.val.Float64()
-	case unknownVal:
-		return 0, false
-	}
-	panic(fmt.Sprintf("%v not a Float", x))
-}
-
-// BitLen returns the number of bits required to represent
-// the absolute value x in binary representation; x must be an Int or an Unknown.
-// If x is Unknown, the result is 0.
-func BitLen(x Value) int {
-	switch x := x.(type) {
-	case int64Val:
-		return new(big.Int).SetInt64(int64(x)).BitLen()
-	case intVal:
-		return x.val.BitLen()
-	case unknownVal:
-		return 0
-	}
-	panic(fmt.Sprintf("%v not an Int", x))
-}
-
-// Sign returns -1, 0, or 1 depending on whether x < 0, x == 0, or x > 0;
-// x must be numeric or Unknown. For complex values x, the sign is 0 if x == 0,
-// otherwise it is != 0. If x is Unknown, the result is 1.
-func Sign(x Value) int {
-	switch x := x.(type) {
-	case int64Val:
-		switch {
-		case x < 0:
-			return -1
-		case x > 0:
-			return 1
-		}
-		return 0
-	case intVal:
-		return x.val.Sign()
-	case floatVal:
-		return x.val.Sign()
-	case complexVal:
-		return x.re.Sign() | x.im.Sign()
-	case unknownVal:
-		return 1 // avoid spurious division by zero errors
-	}
-	panic(fmt.Sprintf("%v not numeric", x))
-}
-
-// ----------------------------------------------------------------------------
-// Support for serializing/deserializing integers
-
-const (
-	// Compute the size of a Word in bytes.
-	_m       = ^big.Word(0)
-	_log     = _m>>8&1 + _m>>16&1 + _m>>32&1
-	wordSize = 1 << _log
-)
-
-// Bytes returns the bytes for the absolute value of x in little-
-// endian binary representation; x must be an Int.
-func Bytes(x Value) []byte {
-	var val *big.Int
-	switch x := x.(type) {
-	case int64Val:
-		val = new(big.Int).SetInt64(int64(x))
-	case intVal:
-		val = x.val
-	default:
-		panic(fmt.Sprintf("%v not an Int", x))
-	}
-
-	words := val.Bits()
-	bytes := make([]byte, len(words)*wordSize)
-
-	i := 0
-	for _, w := range words {
-		for j := 0; j < wordSize; j++ {
-			bytes[i] = byte(w)
-			w >>= 8
-			i++
-		}
-	}
-	// remove leading 0's
-	for i > 0 && bytes[i-1] == 0 {
-		i--
-	}
-
-	return bytes[:i]
-}
-
-// MakeFromBytes returns the Int value given the bytes of its little-endian
-// binary representation. An empty byte slice argument represents 0.
-func MakeFromBytes(bytes []byte) Value {
-	words := make([]big.Word, (len(bytes)+(wordSize-1))/wordSize)
-
-	i := 0
-	var w big.Word
-	var s uint
-	for _, b := range bytes {
-		w |= big.Word(b) << s
-		if s += 8; s == wordSize*8 {
-			words[i] = w
-			i++
-			w = 0
-			s = 0
-		}
-	}
-	// store last word
-	if i < len(words) {
-		words[i] = w
-		i++
-	}
-	// remove leading 0's
-	for i > 0 && words[i-1] == 0 {
-		i--
-	}
-
-	return normInt(new(big.Int).SetBits(words[:i]))
-}
-
-// ----------------------------------------------------------------------------
-// Support for disassembling fractions
-
-// Num returns the numerator of x; x must be Int, Float, or Unknown.
-// If x is Unknown, the result is Unknown, otherwise it is an Int
-// with the same sign as x.
-func Num(x Value) Value {
-	switch x := x.(type) {
-	case unknownVal, int64Val, intVal:
-		return x
-	case floatVal:
-		return normInt(x.val.Num())
-	}
-	panic(fmt.Sprintf("%v not Int or Float", x))
-}
-
-// Denom returns the denominator of x; x must be Int, Float, or Unknown.
-// If x is Unknown, the result is Unknown, otherwise it is an Int >= 1.
-func Denom(x Value) Value {
-	switch x := x.(type) {
-	case unknownVal:
-		return x
-	case int64Val, intVal:
-		return int64Val(1)
-	case floatVal:
-		return normInt(x.val.Denom())
-	}
-	panic(fmt.Sprintf("%v not Int or Float", x))
-}
-
-// ----------------------------------------------------------------------------
-// Support for assembling/disassembling complex numbers
-
-// MakeImag returns the numeric value x*i (possibly 0);
-// x must be Int, Float, or Unknown.
-// If x is Unknown, the result is Unknown.
-func MakeImag(x Value) Value {
-	var im *big.Rat
-	switch x := x.(type) {
-	case unknownVal:
-		return x
-	case int64Val:
-		im = big.NewRat(int64(x), 1)
-	case intVal:
-		im = new(big.Rat).SetFrac(x.val, int1)
-	case floatVal:
-		im = x.val
-	default:
-		panic(fmt.Sprintf("%v not Int or Float", x))
-	}
-	return normComplex(rat0, im)
-}
-
-// Real returns the real part of x, which must be a numeric or unknown value.
-// If x is Unknown, the result is Unknown.
-func Real(x Value) Value {
-	switch x := x.(type) {
-	case unknownVal, int64Val, intVal, floatVal:
-		return x
-	case complexVal:
-		return normFloat(x.re)
-	}
-	panic(fmt.Sprintf("%v not numeric", x))
-}
-
-// Imag returns the imaginary part of x, which must be a numeric or unknown value.
-// If x is Unknown, the result is Unknown.
-func Imag(x Value) Value {
-	switch x := x.(type) {
-	case unknownVal:
-		return x
-	case int64Val, intVal, floatVal:
-		return int64Val(0)
-	case complexVal:
-		return normFloat(x.im)
-	}
-	panic(fmt.Sprintf("%v not numeric", x))
-}
-
-// ----------------------------------------------------------------------------
-// Operations
-
-// is32bit reports whether x can be represented using 32 bits.
-func is32bit(x int64) bool {
-	const s = 32
-	return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-}
-
-// is63bit reports whether x can be represented using 63 bits.
-func is63bit(x int64) bool {
-	const s = 63
-	return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-}
-
-// UnaryOp returns the result of the unary expression op y.
-// The operation must be defined for the operand.
-// If size >= 0 it specifies the ^ (xor) result size in bytes.
-// If y is Unknown, the result is Unknown.
-//
-func UnaryOp(op token.Token, y Value, size int) Value {
-	switch op {
-	case token.ADD:
-		switch y.(type) {
-		case unknownVal, int64Val, intVal, floatVal, complexVal:
-			return y
-		}
-
-	case token.SUB:
-		switch y := y.(type) {
-		case unknownVal:
-			return y
-		case int64Val:
-			if z := -y; z != y {
-				return z // no overflow
-			}
-			return normInt(new(big.Int).Neg(big.NewInt(int64(y))))
-		case intVal:
-			return normInt(new(big.Int).Neg(y.val))
-		case floatVal:
-			return normFloat(new(big.Rat).Neg(y.val))
-		case complexVal:
-			return normComplex(new(big.Rat).Neg(y.re), new(big.Rat).Neg(y.im))
-		}
-
-	case token.XOR:
-		var z big.Int
-		switch y := y.(type) {
-		case unknownVal:
-			return y
-		case int64Val:
-			z.Not(big.NewInt(int64(y)))
-		case intVal:
-			z.Not(y.val)
-		default:
-			goto Error
-		}
-		// For unsigned types, the result will be negative and
-		// thus "too large": We must limit the result size to
-		// the type's size.
-		if size >= 0 {
-			s := uint(size) * 8
-			z.AndNot(&z, new(big.Int).Lsh(big.NewInt(-1), s)) // z &^= (-1)<<s
-		}
-		return normInt(&z)
-
-	case token.NOT:
-		switch y := y.(type) {
-		case unknownVal:
-			return y
-		case boolVal:
-			return !y
-		}
-	}
-
-Error:
-	panic(fmt.Sprintf("invalid unary operation %s%v", op, y))
-}
-
-var (
-	int1 = big.NewInt(1)
-	rat0 = big.NewRat(0, 1)
-)
-
-func ord(x Value) int {
-	switch x.(type) {
-	default:
-		return 0
-	case boolVal, stringVal:
-		return 1
-	case int64Val:
-		return 2
-	case intVal:
-		return 3
-	case floatVal:
-		return 4
-	case complexVal:
-		return 5
-	}
-}
-
-// match returns the matching representation (same type) with the
-// smallest complexity for two values x and y. If one of them is
-// numeric, both of them must be numeric. If one of them is Unknown,
-// both results are Unknown.
-//
-func match(x, y Value) (_, _ Value) {
-	if ord(x) > ord(y) {
-		y, x = match(y, x)
-		return x, y
-	}
-	// ord(x) <= ord(y)
-
-	switch x := x.(type) {
-	case unknownVal:
-		return x, x
-
-	case boolVal, stringVal, complexVal:
-		return x, y
-
-	case int64Val:
-		switch y := y.(type) {
-		case int64Val:
-			return x, y
-		case intVal:
-			return intVal{big.NewInt(int64(x))}, y
-		case floatVal:
-			return floatVal{big.NewRat(int64(x), 1)}, y
-		case complexVal:
-			return complexVal{big.NewRat(int64(x), 1), rat0}, y
-		}
-
-	case intVal:
-		switch y := y.(type) {
-		case intVal:
-			return x, y
-		case floatVal:
-			return floatVal{new(big.Rat).SetFrac(x.val, int1)}, y
-		case complexVal:
-			return complexVal{new(big.Rat).SetFrac(x.val, int1), rat0}, y
-		}
-
-	case floatVal:
-		switch y := y.(type) {
-		case floatVal:
-			return x, y
-		case complexVal:
-			return complexVal{x.val, rat0}, y
-		}
-	}
-
-	panic("unreachable")
-}
-
-// BinaryOp returns the result of the binary expression x op y.
-// The operation must be defined for the operands. If one of the
-// operands is Unknown, the result is Unknown.
-// To force integer division of Int operands, use op == token.QUO_ASSIGN
-// instead of token.QUO; the result is guaranteed to be Int in this case.
-// Division by zero leads to a run-time panic.
-//
-func BinaryOp(x Value, op token.Token, y Value) Value {
-	x, y = match(x, y)
-
-	switch x := x.(type) {
-	case unknownVal:
-		return x
-
-	case boolVal:
-		y := y.(boolVal)
-		switch op {
-		case token.LAND:
-			return x && y
-		case token.LOR:
-			return x || y
-		}
-
-	case int64Val:
-		a := int64(x)
-		b := int64(y.(int64Val))
-		var c int64
-		switch op {
-		case token.ADD:
-			if !is63bit(a) || !is63bit(b) {
-				return normInt(new(big.Int).Add(big.NewInt(a), big.NewInt(b)))
-			}
-			c = a + b
-		case token.SUB:
-			if !is63bit(a) || !is63bit(b) {
-				return normInt(new(big.Int).Sub(big.NewInt(a), big.NewInt(b)))
-			}
-			c = a - b
-		case token.MUL:
-			if !is32bit(a) || !is32bit(b) {
-				return normInt(new(big.Int).Mul(big.NewInt(a), big.NewInt(b)))
-			}
-			c = a * b
-		case token.QUO:
-			return normFloat(new(big.Rat).SetFrac(big.NewInt(a), big.NewInt(b)))
-		case token.QUO_ASSIGN: // force integer division
-			c = a / b
-		case token.REM:
-			c = a % b
-		case token.AND:
-			c = a & b
-		case token.OR:
-			c = a | b
-		case token.XOR:
-			c = a ^ b
-		case token.AND_NOT:
-			c = a &^ b
-		default:
-			goto Error
-		}
-		return int64Val(c)
-
-	case intVal:
-		a := x.val
-		b := y.(intVal).val
-		var c big.Int
-		switch op {
-		case token.ADD:
-			c.Add(a, b)
-		case token.SUB:
-			c.Sub(a, b)
-		case token.MUL:
-			c.Mul(a, b)
-		case token.QUO:
-			return normFloat(new(big.Rat).SetFrac(a, b))
-		case token.QUO_ASSIGN: // force integer division
-			c.Quo(a, b)
-		case token.REM:
-			c.Rem(a, b)
-		case token.AND:
-			c.And(a, b)
-		case token.OR:
-			c.Or(a, b)
-		case token.XOR:
-			c.Xor(a, b)
-		case token.AND_NOT:
-			c.AndNot(a, b)
-		default:
-			goto Error
-		}
-		return normInt(&c)
-
-	case floatVal:
-		a := x.val
-		b := y.(floatVal).val
-		var c big.Rat
-		switch op {
-		case token.ADD:
-			c.Add(a, b)
-		case token.SUB:
-			c.Sub(a, b)
-		case token.MUL:
-			c.Mul(a, b)
-		case token.QUO:
-			c.Quo(a, b)
-		default:
-			goto Error
-		}
-		return normFloat(&c)
-
-	case complexVal:
-		y := y.(complexVal)
-		a, b := x.re, x.im
-		c, d := y.re, y.im
-		var re, im big.Rat
-		switch op {
-		case token.ADD:
-			// (a+c) + i(b+d)
-			re.Add(a, c)
-			im.Add(b, d)
-		case token.SUB:
-			// (a-c) + i(b-d)
-			re.Sub(a, c)
-			im.Sub(b, d)
-		case token.MUL:
-			// (ac-bd) + i(bc+ad)
-			var ac, bd, bc, ad big.Rat
-			ac.Mul(a, c)
-			bd.Mul(b, d)
-			bc.Mul(b, c)
-			ad.Mul(a, d)
-			re.Sub(&ac, &bd)
-			im.Add(&bc, &ad)
-		case token.QUO:
-			// (ac+bd)/s + i(bc-ad)/s, with s = cc + dd
-			var ac, bd, bc, ad, s, cc, dd big.Rat
-			ac.Mul(a, c)
-			bd.Mul(b, d)
-			bc.Mul(b, c)
-			ad.Mul(a, d)
-			cc.Mul(c, c)
-			dd.Mul(d, d)
-			s.Add(&cc, &dd)
-			re.Add(&ac, &bd)
-			re.Quo(&re, &s)
-			im.Sub(&bc, &ad)
-			im.Quo(&im, &s)
-		default:
-			goto Error
-		}
-		return normComplex(&re, &im)
-
-	case stringVal:
-		if op == token.ADD {
-			return x + y.(stringVal)
-		}
-	}
-
-Error:
-	panic(fmt.Sprintf("invalid binary operation %v %s %v", x, op, y))
-}
-
-// Shift returns the result of the shift expression x op s
-// with op == token.SHL or token.SHR (<< or >>). x must be
-// an Int or an Unknown. If x is Unknown, the result is x.
-//
-func Shift(x Value, op token.Token, s uint) Value {
-	switch x := x.(type) {
-	case unknownVal:
-		return x
-
-	case int64Val:
-		if s == 0 {
-			return x
-		}
-		switch op {
-		case token.SHL:
-			z := big.NewInt(int64(x))
-			return normInt(z.Lsh(z, s))
-		case token.SHR:
-			return x >> s
-		}
-
-	case intVal:
-		if s == 0 {
-			return x
-		}
-		var z big.Int
-		switch op {
-		case token.SHL:
-			return normInt(z.Lsh(x.val, s))
-		case token.SHR:
-			return normInt(z.Rsh(x.val, s))
-		}
-	}
-
-	panic(fmt.Sprintf("invalid shift %v %s %d", x, op, s))
-}
-
-func cmpZero(x int, op token.Token) bool {
-	switch op {
-	case token.EQL:
-		return x == 0
-	case token.NEQ:
-		return x != 0
-	case token.LSS:
-		return x < 0
-	case token.LEQ:
-		return x <= 0
-	case token.GTR:
-		return x > 0
-	case token.GEQ:
-		return x >= 0
-	}
-	panic("unreachable")
-}
-
-// Compare returns the result of the comparison x op y.
-// The comparison must be defined for the operands.
-// If one of the operands is Unknown, the result is
-// false.
-//
-func Compare(x Value, op token.Token, y Value) bool {
-	x, y = match(x, y)
-
-	switch x := x.(type) {
-	case unknownVal:
-		return false
-
-	case boolVal:
-		y := y.(boolVal)
-		switch op {
-		case token.EQL:
-			return x == y
-		case token.NEQ:
-			return x != y
-		}
-
-	case int64Val:
-		y := y.(int64Val)
-		switch op {
-		case token.EQL:
-			return x == y
-		case token.NEQ:
-			return x != y
-		case token.LSS:
-			return x < y
-		case token.LEQ:
-			return x <= y
-		case token.GTR:
-			return x > y
-		case token.GEQ:
-			return x >= y
-		}
-
-	case intVal:
-		return cmpZero(x.val.Cmp(y.(intVal).val), op)
-
-	case floatVal:
-		return cmpZero(x.val.Cmp(y.(floatVal).val), op)
-
-	case complexVal:
-		y := y.(complexVal)
-		re := x.re.Cmp(y.re)
-		im := x.im.Cmp(y.im)
-		switch op {
-		case token.EQL:
-			return re == 0 && im == 0
-		case token.NEQ:
-			return re != 0 || im != 0
-		}
-
-	case stringVal:
-		y := y.(stringVal)
-		switch op {
-		case token.EQL:
-			return x == y
-		case token.NEQ:
-			return x != y
-		case token.LSS:
-			return x < y
-		case token.LEQ:
-			return x <= y
-		case token.GTR:
-			return x > y
-		case token.GEQ:
-			return x >= y
-		}
-	}
-
-	panic(fmt.Sprintf("invalid comparison %v %s %v", x, op, y))
-}
diff --git a/vendor/golang.org/x/tools/go/exact/go13.go b/vendor/golang.org/x/tools/go/exact/go13.go
deleted file mode 100644
index 1016c14..0000000
--- a/vendor/golang.org/x/tools/go/exact/go13.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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.
-
-// +build !go1.4
-
-package exact
-
-import (
-	"math"
-	"math/big"
-)
-
-func ratToFloat32(x *big.Rat) (float32, bool) {
-	// Before 1.4, there's no Rat.Float32.
-	// Emulate it, albeit at the cost of
-	// imprecision in corner cases.
-	x64, exact := x.Float64()
-	x32 := float32(x64)
-	if math.IsInf(float64(x32), 0) {
-		exact = false
-	}
-	return x32, exact
-}
diff --git a/vendor/golang.org/x/tools/go/exact/go14.go b/vendor/golang.org/x/tools/go/exact/go14.go
deleted file mode 100644
index b86e5d2..0000000
--- a/vendor/golang.org/x/tools/go/exact/go14.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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.
-
-// +build go1.4
-
-package exact
-
-import "math/big"
-
-func ratToFloat32(x *big.Rat) (float32, bool) {
-	return x.Float32()
-}
diff --git a/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata.go b/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata.go
new file mode 100644
index 0000000..30ed521
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata.go
@@ -0,0 +1,129 @@
+// 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 gccgoexportdata provides functions for reading export data
+// files containing type information produced by the gccgo compiler.
+//
+// This package is a stop-gap until such time as gccgo uses the same
+// export data format as gc; see Go issue 17573. Once that occurs, this
+// package will be deprecated and eventually deleted.
+package gccgoexportdata
+
+// TODO(adonovan): add Find, Write, Importer to the API,
+// for symmetry with gcexportdata.
+
+import (
+	"bytes"
+	"debug/elf"
+	"fmt"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/internal/gccgoimporter"
+)
+
+// CompilerInfo executes the specified gccgo compiler and returns
+// information about it: its version (e.g. "4.8.0"), its target triple
+// (e.g. "x86_64-unknown-linux-gnu"), and the list of directories it
+// searches to find standard packages. The given arguments are passed
+// directly to calls to the specified gccgo compiler.
+func CompilerInfo(gccgo string, args ...string) (version, triple string, dirs []string, err error) {
+	var inst gccgoimporter.GccgoInstallation
+	err = inst.InitFromDriver(gccgo, args...)
+	if err == nil {
+		version = inst.GccVersion
+		triple = inst.TargetTriple
+		dirs = inst.SearchPaths()
+	}
+	return
+}
+
+// NewReader returns a reader for the export data section of an object
+// (.o) or archive (.a) file read from r.
+func NewReader(r io.Reader) (io.Reader, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the file is an archive, extract the first section.
+	const archiveMagic = "!<arch>\n"
+	if bytes.HasPrefix(data, []byte(archiveMagic)) {
+		section, err := firstSection(data[len(archiveMagic):])
+		if err != nil {
+			return nil, err
+		}
+		data = section
+	}
+
+	// Data contains an ELF file with a .go_export section.
+	// ELF magic number is "\x7fELF".
+	ef, err := elf.NewFile(bytes.NewReader(data))
+	if err != nil {
+		return nil, err
+	}
+	sec := ef.Section(".go_export")
+	if sec == nil {
+		return nil, fmt.Errorf("no .go_export section")
+	}
+	return sec.Open(), nil
+}
+
+// firstSection returns the contents of the first regular file in an ELF
+// archive (http://www.sco.com/developers/devspecs/gabi41.pdf, §7.2).
+func firstSection(a []byte) ([]byte, error) {
+	for len(a) >= 60 {
+		var hdr []byte
+		hdr, a = a[:60], a[60:]
+
+		name := strings.TrimSpace(string(hdr[:16]))
+
+		sizeStr := string(hdr[48:58])
+		size, err := strconv.Atoi(strings.TrimSpace(sizeStr))
+		if err != nil {
+			return nil, fmt.Errorf("invalid size: %q", sizeStr)
+		}
+
+		if len(a) < size {
+			return nil, fmt.Errorf("invalid section size: %d", size)
+		}
+
+		// The payload is padded to an even number of bytes.
+		var payload []byte
+		payload, a = a[:size], a[size+size&1:]
+
+		// Skip special files:
+		//   "/"           archive symbol table
+		//   "/SYM64/"     archive symbol table on e.g. s390x
+		//   "//"          archive string table (if any filename is >15 bytes)
+		if name == "/" || name == "/SYM64/" || name == "//" {
+			continue
+		}
+
+		return payload, nil
+	}
+	return nil, fmt.Errorf("archive has no regular sections")
+}
+
+// Read reads export data from in, decodes it, and returns type
+// information for the package.
+// The package name is specified by path.
+//
+// The FileSet parameter is currently unused but exists for symmetry
+// with gcexportdata.
+//
+// Read may inspect and add to the imports map to ensure that references
+// within the export data to other packages are consistent.  The caller
+// must ensure that imports[path] does not exist, or exists but is
+// incomplete (see types.Package.Complete), and Read inserts the
+// resulting package into this map entry.
+//
+// On return, the state of the reader is undefined.
+func Read(in io.Reader, _ *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
+	return gccgoimporter.Parse(in, imports, path)
+}
diff --git a/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata_test.go b/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata_test.go
new file mode 100644
index 0000000..1aa114c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gccgoexportdata/gccgoexportdata_test.go
@@ -0,0 +1,67 @@
+package gccgoexportdata_test
+
+import (
+	"go/types"
+	"os"
+	"testing"
+
+	"golang.org/x/tools/go/gccgoexportdata"
+)
+
+// Test ensures this package can read gccgo export data from the
+// .go_export from a standalone ELF file or such a file in an archive
+// library.
+//
+// The testdata/{short,long}.a ELF archive files were produced by:
+//
+//   $ echo 'package foo; func F()' > foo.go
+//   $ gccgo -c -fgo-pkgpath blah foo.go
+//   $ objcopy -j .go_export foo.o foo.gox
+//   $ ar q short.a foo.gox
+//   $ objcopy -j .go_export foo.o name-longer-than-16-bytes.gox
+//   $ ar q long.a name-longer-than-16-bytes.gox
+//
+// The file long.a contains an archive string table.
+//
+// The errors.gox file (an ELF object file) comes from the toolchain's
+// standard library.
+func Test(t *testing.T) {
+	for _, test := range []struct {
+		filename, path, member, wantType string
+	}{
+		{"testdata/errors.gox", "errors", "New", "func(text string) error"},
+		{"testdata/short.a", "short", "F", "func()"},
+		{"testdata/long.a", "long", "F", "func()"},
+	} {
+		t.Logf("filename = %s", test.filename)
+		f, err := os.Open(test.filename)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		defer f.Close()
+		r, err := gccgoexportdata.NewReader(f)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		imports := make(map[string]*types.Package)
+		pkg, err := gccgoexportdata.Read(r, nil, imports, test.path)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		// Check type of designated package member.
+		obj := pkg.Scope().Lookup(test.member)
+		if obj == nil {
+			t.Errorf("%s.%s not found", test.path, test.member)
+			continue
+		}
+		if obj.Type().String() != test.wantType {
+			t.Errorf("%s.%s.Type = %s, want %s",
+				test.path, test.member, obj.Type(), test.wantType)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/errors.gox b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/errors.gox
new file mode 100644
index 0000000..c6ff16b
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/errors.gox differ
diff --git a/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/long.a b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/long.a
new file mode 100644
index 0000000..c150447
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/long.a differ
diff --git a/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/short.a b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/short.a
new file mode 100644
index 0000000..3cd756e
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gccgoexportdata/testdata/short.a differ
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/example_test.go b/vendor/golang.org/x/tools/go/gcexportdata/example_test.go
new file mode 100644
index 0000000..4ad73ab
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/example_test.go
@@ -0,0 +1,121 @@
+// 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 go1.7
+
+package gcexportdata_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/tools/go/gcexportdata"
+)
+
+// ExampleRead uses gcexportdata.Read to load type information for the
+// "fmt" package from the fmt.a file produced by the gc compiler.
+func ExampleRead() {
+	// Find the export data file.
+	filename, path := gcexportdata.Find("fmt", "")
+	if filename == "" {
+		log.Fatalf("can't find export data for fmt")
+	}
+	fmt.Printf("Package path:       %s\n", path)
+	fmt.Printf("Export data:        %s\n", filepath.Base(filename))
+
+	// Open and read the file.
+	f, err := os.Open(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+	r, err := gcexportdata.NewReader(f)
+	if err != nil {
+		log.Fatalf("reading export data %s: %v", filename, err)
+	}
+
+	// Decode the export data.
+	fset := token.NewFileSet()
+	imports := make(map[string]*types.Package)
+	pkg, err := gcexportdata.Read(r, fset, imports, path)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print package information.
+	fmt.Printf("Package members:    %s...\n", pkg.Scope().Names()[:5])
+	println := pkg.Scope().Lookup("Println")
+	posn := fset.Position(println.Pos())
+	posn.Line = 123 // make example deterministic
+	fmt.Printf("Println type:       %s\n", println.Type())
+	fmt.Printf("Println location:   %s\n", slashify(posn))
+
+	// Output:
+	//
+	// Package path:       fmt
+	// Export data:        fmt.a
+	// Package members:    [Errorf Formatter Fprint Fprintf Fprintln]...
+	// Println type:       func(a ...interface{}) (n int, err error)
+	// Println location:   $GOROOT/src/fmt/print.go:123:1
+}
+
+// ExampleNewImporter demonstrates usage of NewImporter to provide type
+// information for dependencies when type-checking Go source code.
+func ExampleNewImporter() {
+	const src = `package myscanner
+
+// choosing a package that is unlikely to change across releases
+import "text/scanner"
+
+const eof = scanner.EOF
+`
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "myscanner.go", src, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	packages := make(map[string]*types.Package)
+	imp := gcexportdata.NewImporter(fset, packages)
+	conf := types.Config{Importer: imp}
+	pkg, err := conf.Check("myscanner", fset, []*ast.File{f}, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// object from imported package
+	pi := packages["text/scanner"].Scope().Lookup("EOF")
+	fmt.Printf("const %s.%s %s = %s // %s\n",
+		pi.Pkg().Path(),
+		pi.Name(),
+		pi.Type(),
+		pi.(*types.Const).Val(),
+		slashify(fset.Position(pi.Pos())),
+	)
+
+	// object in source package
+	twopi := pkg.Scope().Lookup("eof")
+	fmt.Printf("const %s %s = %s // %s\n",
+		twopi.Name(),
+		twopi.Type(),
+		twopi.(*types.Const).Val(),
+		slashify(fset.Position(twopi.Pos())),
+	)
+
+	// Output:
+	//
+	// const text/scanner.EOF untyped int = -1 // $GOROOT/src/text/scanner/scanner.go:75:1
+	// const eof untyped int = -1 // myscanner.go:6:7
+}
+
+func slashify(posn token.Position) token.Position {
+	posn.Filename = filepath.ToSlash(posn.Filename) // for MS Windows portability
+	return posn
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
new file mode 100644
index 0000000..e53270e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -0,0 +1,100 @@
+// 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 gcexportdata provides functions for locating, reading, and
+// writing export data files containing type information produced by the
+// gc compiler.  This package supports go1.7 export data format and all
+// later versions.
+//
+// This package replaces the deprecated golang.org/x/tools/go/gcimporter15
+// package, which will be deleted in October 2017.
+//
+// Although it might seem convenient for this package to live alongside
+// go/types in the standard library, this would cause version skew
+// problems for developer tools that use it, since they must be able to
+// consume the outputs of the gc compiler both before and after a Go
+// update such as from Go 1.7 to Go 1.8.  Because this package lives in
+// golang.org/x/tools, sites can update their version of this repo some
+// time before the Go 1.8 release and rebuild and redeploy their
+// developer tools, which will then be able to consume both Go 1.7 and
+// Go 1.8 export data files, so they will work before and after the
+// Go update. (See discussion at https://github.com/golang/go/issues/15651.)
+//
+package gcexportdata // import "golang.org/x/tools/go/gcexportdata"
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+
+	gcimporter "golang.org/x/tools/go/gcimporter15"
+)
+
+// Find returns the name of an object (.o) or archive (.a) file
+// containing type information for the specified import path,
+// using the workspace layout conventions of go/build.
+// If no file was found, an empty filename is returned.
+//
+// A relative srcDir is interpreted relative to the current working directory.
+//
+// Find also returns the package's resolved (canonical) import path,
+// reflecting the effects of srcDir and vendoring on importPath.
+func Find(importPath, srcDir string) (filename, path string) {
+	return gcimporter.FindPkg(importPath, srcDir)
+}
+
+// NewReader returns a reader for the export data section of an object
+// (.o) or archive (.a) file read from r.  The new reader may provide
+// additional trailing data beyond the end of the export data.
+func NewReader(r io.Reader) (io.Reader, error) {
+	buf := bufio.NewReader(r)
+	_, err := gcimporter.FindExportData(buf)
+	// If we ever switch to a zip-like archive format with the ToC
+	// at the end, we can return the correct portion of export data,
+	// but for now we must return the entire rest of the file.
+	return buf, err
+}
+
+// Read reads export data from in, decodes it, and returns type
+// information for the package.
+// The package name is specified by path.
+// File position information is added to fset.
+//
+// Read may inspect and add to the imports map to ensure that references
+// within the export data to other packages are consistent.  The caller
+// must ensure that imports[path] does not exist, or exists but is
+// incomplete (see types.Package.Complete), and Read inserts the
+// resulting package into this map entry.
+//
+// On return, the state of the reader is undefined.
+func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
+	data, err := ioutil.ReadAll(in)
+	if err != nil {
+		return nil, fmt.Errorf("reading export data for %q: %v", path, err)
+	}
+
+	if bytes.HasPrefix(data, []byte("!<arch>")) {
+		return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
+	}
+
+	// The App Engine Go runtime v1.6 uses the old export data format.
+	// TODO(adonovan): delete once v1.7 has been around for a while.
+	if bytes.HasPrefix(data, []byte("package ")) {
+		return gcimporter.ImportData(imports, path, path, bytes.NewReader(data))
+	}
+
+	_, pkg, err := gcimporter.BImportData(fset, imports, data, path)
+	return pkg, err
+}
+
+// Write writes encoded type information for the specified package to out.
+// The FileSet provides file position information for named objects.
+func Write(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
+	_, err := out.Write(gcimporter.BExportData(fset, pkg))
+	return err
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata_test.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata_test.go
new file mode 100644
index 0000000..69133db
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata_test.go
@@ -0,0 +1,41 @@
+package gcexportdata_test
+
+import (
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+	"testing"
+
+	"golang.org/x/tools/go/gcexportdata"
+)
+
+// Test to ensure that gcexportdata can read files produced by App
+// Engine Go runtime v1.6.
+func TestAppEngine16(t *testing.T) {
+	// Open and read the file.
+	f, err := os.Open("testdata/errors-ae16.a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r, err := gcexportdata.NewReader(f)
+	if err != nil {
+		log.Fatalf("reading export data: %v", err)
+	}
+
+	// Decode the export data.
+	fset := token.NewFileSet()
+	imports := make(map[string]*types.Package)
+	pkg, err := gcexportdata.Read(r, fset, imports, "errors")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print package information.
+	got := pkg.Scope().Lookup("New").Type().String()
+	want := "func(text string) error"
+	if got != want {
+		t.Errorf("New.Type = %s, want %s", got, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/importer.go b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
new file mode 100644
index 0000000..efe221e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
@@ -0,0 +1,73 @@
+// 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 gcexportdata
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"os"
+)
+
+// NewImporter returns a new instance of the types.Importer interface
+// that reads type information from export data files written by gc.
+// The Importer also satisfies types.ImporterFrom.
+//
+// Export data files are located using "go build" workspace conventions
+// and the build.Default context.
+//
+// Use this importer instead of go/importer.For("gc", ...) to avoid the
+// version-skew problems described in the documentation of this package,
+// or to control the FileSet or access the imports map populated during
+// package loading.
+//
+func NewImporter(fset *token.FileSet, imports map[string]*types.Package) types.ImporterFrom {
+	return importer{fset, imports}
+}
+
+type importer struct {
+	fset    *token.FileSet
+	imports map[string]*types.Package
+}
+
+func (imp importer) Import(importPath string) (*types.Package, error) {
+	return imp.ImportFrom(importPath, "", 0)
+}
+
+func (imp importer) ImportFrom(importPath, srcDir string, mode types.ImportMode) (_ *types.Package, err error) {
+	filename, path := Find(importPath, srcDir)
+	if filename == "" {
+		if importPath == "unsafe" {
+			// Even for unsafe, call Find first in case
+			// the package was vendored.
+			return types.Unsafe, nil
+		}
+		return nil, fmt.Errorf("can't find import: %s", importPath)
+	}
+
+	if pkg, ok := imp.imports[path]; ok && pkg.Complete() {
+		return pkg, nil // cache hit
+	}
+
+	// open file
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		f.Close()
+		if err != nil {
+			// add file name to error
+			err = fmt.Errorf("reading export data: %s: %v", filename, err)
+		}
+	}()
+
+	r, err := NewReader(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return Read(r, imp.fset, imp.imports, path)
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/main.go b/vendor/golang.org/x/tools/go/gcexportdata/main.go
new file mode 100644
index 0000000..106046c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/main.go
@@ -0,0 +1,81 @@
+// 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 ignore
+
+// The gcexportdata command is a diagnostic tool that displays the
+// contents of gc export data files.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+
+	"golang.org/x/tools/go/gcexportdata"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+func main() {
+	log.SetPrefix("gcexportdata: ")
+	log.SetFlags(0)
+	flag.Usage = func() {
+		fmt.Fprintln(os.Stderr, "usage: gcexportdata file.a")
+	}
+	flag.Parse()
+	if flag.NArg() != 1 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	filename := flag.Args()[0]
+
+	f, err := os.Open(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	r, err := gcexportdata.NewReader(f)
+	if err != nil {
+		log.Fatalf("%s: %s", filename, err)
+	}
+
+	// Decode the package.
+	imports := make(map[string]*types.Package)
+	fset := token.NewFileSet()
+	pkg, err := gcexportdata.Read(r, fset, imports, "dummy")
+	if err != nil {
+		log.Fatal("%s: %s", filename, err)
+	}
+
+	// Print all package-level declarations, including non-exported ones.
+	fmt.Printf("package %s\n", pkg.Name())
+	for _, imp := range pkg.Imports() {
+		fmt.Printf("import %q\n", imp.Path())
+	}
+	qual := func(p *types.Package) string {
+		if pkg == p {
+			return ""
+		}
+		return p.Name()
+	}
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		fmt.Printf("%s: %s\n",
+			fset.Position(obj.Pos()),
+			types.ObjectString(obj, qual))
+
+		// For types, print each method.
+		if _, ok := obj.(*types.TypeName); ok {
+			for _, method := range typeutil.IntuitiveMethodSet(obj.Type(), nil) {
+				fmt.Printf("%s: %s\n",
+					fset.Position(method.Obj().Pos()),
+					types.SelectionString(method, qual))
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/testdata/errors-ae16.a b/vendor/golang.org/x/tools/go/gcexportdata/testdata/errors-ae16.a
new file mode 100644
index 0000000..3f1dad5
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gcexportdata/testdata/errors-ae16.a differ
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bexport.go b/vendor/golang.org/x/tools/go/gcimporter15/bexport.go
new file mode 100644
index 0000000..cbf8bc0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bexport.go
@@ -0,0 +1,828 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Binary package export.
+// This file was derived from $GOROOT/src/cmd/compile/internal/gc/bexport.go;
+// see that file for specification of the format.
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"log"
+	"math"
+	"math/big"
+	"sort"
+	"strings"
+)
+
+// If debugFormat is set, each integer and string value is preceded by a marker
+// and position information in the encoding. This mechanism permits an importer
+// to recognize immediately when it is out of sync. The importer recognizes this
+// mode automatically (i.e., it can import export data produced with debugging
+// support even if debugFormat is not set at the time of import). This mode will
+// lead to massively larger export data (by a factor of 2 to 3) and should only
+// be enabled during development and debugging.
+//
+// NOTE: This flag is the first flag to enable if importing dies because of
+// (suspected) format errors, and whenever a change is made to the format.
+const debugFormat = false // default: false
+
+// If trace is set, debugging output is printed to std out.
+const trace = false // default: false
+
+// Current export format version. Increase with each format change.
+// 4: type name objects support type aliases, uses aliasTag
+// 3: Go1.8 encoding (same as version 2, aliasTag defined but never used)
+// 2: removed unused bool in ODCL export (compiler only)
+// 1: header format change (more regular), export package for _ struct fields
+// 0: Go1.7 encoding
+const exportVersion = 4
+
+// trackAllTypes enables cycle tracking for all types, not just named
+// types. The existing compiler invariants assume that unnamed types
+// that are not completely set up are not used, or else there are spurious
+// errors.
+// If disabled, only named types are tracked, possibly leading to slightly
+// less efficient encoding in rare cases. It also prevents the export of
+// some corner-case type declarations (but those are not handled correctly
+// with with the textual export format either).
+// TODO(gri) enable and remove once issues caused by it are fixed
+const trackAllTypes = false
+
+type exporter struct {
+	fset *token.FileSet
+	out  bytes.Buffer
+
+	// object -> index maps, indexed in order of serialization
+	strIndex map[string]int
+	pkgIndex map[*types.Package]int
+	typIndex map[types.Type]int
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+
+	// debugging support
+	written int // bytes written
+	indent  int // for trace
+}
+
+// BExportData returns binary export data for pkg.
+// If no file set is provided, position info will be missing.
+func BExportData(fset *token.FileSet, pkg *types.Package) []byte {
+	p := exporter{
+		fset:          fset,
+		strIndex:      map[string]int{"": 0}, // empty string is mapped to 0
+		pkgIndex:      make(map[*types.Package]int),
+		typIndex:      make(map[types.Type]int),
+		posInfoFormat: true, // TODO(gri) might become a flag, eventually
+	}
+
+	// write version info
+	// The version string must start with "version %d" where %d is the version
+	// number. Additional debugging information may follow after a blank; that
+	// text is ignored by the importer.
+	p.rawStringln(fmt.Sprintf("version %d", exportVersion))
+	var debug string
+	if debugFormat {
+		debug = "debug"
+	}
+	p.rawStringln(debug) // cannot use p.bool since it's affected by debugFormat; also want to see this clearly
+	p.bool(trackAllTypes)
+	p.bool(p.posInfoFormat)
+
+	// --- generic export data ---
+
+	// populate type map with predeclared "known" types
+	for index, typ := range predeclared {
+		p.typIndex[typ] = index
+	}
+	if len(p.typIndex) != len(predeclared) {
+		log.Fatalf("gcimporter: duplicate entries in type map?")
+	}
+
+	// write package data
+	p.pkg(pkg, true)
+	if trace {
+		p.tracef("\n")
+	}
+
+	// write objects
+	objcount := 0
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		if !ast.IsExported(name) {
+			continue
+		}
+		if trace {
+			p.tracef("\n")
+		}
+		p.obj(scope.Lookup(name))
+		objcount++
+	}
+
+	// indicate end of list
+	if trace {
+		p.tracef("\n")
+	}
+	p.tag(endTag)
+
+	// for self-verification only (redundant)
+	p.int(objcount)
+
+	if trace {
+		p.tracef("\n")
+	}
+
+	// --- end of export data ---
+
+	return p.out.Bytes()
+}
+
+func (p *exporter) pkg(pkg *types.Package, emptypath bool) {
+	if pkg == nil {
+		log.Fatalf("gcimporter: unexpected nil pkg")
+	}
+
+	// if we saw the package before, write its index (>= 0)
+	if i, ok := p.pkgIndex[pkg]; ok {
+		p.index('P', i)
+		return
+	}
+
+	// otherwise, remember the package, write the package tag (< 0) and package data
+	if trace {
+		p.tracef("P%d = { ", len(p.pkgIndex))
+		defer p.tracef("} ")
+	}
+	p.pkgIndex[pkg] = len(p.pkgIndex)
+
+	p.tag(packageTag)
+	p.string(pkg.Name())
+	if emptypath {
+		p.string("")
+	} else {
+		p.string(pkg.Path())
+	}
+}
+
+func (p *exporter) obj(obj types.Object) {
+	switch obj := obj.(type) {
+	case *types.Const:
+		p.tag(constTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+		p.value(obj.Val())
+
+	case *types.TypeName:
+		if isAlias(obj) {
+			p.tag(aliasTag)
+			p.pos(obj)
+			p.qualifiedName(obj)
+		} else {
+			p.tag(typeTag)
+		}
+		p.typ(obj.Type())
+
+	case *types.Var:
+		p.tag(varTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+
+	case *types.Func:
+		p.tag(funcTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		sig := obj.Type().(*types.Signature)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+
+	default:
+		log.Fatalf("gcimporter: unexpected object %v (%T)", obj, obj)
+	}
+}
+
+func (p *exporter) pos(obj types.Object) {
+	if !p.posInfoFormat {
+		return
+	}
+
+	file, line := p.fileLine(obj)
+	if file == p.prevFile {
+		// common case: write line delta
+		// delta == 0 means different file or no line change
+		delta := line - p.prevLine
+		p.int(delta)
+		if delta == 0 {
+			p.int(-1) // -1 means no file change
+		}
+	} else {
+		// different file
+		p.int(0)
+		// Encode filename as length of common prefix with previous
+		// filename, followed by (possibly empty) suffix. Filenames
+		// frequently share path prefixes, so this can save a lot
+		// of space and make export data size less dependent on file
+		// path length. The suffix is unlikely to be empty because
+		// file names tend to end in ".go".
+		n := commonPrefixLen(p.prevFile, file)
+		p.int(n)           // n >= 0
+		p.string(file[n:]) // write suffix only
+		p.prevFile = file
+		p.int(line)
+	}
+	p.prevLine = line
+}
+
+func (p *exporter) fileLine(obj types.Object) (file string, line int) {
+	if p.fset != nil {
+		pos := p.fset.Position(obj.Pos())
+		file = pos.Filename
+		line = pos.Line
+	}
+	return
+}
+
+func commonPrefixLen(a, b string) int {
+	if len(a) > len(b) {
+		a, b = b, a
+	}
+	// len(a) <= len(b)
+	i := 0
+	for i < len(a) && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+
+func (p *exporter) qualifiedName(obj types.Object) {
+	p.string(obj.Name())
+	p.pkg(obj.Pkg(), false)
+}
+
+func (p *exporter) typ(t types.Type) {
+	if t == nil {
+		log.Fatalf("gcimporter: nil type")
+	}
+
+	// Possible optimization: Anonymous pointer types *T where
+	// T is a named type are common. We could canonicalize all
+	// such types *T to a single type PT = *T. This would lead
+	// to at most one *T entry in typIndex, and all future *T's
+	// would be encoded as the respective index directly. Would
+	// save 1 byte (pointerTag) per *T and reduce the typIndex
+	// size (at the cost of a canonicalization map). We can do
+	// this later, without encoding format change.
+
+	// if we saw the type before, write its index (>= 0)
+	if i, ok := p.typIndex[t]; ok {
+		p.index('T', i)
+		return
+	}
+
+	// otherwise, remember the type, write the type tag (< 0) and type data
+	if trackAllTypes {
+		if trace {
+			p.tracef("T%d = {>\n", len(p.typIndex))
+			defer p.tracef("<\n} ")
+		}
+		p.typIndex[t] = len(p.typIndex)
+	}
+
+	switch t := t.(type) {
+	case *types.Named:
+		if !trackAllTypes {
+			// if we don't track all types, track named types now
+			p.typIndex[t] = len(p.typIndex)
+		}
+
+		p.tag(namedTag)
+		p.pos(t.Obj())
+		p.qualifiedName(t.Obj())
+		p.typ(t.Underlying())
+		if !types.IsInterface(t) {
+			p.assocMethods(t)
+		}
+
+	case *types.Array:
+		p.tag(arrayTag)
+		p.int64(t.Len())
+		p.typ(t.Elem())
+
+	case *types.Slice:
+		p.tag(sliceTag)
+		p.typ(t.Elem())
+
+	case *dddSlice:
+		p.tag(dddTag)
+		p.typ(t.elem)
+
+	case *types.Struct:
+		p.tag(structTag)
+		p.fieldList(t)
+
+	case *types.Pointer:
+		p.tag(pointerTag)
+		p.typ(t.Elem())
+
+	case *types.Signature:
+		p.tag(signatureTag)
+		p.paramList(t.Params(), t.Variadic())
+		p.paramList(t.Results(), false)
+
+	case *types.Interface:
+		p.tag(interfaceTag)
+		p.iface(t)
+
+	case *types.Map:
+		p.tag(mapTag)
+		p.typ(t.Key())
+		p.typ(t.Elem())
+
+	case *types.Chan:
+		p.tag(chanTag)
+		p.int(int(3 - t.Dir())) // hack
+		p.typ(t.Elem())
+
+	default:
+		log.Fatalf("gcimporter: unexpected type %T: %s", t, t)
+	}
+}
+
+func (p *exporter) assocMethods(named *types.Named) {
+	// Sort methods (for determinism).
+	var methods []*types.Func
+	for i := 0; i < named.NumMethods(); i++ {
+		methods = append(methods, named.Method(i))
+	}
+	sort.Sort(methodsByName(methods))
+
+	p.int(len(methods))
+
+	if trace && methods != nil {
+		p.tracef("associated methods {>\n")
+	}
+
+	for i, m := range methods {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+
+		p.pos(m)
+		name := m.Name()
+		p.string(name)
+		if !exported(name) {
+			p.pkg(m.Pkg(), false)
+		}
+
+		sig := m.Type().(*types.Signature)
+		p.paramList(types.NewTuple(sig.Recv()), false)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+		p.int(0) // dummy value for go:nointerface pragma - ignored by importer
+	}
+
+	if trace && methods != nil {
+		p.tracef("<\n} ")
+	}
+}
+
+type methodsByName []*types.Func
+
+func (x methodsByName) Len() int           { return len(x) }
+func (x methodsByName) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x methodsByName) Less(i, j int) bool { return x[i].Name() < x[j].Name() }
+
+func (p *exporter) fieldList(t *types.Struct) {
+	if trace && t.NumFields() > 0 {
+		p.tracef("fields {>\n")
+		defer p.tracef("<\n} ")
+	}
+
+	p.int(t.NumFields())
+	for i := 0; i < t.NumFields(); i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.field(t.Field(i))
+		p.string(t.Tag(i))
+	}
+}
+
+func (p *exporter) field(f *types.Var) {
+	if !f.IsField() {
+		log.Fatalf("gcimporter: field expected")
+	}
+
+	p.pos(f)
+	p.fieldName(f)
+	p.typ(f.Type())
+}
+
+func (p *exporter) iface(t *types.Interface) {
+	// TODO(gri): enable importer to load embedded interfaces,
+	// then emit Embeddeds and ExplicitMethods separately here.
+	p.int(0)
+
+	n := t.NumMethods()
+	if trace && n > 0 {
+		p.tracef("methods {>\n")
+		defer p.tracef("<\n} ")
+	}
+	p.int(n)
+	for i := 0; i < n; i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.method(t.Method(i))
+	}
+}
+
+func (p *exporter) method(m *types.Func) {
+	sig := m.Type().(*types.Signature)
+	if sig.Recv() == nil {
+		log.Fatalf("gcimporter: method expected")
+	}
+
+	p.pos(m)
+	p.string(m.Name())
+	if m.Name() != "_" && !ast.IsExported(m.Name()) {
+		p.pkg(m.Pkg(), false)
+	}
+
+	// interface method; no need to encode receiver.
+	p.paramList(sig.Params(), sig.Variadic())
+	p.paramList(sig.Results(), false)
+}
+
+func (p *exporter) fieldName(f *types.Var) {
+	name := f.Name()
+
+	if f.Anonymous() {
+		// anonymous field - we distinguish between 3 cases:
+		// 1) field name matches base type name and is exported
+		// 2) field name matches base type name and is not exported
+		// 3) field name doesn't match base type name (alias name)
+		bname := basetypeName(f.Type())
+		if name == bname {
+			if ast.IsExported(name) {
+				name = "" // 1) we don't need to know the field name or package
+			} else {
+				name = "?" // 2) use unexported name "?" to force package export
+			}
+		} else {
+			// 3) indicate alias and export name as is
+			// (this requires an extra "@" but this is a rare case)
+			p.string("@")
+		}
+	}
+
+	p.string(name)
+	if name != "" && !ast.IsExported(name) {
+		p.pkg(f.Pkg(), false)
+	}
+}
+
+func basetypeName(typ types.Type) string {
+	switch typ := deref(typ).(type) {
+	case *types.Basic:
+		return typ.Name()
+	case *types.Named:
+		return typ.Obj().Name()
+	default:
+		return "" // unnamed type
+	}
+}
+
+func (p *exporter) paramList(params *types.Tuple, variadic bool) {
+	// use negative length to indicate unnamed parameters
+	// (look at the first parameter only since either all
+	// names are present or all are absent)
+	n := params.Len()
+	if n > 0 && params.At(0).Name() == "" {
+		n = -n
+	}
+	p.int(n)
+	for i := 0; i < params.Len(); i++ {
+		q := params.At(i)
+		t := q.Type()
+		if variadic && i == params.Len()-1 {
+			t = &dddSlice{t.(*types.Slice).Elem()}
+		}
+		p.typ(t)
+		if n > 0 {
+			name := q.Name()
+			p.string(name)
+			if name != "_" {
+				p.pkg(q.Pkg(), false)
+			}
+		}
+		p.string("") // no compiler-specific info
+	}
+}
+
+func (p *exporter) value(x constant.Value) {
+	if trace {
+		p.tracef("= ")
+	}
+
+	switch x.Kind() {
+	case constant.Bool:
+		tag := falseTag
+		if constant.BoolVal(x) {
+			tag = trueTag
+		}
+		p.tag(tag)
+
+	case constant.Int:
+		if v, exact := constant.Int64Val(x); exact {
+			// common case: x fits into an int64 - use compact encoding
+			p.tag(int64Tag)
+			p.int64(v)
+			return
+		}
+		// uncommon case: large x - use float encoding
+		// (powers of 2 will be encoded efficiently with exponent)
+		p.tag(floatTag)
+		p.float(constant.ToFloat(x))
+
+	case constant.Float:
+		p.tag(floatTag)
+		p.float(x)
+
+	case constant.Complex:
+		p.tag(complexTag)
+		p.float(constant.Real(x))
+		p.float(constant.Imag(x))
+
+	case constant.String:
+		p.tag(stringTag)
+		p.string(constant.StringVal(x))
+
+	case constant.Unknown:
+		// package contains type errors
+		p.tag(unknownTag)
+
+	default:
+		log.Fatalf("gcimporter: unexpected value %v (%T)", x, x)
+	}
+}
+
+func (p *exporter) float(x constant.Value) {
+	if x.Kind() != constant.Float {
+		log.Fatalf("gcimporter: unexpected constant %v, want float", x)
+	}
+	// extract sign (there is no -0)
+	sign := constant.Sign(x)
+	if sign == 0 {
+		// x == 0
+		p.int(0)
+		return
+	}
+	// x != 0
+
+	var f big.Float
+	if v, exact := constant.Float64Val(x); exact {
+		// float64
+		f.SetFloat64(v)
+	} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
+		// TODO(gri): add big.Rat accessor to constant.Value.
+		r := valueToRat(num)
+		f.SetRat(r.Quo(r, valueToRat(denom)))
+	} else {
+		// Value too large to represent as a fraction => inaccessible.
+		// TODO(gri): add big.Float accessor to constant.Value.
+		f.SetFloat64(math.MaxFloat64) // FIXME
+	}
+
+	// extract exponent such that 0.5 <= m < 1.0
+	var m big.Float
+	exp := f.MantExp(&m)
+
+	// extract mantissa as *big.Int
+	// - set exponent large enough so mant satisfies mant.IsInt()
+	// - get *big.Int from mant
+	m.SetMantExp(&m, int(m.MinPrec()))
+	mant, acc := m.Int(nil)
+	if acc != big.Exact {
+		log.Fatalf("gcimporter: internal error")
+	}
+
+	p.int(sign)
+	p.int(exp)
+	p.string(string(mant.Bytes()))
+}
+
+func valueToRat(x constant.Value) *big.Rat {
+	// Convert little-endian to big-endian.
+	// I can't believe this is necessary.
+	bytes := constant.Bytes(x)
+	for i := 0; i < len(bytes)/2; i++ {
+		bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i]
+	}
+	return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes))
+}
+
+func (p *exporter) bool(b bool) bool {
+	if trace {
+		p.tracef("[")
+		defer p.tracef("= %v] ", b)
+	}
+
+	x := 0
+	if b {
+		x = 1
+	}
+	p.int(x)
+	return b
+}
+
+// ----------------------------------------------------------------------------
+// Low-level encoders
+
+func (p *exporter) index(marker byte, index int) {
+	if index < 0 {
+		log.Fatalf("gcimporter: invalid index < 0")
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%c%d ", marker, index)
+	}
+	p.rawInt64(int64(index))
+}
+
+func (p *exporter) tag(tag int) {
+	if tag >= 0 {
+		log.Fatalf("gcimporter: invalid tag >= 0")
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%s ", tagString[-tag])
+	}
+	p.rawInt64(int64(tag))
+}
+
+func (p *exporter) int(x int) {
+	p.int64(int64(x))
+}
+
+func (p *exporter) int64(x int64) {
+	if debugFormat {
+		p.marker('i')
+	}
+	if trace {
+		p.tracef("%d ", x)
+	}
+	p.rawInt64(x)
+}
+
+func (p *exporter) string(s string) {
+	if debugFormat {
+		p.marker('s')
+	}
+	if trace {
+		p.tracef("%q ", s)
+	}
+	// if we saw the string before, write its index (>= 0)
+	// (the empty string is mapped to 0)
+	if i, ok := p.strIndex[s]; ok {
+		p.rawInt64(int64(i))
+		return
+	}
+	// otherwise, remember string and write its negative length and bytes
+	p.strIndex[s] = len(p.strIndex)
+	p.rawInt64(-int64(len(s)))
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+}
+
+// marker emits a marker byte and position information which makes
+// it easy for a reader to detect if it is "out of sync". Used for
+// debugFormat format only.
+func (p *exporter) marker(m byte) {
+	p.rawByte(m)
+	// Enable this for help tracking down the location
+	// of an incorrect marker when running in debugFormat.
+	if false && trace {
+		p.tracef("#%d ", p.written)
+	}
+	p.rawInt64(int64(p.written))
+}
+
+// rawInt64 should only be used by low-level encoders.
+func (p *exporter) rawInt64(x int64) {
+	var tmp [binary.MaxVarintLen64]byte
+	n := binary.PutVarint(tmp[:], x)
+	for i := 0; i < n; i++ {
+		p.rawByte(tmp[i])
+	}
+}
+
+// rawStringln should only be used to emit the initial version string.
+func (p *exporter) rawStringln(s string) {
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+	p.rawByte('\n')
+}
+
+// rawByte is the bottleneck interface to write to p.out.
+// rawByte escapes b as follows (any encoding does that
+// hides '$'):
+//
+//	'$'  => '|' 'S'
+//	'|'  => '|' '|'
+//
+// Necessary so other tools can find the end of the
+// export data by searching for "$$".
+// rawByte should only be used by low-level encoders.
+func (p *exporter) rawByte(b byte) {
+	switch b {
+	case '$':
+		// write '$' as '|' 'S'
+		b = 'S'
+		fallthrough
+	case '|':
+		// write '|' as '|' '|'
+		p.out.WriteByte('|')
+		p.written++
+	}
+	p.out.WriteByte(b)
+	p.written++
+}
+
+// tracef is like fmt.Printf but it rewrites the format string
+// to take care of indentation.
+func (p *exporter) tracef(format string, args ...interface{}) {
+	if strings.ContainsAny(format, "<>\n") {
+		var buf bytes.Buffer
+		for i := 0; i < len(format); i++ {
+			// no need to deal with runes
+			ch := format[i]
+			switch ch {
+			case '>':
+				p.indent++
+				continue
+			case '<':
+				p.indent--
+				continue
+			}
+			buf.WriteByte(ch)
+			if ch == '\n' {
+				for j := p.indent; j > 0; j-- {
+					buf.WriteString(".  ")
+				}
+			}
+		}
+		format = buf.String()
+	}
+	fmt.Printf(format, args...)
+}
+
+// Debugging support.
+// (tagString is only used when tracing is enabled)
+var tagString = [...]string{
+	// Packages
+	-packageTag: "package",
+
+	// Types
+	-namedTag:     "named type",
+	-arrayTag:     "array",
+	-sliceTag:     "slice",
+	-dddTag:       "ddd",
+	-structTag:    "struct",
+	-pointerTag:   "pointer",
+	-signatureTag: "signature",
+	-interfaceTag: "interface",
+	-mapTag:       "map",
+	-chanTag:      "chan",
+
+	// Values
+	-falseTag:    "false",
+	-trueTag:     "true",
+	-int64Tag:    "int64",
+	-floatTag:    "float",
+	-fractionTag: "fraction",
+	-complexTag:  "complex",
+	-stringTag:   "string",
+	-unknownTag:  "unknown",
+
+	// Type aliases
+	-aliasTag: "alias",
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bexport19_test.go b/vendor/golang.org/x/tools/go/gcimporter15/bexport19_test.go
new file mode 100644
index 0000000..f6e9733
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bexport19_test.go
@@ -0,0 +1,93 @@
+// 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 go1.9
+
+package gcimporter_test
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+
+	gcimporter "golang.org/x/tools/go/gcimporter15"
+)
+
+const src = `
+package p
+
+type (
+	T0 = int32
+	T1 = struct{}
+	T2 = struct{ T1 }
+	Invalid = foo // foo is undeclared
+)
+`
+
+func checkPkg(t *testing.T, pkg *types.Package, label string) {
+	T1 := types.NewStruct(nil, nil)
+	T2 := types.NewStruct([]*types.Var{types.NewField(0, pkg, "T1", T1, true)}, nil)
+
+	for _, test := range []struct {
+		name string
+		typ  types.Type
+	}{
+		{"T0", types.Typ[types.Int32]},
+		{"T1", T1},
+		{"T2", T2},
+		{"Invalid", types.Typ[types.Invalid]},
+	} {
+		obj := pkg.Scope().Lookup(test.name)
+		if obj == nil {
+			t.Errorf("%s: %s not found", label, test.name)
+			continue
+		}
+		tname, _ := obj.(*types.TypeName)
+		if tname == nil {
+			t.Errorf("%s: %v not a type name", label, obj)
+			continue
+		}
+		if !tname.IsAlias() {
+			t.Errorf("%s: %v: not marked as alias", label, tname)
+			continue
+		}
+		if got := tname.Type(); !types.Identical(got, test.typ) {
+			t.Errorf("%s: %v: got %v; want %v", label, tname, got, test.typ)
+		}
+	}
+}
+
+func TestTypeAliases(t *testing.T) {
+	// parse and typecheck
+	fset1 := token.NewFileSet()
+	f, err := parser.ParseFile(fset1, "p.go", src, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var conf types.Config
+	pkg1, err := conf.Check("p", fset1, []*ast.File{f}, nil)
+	if err == nil {
+		// foo in undeclared in src; we should see an error
+		t.Fatal("invalid source type-checked without error")
+	}
+	if pkg1 == nil {
+		// despite incorrect src we should see a (partially) type-checked package
+		t.Fatal("nil package returned")
+	}
+	checkPkg(t, pkg1, "export")
+
+	// export
+	exportdata := gcimporter.BExportData(fset1, pkg1)
+
+	// import
+	imports := make(map[string]*types.Package)
+	fset2 := token.NewFileSet()
+	_, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg1.Path())
+	if err != nil {
+		t.Fatalf("BImportData(%s): %v", pkg1.Path(), err)
+	}
+	checkPkg(t, pkg2, "import")
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bexport_test.go b/vendor/golang.org/x/tools/go/gcimporter15/bexport_test.go
new file mode 100644
index 0000000..6ab3bcb
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bexport_test.go
@@ -0,0 +1,326 @@
+// 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 gcimporter_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/constant"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+	gcimporter "golang.org/x/tools/go/gcimporter15"
+	"golang.org/x/tools/go/loader"
+)
+
+func TestBExportData_stdlib(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skipf("incomplete std lib on %s", runtime.GOOS)
+	}
+
+	// Load, parse and type-check the program.
+	ctxt := build.Default // copy
+	ctxt.GOPATH = ""      // disable GOPATH
+	conf := loader.Config{
+		Build:       &ctxt,
+		AllowErrors: true,
+	}
+	for _, path := range buildutil.AllPackages(conf.Build) {
+		conf.Import(path)
+	}
+
+	// Create a package containing type and value errors to ensure
+	// they are properly encoded/decoded.
+	f, err := conf.ParseFile("haserrors/haserrors.go", `package haserrors
+const UnknownValue = "" + 0
+type UnknownType undefined
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf.CreateFromFiles("haserrors", f)
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load failed: %v", err)
+	}
+
+	numPkgs := len(prog.AllPackages)
+	if want := 248; numPkgs < want {
+		t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want)
+	}
+
+	for pkg, info := range prog.AllPackages {
+		if info.Files == nil {
+			continue // empty directory
+		}
+		exportdata := gcimporter.BExportData(conf.Fset, pkg)
+
+		imports := make(map[string]*types.Package)
+		fset2 := token.NewFileSet()
+		n, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg.Path())
+		if err != nil {
+			t.Errorf("BImportData(%s): %v", pkg.Path(), err)
+			continue
+		}
+		if n != len(exportdata) {
+			t.Errorf("BImportData(%s) decoded %d bytes, want %d",
+				pkg.Path(), n, len(exportdata))
+		}
+
+		// Compare the packages' corresponding members.
+		for _, name := range pkg.Scope().Names() {
+			if !ast.IsExported(name) {
+				continue
+			}
+			obj1 := pkg.Scope().Lookup(name)
+			obj2 := pkg2.Scope().Lookup(name)
+			if obj2 == nil {
+				t.Errorf("%s.%s not found, want %s", pkg.Path(), name, obj1)
+				continue
+			}
+
+			fl1 := fileLine(conf.Fset, obj1)
+			fl2 := fileLine(fset2, obj2)
+			if fl1 != fl2 {
+				t.Errorf("%s.%s: got posn %s, want %s",
+					pkg.Path(), name, fl2, fl1)
+			}
+
+			if err := equalObj(obj1, obj2); err != nil {
+				t.Errorf("%s.%s: %s\ngot:  %s\nwant: %s",
+					pkg.Path(), name, err, obj2, obj1)
+			}
+		}
+	}
+}
+
+func fileLine(fset *token.FileSet, obj types.Object) string {
+	posn := fset.Position(obj.Pos())
+	return fmt.Sprintf("%s:%d", posn.Filename, posn.Line)
+}
+
+// equalObj reports how x and y differ.  They are assumed to belong to
+// different universes so cannot be compared directly.
+func equalObj(x, y types.Object) error {
+	if reflect.TypeOf(x) != reflect.TypeOf(y) {
+		return fmt.Errorf("%T vs %T", x, y)
+	}
+	xt := x.Type()
+	yt := y.Type()
+	switch x.(type) {
+	case *types.Var, *types.Func:
+		// ok
+	case *types.Const:
+		xval := x.(*types.Const).Val()
+		yval := y.(*types.Const).Val()
+		// Use string comparison for floating-point values since rounding is permitted.
+		if constant.Compare(xval, token.NEQ, yval) &&
+			!(xval.Kind() == constant.Float && xval.String() == yval.String()) {
+			return fmt.Errorf("unequal constants %s vs %s", xval, yval)
+		}
+	case *types.TypeName:
+		xt = xt.Underlying()
+		yt = yt.Underlying()
+	default:
+		return fmt.Errorf("unexpected %T", x)
+	}
+	return equalType(xt, yt)
+}
+
+func equalType(x, y types.Type) error {
+	if reflect.TypeOf(x) != reflect.TypeOf(y) {
+		return fmt.Errorf("unequal kinds: %T vs %T", x, y)
+	}
+	switch x := x.(type) {
+	case *types.Interface:
+		y := y.(*types.Interface)
+		// TODO(gri): enable separate emission of Embedded interfaces
+		// and ExplicitMethods then use this logic.
+		// if x.NumEmbeddeds() != y.NumEmbeddeds() {
+		// 	return fmt.Errorf("unequal number of embedded interfaces: %d vs %d",
+		// 		x.NumEmbeddeds(), y.NumEmbeddeds())
+		// }
+		// for i := 0; i < x.NumEmbeddeds(); i++ {
+		// 	xi := x.Embedded(i)
+		// 	yi := y.Embedded(i)
+		// 	if xi.String() != yi.String() {
+		// 		return fmt.Errorf("mismatched %th embedded interface: %s vs %s",
+		// 			i, xi, yi)
+		// 	}
+		// }
+		// if x.NumExplicitMethods() != y.NumExplicitMethods() {
+		// 	return fmt.Errorf("unequal methods: %d vs %d",
+		// 		x.NumExplicitMethods(), y.NumExplicitMethods())
+		// }
+		// for i := 0; i < x.NumExplicitMethods(); i++ {
+		// 	xm := x.ExplicitMethod(i)
+		// 	ym := y.ExplicitMethod(i)
+		// 	if xm.Name() != ym.Name() {
+		// 		return fmt.Errorf("mismatched %th method: %s vs %s", i, xm, ym)
+		// 	}
+		// 	if err := equalType(xm.Type(), ym.Type()); err != nil {
+		// 		return fmt.Errorf("mismatched %s method: %s", xm.Name(), err)
+		// 	}
+		// }
+		if x.NumMethods() != y.NumMethods() {
+			return fmt.Errorf("unequal methods: %d vs %d",
+				x.NumMethods(), y.NumMethods())
+		}
+		for i := 0; i < x.NumMethods(); i++ {
+			xm := x.Method(i)
+			ym := y.Method(i)
+			if xm.Name() != ym.Name() {
+				return fmt.Errorf("mismatched %dth method: %s vs %s", i, xm, ym)
+			}
+			if err := equalType(xm.Type(), ym.Type()); err != nil {
+				return fmt.Errorf("mismatched %s method: %s", xm.Name(), err)
+			}
+		}
+	case *types.Array:
+		y := y.(*types.Array)
+		if x.Len() != y.Len() {
+			return fmt.Errorf("unequal array lengths: %d vs %d", x.Len(), y.Len())
+		}
+		if err := equalType(x.Elem(), y.Elem()); err != nil {
+			return fmt.Errorf("array elements: %s", err)
+		}
+	case *types.Basic:
+		y := y.(*types.Basic)
+		if x.Kind() != y.Kind() {
+			return fmt.Errorf("unequal basic types: %s vs %s", x, y)
+		}
+	case *types.Chan:
+		y := y.(*types.Chan)
+		if x.Dir() != y.Dir() {
+			return fmt.Errorf("unequal channel directions: %d vs %d", x.Dir(), y.Dir())
+		}
+		if err := equalType(x.Elem(), y.Elem()); err != nil {
+			return fmt.Errorf("channel elements: %s", err)
+		}
+	case *types.Map:
+		y := y.(*types.Map)
+		if err := equalType(x.Key(), y.Key()); err != nil {
+			return fmt.Errorf("map keys: %s", err)
+		}
+		if err := equalType(x.Elem(), y.Elem()); err != nil {
+			return fmt.Errorf("map values: %s", err)
+		}
+	case *types.Named:
+		y := y.(*types.Named)
+		if x.String() != y.String() {
+			return fmt.Errorf("unequal named types: %s vs %s", x, y)
+		}
+	case *types.Pointer:
+		y := y.(*types.Pointer)
+		if err := equalType(x.Elem(), y.Elem()); err != nil {
+			return fmt.Errorf("pointer elements: %s", err)
+		}
+	case *types.Signature:
+		y := y.(*types.Signature)
+		if err := equalType(x.Params(), y.Params()); err != nil {
+			return fmt.Errorf("parameters: %s", err)
+		}
+		if err := equalType(x.Results(), y.Results()); err != nil {
+			return fmt.Errorf("results: %s", err)
+		}
+		if x.Variadic() != y.Variadic() {
+			return fmt.Errorf("unequal varidicity: %t vs %t",
+				x.Variadic(), y.Variadic())
+		}
+		if (x.Recv() != nil) != (y.Recv() != nil) {
+			return fmt.Errorf("unequal receivers: %s vs %s", x.Recv(), y.Recv())
+		}
+		if x.Recv() != nil {
+			// TODO(adonovan): fix: this assertion fires for interface methods.
+			// The type of the receiver of an interface method is a named type
+			// if the Package was loaded from export data, or an unnamed (interface)
+			// type if the Package was produced by type-checking ASTs.
+			// if err := equalType(x.Recv().Type(), y.Recv().Type()); err != nil {
+			// 	return fmt.Errorf("receiver: %s", err)
+			// }
+		}
+	case *types.Slice:
+		y := y.(*types.Slice)
+		if err := equalType(x.Elem(), y.Elem()); err != nil {
+			return fmt.Errorf("slice elements: %s", err)
+		}
+	case *types.Struct:
+		y := y.(*types.Struct)
+		if x.NumFields() != y.NumFields() {
+			return fmt.Errorf("unequal struct fields: %d vs %d",
+				x.NumFields(), y.NumFields())
+		}
+		for i := 0; i < x.NumFields(); i++ {
+			xf := x.Field(i)
+			yf := y.Field(i)
+			if xf.Name() != yf.Name() {
+				return fmt.Errorf("mismatched fields: %s vs %s", xf, yf)
+			}
+			if err := equalType(xf.Type(), yf.Type()); err != nil {
+				return fmt.Errorf("struct field %s: %s", xf.Name(), err)
+			}
+			if x.Tag(i) != y.Tag(i) {
+				return fmt.Errorf("struct field %s has unequal tags: %q vs %q",
+					xf.Name(), x.Tag(i), y.Tag(i))
+			}
+		}
+	case *types.Tuple:
+		y := y.(*types.Tuple)
+		if x.Len() != y.Len() {
+			return fmt.Errorf("unequal tuple lengths: %d vs %d", x.Len(), y.Len())
+		}
+		for i := 0; i < x.Len(); i++ {
+			if err := equalType(x.At(i).Type(), y.At(i).Type()); err != nil {
+				return fmt.Errorf("tuple element %d: %s", i, err)
+			}
+		}
+	}
+	return nil
+}
+
+// TestVeryLongFile tests the position of an import object declared in
+// a very long input file.  Line numbers greater than maxlines are
+// reported as line 1, not garbage or token.NoPos.
+func TestVeryLongFile(t *testing.T) {
+	// parse and typecheck
+	longFile := "package foo" + strings.Repeat("\n", 123456) + "var X int"
+	fset1 := token.NewFileSet()
+	f, err := parser.ParseFile(fset1, "foo.go", longFile, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var conf types.Config
+	pkg, err := conf.Check("foo", fset1, []*ast.File{f}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// export
+	exportdata := gcimporter.BExportData(fset1, pkg)
+
+	// import
+	imports := make(map[string]*types.Package)
+	fset2 := token.NewFileSet()
+	_, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg.Path())
+	if err != nil {
+		t.Fatalf("BImportData(%s): %v", pkg.Path(), err)
+	}
+
+	// compare
+	posn1 := fset1.Position(pkg.Scope().Lookup("X").Pos())
+	posn2 := fset2.Position(pkg2.Scope().Lookup("X").Pos())
+	if want := "foo.go:1:1"; posn2.String() != want {
+		t.Errorf("X position = %s, want %s (orig was %s)",
+			posn2, want, posn1)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bimport.go b/vendor/golang.org/x/tools/go/gcimporter15/bimport.go
new file mode 100644
index 0000000..1936a7f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bimport.go
@@ -0,0 +1,993 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/bimport.go.
+
+package gcimporter
+
+import (
+	"encoding/binary"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+)
+
+type importer struct {
+	imports    map[string]*types.Package
+	data       []byte
+	importpath string
+	buf        []byte // for reading strings
+	version    int    // export format version
+
+	// object lists
+	strList       []string           // in order of appearance
+	pathList      []string           // in order of appearance
+	pkgList       []*types.Package   // in order of appearance
+	typList       []types.Type       // in order of appearance
+	interfaceList []*types.Interface // for delayed completion only
+	trackAllTypes bool
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+	fset          *token.FileSet
+	files         map[string]*token.File
+
+	// debugging support
+	debugFormat bool
+	read        int // bytes read
+}
+
+// BImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func BImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+	// catch panics and return them as errors
+	defer func() {
+		if e := recover(); e != nil {
+			// The package (filename) causing the problem is added to this
+			// error by a wrapper in the caller (Import in gcimporter.go).
+			// Return a (possibly nil or incomplete) package unchanged (see #16088).
+			err = fmt.Errorf("cannot import, possibly version skew (%v) - reinstall package", e)
+		}
+	}()
+
+	p := importer{
+		imports:    imports,
+		data:       data,
+		importpath: path,
+		version:    -1,           // unknown version
+		strList:    []string{""}, // empty string is mapped to 0
+		pathList:   []string{""}, // empty string is mapped to 0
+		fset:       fset,
+		files:      make(map[string]*token.File),
+	}
+
+	// read version info
+	var versionstr string
+	if b := p.rawByte(); b == 'c' || b == 'd' {
+		// Go1.7 encoding; first byte encodes low-level
+		// encoding format (compact vs debug).
+		// For backward-compatibility only (avoid problems with
+		// old installed packages). Newly compiled packages use
+		// the extensible format string.
+		// TODO(gri) Remove this support eventually; after Go1.8.
+		if b == 'd' {
+			p.debugFormat = true
+		}
+		p.trackAllTypes = p.rawByte() == 'a'
+		p.posInfoFormat = p.int() != 0
+		versionstr = p.string()
+		if versionstr == "v1" {
+			p.version = 0
+		}
+	} else {
+		// Go1.8 extensible encoding
+		// read version string and extract version number (ignore anything after the version number)
+		versionstr = p.rawStringln(b)
+		if s := strings.SplitN(versionstr, " ", 3); len(s) >= 2 && s[0] == "version" {
+			if v, err := strconv.Atoi(s[1]); err == nil && v > 0 {
+				p.version = v
+			}
+		}
+	}
+
+	// read version specific flags - extend as necessary
+	switch p.version {
+	// case 6:
+	// 	...
+	//	fallthrough
+	case 5, 4, 3, 2, 1:
+		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
+		p.trackAllTypes = p.int() != 0
+		p.posInfoFormat = p.int() != 0
+	case 0:
+		// Go1.7 encoding format - nothing to do here
+	default:
+		errorf("unknown export format version %d (%q)", p.version, versionstr)
+	}
+
+	// --- generic export data ---
+
+	// populate typList with predeclared "known" types
+	p.typList = append(p.typList, predeclared...)
+
+	// read package data
+	pkg = p.pkg()
+
+	// read objects of phase 1 only (see cmd/compiler/internal/gc/bexport.go)
+	objcount := 0
+	for {
+		tag := p.tagOrIndex()
+		if tag == endTag {
+			break
+		}
+		p.obj(tag)
+		objcount++
+	}
+
+	// self-verification
+	if count := p.int(); count != objcount {
+		errorf("got %d objects; want %d", objcount, count)
+	}
+
+	// ignore compiler-specific import data
+
+	// complete interfaces
+	// TODO(gri) re-investigate if we still need to do this in a delayed fashion
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types.Package)(nil), p.pkgList[1:]...)
+	sort.Sort(byPath(list))
+	pkg.SetImports(list)
+
+	// package was imported completely and without errors
+	pkg.MarkComplete()
+
+	return p.read, pkg, nil
+}
+
+func errorf(format string, args ...interface{}) {
+	panic(fmt.Sprintf(format, args...))
+}
+
+func (p *importer) pkg() *types.Package {
+	// if the package was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.pkgList[i]
+	}
+
+	// otherwise, i is the package tag (< 0)
+	if i != packageTag {
+		errorf("unexpected package tag %d version %d", i, p.version)
+	}
+
+	// read package data
+	name := p.string()
+	var path string
+	if p.version >= 5 {
+		path = p.path()
+	} else {
+		path = p.string()
+	}
+
+	// we should never see an empty package name
+	if name == "" {
+		errorf("empty package name in import")
+	}
+
+	// an empty path denotes the package we are currently importing;
+	// it must be the first package we see
+	if (path == "") != (len(p.pkgList) == 0) {
+		errorf("package path %q for pkg index %d", path, len(p.pkgList))
+	}
+
+	// if the package was imported before, use that one; otherwise create a new one
+	if path == "" {
+		path = p.importpath
+	}
+	pkg := p.imports[path]
+	if pkg == nil {
+		pkg = types.NewPackage(path, name)
+		p.imports[path] = pkg
+	} else if pkg.Name() != name {
+		errorf("conflicting names %s and %s for package %q", pkg.Name(), name, path)
+	}
+	p.pkgList = append(p.pkgList, pkg)
+
+	return pkg
+}
+
+// objTag returns the tag value for each object kind.
+func objTag(obj types.Object) int {
+	switch obj.(type) {
+	case *types.Const:
+		return constTag
+	case *types.TypeName:
+		return typeTag
+	case *types.Var:
+		return varTag
+	case *types.Func:
+		return funcTag
+	default:
+		errorf("unexpected object: %v (%T)", obj, obj) // panics
+		panic("unreachable")
+	}
+}
+
+func sameObj(a, b types.Object) bool {
+	// Because unnamed types are not canonicalized, we cannot simply compare types for
+	// (pointer) identity.
+	// Ideally we'd check equality of constant values as well, but this is good enough.
+	return objTag(a) == objTag(b) && types.Identical(a.Type(), b.Type())
+}
+
+func (p *importer) declare(obj types.Object) {
+	pkg := obj.Pkg()
+	if alt := pkg.Scope().Insert(obj); alt != nil {
+		// This can only trigger if we import a (non-type) object a second time.
+		// Excluding type aliases, this cannot happen because 1) we only import a package
+		// once; and b) we ignore compiler-specific export data which may contain
+		// functions whose inlined function bodies refer to other functions that
+		// were already imported.
+		// However, type aliases require reexporting the original type, so we need
+		// to allow it (see also the comment in cmd/compile/internal/gc/bimport.go,
+		// method importer.obj, switch case importing functions).
+		// TODO(gri) review/update this comment once the gc compiler handles type aliases.
+		if !sameObj(obj, alt) {
+			errorf("inconsistent import:\n\t%v\npreviously imported as:\n\t%v\n", obj, alt)
+		}
+	}
+}
+
+func (p *importer) obj(tag int) {
+	switch tag {
+	case constTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		val := p.value()
+		p.declare(types.NewConst(pos, pkg, name, typ, val))
+
+	case aliasTag:
+		// TODO(gri) verify type alias hookup is correct
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		p.declare(types.NewTypeName(pos, pkg, name, typ))
+
+	case typeTag:
+		p.typ(nil)
+
+	case varTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		p.declare(types.NewVar(pos, pkg, name, typ))
+
+	case funcTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		sig := types.NewSignature(nil, params, result, isddd)
+		p.declare(types.NewFunc(pos, pkg, name, sig))
+
+	default:
+		errorf("unexpected object tag %d", tag)
+	}
+}
+
+const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
+
+func (p *importer) pos() token.Pos {
+	if !p.posInfoFormat {
+		return token.NoPos
+	}
+
+	file := p.prevFile
+	line := p.prevLine
+	delta := p.int()
+	line += delta
+	if p.version >= 5 {
+		if delta == deltaNewFile {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.path()
+				line = n
+			}
+		}
+	} else {
+		if delta == 0 {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.prevFile[:n] + p.string()
+				line = p.int()
+			}
+		}
+	}
+	p.prevFile = file
+	p.prevLine = line
+
+	// Synthesize a token.Pos
+
+	// Since we don't know the set of needed file positions, we
+	// reserve maxlines positions per file.
+	const maxlines = 64 * 1024
+	f := p.files[file]
+	if f == nil {
+		f = p.fset.AddFile(file, -1, maxlines)
+		p.files[file] = f
+		// Allocate the fake linebreak indices on first use.
+		// TODO(adonovan): opt: save ~512KB using a more complex scheme?
+		fakeLinesOnce.Do(func() {
+			fakeLines = make([]int, maxlines)
+			for i := range fakeLines {
+				fakeLines[i] = i
+			}
+		})
+		f.SetLines(fakeLines)
+	}
+
+	if line > maxlines {
+		line = 1
+	}
+
+	// Treat the file as if it contained only newlines
+	// and column=1: use the line number as the offset.
+	return f.Pos(line - 1)
+}
+
+var (
+	fakeLines     []int
+	fakeLinesOnce sync.Once
+)
+
+func (p *importer) qualifiedName() (pkg *types.Package, name string) {
+	name = p.string()
+	pkg = p.pkg()
+	return
+}
+
+func (p *importer) record(t types.Type) {
+	p.typList = append(p.typList, t)
+}
+
+// A dddSlice is a types.Type representing ...T parameters.
+// It only appears for parameter types and does not escape
+// the importer.
+type dddSlice struct {
+	elem types.Type
+}
+
+func (t *dddSlice) Underlying() types.Type { return t }
+func (t *dddSlice) String() string         { return "..." + t.elem.String() }
+
+// parent is the package which declared the type; parent == nil means
+// the package currently imported. The parent package is needed for
+// exported struct fields and interface methods which don't contain
+// explicit package information in the export data.
+func (p *importer) typ(parent *types.Package) types.Type {
+	// if the type was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.typList[i]
+	}
+
+	// otherwise, i is the type tag (< 0)
+	switch i {
+	case namedTag:
+		// read type object
+		pos := p.pos()
+		parent, name := p.qualifiedName()
+		scope := parent.Scope()
+		obj := scope.Lookup(name)
+
+		// if the object doesn't exist yet, create and insert it
+		if obj == nil {
+			obj = types.NewTypeName(pos, parent, name, nil)
+			scope.Insert(obj)
+		}
+
+		if _, ok := obj.(*types.TypeName); !ok {
+			errorf("pkg = %s, name = %s => %s", parent, name, obj)
+		}
+
+		// associate new named type with obj if it doesn't exist yet
+		t0 := types.NewNamed(obj.(*types.TypeName), nil, nil)
+
+		// but record the existing type, if any
+		t := obj.Type().(*types.Named)
+		p.record(t)
+
+		// read underlying type
+		t0.SetUnderlying(p.typ(parent))
+
+		// interfaces don't have associated methods
+		if types.IsInterface(t0) {
+			return t
+		}
+
+		// read associated methods
+		for i := p.int(); i > 0; i-- {
+			// TODO(gri) replace this with something closer to fieldName
+			pos := p.pos()
+			name := p.string()
+			if !exported(name) {
+				p.pkg()
+			}
+
+			recv, _ := p.paramList() // TODO(gri) do we need a full param list for the receiver?
+			params, isddd := p.paramList()
+			result, _ := p.paramList()
+			p.int() // go:nointerface pragma - discarded
+
+			sig := types.NewSignature(recv.At(0), params, result, isddd)
+			t0.AddMethod(types.NewFunc(pos, parent, name, sig))
+		}
+
+		return t
+
+	case arrayTag:
+		t := new(types.Array)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		n := p.int64()
+		*t = *types.NewArray(p.typ(parent), n)
+		return t
+
+	case sliceTag:
+		t := new(types.Slice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewSlice(p.typ(parent))
+		return t
+
+	case dddTag:
+		t := new(dddSlice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		t.elem = p.typ(parent)
+		return t
+
+	case structTag:
+		t := new(types.Struct)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewStruct(p.fieldList(parent))
+		return t
+
+	case pointerTag:
+		t := new(types.Pointer)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewPointer(p.typ(parent))
+		return t
+
+	case signatureTag:
+		t := new(types.Signature)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		*t = *types.NewSignature(nil, params, result, isddd)
+		return t
+
+	case interfaceTag:
+		// Create a dummy entry in the type list. This is safe because we
+		// cannot expect the interface type to appear in a cycle, as any
+		// such cycle must contain a named type which would have been
+		// first defined earlier.
+		n := len(p.typList)
+		if p.trackAllTypes {
+			p.record(nil)
+		}
+
+		var embeddeds []*types.Named
+		for n := p.int(); n > 0; n-- {
+			p.pos()
+			embeddeds = append(embeddeds, p.typ(parent).(*types.Named))
+		}
+
+		t := types.NewInterface(p.methodList(parent), embeddeds)
+		p.interfaceList = append(p.interfaceList, t)
+		if p.trackAllTypes {
+			p.typList[n] = t
+		}
+		return t
+
+	case mapTag:
+		t := new(types.Map)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		key := p.typ(parent)
+		val := p.typ(parent)
+		*t = *types.NewMap(key, val)
+		return t
+
+	case chanTag:
+		t := new(types.Chan)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		var dir types.ChanDir
+		// tag values must match the constants in cmd/compile/internal/gc/go.go
+		switch d := p.int(); d {
+		case 1 /* Crecv */ :
+			dir = types.RecvOnly
+		case 2 /* Csend */ :
+			dir = types.SendOnly
+		case 3 /* Cboth */ :
+			dir = types.SendRecv
+		default:
+			errorf("unexpected channel dir %d", d)
+		}
+		val := p.typ(parent)
+		*t = *types.NewChan(dir, val)
+		return t
+
+	default:
+		errorf("unexpected type tag %d", i) // panics
+		panic("unreachable")
+	}
+}
+
+func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {
+	if n := p.int(); n > 0 {
+		fields = make([]*types.Var, n)
+		tags = make([]string, n)
+		for i := range fields {
+			fields[i], tags[i] = p.field(parent)
+		}
+	}
+	return
+}
+
+func (p *importer) field(parent *types.Package) (*types.Var, string) {
+	pos := p.pos()
+	pkg, name, alias := p.fieldName(parent)
+	typ := p.typ(parent)
+	tag := p.string()
+
+	anonymous := false
+	if name == "" {
+		// anonymous field - typ must be T or *T and T must be a type name
+		switch typ := deref(typ).(type) {
+		case *types.Basic: // basic types are named types
+			pkg = nil // // objects defined in Universe scope have no package
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			errorf("named base type expected")
+		}
+		anonymous = true
+	} else if alias {
+		// anonymous field: we have an explicit name because it's an alias
+		anonymous = true
+	}
+
+	return types.NewField(pos, pkg, name, typ, anonymous), tag
+}
+
+func (p *importer) methodList(parent *types.Package) (methods []*types.Func) {
+	if n := p.int(); n > 0 {
+		methods = make([]*types.Func, n)
+		for i := range methods {
+			methods[i] = p.method(parent)
+		}
+	}
+	return
+}
+
+func (p *importer) method(parent *types.Package) *types.Func {
+	pos := p.pos()
+	pkg, name, _ := p.fieldName(parent)
+	params, isddd := p.paramList()
+	result, _ := p.paramList()
+	sig := types.NewSignature(nil, params, result, isddd)
+	return types.NewFunc(pos, pkg, name, sig)
+}
+
+func (p *importer) fieldName(parent *types.Package) (pkg *types.Package, name string, alias bool) {
+	name = p.string()
+	pkg = parent
+	if pkg == nil {
+		// use the imported package instead
+		pkg = p.pkgList[0]
+	}
+	if p.version == 0 && name == "_" {
+		// version 0 didn't export a package for _ fields
+		return
+	}
+	switch name {
+	case "":
+		// 1) field name matches base type name and is exported: nothing to do
+	case "?":
+		// 2) field name matches base type name and is not exported: need package
+		name = ""
+		pkg = p.pkg()
+	case "@":
+		// 3) field name doesn't match type name (alias)
+		name = p.string()
+		alias = true
+		fallthrough
+	default:
+		if !exported(name) {
+			pkg = p.pkg()
+		}
+	}
+	return
+}
+
+func (p *importer) paramList() (*types.Tuple, bool) {
+	n := p.int()
+	if n == 0 {
+		return nil, false
+	}
+	// negative length indicates unnamed parameters
+	named := true
+	if n < 0 {
+		n = -n
+		named = false
+	}
+	// n > 0
+	params := make([]*types.Var, n)
+	isddd := false
+	for i := range params {
+		params[i], isddd = p.param(named)
+	}
+	return types.NewTuple(params...), isddd
+}
+
+func (p *importer) param(named bool) (*types.Var, bool) {
+	t := p.typ(nil)
+	td, isddd := t.(*dddSlice)
+	if isddd {
+		t = types.NewSlice(td.elem)
+	}
+
+	var pkg *types.Package
+	var name string
+	if named {
+		name = p.string()
+		if name == "" {
+			errorf("expected named parameter")
+		}
+		if name != "_" {
+			pkg = p.pkg()
+		}
+		if i := strings.Index(name, "·"); i > 0 {
+			name = name[:i] // cut off gc-specific parameter numbering
+		}
+	}
+
+	// read and discard compiler-specific info
+	p.string()
+
+	return types.NewVar(token.NoPos, pkg, name, t), isddd
+}
+
+func exported(name string) bool {
+	ch, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(ch)
+}
+
+func (p *importer) value() constant.Value {
+	switch tag := p.tagOrIndex(); tag {
+	case falseTag:
+		return constant.MakeBool(false)
+	case trueTag:
+		return constant.MakeBool(true)
+	case int64Tag:
+		return constant.MakeInt64(p.int64())
+	case floatTag:
+		return p.float()
+	case complexTag:
+		re := p.float()
+		im := p.float()
+		return constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+	case stringTag:
+		return constant.MakeString(p.string())
+	case unknownTag:
+		return constant.MakeUnknown()
+	default:
+		errorf("unexpected value tag %d", tag) // panics
+		panic("unreachable")
+	}
+}
+
+func (p *importer) float() constant.Value {
+	sign := p.int()
+	if sign == 0 {
+		return constant.MakeInt64(0)
+	}
+
+	exp := p.int()
+	mant := []byte(p.string()) // big endian
+
+	// remove leading 0's if any
+	for len(mant) > 0 && mant[0] == 0 {
+		mant = mant[1:]
+	}
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(mant)-1; i < j; i, j = i+1, j-1 {
+		mant[i], mant[j] = mant[j], mant[i]
+	}
+
+	// adjust exponent (constant.MakeFromBytes creates an integer value,
+	// but mant represents the mantissa bits such that 0.5 <= mant < 1.0)
+	exp -= len(mant) << 3
+	if len(mant) > 0 {
+		for msd := mant[len(mant)-1]; msd&0x80 == 0; msd <<= 1 {
+			exp++
+		}
+	}
+
+	x := constant.MakeFromBytes(mant)
+	switch {
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	}
+
+	if sign < 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+// ----------------------------------------------------------------------------
+// Low-level decoders
+
+func (p *importer) tagOrIndex() int {
+	if p.debugFormat {
+		p.marker('t')
+	}
+
+	return int(p.rawInt64())
+}
+
+func (p *importer) int() int {
+	x := p.int64()
+	if int64(int(x)) != x {
+		errorf("exported integer too large")
+	}
+	return int(x)
+}
+
+func (p *importer) int64() int64 {
+	if p.debugFormat {
+		p.marker('i')
+	}
+
+	return p.rawInt64()
+}
+
+func (p *importer) path() string {
+	if p.debugFormat {
+		p.marker('p')
+	}
+	// if the path was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.pathList[i]
+	}
+	// otherwise, i is the negative path length (< 0)
+	a := make([]string, -i)
+	for n := range a {
+		a[n] = p.string()
+	}
+	s := strings.Join(a, "/")
+	p.pathList = append(p.pathList, s)
+	return s
+}
+
+func (p *importer) string() string {
+	if p.debugFormat {
+		p.marker('s')
+	}
+	// if the string was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.strList[i]
+	}
+	// otherwise, i is the negative string length (< 0)
+	if n := int(-i); n <= cap(p.buf) {
+		p.buf = p.buf[:n]
+	} else {
+		p.buf = make([]byte, n)
+	}
+	for i := range p.buf {
+		p.buf[i] = p.rawByte()
+	}
+	s := string(p.buf)
+	p.strList = append(p.strList, s)
+	return s
+}
+
+func (p *importer) marker(want byte) {
+	if got := p.rawByte(); got != want {
+		errorf("incorrect marker: got %c; want %c (pos = %d)", got, want, p.read)
+	}
+
+	pos := p.read
+	if n := int(p.rawInt64()); n != pos {
+		errorf("incorrect position: got %d; want %d", n, pos)
+	}
+}
+
+// rawInt64 should only be used by low-level decoders.
+func (p *importer) rawInt64() int64 {
+	i, err := binary.ReadVarint(p)
+	if err != nil {
+		errorf("read error: %v", err)
+	}
+	return i
+}
+
+// rawStringln should only be used to read the initial version string.
+func (p *importer) rawStringln(b byte) string {
+	p.buf = p.buf[:0]
+	for b != '\n' {
+		p.buf = append(p.buf, b)
+		b = p.rawByte()
+	}
+	return string(p.buf)
+}
+
+// needed for binary.ReadVarint in rawInt64
+func (p *importer) ReadByte() (byte, error) {
+	return p.rawByte(), nil
+}
+
+// byte is the bottleneck interface for reading p.data.
+// It unescapes '|' 'S' to '$' and '|' '|' to '|'.
+// rawByte should only be used by low-level decoders.
+func (p *importer) rawByte() byte {
+	b := p.data[0]
+	r := 1
+	if b == '|' {
+		b = p.data[1]
+		r = 2
+		switch b {
+		case 'S':
+			b = '$'
+		case '|':
+			// nothing to do
+		default:
+			errorf("unexpected escape sequence in export data")
+		}
+	}
+	p.data = p.data[r:]
+	p.read += r
+	return b
+
+}
+
+// ----------------------------------------------------------------------------
+// Export format
+
+// Tags. Must be < 0.
+const (
+	// Objects
+	packageTag = -(iota + 1)
+	constTag
+	typeTag
+	varTag
+	funcTag
+	endTag
+
+	// Types
+	namedTag
+	arrayTag
+	sliceTag
+	dddTag
+	structTag
+	pointerTag
+	signatureTag
+	interfaceTag
+	mapTag
+	chanTag
+
+	// Values
+	falseTag
+	trueTag
+	int64Tag
+	floatTag
+	fractionTag // not used by gc
+	complexTag
+	stringTag
+	nilTag     // only used by gc (appears in exported inlined function bodies)
+	unknownTag // not used by gc (only appears in packages with errors)
+
+	// Type aliases
+	aliasTag
+)
+
+var predeclared = []types.Type{
+	// basic types
+	types.Typ[types.Bool],
+	types.Typ[types.Int],
+	types.Typ[types.Int8],
+	types.Typ[types.Int16],
+	types.Typ[types.Int32],
+	types.Typ[types.Int64],
+	types.Typ[types.Uint],
+	types.Typ[types.Uint8],
+	types.Typ[types.Uint16],
+	types.Typ[types.Uint32],
+	types.Typ[types.Uint64],
+	types.Typ[types.Uintptr],
+	types.Typ[types.Float32],
+	types.Typ[types.Float64],
+	types.Typ[types.Complex64],
+	types.Typ[types.Complex128],
+	types.Typ[types.String],
+
+	// basic type aliases
+	types.Universe.Lookup("byte").Type(),
+	types.Universe.Lookup("rune").Type(),
+
+	// error
+	types.Universe.Lookup("error").Type(),
+
+	// untyped types
+	types.Typ[types.UntypedBool],
+	types.Typ[types.UntypedInt],
+	types.Typ[types.UntypedRune],
+	types.Typ[types.UntypedFloat],
+	types.Typ[types.UntypedComplex],
+	types.Typ[types.UntypedString],
+	types.Typ[types.UntypedNil],
+
+	// package unsafe
+	types.Typ[types.UnsafePointer],
+
+	// invalid type
+	types.Typ[types.Invalid], // only appears in packages with errors
+
+	// used internally by gc; never used by this package or in .a files
+	anyType{},
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types.Type { return t }
+func (t anyType) String() string         { return "any" }
diff --git a/vendor/golang.org/x/tools/go/gcimporter/exportdata.go b/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
similarity index 67%
rename from vendor/golang.org/x/tools/go/gcimporter/exportdata.go
rename to vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
index 657742b..f33dc56 100644
--- a/vendor/golang.org/x/tools/go/gcimporter/exportdata.go
+++ b/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
@@ -2,13 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/exportdata.go.
+
 // This file implements FindExportData.
 
 package gcimporter
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"io"
 	"strconv"
@@ -29,7 +30,7 @@ func readGopackHeader(r *bufio.Reader) (name string, size int, err error) {
 	s := strings.TrimSpace(string(hdr[16+12+6+6+8:][:10]))
 	size, err = strconv.Atoi(s)
 	if err != nil || hdr[len(hdr)-2] != '`' || hdr[len(hdr)-1] != '\n' {
-		err = errors.New("invalid archive header")
+		err = fmt.Errorf("invalid archive header")
 		return
 	}
 	name = strings.TrimSpace(string(hdr[:16]))
@@ -39,52 +40,34 @@ func readGopackHeader(r *bufio.Reader) (name string, size int, err error) {
 // FindExportData positions the reader r at the beginning of the
 // export data section of an underlying GC-created object/archive
 // file by reading from it. The reader must be positioned at the
-// start of the file before calling this function.
+// start of the file before calling this function. The hdr result
+// is the string before the export data, either "$$" or "$$B".
 //
-func FindExportData(r *bufio.Reader) (err error) {
+func FindExportData(r *bufio.Reader) (hdr string, err error) {
 	// Read first line to make sure this is an object file.
 	line, err := r.ReadSlice('\n')
 	if err != nil {
+		err = fmt.Errorf("can't find export data (%v)", err)
 		return
 	}
+
 	if string(line) == "!<arch>\n" {
 		// Archive file. Scan to __.PKGDEF.
 		var name string
-		var size int
-		if name, size, err = readGopackHeader(r); err != nil {
+		if name, _, err = readGopackHeader(r); err != nil {
 			return
 		}
 
-		// Optional leading __.GOSYMDEF or __.SYMDEF.
-		// Read and discard.
-		if name == "__.SYMDEF" || name == "__.GOSYMDEF" {
-			const block = 4096
-			tmp := make([]byte, block)
-			for size > 0 {
-				n := size
-				if n > block {
-					n = block
-				}
-				if _, err = io.ReadFull(r, tmp[:n]); err != nil {
-					return
-				}
-				size -= n
-			}
-
-			if name, size, err = readGopackHeader(r); err != nil {
-				return
-			}
-		}
-
-		// First real entry should be __.PKGDEF.
+		// First entry should be __.PKGDEF.
 		if name != "__.PKGDEF" {
-			err = errors.New("go archive is missing __.PKGDEF")
+			err = fmt.Errorf("go archive is missing __.PKGDEF")
 			return
 		}
 
 		// Read first line of __.PKGDEF data, so that line
 		// is once again the first line of the input.
 		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
 			return
 		}
 	}
@@ -92,17 +75,19 @@ func FindExportData(r *bufio.Reader) (err error) {
 	// Now at __.PKGDEF in archive or still at beginning of file.
 	// Either way, line should begin with "go object ".
 	if !strings.HasPrefix(string(line), "go object ") {
-		err = errors.New("not a go object file")
+		err = fmt.Errorf("not a Go object file")
 		return
 	}
 
 	// Skip over object header to export data.
-	// Begins after first line with $$.
+	// Begins after first line starting with $$.
 	for line[0] != '$' {
 		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
 			return
 		}
 	}
+	hdr = string(line)
 
 	return
 }
diff --git a/vendor/golang.org/x/tools/go/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
similarity index 79%
rename from vendor/golang.org/x/tools/go/gcimporter/gcimporter.go
rename to vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
index 031e870..6fbc9d7 100644
--- a/vendor/golang.org/x/tools/go/gcimporter/gcimporter.go
+++ b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
@@ -2,58 +2,67 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package gcimporter implements Import for gc-generated object files.
-// Importing this package installs Import as go/types.DefaultImport.
-package gcimporter // import "golang.org/x/tools/go/gcimporter"
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/gcimporter.go,
+// but it also contains the original source-based importer code for Go1.6.
+// Once we stop supporting 1.6, we can remove that code.
+
+// Package gcimporter15 provides various functions for reading
+// gc-generated object files that can be used to implement the
+// Importer interface defined by the Go 1.5 standard library package.
+//
+// Deprecated: this package will be deleted in October 2017.
+// New code should use golang.org/x/tools/go/gcexportdata.
+//
+package gcimporter // import "golang.org/x/tools/go/gcimporter15"
 
 import (
 	"bufio"
 	"errors"
 	"fmt"
 	"go/build"
+	exact "go/constant"
 	"go/token"
+	"go/types"
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
 	"text/scanner"
-
-	"golang.org/x/tools/go/exact"
-	"golang.org/x/tools/go/types"
 )
 
 // debugging/development support
 const debug = false
 
-func init() {
-	types.DefaultImport = Import
-}
-
-var pkgExts = [...]string{".a", ".5", ".6", ".7", ".8", ".9"}
+var pkgExts = [...]string{".a", ".o"}
 
 // FindPkg returns the filename and unique package id for an import
 // path based on package information provided by build.Import (using
-// the build.Default build.Context).
+// the build.Default build.Context). A relative srcDir is interpreted
+// relative to the current working directory.
 // If no file was found, an empty filename is returned.
 //
 func FindPkg(path, srcDir string) (filename, id string) {
-	if len(path) == 0 {
+	if path == "" {
 		return
 	}
 
-	id = path
 	var noext string
 	switch {
 	default:
 		// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
 		// Don't require the source files to be present.
+		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
+			srcDir = abs
+		}
 		bp, _ := build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
 		if bp.PkgObj == "" {
 			return
 		}
 		noext = strings.TrimSuffix(bp.PkgObj, ".a")
+		id = bp.ImportPath
 
 	case build.IsLocalImport(path):
 		// "./x" -> "/this/directory/x.ext", "/this/directory/x"
@@ -65,6 +74,13 @@ func FindPkg(path, srcDir string) (filename, id string) {
 		// does not support absolute imports
 		// "/x" -> "/x.ext", "/x"
 		noext = path
+		id = path
+	}
+
+	if false { // for debugging
+		if path != id {
+			fmt.Printf("%s -> %s\n", path, id)
+		}
 	}
 
 	// try extensions
@@ -111,26 +127,16 @@ func ImportData(packages map[string]*types.Package, filename, id string, data io
 	return
 }
 
-// Import imports a gc-generated package given its import path, adds the
-// corresponding package object to the packages map, and returns the object.
-// Local import paths are interpreted relative to the current working directory.
-// The packages map must contains all packages already imported.
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
+// The packages map must contain all packages already imported.
 //
-func Import(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
-	if path == "unsafe" {
-		return types.Unsafe, nil
-	}
-
-	srcDir := "."
-	if build.IsLocalImport(path) {
-		srcDir, err = os.Getwd()
-		if err != nil {
-			return
-		}
-	}
-
+func Import(packages map[string]*types.Package, path, srcDir string) (pkg *types.Package, err error) {
 	filename, id := FindPkg(path, srcDir)
 	if filename == "" {
+		if path == "unsafe" {
+			return types.Unsafe, nil
+		}
 		err = fmt.Errorf("can't find import: %s", id)
 		return
 	}
@@ -153,12 +159,26 @@ func Import(packages map[string]*types.Package, path string) (pkg *types.Package
 		}
 	}()
 
+	var hdr string
 	buf := bufio.NewReader(f)
-	if err = FindExportData(buf); err != nil {
+	if hdr, err = FindExportData(buf); err != nil {
 		return
 	}
 
-	pkg, err = ImportData(packages, filename, id, buf)
+	switch hdr {
+	case "$$\n":
+		return ImportData(packages, filename, id, buf)
+	case "$$B\n":
+		var data []byte
+		data, err = ioutil.ReadAll(buf)
+		if err == nil {
+			fset := token.NewFileSet()
+			_, pkg, err = BImportData(fset, packages, data, id)
+			return
+		}
+	default:
+		err = fmt.Errorf("unknown export data header: %q", hdr)
+	}
 
 	return
 }
@@ -339,8 +359,10 @@ func (p *parser) parseQualifiedName() (id, name string) {
 }
 
 // getPkg returns the package for a given id. If the package is
-// not found but we have a package name, create the package and
-// add it to the p.localPkgs and p.sharedPkgs maps.
+// not found, create the package and add it to the p.localPkgs
+// and p.sharedPkgs maps. name is the (expected) name of the
+// package. If name == "", the package name is expected to be
+// set later via an import clause in the export data.
 //
 // id identifies a package, usually by a canonical package path like
 // "encoding/json" but possibly by a non-canonical import path like
@@ -353,19 +375,28 @@ func (p *parser) getPkg(id, name string) *types.Package {
 	}
 
 	pkg := p.localPkgs[id]
-	if pkg == nil && name != "" {
+	if pkg == nil {
 		// first import of id from this package
 		pkg = p.sharedPkgs[id]
 		if pkg == nil {
-			// first import of id by this importer
+			// first import of id by this importer;
+			// add (possibly unnamed) pkg to shared packages
 			pkg = types.NewPackage(id, name)
 			p.sharedPkgs[id] = pkg
 		}
-
+		// add (possibly unnamed) pkg to local packages
 		if p.localPkgs == nil {
 			p.localPkgs = make(map[string]*types.Package)
 		}
 		p.localPkgs[id] = pkg
+	} else if name != "" {
+		// package exists already and we have an expected package name;
+		// make sure names match or set package name if necessary
+		if pname := pkg.Name(); pname == "" {
+			pkg.SetName(name)
+		} else if pname != name {
+			p.errorf("%s package name mismatch: %s (given) vs %s (expected)", id, pname, name)
+		}
 	}
 	return pkg
 }
@@ -376,9 +407,6 @@ func (p *parser) getPkg(id, name string) *types.Package {
 func (p *parser) parseExportedName() (pkg *types.Package, name string) {
 	id, name := p.parseQualifiedName()
 	pkg = p.getPkg(id, "")
-	if pkg == nil {
-		p.errorf("%s package not found", id)
-	}
 	return
 }
 
@@ -399,11 +427,11 @@ func (p *parser) parseBasicType() types.Type {
 
 // ArrayType = "[" int_lit "]" Type .
 //
-func (p *parser) parseArrayType() types.Type {
+func (p *parser) parseArrayType(parent *types.Package) types.Type {
 	// "[" already consumed and lookahead known not to be "]"
 	lit := p.expect(scanner.Int)
 	p.expect(']')
-	elem := p.parseType()
+	elem := p.parseType(parent)
 	n, err := strconv.ParseInt(lit, 10, 64)
 	if err != nil {
 		p.error(err)
@@ -413,46 +441,47 @@ func (p *parser) parseArrayType() types.Type {
 
 // MapType = "map" "[" Type "]" Type .
 //
-func (p *parser) parseMapType() types.Type {
+func (p *parser) parseMapType(parent *types.Package) types.Type {
 	p.expectKeyword("map")
 	p.expect('[')
-	key := p.parseType()
+	key := p.parseType(parent)
 	p.expect(']')
-	elem := p.parseType()
+	elem := p.parseType(parent)
 	return types.NewMap(key, elem)
 }
 
 // Name = identifier | "?" | QualifiedName .
 //
-// If materializePkg is set, the returned package is guaranteed to be set.
-// For fully qualified names, the returned package may be a fake package
-// (without name, scope, and not in the p.imports map), created for the
-// sole purpose of providing a package path. Fake packages are created
-// when the package id is not found in the p.imports map; in that case
-// we cannot create a real package because we don't have a package name.
-// For non-qualified names, the returned package is the imported package.
+// For unqualified and anonymous names, the returned package is the parent
+// package unless parent == nil, in which case the returned package is the
+// package being imported. (The parent package is not nil if the the name
+// is an unqualified struct field or interface method name belonging to a
+// type declared in another package.)
 //
-func (p *parser) parseName(materializePkg bool) (pkg *types.Package, name string) {
+// For qualified names, the returned package is nil (and not created if
+// it doesn't exist yet) unless materializePkg is set (which creates an
+// unnamed package with valid package path). In the latter case, a
+// subsequent import clause is expected to provide a name for the package.
+//
+func (p *parser) parseName(parent *types.Package, materializePkg bool) (pkg *types.Package, name string) {
+	pkg = parent
+	if pkg == nil {
+		pkg = p.sharedPkgs[p.id]
+	}
 	switch p.tok {
 	case scanner.Ident:
-		pkg = p.sharedPkgs[p.id]
 		name = p.lit
 		p.next()
 	case '?':
 		// anonymous
-		pkg = p.sharedPkgs[p.id]
 		p.next()
 	case '@':
 		// exported name prefixed with package path
+		pkg = nil
 		var id string
 		id, name = p.parseQualifiedName()
 		if materializePkg {
-			// we don't have a package name - if the package
-			// doesn't exist yet, create a fake package instead
 			pkg = p.getPkg(id, "")
-			if pkg == nil {
-				pkg = types.NewPackage(id, "")
-			}
 		}
 	default:
 		p.error("name expected")
@@ -469,15 +498,28 @@ func deref(typ types.Type) types.Type {
 
 // Field = Name Type [ string_lit ] .
 //
-func (p *parser) parseField() (*types.Var, string) {
-	pkg, name := p.parseName(true)
-	typ := p.parseType()
+func (p *parser) parseField(parent *types.Package) (*types.Var, string) {
+	pkg, name := p.parseName(parent, true)
+
+	if name == "_" {
+		// Blank fields should be package-qualified because they
+		// are unexported identifiers, but gc does not qualify them.
+		// Assuming that the ident belongs to the current package
+		// causes types to change during re-exporting, leading
+		// to spurious "can't assign A to B" errors from go/types.
+		// As a workaround, pretend all blank fields belong
+		// to the same unique dummy package.
+		const blankpkg = "<_>"
+		pkg = p.getPkg(blankpkg, blankpkg)
+	}
+
+	typ := p.parseType(parent)
 	anonymous := false
 	if name == "" {
 		// anonymous field - typ must be T or *T and T must be a type name
 		switch typ := deref(typ).(type) {
 		case *types.Basic: // basic types are named types
-			pkg = nil
+			pkg = nil // objects defined in Universe scope have no package
 			name = typ.Name()
 		case *types.Named:
 			name = typ.Obj().Name()
@@ -501,7 +543,7 @@ func (p *parser) parseField() (*types.Var, string) {
 // StructType = "struct" "{" [ FieldList ] "}" .
 // FieldList  = Field { ";" Field } .
 //
-func (p *parser) parseStructType() types.Type {
+func (p *parser) parseStructType(parent *types.Package) types.Type {
 	var fields []*types.Var
 	var tags []string
 
@@ -511,7 +553,7 @@ func (p *parser) parseStructType() types.Type {
 		if i > 0 {
 			p.expect(';')
 		}
-		fld, tag := p.parseField()
+		fld, tag := p.parseField(parent)
 		if tag != "" && tags == nil {
 			tags = make([]string, i)
 		}
@@ -528,7 +570,7 @@ func (p *parser) parseStructType() types.Type {
 // Parameter = ( identifier | "?" ) [ "..." ] Type [ string_lit ] .
 //
 func (p *parser) parseParameter() (par *types.Var, isVariadic bool) {
-	_, name := p.parseName(false)
+	_, name := p.parseName(nil, false)
 	// remove gc-specific parameter numbering
 	if i := strings.Index(name, "·"); i >= 0 {
 		name = name[:i]
@@ -537,7 +579,7 @@ func (p *parser) parseParameter() (par *types.Var, isVariadic bool) {
 		p.expectSpecial("...")
 		isVariadic = true
 	}
-	typ := p.parseType()
+	typ := p.parseType(nil)
 	if isVariadic {
 		typ = types.NewSlice(typ)
 	}
@@ -600,7 +642,7 @@ func (p *parser) parseSignature(recv *types.Var) *types.Signature {
 // by the compiler and thus embedded interfaces are never
 // visible in the export data.
 //
-func (p *parser) parseInterfaceType() types.Type {
+func (p *parser) parseInterfaceType(parent *types.Package) types.Type {
 	var methods []*types.Func
 
 	p.expectKeyword("interface")
@@ -609,7 +651,7 @@ func (p *parser) parseInterfaceType() types.Type {
 		if i > 0 {
 			p.expect(';')
 		}
-		pkg, name := p.parseName(true)
+		pkg, name := p.parseName(parent, true)
 		sig := p.parseSignature(nil)
 		methods = append(methods, types.NewFunc(token.NoPos, pkg, name, sig))
 	}
@@ -622,7 +664,7 @@ func (p *parser) parseInterfaceType() types.Type {
 
 // ChanType = ( "chan" [ "<-" ] | "<-" "chan" ) Type .
 //
-func (p *parser) parseChanType() types.Type {
+func (p *parser) parseChanType(parent *types.Package) types.Type {
 	dir := types.SendRecv
 	if p.tok == scanner.Ident {
 		p.expectKeyword("chan")
@@ -635,7 +677,7 @@ func (p *parser) parseChanType() types.Type {
 		p.expectKeyword("chan")
 		dir = types.RecvOnly
 	}
-	elem := p.parseType()
+	elem := p.parseType(parent)
 	return types.NewChan(dir, elem)
 }
 
@@ -650,24 +692,24 @@ func (p *parser) parseChanType() types.Type {
 // PointerType = "*" Type .
 // FuncType    = "func" Signature .
 //
-func (p *parser) parseType() types.Type {
+func (p *parser) parseType(parent *types.Package) types.Type {
 	switch p.tok {
 	case scanner.Ident:
 		switch p.lit {
 		default:
 			return p.parseBasicType()
 		case "struct":
-			return p.parseStructType()
+			return p.parseStructType(parent)
 		case "func":
 			// FuncType
 			p.next()
 			return p.parseSignature(nil)
 		case "interface":
-			return p.parseInterfaceType()
+			return p.parseInterfaceType(parent)
 		case "map":
-			return p.parseMapType()
+			return p.parseMapType(parent)
 		case "chan":
-			return p.parseChanType()
+			return p.parseChanType(parent)
 		}
 	case '@':
 		// TypeName
@@ -678,19 +720,19 @@ func (p *parser) parseType() types.Type {
 		if p.tok == ']' {
 			// SliceType
 			p.next()
-			return types.NewSlice(p.parseType())
+			return types.NewSlice(p.parseType(parent))
 		}
-		return p.parseArrayType()
+		return p.parseArrayType(parent)
 	case '*':
 		// PointerType
 		p.next()
-		return types.NewPointer(p.parseType())
+		return types.NewPointer(p.parseType(parent))
 	case '<':
-		return p.parseChanType()
+		return p.parseChanType(parent)
 	case '(':
 		// "(" Type ")"
 		p.next()
-		typ := p.parseType()
+		typ := p.parseType(parent)
 		p.expect(')')
 		return typ
 	}
@@ -727,7 +769,7 @@ func (p *parser) parseInt() string {
 //
 func (p *parser) parseNumber() (typ *types.Basic, val exact.Value) {
 	// mantissa
-	mant := exact.MakeFromLiteral(p.parseInt(), token.INT)
+	mant := exact.MakeFromLiteral(p.parseInt(), token.INT, 0)
 	if mant == nil {
 		panic("invalid mantissa")
 	}
@@ -772,7 +814,8 @@ func (p *parser) parseConstDecl() {
 
 	var typ0 types.Type
 	if p.tok != '=' {
-		typ0 = p.parseType()
+		// constant types are never structured - no need for parent type
+		typ0 = p.parseType(nil)
 	}
 
 	p.expect('=')
@@ -814,13 +857,13 @@ func (p *parser) parseConstDecl() {
 	case scanner.Char:
 		// rune_lit
 		typ = types.Typ[types.UntypedRune]
-		val = exact.MakeFromLiteral(p.lit, token.CHAR)
+		val = exact.MakeFromLiteral(p.lit, token.CHAR, 0)
 		p.next()
 
 	case scanner.String:
 		// string_lit
 		typ = types.Typ[types.UntypedString]
-		val = exact.MakeFromLiteral(p.lit, token.STRING)
+		val = exact.MakeFromLiteral(p.lit, token.STRING, 0)
 		p.next()
 
 	default:
@@ -846,7 +889,7 @@ func (p *parser) parseTypeDecl() {
 	// structure, but throw it away if the object already has a type.
 	// This ensures that all imports refer to the same type object for
 	// a given type declaration.
-	typ := p.parseType()
+	typ := p.parseType(pkg)
 
 	if name := obj.Type().(*types.Named); name.Underlying() == nil {
 		name.SetUnderlying(typ)
@@ -858,7 +901,7 @@ func (p *parser) parseTypeDecl() {
 func (p *parser) parseVarDecl() {
 	p.expectKeyword("var")
 	pkg, name := p.parseExportedName()
-	typ := p.parseType()
+	typ := p.parseType(pkg)
 	pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, name, typ))
 }
 
@@ -894,7 +937,7 @@ func (p *parser) parseMethodDecl() {
 	base := deref(recv.Type()).(*types.Named)
 
 	// parse method name, signature, and possibly inlined body
-	_, name := p.parseName(true)
+	_, name := p.parseName(nil, false)
 	sig := p.parseFunc(recv)
 
 	// methods always belong to the same package as the base type object
@@ -971,9 +1014,12 @@ func (p *parser) parseExport() *types.Package {
 		p.errorf("expected no scanner errors, got %d", n)
 	}
 
-	// Record all referenced packages as imports.
+	// Record all locally referenced packages as imports.
 	var imports []*types.Package
 	for id, pkg2 := range p.localPkgs {
+		if pkg2.Name() == "" {
+			p.errorf("%s package has no name", id)
+		}
 		if id == p.id {
 			continue // avoid self-edge
 		}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/gcimporter_test.go b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter_test.go
new file mode 100644
index 0000000..56cdfc0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter_test.go
@@ -0,0 +1,521 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/gcimporter_test.go,
+// adjusted to make it build with code from (std lib) internal/testenv copied.
+
+package gcimporter
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// ----------------------------------------------------------------------------
+// The following three functions (Builder, HasGoBuild, MustHaveGoBuild) were
+// copied from $GOROOT/src/internal/testenv since that package is not available
+// in x/tools.
+
+// Builder reports the name of the builder running this test
+// (for example, "linux-amd64" or "windows-386-gce").
+// If the test is not running on the build infrastructure,
+// Builder returns the empty string.
+func Builder() string {
+	return os.Getenv("GO_BUILDER_NAME")
+}
+
+// HasGoBuild reports whether the current system can build programs with ``go build''
+// and then run them with os.StartProcess or exec.Command.
+func HasGoBuild() bool {
+	switch runtime.GOOS {
+	case "android", "nacl":
+		return false
+	case "darwin":
+		if strings.HasPrefix(runtime.GOARCH, "arm") {
+			return false
+		}
+	}
+	return true
+}
+
+// MustHaveGoBuild checks that the current system can build programs with ``go build''
+// and then run them with os.StartProcess or exec.Command.
+// If not, MustHaveGoBuild calls t.Skip with an explanation.
+func MustHaveGoBuild(t *testing.T) {
+	if !HasGoBuild() {
+		t.Skipf("skipping test: 'go build' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+// skipSpecialPlatforms causes the test to be skipped for platforms where
+// builders (build.golang.org) don't have access to compiled packages for
+// import.
+func skipSpecialPlatforms(t *testing.T) {
+	switch platform := runtime.GOOS + "-" + runtime.GOARCH; platform {
+	case "nacl-amd64p32",
+		"nacl-386",
+		"nacl-arm",
+		"darwin-arm",
+		"darwin-arm64":
+		t.Skipf("no compiled packages available for import on %s", platform)
+	}
+}
+
+func compile(t *testing.T, dirname, filename string) string {
+	/* testenv. */ MustHaveGoBuild(t)
+	cmd := exec.Command("go", "tool", "compile", filename)
+	cmd.Dir = dirname
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Logf("%s", out)
+		t.Fatalf("go tool compile %s failed: %s", filename, err)
+	}
+	// filename should end with ".go"
+	return filepath.Join(dirname, filename[:len(filename)-2]+"o")
+}
+
+func testPath(t *testing.T, path, srcDir string) *types.Package {
+	t0 := time.Now()
+	pkg, err := Import(make(map[string]*types.Package), path, srcDir)
+	if err != nil {
+		t.Errorf("testPath(%s): %s", path, err)
+		return nil
+	}
+	t.Logf("testPath(%s): %v", path, time.Since(t0))
+	return pkg
+}
+
+const maxTime = 30 * time.Second
+
+func testDir(t *testing.T, dir string, endTime time.Time) (nimports int) {
+	dirname := filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_"+runtime.GOARCH, dir)
+	list, err := ioutil.ReadDir(dirname)
+	if err != nil {
+		t.Fatalf("testDir(%s): %s", dirname, err)
+	}
+	for _, f := range list {
+		if time.Now().After(endTime) {
+			t.Log("testing time used up")
+			return
+		}
+		switch {
+		case !f.IsDir():
+			// try extensions
+			for _, ext := range pkgExts {
+				if strings.HasSuffix(f.Name(), ext) {
+					name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension
+					if testPath(t, filepath.Join(dir, name), dir) != nil {
+						nimports++
+					}
+				}
+			}
+		case f.IsDir():
+			nimports += testDir(t, filepath.Join(dir, f.Name()), endTime)
+		}
+	}
+	return
+}
+
+const testfile = "exports.go"
+
+func TestImportTestdata(t *testing.T) {
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	if outFn := compile(t, "testdata", testfile); outFn != "" {
+		defer os.Remove(outFn)
+	}
+
+	// filename should end with ".go"
+	filename := testfile[:len(testfile)-3]
+	if pkg := testPath(t, "./testdata/"+filename, "."); pkg != nil {
+		// The package's Imports list must include all packages
+		// explicitly imported by testfile, plus all packages
+		// referenced indirectly via exported objects in testfile.
+		// With the textual export format (when run against Go1.6),
+		// the list may also include additional packages that are
+		// not strictly required for import processing alone (they
+		// are exported to err "on the safe side").
+		// For now, we just test the presence of a few packages
+		// that we know are there for sure.
+		got := fmt.Sprint(pkg.Imports())
+		for _, want := range []string{"go/ast", "go/token"} {
+			if !strings.Contains(got, want) {
+				t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+			}
+		}
+	}
+}
+
+func TestVersionHandling(t *testing.T) {
+	skipSpecialPlatforms(t) // we really only need to exclude nacl platforms, but this is fine
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	const dir = "./testdata/versions"
+	list, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, f := range list {
+		name := f.Name()
+		if !strings.HasSuffix(name, ".a") {
+			continue // not a package file
+		}
+		if strings.Contains(name, "corrupted") {
+			continue // don't process a leftover corrupted file
+		}
+		pkgpath := "./" + name[:len(name)-2]
+
+		// test that export data can be imported
+		_, err := Import(make(map[string]*types.Package), pkgpath, dir)
+		if err != nil {
+			t.Errorf("import %q failed: %v", pkgpath, err)
+			continue
+		}
+
+		// create file with corrupted export data
+		// 1) read file
+		data, err := ioutil.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		// 2) find export data
+		i := bytes.Index(data, []byte("\n$$B\n")) + 5
+		j := bytes.Index(data[i:], []byte("\n$$\n")) + i
+		if i < 0 || j < 0 || i > j {
+			t.Fatalf("export data section not found (i = %d, j = %d)", i, j)
+		}
+		// 3) corrupt the data (increment every 7th byte)
+		for k := j - 13; k >= i; k -= 7 {
+			data[k]++
+		}
+		// 4) write the file
+		pkgpath += "_corrupted"
+		filename := filepath.Join(dir, pkgpath) + ".a"
+		ioutil.WriteFile(filename, data, 0666)
+		defer os.Remove(filename)
+
+		// test that importing the corrupted file results in an error
+		_, err = Import(make(map[string]*types.Package), pkgpath, dir)
+		if err == nil {
+			t.Errorf("import corrupted %q succeeded", pkgpath)
+		} else if msg := err.Error(); !strings.Contains(msg, "version skew") {
+			t.Errorf("import %q error incorrect (%s)", pkgpath, msg)
+		}
+	}
+}
+
+func TestImportStdLib(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	dt := maxTime
+	if testing.Short() && /* testenv. */ Builder() == "" {
+		dt = 10 * time.Millisecond
+	}
+	nimports := testDir(t, "", time.Now().Add(dt)) // installed packages
+	t.Logf("tested %d imports", nimports)
+}
+
+var importedObjectTests = []struct {
+	name string
+	want string
+}{
+	{"math.Pi", "const Pi untyped float"},
+	{"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"},
+	// Go 1.7 and 1.8 don't know about embedded interfaces. Leave this
+	// test out for now - the code is tested in the std library anyway.
+	// TODO(gri) enable again once we're off 1.7 and 1.8.
+	// {"io.ReadWriter", "type ReadWriter interface{Reader; Writer}"},
+	{"math.Sin", "func Sin(x float64) float64"},
+	// TODO(gri) add more tests
+}
+
+func TestImportedTypes(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	for _, test := range importedObjectTests {
+		s := strings.Split(test.name, ".")
+		if len(s) != 2 {
+			t.Fatal("inconsistent test data")
+		}
+		importPath := s[0]
+		objName := s[1]
+
+		pkg, err := Import(make(map[string]*types.Package), importPath, ".")
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		obj := pkg.Scope().Lookup(objName)
+		if obj == nil {
+			t.Errorf("%s: object not found", test.name)
+			continue
+		}
+
+		got := types.ObjectString(obj, types.RelativeTo(pkg))
+		if got != test.want {
+			t.Errorf("%s: got %q; want %q", test.name, got, test.want)
+		}
+	}
+}
+
+func TestIssue5815(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	pkg := importPkg(t, "strings")
+
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj.Pkg() == nil {
+			t.Errorf("no pkg for %s", obj)
+		}
+		if tname, _ := obj.(*types.TypeName); tname != nil {
+			named := tname.Type().(*types.Named)
+			for i := 0; i < named.NumMethods(); i++ {
+				m := named.Method(i)
+				if m.Pkg() == nil {
+					t.Errorf("no pkg for %s", m)
+				}
+			}
+		}
+	}
+}
+
+// Smoke test to ensure that imported methods get the correct package.
+func TestCorrectMethodPackage(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	imports := make(map[string]*types.Package)
+	_, err := Import(imports, "net/http", ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mutex := imports["sync"].Scope().Lookup("Mutex").(*types.TypeName).Type()
+	mset := types.NewMethodSet(types.NewPointer(mutex)) // methods of *sync.Mutex
+	sel := mset.Lookup(nil, "Lock")
+	lock := sel.Obj().(*types.Func)
+	if got, want := lock.Pkg().Path(), "sync"; got != want {
+		t.Errorf("got package path %q; want %q", got, want)
+	}
+}
+
+func TestIssue13566(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	if f := compile(t, "testdata", "a.go"); f != "" {
+		defer os.Remove(f)
+	}
+	if f := compile(t, "testdata", "b.go"); f != "" {
+		defer os.Remove(f)
+	}
+
+	// import must succeed (test for issue at hand)
+	pkg := importPkg(t, "./testdata/b")
+
+	// make sure all indirectly imported packages have names
+	for _, imp := range pkg.Imports() {
+		if imp.Name() == "" {
+			t.Errorf("no name for %s package", imp.Path())
+		}
+	}
+}
+
+func TestIssue13898(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// import go/internal/gcimporter which imports go/types partially
+	imports := make(map[string]*types.Package)
+	_, err := Import(imports, "go/internal/gcimporter", ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// look for go/types package
+	var goTypesPkg *types.Package
+	for path, pkg := range imports {
+		if path == "go/types" {
+			goTypesPkg = pkg
+			break
+		}
+	}
+	if goTypesPkg == nil {
+		t.Fatal("go/types not found")
+	}
+
+	// look for go/types.Object type
+	obj := lookupObj(t, goTypesPkg.Scope(), "Object")
+	typ, ok := obj.Type().(*types.Named)
+	if !ok {
+		t.Fatalf("go/types.Object type is %v; wanted named type", typ)
+	}
+
+	// lookup go/types.Object.Pkg method
+	m, index, indirect := types.LookupFieldOrMethod(typ, false, nil, "Pkg")
+	if m == nil {
+		t.Fatalf("go/types.Object.Pkg not found (index = %v, indirect = %v)", index, indirect)
+	}
+
+	// the method must belong to go/types
+	if m.Pkg().Path() != "go/types" {
+		t.Fatalf("found %v; want go/types", m.Pkg())
+	}
+}
+
+func TestIssue15517(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	if f := compile(t, "testdata", "p.go"); f != "" {
+		defer os.Remove(f)
+	}
+
+	// Multiple imports of p must succeed without redeclaration errors.
+	// We use an import path that's not cleaned up so that the eventual
+	// file path for the package is different from the package path; this
+	// will expose the error if it is present.
+	//
+	// (Issue: Both the textual and the binary importer used the file path
+	// of the package to be imported as key into the shared packages map.
+	// However, the binary importer then used the package path to identify
+	// the imported package to mark it as complete; effectively marking the
+	// wrong package as complete. By using an "unclean" package path, the
+	// file and package path are different, exposing the problem if present.
+	// The same issue occurs with vendoring.)
+	imports := make(map[string]*types.Package)
+	for i := 0; i < 3; i++ {
+		if _, err := Import(imports, "./././testdata/p", "."); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestIssue15920(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	if f := compile(t, "testdata", "issue15920.go"); f != "" {
+		defer os.Remove(f)
+	}
+
+	importPkg(t, "./testdata/issue15920")
+}
+
+func TestIssue20046(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	if f := compile(t, "testdata", "issue20046.go"); f != "" {
+		defer os.Remove(f)
+	}
+
+	// "./issue20046".V.M must exist
+	pkg := importPkg(t, "./testdata/issue20046")
+	obj := lookupObj(t, pkg.Scope(), "V")
+	if m, index, indirect := types.LookupFieldOrMethod(obj.Type(), false, nil, "M"); m == nil {
+		t.Fatalf("V.M not found (index = %v, indirect = %v)", index, indirect)
+	}
+}
+
+func importPkg(t *testing.T, path string) *types.Package {
+	pkg, err := Import(make(map[string]*types.Package), path, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg
+}
+
+func lookupObj(t *testing.T, scope *types.Scope, name string) types.Object {
+	if obj := scope.Lookup(name); obj != nil {
+		return obj
+	}
+	t.Fatalf("%s not found", name)
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go b/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go
new file mode 100644
index 0000000..225ffee
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.9
+
+package gcimporter
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return false // there are no type aliases before Go 1.9
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go b/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go
new file mode 100644
index 0000000..c2025d8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.9
+
+package gcimporter
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return obj.IsAlias()
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/a.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/a.go
new file mode 100644
index 0000000..56e4292
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/a.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.
+
+// Input for TestIssue13566
+
+package a
+
+import "encoding/json"
+
+type A struct {
+	a    *A
+	json json.RawMessage
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/b.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/b.go
new file mode 100644
index 0000000..4196678
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/b.go
@@ -0,0 +1,11 @@
+// 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.
+
+// Input for TestIssue13566
+
+package b
+
+import "./a"
+
+type A a.A
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/exports.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/exports.go
new file mode 100644
index 0000000..8ee28b0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/exports.go
@@ -0,0 +1,89 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is used to generate an object file which
+// serves as test file for gcimporter_test.go.
+
+package exports
+
+import (
+	"go/ast"
+)
+
+// Issue 3682: Correctly read dotted identifiers from export data.
+const init1 = 0
+
+func init() {}
+
+const (
+	C0 int = 0
+	C1     = 3.14159265
+	C2     = 2.718281828i
+	C3     = -123.456e-789
+	C4     = +123.456E+789
+	C5     = 1234i
+	C6     = "foo\n"
+	C7     = `bar\n`
+)
+
+type (
+	T1  int
+	T2  [10]int
+	T3  []int
+	T4  *int
+	T5  chan int
+	T6a chan<- int
+	T6b chan (<-chan int)
+	T6c chan<- (chan int)
+	T7  <-chan *ast.File
+	T8  struct{}
+	T9  struct {
+		a    int
+		b, c float32
+		d    []string `go:"tag"`
+	}
+	T10 struct {
+		T8
+		T9
+		_ *T10
+	}
+	T11 map[int]string
+	T12 interface{}
+	T13 interface {
+		m1()
+		m2(int) float32
+	}
+	T14 interface {
+		T12
+		T13
+		m3(x ...struct{}) []T9
+	}
+	T15 func()
+	T16 func(int)
+	T17 func(x int)
+	T18 func() float32
+	T19 func() (x float32)
+	T20 func(...interface{})
+	T21 struct{ next *T21 }
+	T22 struct{ link *T23 }
+	T23 struct{ link *T22 }
+	T24 *T24
+	T25 *T26
+	T26 *T27
+	T27 *T25
+	T28 func(T28) T28
+)
+
+var (
+	V0 int
+	V1 = -991.0
+)
+
+func F1()         {}
+func F2(x int)    {}
+func F3() int     { return 0 }
+func F4() float32 { return 0 }
+func F5(a, b, c int, u, v, w struct{ x, y T1 }, more ...interface{}) (p, q, r chan<- T10)
+
+func (p *T1) M1()
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue15920.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue15920.go
new file mode 100644
index 0000000..c70f7d8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue15920.go
@@ -0,0 +1,11 @@
+// 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 p
+
+// The underlying type of Error is the underlying type of error.
+// Make sure we can import this again without problems.
+type Error error
+
+func F() Error { return nil }
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue20046.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue20046.go
new file mode 100644
index 0000000..c63ee82
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/issue20046.go
@@ -0,0 +1,9 @@
+// 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 p
+
+var V interface {
+	M()
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/p.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/p.go
new file mode 100644
index 0000000..9e2e705
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/p.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.
+
+// Input for TestIssue15517
+
+package p
+
+const C = 0
+
+var V int
+
+func F() {}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test.go b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test.go
new file mode 100644
index 0000000..ac9c968
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test.go
@@ -0,0 +1,25 @@
+// 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.
+
+// To create a test case for a new export format version,
+// build this package with the latest compiler and store
+// the resulting .a file appropriately named in the versions
+// directory. The VersionHandling test will pick it up.
+//
+// In the testdata/versions:
+//
+// go build -o test_go1.$X_$Y.a test.go
+//
+// with $X = Go version and $Y = export format version.
+//
+// Make sure this source is extended such that it exercises
+// whatever export format change has taken place.
+
+package test
+
+// Any release before and including Go 1.7 didn't encode
+// the package for a blank struct field.
+type BlankField struct {
+	_ int
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_0.a b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_0.a
new file mode 100644
index 0000000..edb6c3f
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_0.a differ
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_1.a b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_1.a
new file mode 100644
index 0000000..554d04a
Binary files /dev/null and b/vendor/golang.org/x/tools/go/gcimporter15/testdata/versions/test_go1.7_1.a differ
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/backdoor.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/backdoor.go
new file mode 100644
index 0000000..4feb0dc
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/backdoor.go
@@ -0,0 +1,28 @@
+package gccgoimporter
+
+// This file opens a back door to the parser for golang.org/x/tools/go/gccgoexportdata.
+
+import (
+	"go/types"
+	"io"
+)
+
+// Parse reads and parses gccgo export data from in and constructs a
+// Package, inserting it into the imports map.
+func Parse(in io.Reader, imports map[string]*types.Package, path string) (_ *types.Package, err error) {
+	var p parser
+	p.init(path, in, imports)
+	defer func() {
+		switch x := recover().(type) {
+		case nil:
+			// success
+		case importError:
+			err = x
+		default:
+			panic(x) // resume unexpected panic
+		}
+	}()
+	pkg := p.parsePackage()
+	imports[path] = pkg
+	return pkg, err
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation.go
new file mode 100644
index 0000000..cebfc57
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation.go
@@ -0,0 +1,99 @@
+// 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 gccgoimporter
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/gccgoinstallation.go.
+
+import (
+	"bufio"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// Information about a specific installation of gccgo.
+type GccgoInstallation struct {
+	// Version of gcc (e.g. 4.8.0).
+	GccVersion string
+
+	// Target triple (e.g. x86_64-unknown-linux-gnu).
+	TargetTriple string
+
+	// Built-in library paths used by this installation.
+	LibPaths []string
+}
+
+// Ask the driver at the given path for information for this GccgoInstallation.
+// The given arguments are passed directly to the call to the driver.
+func (inst *GccgoInstallation) InitFromDriver(gccgoPath string, args ...string) (err error) {
+	argv := append([]string{"-###", "-S", "-x", "go", "-"}, args...)
+	cmd := exec.Command(gccgoPath, argv...)
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return
+	}
+
+	scanner := bufio.NewScanner(stderr)
+	for scanner.Scan() {
+		line := scanner.Text()
+		switch {
+		case strings.HasPrefix(line, "Target: "):
+			inst.TargetTriple = line[8:]
+
+		case line[0] == ' ':
+			args := strings.Fields(line)
+			for _, arg := range args[1:] {
+				if strings.HasPrefix(arg, "-L") {
+					inst.LibPaths = append(inst.LibPaths, arg[2:])
+				}
+			}
+		}
+	}
+
+	argv = append([]string{"-dumpversion"}, args...)
+	stdout, err := exec.Command(gccgoPath, argv...).Output()
+	if err != nil {
+		return
+	}
+	inst.GccVersion = strings.TrimSpace(string(stdout))
+
+	return
+}
+
+// Return the list of export search paths for this GccgoInstallation.
+func (inst *GccgoInstallation) SearchPaths() (paths []string) {
+	for _, lpath := range inst.LibPaths {
+		spath := filepath.Join(lpath, "go", inst.GccVersion)
+		fi, err := os.Stat(spath)
+		if err != nil || !fi.IsDir() {
+			continue
+		}
+		paths = append(paths, spath)
+
+		spath = filepath.Join(spath, inst.TargetTriple)
+		fi, err = os.Stat(spath)
+		if err != nil || !fi.IsDir() {
+			continue
+		}
+		paths = append(paths, spath)
+	}
+
+	paths = append(paths, inst.LibPaths...)
+
+	return
+}
+
+// Return an importer that searches incpaths followed by the gcc installation's
+// built-in search paths and the current directory.
+func (inst *GccgoInstallation) GetImporter(incpaths []string, initmap map[*types.Package]InitData) Importer {
+	return GetImporter(append(append(incpaths, inst.SearchPaths()...), "."), initmap)
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation_test.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation_test.go
new file mode 100644
index 0000000..fb1fa6d
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/gccgoinstallation_test.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 gccgoimporter
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/gccgoinstallation_test.go.
+
+import (
+	"go/types"
+	"runtime"
+	"testing"
+)
+
+var importablePackages = [...]string{
+	"archive/tar",
+	"archive/zip",
+	"bufio",
+	"bytes",
+	"compress/bzip2",
+	"compress/flate",
+	"compress/gzip",
+	"compress/lzw",
+	"compress/zlib",
+	"container/heap",
+	"container/list",
+	"container/ring",
+	"crypto/aes",
+	"crypto/cipher",
+	"crypto/des",
+	"crypto/dsa",
+	"crypto/ecdsa",
+	"crypto/elliptic",
+	"crypto",
+	"crypto/hmac",
+	"crypto/md5",
+	"crypto/rand",
+	"crypto/rc4",
+	"crypto/rsa",
+	"crypto/sha1",
+	"crypto/sha256",
+	"crypto/sha512",
+	"crypto/subtle",
+	"crypto/tls",
+	"crypto/x509",
+	"crypto/x509/pkix",
+	"database/sql/driver",
+	"database/sql",
+	"debug/dwarf",
+	"debug/elf",
+	"debug/gosym",
+	"debug/macho",
+	"debug/pe",
+	"encoding/ascii85",
+	"encoding/asn1",
+	"encoding/base32",
+	"encoding/base64",
+	"encoding/binary",
+	"encoding/csv",
+	"encoding/gob",
+	"encoding",
+	"encoding/hex",
+	"encoding/json",
+	"encoding/pem",
+	"encoding/xml",
+	"errors",
+	"exp/proxy",
+	"exp/terminal",
+	"expvar",
+	"flag",
+	"fmt",
+	"go/ast",
+	"go/build",
+	"go/doc",
+	"go/format",
+	"go/parser",
+	"go/printer",
+	"go/scanner",
+	"go/token",
+	"hash/adler32",
+	"hash/crc32",
+	"hash/crc64",
+	"hash/fnv",
+	"hash",
+	"html",
+	"html/template",
+	"image/color",
+	"image/color/palette",
+	"image/draw",
+	"image/gif",
+	"image",
+	"image/jpeg",
+	"image/png",
+	"index/suffixarray",
+	"io",
+	"io/ioutil",
+	"log",
+	"log/syslog",
+	"math/big",
+	"math/cmplx",
+	"math",
+	"math/rand",
+	"mime",
+	"mime/multipart",
+	"net",
+	"net/http/cgi",
+	"net/http/cookiejar",
+	"net/http/fcgi",
+	"net/http",
+	"net/http/httptest",
+	"net/http/httputil",
+	"net/http/pprof",
+	"net/mail",
+	"net/rpc",
+	"net/rpc/jsonrpc",
+	"net/smtp",
+	"net/textproto",
+	"net/url",
+	"old/regexp",
+	"old/template",
+	"os/exec",
+	"os",
+	"os/signal",
+	"os/user",
+	"path/filepath",
+	"path",
+	"reflect",
+	"regexp",
+	"regexp/syntax",
+	"runtime/debug",
+	"runtime",
+	"runtime/pprof",
+	"sort",
+	"strconv",
+	"strings",
+	"sync/atomic",
+	"sync",
+	"syscall",
+	"testing",
+	"testing/iotest",
+	"testing/quick",
+	"text/scanner",
+	"text/tabwriter",
+	"text/template",
+	"text/template/parse",
+	"time",
+	"unicode",
+	"unicode/utf16",
+	"unicode/utf8",
+}
+
+func TestInstallationImporter(t *testing.T) {
+	// This test relies on gccgo being around, which it most likely will be if we
+	// were compiled with gccgo.
+	if runtime.Compiler != "gccgo" {
+		t.Skip("This test needs gccgo")
+		return
+	}
+
+	var inst GccgoInstallation
+	err := inst.InitFromDriver("gccgo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	imp := inst.GetImporter(nil, nil)
+
+	// Ensure we don't regress the number of packages we can parse. First import
+	// all packages into the same map and then each individually.
+	pkgMap := make(map[string]*types.Package)
+	for _, pkg := range importablePackages {
+		_, err = imp(pkgMap, pkg)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	for _, pkg := range importablePackages {
+		_, err = imp(make(map[string]*types.Package), pkg)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	// Test for certain specific entities in the imported data.
+	for _, test := range [...]importerTest{
+		{pkgpath: "io", name: "Reader", want: "type Reader interface{Read(p []uint8) (n int, err error)}"},
+		{pkgpath: "io", name: "ReadWriter", want: "type ReadWriter interface{Reader; Writer}"},
+		{pkgpath: "math", name: "Pi", want: "const Pi untyped float"},
+		{pkgpath: "math", name: "Sin", want: "func Sin(x float64) float64"},
+		{pkgpath: "sort", name: "Ints", want: "func Ints(a []int)"},
+		{pkgpath: "unsafe", name: "Pointer", want: "type Pointer unsafe.Pointer"},
+	} {
+		runImporterTest(t, imp, nil, &test)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer.go
new file mode 100644
index 0000000..a3fae9a
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer.go
@@ -0,0 +1,209 @@
+// 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 gccgoimporter implements Import for gccgo-generated object files.
+package gccgoimporter // import "golang.org/x/tools/go/internal/gccgoimporter"
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/importer.go.
+
+import (
+	"bytes"
+	"debug/elf"
+	"fmt"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// A PackageInit describes an imported package that needs initialization.
+type PackageInit struct {
+	Name     string // short package name
+	InitFunc string // name of init function
+	Priority int    // priority of init function, see InitData.Priority
+}
+
+// The gccgo-specific init data for a package.
+type InitData struct {
+	// Initialization priority of this package relative to other packages.
+	// This is based on the maximum depth of the package's dependency graph;
+	// it is guaranteed to be greater than that of its dependencies.
+	Priority int
+
+	// The list of packages which this package depends on to be initialized,
+	// including itself if needed. This is the subset of the transitive closure of
+	// the package's dependencies that need initialization.
+	Inits []PackageInit
+}
+
+// Locate the file from which to read export data.
+// This is intended to replicate the logic in gofrontend.
+func findExportFile(searchpaths []string, pkgpath string) (string, error) {
+	for _, spath := range searchpaths {
+		pkgfullpath := filepath.Join(spath, pkgpath)
+		pkgdir, name := filepath.Split(pkgfullpath)
+
+		for _, filepath := range [...]string{
+			pkgfullpath,
+			pkgfullpath + ".gox",
+			pkgdir + "lib" + name + ".so",
+			pkgdir + "lib" + name + ".a",
+			pkgfullpath + ".o",
+		} {
+			fi, err := os.Stat(filepath)
+			if err == nil && !fi.IsDir() {
+				return filepath, nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("%s: could not find export data (tried %s)", pkgpath, strings.Join(searchpaths, ":"))
+}
+
+const (
+	gccgov1Magic    = "v1;\n"
+	gccgov2Magic    = "v2;\n"
+	goimporterMagic = "\n$$ "
+	archiveMagic    = "!<ar"
+)
+
+// Opens the export data file at the given path. If this is an ELF file,
+// searches for and opens the .go_export section. If this is an archive,
+// reads the export data from the first member, which is assumed to be an ELF file.
+// This is intended to replicate the logic in gofrontend.
+func openExportFile(fpath string) (reader io.ReadSeeker, closer io.Closer, err error) {
+	f, err := os.Open(fpath)
+	if err != nil {
+		return
+	}
+	closer = f
+	defer func() {
+		if err != nil && closer != nil {
+			f.Close()
+		}
+	}()
+
+	var magic [4]byte
+	_, err = f.ReadAt(magic[:], 0)
+	if err != nil {
+		return
+	}
+
+	var elfreader io.ReaderAt
+	switch string(magic[:]) {
+	case gccgov1Magic, gccgov2Magic, goimporterMagic:
+		// Raw export data.
+		reader = f
+		return
+
+	case archiveMagic:
+		// TODO(pcc): Read the archive directly instead of using "ar".
+		f.Close()
+		closer = nil
+
+		cmd := exec.Command("ar", "p", fpath)
+		var out []byte
+		out, err = cmd.Output()
+		if err != nil {
+			return
+		}
+
+		elfreader = bytes.NewReader(out)
+
+	default:
+		elfreader = f
+	}
+
+	ef, err := elf.NewFile(elfreader)
+	if err != nil {
+		return
+	}
+
+	sec := ef.Section(".go_export")
+	if sec == nil {
+		err = fmt.Errorf("%s: .go_export section not found", fpath)
+		return
+	}
+
+	reader = sec.Open()
+	return
+}
+
+// An Importer resolves import paths to Packages. The imports map records
+// packages already known, indexed by package path.
+// An importer must determine the canonical package path and check imports
+// to see if it is already present in the map. If so, the Importer can return
+// the map entry. Otherwise, the importer must load the package data for the
+// given path into a new *Package, record it in imports map, and return the
+// package.
+type Importer func(imports map[string]*types.Package, path string) (*types.Package, error)
+
+func GetImporter(searchpaths []string, initmap map[*types.Package]InitData) Importer {
+	return func(imports map[string]*types.Package, pkgpath string) (pkg *types.Package, err error) {
+		if pkgpath == "unsafe" {
+			return types.Unsafe, nil
+		}
+
+		fpath, err := findExportFile(searchpaths, pkgpath)
+		if err != nil {
+			return
+		}
+
+		reader, closer, err := openExportFile(fpath)
+		if err != nil {
+			return
+		}
+		if closer != nil {
+			defer closer.Close()
+		}
+
+		var magic [4]byte
+		_, err = reader.Read(magic[:])
+		if err != nil {
+			return
+		}
+		_, err = reader.Seek(0, 0) // 0 bytes after start (use 0, io.SeekStart when we drop Go 1.6)
+		if err != nil {
+			return
+		}
+
+		switch string(magic[:]) {
+		case gccgov1Magic, gccgov2Magic:
+			var p parser
+			p.init(fpath, reader, imports)
+			pkg = p.parsePackage()
+			if initmap != nil {
+				initmap[pkg] = p.initdata
+			}
+
+		// Excluded for now: Standard gccgo doesn't support this import format currently.
+		// case goimporterMagic:
+		// 	var data []byte
+		// 	data, err = ioutil.ReadAll(reader)
+		// 	if err != nil {
+		// 		return
+		// 	}
+		// 	var n int
+		// 	n, pkg, err = importer.ImportData(imports, data)
+		// 	if err != nil {
+		// 		return
+		// 	}
+
+		// 	if initmap != nil {
+		// 		suffixreader := bytes.NewReader(data[n:])
+		// 		var p parser
+		// 		p.init(fpath, suffixreader, nil)
+		// 		p.parseInitData()
+		// 		initmap[pkg] = p.initdata
+		// 	}
+
+		default:
+			err = fmt.Errorf("unrecognized magic string: %q", string(magic[:]))
+		}
+
+		return
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer19_test.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer19_test.go
new file mode 100644
index 0000000..0caa225
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer19_test.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 gccgoimporter
+
+var aliasTests = []importerTest{
+	{pkgpath: "alias", name: "IntAlias2", want: "type IntAlias2 = Int"},
+}
+
+func init() {
+	importerTests = append(importerTests, aliasTests...)
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer_test.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer_test.go
new file mode 100644
index 0000000..2c6f1cb
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/importer_test.go
@@ -0,0 +1,179 @@
+// 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 gccgoimporter
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/importer_test.go
+// except for the importerTests variable which does not contain Go1.9-specific tests.
+// Those are added via importer19_test.go.
+
+import (
+	"go/types"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+type importerTest struct {
+	pkgpath, name, want, wantval string
+	wantinits                    []string
+}
+
+func runImporterTest(t *testing.T, imp Importer, initmap map[*types.Package]InitData, test *importerTest) {
+	pkg, err := imp(make(map[string]*types.Package), test.pkgpath)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if test.name != "" {
+		obj := pkg.Scope().Lookup(test.name)
+		if obj == nil {
+			t.Errorf("%s: object not found", test.name)
+			return
+		}
+
+		got := types.ObjectString(obj, types.RelativeTo(pkg))
+		if got != test.want {
+			t.Errorf("%s: got %q; want %q", test.name, got, test.want)
+		}
+
+		if test.wantval != "" {
+			gotval := obj.(*types.Const).Val().String()
+			if gotval != test.wantval {
+				t.Errorf("%s: got val %q; want val %q", test.name, gotval, test.wantval)
+			}
+		}
+	}
+
+	if len(test.wantinits) > 0 {
+		initdata := initmap[pkg]
+		found := false
+		// Check that the package's own init function has the package's priority
+		for _, pkginit := range initdata.Inits {
+			if pkginit.InitFunc == test.wantinits[0] {
+				if initdata.Priority != pkginit.Priority {
+					t.Errorf("%s: got self priority %d; want %d", test.pkgpath, pkginit.Priority, initdata.Priority)
+				}
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			t.Errorf("%s: could not find expected function %q", test.pkgpath, test.wantinits[0])
+		}
+
+		// Each init function in the list other than the first one is a
+		// dependency of the function immediately before it. Check that
+		// the init functions appear in descending priority order.
+		priority := initdata.Priority
+		for _, wantdepinit := range test.wantinits[1:] {
+			found = false
+			for _, pkginit := range initdata.Inits {
+				if pkginit.InitFunc == wantdepinit {
+					if priority <= pkginit.Priority {
+						t.Errorf("%s: got dep priority %d; want less than %d", test.pkgpath, pkginit.Priority, priority)
+					}
+					found = true
+					priority = pkginit.Priority
+					break
+				}
+			}
+
+			if !found {
+				t.Errorf("%s: could not find expected function %q", test.pkgpath, wantdepinit)
+			}
+		}
+	}
+}
+
+var importerTests = []importerTest{
+	{pkgpath: "pointer", name: "Int8Ptr", want: "type Int8Ptr *int8"},
+	{pkgpath: "complexnums", name: "NN", want: "const NN untyped complex", wantval: "(-1 + -1i)"},
+	{pkgpath: "complexnums", name: "NP", want: "const NP untyped complex", wantval: "(-1 + 1i)"},
+	{pkgpath: "complexnums", name: "PN", want: "const PN untyped complex", wantval: "(1 + -1i)"},
+	{pkgpath: "complexnums", name: "PP", want: "const PP untyped complex", wantval: "(1 + 1i)"},
+	{pkgpath: "conversions", name: "Bits", want: "const Bits Units", wantval: `"bits"`},
+	{pkgpath: "time", name: "Duration", want: "type Duration int64"},
+	{pkgpath: "time", name: "Nanosecond", want: "const Nanosecond Duration", wantval: "1"},
+	{pkgpath: "unicode", name: "IsUpper", want: "func IsUpper(r rune) bool"},
+	{pkgpath: "unicode", name: "MaxRune", want: "const MaxRune untyped rune", wantval: "1114111"},
+	{pkgpath: "imports", wantinits: []string{"imports..import", "fmt..import", "math..import"}},
+	{pkgpath: "escapeinfo", name: "NewT", want: "func NewT(data []byte) *T"},
+}
+
+func TestGoxImporter(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	initmap := make(map[*types.Package]InitData)
+	imp := GetImporter([]string{"testdata"}, initmap)
+
+	for _, test := range importerTests {
+		runImporterTest(t, imp, initmap, &test)
+	}
+}
+
+func TestObjImporter(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	// This test relies on gccgo being around, which it most likely will be if we
+	// were compiled with gccgo.
+	if runtime.Compiler != "gccgo" {
+		t.Skip("This test needs gccgo")
+		return
+	}
+
+	tmpdir, err := ioutil.TempDir("", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	initmap := make(map[*types.Package]InitData)
+	imp := GetImporter([]string{tmpdir}, initmap)
+
+	artmpdir, err := ioutil.TempDir("", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	arinitmap := make(map[*types.Package]InitData)
+	arimp := GetImporter([]string{artmpdir}, arinitmap)
+
+	for _, test := range importerTests {
+		gofile := filepath.Join("testdata", test.pkgpath+".go")
+		ofile := filepath.Join(tmpdir, test.pkgpath+".o")
+		afile := filepath.Join(artmpdir, "lib"+test.pkgpath+".a")
+
+		cmd := exec.Command("gccgo", "-fgo-pkgpath="+test.pkgpath, "-c", "-o", ofile, gofile)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Logf("%s", out)
+			t.Fatalf("gccgo %s failed: %s", gofile, err)
+		}
+
+		runImporterTest(t, imp, initmap, &test)
+
+		cmd = exec.Command("ar", "cr", afile, ofile)
+		out, err = cmd.CombinedOutput()
+		if err != nil {
+			t.Logf("%s", out)
+			t.Fatalf("ar cr %s %s failed: %s", afile, ofile, err)
+		}
+
+		runImporterTest(t, arimp, arinitmap, &test)
+
+		if err = os.Remove(ofile); err != nil {
+			t.Fatal(err)
+		}
+		if err = os.Remove(afile); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err = os.Remove(tmpdir); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser.go
new file mode 100644
index 0000000..9e20df0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser.go
@@ -0,0 +1,910 @@
+// 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 gccgoimporter
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/parser.go.
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+type parser struct {
+	scanner  scanner.Scanner
+	version  string                    // format version
+	tok      rune                      // current token
+	lit      string                    // literal string; only valid for Ident, Int, String tokens
+	pkgpath  string                    // package path of imported package
+	pkgname  string                    // name of imported package
+	pkg      *types.Package            // reference to imported package
+	imports  map[string]*types.Package // package path -> package object
+	typeMap  map[int]types.Type        // type number -> type
+	initdata InitData                  // package init priority data
+}
+
+func (p *parser) init(filename string, src io.Reader, imports map[string]*types.Package) {
+	p.scanner.Init(src)
+	p.scanner.Error = func(_ *scanner.Scanner, msg string) { p.error(msg) }
+	p.scanner.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats | scanner.ScanStrings | scanner.ScanComments | scanner.SkipComments
+	p.scanner.Whitespace = 1<<'\t' | 1<<'\n' | 1<<' '
+	p.scanner.Filename = filename // for good error messages
+	p.next()
+	p.imports = imports
+	p.typeMap = make(map[int]types.Type)
+}
+
+type importError struct {
+	pos scanner.Position
+	err error
+}
+
+func (e importError) Error() string {
+	return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err)
+}
+
+func (p *parser) error(err interface{}) {
+	if s, ok := err.(string); ok {
+		err = errors.New(s)
+	}
+	// panic with a runtime.Error if err is not an error
+	panic(importError{p.scanner.Pos(), err.(error)})
+}
+
+func (p *parser) errorf(format string, args ...interface{}) {
+	p.error(fmt.Errorf(format, args...))
+}
+
+func (p *parser) expect(tok rune) string {
+	lit := p.lit
+	if p.tok != tok {
+		p.errorf("expected %s, got %s (%s)", scanner.TokenString(tok), scanner.TokenString(p.tok), lit)
+	}
+	p.next()
+	return lit
+}
+
+func (p *parser) expectKeyword(keyword string) {
+	lit := p.expect(scanner.Ident)
+	if lit != keyword {
+		p.errorf("expected keyword %s, got %q", keyword, lit)
+	}
+}
+
+func (p *parser) parseString() string {
+	str, err := strconv.Unquote(p.expect(scanner.String))
+	if err != nil {
+		p.error(err)
+	}
+	return str
+}
+
+// unquotedString     = { unquotedStringChar } .
+// unquotedStringChar = <neither a whitespace nor a ';' char> .
+func (p *parser) parseUnquotedString() string {
+	if p.tok == scanner.EOF {
+		p.error("unexpected EOF")
+	}
+	var buf bytes.Buffer
+	buf.WriteString(p.scanner.TokenText())
+	// This loop needs to examine each character before deciding whether to consume it. If we see a semicolon,
+	// we need to let it be consumed by p.next().
+	for ch := p.scanner.Peek(); ch != ';' && ch != scanner.EOF && p.scanner.Whitespace&(1<<uint(ch)) == 0; ch = p.scanner.Peek() {
+		buf.WriteRune(ch)
+		p.scanner.Next()
+	}
+	p.next()
+	return buf.String()
+}
+
+func (p *parser) next() {
+	p.tok = p.scanner.Scan()
+	switch p.tok {
+	case scanner.Ident, scanner.Int, scanner.Float, scanner.String, '·':
+		p.lit = p.scanner.TokenText()
+	default:
+		p.lit = ""
+	}
+}
+
+func (p *parser) parseQualifiedName() (path, name string) {
+	return p.parseQualifiedNameStr(p.parseString())
+}
+
+func (p *parser) parseUnquotedQualifiedName() (path, name string) {
+	return p.parseQualifiedNameStr(p.parseUnquotedString())
+}
+
+// qualifiedName = [ ["."] unquotedString "." ] unquotedString .
+//
+// The above production uses greedy matching.
+func (p *parser) parseQualifiedNameStr(unquotedName string) (pkgpath, name string) {
+	parts := strings.Split(unquotedName, ".")
+	if parts[0] == "" {
+		parts = parts[1:]
+	}
+
+	switch len(parts) {
+	case 0:
+		p.errorf("malformed qualified name: %q", unquotedName)
+	case 1:
+		// unqualified name
+		pkgpath = p.pkgpath
+		name = parts[0]
+	default:
+		// qualified name, which may contain periods
+		pkgpath = strings.Join(parts[0:len(parts)-1], ".")
+		name = parts[len(parts)-1]
+	}
+
+	return
+}
+
+// getPkg returns the package for a given path. If the package is
+// not found but we have a package name, create the package and
+// add it to the p.imports map.
+//
+func (p *parser) getPkg(pkgpath, name string) *types.Package {
+	// package unsafe is not in the imports map - handle explicitly
+	if pkgpath == "unsafe" {
+		return types.Unsafe
+	}
+	pkg := p.imports[pkgpath]
+	if pkg == nil && name != "" {
+		pkg = types.NewPackage(pkgpath, name)
+		p.imports[pkgpath] = pkg
+	}
+	return pkg
+}
+
+// parseExportedName is like parseQualifiedName, but
+// the package path is resolved to an imported *types.Package.
+//
+// ExportedName = string [string] .
+func (p *parser) parseExportedName() (pkg *types.Package, name string) {
+	path, name := p.parseQualifiedName()
+	var pkgname string
+	if p.tok == scanner.String {
+		pkgname = p.parseString()
+	}
+	pkg = p.getPkg(path, pkgname)
+	if pkg == nil {
+		p.errorf("package %s (path = %q) not found", name, path)
+	}
+	return
+}
+
+// Name = QualifiedName | "?" .
+func (p *parser) parseName() string {
+	if p.tok == '?' {
+		// Anonymous.
+		p.next()
+		return ""
+	}
+	// The package path is redundant for us. Don't try to parse it.
+	_, name := p.parseUnquotedQualifiedName()
+	return name
+}
+
+func deref(typ types.Type) types.Type {
+	if p, _ := typ.(*types.Pointer); p != nil {
+		typ = p.Elem()
+	}
+	return typ
+}
+
+// Field = Name Type [string] .
+func (p *parser) parseField(pkg *types.Package) (field *types.Var, tag string) {
+	name := p.parseName()
+	typ := p.parseType(pkg)
+	anon := false
+	if name == "" {
+		anon = true
+		switch typ := deref(typ).(type) {
+		case *types.Basic:
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			p.error("anonymous field expected")
+		}
+	}
+	field = types.NewField(token.NoPos, pkg, name, typ, anon)
+	if p.tok == scanner.String {
+		tag = p.parseString()
+	}
+	return
+}
+
+// Param = Name ["..."] Type .
+func (p *parser) parseParam(pkg *types.Package) (param *types.Var, isVariadic bool) {
+	name := p.parseName()
+	if p.tok == '<' && p.scanner.Peek() == 'e' {
+		// EscInfo = "<esc:" int ">" . (optional and ignored)
+		p.next()
+		p.expectKeyword("esc")
+		p.expect(':')
+		p.expect(scanner.Int)
+		p.expect('>')
+	}
+	if p.tok == '.' {
+		p.next()
+		p.expect('.')
+		p.expect('.')
+		isVariadic = true
+	}
+	typ := p.parseType(pkg)
+	if isVariadic {
+		typ = types.NewSlice(typ)
+	}
+	param = types.NewParam(token.NoPos, pkg, name, typ)
+	return
+}
+
+// Var = Name Type .
+func (p *parser) parseVar(pkg *types.Package) *types.Var {
+	name := p.parseName()
+	return types.NewVar(token.NoPos, pkg, name, p.parseType(pkg))
+}
+
+// Conversion = "convert" "(" Type "," ConstValue ")" .
+func (p *parser) parseConversion(pkg *types.Package) (val constant.Value, typ types.Type) {
+	p.expectKeyword("convert")
+	p.expect('(')
+	typ = p.parseType(pkg)
+	p.expect(',')
+	val, _ = p.parseConstValue(pkg)
+	p.expect(')')
+	return
+}
+
+// ConstValue     = string | "false" | "true" | ["-"] (int ["'"] | FloatOrComplex) | Conversion .
+// FloatOrComplex = float ["i" | ("+"|"-") float "i"] .
+func (p *parser) parseConstValue(pkg *types.Package) (val constant.Value, typ types.Type) {
+	switch p.tok {
+	case scanner.String:
+		str := p.parseString()
+		val = constant.MakeString(str)
+		typ = types.Typ[types.UntypedString]
+		return
+
+	case scanner.Ident:
+		b := false
+		switch p.lit {
+		case "false":
+		case "true":
+			b = true
+
+		case "convert":
+			return p.parseConversion(pkg)
+
+		default:
+			p.errorf("expected const value, got %s (%q)", scanner.TokenString(p.tok), p.lit)
+		}
+
+		p.next()
+		val = constant.MakeBool(b)
+		typ = types.Typ[types.UntypedBool]
+		return
+	}
+
+	sign := ""
+	if p.tok == '-' {
+		p.next()
+		sign = "-"
+	}
+
+	switch p.tok {
+	case scanner.Int:
+		val = constant.MakeFromLiteral(sign+p.lit, token.INT, 0)
+		if val == nil {
+			p.error("could not parse integer literal")
+		}
+
+		p.next()
+		if p.tok == '\'' {
+			p.next()
+			typ = types.Typ[types.UntypedRune]
+		} else {
+			typ = types.Typ[types.UntypedInt]
+		}
+
+	case scanner.Float:
+		re := sign + p.lit
+		p.next()
+
+		var im string
+		switch p.tok {
+		case '+':
+			p.next()
+			im = p.expect(scanner.Float)
+
+		case '-':
+			p.next()
+			im = "-" + p.expect(scanner.Float)
+
+		case scanner.Ident:
+			// re is in fact the imaginary component. Expect "i" below.
+			im = re
+			re = "0"
+
+		default:
+			val = constant.MakeFromLiteral(re, token.FLOAT, 0)
+			if val == nil {
+				p.error("could not parse float literal")
+			}
+			typ = types.Typ[types.UntypedFloat]
+			return
+		}
+
+		p.expectKeyword("i")
+		reval := constant.MakeFromLiteral(re, token.FLOAT, 0)
+		if reval == nil {
+			p.error("could not parse real component of complex literal")
+		}
+		imval := constant.MakeFromLiteral(im+"i", token.IMAG, 0)
+		if imval == nil {
+			p.error("could not parse imag component of complex literal")
+		}
+		val = constant.BinaryOp(reval, token.ADD, imval)
+		typ = types.Typ[types.UntypedComplex]
+
+	default:
+		p.errorf("expected const value, got %s (%q)", scanner.TokenString(p.tok), p.lit)
+	}
+
+	return
+}
+
+// Const = Name [Type] "=" ConstValue .
+func (p *parser) parseConst(pkg *types.Package) *types.Const {
+	name := p.parseName()
+	var typ types.Type
+	if p.tok == '<' {
+		typ = p.parseType(pkg)
+	}
+	p.expect('=')
+	val, vtyp := p.parseConstValue(pkg)
+	if typ == nil {
+		typ = vtyp
+	}
+	return types.NewConst(token.NoPos, pkg, name, typ, val)
+}
+
+// NamedType = TypeName [ "=" ] Type { Method } .
+// TypeName  = ExportedName .
+// Method    = "func" "(" Param ")" Name ParamList ResultList ";" .
+func (p *parser) parseNamedType(n int) types.Type {
+	pkg, name := p.parseExportedName()
+	scope := pkg.Scope()
+
+	if p.tok == '=' {
+		// type alias
+		p.next()
+		typ := p.parseType(pkg)
+		if obj := scope.Lookup(name); obj != nil {
+			typ = obj.Type() // use previously imported type
+			if typ == nil {
+				p.errorf("%v (type alias) used in cycle", obj)
+			}
+		} else {
+			obj = types.NewTypeName(token.NoPos, pkg, name, typ)
+			scope.Insert(obj)
+		}
+		p.typeMap[n] = typ
+		return typ
+	}
+
+	// named type
+	obj := scope.Lookup(name)
+	if obj == nil {
+		// a named type may be referred to before the underlying type
+		// is known - set it up
+		tname := types.NewTypeName(token.NoPos, pkg, name, nil)
+		types.NewNamed(tname, nil, nil)
+		scope.Insert(tname)
+		obj = tname
+	}
+
+	typ := obj.Type()
+	p.typeMap[n] = typ
+
+	nt, ok := typ.(*types.Named)
+	if !ok {
+		// This can happen for unsafe.Pointer, which is a TypeName holding a Basic type.
+		pt := p.parseType(pkg)
+		if pt != typ {
+			p.error("unexpected underlying type for non-named TypeName")
+		}
+		return typ
+	}
+
+	underlying := p.parseType(pkg)
+	if nt.Underlying() == nil {
+		nt.SetUnderlying(underlying.Underlying())
+	}
+
+	// collect associated methods
+	for p.tok == scanner.Ident {
+		p.expectKeyword("func")
+		p.expect('(')
+		receiver, _ := p.parseParam(pkg)
+		p.expect(')')
+		name := p.parseName()
+		params, isVariadic := p.parseParamList(pkg)
+		results := p.parseResultList(pkg)
+		p.expect(';')
+
+		sig := types.NewSignature(receiver, params, results, isVariadic)
+		nt.AddMethod(types.NewFunc(token.NoPos, pkg, name, sig))
+	}
+
+	return nt
+}
+
+func (p *parser) parseInt() int64 {
+	lit := p.expect(scanner.Int)
+	n, err := strconv.ParseInt(lit, 10, 0)
+	if err != nil {
+		p.error(err)
+	}
+	return n
+}
+
+// ArrayOrSliceType = "[" [ int ] "]" Type .
+func (p *parser) parseArrayOrSliceType(pkg *types.Package) types.Type {
+	p.expect('[')
+	if p.tok == ']' {
+		p.next()
+		return types.NewSlice(p.parseType(pkg))
+	}
+
+	n := p.parseInt()
+	p.expect(']')
+	return types.NewArray(p.parseType(pkg), n)
+}
+
+// MapType = "map" "[" Type "]" Type .
+func (p *parser) parseMapType(pkg *types.Package) types.Type {
+	p.expectKeyword("map")
+	p.expect('[')
+	key := p.parseType(pkg)
+	p.expect(']')
+	elem := p.parseType(pkg)
+	return types.NewMap(key, elem)
+}
+
+// ChanType = "chan" ["<-" | "-<"] Type .
+func (p *parser) parseChanType(pkg *types.Package) types.Type {
+	p.expectKeyword("chan")
+	dir := types.SendRecv
+	switch p.tok {
+	case '-':
+		p.next()
+		p.expect('<')
+		dir = types.SendOnly
+
+	case '<':
+		// don't consume '<' if it belongs to Type
+		if p.scanner.Peek() == '-' {
+			p.next()
+			p.expect('-')
+			dir = types.RecvOnly
+		}
+	}
+
+	return types.NewChan(dir, p.parseType(pkg))
+}
+
+// StructType = "struct" "{" { Field } "}" .
+func (p *parser) parseStructType(pkg *types.Package) types.Type {
+	p.expectKeyword("struct")
+
+	var fields []*types.Var
+	var tags []string
+
+	p.expect('{')
+	for p.tok != '}' && p.tok != scanner.EOF {
+		field, tag := p.parseField(pkg)
+		p.expect(';')
+		fields = append(fields, field)
+		tags = append(tags, tag)
+	}
+	p.expect('}')
+
+	return types.NewStruct(fields, tags)
+}
+
+// ParamList = "(" [ { Parameter "," } Parameter ] ")" .
+func (p *parser) parseParamList(pkg *types.Package) (*types.Tuple, bool) {
+	var list []*types.Var
+	isVariadic := false
+
+	p.expect('(')
+	for p.tok != ')' && p.tok != scanner.EOF {
+		if len(list) > 0 {
+			p.expect(',')
+		}
+		par, variadic := p.parseParam(pkg)
+		list = append(list, par)
+		if variadic {
+			if isVariadic {
+				p.error("... not on final argument")
+			}
+			isVariadic = true
+		}
+	}
+	p.expect(')')
+
+	return types.NewTuple(list...), isVariadic
+}
+
+// ResultList = Type | ParamList .
+func (p *parser) parseResultList(pkg *types.Package) *types.Tuple {
+	switch p.tok {
+	case '<':
+		return types.NewTuple(types.NewParam(token.NoPos, pkg, "", p.parseType(pkg)))
+
+	case '(':
+		params, _ := p.parseParamList(pkg)
+		return params
+
+	default:
+		return nil
+	}
+}
+
+// FunctionType = ParamList ResultList .
+func (p *parser) parseFunctionType(pkg *types.Package) *types.Signature {
+	params, isVariadic := p.parseParamList(pkg)
+	results := p.parseResultList(pkg)
+	return types.NewSignature(nil, params, results, isVariadic)
+}
+
+// Func = Name FunctionType .
+func (p *parser) parseFunc(pkg *types.Package) *types.Func {
+	name := p.parseName()
+	if strings.ContainsRune(name, '$') {
+		// This is a Type$equal or Type$hash function, which we don't want to parse,
+		// except for the types.
+		p.discardDirectiveWhileParsingTypes(pkg)
+		return nil
+	}
+	return types.NewFunc(token.NoPos, pkg, name, p.parseFunctionType(pkg))
+}
+
+// InterfaceType = "interface" "{" { ("?" Type | Func) ";" } "}" .
+func (p *parser) parseInterfaceType(pkg *types.Package) types.Type {
+	p.expectKeyword("interface")
+
+	var methods []*types.Func
+	var typs []*types.Named
+
+	p.expect('{')
+	for p.tok != '}' && p.tok != scanner.EOF {
+		if p.tok == '?' {
+			p.next()
+			typs = append(typs, p.parseType(pkg).(*types.Named))
+		} else {
+			method := p.parseFunc(pkg)
+			methods = append(methods, method)
+		}
+		p.expect(';')
+	}
+	p.expect('}')
+
+	return types.NewInterface(methods, typs)
+}
+
+// PointerType = "*" ("any" | Type) .
+func (p *parser) parsePointerType(pkg *types.Package) types.Type {
+	p.expect('*')
+	if p.tok == scanner.Ident {
+		p.expectKeyword("any")
+		return types.Typ[types.UnsafePointer]
+	}
+	return types.NewPointer(p.parseType(pkg))
+}
+
+// TypeDefinition = NamedType | MapType | ChanType | StructType | InterfaceType | PointerType | ArrayOrSliceType | FunctionType .
+func (p *parser) parseTypeDefinition(pkg *types.Package, n int) types.Type {
+	var t types.Type
+	switch p.tok {
+	case scanner.String:
+		t = p.parseNamedType(n)
+
+	case scanner.Ident:
+		switch p.lit {
+		case "map":
+			t = p.parseMapType(pkg)
+
+		case "chan":
+			t = p.parseChanType(pkg)
+
+		case "struct":
+			t = p.parseStructType(pkg)
+
+		case "interface":
+			t = p.parseInterfaceType(pkg)
+		}
+
+	case '*':
+		t = p.parsePointerType(pkg)
+
+	case '[':
+		t = p.parseArrayOrSliceType(pkg)
+
+	case '(':
+		t = p.parseFunctionType(pkg)
+	}
+
+	p.typeMap[n] = t
+	return t
+}
+
+const (
+	// From gofrontend/go/export.h
+	// Note that these values are negative in the gofrontend and have been made positive
+	// in the gccgoimporter.
+	gccgoBuiltinINT8       = 1
+	gccgoBuiltinINT16      = 2
+	gccgoBuiltinINT32      = 3
+	gccgoBuiltinINT64      = 4
+	gccgoBuiltinUINT8      = 5
+	gccgoBuiltinUINT16     = 6
+	gccgoBuiltinUINT32     = 7
+	gccgoBuiltinUINT64     = 8
+	gccgoBuiltinFLOAT32    = 9
+	gccgoBuiltinFLOAT64    = 10
+	gccgoBuiltinINT        = 11
+	gccgoBuiltinUINT       = 12
+	gccgoBuiltinUINTPTR    = 13
+	gccgoBuiltinBOOL       = 15
+	gccgoBuiltinSTRING     = 16
+	gccgoBuiltinCOMPLEX64  = 17
+	gccgoBuiltinCOMPLEX128 = 18
+	gccgoBuiltinERROR      = 19
+	gccgoBuiltinBYTE       = 20
+	gccgoBuiltinRUNE       = 21
+)
+
+func lookupBuiltinType(typ int) types.Type {
+	return [...]types.Type{
+		gccgoBuiltinINT8:       types.Typ[types.Int8],
+		gccgoBuiltinINT16:      types.Typ[types.Int16],
+		gccgoBuiltinINT32:      types.Typ[types.Int32],
+		gccgoBuiltinINT64:      types.Typ[types.Int64],
+		gccgoBuiltinUINT8:      types.Typ[types.Uint8],
+		gccgoBuiltinUINT16:     types.Typ[types.Uint16],
+		gccgoBuiltinUINT32:     types.Typ[types.Uint32],
+		gccgoBuiltinUINT64:     types.Typ[types.Uint64],
+		gccgoBuiltinFLOAT32:    types.Typ[types.Float32],
+		gccgoBuiltinFLOAT64:    types.Typ[types.Float64],
+		gccgoBuiltinINT:        types.Typ[types.Int],
+		gccgoBuiltinUINT:       types.Typ[types.Uint],
+		gccgoBuiltinUINTPTR:    types.Typ[types.Uintptr],
+		gccgoBuiltinBOOL:       types.Typ[types.Bool],
+		gccgoBuiltinSTRING:     types.Typ[types.String],
+		gccgoBuiltinCOMPLEX64:  types.Typ[types.Complex64],
+		gccgoBuiltinCOMPLEX128: types.Typ[types.Complex128],
+		gccgoBuiltinERROR:      types.Universe.Lookup("error").Type(),
+		gccgoBuiltinBYTE:       types.Universe.Lookup("byte").Type(),
+		gccgoBuiltinRUNE:       types.Universe.Lookup("rune").Type(),
+	}[typ]
+}
+
+// Type = "<" "type" ( "-" int | int [ TypeDefinition ] ) ">" .
+func (p *parser) parseType(pkg *types.Package) (t types.Type) {
+	p.expect('<')
+	p.expectKeyword("type")
+
+	switch p.tok {
+	case scanner.Int:
+		n := p.parseInt()
+
+		if p.tok == '>' {
+			t = p.typeMap[int(n)]
+		} else {
+			t = p.parseTypeDefinition(pkg, int(n))
+		}
+
+	case '-':
+		p.next()
+		n := p.parseInt()
+		t = lookupBuiltinType(int(n))
+
+	default:
+		p.errorf("expected type number, got %s (%q)", scanner.TokenString(p.tok), p.lit)
+		return nil
+	}
+
+	p.expect('>')
+	return
+}
+
+// PackageInit = unquotedString unquotedString int .
+func (p *parser) parsePackageInit() PackageInit {
+	name := p.parseUnquotedString()
+	initfunc := p.parseUnquotedString()
+	priority := -1
+	if p.version == "v1" {
+		priority = int(p.parseInt())
+	}
+	return PackageInit{Name: name, InitFunc: initfunc, Priority: priority}
+}
+
+// Throw away tokens until we see a ';'. If we see a '<', attempt to parse as a type.
+func (p *parser) discardDirectiveWhileParsingTypes(pkg *types.Package) {
+	for {
+		switch p.tok {
+		case ';':
+			return
+		case '<':
+			p.parseType(pkg)
+		case scanner.EOF:
+			p.error("unexpected EOF")
+		default:
+			p.next()
+		}
+	}
+}
+
+// Create the package if we have parsed both the package path and package name.
+func (p *parser) maybeCreatePackage() {
+	if p.pkgname != "" && p.pkgpath != "" {
+		p.pkg = p.getPkg(p.pkgpath, p.pkgname)
+	}
+}
+
+// InitDataDirective = ( "v1" | "v2" ) ";" |
+//                     "priority" int ";" |
+//                     "init" { PackageInit } ";" |
+//                     "checksum" unquotedString ";" .
+func (p *parser) parseInitDataDirective() {
+	if p.tok != scanner.Ident {
+		// unexpected token kind; panic
+		p.expect(scanner.Ident)
+	}
+
+	switch p.lit {
+	case "v1", "v2":
+		p.version = p.lit
+		p.next()
+		p.expect(';')
+
+	case "priority":
+		p.next()
+		p.initdata.Priority = int(p.parseInt())
+		p.expect(';')
+
+	case "init":
+		p.next()
+		for p.tok != ';' && p.tok != scanner.EOF {
+			p.initdata.Inits = append(p.initdata.Inits, p.parsePackageInit())
+		}
+		p.expect(';')
+
+	case "init_graph":
+		p.next()
+		// The graph data is thrown away for now.
+		for p.tok != ';' && p.tok != scanner.EOF {
+			p.parseInt()
+			p.parseInt()
+		}
+		p.expect(';')
+
+	case "checksum":
+		// Don't let the scanner try to parse the checksum as a number.
+		defer func(mode uint) {
+			p.scanner.Mode = mode
+		}(p.scanner.Mode)
+		p.scanner.Mode &^= scanner.ScanInts | scanner.ScanFloats
+		p.next()
+		p.parseUnquotedString()
+		p.expect(';')
+
+	default:
+		p.errorf("unexpected identifier: %q", p.lit)
+	}
+}
+
+// Directive = InitDataDirective |
+//             "package" unquotedString [ unquotedString ] [ unquotedString ] ";" |
+//             "pkgpath" unquotedString ";" |
+//             "prefix" unquotedString ";" |
+//             "import" unquotedString unquotedString string ";" |
+//             "func" Func ";" |
+//             "type" Type ";" |
+//             "var" Var ";" |
+//             "const" Const ";" .
+func (p *parser) parseDirective() {
+	if p.tok != scanner.Ident {
+		// unexpected token kind; panic
+		p.expect(scanner.Ident)
+	}
+
+	switch p.lit {
+	case "v1", "v2", "priority", "init", "init_graph", "checksum":
+		p.parseInitDataDirective()
+
+	case "package":
+		p.next()
+		p.pkgname = p.parseUnquotedString()
+		p.maybeCreatePackage()
+		if p.version == "v2" && p.tok != ';' {
+			p.parseUnquotedString()
+			p.parseUnquotedString()
+		}
+		p.expect(';')
+
+	case "pkgpath":
+		p.next()
+		p.pkgpath = p.parseUnquotedString()
+		p.maybeCreatePackage()
+		p.expect(';')
+
+	case "prefix":
+		p.next()
+		p.pkgpath = p.parseUnquotedString()
+		p.expect(';')
+
+	case "import":
+		p.next()
+		pkgname := p.parseUnquotedString()
+		pkgpath := p.parseUnquotedString()
+		p.getPkg(pkgpath, pkgname)
+		p.parseString()
+		p.expect(';')
+
+	case "func":
+		p.next()
+		fun := p.parseFunc(p.pkg)
+		if fun != nil {
+			p.pkg.Scope().Insert(fun)
+		}
+		p.expect(';')
+
+	case "type":
+		p.next()
+		p.parseType(p.pkg)
+		p.expect(';')
+
+	case "var":
+		p.next()
+		v := p.parseVar(p.pkg)
+		p.pkg.Scope().Insert(v)
+		p.expect(';')
+
+	case "const":
+		p.next()
+		c := p.parseConst(p.pkg)
+		p.pkg.Scope().Insert(c)
+		p.expect(';')
+
+	default:
+		p.errorf("unexpected identifier: %q", p.lit)
+	}
+}
+
+// Package = { Directive } .
+func (p *parser) parsePackage() *types.Package {
+	for p.tok != scanner.EOF {
+		p.parseDirective()
+	}
+	for _, typ := range p.typeMap {
+		if it, ok := typ.(*types.Interface); ok {
+			it.Complete()
+		}
+	}
+	p.pkg.MarkComplete()
+	return p.pkg
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser_test.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser_test.go
new file mode 100644
index 0000000..a6f5eda
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/parser_test.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 gccgoimporter
+
+// This is a verbatim copy of $GOROOT/src/go/internal/gccgoimporter/parser_test.go.
+
+import (
+	"bytes"
+	"go/types"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+var typeParserTests = []struct {
+	id, typ, want, underlying, methods string
+}{
+	{id: "foo", typ: "<type -1>", want: "int8"},
+	{id: "foo", typ: "<type 1 *<type -19>>", want: "*error"},
+	{id: "foo", typ: "<type 1 *any>", want: "unsafe.Pointer"},
+	{id: "foo", typ: "<type 1 \"Bar\" <type 2 *<type 1>>>", want: "foo.Bar", underlying: "*foo.Bar"},
+	{id: "foo", typ: "<type 1 \"bar.Foo\" \"bar\" <type -1> func (? <type 1>) M (); >", want: "bar.Foo", underlying: "int8", methods: "func (bar.Foo).M()"},
+	{id: "foo", typ: "<type 1 \".bar.foo\" \"bar\" <type -1>>", want: "bar.foo", underlying: "int8"},
+	{id: "foo", typ: "<type 1 []<type -1>>", want: "[]int8"},
+	{id: "foo", typ: "<type 1 [42]<type -1>>", want: "[42]int8"},
+	{id: "foo", typ: "<type 1 map [<type -1>] <type -2>>", want: "map[int8]int16"},
+	{id: "foo", typ: "<type 1 chan <type -1>>", want: "chan int8"},
+	{id: "foo", typ: "<type 1 chan <- <type -1>>", want: "<-chan int8"},
+	{id: "foo", typ: "<type 1 chan -< <type -1>>", want: "chan<- int8"},
+	{id: "foo", typ: "<type 1 struct { I8 <type -1>; I16 <type -2> \"i16\"; }>", want: "struct{I8 int8; I16 int16 \"i16\"}"},
+	{id: "foo", typ: "<type 1 interface { Foo (a <type -1>, b <type -2>) <type -1>; Bar (? <type -2>, ? ...<type -1>) (? <type -2>, ? <type -1>); Baz (); }>", want: "interface{Bar(int16, ...int8) (int16, int8); Baz(); Foo(a int8, b int16) int8}"},
+	{id: "foo", typ: "<type 1 (? <type -1>) <type -2>>", want: "func(int8) int16"},
+}
+
+func TestTypeParser(t *testing.T) {
+	for _, test := range typeParserTests {
+		var p parser
+		p.init("test.gox", strings.NewReader(test.typ), make(map[string]*types.Package))
+		p.pkgname = test.id
+		p.pkgpath = test.id
+		p.maybeCreatePackage()
+		typ := p.parseType(p.pkg)
+
+		if p.tok != scanner.EOF {
+			t.Errorf("expected full parse, stopped at %q", p.lit)
+		}
+
+		// interfaces must be explicitly completed
+		if ityp, _ := typ.(*types.Interface); ityp != nil {
+			ityp.Complete()
+		}
+
+		got := typ.String()
+		if got != test.want {
+			t.Errorf("got type %q, expected %q", got, test.want)
+		}
+
+		if test.underlying != "" {
+			underlying := typ.Underlying().String()
+			if underlying != test.underlying {
+				t.Errorf("got underlying type %q, expected %q", underlying, test.underlying)
+			}
+		}
+
+		if test.methods != "" {
+			nt := typ.(*types.Named)
+			var buf bytes.Buffer
+			for i := 0; i != nt.NumMethods(); i++ {
+				buf.WriteString(nt.Method(i).String())
+			}
+			methods := buf.String()
+			if methods != test.methods {
+				t.Errorf("got methods %q, expected %q", methods, test.methods)
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/alias.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/alias.gox
new file mode 100644
index 0000000..ced7d84
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/alias.gox
@@ -0,0 +1,4 @@
+v1;
+package alias;
+pkgpath alias;
+type <type 115 "I1" <type 116 interface { M1 (? <type 117 "IntAlias2" = <type 118 "IntAlias" = <type 119 "Int" <type -11>>>>) < type 114>; M2 () <type 1>; }>>;
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.go
new file mode 100644
index 0000000..a51b6b0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.go
@@ -0,0 +1,6 @@
+package complexnums
+
+const NN = -1 - 1i
+const NP = -1 + 1i
+const PN = 1 - 1i
+const PP = 1 + 1i
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.gox
new file mode 100644
index 0000000..b66524f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/complexnums.gox
@@ -0,0 +1,8 @@
+v1;
+package complexnums;
+pkgpath complexnums;
+priority 1;
+const NN = -0.1E1-0.1E1i ;
+const NP = -0.1E1+0.1E1i ;
+const PN = 0.1E1-0.1E1i ;
+const PP = 0.1E1+0.1E1i ;
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.go
new file mode 100644
index 0000000..653927a
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.go
@@ -0,0 +1,5 @@
+package conversions
+
+type Units string
+
+const Bits = Units("bits")
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.gox
new file mode 100644
index 0000000..7de6cda
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/conversions.gox
@@ -0,0 +1,6 @@
+v2;
+package conversions;
+prefix go;
+package conversions go.conversions go.conversions;
+const Bits <type 1 "Units" <type -16>> = convert(<type 1>, "bits");
+type <type 1>;
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.go
new file mode 100644
index 0000000..103ad95
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.go
@@ -0,0 +1,13 @@
+// Test case for escape info in export data. To compile and extract .gox file:
+// gccgo -fgo-optimize-allocs -c escapeinfo.go
+// objcopy -j .go_export escapeinfo.o escapeinfo.gox
+
+package escapeinfo
+
+type T struct{ data []byte }
+
+func NewT(data []byte) *T {
+	return &T{data}
+}
+
+func (*T) Read(p []byte) {}
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.gox
new file mode 100644
index 0000000..1db8156
Binary files /dev/null and b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/escapeinfo.gox differ
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.go
new file mode 100644
index 0000000..7907316
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.go
@@ -0,0 +1,5 @@
+package imports
+
+import "fmt"
+
+var Hello = fmt.Sprintf("Hello, world")
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.gox
new file mode 100644
index 0000000..958a4f5
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/imports.gox
@@ -0,0 +1,7 @@
+v1;
+package imports;
+pkgpath imports;
+priority 7;
+import fmt fmt "fmt";
+init imports imports..import 7 math math..import 1 runtime runtime..import 1 strconv strconv..import 2 io io..import 3 reflect reflect..import 3 syscall syscall..import 3 time time..import 4 os os..import 5 fmt fmt..import 6;
+var Hello <type -16>;
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.go
new file mode 100644
index 0000000..4ebc671
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.go
@@ -0,0 +1,3 @@
+package pointer
+
+type Int8Ptr *int8
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.gox
new file mode 100644
index 0000000..d96ebbd
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/pointer.gox
@@ -0,0 +1,4 @@
+v1;
+package pointer;
+pkgpath pointer;
+type <type 1 "Int8Ptr" <type 2 *<type -1>>>;
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/time.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/time.gox
new file mode 100644
index 0000000..80c2dbc
Binary files /dev/null and b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/time.gox differ
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/unicode.gox b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/unicode.gox
new file mode 100644
index 0000000..e70e539
Binary files /dev/null and b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testdata/unicode.gox differ
diff --git a/vendor/golang.org/x/tools/go/internal/gccgoimporter/testenv_test.go b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testenv_test.go
new file mode 100644
index 0000000..10c11fd
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gccgoimporter/testenv_test.go
@@ -0,0 +1,40 @@
+package gccgoimporter
+
+// This file contains testing utilities copied from $GOROOT/src/internal/testenv/testenv.go.
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// HasGoBuild reports whether the current system can build programs with ``go build''
+// and then run them with os.StartProcess or exec.Command.
+func HasGoBuild() bool {
+	switch runtime.GOOS {
+	case "android", "nacl":
+		return false
+	case "darwin":
+		if strings.HasPrefix(runtime.GOARCH, "arm") {
+			return false
+		}
+	}
+	return true
+}
+
+// MustHaveGoBuild checks that the current system can build programs with ``go build''
+// and then run them with os.StartProcess or exec.Command.
+// If not, MustHaveGoBuild calls t.Skip with an explanation.
+func MustHaveGoBuild(t *testing.T) {
+	if !HasGoBuild() {
+		t.Skipf("skipping test: 'go build' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+}
+
+var testenv = struct {
+	HasGoBuild      func() bool
+	MustHaveGoBuild func(*testing.T)
+}{
+	HasGoBuild:      HasGoBuild,
+	MustHaveGoBuild: MustHaveGoBuild,
+}
diff --git a/vendor/golang.org/x/tools/go/loader/cgo.go b/vendor/golang.org/x/tools/go/loader/cgo.go
index 299e725..72c6f50 100644
--- a/vendor/golang.org/x/tools/go/loader/cgo.go
+++ b/vendor/golang.org/x/tools/go/loader/cgo.go
@@ -1,3 +1,7 @@
+// 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"`.
@@ -33,7 +37,7 @@ package loader
 // 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, oracle, and eg happy.  However, the approach was rejected
+// 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.)
 //
@@ -87,9 +91,9 @@ func processCgoFiles(bp *build.Package, fset *token.FileSet, DisplayPath func(pa
 		if err != nil {
 			return nil, err
 		}
-		defer rd.Close()
 		display := filepath.Join(bp.Dir, cgoDisplayFiles[i])
 		f, err := parser.ParseFile(fset, display, rd, mode)
+		rd.Close()
 		if err != nil {
 			return nil, err
 		}
@@ -106,14 +110,18 @@ var cgoRe = regexp.MustCompile(`[/\\:]`)
 //
 // runCgo is adapted from (*builder).cgo in
 // $GOROOT/src/cmd/go/build.go, but these features are unsupported:
-// pkg-config, Objective C, CGOPKGPATH, CGO_FLAGS.
+// 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 {
-		return nil, nil, fmt.Errorf("cgo pkg-config not supported")
+		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.
diff --git a/vendor/golang.org/x/tools/go/loader/cgo_pkgconfig.go b/vendor/golang.org/x/tools/go/loader/cgo_pkgconfig.go
new file mode 100644
index 0000000..de57422
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/loader/doc.go b/vendor/golang.org/x/tools/go/loader/doc.go
index 1ff4b15..9b51c9e 100644
--- a/vendor/golang.org/x/tools/go/loader/doc.go
+++ b/vendor/golang.org/x/tools/go/loader/doc.go
@@ -50,6 +50,11 @@
 //
 // 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.
@@ -59,14 +64,25 @@
 // same directory.  (go/build.Package calls these files XTestFiles.)
 //
 // An IMPORTABLE package is one that can be referred to by some import
-// spec.  The Path() of each importable package is unique within a
-// Program.
+// 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
+// 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 called "main".
+// 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.
@@ -125,7 +141,7 @@ package loader
 // 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 import path.  The remaining nodes are
+// 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.
 //
@@ -144,7 +160,7 @@ package loader
 // parallel, where "unrelated" means not ordered by the partial order of
 // the import dependency graph.
 //
-// We use a concurrency-safe blocking cache (importer.imported) to
+// 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
diff --git a/vendor/golang.org/x/tools/go/loader/example_test.go b/vendor/golang.org/x/tools/go/loader/example_test.go
new file mode 100644
index 0000000..88adde3
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/example_test.go
@@ -0,0 +1,179 @@
+// 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 go1.8,!go1.9 // TODO(adonovan) determine which versions we need to test here
+// +build !windows
+
+package loader_test
+
+import (
+	"fmt"
+	"go/token"
+	"log"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+
+	"golang.org/x/tools/go/loader"
+)
+
+func printProgram(prog *loader.Program) {
+	// Created packages are the initial packages specified by a call
+	// to CreateFromFilenames or CreateFromFiles.
+	var names []string
+	for _, info := range prog.Created {
+		names = append(names, info.Pkg.Path())
+	}
+	fmt.Printf("created: %s\n", names)
+
+	// Imported packages are the initial packages specified by a
+	// call to Import or ImportWithTests.
+	names = nil
+	for _, info := range prog.Imported {
+		if strings.Contains(info.Pkg.Path(), "internal") {
+			continue // skip, to reduce fragility
+		}
+		names = append(names, info.Pkg.Path())
+	}
+	sort.Strings(names)
+	fmt.Printf("imported: %s\n", names)
+
+	// InitialPackages contains the union of created and imported.
+	names = nil
+	for _, info := range prog.InitialPackages() {
+		names = append(names, info.Pkg.Path())
+	}
+	sort.Strings(names)
+	fmt.Printf("initial: %s\n", names)
+
+	// AllPackages contains all initial packages and their dependencies.
+	names = nil
+	for pkg := range prog.AllPackages {
+		names = append(names, pkg.Path())
+	}
+	sort.Strings(names)
+	fmt.Printf("all: %s\n", names)
+}
+
+func printFilenames(fset *token.FileSet, info *loader.PackageInfo) {
+	var names []string
+	for _, f := range info.Files {
+		names = append(names, filepath.Base(fset.File(f.Pos()).Name()))
+	}
+	fmt.Printf("%s.Files: %s\n", info.Pkg.Path(), names)
+}
+
+// This example loads a set of packages and all of their dependencies
+// from a typical command-line.  FromArgs parses a command line and
+// makes calls to the other methods of Config shown in the examples that
+// follow.
+func ExampleConfig_FromArgs() {
+	args := []string{"mytool", "unicode/utf8", "errors", "runtime", "--", "foo", "bar"}
+	const wantTests = false
+
+	var conf loader.Config
+	rest, err := conf.FromArgs(args[1:], wantTests)
+	prog, err := conf.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("rest: %s\n", rest)
+	printProgram(prog)
+	// Output:
+	// rest: [foo bar]
+	// created: []
+	// imported: [errors runtime unicode/utf8]
+	// initial: [errors runtime unicode/utf8]
+	// all: [errors runtime runtime/internal/atomic runtime/internal/sys unicode/utf8 unsafe]
+}
+
+// This example creates and type-checks a single package (without tests)
+// from a list of filenames, and loads all of its dependencies.
+// (The input files are actually only a small part of the math/cmplx package.)
+func ExampleConfig_CreateFromFilenames() {
+	var conf loader.Config
+	conf.CreateFromFilenames("math/cmplx",
+		filepath.Join(runtime.GOROOT(), "src/math/cmplx/abs.go"),
+		filepath.Join(runtime.GOROOT(), "src/math/cmplx/sin.go"))
+	prog, err := conf.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	printProgram(prog)
+	// Output:
+	// created: [math/cmplx]
+	// imported: []
+	// initial: [math/cmplx]
+	// all: [math math/cmplx unsafe]
+}
+
+// In the examples below, for stability, the chosen packages are
+// relatively small, platform-independent, and low-level (and thus
+// infrequently changing).
+// The strconv package has internal and external tests.
+
+const hello = `package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, world.")
+}
+`
+
+// This example creates and type-checks a package from a list of
+// already-parsed files, and loads all its dependencies.
+func ExampleConfig_CreateFromFiles() {
+	var conf loader.Config
+	f, err := conf.ParseFile("hello.go", hello)
+	if err != nil {
+		log.Fatal(err)
+	}
+	conf.CreateFromFiles("hello", f)
+	prog, err := conf.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	printProgram(prog)
+	printFilenames(prog.Fset, prog.Package("strconv"))
+	// Output:
+	// created: [hello]
+	// imported: []
+	// initial: [hello]
+	// all: [errors fmt hello internal/race io math os reflect runtime runtime/internal/atomic runtime/internal/sys strconv sync sync/atomic syscall time unicode/utf8 unsafe]
+	// strconv.Files: [atob.go atof.go atoi.go decimal.go doc.go extfloat.go ftoa.go isprint.go itoa.go quote.go]
+}
+
+// This example imports three packages, including the tests for one of
+// them, and loads all their dependencies.
+func ExampleConfig_Import() {
+	// ImportWithTest("strconv") causes strconv to include
+	// internal_test.go, and creates an external test package,
+	// strconv_test.
+	// (Compare with the example of CreateFromFiles.)
+
+	var conf loader.Config
+	conf.Import("unicode/utf8")
+	conf.Import("errors")
+	conf.ImportWithTests("strconv")
+	prog, err := conf.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	printProgram(prog)
+	printFilenames(prog.Fset, prog.Package("strconv"))
+	printFilenames(prog.Fset, prog.Package("strconv_test"))
+	// Output:
+	// created: [strconv_test]
+	// imported: [errors strconv unicode/utf8]
+	// initial: [errors strconv strconv_test unicode/utf8]
+	// all: [bufio bytes errors flag fmt internal/race io log math math/rand os reflect runtime runtime/debug runtime/internal/atomic runtime/internal/sys runtime/trace sort strconv strconv_test strings sync sync/atomic syscall testing time unicode unicode/utf8 unsafe]
+	// strconv.Files: [atob.go atof.go atoi.go decimal.go doc.go extfloat.go ftoa.go isprint.go itoa.go quote.go internal_test.go]
+	// strconv_test.Files: [atob_test.go atof_test.go atoi_test.go decimal_test.go example_test.go fp_test.go ftoa_test.go itoa_test.go quote_test.go strconv_test.go]
+}
diff --git a/vendor/golang.org/x/tools/go/loader/loader.go b/vendor/golang.org/x/tools/go/loader/loader.go
index bbacc5b..de756f7 100644
--- a/vendor/golang.org/x/tools/go/loader/loader.go
+++ b/vendor/golang.org/x/tools/go/loader/loader.go
@@ -13,16 +13,19 @@ import (
 	"go/build"
 	"go/parser"
 	"go/token"
+	"go/types"
 	"os"
+	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
 	"time"
 
 	"golang.org/x/tools/go/ast/astutil"
-	"golang.org/x/tools/go/types"
 )
 
+var ignoreVendor build.ImportMode
+
 const trace = false // show timing info for type-checking
 
 // Config specifies the configuration for loading a whole program from
@@ -45,13 +48,13 @@ type Config struct {
 	// The supplied Import function is not used either.
 	TypeChecker types.Config
 
-	// TypeCheckFuncBodies is a predicate over package import
-	// paths.  A package for which the predicate is false will
+	// 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(string) bool
+	TypeCheckFuncBodies func(path string) bool
 
 	// If Build is non-nil, it is used to locate source packages.
 	// Otherwise &build.Default is used.
@@ -84,9 +87,8 @@ type Config struct {
 	// the corresponding elements of the Program.Created slice.
 	CreatePkgs []PkgSpec
 
-	// ImportPkgs specifies a set of initial packages to load from
-	// source.  The map keys are package import paths, used to
-	// locate the package relative to $GOROOT.
+	// 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:
@@ -96,21 +98,43 @@ type Config struct {
 	ImportPkgs map[string]bool
 
 	// FindPackage is called during Load to create the build.Package
-	// for a given import path.  If nil, a default implementation
-	// based on ctxt.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.
+	// 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 string) (*build.Package, error)
+	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      // import path ("" => use package declaration)
+	Path      string      // package path ("" => use package declaration)
 	Files     []*ast.File // ASTs of already-parsed files
 	Filenames []string    // names of files to be parsed
 }
@@ -123,6 +147,15 @@ type Program struct {
 	// 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,
@@ -134,7 +167,7 @@ type Program struct {
 	// dependencies, including incomplete ones.
 	AllPackages map[*types.Package]*PackageInfo
 
-	// importMap is the canonical mapping of import paths to
+	// 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
@@ -152,6 +185,7 @@ type PackageInfo struct {
 	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)
@@ -294,7 +328,7 @@ func (conf *Config) ImportWithTests(path string) { conf.addImport(path, true) }
 func (conf *Config) Import(path string) { conf.addImport(path, false) }
 
 func (conf *Config) addImport(path string, tests bool) {
-	if path == "C" || path == "unsafe" {
+	if path == "C" {
 		return // ignore; not a real package
 	}
 	if conf.ImportPkgs == nil {
@@ -366,6 +400,10 @@ type importer struct {
 	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
 
@@ -378,6 +416,18 @@ type importer struct {
 	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:
@@ -385,35 +435,30 @@ type importer struct {
 // A successful package may still contain type errors.
 //
 type importInfo struct {
-	path     string       // import path
-	mu       sync.Mutex   // guards the following fields prior to completion
-	info     *PackageInfo // results of typechecking (including errors)
-	err      error        // reason for failure to create a package
-	complete sync.Cond    // complete condition is that one of info, err is non-nil.
+	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 and err fields are safe to inspect without a lock.
-// It is concurrency-safe and idempotent.
+// i.e. the info field is safe to inspect.
 func (ii *importInfo) awaitCompletion() {
-	ii.mu.Lock()
-	for ii.info == nil && ii.err == nil {
-		ii.complete.Wait()
-	}
-	ii.mu.Unlock()
+	<-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, err error) {
-	if info == nil && err == nil {
-		panic("Complete(nil, nil)")
+func (ii *importInfo) Complete(info *PackageInfo) {
+	if info == nil {
+		panic("info == nil")
 	}
-	ii.mu.Lock()
 	ii.info = info
-	ii.err = err
-	ii.complete.Broadcast()
-	ii.mu.Unlock()
+	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,
@@ -446,15 +491,7 @@ func (conf *Config) Load() (*Program, error) {
 
 	// Install default FindPackage hook using go/build logic.
 	if conf.FindPackage == nil {
-		conf.FindPackage = func(ctxt *build.Context, path string) (*build.Package, error) {
-			// TODO(adonovan): cache calls to build.Import
-			// so we don't do it three times per test package.
-			bp, err := ctxt.Import(path, conf.Cwd, 0)
-			if _, ok := err.(*build.NoGoError); ok {
-				return bp, nil // empty directory is not an error
-			}
-			return bp, err
-		}
+		conf.FindPackage = (*build.Context).Import
 	}
 
 	prog := &Program{
@@ -467,6 +504,7 @@ func (conf *Config) Load() (*Program, error) {
 	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),
@@ -478,24 +516,26 @@ func (conf *Config) Load() (*Program, error) {
 
 	// Load the initially imported packages and their dependencies,
 	// in parallel.
-	for _, ii := range imp.loadAll("", conf.ImportPkgs) {
-		if ii.err != nil {
-			conf.TypeChecker.Error(ii.err) // failed to create package
-			errpkgs = append(errpkgs, ii.path)
-			continue
-		}
-		prog.Imported[ii.info.Pkg.Path()] = ii.info
+	// 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 path, augment := range conf.ImportPkgs {
+	for importPath, augment := range conf.ImportPkgs {
 		if !augment {
 			continue
 		}
 
-		bp, err := conf.FindPackage(conf.build(), path)
+		// 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.
@@ -507,12 +547,14 @@ func (conf *Config) Load() (*Program, error) {
 			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 loadAll and thus
+			// 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))
@@ -524,19 +566,10 @@ func (conf *Config) Load() (*Program, error) {
 			// that at least one of ii.err and ii.info is non-nil.
 			panic(fmt.Sprintf("imported[%q] == nil", path))
 		}
-		if ii.err != nil {
-			// The sole possible cause is failure of the
-			// FindPackage call in (*importer).load,
-			// but we rechecked that condition above.
-			// Perhaps the state of the file system changed
-			// in between?  Seems unlikely.
-			panic(fmt.Sprintf("imported[%q].err = %v", path, ii.err))
-		}
 		if ii.info == nil {
 			// Unreachable.
-			// Complete has this postcondition:
-			// 	ii.err != nil || ii.info != nil
-			// and we know that ii.err == nil here.
+			// awaitCompletion has the postcondition
+			// ii.info != nil.
 			panic(fmt.Sprintf("imported[%q].info = nil", path))
 		}
 		info := ii.info
@@ -554,8 +587,8 @@ func (conf *Config) Load() (*Program, error) {
 		imp.addFiles(info, files, false)
 	}
 
-	createPkg := func(path string, files []*ast.File, errs []error) {
-		info := imp.newPackageInfo(path)
+	createPkg := func(path, dir string, files []*ast.File, errs []error) {
+		info := imp.newPackageInfo(path, dir)
 		for _, err := range errs {
 			info.appendError(err)
 		}
@@ -569,7 +602,7 @@ func (conf *Config) Load() (*Program, error) {
 
 	// Create packages specified by conf.CreatePkgs.
 	for _, cp := range conf.CreatePkgs {
-		files, errs := parseFiles(conf.fset(), conf.build(), nil, ".", cp.Filenames, conf.ParserMode)
+		files, errs := parseFiles(conf.fset(), conf.build(), nil, conf.Cwd, cp.Filenames, conf.ParserMode)
 		files = append(files, cp.Files...)
 
 		path := cp.Path
@@ -580,14 +613,19 @@ func (conf *Config) Load() (*Program, error) {
 				path = "(unnamed)"
 			}
 		}
-		createPkg(path, files, errs)
+
+		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", files, errs)
+		createPkg(bp.ImportPath+"_test", bp.Dir, files, errs)
 	}
 
 	// -- finishing up (sequential) ----------------------------------------
@@ -697,6 +735,9 @@ func (conf *Config) build() *build.Context {
 //    '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':
@@ -727,8 +768,6 @@ func (conf *Config) parsePackageFiles(bp *build.Package, which rune) ([]*ast.Fil
 // doImport imports the package denoted by path.
 // It implements the types.Importer signature.
 //
-// imports is the type-checker's package canonicalization map.
-//
 // 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
@@ -737,11 +776,6 @@ func (conf *Config) parsePackageFiles(bp *build.Package, which rune) ([]*ast.Fil
 // Idempotent.
 //
 func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, error) {
-	// Package unsafe is handled specially, and has no PackageInfo.
-	// TODO(adonovan): move this check into go/types?
-	if to == "unsafe" {
-		return types.Unsafe, nil
-	}
 	if to == "C" {
 		// This should be unreachable, but ad hoc packages are
 		// not currently subject to cgo preprocessing.
@@ -750,14 +784,24 @@ func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, err
 			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[to]
+	ii := imp.imported[path]
 	imp.importedMu.Unlock()
 	if ii == nil {
-		panic("internal error: unexpected import: " + to)
-	}
-	if ii.err != nil {
-		return nil, ii.err
+		panic("internal error: unexpected import: " + path)
 	}
 	if ii.info != nil {
 		return ii.info.Pkg, nil
@@ -765,7 +809,7 @@ func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, err
 
 	// Import of incomplete package: this indicates a cycle.
 	fromPath := from.Pkg.Path()
-	if cycle := imp.findPath(to, fromPath); cycle != nil {
+	if cycle := imp.findPath(path, fromPath); cycle != nil {
 		cycle = append([]string{fromPath}, cycle...)
 		return nil, fmt.Errorf("import cycle: %s", strings.Join(cycle, " -> "))
 	}
@@ -773,16 +817,62 @@ func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, err
 	panic("internal error: import of incomplete (yet acyclic) package: " + fromPath)
 }
 
-// loadAll loads, parses, and type-checks the specified packages in
+// 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 import path of the importing package, if it is
+// fromPath is the package path of the importing package, if it is
 // importable, "" otherwise.  It is used for cycle detection.
 //
-func (imp *importer) loadAll(fromPath string, paths map[string]bool) []*importInfo {
-	result := make([]*importInfo, 0, len(paths))
-	for path := range paths {
-		result = append(result, imp.startLoad(path))
+// 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 != "" {
@@ -796,13 +886,13 @@ func (imp *importer) loadAll(fromPath string, paths map[string]bool) []*importIn
 			deps = make(map[string]bool)
 			imp.graph[fromPath] = deps
 		}
-		for path := range paths {
-			deps[path] = true
+		for _, ii := range pending {
+			deps[ii.path] = true
 		}
 		imp.graphMu.Unlock()
 	}
 
-	for _, ii := range result {
+	for _, ii := range pending {
 		if fromPath != "" {
 			if cycle := imp.findPath(ii.path, fromPath); cycle != nil {
 				// Cycle-forming import: we must not await its
@@ -814,14 +904,16 @@ func (imp *importer) loadAll(fromPath string, paths map[string]bool) []*importIn
 				// (Also it would complicate the
 				// invariants of importPath completion.)
 				if trace {
-					fmt.Fprintln(os.Stderr, "import cycle: %q", cycle)
+					fmt.Fprintf(os.Stderr, "import cycle: %q\n", cycle)
 				}
 				continue
 			}
 		}
 		ii.awaitCompletion()
+		infos = append(infos, ii.info)
 	}
-	return result
+
+	return infos, errors
 }
 
 // findPath returns an arbitrary path from 'from' to 'to' in the import
@@ -854,20 +946,20 @@ func (imp *importer) findPath(from, to string) []string {
 // 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 and err
-// fields.
+// caller must call awaitCompletion() before accessing its info field.
 //
 // startLoad is concurrency-safe and idempotent.
 //
-func (imp *importer) startLoad(path string) *importInfo {
+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}
-		ii.complete.L = &ii.mu
+		ii = &importInfo{path: path, complete: make(chan struct{})}
 		imp.imported[path] = ii
 		go func() {
-			ii.Complete(imp.load(path))
+			info := imp.load(bp)
+			ii.Complete(info)
 		}()
 	}
 	imp.importedMu.Unlock()
@@ -877,13 +969,8 @@ func (imp *importer) startLoad(path string) *importInfo {
 
 // load implements package loading by parsing Go source files
 // located by go/build.
-//
-func (imp *importer) load(path string) (*PackageInfo, error) {
-	bp, err := imp.conf.FindPackage(imp.conf.build(), path)
-	if err != nil {
-		return nil, err // package not found
-	}
-	info := imp.newPackageInfo(bp.ImportPath)
+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 {
@@ -893,10 +980,10 @@ func (imp *importer) load(path string) (*PackageInfo, error) {
 	imp.addFiles(info, files, true)
 
 	imp.progMu.Lock()
-	imp.prog.importMap[path] = info.Pkg
+	imp.prog.importMap[bp.ImportPath] = info.Pkg
 	imp.progMu.Unlock()
 
-	return info, nil
+	return info
 }
 
 // addFiles adds and type-checks the specified files to info, loading
@@ -908,23 +995,36 @@ func (imp *importer) load(path string) (*PackageInfo, error) {
 // dependency edges that should be checked for potential cycles.
 //
 func (imp *importer) addFiles(info *PackageInfo, files []*ast.File, cycleCheck bool) {
-	info.Files = append(info.Files, files...)
-
 	// Ensure the dependencies are loaded, in parallel.
 	var fromPath string
 	if cycleCheck {
 		fromPath = info.Pkg.Path()
 	}
-	imp.loadAll(fromPath, scanImports(files))
+	// 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))
 	}
 
-	// Ignore the returned (first) error since we
-	// already collect them all in the PackageInfo.
-	info.checker.Files(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",
@@ -932,8 +1032,13 @@ func (imp *importer) addFiles(info *PackageInfo, files []*ast.File, cycleCheck b
 	}
 }
 
-func (imp *importer) newPackageInfo(path string) *PackageInfo {
-	pkg := types.NewPackage(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{
@@ -945,6 +1050,7 @@ func (imp *importer) newPackageInfo(path string) *PackageInfo {
 			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.
@@ -953,9 +1059,7 @@ func (imp *importer) newPackageInfo(path string) *PackageInfo {
 	if f := imp.conf.TypeCheckFuncBodies; f != nil {
 		tc.IgnoreFuncBodies = !f(path)
 	}
-	tc.Import = func(_ map[string]*types.Package, to string) (*types.Package, error) {
-		return imp.doImport(info, to)
-	}
+	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)
@@ -964,3 +1068,10 @@ func (imp *importer) newPackageInfo(path string) *PackageInfo {
 	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/vendor/golang.org/x/tools/go/loader/loader_test.go b/vendor/golang.org/x/tools/go/loader/loader_test.go
new file mode 100644
index 0000000..02630eb
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/loader_test.go
@@ -0,0 +1,816 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package loader_test
+
+import (
+	"fmt"
+	"go/build"
+	"go/constant"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+)
+
+// TestFromArgs checks that conf.FromArgs populates conf correctly.
+// It does no I/O.
+func TestFromArgs(t *testing.T) {
+	type result struct {
+		Err        string
+		Rest       []string
+		ImportPkgs map[string]bool
+		CreatePkgs []loader.PkgSpec
+	}
+	for _, test := range []struct {
+		args  []string
+		tests bool
+		want  result
+	}{
+		// Mix of existing and non-existent packages.
+		{
+			args: []string{"nosuchpkg", "errors"},
+			want: result{
+				ImportPkgs: map[string]bool{"errors": false, "nosuchpkg": false},
+			},
+		},
+		// Same, with -test flag.
+		{
+			args:  []string{"nosuchpkg", "errors"},
+			tests: true,
+			want: result{
+				ImportPkgs: map[string]bool{"errors": true, "nosuchpkg": true},
+			},
+		},
+		// Surplus arguments.
+		{
+			args: []string{"fmt", "errors", "--", "surplus"},
+			want: result{
+				Rest:       []string{"surplus"},
+				ImportPkgs: map[string]bool{"errors": false, "fmt": false},
+			},
+		},
+		// Ad hoc package specified as *.go files.
+		{
+			args: []string{"foo.go", "bar.go"},
+			want: result{CreatePkgs: []loader.PkgSpec{{
+				Filenames: []string{"foo.go", "bar.go"},
+			}}},
+		},
+		// Mixture of *.go and import paths.
+		{
+			args: []string{"foo.go", "fmt"},
+			want: result{
+				Err: "named files must be .go files: fmt",
+			},
+		},
+	} {
+		var conf loader.Config
+		rest, err := conf.FromArgs(test.args, test.tests)
+		got := result{
+			Rest:       rest,
+			ImportPkgs: conf.ImportPkgs,
+			CreatePkgs: conf.CreatePkgs,
+		}
+		if err != nil {
+			got.Err = err.Error()
+		}
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("FromArgs(%q) = %+v, want %+v", test.args, got, test.want)
+		}
+	}
+}
+
+func TestLoad_NoInitialPackages(t *testing.T) {
+	var conf loader.Config
+
+	const wantErr = "no initial packages were loaded"
+
+	prog, err := conf.Load()
+	if err == nil {
+		t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+	} else if err.Error() != wantErr {
+		t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+	}
+	if prog != nil {
+		t.Errorf("Load unexpectedly returned a Program")
+	}
+}
+
+func TestLoad_MissingInitialPackage(t *testing.T) {
+	var conf loader.Config
+	conf.Import("nosuchpkg")
+	conf.Import("errors")
+
+	const wantErr = "couldn't load packages due to errors: nosuchpkg"
+
+	prog, err := conf.Load()
+	if err == nil {
+		t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+	} else if err.Error() != wantErr {
+		t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+	}
+	if prog != nil {
+		t.Errorf("Load unexpectedly returned a Program")
+	}
+}
+
+func TestLoad_MissingInitialPackage_AllowErrors(t *testing.T) {
+	var conf loader.Config
+	conf.AllowErrors = true
+	conf.Import("nosuchpkg")
+	conf.ImportWithTests("errors")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed unexpectedly: %v", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned a nil Program")
+	}
+	if got, want := created(prog), "errors_test"; got != want {
+		t.Errorf("Created = %s, want %s", got, want)
+	}
+	if got, want := imported(prog), "errors"; got != want {
+		t.Errorf("Imported = %s, want %s", got, want)
+	}
+}
+
+func TestCreateUnnamedPackage(t *testing.T) {
+	var conf loader.Config
+	conf.CreateFromFilenames("")
+	prog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load failed: %v", err)
+	}
+	if got, want := fmt.Sprint(prog.InitialPackages()), "[(unnamed)]"; got != want {
+		t.Errorf("InitialPackages = %s, want %s", got, want)
+	}
+}
+
+func TestLoad_MissingFileInCreatedPackage(t *testing.T) {
+	var conf loader.Config
+	conf.CreateFromFilenames("", "missing.go")
+
+	const wantErr = "couldn't load packages due to errors: (unnamed)"
+
+	prog, err := conf.Load()
+	if prog != nil {
+		t.Errorf("Load unexpectedly returned a Program")
+	}
+	if err == nil {
+		t.Fatalf("Load succeeded unexpectedly, want %q", wantErr)
+	}
+	if err.Error() != wantErr {
+		t.Fatalf("Load failed with wrong error %q, want %q", err, wantErr)
+	}
+}
+
+func TestLoad_MissingFileInCreatedPackage_AllowErrors(t *testing.T) {
+	conf := loader.Config{AllowErrors: true}
+	conf.CreateFromFilenames("", "missing.go")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed: %v", err)
+	}
+	if got, want := fmt.Sprint(prog.InitialPackages()), "[(unnamed)]"; got != want {
+		t.Fatalf("InitialPackages = %s, want %s", got, want)
+	}
+}
+
+func TestLoad_ParseError(t *testing.T) {
+	var conf loader.Config
+	conf.CreateFromFilenames("badpkg", "testdata/badpkgdecl.go")
+
+	const wantErr = "couldn't load packages due to errors: badpkg"
+
+	prog, err := conf.Load()
+	if prog != nil {
+		t.Errorf("Load unexpectedly returned a Program")
+	}
+	if err == nil {
+		t.Fatalf("Load succeeded unexpectedly, want %q", wantErr)
+	}
+	if err.Error() != wantErr {
+		t.Fatalf("Load failed with wrong error %q, want %q", err, wantErr)
+	}
+}
+
+func TestLoad_ParseError_AllowErrors(t *testing.T) {
+	var conf loader.Config
+	conf.AllowErrors = true
+	conf.CreateFromFilenames("badpkg", "testdata/badpkgdecl.go")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed unexpectedly: %v", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned a nil Program")
+	}
+	if got, want := created(prog), "badpkg"; got != want {
+		t.Errorf("Created = %s, want %s", got, want)
+	}
+
+	badpkg := prog.Created[0]
+	if len(badpkg.Files) != 1 {
+		t.Errorf("badpkg has %d files, want 1", len(badpkg.Files))
+	}
+	wantErr := filepath.Join("testdata", "badpkgdecl.go") + ":1:34: expected 'package', found 'EOF'"
+	if !hasError(badpkg.Errors, wantErr) {
+		t.Errorf("badpkg.Errors = %v, want %s", badpkg.Errors, wantErr)
+	}
+}
+
+func TestLoad_FromSource_Success(t *testing.T) {
+	var conf loader.Config
+	conf.CreateFromFilenames("P", "testdata/a.go", "testdata/b.go")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed unexpectedly: %v", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned a nil Program")
+	}
+	if got, want := created(prog), "P"; got != want {
+		t.Errorf("Created = %s, want %s", got, want)
+	}
+}
+
+func TestLoad_FromImports_Success(t *testing.T) {
+	var conf loader.Config
+	conf.ImportWithTests("fmt")
+	conf.ImportWithTests("errors")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed unexpectedly: %v", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned a nil Program")
+	}
+	if got, want := created(prog), "errors_test fmt_test"; got != want {
+		t.Errorf("Created = %q, want %s", got, want)
+	}
+	if got, want := imported(prog), "errors fmt"; got != want {
+		t.Errorf("Imported = %s, want %s", got, want)
+	}
+	// Check set of transitive packages.
+	// There are >30 and the set may grow over time, so only check a few.
+	want := map[string]bool{
+		"strings": true,
+		"time":    true,
+		"runtime": true,
+		"testing": true,
+		"unicode": true,
+	}
+	for _, path := range all(prog) {
+		delete(want, path)
+	}
+	if len(want) > 0 {
+		t.Errorf("AllPackages is missing these keys: %q", keys(want))
+	}
+}
+
+func TestLoad_MissingIndirectImport(t *testing.T) {
+	pkgs := map[string]string{
+		"a": `package a; import _ "b"`,
+		"b": `package b; import _ "c"`,
+	}
+	conf := loader.Config{Build: fakeContext(pkgs)}
+	conf.Import("a")
+
+	const wantErr = "couldn't load packages due to errors: b"
+
+	prog, err := conf.Load()
+	if err == nil {
+		t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+	} else if err.Error() != wantErr {
+		t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+	}
+	if prog != nil {
+		t.Errorf("Load unexpectedly returned a Program")
+	}
+}
+
+func TestLoad_BadDependency_AllowErrors(t *testing.T) {
+	for _, test := range []struct {
+		descr    string
+		pkgs     map[string]string
+		wantPkgs string
+	}{
+
+		{
+			descr: "missing dependency",
+			pkgs: map[string]string{
+				"a": `package a; import _ "b"`,
+				"b": `package b; import _ "c"`,
+			},
+			wantPkgs: "a b",
+		},
+		{
+			descr: "bad package decl in dependency",
+			pkgs: map[string]string{
+				"a": `package a; import _ "b"`,
+				"b": `package b; import _ "c"`,
+				"c": `package`,
+			},
+			wantPkgs: "a b",
+		},
+		{
+			descr: "parse error in dependency",
+			pkgs: map[string]string{
+				"a": `package a; import _ "b"`,
+				"b": `package b; import _ "c"`,
+				"c": `package c; var x = `,
+			},
+			wantPkgs: "a b c",
+		},
+	} {
+		conf := loader.Config{
+			AllowErrors: true,
+			Build:       fakeContext(test.pkgs),
+		}
+		conf.Import("a")
+
+		prog, err := conf.Load()
+		if err != nil {
+			t.Errorf("%s: Load failed unexpectedly: %v", test.descr, err)
+		}
+		if prog == nil {
+			t.Fatalf("%s: Load returned a nil Program", test.descr)
+		}
+
+		if got, want := imported(prog), "a"; got != want {
+			t.Errorf("%s: Imported = %s, want %s", test.descr, got, want)
+		}
+		if got := all(prog); strings.Join(got, " ") != test.wantPkgs {
+			t.Errorf("%s: AllPackages = %s, want %s", test.descr, got, test.wantPkgs)
+		}
+	}
+}
+
+func TestCwd(t *testing.T) {
+	ctxt := fakeContext(map[string]string{"one/two/three": `package three`})
+	for _, test := range []struct {
+		cwd, arg, want string
+	}{
+		{cwd: "/go/src/one", arg: "./two/three", want: "one/two/three"},
+		{cwd: "/go/src/one", arg: "../one/two/three", want: "one/two/three"},
+		{cwd: "/go/src/one", arg: "one/two/three", want: "one/two/three"},
+		{cwd: "/go/src/one/two/three", arg: ".", want: "one/two/three"},
+		{cwd: "/go/src/one", arg: "two/three", want: ""},
+	} {
+		conf := loader.Config{
+			Cwd:   test.cwd,
+			Build: ctxt,
+		}
+		conf.Import(test.arg)
+
+		var got string
+		prog, err := conf.Load()
+		if prog != nil {
+			got = imported(prog)
+		}
+		if got != test.want {
+			t.Errorf("Load(%s) from %s: Imported = %s, want %s",
+				test.arg, test.cwd, got, test.want)
+			if err != nil {
+				t.Errorf("Load failed: %v", err)
+			}
+		}
+	}
+}
+
+func TestLoad_vendor(t *testing.T) {
+	pkgs := map[string]string{
+		"a":          `package a; import _ "x"`,
+		"a/vendor":   ``, // mkdir a/vendor
+		"a/vendor/x": `package xa`,
+		"b":          `package b; import _ "x"`,
+		"b/vendor":   ``, // mkdir b/vendor
+		"b/vendor/x": `package xb`,
+		"c":          `package c; import _ "x"`,
+		"x":          `package xc`,
+	}
+	conf := loader.Config{Build: fakeContext(pkgs)}
+	conf.Import("a")
+	conf.Import("b")
+	conf.Import("c")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check that a, b, and c see different versions of x.
+	for _, r := range "abc" {
+		name := string(r)
+		got := prog.Package(name).Pkg.Imports()[0]
+		want := "x" + name
+		if got.Name() != want {
+			t.Errorf("package %s import %q = %s, want %s",
+				name, "x", got.Name(), want)
+		}
+	}
+}
+
+func TestVendorCwd(t *testing.T) {
+	// Test the interaction of cwd and vendor directories.
+	ctxt := fakeContext(map[string]string{
+		"net":          ``, // mkdir net
+		"net/http":     `package http; import _ "hpack"`,
+		"vendor":       ``, // mkdir vendor
+		"vendor/hpack": `package vendorhpack`,
+		"hpack":        `package hpack`,
+	})
+	for i, test := range []struct {
+		cwd, arg, want string
+	}{
+		{cwd: "/go/src/net", arg: "http"}, // not found
+		{cwd: "/go/src/net", arg: "./http", want: "net/http vendor/hpack"},
+		{cwd: "/go/src/net", arg: "hpack", want: "vendor/hpack"},
+		{cwd: "/go/src/vendor", arg: "hpack", want: "vendor/hpack"},
+		{cwd: "/go/src/vendor", arg: "./hpack", want: "vendor/hpack"},
+	} {
+		conf := loader.Config{
+			Cwd:   test.cwd,
+			Build: ctxt,
+		}
+		conf.Import(test.arg)
+
+		var got string
+		prog, err := conf.Load()
+		if prog != nil {
+			got = strings.Join(all(prog), " ")
+		}
+		if got != test.want {
+			t.Errorf("#%d: Load(%s) from %s: got %s, want %s",
+				i, test.arg, test.cwd, got, test.want)
+			if err != nil {
+				t.Errorf("Load failed: %v", err)
+			}
+		}
+	}
+}
+
+func TestVendorCwdIssue16580(t *testing.T) {
+	// Regression test for Go issue 16580.
+	// Import decls in "created" packages were vendor-resolved
+	// w.r.t. cwd, not the parent directory of the package's files.
+	ctxt := fakeContext(map[string]string{
+		"a":          ``, // mkdir a
+		"a/vendor":   ``, // mkdir a/vendor
+		"a/vendor/b": `package b; const X = true`,
+		"b":          `package b; const X = false`,
+	})
+	for _, test := range []struct {
+		filename, cwd string
+		want          bool // expected value of b.X; depends on filename, not on cwd
+	}{
+		{filename: "c.go", cwd: "/go/src", want: false},
+		{filename: "c.go", cwd: "/go/src/a", want: false},
+		{filename: "c.go", cwd: "/go/src/a/b", want: false},
+		{filename: "c.go", cwd: "/go/src/a/vendor/b", want: false},
+
+		{filename: "/go/src/a/c.go", cwd: "/go/src", want: true},
+		{filename: "/go/src/a/c.go", cwd: "/go/src/a", want: true},
+		{filename: "/go/src/a/c.go", cwd: "/go/src/a/b", want: true},
+		{filename: "/go/src/a/c.go", cwd: "/go/src/a/vendor/b", want: true},
+
+		{filename: "/go/src/c/c.go", cwd: "/go/src", want: false},
+		{filename: "/go/src/c/c.go", cwd: "/go/src/a", want: false},
+		{filename: "/go/src/c/c.go", cwd: "/go/src/a/b", want: false},
+		{filename: "/go/src/c/c.go", cwd: "/go/src/a/vendor/b", want: false},
+	} {
+		conf := loader.Config{
+			Cwd:   test.cwd,
+			Build: ctxt,
+		}
+		f, err := conf.ParseFile(test.filename, `package dummy; import "b"; const X = b.X`)
+		if err != nil {
+			t.Fatal(f)
+		}
+		conf.CreateFromFiles("dummy", f)
+
+		prog, err := conf.Load()
+		if err != nil {
+			t.Errorf("%+v: Load failed: %v", test, err)
+			continue
+		}
+
+		x := constant.BoolVal(prog.Created[0].Pkg.Scope().Lookup("X").(*types.Const).Val())
+		if x != test.want {
+			t.Errorf("%+v: b.X = %t", test, x)
+		}
+	}
+
+	// TODO(adonovan): also test imports within XTestGoFiles.
+}
+
+// TODO(adonovan): more Load tests:
+//
+// failures:
+// - to parse package decl of *_test.go files
+// - to parse package decl of external *_test.go files
+// - to parse whole of *_test.go files
+// - to parse whole of external *_test.go files
+// - to open a *.go file during import scanning
+// - to import from binary
+
+// features:
+// - InitialPackages
+// - PackageCreated hook
+// - TypeCheckFuncBodies hook
+
+func TestTransitivelyErrorFreeFlag(t *testing.T) {
+	// Create an minimal custom build.Context
+	// that fakes the following packages:
+	//
+	// a --> b --> c!   c has an error
+	//   \              d and e are transitively error-free.
+	//    e --> d
+	//
+	// Each package [a-e] consists of one file, x.go.
+	pkgs := map[string]string{
+		"a": `package a; import (_ "b"; _ "e")`,
+		"b": `package b; import _ "c"`,
+		"c": `package c; func f() { _ = int(false) }`, // type error within function body
+		"d": `package d;`,
+		"e": `package e; import _ "d"`,
+	}
+	conf := loader.Config{
+		AllowErrors: true,
+		Build:       fakeContext(pkgs),
+	}
+	conf.Import("a")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed: %s", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned nil *Program")
+	}
+
+	for pkg, info := range prog.AllPackages {
+		var wantErr, wantTEF bool
+		switch pkg.Path() {
+		case "a", "b":
+		case "c":
+			wantErr = true
+		case "d", "e":
+			wantTEF = true
+		default:
+			t.Errorf("unexpected package: %q", pkg.Path())
+			continue
+		}
+
+		if (info.Errors != nil) != wantErr {
+			if wantErr {
+				t.Errorf("Package %q.Error = nil, want error", pkg.Path())
+			} else {
+				t.Errorf("Package %q has unexpected Errors: %v",
+					pkg.Path(), info.Errors)
+			}
+		}
+
+		if info.TransitivelyErrorFree != wantTEF {
+			t.Errorf("Package %q.TransitivelyErrorFree=%t, want %t",
+				pkg.Path(), info.TransitivelyErrorFree, wantTEF)
+		}
+	}
+}
+
+// Test that syntax (scan/parse), type, and loader errors are recorded
+// (in PackageInfo.Errors) and reported (via Config.TypeChecker.Error).
+func TestErrorReporting(t *testing.T) {
+	pkgs := map[string]string{
+		"a": `package a; import (_ "b"; _ "c"); var x int = false`,
+		"b": `package b; 'syntax error!`,
+	}
+	conf := loader.Config{
+		AllowErrors: true,
+		Build:       fakeContext(pkgs),
+	}
+	var mu sync.Mutex
+	var allErrors []error
+	conf.TypeChecker.Error = func(err error) {
+		mu.Lock()
+		allErrors = append(allErrors, err)
+		mu.Unlock()
+	}
+	conf.Import("a")
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Errorf("Load failed: %s", err)
+	}
+	if prog == nil {
+		t.Fatalf("Load returned nil *Program")
+	}
+
+	// TODO(adonovan): test keys of ImportMap.
+
+	// Check errors recorded in each PackageInfo.
+	for pkg, info := range prog.AllPackages {
+		switch pkg.Path() {
+		case "a":
+			if !hasError(info.Errors, "cannot convert false") {
+				t.Errorf("a.Errors = %v, want bool conversion (type) error", info.Errors)
+			}
+			if !hasError(info.Errors, "could not import c") {
+				t.Errorf("a.Errors = %v, want import (loader) error", info.Errors)
+			}
+		case "b":
+			if !hasError(info.Errors, "rune literal not terminated") {
+				t.Errorf("b.Errors = %v, want unterminated literal (syntax) error", info.Errors)
+			}
+		}
+	}
+
+	// Check errors reported via error handler.
+	if !hasError(allErrors, "cannot convert false") ||
+		!hasError(allErrors, "rune literal not terminated") ||
+		!hasError(allErrors, "could not import c") {
+		t.Errorf("allErrors = %v, want syntax, type and loader errors", allErrors)
+	}
+}
+
+func TestCycles(t *testing.T) {
+	for _, test := range []struct {
+		descr   string
+		ctxt    *build.Context
+		wantErr string
+	}{
+		{
+			"self-cycle",
+			fakeContext(map[string]string{
+				"main":      `package main; import _ "selfcycle"`,
+				"selfcycle": `package selfcycle; import _ "selfcycle"`,
+			}),
+			`import cycle: selfcycle -> selfcycle`,
+		},
+		{
+			"three-package cycle",
+			fakeContext(map[string]string{
+				"main": `package main; import _ "a"`,
+				"a":    `package a; import _ "b"`,
+				"b":    `package b; import _ "c"`,
+				"c":    `package c; import _ "a"`,
+			}),
+			`import cycle: c -> a -> b -> c`,
+		},
+		{
+			"self-cycle in dependency of test file",
+			buildutil.FakeContext(map[string]map[string]string{
+				"main": {
+					"main.go":      `package main`,
+					"main_test.go": `package main; import _ "a"`,
+				},
+				"a": {
+					"a.go": `package a; import _ "a"`,
+				},
+			}),
+			`import cycle: a -> a`,
+		},
+		// TODO(adonovan): fix: these fail
+		// {
+		// 	"two-package cycle in dependency of test file",
+		// 	buildutil.FakeContext(map[string]map[string]string{
+		// 		"main": {
+		// 			"main.go":      `package main`,
+		// 			"main_test.go": `package main; import _ "a"`,
+		// 		},
+		// 		"a": {
+		// 			"a.go": `package a; import _ "main"`,
+		// 		},
+		// 	}),
+		// 	`import cycle: main -> a -> main`,
+		// },
+		// {
+		// 	"self-cycle in augmented package",
+		// 	buildutil.FakeContext(map[string]map[string]string{
+		// 		"main": {
+		// 			"main.go":      `package main`,
+		// 			"main_test.go": `package main; import _ "main"`,
+		// 		},
+		// 	}),
+		// 	`import cycle: main -> main`,
+		// },
+	} {
+		conf := loader.Config{
+			AllowErrors: true,
+			Build:       test.ctxt,
+		}
+		var mu sync.Mutex
+		var allErrors []error
+		conf.TypeChecker.Error = func(err error) {
+			mu.Lock()
+			allErrors = append(allErrors, err)
+			mu.Unlock()
+		}
+		conf.ImportWithTests("main")
+
+		prog, err := conf.Load()
+		if err != nil {
+			t.Errorf("%s: Load failed: %s", test.descr, err)
+		}
+		if prog == nil {
+			t.Fatalf("%s: Load returned nil *Program", test.descr)
+		}
+
+		if !hasError(allErrors, test.wantErr) {
+			t.Errorf("%s: Load() errors = %q, want %q",
+				test.descr, allErrors, test.wantErr)
+		}
+	}
+
+	// TODO(adonovan):
+	// - Test that in a legal test cycle, none of the symbols
+	//   defined by augmentation are visible via import.
+}
+
+// ---- utilities ----
+
+// Simplifying wrapper around buildutil.FakeContext for single-file packages.
+func fakeContext(pkgs map[string]string) *build.Context {
+	pkgs2 := make(map[string]map[string]string)
+	for path, content := range pkgs {
+		pkgs2[path] = map[string]string{"x.go": content}
+	}
+	return buildutil.FakeContext(pkgs2)
+}
+
+func hasError(errors []error, substr string) bool {
+	for _, err := range errors {
+		if strings.Contains(err.Error(), substr) {
+			return true
+		}
+	}
+	return false
+}
+
+func keys(m map[string]bool) (keys []string) {
+	for key := range m {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return
+}
+
+// Returns all loaded packages.
+func all(prog *loader.Program) []string {
+	var pkgs []string
+	for _, info := range prog.AllPackages {
+		pkgs = append(pkgs, info.Pkg.Path())
+	}
+	sort.Strings(pkgs)
+	return pkgs
+}
+
+// Returns initially imported packages, as a string.
+func imported(prog *loader.Program) string {
+	var pkgs []string
+	for _, info := range prog.Imported {
+		pkgs = append(pkgs, info.Pkg.Path())
+	}
+	sort.Strings(pkgs)
+	return strings.Join(pkgs, " ")
+}
+
+// Returns initially created packages, as a string.
+func created(prog *loader.Program) string {
+	var pkgs []string
+	for _, info := range prog.Created {
+		pkgs = append(pkgs, info.Pkg.Path())
+	}
+	return strings.Join(pkgs, " ")
+}
+
+// Load package "io" twice in parallel.
+// When run with -race, this is a regression test for Go issue 20718, in
+// which the global "unsafe" package was modified concurrently.
+func TestLoad1(t *testing.T) { loadIO(t) }
+func TestLoad2(t *testing.T) { loadIO(t) }
+
+func loadIO(t *testing.T) {
+	t.Parallel()
+	conf := &loader.Config{ImportPkgs: map[string]bool{"io": false}}
+	if _, err := conf.Load(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/loader/stdlib_test.go b/vendor/golang.org/x/tools/go/loader/stdlib_test.go
new file mode 100644
index 0000000..2cd066f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/stdlib_test.go
@@ -0,0 +1,201 @@
+// 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_test
+
+// This file enumerates all packages beneath $GOROOT, loads them, plus
+// their external tests if any, runs the type checker on them, and
+// prints some summary information.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+)
+
+func TestStdlib(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skipf("incomplete std lib on %s", runtime.GOOS)
+	}
+	if testing.Short() {
+		t.Skip("skipping in short mode; uses tons of memory (golang.org/issue/14113)")
+	}
+
+	runtime.GC()
+	t0 := time.Now()
+	var memstats runtime.MemStats
+	runtime.ReadMemStats(&memstats)
+	alloc := memstats.Alloc
+
+	// Load, parse and type-check the program.
+	ctxt := build.Default // copy
+	ctxt.GOPATH = ""      // disable GOPATH
+	conf := loader.Config{Build: &ctxt}
+	for _, path := range buildutil.AllPackages(conf.Build) {
+		conf.ImportWithTests(path)
+	}
+
+	prog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load failed: %v", err)
+	}
+
+	t1 := time.Now()
+	runtime.GC()
+	runtime.ReadMemStats(&memstats)
+
+	numPkgs := len(prog.AllPackages)
+	if want := 205; numPkgs < want {
+		t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want)
+	}
+
+	// Dump package members.
+	if false {
+		for pkg := range prog.AllPackages {
+			fmt.Printf("Package %s:\n", pkg.Path())
+			scope := pkg.Scope()
+			qualifier := types.RelativeTo(pkg)
+			for _, name := range scope.Names() {
+				if ast.IsExported(name) {
+					fmt.Printf("\t%s\n", types.ObjectString(scope.Lookup(name), qualifier))
+				}
+			}
+			fmt.Println()
+		}
+	}
+
+	// Check that Test functions for io/ioutil, regexp and
+	// compress/bzip2 are all simultaneously present.
+	// (The apparent cycle formed when augmenting all three of
+	// these packages by their tests was the original motivation
+	// for reporting b/7114.)
+	//
+	// compress/bzip2.TestBitReader in bzip2_test.go    imports io/ioutil
+	// io/ioutil.TestTempFile       in tempfile_test.go imports regexp
+	// regexp.TestRE2Search         in exec_test.go     imports compress/bzip2
+	for _, test := range []struct{ pkg, fn string }{
+		{"io/ioutil", "TestTempFile"},
+		{"regexp", "TestRE2Search"},
+		{"compress/bzip2", "TestBitReader"},
+	} {
+		info := prog.Imported[test.pkg]
+		if info == nil {
+			t.Errorf("failed to load package %q", test.pkg)
+			continue
+		}
+		obj, _ := info.Pkg.Scope().Lookup(test.fn).(*types.Func)
+		if obj == nil {
+			t.Errorf("package %q has no func %q", test.pkg, test.fn)
+			continue
+		}
+	}
+
+	// Dump some statistics.
+
+	// determine line count
+	var lineCount int
+	prog.Fset.Iterate(func(f *token.File) bool {
+		lineCount += f.LineCount()
+		return true
+	})
+
+	t.Log("GOMAXPROCS:           ", runtime.GOMAXPROCS(0))
+	t.Log("#Source lines:        ", lineCount)
+	t.Log("Load/parse/typecheck: ", t1.Sub(t0))
+	t.Log("#MB:                  ", int64(memstats.Alloc-alloc)/1000000)
+}
+
+func TestCgoOption(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode; uses tons of memory (golang.org/issue/14113)")
+	}
+	switch runtime.GOOS {
+	// On these systems, the net and os/user packages don't use cgo
+	// or the std library is incomplete (Android).
+	case "android", "plan9", "solaris", "windows":
+		t.Skipf("no cgo or incomplete std lib on %s", runtime.GOOS)
+	}
+	// In nocgo builds (e.g. linux-amd64-nocgo),
+	// there is no "runtime/cgo" package,
+	// so cgo-generated Go files will have a failing import.
+	if !build.Default.CgoEnabled {
+		return
+	}
+	// Test that we can load cgo-using packages with
+	// CGO_ENABLED=[01], which causes go/build to select pure
+	// Go/native implementations, respectively, based on build
+	// tags.
+	//
+	// Each entry specifies a package-level object and the generic
+	// file expected to define it when cgo is disabled.
+	// When cgo is enabled, the exact file is not specified (since
+	// it varies by platform), but must differ from the generic one.
+	//
+	// The test also loads the actual file to verify that the
+	// object is indeed defined at that location.
+	for _, test := range []struct {
+		pkg, name, genericFile string
+	}{
+		{"net", "cgoLookupHost", "cgo_stub.go"},
+		{"os/user", "current", "lookup_stubs.go"},
+	} {
+		ctxt := build.Default
+		for _, ctxt.CgoEnabled = range []bool{false, true} {
+			conf := loader.Config{Build: &ctxt}
+			conf.Import(test.pkg)
+			prog, err := conf.Load()
+			if err != nil {
+				t.Errorf("Load failed: %v", err)
+				continue
+			}
+			info := prog.Imported[test.pkg]
+			if info == nil {
+				t.Errorf("package %s not found", test.pkg)
+				continue
+			}
+			obj := info.Pkg.Scope().Lookup(test.name)
+			if obj == nil {
+				t.Errorf("no object %s.%s", test.pkg, test.name)
+				continue
+			}
+			posn := prog.Fset.Position(obj.Pos())
+			t.Logf("%s: %s (CgoEnabled=%t)", posn, obj, ctxt.CgoEnabled)
+
+			gotFile := filepath.Base(posn.Filename)
+			filesMatch := gotFile == test.genericFile
+
+			if ctxt.CgoEnabled && filesMatch {
+				t.Errorf("CGO_ENABLED=1: %s found in %s, want native file",
+					obj, gotFile)
+			} else if !ctxt.CgoEnabled && !filesMatch {
+				t.Errorf("CGO_ENABLED=0: %s found in %s, want %s",
+					obj, gotFile, test.genericFile)
+			}
+
+			// Load the file and check the object is declared at the right place.
+			b, err := ioutil.ReadFile(posn.Filename)
+			if err != nil {
+				t.Errorf("can't read %s: %s", posn.Filename, err)
+				continue
+			}
+			line := string(bytes.Split(b, []byte("\n"))[posn.Line-1])
+			ident := line[posn.Column-1:]
+			if !strings.HasPrefix(ident, test.name) {
+				t.Errorf("%s: %s not declared here (looking at %q)", posn, obj, ident)
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/loader/testdata/a.go b/vendor/golang.org/x/tools/go/loader/testdata/a.go
new file mode 100644
index 0000000..bae3955
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/testdata/a.go
@@ -0,0 +1 @@
+package P
diff --git a/vendor/golang.org/x/tools/go/loader/testdata/b.go b/vendor/golang.org/x/tools/go/loader/testdata/b.go
new file mode 100644
index 0000000..bae3955
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/testdata/b.go
@@ -0,0 +1 @@
+package P
diff --git a/vendor/golang.org/x/tools/go/loader/testdata/badpkgdecl.go b/vendor/golang.org/x/tools/go/loader/testdata/badpkgdecl.go
new file mode 100644
index 0000000..1e39359
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/loader/testdata/badpkgdecl.go
@@ -0,0 +1 @@
+// this file has no package decl
diff --git a/vendor/golang.org/x/tools/go/loader/util.go b/vendor/golang.org/x/tools/go/loader/util.go
index 0404e99..7f38dd7 100644
--- a/vendor/golang.org/x/tools/go/loader/util.go
+++ b/vendor/golang.org/x/tools/go/loader/util.go
@@ -19,7 +19,7 @@ import (
 
 // We use a counting semaphore to limit
 // the number of parallel I/O calls per process.
-var sema = make(chan bool, 10)
+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,
@@ -42,10 +42,10 @@ func parseFiles(fset *token.FileSet, ctxt *build.Context, displayPath func(strin
 		}
 		wg.Add(1)
 		go func(i int, file string) {
-			sema <- true // wait
+			ioLimit <- true // wait
 			defer func() {
 				wg.Done()
-				<-sema // signal
+				<-ioLimit // signal
 			}()
 			var rd io.ReadCloser
 			var err error
@@ -88,7 +88,7 @@ func parseFiles(fset *token.FileSet, ctxt *build.Context, displayPath func(strin
 	return parsed, errors
 }
 
-// scanImports returns the set of all package import paths from all
+// 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)
@@ -103,8 +103,8 @@ func scanImports(files []*ast.File) map[string]bool {
 					if err != nil {
 						continue // quietly ignore the error
 					}
-					if path == "C" || path == "unsafe" {
-						continue // skip pseudo packages
+					if path == "C" {
+						continue // skip pseudopackage
 					}
 					imports[path] = true
 				}
diff --git a/vendor/golang.org/x/tools/go/pointer/analysis.go b/vendor/golang.org/x/tools/go/pointer/analysis.go
index d02e536..0abb04d 100644
--- a/vendor/golang.org/x/tools/go/pointer/analysis.go
+++ b/vendor/golang.org/x/tools/go/pointer/analysis.go
@@ -9,6 +9,7 @@ package pointer
 import (
 	"fmt"
 	"go/token"
+	"go/types"
 	"io"
 	"os"
 	"reflect"
@@ -18,7 +19,6 @@ import (
 
 	"golang.org/x/tools/go/callgraph"
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 	"golang.org/x/tools/go/types/typeutil"
 )
 
@@ -177,6 +177,11 @@ func (a *analysis) warnf(pos token.Pos, format string, args ...interface{}) {
 
 // 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())
@@ -254,17 +259,17 @@ func Analyze(config *Config) (result *Result, err error) {
 	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.Object.Complete() {
-			return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete`, pkg.Object.Path())
+		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.Object.Scope().Lookup("Value")
+		rV := reflect.Pkg.Scope().Lookup("Value")
 		a.reflectValueObj = rV
 		a.reflectValueCall = a.prog.LookupMethod(rV.Type(), nil, "Call")
-		a.reflectType = reflect.Object.Scope().Lookup("Type").Type().(*types.Named)
-		a.reflectRtypeObj = reflect.Object.Scope().Lookup("rtype")
+		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.
diff --git a/vendor/golang.org/x/tools/go/pointer/api.go b/vendor/golang.org/x/tools/go/pointer/api.go
index 8f9ae0a..2b7e79e 100644
--- a/vendor/golang.org/x/tools/go/pointer/api.go
+++ b/vendor/golang.org/x/tools/go/pointer/api.go
@@ -16,7 +16,9 @@ import (
 	"golang.org/x/tools/go/types/typeutil"
 )
 
-// A Config formulates a pointer analysis problem for Analyze().
+// 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
@@ -61,6 +63,7 @@ type Config struct {
 	//
 	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.
@@ -80,9 +83,6 @@ const (
 
 // AddQuery adds v to Config.Queries.
 // Precondition: CanPoint(v.Type()).
-// TODO(adonovan): consider returning a new Pointer for this query,
-// which will be initialized during analysis.  That avoids the needs
-// for the corresponding ssa.Value-keyed maps in Config and Result.
 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()))
@@ -105,6 +105,46 @@ func (c *Config) AddIndirectQuery(v ssa.Value) {
 	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
diff --git a/vendor/golang.org/x/tools/go/pointer/constraint.go b/vendor/golang.org/x/tools/go/pointer/constraint.go
index e6371cc..54b5428 100644
--- a/vendor/golang.org/x/tools/go/pointer/constraint.go
+++ b/vendor/golang.org/x/tools/go/pointer/constraint.go
@@ -4,9 +4,7 @@
 
 package pointer
 
-import (
-	"golang.org/x/tools/go/types"
-)
+import "go/types"
 
 type constraint interface {
 	// For a complex constraint, returns the nodeid of the pointer
diff --git a/vendor/golang.org/x/tools/go/pointer/doc.go b/vendor/golang.org/x/tools/go/pointer/doc.go
index 22e569c..e317cf5 100644
--- a/vendor/golang.org/x/tools/go/pointer/doc.go
+++ b/vendor/golang.org/x/tools/go/pointer/doc.go
@@ -431,7 +431,7 @@ Structs
   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 distiction
+  (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,
diff --git a/vendor/golang.org/x/tools/go/pointer/example_test.go b/vendor/golang.org/x/tools/go/pointer/example_test.go
new file mode 100644
index 0000000..673de7a
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/example_test.go
@@ -0,0 +1,126 @@
+// 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_test
+
+import (
+	"fmt"
+	"sort"
+
+	"golang.org/x/tools/go/callgraph"
+	"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"
+)
+
+// This program demonstrates how to use the pointer analysis to
+// obtain a conservative call-graph of a Go program.
+// It also shows how to compute the points-to set of a variable,
+// in this case, (C).f's ch parameter.
+//
+func Example() {
+	const myprog = `
+package main
+
+import "fmt"
+
+type I interface {
+	f(map[string]int)
+}
+
+type C struct{}
+
+func (C) f(m map[string]int) {
+	fmt.Println("C.f()")
+}
+
+func main() {
+	var i I = C{}
+	x := map[string]int{"one":1}
+	i.f(x) // dynamic method call
+}
+`
+	var conf loader.Config
+
+	// Parse the input file, a string.
+	// (Command-line tools should use conf.FromArgs.)
+	file, err := conf.ParseFile("myprog.go", myprog)
+	if err != nil {
+		fmt.Print(err) // parse error
+		return
+	}
+
+	// Create single-file main package and import its dependencies.
+	conf.CreateFromFiles("main", file)
+
+	iprog, err := conf.Load()
+	if err != nil {
+		fmt.Print(err) // type error in some package
+		return
+	}
+
+	// Create SSA-form program representation.
+	prog := ssautil.CreateProgram(iprog, 0)
+	mainPkg := prog.Package(iprog.Created[0].Pkg)
+
+	// Build SSA code for bodies of all functions in the whole program.
+	prog.Build()
+
+	// Configure the pointer analysis to build a call-graph.
+	config := &pointer.Config{
+		Mains:          []*ssa.Package{mainPkg},
+		BuildCallGraph: true,
+	}
+
+	// Query points-to set of (C).f's parameter m, a map.
+	C := mainPkg.Type("C").Type()
+	Cfm := prog.LookupMethod(C, mainPkg.Pkg, "f").Params[1]
+	config.AddQuery(Cfm)
+
+	// Run the pointer analysis.
+	result, err := pointer.Analyze(config)
+	if err != nil {
+		panic(err) // internal error in pointer analysis
+	}
+
+	// Find edges originating from the main package.
+	// By converting to strings, we de-duplicate nodes
+	// representing the same function due to context sensitivity.
+	var edges []string
+	callgraph.GraphVisitEdges(result.CallGraph, func(edge *callgraph.Edge) error {
+		caller := edge.Caller.Func
+		if caller.Pkg == mainPkg {
+			edges = append(edges, fmt.Sprint(caller, " --> ", edge.Callee.Func))
+		}
+		return nil
+	})
+
+	// Print the edges in sorted order.
+	sort.Strings(edges)
+	for _, edge := range edges {
+		fmt.Println(edge)
+	}
+	fmt.Println()
+
+	// Print the labels of (C).f(m)'s points-to set.
+	fmt.Println("m may point to:")
+	var labels []string
+	for _, l := range result.Queries[Cfm].PointsTo().Labels() {
+		label := fmt.Sprintf("  %s: %s", prog.Fset.Position(l.Pos()), l)
+		labels = append(labels, label)
+	}
+	sort.Strings(labels)
+	for _, label := range labels {
+		fmt.Println(label)
+	}
+
+	// Output:
+	// (main.C).f --> fmt.Println
+	// main.init --> fmt.init
+	// main.main --> (main.C).f
+	//
+	// m may point to:
+	//   myprog.go:18:21: makemap
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/gen.go b/vendor/golang.org/x/tools/go/pointer/gen.go
index 6c256ac..a111175 100644
--- a/vendor/golang.org/x/tools/go/pointer/gen.go
+++ b/vendor/golang.org/x/tools/go/pointer/gen.go
@@ -13,10 +13,10 @@ package pointer
 import (
 	"fmt"
 	"go/token"
+	"go/types"
 
 	"golang.org/x/tools/go/callgraph"
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 var (
@@ -108,6 +108,16 @@ func (a *analysis) setValueNode(v ssa.Value, id nodeid, cgn *cgnode) {
 		}
 		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
@@ -1050,11 +1060,32 @@ func (a *analysis) genInstr(cgn *cgnode, instr ssa.Instruction) {
 			// 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).
-			a.genLoad(cgn, a.valueNode(instr)+1, theMap, 0, ksize+vsize)
+			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:
@@ -1223,7 +1254,7 @@ func (a *analysis) genMethodsOf(T types.Type) {
 	// 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.Method(mset.At(i))
+		m := a.prog.MethodValue(mset.At(i))
 		a.valueNode(m)
 
 		if !itf {
@@ -1266,7 +1297,9 @@ func (a *analysis) generate() {
 		a.genMethodsOf(T)
 	}
 
-	// Generate constraints for entire program.
+	// 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:]
diff --git a/vendor/golang.org/x/tools/go/pointer/hvn.go b/vendor/golang.org/x/tools/go/pointer/hvn.go
index a3ef1f3..48051ae 100644
--- a/vendor/golang.org/x/tools/go/pointer/hvn.go
+++ b/vendor/golang.org/x/tools/go/pointer/hvn.go
@@ -1,3 +1,7 @@
+// 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
@@ -70,7 +74,7 @@ package pointer
 //
 // PERFORMANCE
 //
-// In two benchmarks (oracle and godoc), HVN eliminates about two thirds
+// 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
@@ -159,11 +163,11 @@ package pointer
 
 import (
 	"fmt"
+	"go/types"
 	"io"
 	"reflect"
 
 	"golang.org/x/tools/container/intsets"
-	"golang.org/x/tools/go/types"
 )
 
 // A peLabel is a pointer-equivalence label: two nodes with the same
@@ -529,7 +533,7 @@ func (h *hvn) markIndirectNodes() {
 		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()) {
+			for range h.a.flatten(tArray.Elem()) {
 				id++
 				h.markIndirect(onodeid(id), "array elem")
 			}
diff --git a/vendor/golang.org/x/tools/go/pointer/intrinsics.go b/vendor/golang.org/x/tools/go/pointer/intrinsics.go
index 251c0e2..b7e2b14 100644
--- a/vendor/golang.org/x/tools/go/pointer/intrinsics.go
+++ b/vendor/golang.org/x/tools/go/pointer/intrinsics.go
@@ -17,9 +17,9 @@ package pointer
 
 import (
 	"fmt"
+	"go/types"
 
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 // Instances of 'intrinsic' generate analysis constraints for calls to
@@ -38,144 +38,120 @@ func init() {
 	// 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,
-		"runtime.BlockProfile":                  ext۰NoEffect,
-		"runtime.Breakpoint":                    ext۰NoEffect,
-		"runtime.CPUProfile":                    ext۰NoEffect, // good enough
-		"runtime.Caller":                        ext۰NoEffect,
-		"runtime.Callers":                       ext۰NoEffect, // good enough
-		"runtime.FuncForPC":                     ext۰NoEffect,
-		"runtime.GC":                            ext۰NoEffect,
-		"runtime.GOMAXPROCS":                    ext۰NoEffect,
-		"runtime.Goexit":                        ext۰NoEffect,
-		"runtime.GoroutineProfile":              ext۰NoEffect,
-		"runtime.Gosched":                       ext۰NoEffect,
-		"runtime.MemProfile":                    ext۰NoEffect,
-		"runtime.NumCPU":                        ext۰NoEffect,
-		"runtime.NumGoroutine":                  ext۰NoEffect,
-		"runtime.ReadMemStats":                  ext۰NoEffect,
-		"runtime.SetBlockProfileRate":           ext۰NoEffect,
-		"runtime.SetCPUProfileRate":             ext۰NoEffect,
-		"runtime.SetFinalizer":                  ext۰runtime۰SetFinalizer,
-		"runtime.Stack":                         ext۰NoEffect,
-		"runtime.ThreadCreateProfile":           ext۰NoEffect,
-		"runtime.cstringToGo":                   ext۰NoEffect,
-		"runtime.funcentry_go":                  ext۰NoEffect,
-		"runtime.funcline_go":                   ext۰NoEffect,
-		"runtime.funcname_go":                   ext۰NoEffect,
-		"runtime.getgoroot":                     ext۰NoEffect,
-		"runtime/pprof.runtime_cyclesPerSecond": ext۰NoEffect,
-		"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,
+		"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
 	}
@@ -198,6 +174,11 @@ func (a *analysis) findIntrinsic(fn *ssa.Function) intrinsic {
 				// 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
@@ -211,7 +192,7 @@ func (a *analysis) isReflect(fn *ssa.Function) bool {
 		return false // "reflect" package not loaded
 	}
 	reflectPackage := a.reflectValueObj.Pkg()
-	if fn.Pkg != nil && fn.Pkg.Object == reflectPackage {
+	if fn.Pkg != nil && fn.Pkg.Pkg == reflectPackage {
 		return true
 	}
 	// Synthetic wrappers have a nil Pkg, so they slip through the
diff --git a/vendor/golang.org/x/tools/go/pointer/labels.go b/vendor/golang.org/x/tools/go/pointer/labels.go
index cf6ef20..7d64ef6 100644
--- a/vendor/golang.org/x/tools/go/pointer/labels.go
+++ b/vendor/golang.org/x/tools/go/pointer/labels.go
@@ -7,10 +7,10 @@ package pointer
 import (
 	"fmt"
 	"go/token"
+	"go/types"
 	"strings"
 
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 // A Label is an entity that may be pointed to by a pointer, map,
diff --git a/vendor/golang.org/x/tools/go/pointer/opt.go b/vendor/golang.org/x/tools/go/pointer/opt.go
index 2620cc0..81f80aa 100644
--- a/vendor/golang.org/x/tools/go/pointer/opt.go
+++ b/vendor/golang.org/x/tools/go/pointer/opt.go
@@ -102,6 +102,13 @@ func (a *analysis) renumber() {
 		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 {
diff --git a/vendor/golang.org/x/tools/go/pointer/pointer_test.go b/vendor/golang.org/x/tools/go/pointer/pointer_test.go
new file mode 100644
index 0000000..a06f304
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/pointer_test.go
@@ -0,0 +1,601 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package pointer_test
+
+// This test uses 'expectation' comments embedded within testdata/*.go
+// files to specify the expected pointer analysis behaviour.
+// See below for grammar.
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/callgraph"
+	"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"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+var inputs = []string{
+	"testdata/a_test.go",
+	"testdata/another.go",
+	"testdata/arrayreflect.go",
+	"testdata/arrays.go",
+	"testdata/channels.go",
+	"testdata/chanreflect.go",
+	"testdata/context.go",
+	"testdata/conv.go",
+	"testdata/extended.go",
+	"testdata/finalizer.go",
+	"testdata/flow.go",
+	"testdata/fmtexcerpt.go",
+	"testdata/func.go",
+	"testdata/funcreflect.go",
+	"testdata/hello.go", // NB: causes spurious failure of HVN cross-check
+	"testdata/interfaces.go",
+	"testdata/issue9002.go",
+	"testdata/mapreflect.go",
+	"testdata/maps.go",
+	"testdata/panic.go",
+	"testdata/recur.go",
+	"testdata/reflect.go",
+	"testdata/rtti.go",
+	"testdata/structreflect.go",
+	"testdata/structs.go",
+	// "testdata/timer.go", // TODO(adonovan): fix broken assumptions about runtime timers
+}
+
+// Expectation grammar:
+//
+// @calls f -> g
+//
+//   A 'calls' expectation asserts that edge (f, g) appears in the
+//   callgraph.  f and g are notated as per Function.String(), which
+//   may contain spaces (e.g. promoted method in anon struct).
+//
+// @pointsto a | b | c
+//
+//   A 'pointsto' expectation asserts that the points-to set of its
+//   operand contains exactly the set of labels {a,b,c} notated as per
+//   labelString.
+//
+//   A 'pointsto' expectation must appear on the same line as a
+//   print(x) statement; the expectation's operand is x.
+//
+//   If one of the strings is "...", the expectation asserts that the
+//   points-to set at least the other labels.
+//
+//   We use '|' because label names may contain spaces, e.g.  methods
+//   of anonymous structs.
+//
+//   From a theoretical perspective, concrete types in interfaces are
+//   labels too, but they are represented differently and so have a
+//   different expectation, @types, below.
+//
+// @types t | u | v
+//
+//   A 'types' expectation asserts that the set of possible dynamic
+//   types of its interface operand is exactly {t,u,v}, notated per
+//   go/types.Type.String(). In other words, it asserts that the type
+//   component of the interface may point to that set of concrete type
+//   literals.  It also works for reflect.Value, though the types
+//   needn't be concrete in that case.
+//
+//   A 'types' expectation must appear on the same line as a
+//   print(x) statement; the expectation's operand is x.
+//
+//   If one of the strings is "...", the expectation asserts that the
+//   interface's type may point to at least the other types.
+//
+//   We use '|' because type names may contain spaces.
+//
+// @warning "regexp"
+//
+//   A 'warning' expectation asserts that the analysis issues a
+//   warning that matches the regular expression within the string
+//   literal.
+//
+// @line id
+//
+//   A line directive associates the name "id" with the current
+//   file:line.  The string form of labels will use this id instead of
+//   a file:line, making @pointsto expectations more robust against
+//   perturbations in the source file.
+//   (NB, anon functions still include line numbers.)
+//
+type expectation struct {
+	kind     string // "pointsto" | "pointstoquery" | "types" | "calls" | "warning"
+	filename string
+	linenum  int // source line number, 1-based
+	args     []string
+	query    string           // extended query
+	extended *pointer.Pointer // extended query pointer
+	types    []types.Type     // for types
+}
+
+func (e *expectation) String() string {
+	return fmt.Sprintf("@%s[%s]", e.kind, strings.Join(e.args, " | "))
+}
+
+func (e *expectation) errorf(format string, args ...interface{}) {
+	fmt.Printf("%s:%d: ", e.filename, e.linenum)
+	fmt.Printf(format, args...)
+	fmt.Println()
+}
+
+func (e *expectation) needsProbe() bool {
+	return e.kind == "pointsto" || e.kind == "pointstoquery" || e.kind == "types"
+}
+
+// Find probe (call to print(x)) of same source file/line as expectation.
+func findProbe(prog *ssa.Program, probes map[*ssa.CallCommon]bool, queries map[ssa.Value]pointer.Pointer, e *expectation) (site *ssa.CallCommon, pts pointer.PointsToSet) {
+	for call := range probes {
+		pos := prog.Fset.Position(call.Pos())
+		if pos.Line == e.linenum && pos.Filename == e.filename {
+			// TODO(adonovan): send this to test log (display only on failure).
+			// fmt.Printf("%s:%d: info: found probe for %s: %s\n",
+			// 	e.filename, e.linenum, e, p.arg0) // debugging
+			return call, queries[call.Args[0]].PointsTo()
+		}
+	}
+	return // e.g. analysis didn't reach this call
+}
+
+func doOneInput(input, filename string) bool {
+	var conf loader.Config
+
+	// Parsing.
+	f, err := conf.ParseFile(filename, input)
+	if err != nil {
+		fmt.Println(err)
+		return false
+	}
+
+	// Create single-file main package and import its dependencies.
+	conf.CreateFromFiles("main", f)
+	iprog, err := conf.Load()
+	if err != nil {
+		fmt.Println(err)
+		return false
+	}
+	mainPkgInfo := iprog.Created[0].Pkg
+
+	// SSA creation + building.
+	prog := ssautil.CreateProgram(iprog, ssa.SanityCheckFunctions)
+	prog.Build()
+
+	mainpkg := prog.Package(mainPkgInfo)
+	ptrmain := mainpkg // main package for the pointer analysis
+	if mainpkg.Func("main") == nil {
+		// No main function; assume it's a test.
+		ptrmain = prog.CreateTestMainPackage(mainpkg)
+	}
+
+	// Find all calls to the built-in print(x).  Analytically,
+	// print is a no-op, but it's a convenient hook for testing
+	// the PTS of an expression, so our tests use it.
+	probes := make(map[*ssa.CallCommon]bool)
+	for fn := range ssautil.AllFunctions(prog) {
+		if fn.Pkg == mainpkg {
+			for _, b := range fn.Blocks {
+				for _, instr := range b.Instrs {
+					if instr, ok := instr.(ssa.CallInstruction); ok {
+						call := instr.Common()
+						if b, ok := call.Value.(*ssa.Builtin); ok && b.Name() == "print" && len(call.Args) == 1 {
+							probes[instr.Common()] = true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	ok := true
+
+	lineMapping := make(map[string]string) // maps "file:line" to @line tag
+
+	// Parse expectations in this input.
+	var exps []*expectation
+	re := regexp.MustCompile("// *@([a-z]*) *(.*)$")
+	lines := strings.Split(input, "\n")
+	for linenum, line := range lines {
+		linenum++ // make it 1-based
+		if matches := re.FindAllStringSubmatch(line, -1); matches != nil {
+			match := matches[0]
+			kind, rest := match[1], match[2]
+			e := &expectation{kind: kind, filename: filename, linenum: linenum}
+
+			if kind == "line" {
+				if rest == "" {
+					ok = false
+					e.errorf("@%s expectation requires identifier", kind)
+				} else {
+					lineMapping[fmt.Sprintf("%s:%d", filename, linenum)] = rest
+				}
+				continue
+			}
+
+			if e.needsProbe() && !strings.Contains(line, "print(") {
+				ok = false
+				e.errorf("@%s expectation must follow call to print(x)", kind)
+				continue
+			}
+
+			switch kind {
+			case "pointsto":
+				e.args = split(rest, "|")
+
+			case "pointstoquery":
+				args := strings.SplitN(rest, " ", 2)
+				e.query = args[0]
+				e.args = split(args[1], "|")
+			case "types":
+				for _, typstr := range split(rest, "|") {
+					var t types.Type = types.Typ[types.Invalid] // means "..."
+					if typstr != "..." {
+						tv, err := types.Eval(prog.Fset, mainpkg.Pkg, f.Pos(), typstr)
+						if err != nil {
+							ok = false
+							// Don't print err since its location is bad.
+							e.errorf("'%s' is not a valid type: %s", typstr, err)
+							continue
+						}
+						t = tv.Type
+					}
+					e.types = append(e.types, t)
+				}
+
+			case "calls":
+				e.args = split(rest, "->")
+				// TODO(adonovan): eagerly reject the
+				// expectation if fn doesn't denote
+				// existing function, rather than fail
+				// the expectation after analysis.
+				if len(e.args) != 2 {
+					ok = false
+					e.errorf("@calls expectation wants 'caller -> callee' arguments")
+					continue
+				}
+
+			case "warning":
+				lit, err := strconv.Unquote(strings.TrimSpace(rest))
+				if err != nil {
+					ok = false
+					e.errorf("couldn't parse @warning operand: %s", err.Error())
+					continue
+				}
+				e.args = append(e.args, lit)
+
+			default:
+				ok = false
+				e.errorf("unknown expectation kind: %s", e)
+				continue
+			}
+			exps = append(exps, e)
+		}
+	}
+
+	var log bytes.Buffer
+	fmt.Fprintf(&log, "Input: %s\n", filename)
+
+	// Run the analysis.
+	config := &pointer.Config{
+		Reflection:     true,
+		BuildCallGraph: true,
+		Mains:          []*ssa.Package{ptrmain},
+		Log:            &log,
+	}
+probeLoop:
+	for probe := range probes {
+		v := probe.Args[0]
+		pos := prog.Fset.Position(probe.Pos())
+		for _, e := range exps {
+			if e.linenum == pos.Line && e.filename == pos.Filename && e.kind == "pointstoquery" {
+				var err error
+				e.extended, err = config.AddExtendedQuery(v, e.query)
+				if err != nil {
+					panic(err)
+				}
+				continue probeLoop
+			}
+		}
+		if pointer.CanPoint(v.Type()) {
+			config.AddQuery(v)
+		}
+	}
+
+	// Print the log is there was an error or a panic.
+	complete := false
+	defer func() {
+		if !complete || !ok {
+			log.WriteTo(os.Stderr)
+		}
+	}()
+
+	result, err := pointer.Analyze(config)
+	if err != nil {
+		panic(err) // internal error in pointer analysis
+	}
+
+	// Check the expectations.
+	for _, e := range exps {
+		var call *ssa.CallCommon
+		var pts pointer.PointsToSet
+		var tProbe types.Type
+		if e.needsProbe() {
+			if call, pts = findProbe(prog, probes, result.Queries, e); call == nil {
+				ok = false
+				e.errorf("unreachable print() statement has expectation %s", e)
+				continue
+			}
+			if e.extended != nil {
+				pts = e.extended.PointsTo()
+			}
+			tProbe = call.Args[0].Type()
+			if !pointer.CanPoint(tProbe) {
+				ok = false
+				e.errorf("expectation on non-pointerlike operand: %s", tProbe)
+				continue
+			}
+		}
+
+		switch e.kind {
+		case "pointsto", "pointstoquery":
+			if !checkPointsToExpectation(e, pts, lineMapping, prog) {
+				ok = false
+			}
+
+		case "types":
+			if !checkTypesExpectation(e, pts, tProbe) {
+				ok = false
+			}
+
+		case "calls":
+			if !checkCallsExpectation(prog, e, result.CallGraph) {
+				ok = false
+			}
+
+		case "warning":
+			if !checkWarningExpectation(prog, e, result.Warnings) {
+				ok = false
+			}
+		}
+	}
+
+	complete = true
+
+	// ok = false // debugging: uncomment to always see log
+
+	return ok
+}
+
+func labelString(l *pointer.Label, lineMapping map[string]string, prog *ssa.Program) string {
+	// Functions and Globals need no pos suffix,
+	// nor do allocations in intrinsic operations
+	// (for which we'll print the function name).
+	switch l.Value().(type) {
+	case nil, *ssa.Function, *ssa.Global:
+		return l.String()
+	}
+
+	str := l.String()
+	if pos := l.Pos(); pos != token.NoPos {
+		// Append the position, using a @line tag instead of a line number, if defined.
+		posn := prog.Fset.Position(pos)
+		s := fmt.Sprintf("%s:%d", posn.Filename, posn.Line)
+		if tag, ok := lineMapping[s]; ok {
+			return fmt.Sprintf("%s@%s:%d", str, tag, posn.Column)
+		}
+		str = fmt.Sprintf("%s@%s", str, posn)
+	}
+	return str
+}
+
+func checkPointsToExpectation(e *expectation, pts pointer.PointsToSet, lineMapping map[string]string, prog *ssa.Program) bool {
+	expected := make(map[string]int)
+	surplus := make(map[string]int)
+	exact := true
+	for _, g := range e.args {
+		if g == "..." {
+			exact = false
+			continue
+		}
+		expected[g]++
+	}
+	// Find the set of labels that the probe's
+	// argument (x in print(x)) may point to.
+	for _, label := range pts.Labels() {
+		name := labelString(label, lineMapping, prog)
+		if expected[name] > 0 {
+			expected[name]--
+		} else if exact {
+			surplus[name]++
+		}
+	}
+	// Report multiset difference:
+	ok := true
+	for _, count := range expected {
+		if count > 0 {
+			ok = false
+			e.errorf("value does not alias these expected labels: %s", join(expected))
+			break
+		}
+	}
+	for _, count := range surplus {
+		if count > 0 {
+			ok = false
+			e.errorf("value may additionally alias these labels: %s", join(surplus))
+			break
+		}
+	}
+	return ok
+}
+
+func checkTypesExpectation(e *expectation, pts pointer.PointsToSet, typ types.Type) bool {
+	var expected typeutil.Map
+	var surplus typeutil.Map
+	exact := true
+	for _, g := range e.types {
+		if g == types.Typ[types.Invalid] {
+			exact = false
+			continue
+		}
+		expected.Set(g, struct{}{})
+	}
+
+	if !pointer.CanHaveDynamicTypes(typ) {
+		e.errorf("@types expectation requires an interface- or reflect.Value-typed operand, got %s", typ)
+		return false
+	}
+
+	// Find the set of types that the probe's
+	// argument (x in print(x)) may contain.
+	for _, T := range pts.DynamicTypes().Keys() {
+		if expected.At(T) != nil {
+			expected.Delete(T)
+		} else if exact {
+			surplus.Set(T, struct{}{})
+		}
+	}
+	// Report set difference:
+	ok := true
+	if expected.Len() > 0 {
+		ok = false
+		e.errorf("interface cannot contain these types: %s", expected.KeysString())
+	}
+	if surplus.Len() > 0 {
+		ok = false
+		e.errorf("interface may additionally contain these types: %s", surplus.KeysString())
+	}
+	return ok
+}
+
+var errOK = errors.New("OK")
+
+func checkCallsExpectation(prog *ssa.Program, e *expectation, cg *callgraph.Graph) bool {
+	found := make(map[string]int)
+	err := callgraph.GraphVisitEdges(cg, func(edge *callgraph.Edge) error {
+		// Name-based matching is inefficient but it allows us to
+		// match functions whose names that would not appear in an
+		// index ("<root>") or which are not unique ("func@1.2").
+		if edge.Caller.Func.String() == e.args[0] {
+			calleeStr := edge.Callee.Func.String()
+			if calleeStr == e.args[1] {
+				return errOK // expectation satisfied; stop the search
+			}
+			found[calleeStr]++
+		}
+		return nil
+	})
+	if err == errOK {
+		return true
+	}
+	if len(found) == 0 {
+		e.errorf("didn't find any calls from %s", e.args[0])
+	}
+	e.errorf("found no call from %s to %s, but only to %s",
+		e.args[0], e.args[1], join(found))
+	return false
+}
+
+func checkWarningExpectation(prog *ssa.Program, e *expectation, warnings []pointer.Warning) bool {
+	// TODO(adonovan): check the position part of the warning too?
+	re, err := regexp.Compile(e.args[0])
+	if err != nil {
+		e.errorf("invalid regular expression in @warning expectation: %s", err.Error())
+		return false
+	}
+
+	if len(warnings) == 0 {
+		e.errorf("@warning %q expectation, but no warnings", e.args[0])
+		return false
+	}
+
+	for _, w := range warnings {
+		if re.MatchString(w.Message) {
+			return true
+		}
+	}
+
+	e.errorf("@warning %q expectation not satisfied; found these warnings though:", e.args[0])
+	for _, w := range warnings {
+		fmt.Printf("%s: warning: %s\n", prog.Fset.Position(w.Pos), w.Message)
+	}
+	return false
+}
+
+func TestInput(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode; this test requires tons of memory; golang.org/issue/14113")
+	}
+	ok := true
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Errorf("os.Getwd: %s", err)
+		return
+	}
+
+	// 'go test' does a chdir so that relative paths in
+	// diagnostics no longer make sense relative to the invoking
+	// shell's cwd.  We print a special marker so that Emacs can
+	// make sense of them.
+	fmt.Fprintf(os.Stderr, "Entering directory `%s'\n", wd)
+
+	for _, filename := range inputs {
+		content, err := ioutil.ReadFile(filename)
+		if err != nil {
+			t.Errorf("couldn't read file '%s': %s", filename, err)
+			continue
+		}
+
+		if !doOneInput(string(content), filename) {
+			ok = false
+		}
+	}
+	if !ok {
+		t.Fail()
+	}
+}
+
+// join joins the elements of multiset with " | "s.
+func join(set map[string]int) string {
+	var buf bytes.Buffer
+	sep := ""
+	for name, count := range set {
+		for i := 0; i < count; i++ {
+			buf.WriteString(sep)
+			sep = " | "
+			buf.WriteString(name)
+		}
+	}
+	return buf.String()
+}
+
+// split returns the list of sep-delimited non-empty strings in s.
+func split(s, sep string) (r []string) {
+	for _, elem := range strings.Split(s, sep) {
+		elem = strings.TrimSpace(elem)
+		if elem != "" {
+			r = append(r, elem)
+		}
+	}
+	return
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/query.go b/vendor/golang.org/x/tools/go/pointer/query.go
new file mode 100644
index 0000000..1263d31
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/pointer/query_test.go b/vendor/golang.org/x/tools/go/pointer/query_test.go
new file mode 100644
index 0000000..099cc54
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/query_test.go
@@ -0,0 +1,68 @@
+package pointer
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"testing"
+)
+
+func TestParseExtendedQuery(t *testing.T) {
+	const myprog = `
+package pkg
+var V1 *int
+var V2 **int
+var V3 []*int
+var V4 chan []*int
+var V5 struct {F1, F2 chan *int}
+var V6 [1]chan *int
+var V7 int
+`
+	tests := []struct {
+		in    string
+		out   []interface{}
+		v     string
+		valid bool
+	}{
+		{`x`, []interface{}{"x"}, "V1", true},
+		{`*x`, []interface{}{"x", "load"}, "V2", true},
+		{`x[0]`, []interface{}{"x", "sliceelem"}, "V3", true},
+		{`<-x`, []interface{}{"x", "recv"}, "V4", true},
+		{`(<-x)[0]`, []interface{}{"x", "recv", "sliceelem"}, "V4", true},
+		{`<-x.F2`, []interface{}{"x", "field", 1, "recv"}, "V5", true},
+		{`<-x[0]`, []interface{}{"x", "arrayelem", "recv"}, "V6", true},
+		{`x`, nil, "V7", false},
+		{`y`, nil, "V1", false},
+		{`x; x`, nil, "V1", false},
+		{`x()`, nil, "V1", false},
+		{`close(x)`, nil, "V1", false},
+	}
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "file.go", myprog, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := &types.Config{}
+	pkg, err := cfg.Check("main", fset, []*ast.File{f}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, test := range tests {
+		typ := pkg.Scope().Lookup(test.v).Type().Underlying()
+		ops, _, err := parseExtendedQuery(typ, test.in)
+		if test.valid && err != nil {
+			t.Errorf("parseExtendedQuery(%q) = %s, expected no error", test.in, err)
+		}
+		if !test.valid && err == nil {
+			t.Errorf("parseExtendedQuery(%q) succeeded, expected error", test.in)
+		}
+
+		if !reflect.DeepEqual(ops, test.out) {
+			t.Errorf("parseExtendedQuery(%q) = %#v, want %#v", test.in, ops, test.out)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/reflect.go b/vendor/golang.org/x/tools/go/pointer/reflect.go
index 466995c..3439a89 100644
--- a/vendor/golang.org/x/tools/go/pointer/reflect.go
+++ b/vendor/golang.org/x/tools/go/pointer/reflect.go
@@ -1,3 +1,7 @@
+// 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
@@ -26,11 +30,11 @@ package pointer
 
 import (
 	"fmt"
+	exact "go/constant"
+	"go/types"
 	"reflect"
 
-	"golang.org/x/tools/go/exact"
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 func init() {
@@ -1879,7 +1883,7 @@ func (c *rtypeMethodByNameConstraint) solve(a *analysis, delta *nodeset) {
 				if isIface {
 					sig = sel.Type().(*types.Signature)
 				} else {
-					fn = a.prog.Method(sel)
+					fn = a.prog.MethodValue(sel)
 					// move receiver to params[0]
 					sig = changeRecv(fn.Signature)
 				}
diff --git a/vendor/golang.org/x/tools/go/pointer/solve.go b/vendor/golang.org/x/tools/go/pointer/solve.go
index ad1a65f..0fdd098 100644
--- a/vendor/golang.org/x/tools/go/pointer/solve.go
+++ b/vendor/golang.org/x/tools/go/pointer/solve.go
@@ -9,8 +9,7 @@ package pointer
 
 import (
 	"fmt"
-
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
 type solverState struct {
diff --git a/vendor/golang.org/x/tools/go/pointer/stdlib_test.go b/vendor/golang.org/x/tools/go/pointer/stdlib_test.go
new file mode 100644
index 0000000..d3ba721
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/stdlib_test.go
@@ -0,0 +1,111 @@
+// 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.
+
+// Incomplete source tree on Android.
+
+// +build !android
+
+package pointer
+
+// This file runs the pointer analysis on all packages and tests beneath
+// $GOROOT.  It provides a "smoke test" that the analysis doesn't crash
+// on a large input, and a benchmark for performance measurement.
+//
+// Because it is relatively slow, the --stdlib flag must be enabled for
+// this test to run:
+//    % go test -v golang.org/x/tools/go/pointer --stdlib
+
+import (
+	"flag"
+	"go/build"
+	"go/token"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+var runStdlibTest = flag.Bool("stdlib", false, "Run the (slow) stdlib test")
+
+func TestStdlib(t *testing.T) {
+	if !*runStdlibTest {
+		t.Skip("skipping (slow) stdlib test (use --stdlib)")
+	}
+
+	// Load, parse and type-check the program.
+	ctxt := build.Default // copy
+	ctxt.GOPATH = ""      // disable GOPATH
+	conf := loader.Config{Build: &ctxt}
+	if _, err := conf.FromArgs(buildutil.AllPackages(conf.Build), true); err != nil {
+		t.Errorf("FromArgs failed: %v", err)
+		return
+	}
+
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load failed: %v", err)
+	}
+
+	// Create SSA packages.
+	prog := ssautil.CreateProgram(iprog, 0)
+	prog.Build()
+
+	numPkgs := len(prog.AllPackages())
+	if want := 240; numPkgs < want {
+		t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want)
+	}
+
+	// Determine the set of packages/tests to analyze.
+	var mains []*ssa.Package
+	for _, info := range iprog.InitialPackages() {
+		ssapkg := prog.Package(info.Pkg)
+		if main := prog.CreateTestMainPackage(ssapkg); main != nil {
+			mains = append(mains, main)
+		}
+	}
+	if mains == nil {
+		t.Fatal("no tests found in analysis scope")
+	}
+
+	// Run the analysis.
+	config := &Config{
+		Reflection:     false, // TODO(adonovan): fix remaining bug in rVCallConstraint, then enable.
+		BuildCallGraph: true,
+		Mains:          mains,
+	}
+	// TODO(adonovan): add some query values (affects track bits).
+
+	t0 := time.Now()
+
+	result, err := Analyze(config)
+	if err != nil {
+		t.Fatal(err) // internal error in pointer analysis
+	}
+	_ = result // TODO(adonovan): measure something
+
+	t1 := time.Now()
+
+	// Dump some statistics.
+	allFuncs := ssautil.AllFunctions(prog)
+	var numInstrs int
+	for fn := range allFuncs {
+		for _, b := range fn.Blocks {
+			numInstrs += len(b.Instrs)
+		}
+	}
+
+	// determine line count
+	var lineCount int
+	prog.Fset.Iterate(func(f *token.File) bool {
+		lineCount += f.LineCount()
+		return true
+	})
+
+	t.Log("#Source lines:          ", lineCount)
+	t.Log("#Instructions:          ", numInstrs)
+	t.Log("Pointer analysis:       ", t1.Sub(t0))
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/a_test.go b/vendor/golang.org/x/tools/go/pointer/testdata/a_test.go
new file mode 100644
index 0000000..3baa9ac
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/a_test.go
@@ -0,0 +1,42 @@
+// +build ignore
+
+package a
+
+// This test exercises the synthesis of testmain packages for tests.
+// The test framework doesn't directly let us perform negative
+// assertions (i.e. that TestingQuux isn't called, or that its
+// parameter's PTS is empty) so this test is rather roundabout.
+
+import "testing"
+
+func log(f func(*testing.T)) {
+	// The PTS of f is the set of called tests.  TestingQuux is not present.
+	print(f) // @pointsto main.Test | main.TestFoo
+}
+
+func Test(t *testing.T) {
+	// Don't assert @pointsto(t) since its label contains a fragile line number.
+	log(Test)
+}
+
+func TestFoo(t *testing.T) {
+	// Don't assert @pointsto(t) since its label contains a fragile line number.
+	log(TestFoo)
+}
+
+func TestingQuux(t *testing.T) {
+	// We can't assert @pointsto(t) since this is dead code.
+	log(TestingQuux)
+}
+
+func BenchmarkFoo(b *testing.B) {
+}
+
+func ExampleBar() {
+}
+
+// Excludes TestingQuux.
+// @calls testing.tRunner -> main.Test
+// @calls testing.tRunner -> main.TestFoo
+// @calls testing.runExample -> main.ExampleBar
+// @calls (*testing.B).runN -> main.BenchmarkFoo
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/another.go b/vendor/golang.org/x/tools/go/pointer/testdata/another.go
new file mode 100644
index 0000000..12ed690
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/another.go
@@ -0,0 +1,36 @@
+// +build ignore
+
+package main
+
+var unknown bool
+
+type S string
+
+func incr(x int) int { return x + 1 }
+
+func main() {
+	var i interface{}
+	i = 1
+	if unknown {
+		i = S("foo")
+	}
+	if unknown {
+		i = (func(int, int))(nil) // NB type compares equal to that below.
+	}
+	// Look, the test harness can handle equal-but-not-String-equal
+	// types because we parse types and using a typemap.
+	if unknown {
+		i = (func(x int, y int))(nil)
+	}
+	if unknown {
+		i = incr
+	}
+	print(i) // @types int | S | func(int, int) | func(int) int
+
+	// NB, an interface may never directly alias any global
+	// labels, even though it may contain pointers that do.
+	print(i)                 // @pointsto makeinterface:func(x int) int | makeinterface:func(x int, y int) | makeinterface:func(int, int) | makeinterface:int | makeinterface:main.S
+	print(i.(func(int) int)) // @pointsto main.incr
+
+	print() // regression test for crash
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/arrayreflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/arrayreflect.go
new file mode 100644
index 0000000..2b23674
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/arrayreflect.go
@@ -0,0 +1,191 @@
+// +build ignore
+
+package main
+
+// Test of arrays & slices with reflection.
+
+import "reflect"
+
+var a, b int
+
+type S string
+
+func reflectValueSlice() {
+	// reflect.Value contains a slice.
+	slice := make([]*int, 10) // @line slice
+	slice[0] = &a
+	rvsl := reflect.ValueOf(slice).Slice(0, 0)
+	print(rvsl.Interface())              // @types []*int
+	print(rvsl.Interface().([]*int))     // @pointsto makeslice@slice:15
+	print(rvsl.Interface().([]*int)[42]) // @pointsto main.a
+
+	// reflect.Value contains an array (non-addressable).
+	array := [10]*int{&a} // @line array
+	rvarray := reflect.ValueOf(array).Slice(0, 0)
+	print(rvarray.Interface())              // @types
+	print(rvarray.Interface().([]*int))     // @pointsto
+	print(rvarray.Interface().([]*int)[42]) // @pointsto
+
+	// reflect.Value contains a pointer-to-array
+	rvparray := reflect.ValueOf(&array).Slice(0, 0)
+	print(rvparray.Interface())              // @types []*int
+	print(rvparray.Interface().([]*int))     // @pointsto array@array:2
+	print(rvparray.Interface().([]*int)[42]) // @pointsto main.a
+
+	// reflect.Value contains a string.
+	rvstring := reflect.ValueOf("hi").Slice(0, 0)
+	print(rvstring.Interface()) // @types string
+
+	// reflect.Value contains a (named) string type.
+	rvS := reflect.ValueOf(S("hi")).Slice(0, 0)
+	print(rvS.Interface()) // @types S
+
+	// reflect.Value contains a non-array pointer.
+	rvptr := reflect.ValueOf(new(int)).Slice(0, 0)
+	print(rvptr.Interface()) // @types
+
+	// reflect.Value contains a non-string basic type.
+	rvint := reflect.ValueOf(3).Slice(0, 0)
+	print(rvint.Interface()) // @types
+}
+
+func reflectValueBytes() {
+	sl1 := make([]byte, 0) // @line ar5sl1
+	sl2 := make([]byte, 0) // @line ar5sl2
+
+	rvsl1 := reflect.ValueOf(sl1)
+	print(rvsl1.Interface())          // @types []byte
+	print(rvsl1.Interface().([]byte)) // @pointsto makeslice@ar5sl1:13
+	print(rvsl1.Bytes())              // @pointsto makeslice@ar5sl1:13
+
+	rvsl2 := reflect.ValueOf(123)
+	rvsl2.SetBytes(sl2)
+	print(rvsl2.Interface())          // @types int
+	print(rvsl2.Interface().([]byte)) // @pointsto
+	print(rvsl2.Bytes())              // @pointsto
+
+	rvsl3 := reflect.ValueOf([]byte(nil))
+	rvsl3.SetBytes(sl2)
+	print(rvsl3.Interface())          // @types []byte
+	print(rvsl3.Interface().([]byte)) // @pointsto makeslice@ar5sl2:13
+	print(rvsl3.Bytes())              // @pointsto makeslice@ar5sl2:13
+}
+
+func reflectValueIndex() {
+	slice := []*int{&a} // @line ar6slice
+	rv1 := reflect.ValueOf(slice)
+	print(rv1.Index(42).Interface())        // @types *int
+	print(rv1.Index(42).Interface().(*int)) // @pointsto main.a
+
+	array := [10]*int{&a}
+	rv2 := reflect.ValueOf(array)
+	print(rv2.Index(42).Interface())        // @types *int
+	print(rv2.Index(42).Interface().(*int)) // @pointsto main.a
+
+	rv3 := reflect.ValueOf("string")
+	print(rv3.Index(42).Interface()) // @types rune
+
+	rv4 := reflect.ValueOf(&array)
+	print(rv4.Index(42).Interface()) // @types
+
+	rv5 := reflect.ValueOf(3)
+	print(rv5.Index(42).Interface()) // @types
+}
+
+func reflectValueElem() {
+	// Interface.
+	var iface interface{} = &a
+	rv1 := reflect.ValueOf(&iface).Elem()
+	print(rv1.Interface())               // @types *int
+	print(rv1.Interface().(*int))        // @pointsto main.a
+	print(rv1.Elem().Interface())        // @types *int
+	print(rv1.Elem().Interface().(*int)) // @pointsto main.a
+
+	print(reflect.ValueOf(new(interface{})).Elem().Elem()) // @types
+
+	// Pointer.
+	ptr := &a
+	rv2 := reflect.ValueOf(&ptr)
+	print(rv2.Elem().Interface())        // @types *int
+	print(rv2.Elem().Interface().(*int)) // @pointsto main.a
+
+	// No other type works with (rV).Elem, not even those that
+	// work with (rT).Elem: slice, array, map, chan.
+
+	rv3 := reflect.ValueOf([]*int{&a})
+	print(rv3.Elem().Interface()) // @types
+
+	rv4 := reflect.ValueOf([10]*int{&a})
+	print(rv4.Elem().Interface()) // @types
+
+	rv5 := reflect.ValueOf(map[*int]*int{&a: &b})
+	print(rv5.Elem().Interface()) // @types
+
+	ch := make(chan *int)
+	ch <- &a
+	rv6 := reflect.ValueOf(ch)
+	print(rv6.Elem().Interface()) // @types
+
+	rv7 := reflect.ValueOf(3)
+	print(rv7.Elem().Interface()) // @types
+}
+
+func reflectTypeElem() {
+	rt1 := reflect.TypeOf(make([]*int, 0))
+	print(reflect.Zero(rt1.Elem())) // @types *int
+
+	rt2 := reflect.TypeOf([10]*int{})
+	print(reflect.Zero(rt2.Elem())) // @types *int
+
+	rt3 := reflect.TypeOf(map[*int]*int{})
+	print(reflect.Zero(rt3.Elem())) // @types *int
+
+	rt4 := reflect.TypeOf(make(chan *int))
+	print(reflect.Zero(rt4.Elem())) // @types *int
+
+	ptr := &a
+	rt5 := reflect.TypeOf(&ptr)
+	print(reflect.Zero(rt5.Elem())) // @types *int
+
+	rt6 := reflect.TypeOf(3)
+	print(reflect.Zero(rt6.Elem())) // @types
+}
+
+func reflectPtrTo() {
+	tInt := reflect.TypeOf(3)
+	tPtrInt := reflect.PtrTo(tInt)
+	print(reflect.Zero(tPtrInt)) // @types *int
+	tPtrPtrInt := reflect.PtrTo(tPtrInt)
+	print(reflect.Zero(tPtrPtrInt)) // @types **int
+}
+
+func reflectSliceOf() {
+	tInt := reflect.TypeOf(3)
+	tSliceInt := reflect.SliceOf(tInt)
+	print(reflect.Zero(tSliceInt)) // @types []int
+}
+
+type T struct{ x int }
+
+func reflectMakeSlice() {
+	rt := []reflect.Type{
+		reflect.TypeOf(3),
+		reflect.TypeOf([]int{}),
+		reflect.TypeOf([]T{}),
+	}[0]
+	sl := reflect.MakeSlice(rt, 0, 0)
+	print(sl)                         // @types []int | []T
+	print(sl)                         // @pointsto <alloc in reflect.MakeSlice> | <alloc in reflect.MakeSlice>
+	print(&sl.Interface().([]T)[0].x) // @pointsto <alloc in reflect.MakeSlice>[*].x
+}
+
+func main() {
+	reflectValueSlice()
+	reflectValueBytes()
+	reflectValueIndex()
+	reflectValueElem()
+	reflectTypeElem()
+	reflectPtrTo()
+	reflectSliceOf()
+	reflectMakeSlice()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/arrays.go b/vendor/golang.org/x/tools/go/pointer/testdata/arrays.go
new file mode 100644
index 0000000..e57a15b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/arrays.go
@@ -0,0 +1,97 @@
+// +build ignore
+
+package main
+
+var unknown bool // defeat dead-code elimination
+
+var a, b int
+
+func array1() {
+	sliceA := make([]*int, 10) // @line a1make
+	sliceA[0] = &a
+
+	var sliceB []*int
+	sliceB = append(sliceB, &b) // @line a1append
+
+	print(sliceA)    // @pointsto makeslice@a1make:16
+	print(sliceA[0]) // @pointsto main.a
+
+	print(sliceB)      // @pointsto append@a1append:17
+	print(sliceB[100]) // @pointsto main.b
+}
+
+func array2() {
+	sliceA := make([]*int, 10) // @line a2make
+	sliceA[0] = &a
+
+	sliceB := sliceA[:]
+
+	print(sliceA)    // @pointsto makeslice@a2make:16
+	print(sliceA[0]) // @pointsto main.a
+
+	print(sliceB)    // @pointsto makeslice@a2make:16
+	print(sliceB[0]) // @pointsto main.a
+}
+
+func array3() {
+	a := []interface{}{"", 1}
+	b := []interface{}{true, func() {}}
+	print(a[0]) // @types string | int
+	print(b[0]) // @types bool | func()
+}
+
+// Test of append, copy, slice.
+func array4() {
+	var s2 struct { // @line a4L0
+		a [3]int
+		b struct{ c, d int }
+	}
+	var sl1 = make([]*int, 10) // @line a4make
+	var someint int            // @line a4L1
+	sl1[1] = &someint
+	sl2 := append(sl1, &s2.a[1]) // @line a4append1
+	print(sl1)                   // @pointsto makeslice@a4make:16
+	print(sl2)                   // @pointsto append@a4append1:15 | makeslice@a4make:16
+	print(sl1[0])                // @pointsto someint@a4L1:6 | s2.a[*]@a4L0:6
+	print(sl2[0])                // @pointsto someint@a4L1:6 | s2.a[*]@a4L0:6
+
+	// In z=append(x,y) we should observe flow from y[*] to x[*].
+	var sl3 = make([]*int, 10) // @line a4L2
+	_ = append(sl3, &s2.a[1])
+	print(sl3)    // @pointsto makeslice@a4L2:16
+	print(sl3[0]) // @pointsto s2.a[*]@a4L0:6
+
+	var sl4 = []*int{&a} // @line a4L3
+	sl4a := append(sl4)  // @line a4L4
+	print(sl4a)          // @pointsto slicelit@a4L3:18 | append@a4L4:16
+	print(&sl4a[0])      // @pointsto slicelit[*]@a4L3:18 | append[*]@a4L4:16
+	print(sl4a[0])       // @pointsto main.a
+
+	var sl5 = []*int{&b} // @line a4L5
+	copy(sl5, sl4)
+	print(sl5)     // @pointsto slicelit@a4L5:18
+	print(&sl5[0]) // @pointsto slicelit[*]@a4L5:18
+	print(sl5[0])  // @pointsto main.b | main.a
+
+	var sl6 = sl5[:0]
+	print(sl6)     // @pointsto slicelit@a4L5:18
+	print(&sl6[0]) // @pointsto slicelit[*]@a4L5:18
+	print(sl6[0])  // @pointsto main.b | main.a
+}
+
+func array5() {
+	var arr [2]*int
+	arr[0] = &a
+	arr[1] = &b
+
+	var n int
+	print(arr[n]) // @pointsto main.a | main.b
+}
+
+func main() {
+	array1()
+	array2()
+	array3()
+	array4()
+	array5()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/channels.go b/vendor/golang.org/x/tools/go/pointer/testdata/channels.go
new file mode 100644
index 0000000..377b68a
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/channels.go
@@ -0,0 +1,118 @@
+// +build ignore
+
+package main
+
+func incr(x int) int { return x + 1 }
+
+func decr(x int) int { return x - 1 }
+
+var unknown bool // defeat dead-code elimination
+
+func chan1() {
+	chA := make(chan func(int) int, 0) // @line c1makeA
+	chB := make(chan func(int) int, 0) // @line c1makeB
+	chA <- incr
+	chB <- decr
+	chB <- func(int) int { return 1 }
+
+	print(chA)   // @pointsto makechan@c1makeA:13
+	print(<-chA) // @pointsto main.incr
+
+	print(chB)   // @pointsto makechan@c1makeB:13
+	print(<-chB) // @pointsto main.decr | main.chan1$1
+}
+
+func chan2() {
+	chA := make(chan func(int) int, 0) // @line c2makeA
+	chB := make(chan func(int) int, 0) // @line c2makeB
+	chA <- incr
+	chB <- decr
+	chB <- func(int) int { return 1 }
+
+	// Channels flow together.
+	// Labelsets remain distinct but elements are merged.
+	chAB := chA
+	if unknown {
+		chAB = chB
+	}
+
+	print(chA)   // @pointsto makechan@c2makeA:13
+	print(<-chA) // @pointsto main.incr
+
+	print(chB)   // @pointsto makechan@c2makeB:13
+	print(<-chB) // @pointsto main.decr | main.chan2$1
+
+	print(chAB)   // @pointsto makechan@c2makeA:13 | makechan@c2makeB:13
+	print(<-chAB) // @pointsto main.incr | main.decr | main.chan2$1
+
+	(<-chA)(3)
+}
+
+// @calls main.chan2 -> main.incr
+
+func chan3() {
+	chA := make(chan func(int) int, 0) // @line c3makeA
+	chB := make(chan func(int) int, 0) // @line c3makeB
+	chA <- incr
+	chB <- decr
+	chB <- func(int) int { return 1 }
+	print(chA)   // @pointsto makechan@c3makeA:13
+	print(<-chA) // @pointsto main.incr
+	print(chB)   // @pointsto makechan@c3makeB:13
+	print(<-chB) // @pointsto main.decr | main.chan3$1
+
+	(<-chA)(3)
+}
+
+// @calls main.chan3 -> main.incr
+
+func chan4() {
+	chA := make(chan func(int) int, 0) // @line c4makeA
+	chB := make(chan func(int) int, 0) // @line c4makeB
+
+	select {
+	case chA <- incr:
+	case chB <- decr:
+	case a := <-chA:
+		print(a) // @pointsto main.incr
+	case b := <-chB:
+		print(b) // @pointsto main.decr
+	default:
+		print(chA) // @pointsto makechan@c4makeA:13
+		print(chB) // @pointsto makechan@c4makeB:13
+	}
+
+	for k := range chA {
+		print(k) // @pointsto main.incr
+	}
+	// Exercise constraint generation (regtest for a crash).
+	for range chA {
+	}
+}
+
+// Multi-word channel value in select with multiple receive cases.
+// (Regtest for a crash.)
+func chan5() {
+	type T struct {
+		x *int
+		y interface{}
+	}
+	ch := make(chan T)
+	ch <- T{new(int), incr} // @line ch5new
+	select {
+	case a := <-ch:
+		print(a.x) // @pointsto new@ch5new:13
+		print(a.y) // @types func(x int) int
+	case b := <-ch:
+		print(b.x) // @pointsto new@ch5new:13
+		print(b.y) // @types func(x int) int
+	}
+}
+
+func main() {
+	chan1()
+	chan2()
+	chan3()
+	chan4()
+	chan5()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect.go
new file mode 100644
index 0000000..7d22efe
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect.go
@@ -0,0 +1,85 @@
+// +build ignore
+
+package main
+
+import "reflect"
+
+// Test of channels with reflection.
+
+var a, b int
+
+func chanreflect1() {
+	ch := make(chan *int, 0) // @line cr1make
+	crv := reflect.ValueOf(ch)
+	crv.Send(reflect.ValueOf(&a))
+	print(crv.Interface())             // @types chan *int
+	print(crv.Interface().(chan *int)) // @pointsto makechan@cr1make:12
+	print(<-ch)                        // @pointsto main.a
+}
+
+func chanreflect1i() {
+	// Exercises reflect.Value conversions to/from interfaces:
+	// a different code path than for concrete types.
+	ch := make(chan interface{}, 0)
+	reflect.ValueOf(ch).Send(reflect.ValueOf(&a))
+	v := <-ch
+	print(v)        // @types *int
+	print(v.(*int)) // @pointsto main.a
+}
+
+func chanreflect2() {
+	ch := make(chan *int, 0)
+	ch <- &b
+	crv := reflect.ValueOf(ch)
+	r, _ := crv.Recv()
+	print(r.Interface())        // @types *int
+	print(r.Interface().(*int)) // @pointsto main.b
+}
+
+func chanOfRecv() {
+	// MakeChan(<-chan) is a no-op.
+	t := reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(&a))
+	print(reflect.Zero(t).Interface())                      // @types <-chan *int
+	print(reflect.MakeChan(t, 0).Interface().(<-chan *int)) // @pointsto
+	print(reflect.MakeChan(t, 0).Interface().(chan *int))   // @pointsto
+}
+
+func chanOfSend() {
+	// MakeChan(chan<-) is a no-op.
+	t := reflect.ChanOf(reflect.SendDir, reflect.TypeOf(&a))
+	print(reflect.Zero(t).Interface())                      // @types chan<- *int
+	print(reflect.MakeChan(t, 0).Interface().(chan<- *int)) // @pointsto
+	print(reflect.MakeChan(t, 0).Interface().(chan *int))   // @pointsto
+}
+
+func chanOfBoth() {
+	t := reflect.ChanOf(reflect.BothDir, reflect.TypeOf(&a))
+	print(reflect.Zero(t).Interface()) // @types chan *int
+	ch := reflect.MakeChan(t, 0)
+	print(ch.Interface().(chan *int)) // @pointsto <alloc in reflect.MakeChan>
+	ch.Send(reflect.ValueOf(&b))
+	ch.Interface().(chan *int) <- &a
+	r, _ := ch.Recv()
+	print(r.Interface().(*int))         // @pointsto main.a | main.b
+	print(<-ch.Interface().(chan *int)) // @pointsto main.a | main.b
+}
+
+var unknownDir reflect.ChanDir // not a constant
+
+func chanOfUnknown() {
+	// Unknown channel direction: assume all three.
+	// MakeChan only works on the bi-di channel type.
+	t := reflect.ChanOf(unknownDir, reflect.TypeOf(&a))
+	print(reflect.Zero(t).Interface())        // @types <-chan *int | chan<- *int | chan *int
+	print(reflect.MakeChan(t, 0).Interface()) // @types chan *int
+}
+
+func main() {
+	chanreflect1()
+	chanreflect1i()
+	chanreflect2()
+	chanOfRecv()
+	chanOfSend()
+	chanOfBoth()
+	chanOfUnknown()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect1.go b/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect1.go
new file mode 100644
index 0000000..c5e2587
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/chanreflect1.go
@@ -0,0 +1,35 @@
+// +build ignore
+
+package main
+
+import "reflect"
+
+//
+// This test is very sensitive to line-number perturbations!
+
+// Test of channels with reflection.
+
+var a, b int
+
+func chanreflect1() {
+	ch := make(chan *int, 0)
+	crv := reflect.ValueOf(ch)
+	crv.Send(reflect.ValueOf(&a))
+	print(crv.Interface())             // @types chan *int
+	print(crv.Interface().(chan *int)) // @pointsto makechan@testdata/chanreflect.go:15:12
+	print(<-ch)                        // @pointsto main.a
+}
+
+func chanreflect2() {
+	ch := make(chan *int, 0)
+	ch <- &b
+	crv := reflect.ValueOf(ch)
+	r, _ := crv.Recv()
+	print(r.Interface())        // @types *int
+	print(r.Interface().(*int)) // @pointsto main.b
+}
+
+func main() {
+	chanreflect1()
+	chanreflect2()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/context.go b/vendor/golang.org/x/tools/go/pointer/testdata/context.go
new file mode 100644
index 0000000..ed616e7
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/context.go
@@ -0,0 +1,48 @@
+// +build ignore
+
+package main
+
+// Test of context-sensitive treatment of certain function calls,
+// e.g. static calls to simple accessor methods.
+
+var a, b int
+
+type T struct{ x *int }
+
+func (t *T) SetX(x *int) { t.x = x }
+func (t *T) GetX() *int  { return t.x }
+
+func context1() {
+	var t1, t2 T
+	t1.SetX(&a)
+	t2.SetX(&b)
+	print(t1.GetX()) // @pointsto main.a
+	print(t2.GetX()) // @pointsto main.b
+}
+
+func context2() {
+	id := func(x *int) *int {
+		print(x) // @pointsto main.a | main.b
+		return x
+	}
+	print(id(&a)) // @pointsto main.a
+	print(id(&b)) // @pointsto main.b
+
+	// Same again, but anon func has free vars.
+	var c int // @line context2c
+	id2 := func(x *int) (*int, *int) {
+		print(x) // @pointsto main.a | main.b
+		return x, &c
+	}
+	p, q := id2(&a)
+	print(p) // @pointsto main.a
+	print(q) // @pointsto c@context2c:6
+	r, s := id2(&b)
+	print(r) // @pointsto main.b
+	print(s) // @pointsto c@context2c:6
+}
+
+func main() {
+	context1()
+	context2()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/conv.go b/vendor/golang.org/x/tools/go/pointer/testdata/conv.go
new file mode 100644
index 0000000..692f0ce
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/conv.go
@@ -0,0 +1,63 @@
+// +build ignore
+
+package main
+
+import "unsafe"
+
+var a int
+
+func conv1() {
+	// Conversions of channel direction.
+	ch := make(chan int)    // @line c1make
+	print((<-chan int)(ch)) // @pointsto makechan@c1make:12
+	print((chan<- int)(ch)) // @pointsto makechan@c1make:12
+}
+
+func conv2() {
+	// string -> []byte/[]rune conversion
+	s := "foo"
+	ba := []byte(s) // @line c2ba
+	ra := []rune(s) // @line c2ra
+	print(ba)       // @pointsto convert@c2ba:14
+	print(ra)       // @pointsto convert@c2ra:14
+}
+
+func conv3() {
+	// Conversion of same underlying types.
+	type PI *int
+	pi := PI(&a)
+	print(pi) // @pointsto main.a
+
+	pint := (*int)(pi)
+	print(pint) // @pointsto main.a
+
+	// Conversions between pointers to identical base types.
+	var y *PI = &pi
+	var x **int = (**int)(y)
+	print(*x) // @pointsto main.a
+	print(*y) // @pointsto main.a
+	y = (*PI)(x)
+	print(*y) // @pointsto main.a
+}
+
+func conv4() {
+	// Handling of unsafe.Pointer conversion is unsound:
+	// we lose the alias to main.a and get something like new(int) instead.
+	p := (*int)(unsafe.Pointer(&a)) // @line c2p
+	print(p)                        // @pointsto convert@c2p:13
+}
+
+// Regression test for b/8231.
+func conv5() {
+	type P unsafe.Pointer
+	var i *struct{}
+	_ = P(i)
+}
+
+func main() {
+	conv1()
+	conv2()
+	conv3()
+	conv4()
+	conv5()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/extended.go b/vendor/golang.org/x/tools/go/pointer/testdata/extended.go
new file mode 100644
index 0000000..b3dd203
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/extended.go
@@ -0,0 +1,21 @@
+// +build ignore
+
+package main
+
+var a int
+
+type t struct {
+	a *map[string]chan *int
+}
+
+func fn() []t {
+	m := make(map[string]chan *int)
+	m[""] = make(chan *int, 1)
+	m[""] <- &a
+	return []t{t{a: &m}}
+}
+
+func main() {
+	x := fn()
+	print(x) // @pointstoquery <-(*x[i].a)[key] main.a
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/finalizer.go b/vendor/golang.org/x/tools/go/pointer/testdata/finalizer.go
new file mode 100644
index 0000000..97f25c9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/finalizer.go
@@ -0,0 +1,89 @@
+package main
+
+import "runtime"
+
+func final1a(x *int) int {
+	print(x) // @pointsto new@newint:10
+	return *x
+}
+
+func final1b(x *bool) {
+	print(x) // @pointsto
+}
+
+func runtimeSetFinalizer1() {
+	x := new(int)                    // @line newint
+	runtime.SetFinalizer(x, final1a) // ok: final1a's result is ignored
+	runtime.SetFinalizer(x, final1b) // param type mismatch: no effect
+}
+
+// @calls main.runtimeSetFinalizer1 -> main.final1a
+// @calls main.runtimeSetFinalizer1 -> main.final1b
+
+func final2a(x *bool) {
+	print(x) // @pointsto new@newbool1:10 | new@newbool2:10
+}
+
+func final2b(x *bool) {
+	print(x) // @pointsto new@newbool1:10 | new@newbool2:10
+}
+
+func runtimeSetFinalizer2() {
+	x := new(bool) // @line newbool1
+	f := final2a
+	if unknown {
+		x = new(bool) // @line newbool2
+		f = final2b
+	}
+	runtime.SetFinalizer(x, f)
+}
+
+// @calls main.runtimeSetFinalizer2 -> main.final2a
+// @calls main.runtimeSetFinalizer2 -> main.final2b
+
+type T int
+
+func (t *T) finalize() {
+	print(t) // @pointsto new@final3:10
+}
+
+func runtimeSetFinalizer3() {
+	x := new(T) // @line final3
+	runtime.SetFinalizer(x, (*T).finalize)
+}
+
+// @calls main.runtimeSetFinalizer3 -> (*main.T).finalize$thunk
+
+// I hope I never live to see this code in the wild.
+var setFinalizer = runtime.SetFinalizer
+
+func final4(x *int) {
+	print(x) // @pointsto new@finalIndirect:10
+}
+
+func runtimeSetFinalizerIndirect() {
+	// In an indirect call, the shared contour for SetFinalizer is
+	// used, i.e. the call is not inlined and appears in the call graph.
+	x := new(int) // @line finalIndirect
+	setFinalizer(x, final4)
+}
+
+// Exercise the elimination of SetFinalizer
+// constraints with non-pointer operands.
+func runtimeSetFinalizerNonpointer() {
+	runtime.SetFinalizer(nil, (*T).finalize) // x is a non-pointer
+	runtime.SetFinalizer((*T).finalize, nil) // f is a non-pointer
+}
+
+// @calls main.runtimeSetFinalizerIndirect -> runtime.SetFinalizer
+// @calls runtime.SetFinalizer -> main.final4
+
+func main() {
+	runtimeSetFinalizer1()
+	runtimeSetFinalizer2()
+	runtimeSetFinalizer3()
+	runtimeSetFinalizerIndirect()
+	runtimeSetFinalizerNonpointer()
+}
+
+var unknown bool // defeat dead-code elimination
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/flow.go b/vendor/golang.org/x/tools/go/pointer/testdata/flow.go
new file mode 100644
index 0000000..6fb599e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/flow.go
@@ -0,0 +1,63 @@
+// +build ignore
+
+package main
+
+// Demonstration of directionality of flow edges.
+
+func f1() {}
+func f2() {}
+
+var somepred bool
+
+// Tracking functions.
+func flow1() {
+	s := f1
+	p := f2
+	q := p
+	r := q
+	if somepred {
+		r = s
+	}
+	print(s) // @pointsto main.f1
+	print(p) // @pointsto main.f2
+	print(q) // @pointsto main.f2
+	print(r) // @pointsto main.f1 | main.f2
+}
+
+// Tracking concrete types in interfaces.
+func flow2() {
+	var s interface{} = 1
+	var p interface{} = "foo"
+	q := p
+	r := q
+	if somepred {
+		r = s
+	}
+	print(s) // @types int
+	print(p) // @types string
+	print(q) // @types string
+	print(r) // @types int | string
+}
+
+var g1, g2 int
+
+// Tracking addresses of globals.
+func flow3() {
+	s := &g1
+	p := &g2
+	q := p
+	r := q
+	if somepred {
+		r = s
+	}
+	print(s) // @pointsto main.g1
+	print(p) // @pointsto main.g2
+	print(q) // @pointsto main.g2
+	print(r) // @pointsto main.g2 | main.g1
+}
+
+func main() {
+	flow1()
+	flow2()
+	flow3()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/fmtexcerpt.go b/vendor/golang.org/x/tools/go/pointer/testdata/fmtexcerpt.go
new file mode 100644
index 0000000..ee2a0e7
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/fmtexcerpt.go
@@ -0,0 +1,42 @@
+// +build ignore
+
+// This is a slice of the fmt package.
+
+package main
+
+type pp struct {
+	field interface{}
+}
+
+func newPrinter() *pp {
+	return new(pp)
+}
+
+func Fprintln(a ...interface{}) {
+	p := newPrinter()
+	p.doPrint(a, true, true)
+}
+
+func Println(a ...interface{}) {
+	Fprintln(a...)
+}
+
+func (p *pp) doPrint(a []interface{}, addspace, addnewline bool) {
+	print(a[0]) // @types S | string
+	stringer := a[0].(interface {
+		String() string
+	})
+
+	stringer.String()
+	print(stringer) // @types S
+}
+
+type S int
+
+func (S) String() string { return "" }
+
+func main() {
+	Println("Hello, World!", S(0))
+}
+
+// @calls (*main.pp).doPrint -> (main.S).String
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/func.go b/vendor/golang.org/x/tools/go/pointer/testdata/func.go
new file mode 100644
index 0000000..2155f8e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/func.go
@@ -0,0 +1,205 @@
+// +build ignore
+
+package main
+
+var a, b, c int
+
+var unknown bool // defeat dead-code elimination
+
+func func1() {
+	var h int // @line f1h
+	f := func(x *int) *int {
+		if unknown {
+			return &b
+		}
+		return x
+	}
+
+	// FV(g) = {f, h}
+	g := func(x *int) *int {
+		if unknown {
+			return &h
+		}
+		return f(x)
+	}
+
+	print(g(&a)) // @pointsto main.a | main.b | h@f1h:6
+	print(f(&a)) // @pointsto main.a | main.b
+	print(&a)    // @pointsto main.a
+}
+
+// @calls main.func1 -> main.func1$2
+// @calls main.func1 -> main.func1$1
+// @calls main.func1$2 ->  main.func1$1
+
+func func2() {
+	var x, y *int
+	defer func() {
+		x = &a
+	}()
+	go func() {
+		y = &b
+	}()
+	print(x) // @pointsto main.a
+	print(y) // @pointsto main.b
+}
+
+func func3() {
+	x, y := func() (x, y *int) {
+		x = &a
+		y = &b
+		if unknown {
+			return nil, &c
+		}
+		return
+	}()
+	print(x) // @pointsto main.a
+	print(y) // @pointsto main.b | main.c
+}
+
+func swap(x, y *int) (*int, *int) { // @line swap
+	print(&x) // @pointsto x@swap:11
+	print(x)  // @pointsto makeslice[*]@func4make:11
+	print(&y) // @pointsto y@swap:14
+	print(y)  // @pointsto j@f4j:5
+	return y, x
+}
+
+func func4() {
+	a := make([]int, 10) // @line func4make
+	i, j := 123, 456     // @line f4j
+	_ = i
+	p, q := swap(&a[3], &j)
+	print(p) // @pointsto j@f4j:5
+	print(q) // @pointsto makeslice[*]@func4make:11
+
+	f := &b
+	print(f) // @pointsto main.b
+}
+
+type T int
+
+func (t *T) f(x *int) *int {
+	print(t) // @pointsto main.a
+	print(x) // @pointsto main.c
+	return &b
+}
+
+func (t *T) g(x *int) *int {
+	print(t) // @pointsto main.a
+	print(x) // @pointsto main.b
+	return &c
+}
+
+func (t *T) h(x *int) *int {
+	print(t) // @pointsto main.a
+	print(x) // @pointsto main.b
+	return &c
+}
+
+var h func(*T, *int) *int
+
+func func5() {
+	// Static call of method.
+	t := (*T)(&a)
+	print(t.f(&c)) // @pointsto main.b
+
+	// Static call of method as function
+	print((*T).g(t, &b)) // @pointsto main.c
+
+	// Dynamic call (not invoke) of method.
+	h = (*T).h
+	print(h(t, &b)) // @pointsto main.c
+}
+
+// @calls main.func5 -> (*main.T).f
+// @calls main.func5 -> (*main.T).g$thunk
+// @calls main.func5 -> (*main.T).h$thunk
+
+func func6() {
+	A := &a
+	f := func() *int {
+		return A // (free variable)
+	}
+	print(f()) // @pointsto main.a
+}
+
+// @calls main.func6 -> main.func6$1
+
+type I interface {
+	f()
+}
+
+type D struct{}
+
+func (D) f() {}
+
+func func7() {
+	var i I = D{}
+	imethodClosure := i.f
+	imethodClosure()
+	// @calls main.func7 -> (main.I).f$bound
+	// @calls (main.I).f$bound -> (main.D).f
+
+	var d D
+	cmethodClosure := d.f
+	cmethodClosure()
+	// @calls main.func7 -> (main.D).f$bound
+	// @calls (main.D).f$bound ->(main.D).f
+
+	methodExpr := D.f
+	methodExpr(d)
+	// @calls main.func7 -> (main.D).f$thunk
+}
+
+func func8(x ...int) {
+	print(&x[0]) // @pointsto varargs[*]@varargs:15
+}
+
+type E struct {
+	x1, x2, x3, x4, x5 *int
+}
+
+func (e E) f() {}
+
+func func9() {
+	// Regression test for bug reported by Jon Valdes on golang-dev, Jun 19 2014.
+	// The receiver of a bound method closure may be of a multi-node type, E.
+	// valueNode was reserving only a single node for it, so the
+	// nodes used by the immediately following constraints
+	// (e.g. param 'i') would get clobbered.
+
+	var e E
+	e.x1 = &a
+	e.x2 = &a
+	e.x3 = &a
+	e.x4 = &a
+	e.x5 = &a
+
+	_ = e.f // form a closure---must reserve sizeof(E) nodes
+
+	func(i I) {
+		i.f() // must not crash the solver
+	}(new(D))
+
+	print(e.x1) // @pointsto main.a
+	print(e.x2) // @pointsto main.a
+	print(e.x3) // @pointsto main.a
+	print(e.x4) // @pointsto main.a
+	print(e.x5) // @pointsto main.a
+}
+
+func main() {
+	func1()
+	func2()
+	func3()
+	func4()
+	func5()
+	func6()
+	func7()
+	func8(1, 2, 3) // @line varargs
+	func9()
+}
+
+// @calls <root> -> main.main
+// @calls <root> -> main.init
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/funcreflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/funcreflect.go
new file mode 100644
index 0000000..a0a9a5f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/funcreflect.go
@@ -0,0 +1,130 @@
+// +build ignore
+
+package main
+
+import "reflect"
+
+var zero, a, b int
+var false2 bool
+
+func f(p *int, q hasF) *int {
+	print(p)      // @pointsto main.a
+	print(q)      // @types *T
+	print(q.(*T)) // @pointsto new@newT1:22
+	return &b
+}
+
+func g(p *bool) (*int, *bool, hasF) {
+	return &b, p, new(T) // @line newT2
+}
+
+func reflectValueCall() {
+	rvf := reflect.ValueOf(f)
+	res := rvf.Call([]reflect.Value{
+		// argument order is not significant:
+		reflect.ValueOf(new(T)), // @line newT1
+		reflect.ValueOf(&a),
+	})
+	print(res[0].Interface())        // @types *int
+	print(res[0].Interface().(*int)) // @pointsto main.b
+}
+
+// @calls main.reflectValueCall -> main.f
+
+func reflectValueCallIndirect() {
+	rvf := reflect.ValueOf(g)
+	call := rvf.Call // kids, don't try this at home
+
+	// Indirect call uses shared contour.
+	//
+	// Also notice that argument position doesn't matter, and args
+	// of inappropriate type (e.g. 'a') are ignored.
+	res := call([]reflect.Value{
+		reflect.ValueOf(&a),
+		reflect.ValueOf(&false2),
+	})
+	res0 := res[0].Interface()
+	print(res0)         // @types *int | *bool | *T
+	print(res0.(*int))  // @pointsto main.b
+	print(res0.(*bool)) // @pointsto main.false2
+	print(res0.(hasF))  // @types *T
+	print(res0.(*T))    // @pointsto new@newT2:19
+}
+
+// @calls main.reflectValueCallIndirect -> (reflect.Value).Call$bound
+// @calls (reflect.Value).Call$bound -> main.g
+
+func reflectTypeInOut() {
+	var f func(float64, bool) (string, int)
+	print(reflect.Zero(reflect.TypeOf(f).In(0)).Interface())    // @types float64
+	print(reflect.Zero(reflect.TypeOf(f).In(1)).Interface())    // @types bool
+	print(reflect.Zero(reflect.TypeOf(f).In(-1)).Interface())   // @types float64 | bool
+	print(reflect.Zero(reflect.TypeOf(f).In(zero)).Interface()) // @types float64 | bool
+
+	print(reflect.Zero(reflect.TypeOf(f).Out(0)).Interface()) // @types string
+	print(reflect.Zero(reflect.TypeOf(f).Out(1)).Interface()) // @types int
+	print(reflect.Zero(reflect.TypeOf(f).Out(2)).Interface()) // @types
+
+	print(reflect.Zero(reflect.TypeOf(3).Out(0)).Interface()) // @types
+}
+
+type hasF interface {
+	F()
+}
+
+type T struct{}
+
+func (T) F()    {}
+func (T) g(int) {}
+
+type U struct{}
+
+func (U) F(int)    {}
+func (U) g(string) {}
+
+type I interface {
+	f()
+}
+
+var nonconst string
+
+func reflectTypeMethodByName() {
+	TU := reflect.TypeOf([]interface{}{T{}, U{}}[0])
+	print(reflect.Zero(TU)) // @types T | U
+
+	F, _ := TU.MethodByName("F")
+	print(reflect.Zero(F.Type)) // @types func(T) | func(U, int)
+	print(F.Func)               // @pointsto (main.T).F | (main.U).F
+
+	g, _ := TU.MethodByName("g")
+	print(reflect.Zero(g.Type)) // @types func(T, int) | func(U, string)
+	print(g.Func)               // @pointsto (main.T).g | (main.U).g
+
+	// Non-literal method names are treated less precisely.
+	U := reflect.TypeOf(U{})
+	X, _ := U.MethodByName(nonconst)
+	print(reflect.Zero(X.Type)) // @types func(U, int) | func(U, string)
+	print(X.Func)               // @pointsto (main.U).F | (main.U).g
+
+	// Interface methods.
+	rThasF := reflect.TypeOf(new(hasF)).Elem()
+	print(reflect.Zero(rThasF)) // @types hasF
+	F2, _ := rThasF.MethodByName("F")
+	print(reflect.Zero(F2.Type)) // @types func()
+	print(F2.Func)               // @pointsto
+
+}
+
+func reflectTypeMethod() {
+	m := reflect.TypeOf(T{}).Method(0)
+	print(reflect.Zero(m.Type)) // @types func(T) | func(T, int)
+	print(m.Func)               // @pointsto (main.T).F | (main.T).g
+}
+
+func main() {
+	reflectValueCall()
+	reflectValueCallIndirect()
+	reflectTypeInOut()
+	reflectTypeMethodByName()
+	reflectTypeMethod()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/hello.go b/vendor/golang.org/x/tools/go/pointer/testdata/hello.go
new file mode 100644
index 0000000..b81784b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/hello.go
@@ -0,0 +1,27 @@
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+type S int
+
+var theS S
+
+func (s *S) String() string {
+	print(s) // @pointsto main.theS
+	return ""
+}
+
+func main() {
+	// os.Args is considered intrinsically allocated,
+	// but may also be set explicitly (e.g. on Windows), hence '...'.
+	print(os.Args) // @pointsto <command-line args> | ...
+	fmt.Println("Hello, World!", &theS)
+}
+
+// @calls main.main               -> fmt.Println
+// @calls (*fmt.pp).handleMethods -> (*main.S).String
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/interfaces.go b/vendor/golang.org/x/tools/go/pointer/testdata/interfaces.go
new file mode 100644
index 0000000..91c0fa9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/interfaces.go
@@ -0,0 +1,152 @@
+// +build ignore
+
+package main
+
+type I interface {
+	f()
+}
+
+type C int
+
+func (*C) f() {}
+
+type D struct{ ptr *int }
+
+func (D) f() {}
+
+type E struct{}
+
+func (*E) f() {}
+
+var a, b int
+
+var unknown bool // defeat dead-code elimination
+
+func interface1() {
+	var i interface{} = &a
+	var j interface{} = D{&b}
+	k := j
+	if unknown {
+		k = i
+	}
+
+	print(i) // @types *int
+	print(j) // @types D
+	print(k) // @types *int | D
+
+	print(i.(*int)) // @pointsto main.a
+	print(j.(*int)) // @pointsto
+	print(k.(*int)) // @pointsto main.a
+
+	print(i.(D).ptr) // @pointsto
+	print(j.(D).ptr) // @pointsto main.b
+	print(k.(D).ptr) // @pointsto main.b
+}
+
+func interface2() {
+	var i I = (*C)(&a)
+	var j I = D{&a}
+	k := j
+	if unknown {
+		k = i
+	}
+
+	print(i) // @types *C
+	print(j) // @types D
+	print(k) // @types *C | D
+	print(k) // @pointsto makeinterface:main.D | makeinterface:*main.C
+
+	k.f()
+	// @calls main.interface2 -> (*main.C).f
+	// @calls main.interface2 -> (main.D).f
+
+	print(i.(*C))    // @pointsto main.a
+	print(j.(D).ptr) // @pointsto main.a
+	print(k.(*C))    // @pointsto main.a
+
+	switch x := k.(type) {
+	case *C:
+		print(x) // @pointsto main.a
+	case D:
+		print(x.ptr) // @pointsto main.a
+	case *E:
+		print(x) // @pointsto
+	}
+}
+
+func interface3() {
+	// There should be no backflow of concrete types from the type-switch to x.
+	var x interface{} = 0
+	print(x) // @types int
+	switch x.(type) {
+	case int:
+	case string:
+	}
+}
+
+func interface4() {
+	var i interface{} = D{&a}
+	if unknown {
+		i = 123
+	}
+
+	print(i) // @types int | D
+
+	j := i.(I)       // interface narrowing type-assertion
+	print(j)         // @types D
+	print(j.(D).ptr) // @pointsto main.a
+
+	var l interface{} = j // interface widening assignment.
+	print(l)              // @types D
+	print(l.(D).ptr)      // @pointsto main.a
+
+	m := j.(interface{}) // interface widening type-assertion.
+	print(m)             // @types D
+	print(m.(D).ptr)     // @pointsto main.a
+}
+
+// Interface method calls and value flow:
+
+type J interface {
+	f(*int) *int
+}
+
+type P struct {
+	x int
+}
+
+func (p *P) f(pi *int) *int {
+	print(p)  // @pointsto p@i5p:6
+	print(pi) // @pointsto i@i5i:6
+	return &p.x
+}
+
+func interface5() {
+	var p P // @line i5p
+	var j J = &p
+	var i int      // @line i5i
+	print(j.f(&i)) // @pointsto p.x@i5p:6
+	print(&i)      // @pointsto i@i5i:6
+
+	print(j) // @pointsto makeinterface:*main.P
+}
+
+// @calls main.interface5 -> (*main.P).f
+
+func interface6() {
+	f := I.f
+	print(f) // @pointsto (main.I).f$thunk
+	f(new(struct{ D }))
+}
+
+// @calls main.interface6 -> (main.I).f$thunk
+// @calls (main.I).f$thunk -> (*struct{main.D}).f
+
+func main() {
+	interface1()
+	interface2()
+	interface3()
+	interface4()
+	interface5()
+	interface6()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/issue9002.go b/vendor/golang.org/x/tools/go/pointer/testdata/issue9002.go
new file mode 100644
index 0000000..b7c2c61
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/issue9002.go
@@ -0,0 +1,17 @@
+package main
+
+func main() {
+	// Regression test for golang issue 9002.
+	//
+	// The two-result "value,ok" receive operation generated a
+	// too-wide constraint loading (value int, ok bool), not bool,
+	// from the channel.
+	//
+	// This bug manifested itself in an out-of-bounds array access
+	// when the makechan object was the highest-numbered node, as in
+	// this program.
+	//
+	// In more realistic programs it silently resulted in bogus
+	// constraints.
+	_, _ = <-make(chan int)
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/mapreflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/mapreflect.go
new file mode 100644
index 0000000..bc5e7e6
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/mapreflect.go
@@ -0,0 +1,117 @@
+// +build ignore
+
+package main
+
+// Test of maps with reflection.
+
+import "reflect"
+
+var a int
+var b bool
+
+func reflectMapKeysIndex() {
+	m := make(map[*int]*bool) // @line mr1make
+	m[&a] = &b
+
+	mrv := reflect.ValueOf(m)
+	print(mrv.Interface())                  // @types map[*int]*bool
+	print(mrv.Interface().(map[*int]*bool)) // @pointsto makemap@mr1make:11
+	print(mrv)                              // @pointsto makeinterface:map[*int]*bool
+	print(mrv)                              // @types map[*int]*bool
+
+	keys := mrv.MapKeys()
+	print(keys) // @pointsto <alloc in (reflect.Value).MapKeys>
+	for _, k := range keys {
+		print(k)                    // @pointsto <alloc in (reflect.Value).MapKeys>
+		print(k)                    // @types *int
+		print(k.Interface())        // @types *int
+		print(k.Interface().(*int)) // @pointsto main.a
+
+		v := mrv.MapIndex(k)
+		print(v.Interface())         // @types *bool
+		print(v.Interface().(*bool)) // @pointsto main.b
+	}
+}
+
+func reflectSetMapIndex() {
+	m := make(map[*int]*bool)
+	mrv := reflect.ValueOf(m)
+	mrv.SetMapIndex(reflect.ValueOf(&a), reflect.ValueOf(&b))
+
+	print(m[nil]) // @pointsto main.b
+
+	for _, k := range mrv.MapKeys() {
+		print(k.Interface())        // @types *int
+		print(k.Interface().(*int)) // @pointsto main.a
+	}
+
+	tmap := reflect.TypeOf(m)
+	// types.EvalNode won't let us refer to non-exported types:
+	// print(tmap) // #@types *reflect.rtype
+	print(tmap) // @pointsto map[*int]*bool
+
+	zmap := reflect.Zero(tmap)
+	print(zmap)             // @pointsto <alloc in reflect.Zero>
+	print(zmap.Interface()) // @pointsto <alloc in reflect.Zero>
+
+	print(tmap.Key())                            // @pointsto *int
+	print(tmap.Elem())                           // @pointsto *bool
+	print(reflect.Zero(tmap.Key()))              // @pointsto <alloc in reflect.Zero>
+	print(reflect.Zero(tmap.Key()).Interface())  // @pointsto <alloc in reflect.Zero>
+	print(reflect.Zero(tmap.Key()).Interface())  // @types *int
+	print(reflect.Zero(tmap.Elem()))             // @pointsto <alloc in reflect.Zero>
+	print(reflect.Zero(tmap.Elem()).Interface()) // @pointsto <alloc in reflect.Zero>
+	print(reflect.Zero(tmap.Elem()).Interface()) // @types *bool
+}
+
+func reflectSetMapIndexInterface() {
+	// Exercises reflect.Value conversions to/from interfaces:
+	// a different code path than for concrete types.
+	m := make(map[interface{}]interface{})
+	reflect.ValueOf(m).SetMapIndex(reflect.ValueOf(&a), reflect.ValueOf(&b))
+	for k, v := range m {
+		print(k)         // @types *int
+		print(k.(*int))  // @pointsto main.a
+		print(v)         // @types *bool
+		print(v.(*bool)) // @pointsto main.b
+	}
+}
+
+func reflectSetMapIndexAssignable() {
+	// SetMapIndex performs implicit assignability conversions.
+	type I *int
+	type J *int
+
+	str := reflect.ValueOf("")
+
+	// *int is assignable to I.
+	m1 := make(map[string]I)
+	reflect.ValueOf(m1).SetMapIndex(str, reflect.ValueOf(new(int))) // @line int
+	print(m1[""])                                                   // @pointsto new@int:58
+
+	// I is assignable to I.
+	m2 := make(map[string]I)
+	reflect.ValueOf(m2).SetMapIndex(str, reflect.ValueOf(I(new(int)))) // @line I
+	print(m2[""])                                                      // @pointsto new@I:60
+
+	// J is not assignable to I.
+	m3 := make(map[string]I)
+	reflect.ValueOf(m3).SetMapIndex(str, reflect.ValueOf(J(new(int))))
+	print(m3[""]) // @pointsto
+}
+
+func reflectMakeMap() {
+	t := reflect.TypeOf(map[*int]*bool(nil))
+	v := reflect.MakeMap(t)
+	print(v) // @types map[*int]*bool
+	print(v) // @pointsto <alloc in reflect.MakeMap>
+}
+
+func main() {
+	reflectMapKeysIndex()
+	reflectSetMapIndex()
+	reflectSetMapIndexInterface()
+	reflectSetMapIndexAssignable()
+	reflectMakeMap()
+	// TODO(adonovan): reflect.MapOf(Type)
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/maps.go b/vendor/golang.org/x/tools/go/pointer/testdata/maps.go
new file mode 100644
index 0000000..6729304
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/maps.go
@@ -0,0 +1,74 @@
+// +build ignore
+
+package main
+
+// Test of maps.
+
+var a, b, c int
+
+func maps1() {
+	m1 := map[*int]*int{&a: &b} // @line m1m1
+	m2 := make(map[*int]*int)   // @line m1m2
+	m2[&b] = &a
+
+	print(m1[nil]) // @pointsto main.b | main.c
+	print(m2[nil]) // @pointsto main.a
+
+	print(m1) // @pointsto makemap@m1m1:21
+	print(m2) // @pointsto makemap@m1m2:12
+
+	m1[&b] = &c
+
+	for k, v := range m1 {
+		print(k) // @pointsto main.a | main.b
+		print(v) // @pointsto main.b | main.c
+	}
+
+	for k, v := range m2 {
+		print(k) // @pointsto main.b
+		print(v) // @pointsto main.a
+	}
+
+	// Lookup doesn't create any aliases.
+	print(m2[&c]) // @pointsto main.a
+	if _, ok := m2[&a]; ok {
+		print(m2[&c]) // @pointsto main.a
+	}
+}
+
+func maps2() {
+	m1 := map[*int]*int{&a: &b}
+	m2 := map[*int]*int{&b: &c}
+	_ = []map[*int]*int{m1, m2} // (no spurious merging of m1, m2)
+
+	print(m1[nil]) // @pointsto main.b
+	print(m2[nil]) // @pointsto main.c
+}
+
+var g int
+
+func maps3() {
+	// Regression test for a constraint generation bug for map range
+	// loops in which the key is unused: the (ok, k, v) tuple
+	// returned by ssa.Next may have type 'invalid' for the k and/or
+	// v components, so copying the map key or value may cause
+	// miswiring if the key has >1 components.  In the worst case,
+	// this causes a crash.  The test below used to report that
+	// pts(v) includes not just main.g but new(float64) too, which
+	// is ill-typed.
+
+	// sizeof(K) > 1, abstractly
+	type K struct{ a, b *float64 }
+	k := K{new(float64), nil}
+	m := map[K]*int{k: &g}
+
+	for _, v := range m {
+		print(v) // @pointsto main.g
+	}
+}
+
+func main() {
+	maps1()
+	maps2()
+	maps3()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/panic.go b/vendor/golang.org/x/tools/go/pointer/testdata/panic.go
new file mode 100644
index 0000000..ee8a766
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/panic.go
@@ -0,0 +1,36 @@
+// +build ignore
+
+package main
+
+// Test of value flow from panic() to recover().
+// We model them as stores/loads of a global location.
+// We ignore concrete panic types originating from the runtime.
+
+var someval int
+
+type myPanic struct{}
+
+func f(int) {}
+
+func g() string { return "" }
+
+func deadcode() {
+	panic(123) // not reached
+}
+
+func main() {
+	switch someval {
+	case 0:
+		panic("oops")
+	case 1:
+		panic(myPanic{})
+	case 2:
+		panic(f)
+	case 3:
+		panic(g)
+	}
+	ex := recover()
+	print(ex)                 // @types myPanic | string | func(int) | func() string
+	print(ex.(func(int)))     // @pointsto main.f
+	print(ex.(func() string)) // @pointsto main.g
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/recur.go b/vendor/golang.org/x/tools/go/pointer/testdata/recur.go
new file mode 100644
index 0000000..4c7229d
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/recur.go
@@ -0,0 +1,11 @@
+// +build ignore
+
+package main
+
+// Analysis abstraction of recursive calls is finite.
+
+func main() {
+	main()
+}
+
+// @calls main.main -> main.main
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/reflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/reflect.go
new file mode 100644
index 0000000..6b8d0f2
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/reflect.go
@@ -0,0 +1,115 @@
+// +build ignore
+
+package main
+
+import "reflect"
+import "unsafe"
+
+var a, b int
+var unknown bool
+
+func reflectIndirect() {
+	ptr := &a
+	// Pointer:
+	print(reflect.Indirect(reflect.ValueOf(&ptr)).Interface().(*int)) // @pointsto main.a
+	// Non-pointer:
+	print(reflect.Indirect(reflect.ValueOf([]*int{ptr})).Interface().([]*int)[0]) // @pointsto main.a
+}
+
+func reflectNewAt() {
+	var x [8]byte
+	print(reflect.NewAt(reflect.TypeOf(3), unsafe.Pointer(&x)).Interface()) // @types *int
+}
+
+// @warning "unsound: main.reflectNewAt contains a reflect.NewAt.. call"
+
+func reflectTypeOf() {
+	t := reflect.TypeOf(3)
+	if unknown {
+		t = reflect.TypeOf("foo")
+	}
+	// TODO(adonovan): make types.Eval let us refer to unexported types.
+	print(t)                             // #@types *reflect.rtype
+	print(reflect.Zero(t).Interface())   // @types int | string
+	newint := reflect.New(t).Interface() // @line rtonew
+	print(newint)                        // @types *int | *string
+	print(newint.(*int))                 // @pointsto <alloc in reflect.New>
+	print(newint.(*string))              // @pointsto <alloc in reflect.New>
+}
+
+func reflectTypeElem() {
+	print(reflect.Zero(reflect.TypeOf(&a).Elem()).Interface())                       // @types int
+	print(reflect.Zero(reflect.TypeOf([]string{}).Elem()).Interface())               // @types string
+	print(reflect.Zero(reflect.TypeOf(make(chan bool)).Elem()).Interface())          // @types bool
+	print(reflect.Zero(reflect.TypeOf(make(map[string]float64)).Elem()).Interface()) // @types float64
+	print(reflect.Zero(reflect.TypeOf([3]complex64{}).Elem()).Interface())           // @types complex64
+	print(reflect.Zero(reflect.TypeOf(3).Elem()).Interface())                        // @types
+	print(reflect.Zero(reflect.TypeOf(new(interface{})).Elem()))                     // @types interface{}
+	print(reflect.Zero(reflect.TypeOf(new(interface{})).Elem()).Interface())         // @types
+}
+
+// reflect.Values within reflect.Values.
+func metareflection() {
+	// "box" a *int twice, unbox it twice.
+	v0 := reflect.ValueOf(&a)
+	print(v0)                              // @types *int
+	v1 := reflect.ValueOf(v0)              // box
+	print(v1)                              // @types reflect.Value
+	v2 := reflect.ValueOf(v1)              // box
+	print(v2)                              // @types reflect.Value
+	v1a := v2.Interface().(reflect.Value)  // unbox
+	print(v1a)                             // @types reflect.Value
+	v0a := v1a.Interface().(reflect.Value) // unbox
+	print(v0a)                             // @types *int
+	print(v0a.Interface().(*int))          // @pointsto main.a
+
+	// "box" an interface{} lvalue twice, unbox it twice.
+	var iface interface{} = 3
+	x0 := reflect.ValueOf(&iface).Elem()
+	print(x0)                              // @types interface{}
+	x1 := reflect.ValueOf(x0)              // box
+	print(x1)                              // @types reflect.Value
+	x2 := reflect.ValueOf(x1)              // box
+	print(x2)                              // @types reflect.Value
+	x1a := x2.Interface().(reflect.Value)  // unbox
+	print(x1a)                             // @types reflect.Value
+	x0a := x1a.Interface().(reflect.Value) // unbox
+	print(x0a)                             // @types interface{}
+	print(x0a.Interface())                 // @types int
+}
+
+type T struct{}
+
+// When the output of a type constructor flows to its input, we must
+// bound the set of types created to ensure termination of the algorithm.
+func typeCycle() {
+	t := reflect.TypeOf(0)
+	u := reflect.TypeOf("")
+	v := reflect.TypeOf(T{})
+	for unknown {
+		t = reflect.PtrTo(t)
+		t = reflect.SliceOf(t)
+
+		u = reflect.SliceOf(u)
+
+		if unknown {
+			v = reflect.ChanOf(reflect.BothDir, v)
+		} else {
+			v = reflect.PtrTo(v)
+		}
+	}
+
+	// Type height is bounded to about 4 map/slice/chan/pointer constructors.
+	print(reflect.Zero(t).Interface()) // @types int | []*int | []*[]*int
+	print(reflect.Zero(u).Interface()) // @types string | []string | [][]string | [][][]string | [][][][]string
+	print(reflect.Zero(v).Interface()) // @types T | *T | **T | ***T | ****T | chan T | *chan T | **chan T | chan *T | *chan *T | chan **T | chan ***T | chan chan T | chan *chan T | chan chan *T
+}
+
+func main() {
+	reflectIndirect()
+	reflectNewAt()
+	reflectTypeOf()
+	reflectTypeElem()
+	metareflection()
+	typeCycle()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/rtti.go b/vendor/golang.org/x/tools/go/pointer/testdata/rtti.go
new file mode 100644
index 0000000..88e1798
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/rtti.go
@@ -0,0 +1,29 @@
+package main
+
+// Regression test for guru crash
+// https://code.google.com/p/go/issues/detail?id=6605
+//
+// Using reflection, methods may be called on types that are not the
+// operand of any ssa.MakeInterface instruction.  In this example,
+// (Y).F is called by deriving the type Y from *Y.  Prior to the fix,
+// no RTTI (or method set) for type Y was included in the program, so
+// the F() call would crash.
+
+import "reflect"
+
+var a int
+
+type X struct{}
+
+func (X) F() *int {
+	return &a
+}
+
+type I interface {
+	F() *int
+}
+
+func main() {
+	type Y struct{ X }
+	print(reflect.Indirect(reflect.ValueOf(new(Y))).Interface().(I).F()) // @pointsto main.a
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/structreflect.go b/vendor/golang.org/x/tools/go/pointer/testdata/structreflect.go
new file mode 100644
index 0000000..9fb49f5
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/structreflect.go
@@ -0,0 +1,45 @@
+// +build ignore
+
+package main
+
+import "reflect"
+
+type A struct {
+	f *int
+	g interface{}
+	h bool
+}
+
+var dyn string
+
+func reflectTypeFieldByName() {
+	f, _ := reflect.TypeOf(A{}).FieldByName("f")
+	print(f.Type) // @pointsto *int
+
+	g, _ := reflect.TypeOf(A{}).FieldByName("g")
+	print(g.Type)               // @pointsto interface{}
+	print(reflect.Zero(g.Type)) // @pointsto <alloc in reflect.Zero>
+	print(reflect.Zero(g.Type)) // @types interface{}
+
+	print(reflect.Zero(g.Type).Interface()) // @pointsto
+	print(reflect.Zero(g.Type).Interface()) // @types
+
+	h, _ := reflect.TypeOf(A{}).FieldByName("h")
+	print(h.Type) // @pointsto bool
+
+	missing, _ := reflect.TypeOf(A{}).FieldByName("missing")
+	print(missing.Type) // @pointsto
+
+	dyn, _ := reflect.TypeOf(A{}).FieldByName(dyn)
+	print(dyn.Type) // @pointsto *int | bool | interface{}
+}
+
+func reflectTypeField() {
+	fld := reflect.TypeOf(A{}).Field(0)
+	print(fld.Type) // @pointsto *int | bool | interface{}
+}
+
+func main() {
+	reflectTypeFieldByName()
+	reflectTypeField()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/structs.go b/vendor/golang.org/x/tools/go/pointer/testdata/structs.go
new file mode 100644
index 0000000..9036d60
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/structs.go
@@ -0,0 +1,100 @@
+// +build ignore
+
+package main
+
+var unknown bool // defeat dead-code elimination
+
+var p, q int
+
+type A struct {
+	f *int
+	g interface{}
+}
+
+func (a A) m1() {
+	print(a.f) // @pointsto main.p
+}
+
+func (a *A) m2() {
+	print(a)   // @pointsto complit.A@struct1s:9
+	print(a.f) // @pointsto main.p
+}
+
+type B struct {
+	h *int
+	A
+}
+
+func structs1() {
+	b := &B{ // @line struct1s
+		h: &q,
+	}
+	b.f = &p
+	b.g = b
+
+	print(b.h) // @pointsto main.q
+	print(b.f) // @pointsto main.p
+	print(b.g) // @types *B
+
+	ptr := &b.f
+	print(*ptr) // @pointsto main.p
+
+	b.m1()
+	b.m2()
+}
+
+// @calls main.structs1 -> (main.A).m1
+// @calls main.structs1 -> (*main.A).m2
+// @calls (*main.B).m1 -> (main.A).m1
+// @calls (*main.B).m2 -> (*main.A).m2
+
+type T struct {
+	x int
+	y int
+}
+
+type S struct {
+	a [3]T
+	b *[3]T
+	c [3]*T
+}
+
+func structs2() {
+	var s S          // @line s2s
+	print(&s)        // @pointsto s@s2s:6
+	print(&s.a)      // @pointsto s.a@s2s:6
+	print(&s.a[0])   // @pointsto s.a[*]@s2s:6
+	print(&s.a[0].x) // @pointsto s.a[*].x@s2s:6
+	print(&s.a[0].y) // @pointsto s.a[*].y@s2s:6
+	print(&s.b)      // @pointsto s.b@s2s:6
+	print(&s.b[0])   // @pointsto
+	print(&s.b[0].x) // @pointsto
+	print(&s.b[0].y) // @pointsto
+	print(&s.c)      // @pointsto s.c@s2s:6
+	print(&s.c[0])   // @pointsto s.c[*]@s2s:6
+	print(&s.c[0].x) // @pointsto
+	print(&s.c[0].y) // @pointsto
+
+	var s2 S          // @line s2s2
+	s2.b = new([3]T)  // @line s2s2b
+	print(s2.b)       // @pointsto new@s2s2b:12
+	print(&s2.b)      // @pointsto s2.b@s2s2:6
+	print(&s2.b[0])   // @pointsto new[*]@s2s2b:12
+	print(&s2.b[0].x) // @pointsto new[*].x@s2s2b:12
+	print(&s2.b[0].y) // @pointsto new[*].y@s2s2b:12
+	print(&s2.c[0].x) // @pointsto
+	print(&s2.c[0].y) // @pointsto
+
+	var s3 S          // @line s2s3
+	s3.c[2] = new(T)  // @line s2s3c
+	print(&s3.c)      // @pointsto s3.c@s2s3:6
+	print(s3.c[1])    // @pointsto new@s2s3c:15
+	print(&s3.c[1])   // @pointsto s3.c[*]@s2s3:6
+	print(&s3.c[1].x) // @pointsto new.x@s2s3c:15
+	print(&s3.c[1].y) // @pointsto new.y@s2s3c:15
+}
+
+func main() {
+	structs1()
+	structs2()
+}
diff --git a/vendor/golang.org/x/tools/go/pointer/testdata/timer.go b/vendor/golang.org/x/tools/go/pointer/testdata/timer.go
new file mode 100644
index 0000000..465d081
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/pointer/testdata/timer.go
@@ -0,0 +1,24 @@
+// +build ignore
+
+package main
+
+import "time"
+
+func after() {}
+
+func main() {
+	// @calls time.startTimer -> time.sendTime
+	ticker := time.NewTicker(1)
+	<-ticker.C
+
+	// @calls time.startTimer -> time.sendTime
+	timer := time.NewTimer(time.Second)
+	<-timer.C
+
+	// @calls time.startTimer -> time.goFunc
+	// @calls time.goFunc -> main.after
+	timer = time.AfterFunc(time.Second, after)
+	<-timer.C
+}
+
+// @calls time.sendTime -> time.Now
diff --git a/vendor/golang.org/x/tools/go/pointer/util.go b/vendor/golang.org/x/tools/go/pointer/util.go
index d4ccbb5..683fddd 100644
--- a/vendor/golang.org/x/tools/go/pointer/util.go
+++ b/vendor/golang.org/x/tools/go/pointer/util.go
@@ -7,6 +7,7 @@ package pointer
 import (
 	"bytes"
 	"fmt"
+	"go/types"
 	"log"
 	"os"
 	"os/exec"
@@ -14,7 +15,6 @@ import (
 	"time"
 
 	"golang.org/x/tools/container/intsets"
-	"golang.org/x/tools/go/types"
 )
 
 // CanPoint reports whether the type T is pointerlike,
@@ -26,7 +26,6 @@ func CanPoint(T types.Type) bool {
 			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
 	}
@@ -171,7 +170,7 @@ func (a *analysis) flatten(t types.Type) []*fieldInfo {
 			}
 
 		default:
-			panic(t)
+			panic(fmt.Sprintf("cannot flatten unsupported type %T", t))
 		}
 
 		a.flattenMemo[t] = fl
diff --git a/vendor/golang.org/x/tools/go/ssa/builder.go b/vendor/golang.org/x/tools/go/ssa/builder.go
index 5b8ce0e..44abc5b 100644
--- a/vendor/golang.org/x/tools/go/ssa/builder.go
+++ b/vendor/golang.org/x/tools/go/ssa/builder.go
@@ -32,13 +32,11 @@ package ssa
 import (
 	"fmt"
 	"go/ast"
+	exact "go/constant"
 	"go/token"
+	"go/types"
 	"os"
 	"sync"
-	"sync/atomic"
-
-	"golang.org/x/tools/go/exact"
-	"golang.org/x/tools/go/types"
 )
 
 type opaqueType struct {
@@ -60,7 +58,7 @@ var (
 	tString     = types.Typ[types.String]
 	tUntypedNil = types.Typ[types.UntypedNil]
 	tRangeIter  = &opaqueType{nil, "iter"} // the type of all "range" iterators
-	tEface      = new(types.Interface)
+	tEface      = types.NewInterface(nil, nil).Complete()
 
 	// SSA Value constants.
 	vZero = intConst(0)
@@ -156,7 +154,7 @@ func (b *builder) logicalBinop(fn *Function, e *ast.BinaryExpr) Value {
 
 	// All edges from e.X to done carry the short-circuit value.
 	var edges []Value
-	for _ = range done.Preds {
+	for range done.Preds {
 		edges = append(edges, short)
 	}
 
@@ -243,7 +241,7 @@ func (b *builder) builtin(fn *Function, obj *types.Builtin, args []ast.Expr, typ
 			}
 			if m, ok := m.(*Const); ok {
 				// treat make([]T, n, m) as new([m]T)[:n]
-				cap, _ := exact.Int64Val(m.Value)
+				cap := m.Int64()
 				at := types.NewArray(typ.Underlying().(*types.Slice).Elem(), cap)
 				alloc := emitNew(fn, at, pos)
 				alloc.Comment = "makeslice"
@@ -1055,6 +1053,7 @@ func (b *builder) assignStmt(fn *Function, lhss, rhss []ast.Expr, isDef bool) {
 	} 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))
 		}
@@ -1194,9 +1193,26 @@ func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero
 		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, b.expr(fn, e.Key), t.Key()),
+				k:   emitConv(fn, key, t.Key()),
 				t:   t.Elem(),
 				pos: e.Colon,
 			}
@@ -2209,17 +2225,15 @@ func (b *builder) buildFuncDecl(pkg *Package, decl *ast.FuncDecl) {
 	b.buildFunction(fn)
 }
 
-// BuildAll calls Package.Build() for each package in prog.
+// Build calls Package.Build for each package in prog.
 // Building occurs in parallel unless the BuildSerially mode flag was set.
 //
-// BuildAll is intended for whole-program analysis; a typical compiler
+// Build is intended for whole-program analysis; a typical compiler
 // need only build a single package.
 //
-// BuildAll is idempotent and thread-safe.
+// Build is idempotent and thread-safe.
 //
-// TODO(adonovan): rename to Build.
-//
-func (prog *Program) BuildAll() {
+func (prog *Program) Build() {
 	var wg sync.WaitGroup
 	for _, p := range prog.packages {
 		if prog.mode&BuildSerially != 0 {
@@ -2243,17 +2257,12 @@ func (prog *Program) BuildAll() {
 //
 // Build is idempotent and thread-safe.
 //
-func (p *Package) Build() {
-	if !atomic.CompareAndSwapInt32(&p.started, 0, 1) {
-		return // already started
-	}
+func (p *Package) Build() { p.buildOnce.Do(p.build) }
+
+func (p *Package) build() {
 	if p.info == nil {
 		return // synthetic package, e.g. "testmain"
 	}
-	if p.files == nil {
-		p.info = nil
-		return // package loaded from export data
-	}
 
 	// Ensure we have runtime type info for all exported members.
 	// TODO(adonovan): ideally belongs in memberFromObject, but
@@ -2281,10 +2290,10 @@ func (p *Package) Build() {
 		emitStore(init, initguard, vTrue, token.NoPos)
 
 		// Call the init() function of each package we import.
-		for _, pkg := range p.Object.Imports() {
+		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.Object.Path(), pkg.Path()))
+				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
diff --git a/vendor/golang.org/x/tools/go/ssa/builder_test.go b/vendor/golang.org/x/tools/go/ssa/builder_test.go
new file mode 100644
index 0000000..c45f930
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/builder_test.go
@@ -0,0 +1,500 @@
+// 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_test
+
+import (
+	"bytes"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+func isEmpty(f *ssa.Function) bool { return f.Blocks == nil }
+
+// Tests that programs partially loaded from gc object files contain
+// functions with no code for the external portions, but are otherwise ok.
+func TestBuildPackage(t *testing.T) {
+	input := `
+package main
+
+import (
+	"bytes"
+	"io"
+	"testing"
+)
+
+func main() {
+        var t testing.T
+	t.Parallel()    // static call to external declared method
+        t.Fail()        // static call to promoted external declared method
+        testing.Short() // static call to external package-level function
+
+        var w io.Writer = new(bytes.Buffer)
+        w.Write(nil)    // interface invoke of external declared method
+}
+`
+
+	// Parse the file.
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "input.go", input, 0)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	// Build an SSA program from the parsed file.
+	// Load its dependencies from gc binary export data.
+	mainPkg, _, err := ssautil.BuildPackage(&types.Config{Importer: importer.Default()}, fset,
+		types.NewPackage("main", ""), []*ast.File{f}, ssa.SanityCheckFunctions)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	// The main package, its direct and indirect dependencies are loaded.
+	deps := []string{
+		// directly imported dependencies:
+		"bytes", "io", "testing",
+		// indirect dependencies mentioned by
+		// the direct imports' export data
+		"sync", "unicode", "time",
+	}
+
+	prog := mainPkg.Prog
+	all := prog.AllPackages()
+	if len(all) <= len(deps) {
+		t.Errorf("unexpected set of loaded packages: %q", all)
+	}
+	for _, path := range deps {
+		pkg := prog.ImportedPackage(path)
+		if pkg == nil {
+			t.Errorf("package not loaded: %q", path)
+			continue
+		}
+
+		// External packages should have no function bodies (except for wrappers).
+		isExt := pkg != mainPkg
+
+		// init()
+		if isExt && !isEmpty(pkg.Func("init")) {
+			t.Errorf("external package %s has non-empty init", pkg)
+		} else if !isExt && isEmpty(pkg.Func("init")) {
+			t.Errorf("main package %s has empty init", pkg)
+		}
+
+		for _, mem := range pkg.Members {
+			switch mem := mem.(type) {
+			case *ssa.Function:
+				// Functions at package level.
+				if isExt && !isEmpty(mem) {
+					t.Errorf("external function %s is non-empty", mem)
+				} else if !isExt && isEmpty(mem) {
+					t.Errorf("function %s is empty", mem)
+				}
+
+			case *ssa.Type:
+				// Methods of named types T.
+				// (In this test, all exported methods belong to *T not T.)
+				if !isExt {
+					t.Fatalf("unexpected name type in main package: %s", mem)
+				}
+				mset := prog.MethodSets.MethodSet(types.NewPointer(mem.Type()))
+				for i, n := 0, mset.Len(); i < n; i++ {
+					m := prog.MethodValue(mset.At(i))
+					// For external types, only synthetic wrappers have code.
+					expExt := !strings.Contains(m.Synthetic, "wrapper")
+					if expExt && !isEmpty(m) {
+						t.Errorf("external method %s is non-empty: %s",
+							m, m.Synthetic)
+					} else if !expExt && isEmpty(m) {
+						t.Errorf("method function %s is empty: %s",
+							m, m.Synthetic)
+					}
+				}
+			}
+		}
+	}
+
+	expectedCallee := []string{
+		"(*testing.T).Parallel",
+		"(*testing.common).Fail",
+		"testing.Short",
+		"N/A",
+	}
+	callNum := 0
+	for _, b := range mainPkg.Func("main").Blocks {
+		for _, instr := range b.Instrs {
+			switch instr := instr.(type) {
+			case ssa.CallInstruction:
+				call := instr.Common()
+				if want := expectedCallee[callNum]; want != "N/A" {
+					got := call.StaticCallee().String()
+					if want != got {
+						t.Errorf("call #%d from main.main: got callee %s, want %s",
+							callNum, got, want)
+					}
+				}
+				callNum++
+			}
+		}
+	}
+	if callNum != 4 {
+		t.Errorf("in main.main: got %d calls, want %d", callNum, 4)
+	}
+}
+
+// TestRuntimeTypes tests that (*Program).RuntimeTypes() includes all necessary types.
+func TestRuntimeTypes(t *testing.T) {
+	tests := []struct {
+		input string
+		want  []string
+	}{
+		// An exported package-level type is needed.
+		{`package A; type T struct{}; func (T) f() {}`,
+			[]string{"*p.T", "p.T"},
+		},
+		// An unexported package-level type is not needed.
+		{`package B; type t struct{}; func (t) f() {}`,
+			nil,
+		},
+		// Subcomponents of type of exported package-level var are needed.
+		{`package C; import "bytes"; var V struct {*bytes.Buffer}`,
+			[]string{"*bytes.Buffer", "*struct{*bytes.Buffer}", "struct{*bytes.Buffer}"},
+		},
+		// Subcomponents of type of unexported package-level var are not needed.
+		{`package D; import "bytes"; var v struct {*bytes.Buffer}`,
+			nil,
+		},
+		// Subcomponents of type of exported package-level function are needed.
+		{`package E; import "bytes"; func F(struct {*bytes.Buffer}) {}`,
+			[]string{"*bytes.Buffer", "struct{*bytes.Buffer}"},
+		},
+		// Subcomponents of type of unexported package-level function are not needed.
+		{`package F; import "bytes"; func f(struct {*bytes.Buffer}) {}`,
+			nil,
+		},
+		// Subcomponents of type of exported method of uninstantiated unexported type are not needed.
+		{`package G; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v x`,
+			nil,
+		},
+		// ...unless used by MakeInterface.
+		{`package G2; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v interface{} = x{}`,
+			[]string{"*bytes.Buffer", "*p.x", "p.x", "struct{*bytes.Buffer}"},
+		},
+		// Subcomponents of type of unexported method are not needed.
+		{`package I; import "bytes"; type X struct{}; func (X) G(struct {*bytes.Buffer}) {}`,
+			[]string{"*bytes.Buffer", "*p.X", "p.X", "struct{*bytes.Buffer}"},
+		},
+		// Local types aren't needed.
+		{`package J; import "bytes"; func f() { type T struct {*bytes.Buffer}; var t T; _ = t }`,
+			nil,
+		},
+		// ...unless used by MakeInterface.
+		{`package K; import "bytes"; func f() { type T struct {*bytes.Buffer}; _ = interface{}(T{}) }`,
+			[]string{"*bytes.Buffer", "*p.T", "p.T"},
+		},
+		// Types used as operand of MakeInterface are needed.
+		{`package L; import "bytes"; func f() { _ = interface{}(struct{*bytes.Buffer}{}) }`,
+			[]string{"*bytes.Buffer", "struct{*bytes.Buffer}"},
+		},
+		// MakeInterface is optimized away when storing to a blank.
+		{`package M; import "bytes"; var _ interface{} = struct{*bytes.Buffer}{}`,
+			nil,
+		},
+	}
+	for _, test := range tests {
+		// Parse the file.
+		fset := token.NewFileSet()
+		f, err := parser.ParseFile(fset, "input.go", test.input, 0)
+		if err != nil {
+			t.Errorf("test %q: %s", test.input[:15], err)
+			continue
+		}
+
+		// Create a single-file main package.
+		// Load dependencies from gc binary export data.
+		ssapkg, _, err := ssautil.BuildPackage(&types.Config{Importer: importer.Default()}, fset,
+			types.NewPackage("p", ""), []*ast.File{f}, ssa.SanityCheckFunctions)
+		if err != nil {
+			t.Errorf("test %q: %s", test.input[:15], err)
+			continue
+		}
+
+		var typstrs []string
+		for _, T := range ssapkg.Prog.RuntimeTypes() {
+			typstrs = append(typstrs, T.String())
+		}
+		sort.Strings(typstrs)
+
+		if !reflect.DeepEqual(typstrs, test.want) {
+			t.Errorf("test 'package %s': got %q, want %q",
+				f.Name.Name, typstrs, test.want)
+		}
+	}
+}
+
+// TestInit tests that synthesized init functions are correctly formed.
+// Bare init functions omit calls to dependent init functions and the use of
+// an init guard. They are useful in cases where the client uses a different
+// calling convention for init functions, or cases where it is easier for a
+// client to analyze bare init functions. Both of these aspects are used by
+// the llgo compiler for simpler integration with gccgo's runtime library,
+// and to simplify the analysis whereby it deduces which stores to globals
+// can be lowered to global initializers.
+func TestInit(t *testing.T) {
+	tests := []struct {
+		mode        ssa.BuilderMode
+		input, want string
+	}{
+		{0, `package A; import _ "errors"; var i int = 42`,
+			`# Name: A.init
+# Package: A
+# Synthetic: package initializer
+func init():
+0:                                                                entry P:0 S:2
+	t0 = *init$guard                                                   bool
+	if t0 goto 2 else 1
+1:                                                           init.start P:1 S:1
+	*init$guard = true:bool
+	t1 = errors.init()                                                   ()
+	*i = 42:int
+	jump 2
+2:                                                            init.done P:2 S:0
+	return
+
+`},
+		{ssa.BareInits, `package B; import _ "errors"; var i int = 42`,
+			`# Name: B.init
+# Package: B
+# Synthetic: package initializer
+func init():
+0:                                                                entry P:0 S:0
+	*i = 42:int
+	return
+
+`},
+	}
+	for _, test := range tests {
+		// Create a single-file main package.
+		var conf loader.Config
+		f, err := conf.ParseFile("<input>", test.input)
+		if err != nil {
+			t.Errorf("test %q: %s", test.input[:15], err)
+			continue
+		}
+		conf.CreateFromFiles(f.Name.Name, f)
+
+		lprog, err := conf.Load()
+		if err != nil {
+			t.Errorf("test 'package %s': Load: %s", f.Name.Name, err)
+			continue
+		}
+		prog := ssautil.CreateProgram(lprog, test.mode)
+		mainPkg := prog.Package(lprog.Created[0].Pkg)
+		prog.Build()
+		initFunc := mainPkg.Func("init")
+		if initFunc == nil {
+			t.Errorf("test 'package %s': no init function", f.Name.Name)
+			continue
+		}
+
+		var initbuf bytes.Buffer
+		_, err = initFunc.WriteTo(&initbuf)
+		if err != nil {
+			t.Errorf("test 'package %s': WriteTo: %s", f.Name.Name, err)
+			continue
+		}
+
+		if initbuf.String() != test.want {
+			t.Errorf("test 'package %s': got %s, want %s", f.Name.Name, initbuf.String(), test.want)
+		}
+	}
+}
+
+// TestSyntheticFuncs checks that the expected synthetic functions are
+// created, reachable, and not duplicated.
+func TestSyntheticFuncs(t *testing.T) {
+	const input = `package P
+type T int
+func (T) f() int
+func (*T) g() int
+var (
+	// thunks
+	a = T.f
+	b = T.f
+	c = (struct{T}).f
+	d = (struct{T}).f
+	e = (*T).g
+	f = (*T).g
+	g = (struct{*T}).g
+	h = (struct{*T}).g
+
+	// bounds
+	i = T(0).f
+	j = T(0).f
+	k = new(T).g
+	l = new(T).g
+
+	// wrappers
+	m interface{} = struct{T}{}
+	n interface{} = struct{T}{}
+	o interface{} = struct{*T}{}
+	p interface{} = struct{*T}{}
+	q interface{} = new(struct{T})
+	r interface{} = new(struct{T})
+	s interface{} = new(struct{*T})
+	t interface{} = new(struct{*T})
+)
+`
+	// Parse
+	var conf loader.Config
+	f, err := conf.ParseFile("<input>", input)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	conf.CreateFromFiles(f.Name.Name, f)
+
+	// Load
+	lprog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+
+	// Create and build SSA
+	prog := ssautil.CreateProgram(lprog, 0)
+	prog.Build()
+
+	// Enumerate reachable synthetic functions
+	want := map[string]string{
+		"(*P.T).g$bound": "bound method wrapper for func (*P.T).g() int",
+		"(P.T).f$bound":  "bound method wrapper for func (P.T).f() int",
+
+		"(*P.T).g$thunk":         "thunk for func (*P.T).g() int",
+		"(P.T).f$thunk":          "thunk for func (P.T).f() int",
+		"(struct{*P.T}).g$thunk": "thunk for func (*P.T).g() int",
+		"(struct{P.T}).f$thunk":  "thunk for func (P.T).f() int",
+
+		"(*P.T).f":          "wrapper for func (P.T).f() int",
+		"(*struct{*P.T}).f": "wrapper for func (P.T).f() int",
+		"(*struct{*P.T}).g": "wrapper for func (*P.T).g() int",
+		"(*struct{P.T}).f":  "wrapper for func (P.T).f() int",
+		"(*struct{P.T}).g":  "wrapper for func (*P.T).g() int",
+		"(struct{*P.T}).f":  "wrapper for func (P.T).f() int",
+		"(struct{*P.T}).g":  "wrapper for func (*P.T).g() int",
+		"(struct{P.T}).f":   "wrapper for func (P.T).f() int",
+
+		"P.init": "package initializer",
+	}
+	for fn := range ssautil.AllFunctions(prog) {
+		if fn.Synthetic == "" {
+			continue
+		}
+		name := fn.String()
+		wantDescr, ok := want[name]
+		if !ok {
+			t.Errorf("got unexpected/duplicate func: %q: %q", name, fn.Synthetic)
+			continue
+		}
+		delete(want, name)
+
+		if wantDescr != fn.Synthetic {
+			t.Errorf("(%s).Synthetic = %q, want %q", name, fn.Synthetic, wantDescr)
+		}
+	}
+	for fn, descr := range want {
+		t.Errorf("want func: %q: %q", fn, descr)
+	}
+}
+
+// TestPhiElimination ensures that dead phis, including those that
+// participate in a cycle, are properly eliminated.
+func TestPhiElimination(t *testing.T) {
+	const input = `
+package p
+
+func f() error
+
+func g(slice []int) {
+	for {
+		for range slice {
+			// e should not be lifted to a dead φ-node.
+			e := f()
+			h(e)
+		}
+	}
+}
+
+func h(error)
+`
+	// The SSA code for this function should look something like this:
+	// 0:
+	//         jump 1
+	// 1:
+	//         t0 = len(slice)
+	//         jump 2
+	// 2:
+	//         t1 = phi [1: -1:int, 3: t2]
+	//         t2 = t1 + 1:int
+	//         t3 = t2 < t0
+	//         if t3 goto 3 else 1
+	// 3:
+	//         t4 = f()
+	//         t5 = h(t4)
+	//         jump 2
+	//
+	// But earlier versions of the SSA construction algorithm would
+	// additionally generate this cycle of dead phis:
+	//
+	// 1:
+	//         t7 = phi [0: nil:error, 2: t8] #e
+	//         ...
+	// 2:
+	//         t8 = phi [1: t7, 3: t4] #e
+	//         ...
+
+	// Parse
+	var conf loader.Config
+	f, err := conf.ParseFile("<input>", input)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	conf.CreateFromFiles("p", f)
+
+	// Load
+	lprog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+
+	// Create and build SSA
+	prog := ssautil.CreateProgram(lprog, 0)
+	p := prog.Package(lprog.Package("p").Pkg)
+	p.Build()
+	g := p.Func("g")
+
+	phis := 0
+	for _, b := range g.Blocks {
+		for _, instr := range b.Instrs {
+			if _, ok := instr.(*ssa.Phi); ok {
+				phis++
+			}
+		}
+	}
+	if phis != 1 {
+		g.WriteTo(os.Stderr)
+		t.Errorf("expected a single Phi (for the range index), got %d", phis)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/const.go b/vendor/golang.org/x/tools/go/ssa/const.go
index 304096e..2870eea 100644
--- a/vendor/golang.org/x/tools/go/ssa/const.go
+++ b/vendor/golang.org/x/tools/go/ssa/const.go
@@ -8,11 +8,10 @@ package ssa
 
 import (
 	"fmt"
+	exact "go/constant"
 	"go/token"
+	"go/types"
 	"strconv"
-
-	"golang.org/x/tools/go/exact"
-	"golang.org/x/tools/go/types"
 )
 
 // NewConst returns a new constant of the specified value and type.
@@ -116,11 +115,13 @@ 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 := c.Value; x.Kind() {
+	switch x := exact.ToInt(c.Value); x.Kind() {
 	case exact.Int:
 		if i, ok := exact.Int64Val(x); ok {
 			return i
@@ -137,7 +138,7 @@ func (c *Const) Int64() int64 {
 // an unsigned 64-bit integer.
 //
 func (c *Const) Uint64() uint64 {
-	switch x := c.Value; x.Kind() {
+	switch x := exact.ToInt(c.Value); x.Kind() {
 	case exact.Int:
 		if u, ok := exact.Uint64Val(x); ok {
 			return u
diff --git a/vendor/golang.org/x/tools/go/ssa/create.go b/vendor/golang.org/x/tools/go/ssa/create.go
index 88226ae..69ac12b 100644
--- a/vendor/golang.org/x/tools/go/ssa/create.go
+++ b/vendor/golang.org/x/tools/go/ssa/create.go
@@ -11,10 +11,10 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"go/types"
 	"os"
 	"sync"
 
-	"golang.org/x/tools/go/types"
 	"golang.org/x/tools/go/types/typeutil"
 )
 
@@ -49,6 +49,11 @@ func NewProgram(fset *token.FileSet, mode BuilderMode) *Program {
 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,
@@ -162,7 +167,7 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 		Prog:    prog,
 		Members: make(map[string]Member),
 		values:  make(map[types.Object]Value),
-		Object:  pkg,
+		Pkg:     pkg,
 		info:    info,  // transient (CREATE and BUILD phases)
 		files:   files, // transient (CREATE and BUILD phases)
 	}
@@ -187,17 +192,18 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 			}
 		}
 	} else {
-		// GC-compiled binary package.
+		// GC-compiled binary package (or "unsafe")
 		// No code.
 		// No position information.
-		scope := p.Object.Scope()
+		scope := p.Pkg.Scope()
 		for _, name := range scope.Names() {
 			obj := scope.Lookup(name)
 			memberFromObject(p, obj, nil)
 			if obj, ok := obj.(*types.TypeName); ok {
-				named := obj.Type().(*types.Named)
-				for i, n := 0, named.NumMethods(); i < n; i++ {
-					memberFromObject(p, named.Method(i), nil)
+				if named, ok := obj.Type().(*types.Named); ok {
+					for i, n := 0, named.NumMethods(); i < n; i++ {
+						memberFromObject(p, named.Method(i), nil)
+					}
 				}
 			}
 		}
@@ -224,9 +230,9 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 	}
 
 	if importable {
-		prog.imported[p.Object.Path()] = p
+		prog.imported[p.Pkg.Path()] = p
 	}
-	prog.packages[p.Object] = p
+	prog.packages[p.Pkg] = p
 
 	return p
 }
diff --git a/vendor/golang.org/x/tools/go/ssa/emit.go b/vendor/golang.org/x/tools/go/ssa/emit.go
index fa9646b..1036988 100644
--- a/vendor/golang.org/x/tools/go/ssa/emit.go
+++ b/vendor/golang.org/x/tools/go/ssa/emit.go
@@ -10,8 +10,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
-
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
 // emitNew emits to f a new (heap Alloc) instruction allocating an
@@ -148,7 +147,7 @@ func emitCompare(f *Function, op token.Token, x, y Value, pos token.Pos) Value {
 //
 func isValuePreserving(ut_src, ut_dst types.Type) bool {
 	// Identical underlying types?
-	if types.Identical(ut_dst, ut_src) {
+	if structTypesIdentical(ut_dst, ut_src) {
 		return true
 	}
 
diff --git a/vendor/golang.org/x/tools/go/ssa/example_test.go b/vendor/golang.org/x/tools/go/ssa/example_test.go
new file mode 100644
index 0000000..31fa561
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/example_test.go
@@ -0,0 +1,138 @@
+// 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_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+const hello = `
+package main
+
+import "fmt"
+
+const message = "Hello, World!"
+
+func main() {
+	fmt.Println(message)
+}
+`
+
+// This program demonstrates how to run the SSA builder on a single
+// package of one or more already-parsed files.  Its dependencies are
+// loaded from compiler export data.  This is what you'd typically use
+// for a compiler; it does not depend on golang.org/x/tools/go/loader.
+//
+// It shows the printed representation of packages, functions, and
+// instructions.  Within the function listing, the name of each
+// BasicBlock such as ".0.entry" is printed left-aligned, followed by
+// the block's Instructions.
+//
+// For each instruction that defines an SSA virtual register
+// (i.e. implements Value), the type of that value is shown in the
+// right column.
+//
+// Build and run the ssadump.go program if you want a standalone tool
+// with similar functionality. It is located at
+// golang.org/x/tools/cmd/ssadump.
+//
+func ExampleBuildPackage() {
+	// Parse the source files.
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "hello.go", hello, parser.ParseComments)
+	if err != nil {
+		fmt.Print(err) // parse error
+		return
+	}
+	files := []*ast.File{f}
+
+	// Create the type-checker's package.
+	pkg := types.NewPackage("hello", "")
+
+	// Type-check the package, load dependencies.
+	// Create and build the SSA program.
+	hello, _, err := ssautil.BuildPackage(
+		&types.Config{Importer: importer.Default()}, fset, pkg, files, ssa.SanityCheckFunctions)
+	if err != nil {
+		fmt.Print(err) // type error in some package
+		return
+	}
+
+	// Print out the package.
+	hello.WriteTo(os.Stdout)
+
+	// Print out the package-level functions.
+	hello.Func("init").WriteTo(os.Stdout)
+	hello.Func("main").WriteTo(os.Stdout)
+
+	// Output:
+	//
+	// package hello:
+	//   func  init       func()
+	//   var   init$guard bool
+	//   func  main       func()
+	//   const message    message = "Hello, World!":untyped string
+	//
+	// # Name: hello.init
+	// # Package: hello
+	// # Synthetic: package initializer
+	// func init():
+	// 0:                                                                entry P:0 S:2
+	// 	t0 = *init$guard                                                   bool
+	// 	if t0 goto 2 else 1
+	// 1:                                                           init.start P:1 S:1
+	// 	*init$guard = true:bool
+	// 	t1 = fmt.init()                                                      ()
+	// 	jump 2
+	// 2:                                                            init.done P:2 S:0
+	// 	return
+	//
+	// # Name: hello.main
+	// # Package: hello
+	// # Location: hello.go:8:6
+	// func main():
+	// 0:                                                                entry P:0 S:0
+	// 	t0 = new [1]interface{} (varargs)                       *[1]interface{}
+	// 	t1 = &t0[0:int]                                            *interface{}
+	// 	t2 = make interface{} <- string ("Hello, World!":string)    interface{}
+	// 	*t1 = t2
+	// 	t3 = slice t0[:]                                          []interface{}
+	// 	t4 = fmt.Println(t3...)                              (n int, err error)
+	// 	return
+}
+
+// This program shows how to load a main package (cmd/cover) and all its
+// dependencies from source, using the loader, and then build SSA code
+// for the entire program.  This is what you'd typically use for a
+// whole-program analysis.
+//
+func ExampleLoadProgram() {
+	// Load cmd/cover and its dependencies.
+	var conf loader.Config
+	conf.Import("cmd/cover")
+	lprog, err := conf.Load()
+	if err != nil {
+		fmt.Print(err) // type error in some package
+		return
+	}
+
+	// Create SSA-form program representation.
+	prog := ssautil.CreateProgram(lprog, ssa.SanityCheckFunctions)
+
+	// Build SSA code for the entire cmd/cover program.
+	prog.Build()
+
+	// Output:
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/func.go b/vendor/golang.org/x/tools/go/ssa/func.go
index a9c0f75..b21ff4e 100644
--- a/vendor/golang.org/x/tools/go/ssa/func.go
+++ b/vendor/golang.org/x/tools/go/ssa/func.go
@@ -11,11 +11,10 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"go/types"
 	"io"
 	"os"
 	"strings"
-
-	"golang.org/x/tools/go/types"
 )
 
 // addEdge adds a control-flow graph edge from from to to.
@@ -501,7 +500,7 @@ func (f *Function) RelString(from *types.Package) string {
 
 	// Package-level function?
 	// Prefix with package name for cross-package references only.
-	if p := f.pkgobj(); p != nil && p != from {
+	if p := f.pkg(); p != nil && p != from {
 		return fmt.Sprintf("%s.%s", p.Path(), f.name)
 	}
 
@@ -529,9 +528,9 @@ func writeSignature(buf *bytes.Buffer, from *types.Package, name string, sig *ty
 	types.WriteSignature(buf, sig, types.RelativeTo(from))
 }
 
-func (f *Function) pkgobj() *types.Package {
+func (f *Function) pkg() *types.Package {
 	if f.Pkg != nil {
-		return f.Pkg.Object
+		return f.Pkg.Pkg
 	}
 	return nil
 }
@@ -549,7 +548,7 @@ func (f *Function) WriteTo(w io.Writer) (int64, error) {
 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.Object.Path())
+		fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Pkg.Path())
 	}
 	if syn := f.Synthetic; syn != "" {
 		fmt.Fprintln(buf, "# Synthetic:", syn)
@@ -566,7 +565,7 @@ func WriteFunction(buf *bytes.Buffer, f *Function) {
 		fmt.Fprintf(buf, "# Recover: %s\n", f.Recover)
 	}
 
-	from := f.pkgobj()
+	from := f.pkg()
 
 	if f.FreeVars != nil {
 		buf.WriteString("# Free variables:\n")
diff --git a/vendor/golang.org/x/tools/go/ssa/identical.go b/vendor/golang.org/x/tools/go/ssa/identical.go
new file mode 100644
index 0000000..53cbee1
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/ssa/identical_17.go b/vendor/golang.org/x/tools/go/ssa/identical_17.go
new file mode 100644
index 0000000..da89d33
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/go/ssa/identical_test.go b/vendor/golang.org/x/tools/go/ssa/identical_test.go
new file mode 100644
index 0000000..404693d
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/identical_test.go
@@ -0,0 +1,9 @@
+//+build go1.8
+
+package ssa_test
+
+import "testing"
+
+func TestValueForExprStructConv(t *testing.T) {
+	testValueForExpr(t, "testdata/structconv.go")
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/external.go b/vendor/golang.org/x/tools/go/ssa/interp/external.go
new file mode 100644
index 0000000..34442ca
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/external.go
@@ -0,0 +1,557 @@
+// 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 interp
+
+// Emulated functions that we cannot interpret because they are
+// external or because they use "unsafe" or "reflect" operations.
+
+import (
+	"go/types"
+	"math"
+	"os"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"time"
+	"unsafe"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+type externalFn func(fr *frame, args []value) value
+
+// TODO(adonovan): fix: reflect.Value abstracts an lvalue or an
+// rvalue; Set() causes mutations that can be observed via aliases.
+// We have not captured that correctly here.
+
+// Key strings are from Function.String().
+var externals = make(map[string]externalFn)
+
+func init() {
+	// That little dot ۰ is an Arabic zero numeral (U+06F0), categories [Nd].
+	for k, v := range map[string]externalFn{
+		"(*sync.Pool).Get":                 ext۰sync۰Pool۰Get,
+		"(*sync.Pool).Put":                 ext۰nop,
+		"(reflect.Value).Bool":             ext۰reflect۰Value۰Bool,
+		"(reflect.Value).CanAddr":          ext۰reflect۰Value۰CanAddr,
+		"(reflect.Value).CanInterface":     ext۰reflect۰Value۰CanInterface,
+		"(reflect.Value).Elem":             ext۰reflect۰Value۰Elem,
+		"(reflect.Value).Field":            ext۰reflect۰Value۰Field,
+		"(reflect.Value).Float":            ext۰reflect۰Value۰Float,
+		"(reflect.Value).Index":            ext۰reflect۰Value۰Index,
+		"(reflect.Value).Int":              ext۰reflect۰Value۰Int,
+		"(reflect.Value).Interface":        ext۰reflect۰Value۰Interface,
+		"(reflect.Value).IsNil":            ext۰reflect۰Value۰IsNil,
+		"(reflect.Value).IsValid":          ext۰reflect۰Value۰IsValid,
+		"(reflect.Value).Kind":             ext۰reflect۰Value۰Kind,
+		"(reflect.Value).Len":              ext۰reflect۰Value۰Len,
+		"(reflect.Value).MapIndex":         ext۰reflect۰Value۰MapIndex,
+		"(reflect.Value).MapKeys":          ext۰reflect۰Value۰MapKeys,
+		"(reflect.Value).NumField":         ext۰reflect۰Value۰NumField,
+		"(reflect.Value).NumMethod":        ext۰reflect۰Value۰NumMethod,
+		"(reflect.Value).Pointer":          ext۰reflect۰Value۰Pointer,
+		"(reflect.Value).Set":              ext۰reflect۰Value۰Set,
+		"(reflect.Value).String":           ext۰reflect۰Value۰String,
+		"(reflect.Value).Type":             ext۰reflect۰Value۰Type,
+		"(reflect.Value).Uint":             ext۰reflect۰Value۰Uint,
+		"(reflect.error).Error":            ext۰reflect۰error۰Error,
+		"(reflect.rtype).Bits":             ext۰reflect۰rtype۰Bits,
+		"(reflect.rtype).Elem":             ext۰reflect۰rtype۰Elem,
+		"(reflect.rtype).Field":            ext۰reflect۰rtype۰Field,
+		"(reflect.rtype).In":               ext۰reflect۰rtype۰In,
+		"(reflect.rtype).Kind":             ext۰reflect۰rtype۰Kind,
+		"(reflect.rtype).NumField":         ext۰reflect۰rtype۰NumField,
+		"(reflect.rtype).NumIn":            ext۰reflect۰rtype۰NumIn,
+		"(reflect.rtype).NumMethod":        ext۰reflect۰rtype۰NumMethod,
+		"(reflect.rtype).NumOut":           ext۰reflect۰rtype۰NumOut,
+		"(reflect.rtype).Out":              ext۰reflect۰rtype۰Out,
+		"(reflect.rtype).Size":             ext۰reflect۰rtype۰Size,
+		"(reflect.rtype).String":           ext۰reflect۰rtype۰String,
+		"bytes.init":                       ext۰nop, // avoid asm dependency
+		"bytes.Equal":                      ext۰bytes۰Equal,
+		"bytes.IndexByte":                  ext۰bytes۰IndexByte,
+		"hash/crc32.haveSSE42":             ext۰crc32۰haveSSE42,
+		"internal/cpu.cpuid":               ext۰cpu۰cpuid,
+		"math.Abs":                         ext۰math۰Abs,
+		"math.Exp":                         ext۰math۰Exp,
+		"math.Float32bits":                 ext۰math۰Float32bits,
+		"math.Float32frombits":             ext۰math۰Float32frombits,
+		"math.Float64bits":                 ext۰math۰Float64bits,
+		"math.Float64frombits":             ext۰math۰Float64frombits,
+		"math.Ldexp":                       ext۰math۰Ldexp,
+		"math.Log":                         ext۰math۰Log,
+		"math.Min":                         ext۰math۰Min,
+		"math.hasSSE4":                     ext۰math۰hasSSE4,
+		"math.hasVectorFacility":           ext۰math۰hasVectorFacility,
+		"os.runtime_args":                  ext۰os۰runtime_args,
+		"os.runtime_beforeExit":            ext۰nop,
+		"os/signal.init":                   ext۰nop,
+		"reflect.New":                      ext۰reflect۰New,
+		"reflect.SliceOf":                  ext۰reflect۰SliceOf,
+		"reflect.TypeOf":                   ext۰reflect۰TypeOf,
+		"reflect.ValueOf":                  ext۰reflect۰ValueOf,
+		"reflect.Zero":                     ext۰reflect۰Zero,
+		"reflect.init":                     ext۰reflect۰Init,
+		"reflect.valueInterface":           ext۰reflect۰valueInterface,
+		"runtime.Breakpoint":               ext۰runtime۰Breakpoint,
+		"runtime.Caller":                   ext۰runtime۰Caller,
+		"runtime.Callers":                  ext۰runtime۰Callers,
+		"runtime.FuncForPC":                ext۰runtime۰FuncForPC,
+		"runtime.GC":                       ext۰runtime۰GC,
+		"runtime.GOMAXPROCS":               ext۰runtime۰GOMAXPROCS,
+		"runtime.Goexit":                   ext۰runtime۰Goexit,
+		"runtime.Gosched":                  ext۰runtime۰Gosched,
+		"runtime.init":                     ext۰nop,
+		"runtime.KeepAlive":                ext۰nop,
+		"runtime.NumCPU":                   ext۰runtime۰NumCPU,
+		"runtime.NumGoroutine":             ext۰runtime۰NumGoroutine,
+		"runtime.ReadMemStats":             ext۰runtime۰ReadMemStats,
+		"runtime.SetFinalizer":             ext۰nop, // ignore
+		"(*runtime.Func).Entry":            ext۰runtime۰Func۰Entry,
+		"(*runtime.Func).FileLine":         ext۰runtime۰Func۰FileLine,
+		"(*runtime.Func).Name":             ext۰runtime۰Func۰Name,
+		"runtime.environ":                  ext۰runtime۰environ,
+		"runtime.getgoroot":                ext۰runtime۰getgoroot,
+		"strings.init":                     ext۰nop, // avoid asm dependency
+		"strings.Count":                    ext۰strings۰Count,
+		"strings.Index":                    ext۰strings۰Index,
+		"strings.IndexByte":                ext۰strings۰IndexByte,
+		"sync.runtime_Semacquire":          ext۰nop, // unimplementable
+		"sync.runtime_Semrelease":          ext۰nop, // unimplementable
+		"sync.runtime_Syncsemcheck":        ext۰nop, // unimplementable
+		"sync.runtime_notifyListCheck":     ext۰nop,
+		"sync.runtime_registerPoolCleanup": ext۰nop,
+		"sync/atomic.AddInt32":             ext۰atomic۰AddInt32,
+		"sync/atomic.AddUint32":            ext۰atomic۰AddUint32,
+		"sync/atomic.CompareAndSwapInt32":  ext۰atomic۰CompareAndSwapInt32,
+		"sync/atomic.CompareAndSwapUint32": ext۰atomic۰CompareAndSwapUint32,
+		"sync/atomic.LoadInt32":            ext۰atomic۰LoadInt32,
+		"sync/atomic.LoadUint32":           ext۰atomic۰LoadUint32,
+		"sync/atomic.StoreInt32":           ext۰atomic۰StoreInt32,
+		"sync/atomic.StoreUint32":          ext۰atomic۰StoreUint32,
+		"sync/atomic.AddInt64":             ext۰atomic۰AddInt64,
+		"sync/atomic.AddUint64":            ext۰atomic۰AddUint64,
+		"sync/atomic.CompareAndSwapInt64":  ext۰atomic۰CompareAndSwapInt64,
+		"sync/atomic.CompareAndSwapUint64": ext۰atomic۰CompareAndSwapUint64,
+		"sync/atomic.LoadInt64":            ext۰atomic۰LoadInt64,
+		"sync/atomic.LoadUint64":           ext۰atomic۰LoadUint64,
+		"sync/atomic.StoreInt64":           ext۰atomic۰StoreInt64,
+		"sync/atomic.StoreUint64":          ext۰atomic۰StoreUint64,
+		"(*sync/atomic.Value).Load":        ext۰atomic۰ValueLoad,
+		"(*sync/atomic.Value).Store":       ext۰atomic۰ValueStore,
+		"testing.MainStart":                ext۰testing۰MainStart,
+		"time.Sleep":                       ext۰time۰Sleep,
+		"time.now":                         ext۰time۰now,
+	} {
+		externals[k] = v
+	}
+}
+
+// wrapError returns an interpreted 'error' interface value for err.
+func wrapError(err error) value {
+	if err == nil {
+		return iface{}
+	}
+	return iface{t: errorType, v: err.Error()}
+}
+
+func ext۰nop(fr *frame, args []value) value { return nil }
+
+func ext۰sync۰Pool۰Get(fr *frame, args []value) value {
+	Pool := fr.i.prog.ImportedPackage("sync").Type("Pool").Object()
+	_, newIndex, _ := types.LookupFieldOrMethod(Pool.Type(), false, Pool.Pkg(), "New")
+
+	if New := (*args[0].(*value)).(structure)[newIndex[0]]; New != nil {
+		return call(fr.i, fr, 0, New, nil)
+	}
+	return nil
+}
+
+func ext۰bytes۰Equal(fr *frame, args []value) value {
+	// func Equal(a, b []byte) bool
+	a := args[0].([]value)
+	b := args[1].([]value)
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func ext۰bytes۰IndexByte(fr *frame, args []value) value {
+	// func IndexByte(s []byte, c byte) int
+	s := args[0].([]value)
+	c := args[1].(byte)
+	for i, b := range s {
+		if b.(byte) == c {
+			return i
+		}
+	}
+	return -1
+}
+
+func ext۰crc32۰haveSSE42(fr *frame, args []value) value {
+	return false
+}
+
+func ext۰math۰Float64frombits(fr *frame, args []value) value {
+	return math.Float64frombits(args[0].(uint64))
+}
+
+func ext۰math۰Float64bits(fr *frame, args []value) value {
+	return math.Float64bits(args[0].(float64))
+}
+
+func ext۰math۰Float32frombits(fr *frame, args []value) value {
+	return math.Float32frombits(args[0].(uint32))
+}
+
+func ext۰math۰Abs(fr *frame, args []value) value {
+	return math.Abs(args[0].(float64))
+}
+
+func ext۰math۰Exp(fr *frame, args []value) value {
+	return math.Exp(args[0].(float64))
+}
+
+func ext۰math۰Float32bits(fr *frame, args []value) value {
+	return math.Float32bits(args[0].(float32))
+}
+
+func ext۰math۰Min(fr *frame, args []value) value {
+	return math.Min(args[0].(float64), args[1].(float64))
+}
+
+func ext۰math۰hasSSE4(fr *frame, args []value) value {
+	return false
+}
+
+func ext۰math۰hasVectorFacility(fr *frame, args []value) value {
+	return false
+}
+
+func ext۰math۰Ldexp(fr *frame, args []value) value {
+	return math.Ldexp(args[0].(float64), args[1].(int))
+}
+
+func ext۰math۰Log(fr *frame, args []value) value {
+	return math.Log(args[0].(float64))
+}
+
+func ext۰os۰runtime_args(fr *frame, args []value) value {
+	return fr.i.osArgs
+}
+
+func ext۰runtime۰Breakpoint(fr *frame, args []value) value {
+	runtime.Breakpoint()
+	return nil
+}
+
+func ext۰runtime۰Caller(fr *frame, args []value) value {
+	// func Caller(skip int) (pc uintptr, file string, line int, ok bool)
+	skip := 1 + args[0].(int)
+	for i := 0; i < skip; i++ {
+		if fr != nil {
+			fr = fr.caller
+		}
+	}
+	var pc uintptr
+	var file string
+	var line int
+	var ok bool
+	if fr != nil {
+		fn := fr.fn
+		// TODO(adonovan): use pc/posn of current instruction, not start of fn.
+		// (Required to interpret the log package's tests.)
+		pc = uintptr(unsafe.Pointer(fn))
+		posn := fn.Prog.Fset.Position(fn.Pos())
+		file = posn.Filename
+		line = posn.Line
+		ok = true
+	}
+	return tuple{pc, file, line, ok}
+}
+
+func ext۰runtime۰Callers(fr *frame, args []value) value {
+	// Callers(skip int, pc []uintptr) int
+	skip := args[0].(int)
+	pc := args[1].([]value)
+	for i := 0; i < skip; i++ {
+		if fr != nil {
+			fr = fr.caller
+		}
+	}
+	i := 0
+	for fr != nil && i < len(pc) {
+		pc[i] = uintptr(unsafe.Pointer(fr.fn))
+		i++
+		fr = fr.caller
+	}
+	return i
+}
+
+func ext۰runtime۰FuncForPC(fr *frame, args []value) value {
+	// FuncForPC(pc uintptr) *Func
+	pc := args[0].(uintptr)
+	var fn *ssa.Function
+	if pc != 0 {
+		fn = (*ssa.Function)(unsafe.Pointer(pc)) // indeed unsafe!
+	}
+	var Func value
+	Func = structure{fn} // a runtime.Func
+	return &Func
+}
+
+func ext۰runtime۰environ(fr *frame, args []value) value {
+	// This function also implements syscall.runtime_envs.
+	return environ
+}
+
+func ext۰runtime۰getgoroot(fr *frame, args []value) value {
+	return os.Getenv("GOROOT")
+}
+
+func ext۰strings۰Count(fr *frame, args []value) value {
+	// Call compiled version to avoid asm dependency.
+	return strings.Count(args[0].(string), args[1].(string))
+}
+
+func ext۰strings۰IndexByte(fr *frame, args []value) value {
+	// Call compiled version to avoid asm dependency.
+	return strings.IndexByte(args[0].(string), args[1].(byte))
+}
+
+func ext۰strings۰Index(fr *frame, args []value) value {
+	// Call compiled version to avoid asm dependency.
+	return strings.Index(args[0].(string), args[1].(string))
+}
+
+func ext۰runtime۰GOMAXPROCS(fr *frame, args []value) value {
+	// Ignore args[0]; don't let the interpreted program
+	// set the interpreter's GOMAXPROCS!
+	return runtime.GOMAXPROCS(0)
+}
+
+func ext۰runtime۰Goexit(fr *frame, args []value) value {
+	// TODO(adonovan): don't kill the interpreter's main goroutine.
+	runtime.Goexit()
+	return nil
+}
+
+func ext۰runtime۰GC(fr *frame, args []value) value {
+	runtime.GC()
+	return nil
+}
+
+func ext۰runtime۰Gosched(fr *frame, args []value) value {
+	runtime.Gosched()
+	return nil
+}
+
+func ext۰runtime۰NumCPU(fr *frame, args []value) value {
+	return runtime.NumCPU()
+}
+
+func ext۰runtime۰NumGoroutine(fr *frame, args []value) value {
+	return int(atomic.LoadInt32(&fr.i.goroutines))
+}
+
+func ext۰runtime۰ReadMemStats(fr *frame, args []value) value {
+	// TODO(adonovan): populate args[0].(Struct)
+	return nil
+}
+
+func ext۰atomic۰LoadUint32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	return (*args[0].(*value)).(uint32)
+}
+
+func ext۰atomic۰StoreUint32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	*args[0].(*value) = args[1].(uint32)
+	return nil
+}
+
+func ext۰atomic۰LoadInt32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	return (*args[0].(*value)).(int32)
+}
+
+func ext۰atomic۰StoreInt32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	*args[0].(*value) = args[1].(int32)
+	return nil
+}
+
+func ext۰atomic۰CompareAndSwapInt32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	if (*p).(int32) == args[1].(int32) {
+		*p = args[2].(int32)
+		return true
+	}
+	return false
+}
+
+func ext۰atomic۰CompareAndSwapUint32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	if (*p).(uint32) == args[1].(uint32) {
+		*p = args[2].(uint32)
+		return true
+	}
+	return false
+}
+
+func ext۰atomic۰AddInt32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	newv := (*p).(int32) + args[1].(int32)
+	*p = newv
+	return newv
+}
+
+func ext۰atomic۰AddUint32(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	newv := (*p).(uint32) + args[1].(uint32)
+	*p = newv
+	return newv
+}
+
+func ext۰atomic۰LoadUint64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	return (*args[0].(*value)).(uint64)
+}
+
+func ext۰atomic۰StoreUint64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	*args[0].(*value) = args[1].(uint64)
+	return nil
+}
+
+func ext۰atomic۰LoadInt64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	return (*args[0].(*value)).(int64)
+}
+
+func ext۰atomic۰StoreInt64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	*args[0].(*value) = args[1].(int64)
+	return nil
+}
+
+func ext۰atomic۰CompareAndSwapInt64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	if (*p).(int64) == args[1].(int64) {
+		*p = args[2].(int64)
+		return true
+	}
+	return false
+}
+
+func ext۰atomic۰CompareAndSwapUint64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	if (*p).(uint64) == args[1].(uint64) {
+		*p = args[2].(uint64)
+		return true
+	}
+	return false
+}
+
+func ext۰atomic۰AddInt64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	newv := (*p).(int64) + args[1].(int64)
+	*p = newv
+	return newv
+}
+
+func ext۰atomic۰AddUint64(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	p := args[0].(*value)
+	newv := (*p).(uint64) + args[1].(uint64)
+	*p = newv
+	return newv
+}
+
+func ext۰atomic۰ValueLoad(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	// Receiver is *struct{v interface{}}.
+	return (*args[0].(*value)).(structure)[0]
+}
+
+func ext۰atomic۰ValueStore(fr *frame, args []value) value {
+	// TODO(adonovan): fix: not atomic!
+	// Receiver is *struct{v interface{}}.
+	(*args[0].(*value)).(structure)[0] = args[1]
+	return nil
+}
+
+func ext۰cpu۰cpuid(fr *frame, args []value) value {
+	return tuple{uint32(0), uint32(0), uint32(0), uint32(0)}
+}
+
+// Pretend: type runtime.Func struct { entry *ssa.Function }
+
+func ext۰runtime۰Func۰FileLine(fr *frame, args []value) value {
+	// func (*runtime.Func) FileLine(uintptr) (string, int)
+	f, _ := (*args[0].(*value)).(structure)[0].(*ssa.Function)
+	pc := args[1].(uintptr)
+	_ = pc
+	if f != nil {
+		// TODO(adonovan): use position of current instruction, not fn.
+		posn := f.Prog.Fset.Position(f.Pos())
+		return tuple{posn.Filename, posn.Line}
+	}
+	return tuple{"", 0}
+}
+
+func ext۰runtime۰Func۰Name(fr *frame, args []value) value {
+	// func (*runtime.Func) Name() string
+	f, _ := (*args[0].(*value)).(structure)[0].(*ssa.Function)
+	if f != nil {
+		return f.String()
+	}
+	return ""
+}
+
+func ext۰runtime۰Func۰Entry(fr *frame, args []value) value {
+	// func (*runtime.Func) Entry() uintptr
+	f, _ := (*args[0].(*value)).(structure)[0].(*ssa.Function)
+	return uintptr(unsafe.Pointer(f))
+}
+
+func ext۰time۰now(fr *frame, args []value) value {
+	nano := time.Now().UnixNano()
+	return tuple{int64(nano / 1e9), int32(nano % 1e9), int64(0)}
+}
+
+func ext۰time۰Sleep(fr *frame, args []value) value {
+	time.Sleep(time.Duration(args[0].(int64)))
+	return nil
+}
+
+func valueToBytes(v value) []byte {
+	in := v.([]value)
+	b := make([]byte, len(in))
+	for i := range in {
+		b[i] = in[i].(byte)
+	}
+	return b
+}
+
+func ext۰testing۰MainStart(fr *frame, args []value) value {
+	// We no longer support interpretation of the "testing" package
+	// because it changes too often and uses low-level features that
+	// are a pain to emulate.
+	panic(`interpretation of the "testing" package is no longer supported`)
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/external_darwin.go b/vendor/golang.org/x/tools/go/ssa/interp/external_darwin.go
new file mode 100644
index 0000000..4713009
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/external_darwin.go
@@ -0,0 +1,35 @@
+// 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.
+
+// +build darwin
+
+package interp
+
+import "syscall"
+
+func init() {
+	externals["syscall.Sysctl"] = ext۰syscall۰Sysctl
+
+	fillStat = func(st *syscall.Stat_t, stat structure) {
+		stat[0] = st.Dev
+		stat[1] = st.Mode
+		stat[2] = st.Nlink
+		stat[3] = st.Ino
+		stat[4] = st.Uid
+		stat[5] = st.Gid
+		stat[6] = st.Rdev
+		// TODO(adonovan): fix: copy Timespecs.
+		// stat[8] = st.Atim
+		// stat[9] = st.Mtim
+		// stat[10] = st.Ctim
+		stat[12] = st.Size
+		stat[13] = st.Blocks
+		stat[14] = st.Blksize
+	}
+}
+
+func ext۰syscall۰Sysctl(fr *frame, args []value) value {
+	r, err := syscall.Sysctl(args[0].(string))
+	return tuple{r, wrapError(err)}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/external_unix.go b/vendor/golang.org/x/tools/go/ssa/interp/external_unix.go
new file mode 100644
index 0000000..bfa39f6
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/external_unix.go
@@ -0,0 +1,256 @@
+// 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.
+
+// +build darwin linux
+
+package interp
+
+import "syscall"
+
+func init() {
+	for k, v := range map[string]externalFn{
+		"os.Pipe":              ext۰os۰Pipe,
+		"syscall.Close":        ext۰syscall۰Close,
+		"syscall.Exit":         ext۰syscall۰Exit,
+		"syscall.Fchown":       ext۰syscall۰Fchown,
+		"syscall.Fstat":        ext۰syscall۰Fstat,
+		"syscall.Ftruncate":    ext۰syscall۰Ftruncate,
+		"syscall.Getpid":       ext۰syscall۰Getpid,
+		"syscall.Getwd":        ext۰syscall۰Getwd,
+		"syscall.Kill":         ext۰syscall۰Kill,
+		"syscall.Link":         ext۰syscall۰Link,
+		"syscall.Lstat":        ext۰syscall۰Lstat,
+		"syscall.Mkdir":        ext۰syscall۰Mkdir,
+		"syscall.Open":         ext۰syscall۰Open,
+		"syscall.ParseDirent":  ext۰syscall۰ParseDirent,
+		"syscall.RawSyscall":   ext۰syscall۰RawSyscall,
+		"syscall.Read":         ext۰syscall۰Read,
+		"syscall.ReadDirent":   ext۰syscall۰ReadDirent,
+		"syscall.Readlink":     ext۰syscall۰Readlink,
+		"syscall.Rmdir":        ext۰syscall۰Rmdir,
+		"syscall.Seek":         ext۰syscall۰Seek,
+		"syscall.Stat":         ext۰syscall۰Stat,
+		"syscall.Symlink":      ext۰syscall۰Symlink,
+		"syscall.Write":        ext۰syscall۰Write,
+		"syscall.Unlink":       ext۰syscall۰Unlink,
+		"syscall۰UtimesNano":   ext۰syscall۰UtimesNano,
+		"syscall.setenv_c":     ext۰nop,
+		"syscall.unsetenv_c":   ext۰nop,
+		"syscall.runtime_envs": ext۰runtime۰environ,
+	} {
+		externals[k] = v
+	}
+
+	syswrite = syscall.Write
+}
+
+func ext۰os۰Pipe(fr *frame, args []value) value {
+	// func os.Pipe() (r *File, w *File, err error)
+
+	// The portable POSIX pipe(2) call is good enough for our needs.
+	var p [2]int
+	if err := syscall.Pipe(p[:]); err != nil {
+		// TODO(adonovan): fix: return an *os.SyscallError.
+		return tuple{nil, nil, wrapError(err)}
+	}
+
+	NewFile := fr.i.prog.ImportedPackage("os").Func("NewFile")
+	r := call(fr.i, fr, 0, NewFile, []value{uintptr(p[0]), "|0"})
+	w := call(fr.i, fr, 0, NewFile, []value{uintptr(p[1]), "|1"})
+	return tuple{r, w, wrapError(nil)}
+}
+
+// overridden on darwin
+var fillStat = func(st *syscall.Stat_t, stat structure) {
+	stat[0] = st.Dev
+	stat[1] = st.Ino
+	stat[2] = st.Nlink
+	stat[3] = st.Mode
+	stat[4] = st.Uid
+	stat[5] = st.Gid
+	stat[7] = st.Rdev
+	stat[8] = st.Size
+	stat[9] = st.Blksize
+	stat[10] = st.Blocks
+	// TODO(adonovan): fix: copy Timespecs.
+	// stat[11] = st.Atim
+	// stat[12] = st.Mtim
+	// stat[13] = st.Ctim
+}
+
+func ext۰syscall۰Close(fr *frame, args []value) value {
+	// func Close(fd int) (err error)
+	return wrapError(syscall.Close(args[0].(int)))
+}
+
+func ext۰syscall۰Exit(fr *frame, args []value) value {
+	panic(exitPanic(args[0].(int)))
+}
+
+func ext۰syscall۰Fchown(fr *frame, args []value) value {
+	fd := args[0].(int)
+	uid := args[1].(int)
+	gid := args[2].(int)
+	return wrapError(syscall.Fchown(fd, uid, gid))
+}
+
+func ext۰syscall۰Fstat(fr *frame, args []value) value {
+	// func Fstat(fd int, stat *Stat_t) (err error)
+	fd := args[0].(int)
+	stat := (*args[1].(*value)).(structure)
+
+	var st syscall.Stat_t
+	err := syscall.Fstat(fd, &st)
+	fillStat(&st, stat)
+	return wrapError(err)
+}
+
+func ext۰syscall۰Ftruncate(fr *frame, args []value) value {
+	fd := args[0].(int)
+	length := args[1].(int64)
+	return wrapError(syscall.Ftruncate(fd, length))
+}
+
+func ext۰syscall۰Getpid(fr *frame, args []value) value {
+	return syscall.Getpid()
+}
+
+func ext۰syscall۰Getwd(fr *frame, args []value) value {
+	s, err := syscall.Getwd()
+	return tuple{s, wrapError(err)}
+}
+
+func ext۰syscall۰Kill(fr *frame, args []value) value {
+	// func Kill(pid int, sig Signal) (err error)
+	return wrapError(syscall.Kill(args[0].(int), syscall.Signal(args[1].(int))))
+}
+
+func ext۰syscall۰Link(fr *frame, args []value) value {
+	path := args[0].(string)
+	link := args[1].(string)
+	return wrapError(syscall.Link(path, link))
+}
+
+func ext۰syscall۰Lstat(fr *frame, args []value) value {
+	// func Lstat(name string, stat *Stat_t) (err error)
+	name := args[0].(string)
+	stat := (*args[1].(*value)).(structure)
+
+	var st syscall.Stat_t
+	err := syscall.Lstat(name, &st)
+	fillStat(&st, stat)
+	return wrapError(err)
+}
+
+func ext۰syscall۰Mkdir(fr *frame, args []value) value {
+	path := args[0].(string)
+	mode := args[1].(uint32)
+	return wrapError(syscall.Mkdir(path, mode))
+}
+
+func ext۰syscall۰Open(fr *frame, args []value) value {
+	// func Open(path string, mode int, perm uint32) (fd int, err error) {
+	path := args[0].(string)
+	mode := args[1].(int)
+	perm := args[2].(uint32)
+	fd, err := syscall.Open(path, mode, perm)
+	return tuple{fd, wrapError(err)}
+}
+
+func ext۰syscall۰ParseDirent(fr *frame, args []value) value {
+	// func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string)
+	max := args[1].(int)
+	var names []string
+	for _, iname := range args[2].([]value) {
+		names = append(names, iname.(string))
+	}
+	consumed, count, newnames := syscall.ParseDirent(valueToBytes(args[0]), max, names)
+	var inewnames []value
+	for _, newname := range newnames {
+		inewnames = append(inewnames, newname)
+	}
+	return tuple{consumed, count, inewnames}
+}
+
+func ext۰syscall۰RawSyscall(fr *frame, args []value) value {
+	return tuple{uintptr(0), uintptr(0), uintptr(syscall.ENOSYS)}
+}
+
+func ext۰syscall۰Read(fr *frame, args []value) value {
+	// func Read(fd int, p []byte) (n int, err error)
+	fd := args[0].(int)
+	p := args[1].([]value)
+	b := make([]byte, len(p))
+	n, err := syscall.Read(fd, b)
+	for i := 0; i < n; i++ {
+		p[i] = b[i]
+	}
+	return tuple{n, wrapError(err)}
+}
+
+func ext۰syscall۰ReadDirent(fr *frame, args []value) value {
+	// func ReadDirent(fd int, buf []byte) (n int, err error)
+	fd := args[0].(int)
+	p := args[1].([]value)
+	b := make([]byte, len(p))
+	n, err := syscall.ReadDirent(fd, b)
+	for i := 0; i < n; i++ {
+		p[i] = b[i]
+	}
+	return tuple{n, wrapError(err)}
+}
+
+func ext۰syscall۰Readlink(fr *frame, args []value) value {
+	path := args[0].(string)
+	buf := valueToBytes(args[1])
+	n, err := syscall.Readlink(path, buf)
+	return tuple{n, wrapError(err)}
+}
+
+func ext۰syscall۰Rmdir(fr *frame, args []value) value {
+	return wrapError(syscall.Rmdir(args[0].(string)))
+}
+
+func ext۰syscall۰Seek(fr *frame, args []value) value {
+	fd := args[0].(int)
+	offset := args[1].(int64)
+	whence := args[2].(int)
+	new, err := syscall.Seek(fd, offset, whence)
+	return tuple{new, wrapError(err)}
+}
+
+func ext۰syscall۰Stat(fr *frame, args []value) value {
+	// func Stat(name string, stat *Stat_t) (err error)
+	name := args[0].(string)
+	stat := (*args[1].(*value)).(structure)
+
+	var st syscall.Stat_t
+	err := syscall.Stat(name, &st)
+	fillStat(&st, stat)
+	return wrapError(err)
+}
+
+func ext۰syscall۰Symlink(fr *frame, args []value) value {
+	path := args[0].(string)
+	link := args[1].(string)
+	return wrapError(syscall.Symlink(path, link))
+}
+
+func ext۰syscall۰Unlink(fr *frame, args []value) value {
+	return wrapError(syscall.Unlink(args[0].(string)))
+}
+
+func ext۰syscall۰UtimesNano(fr *frame, args []value) value {
+	path := args[0].(string)
+	var ts [2]syscall.Timespec
+	err := syscall.UtimesNano(path, ts[:])
+	// TODO(adonovan): copy the Timespecs into args[1]
+	return wrapError(err)
+}
+
+func ext۰syscall۰Write(fr *frame, args []value) value {
+	// func Write(fd int, p []byte) (n int, err error)
+	n, err := write(args[0].(int), valueToBytes(args[1]))
+	return tuple{n, wrapError(err)}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/interp.go b/vendor/golang.org/x/tools/go/ssa/interp/interp.go
new file mode 100644
index 0000000..c092960
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/interp.go
@@ -0,0 +1,764 @@
+// 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/interp defines an interpreter for the SSA
+// representation of Go programs.
+//
+// This interpreter is provided as an adjunct for testing the SSA
+// construction algorithm.  Its purpose is to provide a minimal
+// metacircular implementation of the dynamic semantics of each SSA
+// instruction.  It is not, and will never be, a production-quality Go
+// interpreter.
+//
+// The following is a partial list of Go features that are currently
+// unsupported or incomplete in the interpreter.
+//
+// * Unsafe operations, including all uses of unsafe.Pointer, are
+// impossible to support given the "boxed" value representation we
+// have chosen.
+//
+// * The reflect package is only partially implemented.
+//
+// * The "testing" package is no longer supported because it
+// depends on low-level details that change too often.
+//
+// * "sync/atomic" operations are not atomic due to the "boxed" value
+// representation: it is not possible to read, modify and write an
+// interface value atomically. As a consequence, Mutexes are currently
+// broken.
+//
+// * recover is only partially implemented.  Also, the interpreter
+// makes no attempt to distinguish target panics from interpreter
+// crashes.
+//
+// * map iteration is asymptotically inefficient.
+//
+// * the sizes of the int, uint and uintptr types in the target
+// program are assumed to be the same as those of the interpreter
+// itself.
+//
+// * all values occupy space, even those of types defined by the spec
+// to have zero size, e.g. struct{}.  This can cause asymptotic
+// performance degradation.
+//
+// * os.Exit is implemented using panic, causing deferred functions to
+// run.
+package interp // import "golang.org/x/tools/go/ssa/interp"
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"os"
+	"reflect"
+	"runtime"
+	"sync/atomic"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+type continuation int
+
+const (
+	kNext continuation = iota
+	kReturn
+	kJump
+)
+
+// Mode is a bitmask of options affecting the interpreter.
+type Mode uint
+
+const (
+	DisableRecover Mode = 1 << iota // Disable recover() in target programs; show interpreter crash instead.
+	EnableTracing                   // Print a trace of all instructions as they are interpreted.
+)
+
+type methodSet map[string]*ssa.Function
+
+// State shared between all interpreted goroutines.
+type interpreter struct {
+	osArgs             []value              // the value of os.Args
+	prog               *ssa.Program         // the SSA program
+	globals            map[ssa.Value]*value // addresses of global variables (immutable)
+	mode               Mode                 // interpreter options
+	reflectPackage     *ssa.Package         // the fake reflect package
+	errorMethods       methodSet            // the method set of reflect.error, which implements the error interface.
+	rtypeMethods       methodSet            // the method set of rtype, which implements the reflect.Type interface.
+	runtimeErrorString types.Type           // the runtime.errorString type
+	sizes              types.Sizes          // the effective type-sizing function
+	goroutines         int32                // atomically updated
+}
+
+type deferred struct {
+	fn    value
+	args  []value
+	instr *ssa.Defer
+	tail  *deferred
+}
+
+type frame struct {
+	i                *interpreter
+	caller           *frame
+	fn               *ssa.Function
+	block, prevBlock *ssa.BasicBlock
+	env              map[ssa.Value]value // dynamic values of SSA variables
+	locals           []value
+	defers           *deferred
+	result           value
+	panicking        bool
+	panic            interface{}
+}
+
+func (fr *frame) get(key ssa.Value) value {
+	switch key := key.(type) {
+	case nil:
+		// Hack; simplifies handling of optional attributes
+		// such as ssa.Slice.{Low,High}.
+		return nil
+	case *ssa.Function, *ssa.Builtin:
+		return key
+	case *ssa.Const:
+		return constValue(key)
+	case *ssa.Global:
+		if r, ok := fr.i.globals[key]; ok {
+			return r
+		}
+	}
+	if r, ok := fr.env[key]; ok {
+		return r
+	}
+	panic(fmt.Sprintf("get: no value for %T: %v", key, key.Name()))
+}
+
+// runDefer runs a deferred call d.
+// It always returns normally, but may set or clear fr.panic.
+//
+func (fr *frame) runDefer(d *deferred) {
+	if fr.i.mode&EnableTracing != 0 {
+		fmt.Fprintf(os.Stderr, "%s: invoking deferred function call\n",
+			fr.i.prog.Fset.Position(d.instr.Pos()))
+	}
+	var ok bool
+	defer func() {
+		if !ok {
+			// Deferred call created a new state of panic.
+			fr.panicking = true
+			fr.panic = recover()
+		}
+	}()
+	call(fr.i, fr, d.instr.Pos(), d.fn, d.args)
+	ok = true
+}
+
+// runDefers executes fr's deferred function calls in LIFO order.
+//
+// On entry, fr.panicking indicates a state of panic; if
+// true, fr.panic contains the panic value.
+//
+// On completion, if a deferred call started a panic, or if no
+// deferred call recovered from a previous state of panic, then
+// runDefers itself panics after the last deferred call has run.
+//
+// If there was no initial state of panic, or it was recovered from,
+// runDefers returns normally.
+//
+func (fr *frame) runDefers() {
+	for d := fr.defers; d != nil; d = d.tail {
+		fr.runDefer(d)
+	}
+	fr.defers = nil
+	if fr.panicking {
+		panic(fr.panic) // new panic, or still panicking
+	}
+}
+
+// lookupMethod returns the method set for type typ, which may be one
+// of the interpreter's fake types.
+func lookupMethod(i *interpreter, typ types.Type, meth *types.Func) *ssa.Function {
+	switch typ {
+	case rtypeType:
+		return i.rtypeMethods[meth.Id()]
+	case errorType:
+		return i.errorMethods[meth.Id()]
+	}
+	return i.prog.LookupMethod(typ, meth.Pkg(), meth.Name())
+}
+
+// visitInstr interprets a single ssa.Instruction within the activation
+// record frame.  It returns a continuation value indicating where to
+// read the next instruction from.
+func visitInstr(fr *frame, instr ssa.Instruction) continuation {
+	switch instr := instr.(type) {
+	case *ssa.DebugRef:
+		// no-op
+
+	case *ssa.UnOp:
+		fr.env[instr] = unop(instr, fr.get(instr.X))
+
+	case *ssa.BinOp:
+		fr.env[instr] = binop(instr.Op, instr.X.Type(), fr.get(instr.X), fr.get(instr.Y))
+
+	case *ssa.Call:
+		fn, args := prepareCall(fr, &instr.Call)
+		fr.env[instr] = call(fr.i, fr, instr.Pos(), fn, args)
+
+	case *ssa.ChangeInterface:
+		fr.env[instr] = fr.get(instr.X)
+
+	case *ssa.ChangeType:
+		fr.env[instr] = fr.get(instr.X) // (can't fail)
+
+	case *ssa.Convert:
+		fr.env[instr] = conv(instr.Type(), instr.X.Type(), fr.get(instr.X))
+
+	case *ssa.MakeInterface:
+		fr.env[instr] = iface{t: instr.X.Type(), v: fr.get(instr.X)}
+
+	case *ssa.Extract:
+		fr.env[instr] = fr.get(instr.Tuple).(tuple)[instr.Index]
+
+	case *ssa.Slice:
+		fr.env[instr] = slice(fr.get(instr.X), fr.get(instr.Low), fr.get(instr.High), fr.get(instr.Max))
+
+	case *ssa.Return:
+		switch len(instr.Results) {
+		case 0:
+		case 1:
+			fr.result = fr.get(instr.Results[0])
+		default:
+			var res []value
+			for _, r := range instr.Results {
+				res = append(res, fr.get(r))
+			}
+			fr.result = tuple(res)
+		}
+		fr.block = nil
+		return kReturn
+
+	case *ssa.RunDefers:
+		fr.runDefers()
+
+	case *ssa.Panic:
+		panic(targetPanic{fr.get(instr.X)})
+
+	case *ssa.Send:
+		fr.get(instr.Chan).(chan value) <- fr.get(instr.X)
+
+	case *ssa.Store:
+		store(deref(instr.Addr.Type()), fr.get(instr.Addr).(*value), fr.get(instr.Val))
+
+	case *ssa.If:
+		succ := 1
+		if fr.get(instr.Cond).(bool) {
+			succ = 0
+		}
+		fr.prevBlock, fr.block = fr.block, fr.block.Succs[succ]
+		return kJump
+
+	case *ssa.Jump:
+		fr.prevBlock, fr.block = fr.block, fr.block.Succs[0]
+		return kJump
+
+	case *ssa.Defer:
+		fn, args := prepareCall(fr, &instr.Call)
+		fr.defers = &deferred{
+			fn:    fn,
+			args:  args,
+			instr: instr,
+			tail:  fr.defers,
+		}
+
+	case *ssa.Go:
+		fn, args := prepareCall(fr, &instr.Call)
+		atomic.AddInt32(&fr.i.goroutines, 1)
+		go func() {
+			call(fr.i, nil, instr.Pos(), fn, args)
+			atomic.AddInt32(&fr.i.goroutines, -1)
+		}()
+
+	case *ssa.MakeChan:
+		fr.env[instr] = make(chan value, asInt(fr.get(instr.Size)))
+
+	case *ssa.Alloc:
+		var addr *value
+		if instr.Heap {
+			// new
+			addr = new(value)
+			fr.env[instr] = addr
+		} else {
+			// local
+			addr = fr.env[instr].(*value)
+		}
+		*addr = zero(deref(instr.Type()))
+
+	case *ssa.MakeSlice:
+		slice := make([]value, asInt(fr.get(instr.Cap)))
+		tElt := instr.Type().Underlying().(*types.Slice).Elem()
+		for i := range slice {
+			slice[i] = zero(tElt)
+		}
+		fr.env[instr] = slice[:asInt(fr.get(instr.Len))]
+
+	case *ssa.MakeMap:
+		reserve := 0
+		if instr.Reserve != nil {
+			reserve = asInt(fr.get(instr.Reserve))
+		}
+		fr.env[instr] = makeMap(instr.Type().Underlying().(*types.Map).Key(), reserve)
+
+	case *ssa.Range:
+		fr.env[instr] = rangeIter(fr.get(instr.X), instr.X.Type())
+
+	case *ssa.Next:
+		fr.env[instr] = fr.get(instr.Iter).(iter).next()
+
+	case *ssa.FieldAddr:
+		fr.env[instr] = &(*fr.get(instr.X).(*value)).(structure)[instr.Field]
+
+	case *ssa.Field:
+		fr.env[instr] = fr.get(instr.X).(structure)[instr.Field]
+
+	case *ssa.IndexAddr:
+		x := fr.get(instr.X)
+		idx := fr.get(instr.Index)
+		switch x := x.(type) {
+		case []value:
+			fr.env[instr] = &x[asInt(idx)]
+		case *value: // *array
+			fr.env[instr] = &(*x).(array)[asInt(idx)]
+		default:
+			panic(fmt.Sprintf("unexpected x type in IndexAddr: %T", x))
+		}
+
+	case *ssa.Index:
+		fr.env[instr] = fr.get(instr.X).(array)[asInt(fr.get(instr.Index))]
+
+	case *ssa.Lookup:
+		fr.env[instr] = lookup(instr, fr.get(instr.X), fr.get(instr.Index))
+
+	case *ssa.MapUpdate:
+		m := fr.get(instr.Map)
+		key := fr.get(instr.Key)
+		v := fr.get(instr.Value)
+		switch m := m.(type) {
+		case map[value]value:
+			m[key] = v
+		case *hashmap:
+			m.insert(key.(hashable), v)
+		default:
+			panic(fmt.Sprintf("illegal map type: %T", m))
+		}
+
+	case *ssa.TypeAssert:
+		fr.env[instr] = typeAssert(fr.i, instr, fr.get(instr.X).(iface))
+
+	case *ssa.MakeClosure:
+		var bindings []value
+		for _, binding := range instr.Bindings {
+			bindings = append(bindings, fr.get(binding))
+		}
+		fr.env[instr] = &closure{instr.Fn.(*ssa.Function), bindings}
+
+	case *ssa.Phi:
+		for i, pred := range instr.Block().Preds {
+			if fr.prevBlock == pred {
+				fr.env[instr] = fr.get(instr.Edges[i])
+				break
+			}
+		}
+
+	case *ssa.Select:
+		var cases []reflect.SelectCase
+		if !instr.Blocking {
+			cases = append(cases, reflect.SelectCase{
+				Dir: reflect.SelectDefault,
+			})
+		}
+		for _, state := range instr.States {
+			var dir reflect.SelectDir
+			if state.Dir == types.RecvOnly {
+				dir = reflect.SelectRecv
+			} else {
+				dir = reflect.SelectSend
+			}
+			var send reflect.Value
+			if state.Send != nil {
+				send = reflect.ValueOf(fr.get(state.Send))
+			}
+			cases = append(cases, reflect.SelectCase{
+				Dir:  dir,
+				Chan: reflect.ValueOf(fr.get(state.Chan)),
+				Send: send,
+			})
+		}
+		chosen, recv, recvOk := reflect.Select(cases)
+		if !instr.Blocking {
+			chosen-- // default case should have index -1.
+		}
+		r := tuple{chosen, recvOk}
+		for i, st := range instr.States {
+			if st.Dir == types.RecvOnly {
+				var v value
+				if i == chosen && recvOk {
+					// No need to copy since send makes an unaliased copy.
+					v = recv.Interface().(value)
+				} else {
+					v = zero(st.Chan.Type().Underlying().(*types.Chan).Elem())
+				}
+				r = append(r, v)
+			}
+		}
+		fr.env[instr] = r
+
+	default:
+		panic(fmt.Sprintf("unexpected instruction: %T", instr))
+	}
+
+	// if val, ok := instr.(ssa.Value); ok {
+	// 	fmt.Println(toString(fr.env[val])) // debugging
+	// }
+
+	return kNext
+}
+
+// prepareCall determines the function value and argument values for a
+// function call in a Call, Go or Defer instruction, performing
+// interface method lookup if needed.
+//
+func prepareCall(fr *frame, call *ssa.CallCommon) (fn value, args []value) {
+	v := fr.get(call.Value)
+	if call.Method == nil {
+		// Function call.
+		fn = v
+	} else {
+		// Interface method invocation.
+		recv := v.(iface)
+		if recv.t == nil {
+			panic("method invoked on nil interface")
+		}
+		if f := lookupMethod(fr.i, recv.t, call.Method); f == nil {
+			// Unreachable in well-typed programs.
+			panic(fmt.Sprintf("method set for dynamic type %v does not contain %s", recv.t, call.Method))
+		} else {
+			fn = f
+		}
+		args = append(args, recv.v)
+	}
+	for _, arg := range call.Args {
+		args = append(args, fr.get(arg))
+	}
+	return
+}
+
+// call interprets a call to a function (function, builtin or closure)
+// fn with arguments args, returning its result.
+// callpos is the position of the callsite.
+//
+func call(i *interpreter, caller *frame, callpos token.Pos, fn value, args []value) value {
+	switch fn := fn.(type) {
+	case *ssa.Function:
+		if fn == nil {
+			panic("call of nil function") // nil of func type
+		}
+		return callSSA(i, caller, callpos, fn, args, nil)
+	case *closure:
+		return callSSA(i, caller, callpos, fn.Fn, args, fn.Env)
+	case *ssa.Builtin:
+		return callBuiltin(caller, callpos, fn, args)
+	}
+	panic(fmt.Sprintf("cannot call %T", fn))
+}
+
+func loc(fset *token.FileSet, pos token.Pos) string {
+	if pos == token.NoPos {
+		return ""
+	}
+	return " at " + fset.Position(pos).String()
+}
+
+// callSSA interprets a call to function fn with arguments args,
+// and lexical environment env, returning its result.
+// callpos is the position of the callsite.
+//
+func callSSA(i *interpreter, caller *frame, callpos token.Pos, fn *ssa.Function, args []value, env []value) value {
+	if i.mode&EnableTracing != 0 {
+		fset := fn.Prog.Fset
+		// TODO(adonovan): fix: loc() lies for external functions.
+		fmt.Fprintf(os.Stderr, "Entering %s%s.\n", fn, loc(fset, fn.Pos()))
+		suffix := ""
+		if caller != nil {
+			suffix = ", resuming " + caller.fn.String() + loc(fset, callpos)
+		}
+		defer fmt.Fprintf(os.Stderr, "Leaving %s%s.\n", fn, suffix)
+	}
+	fr := &frame{
+		i:      i,
+		caller: caller, // for panic/recover
+		fn:     fn,
+	}
+	if fn.Parent() == nil {
+		name := fn.String()
+		if ext := externals[name]; ext != nil {
+			if i.mode&EnableTracing != 0 {
+				fmt.Fprintln(os.Stderr, "\t(external)")
+			}
+			return ext(fr, args)
+		}
+		if fn.Blocks == nil {
+			panic("no code for function: " + name)
+		}
+	}
+	fr.env = make(map[ssa.Value]value)
+	fr.block = fn.Blocks[0]
+	fr.locals = make([]value, len(fn.Locals))
+	for i, l := range fn.Locals {
+		fr.locals[i] = zero(deref(l.Type()))
+		fr.env[l] = &fr.locals[i]
+	}
+	for i, p := range fn.Params {
+		fr.env[p] = args[i]
+	}
+	for i, fv := range fn.FreeVars {
+		fr.env[fv] = env[i]
+	}
+	for fr.block != nil {
+		runFrame(fr)
+	}
+	// Destroy the locals to avoid accidental use after return.
+	for i := range fn.Locals {
+		fr.locals[i] = bad{}
+	}
+	return fr.result
+}
+
+// runFrame executes SSA instructions starting at fr.block and
+// continuing until a return, a panic, or a recovered panic.
+//
+// After a panic, runFrame panics.
+//
+// After a normal return, fr.result contains the result of the call
+// and fr.block is nil.
+//
+// A recovered panic in a function without named return parameters
+// (NRPs) becomes a normal return of the zero value of the function's
+// result type.
+//
+// After a recovered panic in a function with NRPs, fr.result is
+// undefined and fr.block contains the block at which to resume
+// control.
+//
+func runFrame(fr *frame) {
+	defer func() {
+		if fr.block == nil {
+			return // normal return
+		}
+		if fr.i.mode&DisableRecover != 0 {
+			return // let interpreter crash
+		}
+		fr.panicking = true
+		fr.panic = recover()
+		if fr.i.mode&EnableTracing != 0 {
+			fmt.Fprintf(os.Stderr, "Panicking: %T %v.\n", fr.panic, fr.panic)
+		}
+		fr.runDefers()
+		fr.block = fr.fn.Recover
+	}()
+
+	for {
+		if fr.i.mode&EnableTracing != 0 {
+			fmt.Fprintf(os.Stderr, ".%s:\n", fr.block)
+		}
+	block:
+		for _, instr := range fr.block.Instrs {
+			if fr.i.mode&EnableTracing != 0 {
+				if v, ok := instr.(ssa.Value); ok {
+					fmt.Fprintln(os.Stderr, "\t", v.Name(), "=", instr)
+				} else {
+					fmt.Fprintln(os.Stderr, "\t", instr)
+				}
+			}
+			switch visitInstr(fr, instr) {
+			case kReturn:
+				return
+			case kNext:
+				// no-op
+			case kJump:
+				break block
+			}
+		}
+	}
+}
+
+// doRecover implements the recover() built-in.
+func doRecover(caller *frame) value {
+	// recover() must be exactly one level beneath the deferred
+	// function (two levels beneath the panicking function) to
+	// have any effect.  Thus we ignore both "defer recover()" and
+	// "defer f() -> g() -> recover()".
+	if caller.i.mode&DisableRecover == 0 &&
+		caller != nil && !caller.panicking &&
+		caller.caller != nil && caller.caller.panicking {
+		caller.caller.panicking = false
+		p := caller.caller.panic
+		caller.caller.panic = nil
+
+		// TODO(adonovan): support runtime.Goexit.
+		switch p := p.(type) {
+		case targetPanic:
+			// The target program explicitly called panic().
+			return p.v
+		case runtime.Error:
+			// The interpreter encountered a runtime error.
+			return iface{caller.i.runtimeErrorString, p.Error()}
+		case string:
+			// The interpreter explicitly called panic().
+			return iface{caller.i.runtimeErrorString, p}
+		default:
+			panic(fmt.Sprintf("unexpected panic type %T in target call to recover()", p))
+		}
+	}
+	return iface{}
+}
+
+// setGlobal sets the value of a system-initialized global variable.
+func setGlobal(i *interpreter, pkg *ssa.Package, name string, v value) {
+	if g, ok := i.globals[pkg.Var(name)]; ok {
+		*g = v
+		return
+	}
+	panic("no global variable: " + pkg.Pkg.Path() + "." + name)
+}
+
+var environ []value
+
+func init() {
+	for _, s := range os.Environ() {
+		environ = append(environ, s)
+	}
+	environ = append(environ, "GOSSAINTERP=1")
+	environ = append(environ, "GOARCH="+runtime.GOARCH)
+}
+
+// deleteBodies delete the bodies of all standalone functions except the
+// specified ones.  A missing intrinsic leads to a clear runtime error.
+func deleteBodies(pkg *ssa.Package, except ...string) {
+	keep := make(map[string]bool)
+	for _, e := range except {
+		keep[e] = true
+	}
+	for _, mem := range pkg.Members {
+		if fn, ok := mem.(*ssa.Function); ok && !keep[fn.Name()] {
+			fn.Blocks = nil
+		}
+	}
+}
+
+// Interpret interprets the Go program whose main package is mainpkg.
+// mode specifies various interpreter options.  filename and args are
+// the initial values of os.Args for the target program.  sizes is the
+// effective type-sizing function for this program.
+//
+// Interpret returns the exit code of the program: 2 for panic (like
+// gc does), or the argument to os.Exit for normal termination.
+//
+// The SSA program must include the "runtime" package.
+//
+func Interpret(mainpkg *ssa.Package, mode Mode, sizes types.Sizes, filename string, args []string) (exitCode int) {
+	if syswrite == nil {
+		fmt.Fprintln(os.Stderr, "Interpret: unsupported platform.")
+		return 1
+	}
+
+	i := &interpreter{
+		prog:       mainpkg.Prog,
+		globals:    make(map[ssa.Value]*value),
+		mode:       mode,
+		sizes:      sizes,
+		goroutines: 1,
+	}
+	runtimePkg := i.prog.ImportedPackage("runtime")
+	if runtimePkg == nil {
+		panic("ssa.Program doesn't include runtime package")
+	}
+	i.runtimeErrorString = runtimePkg.Type("errorString").Object().Type()
+
+	initReflect(i)
+
+	i.osArgs = append(i.osArgs, filename)
+	for _, arg := range args {
+		i.osArgs = append(i.osArgs, arg)
+	}
+
+	for _, pkg := range i.prog.AllPackages() {
+		// Initialize global storage.
+		for _, m := range pkg.Members {
+			switch v := m.(type) {
+			case *ssa.Global:
+				cell := zero(deref(v.Type()))
+				i.globals[v] = &cell
+			}
+		}
+
+		// Ad-hoc initialization for magic system variables.
+		switch pkg.Pkg.Path() {
+		case "syscall":
+			setGlobal(i, pkg, "envs", environ)
+
+		case "reflect":
+			deleteBodies(pkg, "DeepEqual", "deepValueEqual")
+
+		case "runtime":
+			sz := sizes.Sizeof(pkg.Pkg.Scope().Lookup("MemStats").Type())
+			setGlobal(i, pkg, "sizeof_C_MStats", uintptr(sz))
+			deleteBodies(pkg, "GOROOT", "gogetenv")
+		}
+	}
+
+	// Top-level error handler.
+	exitCode = 2
+	defer func() {
+		if exitCode != 2 || i.mode&DisableRecover != 0 {
+			return
+		}
+		switch p := recover().(type) {
+		case exitPanic:
+			exitCode = int(p)
+			return
+		case targetPanic:
+			fmt.Fprintln(os.Stderr, "panic:", toString(p.v))
+		case runtime.Error:
+			fmt.Fprintln(os.Stderr, "panic:", p.Error())
+		case string:
+			fmt.Fprintln(os.Stderr, "panic:", p)
+		default:
+			fmt.Fprintf(os.Stderr, "panic: unexpected type: %T: %v\n", p, p)
+		}
+
+		// TODO(adonovan): dump panicking interpreter goroutine?
+		// buf := make([]byte, 0x10000)
+		// runtime.Stack(buf, false)
+		// fmt.Fprintln(os.Stderr, string(buf))
+		// (Or dump panicking target goroutine?)
+	}()
+
+	// Run!
+	call(i, nil, token.NoPos, mainpkg.Func("init"), nil)
+	if mainFn := mainpkg.Func("main"); mainFn != nil {
+		call(i, nil, token.NoPos, mainFn, nil)
+		exitCode = 0
+	} else {
+		fmt.Fprintln(os.Stderr, "No main function.")
+		exitCode = 1
+	}
+	return
+}
+
+// deref returns a pointer's element type; otherwise it returns typ.
+// TODO(adonovan): Import from ssa?
+func deref(typ types.Type) types.Type {
+	if p, ok := typ.Underlying().(*types.Pointer); ok {
+		return p.Elem()
+	}
+	return typ
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/interp_test.go b/vendor/golang.org/x/tools/go/ssa/interp/interp_test.go
new file mode 100644
index 0000000..997922f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/interp_test.go
@@ -0,0 +1,317 @@
+// 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.
+
+// +build linux darwin
+
+package interp_test
+
+import (
+	"bytes"
+	"fmt"
+	"go/build"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/interp"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// Each line contains a space-separated list of $GOROOT/test/
+// filenames comprising the main package of a program.
+// They are ordered quickest-first, roughly.
+//
+// TODO(adonovan): integrate into the $GOROOT/test driver scripts,
+// golden file checking, etc.
+var gorootTestTests = []string{
+	"235.go",
+	"alias1.go",
+	"chancap.go",
+	"func5.go",
+	"func6.go",
+	"func7.go",
+	"func8.go",
+	"helloworld.go",
+	"varinit.go",
+	"escape3.go",
+	"initcomma.go",
+	"cmp.go",
+	"compos.go",
+	"turing.go",
+	"indirect.go",
+	"complit.go",
+	"for.go",
+	"struct0.go",
+	"intcvt.go",
+	"printbig.go",
+	"deferprint.go",
+	"escape.go",
+	"range.go",
+	"const4.go",
+	"float_lit.go",
+	"bigalg.go",
+	"decl.go",
+	"if.go",
+	"named.go",
+	"bigmap.go",
+	"func.go",
+	"reorder2.go",
+	"closure.go",
+	"gc.go",
+	"simassign.go",
+	"iota.go",
+	"nilptr2.go",
+	"goprint.go", // doesn't actually assert anything (cmpout)
+	"utf.go",
+	"method.go",
+	"char_lit.go",
+	"env.go",
+	"int_lit.go",
+	"string_lit.go",
+	"defer.go",
+	"typeswitch.go",
+	"stringrange.go",
+	"reorder.go",
+	"method3.go",
+	"literal.go",
+	"nul1.go", // doesn't actually assert anything (errorcheckoutput)
+	"zerodivide.go",
+	"convert.go",
+	"convT2X.go",
+	"switch.go",
+	"initialize.go",
+	"ddd.go",
+	"blank.go", // partly disabled
+	"map.go",
+	"closedchan.go",
+	"divide.go",
+	"rename.go",
+	"const3.go",
+	"nil.go",
+	"recover.go", // reflection parts disabled
+	"recover1.go",
+	"recover2.go",
+	"recover3.go",
+	"typeswitch1.go",
+	"floatcmp.go",
+	"crlf.go", // doesn't actually assert anything (runoutput)
+	// Slow tests follow.
+	"bom.go", // ~1.7s
+	"gc1.go", // ~1.7s
+	"cmplxdivide.go cmplxdivide1.go", // ~2.4s
+
+	// Working, but not worth enabling:
+	// "append.go",    // works, but slow (15s).
+	// "gc2.go",       // works, but slow, and cheats on the memory check.
+	// "sigchld.go",   // works, but only on POSIX.
+	// "peano.go",     // works only up to n=9, and slow even then.
+	// "stack.go",     // works, but too slow (~30s) by default.
+	// "solitaire.go", // works, but too slow (~30s).
+	// "const.go",     // works but for but one bug: constant folder doesn't consider representations.
+	// "init1.go",     // too slow (80s) and not that interesting. Cheats on ReadMemStats check too.
+	// "rotate.go rotate0.go", // emits source for a test
+	// "rotate.go rotate1.go", // emits source for a test
+	// "rotate.go rotate2.go", // emits source for a test
+	// "rotate.go rotate3.go", // emits source for a test
+	// "64bit.go",             // emits source for a test
+	// "run.go",               // test driver, not a test.
+
+	// Broken.  TODO(adonovan): fix.
+	// copy.go         // very slow; but with N=4 quickly crashes, slice index out of range.
+	// nilptr.go       // interp: V > uintptr not implemented. Slow test, lots of mem
+	// args.go         // works, but requires specific os.Args from the driver.
+	// index.go        // a template, not a real test.
+	// mallocfin.go    // SetFinalizer not implemented.
+
+	// TODO(adonovan): add tests from $GOROOT/test/* subtrees:
+	// bench chan bugs fixedbugs interface ken.
+}
+
+// These are files in go.tools/go/ssa/interp/testdata/.
+var testdataTests = []string{
+	"boundmeth.go",
+	"complit.go",
+	"coverage.go",
+	"defer.go",
+	"fieldprom.go",
+	"ifaceconv.go",
+	"ifaceprom.go",
+	"initorder.go",
+	"methprom.go",
+	"mrvchain.go",
+	"range.go",
+	"recover.go",
+	"reflect.go",
+	"static.go",
+	"callstack.go",
+}
+
+type successPredicate func(exitcode int, output string) error
+
+func run(t *testing.T, dir, input string, success successPredicate) bool {
+	if runtime.GOOS == "darwin" {
+		t.Skip("skipping on darwin until golang.org/issue/23166 is fixed")
+	}
+	fmt.Printf("Input: %s\n", input)
+
+	start := time.Now()
+
+	var inputs []string
+	for _, i := range strings.Split(input, " ") {
+		if strings.HasSuffix(i, ".go") {
+			i = dir + i
+		}
+		inputs = append(inputs, i)
+	}
+
+	var conf loader.Config
+	if _, err := conf.FromArgs(inputs, true); err != nil {
+		t.Errorf("FromArgs(%s) failed: %s", inputs, err)
+		return false
+	}
+
+	conf.Import("runtime")
+
+	// Print a helpful hint if we don't make it to the end.
+	var hint string
+	defer func() {
+		if hint != "" {
+			fmt.Println("FAIL")
+			fmt.Println(hint)
+		} else {
+			fmt.Println("PASS")
+		}
+
+		interp.CapturedOutput = nil
+	}()
+
+	hint = fmt.Sprintf("To dump SSA representation, run:\n%% go build golang.org/x/tools/cmd/ssadump && ./ssadump -test -build=CFP %s\n", input)
+
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Errorf("conf.Load(%s) failed: %s", inputs, err)
+		return false
+	}
+
+	prog := ssautil.CreateProgram(iprog, ssa.SanityCheckFunctions)
+	prog.Build()
+
+	// Find first main or test package among the initial packages.
+	var mainPkg *ssa.Package
+	for _, info := range iprog.InitialPackages() {
+		if info.Pkg.Path() == "runtime" {
+			continue // not an initial package
+		}
+		p := prog.Package(info.Pkg)
+		if p.Pkg.Name() == "main" && p.Func("main") != nil {
+			mainPkg = p
+			break
+		}
+
+		mainPkg = prog.CreateTestMainPackage(p)
+		if mainPkg != nil {
+			break
+		}
+	}
+	if mainPkg == nil {
+		t.Fatalf("no main or test packages among initial packages: %s", inputs)
+	}
+
+	var out bytes.Buffer
+	interp.CapturedOutput = &out
+
+	hint = fmt.Sprintf("To trace execution, run:\n%% go build golang.org/x/tools/cmd/ssadump && ./ssadump -build=C -test -run --interp=T %s\n", input)
+	exitCode := interp.Interpret(mainPkg, 0, &types.StdSizes{WordSize: 8, MaxAlign: 8}, inputs[0], []string{})
+
+	// The definition of success varies with each file.
+	if err := success(exitCode, out.String()); err != nil {
+		t.Errorf("interp.Interpret(%s) failed: %s", inputs, err)
+		return false
+	}
+
+	hint = "" // call off the hounds
+
+	if false {
+		fmt.Println(input, time.Since(start)) // test profiling
+	}
+
+	return true
+}
+
+const slash = string(os.PathSeparator)
+
+func printFailures(failures []string) {
+	if failures != nil {
+		fmt.Println("The following tests failed:")
+		for _, f := range failures {
+			fmt.Printf("\t%s\n", f)
+		}
+	}
+}
+
+func success(exitcode int, output string) error {
+	if exitcode != 0 {
+		return fmt.Errorf("exit code was %d", exitcode)
+	}
+	if strings.Contains(output, "BUG") {
+		return fmt.Errorf("exited zero but output contained 'BUG'")
+	}
+	return nil
+}
+
+// TestTestdataFiles runs the interpreter on testdata/*.go.
+func TestTestdataFiles(t *testing.T) {
+	var failures []string
+	start := time.Now()
+	for _, input := range testdataTests {
+		if testing.Short() && time.Since(start) > 30*time.Second {
+			printFailures(failures)
+			t.Skipf("timeout - aborting test")
+		}
+		if !run(t, "testdata"+slash, input, success) {
+			failures = append(failures, input)
+		}
+	}
+	printFailures(failures)
+}
+
+// TestGorootTest runs the interpreter on $GOROOT/test/*.go.
+func TestGorootTest(t *testing.T) {
+	if testing.Short() {
+		t.Skip() // too slow (~30s)
+	}
+
+	var failures []string
+
+	for _, input := range gorootTestTests {
+		if !run(t, filepath.Join(build.Default.GOROOT, "test")+slash, input, success) {
+			failures = append(failures, input)
+		}
+	}
+	printFailures(failures)
+}
+
+// CreateTestMainPackage should return nil if there were no tests.
+func TestNullTestmainPackage(t *testing.T) {
+	var conf loader.Config
+	conf.CreateFromFilenames("", "testdata/b_test.go")
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("CreatePackages failed: %s", err)
+	}
+	prog := ssautil.CreateProgram(iprog, ssa.SanityCheckFunctions)
+	mainPkg := prog.Package(iprog.Created[0].Pkg)
+	if mainPkg.Func("main") != nil {
+		t.Fatalf("unexpected main function")
+	}
+	if prog.CreateTestMainPackage(mainPkg) != nil {
+		t.Fatalf("CreateTestMainPackage returned non-nil")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/map.go b/vendor/golang.org/x/tools/go/ssa/interp/map.go
new file mode 100644
index 0000000..92ccf90
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/map.go
@@ -0,0 +1,121 @@
+// 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 interp
+
+// Custom hashtable atop map.
+// For use when the key's equivalence relation is not consistent with ==.
+
+// The Go specification doesn't address the atomicity of map operations.
+// The FAQ states that an implementation is permitted to crash on
+// concurrent map access.
+
+import (
+	"go/types"
+)
+
+type hashable interface {
+	hash(t types.Type) int
+	eq(t types.Type, x interface{}) bool
+}
+
+type entry struct {
+	key   hashable
+	value value
+	next  *entry
+}
+
+// A hashtable atop the built-in map.  Since each bucket contains
+// exactly one hash value, there's no need to perform hash-equality
+// tests when walking the linked list.  Rehashing is done by the
+// underlying map.
+type hashmap struct {
+	keyType types.Type
+	table   map[int]*entry
+	length  int // number of entries in map
+}
+
+// makeMap returns an empty initialized map of key type kt,
+// preallocating space for reserve elements.
+func makeMap(kt types.Type, reserve int) value {
+	if usesBuiltinMap(kt) {
+		return make(map[value]value, reserve)
+	}
+	return &hashmap{keyType: kt, table: make(map[int]*entry, reserve)}
+}
+
+// delete removes the association for key k, if any.
+func (m *hashmap) delete(k hashable) {
+	if m != nil {
+		hash := k.hash(m.keyType)
+		head := m.table[hash]
+		if head != nil {
+			if k.eq(m.keyType, head.key) {
+				m.table[hash] = head.next
+				m.length--
+				return
+			}
+			prev := head
+			for e := head.next; e != nil; e = e.next {
+				if k.eq(m.keyType, e.key) {
+					prev.next = e.next
+					m.length--
+					return
+				}
+				prev = e
+			}
+		}
+	}
+}
+
+// lookup returns the value associated with key k, if present, or
+// value(nil) otherwise.
+func (m *hashmap) lookup(k hashable) value {
+	if m != nil {
+		hash := k.hash(m.keyType)
+		for e := m.table[hash]; e != nil; e = e.next {
+			if k.eq(m.keyType, e.key) {
+				return e.value
+			}
+		}
+	}
+	return nil
+}
+
+// insert updates the map to associate key k with value v.  If there
+// was already an association for an eq() (though not necessarily ==)
+// k, the previous key remains in the map and its associated value is
+// updated.
+func (m *hashmap) insert(k hashable, v value) {
+	hash := k.hash(m.keyType)
+	head := m.table[hash]
+	for e := head; e != nil; e = e.next {
+		if k.eq(m.keyType, e.key) {
+			e.value = v
+			return
+		}
+	}
+	m.table[hash] = &entry{
+		key:   k,
+		value: v,
+		next:  head,
+	}
+	m.length++
+}
+
+// len returns the number of key/value associations in the map.
+func (m *hashmap) len() int {
+	if m != nil {
+		return m.length
+	}
+	return 0
+}
+
+// entries returns a rangeable map of entries.
+func (m *hashmap) entries() map[int]*entry {
+	if m != nil {
+		return m.table
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/ops.go b/vendor/golang.org/x/tools/go/ssa/interp/ops.go
new file mode 100644
index 0000000..f3419ec
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/ops.go
@@ -0,0 +1,1396 @@
+// 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 interp
+
+import (
+	"bytes"
+	"fmt"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"strings"
+	"sync"
+	"unsafe"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+// If the target program panics, the interpreter panics with this type.
+type targetPanic struct {
+	v value
+}
+
+func (p targetPanic) String() string {
+	return toString(p.v)
+}
+
+// If the target program calls exit, the interpreter panics with this type.
+type exitPanic int
+
+// constValue returns the value of the constant with the
+// dynamic type tag appropriate for c.Type().
+func constValue(c *ssa.Const) value {
+	if c.IsNil() {
+		return zero(c.Type()) // typed nil
+	}
+
+	if t, ok := c.Type().Underlying().(*types.Basic); ok {
+		// TODO(adonovan): eliminate untyped constants from SSA form.
+		switch t.Kind() {
+		case types.Bool, types.UntypedBool:
+			return exact.BoolVal(c.Value)
+		case types.Int, types.UntypedInt:
+			// Assume sizeof(int) is same on host and target.
+			return int(c.Int64())
+		case types.Int8:
+			return int8(c.Int64())
+		case types.Int16:
+			return int16(c.Int64())
+		case types.Int32, types.UntypedRune:
+			return int32(c.Int64())
+		case types.Int64:
+			return c.Int64()
+		case types.Uint:
+			// Assume sizeof(uint) is same on host and target.
+			return uint(c.Uint64())
+		case types.Uint8:
+			return uint8(c.Uint64())
+		case types.Uint16:
+			return uint16(c.Uint64())
+		case types.Uint32:
+			return uint32(c.Uint64())
+		case types.Uint64:
+			return c.Uint64()
+		case types.Uintptr:
+			// Assume sizeof(uintptr) is same on host and target.
+			return uintptr(c.Uint64())
+		case types.Float32:
+			return float32(c.Float64())
+		case types.Float64, types.UntypedFloat:
+			return c.Float64()
+		case types.Complex64:
+			return complex64(c.Complex128())
+		case types.Complex128, types.UntypedComplex:
+			return c.Complex128()
+		case types.String, types.UntypedString:
+			if c.Value.Kind() == exact.String {
+				return exact.StringVal(c.Value)
+			}
+			return string(rune(c.Int64()))
+		}
+	}
+
+	panic(fmt.Sprintf("constValue: %s", c))
+}
+
+// asInt converts x, which must be an integer, to an int suitable for
+// use as a slice or array index or operand to make().
+func asInt(x value) int {
+	switch x := x.(type) {
+	case int:
+		return x
+	case int8:
+		return int(x)
+	case int16:
+		return int(x)
+	case int32:
+		return int(x)
+	case int64:
+		return int(x)
+	case uint:
+		return int(x)
+	case uint8:
+		return int(x)
+	case uint16:
+		return int(x)
+	case uint32:
+		return int(x)
+	case uint64:
+		return int(x)
+	case uintptr:
+		return int(x)
+	}
+	panic(fmt.Sprintf("cannot convert %T to int", x))
+}
+
+// asUint64 converts x, which must be an unsigned integer, to a uint64
+// suitable for use as a bitwise shift count.
+func asUint64(x value) uint64 {
+	switch x := x.(type) {
+	case uint:
+		return uint64(x)
+	case uint8:
+		return uint64(x)
+	case uint16:
+		return uint64(x)
+	case uint32:
+		return uint64(x)
+	case uint64:
+		return x
+	case uintptr:
+		return uint64(x)
+	}
+	panic(fmt.Sprintf("cannot convert %T to uint64", x))
+}
+
+// zero returns a new "zero" value of the specified type.
+func zero(t types.Type) value {
+	switch t := t.(type) {
+	case *types.Basic:
+		if t.Kind() == types.UntypedNil {
+			panic("untyped nil has no zero value")
+		}
+		if t.Info()&types.IsUntyped != 0 {
+			// TODO(adonovan): make it an invariant that
+			// this is unreachable.  Currently some
+			// constants have 'untyped' types when they
+			// should be defaulted by the typechecker.
+			t = ssa.DefaultType(t).(*types.Basic)
+		}
+		switch t.Kind() {
+		case types.Bool:
+			return false
+		case types.Int:
+			return int(0)
+		case types.Int8:
+			return int8(0)
+		case types.Int16:
+			return int16(0)
+		case types.Int32:
+			return int32(0)
+		case types.Int64:
+			return int64(0)
+		case types.Uint:
+			return uint(0)
+		case types.Uint8:
+			return uint8(0)
+		case types.Uint16:
+			return uint16(0)
+		case types.Uint32:
+			return uint32(0)
+		case types.Uint64:
+			return uint64(0)
+		case types.Uintptr:
+			return uintptr(0)
+		case types.Float32:
+			return float32(0)
+		case types.Float64:
+			return float64(0)
+		case types.Complex64:
+			return complex64(0)
+		case types.Complex128:
+			return complex128(0)
+		case types.String:
+			return ""
+		case types.UnsafePointer:
+			return unsafe.Pointer(nil)
+		default:
+			panic(fmt.Sprint("zero for unexpected type:", t))
+		}
+	case *types.Pointer:
+		return (*value)(nil)
+	case *types.Array:
+		a := make(array, t.Len())
+		for i := range a {
+			a[i] = zero(t.Elem())
+		}
+		return a
+	case *types.Named:
+		return zero(t.Underlying())
+	case *types.Interface:
+		return iface{} // nil type, methodset and value
+	case *types.Slice:
+		return []value(nil)
+	case *types.Struct:
+		s := make(structure, t.NumFields())
+		for i := range s {
+			s[i] = zero(t.Field(i).Type())
+		}
+		return s
+	case *types.Tuple:
+		if t.Len() == 1 {
+			return zero(t.At(0).Type())
+		}
+		s := make(tuple, t.Len())
+		for i := range s {
+			s[i] = zero(t.At(i).Type())
+		}
+		return s
+	case *types.Chan:
+		return chan value(nil)
+	case *types.Map:
+		if usesBuiltinMap(t.Key()) {
+			return map[value]value(nil)
+		}
+		return (*hashmap)(nil)
+	case *types.Signature:
+		return (*ssa.Function)(nil)
+	}
+	panic(fmt.Sprint("zero: unexpected ", t))
+}
+
+// slice returns x[lo:hi:max].  Any of lo, hi and max may be nil.
+func slice(x, lo, hi, max value) value {
+	var Len, Cap int
+	switch x := x.(type) {
+	case string:
+		Len = len(x)
+	case []value:
+		Len = len(x)
+		Cap = cap(x)
+	case *value: // *array
+		a := (*x).(array)
+		Len = len(a)
+		Cap = cap(a)
+	}
+
+	l := 0
+	if lo != nil {
+		l = asInt(lo)
+	}
+
+	h := Len
+	if hi != nil {
+		h = asInt(hi)
+	}
+
+	m := Cap
+	if max != nil {
+		m = asInt(max)
+	}
+
+	switch x := x.(type) {
+	case string:
+		return x[l:h]
+	case []value:
+		return x[l:h:m]
+	case *value: // *array
+		a := (*x).(array)
+		return []value(a)[l:h:m]
+	}
+	panic(fmt.Sprintf("slice: unexpected X type: %T", x))
+}
+
+// lookup returns x[idx] where x is a map or string.
+func lookup(instr *ssa.Lookup, x, idx value) value {
+	switch x := x.(type) { // map or string
+	case map[value]value, *hashmap:
+		var v value
+		var ok bool
+		switch x := x.(type) {
+		case map[value]value:
+			v, ok = x[idx]
+		case *hashmap:
+			v = x.lookup(idx.(hashable))
+			ok = v != nil
+		}
+		if !ok {
+			v = zero(instr.X.Type().Underlying().(*types.Map).Elem())
+		}
+		if instr.CommaOk {
+			v = tuple{v, ok}
+		}
+		return v
+	case string:
+		return x[asInt(idx)]
+	}
+	panic(fmt.Sprintf("unexpected x type in Lookup: %T", x))
+}
+
+// binop implements all arithmetic and logical binary operators for
+// numeric datatypes and strings.  Both operands must have identical
+// dynamic type.
+//
+func binop(op token.Token, t types.Type, x, y value) value {
+	switch op {
+	case token.ADD:
+		switch x.(type) {
+		case int:
+			return x.(int) + y.(int)
+		case int8:
+			return x.(int8) + y.(int8)
+		case int16:
+			return x.(int16) + y.(int16)
+		case int32:
+			return x.(int32) + y.(int32)
+		case int64:
+			return x.(int64) + y.(int64)
+		case uint:
+			return x.(uint) + y.(uint)
+		case uint8:
+			return x.(uint8) + y.(uint8)
+		case uint16:
+			return x.(uint16) + y.(uint16)
+		case uint32:
+			return x.(uint32) + y.(uint32)
+		case uint64:
+			return x.(uint64) + y.(uint64)
+		case uintptr:
+			return x.(uintptr) + y.(uintptr)
+		case float32:
+			return x.(float32) + y.(float32)
+		case float64:
+			return x.(float64) + y.(float64)
+		case complex64:
+			return x.(complex64) + y.(complex64)
+		case complex128:
+			return x.(complex128) + y.(complex128)
+		case string:
+			return x.(string) + y.(string)
+		}
+
+	case token.SUB:
+		switch x.(type) {
+		case int:
+			return x.(int) - y.(int)
+		case int8:
+			return x.(int8) - y.(int8)
+		case int16:
+			return x.(int16) - y.(int16)
+		case int32:
+			return x.(int32) - y.(int32)
+		case int64:
+			return x.(int64) - y.(int64)
+		case uint:
+			return x.(uint) - y.(uint)
+		case uint8:
+			return x.(uint8) - y.(uint8)
+		case uint16:
+			return x.(uint16) - y.(uint16)
+		case uint32:
+			return x.(uint32) - y.(uint32)
+		case uint64:
+			return x.(uint64) - y.(uint64)
+		case uintptr:
+			return x.(uintptr) - y.(uintptr)
+		case float32:
+			return x.(float32) - y.(float32)
+		case float64:
+			return x.(float64) - y.(float64)
+		case complex64:
+			return x.(complex64) - y.(complex64)
+		case complex128:
+			return x.(complex128) - y.(complex128)
+		}
+
+	case token.MUL:
+		switch x.(type) {
+		case int:
+			return x.(int) * y.(int)
+		case int8:
+			return x.(int8) * y.(int8)
+		case int16:
+			return x.(int16) * y.(int16)
+		case int32:
+			return x.(int32) * y.(int32)
+		case int64:
+			return x.(int64) * y.(int64)
+		case uint:
+			return x.(uint) * y.(uint)
+		case uint8:
+			return x.(uint8) * y.(uint8)
+		case uint16:
+			return x.(uint16) * y.(uint16)
+		case uint32:
+			return x.(uint32) * y.(uint32)
+		case uint64:
+			return x.(uint64) * y.(uint64)
+		case uintptr:
+			return x.(uintptr) * y.(uintptr)
+		case float32:
+			return x.(float32) * y.(float32)
+		case float64:
+			return x.(float64) * y.(float64)
+		case complex64:
+			return x.(complex64) * y.(complex64)
+		case complex128:
+			return x.(complex128) * y.(complex128)
+		}
+
+	case token.QUO:
+		switch x.(type) {
+		case int:
+			return x.(int) / y.(int)
+		case int8:
+			return x.(int8) / y.(int8)
+		case int16:
+			return x.(int16) / y.(int16)
+		case int32:
+			return x.(int32) / y.(int32)
+		case int64:
+			return x.(int64) / y.(int64)
+		case uint:
+			return x.(uint) / y.(uint)
+		case uint8:
+			return x.(uint8) / y.(uint8)
+		case uint16:
+			return x.(uint16) / y.(uint16)
+		case uint32:
+			return x.(uint32) / y.(uint32)
+		case uint64:
+			return x.(uint64) / y.(uint64)
+		case uintptr:
+			return x.(uintptr) / y.(uintptr)
+		case float32:
+			return x.(float32) / y.(float32)
+		case float64:
+			return x.(float64) / y.(float64)
+		case complex64:
+			return x.(complex64) / y.(complex64)
+		case complex128:
+			return x.(complex128) / y.(complex128)
+		}
+
+	case token.REM:
+		switch x.(type) {
+		case int:
+			return x.(int) % y.(int)
+		case int8:
+			return x.(int8) % y.(int8)
+		case int16:
+			return x.(int16) % y.(int16)
+		case int32:
+			return x.(int32) % y.(int32)
+		case int64:
+			return x.(int64) % y.(int64)
+		case uint:
+			return x.(uint) % y.(uint)
+		case uint8:
+			return x.(uint8) % y.(uint8)
+		case uint16:
+			return x.(uint16) % y.(uint16)
+		case uint32:
+			return x.(uint32) % y.(uint32)
+		case uint64:
+			return x.(uint64) % y.(uint64)
+		case uintptr:
+			return x.(uintptr) % y.(uintptr)
+		}
+
+	case token.AND:
+		switch x.(type) {
+		case int:
+			return x.(int) & y.(int)
+		case int8:
+			return x.(int8) & y.(int8)
+		case int16:
+			return x.(int16) & y.(int16)
+		case int32:
+			return x.(int32) & y.(int32)
+		case int64:
+			return x.(int64) & y.(int64)
+		case uint:
+			return x.(uint) & y.(uint)
+		case uint8:
+			return x.(uint8) & y.(uint8)
+		case uint16:
+			return x.(uint16) & y.(uint16)
+		case uint32:
+			return x.(uint32) & y.(uint32)
+		case uint64:
+			return x.(uint64) & y.(uint64)
+		case uintptr:
+			return x.(uintptr) & y.(uintptr)
+		}
+
+	case token.OR:
+		switch x.(type) {
+		case int:
+			return x.(int) | y.(int)
+		case int8:
+			return x.(int8) | y.(int8)
+		case int16:
+			return x.(int16) | y.(int16)
+		case int32:
+			return x.(int32) | y.(int32)
+		case int64:
+			return x.(int64) | y.(int64)
+		case uint:
+			return x.(uint) | y.(uint)
+		case uint8:
+			return x.(uint8) | y.(uint8)
+		case uint16:
+			return x.(uint16) | y.(uint16)
+		case uint32:
+			return x.(uint32) | y.(uint32)
+		case uint64:
+			return x.(uint64) | y.(uint64)
+		case uintptr:
+			return x.(uintptr) | y.(uintptr)
+		}
+
+	case token.XOR:
+		switch x.(type) {
+		case int:
+			return x.(int) ^ y.(int)
+		case int8:
+			return x.(int8) ^ y.(int8)
+		case int16:
+			return x.(int16) ^ y.(int16)
+		case int32:
+			return x.(int32) ^ y.(int32)
+		case int64:
+			return x.(int64) ^ y.(int64)
+		case uint:
+			return x.(uint) ^ y.(uint)
+		case uint8:
+			return x.(uint8) ^ y.(uint8)
+		case uint16:
+			return x.(uint16) ^ y.(uint16)
+		case uint32:
+			return x.(uint32) ^ y.(uint32)
+		case uint64:
+			return x.(uint64) ^ y.(uint64)
+		case uintptr:
+			return x.(uintptr) ^ y.(uintptr)
+		}
+
+	case token.AND_NOT:
+		switch x.(type) {
+		case int:
+			return x.(int) &^ y.(int)
+		case int8:
+			return x.(int8) &^ y.(int8)
+		case int16:
+			return x.(int16) &^ y.(int16)
+		case int32:
+			return x.(int32) &^ y.(int32)
+		case int64:
+			return x.(int64) &^ y.(int64)
+		case uint:
+			return x.(uint) &^ y.(uint)
+		case uint8:
+			return x.(uint8) &^ y.(uint8)
+		case uint16:
+			return x.(uint16) &^ y.(uint16)
+		case uint32:
+			return x.(uint32) &^ y.(uint32)
+		case uint64:
+			return x.(uint64) &^ y.(uint64)
+		case uintptr:
+			return x.(uintptr) &^ y.(uintptr)
+		}
+
+	case token.SHL:
+		y := asUint64(y)
+		switch x.(type) {
+		case int:
+			return x.(int) << y
+		case int8:
+			return x.(int8) << y
+		case int16:
+			return x.(int16) << y
+		case int32:
+			return x.(int32) << y
+		case int64:
+			return x.(int64) << y
+		case uint:
+			return x.(uint) << y
+		case uint8:
+			return x.(uint8) << y
+		case uint16:
+			return x.(uint16) << y
+		case uint32:
+			return x.(uint32) << y
+		case uint64:
+			return x.(uint64) << y
+		case uintptr:
+			return x.(uintptr) << y
+		}
+
+	case token.SHR:
+		y := asUint64(y)
+		switch x.(type) {
+		case int:
+			return x.(int) >> y
+		case int8:
+			return x.(int8) >> y
+		case int16:
+			return x.(int16) >> y
+		case int32:
+			return x.(int32) >> y
+		case int64:
+			return x.(int64) >> y
+		case uint:
+			return x.(uint) >> y
+		case uint8:
+			return x.(uint8) >> y
+		case uint16:
+			return x.(uint16) >> y
+		case uint32:
+			return x.(uint32) >> y
+		case uint64:
+			return x.(uint64) >> y
+		case uintptr:
+			return x.(uintptr) >> y
+		}
+
+	case token.LSS:
+		switch x.(type) {
+		case int:
+			return x.(int) < y.(int)
+		case int8:
+			return x.(int8) < y.(int8)
+		case int16:
+			return x.(int16) < y.(int16)
+		case int32:
+			return x.(int32) < y.(int32)
+		case int64:
+			return x.(int64) < y.(int64)
+		case uint:
+			return x.(uint) < y.(uint)
+		case uint8:
+			return x.(uint8) < y.(uint8)
+		case uint16:
+			return x.(uint16) < y.(uint16)
+		case uint32:
+			return x.(uint32) < y.(uint32)
+		case uint64:
+			return x.(uint64) < y.(uint64)
+		case uintptr:
+			return x.(uintptr) < y.(uintptr)
+		case float32:
+			return x.(float32) < y.(float32)
+		case float64:
+			return x.(float64) < y.(float64)
+		case string:
+			return x.(string) < y.(string)
+		}
+
+	case token.LEQ:
+		switch x.(type) {
+		case int:
+			return x.(int) <= y.(int)
+		case int8:
+			return x.(int8) <= y.(int8)
+		case int16:
+			return x.(int16) <= y.(int16)
+		case int32:
+			return x.(int32) <= y.(int32)
+		case int64:
+			return x.(int64) <= y.(int64)
+		case uint:
+			return x.(uint) <= y.(uint)
+		case uint8:
+			return x.(uint8) <= y.(uint8)
+		case uint16:
+			return x.(uint16) <= y.(uint16)
+		case uint32:
+			return x.(uint32) <= y.(uint32)
+		case uint64:
+			return x.(uint64) <= y.(uint64)
+		case uintptr:
+			return x.(uintptr) <= y.(uintptr)
+		case float32:
+			return x.(float32) <= y.(float32)
+		case float64:
+			return x.(float64) <= y.(float64)
+		case string:
+			return x.(string) <= y.(string)
+		}
+
+	case token.EQL:
+		return eqnil(t, x, y)
+
+	case token.NEQ:
+		return !eqnil(t, x, y)
+
+	case token.GTR:
+		switch x.(type) {
+		case int:
+			return x.(int) > y.(int)
+		case int8:
+			return x.(int8) > y.(int8)
+		case int16:
+			return x.(int16) > y.(int16)
+		case int32:
+			return x.(int32) > y.(int32)
+		case int64:
+			return x.(int64) > y.(int64)
+		case uint:
+			return x.(uint) > y.(uint)
+		case uint8:
+			return x.(uint8) > y.(uint8)
+		case uint16:
+			return x.(uint16) > y.(uint16)
+		case uint32:
+			return x.(uint32) > y.(uint32)
+		case uint64:
+			return x.(uint64) > y.(uint64)
+		case uintptr:
+			return x.(uintptr) > y.(uintptr)
+		case float32:
+			return x.(float32) > y.(float32)
+		case float64:
+			return x.(float64) > y.(float64)
+		case string:
+			return x.(string) > y.(string)
+		}
+
+	case token.GEQ:
+		switch x.(type) {
+		case int:
+			return x.(int) >= y.(int)
+		case int8:
+			return x.(int8) >= y.(int8)
+		case int16:
+			return x.(int16) >= y.(int16)
+		case int32:
+			return x.(int32) >= y.(int32)
+		case int64:
+			return x.(int64) >= y.(int64)
+		case uint:
+			return x.(uint) >= y.(uint)
+		case uint8:
+			return x.(uint8) >= y.(uint8)
+		case uint16:
+			return x.(uint16) >= y.(uint16)
+		case uint32:
+			return x.(uint32) >= y.(uint32)
+		case uint64:
+			return x.(uint64) >= y.(uint64)
+		case uintptr:
+			return x.(uintptr) >= y.(uintptr)
+		case float32:
+			return x.(float32) >= y.(float32)
+		case float64:
+			return x.(float64) >= y.(float64)
+		case string:
+			return x.(string) >= y.(string)
+		}
+	}
+	panic(fmt.Sprintf("invalid binary op: %T %s %T", x, op, y))
+}
+
+// eqnil returns the comparison x == y using the equivalence relation
+// appropriate for type t.
+// If t is a reference type, at most one of x or y may be a nil value
+// of that type.
+//
+func eqnil(t types.Type, x, y value) bool {
+	switch t.Underlying().(type) {
+	case *types.Map, *types.Signature, *types.Slice:
+		// Since these types don't support comparison,
+		// one of the operands must be a literal nil.
+		switch x := x.(type) {
+		case *hashmap:
+			return (x != nil) == (y.(*hashmap) != nil)
+		case map[value]value:
+			return (x != nil) == (y.(map[value]value) != nil)
+		case *ssa.Function:
+			switch y := y.(type) {
+			case *ssa.Function:
+				return (x != nil) == (y != nil)
+			case *closure:
+				return true
+			}
+		case *closure:
+			return (x != nil) == (y.(*ssa.Function) != nil)
+		case []value:
+			return (x != nil) == (y.([]value) != nil)
+		}
+		panic(fmt.Sprintf("eqnil(%s): illegal dynamic type: %T", t, x))
+	}
+
+	return equals(t, x, y)
+}
+
+func unop(instr *ssa.UnOp, x value) value {
+	switch instr.Op {
+	case token.ARROW: // receive
+		v, ok := <-x.(chan value)
+		if !ok {
+			v = zero(instr.X.Type().Underlying().(*types.Chan).Elem())
+		}
+		if instr.CommaOk {
+			v = tuple{v, ok}
+		}
+		return v
+	case token.SUB:
+		switch x := x.(type) {
+		case int:
+			return -x
+		case int8:
+			return -x
+		case int16:
+			return -x
+		case int32:
+			return -x
+		case int64:
+			return -x
+		case uint:
+			return -x
+		case uint8:
+			return -x
+		case uint16:
+			return -x
+		case uint32:
+			return -x
+		case uint64:
+			return -x
+		case uintptr:
+			return -x
+		case float32:
+			return -x
+		case float64:
+			return -x
+		case complex64:
+			return -x
+		case complex128:
+			return -x
+		}
+	case token.MUL:
+		return load(deref(instr.X.Type()), x.(*value))
+	case token.NOT:
+		return !x.(bool)
+	case token.XOR:
+		switch x := x.(type) {
+		case int:
+			return ^x
+		case int8:
+			return ^x
+		case int16:
+			return ^x
+		case int32:
+			return ^x
+		case int64:
+			return ^x
+		case uint:
+			return ^x
+		case uint8:
+			return ^x
+		case uint16:
+			return ^x
+		case uint32:
+			return ^x
+		case uint64:
+			return ^x
+		case uintptr:
+			return ^x
+		}
+	}
+	panic(fmt.Sprintf("invalid unary op %s %T", instr.Op, x))
+}
+
+// typeAssert checks whether dynamic type of itf is instr.AssertedType.
+// It returns the extracted value on success, and panics on failure,
+// unless instr.CommaOk, in which case it always returns a "value,ok" tuple.
+//
+func typeAssert(i *interpreter, instr *ssa.TypeAssert, itf iface) value {
+	var v value
+	err := ""
+	if itf.t == nil {
+		err = fmt.Sprintf("interface conversion: interface is nil, not %s", instr.AssertedType)
+
+	} else if idst, ok := instr.AssertedType.Underlying().(*types.Interface); ok {
+		v = itf
+		err = checkInterface(i, idst, itf)
+
+	} else if types.Identical(itf.t, instr.AssertedType) {
+		v = itf.v // extract value
+
+	} else {
+		err = fmt.Sprintf("interface conversion: interface is %s, not %s", itf.t, instr.AssertedType)
+	}
+
+	if err != "" {
+		if !instr.CommaOk {
+			panic(err)
+		}
+		return tuple{zero(instr.AssertedType), false}
+	}
+	if instr.CommaOk {
+		return tuple{v, true}
+	}
+	return v
+}
+
+// If CapturedOutput is non-nil, all writes by the interpreted program
+// to file descriptors 1 and 2 will also be written to CapturedOutput.
+//
+// (The $GOROOT/test system requires that the test be considered a
+// failure if "BUG" appears in the combined stdout/stderr output, even
+// if it exits zero.  This is a global variable shared by all
+// interpreters in the same process.)
+//
+var CapturedOutput *bytes.Buffer
+var capturedOutputMu sync.Mutex
+
+// write writes bytes b to the target program's file descriptor fd.
+// The print/println built-ins and the write() system call funnel
+// through here so they can be captured by the test driver.
+func write(fd int, b []byte) (int, error) {
+	// TODO(adonovan): fix: on Windows, std{out,err} are not 1, 2.
+	if CapturedOutput != nil && (fd == 1 || fd == 2) {
+		capturedOutputMu.Lock()
+		CapturedOutput.Write(b) // ignore errors
+		capturedOutputMu.Unlock()
+	}
+	return syswrite(fd, b)
+}
+
+var syswrite func(int, []byte) (int, error) // set on darwin/linux only
+
+// callBuiltin interprets a call to builtin fn with arguments args,
+// returning its result.
+func callBuiltin(caller *frame, callpos token.Pos, fn *ssa.Builtin, args []value) value {
+	switch fn.Name() {
+	case "append":
+		if len(args) == 1 {
+			return args[0]
+		}
+		if s, ok := args[1].(string); ok {
+			// append([]byte, ...string) []byte
+			arg0 := args[0].([]value)
+			for i := 0; i < len(s); i++ {
+				arg0 = append(arg0, s[i])
+			}
+			return arg0
+		}
+		// append([]T, ...[]T) []T
+		return append(args[0].([]value), args[1].([]value)...)
+
+	case "copy": // copy([]T, []T) int or copy([]byte, string) int
+		src := args[1]
+		if _, ok := src.(string); ok {
+			params := fn.Type().(*types.Signature).Params()
+			src = conv(params.At(0).Type(), params.At(1).Type(), src)
+		}
+		return copy(args[0].([]value), src.([]value))
+
+	case "close": // close(chan T)
+		close(args[0].(chan value))
+		return nil
+
+	case "delete": // delete(map[K]value, K)
+		switch m := args[0].(type) {
+		case map[value]value:
+			delete(m, args[1])
+		case *hashmap:
+			m.delete(args[1].(hashable))
+		default:
+			panic(fmt.Sprintf("illegal map type: %T", m))
+		}
+		return nil
+
+	case "print", "println": // print(any, ...)
+		ln := fn.Name() == "println"
+		var buf bytes.Buffer
+		for i, arg := range args {
+			if i > 0 && ln {
+				buf.WriteRune(' ')
+			}
+			buf.WriteString(toString(arg))
+		}
+		if ln {
+			buf.WriteRune('\n')
+		}
+		write(1, buf.Bytes())
+		return nil
+
+	case "len":
+		switch x := args[0].(type) {
+		case string:
+			return len(x)
+		case array:
+			return len(x)
+		case *value:
+			return len((*x).(array))
+		case []value:
+			return len(x)
+		case map[value]value:
+			return len(x)
+		case *hashmap:
+			return x.len()
+		case chan value:
+			return len(x)
+		default:
+			panic(fmt.Sprintf("len: illegal operand: %T", x))
+		}
+
+	case "cap":
+		switch x := args[0].(type) {
+		case array:
+			return cap(x)
+		case *value:
+			return cap((*x).(array))
+		case []value:
+			return cap(x)
+		case chan value:
+			return cap(x)
+		default:
+			panic(fmt.Sprintf("cap: illegal operand: %T", x))
+		}
+
+	case "real":
+		switch c := args[0].(type) {
+		case complex64:
+			return real(c)
+		case complex128:
+			return real(c)
+		default:
+			panic(fmt.Sprintf("real: illegal operand: %T", c))
+		}
+
+	case "imag":
+		switch c := args[0].(type) {
+		case complex64:
+			return imag(c)
+		case complex128:
+			return imag(c)
+		default:
+			panic(fmt.Sprintf("imag: illegal operand: %T", c))
+		}
+
+	case "complex":
+		switch f := args[0].(type) {
+		case float32:
+			return complex(f, args[1].(float32))
+		case float64:
+			return complex(f, args[1].(float64))
+		default:
+			panic(fmt.Sprintf("complex: illegal operand: %T", f))
+		}
+
+	case "panic":
+		// ssa.Panic handles most cases; this is only for "go
+		// panic" or "defer panic".
+		panic(targetPanic{args[0]})
+
+	case "recover":
+		return doRecover(caller)
+
+	case "ssa:wrapnilchk":
+		recv := args[0]
+		if recv.(*value) == nil {
+			recvType := args[1]
+			methodName := args[2]
+			panic(fmt.Sprintf("value method (%s).%s called using nil *%s pointer",
+				recvType, methodName, recvType))
+		}
+		return recv
+	}
+
+	panic("unknown built-in: " + fn.Name())
+}
+
+func rangeIter(x value, t types.Type) iter {
+	switch x := x.(type) {
+	case map[value]value:
+		// TODO(adonovan): fix: leaks goroutines and channels
+		// on each incomplete map iteration.  We need to open
+		// up an iteration interface using the
+		// reflect.(Value).MapKeys machinery.
+		it := make(mapIter)
+		go func() {
+			for k, v := range x {
+				it <- [2]value{k, v}
+			}
+			close(it)
+		}()
+		return it
+	case *hashmap:
+		// TODO(adonovan): fix: leaks goroutines and channels
+		// on each incomplete map iteration.  We need to open
+		// up an iteration interface using the
+		// reflect.(Value).MapKeys machinery.
+		it := make(mapIter)
+		go func() {
+			for _, e := range x.entries() {
+				for e != nil {
+					it <- [2]value{e.key, e.value}
+					e = e.next
+				}
+			}
+			close(it)
+		}()
+		return it
+	case string:
+		return &stringIter{Reader: strings.NewReader(x)}
+	}
+	panic(fmt.Sprintf("cannot range over %T", x))
+}
+
+// widen widens a basic typed value x to the widest type of its
+// category, one of:
+//   bool, int64, uint64, float64, complex128, string.
+// This is inefficient but reduces the size of the cross-product of
+// cases we have to consider.
+//
+func widen(x value) value {
+	switch y := x.(type) {
+	case bool, int64, uint64, float64, complex128, string, unsafe.Pointer:
+		return x
+	case int:
+		return int64(y)
+	case int8:
+		return int64(y)
+	case int16:
+		return int64(y)
+	case int32:
+		return int64(y)
+	case uint:
+		return uint64(y)
+	case uint8:
+		return uint64(y)
+	case uint16:
+		return uint64(y)
+	case uint32:
+		return uint64(y)
+	case uintptr:
+		return uint64(y)
+	case float32:
+		return float64(y)
+	case complex64:
+		return complex128(y)
+	}
+	panic(fmt.Sprintf("cannot widen %T", x))
+}
+
+// conv converts the value x of type t_src to type t_dst and returns
+// the result.
+// Possible cases are described with the ssa.Convert operator.
+//
+func conv(t_dst, t_src types.Type, x value) value {
+	ut_src := t_src.Underlying()
+	ut_dst := t_dst.Underlying()
+
+	// Destination type is not an "untyped" type.
+	if b, ok := ut_dst.(*types.Basic); ok && b.Info()&types.IsUntyped != 0 {
+		panic("oops: conversion to 'untyped' type: " + b.String())
+	}
+
+	// Nor is it an interface type.
+	if _, ok := ut_dst.(*types.Interface); ok {
+		if _, ok := ut_src.(*types.Interface); ok {
+			panic("oops: Convert should be ChangeInterface")
+		} else {
+			panic("oops: Convert should be MakeInterface")
+		}
+	}
+
+	// Remaining conversions:
+	//    + untyped string/number/bool constant to a specific
+	//      representation.
+	//    + conversions between non-complex numeric types.
+	//    + conversions between complex numeric types.
+	//    + integer/[]byte/[]rune -> string.
+	//    + string -> []byte/[]rune.
+	//
+	// All are treated the same: first we extract the value to the
+	// widest representation (int64, uint64, float64, complex128,
+	// or string), then we convert it to the desired type.
+
+	switch ut_src := ut_src.(type) {
+	case *types.Pointer:
+		switch ut_dst := ut_dst.(type) {
+		case *types.Basic:
+			// *value to unsafe.Pointer?
+			if ut_dst.Kind() == types.UnsafePointer {
+				return unsafe.Pointer(x.(*value))
+			}
+		}
+
+	case *types.Slice:
+		// []byte or []rune -> string
+		// TODO(adonovan): fix: type B byte; conv([]B -> string).
+		switch ut_src.Elem().(*types.Basic).Kind() {
+		case types.Byte:
+			x := x.([]value)
+			b := make([]byte, 0, len(x))
+			for i := range x {
+				b = append(b, x[i].(byte))
+			}
+			return string(b)
+
+		case types.Rune:
+			x := x.([]value)
+			r := make([]rune, 0, len(x))
+			for i := range x {
+				r = append(r, x[i].(rune))
+			}
+			return string(r)
+		}
+
+	case *types.Basic:
+		x = widen(x)
+
+		// integer -> string?
+		// TODO(adonovan): fix: test integer -> named alias of string.
+		if ut_src.Info()&types.IsInteger != 0 {
+			if ut_dst, ok := ut_dst.(*types.Basic); ok && ut_dst.Kind() == types.String {
+				return string(asInt(x))
+			}
+		}
+
+		// string -> []rune, []byte or string?
+		if s, ok := x.(string); ok {
+			switch ut_dst := ut_dst.(type) {
+			case *types.Slice:
+				var res []value
+				// TODO(adonovan): fix: test named alias of rune, byte.
+				switch ut_dst.Elem().(*types.Basic).Kind() {
+				case types.Rune:
+					for _, r := range []rune(s) {
+						res = append(res, r)
+					}
+					return res
+				case types.Byte:
+					for _, b := range []byte(s) {
+						res = append(res, b)
+					}
+					return res
+				}
+			case *types.Basic:
+				if ut_dst.Kind() == types.String {
+					return x.(string)
+				}
+			}
+			break // fail: no other conversions for string
+		}
+
+		// unsafe.Pointer -> *value
+		if ut_src.Kind() == types.UnsafePointer {
+			// TODO(adonovan): this is wrong and cannot
+			// really be fixed with the current design.
+			//
+			// return (*value)(x.(unsafe.Pointer))
+			// creates a new pointer of a different
+			// type but the underlying interface value
+			// knows its "true" type and so cannot be
+			// meaningfully used through the new pointer.
+			//
+			// To make this work, the interpreter needs to
+			// simulate the memory layout of a real
+			// compiled implementation.
+			//
+			// To at least preserve type-safety, we'll
+			// just return the zero value of the
+			// destination type.
+			return zero(t_dst)
+		}
+
+		// Conversions between complex numeric types?
+		if ut_src.Info()&types.IsComplex != 0 {
+			switch ut_dst.(*types.Basic).Kind() {
+			case types.Complex64:
+				return complex64(x.(complex128))
+			case types.Complex128:
+				return x.(complex128)
+			}
+			break // fail: no other conversions for complex
+		}
+
+		// Conversions between non-complex numeric types?
+		if ut_src.Info()&types.IsNumeric != 0 {
+			kind := ut_dst.(*types.Basic).Kind()
+			switch x := x.(type) {
+			case int64: // signed integer -> numeric?
+				switch kind {
+				case types.Int:
+					return int(x)
+				case types.Int8:
+					return int8(x)
+				case types.Int16:
+					return int16(x)
+				case types.Int32:
+					return int32(x)
+				case types.Int64:
+					return int64(x)
+				case types.Uint:
+					return uint(x)
+				case types.Uint8:
+					return uint8(x)
+				case types.Uint16:
+					return uint16(x)
+				case types.Uint32:
+					return uint32(x)
+				case types.Uint64:
+					return uint64(x)
+				case types.Uintptr:
+					return uintptr(x)
+				case types.Float32:
+					return float32(x)
+				case types.Float64:
+					return float64(x)
+				}
+
+			case uint64: // unsigned integer -> numeric?
+				switch kind {
+				case types.Int:
+					return int(x)
+				case types.Int8:
+					return int8(x)
+				case types.Int16:
+					return int16(x)
+				case types.Int32:
+					return int32(x)
+				case types.Int64:
+					return int64(x)
+				case types.Uint:
+					return uint(x)
+				case types.Uint8:
+					return uint8(x)
+				case types.Uint16:
+					return uint16(x)
+				case types.Uint32:
+					return uint32(x)
+				case types.Uint64:
+					return uint64(x)
+				case types.Uintptr:
+					return uintptr(x)
+				case types.Float32:
+					return float32(x)
+				case types.Float64:
+					return float64(x)
+				}
+
+			case float64: // floating point -> numeric?
+				switch kind {
+				case types.Int:
+					return int(x)
+				case types.Int8:
+					return int8(x)
+				case types.Int16:
+					return int16(x)
+				case types.Int32:
+					return int32(x)
+				case types.Int64:
+					return int64(x)
+				case types.Uint:
+					return uint(x)
+				case types.Uint8:
+					return uint8(x)
+				case types.Uint16:
+					return uint16(x)
+				case types.Uint32:
+					return uint32(x)
+				case types.Uint64:
+					return uint64(x)
+				case types.Uintptr:
+					return uintptr(x)
+				case types.Float32:
+					return float32(x)
+				case types.Float64:
+					return float64(x)
+				}
+			}
+		}
+	}
+
+	panic(fmt.Sprintf("unsupported conversion: %s  -> %s, dynamic type %T", t_src, t_dst, x))
+}
+
+// checkInterface checks that the method set of x implements the
+// interface itype.
+// On success it returns "", on failure, an error message.
+//
+func checkInterface(i *interpreter, itype *types.Interface, x iface) string {
+	if meth, _ := types.MissingMethod(x.t, itype, true); meth != nil {
+		return fmt.Sprintf("interface conversion: %v is not %v: missing method %s",
+			x.t, itype, meth.Name())
+	}
+	return "" // ok
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/reflect.go b/vendor/golang.org/x/tools/go/ssa/interp/reflect.go
new file mode 100644
index 0000000..2b82899
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/reflect.go
@@ -0,0 +1,574 @@
+// 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 interp
+
+// Emulated "reflect" package.
+//
+// We completely replace the built-in "reflect" package.
+// The only thing clients can depend upon are that reflect.Type is an
+// interface and reflect.Value is an (opaque) struct.
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"reflect"
+	"unsafe"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+type opaqueType struct {
+	types.Type
+	name string
+}
+
+func (t *opaqueType) String() string { return t.name }
+
+// A bogus "reflect" type-checker package.  Shared across interpreters.
+var reflectTypesPackage = types.NewPackage("reflect", "reflect")
+
+// rtype is the concrete type the interpreter uses to implement the
+// reflect.Type interface.
+//
+// type rtype <opaque>
+var rtypeType = makeNamedType("rtype", &opaqueType{nil, "rtype"})
+
+// error is an (interpreted) named type whose underlying type is string.
+// The interpreter uses it for all implementations of the built-in error
+// interface that it creates.
+// We put it in the "reflect" package for expedience.
+//
+// type error string
+var errorType = makeNamedType("error", &opaqueType{nil, "error"})
+
+func makeNamedType(name string, underlying types.Type) *types.Named {
+	obj := types.NewTypeName(token.NoPos, reflectTypesPackage, name, nil)
+	return types.NewNamed(obj, underlying, nil)
+}
+
+func makeReflectValue(t types.Type, v value) value {
+	return structure{rtype{t}, v}
+}
+
+// Given a reflect.Value, returns its rtype.
+func rV2T(v value) rtype {
+	return v.(structure)[0].(rtype)
+}
+
+// Given a reflect.Value, returns the underlying interpreter value.
+func rV2V(v value) value {
+	return v.(structure)[1]
+}
+
+// makeReflectType boxes up an rtype in a reflect.Type interface.
+func makeReflectType(rt rtype) value {
+	return iface{rtypeType, rt}
+}
+
+func ext۰reflect۰Init(fr *frame, args []value) value {
+	// Signature: func()
+	return nil
+}
+
+func ext۰reflect۰rtype۰Bits(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) int
+	rt := args[0].(rtype).t
+	basic, ok := rt.Underlying().(*types.Basic)
+	if !ok {
+		panic(fmt.Sprintf("reflect.Type.Bits(%T): non-basic type", rt))
+	}
+	return int(fr.i.sizes.Sizeof(basic)) * 8
+}
+
+func ext۰reflect۰rtype۰Elem(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) reflect.Type
+	return makeReflectType(rtype{args[0].(rtype).t.Underlying().(interface {
+		Elem() types.Type
+	}).Elem()})
+}
+
+func ext۰reflect۰rtype۰Field(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype, i int) reflect.StructField
+	st := args[0].(rtype).t.Underlying().(*types.Struct)
+	i := args[1].(int)
+	f := st.Field(i)
+	return structure{
+		f.Name(),
+		f.Pkg().Path(),
+		makeReflectType(rtype{f.Type()}),
+		st.Tag(i),
+		0,         // TODO(adonovan): offset
+		[]value{}, // TODO(adonovan): indices
+		f.Anonymous(),
+	}
+}
+
+func ext۰reflect۰rtype۰In(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype, i int) int
+	i := args[1].(int)
+	return makeReflectType(rtype{args[0].(rtype).t.(*types.Signature).Params().At(i).Type()})
+}
+
+func ext۰reflect۰rtype۰Kind(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) uint
+	return uint(reflectKind(args[0].(rtype).t))
+}
+
+func ext۰reflect۰rtype۰NumField(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) int
+	return args[0].(rtype).t.Underlying().(*types.Struct).NumFields()
+}
+
+func ext۰reflect۰rtype۰NumIn(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) int
+	return args[0].(rtype).t.(*types.Signature).Params().Len()
+}
+
+func ext۰reflect۰rtype۰NumMethod(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) int
+	return fr.i.prog.MethodSets.MethodSet(args[0].(rtype).t).Len()
+}
+
+func ext۰reflect۰rtype۰NumOut(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) int
+	return args[0].(rtype).t.(*types.Signature).Results().Len()
+}
+
+func ext۰reflect۰rtype۰Out(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype, i int) int
+	i := args[1].(int)
+	return makeReflectType(rtype{args[0].(rtype).t.(*types.Signature).Results().At(i).Type()})
+}
+
+func ext۰reflect۰rtype۰Size(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) uintptr
+	return uintptr(fr.i.sizes.Sizeof(args[0].(rtype).t))
+}
+
+func ext۰reflect۰rtype۰String(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) string
+	return args[0].(rtype).t.String()
+}
+
+func ext۰reflect۰New(fr *frame, args []value) value {
+	// Signature: func (t reflect.Type) reflect.Value
+	t := args[0].(iface).v.(rtype).t
+	alloc := zero(t)
+	return makeReflectValue(types.NewPointer(t), &alloc)
+}
+
+func ext۰reflect۰SliceOf(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) Type
+	return makeReflectType(rtype{types.NewSlice(args[0].(iface).v.(rtype).t)})
+}
+
+func ext۰reflect۰TypeOf(fr *frame, args []value) value {
+	// Signature: func (t reflect.rtype) Type
+	return makeReflectType(rtype{args[0].(iface).t})
+}
+
+func ext۰reflect۰ValueOf(fr *frame, args []value) value {
+	// Signature: func (interface{}) reflect.Value
+	itf := args[0].(iface)
+	return makeReflectValue(itf.t, itf.v)
+}
+
+func ext۰reflect۰Zero(fr *frame, args []value) value {
+	// Signature: func (t reflect.Type) reflect.Value
+	t := args[0].(iface).v.(rtype).t
+	return makeReflectValue(t, zero(t))
+}
+
+func reflectKind(t types.Type) reflect.Kind {
+	switch t := t.(type) {
+	case *types.Named:
+		return reflectKind(t.Underlying())
+	case *types.Basic:
+		switch t.Kind() {
+		case types.Bool:
+			return reflect.Bool
+		case types.Int:
+			return reflect.Int
+		case types.Int8:
+			return reflect.Int8
+		case types.Int16:
+			return reflect.Int16
+		case types.Int32:
+			return reflect.Int32
+		case types.Int64:
+			return reflect.Int64
+		case types.Uint:
+			return reflect.Uint
+		case types.Uint8:
+			return reflect.Uint8
+		case types.Uint16:
+			return reflect.Uint16
+		case types.Uint32:
+			return reflect.Uint32
+		case types.Uint64:
+			return reflect.Uint64
+		case types.Uintptr:
+			return reflect.Uintptr
+		case types.Float32:
+			return reflect.Float32
+		case types.Float64:
+			return reflect.Float64
+		case types.Complex64:
+			return reflect.Complex64
+		case types.Complex128:
+			return reflect.Complex128
+		case types.String:
+			return reflect.String
+		case types.UnsafePointer:
+			return reflect.UnsafePointer
+		}
+	case *types.Array:
+		return reflect.Array
+	case *types.Chan:
+		return reflect.Chan
+	case *types.Signature:
+		return reflect.Func
+	case *types.Interface:
+		return reflect.Interface
+	case *types.Map:
+		return reflect.Map
+	case *types.Pointer:
+		return reflect.Ptr
+	case *types.Slice:
+		return reflect.Slice
+	case *types.Struct:
+		return reflect.Struct
+	}
+	panic(fmt.Sprint("unexpected type: ", t))
+}
+
+func ext۰reflect۰Value۰Kind(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) uint
+	return uint(reflectKind(rV2T(args[0]).t))
+}
+
+func ext۰reflect۰Value۰String(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) string
+	return toString(rV2V(args[0]))
+}
+
+func ext۰reflect۰Value۰Type(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) reflect.Type
+	return makeReflectType(rV2T(args[0]))
+}
+
+func ext۰reflect۰Value۰Uint(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) uint64
+	switch v := rV2V(args[0]).(type) {
+	case uint:
+		return uint64(v)
+	case uint8:
+		return uint64(v)
+	case uint16:
+		return uint64(v)
+	case uint32:
+		return uint64(v)
+	case uint64:
+		return uint64(v)
+	case uintptr:
+		return uint64(v)
+	}
+	panic("reflect.Value.Uint")
+}
+
+func ext۰reflect۰Value۰Len(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) int
+	switch v := rV2V(args[0]).(type) {
+	case string:
+		return len(v)
+	case array:
+		return len(v)
+	case chan value:
+		return cap(v)
+	case []value:
+		return len(v)
+	case *hashmap:
+		return v.len()
+	case map[value]value:
+		return len(v)
+	default:
+		panic(fmt.Sprintf("reflect.(Value).Len(%v)", v))
+	}
+}
+
+func ext۰reflect۰Value۰MapIndex(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) Value
+	tValue := rV2T(args[0]).t.Underlying().(*types.Map).Key()
+	k := rV2V(args[1])
+	switch m := rV2V(args[0]).(type) {
+	case map[value]value:
+		if v, ok := m[k]; ok {
+			return makeReflectValue(tValue, v)
+		}
+
+	case *hashmap:
+		if v := m.lookup(k.(hashable)); v != nil {
+			return makeReflectValue(tValue, v)
+		}
+
+	default:
+		panic(fmt.Sprintf("(reflect.Value).MapIndex(%T, %T)", m, k))
+	}
+	return makeReflectValue(nil, nil)
+}
+
+func ext۰reflect۰Value۰MapKeys(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) []Value
+	var keys []value
+	tKey := rV2T(args[0]).t.Underlying().(*types.Map).Key()
+	switch v := rV2V(args[0]).(type) {
+	case map[value]value:
+		for k := range v {
+			keys = append(keys, makeReflectValue(tKey, k))
+		}
+
+	case *hashmap:
+		for _, e := range v.entries() {
+			for ; e != nil; e = e.next {
+				keys = append(keys, makeReflectValue(tKey, e.key))
+			}
+		}
+
+	default:
+		panic(fmt.Sprintf("(reflect.Value).MapKeys(%T)", v))
+	}
+	return keys
+}
+
+func ext۰reflect۰Value۰NumField(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) int
+	return len(rV2V(args[0]).(structure))
+}
+
+func ext۰reflect۰Value۰NumMethod(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) int
+	return fr.i.prog.MethodSets.MethodSet(rV2T(args[0]).t).Len()
+}
+
+func ext۰reflect۰Value۰Pointer(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value) uintptr
+	switch v := rV2V(args[0]).(type) {
+	case *value:
+		return uintptr(unsafe.Pointer(v))
+	case chan value:
+		return reflect.ValueOf(v).Pointer()
+	case []value:
+		return reflect.ValueOf(v).Pointer()
+	case *hashmap:
+		return reflect.ValueOf(v.entries()).Pointer()
+	case map[value]value:
+		return reflect.ValueOf(v).Pointer()
+	case *ssa.Function:
+		return uintptr(unsafe.Pointer(v))
+	case *closure:
+		return uintptr(unsafe.Pointer(v))
+	default:
+		panic(fmt.Sprintf("reflect.(Value).Pointer(%T)", v))
+	}
+}
+
+func ext۰reflect۰Value۰Index(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value, i int) Value
+	i := args[1].(int)
+	t := rV2T(args[0]).t.Underlying()
+	switch v := rV2V(args[0]).(type) {
+	case array:
+		return makeReflectValue(t.(*types.Array).Elem(), v[i])
+	case []value:
+		return makeReflectValue(t.(*types.Slice).Elem(), v[i])
+	default:
+		panic(fmt.Sprintf("reflect.(Value).Index(%T)", v))
+	}
+}
+
+func ext۰reflect۰Value۰Bool(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) bool
+	return rV2V(args[0]).(bool)
+}
+
+func ext۰reflect۰Value۰CanAddr(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value) bool
+	// Always false for our representation.
+	return false
+}
+
+func ext۰reflect۰Value۰CanInterface(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value) bool
+	// Always true for our representation.
+	return true
+}
+
+func ext۰reflect۰Value۰Elem(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value) reflect.Value
+	switch x := rV2V(args[0]).(type) {
+	case iface:
+		return makeReflectValue(x.t, x.v)
+	case *value:
+		return makeReflectValue(rV2T(args[0]).t.Underlying().(*types.Pointer).Elem(), *x)
+	default:
+		panic(fmt.Sprintf("reflect.(Value).Elem(%T)", x))
+	}
+}
+
+func ext۰reflect۰Value۰Field(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value, i int) reflect.Value
+	v := args[0]
+	i := args[1].(int)
+	return makeReflectValue(rV2T(v).t.Underlying().(*types.Struct).Field(i).Type(), rV2V(v).(structure)[i])
+}
+
+func ext۰reflect۰Value۰Float(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) float64
+	switch v := rV2V(args[0]).(type) {
+	case float32:
+		return float64(v)
+	case float64:
+		return float64(v)
+	}
+	panic("reflect.Value.Float")
+}
+
+func ext۰reflect۰Value۰Interface(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value) interface{}
+	return ext۰reflect۰valueInterface(fr, args)
+}
+
+func ext۰reflect۰Value۰Int(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) int64
+	switch x := rV2V(args[0]).(type) {
+	case int:
+		return int64(x)
+	case int8:
+		return int64(x)
+	case int16:
+		return int64(x)
+	case int32:
+		return int64(x)
+	case int64:
+		return x
+	default:
+		panic(fmt.Sprintf("reflect.(Value).Int(%T)", x))
+	}
+}
+
+func ext۰reflect۰Value۰IsNil(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) bool
+	switch x := rV2V(args[0]).(type) {
+	case *value:
+		return x == nil
+	case chan value:
+		return x == nil
+	case map[value]value:
+		return x == nil
+	case *hashmap:
+		return x == nil
+	case iface:
+		return x.t == nil
+	case []value:
+		return x == nil
+	case *ssa.Function:
+		return x == nil
+	case *ssa.Builtin:
+		return x == nil
+	case *closure:
+		return x == nil
+	default:
+		panic(fmt.Sprintf("reflect.(Value).IsNil(%T)", x))
+	}
+}
+
+func ext۰reflect۰Value۰IsValid(fr *frame, args []value) value {
+	// Signature: func (reflect.Value) bool
+	return rV2V(args[0]) != nil
+}
+
+func ext۰reflect۰Value۰Set(fr *frame, args []value) value {
+	// TODO(adonovan): implement.
+	return nil
+}
+
+func ext۰reflect۰valueInterface(fr *frame, args []value) value {
+	// Signature: func (v reflect.Value, safe bool) interface{}
+	v := args[0].(structure)
+	return iface{rV2T(v).t, rV2V(v)}
+}
+
+func ext۰reflect۰error۰Error(fr *frame, args []value) value {
+	return args[0]
+}
+
+// newMethod creates a new method of the specified name, package and receiver type.
+func newMethod(pkg *ssa.Package, recvType types.Type, name string) *ssa.Function {
+	// TODO(adonovan): fix: hack: currently the only part of Signature
+	// that is needed is the "pointerness" of Recv.Type, and for
+	// now, we'll set it to always be false since we're only
+	// concerned with rtype.  Encapsulate this better.
+	sig := types.NewSignature(types.NewVar(token.NoPos, nil, "recv", recvType), nil, nil, false)
+	fn := pkg.Prog.NewFunction(name, sig, "fake reflect method")
+	fn.Pkg = pkg
+	return fn
+}
+
+func initReflect(i *interpreter) {
+	i.reflectPackage = &ssa.Package{
+		Prog:    i.prog,
+		Pkg:     reflectTypesPackage,
+		Members: make(map[string]ssa.Member),
+	}
+
+	// Clobber the type-checker's notion of reflect.Value's
+	// underlying type so that it more closely matches the fake one
+	// (at least in the number of fields---we lie about the type of
+	// the rtype field).
+	//
+	// We must ensure that calls to (ssa.Value).Type() return the
+	// fake type so that correct "shape" is used when allocating
+	// variables, making zero values, loading, and storing.
+	//
+	// TODO(adonovan): obviously this is a hack.  We need a cleaner
+	// way to fake the reflect package (almost---DeepEqual is fine).
+	// One approach would be not to even load its source code, but
+	// provide fake source files.  This would guarantee that no bad
+	// information leaks into other packages.
+	if r := i.prog.ImportedPackage("reflect"); r != nil {
+		rV := r.Pkg.Scope().Lookup("Value").Type().(*types.Named)
+
+		// delete bodies of the old methods
+		mset := i.prog.MethodSets.MethodSet(rV)
+		for j := 0; j < mset.Len(); j++ {
+			i.prog.MethodValue(mset.At(j)).Blocks = nil
+		}
+
+		tEface := types.NewInterface(nil, nil).Complete()
+		rV.SetUnderlying(types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, r.Pkg, "t", tEface, false), // a lie
+			types.NewField(token.NoPos, r.Pkg, "v", tEface, false),
+		}, nil))
+	}
+
+	i.rtypeMethods = methodSet{
+		"Bits":      newMethod(i.reflectPackage, rtypeType, "Bits"),
+		"Elem":      newMethod(i.reflectPackage, rtypeType, "Elem"),
+		"Field":     newMethod(i.reflectPackage, rtypeType, "Field"),
+		"In":        newMethod(i.reflectPackage, rtypeType, "In"),
+		"Kind":      newMethod(i.reflectPackage, rtypeType, "Kind"),
+		"NumField":  newMethod(i.reflectPackage, rtypeType, "NumField"),
+		"NumIn":     newMethod(i.reflectPackage, rtypeType, "NumIn"),
+		"NumMethod": newMethod(i.reflectPackage, rtypeType, "NumMethod"),
+		"NumOut":    newMethod(i.reflectPackage, rtypeType, "NumOut"),
+		"Out":       newMethod(i.reflectPackage, rtypeType, "Out"),
+		"Size":      newMethod(i.reflectPackage, rtypeType, "Size"),
+		"String":    newMethod(i.reflectPackage, rtypeType, "String"),
+	}
+	i.errorMethods = methodSet{
+		"Error": newMethod(i.reflectPackage, errorType, "Error"),
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/a_test.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/a_test.go
new file mode 100644
index 0000000..844ec5c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/a_test.go
@@ -0,0 +1,17 @@
+package a
+
+import "testing"
+
+func TestFoo(t *testing.T) {
+	t.Error("foo")
+}
+
+func TestBar(t *testing.T) {
+	t.Error("bar")
+}
+
+func BenchmarkWiz(b *testing.B) {
+	b.Error("wiz")
+}
+
+// Don't test Examples since that testing package needs pipe(2) for that.
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/b_test.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/b_test.go
new file mode 100644
index 0000000..4a30e96
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/b_test.go
@@ -0,0 +1,11 @@
+package b
+
+import "testing"
+
+func NotATest(t *testing.T) {
+	t.Error("foo")
+}
+
+func NotABenchmark(b *testing.B) {
+	b.Error("wiz")
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/boundmeth.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/boundmeth.go
new file mode 100644
index 0000000..255cc60
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/boundmeth.go
@@ -0,0 +1,144 @@
+// Tests of bound method closures.
+
+package main
+
+import "fmt"
+
+func assert(b bool) {
+	if !b {
+		panic("oops")
+	}
+}
+
+type I int
+
+func (i I) add(x int) int {
+	return int(i) + x
+}
+
+func valueReceiver() {
+	var three I = 3
+	assert(three.add(5) == 8)
+	var add3 func(int) int = three.add
+	assert(add3(5) == 8)
+}
+
+type S struct{ x int }
+
+func (s *S) incr() {
+	s.x++
+}
+
+func (s *S) get() int {
+	return s.x
+}
+
+func pointerReceiver() {
+	ps := new(S)
+	incr := ps.incr
+	get := ps.get
+	assert(get() == 0)
+	incr()
+	incr()
+	incr()
+	assert(get() == 3)
+}
+
+func addressibleValuePointerReceiver() {
+	var s S
+	incr := s.incr
+	get := s.get
+	assert(get() == 0)
+	incr()
+	incr()
+	incr()
+	assert(get() == 3)
+}
+
+type S2 struct {
+	S
+}
+
+func promotedReceiver() {
+	var s2 S2
+	incr := s2.incr
+	get := s2.get
+	assert(get() == 0)
+	incr()
+	incr()
+	incr()
+	assert(get() == 3)
+}
+
+func anonStruct() {
+	var s struct{ S }
+	incr := s.incr
+	get := s.get
+	assert(get() == 0)
+	incr()
+	incr()
+	incr()
+	assert(get() == 3)
+}
+
+func typeCheck() {
+	var i interface{}
+	i = (*S).incr
+	_ = i.(func(*S)) // type assertion: receiver type prepended to params
+
+	var s S
+	i = s.incr
+	_ = i.(func()) // type assertion: receiver type disappears
+}
+
+type errString string
+
+func (err errString) Error() string {
+	return string(err)
+}
+
+// Regression test for a builder crash.
+func regress1(x error) func() string {
+	return x.Error
+}
+
+// Regression test for b/7269:
+// taking the value of an interface method performs a nil check.
+func nilInterfaceMethodValue() {
+	err := fmt.Errorf("ok")
+	f := err.Error
+	if got := f(); got != "ok" {
+		panic(got)
+	}
+
+	err = nil
+	if got := f(); got != "ok" {
+		panic(got)
+	}
+
+	defer func() {
+		r := fmt.Sprint(recover())
+		// runtime panic string varies across toolchains
+		if r != "runtime error: interface conversion: interface is nil, not error" &&
+			r != "runtime error: invalid memory address or nil pointer dereference" {
+			panic("want runtime panic from nil interface method value, got " + r)
+		}
+	}()
+	f = err.Error // runtime panic: err is nil
+	panic("unreachable")
+}
+
+func main() {
+	valueReceiver()
+	pointerReceiver()
+	addressibleValuePointerReceiver()
+	promotedReceiver()
+	anonStruct()
+	typeCheck()
+
+	if e := regress1(errString("hi"))(); e != "hi" {
+		panic(e)
+	}
+
+	nilInterfaceMethodValue()
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/c_test.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/c_test.go
new file mode 100644
index 0000000..ad80b91
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/c_test.go
@@ -0,0 +1,17 @@
+package c_test
+
+import (
+	"os"
+	"testing"
+)
+
+func TestC(t *testing.T) {
+	println("TestC")
+}
+
+func TestMain(m *testing.M) {
+	println("TestMain start")
+	code := m.Run()
+	println("TestMain end")
+	os.Exit(code)
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/callstack.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/callstack.go
new file mode 100644
index 0000000..56f3b28
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/callstack.go
@@ -0,0 +1,52 @@
+package main
+
+import (
+	"fmt"
+	"path"
+	"runtime"
+	"strings"
+)
+
+var stack string
+
+func f() {
+	pc := make([]uintptr, 6)
+	pc = pc[:runtime.Callers(1, pc)]
+	for _, f := range pc {
+		Func := runtime.FuncForPC(f)
+		name := Func.Name()
+		if strings.Contains(name, "$") || strings.Contains(name, ".func") {
+			name = "func" // anon funcs vary across toolchains
+		}
+		file, line := Func.FileLine(0)
+		stack += fmt.Sprintf("%s at %s:%d\n", name, path.Base(file), line)
+	}
+}
+
+func g() { f() }
+func h() { g() }
+func i() { func() { h() }() }
+
+// Hack: the 'func' and the call to Caller are on the same line,
+// to paper over differences between toolchains.
+// (The interpreter's location info isn't yet complete.)
+func runtimeCaller0() (uintptr, string, int, bool) { return runtime.Caller(0) }
+
+func main() {
+	i()
+	if stack != `main.f at callstack.go:12
+main.g at callstack.go:26
+main.h at callstack.go:27
+func at callstack.go:28
+main.i at callstack.go:28
+main.main at callstack.go:35
+` {
+		panic("unexpected stack: " + stack)
+	}
+
+	pc, file, line, _ := runtimeCaller0()
+	got := fmt.Sprintf("%s @ %s:%d", runtime.FuncForPC(pc).Name(), path.Base(file), line)
+	if got != "main.runtimeCaller0 @ callstack.go:33" {
+		panic("runtime.Caller: " + got)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/complit.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/complit.go
new file mode 100644
index 0000000..7bec523
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/complit.go
@@ -0,0 +1,184 @@
+package main
+
+// Tests of composite literals.
+
+import "fmt"
+
+// Map literals.
+func init() {
+	type M map[int]int
+	m1 := []*M{{1: 1}, &M{2: 2}}
+	want := "map[1:1] map[2:2]"
+	if got := fmt.Sprint(*m1[0], *m1[1]); got != want {
+		panic(got)
+	}
+	m2 := []M{{1: 1}, M{2: 2}}
+	if got := fmt.Sprint(m2[0], m2[1]); got != want {
+		panic(got)
+	}
+}
+
+// Nonliteral keys in composite literal.
+func init() {
+	const zero int = 1
+	var v = []int{1 + zero: 42}
+	if x := fmt.Sprint(v); x != "[0 0 42]" {
+		panic(x)
+	}
+}
+
+// Test for in-place initialization.
+func init() {
+	// struct
+	type S struct {
+		a, b int
+	}
+	s := S{1, 2}
+	s = S{b: 3}
+	if s.a != 0 {
+		panic("s.a != 0")
+	}
+	if s.b != 3 {
+		panic("s.b != 3")
+	}
+	s = S{}
+	if s.a != 0 {
+		panic("s.a != 0")
+	}
+	if s.b != 0 {
+		panic("s.b != 0")
+	}
+
+	// array
+	type A [4]int
+	a := A{2, 4, 6, 8}
+	a = A{1: 6, 2: 4}
+	if a[0] != 0 {
+		panic("a[0] != 0")
+	}
+	if a[1] != 6 {
+		panic("a[1] != 6")
+	}
+	if a[2] != 4 {
+		panic("a[2] != 4")
+	}
+	if a[3] != 0 {
+		panic("a[3] != 0")
+	}
+	a = A{}
+	if a[0] != 0 {
+		panic("a[0] != 0")
+	}
+	if a[1] != 0 {
+		panic("a[1] != 0")
+	}
+	if a[2] != 0 {
+		panic("a[2] != 0")
+	}
+	if a[3] != 0 {
+		panic("a[3] != 0")
+	}
+}
+
+// Regression test for https://github.com/golang/go/issues/10127:
+// composite literal clobbers destination before reading from it.
+func init() {
+	// map
+	{
+		type M map[string]int
+		m := M{"x": 1, "y": 2}
+		m = M{"x": m["y"], "y": m["x"]}
+		if m["x"] != 2 || m["y"] != 1 {
+			panic(fmt.Sprint(m))
+		}
+
+		n := M{"x": 3}
+		m, n = M{"x": n["x"]}, M{"x": m["x"]} // parallel assignment
+		if got := fmt.Sprint(m["x"], n["x"]); got != "3 2" {
+			panic(got)
+		}
+	}
+
+	// struct
+	{
+		type T struct{ x, y, z int }
+		t := T{x: 1, y: 2, z: 3}
+
+		t = T{x: t.y, y: t.z, z: t.x} // all fields
+		if got := fmt.Sprint(t); got != "{2 3 1}" {
+			panic(got)
+		}
+
+		t = T{x: t.y, y: t.z + 3} // not all fields
+		if got := fmt.Sprint(t); got != "{3 4 0}" {
+			panic(got)
+		}
+
+		u := T{x: 5, y: 6, z: 7}
+		t, u = T{x: u.x}, T{x: t.x} // parallel assignment
+		if got := fmt.Sprint(t, u); got != "{5 0 0} {3 0 0}" {
+			panic(got)
+		}
+	}
+
+	// array
+	{
+		a := [3]int{0: 1, 1: 2, 2: 3}
+
+		a = [3]int{0: a[1], 1: a[2], 2: a[0]} //  all elements
+		if got := fmt.Sprint(a); got != "[2 3 1]" {
+			panic(got)
+		}
+
+		a = [3]int{0: a[1], 1: a[2] + 3} //  not all elements
+		if got := fmt.Sprint(a); got != "[3 4 0]" {
+			panic(got)
+		}
+
+		b := [3]int{0: 5, 1: 6, 2: 7}
+		a, b = [3]int{0: b[0]}, [3]int{0: a[0]} // parallel assignment
+		if got := fmt.Sprint(a, b); got != "[5 0 0] [3 0 0]" {
+			panic(got)
+		}
+	}
+
+	// slice
+	{
+		s := []int{0: 1, 1: 2, 2: 3}
+
+		s = []int{0: s[1], 1: s[2], 2: s[0]} //  all elements
+		if got := fmt.Sprint(s); got != "[2 3 1]" {
+			panic(got)
+		}
+
+		s = []int{0: s[1], 1: s[2] + 3} //  not all elements
+		if got := fmt.Sprint(s); got != "[3 4]" {
+			panic(got)
+		}
+
+		t := []int{0: 5, 1: 6, 2: 7}
+		s, t = []int{0: t[0]}, []int{0: s[0]} // parallel assignment
+		if got := fmt.Sprint(s, t); got != "[5] [3]" {
+			panic(got)
+		}
+	}
+}
+
+// Regression test for https://github.com/golang/go/issues/13341:
+// within a map literal, if a key expression is a composite literal,
+// Go 1.5 allows its type to be omitted.  An & operation may be implied.
+func init() {
+	type S struct{ x int }
+	// same as map[*S]bool{&S{x: 1}: true}
+	m := map[*S]bool{{x: 1}: true}
+	for s := range m {
+		if s.x != 1 {
+			panic(s) // wrong key
+		}
+		return
+	}
+	panic("map is empty")
+}
+
+func main() {
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/coverage.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/coverage.go
new file mode 100644
index 0000000..37ef95c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/coverage.go
@@ -0,0 +1,534 @@
+// This interpreter test is designed to run very quickly yet provide
+// some coverage of a broad selection of constructs.
+//
+// Validate this file with 'go run' after editing.
+// TODO(adonovan): break this into small files organized by theme.
+
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func init() {
+	// Call of variadic function with (implicit) empty slice.
+	if x := fmt.Sprint(); x != "" {
+		panic(x)
+	}
+}
+
+type empty interface{}
+
+type I interface {
+	f() int
+}
+
+type T struct{ z int }
+
+func (t T) f() int { return t.z }
+
+func use(interface{}) {}
+
+var counter = 2
+
+// Test initialization, including init blocks containing 'return'.
+// Assertion is in main.
+func init() {
+	counter *= 3
+	return
+	counter *= 3
+}
+
+func init() {
+	counter *= 5
+	return
+	counter *= 5
+}
+
+// Recursion.
+func fib(x int) int {
+	if x < 2 {
+		return x
+	}
+	return fib(x-1) + fib(x-2)
+}
+
+func fibgen(ch chan int) {
+	for x := 0; x < 10; x++ {
+		ch <- fib(x)
+	}
+	close(ch)
+}
+
+// Goroutines and channels.
+func init() {
+	ch := make(chan int)
+	go fibgen(ch)
+	var fibs []int
+	for v := range ch {
+		fibs = append(fibs, v)
+		if len(fibs) == 10 {
+			break
+		}
+	}
+	if x := fmt.Sprint(fibs); x != "[0 1 1 2 3 5 8 13 21 34]" {
+		panic(x)
+	}
+}
+
+// Test of aliasing.
+func init() {
+	type S struct {
+		a, b string
+	}
+
+	s1 := []string{"foo", "bar"}
+	s2 := s1 // creates an alias
+	s2[0] = "wiz"
+	if x := fmt.Sprint(s1, s2); x != "[wiz bar] [wiz bar]" {
+		panic(x)
+	}
+
+	pa1 := &[2]string{"foo", "bar"}
+	pa2 := pa1 // creates an alias
+	pa2[0] = "wiz"
+	if x := fmt.Sprint(*pa1, *pa2); x != "[wiz bar] [wiz bar]" {
+		panic(x)
+	}
+
+	a1 := [2]string{"foo", "bar"}
+	a2 := a1 // creates a copy
+	a2[0] = "wiz"
+	if x := fmt.Sprint(a1, a2); x != "[foo bar] [wiz bar]" {
+		panic(x)
+	}
+
+	t1 := S{"foo", "bar"}
+	t2 := t1 // copy
+	t2.a = "wiz"
+	if x := fmt.Sprint(t1, t2); x != "{foo bar} {wiz bar}" {
+		panic(x)
+	}
+}
+
+func main() {
+	print() // legal
+
+	if counter != 2*3*5 {
+		panic(counter)
+	}
+
+	// Test builtins (e.g. complex) preserve named argument types.
+	type N complex128
+	var n N
+	n = complex(1.0, 2.0)
+	if n != complex(1.0, 2.0) {
+		panic(n)
+	}
+	if x := reflect.TypeOf(n).String(); x != "main.N" {
+		panic(x)
+	}
+	if real(n) != 1.0 || imag(n) != 2.0 {
+		panic(n)
+	}
+
+	// Channel + select.
+	ch := make(chan int, 1)
+	select {
+	case ch <- 1:
+		// ok
+	default:
+		panic("couldn't send")
+	}
+	if <-ch != 1 {
+		panic("couldn't receive")
+	}
+	// A "receive" select-case that doesn't declare its vars.  (regression test)
+	anint := 0
+	ok := false
+	select {
+	case anint, ok = <-ch:
+	case anint = <-ch:
+	default:
+	}
+	_ = anint
+	_ = ok
+
+	// Anon structs with methods.
+	anon := struct{ T }{T: T{z: 1}}
+	if x := anon.f(); x != 1 {
+		panic(x)
+	}
+	var i I = anon
+	if x := i.f(); x != 1 {
+		panic(x)
+	}
+	// NB. precise output of reflect.Type.String is undefined.
+	if x := reflect.TypeOf(i).String(); x != "struct { main.T }" && x != "struct{main.T}" {
+		panic(x)
+	}
+
+	// fmt.
+	const message = "Hello, World!"
+	if fmt.Sprintf("%s, %s!", "Hello", "World") != message {
+		panic("oops")
+	}
+
+	// Type assertion.
+	type S struct {
+		f int
+	}
+	var e empty = S{f: 42}
+	switch v := e.(type) {
+	case S:
+		if v.f != 42 {
+			panic(v.f)
+		}
+	default:
+		panic(reflect.TypeOf(v))
+	}
+	if i, ok := e.(I); ok {
+		panic(i)
+	}
+
+	// Switch.
+	var x int
+	switch x {
+	case 1:
+		panic(x)
+		fallthrough
+	case 2, 3:
+		panic(x)
+	default:
+		// ok
+	}
+	// empty switch
+	switch {
+	}
+	// empty switch
+	switch {
+	default:
+	}
+	// empty switch
+	switch {
+	default:
+		fallthrough
+	case false:
+	}
+
+	// string -> []rune conversion.
+	use([]rune("foo"))
+
+	// Calls of form x.f().
+	type S2 struct {
+		f func() int
+	}
+	S2{f: func() int { return 1 }}.f() // field is a func value
+	T{}.f()                            // method call
+	i.f()                              // interface method invocation
+	(interface {
+		f() int
+	}(T{})).f() // anon interface method invocation
+
+	// Map lookup.
+	if v, ok := map[string]string{}["foo5"]; v != "" || ok {
+		panic("oops")
+	}
+
+	// Regression test: implicit address-taken struct literal
+	// inside literal map element.
+	_ = map[int]*struct{}{0: {}}
+}
+
+type mybool bool
+
+func (mybool) f() {}
+
+func init() {
+	type mybool bool
+	var b mybool
+	var i interface{} = b || b // result preserves types of operands
+	_ = i.(mybool)
+
+	i = false && b // result preserves type of "typed" operand
+	_ = i.(mybool)
+
+	i = b || true // result preserves type of "typed" operand
+	_ = i.(mybool)
+}
+
+func init() {
+	var x, y int
+	var b mybool = x == y // x==y is an untyped bool
+	b.f()
+}
+
+// Simple closures.
+func init() {
+	b := 3
+	f := func(a int) int {
+		return a + b
+	}
+	b++
+	if x := f(1); x != 5 { // 1+4 == 5
+		panic(x)
+	}
+	b++
+	if x := f(2); x != 7 { // 2+5 == 7
+		panic(x)
+	}
+	if b := f(1) < 16 || f(2) < 17; !b {
+		panic("oops")
+	}
+}
+
+// Shifts.
+func init() {
+	var i int64 = 1
+	var u uint64 = 1 << 32
+	if x := i << uint32(u); x != 1 {
+		panic(x)
+	}
+	if x := i << uint64(u); x != 0 {
+		panic(x)
+	}
+}
+
+// Implicit conversion of delete() key operand.
+func init() {
+	type I interface{}
+	m := make(map[I]bool)
+	m[1] = true
+	m[I(2)] = true
+	if len(m) != 2 {
+		panic(m)
+	}
+	delete(m, I(1))
+	delete(m, 2)
+	if len(m) != 0 {
+		panic(m)
+	}
+}
+
+// An I->I conversion always succeeds.
+func init() {
+	var x I
+	if I(x) != I(nil) {
+		panic("I->I conversion failed")
+	}
+}
+
+// An I->I type-assert fails iff the value is nil.
+func init() {
+	defer func() {
+		r := fmt.Sprint(recover())
+		// Exact error varies by toolchain.
+		if r != "runtime error: interface conversion: interface is nil, not main.I" &&
+			r != "interface conversion: interface is nil, not main.I" {
+			panic("I->I type assertion succeeded for nil value")
+		}
+	}()
+	var x I
+	_ = x.(I)
+}
+
+//////////////////////////////////////////////////////////////////////
+// Variadic bridge methods and interface thunks.
+
+type VT int
+
+var vcount = 0
+
+func (VT) f(x int, y ...string) {
+	vcount++
+	if x != 1 {
+		panic(x)
+	}
+	if len(y) != 2 || y[0] != "foo" || y[1] != "bar" {
+		panic(y)
+	}
+}
+
+type VS struct {
+	VT
+}
+
+type VI interface {
+	f(x int, y ...string)
+}
+
+func init() {
+	foobar := []string{"foo", "bar"}
+	var s VS
+	s.f(1, "foo", "bar")
+	s.f(1, foobar...)
+	if vcount != 2 {
+		panic("s.f not called twice")
+	}
+
+	fn := VI.f
+	fn(s, 1, "foo", "bar")
+	fn(s, 1, foobar...)
+	if vcount != 4 {
+		panic("I.f not called twice")
+	}
+}
+
+// Multiple labels on same statement.
+func multipleLabels() {
+	var trace []int
+	i := 0
+one:
+two:
+	for ; i < 3; i++ {
+		trace = append(trace, i)
+		switch i {
+		case 0:
+			continue two
+		case 1:
+			i++
+			goto one
+		case 2:
+			break two
+		}
+	}
+	if x := fmt.Sprint(trace); x != "[0 1 2]" {
+		panic(x)
+	}
+}
+
+func init() {
+	multipleLabels()
+}
+
+func init() {
+	// Struct equivalence ignores blank fields.
+	type s struct{ x, _, z int }
+	s1 := s{x: 1, z: 3}
+	s2 := s{x: 1, z: 3}
+	if s1 != s2 {
+		panic("not equal")
+	}
+}
+
+func init() {
+	// A slice var can be compared to const []T nil.
+	var i interface{} = []string{"foo"}
+	var j interface{} = []string(nil)
+	if i.([]string) == nil {
+		panic("expected i non-nil")
+	}
+	if j.([]string) != nil {
+		panic("expected j nil")
+	}
+	// But two slices cannot be compared, even if one is nil.
+	defer func() {
+		r := fmt.Sprint(recover())
+		if r != "runtime error: comparing uncomparable type []string" {
+			panic("want panic from slice comparison, got " + r)
+		}
+	}()
+	_ = i == j // interface comparison recurses on types
+}
+
+func init() {
+	// Regression test for SSA renaming bug.
+	var ints []int
+	for range "foo" {
+		var x int
+		x++
+		ints = append(ints, x)
+	}
+	if fmt.Sprint(ints) != "[1 1 1]" {
+		panic(ints)
+	}
+}
+
+// Regression test for issue 6949:
+// []byte("foo") is not a constant since it allocates memory.
+func init() {
+	var r string
+	for i, b := range "ABC" {
+		x := []byte("abc")
+		x[i] = byte(b)
+		r += string(x)
+	}
+	if r != "AbcaBcabC" {
+		panic(r)
+	}
+}
+
+// Test of 3-operand x[lo:hi:max] slice.
+func init() {
+	s := []int{0, 1, 2, 3}
+	lenCapLoHi := func(x []int) [4]int { return [4]int{len(x), cap(x), x[0], x[len(x)-1]} }
+	if got := lenCapLoHi(s[1:3]); got != [4]int{2, 3, 1, 2} {
+		panic(got)
+	}
+	if got := lenCapLoHi(s[1:3:3]); got != [4]int{2, 2, 1, 2} {
+		panic(got)
+	}
+	max := 3
+	if "a"[0] == 'a' {
+		max = 2 // max is non-constant, even in SSA form
+	}
+	if got := lenCapLoHi(s[1:2:max]); got != [4]int{1, 1, 1, 1} {
+		panic(got)
+	}
+}
+
+var one = 1 // not a constant
+
+// Test makeslice.
+func init() {
+	check := func(s []string, wantLen, wantCap int) {
+		if len(s) != wantLen {
+			panic(len(s))
+		}
+		if cap(s) != wantCap {
+			panic(cap(s))
+		}
+	}
+	//                                       SSA form:
+	check(make([]string, 10), 10, 10)     // new([10]string)[:10]
+	check(make([]string, one), 1, 1)      // make([]string, one, one)
+	check(make([]string, 0, 10), 0, 10)   // new([10]string)[:0]
+	check(make([]string, 0, one), 0, 1)   // make([]string, 0, one)
+	check(make([]string, one, 10), 1, 10) // new([10]string)[:one]
+	check(make([]string, one, one), 1, 1) // make([]string, one, one)
+}
+
+// Test that a nice error is issued by indirection wrappers.
+func init() {
+	var ptr *T
+	var i I = ptr
+
+	defer func() {
+		r := fmt.Sprint(recover())
+		// Exact error varies by toolchain:
+		if r != "runtime error: value method (main.T).f called using nil *main.T pointer" &&
+			r != "value method main.T.f called using nil *T pointer" {
+			panic("want panic from call with nil receiver, got " + r)
+		}
+	}()
+	i.f()
+	panic("unreachable")
+}
+
+// Regression test for a subtle bug in which copying values would causes
+// subcomponents of aggregate variables to change address, breaking
+// aliases.
+func init() {
+	type T struct{ f int }
+	var x T
+	p := &x.f
+	x = T{}
+	*p = 1
+	if x.f != 1 {
+		panic("lost store")
+	}
+	if p != &x.f {
+		panic("unstable address")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/defer.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/defer.go
new file mode 100644
index 0000000..f5bae6c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/defer.go
@@ -0,0 +1,53 @@
+package main
+
+// Tests of defer.  (Deferred recover() belongs is recover.go.)
+
+import "fmt"
+
+func deferMutatesResults(noArgReturn bool) (a, b int) {
+	defer func() {
+		if a != 1 || b != 2 {
+			panic(fmt.Sprint(a, b))
+		}
+		a, b = 3, 4
+	}()
+	if noArgReturn {
+		a, b = 1, 2
+		return
+	}
+	return 1, 2
+}
+
+func init() {
+	a, b := deferMutatesResults(true)
+	if a != 3 || b != 4 {
+		panic(fmt.Sprint(a, b))
+	}
+	a, b = deferMutatesResults(false)
+	if a != 3 || b != 4 {
+		panic(fmt.Sprint(a, b))
+	}
+}
+
+// We concatenate init blocks to make a single function, but we must
+// run defers at the end of each block, not the combined function.
+var deferCount = 0
+
+func init() {
+	deferCount = 1
+	defer func() {
+		deferCount++
+	}()
+	// defer runs HERE
+}
+
+func init() {
+	// Strictly speaking the spec says deferCount may be 0 or 2
+	// since the relative order of init blocks is unspecified.
+	if deferCount != 2 {
+		panic(deferCount) // defer call has not run!
+	}
+}
+
+func main() {
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/fieldprom.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/fieldprom.go
new file mode 100644
index 0000000..fc276dd
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/fieldprom.go
@@ -0,0 +1,114 @@
+package main
+
+// Tests of field promotion logic.
+
+type A struct {
+	x int
+	y *int
+}
+
+type B struct {
+	p int
+	q *int
+}
+
+type C struct {
+	A
+	*B
+}
+
+type D struct {
+	a int
+	C
+}
+
+func assert(cond bool) {
+	if !cond {
+		panic("failed")
+	}
+}
+
+func f1(c C) {
+	assert(c.x == c.A.x)
+	assert(c.y == c.A.y)
+	assert(&c.x == &c.A.x)
+	assert(&c.y == &c.A.y)
+
+	assert(c.p == c.B.p)
+	assert(c.q == c.B.q)
+	assert(&c.p == &c.B.p)
+	assert(&c.q == &c.B.q)
+
+	c.x = 1
+	*c.y = 1
+	c.p = 1
+	*c.q = 1
+}
+
+func f2(c *C) {
+	assert(c.x == c.A.x)
+	assert(c.y == c.A.y)
+	assert(&c.x == &c.A.x)
+	assert(&c.y == &c.A.y)
+
+	assert(c.p == c.B.p)
+	assert(c.q == c.B.q)
+	assert(&c.p == &c.B.p)
+	assert(&c.q == &c.B.q)
+
+	c.x = 1
+	*c.y = 1
+	c.p = 1
+	*c.q = 1
+}
+
+func f3(d D) {
+	assert(d.x == d.C.A.x)
+	assert(d.y == d.C.A.y)
+	assert(&d.x == &d.C.A.x)
+	assert(&d.y == &d.C.A.y)
+
+	assert(d.p == d.C.B.p)
+	assert(d.q == d.C.B.q)
+	assert(&d.p == &d.C.B.p)
+	assert(&d.q == &d.C.B.q)
+
+	d.x = 1
+	*d.y = 1
+	d.p = 1
+	*d.q = 1
+}
+
+func f4(d *D) {
+	assert(d.x == d.C.A.x)
+	assert(d.y == d.C.A.y)
+	assert(&d.x == &d.C.A.x)
+	assert(&d.y == &d.C.A.y)
+
+	assert(d.p == d.C.B.p)
+	assert(d.q == d.C.B.q)
+	assert(&d.p == &d.C.B.p)
+	assert(&d.q == &d.C.B.q)
+
+	d.x = 1
+	*d.y = 1
+	d.p = 1
+	*d.q = 1
+}
+
+func main() {
+	y := 123
+	c := C{
+		A{x: 42, y: &y},
+		&B{p: 42, q: &y},
+	}
+
+	assert(&c.x == &c.A.x)
+
+	f1(c)
+	f2(&c)
+
+	d := D{C: c}
+	f3(d)
+	f4(&d)
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceconv.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceconv.go
new file mode 100644
index 0000000..96fc105
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceconv.go
@@ -0,0 +1,83 @@
+package main
+
+// Tests of interface conversions and type assertions.
+
+type I0 interface {
+}
+type I1 interface {
+	f()
+}
+type I2 interface {
+	f()
+	g()
+}
+
+type C0 struct{}
+type C1 struct{}
+
+func (C1) f() {}
+
+type C2 struct{}
+
+func (C2) f() {}
+func (C2) g() {}
+
+func main() {
+	var i0 I0
+	var i1 I1
+	var i2 I2
+
+	// Nil always causes a type assertion to fail, even to the
+	// same type.
+	if _, ok := i0.(I0); ok {
+		panic("nil i0.(I0) succeeded")
+	}
+	if _, ok := i1.(I1); ok {
+		panic("nil i1.(I1) succeeded")
+	}
+	if _, ok := i2.(I2); ok {
+		panic("nil i2.(I2) succeeded")
+	}
+
+	// Conversions can't fail, even with nil.
+	_ = I0(i0)
+
+	_ = I0(i1)
+	_ = I1(i1)
+
+	_ = I0(i2)
+	_ = I1(i2)
+	_ = I2(i2)
+
+	// Non-nil type assertions pass or fail based on the concrete type.
+	i1 = C1{}
+	if _, ok := i1.(I0); !ok {
+		panic("C1 i1.(I0) failed")
+	}
+	if _, ok := i1.(I1); !ok {
+		panic("C1 i1.(I1) failed")
+	}
+	if _, ok := i1.(I2); ok {
+		panic("C1 i1.(I2) succeeded")
+	}
+
+	i1 = C2{}
+	if _, ok := i1.(I0); !ok {
+		panic("C2 i1.(I0) failed")
+	}
+	if _, ok := i1.(I1); !ok {
+		panic("C2 i1.(I1) failed")
+	}
+	if _, ok := i1.(I2); !ok {
+		panic("C2 i1.(I2) failed")
+	}
+
+	// Conversions can't fail.
+	i1 = C1{}
+	if I0(i1) == nil {
+		panic("C1 I0(i1) was nil")
+	}
+	if I1(i1) == nil {
+		panic("C1 I1(i1) was nil")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceprom.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceprom.go
new file mode 100644
index 0000000..414dc73
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/ifaceprom.go
@@ -0,0 +1,58 @@
+package main
+
+// Test of promotion of methods of an interface embedded within a
+// struct.  In particular, this test exercises that the correct
+// method is called.
+
+type I interface {
+	one() int
+	two() string
+}
+
+type S struct {
+	I
+}
+
+type impl struct{}
+
+func (impl) one() int {
+	return 1
+}
+
+func (impl) two() string {
+	return "two"
+}
+
+func main() {
+	var s S
+	s.I = impl{}
+	if one := s.I.one(); one != 1 {
+		panic(one)
+	}
+	if one := s.one(); one != 1 {
+		panic(one)
+	}
+	closOne := s.I.one
+	if one := closOne(); one != 1 {
+		panic(one)
+	}
+	closOne = s.one
+	if one := closOne(); one != 1 {
+		panic(one)
+	}
+
+	if two := s.I.two(); two != "two" {
+		panic(two)
+	}
+	if two := s.two(); two != "two" {
+		panic(two)
+	}
+	closTwo := s.I.two
+	if two := closTwo(); two != "two" {
+		panic(two)
+	}
+	closTwo = s.two
+	if two := closTwo(); two != "two" {
+		panic(two)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/initorder.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/initorder.go
new file mode 100644
index 0000000..0f26bed
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/initorder.go
@@ -0,0 +1,67 @@
+package main
+
+import "fmt"
+
+// Test of initialization order of package-level vars.
+
+var counter int
+
+func next() int {
+	c := counter
+	counter++
+	return c
+}
+
+func next2() (x int, y int) {
+	x = next()
+	y = next()
+	return
+}
+
+func makeOrder() int {
+	_, _, _, _ = f, b, d, e
+	return 0
+}
+
+func main() {
+	// Initialization constraints:
+	// - {f,b,c/d,e} < order  (ref graph traversal)
+	// - order < {a}          (lexical order)
+	// - b < c/d < e < f      (lexical order)
+	// Solution: a b c/d e f
+	abcdef := [6]int{a, b, c, d, e, f}
+	if abcdef != [6]int{0, 1, 2, 3, 4, 5} {
+		panic(abcdef)
+	}
+}
+
+var order = makeOrder()
+
+var a, b = next(), next()
+var c, d = next2()
+var e, f = next(), next()
+
+// ------------------------------------------------------------------------
+
+var order2 []string
+
+func create(x int, name string) int {
+	order2 = append(order2, name)
+	return x
+}
+
+var C = create(B+1, "C")
+var A, B = create(1, "A"), create(2, "B")
+
+// Initialization order of package-level value specs.
+func init() {
+	x := fmt.Sprint(order2)
+	// Result varies by toolchain.  This is a spec bug.
+	if x != "[B C A]" && // gc
+		x != "[A B C]" { // go/types
+		panic(x)
+	}
+	if C != 3 {
+		panic(c)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/methprom.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/methprom.go
new file mode 100644
index 0000000..e8e384c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/methprom.go
@@ -0,0 +1,93 @@
+package main
+
+// Tests of method promotion logic.
+
+type A struct{ magic int }
+
+func (a A) x() {
+	if a.magic != 1 {
+		panic(a.magic)
+	}
+}
+func (a *A) y() *A {
+	return a
+}
+
+type B struct{ magic int }
+
+func (b B) p() {
+	if b.magic != 2 {
+		panic(b.magic)
+	}
+}
+func (b *B) q() {
+	if b != theC.B {
+		panic("oops")
+	}
+}
+
+type I interface {
+	f()
+}
+
+type impl struct{ magic int }
+
+func (i impl) f() {
+	if i.magic != 3 {
+		panic("oops")
+	}
+}
+
+type C struct {
+	A
+	*B
+	I
+}
+
+func assert(cond bool) {
+	if !cond {
+		panic("failed")
+	}
+}
+
+var theC = C{
+	A: A{1},
+	B: &B{2},
+	I: impl{3},
+}
+
+func addr() *C {
+	return &theC
+}
+
+func value() C {
+	return theC
+}
+
+func main() {
+	// address
+	addr().x()
+	if addr().y() != &theC.A {
+		panic("oops")
+	}
+	addr().p()
+	addr().q()
+	addr().f()
+
+	// addressable value
+	var c C = value()
+	c.x()
+	if c.y() != &c.A {
+		panic("oops")
+	}
+	c.p()
+	c.q()
+	c.f()
+
+	// non-addressable value
+	value().x()
+	// value().y() // not in method set
+	value().p()
+	value().q()
+	value().f()
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/mrvchain.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/mrvchain.go
new file mode 100644
index 0000000..70dfd02
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/mrvchain.go
@@ -0,0 +1,75 @@
+// Tests of call chaining f(g()) when g has multiple return values (MRVs).
+// See https://code.google.com/p/go/issues/detail?id=4573.
+
+package main
+
+func assert(actual, expected int) {
+	if actual != expected {
+		panic(actual)
+	}
+}
+
+func g() (int, int) {
+	return 5, 7
+}
+
+func g2() (float64, float64) {
+	return 5, 7
+}
+
+func f1v(x int, v ...int) {
+	assert(x, 5)
+	assert(v[0], 7)
+}
+
+func f2(x, y int) {
+	assert(x, 5)
+	assert(y, 7)
+}
+
+func f2v(x, y int, v ...int) {
+	assert(x, 5)
+	assert(y, 7)
+	assert(len(v), 0)
+}
+
+func complexArgs() (float64, float64) {
+	return 5, 7
+}
+
+func appendArgs() ([]string, string) {
+	return []string{"foo"}, "bar"
+}
+
+func h() (i interface{}, ok bool) {
+	m := map[int]string{1: "hi"}
+	i, ok = m[1] // string->interface{} conversion within multi-valued expression
+	return
+}
+
+func h2() (i interface{}, ok bool) {
+	ch := make(chan string, 1)
+	ch <- "hi"
+	i, ok = <-ch // string->interface{} conversion within multi-valued expression
+	return
+}
+
+func main() {
+	f1v(g())
+	f2(g())
+	f2v(g())
+	if c := complex(complexArgs()); c != 5+7i {
+		panic(c)
+	}
+	if s := append(appendArgs()); len(s) != 2 || s[0] != "foo" || s[1] != "bar" {
+		panic(s)
+	}
+	i, ok := h()
+	if !ok || i.(string) != "hi" {
+		panic(i)
+	}
+	i, ok = h2()
+	if !ok || i.(string) != "hi" {
+		panic(i)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/range.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/range.go
new file mode 100644
index 0000000..da8a421
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/range.go
@@ -0,0 +1,55 @@
+package main
+
+// Tests of range loops.
+
+import "fmt"
+
+// Range over string.
+func init() {
+	if x := len("Hello, 世界"); x != 13 { // bytes
+		panic(x)
+	}
+	var indices []int
+	var runes []rune
+	for i, r := range "Hello, 世界" {
+		runes = append(runes, r)
+		indices = append(indices, i)
+	}
+	if x := fmt.Sprint(runes); x != "[72 101 108 108 111 44 32 19990 30028]" {
+		panic(x)
+	}
+	if x := fmt.Sprint(indices); x != "[0 1 2 3 4 5 6 7 10]" {
+		panic(x)
+	}
+	s := ""
+	for _, r := range runes {
+		s = fmt.Sprintf("%s%c", s, r)
+	}
+	if s != "Hello, 世界" {
+		panic(s)
+	}
+
+	var x int
+	for range "Hello, 世界" {
+		x++
+	}
+	if x != len(indices) {
+		panic(x)
+	}
+}
+
+// Regression test for range of pointer to named array type.
+func init() {
+	type intarr [3]int
+	ia := intarr{1, 2, 3}
+	var count int
+	for _, x := range &ia {
+		count += x
+	}
+	if count != 6 {
+		panic(count)
+	}
+}
+
+func main() {
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/recover.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/recover.go
new file mode 100644
index 0000000..b560052
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/recover.go
@@ -0,0 +1,34 @@
+package main
+
+// Tests of panic/recover.
+
+import "fmt"
+
+func fortyTwo() (r int) {
+	r = 42
+	// The next two statements simulate a 'return' statement.
+	defer func() { recover() }()
+	panic(nil)
+}
+
+func zero() int {
+	defer func() { recover() }()
+	panic(1)
+}
+
+func zeroEmpty() (int, string) {
+	defer func() { recover() }()
+	panic(1)
+}
+
+func main() {
+	if r := fortyTwo(); r != 42 {
+		panic(r)
+	}
+	if r := zero(); r != 0 {
+		panic(r)
+	}
+	if r, s := zeroEmpty(); r != 0 || s != "" {
+		panic(fmt.Sprint(r, s))
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/reflect.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/reflect.go
new file mode 100644
index 0000000..6aa9a67
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/reflect.go
@@ -0,0 +1,11 @@
+package main
+
+import "reflect"
+
+func main() {
+	// Regression test for issue 9462.
+	got := reflect.SliceOf(reflect.TypeOf(byte(0))).String()
+	if got != "[]uint8" && got != "[]byte" { // result varies by toolchain
+		println("BUG: " + got)
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/testdata/static.go b/vendor/golang.org/x/tools/go/ssa/interp/testdata/static.go
new file mode 100644
index 0000000..b115513
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/testdata/static.go
@@ -0,0 +1,58 @@
+package main
+
+// Static tests of SSA builder (via the sanity checker).
+// Dynamic semantics are not exercised.
+
+func init() {
+	// Regression test for issue 6806.
+	ch := make(chan int)
+	select {
+	case n, _ := <-ch:
+		_ = n
+	default:
+		// The default case disables the simplification of
+		// select to a simple receive statement.
+	}
+
+	// value,ok-form receive where TypeOf(ok) is a named boolean.
+	type mybool bool
+	var x int
+	var y mybool
+	select {
+	case x, y = <-ch:
+	default:
+		// The default case disables the simplification of
+		// select to a simple receive statement.
+	}
+	_ = x
+	_ = y
+}
+
+var a int
+
+// Regression test for issue 7840 (covered by SSA sanity checker).
+func bug7840() bool {
+	// This creates a single-predecessor block with a φ-node.
+	return false && a == 0 && a == 0
+}
+
+// A blocking select (sans "default:") cannot fall through.
+// Regression test for issue 7022.
+func bug7022() int {
+	var c1, c2 chan int
+	select {
+	case <-c1:
+		return 123
+	case <-c2:
+		return 456
+	}
+}
+
+// Parens should not prevent intrinsic treatment of built-ins.
+// (Regression test for a crash.)
+func init() {
+	_ = (new)(int)
+	_ = (make)([]int, 0)
+}
+
+func main() {}
diff --git a/vendor/golang.org/x/tools/go/ssa/interp/value.go b/vendor/golang.org/x/tools/go/ssa/interp/value.go
new file mode 100644
index 0000000..4faa7b8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/interp/value.go
@@ -0,0 +1,497 @@
+// 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 interp
+
+// Values
+//
+// All interpreter values are "boxed" in the empty interface, value.
+// The range of possible dynamic types within value are:
+//
+// - bool
+// - numbers (all built-in int/float/complex types are distinguished)
+// - string
+// - map[value]value --- maps for which  usesBuiltinMap(keyType)
+//   *hashmap        --- maps for which !usesBuiltinMap(keyType)
+// - chan value
+// - []value --- slices
+// - iface --- interfaces.
+// - structure --- structs.  Fields are ordered and accessed by numeric indices.
+// - array --- arrays.
+// - *value --- pointers.  Careful: *value is a distinct type from *array etc.
+// - *ssa.Function \
+//   *ssa.Builtin   } --- functions.  A nil 'func' is always of type *ssa.Function.
+//   *closure      /
+// - tuple --- as returned by Return, Next, "value,ok" modes, etc.
+// - iter --- iterators from 'range' over map or string.
+// - bad --- a poison pill for locals that have gone out of scope.
+// - rtype -- the interpreter's concrete implementation of reflect.Type
+//
+// Note that nil is not on this list.
+//
+// Pay close attention to whether or not the dynamic type is a pointer.
+// The compiler cannot help you since value is an empty interface.
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"io"
+	"reflect"
+	"strings"
+	"sync"
+	"unsafe"
+
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+type value interface{}
+
+type tuple []value
+
+type array []value
+
+type iface struct {
+	t types.Type // never an "untyped" type
+	v value
+}
+
+type structure []value
+
+// For map, array, *array, slice, string or channel.
+type iter interface {
+	// next returns a Tuple (key, value, ok).
+	// key and value are unaliased, e.g. copies of the sequence element.
+	next() tuple
+}
+
+type closure struct {
+	Fn  *ssa.Function
+	Env []value
+}
+
+type bad struct{}
+
+type rtype struct {
+	t types.Type
+}
+
+// Hash functions and equivalence relation:
+
+// hashString computes the FNV hash of s.
+func hashString(s string) int {
+	var h uint32
+	for i := 0; i < len(s); i++ {
+		h ^= uint32(s[i])
+		h *= 16777619
+	}
+	return int(h)
+}
+
+var (
+	mu     sync.Mutex
+	hasher = typeutil.MakeHasher()
+)
+
+// hashType returns a hash for t such that
+// types.Identical(x, y) => hashType(x) == hashType(y).
+func hashType(t types.Type) int {
+	mu.Lock()
+	h := int(hasher.Hash(t))
+	mu.Unlock()
+	return h
+}
+
+// usesBuiltinMap returns true if the built-in hash function and
+// equivalence relation for type t are consistent with those of the
+// interpreter's representation of type t.  Such types are: all basic
+// types (bool, numbers, string), pointers and channels.
+//
+// usesBuiltinMap returns false for types that require a custom map
+// implementation: interfaces, arrays and structs.
+//
+// Panic ensues if t is an invalid map key type: function, map or slice.
+func usesBuiltinMap(t types.Type) bool {
+	switch t := t.(type) {
+	case *types.Basic, *types.Chan, *types.Pointer:
+		return true
+	case *types.Named:
+		return usesBuiltinMap(t.Underlying())
+	case *types.Interface, *types.Array, *types.Struct:
+		return false
+	}
+	panic(fmt.Sprintf("invalid map key type: %T", t))
+}
+
+func (x array) eq(t types.Type, _y interface{}) bool {
+	y := _y.(array)
+	tElt := t.Underlying().(*types.Array).Elem()
+	for i, xi := range x {
+		if !equals(tElt, xi, y[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (x array) hash(t types.Type) int {
+	h := 0
+	tElt := t.Underlying().(*types.Array).Elem()
+	for _, xi := range x {
+		h += hash(tElt, xi)
+	}
+	return h
+}
+
+func (x structure) eq(t types.Type, _y interface{}) bool {
+	y := _y.(structure)
+	tStruct := t.Underlying().(*types.Struct)
+	for i, n := 0, tStruct.NumFields(); i < n; i++ {
+		if f := tStruct.Field(i); !f.Anonymous() {
+			if !equals(f.Type(), x[i], y[i]) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (x structure) hash(t types.Type) int {
+	tStruct := t.Underlying().(*types.Struct)
+	h := 0
+	for i, n := 0, tStruct.NumFields(); i < n; i++ {
+		if f := tStruct.Field(i); !f.Anonymous() {
+			h += hash(f.Type(), x[i])
+		}
+	}
+	return h
+}
+
+// nil-tolerant variant of types.Identical.
+func sameType(x, y types.Type) bool {
+	if x == nil {
+		return y == nil
+	}
+	return y != nil && types.Identical(x, y)
+}
+
+func (x iface) eq(t types.Type, _y interface{}) bool {
+	y := _y.(iface)
+	return sameType(x.t, y.t) && (x.t == nil || equals(x.t, x.v, y.v))
+}
+
+func (x iface) hash(_ types.Type) int {
+	return hashType(x.t)*8581 + hash(x.t, x.v)
+}
+
+func (x rtype) hash(_ types.Type) int {
+	return hashType(x.t)
+}
+
+func (x rtype) eq(_ types.Type, y interface{}) bool {
+	return types.Identical(x.t, y.(rtype).t)
+}
+
+// equals returns true iff x and y are equal according to Go's
+// linguistic equivalence relation for type t.
+// In a well-typed program, the dynamic types of x and y are
+// guaranteed equal.
+func equals(t types.Type, x, y value) bool {
+	switch x := x.(type) {
+	case bool:
+		return x == y.(bool)
+	case int:
+		return x == y.(int)
+	case int8:
+		return x == y.(int8)
+	case int16:
+		return x == y.(int16)
+	case int32:
+		return x == y.(int32)
+	case int64:
+		return x == y.(int64)
+	case uint:
+		return x == y.(uint)
+	case uint8:
+		return x == y.(uint8)
+	case uint16:
+		return x == y.(uint16)
+	case uint32:
+		return x == y.(uint32)
+	case uint64:
+		return x == y.(uint64)
+	case uintptr:
+		return x == y.(uintptr)
+	case float32:
+		return x == y.(float32)
+	case float64:
+		return x == y.(float64)
+	case complex64:
+		return x == y.(complex64)
+	case complex128:
+		return x == y.(complex128)
+	case string:
+		return x == y.(string)
+	case *value:
+		return x == y.(*value)
+	case chan value:
+		return x == y.(chan value)
+	case structure:
+		return x.eq(t, y)
+	case array:
+		return x.eq(t, y)
+	case iface:
+		return x.eq(t, y)
+	case rtype:
+		return x.eq(t, y)
+	}
+
+	// Since map, func and slice don't support comparison, this
+	// case is only reachable if one of x or y is literally nil
+	// (handled in eqnil) or via interface{} values.
+	panic(fmt.Sprintf("comparing uncomparable type %s", t))
+}
+
+// Returns an integer hash of x such that equals(x, y) => hash(x) == hash(y).
+func hash(t types.Type, x value) int {
+	switch x := x.(type) {
+	case bool:
+		if x {
+			return 1
+		}
+		return 0
+	case int:
+		return x
+	case int8:
+		return int(x)
+	case int16:
+		return int(x)
+	case int32:
+		return int(x)
+	case int64:
+		return int(x)
+	case uint:
+		return int(x)
+	case uint8:
+		return int(x)
+	case uint16:
+		return int(x)
+	case uint32:
+		return int(x)
+	case uint64:
+		return int(x)
+	case uintptr:
+		return int(x)
+	case float32:
+		return int(x)
+	case float64:
+		return int(x)
+	case complex64:
+		return int(real(x))
+	case complex128:
+		return int(real(x))
+	case string:
+		return hashString(x)
+	case *value:
+		return int(uintptr(unsafe.Pointer(x)))
+	case chan value:
+		return int(uintptr(reflect.ValueOf(x).Pointer()))
+	case structure:
+		return x.hash(t)
+	case array:
+		return x.hash(t)
+	case iface:
+		return x.hash(t)
+	case rtype:
+		return x.hash(t)
+	}
+	panic(fmt.Sprintf("%T is unhashable", x))
+}
+
+// reflect.Value struct values don't have a fixed shape, since the
+// payload can be a scalar or an aggregate depending on the instance.
+// So store (and load) can't simply use recursion over the shape of the
+// rhs value, or the lhs, to copy the value; we need the static type
+// information.  (We can't make reflect.Value a new basic data type
+// because its "structness" is exposed to Go programs.)
+
+// load returns the value of type T in *addr.
+func load(T types.Type, addr *value) value {
+	switch T := T.Underlying().(type) {
+	case *types.Struct:
+		v := (*addr).(structure)
+		a := make(structure, len(v))
+		for i := range a {
+			a[i] = load(T.Field(i).Type(), &v[i])
+		}
+		return a
+	case *types.Array:
+		v := (*addr).(array)
+		a := make(array, len(v))
+		for i := range a {
+			a[i] = load(T.Elem(), &v[i])
+		}
+		return a
+	default:
+		return *addr
+	}
+}
+
+// store stores value v of type T into *addr.
+func store(T types.Type, addr *value, v value) {
+	switch T := T.Underlying().(type) {
+	case *types.Struct:
+		lhs := (*addr).(structure)
+		rhs := v.(structure)
+		for i := range lhs {
+			store(T.Field(i).Type(), &lhs[i], rhs[i])
+		}
+	case *types.Array:
+		lhs := (*addr).(array)
+		rhs := v.(array)
+		for i := range lhs {
+			store(T.Elem(), &lhs[i], rhs[i])
+		}
+	default:
+		*addr = v
+	}
+}
+
+// Prints in the style of built-in println.
+// (More or less; in gc println is actually a compiler intrinsic and
+// can distinguish println(1) from println(interface{}(1)).)
+func writeValue(buf *bytes.Buffer, v value) {
+	switch v := v.(type) {
+	case nil, bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128, string:
+		fmt.Fprintf(buf, "%v", v)
+
+	case map[value]value:
+		buf.WriteString("map[")
+		sep := ""
+		for k, e := range v {
+			buf.WriteString(sep)
+			sep = " "
+			writeValue(buf, k)
+			buf.WriteString(":")
+			writeValue(buf, e)
+		}
+		buf.WriteString("]")
+
+	case *hashmap:
+		buf.WriteString("map[")
+		sep := " "
+		for _, e := range v.entries() {
+			for e != nil {
+				buf.WriteString(sep)
+				sep = " "
+				writeValue(buf, e.key)
+				buf.WriteString(":")
+				writeValue(buf, e.value)
+				e = e.next
+			}
+		}
+		buf.WriteString("]")
+
+	case chan value:
+		fmt.Fprintf(buf, "%v", v) // (an address)
+
+	case *value:
+		if v == nil {
+			buf.WriteString("<nil>")
+		} else {
+			fmt.Fprintf(buf, "%p", v)
+		}
+
+	case iface:
+		fmt.Fprintf(buf, "(%s, ", v.t)
+		writeValue(buf, v.v)
+		buf.WriteString(")")
+
+	case structure:
+		buf.WriteString("{")
+		for i, e := range v {
+			if i > 0 {
+				buf.WriteString(" ")
+			}
+			writeValue(buf, e)
+		}
+		buf.WriteString("}")
+
+	case array:
+		buf.WriteString("[")
+		for i, e := range v {
+			if i > 0 {
+				buf.WriteString(" ")
+			}
+			writeValue(buf, e)
+		}
+		buf.WriteString("]")
+
+	case []value:
+		buf.WriteString("[")
+		for i, e := range v {
+			if i > 0 {
+				buf.WriteString(" ")
+			}
+			writeValue(buf, e)
+		}
+		buf.WriteString("]")
+
+	case *ssa.Function, *ssa.Builtin, *closure:
+		fmt.Fprintf(buf, "%p", v) // (an address)
+
+	case rtype:
+		buf.WriteString(v.t.String())
+
+	case tuple:
+		// Unreachable in well-formed Go programs
+		buf.WriteString("(")
+		for i, e := range v {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			writeValue(buf, e)
+		}
+		buf.WriteString(")")
+
+	default:
+		fmt.Fprintf(buf, "<%T>", v)
+	}
+}
+
+// Implements printing of Go values in the style of built-in println.
+func toString(v value) string {
+	var b bytes.Buffer
+	writeValue(&b, v)
+	return b.String()
+}
+
+// ------------------------------------------------------------------------
+// Iterators
+
+type stringIter struct {
+	*strings.Reader
+	i int
+}
+
+func (it *stringIter) next() tuple {
+	okv := make(tuple, 3)
+	ch, n, err := it.ReadRune()
+	ok := err != io.EOF
+	okv[0] = ok
+	if ok {
+		okv[1] = it.i
+		okv[2] = ch
+	}
+	it.i += n
+	return okv
+}
+
+type mapIter chan [2]value
+
+func (it mapIter) next() tuple {
+	kv, ok := <-it
+	return tuple{ok, kv[0], kv[1]}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/lift.go b/vendor/golang.org/x/tools/go/ssa/lift.go
index 3771f61..048e9b0 100644
--- a/vendor/golang.org/x/tools/go/ssa/lift.go
+++ b/vendor/golang.org/x/tools/go/ssa/lift.go
@@ -36,22 +36,18 @@ package ssa
 // Consider exploiting liveness information to avoid creating dead
 // φ-nodes which we then immediately remove.
 //
-// Integrate lifting with scalar replacement of aggregates (SRA) since
-// the two are synergistic.
-//
 // Also see many other "TODO: opt" suggestions in the code.
 
 import (
 	"fmt"
 	"go/token"
+	"go/types"
 	"math/big"
 	"os"
-
-	"golang.org/x/tools/go/types"
 )
 
-// If true, perform sanity checking and show diagnostic information at
-// each step of lifting.  Very verbose.
+// 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
@@ -123,7 +119,7 @@ func removeInstr(refs []Instruction, instr Instruction) []Instruction {
 	return refs[:i]
 }
 
-// lift attempts to replace local and new Allocs accessed only with
+// 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.
 //
@@ -179,6 +175,11 @@ func lift(fn *Function) {
 	// 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
@@ -189,7 +190,7 @@ func lift(fn *Function) {
 			switch instr := instr.(type) {
 			case *Alloc:
 				index := -1
-				if liftAlloc(df, instr, newPhis) {
+				if liftAlloc(df, instr, newPhis, &fresh) {
 					index = numAllocs
 					numAllocs++
 				}
@@ -212,29 +213,13 @@ func lift(fn *Function) {
 	// Renaming.
 	rename(fn.Blocks[0], renaming, newPhis)
 
-	// Eliminate dead new phis, then prepend the live ones to each block.
-	for _, b := range fn.Blocks {
+	// Eliminate dead φ-nodes.
+	removeDeadPhis(fn.Blocks, newPhis)
 
-		// Compress the newPhis slice to eliminate unused phis.
-		// TODO(adonovan): opt: compute liveness to avoid
-		// placing phis in blocks for which the alloc cell is
-		// not live.
+	// Prepend remaining live φ-nodes to each block.
+	for _, b := range fn.Blocks {
 		nps := newPhis[b]
-		j := 0
-		for _, np := range nps {
-			if !phiIsLive(np.phi) {
-				// discard it, first removing it from referrers
-				for _, newval := range np.phi.Edges {
-					if refs := newval.Referrers(); refs != nil {
-						*refs = removeInstr(*refs, np.phi)
-					}
-				}
-				continue
-			}
-			nps[j] = np
-			j++
-		}
-		nps = nps[:j]
+		j := len(nps)
 
 		rundefersToKill := b.rundefers
 		if usesDefer {
@@ -246,8 +231,8 @@ func lift(fn *Function) {
 		}
 
 		// Compact nps + non-nil Instrs into a new slice.
-		// TODO(adonovan): opt: compact in situ if there is
-		// sufficient space or slack in the 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
@@ -264,9 +249,6 @@ func lift(fn *Function) {
 			dst[j] = instr
 			j++
 		}
-		for i, np := range nps {
-			dst[i] = np.phi
-		}
 		b.Instrs = dst
 	}
 
@@ -285,15 +267,76 @@ func lift(fn *Function) {
 	fn.Locals = fn.Locals[:j]
 }
 
-func phiIsLive(phi *Phi) bool {
+// 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 instr == phi {
-			continue // self-refs don't count
+		if _, ok := instr.(*Phi); !ok {
+			return true
 		}
-		if _, ok := instr.(*DebugRef); ok {
-			continue // debug refs don't count
-		}
-		return true
 	}
 	return false
 }
@@ -338,7 +381,9 @@ type newPhiMap map[*BasicBlock][]newPhi
 // and if so, it populates newPhis with all the φ-nodes it may require
 // and returns true.
 //
-func liftAlloc(df domFrontier, alloc *Alloc, newPhis newPhiMap) bool {
+// 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) {
@@ -421,6 +466,10 @@ func liftAlloc(df domFrontier, alloc *Alloc, newPhis newPhiMap) bool {
 					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
@@ -590,10 +639,15 @@ func rename(u *BasicBlock, renaming []Value, newPhis newPhiMap) {
 
 	// Continue depth-first recursion over domtree, pushing a
 	// fresh copy of the renaming map for each subtree.
-	for _, v := range u.dom.children {
-		// TODO(adonovan): opt: avoid copy on final iteration; use destructive update.
-		r := make([]Value, len(renaming))
-		copy(r, renaming)
+	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/vendor/golang.org/x/tools/go/ssa/lvalue.go b/vendor/golang.org/x/tools/go/ssa/lvalue.go
index 4284b1c..4d85be3 100644
--- a/vendor/golang.org/x/tools/go/ssa/lvalue.go
+++ b/vendor/golang.org/x/tools/go/ssa/lvalue.go
@@ -10,8 +10,7 @@ package ssa
 import (
 	"go/ast"
 	"go/token"
-
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
 // An lvalue represents an assignable location that may appear on the
diff --git a/vendor/golang.org/x/tools/go/ssa/methods.go b/vendor/golang.org/x/tools/go/ssa/methods.go
index 12534de..080dca9 100644
--- a/vendor/golang.org/x/tools/go/ssa/methods.go
+++ b/vendor/golang.org/x/tools/go/ssa/methods.go
@@ -8,24 +8,20 @@ package ssa
 
 import (
 	"fmt"
-
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
-// Method returns the Function implementing method sel, building
+// 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.
 //
-// TODO(adonovan): rename this to MethodValue because of the
-// precondition, and for consistency with functions in source.go.
-//
 // Thread-safe.
 //
 // EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
 //
-func (prog *Program) Method(sel *types.Selection) *Function {
+func (prog *Program) MethodValue(sel *types.Selection) *Function {
 	if sel.Kind() != types.MethodVal {
 		panic(fmt.Sprintf("Method(%s) kind != MethodVal", sel))
 	}
@@ -52,7 +48,7 @@ func (prog *Program) LookupMethod(T types.Type, pkg *types.Package, name string)
 	if sel == nil {
 		panic(fmt.Sprintf("%s has no method %s", T, types.Id(pkg, name)))
 	}
-	return prog.Method(sel)
+	return prog.MethodValue(sel)
 }
 
 // methodSet contains the (concrete) methods of a non-interface type.
diff --git a/vendor/golang.org/x/tools/go/ssa/mode.go b/vendor/golang.org/x/tools/go/ssa/mode.go
index bbd613a..d2a2698 100644
--- a/vendor/golang.org/x/tools/go/ssa/mode.go
+++ b/vendor/golang.org/x/tools/go/ssa/mode.go
@@ -8,11 +8,16 @@ package ssa
 
 import (
 	"bytes"
-	"flag"
 	"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 (
@@ -26,7 +31,7 @@ const (
 	BareInits                                    // Build init functions without guards or calls to dependent inits
 )
 
-const modeFlagUsage = `Options controlling the SSA builder.
+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.
@@ -38,20 +43,34 @@ 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.
 `
 
-// BuilderModeFlag creates a new command line flag of type BuilderMode,
-// adds it to the specified flag set, and returns it.
-//
-// Example:
-// 	var ssabuild = BuilderModeFlag(flag.CommandLine, "ssabuild", 0)
-//
-func BuilderModeFlag(set *flag.FlagSet, name string, value BuilderMode) *BuilderMode {
-	set.Var((*builderModeValue)(&value), name, modeFlagUsage)
-	return &value
+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()
 }
 
-type builderModeValue BuilderMode // satisfies flag.Value and flag.Getter.
-
-func (v *builderModeValue) Set(s string) error {
+// 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 {
@@ -73,35 +92,9 @@ func (v *builderModeValue) Set(s string) error {
 			return fmt.Errorf("unknown BuilderMode option: %q", c)
 		}
 	}
-	*v = builderModeValue(mode)
+	*m = mode
 	return nil
 }
 
-func (v *builderModeValue) Get() interface{} { return BuilderMode(*v) }
-
-func (v *builderModeValue) String() string {
-	mode := BuilderMode(*v)
-	var buf bytes.Buffer
-	if mode&GlobalDebug != 0 {
-		buf.WriteByte('D')
-	}
-	if mode&PrintPackages != 0 {
-		buf.WriteByte('P')
-	}
-	if mode&PrintFunctions != 0 {
-		buf.WriteByte('F')
-	}
-	if mode&LogSource != 0 {
-		buf.WriteByte('S')
-	}
-	if mode&SanityCheckFunctions != 0 {
-		buf.WriteByte('C')
-	}
-	if mode&NaiveForm != 0 {
-		buf.WriteByte('N')
-	}
-	if mode&BuildSerially != 0 {
-		buf.WriteByte('L')
-	}
-	return buf.String()
-}
+// Get returns m.
+func (m BuilderMode) Get() interface{} { return m }
diff --git a/vendor/golang.org/x/tools/go/ssa/print.go b/vendor/golang.org/x/tools/go/ssa/print.go
index 88c31f6..3333ba4 100644
--- a/vendor/golang.org/x/tools/go/ssa/print.go
+++ b/vendor/golang.org/x/tools/go/ssa/print.go
@@ -10,11 +10,11 @@ package ssa
 import (
 	"bytes"
 	"fmt"
+	"go/types"
 	"io"
 	"reflect"
 	"sort"
 
-	"golang.org/x/tools/go/types"
 	"golang.org/x/tools/go/types/typeutil"
 )
 
@@ -27,7 +27,7 @@ import (
 func relName(v Value, i Instruction) string {
 	var from *types.Package
 	if i != nil {
-		from = i.Parent().pkgobj()
+		from = i.Parent().pkg()
 	}
 	switch v := v.(type) {
 	case Member: // *Function or *Global
@@ -45,8 +45,8 @@ func relType(t types.Type, from *types.Package) string {
 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 obj := m.Package().Object; obj != nil && obj != from {
-		return fmt.Sprintf("%s.%s", obj.Path(), m.Name())
+	if pkg := m.Package().Pkg; pkg != nil && pkg != from {
+		return fmt.Sprintf("%s.%s", pkg.Path(), m.Name())
 	}
 	return m.Name()
 }
@@ -57,12 +57,12 @@ func relString(m Member, from *types.Package) string {
 // It never appears in disassembly, which uses Value.Name().
 
 func (v *Parameter) String() string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("parameter %s : %s", v.Name(), relType(v.Type(), from))
 }
 
 func (v *FreeVar) String() string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("freevar %s : %s", v.Name(), relType(v.Type(), from))
 }
 
@@ -77,7 +77,7 @@ func (v *Alloc) String() string {
 	if v.Heap {
 		op = "new"
 	}
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("%s %s (%s)", op, relType(deref(v.Type()), from), v.Comment)
 }
 
@@ -89,8 +89,12 @@ func (v *Phi) String() string {
 			b.WriteString(", ")
 		}
 		// Be robust against malformed CFG.
+		if v.block == nil {
+			b.WriteString("??")
+			continue
+		}
 		block := -1
-		if v.block != nil && i < len(v.block.Preds) {
+		if i < len(v.block.Preds) {
 			block = v.block.Preds[i].Index
 		}
 		fmt.Fprintf(&b, "%d: ", block)
@@ -147,7 +151,7 @@ func (v *UnOp) String() string {
 }
 
 func printConv(prefix string, v, x Value) string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("%s %s <- %s (%s)",
 		prefix,
 		relType(v.Type(), from),
@@ -177,7 +181,7 @@ func (v *MakeClosure) String() string {
 }
 
 func (v *MakeSlice) String() string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("make %s %s %s",
 		relType(v.Type(), from),
 		relName(v.Len, v),
@@ -209,12 +213,12 @@ func (v *MakeMap) String() string {
 	if v.Reserve != nil {
 		res = relName(v.Reserve, v)
 	}
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("make %s %s", relType(v.Type(), from), res)
 }
 
 func (v *MakeChan) String() string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("make %s %s", relType(v.Type(), from), relName(v.Size, v))
 }
 
@@ -259,7 +263,7 @@ func (v *Next) String() string {
 }
 
 func (v *TypeAssert) String() string {
-	from := v.Parent().pkgobj()
+	from := v.Parent().pkg()
 	return fmt.Sprintf("typeassert%s %s.(%s)", commaOk(v.CommaOk), relName(v.X, v), relType(v.AssertedType, from))
 }
 
@@ -366,7 +370,7 @@ func (s *DebugRef) String() string {
 }
 
 func (p *Package) String() string {
-	return "package " + p.Object.Path()
+	return "package " + p.Pkg.Path()
 }
 
 var _ io.WriterTo = (*Package)(nil) // *Package implements io.Writer
@@ -391,7 +395,7 @@ func WritePackage(buf *bytes.Buffer, p *Package) {
 		names = append(names, name)
 	}
 
-	from := p.Object
+	from := p.Pkg
 	sort.Strings(names)
 	for _, name := range names {
 		switch mem := p.Members[name].(type) {
diff --git a/vendor/golang.org/x/tools/go/ssa/sanity.go b/vendor/golang.org/x/tools/go/ssa/sanity.go
index b0593d0..0d13beb 100644
--- a/vendor/golang.org/x/tools/go/ssa/sanity.go
+++ b/vendor/golang.org/x/tools/go/ssa/sanity.go
@@ -9,11 +9,10 @@ package ssa
 
 import (
 	"fmt"
+	"go/types"
 	"io"
 	"os"
 	"strings"
-
-	"golang.org/x/tools/go/types"
 )
 
 type sanity struct {
@@ -210,7 +209,7 @@ func (s *sanity) checkInstr(idx int, instr Instruction) {
 	// enclosing Function or Package.
 }
 
-func (s *sanity) checkFinalInstr(idx int, instr Instruction) {
+func (s *sanity) checkFinalInstr(instr Instruction) {
 	switch instr := instr.(type) {
 	case *If:
 		if nsuccs := len(s.block.Succs); nsuccs != 2 {
@@ -325,7 +324,7 @@ func (s *sanity) checkBlock(b *BasicBlock, index int) {
 		if j < n-1 {
 			s.checkInstr(j, instr)
 		} else {
-			s.checkFinalInstr(j, instr)
+			s.checkFinalInstr(instr)
 		}
 
 		// Check Instruction.Operands.
@@ -352,7 +351,9 @@ func (s *sanity) checkBlock(b *BasicBlock, index int) {
 			// 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.Parent() != s.fn {
+				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())
 				}
 			}
@@ -407,8 +408,8 @@ func (s *sanity) checkFunction(fn *Function) bool {
 		s.errorf("nil Prog")
 	}
 
-	fn.String()               // must not crash
-	fn.RelString(fn.pkgobj()) // must not crash
+	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
@@ -484,7 +485,7 @@ func (s *sanity) checkFunction(fn *Function) bool {
 // 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.Object == nil {
+	if pkg.Pkg == nil {
 		panic(fmt.Sprintf("Package %s has no Object", pkg))
 	}
 	pkg.String() // must not crash
@@ -492,7 +493,7 @@ func sanityCheckPackage(pkg *Package) {
 	for name, mem := range pkg.Members {
 		if name != mem.Name() {
 			panic(fmt.Sprintf("%s: %T.Name() = %s, want %s",
-				pkg.Object.Path(), mem, mem.Name(), name))
+				pkg.Pkg.Path(), mem, mem.Name(), name))
 		}
 		obj := mem.Object()
 		if obj == nil {
@@ -510,7 +511,7 @@ func sanityCheckPackage(pkg *Package) {
 				// its types.Func ("init") and its ssa.Function ("init#%d").
 			} else {
 				panic(fmt.Sprintf("%s: %T.Object().Name() = %s, want %s",
-					pkg.Object.Path(), mem, obj.Name(), name))
+					pkg.Pkg.Path(), mem, obj.Name(), name))
 			}
 		}
 		if obj.Pos() != mem.Pos() {
diff --git a/vendor/golang.org/x/tools/go/ssa/source.go b/vendor/golang.org/x/tools/go/ssa/source.go
index 84e6f1d..6d2223e 100644
--- a/vendor/golang.org/x/tools/go/ssa/source.go
+++ b/vendor/golang.org/x/tools/go/ssa/source.go
@@ -13,8 +13,7 @@ package ssa
 import (
 	"go/ast"
 	"go/token"
-
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
 // EnclosingFunction returns the function that contains the syntax
diff --git a/vendor/golang.org/x/tools/go/ssa/source_test.go b/vendor/golang.org/x/tools/go/ssa/source_test.go
new file mode 100644
index 0000000..43051f8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/source_test.go
@@ -0,0 +1,397 @@
+// 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_test
+
+// This file defines tests of source-level debugging utilities.
+
+import (
+	"fmt"
+	"go/ast"
+	exact "go/constant"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+func TestObjValueLookup(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skipf("no testdata directory on %s", runtime.GOOS)
+	}
+
+	conf := loader.Config{ParserMode: parser.ParseComments}
+	f, err := conf.ParseFile("testdata/objlookup.go", nil)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	conf.CreateFromFiles("main", f)
+
+	// Maps each var Ident (represented "name:linenum") to the
+	// kind of ssa.Value we expect (represented "Constant", "&Alloc").
+	expectations := make(map[string]string)
+
+	// Find all annotations of form x::BinOp, &y::Alloc, etc.
+	re := regexp.MustCompile(`(\b|&)?(\w*)::(\w*)\b`)
+	for _, c := range f.Comments {
+		text := c.Text()
+		pos := conf.Fset.Position(c.Pos())
+		for _, m := range re.FindAllStringSubmatch(text, -1) {
+			key := fmt.Sprintf("%s:%d", m[2], pos.Line)
+			value := m[1] + m[3]
+			expectations[key] = value
+		}
+	}
+
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	prog := ssautil.CreateProgram(iprog, 0 /*|ssa.PrintFunctions*/)
+	mainInfo := iprog.Created[0]
+	mainPkg := prog.Package(mainInfo.Pkg)
+	mainPkg.SetDebugMode(true)
+	mainPkg.Build()
+
+	var varIds []*ast.Ident
+	var varObjs []*types.Var
+	for id, obj := range mainInfo.Defs {
+		// Check invariants for func and const objects.
+		switch obj := obj.(type) {
+		case *types.Func:
+			checkFuncValue(t, prog, obj)
+
+		case *types.Const:
+			checkConstValue(t, prog, obj)
+
+		case *types.Var:
+			if id.Name == "_" {
+				continue
+			}
+			varIds = append(varIds, id)
+			varObjs = append(varObjs, obj)
+		}
+	}
+	for id, obj := range mainInfo.Uses {
+		if obj, ok := obj.(*types.Var); ok {
+			varIds = append(varIds, id)
+			varObjs = append(varObjs, obj)
+		}
+	}
+
+	// Check invariants for var objects.
+	// The result varies based on the specific Ident.
+	for i, id := range varIds {
+		obj := varObjs[i]
+		ref, _ := astutil.PathEnclosingInterval(f, id.Pos(), id.Pos())
+		pos := prog.Fset.Position(id.Pos())
+		exp := expectations[fmt.Sprintf("%s:%d", id.Name, pos.Line)]
+		if exp == "" {
+			t.Errorf("%s: no expectation for var ident %s ", pos, id.Name)
+			continue
+		}
+		wantAddr := false
+		if exp[0] == '&' {
+			wantAddr = true
+			exp = exp[1:]
+		}
+		checkVarValue(t, prog, mainPkg, ref, obj, exp, wantAddr)
+	}
+}
+
+func checkFuncValue(t *testing.T, prog *ssa.Program, obj *types.Func) {
+	fn := prog.FuncValue(obj)
+	// fmt.Printf("FuncValue(%s) = %s\n", obj, fn) // debugging
+	if fn == nil {
+		if obj.Name() != "interfaceMethod" {
+			t.Errorf("FuncValue(%s) == nil", obj)
+		}
+		return
+	}
+	if fnobj := fn.Object(); fnobj != obj {
+		t.Errorf("FuncValue(%s).Object() == %s; value was %s",
+			obj, fnobj, fn.Name())
+		return
+	}
+	if !types.Identical(fn.Type(), obj.Type()) {
+		t.Errorf("FuncValue(%s).Type() == %s", obj, fn.Type())
+		return
+	}
+}
+
+func checkConstValue(t *testing.T, prog *ssa.Program, obj *types.Const) {
+	c := prog.ConstValue(obj)
+	// fmt.Printf("ConstValue(%s) = %s\n", obj, c) // debugging
+	if c == nil {
+		t.Errorf("ConstValue(%s) == nil", obj)
+		return
+	}
+	if !types.Identical(c.Type(), obj.Type()) {
+		t.Errorf("ConstValue(%s).Type() == %s", obj, c.Type())
+		return
+	}
+	if obj.Name() != "nil" {
+		if !exact.Compare(c.Value, token.EQL, obj.Val()) {
+			t.Errorf("ConstValue(%s).Value (%s) != %s",
+				obj, c.Value, obj.Val())
+			return
+		}
+	}
+}
+
+func checkVarValue(t *testing.T, prog *ssa.Program, pkg *ssa.Package, ref []ast.Node, obj *types.Var, expKind string, wantAddr bool) {
+	// The prefix of all assertions messages.
+	prefix := fmt.Sprintf("VarValue(%s @ L%d)",
+		obj, prog.Fset.Position(ref[0].Pos()).Line)
+
+	v, gotAddr := prog.VarValue(obj, pkg, ref)
+
+	// Kind is the concrete type of the ssa Value.
+	gotKind := "nil"
+	if v != nil {
+		gotKind = fmt.Sprintf("%T", v)[len("*ssa."):]
+	}
+
+	// fmt.Printf("%s = %v (kind %q; expect %q) wantAddr=%t gotAddr=%t\n", prefix, v, gotKind, expKind, wantAddr, gotAddr) // debugging
+
+	// Check the kinds match.
+	// "nil" indicates expected failure (e.g. optimized away).
+	if expKind != gotKind {
+		t.Errorf("%s concrete type == %s, want %s", prefix, gotKind, expKind)
+	}
+
+	// Check the types match.
+	// If wantAddr, the expected type is the object's address.
+	if v != nil {
+		expType := obj.Type()
+		if wantAddr {
+			expType = types.NewPointer(expType)
+			if !gotAddr {
+				t.Errorf("%s: got value, want address", prefix)
+			}
+		} else if gotAddr {
+			t.Errorf("%s: got address, want value", prefix)
+		}
+		if !types.Identical(v.Type(), expType) {
+			t.Errorf("%s.Type() == %s, want %s", prefix, v.Type(), expType)
+		}
+	}
+}
+
+// Ensure that, in debug mode, we can determine the ssa.Value
+// corresponding to every ast.Expr.
+func TestValueForExpr(t *testing.T) {
+	testValueForExpr(t, "testdata/valueforexpr.go")
+}
+
+func testValueForExpr(t *testing.T, testfile string) {
+	if runtime.GOOS == "android" {
+		t.Skipf("no testdata dir on %s", runtime.GOOS)
+	}
+
+	conf := loader.Config{ParserMode: parser.ParseComments}
+	f, err := conf.ParseFile(testfile, nil)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	conf.CreateFromFiles("main", f)
+
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	mainInfo := iprog.Created[0]
+
+	prog := ssautil.CreateProgram(iprog, 0)
+	mainPkg := prog.Package(mainInfo.Pkg)
+	mainPkg.SetDebugMode(true)
+	mainPkg.Build()
+
+	if false {
+		// debugging
+		for _, mem := range mainPkg.Members {
+			if fn, ok := mem.(*ssa.Function); ok {
+				fn.WriteTo(os.Stderr)
+			}
+		}
+	}
+
+	// Find the actual AST node for each canonical position.
+	parenExprByPos := make(map[token.Pos]*ast.ParenExpr)
+	ast.Inspect(f, func(n ast.Node) bool {
+		if n != nil {
+			if e, ok := n.(*ast.ParenExpr); ok {
+				parenExprByPos[e.Pos()] = e
+			}
+		}
+		return true
+	})
+
+	// Find all annotations of form /*@kind*/.
+	for _, c := range f.Comments {
+		text := strings.TrimSpace(c.Text())
+		if text == "" || text[0] != '@' {
+			continue
+		}
+		text = text[1:]
+		pos := c.End() + 1
+		position := prog.Fset.Position(pos)
+		var e ast.Expr
+		if target := parenExprByPos[pos]; target == nil {
+			t.Errorf("%s: annotation doesn't precede ParenExpr: %q", position, text)
+			continue
+		} else {
+			e = target.X
+		}
+
+		path, _ := astutil.PathEnclosingInterval(f, pos, pos)
+		if path == nil {
+			t.Errorf("%s: can't find AST path from root to comment: %s", position, text)
+			continue
+		}
+
+		fn := ssa.EnclosingFunction(mainPkg, path)
+		if fn == nil {
+			t.Errorf("%s: can't find enclosing function", position)
+			continue
+		}
+
+		v, gotAddr := fn.ValueForExpr(e) // (may be nil)
+		got := strings.TrimPrefix(fmt.Sprintf("%T", v), "*ssa.")
+		if want := text; got != want {
+			t.Errorf("%s: got value %q, want %q", position, got, want)
+		}
+		if v != nil {
+			T := v.Type()
+			if gotAddr {
+				T = T.Underlying().(*types.Pointer).Elem() // deref
+			}
+			if !types.Identical(T, mainInfo.TypeOf(e)) {
+				t.Errorf("%s: got type %s, want %s", position, mainInfo.TypeOf(e), T)
+			}
+		}
+	}
+}
+
+// findInterval parses input and returns the [start, end) positions of
+// the first occurrence of substr in input.  f==nil indicates failure;
+// an error has already been reported in that case.
+//
+func findInterval(t *testing.T, fset *token.FileSet, input, substr string) (f *ast.File, start, end token.Pos) {
+	f, err := parser.ParseFile(fset, "<input>", input, 0)
+	if err != nil {
+		t.Errorf("parse error: %s", err)
+		return
+	}
+
+	i := strings.Index(input, substr)
+	if i < 0 {
+		t.Errorf("%q is not a substring of input", substr)
+		f = nil
+		return
+	}
+
+	filePos := fset.File(f.Package)
+	return f, filePos.Pos(i), filePos.Pos(i + len(substr))
+}
+
+func TestEnclosingFunction(t *testing.T) {
+	tests := []struct {
+		input  string // the input file
+		substr string // first occurrence of this string denotes interval
+		fn     string // name of expected containing function
+	}{
+		// We use distinctive numbers as syntactic landmarks.
+
+		// Ordinary function:
+		{`package main
+		  func f() { println(1003) }`,
+			"100", "main.f"},
+		// Methods:
+		{`package main
+                  type T int
+		  func (t T) f() { println(200) }`,
+			"200", "(main.T).f"},
+		// Function literal:
+		{`package main
+		  func f() { println(func() { print(300) }) }`,
+			"300", "main.f$1"},
+		// Doubly nested
+		{`package main
+		  func f() { println(func() { print(func() { print(350) })})}`,
+			"350", "main.f$1$1"},
+		// Implicit init for package-level var initializer.
+		{"package main; var a = 400", "400", "main.init"},
+		// No code for constants:
+		{"package main; const a = 500", "500", "(none)"},
+		// Explicit init()
+		{"package main; func init() { println(600) }", "600", "main.init#1"},
+		// Multiple explicit init functions:
+		{`package main
+		  func init() { println("foo") }
+		  func init() { println(800) }`,
+			"800", "main.init#2"},
+		// init() containing FuncLit.
+		{`package main
+		  func init() { println(func(){print(900)}) }`,
+			"900", "main.init#1$1"},
+	}
+	for _, test := range tests {
+		conf := loader.Config{Fset: token.NewFileSet()}
+		f, start, end := findInterval(t, conf.Fset, test.input, test.substr)
+		if f == nil {
+			continue
+		}
+		path, exact := astutil.PathEnclosingInterval(f, start, end)
+		if !exact {
+			t.Errorf("EnclosingFunction(%q) not exact", test.substr)
+			continue
+		}
+
+		conf.CreateFromFiles("main", f)
+
+		iprog, err := conf.Load()
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		prog := ssautil.CreateProgram(iprog, 0)
+		pkg := prog.Package(iprog.Created[0].Pkg)
+		pkg.Build()
+
+		name := "(none)"
+		fn := ssa.EnclosingFunction(pkg, path)
+		if fn != nil {
+			name = fn.String()
+		}
+
+		if name != test.fn {
+			t.Errorf("EnclosingFunction(%q in %q) got %s, want %s",
+				test.substr, test.input, name, test.fn)
+			continue
+		}
+
+		// While we're here: test HasEnclosingFunction.
+		if has := ssa.HasEnclosingFunction(pkg, path); has != (fn != nil) {
+			t.Errorf("HasEnclosingFunction(%q in %q) got %v, want %v",
+				test.substr, test.input, has, fn != nil)
+			continue
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/ssa.go b/vendor/golang.org/x/tools/go/ssa/ssa.go
index f4c64bb..e8350f1 100644
--- a/vendor/golang.org/x/tools/go/ssa/ssa.go
+++ b/vendor/golang.org/x/tools/go/ssa/ssa.go
@@ -10,11 +10,11 @@ package ssa
 import (
 	"fmt"
 	"go/ast"
+	exact "go/constant"
 	"go/token"
+	"go/types"
 	"sync"
 
-	"golang.org/x/tools/go/exact"
-	"golang.org/x/tools/go/types"
 	"golang.org/x/tools/go/types/typeutil"
 )
 
@@ -45,7 +45,7 @@ type Program struct {
 //
 type Package struct {
 	Prog    *Program               // the owning program
-	Object  *types.Package         // the type checker's package object for this package
+	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
@@ -53,10 +53,10 @@ type Package struct {
 
 	// The following fields are set transiently, then cleared
 	// after building.
-	started int32       // atomically tested and set at start of build phase
-	ninit   int32       // number of init functions
-	info    *types.Info // package type information
-	files   []*ast.File // package ASTs
+	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,
@@ -75,9 +75,6 @@ type Member interface {
 }
 
 // A Type is a Member of a Package representing a package-level named type.
-//
-// Type() returns a *types.Named.
-//
 type Type struct {
 	object *types.TypeName
 	pkg    *Package
@@ -95,7 +92,6 @@ type Type struct {
 type NamedConst struct {
 	object *types.Const
 	Value  *Const
-	pos    token.Pos
 	pkg    *Package
 }
 
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/load.go b/vendor/golang.org/x/tools/go/ssa/ssautil/load.go
index c2b8ce1..30b8053 100644
--- a/vendor/golang.org/x/tools/go/ssa/ssautil/load.go
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/load.go
@@ -9,17 +9,17 @@ package ssautil
 import (
 	"go/ast"
 	"go/token"
+	"go/types"
 
 	"golang.org/x/tools/go/loader"
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 // 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 BuildAll() is called
+// Code for bodies of functions is not built until Build is called
 // on the result.
 //
 // mode controls diagnostics and checking during SSA construction.
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/load_test.go b/vendor/golang.org/x/tools/go/ssa/ssautil/load_test.go
new file mode 100644
index 0000000..8ccd463
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/load_test.go
@@ -0,0 +1,64 @@
+// 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_test
+
+import (
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"testing"
+
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+const hello = `package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, world")
+}
+`
+
+func TestBuildPackage(t *testing.T) {
+	// There is a more substantial test of BuildPackage and the
+	// SSA program it builds in ../ssa/builder_test.go.
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "hello.go", hello, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pkg := types.NewPackage("hello", "")
+	ssapkg, _, err := ssautil.BuildPackage(&types.Config{Importer: importer.Default()}, fset, pkg, []*ast.File{f}, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pkg.Name() != "main" {
+		t.Errorf("pkg.Name() = %s, want main", pkg.Name())
+	}
+	if ssapkg.Func("main") == nil {
+		ssapkg.WriteTo(os.Stderr)
+		t.Errorf("ssapkg has no main function")
+	}
+}
+
+func TestBuildPackage_MissingImport(t *testing.T) {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "bad.go", `package bad; import "missing"`, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pkg := types.NewPackage("bad", "")
+	ssapkg, _, err := ssautil.BuildPackage(new(types.Config), fset, pkg, []*ast.File{f}, 0)
+	if err == nil || ssapkg != nil {
+		t.Fatal("BuildPackage succeeded unexpectedly")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go b/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go
index 70fff9c..db03bf5 100644
--- a/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go
@@ -22,9 +22,9 @@ import (
 	"bytes"
 	"fmt"
 	"go/token"
+	"go/types"
 
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/types"
 )
 
 // A ConstCase represents a single constant comparison.
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/switch_test.go b/vendor/golang.org/x/tools/go/ssa/ssautil/switch_test.go
new file mode 100644
index 0000000..a47dbef
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/switch_test.go
@@ -0,0 +1,74 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package ssautil_test
+
+import (
+	"go/parser"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+func TestSwitches(t *testing.T) {
+	conf := loader.Config{ParserMode: parser.ParseComments}
+	f, err := conf.ParseFile("testdata/switches.go", nil)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	conf.CreateFromFiles("main", f)
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	prog := ssautil.CreateProgram(iprog, 0)
+	mainPkg := prog.Package(iprog.Created[0].Pkg)
+	mainPkg.Build()
+
+	for _, mem := range mainPkg.Members {
+		if fn, ok := mem.(*ssa.Function); ok {
+			if fn.Synthetic != "" {
+				continue // e.g. init()
+			}
+			// Each (multi-line) "switch" comment within
+			// this function must match the printed form
+			// of a ConstSwitch.
+			var wantSwitches []string
+			for _, c := range f.Comments {
+				if fn.Syntax().Pos() <= c.Pos() && c.Pos() < fn.Syntax().End() {
+					text := strings.TrimSpace(c.Text())
+					if strings.HasPrefix(text, "switch ") {
+						wantSwitches = append(wantSwitches, text)
+					}
+				}
+			}
+
+			switches := ssautil.Switches(fn)
+			if len(switches) != len(wantSwitches) {
+				t.Errorf("in %s, found %d switches, want %d", fn, len(switches), len(wantSwitches))
+			}
+			for i, sw := range switches {
+				got := sw.String()
+				if i >= len(wantSwitches) {
+					continue
+				}
+				want := wantSwitches[i]
+				if got != want {
+					t.Errorf("in %s, found switch %d: got <<%s>>, want <<%s>>", fn, i, got, want)
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go b/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go
new file mode 100644
index 0000000..8ab4c11
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go
@@ -0,0 +1,357 @@
+// +build ignore
+
+package main
+
+// This file is the input to TestSwitches in switch_test.go.
+// Each multiway conditional with constant or type cases (Switch)
+// discovered by Switches is printed, and compared with the
+// comments.
+//
+// The body of each case is printed as the value of its first
+// instruction.
+
+// -------- Value switches --------
+
+func SimpleSwitch(x, y int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(23:int)
+	// case 3:int: print(23:int)
+	// case 4:int: print(3:int)
+	// default: x == y
+	// }
+	switch x {
+	case 1:
+		print(1)
+	case 2, 3:
+		print(23)
+		fallthrough
+	case 4:
+		print(3)
+	default:
+		print(4)
+	case y:
+		print(5)
+	}
+	print(6)
+}
+
+func four() int { return 4 }
+
+// A non-constant case makes a switch "impure", but its pure
+// cases form two separate switches.
+func SwitchWithNonConstantCase(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(23:int)
+	// case 3:int: print(23:int)
+	// default: four()
+	// }
+
+	// switch x {
+	// case 5:int: print(5:int)
+	// case 6:int: print(6:int)
+	// default: print("done":string)
+	// }
+	switch x {
+	case 1:
+		print(1)
+	case 2, 3:
+		print(23)
+	case four():
+		print(3)
+	case 5:
+		print(5)
+	case 6:
+		print(6)
+	}
+	print("done")
+}
+
+// Switches may be found even where the source
+// program doesn't have a switch statement.
+
+func ImplicitSwitches(x, y int) {
+	// switch x {
+	// case 1:int: print(12:int)
+	// case 2:int: print(12:int)
+	// default: x < 5:int
+	// }
+	if x == 1 || 2 == x || x < 5 {
+		print(12)
+	}
+
+	// switch x {
+	// case 3:int: print(34:int)
+	// case 4:int: print(34:int)
+	// default: x == y
+	// }
+	if x == 3 || 4 == x || x == y {
+		print(34)
+	}
+
+	// Not a switch: no consistent variable.
+	if x == 5 || y == 6 {
+		print(56)
+	}
+
+	// Not a switch: only one constant comparison.
+	if x == 7 || x == y {
+		print(78)
+	}
+}
+
+func IfElseBasedSwitch(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(2:int)
+	// default: print("else":string)
+	// }
+	if x == 1 {
+		print(1)
+	} else if x == 2 {
+		print(2)
+	} else {
+		print("else")
+	}
+}
+
+func GotoBasedSwitch(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(2:int)
+	// default: print("else":string)
+	// }
+	if x == 1 {
+		goto L1
+	}
+	if x == 2 {
+		goto L2
+	}
+	print("else")
+L1:
+	print(1)
+	goto end
+L2:
+	print(2)
+end:
+}
+
+func SwitchInAForLoop(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(2:int)
+	// default: print("head":string)
+	// }
+loop:
+	for {
+		print("head")
+		switch x {
+		case 1:
+			print(1)
+			break loop
+		case 2:
+			print(2)
+			break loop
+		}
+	}
+}
+
+// This case is a switch in a for-loop, both constructed using goto.
+// As before, the default case points back to the block containing the
+// switch, but that's ok.
+func SwitchInAForLoopUsingGoto(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: print(2:int)
+	// default: print("head":string)
+	// }
+loop:
+	print("head")
+	if x == 1 {
+		goto L1
+	}
+	if x == 2 {
+		goto L2
+	}
+	goto loop
+L1:
+	print(1)
+	goto end
+L2:
+	print(2)
+end:
+}
+
+func UnstructuredSwitchInAForLoop(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 2:int: x == 1:int
+	// default: print("end":string)
+	// }
+	for {
+		if x == 1 {
+			print(1)
+			return
+		}
+		if x == 2 {
+			continue
+		}
+		break
+	}
+	print("end")
+}
+
+func CaseWithMultiplePreds(x int) {
+	for {
+		if x == 1 {
+			print(1)
+			return
+		}
+	loop:
+		// This block has multiple predecessors,
+		// so can't be treated as a switch case.
+		if x == 2 {
+			goto loop
+		}
+		break
+	}
+	print("end")
+}
+
+func DuplicateConstantsAreNotEliminated(x int) {
+	// switch x {
+	// case 1:int: print(1:int)
+	// case 1:int: print("1a":string)
+	// case 2:int: print(2:int)
+	// default: return
+	// }
+	if x == 1 {
+		print(1)
+	} else if x == 1 { // duplicate => unreachable
+		print("1a")
+	} else if x == 2 {
+		print(2)
+	}
+}
+
+// Interface values (created by comparisons) are not constants,
+// so ConstSwitch.X is never of interface type.
+func MakeInterfaceIsNotAConstant(x interface{}) {
+	if x == "foo" {
+		print("foo")
+	} else if x == 1 {
+		print(1)
+	}
+}
+
+func ZeroInitializedVarsAreConstants(x int) {
+	// switch x {
+	// case 0:int: print(1:int)
+	// case 2:int: print(2:int)
+	// default: print("end":string)
+	// }
+	var zero int // SSA construction replaces zero with 0
+	if x == zero {
+		print(1)
+	} else if x == 2 {
+		print(2)
+	}
+	print("end")
+}
+
+// -------- Select --------
+
+// NB, potentially fragile reliance on register number.
+func SelectDesugarsToSwitch(ch chan int) {
+	// switch t1 {
+	// case 0:int: extract t0 #2
+	// case 1:int: println(0:int)
+	// case 2:int: println(1:int)
+	// default: println("default":string)
+	// }
+	select {
+	case x := <-ch:
+		println(x)
+	case <-ch:
+		println(0)
+	case ch <- 1:
+		println(1)
+	default:
+		println("default")
+	}
+}
+
+// NB, potentially fragile reliance on register number.
+func NonblockingSelectDefaultCasePanics(ch chan int) {
+	// switch t1 {
+	// case 0:int: extract t0 #2
+	// case 1:int: println(0:int)
+	// case 2:int: println(1:int)
+	// default: make interface{} <- string ("blocking select m...":string)
+	// }
+	select {
+	case x := <-ch:
+		println(x)
+	case <-ch:
+		println(0)
+	case ch <- 1:
+		println(1)
+	}
+}
+
+// -------- Type switches --------
+
+// NB, reliance on fragile register numbering.
+func SimpleTypeSwitch(x interface{}) {
+	// switch x.(type) {
+	// case t3 int: println(x)
+	// case t7 bool: println(x)
+	// case t10 string: println(t10)
+	// default: println(x)
+	// }
+	switch y := x.(type) {
+	case nil:
+		println(y)
+	case int, bool:
+		println(y)
+	case string:
+		println(y)
+	default:
+		println(y)
+	}
+}
+
+// NB, potentially fragile reliance on register number.
+func DuplicateTypesAreNotEliminated(x interface{}) {
+	// switch x.(type) {
+	// case t1 string: println(1:int)
+	// case t5 interface{}: println(t5)
+	// case t9 int: println(3:int)
+	// default: return
+	// }
+	switch y := x.(type) {
+	case string:
+		println(1)
+	case interface{}:
+		println(y)
+	case int:
+		println(3) // unreachable!
+	}
+}
+
+// NB, potentially fragile reliance on register number.
+func AdHocTypeSwitch(x interface{}) {
+	// switch x.(type) {
+	// case t1 int: println(t1)
+	// case t5 string: println(t5)
+	// default: print("default":string)
+	// }
+	if i, ok := x.(int); ok {
+		println(i)
+	} else if s, ok := x.(string); ok {
+		println(s)
+	} else {
+		print("default")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go b/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go
index 30843c3..3424e8a 100644
--- a/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go
+++ b/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go
@@ -44,7 +44,7 @@ func (visit *visitor) program() {
 	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.Method(mset.At(i)))
+			visit.function(visit.prog.MethodValue(mset.At(i)))
 		}
 	}
 }
@@ -64,3 +64,16 @@ func (visit *visitor) function(fn *ssa.Function) {
 		}
 	}
 }
+
+// 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/vendor/golang.org/x/tools/go/ssa/stdlib_test.go b/vendor/golang.org/x/tools/go/ssa/stdlib_test.go
new file mode 100644
index 0000000..f7e0f86
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/stdlib_test.go
@@ -0,0 +1,151 @@
+// 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.
+
+// Incomplete source tree on Android.
+
+// +build !android
+
+package ssa_test
+
+// This file runs the SSA builder in sanity-checking mode on all
+// packages beneath $GOROOT and prints some summary information.
+//
+// Run with "go test -cpu=8 to" set GOMAXPROCS.
+
+import (
+	"go/ast"
+	"go/build"
+	"go/token"
+	"runtime"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// Skip the set of packages that transitively depend on
+// cmd/internal/objfile, which uses vendoring,
+// which go/loader does not yet support.
+// TODO(adonovan): add support for vendoring and delete this.
+var skip = map[string]bool{
+	"cmd/addr2line":        true,
+	"cmd/internal/objfile": true,
+	"cmd/nm":               true,
+	"cmd/objdump":          true,
+	"cmd/pprof":            true,
+}
+
+func bytesAllocated() uint64 {
+	runtime.GC()
+	var stats runtime.MemStats
+	runtime.ReadMemStats(&stats)
+	return stats.Alloc
+}
+
+func TestStdlib(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode; too slow (golang.org/issue/14113)")
+	}
+	// Load, parse and type-check the program.
+	t0 := time.Now()
+	alloc0 := bytesAllocated()
+
+	// Load, parse and type-check the program.
+	ctxt := build.Default // copy
+	ctxt.GOPATH = ""      // disable GOPATH
+	conf := loader.Config{Build: &ctxt}
+	for _, path := range buildutil.AllPackages(conf.Build) {
+		if skip[path] {
+			continue
+		}
+		conf.ImportWithTests(path)
+	}
+
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Fatalf("Load failed: %v", err)
+	}
+
+	t1 := time.Now()
+	alloc1 := bytesAllocated()
+
+	// Create SSA packages.
+	var mode ssa.BuilderMode
+	// Comment out these lines during benchmarking.  Approx SSA build costs are noted.
+	mode |= ssa.SanityCheckFunctions // + 2% space, + 4% time
+	mode |= ssa.GlobalDebug          // +30% space, +18% time
+	prog := ssautil.CreateProgram(iprog, mode)
+
+	t2 := time.Now()
+
+	// Build SSA.
+	prog.Build()
+
+	t3 := time.Now()
+	alloc3 := bytesAllocated()
+
+	numPkgs := len(prog.AllPackages())
+	if want := 140; numPkgs < want {
+		t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want)
+	}
+
+	// Keep iprog reachable until after we've measured memory usage.
+	if len(iprog.AllPackages) == 0 {
+		panic("unreachable")
+	}
+
+	allFuncs := ssautil.AllFunctions(prog)
+
+	// Check that all non-synthetic functions have distinct names.
+	// Synthetic wrappers for exported methods should be distinct too,
+	// except for unexported ones (explained at (*Function).RelString).
+	byName := make(map[string]*ssa.Function)
+	for fn := range allFuncs {
+		if fn.Synthetic == "" || ast.IsExported(fn.Name()) {
+			str := fn.String()
+			prev := byName[str]
+			byName[str] = fn
+			if prev != nil {
+				t.Errorf("%s: duplicate function named %s",
+					prog.Fset.Position(fn.Pos()), str)
+				t.Errorf("%s:   (previously defined here)",
+					prog.Fset.Position(prev.Pos()))
+			}
+		}
+	}
+
+	// Dump some statistics.
+	var numInstrs int
+	for fn := range allFuncs {
+		for _, b := range fn.Blocks {
+			numInstrs += len(b.Instrs)
+		}
+	}
+
+	// determine line count
+	var lineCount int
+	prog.Fset.Iterate(func(f *token.File) bool {
+		lineCount += f.LineCount()
+		return true
+	})
+
+	// NB: when benchmarking, don't forget to clear the debug +
+	// sanity builder flags for better performance.
+
+	t.Log("GOMAXPROCS:           ", runtime.GOMAXPROCS(0))
+	t.Log("#Source lines:        ", lineCount)
+	t.Log("Load/parse/typecheck: ", t1.Sub(t0))
+	t.Log("SSA create:           ", t2.Sub(t1))
+	t.Log("SSA build:            ", t3.Sub(t2))
+
+	// SSA stats:
+	t.Log("#Packages:            ", numPkgs)
+	t.Log("#Functions:           ", len(allFuncs))
+	t.Log("#Instructions:        ", numInstrs)
+	t.Log("#MB AST+types:        ", int64(alloc1-alloc0)/1e6)
+	t.Log("#MB SSA:              ", int64(alloc3-alloc1)/1e6)
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/testdata/objlookup.go b/vendor/golang.org/x/tools/go/ssa/testdata/objlookup.go
new file mode 100644
index 0000000..1aaa417
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/testdata/objlookup.go
@@ -0,0 +1,160 @@
+//+build ignore
+
+package main
+
+// This file is the input to TestObjValueLookup in source_test.go,
+// which ensures that each occurrence of an ident defining or
+// referring to a func, var or const object can be mapped to its
+// corresponding SSA Value.
+//
+// For every reference to a var object, we use annotations in comments
+// to denote both the expected SSA Value kind, and whether to expect
+// its value (x) or its address (&x).
+//
+// For const and func objects, the results don't vary by reference and
+// are always values not addresses, so no annotations are needed.  The
+// declaration is enough.
+
+import "fmt"
+import "os"
+
+type J int
+
+func (*J) method() {}
+
+const globalConst = 0
+
+var globalVar int // &globalVar::Global
+
+func globalFunc() {}
+
+type I interface {
+	interfaceMethod()
+}
+
+type S struct {
+	x int // x::nil
+}
+
+func main() {
+	print(globalVar) // globalVar::UnOp
+	globalVar = 1    // globalVar::Const
+
+	var v0 int = 1 // v0::Const (simple local value spec)
+	if v0 > 0 {    // v0::Const
+		v0 = 2 // v0::Const
+	}
+	print(v0) // v0::Phi
+
+	// v1 is captured and thus implicitly address-taken.
+	var v1 int = 1         // v1::Const
+	v1 = 2                 // v1::Const
+	fmt.Println(v1)        // v1::UnOp (load)
+	f := func(param int) { // f::MakeClosure param::Parameter
+		if y := 1; y > 0 { // y::Const
+			print(v1, param) // v1::UnOp (load) param::Parameter
+		}
+		param = 2      // param::Const
+		println(param) // param::Const
+	}
+
+	f(0) // f::MakeClosure
+
+	var v2 int // v2::Const (implicitly zero-initialized local value spec)
+	print(v2)  // v2::Const
+
+	m := make(map[string]int) // m::MakeMap
+
+	// Local value spec with multi-valued RHS:
+	var v3, v4 = m[""] // v3::Extract v4::Extract m::MakeMap
+	print(v3)          // v3::Extract
+	print(v4)          // v4::Extract
+
+	v3++    // v3::BinOp (assign with op)
+	v3 += 2 // v3::BinOp (assign with op)
+
+	v5, v6 := false, "" // v5::Const v6::Const (defining assignment)
+	print(v5)           // v5::Const
+	print(v6)           // v6::Const
+
+	var v7 S    // &v7::Alloc
+	v7.x = 1    // &v7::Alloc &x::FieldAddr
+	print(v7.x) // &v7::Alloc &x::FieldAddr
+
+	var v8 [1]int // &v8::Alloc
+	v8[0] = 0     // &v8::Alloc
+	print(v8[:])  // &v8::Alloc
+	_ = v8[0]     // &v8::Alloc
+	_ = v8[:][0]  // &v8::Alloc
+	v8ptr := &v8  // v8ptr::Alloc &v8::Alloc
+	_ = v8ptr[0]  // v8ptr::Alloc
+	_ = *v8ptr    // v8ptr::Alloc
+
+	v8a := make([]int, 1) // v8a::Slice
+	v8a[0] = 0            // v8a::Slice
+	print(v8a[:])         // v8a::Slice
+
+	v9 := S{} // &v9::Alloc
+
+	v10 := &v9 // v10::Alloc &v9::Alloc
+	_ = v10    // v10::Alloc
+
+	var v11 *J = nil // v11::Const
+	v11.method()     // v11::Const
+
+	var v12 J    // &v12::Alloc
+	v12.method() // &v12::Alloc (implicitly address-taken)
+
+	// NB, in the following, 'method' resolves to the *types.Func
+	// of (*J).method, so it doesn't help us locate the specific
+	// ssa.Values here: a bound-method closure and a promotion
+	// wrapper.
+	_ = v11.method            // v11::Const
+	_ = (*struct{ J }).method // J::nil
+
+	// These vars are not optimised away.
+	if false {
+		v13 := 0     // v13::Const
+		println(v13) // v13::Const
+	}
+
+	switch x := 1; x { // x::Const
+	case v0: // v0::Phi
+	}
+
+	for k, v := range m { // k::Extract v::Extract m::MakeMap
+		_ = k // k::Extract
+		v++   // v::BinOp
+	}
+
+	if y := 0; y > 1 { // y::Const y::Const
+	}
+
+	var i interface{}      // i::Const (nil interface)
+	i = 1                  // i::MakeInterface
+	switch i := i.(type) { // i::MakeInterface i::MakeInterface
+	case int:
+		println(i) // i::Extract
+	}
+
+	ch := make(chan int) // ch::MakeChan
+	select {
+	case x := <-ch: // x::UnOp (receive) ch::MakeChan
+		_ = x // x::UnOp
+	}
+
+	// .Op is an inter-package FieldVal-selection.
+	var err os.PathError // &err::Alloc
+	_ = err.Op           // &err::Alloc &Op::FieldAddr
+	_ = &err.Op          // &err::Alloc &Op::FieldAddr
+
+	// Exercise corner-cases of lvalues vs rvalues.
+	// (Guessing IsAddr from the 'pointerness' won't cut it here.)
+	type N *N
+	var n N    // n::Const
+	n1 := n    // n1::Const n::Const
+	n2 := &n1  // n2::Alloc &n1::Alloc
+	n3 := *n2  // n3::UnOp n2::Alloc
+	n4 := **n3 // n4::UnOp n3::UnOp
+	_ = n4     // n4::UnOp
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/testdata/structconv.go b/vendor/golang.org/x/tools/go/ssa/testdata/structconv.go
new file mode 100644
index 0000000..3126469
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/testdata/structconv.go
@@ -0,0 +1,24 @@
+//+build ignore
+
+// This file is the input to TestValueForExprStructConv in identical_test.go,
+// which uses the same framework as TestValueForExpr does in source_test.go.
+//
+// In Go 1.8, struct conversions are permitted even when the struct types have
+// different tags. This wasn't permitted in earlier versions of Go, so this file
+// exists separately from valueforexpr.go to just test this behavior in Go 1.8
+// and later.
+
+package main
+
+type t1 struct {
+	x int
+}
+type t2 struct {
+	x int `tag`
+}
+
+func main() {
+	var tv1 t1
+	var tv2 t2 = /*@ChangeType*/ (t2(tv1))
+	_ = tv2
+}
diff --git a/vendor/golang.org/x/tools/go/ssa/testdata/valueforexpr.go b/vendor/golang.org/x/tools/go/ssa/testdata/valueforexpr.go
new file mode 100644
index 0000000..4a2cb85
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/testdata/valueforexpr.go
@@ -0,0 +1,152 @@
+//+build ignore
+
+package main
+
+// This file is the input to TestValueForExpr in source_test.go, which
+// ensures that each expression e immediately following a /*@kind*/(x)
+// annotation, when passed to Function.ValueForExpr(e), returns a
+// non-nil Value of the same type as e and of kind 'kind'.
+
+func f(spilled, unspilled int) {
+	_ = /*@UnOp*/ (spilled)
+	_ = /*@Parameter*/ (unspilled)
+	_ = /*@<nil>*/ (1 + 2) // (constant)
+	i := 0
+
+	f := func() (int, int) { return 0, 0 }
+
+	/*@Call*/ (print( /*@BinOp*/ (i + 1)))
+	_, _ = /*@Call*/ (f())
+	ch := /*@MakeChan*/ (make(chan int))
+	/*@UnOp*/ (<-ch)
+	x := /*@UnOp*/ (<-ch)
+	_ = x
+	select {
+	case /*@Extract*/ (<-ch):
+	case x := /*@Extract*/ (<-ch):
+		_ = x
+	}
+	defer /*@Function*/ (func() {
+	})()
+	go /*@Function*/ (func() {
+	})()
+	y := 0
+	if true && /*@BinOp*/ (bool(y > 0)) {
+		y = 1
+	}
+	_ = /*@Phi*/ (y)
+	map1 := /*@MakeMap*/ (make(map[string]string))
+	_ = map1
+	_ = /*@Slice*/ (make([]int, 0))
+	_ = /*@MakeClosure*/ (func() { print(spilled) })
+
+	sl := []int{}
+	_ = /*@Slice*/ (sl[:0])
+
+	_ = /*@<nil>*/ (new(int)) // optimized away
+	tmp := /*@Alloc*/ (new(int))
+	_ = tmp
+	var iface interface{}
+	_ = /*@TypeAssert*/ (iface.(int))
+	_ = /*@UnOp*/ (sl[0])
+	_ = /*@IndexAddr*/ (&sl[0])
+	_ = /*@Index*/ ([2]int{}[0])
+	var p *int
+	_ = /*@UnOp*/ (*p)
+
+	_ = /*@UnOp*/ (global)
+	/*@UnOp*/ (global)[""] = ""
+	/*@Global*/ (global) = map[string]string{}
+
+	var local t
+	/*UnOp*/ (local.x) = 1
+
+	// Exercise corner-cases of lvalues vs rvalues.
+	type N *N
+	var n N
+	/*@UnOp*/ (n) = /*@UnOp*/ (n)
+	/*@ChangeType*/ (n) = /*@Alloc*/ (&n)
+	/*@UnOp*/ (n) = /*@UnOp*/ (*n)
+	/*@UnOp*/ (n) = /*@UnOp*/ (**n)
+}
+
+func complit() {
+	// Composite literals.
+	// We get different results for
+	// - composite literal as value (e.g. operand to print)
+	// - composite literal initializer for addressable value
+	// - composite literal value assigned to blank var
+
+	// 1. Slices
+	print( /*@Slice*/ ([]int{}))
+	print( /*@Alloc*/ (&[]int{}))
+	print(& /*@Slice*/ ([]int{}))
+
+	sl1 := /*@Slice*/ ([]int{})
+	sl2 := /*@Alloc*/ (&[]int{})
+	sl3 := & /*@Slice*/ ([]int{})
+	_, _, _ = sl1, sl2, sl3
+
+	_ = /*@Slice*/ ([]int{})
+	_ = /*@<nil>*/ (& /*@Slice*/ ([]int{})) // & optimized away
+	_ = & /*@Slice*/ ([]int{})
+
+	// 2. Arrays
+	print( /*@UnOp*/ ([1]int{}))
+	print( /*@Alloc*/ (&[1]int{}))
+	print(& /*@Alloc*/ ([1]int{}))
+
+	arr1 := /*@Alloc*/ ([1]int{})
+	arr2 := /*@Alloc*/ (&[1]int{})
+	arr3 := & /*@Alloc*/ ([1]int{})
+	_, _, _ = arr1, arr2, arr3
+
+	_ = /*@UnOp*/ ([1]int{})
+	_ = /*@Alloc*/ (& /*@Alloc*/ ([1]int{}))
+	_ = & /*@Alloc*/ ([1]int{})
+
+	// 3. Maps
+	type M map[int]int
+	print( /*@MakeMap*/ (M{}))
+	print( /*@Alloc*/ (&M{}))
+	print(& /*@MakeMap*/ (M{}))
+
+	m1 := /*@MakeMap*/ (M{})
+	m2 := /*@Alloc*/ (&M{})
+	m3 := & /*@MakeMap*/ (M{})
+	_, _, _ = m1, m2, m3
+
+	_ = /*@MakeMap*/ (M{})
+	_ = /*@<nil>*/ (& /*@MakeMap*/ (M{})) // & optimized away
+	_ = & /*@MakeMap*/ (M{})
+
+	// 4. Structs
+	print( /*@UnOp*/ (struct{}{}))
+	print( /*@Alloc*/ (&struct{}{}))
+	print(& /*@Alloc*/ (struct{}{}))
+
+	s1 := /*@Alloc*/ (struct{}{})
+	s2 := /*@Alloc*/ (&struct{}{})
+	s3 := & /*@Alloc*/ (struct{}{})
+	_, _, _ = s1, s2, s3
+
+	_ = /*@UnOp*/ (struct{}{})
+	_ = /*@Alloc*/ (& /*@Alloc*/ (struct{}{}))
+	_ = & /*@Alloc*/ (struct{}{})
+}
+
+type t struct{ x int }
+
+// Ensure we can locate methods of named types.
+func (t) f(param int) {
+	_ = /*@Parameter*/ (param)
+}
+
+// Ensure we can locate init functions.
+func init() {
+	m := /*@MakeMap*/ (make(map[string]string))
+	_ = m
+}
+
+// Ensure we can locate variables in initializer expressions.
+var global = /*@MakeMap*/ (make(map[string]string))
diff --git a/vendor/golang.org/x/tools/go/ssa/testmain.go b/vendor/golang.org/x/tools/go/ssa/testmain.go
index a7b1242..ea232ad 100644
--- a/vendor/golang.org/x/tools/go/ssa/testmain.go
+++ b/vendor/golang.org/x/tools/go/ssa/testmain.go
@@ -7,27 +7,27 @@ 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/token"
+	"go/parser"
+	"go/types"
+	"log"
 	"os"
-	"sort"
 	"strings"
-
-	"golang.org/x/tools/go/exact"
-	"golang.org/x/tools/go/types"
+	"text/template"
 )
 
-// FindTests returns the list of packages that define at least one Test,
-// Example or Benchmark function (as defined by "go test"), and the
-// lists of all such functions.
-//
-func FindTests(pkgs []*Package) (testpkgs []*Package, tests, benchmarks, examples []*Function) {
-	if len(pkgs) == 0 {
-		return
-	}
-	prog := pkgs[0].Prog
+// 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.
@@ -35,40 +35,41 @@ func FindTests(pkgs []*Package) (testpkgs []*Package, tests, benchmarks, example
 	var benchmarkSig *types.Signature                         // func(*testing.B)
 	var exampleSig = types.NewSignature(nil, nil, nil, false) // func()
 
-	// Obtain the types from the parameters of testing.Main().
+	// Obtain the types from the parameters of testing.MainStart.
 	if testingPkg := prog.ImportedPackage("testing"); testingPkg != nil {
-		params := testingPkg.Func("Main").Signature.Params()
+		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
+			}
+		}
 	}
 
-	seen := make(map[*Package]bool)
-	for _, pkg := range pkgs {
-		if pkg.Prog != prog {
-			panic("wrong Program")
-		}
+	// 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") {
 
-		// 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
-				}
-
-				if !seen[pkg] {
-					seen[pkg] = true
-					testpkgs = append(testpkgs, pkg)
-				}
+			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
 			}
 		}
 	}
@@ -80,211 +81,16 @@ func isTestSig(f *Function, prefix string, sig *types.Signature) bool {
 	return isTest(f.Name(), prefix) && types.Identical(f.Signature, sig)
 }
 
-// If non-nil, testMainStartBodyHook is called immediately after
-// startBody for main.init and main.main, making it easy for users to
-// add custom imports and initialization steps for proprietary build
-// systems that don't exactly follow 'go test' conventions.
-var testMainStartBodyHook func(*Function)
-
-// CreateTestMainPackage creates and returns a synthetic "main"
-// package that runs all the tests of the supplied packages, similar
-// to the one that would be created by the 'go test' tool.
-//
-// It returns nil if the program contains no tests.
-//
-func (prog *Program) CreateTestMainPackage(pkgs ...*Package) *Package {
-	pkgs, tests, benchmarks, examples := FindTests(pkgs)
-	if len(pkgs) == 0 {
-		return nil
-	}
-
-	testmain := &Package{
-		Prog:    prog,
-		Members: make(map[string]Member),
-		values:  make(map[types.Object]Value),
-		Object:  types.NewPackage("test$main", "main"),
-	}
-
-	// Build package's init function.
-	init := &Function{
-		name:      "init",
-		Signature: new(types.Signature),
-		Synthetic: "package initializer",
-		Pkg:       testmain,
-		Prog:      prog,
-	}
-	init.startBody()
-
-	if testMainStartBodyHook != nil {
-		testMainStartBodyHook(init)
-	}
-
-	// Initialize packages to test.
-	var pkgpaths []string
-	for _, pkg := range pkgs {
-		var v Call
-		v.Call.Value = pkg.init
-		v.setType(types.NewTuple())
-		init.emit(&v)
-
-		pkgpaths = append(pkgpaths, pkg.Object.Path())
-	}
-	sort.Strings(pkgpaths)
-	init.emit(new(Return))
-	init.finishBody()
-	testmain.init = init
-	testmain.Object.MarkComplete()
-	testmain.Members[init.name] = init
-
-	// For debugging convenience, define an unexported const
-	// that enumerates the packages.
-	packagesConst := types.NewConst(token.NoPos, testmain.Object, "packages", tString,
-		exact.MakeString(strings.Join(pkgpaths, " ")))
-	memberFromObject(testmain, packagesConst, nil)
-
-	// Create main *types.Func and *ssa.Function
-	mainFunc := types.NewFunc(token.NoPos, testmain.Object, "main", new(types.Signature))
-	memberFromObject(testmain, mainFunc, nil)
-	main := testmain.Func("main")
-	main.Synthetic = "test main function"
-
-	main.startBody()
-
-	if testMainStartBodyHook != nil {
-		testMainStartBodyHook(main)
-	}
-
-	if testingPkg := prog.ImportedPackage("testing"); testingPkg != nil {
-		testingMain := testingPkg.Func("Main")
-		testingMainParams := testingMain.Signature.Params()
-
-		// The generated code is as if compiled from this:
-		//
-		// func main() {
-		//      match      := func(_, _ string) (bool, error) { return true, nil }
-		//      tests      := []testing.InternalTest{{"TestFoo", TestFoo}, ...}
-		//      benchmarks := []testing.InternalBenchmark{...}
-		//      examples   := []testing.InternalExample{...}
-		// 	testing.Main(match, tests, benchmarks, examples)
-		// }
-
-		matcher := &Function{
-			name:      "matcher",
-			Signature: testingMainParams.At(0).Type().(*types.Signature),
-			Synthetic: "test matcher predicate",
-			parent:    main,
-			Pkg:       testmain,
-			Prog:      prog,
-		}
-		main.AnonFuncs = append(main.AnonFuncs, matcher)
-		matcher.startBody()
-		matcher.emit(&Return{Results: []Value{vTrue, nilConst(types.Universe.Lookup("error").Type())}})
-		matcher.finishBody()
-
-		// Emit call: testing.Main(matcher, tests, benchmarks, examples).
-		var c Call
-		c.Call.Value = testingMain
-		c.Call.Args = []Value{
-			matcher,
-			testMainSlice(main, tests, testingMainParams.At(1).Type()),
-			testMainSlice(main, benchmarks, testingMainParams.At(2).Type()),
-			testMainSlice(main, examples, testingMainParams.At(3).Type()),
-		}
-		emitTailCall(main, &c)
-	} else {
-		// The program does not import "testing", but FindTests
-		// returned non-nil, which must mean there were Examples
-		// but no Tests or Benchmarks.
-		// We'll simply call them from testmain.main; this will
-		// ensure they don't panic, but will not check any
-		// "Output:" comments.
-		for _, eg := range examples {
-			var c Call
-			c.Call.Value = eg
-			c.setType(types.NewTuple())
-			main.emit(&c)
-		}
-		main.emit(&Return{})
-		main.currentBlock = nil
-	}
-
-	main.finishBody()
-
-	testmain.Members["main"] = main
-
-	if prog.mode&PrintPackages != 0 {
-		printMu.Lock()
-		testmain.WriteTo(os.Stdout)
-		printMu.Unlock()
-	}
-
-	if prog.mode&SanityCheckFunctions != 0 {
-		sanityCheckPackage(testmain)
-	}
-
-	prog.packages[testmain.Object] = testmain
-
-	return testmain
-}
-
-// testMainSlice emits to fn code to construct a slice of type slice
-// (one of []testing.Internal{Test,Benchmark,Example}) for all
-// functions in testfuncs.  It returns the slice value.
-//
-func testMainSlice(fn *Function, testfuncs []*Function, slice types.Type) Value {
-	if testfuncs == nil {
-		return nilConst(slice)
-	}
-
-	tElem := slice.(*types.Slice).Elem()
-	tPtrString := types.NewPointer(tString)
-	tPtrElem := types.NewPointer(tElem)
-	tPtrFunc := types.NewPointer(funcField(slice))
-
-	// Emit: array = new [n]testing.InternalTest
-	tArray := types.NewArray(tElem, int64(len(testfuncs)))
-	array := emitNew(fn, tArray, token.NoPos)
-	array.Comment = "test main"
-	for i, testfunc := range testfuncs {
-		// Emit: pitem = &array[i]
-		ia := &IndexAddr{X: array, Index: intConst(int64(i))}
-		ia.setType(tPtrElem)
-		pitem := fn.emit(ia)
-
-		// Emit: pname = &pitem.Name
-		fa := &FieldAddr{X: pitem, Field: 0} // .Name
-		fa.setType(tPtrString)
-		pname := fn.emit(fa)
-
-		// Emit: *pname = "testfunc"
-		emitStore(fn, pname, stringConst(testfunc.Name()), token.NoPos)
-
-		// Emit: pfunc = &pitem.F
-		fa = &FieldAddr{X: pitem, Field: 1} // .F
-		fa.setType(tPtrFunc)
-		pfunc := fn.emit(fa)
-
-		// Emit: *pfunc = testfunc
-		emitStore(fn, pfunc, testfunc, token.NoPos)
-	}
-
-	// Emit: slice array[:]
-	sl := &Slice{X: array}
-	sl.setType(slice)
-	return fn.emit(sl)
-}
-
 // 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)
 }
 
-// Plundered from $GOROOT/src/cmd/go/test.go
-
 // 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
@@ -294,3 +100,168 @@ func isTest(name, prefix string) bool {
 	}
 	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/vendor/golang.org/x/tools/go/ssa/testmain_test.go b/vendor/golang.org/x/tools/go/ssa/testmain_test.go
new file mode 100644
index 0000000..e24b23b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ssa/testmain_test.go
@@ -0,0 +1,124 @@
+// 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 ssa_test
+
+// Tests of FindTests.  CreateTestMainPackage is tested via the interpreter.
+// TODO(adonovan): test the 'pkgs' result from FindTests.
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+func create(t *testing.T, content string) *ssa.Package {
+	var conf loader.Config
+	f, err := conf.ParseFile("foo_test.go", content)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf.CreateFromFiles("foo", f)
+
+	lprog, err := conf.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We needn't call Build.
+	foo := lprog.Package("foo").Pkg
+	return ssautil.CreateProgram(lprog, ssa.SanityCheckFunctions).Package(foo)
+}
+
+func TestFindTests(t *testing.T) {
+	test := `
+package foo
+
+import "testing"
+
+type T int
+
+// Tests:
+func Test(t *testing.T) {}
+func TestA(t *testing.T) {}
+func TestB(t *testing.T) {}
+
+// Not tests:
+func testC(t *testing.T) {}
+func TestD() {}
+func testE(t *testing.T) int { return 0 }
+func (T) Test(t *testing.T) {}
+
+// Benchmarks:
+func Benchmark(*testing.B) {}
+func BenchmarkA(b *testing.B) {}
+func BenchmarkB(*testing.B) {}
+
+// Not benchmarks:
+func benchmarkC(t *testing.T) {}
+func BenchmarkD() {}
+func benchmarkE(t *testing.T) int { return 0 }
+func (T) Benchmark(t *testing.T) {}
+
+// Examples:
+func Example() {}
+func ExampleA() {}
+
+// Not examples:
+func exampleC() {}
+func ExampleD(t *testing.T) {}
+func exampleE() int { return 0 }
+func (T) Example() {}
+`
+	pkg := create(t, test)
+	tests, benchmarks, examples, _ := ssa.FindTests(pkg)
+
+	sort.Sort(funcsByPos(tests))
+	if got, want := fmt.Sprint(tests), "[foo.Test foo.TestA foo.TestB]"; got != want {
+		t.Errorf("FindTests.tests = %s, want %s", got, want)
+	}
+
+	sort.Sort(funcsByPos(benchmarks))
+	if got, want := fmt.Sprint(benchmarks), "[foo.Benchmark foo.BenchmarkA foo.BenchmarkB]"; got != want {
+		t.Errorf("FindTests.benchmarks = %s, want %s", got, want)
+	}
+
+	sort.Sort(funcsByPos(examples))
+	if got, want := fmt.Sprint(examples), "[foo.Example foo.ExampleA]"; got != want {
+		t.Errorf("FindTests examples = %s, want %s", got, want)
+	}
+}
+
+func TestFindTestsTesting(t *testing.T) {
+	test := `
+package foo
+
+// foo does not import "testing", but defines Examples.
+
+func Example() {}
+func ExampleA() {}
+`
+	pkg := create(t, test)
+	tests, benchmarks, examples, _ := ssa.FindTests(pkg)
+	if len(tests) > 0 {
+		t.Errorf("FindTests.tests = %s, want none", tests)
+	}
+	if len(benchmarks) > 0 {
+		t.Errorf("FindTests.benchmarks = %s, want none", benchmarks)
+	}
+	sort.Sort(funcsByPos(examples))
+	if got, want := fmt.Sprint(examples), "[foo.Example foo.ExampleA]"; got != want {
+		t.Errorf("FindTests examples = %s, want %s", got, want)
+	}
+}
+
+type funcsByPos []*ssa.Function
+
+func (p funcsByPos) Len() int           { return len(p) }
+func (p funcsByPos) Less(i, j int) bool { return p[i].Pos() < p[j].Pos() }
+func (p funcsByPos) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
diff --git a/vendor/golang.org/x/tools/go/ssa/util.go b/vendor/golang.org/x/tools/go/ssa/util.go
index 4f9d43d..ddb1184 100644
--- a/vendor/golang.org/x/tools/go/ssa/util.go
+++ b/vendor/golang.org/x/tools/go/ssa/util.go
@@ -10,11 +10,11 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"go/types"
 	"io"
 	"os"
 
 	"golang.org/x/tools/go/ast/astutil"
-	"golang.org/x/tools/go/types"
 )
 
 //// AST utilities
@@ -58,7 +58,7 @@ func recvType(obj *types.Func) types.Type {
 //
 // Exported to ssa/interp.
 //
-// TODO(gri): this is a copy of go/types.defaultType; export that function.
+// TODO(adonovan): use go/types.DefaultType after 1.8.
 //
 func DefaultType(typ types.Type) types.Type {
 	if t, ok := typ.(*types.Basic); ok {
diff --git a/vendor/golang.org/x/tools/go/ssa/wrappers.go b/vendor/golang.org/x/tools/go/ssa/wrappers.go
index ff1eac5..701dd90 100644
--- a/vendor/golang.org/x/tools/go/ssa/wrappers.go
+++ b/vendor/golang.org/x/tools/go/ssa/wrappers.go
@@ -22,7 +22,7 @@ package ssa
 import (
 	"fmt"
 
-	"golang.org/x/tools/go/types"
+	"go/types"
 )
 
 // -- wrappers -----------------------------------------------------------
diff --git a/vendor/golang.org/x/tools/go/types/api.go b/vendor/golang.org/x/tools/go/types/api.go
deleted file mode 100644
index 5344a39..0000000
--- a/vendor/golang.org/x/tools/go/types/api.go
+++ /dev/null
@@ -1,365 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package types declares the data types and implements
-// the algorithms for type-checking of Go packages.
-// Use Check and Config.Check to invoke the type-checker.
-//
-// Type-checking consists of several interdependent phases:
-//
-// Name resolution maps each identifier (ast.Ident) in the program to the
-// language object (Object) it denotes.
-// Use Info.{Defs,Uses,Implicits} for the results of name resolution.
-//
-// Constant folding computes the exact constant value (exact.Value) for
-// every expression (ast.Expr) that is a compile-time constant.
-// Use Info.Types[expr].Value for the results of constant folding.
-//
-// Type inference computes the type (Type) of every expression (ast.Expr)
-// and checks for compliance with the language specification.
-// Use Info.Types[expr].Type for the results of type inference.
-//
-package types // import "golang.org/x/tools/go/types"
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// Check type-checks a package and returns the resulting complete package
-// object, or a nil package and the first error. The package is specified
-// by a list of *ast.Files and corresponding file set, and the import path
-// the package is identified with. The clean path must not be empty or dot (".").
-//
-// For more control over type-checking and results, use Config.Check.
-func Check(path string, fset *token.FileSet, files []*ast.File) (*Package, error) {
-	var conf Config
-	pkg, err := conf.Check(path, fset, files, nil)
-	if err != nil {
-		return nil, err
-	}
-	return pkg, nil
-}
-
-// An Error describes a type-checking error; it implements the error interface.
-// A "soft" error is an error that still permits a valid interpretation of a
-// package (such as "unused variable"); "hard" errors may lead to unpredictable
-// behavior if ignored.
-type Error struct {
-	Fset *token.FileSet // file set for interpretation of Pos
-	Pos  token.Pos      // error position
-	Msg  string         // error message
-	Soft bool           // if set, error is "soft"
-}
-
-// Error returns an error string formatted as follows:
-// filename:line:column: message
-func (err Error) Error() string {
-	return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
-}
-
-// An importer resolves import paths to Packages.
-// The imports map records packages already known,
-// indexed by package path. The type-checker
-// will invoke Import with Config.Packages.
-// An importer must determine the canonical package path and
-// check imports to see if it is already present in the map.
-// If so, the Importer can return the map entry.  Otherwise,
-// the importer must load the package data for the given path
-// into a new *Package, record it in imports map, and return
-// the package.
-// TODO(gri) Need to be clearer about requirements of completeness.
-type Importer func(map[string]*Package, string) (*Package, error)
-
-// A Config specifies the configuration for type checking.
-// The zero value for Config is a ready-to-use default configuration.
-type Config struct {
-	// If IgnoreFuncBodies is set, function bodies are not
-	// type-checked.
-	IgnoreFuncBodies bool
-
-	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
-	// declares an empty "C" package and errors are omitted for qualified
-	// identifiers referring to package C (which won't find an object).
-	// This feature is intended for the standard library cmd/api tool.
-	//
-	// Caution: Effects may be unpredictable due to follow-up errors.
-	//          Do not use casually!
-	FakeImportC bool
-
-	// Packages is used to look up (and thus canonicalize) packages by
-	// package path. If Packages is nil, it is set to a new empty map.
-	// During type-checking, imported packages are added to the map.
-	Packages map[string]*Package
-
-	// If Error != nil, it is called with each error found
-	// during type checking; err has dynamic type Error.
-	// Secondary errors (for instance, to enumerate all types
-	// involved in an invalid recursive type declaration) have
-	// error strings that start with a '\t' character.
-	// If Error == nil, type-checking stops with the first
-	// error found.
-	Error func(err error)
-
-	// If Import != nil, it is called for each imported package.
-	// Otherwise, DefaultImport is called.
-	Import Importer
-
-	// If Sizes != nil, it provides the sizing functions for package unsafe.
-	// Otherwise &StdSizes{WordSize: 8, MaxAlign: 8} is used instead.
-	Sizes Sizes
-
-	// If DisableUnusedImportCheck is set, packages are not checked
-	// for unused imports.
-	DisableUnusedImportCheck bool
-}
-
-// DefaultImport is the default importer invoked if Config.Import == nil.
-// The declaration:
-//
-//	import _ "golang.org/x/tools/go/gcimporter"
-//
-// in a client of go/types will initialize DefaultImport to gcimporter.Import.
-var DefaultImport Importer
-
-// Info holds result type information for a type-checked package.
-// Only the information for which a map is provided is collected.
-// If the package has type errors, the collected information may
-// be incomplete.
-type Info struct {
-	// Types maps expressions to their types, and for constant
-	// expressions, their values. Invalid expressions are omitted.
-	//
-	// For (possibly parenthesized) identifiers denoting built-in
-	// functions, the recorded signatures are call-site specific:
-	// if the call result is not a constant, the recorded type is
-	// an argument-specific signature. Otherwise, the recorded type
-	// is invalid.
-	//
-	// Identifiers on the lhs of declarations (i.e., the identifiers
-	// which are being declared) are collected in the Defs map.
-	// Identifiers denoting packages are collected in the Uses maps.
-	Types map[ast.Expr]TypeAndValue
-
-	// Defs maps identifiers to the objects they define (including
-	// package names, dots "." of dot-imports, and blank "_" identifiers).
-	// For identifiers that do not denote objects (e.g., the package name
-	// in package clauses, or symbolic variables t in t := x.(type) of
-	// type switch headers), the corresponding objects are nil.
-	//
-	// For an anonymous field, Defs returns the field *Var it defines.
-	//
-	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
-	Defs map[*ast.Ident]Object
-
-	// Uses maps identifiers to the objects they denote.
-	//
-	// For an anonymous field, Uses returns the *TypeName it denotes.
-	//
-	// Invariant: Uses[id].Pos() != id.Pos()
-	Uses map[*ast.Ident]Object
-
-	// Implicits maps nodes to their implicitly declared objects, if any.
-	// The following node and object types may appear:
-	//
-	//	node               declared object
-	//
-	//	*ast.ImportSpec    *PkgName for dot-imports and imports without renames
-	//	*ast.CaseClause    type-specific *Var for each type switch case clause (incl. default)
-	//      *ast.Field         anonymous struct field or parameter *Var
-	//
-	Implicits map[ast.Node]Object
-
-	// Selections maps selector expressions (excluding qualified identifiers)
-	// to their corresponding selections.
-	Selections map[*ast.SelectorExpr]*Selection
-
-	// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
-	// associated with a specific node but with all files belonging to a package.
-	// Thus, the package scope can be found in the type-checked Package object.
-	// Scopes nest, with the Universe scope being the outermost scope, enclosing
-	// the package scope, which contains (one or more) files scopes, which enclose
-	// function scopes which in turn enclose statement and function literal scopes.
-	// Note that even though package-level functions are declared in the package
-	// scope, the function scopes are embedded in the file scope of the file
-	// containing the function declaration.
-	//
-	// The following node types may appear in Scopes:
-	//
-	//	*ast.File
-	//	*ast.FuncType
-	//	*ast.BlockStmt
-	//	*ast.IfStmt
-	//	*ast.SwitchStmt
-	//	*ast.TypeSwitchStmt
-	//	*ast.CaseClause
-	//	*ast.CommClause
-	//	*ast.ForStmt
-	//	*ast.RangeStmt
-	//
-	Scopes map[ast.Node]*Scope
-
-	// InitOrder is the list of package-level initializers in the order in which
-	// they must be executed. Initializers referring to variables related by an
-	// initialization dependency appear in topological order, the others appear
-	// in source order. Variables without an initialization expression do not
-	// appear in this list.
-	InitOrder []*Initializer
-}
-
-// TypeOf returns the type of expression e, or nil if not found.
-// Precondition: the Types, Uses and Defs maps are populated.
-//
-func (info *Info) TypeOf(e ast.Expr) Type {
-	if t, ok := info.Types[e]; ok {
-		return t.Type
-	}
-	if id, _ := e.(*ast.Ident); id != nil {
-		if obj := info.ObjectOf(id); obj != nil {
-			return obj.Type()
-		}
-	}
-	return nil
-}
-
-// ObjectOf returns the object denoted by the specified id,
-// or nil if not found.
-//
-// If id is an anonymous struct field, ObjectOf returns the field (*Var)
-// it uses, not the type (*TypeName) it defines.
-//
-// Precondition: the Uses and Defs maps are populated.
-//
-func (info *Info) ObjectOf(id *ast.Ident) Object {
-	if obj, _ := info.Defs[id]; obj != nil {
-		return obj
-	}
-	return info.Uses[id]
-}
-
-// TypeAndValue reports the type and value (for constants)
-// of the corresponding expression.
-type TypeAndValue struct {
-	mode  operandMode
-	Type  Type
-	Value exact.Value
-}
-
-// TODO(gri) Consider eliminating the IsVoid predicate. Instead, report
-// "void" values as regular values but with the empty tuple type.
-
-// IsVoid reports whether the corresponding expression
-// is a function call without results.
-func (tv TypeAndValue) IsVoid() bool {
-	return tv.mode == novalue
-}
-
-// IsType reports whether the corresponding expression specifies a type.
-func (tv TypeAndValue) IsType() bool {
-	return tv.mode == typexpr
-}
-
-// IsBuiltin reports whether the corresponding expression denotes
-// a (possibly parenthesized) built-in function.
-func (tv TypeAndValue) IsBuiltin() bool {
-	return tv.mode == builtin
-}
-
-// IsValue reports whether the corresponding expression is a value.
-// Builtins are not considered values. Constant values have a non-
-// nil Value.
-func (tv TypeAndValue) IsValue() bool {
-	switch tv.mode {
-	case constant, variable, mapindex, value, commaok:
-		return true
-	}
-	return false
-}
-
-// IsNil reports whether the corresponding expression denotes the
-// predeclared value nil.
-func (tv TypeAndValue) IsNil() bool {
-	return tv.mode == value && tv.Type == Typ[UntypedNil]
-}
-
-// Addressable reports whether the corresponding expression
-// is addressable (http://golang.org/ref/spec#Address_operators).
-func (tv TypeAndValue) Addressable() bool {
-	return tv.mode == variable
-}
-
-// Assignable reports whether the corresponding expression
-// is assignable to (provided a value of the right type).
-func (tv TypeAndValue) Assignable() bool {
-	return tv.mode == variable || tv.mode == mapindex
-}
-
-// HasOk reports whether the corresponding expression may be
-// used on the lhs of a comma-ok assignment.
-func (tv TypeAndValue) HasOk() bool {
-	return tv.mode == commaok || tv.mode == mapindex
-}
-
-// An Initializer describes a package-level variable, or a list of variables in case
-// of a multi-valued initialization expression, and the corresponding initialization
-// expression.
-type Initializer struct {
-	Lhs []*Var // var Lhs = Rhs
-	Rhs ast.Expr
-}
-
-func (init *Initializer) String() string {
-	var buf bytes.Buffer
-	for i, lhs := range init.Lhs {
-		if i > 0 {
-			buf.WriteString(", ")
-		}
-		buf.WriteString(lhs.Name())
-	}
-	buf.WriteString(" = ")
-	WriteExpr(&buf, init.Rhs)
-	return buf.String()
-}
-
-// Check type-checks a package and returns the resulting package object,
-// the first error if any, and if info != nil, additional type information.
-// The package is marked as complete if no errors occurred, otherwise it is
-// incomplete. See Config.Error for controlling behavior in the presence of
-// errors.
-//
-// The package is specified by a list of *ast.Files and corresponding
-// file set, and the package path the package is identified with.
-// The clean path must not be empty or dot (".").
-func (conf *Config) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (*Package, error) {
-	pkg := NewPackage(path, "")
-	return pkg, NewChecker(conf, fset, pkg, info).Files(files)
-}
-
-// AssertableTo reports whether a value of type V can be asserted to have type T.
-func AssertableTo(V *Interface, T Type) bool {
-	m, _ := assertableTo(V, T)
-	return m == nil
-}
-
-// AssignableTo reports whether a value of type V is assignable to a variable of type T.
-func AssignableTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
-	return x.assignableTo(nil, T) // config not needed for non-constant x
-}
-
-// ConvertibleTo reports whether a value of type V is convertible to a value of type T.
-func ConvertibleTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
-	return x.convertibleTo(nil, T) // config not needed for non-constant x
-}
-
-// Implements reports whether type V implements interface T.
-func Implements(V Type, T *Interface) bool {
-	f, _ := MissingMethod(V, T, true)
-	return f == nil
-}
diff --git a/vendor/golang.org/x/tools/go/types/assignments.go b/vendor/golang.org/x/tools/go/types/assignments.go
deleted file mode 100644
index 93b842e..0000000
--- a/vendor/golang.org/x/tools/go/types/assignments.go
+++ /dev/null
@@ -1,328 +0,0 @@
-// 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.
-
-// This file implements initialization and assignment checks.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-)
-
-// assignment reports whether x can be assigned to a variable of type T,
-// if necessary by attempting to convert untyped values to the appropriate
-// type. If x.mode == invalid upon return, then assignment has already
-// issued an error message and the caller doesn't have to report another.
-// Use T == nil to indicate assignment to an untyped blank identifier.
-//
-// TODO(gri) Should find a better way to handle in-band errors.
-//
-func (check *Checker) assignment(x *operand, T Type) bool {
-	switch x.mode {
-	case invalid:
-		return true // error reported before
-	case constant, variable, mapindex, value, commaok:
-		// ok
-	default:
-		unreachable()
-	}
-
-	// x must be a single value
-	// (tuple types are never named - no need for underlying type)
-	if t, _ := x.typ.(*Tuple); t != nil {
-		assert(t.Len() > 1)
-		check.errorf(x.pos(), "%d-valued expression %s used as single value", t.Len(), x)
-		x.mode = invalid
-		return false
-	}
-
-	if isUntyped(x.typ) {
-		target := T
-		// spec: "If an untyped constant is assigned to a variable of interface
-		// type or the blank identifier, the constant is first converted to type
-		// bool, rune, int, float64, complex128 or string respectively, depending
-		// on whether the value is a boolean, rune, integer, floating-point, complex,
-		// or string constant."
-		if T == nil || IsInterface(T) {
-			if T == nil && x.typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil")
-				x.mode = invalid
-				return false
-			}
-			target = defaultType(x.typ)
-		}
-		check.convertUntyped(x, target)
-		if x.mode == invalid {
-			return false
-		}
-	}
-
-	// spec: "If a left-hand side is the blank identifier, any typed or
-	// non-constant value except for the predeclared identifier nil may
-	// be assigned to it."
-	return T == nil || x.assignableTo(check.conf, T)
-}
-
-func (check *Checker) initConst(lhs *Const, x *operand) {
-	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return
-	}
-
-	// rhs must be a constant
-	if x.mode != constant {
-		check.errorf(x.pos(), "%s is not constant", x)
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return
-	}
-	assert(isConstType(x.typ))
-
-	// If the lhs doesn't have a type yet, use the type of x.
-	if lhs.typ == nil {
-		lhs.typ = x.typ
-	}
-
-	if !check.assignment(x, lhs.typ) {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "cannot define constant %s (type %s) as %s", lhs.Name(), lhs.typ, x)
-		}
-		return
-	}
-
-	lhs.val = x.val
-}
-
-// If result is set, lhs is a function result parameter and x is a return result.
-func (check *Checker) initVar(lhs *Var, x *operand, result bool) Type {
-	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return nil
-	}
-
-	// If the lhs doesn't have a type yet, use the type of x.
-	if lhs.typ == nil {
-		typ := x.typ
-		if isUntyped(typ) {
-			// convert untyped types to default types
-			if typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil")
-				lhs.typ = Typ[Invalid]
-				return nil
-			}
-			typ = defaultType(typ)
-		}
-		lhs.typ = typ
-	}
-
-	if !check.assignment(x, lhs.typ) {
-		if x.mode != invalid {
-			if result {
-				// don't refer to lhs.name because it may be an anonymous result parameter
-				check.errorf(x.pos(), "cannot return %s as value of type %s", x, lhs.typ)
-			} else {
-				check.errorf(x.pos(), "cannot initialize %s with %s", lhs, x)
-			}
-		}
-		return nil
-	}
-
-	return x.typ
-}
-
-func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
-	if x.mode == invalid || x.typ == Typ[Invalid] {
-		return nil
-	}
-
-	// Determine if the lhs is a (possibly parenthesized) identifier.
-	ident, _ := unparen(lhs).(*ast.Ident)
-
-	// Don't evaluate lhs if it is the blank identifier.
-	if ident != nil && ident.Name == "_" {
-		check.recordDef(ident, nil)
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			x.typ = nil
-		}
-		return x.typ
-	}
-
-	// If the lhs is an identifier denoting a variable v, this assignment
-	// is not a 'use' of v. Remember current value of v.used and restore
-	// after evaluating the lhs via check.expr.
-	var v *Var
-	var v_used bool
-	if ident != nil {
-		if _, obj := check.scope.LookupParent(ident.Name, token.NoPos); obj != nil {
-			v, _ = obj.(*Var)
-			if v != nil {
-				v_used = v.used
-			}
-		}
-	}
-
-	var z operand
-	check.expr(&z, lhs)
-	if v != nil {
-		v.used = v_used // restore v.used
-	}
-
-	if z.mode == invalid || z.typ == Typ[Invalid] {
-		return nil
-	}
-
-	// spec: "Each left-hand side operand must be addressable, a map index
-	// expression, or the blank identifier. Operands may be parenthesized."
-	switch z.mode {
-	case invalid:
-		return nil
-	case variable, mapindex:
-		// ok
-	default:
-		check.errorf(z.pos(), "cannot assign to %s", &z)
-		return nil
-	}
-
-	if !check.assignment(x, z.typ) {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "cannot assign %s to %s", x, &z)
-		}
-		return nil
-	}
-
-	return x.typ
-}
-
-// If returnPos is valid, initVars is called to type-check the assignment of
-// return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, rhs []ast.Expr, returnPos token.Pos) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.expr(x, rhs[i]) }, len(rhs), l == 2 && !returnPos.IsValid())
-	if get == nil || l != r {
-		// invalidate lhs and use rhs
-		for _, obj := range lhs {
-			if obj.typ == nil {
-				obj.typ = Typ[Invalid]
-			}
-		}
-		if get == nil {
-			return // error reported by unpack
-		}
-		check.useGetter(get, r)
-		if returnPos.IsValid() {
-			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", l, r)
-			return
-		}
-		check.errorf(rhs[0].Pos(), "assignment count mismatch (%d vs %d)", l, r)
-		return
-	}
-
-	var x operand
-	if commaOk {
-		var a [2]Type
-		for i := range a {
-			get(&x, i)
-			a[i] = check.initVar(lhs[i], &x, returnPos.IsValid())
-		}
-		check.recordCommaOkTypes(rhs[0], a)
-		return
-	}
-
-	for i, lhs := range lhs {
-		get(&x, i)
-		check.initVar(lhs, &x, returnPos.IsValid())
-	}
-}
-
-func (check *Checker) assignVars(lhs, rhs []ast.Expr) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.expr(x, rhs[i]) }, len(rhs), l == 2)
-	if get == nil {
-		return // error reported by unpack
-	}
-	if l != r {
-		check.useGetter(get, r)
-		check.errorf(rhs[0].Pos(), "assignment count mismatch (%d vs %d)", l, r)
-		return
-	}
-
-	var x operand
-	if commaOk {
-		var a [2]Type
-		for i := range a {
-			get(&x, i)
-			a[i] = check.assignVar(lhs[i], &x)
-		}
-		check.recordCommaOkTypes(rhs[0], a)
-		return
-	}
-
-	for i, lhs := range lhs {
-		get(&x, i)
-		check.assignVar(lhs, &x)
-	}
-}
-
-func (check *Checker) shortVarDecl(pos token.Pos, lhs, rhs []ast.Expr) {
-	scope := check.scope
-
-	// collect lhs variables
-	var newVars []*Var
-	var lhsVars = make([]*Var, len(lhs))
-	for i, lhs := range lhs {
-		var obj *Var
-		if ident, _ := lhs.(*ast.Ident); ident != nil {
-			// Use the correct obj if the ident is redeclared. The
-			// variable's scope starts after the declaration; so we
-			// must use Scope.Lookup here and call Scope.Insert
-			// (via check.declare) later.
-			name := ident.Name
-			if alt := scope.Lookup(name); alt != nil {
-				// redeclared object must be a variable
-				if alt, _ := alt.(*Var); alt != nil {
-					obj = alt
-				} else {
-					check.errorf(lhs.Pos(), "cannot assign to %s", lhs)
-				}
-				check.recordUse(ident, alt)
-			} else {
-				// declare new variable, possibly a blank (_) variable
-				obj = NewVar(ident.Pos(), check.pkg, name, nil)
-				if name != "_" {
-					newVars = append(newVars, obj)
-				}
-				check.recordDef(ident, obj)
-			}
-		} else {
-			check.errorf(lhs.Pos(), "cannot declare %s", lhs)
-		}
-		if obj == nil {
-			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
-		}
-		lhsVars[i] = obj
-	}
-
-	check.initVars(lhsVars, rhs, token.NoPos)
-
-	// declare new variables
-	if len(newVars) > 0 {
-		// spec: "The scope of a constant or variable identifier declared inside
-		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-		// for short variable declarations) and ends at the end of the innermost
-		// containing block."
-		scopePos := rhs[len(rhs)-1].End()
-		for _, obj := range newVars {
-			check.declare(scope, nil, obj, scopePos) // recordObject already called
-		}
-	} else {
-		check.softErrorf(pos, "no new variables on left side of :=")
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/builtins.go b/vendor/golang.org/x/tools/go/types/builtins.go
deleted file mode 100644
index f45f930..0000000
--- a/vendor/golang.org/x/tools/go/types/builtins.go
+++ /dev/null
@@ -1,628 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of builtin function calls.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// builtin type-checks a call to the built-in specified by id and
-// returns true if the call is valid, with *x holding the result;
-// but x.expr is not set. If the call is invalid, the result is
-// false, and *x is undefined.
-//
-func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
-	// append is the only built-in that permits the use of ... for the last argument
-	bin := predeclaredFuncs[id]
-	if call.Ellipsis.IsValid() && id != _Append {
-		check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
-		check.use(call.Args...)
-		return
-	}
-
-	// For len(x) and cap(x) we need to know if x contains any function calls or
-	// receive operations. Save/restore current setting and set hasCallOrRecv to
-	// false for the evaluation of x so that we can check it afterwards.
-	// Note: We must do this _before_ calling unpack because unpack evaluates the
-	//       first argument before we even call arg(x, 0)!
-	if id == _Len || id == _Cap {
-		defer func(b bool) {
-			check.hasCallOrRecv = b
-		}(check.hasCallOrRecv)
-		check.hasCallOrRecv = false
-	}
-
-	// determine actual arguments
-	var arg getter
-	nargs := len(call.Args)
-	switch id {
-	default:
-		// make argument getter
-		arg, nargs, _ = unpack(func(x *operand, i int) { check.expr(x, call.Args[i]) }, nargs, false)
-		if arg == nil {
-			return
-		}
-		// evaluate first argument, if present
-		if nargs > 0 {
-			arg(x, 0)
-			if x.mode == invalid {
-				return
-			}
-		}
-	case _Make, _New, _Offsetof, _Trace:
-		// arguments require special handling
-	}
-
-	// check argument count
-	{
-		msg := ""
-		if nargs < bin.nargs {
-			msg = "not enough"
-		} else if !bin.variadic && nargs > bin.nargs {
-			msg = "too many"
-		}
-		if msg != "" {
-			check.invalidOp(call.Rparen, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
-			return
-		}
-	}
-
-	switch id {
-	case _Append:
-		// append(s S, x ...T) S, where T is the element type of S
-		// spec: "The variadic function append appends zero or more values x to s of type
-		// S, which must be a slice type, and returns the resulting slice, also of type S.
-		// The values x are passed to a parameter of type ...T where T is the element type
-		// of S and the respective parameter passing rules apply."
-		S := x.typ
-		var T Type
-		if s, _ := S.Underlying().(*Slice); s != nil {
-			T = s.elem
-		} else {
-			check.invalidArg(x.pos(), "%s is not a slice", x)
-			return
-		}
-
-		// remember arguments that have been evaluated already
-		alist := []operand{*x}
-
-		// spec: "As a special case, append also accepts a first argument assignable
-		// to type []byte with a second argument of string type followed by ... .
-		// This form appends the bytes of the string.
-		if nargs == 2 && call.Ellipsis.IsValid() && x.assignableTo(check.conf, NewSlice(universeByte)) {
-			arg(x, 1)
-			if x.mode == invalid {
-				return
-			}
-			if isString(x.typ) {
-				if check.Types != nil {
-					sig := makeSig(S, S, x.typ)
-					sig.variadic = true
-					check.recordBuiltinType(call.Fun, sig)
-				}
-				x.mode = value
-				x.typ = S
-				break
-			}
-			alist = append(alist, *x)
-			// fallthrough
-		}
-
-		// check general case by creating custom signature
-		sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
-		sig.variadic = true
-		check.arguments(x, call, sig, func(x *operand, i int) {
-			// only evaluate arguments that have not been evaluated before
-			if i < len(alist) {
-				*x = alist[i]
-				return
-			}
-			arg(x, i)
-		}, nargs)
-		// ok to continue even if check.arguments reported errors
-
-		x.mode = value
-		x.typ = S
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, sig)
-		}
-
-	case _Cap, _Len:
-		// cap(x)
-		// len(x)
-		mode := invalid
-		var typ Type
-		var val exact.Value
-		switch typ = implicitArrayDeref(x.typ.Underlying()); t := typ.(type) {
-		case *Basic:
-			if isString(t) && id == _Len {
-				if x.mode == constant {
-					mode = constant
-					val = exact.MakeInt64(int64(len(exact.StringVal(x.val))))
-				} else {
-					mode = value
-				}
-			}
-
-		case *Array:
-			mode = value
-			// spec: "The expressions len(s) and cap(s) are constants
-			// if the type of s is an array or pointer to an array and
-			// the expression s does not contain channel receives or
-			// function calls; in this case s is not evaluated."
-			if !check.hasCallOrRecv {
-				mode = constant
-				val = exact.MakeInt64(t.len)
-			}
-
-		case *Slice, *Chan:
-			mode = value
-
-		case *Map:
-			if id == _Len {
-				mode = value
-			}
-		}
-
-		if mode == invalid {
-			check.invalidArg(x.pos(), "%s for %s", x, bin.name)
-			return
-		}
-
-		x.mode = mode
-		x.typ = Typ[Int]
-		x.val = val
-		if check.Types != nil && mode != constant {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ))
-		}
-
-	case _Close:
-		// close(c)
-		c, _ := x.typ.Underlying().(*Chan)
-		if c == nil {
-			check.invalidArg(x.pos(), "%s is not a channel", x)
-			return
-		}
-		if c.dir == RecvOnly {
-			check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, c))
-		}
-
-	case _Complex:
-		// complex(x, y realT) complexT
-		if !check.complexArg(x) {
-			return
-		}
-
-		var y operand
-		arg(&y, 1)
-		if y.mode == invalid {
-			return
-		}
-		if !check.complexArg(&y) {
-			return
-		}
-
-		check.convertUntyped(x, y.typ)
-		if x.mode == invalid {
-			return
-		}
-		check.convertUntyped(&y, x.typ)
-		if y.mode == invalid {
-			return
-		}
-
-		if !Identical(x.typ, y.typ) {
-			check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
-			return
-		}
-
-		if x.mode == constant && y.mode == constant {
-			x.val = exact.BinaryOp(x.val, token.ADD, exact.MakeImag(y.val))
-		} else {
-			x.mode = value
-		}
-
-		realT := x.typ
-		complexT := Typ[Invalid]
-		switch realT.Underlying().(*Basic).kind {
-		case Float32:
-			complexT = Typ[Complex64]
-		case Float64:
-			complexT = Typ[Complex128]
-		case UntypedInt, UntypedRune, UntypedFloat:
-			if x.mode == constant {
-				realT = defaultType(realT).(*Basic)
-				complexT = Typ[UntypedComplex]
-			} else {
-				// untyped but not constant; probably because one
-				// operand is a non-constant shift of untyped lhs
-				realT = Typ[Float64]
-				complexT = Typ[Complex128]
-			}
-		default:
-			check.invalidArg(x.pos(), "float32 or float64 arguments expected")
-			return
-		}
-
-		x.typ = complexT
-		if check.Types != nil && x.mode != constant {
-			check.recordBuiltinType(call.Fun, makeSig(complexT, realT, realT))
-		}
-
-		if x.mode != constant {
-			// The arguments have now their final types, which at run-
-			// time will be materialized. Update the expression trees.
-			// If the current types are untyped, the materialized type
-			// is the respective default type.
-			// (If the result is constant, the arguments are never
-			// materialized and there is nothing to do.)
-			check.updateExprType(x.expr, realT, true)
-			check.updateExprType(y.expr, realT, true)
-		}
-
-	case _Copy:
-		// copy(x, y []T) int
-		var dst Type
-		if t, _ := x.typ.Underlying().(*Slice); t != nil {
-			dst = t.elem
-		}
-
-		var y operand
-		arg(&y, 1)
-		if y.mode == invalid {
-			return
-		}
-		var src Type
-		switch t := y.typ.Underlying().(type) {
-		case *Basic:
-			if isString(y.typ) {
-				src = universeByte
-			}
-		case *Slice:
-			src = t.elem
-		}
-
-		if dst == nil || src == nil {
-			check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
-			return
-		}
-
-		if !Identical(dst, src) {
-			check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
-			return
-		}
-
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
-		}
-		x.mode = value
-		x.typ = Typ[Int]
-
-	case _Delete:
-		// delete(m, k)
-		m, _ := x.typ.Underlying().(*Map)
-		if m == nil {
-			check.invalidArg(x.pos(), "%s is not a map", x)
-			return
-		}
-		arg(x, 1) // k
-		if x.mode == invalid {
-			return
-		}
-
-		if !x.assignableTo(check.conf, m.key) {
-			check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, m, m.key))
-		}
-
-	case _Imag, _Real:
-		// imag(complexT) realT
-		// real(complexT) realT
-		if !isComplex(x.typ) {
-			check.invalidArg(x.pos(), "%s must be a complex number", x)
-			return
-		}
-		if x.mode == constant {
-			if id == _Real {
-				x.val = exact.Real(x.val)
-			} else {
-				x.val = exact.Imag(x.val)
-			}
-		} else {
-			x.mode = value
-		}
-		var k BasicKind
-		switch x.typ.Underlying().(*Basic).kind {
-		case Complex64:
-			k = Float32
-		case Complex128:
-			k = Float64
-		case UntypedComplex:
-			k = UntypedFloat
-		default:
-			unreachable()
-		}
-
-		if check.Types != nil && x.mode != constant {
-			check.recordBuiltinType(call.Fun, makeSig(Typ[k], x.typ))
-		}
-		x.typ = Typ[k]
-
-	case _Make:
-		// make(T, n)
-		// make(T, n, m)
-		// (no argument evaluated yet)
-		arg0 := call.Args[0]
-		T := check.typ(arg0)
-		if T == Typ[Invalid] {
-			return
-		}
-
-		var min int // minimum number of arguments
-		switch T.Underlying().(type) {
-		case *Slice:
-			min = 2
-		case *Map, *Chan:
-			min = 1
-		default:
-			check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
-			return
-		}
-		if nargs < min || min+1 < nargs {
-			check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, nargs)
-			return
-		}
-		var sizes []int64 // constant integer arguments, if any
-		for _, arg := range call.Args[1:] {
-			if s, ok := check.index(arg, -1); ok && s >= 0 {
-				sizes = append(sizes, s)
-			}
-		}
-		if len(sizes) == 2 && sizes[0] > sizes[1] {
-			check.invalidArg(call.Args[1].Pos(), "length and capacity swapped")
-			// safe to continue
-		}
-		x.mode = value
-		x.typ = T
-		if check.Types != nil {
-			params := [...]Type{T, Typ[Int], Typ[Int]}
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, params[:1+len(sizes)]...))
-		}
-
-	case _New:
-		// new(T)
-		// (no argument evaluated yet)
-		T := check.typ(call.Args[0])
-		if T == Typ[Invalid] {
-			return
-		}
-
-		x.mode = value
-		x.typ = &Pointer{base: T}
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
-		}
-
-	case _Panic:
-		// panic(x)
-		T := new(Interface)
-		if !check.assignment(x, T) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, T))
-		}
-
-	case _Print, _Println:
-		// print(x, y, ...)
-		// println(x, y, ...)
-		var params []Type
-		if nargs > 0 {
-			params = make([]Type, nargs)
-			for i := 0; i < nargs; i++ {
-				if i > 0 {
-					arg(x, i) // first argument already evaluated
-				}
-				if !check.assignment(x, nil) {
-					assert(x.mode == invalid)
-					return
-				}
-				params[i] = x.typ
-			}
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, params...))
-		}
-
-	case _Recover:
-		// recover() interface{}
-		x.mode = value
-		x.typ = new(Interface)
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ))
-		}
-
-	case _Alignof:
-		// unsafe.Alignof(x T) uintptr
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = constant
-		x.val = exact.MakeInt64(check.conf.alignof(x.typ))
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Offsetof:
-		// unsafe.Offsetof(x T) uintptr, where x must be a selector
-		// (no argument evaluated yet)
-		arg0 := call.Args[0]
-		selx, _ := unparen(arg0).(*ast.SelectorExpr)
-		if selx == nil {
-			check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
-			check.use(arg0)
-			return
-		}
-
-		check.expr(x, selx.X)
-		if x.mode == invalid {
-			return
-		}
-
-		base := derefStructPtr(x.typ)
-		sel := selx.Sel.Name
-		obj, index, indirect := LookupFieldOrMethod(base, false, check.pkg, sel)
-		switch obj.(type) {
-		case nil:
-			check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
-			return
-		case *Func:
-			// TODO(gri) Using derefStructPtr may result in methods being found
-			// that don't actually exist. An error either way, but the error
-			// message is confusing. See: http://play.golang.org/p/al75v23kUy ,
-			// but go/types reports: "invalid argument: x.m is a method value".
-			check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
-			return
-		}
-		if indirect {
-			check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
-			return
-		}
-
-		// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
-		check.recordSelection(selx, FieldVal, base, obj, index, false)
-
-		offs := check.conf.offsetof(base, index)
-		x.mode = constant
-		x.val = exact.MakeInt64(offs)
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Sizeof:
-		// unsafe.Sizeof(x T) uintptr
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = constant
-		x.val = exact.MakeInt64(check.conf.sizeof(x.typ))
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Assert:
-		// assert(pred) causes a typechecker error if pred is false.
-		// The result of assert is the value of pred if there is no error.
-		// Note: assert is only available in self-test mode.
-		if x.mode != constant || !isBoolean(x.typ) {
-			check.invalidArg(x.pos(), "%s is not a boolean constant", x)
-			return
-		}
-		if x.val.Kind() != exact.Bool {
-			check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
-			return
-		}
-		if !exact.BoolVal(x.val) {
-			check.errorf(call.Pos(), "%s failed", call)
-			// compile-time assertion failure - safe to continue
-		}
-		// result is constant - no need to record signature
-
-	case _Trace:
-		// trace(x, y, z, ...) dumps the positions, expressions, and
-		// values of its arguments. The result of trace is the value
-		// of the first argument.
-		// Note: trace is only available in self-test mode.
-		// (no argument evaluated yet)
-		if nargs == 0 {
-			check.dump("%s: trace() without arguments", call.Pos())
-			x.mode = novalue
-			break
-		}
-		var t operand
-		x1 := x
-		for _, arg := range call.Args {
-			check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
-			check.dump("%s: %s", x1.pos(), x1)
-			x1 = &t // use incoming x only for first argument
-		}
-		// trace is only available in test mode - no need to record signature
-
-	default:
-		unreachable()
-	}
-
-	return true
-}
-
-// makeSig makes a signature for the given argument and result types.
-// Default types are used for untyped arguments, and res may be nil.
-func makeSig(res Type, args ...Type) *Signature {
-	list := make([]*Var, len(args))
-	for i, param := range args {
-		list[i] = NewVar(token.NoPos, nil, "", defaultType(param))
-	}
-	params := NewTuple(list...)
-	var result *Tuple
-	if res != nil {
-		assert(!isUntyped(res))
-		result = NewTuple(NewVar(token.NoPos, nil, "", res))
-	}
-	return &Signature{params: params, results: result}
-}
-
-// implicitArrayDeref returns A if typ is of the form *A and A is an array;
-// otherwise it returns typ.
-//
-func implicitArrayDeref(typ Type) Type {
-	if p, ok := typ.(*Pointer); ok {
-		if a, ok := p.base.Underlying().(*Array); ok {
-			return a
-		}
-	}
-	return typ
-}
-
-// 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
-	}
-}
-
-func (check *Checker) complexArg(x *operand) bool {
-	t, _ := x.typ.Underlying().(*Basic)
-	if t != nil && (t.info&IsFloat != 0 || t.kind == UntypedInt || t.kind == UntypedRune) {
-		return true
-	}
-	check.invalidArg(x.pos(), "%s must be a float32, float64, or an untyped non-complex numeric constant", x)
-	return false
-}
diff --git a/vendor/golang.org/x/tools/go/types/call.go b/vendor/golang.org/x/tools/go/types/call.go
deleted file mode 100644
index 1e94212..0000000
--- a/vendor/golang.org/x/tools/go/types/call.go
+++ /dev/null
@@ -1,441 +0,0 @@
-// 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.
-
-// This file implements typechecking of call and selector expressions.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-)
-
-func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
-	check.exprOrType(x, e.Fun)
-
-	switch x.mode {
-	case invalid:
-		check.use(e.Args...)
-		x.mode = invalid
-		x.expr = e
-		return statement
-
-	case typexpr:
-		// conversion
-		T := x.typ
-		x.mode = invalid
-		switch n := len(e.Args); n {
-		case 0:
-			check.errorf(e.Rparen, "missing argument in conversion to %s", T)
-		case 1:
-			check.expr(x, e.Args[0])
-			if x.mode != invalid {
-				check.conversion(x, T)
-			}
-		default:
-			check.errorf(e.Args[n-1].Pos(), "too many arguments in conversion to %s", T)
-		}
-		x.expr = e
-		return conversion
-
-	case builtin:
-		id := x.id
-		if !check.builtin(x, e, id) {
-			x.mode = invalid
-		}
-		x.expr = e
-		// a non-constant result implies a function call
-		if x.mode != invalid && x.mode != constant {
-			check.hasCallOrRecv = true
-		}
-		return predeclaredFuncs[id].kind
-
-	default:
-		// function/method call
-		sig, _ := x.typ.Underlying().(*Signature)
-		if sig == nil {
-			check.invalidOp(x.pos(), "cannot call non-function %s", x)
-			x.mode = invalid
-			x.expr = e
-			return statement
-		}
-
-		arg, n, _ := unpack(func(x *operand, i int) { check.expr(x, e.Args[i]) }, len(e.Args), false)
-		if arg == nil {
-			x.mode = invalid
-			x.expr = e
-			return statement
-		}
-
-		check.arguments(x, e, sig, arg, n)
-
-		// determine result
-		switch sig.results.Len() {
-		case 0:
-			x.mode = novalue
-		case 1:
-			x.mode = value
-			x.typ = sig.results.vars[0].typ // unpack tuple
-		default:
-			x.mode = value
-			x.typ = sig.results
-		}
-		x.expr = e
-		check.hasCallOrRecv = true
-
-		return statement
-	}
-}
-
-// use type-checks each argument.
-// Useful to make sure expressions are evaluated
-// (and variables are "used") in the presence of other errors.
-func (check *Checker) use(arg ...ast.Expr) {
-	var x operand
-	for _, e := range arg {
-		check.rawExpr(&x, e, nil)
-	}
-}
-
-// useGetter is like use, but takes a getter instead of a list of expressions.
-// It should be called instead of use if a getter is present to avoid repeated
-// evaluation of the first argument (since the getter was likely obtained via
-// unpack, which may have evaluated the first argument already).
-func (check *Checker) useGetter(get getter, n int) {
-	var x operand
-	for i := 0; i < n; i++ {
-		get(&x, i)
-	}
-}
-
-// A getter sets x as the i'th operand, where 0 <= i < n and n is the total
-// number of operands (context-specific, and maintained elsewhere). A getter
-// type-checks the i'th operand; the details of the actual check are getter-
-// specific.
-type getter func(x *operand, i int)
-
-// unpack takes a getter get and a number of operands n. If n == 1, unpack
-// calls the incoming getter for the first operand. If that operand is
-// invalid, unpack returns (nil, 0, false). Otherwise, if that operand is a
-// function call, or a comma-ok expression and allowCommaOk is set, the result
-// is a new getter and operand count providing access to the function results,
-// or comma-ok values, respectively. The third result value reports if it
-// is indeed the comma-ok case. In all other cases, the incoming getter and
-// operand count are returned unchanged, and the third result value is false.
-//
-// In other words, if there's exactly one operand that - after type-checking
-// by calling get - stands for multiple operands, the resulting getter provides
-// access to those operands instead.
-//
-// If the returned getter is called at most once for a given operand index i
-// (including i == 0), that operand is guaranteed to cause only one call of
-// the incoming getter with that i.
-//
-func unpack(get getter, n int, allowCommaOk bool) (getter, int, bool) {
-	if n == 1 {
-		// possibly result of an n-valued function call or comma,ok value
-		var x0 operand
-		get(&x0, 0)
-		if x0.mode == invalid {
-			return nil, 0, false
-		}
-
-		if t, ok := x0.typ.(*Tuple); ok {
-			// result of an n-valued function call
-			return func(x *operand, i int) {
-				x.mode = value
-				x.expr = x0.expr
-				x.typ = t.At(i).typ
-			}, t.Len(), false
-		}
-
-		if x0.mode == mapindex || x0.mode == commaok {
-			// comma-ok value
-			if allowCommaOk {
-				a := [2]Type{x0.typ, Typ[UntypedBool]}
-				return func(x *operand, i int) {
-					x.mode = value
-					x.expr = x0.expr
-					x.typ = a[i]
-				}, 2, true
-			}
-			x0.mode = value
-		}
-
-		// single value
-		return func(x *operand, i int) {
-			if i != 0 {
-				unreachable()
-			}
-			*x = x0
-		}, 1, false
-	}
-
-	// zero or multiple values
-	return get, n, false
-}
-
-// arguments checks argument passing for the call with the given signature.
-// The arg function provides the operand for the i'th argument.
-func (check *Checker) arguments(x *operand, call *ast.CallExpr, sig *Signature, arg getter, n int) {
-	if call.Ellipsis.IsValid() {
-		// last argument is of the form x...
-		if len(call.Args) == 1 && n > 1 {
-			// f()... is not permitted if f() is multi-valued
-			check.errorf(call.Ellipsis, "cannot use ... with %d-valued expression %s", n, call.Args[0])
-			check.useGetter(arg, n)
-			return
-		}
-		if !sig.variadic {
-			check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun)
-			check.useGetter(arg, n)
-			return
-		}
-	}
-
-	// evaluate arguments
-	for i := 0; i < n; i++ {
-		arg(x, i)
-		if x.mode != invalid {
-			var ellipsis token.Pos
-			if i == n-1 && call.Ellipsis.IsValid() {
-				ellipsis = call.Ellipsis
-			}
-			check.argument(sig, i, x, ellipsis)
-		}
-	}
-
-	// check argument count
-	if sig.variadic {
-		// a variadic function accepts an "empty"
-		// last argument: count one extra
-		n++
-	}
-	if n < sig.params.Len() {
-		check.errorf(call.Rparen, "too few arguments in call to %s", call.Fun)
-		// ok to continue
-	}
-}
-
-// argument checks passing of argument x to the i'th parameter of the given signature.
-// If ellipsis is valid, the argument is followed by ... at that position in the call.
-func (check *Checker) argument(sig *Signature, i int, x *operand, ellipsis token.Pos) {
-	n := sig.params.Len()
-
-	// determine parameter type
-	var typ Type
-	switch {
-	case i < n:
-		typ = sig.params.vars[i].typ
-	case sig.variadic:
-		typ = sig.params.vars[n-1].typ
-		if debug {
-			if _, ok := typ.(*Slice); !ok {
-				check.dump("%s: expected unnamed slice type, got %s", sig.params.vars[n-1].Pos(), typ)
-			}
-		}
-	default:
-		check.errorf(x.pos(), "too many arguments")
-		return
-	}
-
-	if ellipsis.IsValid() {
-		// argument is of the form x...
-		if i != n-1 {
-			check.errorf(ellipsis, "can only use ... with matching parameter")
-			return
-		}
-		switch t := x.typ.Underlying().(type) {
-		case *Slice:
-			// ok
-		case *Tuple:
-			check.errorf(ellipsis, "cannot use ... with %d-valued expression %s", t.Len(), x)
-			return
-		default:
-			check.errorf(x.pos(), "cannot use %s as parameter of type %s", x, typ)
-			return
-		}
-	} else if sig.variadic && i >= n-1 {
-		// use the variadic parameter slice's element type
-		typ = typ.(*Slice).elem
-	}
-
-	if !check.assignment(x, typ) && x.mode != invalid {
-		check.errorf(x.pos(), "cannot pass argument %s to parameter of type %s", x, typ)
-	}
-}
-
-func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
-	// these must be declared before the "goto Error" statements
-	var (
-		obj      Object
-		index    []int
-		indirect bool
-	)
-
-	sel := e.Sel.Name
-	// If the identifier refers to a package, handle everything here
-	// so we don't need a "package" mode for operands: package names
-	// can only appear in qualified identifiers which are mapped to
-	// selector expressions.
-	if ident, ok := e.X.(*ast.Ident); ok {
-		_, obj := check.scope.LookupParent(ident.Name, check.pos)
-		if pkg, _ := obj.(*PkgName); pkg != nil {
-			assert(pkg.pkg == check.pkg)
-			check.recordUse(ident, pkg)
-			pkg.used = true
-			exp := pkg.imported.scope.Lookup(sel)
-			if exp == nil {
-				if !pkg.imported.fake {
-					check.errorf(e.Pos(), "%s not declared by package %s", sel, ident)
-				}
-				goto Error
-			}
-			if !exp.Exported() {
-				check.errorf(e.Pos(), "%s not exported by package %s", sel, ident)
-				// ok to continue
-			}
-			check.recordUse(e.Sel, exp)
-			// Simplified version of the code for *ast.Idents:
-			// - imported objects are always fully initialized
-			switch exp := exp.(type) {
-			case *Const:
-				assert(exp.Val() != nil)
-				x.mode = constant
-				x.typ = exp.typ
-				x.val = exp.val
-			case *TypeName:
-				x.mode = typexpr
-				x.typ = exp.typ
-			case *Var:
-				x.mode = variable
-				x.typ = exp.typ
-			case *Func:
-				x.mode = value
-				x.typ = exp.typ
-			case *Builtin:
-				x.mode = builtin
-				x.typ = exp.typ
-				x.id = exp.id
-			default:
-				unreachable()
-			}
-			x.expr = e
-			return
-		}
-	}
-
-	check.exprOrType(x, e.X)
-	if x.mode == invalid {
-		goto Error
-	}
-
-	obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel)
-	if obj == nil {
-		switch {
-		case index != nil:
-			// TODO(gri) should provide actual type where the conflict happens
-			check.invalidOp(e.Pos(), "ambiguous selector %s", sel)
-		case indirect:
-			check.invalidOp(e.Pos(), "%s is not in method set of %s", sel, x.typ)
-		default:
-			check.invalidOp(e.Pos(), "%s has no field or method %s", x, sel)
-		}
-		goto Error
-	}
-
-	if x.mode == typexpr {
-		// method expression
-		m, _ := obj.(*Func)
-		if m == nil {
-			check.invalidOp(e.Pos(), "%s has no method %s", x, sel)
-			goto Error
-		}
-
-		check.recordSelection(e, MethodExpr, x.typ, m, index, indirect)
-
-		// the receiver type becomes the type of the first function
-		// argument of the method expression's function type
-		var params []*Var
-		sig := m.typ.(*Signature)
-		if sig.params != nil {
-			params = sig.params.vars
-		}
-		x.mode = value
-		x.typ = &Signature{
-			params:   NewTuple(append([]*Var{NewVar(token.NoPos, check.pkg, "", x.typ)}, params...)...),
-			results:  sig.results,
-			variadic: sig.variadic,
-		}
-
-		check.addDeclDep(m)
-
-	} else {
-		// regular selector
-		switch obj := obj.(type) {
-		case *Var:
-			check.recordSelection(e, FieldVal, x.typ, obj, index, indirect)
-			if x.mode == variable || indirect {
-				x.mode = variable
-			} else {
-				x.mode = value
-			}
-			x.typ = obj.typ
-
-		case *Func:
-			// TODO(gri) If we needed to take into account the receiver's
-			// addressability, should we report the type &(x.typ) instead?
-			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
-
-			if debug {
-				// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
-				typ := x.typ
-				if x.mode == variable {
-					// If typ is not an (unnamed) pointer or an interface,
-					// use *typ instead, because the method set of *typ
-					// includes the methods of typ.
-					// Variables are addressable, so we can always take their
-					// address.
-					if _, ok := typ.(*Pointer); !ok && !IsInterface(typ) {
-						typ = &Pointer{base: typ}
-					}
-				}
-				// If we created a synthetic pointer type above, we will throw
-				// away the method set computed here after use.
-				// TODO(gri) Method set computation should probably always compute
-				// both, the value and the pointer receiver method set and represent
-				// them in a single structure.
-				// TODO(gri) Consider also using a method set cache for the lifetime
-				// of checker once we rely on MethodSet lookup instead of individual
-				// lookup.
-				mset := NewMethodSet(typ)
-				if m := mset.Lookup(check.pkg, sel); m == nil || m.obj != obj {
-					check.dump("%s: (%s).%v -> %s", e.Pos(), typ, obj.name, m)
-					check.dump("%s\n", mset)
-					panic("method sets and lookup don't agree")
-				}
-			}
-
-			x.mode = value
-
-			// remove receiver
-			sig := *obj.typ.(*Signature)
-			sig.recv = nil
-			x.typ = &sig
-
-			check.addDeclDep(obj)
-
-		default:
-			unreachable()
-		}
-	}
-
-	// everything went well
-	x.expr = e
-	return
-
-Error:
-	x.mode = invalid
-	x.expr = e
-}
diff --git a/vendor/golang.org/x/tools/go/types/check.go b/vendor/golang.org/x/tools/go/types/check.go
deleted file mode 100644
index 964d2bd..0000000
--- a/vendor/golang.org/x/tools/go/types/check.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements the Check function, which drives type-checking.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// debugging/development support
-const (
-	debug = false // leave on during development
-	trace = false // turn on for detailed type resolution traces
-)
-
-// If Strict is set, the type-checker enforces additional
-// rules not specified by the Go 1 spec, but which will
-// catch guaranteed run-time errors if the respective
-// code is executed. In other words, programs passing in
-// Strict mode are Go 1 compliant, but not all Go 1 programs
-// will pass in Strict mode. The additional rules are:
-//
-// - A type assertion x.(T) where T is an interface type
-//   is invalid if any (statically known) method that exists
-//   for both x and T have different signatures.
-//
-const strict = false
-
-// exprInfo stores information about an untyped expression.
-type exprInfo struct {
-	isLhs bool // expression is lhs operand of a shift with delayed type-check
-	mode  operandMode
-	typ   *Basic
-	val   exact.Value // constant value; or nil (if not a constant)
-}
-
-// funcInfo stores the information required for type-checking a function.
-type funcInfo struct {
-	name string    // for debugging/tracing only
-	decl *declInfo // for cycle detection
-	sig  *Signature
-	body *ast.BlockStmt
-}
-
-// A context represents the context within which an object is type-checked.
-type context struct {
-	decl          *declInfo   // package-level declaration whose init expression/function body is checked
-	scope         *Scope      // top-most scope for lookups
-	iota          exact.Value // value of iota in a constant declaration; nil otherwise
-	sig           *Signature  // function signature if inside a function; nil otherwise
-	hasLabel      bool        // set if a function makes use of labels (only ~1% of functions); unused outside functions
-	hasCallOrRecv bool        // set if an expression contains a function call or channel receive operation
-}
-
-// A Checker maintains the state of the type checker.
-// It must be created with NewChecker.
-type Checker struct {
-	// package information
-	// (initialized by NewChecker, valid for the life-time of checker)
-	conf *Config
-	fset *token.FileSet
-	pkg  *Package
-	*Info
-	objMap map[Object]*declInfo // maps package-level object to declaration info
-
-	// information collected during type-checking of a set of package files
-	// (initialized by Files, valid only for the duration of check.Files;
-	// maps and lists are allocated on demand)
-	files            []*ast.File                       // package files
-	unusedDotImports map[*Scope]map[*Package]token.Pos // positions of unused dot-imported packages for each file scope
-
-	firstErr error                 // first error encountered
-	methods  map[string][]*Func    // maps type names to associated methods
-	untyped  map[ast.Expr]exprInfo // map of expressions without final type
-	funcs    []funcInfo            // list of functions to type-check
-	delayed  []func()              // delayed checks requiring fully setup types
-
-	// context within which the current object is type-checked
-	// (valid only for the duration of type-checking a specific object)
-	context
-	pos token.Pos // if valid, identifiers are looked up as if at position pos (used by Eval)
-
-	// debugging
-	indent int // indentation for tracing
-}
-
-// addUnusedImport adds the position of a dot-imported package
-// pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, pos token.Pos) {
-	mm := check.unusedDotImports
-	if mm == nil {
-		mm = make(map[*Scope]map[*Package]token.Pos)
-		check.unusedDotImports = mm
-	}
-	m := mm[scope]
-	if m == nil {
-		m = make(map[*Package]token.Pos)
-		mm[scope] = m
-	}
-	m[pkg] = pos
-}
-
-// addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
-func (check *Checker) addDeclDep(to Object) {
-	from := check.decl
-	if from == nil {
-		return // not in a package-level init expression
-	}
-	if _, found := check.objMap[to]; !found {
-		return // to is not a package-level object
-	}
-	from.addDep(to)
-}
-
-func (check *Checker) assocMethod(tname string, meth *Func) {
-	m := check.methods
-	if m == nil {
-		m = make(map[string][]*Func)
-		check.methods = m
-	}
-	m[tname] = append(m[tname], meth)
-}
-
-func (check *Checker) rememberUntyped(e ast.Expr, lhs bool, mode operandMode, typ *Basic, val exact.Value) {
-	m := check.untyped
-	if m == nil {
-		m = make(map[ast.Expr]exprInfo)
-		check.untyped = m
-	}
-	m[e] = exprInfo{lhs, mode, typ, val}
-}
-
-func (check *Checker) later(name string, decl *declInfo, sig *Signature, body *ast.BlockStmt) {
-	check.funcs = append(check.funcs, funcInfo{name, decl, sig, body})
-}
-
-func (check *Checker) delay(f func()) {
-	check.delayed = append(check.delayed, f)
-}
-
-// NewChecker returns a new Checker instance for a given package.
-// Package files may be added incrementally via checker.Files.
-func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker {
-	// make sure we have a configuration
-	if conf == nil {
-		conf = new(Config)
-	}
-
-	// make sure we have a package canonicalization map
-	if conf.Packages == nil {
-		conf.Packages = make(map[string]*Package)
-	}
-
-	// make sure we have an info struct
-	if info == nil {
-		info = new(Info)
-	}
-
-	return &Checker{
-		conf:   conf,
-		fset:   fset,
-		pkg:    pkg,
-		Info:   info,
-		objMap: make(map[Object]*declInfo),
-	}
-}
-
-// initFiles initializes the files-specific portion of checker.
-// The provided files must all belong to the same package.
-func (check *Checker) initFiles(files []*ast.File) {
-	// start with a clean slate (check.Files may be called multiple times)
-	check.files = nil
-	check.unusedDotImports = nil
-
-	check.firstErr = nil
-	check.methods = nil
-	check.untyped = nil
-	check.funcs = nil
-	check.delayed = nil
-
-	// determine package name and collect valid files
-	pkg := check.pkg
-	for _, file := range files {
-		switch name := file.Name.Name; pkg.name {
-		case "":
-			if name != "_" {
-				pkg.name = name
-			} else {
-				check.errorf(file.Name.Pos(), "invalid package name _")
-			}
-			fallthrough
-
-		case name:
-			check.files = append(check.files, file)
-
-		default:
-			check.errorf(file.Package, "package %s; expected %s", name, pkg.name)
-			// ignore this file
-		}
-	}
-}
-
-// A bailout panic is used for early termination.
-type bailout struct{}
-
-func (check *Checker) handleBailout(err *error) {
-	switch p := recover().(type) {
-	case nil, bailout:
-		// normal return or early exit
-		*err = check.firstErr
-	default:
-		// re-panic
-		panic(p)
-	}
-}
-
-// Files checks the provided files as part of the checker's package.
-func (check *Checker) Files(files []*ast.File) (err error) {
-	defer check.handleBailout(&err)
-
-	check.initFiles(files)
-
-	check.collectObjects()
-
-	check.packageObjects(check.resolveOrder())
-
-	check.functionBodies()
-
-	check.initOrder()
-
-	if !check.conf.DisableUnusedImportCheck {
-		check.unusedImports()
-	}
-
-	// perform delayed checks
-	for _, f := range check.delayed {
-		f()
-	}
-
-	check.recordUntyped()
-
-	check.pkg.complete = true
-	return
-}
-
-func (check *Checker) recordUntyped() {
-	if !debug && check.Types == nil {
-		return // nothing to do
-	}
-
-	for x, info := range check.untyped {
-		if debug && isTyped(info.typ) {
-			check.dump("%s: %s (type %s) is typed", x.Pos(), x, info.typ)
-			unreachable()
-		}
-		check.recordTypeAndValue(x, info.mode, info.typ, info.val)
-	}
-}
-
-func (check *Checker) recordTypeAndValue(x ast.Expr, mode operandMode, typ Type, val exact.Value) {
-	assert(x != nil)
-	assert(typ != nil)
-	if mode == invalid {
-		return // omit
-	}
-	assert(typ != nil)
-	if mode == constant {
-		assert(val != nil)
-		assert(typ == Typ[Invalid] || isConstType(typ))
-	}
-	if m := check.Types; m != nil {
-		m[x] = TypeAndValue{mode, typ, val}
-	}
-}
-
-func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
-	// f must be a (possibly parenthesized) identifier denoting a built-in
-	// (built-ins in package unsafe always produce a constant result and
-	// we don't record their signatures, so we don't see qualified idents
-	// here): record the signature for f and possible children.
-	for {
-		check.recordTypeAndValue(f, builtin, sig, nil)
-		switch p := f.(type) {
-		case *ast.Ident:
-			return // we're done
-		case *ast.ParenExpr:
-			f = p.X
-		default:
-			unreachable()
-		}
-	}
-}
-
-func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) {
-	assert(x != nil)
-	if a[0] == nil || a[1] == nil {
-		return
-	}
-	assert(isTyped(a[0]) && isTyped(a[1]) && isBoolean(a[1]))
-	if m := check.Types; m != nil {
-		for {
-			tv := m[x]
-			assert(tv.Type != nil) // should have been recorded already
-			pos := x.Pos()
-			tv.Type = NewTuple(
-				NewVar(pos, check.pkg, "", a[0]),
-				NewVar(pos, check.pkg, "", a[1]),
-			)
-			m[x] = tv
-			// if x is a parenthesized expression (p.X), update p.X
-			p, _ := x.(*ast.ParenExpr)
-			if p == nil {
-				break
-			}
-			x = p.X
-		}
-	}
-}
-
-func (check *Checker) recordDef(id *ast.Ident, obj Object) {
-	assert(id != nil)
-	if m := check.Defs; m != nil {
-		m[id] = obj
-	}
-}
-
-func (check *Checker) recordUse(id *ast.Ident, obj Object) {
-	assert(id != nil)
-	assert(obj != nil)
-	if m := check.Uses; m != nil {
-		m[id] = obj
-	}
-}
-
-func (check *Checker) recordImplicit(node ast.Node, obj Object) {
-	assert(node != nil)
-	assert(obj != nil)
-	if m := check.Implicits; m != nil {
-		m[node] = obj
-	}
-}
-
-func (check *Checker) recordSelection(x *ast.SelectorExpr, kind SelectionKind, recv Type, obj Object, index []int, indirect bool) {
-	assert(obj != nil && (recv == nil || len(index) > 0))
-	check.recordUse(x.Sel, obj)
-	// TODO(gri) Should we also call recordTypeAndValue?
-	if m := check.Selections; m != nil {
-		m[x] = &Selection{kind, recv, obj, index, indirect}
-	}
-}
-
-func (check *Checker) recordScope(node ast.Node, scope *Scope) {
-	assert(node != nil)
-	assert(scope != nil)
-	if m := check.Scopes; m != nil {
-		m[node] = scope
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/conversions.go b/vendor/golang.org/x/tools/go/types/conversions.go
deleted file mode 100644
index 6e279ca..0000000
--- a/vendor/golang.org/x/tools/go/types/conversions.go
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of conversions.
-
-package types
-
-import "golang.org/x/tools/go/exact"
-
-// Conversion type-checks the conversion T(x).
-// The result is in x.
-func (check *Checker) conversion(x *operand, T Type) {
-	constArg := x.mode == constant
-
-	var ok bool
-	switch {
-	case constArg && isConstType(T):
-		// constant conversion
-		switch t := T.Underlying().(*Basic); {
-		case representableConst(x.val, check.conf, t.kind, &x.val):
-			ok = true
-		case isInteger(x.typ) && isString(t):
-			codepoint := int64(-1)
-			if i, ok := exact.Int64Val(x.val); ok {
-				codepoint = i
-			}
-			// If codepoint < 0 the absolute value is too large (or unknown) for
-			// conversion. This is the same as converting any other out-of-range
-			// value - let string(codepoint) do the work.
-			x.val = exact.MakeString(string(codepoint))
-			ok = true
-		}
-	case x.convertibleTo(check.conf, T):
-		// non-constant conversion
-		x.mode = value
-		ok = true
-	}
-
-	if !ok {
-		check.errorf(x.pos(), "cannot convert %s to %s", x, T)
-		x.mode = invalid
-		return
-	}
-
-	// The conversion argument types are final. For untyped values the
-	// conversion provides the type, per the spec: "A constant may be
-	// given a type explicitly by a constant declaration or conversion,...".
-	final := x.typ
-	if isUntyped(x.typ) {
-		final = T
-		// - For conversions to interfaces, use the argument's default type.
-		// - For conversions of untyped constants to non-constant types, also
-		//   use the default type (e.g., []byte("foo") should report string
-		//   not []byte as type for the constant "foo").
-		// - Keep untyped nil for untyped nil arguments.
-		if IsInterface(T) || constArg && !isConstType(T) {
-			final = defaultType(x.typ)
-		}
-		check.updateExprType(x.expr, final, true)
-	}
-
-	x.typ = T
-}
-
-func (x *operand) convertibleTo(conf *Config, T Type) bool {
-	// "x is assignable to T"
-	if x.assignableTo(conf, T) {
-		return true
-	}
-
-	// "x's type and T have identical underlying types"
-	V := x.typ
-	Vu := V.Underlying()
-	Tu := T.Underlying()
-	if Identical(Vu, Tu) {
-		return true
-	}
-
-	// "x's type and T are unnamed pointer types and their pointer base types have identical underlying types"
-	if V, ok := V.(*Pointer); ok {
-		if T, ok := T.(*Pointer); ok {
-			if Identical(V.base.Underlying(), T.base.Underlying()) {
-				return true
-			}
-		}
-	}
-
-	// "x's type and T are both integer or floating point types"
-	if (isInteger(V) || isFloat(V)) && (isInteger(T) || isFloat(T)) {
-		return true
-	}
-
-	// "x's type and T are both complex types"
-	if isComplex(V) && isComplex(T) {
-		return true
-	}
-
-	// "x is an integer or a slice of bytes or runes and T is a string type"
-	if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) {
-		return true
-	}
-
-	// "x is a string and T is a slice of bytes or runes"
-	if isString(V) && isBytesOrRunes(Tu) {
-		return true
-	}
-
-	// package unsafe:
-	// "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer"
-	if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(T) {
-		return true
-	}
-	// "and vice versa"
-	if isUnsafePointer(V) && (isPointer(Tu) || isUintptr(Tu)) {
-		return true
-	}
-
-	return false
-}
-
-func isUintptr(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == Uintptr
-}
-
-func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this (typ.Underlying() instead of just typ) correct?
-	//            The spec does not say so, but gc claims it is. See also
-	//            issue 6326.
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == UnsafePointer
-}
-
-func isPointer(typ Type) bool {
-	_, ok := typ.Underlying().(*Pointer)
-	return ok
-}
-
-func isBytesOrRunes(typ Type) bool {
-	if s, ok := typ.(*Slice); ok {
-		t, ok := s.elem.Underlying().(*Basic)
-		return ok && (t.kind == Byte || t.kind == Rune)
-	}
-	return false
-}
diff --git a/vendor/golang.org/x/tools/go/types/decl.go b/vendor/golang.org/x/tools/go/types/decl.go
deleted file mode 100644
index 9eba85c..0000000
--- a/vendor/golang.org/x/tools/go/types/decl.go
+++ /dev/null
@@ -1,431 +0,0 @@
-// 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 types
-
-import (
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-func (check *Checker) reportAltDecl(obj Object) {
-	if pos := obj.Pos(); pos.IsValid() {
-		// We use "other" rather than "previous" here because
-		// the first declaration seen may not be textually
-		// earlier in the source.
-		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
-	}
-}
-
-func (check *Checker) declare(scope *Scope, id *ast.Ident, obj Object, pos token.Pos) {
-	// spec: "The blank identifier, represented by the underscore
-	// character _, may be used in a declaration like any other
-	// identifier but the declaration does not introduce a new
-	// binding."
-	if obj.Name() != "_" {
-		if alt := scope.Insert(obj); alt != nil {
-			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
-			check.reportAltDecl(alt)
-			return
-		}
-		obj.setScopePos(pos)
-	}
-	if id != nil {
-		check.recordDef(id, obj)
-	}
-}
-
-// objDecl type-checks the declaration of obj in its respective (file) context.
-// See check.typ for the details on def and path.
-func (check *Checker) objDecl(obj Object, def *Named, path []*TypeName) {
-	if obj.Type() != nil {
-		return // already checked - nothing to do
-	}
-
-	if trace {
-		check.trace(obj.Pos(), "-- declaring %s", obj.Name())
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(obj.Pos(), "=> %s", obj)
-		}()
-	}
-
-	d := check.objMap[obj]
-	if d == nil {
-		check.dump("%s: %s should have been declared", obj.Pos(), obj.Name())
-		unreachable()
-	}
-
-	// save/restore current context and setup object context
-	defer func(ctxt context) {
-		check.context = ctxt
-	}(check.context)
-	check.context = context{
-		scope: d.file,
-	}
-
-	// Const and var declarations must not have initialization
-	// cycles. We track them by remembering the current declaration
-	// in check.decl. Initialization expressions depending on other
-	// consts, vars, or functions, add dependencies to the current
-	// check.decl.
-	switch obj := obj.(type) {
-	case *Const:
-		check.decl = d // new package-level const decl
-		check.constDecl(obj, d.typ, d.init)
-	case *Var:
-		check.decl = d // new package-level var decl
-		check.varDecl(obj, d.lhs, d.typ, d.init)
-	case *TypeName:
-		// invalid recursive types are detected via path
-		check.typeDecl(obj, d.typ, def, path)
-	case *Func:
-		// functions may be recursive - no need to track dependencies
-		check.funcDecl(obj, d)
-	default:
-		unreachable()
-	}
-}
-
-func (check *Checker) constDecl(obj *Const, typ, init ast.Expr) {
-	assert(obj.typ == nil)
-
-	if obj.visited {
-		obj.typ = Typ[Invalid]
-		return
-	}
-	obj.visited = true
-
-	// use the correct value of iota
-	assert(check.iota == nil)
-	check.iota = obj.val
-	defer func() { check.iota = nil }()
-
-	// provide valid constant value under all circumstances
-	obj.val = exact.MakeUnknown()
-
-	// determine type, if any
-	if typ != nil {
-		t := check.typ(typ)
-		if !isConstType(t) {
-			check.errorf(typ.Pos(), "invalid constant type %s", t)
-			obj.typ = Typ[Invalid]
-			return
-		}
-		obj.typ = t
-	}
-
-	// check initialization
-	var x operand
-	if init != nil {
-		check.expr(&x, init)
-	}
-	check.initConst(obj, &x)
-}
-
-func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
-	assert(obj.typ == nil)
-
-	if obj.visited {
-		obj.typ = Typ[Invalid]
-		return
-	}
-	obj.visited = true
-
-	// var declarations cannot use iota
-	assert(check.iota == nil)
-
-	// determine type, if any
-	if typ != nil {
-		obj.typ = check.typ(typ)
-	}
-
-	// check initialization
-	if init == nil {
-		if typ == nil {
-			// error reported before by arityMatch
-			obj.typ = Typ[Invalid]
-		}
-		return
-	}
-
-	if lhs == nil || len(lhs) == 1 {
-		assert(lhs == nil || lhs[0] == obj)
-		var x operand
-		check.expr(&x, init)
-		check.initVar(obj, &x, false)
-		return
-	}
-
-	if debug {
-		// obj must be one of lhs
-		found := false
-		for _, lhs := range lhs {
-			if obj == lhs {
-				found = true
-				break
-			}
-		}
-		if !found {
-			panic("inconsistent lhs")
-		}
-	}
-	check.initVars(lhs, []ast.Expr{init}, token.NoPos)
-}
-
-// underlying returns the underlying type of typ; possibly by following
-// forward chains of named types. Such chains only exist while named types
-// are incomplete.
-func underlying(typ Type) Type {
-	for {
-		n, _ := typ.(*Named)
-		if n == nil {
-			break
-		}
-		typ = n.underlying
-	}
-	return typ
-}
-
-func (n *Named) setUnderlying(typ Type) {
-	if n != nil {
-		n.underlying = typ
-	}
-}
-
-func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, path []*TypeName) {
-	assert(obj.typ == nil)
-
-	// type declarations cannot use iota
-	assert(check.iota == nil)
-
-	named := &Named{obj: obj}
-	def.setUnderlying(named)
-	obj.typ = named // make sure recursive type declarations terminate
-
-	// determine underlying type of named
-	check.typExpr(typ, named, append(path, obj))
-
-	// The underlying type of named may be itself a named type that is
-	// incomplete:
-	//
-	//	type (
-	//		A B
-	//		B *C
-	//		C A
-	//	)
-	//
-	// The type of C is the (named) type of A which is incomplete,
-	// and which has as its underlying type the named type B.
-	// Determine the (final, unnamed) underlying type by resolving
-	// any forward chain (they always end in an unnamed type).
-	named.underlying = underlying(named.underlying)
-
-	// check and add associated methods
-	// TODO(gri) It's easy to create pathological cases where the
-	// current approach is incorrect: In general we need to know
-	// and add all methods _before_ type-checking the type.
-	// See http://play.golang.org/p/WMpE0q2wK8
-	check.addMethodDecls(obj)
-}
-
-func (check *Checker) addMethodDecls(obj *TypeName) {
-	// get associated methods
-	methods := check.methods[obj.name]
-	if len(methods) == 0 {
-		return // no methods
-	}
-	delete(check.methods, obj.name)
-
-	// use an objset to check for name conflicts
-	var mset objset
-
-	// spec: "If the base type is a struct type, the non-blank method
-	// and field names must be distinct."
-	base := obj.typ.(*Named)
-	if t, _ := base.underlying.(*Struct); t != nil {
-		for _, fld := range t.fields {
-			if fld.name != "_" {
-				assert(mset.insert(fld) == nil)
-			}
-		}
-	}
-
-	// Checker.Files may be called multiple times; additional package files
-	// may add methods to already type-checked types. Add pre-existing methods
-	// so that we can detect redeclarations.
-	for _, m := range base.methods {
-		assert(m.name != "_")
-		assert(mset.insert(m) == nil)
-	}
-
-	// type-check methods
-	for _, m := range methods {
-		// spec: "For a base type, the non-blank names of methods bound
-		// to it must be unique."
-		if m.name != "_" {
-			if alt := mset.insert(m); alt != nil {
-				switch alt.(type) {
-				case *Var:
-					check.errorf(m.pos, "field and method with the same name %s", m.name)
-				case *Func:
-					check.errorf(m.pos, "method %s already declared for %s", m.name, base)
-				default:
-					unreachable()
-				}
-				check.reportAltDecl(alt)
-				continue
-			}
-		}
-		check.objDecl(m, nil, nil)
-		// methods with blank _ names cannot be found - don't keep them
-		if m.name != "_" {
-			base.methods = append(base.methods, m)
-		}
-	}
-}
-
-func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
-	assert(obj.typ == nil)
-
-	// func declarations cannot use iota
-	assert(check.iota == nil)
-
-	sig := new(Signature)
-	obj.typ = sig // guard against cycles
-	fdecl := decl.fdecl
-	check.funcType(sig, fdecl.Recv, fdecl.Type)
-	if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
-		check.errorf(fdecl.Pos(), "func init must have no arguments and no return values")
-		// ok to continue
-	}
-
-	// function body must be type-checked after global declarations
-	// (functions implemented elsewhere have no body)
-	if !check.conf.IgnoreFuncBodies && fdecl.Body != nil {
-		check.later(obj.name, decl, sig, fdecl.Body)
-	}
-}
-
-func (check *Checker) declStmt(decl ast.Decl) {
-	pkg := check.pkg
-
-	switch d := decl.(type) {
-	case *ast.BadDecl:
-		// ignore
-
-	case *ast.GenDecl:
-		var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-		for iota, spec := range d.Specs {
-			switch s := spec.(type) {
-			case *ast.ValueSpec:
-				switch d.Tok {
-				case token.CONST:
-					// determine which init exprs to use
-					switch {
-					case s.Type != nil || len(s.Values) > 0:
-						last = s
-					case last == nil:
-						last = new(ast.ValueSpec) // make sure last exists
-					}
-
-					// declare all constants
-					lhs := make([]*Const, len(s.Names))
-					for i, name := range s.Names {
-						obj := NewConst(name.Pos(), pkg, name.Name, nil, exact.MakeInt64(int64(iota)))
-						lhs[i] = obj
-
-						var init ast.Expr
-						if i < len(last.Values) {
-							init = last.Values[i]
-						}
-
-						check.constDecl(obj, last.Type, init)
-					}
-
-					check.arityMatch(s, last)
-
-					// spec: "The scope of a constant or variable identifier declared
-					// inside a function begins at the end of the ConstSpec or VarSpec
-					// (ShortVarDecl for short variable declarations) and ends at the
-					// end of the innermost containing block."
-					scopePos := s.End()
-					for i, name := range s.Names {
-						check.declare(check.scope, name, lhs[i], scopePos)
-					}
-
-				case token.VAR:
-					lhs0 := make([]*Var, len(s.Names))
-					for i, name := range s.Names {
-						lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
-					}
-
-					// initialize all variables
-					for i, obj := range lhs0 {
-						var lhs []*Var
-						var init ast.Expr
-						switch len(s.Values) {
-						case len(s.Names):
-							// lhs and rhs match
-							init = s.Values[i]
-						case 1:
-							// rhs is expected to be a multi-valued expression
-							lhs = lhs0
-							init = s.Values[0]
-						default:
-							if i < len(s.Values) {
-								init = s.Values[i]
-							}
-						}
-						check.varDecl(obj, lhs, s.Type, init)
-						if len(s.Values) == 1 {
-							// If we have a single lhs variable we are done either way.
-							// If we have a single rhs expression, it must be a multi-
-							// valued expression, in which case handling the first lhs
-							// variable will cause all lhs variables to have a type
-							// assigned, and we are done as well.
-							if debug {
-								for _, obj := range lhs0 {
-									assert(obj.typ != nil)
-								}
-							}
-							break
-						}
-					}
-
-					check.arityMatch(s, nil)
-
-					// declare all variables
-					// (only at this point are the variable scopes (parents) set)
-					scopePos := s.End() // see constant declarations
-					for i, name := range s.Names {
-						// see constant declarations
-						check.declare(check.scope, name, lhs0[i], scopePos)
-					}
-
-				default:
-					check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
-				}
-
-			case *ast.TypeSpec:
-				obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-				// spec: "The scope of a type identifier declared inside a function
-				// begins at the identifier in the TypeSpec and ends at the end of
-				// the innermost containing block."
-				scopePos := s.Name.Pos()
-				check.declare(check.scope, s.Name, obj, scopePos)
-				check.typeDecl(obj, s.Type, nil, nil)
-
-			default:
-				check.invalidAST(s.Pos(), "const, type, or var declaration expected")
-			}
-		}
-
-	default:
-		check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/errors.go b/vendor/golang.org/x/tools/go/types/errors.go
deleted file mode 100644
index 0c0049b..0000000
--- a/vendor/golang.org/x/tools/go/types/errors.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements various error reporters.
-
-package types
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"strings"
-)
-
-func assert(p bool) {
-	if !p {
-		panic("assertion failed")
-	}
-}
-
-func unreachable() {
-	panic("unreachable")
-}
-
-func (check *Checker) qualifier(pkg *Package) string {
-	if pkg != check.pkg {
-		return pkg.path
-	}
-	return ""
-}
-
-func (check *Checker) sprintf(format string, args ...interface{}) string {
-	for i, arg := range args {
-		switch a := arg.(type) {
-		case nil:
-			arg = "<nil>"
-		case operand:
-			panic("internal error: should always pass *operand")
-		case *operand:
-			arg = operandString(a, check.qualifier)
-		case token.Pos:
-			arg = check.fset.Position(a).String()
-		case ast.Expr:
-			arg = ExprString(a)
-		case Object:
-			arg = ObjectString(a, check.qualifier)
-		case Type:
-			arg = TypeString(a, check.qualifier)
-		}
-		args[i] = arg
-	}
-	return fmt.Sprintf(format, args...)
-}
-
-func (check *Checker) trace(pos token.Pos, format string, args ...interface{}) {
-	fmt.Printf("%s:\t%s%s\n",
-		check.fset.Position(pos),
-		strings.Repeat(".  ", check.indent),
-		check.sprintf(format, args...),
-	)
-}
-
-// dump is only needed for debugging
-func (check *Checker) dump(format string, args ...interface{}) {
-	fmt.Println(check.sprintf(format, args...))
-}
-
-func (check *Checker) err(pos token.Pos, msg string, soft bool) {
-	err := Error{check.fset, pos, msg, soft}
-	if check.firstErr == nil {
-		check.firstErr = err
-	}
-	f := check.conf.Error
-	if f == nil {
-		panic(bailout{}) // report only first error
-	}
-	f(err)
-}
-
-func (check *Checker) error(pos token.Pos, msg string) {
-	check.err(pos, msg, false)
-}
-
-func (check *Checker) errorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), false)
-}
-
-func (check *Checker) softErrorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), true)
-}
-
-func (check *Checker) invalidAST(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid AST: "+format, args...)
-}
-
-func (check *Checker) invalidArg(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid argument: "+format, args...)
-}
-
-func (check *Checker) invalidOp(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid operation: "+format, args...)
-}
diff --git a/vendor/golang.org/x/tools/go/types/eval.go b/vendor/golang.org/x/tools/go/types/eval.go
deleted file mode 100644
index c09f2a3..0000000
--- a/vendor/golang.org/x/tools/go/types/eval.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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 types
-
-import (
-	"fmt"
-	"go/parser"
-	"go/token"
-)
-
-// Eval returns the type and, if constant, the value for the
-// expression expr, evaluated at position pos of package pkg,
-// which must have been derived from type-checking an AST with
-// complete position information relative to the provided file
-// set.
-//
-// If the expression contains function literals, their bodies
-// are ignored (i.e., the bodies are not type-checked).
-//
-// If pkg == nil, the Universe scope is used and the provided
-// position pos is ignored. If pkg != nil, and pos is invalid,
-// the package scope is used. Otherwise, pos must belong to the
-// package.
-//
-// An error is returned if pos is not within the package or
-// if the node cannot be evaluated.
-//
-// Note: Eval should not be used instead of running Check to compute
-// types and values, but in addition to Check. Eval will re-evaluate
-// its argument each time, and it also does not know about the context
-// in which an expression is used (e.g., an assignment). Thus, top-
-// level untyped constants will return an untyped type rather then the
-// respective context-specific type.
-//
-func Eval(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (tv TypeAndValue, err error) {
-	// determine scope
-	var scope *Scope
-	if pkg == nil {
-		scope = Universe
-		pos = token.NoPos
-	} else if !pos.IsValid() {
-		scope = pkg.scope
-	} else {
-		// The package scope extent (position information) may be
-		// incorrect (files spread accross a wide range of fset
-		// positions) - ignore it and just consider its children
-		// (file scopes).
-		for _, fscope := range pkg.scope.children {
-			if scope = fscope.Innermost(pos); scope != nil {
-				break
-			}
-		}
-		if scope == nil || debug {
-			s := scope
-			for s != nil && s != pkg.scope {
-				s = s.parent
-			}
-			// s == nil || s == pkg.scope
-			if s == nil {
-				return TypeAndValue{}, fmt.Errorf("no position %s found in package %s", fset.Position(pos), pkg.name)
-			}
-		}
-	}
-
-	// parse expressions
-	// BUG(gri) In case of type-checking errors below, the type checker
-	//          doesn't have the correct file set for expr. The correct
-	//          solution requires a ParseExpr that uses the incoming
-	//          file set fset.
-	node, err := parser.ParseExpr(expr)
-	if err != nil {
-		return TypeAndValue{}, err
-	}
-
-	// initialize checker
-	check := NewChecker(nil, fset, pkg, nil)
-	check.scope = scope
-	check.pos = pos
-	defer check.handleBailout(&err)
-
-	// evaluate node
-	var x operand
-	check.rawExpr(&x, node, nil)
-	return TypeAndValue{x.mode, x.typ, x.val}, err
-}
diff --git a/vendor/golang.org/x/tools/go/types/expr.go b/vendor/golang.org/x/tools/go/types/expr.go
deleted file mode 100644
index 6efc7b4..0000000
--- a/vendor/golang.org/x/tools/go/types/expr.go
+++ /dev/null
@@ -1,1497 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of expressions.
-
-package types
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"math"
-
-	"golang.org/x/tools/go/exact"
-)
-
-/*
-Basic algorithm:
-
-Expressions are checked recursively, top down. Expression checker functions
-are generally of the form:
-
-  func f(x *operand, e *ast.Expr, ...)
-
-where e is the expression to be checked, and x is the result of the check.
-The check performed by f may fail in which case x.mode == invalid, and
-related error messages will have been issued by f.
-
-If a hint argument is present, it is the composite literal element type
-of an outer composite literal; it is used to type-check composite literal
-elements that have no explicit type specification in the source
-(e.g.: []T{{...}, {...}}, the hint is the type T in this case).
-
-All expressions are checked via rawExpr, which dispatches according
-to expression kind. Upon returning, rawExpr is recording the types and
-constant values for all expressions that have an untyped type (those types
-may change on the way up in the expression tree). Usually these are constants,
-but the results of comparisons or non-constant shifts of untyped constants
-may also be untyped, but not constant.
-
-Untyped expressions may eventually become fully typed (i.e., not untyped),
-typically when the value is assigned to a variable, or is used otherwise.
-The updateExprType method is used to record this final type and update
-the recorded types: the type-checked expression tree is again traversed down,
-and the new type is propagated as needed. Untyped constant expression values
-that become fully typed must now be representable by the full type (constant
-sub-expression trees are left alone except for their roots). This mechanism
-ensures that a client sees the actual (run-time) type an untyped value would
-have. It also permits type-checking of lhs shift operands "as if the shift
-were not present": when updateExprType visits an untyped lhs shift operand
-and assigns it it's final type, that type must be an integer type, and a
-constant lhs must be representable as an integer.
-
-When an expression gets its final type, either on the way out from rawExpr,
-on the way down in updateExprType, or at the end of the type checker run,
-the type (and constant value, if any) is recorded via Info.Types, if present.
-*/
-
-type opPredicates map[token.Token]func(Type) bool
-
-var unaryOpPredicates = opPredicates{
-	token.ADD: isNumeric,
-	token.SUB: isNumeric,
-	token.XOR: isInteger,
-	token.NOT: isBoolean,
-}
-
-func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
-	if pred := m[op]; pred != nil {
-		if !pred(x.typ) {
-			check.invalidOp(x.pos(), "operator %s not defined for %s", op, x)
-			return false
-		}
-	} else {
-		check.invalidAST(x.pos(), "unknown operator %s", op)
-		return false
-	}
-	return true
-}
-
-// The unary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
-	switch op {
-	case token.AND:
-		// spec: "As an exception to the addressability
-		// requirement x may also be a composite literal."
-		if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable {
-			check.invalidOp(x.pos(), "cannot take address of %s", x)
-			x.mode = invalid
-			return
-		}
-		x.mode = value
-		x.typ = &Pointer{base: x.typ}
-		return
-
-	case token.ARROW:
-		typ, ok := x.typ.Underlying().(*Chan)
-		if !ok {
-			check.invalidOp(x.pos(), "cannot receive from non-channel %s", x)
-			x.mode = invalid
-			return
-		}
-		if typ.dir == SendOnly {
-			check.invalidOp(x.pos(), "cannot receive from send-only channel %s", x)
-			x.mode = invalid
-			return
-		}
-		x.mode = commaok
-		x.typ = typ.elem
-		check.hasCallOrRecv = true
-		return
-	}
-
-	if !check.op(unaryOpPredicates, x, op) {
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant {
-		typ := x.typ.Underlying().(*Basic)
-		size := -1
-		if isUnsigned(typ) {
-			size = int(check.conf.sizeof(typ))
-		}
-		x.val = exact.UnaryOp(op, x.val, size)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
-		return
-	}
-
-	x.mode = value
-	// x.typ remains unchanged
-}
-
-func isShift(op token.Token) bool {
-	return op == token.SHL || op == token.SHR
-}
-
-func isComparison(op token.Token) bool {
-	// Note: tokens are not ordered well to make this much easier
-	switch op {
-	case token.EQL, token.NEQ, token.LSS, token.LEQ, token.GTR, token.GEQ:
-		return true
-	}
-	return false
-}
-
-func fitsFloat32(x exact.Value) bool {
-	f32, _ := exact.Float32Val(x)
-	f := float64(f32)
-	return !math.IsInf(f, 0)
-}
-
-func roundFloat32(x exact.Value) exact.Value {
-	f32, _ := exact.Float32Val(x)
-	f := float64(f32)
-	if !math.IsInf(f, 0) {
-		return exact.MakeFloat64(f)
-	}
-	return nil
-}
-
-func fitsFloat64(x exact.Value) bool {
-	f, _ := exact.Float64Val(x)
-	return !math.IsInf(f, 0)
-}
-
-func roundFloat64(x exact.Value) exact.Value {
-	f, _ := exact.Float64Val(x)
-	if !math.IsInf(f, 0) {
-		return exact.MakeFloat64(f)
-	}
-	return nil
-}
-
-// representableConst reports whether x can be represented as
-// value of the given basic type kind and for the configuration
-// provided (only needed for int/uint sizes).
-//
-// If rounded != nil, *rounded is set to the rounded value of x for
-// representable floating-point values; it is left alone otherwise.
-// It is ok to provide the addressof the first argument for rounded.
-func representableConst(x exact.Value, conf *Config, as BasicKind, rounded *exact.Value) bool {
-	switch x.Kind() {
-	case exact.Unknown:
-		return true
-
-	case exact.Bool:
-		return as == Bool || as == UntypedBool
-
-	case exact.Int:
-		if x, ok := exact.Int64Val(x); ok {
-			switch as {
-			case Int:
-				var s = uint(conf.sizeof(Typ[as])) * 8
-				return int64(-1)<<(s-1) <= x && x <= int64(1)<<(s-1)-1
-			case Int8:
-				const s = 8
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int16:
-				const s = 16
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int32:
-				const s = 32
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int64:
-				return true
-			case Uint, Uintptr:
-				if s := uint(conf.sizeof(Typ[as])) * 8; s < 64 {
-					return 0 <= x && x <= int64(1)<<s-1
-				}
-				return 0 <= x
-			case Uint8:
-				const s = 8
-				return 0 <= x && x <= 1<<s-1
-			case Uint16:
-				const s = 16
-				return 0 <= x && x <= 1<<s-1
-			case Uint32:
-				const s = 32
-				return 0 <= x && x <= 1<<s-1
-			case Uint64:
-				return 0 <= x
-			case Float32, Float64, Complex64, Complex128,
-				UntypedInt, UntypedFloat, UntypedComplex:
-				return true
-			}
-		}
-
-		n := exact.BitLen(x)
-		switch as {
-		case Uint, Uintptr:
-			var s = uint(conf.sizeof(Typ[as])) * 8
-			return exact.Sign(x) >= 0 && n <= int(s)
-		case Uint64:
-			return exact.Sign(x) >= 0 && n <= 64
-		case Float32, Complex64:
-			if rounded == nil {
-				return fitsFloat32(x)
-			}
-			r := roundFloat32(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case Float64, Complex128:
-			if rounded == nil {
-				return fitsFloat64(x)
-			}
-			r := roundFloat64(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case UntypedInt, UntypedFloat, UntypedComplex:
-			return true
-		}
-
-	case exact.Float:
-		switch as {
-		case Float32, Complex64:
-			if rounded == nil {
-				return fitsFloat32(x)
-			}
-			r := roundFloat32(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case Float64, Complex128:
-			if rounded == nil {
-				return fitsFloat64(x)
-			}
-			r := roundFloat64(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case UntypedFloat, UntypedComplex:
-			return true
-		}
-
-	case exact.Complex:
-		switch as {
-		case Complex64:
-			if rounded == nil {
-				return fitsFloat32(exact.Real(x)) && fitsFloat32(exact.Imag(x))
-			}
-			re := roundFloat32(exact.Real(x))
-			im := roundFloat32(exact.Imag(x))
-			if re != nil && im != nil {
-				*rounded = exact.BinaryOp(re, token.ADD, exact.MakeImag(im))
-				return true
-			}
-		case Complex128:
-			if rounded == nil {
-				return fitsFloat64(exact.Real(x)) && fitsFloat64(exact.Imag(x))
-			}
-			re := roundFloat64(exact.Real(x))
-			im := roundFloat64(exact.Imag(x))
-			if re != nil && im != nil {
-				*rounded = exact.BinaryOp(re, token.ADD, exact.MakeImag(im))
-				return true
-			}
-		case UntypedComplex:
-			return true
-		}
-
-	case exact.String:
-		return as == String || as == UntypedString
-
-	default:
-		unreachable()
-	}
-
-	return false
-}
-
-// representable checks that a constant operand is representable in the given basic type.
-func (check *Checker) representable(x *operand, typ *Basic) {
-	assert(x.mode == constant)
-	if !representableConst(x.val, check.conf, typ.kind, &x.val) {
-		var msg string
-		if isNumeric(x.typ) && isNumeric(typ) {
-			// numeric conversion : error msg
-			//
-			// integer -> integer : overflows
-			// integer -> float   : overflows (actually not possible)
-			// float   -> integer : truncated
-			// float   -> float   : overflows
-			//
-			if !isInteger(x.typ) && isInteger(typ) {
-				msg = "%s truncated to %s"
-			} else {
-				msg = "%s overflows %s"
-			}
-		} else {
-			msg = "cannot convert %s to %s"
-		}
-		check.errorf(x.pos(), msg, x, typ)
-		x.mode = invalid
-	}
-}
-
-// updateExprType updates the type of x to typ and invokes itself
-// recursively for the operands of x, depending on expression kind.
-// If typ is still an untyped and not the final type, updateExprType
-// only updates the recorded untyped type for x and possibly its
-// operands. Otherwise (i.e., typ is not an untyped type anymore,
-// or it is the final type for x), the type and value are recorded.
-// Also, if x is a constant, it must be representable as a value of typ,
-// and if x is the (formerly untyped) lhs operand of a non-constant
-// shift, it must be an integer value.
-//
-func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) {
-	old, found := check.untyped[x]
-	if !found {
-		return // nothing to do
-	}
-
-	// update operands of x if necessary
-	switch x := x.(type) {
-	case *ast.BadExpr,
-		*ast.FuncLit,
-		*ast.CompositeLit,
-		*ast.IndexExpr,
-		*ast.SliceExpr,
-		*ast.TypeAssertExpr,
-		*ast.StarExpr,
-		*ast.KeyValueExpr,
-		*ast.ArrayType,
-		*ast.StructType,
-		*ast.FuncType,
-		*ast.InterfaceType,
-		*ast.MapType,
-		*ast.ChanType:
-		// These expression are never untyped - nothing to do.
-		// The respective sub-expressions got their final types
-		// upon assignment or use.
-		if debug {
-			check.dump("%s: found old type(%s): %s (new: %s)", x.Pos(), x, old.typ, typ)
-			unreachable()
-		}
-		return
-
-	case *ast.CallExpr:
-		// Resulting in an untyped constant (e.g., built-in complex).
-		// The respective calls take care of calling updateExprType
-		// for the arguments if necessary.
-
-	case *ast.Ident, *ast.BasicLit, *ast.SelectorExpr:
-		// An identifier denoting a constant, a constant literal,
-		// or a qualified identifier (imported untyped constant).
-		// No operands to take care of.
-
-	case *ast.ParenExpr:
-		check.updateExprType(x.X, typ, final)
-
-	case *ast.UnaryExpr:
-		// If x is a constant, the operands were constants.
-		// They don't need to be updated since they never
-		// get "materialized" into a typed value; and they
-		// will be processed at the end of the type check.
-		if old.val != nil {
-			break
-		}
-		check.updateExprType(x.X, typ, final)
-
-	case *ast.BinaryExpr:
-		if old.val != nil {
-			break // see comment for unary expressions
-		}
-		if isComparison(x.Op) {
-			// The result type is independent of operand types
-			// and the operand types must have final types.
-		} else if isShift(x.Op) {
-			// The result type depends only on lhs operand.
-			// The rhs type was updated when checking the shift.
-			check.updateExprType(x.X, typ, final)
-		} else {
-			// The operand types match the result type.
-			check.updateExprType(x.X, typ, final)
-			check.updateExprType(x.Y, typ, final)
-		}
-
-	default:
-		unreachable()
-	}
-
-	// If the new type is not final and still untyped, just
-	// update the recorded type.
-	if !final && isUntyped(typ) {
-		old.typ = typ.Underlying().(*Basic)
-		check.untyped[x] = old
-		return
-	}
-
-	// Otherwise we have the final (typed or untyped type).
-	// Remove it from the map of yet untyped expressions.
-	delete(check.untyped, x)
-
-	// If x is the lhs of a shift, its final type must be integer.
-	// We already know from the shift check that it is representable
-	// as an integer if it is a constant.
-	if old.isLhs && !isInteger(typ) {
-		check.invalidOp(x.Pos(), "shifted operand %s (type %s) must be integer", x, typ)
-		return
-	}
-
-	// Everything's fine, record final type and value for x.
-	check.recordTypeAndValue(x, old.mode, typ, old.val)
-}
-
-// updateExprVal updates the value of x to val.
-func (check *Checker) updateExprVal(x ast.Expr, val exact.Value) {
-	if info, ok := check.untyped[x]; ok {
-		info.val = val
-		check.untyped[x] = info
-	}
-}
-
-// convertUntyped attempts to set the type of an untyped value to the target type.
-func (check *Checker) convertUntyped(x *operand, target Type) {
-	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
-		return
-	}
-
-	// TODO(gri) Sloppy code - clean up. This function is central
-	//           to assignment and expression checking.
-
-	if isUntyped(target) {
-		// both x and target are untyped
-		xkind := x.typ.(*Basic).kind
-		tkind := target.(*Basic).kind
-		if isNumeric(x.typ) && isNumeric(target) {
-			if xkind < tkind {
-				x.typ = target
-				check.updateExprType(x.expr, target, false)
-			}
-		} else if xkind != tkind {
-			goto Error
-		}
-		return
-	}
-
-	// typed target
-	switch t := target.Underlying().(type) {
-	case *Basic:
-		if x.mode == constant {
-			check.representable(x, t)
-			if x.mode == invalid {
-				return
-			}
-			// expression value may have been rounded - update if needed
-			// TODO(gri) A floating-point value may silently underflow to
-			// zero. If it was negative, the sign is lost. See issue 6898.
-			check.updateExprVal(x.expr, x.val)
-		} else {
-			// Non-constant untyped values may appear as the
-			// result of comparisons (untyped bool), intermediate
-			// (delayed-checked) rhs operands of shifts, and as
-			// the value nil.
-			switch x.typ.(*Basic).kind {
-			case UntypedBool:
-				if !isBoolean(target) {
-					goto Error
-				}
-			case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
-				if !isNumeric(target) {
-					goto Error
-				}
-			case UntypedString:
-				// Non-constant untyped string values are not
-				// permitted by the spec and should not occur.
-				unreachable()
-			case UntypedNil:
-				// Unsafe.Pointer is a basic type that includes nil.
-				if !hasNil(target) {
-					goto Error
-				}
-			default:
-				goto Error
-			}
-		}
-	case *Interface:
-		if !x.isNil() && !t.Empty() /* empty interfaces are ok */ {
-			goto Error
-		}
-		// Update operand types to the default type rather then
-		// the target (interface) type: values must have concrete
-		// dynamic types. If the value is nil, keep it untyped
-		// (this is important for tools such as go vet which need
-		// the dynamic type for argument checking of say, print
-		// functions)
-		if x.isNil() {
-			target = Typ[UntypedNil]
-		} else {
-			// cannot assign untyped values to non-empty interfaces
-			if !t.Empty() {
-				goto Error
-			}
-			target = defaultType(x.typ)
-		}
-	case *Pointer, *Signature, *Slice, *Map, *Chan:
-		if !x.isNil() {
-			goto Error
-		}
-		// keep nil untyped - see comment for interfaces, above
-		target = Typ[UntypedNil]
-	default:
-		goto Error
-	}
-
-	x.typ = target
-	check.updateExprType(x.expr, target, true) // UntypedNils are final
-	return
-
-Error:
-	check.errorf(x.pos(), "cannot convert %s to %s", x, target)
-	x.mode = invalid
-}
-
-func (check *Checker) comparison(x, y *operand, op token.Token) {
-	// spec: "In any comparison, the first operand must be assignable
-	// to the type of the second operand, or vice versa."
-	err := ""
-	if x.assignableTo(check.conf, y.typ) || y.assignableTo(check.conf, x.typ) {
-		defined := false
-		switch op {
-		case token.EQL, token.NEQ:
-			// spec: "The equality operators == and != apply to operands that are comparable."
-			defined = Comparable(x.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ)
-		case token.LSS, token.LEQ, token.GTR, token.GEQ:
-			// spec: The ordering operators <, <=, >, and >= apply to operands that are ordered."
-			defined = isOrdered(x.typ)
-		default:
-			unreachable()
-		}
-		if !defined {
-			typ := x.typ
-			if x.isNil() {
-				typ = y.typ
-			}
-			err = check.sprintf("operator %s not defined for %s", op, typ)
-		}
-	} else {
-		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
-	}
-
-	if err != "" {
-		check.errorf(x.pos(), "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant && y.mode == constant {
-		x.val = exact.MakeBool(exact.Compare(x.val, op, y.val))
-		// The operands are never materialized; no need to update
-		// their types.
-	} else {
-		x.mode = value
-		// The operands have now their final types, which at run-
-		// time will be materialized. Update the expression trees.
-		// If the current types are untyped, the materialized type
-		// is the respective default type.
-		check.updateExprType(x.expr, defaultType(x.typ), true)
-		check.updateExprType(y.expr, defaultType(y.typ), true)
-	}
-
-	// spec: "Comparison operators compare two operands and yield
-	//        an untyped boolean value."
-	x.typ = Typ[UntypedBool]
-}
-
-func (check *Checker) shift(x, y *operand, op token.Token) {
-	untypedx := isUntyped(x.typ)
-
-	// The lhs must be of integer type or be representable
-	// as an integer; otherwise the shift has no chance.
-	if !x.isInteger() {
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
-		x.mode = invalid
-		return
-	}
-
-	// spec: "The right operand in a shift expression must have unsigned
-	// integer type or be an untyped constant that can be converted to
-	// unsigned integer type."
-	switch {
-	case isInteger(y.typ) && isUnsigned(y.typ):
-		// nothing to do
-	case isUntyped(y.typ):
-		check.convertUntyped(y, Typ[UntypedInt])
-		if y.mode == invalid {
-			x.mode = invalid
-			return
-		}
-	default:
-		check.invalidOp(y.pos(), "shift count %s must be unsigned integer", y)
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant {
-		if y.mode == constant {
-			// rhs must be an integer value
-			if !y.isInteger() {
-				check.invalidOp(y.pos(), "shift count %s must be unsigned integer", y)
-				x.mode = invalid
-				return
-			}
-			// rhs must be within reasonable bounds
-			const stupidShift = 1023 - 1 + 52 // so we can express smallestFloat64
-			s, ok := exact.Uint64Val(y.val)
-			if !ok || s > stupidShift {
-				check.invalidOp(y.pos(), "stupid shift count %s", y)
-				x.mode = invalid
-				return
-			}
-			// The lhs is representable as an integer but may not be an integer
-			// (e.g., 2.0, an untyped float) - this can only happen for untyped
-			// non-integer numeric constants. Correct the type so that the shift
-			// result is of integer type.
-			if !isInteger(x.typ) {
-				x.typ = Typ[UntypedInt]
-			}
-			x.val = exact.Shift(x.val, op, uint(s))
-			return
-		}
-
-		// non-constant shift with constant lhs
-		if untypedx {
-			// spec: "If the left operand of a non-constant shift
-			// expression is an untyped constant, the type of the
-			// constant is what it would be if the shift expression
-			// were replaced by its left operand alone.".
-			//
-			// Delay operand checking until we know the final type:
-			// The lhs expression must be in the untyped map, mark
-			// the entry as lhs shift operand.
-			info, found := check.untyped[x.expr]
-			assert(found)
-			info.isLhs = true
-			check.untyped[x.expr] = info
-			// keep x's type
-			x.mode = value
-			return
-		}
-	}
-
-	// constant rhs must be >= 0
-	if y.mode == constant && exact.Sign(y.val) < 0 {
-		check.invalidOp(y.pos(), "shift count %s must not be negative", y)
-	}
-
-	// non-constant shift - lhs must be an integer
-	if !isInteger(x.typ) {
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
-		x.mode = invalid
-		return
-	}
-
-	x.mode = value
-}
-
-var binaryOpPredicates = opPredicates{
-	token.ADD: func(typ Type) bool { return isNumeric(typ) || isString(typ) },
-	token.SUB: isNumeric,
-	token.MUL: isNumeric,
-	token.QUO: isNumeric,
-	token.REM: isInteger,
-
-	token.AND:     isInteger,
-	token.OR:      isInteger,
-	token.XOR:     isInteger,
-	token.AND_NOT: isInteger,
-
-	token.LAND: isBoolean,
-	token.LOR:  isBoolean,
-}
-
-// The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token) {
-	var y operand
-
-	check.expr(x, lhs)
-	check.expr(&y, rhs)
-
-	if x.mode == invalid {
-		return
-	}
-	if y.mode == invalid {
-		x.mode = invalid
-		x.expr = y.expr
-		return
-	}
-
-	if isShift(op) {
-		check.shift(x, &y, op)
-		return
-	}
-
-	check.convertUntyped(x, y.typ)
-	if x.mode == invalid {
-		return
-	}
-	check.convertUntyped(&y, x.typ)
-	if y.mode == invalid {
-		x.mode = invalid
-		return
-	}
-
-	if isComparison(op) {
-		check.comparison(x, &y, op)
-		return
-	}
-
-	if !Identical(x.typ, y.typ) {
-		// only report an error if we have valid types
-		// (otherwise we had an error reported elsewhere already)
-		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
-			check.invalidOp(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
-		}
-		x.mode = invalid
-		return
-	}
-
-	if !check.op(binaryOpPredicates, x, op) {
-		x.mode = invalid
-		return
-	}
-
-	if (op == token.QUO || op == token.REM) && (x.mode == constant || isInteger(x.typ)) && y.mode == constant && exact.Sign(y.val) == 0 {
-		check.invalidOp(y.pos(), "division by zero")
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant && y.mode == constant {
-		typ := x.typ.Underlying().(*Basic)
-		// force integer division of integer operands
-		if op == token.QUO && isInteger(typ) {
-			op = token.QUO_ASSIGN
-		}
-		x.val = exact.BinaryOp(x.val, op, y.val)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
-		return
-	}
-
-	x.mode = value
-	// x.typ is unchanged
-}
-
-// index checks an index expression for validity.
-// If max >= 0, it is the upper bound for index.
-// If index is valid and the result i >= 0, then i is the constant value of index.
-func (check *Checker) index(index ast.Expr, max int64) (i int64, valid bool) {
-	var x operand
-	check.expr(&x, index)
-	if x.mode == invalid {
-		return
-	}
-
-	// an untyped constant must be representable as Int
-	check.convertUntyped(&x, Typ[Int])
-	if x.mode == invalid {
-		return
-	}
-
-	// the index must be of integer type
-	if !isInteger(x.typ) {
-		check.invalidArg(x.pos(), "index %s must be integer", &x)
-		return
-	}
-
-	// a constant index i must be in bounds
-	if x.mode == constant {
-		if exact.Sign(x.val) < 0 {
-			check.invalidArg(x.pos(), "index %s must not be negative", &x)
-			return
-		}
-		i, valid = exact.Int64Val(x.val)
-		if !valid || max >= 0 && i >= max {
-			check.errorf(x.pos(), "index %s is out of bounds", &x)
-			return i, false
-		}
-		// 0 <= i [ && i < max ]
-		return i, true
-	}
-
-	return -1, true
-}
-
-// indexElts checks the elements (elts) of an array or slice composite literal
-// against the literal's element type (typ), and the element indices against
-// the literal length if known (length >= 0). It returns the length of the
-// literal (maximum index value + 1).
-//
-func (check *Checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64 {
-	visited := make(map[int64]bool, len(elts))
-	var index, max int64
-	for _, e := range elts {
-		// determine and check index
-		validIndex := false
-		eval := e
-		if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-			if i, ok := check.index(kv.Key, length); ok {
-				if i >= 0 {
-					index = i
-					validIndex = true
-				} else {
-					check.errorf(e.Pos(), "index %s must be integer constant", kv.Key)
-				}
-			}
-			eval = kv.Value
-		} else if length >= 0 && index >= length {
-			check.errorf(e.Pos(), "index %d is out of bounds (>= %d)", index, length)
-		} else {
-			validIndex = true
-		}
-
-		// if we have a valid index, check for duplicate entries
-		if validIndex {
-			if visited[index] {
-				check.errorf(e.Pos(), "duplicate index %d in array or slice literal", index)
-			}
-			visited[index] = true
-		}
-		index++
-		if index > max {
-			max = index
-		}
-
-		// check element against composite literal element type
-		var x operand
-		check.exprWithHint(&x, eval, typ)
-		if !check.assignment(&x, typ) && x.mode != invalid {
-			check.errorf(x.pos(), "cannot use %s as %s value in array or slice literal", &x, typ)
-		}
-	}
-	return max
-}
-
-// exprKind describes the kind of an expression; the kind
-// determines if an expression is valid in 'statement context'.
-type exprKind int
-
-const (
-	conversion exprKind = iota
-	expression
-	statement
-)
-
-// rawExpr typechecks expression e and initializes x with the expression
-// value or type. If an error occurred, x.mode is set to invalid.
-// If hint != nil, it is the type of a composite literal element.
-//
-func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
-	if trace {
-		check.trace(e.Pos(), "%s", e)
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(e.Pos(), "=> %s", x)
-		}()
-	}
-
-	kind := check.exprInternal(x, e, hint)
-
-	// convert x into a user-friendly set of values
-	// TODO(gri) this code can be simplified
-	var typ Type
-	var val exact.Value
-	switch x.mode {
-	case invalid:
-		typ = Typ[Invalid]
-	case novalue:
-		typ = (*Tuple)(nil)
-	case constant:
-		typ = x.typ
-		val = x.val
-	default:
-		typ = x.typ
-	}
-	assert(x.expr != nil && typ != nil)
-
-	if isUntyped(typ) {
-		// delay type and value recording until we know the type
-		// or until the end of type checking
-		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
-	} else {
-		check.recordTypeAndValue(e, x.mode, typ, val)
-	}
-
-	return kind
-}
-
-// exprInternal contains the core of type checking of expressions.
-// Must only be called by rawExpr.
-//
-func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
-	// make sure x has a valid state in case of bailout
-	// (was issue 5770)
-	x.mode = invalid
-	x.typ = Typ[Invalid]
-
-	switch e := e.(type) {
-	case *ast.BadExpr:
-		goto Error // error was reported before
-
-	case *ast.Ident:
-		check.ident(x, e, nil, nil)
-
-	case *ast.Ellipsis:
-		// ellipses are handled explicitly where they are legal
-		// (array composite literals and parameter lists)
-		check.error(e.Pos(), "invalid use of '...'")
-		goto Error
-
-	case *ast.BasicLit:
-		x.setConst(e.Kind, e.Value)
-		if x.mode == invalid {
-			check.invalidAST(e.Pos(), "invalid literal %v", e.Value)
-			goto Error
-		}
-
-	case *ast.FuncLit:
-		if sig, ok := check.typ(e.Type).(*Signature); ok {
-			// Anonymous functions are considered part of the
-			// init expression/func declaration which contains
-			// them: use existing package-level declaration info.
-			check.funcBody(check.decl, "", sig, e.Body)
-			x.mode = value
-			x.typ = sig
-		} else {
-			check.invalidAST(e.Pos(), "invalid function literal %s", e)
-			goto Error
-		}
-
-	case *ast.CompositeLit:
-		typ := hint
-		openArray := false
-		if e.Type != nil {
-			// [...]T array types may only appear with composite literals.
-			// Check for them here so we don't have to handle ... in general.
-			typ = nil
-			if atyp, _ := e.Type.(*ast.ArrayType); atyp != nil && atyp.Len != nil {
-				if ellip, _ := atyp.Len.(*ast.Ellipsis); ellip != nil && ellip.Elt == nil {
-					// We have an "open" [...]T array type.
-					// Create a new ArrayType with unknown length (-1)
-					// and finish setting it up after analyzing the literal.
-					typ = &Array{len: -1, elem: check.typ(atyp.Elt)}
-					openArray = true
-				}
-			}
-			if typ == nil {
-				typ = check.typ(e.Type)
-			}
-		}
-		if typ == nil {
-			// TODO(gri) provide better error messages depending on context
-			check.error(e.Pos(), "missing type in composite literal")
-			goto Error
-		}
-
-		switch typ, _ := deref(typ); utyp := typ.Underlying().(type) {
-		case *Struct:
-			if len(e.Elts) == 0 {
-				break
-			}
-			fields := utyp.fields
-			if _, ok := e.Elts[0].(*ast.KeyValueExpr); ok {
-				// all elements must have keys
-				visited := make([]bool, len(fields))
-				for _, e := range e.Elts {
-					kv, _ := e.(*ast.KeyValueExpr)
-					if kv == nil {
-						check.error(e.Pos(), "mixture of field:value and value elements in struct literal")
-						continue
-					}
-					key, _ := kv.Key.(*ast.Ident)
-					if key == nil {
-						check.errorf(kv.Pos(), "invalid field name %s in struct literal", kv.Key)
-						continue
-					}
-					i := fieldIndex(utyp.fields, check.pkg, key.Name)
-					if i < 0 {
-						check.errorf(kv.Pos(), "unknown field %s in struct literal", key.Name)
-						continue
-					}
-					fld := fields[i]
-					check.recordUse(key, fld)
-					// 0 <= i < len(fields)
-					if visited[i] {
-						check.errorf(kv.Pos(), "duplicate field name %s in struct literal", key.Name)
-						continue
-					}
-					visited[i] = true
-					check.expr(x, kv.Value)
-					etyp := fld.typ
-					if !check.assignment(x, etyp) {
-						if x.mode != invalid {
-							check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
-						}
-						continue
-					}
-				}
-			} else {
-				// no element must have a key
-				for i, e := range e.Elts {
-					if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-						check.error(kv.Pos(), "mixture of field:value and value elements in struct literal")
-						continue
-					}
-					check.expr(x, e)
-					if i >= len(fields) {
-						check.error(x.pos(), "too many values in struct literal")
-						break // cannot continue
-					}
-					// i < len(fields)
-					fld := fields[i]
-					if !fld.Exported() && fld.pkg != check.pkg {
-						check.errorf(x.pos(), "implicit assignment to unexported field %s in %s literal", fld.name, typ)
-						continue
-					}
-					etyp := fld.typ
-					if !check.assignment(x, etyp) {
-						if x.mode != invalid {
-							check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
-						}
-						continue
-					}
-				}
-				if len(e.Elts) < len(fields) {
-					check.error(e.Rbrace, "too few values in struct literal")
-					// ok to continue
-				}
-			}
-
-		case *Array:
-			n := check.indexedElts(e.Elts, utyp.elem, utyp.len)
-			// if we have an "open" [...]T array, set the length now that we know it
-			if openArray {
-				utyp.len = n
-			}
-
-		case *Slice:
-			check.indexedElts(e.Elts, utyp.elem, -1)
-
-		case *Map:
-			visited := make(map[interface{}][]Type, len(e.Elts))
-			for _, e := range e.Elts {
-				kv, _ := e.(*ast.KeyValueExpr)
-				if kv == nil {
-					check.error(e.Pos(), "missing key in map literal")
-					continue
-				}
-				check.exprWithHint(x, kv.Key, utyp.key)
-				if !check.assignment(x, utyp.key) {
-					if x.mode != invalid {
-						check.errorf(x.pos(), "cannot use %s as %s key in map literal", x, utyp.key)
-					}
-					continue
-				}
-				if x.mode == constant {
-					duplicate := false
-					// if the key is of interface type, the type is also significant when checking for duplicates
-					if _, ok := utyp.key.Underlying().(*Interface); ok {
-						for _, vtyp := range visited[x.val] {
-							if Identical(vtyp, x.typ) {
-								duplicate = true
-								break
-							}
-						}
-						visited[x.val] = append(visited[x.val], x.typ)
-					} else {
-						_, duplicate = visited[x.val]
-						visited[x.val] = nil
-					}
-					if duplicate {
-						check.errorf(x.pos(), "duplicate key %s in map literal", x.val)
-						continue
-					}
-				}
-				check.exprWithHint(x, kv.Value, utyp.elem)
-				if !check.assignment(x, utyp.elem) {
-					if x.mode != invalid {
-						check.errorf(x.pos(), "cannot use %s as %s value in map literal", x, utyp.elem)
-					}
-					continue
-				}
-			}
-
-		default:
-			// if utyp is invalid, an error was reported before
-			if utyp != Typ[Invalid] {
-				check.errorf(e.Pos(), "invalid composite literal type %s", typ)
-				goto Error
-			}
-		}
-
-		x.mode = value
-		x.typ = typ
-
-	case *ast.ParenExpr:
-		kind := check.rawExpr(x, e.X, nil)
-		x.expr = e
-		return kind
-
-	case *ast.SelectorExpr:
-		check.selector(x, e)
-
-	case *ast.IndexExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
-		case *Basic:
-			if isString(typ) {
-				valid = true
-				if x.mode == constant {
-					length = int64(len(exact.StringVal(x.val)))
-				}
-				// an indexed string always yields a byte value
-				// (not a constant) even if the string and the
-				// index are constant
-				x.mode = value
-				x.typ = universeByte // use 'byte' name
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				x.mode = value
-			}
-			x.typ = typ.elem
-
-		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-				valid = true
-				length = typ.len
-				x.mode = variable
-				x.typ = typ.elem
-			}
-
-		case *Slice:
-			valid = true
-			x.mode = variable
-			x.typ = typ.elem
-
-		case *Map:
-			var key operand
-			check.expr(&key, e.Index)
-			if !check.assignment(&key, typ.key) {
-				if key.mode != invalid {
-					check.invalidOp(key.pos(), "cannot use %s as map index of type %s", &key, typ.key)
-				}
-				goto Error
-			}
-			x.mode = mapindex
-			x.typ = typ.elem
-			x.expr = e
-			return expression
-		}
-
-		if !valid {
-			check.invalidOp(x.pos(), "cannot index %s", x)
-			goto Error
-		}
-
-		if e.Index == nil {
-			check.invalidAST(e.Pos(), "missing index for %s", x)
-			goto Error
-		}
-
-		check.index(e.Index, length)
-		// ok to continue
-
-	case *ast.SliceExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
-		case *Basic:
-			if isString(typ) {
-				if slice3(e) {
-					check.invalidOp(x.pos(), "3-index slice of string")
-					goto Error
-				}
-				valid = true
-				if x.mode == constant {
-					length = int64(len(exact.StringVal(x.val)))
-				}
-				// spec: "For untyped string operands the result
-				// is a non-constant value of type string."
-				if typ.kind == UntypedString {
-					x.typ = Typ[String]
-				}
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				check.invalidOp(x.pos(), "cannot slice %s (value not addressable)", x)
-				goto Error
-			}
-			x.typ = &Slice{elem: typ.elem}
-
-		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-				valid = true
-				length = typ.len
-				x.typ = &Slice{elem: typ.elem}
-			}
-
-		case *Slice:
-			valid = true
-			// x.typ doesn't change
-		}
-
-		if !valid {
-			check.invalidOp(x.pos(), "cannot slice %s", x)
-			goto Error
-		}
-
-		x.mode = value
-
-		// spec: "Only the first index may be omitted; it defaults to 0."
-		if slice3(e) && (e.High == nil || sliceMax(e) == nil) {
-			check.error(e.Rbrack, "2nd and 3rd index required in 3-index slice")
-			goto Error
-		}
-
-		// check indices
-		var ind [3]int64
-		for i, expr := range []ast.Expr{e.Low, e.High, sliceMax(e)} {
-			x := int64(-1)
-			switch {
-			case expr != nil:
-				// The "capacity" is only known statically for strings, arrays,
-				// and pointers to arrays, and it is the same as the length for
-				// those types.
-				max := int64(-1)
-				if length >= 0 {
-					max = length + 1
-				}
-				if t, ok := check.index(expr, max); ok && t >= 0 {
-					x = t
-				}
-			case i == 0:
-				// default is 0 for the first index
-				x = 0
-			case length >= 0:
-				// default is length (== capacity) otherwise
-				x = length
-			}
-			ind[i] = x
-		}
-
-		// constant indices must be in range
-		// (check.index already checks that existing indices >= 0)
-	L:
-		for i, x := range ind[:len(ind)-1] {
-			if x > 0 {
-				for _, y := range ind[i+1:] {
-					if y >= 0 && x > y {
-						check.errorf(e.Rbrack, "invalid slice indices: %d > %d", x, y)
-						break L // only report one error, ok to continue
-					}
-				}
-			}
-		}
-
-	case *ast.TypeAssertExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
-		if xtyp == nil {
-			check.invalidOp(x.pos(), "%s is not an interface", x)
-			goto Error
-		}
-		// x.(type) expressions are handled explicitly in type switches
-		if e.Type == nil {
-			check.invalidAST(e.Pos(), "use of .(type) outside type switch")
-			goto Error
-		}
-		T := check.typ(e.Type)
-		if T == Typ[Invalid] {
-			goto Error
-		}
-		check.typeAssertion(x.pos(), x, xtyp, T)
-		x.mode = commaok
-		x.typ = T
-
-	case *ast.CallExpr:
-		return check.call(x, e)
-
-	case *ast.StarExpr:
-		check.exprOrType(x, e.X)
-		switch x.mode {
-		case invalid:
-			goto Error
-		case typexpr:
-			x.typ = &Pointer{base: x.typ}
-		default:
-			if typ, ok := x.typ.Underlying().(*Pointer); ok {
-				x.mode = variable
-				x.typ = typ.base
-			} else {
-				check.invalidOp(x.pos(), "cannot indirect %s", x)
-				goto Error
-			}
-		}
-
-	case *ast.UnaryExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-		check.unary(x, e, e.Op)
-		if x.mode == invalid {
-			goto Error
-		}
-		if e.Op == token.ARROW {
-			x.expr = e
-			return statement // receive operations may appear in statement context
-		}
-
-	case *ast.BinaryExpr:
-		check.binary(x, e, e.X, e.Y, e.Op)
-		if x.mode == invalid {
-			goto Error
-		}
-
-	case *ast.KeyValueExpr:
-		// key:value expressions are handled in composite literals
-		check.invalidAST(e.Pos(), "no key:value expected")
-		goto Error
-
-	case *ast.ArrayType, *ast.StructType, *ast.FuncType,
-		*ast.InterfaceType, *ast.MapType, *ast.ChanType:
-		x.mode = typexpr
-		x.typ = check.typ(e)
-		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
-		// even though check.typ has already called it. This is fine as both
-		// times the same expression and type are recorded. It is also not a
-		// performance issue because we only reach here for composite literal
-		// types, which are comparatively rare.
-
-	default:
-		panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
-	}
-
-	// everything went well
-	x.expr = e
-	return expression
-
-Error:
-	x.mode = invalid
-	x.expr = e
-	return statement // avoid follow-up errors
-}
-
-// typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
-func (check *Checker) typeAssertion(pos token.Pos, x *operand, xtyp *Interface, T Type) {
-	method, wrongType := assertableTo(xtyp, T)
-	if method == nil {
-		return
-	}
-
-	var msg string
-	if wrongType {
-		msg = "wrong type for method"
-	} else {
-		msg = "missing method"
-	}
-	check.errorf(pos, "%s cannot have dynamic type %s (%s %s)", x, T, msg, method.name)
-}
-
-// expr typechecks expression e and initializes x with the expression value.
-// If an error occurred, x.mode is set to invalid.
-//
-func (check *Checker) expr(x *operand, e ast.Expr) {
-	check.rawExpr(x, e, nil)
-	var msg string
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "used as value"
-	case builtin:
-		msg = "must be called"
-	case typexpr:
-		msg = "is not an expression"
-	}
-	check.errorf(x.pos(), "%s %s", x, msg)
-	x.mode = invalid
-}
-
-// exprWithHint typechecks expression e and initializes x with the expression value.
-// If an error occurred, x.mode is set to invalid.
-// If hint != nil, it is the type of a composite literal element.
-//
-func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
-	assert(hint != nil)
-	check.rawExpr(x, e, hint)
-	var msg string
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "used as value"
-	case builtin:
-		msg = "must be called"
-	case typexpr:
-		msg = "is not an expression"
-	}
-	check.errorf(x.pos(), "%s %s", x, msg)
-	x.mode = invalid
-}
-
-// exprOrType typechecks expression or type e and initializes x with the expression value or type.
-// If an error occurred, x.mode is set to invalid.
-//
-func (check *Checker) exprOrType(x *operand, e ast.Expr) {
-	check.rawExpr(x, e, nil)
-	if x.mode == novalue {
-		check.errorf(x.pos(), "%s used as value or type", x)
-		x.mode = invalid
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/exprstring.go b/vendor/golang.org/x/tools/go/types/exprstring.go
deleted file mode 100644
index 370bdf3..0000000
--- a/vendor/golang.org/x/tools/go/types/exprstring.go
+++ /dev/null
@@ -1,220 +0,0 @@
-// 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.
-
-// This file implements printing of expressions.
-
-package types
-
-import (
-	"bytes"
-	"go/ast"
-)
-
-// ExprString returns the (possibly simplified) string representation for x.
-func ExprString(x ast.Expr) string {
-	var buf bytes.Buffer
-	WriteExpr(&buf, x)
-	return buf.String()
-}
-
-// WriteExpr writes the (possibly simplified) string representation for x to buf.
-func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
-	// The AST preserves source-level parentheses so there is
-	// no need to introduce them here to correct for different
-	// operator precedences. (This assumes that the AST was
-	// generated by a Go parser.)
-
-	switch x := x.(type) {
-	default:
-		buf.WriteString("(bad expr)") // nil, ast.BadExpr, ast.KeyValueExpr
-
-	case *ast.Ident:
-		buf.WriteString(x.Name)
-
-	case *ast.Ellipsis:
-		buf.WriteString("...")
-		if x.Elt != nil {
-			WriteExpr(buf, x.Elt)
-		}
-
-	case *ast.BasicLit:
-		buf.WriteString(x.Value)
-
-	case *ast.FuncLit:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // simplified
-
-	case *ast.CompositeLit:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // simplified
-
-	case *ast.ParenExpr:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.X)
-		buf.WriteByte(')')
-
-	case *ast.SelectorExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('.')
-		buf.WriteString(x.Sel.Name)
-
-	case *ast.IndexExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		WriteExpr(buf, x.Index)
-		buf.WriteByte(']')
-
-	case *ast.SliceExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		if x.Low != nil {
-			WriteExpr(buf, x.Low)
-		}
-		buf.WriteByte(':')
-		if x.High != nil {
-			WriteExpr(buf, x.High)
-		}
-		if x.Slice3 {
-			buf.WriteByte(':')
-			if x.Max != nil {
-				WriteExpr(buf, x.Max)
-			}
-		}
-		buf.WriteByte(']')
-
-	case *ast.TypeAssertExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteString(".(")
-		WriteExpr(buf, x.Type)
-		buf.WriteByte(')')
-
-	case *ast.CallExpr:
-		WriteExpr(buf, x.Fun)
-		buf.WriteByte('(')
-		for i, arg := range x.Args {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			WriteExpr(buf, arg)
-		}
-		if x.Ellipsis.IsValid() {
-			buf.WriteString("...")
-		}
-		buf.WriteByte(')')
-
-	case *ast.StarExpr:
-		buf.WriteByte('*')
-		WriteExpr(buf, x.X)
-
-	case *ast.UnaryExpr:
-		buf.WriteString(x.Op.String())
-		WriteExpr(buf, x.X)
-
-	case *ast.BinaryExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte(' ')
-		buf.WriteString(x.Op.String())
-		buf.WriteByte(' ')
-		WriteExpr(buf, x.Y)
-
-	case *ast.ArrayType:
-		buf.WriteByte('[')
-		if x.Len != nil {
-			WriteExpr(buf, x.Len)
-		}
-		buf.WriteByte(']')
-		WriteExpr(buf, x.Elt)
-
-	case *ast.StructType:
-		buf.WriteString("struct{")
-		writeFieldList(buf, x.Fields, "; ", false)
-		buf.WriteByte('}')
-
-	case *ast.FuncType:
-		buf.WriteString("func")
-		writeSigExpr(buf, x)
-
-	case *ast.InterfaceType:
-		buf.WriteString("interface{")
-		writeFieldList(buf, x.Methods, "; ", true)
-		buf.WriteByte('}')
-
-	case *ast.MapType:
-		buf.WriteString("map[")
-		WriteExpr(buf, x.Key)
-		buf.WriteByte(']')
-		WriteExpr(buf, x.Value)
-
-	case *ast.ChanType:
-		var s string
-		switch x.Dir {
-		case ast.SEND:
-			s = "chan<- "
-		case ast.RECV:
-			s = "<-chan "
-		default:
-			s = "chan "
-		}
-		buf.WriteString(s)
-		WriteExpr(buf, x.Value)
-	}
-}
-
-func writeSigExpr(buf *bytes.Buffer, sig *ast.FuncType) {
-	buf.WriteByte('(')
-	writeFieldList(buf, sig.Params, ", ", false)
-	buf.WriteByte(')')
-
-	res := sig.Results
-	n := res.NumFields()
-	if n == 0 {
-		// no result
-		return
-	}
-
-	buf.WriteByte(' ')
-	if n == 1 && len(res.List[0].Names) == 0 {
-		// single unnamed result
-		WriteExpr(buf, res.List[0].Type)
-		return
-	}
-
-	// multiple or named result(s)
-	buf.WriteByte('(')
-	writeFieldList(buf, res, ", ", false)
-	buf.WriteByte(')')
-}
-
-func writeFieldList(buf *bytes.Buffer, fields *ast.FieldList, sep string, iface bool) {
-	for i, f := range fields.List {
-		if i > 0 {
-			buf.WriteString(sep)
-		}
-
-		// field list names
-		for i, name := range f.Names {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			buf.WriteString(name.Name)
-		}
-
-		// types of interface methods consist of signatures only
-		if sig, _ := f.Type.(*ast.FuncType); sig != nil && iface {
-			writeSigExpr(buf, sig)
-			continue
-		}
-
-		// named fields are separated with a blank from the field type
-		if len(f.Names) > 0 {
-			buf.WriteByte(' ')
-		}
-
-		WriteExpr(buf, f.Type)
-
-		// ignore tag
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/go11.go b/vendor/golang.org/x/tools/go/types/go11.go
deleted file mode 100644
index cf41cab..0000000
--- a/vendor/golang.org/x/tools/go/types/go11.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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.
-
-// +build !go1.2
-
-package types
-
-import "go/ast"
-
-func slice3(x *ast.SliceExpr) bool {
-	return false
-}
-
-func sliceMax(x *ast.SliceExpr) ast.Expr {
-	return nil
-}
diff --git a/vendor/golang.org/x/tools/go/types/go12.go b/vendor/golang.org/x/tools/go/types/go12.go
deleted file mode 100644
index 2017442..0000000
--- a/vendor/golang.org/x/tools/go/types/go12.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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.
-
-// +build go1.2
-
-package types
-
-import "go/ast"
-
-func slice3(x *ast.SliceExpr) bool {
-	return x.Slice3
-}
-
-func sliceMax(x *ast.SliceExpr) ast.Expr {
-	return x.Max
-}
diff --git a/vendor/golang.org/x/tools/go/types/initorder.go b/vendor/golang.org/x/tools/go/types/initorder.go
deleted file mode 100644
index 0fd567b..0000000
--- a/vendor/golang.org/x/tools/go/types/initorder.go
+++ /dev/null
@@ -1,222 +0,0 @@
-// 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 types
-
-import (
-	"container/heap"
-	"fmt"
-)
-
-// initOrder computes the Info.InitOrder for package variables.
-func (check *Checker) initOrder() {
-	// An InitOrder may already have been computed if a package is
-	// built from several calls to (*Checker).Files.  Clear it.
-	check.Info.InitOrder = check.Info.InitOrder[:0]
-
-	// compute the object dependency graph and
-	// initialize a priority queue with the list
-	// of graph nodes
-	pq := nodeQueue(dependencyGraph(check.objMap))
-	heap.Init(&pq)
-
-	const debug = false
-	if debug {
-		fmt.Printf("package %s: object dependency graph\n", check.pkg.Name())
-		for _, n := range pq {
-			for _, o := range n.out {
-				fmt.Printf("\t%s -> %s\n", n.obj.Name(), o.obj.Name())
-			}
-		}
-		fmt.Println()
-		fmt.Printf("package %s: initialization order\n", check.pkg.Name())
-	}
-
-	// determine initialization order by removing the highest priority node
-	// (the one with the fewest dependencies) and its edges from the graph,
-	// repeatedly, until there are no nodes left.
-	// In a valid Go program, those nodes always have zero dependencies (after
-	// removing all incoming dependencies), otherwise there are initialization
-	// cycles.
-	mark := 0
-	emitted := make(map[*declInfo]bool)
-	for len(pq) > 0 {
-		// get the next node
-		n := heap.Pop(&pq).(*objNode)
-
-		// if n still depends on other nodes, we have a cycle
-		if n.in > 0 {
-			mark++ // mark nodes using a different value each time
-			cycle := findPath(n, n, mark)
-			if i := valIndex(cycle); i >= 0 {
-				check.reportCycle(cycle, i)
-			}
-			// ok to continue, but the variable initialization order
-			// will be incorrect at this point since it assumes no
-			// cycle errors
-		}
-
-		// reduce dependency count of all dependent nodes
-		// and update priority queue
-		for _, out := range n.out {
-			out.in--
-			heap.Fix(&pq, out.index)
-		}
-
-		// record the init order for variables with initializers only
-		v, _ := n.obj.(*Var)
-		info := check.objMap[v]
-		if v == nil || !info.hasInitializer() {
-			continue
-		}
-
-		// n:1 variable declarations such as: a, b = f()
-		// introduce a node for each lhs variable (here: a, b);
-		// but they all have the same initializer - emit only
-		// one, for the first variable seen
-		if emitted[info] {
-			continue // initializer already emitted, if any
-		}
-		emitted[info] = true
-
-		infoLhs := info.lhs // possibly nil (see declInfo.lhs field comment)
-		if infoLhs == nil {
-			infoLhs = []*Var{v}
-		}
-		init := &Initializer{infoLhs, info.init}
-		check.Info.InitOrder = append(check.Info.InitOrder, init)
-
-		if debug {
-			fmt.Printf("\t%s\n", init)
-		}
-	}
-
-	if debug {
-		fmt.Println()
-	}
-}
-
-// findPath returns the (reversed) list of nodes z, ... c, b, a,
-// such that there is a path (list of edges) from a to z.
-// If there is no such path, the result is nil.
-// Nodes marked with the value mark are considered "visited";
-// unvisited nodes are marked during the graph search.
-func findPath(a, z *objNode, mark int) []*objNode {
-	if a.mark == mark {
-		return nil // node already seen
-	}
-	a.mark = mark
-
-	for _, n := range a.out {
-		if n == z {
-			return []*objNode{z}
-		}
-		if P := findPath(n, z, mark); P != nil {
-			return append(P, n)
-		}
-	}
-
-	return nil
-}
-
-// valIndex returns the index of the first constant or variable in a,
-// if any; or a value < 0.
-func valIndex(a []*objNode) int {
-	for i, n := range a {
-		switch n.obj.(type) {
-		case *Const, *Var:
-			return i
-		}
-	}
-	return -1
-}
-
-// reportCycle reports an error for the cycle starting at i.
-func (check *Checker) reportCycle(cycle []*objNode, i int) {
-	obj := cycle[i].obj
-	check.errorf(obj.Pos(), "initialization cycle for %s", obj.Name())
-	// print cycle
-	for _ = range cycle {
-		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
-		i++
-		if i >= len(cycle) {
-			i = 0
-		}
-		obj = cycle[i].obj
-	}
-	check.errorf(obj.Pos(), "\t%s", obj.Name())
-}
-
-// An objNode represents a node in the object dependency graph.
-// Each node b in a.out represents an edge a->b indicating that
-// b depends on a.
-// Nodes may be marked for cycle detection. A node n is marked
-// if n.mark corresponds to the current mark value.
-type objNode struct {
-	obj   Object     // object represented by this node
-	in    int        // number of nodes this node depends on
-	out   []*objNode // list of nodes that depend on this node
-	index int        // node index in list of nodes
-	mark  int        // for cycle detection
-}
-
-// dependencyGraph computes the transposed object dependency graph
-// from the given objMap. The transposed graph is returned as a list
-// of nodes; an edge d->n indicates that node n depends on node d.
-func dependencyGraph(objMap map[Object]*declInfo) []*objNode {
-	// M maps each object to its corresponding node
-	M := make(map[Object]*objNode, len(objMap))
-	for obj := range objMap {
-		M[obj] = &objNode{obj: obj}
-	}
-
-	// G is the graph of nodes n
-	G := make([]*objNode, len(M))
-	i := 0
-	for obj, n := range M {
-		deps := objMap[obj].deps
-		n.in = len(deps)
-		for d := range deps {
-			d := M[d]                // node n depends on node d
-			d.out = append(d.out, n) // add edge d->n
-		}
-
-		G[i] = n
-		n.index = i
-		i++
-	}
-
-	return G
-}
-
-// nodeQueue implements the container/heap interface;
-// a nodeQueue may be used as a priority queue.
-type nodeQueue []*objNode
-
-func (a nodeQueue) Len() int { return len(a) }
-
-func (a nodeQueue) Swap(i, j int) {
-	x, y := a[i], a[j]
-	a[i], a[j] = y, x
-	x.index, y.index = j, i
-}
-
-func (a nodeQueue) Less(i, j int) bool {
-	x, y := a[i], a[j]
-	// nodes are prioritized by number of incoming dependencies (1st key)
-	// and source order (2nd key)
-	return x.in < y.in || x.in == y.in && x.obj.order() < y.obj.order()
-}
-
-func (a *nodeQueue) Push(x interface{}) {
-	panic("unreachable")
-}
-
-func (a *nodeQueue) Pop() interface{} {
-	n := len(*a)
-	x := (*a)[n-1]
-	x.index = -1 // for safety
-	*a = (*a)[:n-1]
-	return x
-}
diff --git a/vendor/golang.org/x/tools/go/types/labels.go b/vendor/golang.org/x/tools/go/types/labels.go
deleted file mode 100644
index 7364d4d..0000000
--- a/vendor/golang.org/x/tools/go/types/labels.go
+++ /dev/null
@@ -1,268 +0,0 @@
-// 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 types
-
-import (
-	"go/ast"
-	"go/token"
-)
-
-// labels checks correct label use in body.
-func (check *Checker) labels(body *ast.BlockStmt) {
-	// set of all labels in this body
-	all := NewScope(nil, body.Pos(), body.End(), "label")
-
-	fwdJumps := check.blockBranches(all, nil, nil, body.List)
-
-	// If there are any forward jumps left, no label was found for
-	// the corresponding goto statements. Either those labels were
-	// never defined, or they are inside blocks and not reachable
-	// for the respective gotos.
-	for _, jmp := range fwdJumps {
-		var msg string
-		name := jmp.Label.Name
-		if alt := all.Lookup(name); alt != nil {
-			msg = "goto %s jumps into block"
-			alt.(*Label).used = true // avoid another error
-		} else {
-			msg = "label %s not declared"
-		}
-		check.errorf(jmp.Label.Pos(), msg, name)
-	}
-
-	// spec: "It is illegal to define a label that is never used."
-	for _, obj := range all.elems {
-		if lbl := obj.(*Label); !lbl.used {
-			check.softErrorf(lbl.pos, "label %s declared but not used", lbl.name)
-		}
-	}
-}
-
-// A block tracks label declarations in a block and its enclosing blocks.
-type block struct {
-	parent *block                      // enclosing block
-	lstmt  *ast.LabeledStmt            // labeled statement to which this block belongs, or nil
-	labels map[string]*ast.LabeledStmt // allocated lazily
-}
-
-// insert records a new label declaration for the current block.
-// The label must not have been declared before in any block.
-func (b *block) insert(s *ast.LabeledStmt) {
-	name := s.Label.Name
-	if debug {
-		assert(b.gotoTarget(name) == nil)
-	}
-	labels := b.labels
-	if labels == nil {
-		labels = make(map[string]*ast.LabeledStmt)
-		b.labels = labels
-	}
-	labels[name] = s
-}
-
-// gotoTarget returns the labeled statement in the current
-// or an enclosing block with the given label name, or nil.
-func (b *block) gotoTarget(name string) *ast.LabeledStmt {
-	for s := b; s != nil; s = s.parent {
-		if t := s.labels[name]; t != nil {
-			return t
-		}
-	}
-	return nil
-}
-
-// enclosingTarget returns the innermost enclosing labeled
-// statement with the given label name, or nil.
-func (b *block) enclosingTarget(name string) *ast.LabeledStmt {
-	for s := b; s != nil; s = s.parent {
-		if t := s.lstmt; t != nil && t.Label.Name == name {
-			return t
-		}
-	}
-	return nil
-}
-
-// blockBranches processes a block's statement list and returns the set of outgoing forward jumps.
-// all is the scope of all declared labels, parent the set of labels declared in the immediately
-// enclosing block, and lstmt is the labeled statement this block is associated with (or nil).
-func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *ast.LabeledStmt, list []ast.Stmt) []*ast.BranchStmt {
-	b := &block{parent: parent, lstmt: lstmt}
-
-	var (
-		varDeclPos         token.Pos
-		fwdJumps, badJumps []*ast.BranchStmt
-	)
-
-	// All forward jumps jumping over a variable declaration are possibly
-	// invalid (they may still jump out of the block and be ok).
-	// recordVarDecl records them for the given position.
-	recordVarDecl := func(pos token.Pos) {
-		varDeclPos = pos
-		badJumps = append(badJumps[:0], fwdJumps...) // copy fwdJumps to badJumps
-	}
-
-	jumpsOverVarDecl := func(jmp *ast.BranchStmt) bool {
-		if varDeclPos.IsValid() {
-			for _, bad := range badJumps {
-				if jmp == bad {
-					return true
-				}
-			}
-		}
-		return false
-	}
-
-	blockBranches := func(lstmt *ast.LabeledStmt, list []ast.Stmt) {
-		// Unresolved forward jumps inside the nested block
-		// become forward jumps in the current block.
-		fwdJumps = append(fwdJumps, check.blockBranches(all, b, lstmt, list)...)
-	}
-
-	var stmtBranches func(ast.Stmt)
-	stmtBranches = func(s ast.Stmt) {
-		switch s := s.(type) {
-		case *ast.DeclStmt:
-			if d, _ := s.Decl.(*ast.GenDecl); d != nil && d.Tok == token.VAR {
-				recordVarDecl(d.Pos())
-			}
-
-		case *ast.LabeledStmt:
-			// declare non-blank label
-			if name := s.Label.Name; name != "_" {
-				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
-				if alt := all.Insert(lbl); alt != nil {
-					check.softErrorf(lbl.pos, "label %s already declared", name)
-					check.reportAltDecl(alt)
-					// ok to continue
-				} else {
-					b.insert(s)
-					check.recordDef(s.Label, lbl)
-				}
-				// resolve matching forward jumps and remove them from fwdJumps
-				i := 0
-				for _, jmp := range fwdJumps {
-					if jmp.Label.Name == name {
-						// match
-						lbl.used = true
-						check.recordUse(jmp.Label, lbl)
-						if jumpsOverVarDecl(jmp) {
-							check.softErrorf(
-								jmp.Label.Pos(),
-								"goto %s jumps over variable declaration at line %d",
-								name,
-								check.fset.Position(varDeclPos).Line,
-							)
-							// ok to continue
-						}
-					} else {
-						// no match - record new forward jump
-						fwdJumps[i] = jmp
-						i++
-					}
-				}
-				fwdJumps = fwdJumps[:i]
-				lstmt = s
-			}
-			stmtBranches(s.Stmt)
-
-		case *ast.BranchStmt:
-			if s.Label == nil {
-				return // checked in 1st pass (check.stmt)
-			}
-
-			// determine and validate target
-			name := s.Label.Name
-			switch s.Tok {
-			case token.BREAK:
-				// spec: "If there is a label, it must be that of an enclosing
-				// "for", "switch", or "select" statement, and that is the one
-				// whose execution terminates."
-				valid := false
-				if t := b.enclosingTarget(name); t != nil {
-					switch t.Stmt.(type) {
-					case *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt, *ast.ForStmt, *ast.RangeStmt:
-						valid = true
-					}
-				}
-				if !valid {
-					check.errorf(s.Label.Pos(), "invalid break label %s", name)
-					return
-				}
-
-			case token.CONTINUE:
-				// spec: "If there is a label, it must be that of an enclosing
-				// "for" statement, and that is the one whose execution advances."
-				valid := false
-				if t := b.enclosingTarget(name); t != nil {
-					switch t.Stmt.(type) {
-					case *ast.ForStmt, *ast.RangeStmt:
-						valid = true
-					}
-				}
-				if !valid {
-					check.errorf(s.Label.Pos(), "invalid continue label %s", name)
-					return
-				}
-
-			case token.GOTO:
-				if b.gotoTarget(name) == nil {
-					// label may be declared later - add branch to forward jumps
-					fwdJumps = append(fwdJumps, s)
-					return
-				}
-
-			default:
-				check.invalidAST(s.Pos(), "branch statement: %s %s", s.Tok, name)
-				return
-			}
-
-			// record label use
-			obj := all.Lookup(name)
-			obj.(*Label).used = true
-			check.recordUse(s.Label, obj)
-
-		case *ast.AssignStmt:
-			if s.Tok == token.DEFINE {
-				recordVarDecl(s.Pos())
-			}
-
-		case *ast.BlockStmt:
-			blockBranches(lstmt, s.List)
-
-		case *ast.IfStmt:
-			stmtBranches(s.Body)
-			if s.Else != nil {
-				stmtBranches(s.Else)
-			}
-
-		case *ast.CaseClause:
-			blockBranches(nil, s.Body)
-
-		case *ast.SwitchStmt:
-			stmtBranches(s.Body)
-
-		case *ast.TypeSwitchStmt:
-			stmtBranches(s.Body)
-
-		case *ast.CommClause:
-			blockBranches(nil, s.Body)
-
-		case *ast.SelectStmt:
-			stmtBranches(s.Body)
-
-		case *ast.ForStmt:
-			stmtBranches(s.Body)
-
-		case *ast.RangeStmt:
-			stmtBranches(s.Body)
-		}
-	}
-
-	for _, s := range list {
-		stmtBranches(s)
-	}
-
-	return fwdJumps
-}
diff --git a/vendor/golang.org/x/tools/go/types/lookup.go b/vendor/golang.org/x/tools/go/types/lookup.go
deleted file mode 100644
index 3caca55..0000000
--- a/vendor/golang.org/x/tools/go/types/lookup.go
+++ /dev/null
@@ -1,341 +0,0 @@
-// 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.
-
-// This file implements various field and method lookup functions.
-
-package types
-
-// LookupFieldOrMethod looks up a field or method with given package and name
-// in T and returns the corresponding *Var or *Func, an index sequence, and a
-// bool indicating if there were any pointer indirections on the path to the
-// field or method. If addressable is set, T is the type of an addressable
-// variable (only matters for method lookups).
-//
-// The last index entry is the field or method index in the (possibly embedded)
-// type where the entry was found, either:
-//
-//	1) the list of declared methods of a named type; or
-//	2) the list of all methods (method set) of an interface type; or
-//	3) the list of fields of a struct type.
-//
-// The earlier index entries are the indices of the anonymous struct fields
-// traversed to get to the found entry, starting at depth 0.
-//
-// If no entry is found, a nil object is returned. In this case, the returned
-// index and indirect values have the following meaning:
-//
-//	- If index != nil, the index sequence points to an ambiguous entry
-//	(the same name appeared more than once at the same embedding level).
-//
-//	- If indirect is set, a method with a pointer receiver type was found
-//      but there was no pointer on the path from the actual receiver type to
-//	the method's formal receiver base type, nor was the receiver addressable.
-//
-func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
-	// Methods cannot be associated to a named pointer type
-	// (spec: "The type denoted by T is called the receiver base type;
-	// it must not be a pointer or interface type and it must be declared
-	// in the same package as the method.").
-	// Thus, if we have a named pointer type, proceed with the underlying
-	// pointer type but discard the result if it is a method since we would
-	// not have found it for T (see also issue 8590).
-	if t, _ := T.(*Named); t != nil {
-		if p, _ := t.underlying.(*Pointer); p != nil {
-			obj, index, indirect = lookupFieldOrMethod(p, false, pkg, name)
-			if _, ok := obj.(*Func); ok {
-				return nil, nil, false
-			}
-			return
-		}
-	}
-
-	return lookupFieldOrMethod(T, addressable, pkg, name)
-}
-
-// TODO(gri) The named type consolidation and seen maps below must be
-//           indexed by unique keys for a given type. Verify that named
-//           types always have only one representation (even when imported
-//           indirectly via different packages.)
-
-func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
-	// WARNING: The code in this function is extremely subtle - do not modify casually!
-	//          This function and NewMethodSet should be kept in sync.
-
-	if name == "_" {
-		return // blank fields/methods are never found
-	}
-
-	typ, isPtr := deref(T)
-	named, _ := typ.(*Named)
-
-	// *typ where typ is an interface has no methods.
-	if isPtr {
-		utyp := typ
-		if named != nil {
-			utyp = named.underlying
-		}
-		if _, ok := utyp.(*Interface); ok {
-			return
-		}
-	}
-
-	// Start with typ as single entry at shallowest depth.
-	// If typ is not a named type, insert a nil type instead.
-	current := []embeddedType{{named, nil, isPtr, false}}
-
-	// named types that we have seen already, allocated lazily
-	var seen map[*Named]bool
-
-	// search current depth
-	for len(current) > 0 {
-		var next []embeddedType // embedded types found at current depth
-
-		// look for (pkg, name) in all types at current depth
-		for _, e := range current {
-			// The very first time only, e.typ may be nil.
-			// In this case, we don't have a named type and
-			// we simply continue with the underlying type.
-			if e.typ != nil {
-				if seen[e.typ] {
-					// We have seen this type before, at a more shallow depth
-					// (note that multiples of this type at the current depth
-					// were consolidated before). The type at that depth shadows
-					// this same type at the current depth, so we can ignore
-					// this one.
-					continue
-				}
-				if seen == nil {
-					seen = make(map[*Named]bool)
-				}
-				seen[e.typ] = true
-
-				// look for a matching attached method
-				if i, m := lookupMethod(e.typ.methods, pkg, name); m != nil {
-					// potential match
-					assert(m.typ != nil)
-					index = concat(e.index, i)
-					if obj != nil || e.multiples {
-						return nil, index, false // collision
-					}
-					obj = m
-					indirect = e.indirect
-					continue // we can't have a matching field or interface method
-				}
-
-				// continue with underlying type
-				typ = e.typ.underlying
-			}
-
-			switch t := typ.(type) {
-			case *Struct:
-				// look for a matching field and collect embedded types
-				for i, f := range t.fields {
-					if f.sameId(pkg, name) {
-						assert(f.typ != nil)
-						index = concat(e.index, i)
-						if obj != nil || e.multiples {
-							return nil, index, false // collision
-						}
-						obj = f
-						indirect = e.indirect
-						continue // we can't have a matching interface method
-					}
-					// Collect embedded struct fields for searching the next
-					// lower depth, but only if we have not seen a match yet
-					// (if we have a match it is either the desired field or
-					// we have a name collision on the same depth; in either
-					// case we don't need to look further).
-					// Embedded fields are always of the form T or *T where
-					// T is a named type. If e.typ appeared multiple times at
-					// this depth, f.typ appears multiple times at the next
-					// depth.
-					if obj == nil && f.anonymous {
-						// Ignore embedded basic types - only user-defined
-						// named types can have methods or struct fields.
-						typ, isPtr := deref(f.typ)
-						if t, _ := typ.(*Named); t != nil {
-							next = append(next, embeddedType{t, concat(e.index, i), e.indirect || isPtr, e.multiples})
-						}
-					}
-				}
-
-			case *Interface:
-				// look for a matching method
-				// TODO(gri) t.allMethods is sorted - use binary search
-				if i, m := lookupMethod(t.allMethods, pkg, name); m != nil {
-					assert(m.typ != nil)
-					index = concat(e.index, i)
-					if obj != nil || e.multiples {
-						return nil, index, false // collision
-					}
-					obj = m
-					indirect = e.indirect
-				}
-			}
-		}
-
-		if obj != nil {
-			// found a potential match
-			// spec: "A method call x.m() is valid if the method set of (the type of) x
-			//        contains m and the argument list can be assigned to the parameter
-			//        list of m. If x is addressable and &x's method set contains m, x.m()
-			//        is shorthand for (&x).m()".
-			if f, _ := obj.(*Func); f != nil && ptrRecv(f) && !indirect && !addressable {
-				return nil, nil, true // pointer/addressable receiver required
-			}
-			return
-		}
-
-		current = consolidateMultiples(next)
-	}
-
-	return nil, nil, false // not found
-}
-
-// embeddedType represents an embedded named type
-type embeddedType struct {
-	typ       *Named // nil means use the outer typ variable instead
-	index     []int  // embedded field indices, starting with index at depth 0
-	indirect  bool   // if set, there was a pointer indirection on the path to this field
-	multiples bool   // if set, typ appears multiple times at this depth
-}
-
-// consolidateMultiples collects multiple list entries with the same type
-// into a single entry marked as containing multiples. The result is the
-// consolidated list.
-func consolidateMultiples(list []embeddedType) []embeddedType {
-	if len(list) <= 1 {
-		return list // at most one entry - nothing to do
-	}
-
-	n := 0                       // number of entries w/ unique type
-	prev := make(map[*Named]int) // index at which type was previously seen
-	for _, e := range list {
-		if i, found := prev[e.typ]; found {
-			list[i].multiples = true
-			// ignore this entry
-		} else {
-			prev[e.typ] = n
-			list[n] = e
-			n++
-		}
-	}
-	return list[:n]
-}
-
-// MissingMethod returns (nil, false) if V implements T, otherwise it
-// returns a missing method required by T and whether it is missing or
-// just has the wrong type.
-//
-// For non-interface types V, or if static is set, V implements T if all
-// methods of T are present in V. Otherwise (V is an interface and static
-// is not set), MissingMethod only checks that methods of T which are also
-// present in V have matching types (e.g., for a type assertion x.(T) where
-// x is of interface type V).
-//
-func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) {
-	// fast path for common case
-	if T.Empty() {
-		return
-	}
-
-	// TODO(gri) Consider using method sets here. Might be more efficient.
-
-	if ityp, _ := V.Underlying().(*Interface); ityp != nil {
-		// TODO(gri) allMethods is sorted - can do this more efficiently
-		for _, m := range T.allMethods {
-			_, obj := lookupMethod(ityp.allMethods, m.pkg, m.name)
-			switch {
-			case obj == nil:
-				if static {
-					return m, false
-				}
-			case !Identical(obj.Type(), m.typ):
-				return m, true
-			}
-		}
-		return
-	}
-
-	// A concrete type implements T if it implements all methods of T.
-	for _, m := range T.allMethods {
-		obj, _, _ := lookupFieldOrMethod(V, false, m.pkg, m.name)
-
-		f, _ := obj.(*Func)
-		if f == nil {
-			return m, false
-		}
-
-		if !Identical(f.typ, m.typ) {
-			return m, true
-		}
-	}
-
-	return
-}
-
-// assertableTo reports whether a value of type V can be asserted to have type T.
-// It returns (nil, false) as affirmative answer. Otherwise it returns a missing
-// method required by V and whether it is missing or just has the wrong type.
-func assertableTo(V *Interface, T Type) (method *Func, wrongType bool) {
-	// no static check is required if T is an interface
-	// spec: "If T is an interface type, x.(T) asserts that the
-	//        dynamic type of x implements the interface T."
-	if _, ok := T.Underlying().(*Interface); ok && !strict {
-		return
-	}
-	return MissingMethod(T, V, false)
-}
-
-// deref dereferences typ if it is a *Pointer and returns its base and true.
-// Otherwise it returns (typ, false).
-func deref(typ Type) (Type, bool) {
-	if p, _ := typ.(*Pointer); p != nil {
-		return p.base, true
-	}
-	return typ, false
-}
-
-// derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
-// (named or unnamed) struct and returns its base. Otherwise it returns typ.
-func derefStructPtr(typ Type) Type {
-	if p, _ := typ.Underlying().(*Pointer); p != nil {
-		if _, ok := p.base.Underlying().(*Struct); ok {
-			return p.base
-		}
-	}
-	return typ
-}
-
-// concat returns the result of concatenating list and i.
-// The result does not share its underlying array with list.
-func concat(list []int, i int) []int {
-	var t []int
-	t = append(t, list...)
-	return append(t, i)
-}
-
-// fieldIndex returns the index for the field with matching package and name, or a value < 0.
-func fieldIndex(fields []*Var, pkg *Package, name string) int {
-	if name != "_" {
-		for i, f := range fields {
-			if f.sameId(pkg, name) {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
-// lookupMethod returns the index of and method with matching package and name, or (-1, nil).
-func lookupMethod(methods []*Func, pkg *Package, name string) (int, *Func) {
-	if name != "_" {
-		for i, m := range methods {
-			if m.sameId(pkg, name) {
-				return i, m
-			}
-		}
-	}
-	return -1, nil
-}
diff --git a/vendor/golang.org/x/tools/go/types/methodset.go b/vendor/golang.org/x/tools/go/types/methodset.go
deleted file mode 100644
index 8aff6f9..0000000
--- a/vendor/golang.org/x/tools/go/types/methodset.go
+++ /dev/null
@@ -1,271 +0,0 @@
-// 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.
-
-// This file implements method sets.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-)
-
-// A MethodSet is an ordered set of concrete or abstract (interface) methods;
-// a method is a MethodVal selection, and they are ordered by ascending m.Obj().Id().
-// The zero value for a MethodSet is a ready-to-use empty method set.
-type MethodSet struct {
-	list []*Selection
-}
-
-func (s *MethodSet) String() string {
-	if s.Len() == 0 {
-		return "MethodSet {}"
-	}
-
-	var buf bytes.Buffer
-	fmt.Fprintln(&buf, "MethodSet {")
-	for _, f := range s.list {
-		fmt.Fprintf(&buf, "\t%s\n", f)
-	}
-	fmt.Fprintln(&buf, "}")
-	return buf.String()
-}
-
-// Len returns the number of methods in s.
-func (s *MethodSet) Len() int { return len(s.list) }
-
-// At returns the i'th method in s for 0 <= i < s.Len().
-func (s *MethodSet) At(i int) *Selection { return s.list[i] }
-
-// Lookup returns the method with matching package and name, or nil if not found.
-func (s *MethodSet) Lookup(pkg *Package, name string) *Selection {
-	if s.Len() == 0 {
-		return nil
-	}
-
-	key := Id(pkg, name)
-	i := sort.Search(len(s.list), func(i int) bool {
-		m := s.list[i]
-		return m.obj.Id() >= key
-	})
-	if i < len(s.list) {
-		m := s.list[i]
-		if m.obj.Id() == key {
-			return m
-		}
-	}
-	return nil
-}
-
-// Shared empty method set.
-var emptyMethodSet MethodSet
-
-// NewMethodSet returns the method set for the given type T.  It
-// always returns a non-nil method set, even if it is empty.
-//
-// A MethodSetCache handles repeat queries more efficiently.
-//
-func NewMethodSet(T Type) *MethodSet {
-	// WARNING: The code in this function is extremely subtle - do not modify casually!
-	//          This function and lookupFieldOrMethod should be kept in sync.
-
-	// method set up to the current depth, allocated lazily
-	var base methodSet
-
-	typ, isPtr := deref(T)
-	named, _ := typ.(*Named)
-
-	// *typ where typ is an interface has no methods.
-	if isPtr {
-		utyp := typ
-		if named != nil {
-			utyp = named.underlying
-		}
-		if _, ok := utyp.(*Interface); ok {
-			return &emptyMethodSet
-		}
-	}
-
-	// Start with typ as single entry at shallowest depth.
-	// If typ is not a named type, insert a nil type instead.
-	current := []embeddedType{{named, nil, isPtr, false}}
-
-	// named types that we have seen already, allocated lazily
-	var seen map[*Named]bool
-
-	// collect methods at current depth
-	for len(current) > 0 {
-		var next []embeddedType // embedded types found at current depth
-
-		// field and method sets at current depth, allocated lazily
-		var fset fieldSet
-		var mset methodSet
-
-		for _, e := range current {
-			// The very first time only, e.typ may be nil.
-			// In this case, we don't have a named type and
-			// we simply continue with the underlying type.
-			if e.typ != nil {
-				if seen[e.typ] {
-					// We have seen this type before, at a more shallow depth
-					// (note that multiples of this type at the current depth
-					// were consolidated before). The type at that depth shadows
-					// this same type at the current depth, so we can ignore
-					// this one.
-					continue
-				}
-				if seen == nil {
-					seen = make(map[*Named]bool)
-				}
-				seen[e.typ] = true
-
-				mset = mset.add(e.typ.methods, e.index, e.indirect, e.multiples)
-
-				// continue with underlying type
-				typ = e.typ.underlying
-			}
-
-			switch t := typ.(type) {
-			case *Struct:
-				for i, f := range t.fields {
-					fset = fset.add(f, e.multiples)
-
-					// Embedded fields are always of the form T or *T where
-					// T is a named type. If typ appeared multiple times at
-					// this depth, f.Type appears multiple times at the next
-					// depth.
-					if f.anonymous {
-						// Ignore embedded basic types - only user-defined
-						// named types can have methods or struct fields.
-						typ, isPtr := deref(f.typ)
-						if t, _ := typ.(*Named); t != nil {
-							next = append(next, embeddedType{t, concat(e.index, i), e.indirect || isPtr, e.multiples})
-						}
-					}
-				}
-
-			case *Interface:
-				mset = mset.add(t.allMethods, e.index, true, e.multiples)
-			}
-		}
-
-		// Add methods and collisions at this depth to base if no entries with matching
-		// names exist already.
-		for k, m := range mset {
-			if _, found := base[k]; !found {
-				// Fields collide with methods of the same name at this depth.
-				if _, found := fset[k]; found {
-					m = nil // collision
-				}
-				if base == nil {
-					base = make(methodSet)
-				}
-				base[k] = m
-			}
-		}
-
-		// Multiple fields with matching names collide at this depth and shadow all
-		// entries further down; add them as collisions to base if no entries with
-		// matching names exist already.
-		for k, f := range fset {
-			if f == nil {
-				if _, found := base[k]; !found {
-					if base == nil {
-						base = make(methodSet)
-					}
-					base[k] = nil // collision
-				}
-			}
-		}
-
-		current = consolidateMultiples(next)
-	}
-
-	if len(base) == 0 {
-		return &emptyMethodSet
-	}
-
-	// collect methods
-	var list []*Selection
-	for _, m := range base {
-		if m != nil {
-			m.recv = T
-			list = append(list, m)
-		}
-	}
-	sort.Sort(byUniqueName(list))
-	return &MethodSet{list}
-}
-
-// A fieldSet is a set of fields and name collisions.
-// A collision indicates that multiple fields with the
-// same unique id appeared.
-type fieldSet map[string]*Var // a nil entry indicates a name collision
-
-// Add adds field f to the field set s.
-// If multiples is set, f appears multiple times
-// and is treated as a collision.
-func (s fieldSet) add(f *Var, multiples bool) fieldSet {
-	if s == nil {
-		s = make(fieldSet)
-	}
-	key := f.Id()
-	// if f is not in the set, add it
-	if !multiples {
-		if _, found := s[key]; !found {
-			s[key] = f
-			return s
-		}
-	}
-	s[key] = nil // collision
-	return s
-}
-
-// A methodSet is a set of methods and name collisions.
-// A collision indicates that multiple methods with the
-// same unique id appeared.
-type methodSet map[string]*Selection // a nil entry indicates a name collision
-
-// Add adds all functions in list to the method set s.
-// If multiples is set, every function in list appears multiple times
-// and is treated as a collision.
-func (s methodSet) add(list []*Func, index []int, indirect bool, multiples bool) methodSet {
-	if len(list) == 0 {
-		return s
-	}
-	if s == nil {
-		s = make(methodSet)
-	}
-	for i, f := range list {
-		key := f.Id()
-		// if f is not in the set, add it
-		if !multiples {
-			// TODO(gri) A found method may not be added because it's not in the method set
-			// (!indirect && ptrRecv(f)). A 2nd method on the same level may be in the method
-			// set and may not collide with the first one, thus leading to a false positive.
-			// Is that possible? Investigate.
-			if _, found := s[key]; !found && (indirect || !ptrRecv(f)) {
-				s[key] = &Selection{MethodVal, nil, f, concat(index, i), indirect}
-				continue
-			}
-		}
-		s[key] = nil // collision
-	}
-	return s
-}
-
-// ptrRecv reports whether the receiver is of the form *T.
-// The receiver must exist.
-func ptrRecv(f *Func) bool {
-	_, isPtr := deref(f.typ.(*Signature).recv.typ)
-	return isPtr
-}
-
-// byUniqueName function lists can be sorted by their unique names.
-type byUniqueName []*Selection
-
-func (a byUniqueName) Len() int           { return len(a) }
-func (a byUniqueName) Less(i, j int) bool { return a[i].obj.Id() < a[j].obj.Id() }
-func (a byUniqueName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/vendor/golang.org/x/tools/go/types/object.go b/vendor/golang.org/x/tools/go/types/object.go
deleted file mode 100644
index a9b6c43..0000000
--- a/vendor/golang.org/x/tools/go/types/object.go
+++ /dev/null
@@ -1,361 +0,0 @@
-// 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 types
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// TODO(gri) Document factory, accessor methods, and fields. General clean-up.
-
-// An Object describes a named language entity such as a package,
-// constant, type, variable, function (incl. methods), or label.
-// All objects implement the Object interface.
-//
-type Object interface {
-	Parent() *Scope // scope in which this object is declared
-	Pos() token.Pos // position of object identifier in declaration
-	Pkg() *Package  // nil for objects in the Universe scope and labels
-	Name() string   // package local object name
-	Type() Type     // object type
-	Exported() bool // reports whether the name starts with a capital letter
-	Id() string     // object id (see Id below)
-
-	// String returns a human-readable string of the object.
-	String() string
-
-	// order reflects a package-level object's source order: if object
-	// a is before object b in the source, then a.order() < b.order().
-	// order returns a value > 0 for package-level objects; it returns
-	// 0 for all other objects (including objects in file scopes).
-	order() uint32
-
-	// setOrder sets the order number of the object. It must be > 0.
-	setOrder(uint32)
-
-	// setParent sets the parent scope of the object.
-	setParent(*Scope)
-
-	// sameId reports whether obj.Id() and Id(pkg, name) are the same.
-	sameId(pkg *Package, name string) bool
-
-	// scopePos returns the start position of the scope of this Object
-	scopePos() token.Pos
-
-	// setScopePos sets the start position of the scope for this Object.
-	setScopePos(pos token.Pos)
-}
-
-// Id returns name if it is exported, otherwise it
-// returns the name qualified with the package path.
-func Id(pkg *Package, name string) string {
-	if ast.IsExported(name) {
-		return name
-	}
-	// unexported names need the package path for differentiation
-	// (if there's no package, make sure we don't start with '.'
-	// as that may change the order of methods between a setup
-	// inside a package and outside a package - which breaks some
-	// tests)
-	path := "_"
-	// TODO(gri): shouldn't !ast.IsExported(name) => pkg != nil be an precondition?
-	// if pkg == nil {
-	// 	panic("nil package in lookup of unexported name")
-	// }
-	if pkg != nil {
-		path = pkg.path
-		if path == "" {
-			path = "_"
-		}
-	}
-	return path + "." + name
-}
-
-// An object implements the common parts of an Object.
-type object struct {
-	parent    *Scope
-	pos       token.Pos
-	pkg       *Package
-	name      string
-	typ       Type
-	order_    uint32
-	scopePos_ token.Pos
-}
-
-func (obj *object) Parent() *Scope      { return obj.parent }
-func (obj *object) Pos() token.Pos      { return obj.pos }
-func (obj *object) Pkg() *Package       { return obj.pkg }
-func (obj *object) Name() string        { return obj.name }
-func (obj *object) Type() Type          { return obj.typ }
-func (obj *object) Exported() bool      { return ast.IsExported(obj.name) }
-func (obj *object) Id() string          { return Id(obj.pkg, obj.name) }
-func (obj *object) String() string      { panic("abstract") }
-func (obj *object) order() uint32       { return obj.order_ }
-func (obj *object) scopePos() token.Pos { return obj.scopePos_ }
-
-func (obj *object) setParent(parent *Scope)   { obj.parent = parent }
-func (obj *object) setOrder(order uint32)     { assert(order > 0); obj.order_ = order }
-func (obj *object) setScopePos(pos token.Pos) { obj.scopePos_ = pos }
-
-func (obj *object) sameId(pkg *Package, name string) bool {
-	// spec:
-	// "Two identifiers are different if they are spelled differently,
-	// or if they appear in different packages and are not exported.
-	// Otherwise, they are the same."
-	if name != obj.name {
-		return false
-	}
-	// obj.Name == name
-	if obj.Exported() {
-		return true
-	}
-	// not exported, so packages must be the same (pkg == nil for
-	// fields in Universe scope; this can only happen for types
-	// introduced via Eval)
-	if pkg == nil || obj.pkg == nil {
-		return pkg == obj.pkg
-	}
-	// pkg != nil && obj.pkg != nil
-	return pkg.path == obj.pkg.path
-}
-
-// A PkgName represents an imported Go package.
-type PkgName struct {
-	object
-	imported *Package
-	used     bool // set if the package was used
-}
-
-func NewPkgName(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName {
-	return &PkgName{object{nil, pos, pkg, name, Typ[Invalid], 0, token.NoPos}, imported, false}
-}
-
-// Imported returns the package that was imported.
-// It is distinct from Pkg(), which is the package containing the import statement.
-func (obj *PkgName) Imported() *Package { return obj.imported }
-
-// A Const represents a declared constant.
-type Const struct {
-	object
-	val     exact.Value
-	visited bool // for initialization cycle detection
-}
-
-func NewConst(pos token.Pos, pkg *Package, name string, typ Type, val exact.Value) *Const {
-	return &Const{object{nil, pos, pkg, name, typ, 0, token.NoPos}, val, false}
-}
-
-func (obj *Const) Val() exact.Value { return obj.val }
-
-// A TypeName represents a declared type.
-type TypeName struct {
-	object
-}
-
-func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName {
-	return &TypeName{object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-// A Variable represents a declared variable (including function parameters and results, and struct fields).
-type Var struct {
-	object
-	anonymous bool // if set, the variable is an anonymous struct field, and name is the type name
-	visited   bool // for initialization cycle detection
-	isField   bool // var is struct field
-	used      bool // set if the variable was used
-}
-
-func NewVar(pos token.Pos, pkg *Package, name string, typ Type) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}, used: true} // parameters are always 'used'
-}
-
-func NewField(pos token.Pos, pkg *Package, name string, typ Type, anonymous bool) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}, anonymous: anonymous, isField: true}
-}
-
-func (obj *Var) Anonymous() bool { return obj.anonymous }
-
-func (obj *Var) IsField() bool { return obj.isField }
-
-// A Func represents a declared function, concrete method, or abstract
-// (interface) method.  Its Type() is always a *Signature.
-// An abstract method may belong to many interfaces due to embedding.
-type Func struct {
-	object
-}
-
-func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func {
-	// don't store a nil signature
-	var typ Type
-	if sig != nil {
-		typ = sig
-	}
-	return &Func{object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-// FullName returns the package- or receiver-type-qualified name of
-// function or method obj.
-func (obj *Func) FullName() string {
-	var buf bytes.Buffer
-	writeFuncName(&buf, obj, nil)
-	return buf.String()
-}
-
-func (obj *Func) Scope() *Scope {
-	return obj.typ.(*Signature).scope
-}
-
-// A Label represents a declared label.
-type Label struct {
-	object
-	used bool // set if the label was used
-}
-
-func NewLabel(pos token.Pos, pkg *Package, name string) *Label {
-	return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid]}, false}
-}
-
-// A Builtin represents a built-in function.
-// Builtins don't have a valid type.
-type Builtin struct {
-	object
-	id builtinId
-}
-
-func newBuiltin(id builtinId) *Builtin {
-	return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid]}, id}
-}
-
-// Nil represents the predeclared value nil.
-type Nil struct {
-	object
-}
-
-func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
-	typ := obj.Type()
-	switch obj := obj.(type) {
-	case *PkgName:
-		fmt.Fprintf(buf, "package %s", obj.Name())
-		if path := obj.imported.path; path != "" && path != obj.name {
-			fmt.Fprintf(buf, " (%q)", path)
-		}
-		return
-
-	case *Const:
-		buf.WriteString("const")
-
-	case *TypeName:
-		buf.WriteString("type")
-		typ = typ.Underlying()
-
-	case *Var:
-		if obj.isField {
-			buf.WriteString("field")
-		} else {
-			buf.WriteString("var")
-		}
-
-	case *Func:
-		buf.WriteString("func ")
-		writeFuncName(buf, obj, qf)
-		if typ != nil {
-			WriteSignature(buf, typ.(*Signature), qf)
-		}
-		return
-
-	case *Label:
-		buf.WriteString("label")
-		typ = nil
-
-	case *Builtin:
-		buf.WriteString("builtin")
-		typ = nil
-
-	case *Nil:
-		buf.WriteString("nil")
-		return
-
-	default:
-		panic(fmt.Sprintf("writeObject(%T)", obj))
-	}
-
-	buf.WriteByte(' ')
-
-	// For package-level objects, qualify the name.
-	if obj.Pkg() != nil && obj.Pkg().scope.Lookup(obj.Name()) == obj {
-		writePackage(buf, obj.Pkg(), qf)
-	}
-	buf.WriteString(obj.Name())
-	if typ != nil {
-		buf.WriteByte(' ')
-		WriteType(buf, typ, qf)
-	}
-}
-
-func writePackage(buf *bytes.Buffer, pkg *Package, qf Qualifier) {
-	if pkg == nil {
-		return
-	}
-	var s string
-	if qf != nil {
-		s = qf(pkg)
-	} else {
-		s = pkg.Path()
-	}
-	if s != "" {
-		buf.WriteString(s)
-		buf.WriteByte('.')
-	}
-}
-
-// ObjectString returns the string form of obj.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func ObjectString(obj Object, qf Qualifier) string {
-	var buf bytes.Buffer
-	writeObject(&buf, obj, qf)
-	return buf.String()
-}
-
-func (obj *PkgName) String() string  { return ObjectString(obj, nil) }
-func (obj *Const) String() string    { return ObjectString(obj, nil) }
-func (obj *TypeName) String() string { return ObjectString(obj, nil) }
-func (obj *Var) String() string      { return ObjectString(obj, nil) }
-func (obj *Func) String() string     { return ObjectString(obj, nil) }
-func (obj *Label) String() string    { return ObjectString(obj, nil) }
-func (obj *Builtin) String() string  { return ObjectString(obj, nil) }
-func (obj *Nil) String() string      { return ObjectString(obj, nil) }
-
-func writeFuncName(buf *bytes.Buffer, f *Func, qf Qualifier) {
-	if f.typ != nil {
-		sig := f.typ.(*Signature)
-		if recv := sig.Recv(); recv != nil {
-			buf.WriteByte('(')
-			if _, ok := recv.Type().(*Interface); ok {
-				// gcimporter creates abstract methods of
-				// named interfaces using the interface type
-				// (not the named type) as the receiver.
-				// Don't print it in full.
-				buf.WriteString("interface")
-			} else {
-				WriteType(buf, recv.Type(), qf)
-			}
-			buf.WriteByte(')')
-			buf.WriteByte('.')
-		} else if f.pkg != nil {
-			writePackage(buf, f.pkg, qf)
-		}
-	}
-	buf.WriteString(f.name)
-}
diff --git a/vendor/golang.org/x/tools/go/types/objset.go b/vendor/golang.org/x/tools/go/types/objset.go
deleted file mode 100644
index 55eb74a..0000000
--- a/vendor/golang.org/x/tools/go/types/objset.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// 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.
-
-// This file implements objsets.
-//
-// An objset is similar to a Scope but objset elements
-// are identified by their unique id, instead of their
-// object name.
-
-package types
-
-// An objset is a set of objects identified by their unique id.
-// The zero value for objset is a ready-to-use empty objset.
-type objset map[string]Object // initialized lazily
-
-// insert attempts to insert an object obj into objset s.
-// If s already contains an alternative object alt with
-// the same name, insert leaves s unchanged and returns alt.
-// Otherwise it inserts obj and returns nil.
-func (s *objset) insert(obj Object) Object {
-	id := obj.Id()
-	if alt := (*s)[id]; alt != nil {
-		return alt
-	}
-	if *s == nil {
-		*s = make(map[string]Object)
-	}
-	(*s)[id] = obj
-	return nil
-}
diff --git a/vendor/golang.org/x/tools/go/types/operand.go b/vendor/golang.org/x/tools/go/types/operand.go
deleted file mode 100644
index d52b30e..0000000
--- a/vendor/golang.org/x/tools/go/types/operand.go
+++ /dev/null
@@ -1,288 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file defines operands and associated operations.
-
-package types
-
-import (
-	"bytes"
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// An operandMode specifies the (addressing) mode of an operand.
-type operandMode byte
-
-const (
-	invalid  operandMode = iota // operand is invalid
-	novalue                     // operand represents no value (result of a function call w/o result)
-	builtin                     // operand is a built-in function
-	typexpr                     // operand is a type
-	constant                    // operand is a constant; the operand's typ is a Basic type
-	variable                    // operand is an addressable variable
-	mapindex                    // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
-	value                       // operand is a computed value
-	commaok                     // like value, but operand may be used in a comma,ok expression
-)
-
-var operandModeString = [...]string{
-	invalid:  "invalid operand",
-	novalue:  "no value",
-	builtin:  "built-in",
-	typexpr:  "type",
-	constant: "constant",
-	variable: "variable",
-	mapindex: "map index expression",
-	value:    "value",
-	commaok:  "comma, ok expression",
-}
-
-// An operand represents an intermediate value during type checking.
-// Operands have an (addressing) mode, the expression evaluating to
-// the operand, the operand's type, a value for constants, and an id
-// for built-in functions.
-// The zero value of operand is a ready to use invalid operand.
-//
-type operand struct {
-	mode operandMode
-	expr ast.Expr
-	typ  Type
-	val  exact.Value
-	id   builtinId
-}
-
-// pos returns the position of the expression corresponding to x.
-// If x is invalid the position is token.NoPos.
-//
-func (x *operand) pos() token.Pos {
-	// x.expr may not be set if x is invalid
-	if x.expr == nil {
-		return token.NoPos
-	}
-	return x.expr.Pos()
-}
-
-// Operand string formats
-// (not all "untyped" cases can appear due to the type system,
-// but they fall out naturally here)
-//
-// mode       format
-//
-// invalid    <expr> (               <mode>                    )
-// novalue    <expr> (               <mode>                    )
-// builtin    <expr> (               <mode>                    )
-// typexpr    <expr> (               <mode>                    )
-//
-// constant   <expr> (<untyped kind> <mode>                    )
-// constant   <expr> (               <mode>       of type <typ>)
-// constant   <expr> (<untyped kind> <mode> <val>              )
-// constant   <expr> (               <mode> <val> of type <typ>)
-//
-// variable   <expr> (<untyped kind> <mode>                    )
-// variable   <expr> (               <mode>       of type <typ>)
-//
-// mapindex   <expr> (<untyped kind> <mode>                    )
-// mapindex   <expr> (               <mode>       of type <typ>)
-//
-// value      <expr> (<untyped kind> <mode>                    )
-// value      <expr> (               <mode>       of type <typ>)
-//
-// commaok    <expr> (<untyped kind> <mode>                    )
-// commaok    <expr> (               <mode>       of type <typ>)
-//
-func operandString(x *operand, qf Qualifier) string {
-	var buf bytes.Buffer
-
-	var expr string
-	if x.expr != nil {
-		expr = ExprString(x.expr)
-	} else {
-		switch x.mode {
-		case builtin:
-			expr = predeclaredFuncs[x.id].name
-		case typexpr:
-			expr = TypeString(x.typ, qf)
-		case constant:
-			expr = x.val.String()
-		}
-	}
-
-	// <expr> (
-	if expr != "" {
-		buf.WriteString(expr)
-		buf.WriteString(" (")
-	}
-
-	// <untyped kind>
-	hasType := false
-	switch x.mode {
-	case invalid, novalue, builtin, typexpr:
-		// no type
-	default:
-		// has type
-		if isUntyped(x.typ) {
-			buf.WriteString(x.typ.(*Basic).name)
-			buf.WriteByte(' ')
-			break
-		}
-		hasType = true
-	}
-
-	// <mode>
-	buf.WriteString(operandModeString[x.mode])
-
-	// <val>
-	if x.mode == constant {
-		if s := x.val.String(); s != expr {
-			buf.WriteByte(' ')
-			buf.WriteString(s)
-		}
-	}
-
-	// <typ>
-	if hasType {
-		if x.typ != Typ[Invalid] {
-			buf.WriteString(" of type ")
-			WriteType(&buf, x.typ, qf)
-		} else {
-			buf.WriteString(" with invalid type")
-		}
-	}
-
-	// )
-	if expr != "" {
-		buf.WriteByte(')')
-	}
-
-	return buf.String()
-}
-
-func (x *operand) String() string {
-	return operandString(x, nil)
-}
-
-// setConst sets x to the untyped constant for literal lit.
-func (x *operand) setConst(tok token.Token, lit string) {
-	val := exact.MakeFromLiteral(lit, tok)
-	if val == nil {
-		// TODO(gri) Should we make it an unknown constant instead?
-		x.mode = invalid
-		return
-	}
-
-	var kind BasicKind
-	switch tok {
-	case token.INT:
-		kind = UntypedInt
-	case token.FLOAT:
-		kind = UntypedFloat
-	case token.IMAG:
-		kind = UntypedComplex
-	case token.CHAR:
-		kind = UntypedRune
-	case token.STRING:
-		kind = UntypedString
-	}
-
-	x.mode = constant
-	x.typ = Typ[kind]
-	x.val = val
-}
-
-// isNil reports whether x is the nil value.
-func (x *operand) isNil() bool {
-	return x.mode == value && x.typ == Typ[UntypedNil]
-}
-
-// TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
-//           checker.representable, and checker.assignment are
-//           overlapping in functionality. Need to simplify and clean up.
-
-// assignableTo reports whether x is assignable to a variable of type T.
-func (x *operand) assignableTo(conf *Config, T Type) bool {
-	if x.mode == invalid || T == Typ[Invalid] {
-		return true // avoid spurious errors
-	}
-
-	V := x.typ
-
-	// x's type is identical to T
-	if Identical(V, T) {
-		return true
-	}
-
-	Vu := V.Underlying()
-	Tu := T.Underlying()
-
-	// T is an interface type and x implements T
-	// (Do this check first as it might succeed early.)
-	if Ti, ok := Tu.(*Interface); ok {
-		if Implements(x.typ, Ti) {
-			return true
-		}
-	}
-
-	// x's type V and T have identical underlying types
-	// and at least one of V or T is not a named type
-	if Identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
-		return true
-	}
-
-	// x is a bidirectional channel value, T is a channel
-	// type, x's type V and T have identical element types,
-	// and at least one of V or T is not a named type
-	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
-		if Tc, ok := Tu.(*Chan); ok && Identical(Vc.elem, Tc.elem) {
-			return !isNamed(V) || !isNamed(T)
-		}
-	}
-
-	// x is the predeclared identifier nil and T is a pointer,
-	// function, slice, map, channel, or interface type
-	if x.isNil() {
-		switch t := Tu.(type) {
-		case *Basic:
-			if t.kind == UnsafePointer {
-				return true
-			}
-		case *Pointer, *Signature, *Slice, *Map, *Chan, *Interface:
-			return true
-		}
-		return false
-	}
-
-	// x is an untyped constant representable by a value of type T
-	// TODO(gri) This is borrowing from checker.convertUntyped and
-	//           checker.representable. Need to clean up.
-	if isUntyped(Vu) {
-		switch t := Tu.(type) {
-		case *Basic:
-			if x.mode == constant {
-				return representableConst(x.val, conf, t.kind, nil)
-			}
-			// The result of a comparison is an untyped boolean,
-			// but may not be a constant.
-			if Vb, _ := Vu.(*Basic); Vb != nil {
-				return Vb.kind == UntypedBool && isBoolean(Tu)
-			}
-		case *Interface:
-			return x.isNil() || t.Empty()
-		case *Pointer, *Signature, *Slice, *Map, *Chan:
-			return x.isNil()
-		}
-	}
-
-	return false
-}
-
-// isInteger reports whether x is a value of integer type
-// or an untyped constant representable as an integer.
-func (x *operand) isInteger() bool {
-	return x.mode == invalid ||
-		isInteger(x.typ) ||
-		isUntyped(x.typ) && x.mode == constant && representableConst(x.val, nil, UntypedInt, nil) // no *Config required for UntypedInt
-}
diff --git a/vendor/golang.org/x/tools/go/types/ordering.go b/vendor/golang.org/x/tools/go/types/ordering.go
deleted file mode 100644
index 6bb98f2..0000000
--- a/vendor/golang.org/x/tools/go/types/ordering.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// 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 resolveOrder.
-
-package types
-
-import (
-	"go/ast"
-	"sort"
-)
-
-// resolveOrder computes the order in which package-level objects
-// must be type-checked.
-//
-// Interface types appear first in the list, sorted topologically
-// by dependencies on embedded interfaces that are also declared
-// in this package, followed by all other objects sorted in source
-// order.
-//
-// TODO(gri) Consider sorting all types by dependencies here, and
-// in the process check _and_ report type cycles. This may simplify
-// the full type-checking phase.
-//
-func (check *Checker) resolveOrder() []Object {
-	var ifaces, others []Object
-
-	// collect interface types with their dependencies, and all other objects
-	for obj := range check.objMap {
-		if ityp := check.interfaceFor(obj); ityp != nil {
-			ifaces = append(ifaces, obj)
-			// determine dependencies on embedded interfaces
-			for _, f := range ityp.Methods.List {
-				if len(f.Names) == 0 {
-					// Embedded interface: The type must be a (possibly
-					// qualified) identifier denoting another interface.
-					// Imported interfaces are already fully resolved,
-					// so we can ignore qualified identifiers.
-					if ident, _ := f.Type.(*ast.Ident); ident != nil {
-						embedded := check.pkg.scope.Lookup(ident.Name)
-						if check.interfaceFor(embedded) != nil {
-							check.objMap[obj].addDep(embedded)
-						}
-					}
-				}
-			}
-		} else {
-			others = append(others, obj)
-		}
-	}
-
-	// final object order
-	var order []Object
-
-	// sort interface types topologically by dependencies,
-	// and in source order if there are no dependencies
-	sort.Sort(inSourceOrder(ifaces))
-	if debug {
-		for _, obj := range ifaces {
-			assert(check.objMap[obj].mark == 0)
-		}
-	}
-	for _, obj := range ifaces {
-		check.appendInPostOrder(&order, obj)
-	}
-
-	// sort everything else in source order
-	sort.Sort(inSourceOrder(others))
-
-	return append(order, others...)
-}
-
-// interfaceFor returns the AST interface denoted by obj, or nil.
-func (check *Checker) interfaceFor(obj Object) *ast.InterfaceType {
-	tname, _ := obj.(*TypeName)
-	if tname == nil {
-		return nil // not a type
-	}
-	d := check.objMap[obj]
-	if d == nil {
-		check.dump("%s: %s should have been declared", obj.Pos(), obj.Name())
-		unreachable()
-	}
-	if d.typ == nil {
-		return nil // invalid AST - ignore (will be handled later)
-	}
-	ityp, _ := d.typ.(*ast.InterfaceType)
-	return ityp
-}
-
-func (check *Checker) appendInPostOrder(order *[]Object, obj Object) {
-	d := check.objMap[obj]
-	if d.mark != 0 {
-		// We've already seen this object; either because it's
-		// already added to order, or because we have a cycle.
-		// In both cases we stop. Cycle errors are reported
-		// when type-checking types.
-		return
-	}
-	d.mark = 1
-
-	for _, obj := range orderedSetObjects(d.deps) {
-		check.appendInPostOrder(order, obj)
-	}
-
-	*order = append(*order, obj)
-}
-
-func orderedSetObjects(set map[Object]bool) []Object {
-	list := make([]Object, len(set))
-	i := 0
-	for obj := range set {
-		// we don't care about the map element value
-		list[i] = obj
-		i++
-	}
-	sort.Sort(inSourceOrder(list))
-	return list
-}
-
-// inSourceOrder implements the sort.Sort interface.
-type inSourceOrder []Object
-
-func (a inSourceOrder) Len() int           { return len(a) }
-func (a inSourceOrder) Less(i, j int) bool { return a[i].order() < a[j].order() }
-func (a inSourceOrder) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/vendor/golang.org/x/tools/go/types/package.go b/vendor/golang.org/x/tools/go/types/package.go
deleted file mode 100644
index 48fe839..0000000
--- a/vendor/golang.org/x/tools/go/types/package.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// 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 types
-
-import (
-	"fmt"
-	"go/token"
-)
-
-// A Package describes a Go package.
-type Package struct {
-	path     string
-	name     string
-	scope    *Scope
-	complete bool
-	imports  []*Package
-	fake     bool // scope lookup errors are silently dropped if package is fake (internal use only)
-}
-
-// NewPackage returns a new Package for the given package path and name;
-// the name must not be the blank identifier.
-// The package is not complete and contains no explicit imports.
-func NewPackage(path, name string) *Package {
-	if name == "_" {
-		panic("invalid package name _")
-	}
-	scope := NewScope(Universe, token.NoPos, token.NoPos, fmt.Sprintf("package %q", path))
-	return &Package{path: path, name: name, scope: scope}
-}
-
-// Path returns the package path.
-func (pkg *Package) Path() string { return pkg.path }
-
-// Name returns the package name.
-func (pkg *Package) Name() string { return pkg.name }
-
-// Scope returns the (complete or incomplete) package scope
-// holding the objects declared at package level (TypeNames,
-// Consts, Vars, and Funcs).
-func (pkg *Package) Scope() *Scope { return pkg.scope }
-
-// A package is complete if its scope contains (at least) all
-// exported objects; otherwise it is incomplete.
-func (pkg *Package) Complete() bool { return pkg.complete }
-
-// MarkComplete marks a package as complete.
-func (pkg *Package) MarkComplete() { pkg.complete = true }
-
-// Imports returns the list of packages directly imported by
-// pkg; the list is in source order. Package unsafe is excluded.
-//
-// If pkg was loaded from export data, Imports includes packages that
-// provide package-level objects referenced by pkg.  This may be more or
-// less than the set of packages directly imported by pkg's source code.
-func (pkg *Package) Imports() []*Package { return pkg.imports }
-
-// SetImports sets the list of explicitly imported packages to list.
-// It is the caller's responsibility to make sure list elements are unique.
-func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }
-
-func (pkg *Package) String() string {
-	return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)
-}
diff --git a/vendor/golang.org/x/tools/go/types/predicates.go b/vendor/golang.org/x/tools/go/types/predicates.go
deleted file mode 100644
index 993c6d2..0000000
--- a/vendor/golang.org/x/tools/go/types/predicates.go
+++ /dev/null
@@ -1,309 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements commonly used type predicates.
-
-package types
-
-import "sort"
-
-func isNamed(typ Type) bool {
-	if _, ok := typ.(*Basic); ok {
-		return ok
-	}
-	_, ok := typ.(*Named)
-	return ok
-}
-
-func isBoolean(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsBoolean != 0
-}
-
-func isInteger(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsInteger != 0
-}
-
-func isUnsigned(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUnsigned != 0
-}
-
-func isFloat(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsFloat != 0
-}
-
-func isComplex(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsComplex != 0
-}
-
-func isNumeric(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsNumeric != 0
-}
-
-func isString(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsString != 0
-}
-
-func isTyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return !ok || t.info&IsUntyped == 0
-}
-
-func isUntyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUntyped != 0
-}
-
-func isOrdered(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsOrdered != 0
-}
-
-func isConstType(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsConstType != 0
-}
-
-// IsInterface reports whether typ is an interface type.
-func IsInterface(typ Type) bool {
-	_, ok := typ.Underlying().(*Interface)
-	return ok
-}
-
-// Comparable reports whether values of type T are comparable.
-func Comparable(T Type) bool {
-	switch t := T.Underlying().(type) {
-	case *Basic:
-		// assume invalid types to be comparable
-		// to avoid follow-up errors
-		return t.kind != UntypedNil
-	case *Pointer, *Interface, *Chan:
-		return true
-	case *Struct:
-		for _, f := range t.fields {
-			if !Comparable(f.typ) {
-				return false
-			}
-		}
-		return true
-	case *Array:
-		return Comparable(t.elem)
-	}
-	return false
-}
-
-// hasNil reports whether a type includes the nil value.
-func hasNil(typ Type) bool {
-	switch t := typ.Underlying().(type) {
-	case *Basic:
-		return t.kind == UnsafePointer
-	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
-		return true
-	}
-	return false
-}
-
-// Identical reports whether x and y are identical.
-func Identical(x, y Type) bool {
-	return identical(x, y, nil)
-}
-
-// An ifacePair is a node in a stack of interface type pairs compared for identity.
-type ifacePair struct {
-	x, y *Interface
-	prev *ifacePair
-}
-
-func (p *ifacePair) identical(q *ifacePair) bool {
-	return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x
-}
-
-func identical(x, y Type, p *ifacePair) bool {
-	if x == y {
-		return true
-	}
-
-	switch x := x.(type) {
-	case *Basic:
-		// Basic types are singletons except for the rune and byte
-		// aliases, thus we cannot solely rely on the x == y check
-		// above.
-		if y, ok := y.(*Basic); ok {
-			return x.kind == y.kind
-		}
-
-	case *Array:
-		// Two array types are identical if they have identical element types
-		// and the same array length.
-		if y, ok := y.(*Array); ok {
-			return x.len == y.len && identical(x.elem, y.elem, p)
-		}
-
-	case *Slice:
-		// Two slice types are identical if they have identical element types.
-		if y, ok := y.(*Slice); ok {
-			return identical(x.elem, y.elem, p)
-		}
-
-	case *Struct:
-		// Two struct types are identical if they have the same sequence of fields,
-		// and if corresponding fields have the same names, and identical types,
-		// and identical tags. Two anonymous fields are considered to have the same
-		// name. Lower-case field names from different packages are always different.
-		if y, ok := y.(*Struct); ok {
-			if x.NumFields() == y.NumFields() {
-				for i, f := range x.fields {
-					g := y.fields[i]
-					if f.anonymous != g.anonymous ||
-						x.Tag(i) != y.Tag(i) ||
-						!f.sameId(g.pkg, g.name) ||
-						!identical(f.typ, g.typ, p) {
-						return false
-					}
-				}
-				return true
-			}
-		}
-
-	case *Pointer:
-		// Two pointer types are identical if they have identical base types.
-		if y, ok := y.(*Pointer); ok {
-			return identical(x.base, y.base, p)
-		}
-
-	case *Tuple:
-		// Two tuples types are identical if they have the same number of elements
-		// and corresponding elements have identical types.
-		if y, ok := y.(*Tuple); ok {
-			if x.Len() == y.Len() {
-				if x != nil {
-					for i, v := range x.vars {
-						w := y.vars[i]
-						if !identical(v.typ, w.typ, p) {
-							return false
-						}
-					}
-				}
-				return true
-			}
-		}
-
-	case *Signature:
-		// Two function types are identical if they have the same number of parameters
-		// and result values, corresponding parameter and result types are identical,
-		// and either both functions are variadic or neither is. Parameter and result
-		// names are not required to match.
-		if y, ok := y.(*Signature); ok {
-			return x.variadic == y.variadic &&
-				identical(x.params, y.params, p) &&
-				identical(x.results, y.results, p)
-		}
-
-	case *Interface:
-		// Two interface types are identical if they have the same set of methods with
-		// the same names and identical function types. Lower-case method names from
-		// different packages are always different. The order of the methods is irrelevant.
-		if y, ok := y.(*Interface); ok {
-			a := x.allMethods
-			b := y.allMethods
-			if len(a) == len(b) {
-				// Interface types are the only types where cycles can occur
-				// that are not "terminated" via named types; and such cycles
-				// can only be created via method parameter types that are
-				// anonymous interfaces (directly or indirectly) embedding
-				// the current interface. Example:
-				//
-				//    type T interface {
-				//        m() interface{T}
-				//    }
-				//
-				// If two such (differently named) interfaces are compared,
-				// endless recursion occurs if the cycle is not detected.
-				//
-				// If x and y were compared before, they must be equal
-				// (if they were not, the recursion would have stopped);
-				// search the ifacePair stack for the same pair.
-				//
-				// This is a quadratic algorithm, but in practice these stacks
-				// are extremely short (bounded by the nesting depth of interface
-				// type declarations that recur via parameter types, an extremely
-				// rare occurrence). An alternative implementation might use a
-				// "visited" map, but that is probably less efficient overall.
-				q := &ifacePair{x, y, p}
-				for p != nil {
-					if p.identical(q) {
-						return true // same pair was compared before
-					}
-					p = p.prev
-				}
-				if debug {
-					assert(sort.IsSorted(byUniqueMethodName(a)))
-					assert(sort.IsSorted(byUniqueMethodName(b)))
-				}
-				for i, f := range a {
-					g := b[i]
-					if f.Id() != g.Id() || !identical(f.typ, g.typ, q) {
-						return false
-					}
-				}
-				return true
-			}
-		}
-
-	case *Map:
-		// Two map types are identical if they have identical key and value types.
-		if y, ok := y.(*Map); ok {
-			return identical(x.key, y.key, p) && identical(x.elem, y.elem, p)
-		}
-
-	case *Chan:
-		// Two channel types are identical if they have identical value types
-		// and the same direction.
-		if y, ok := y.(*Chan); ok {
-			return x.dir == y.dir && identical(x.elem, y.elem, p)
-		}
-
-	case *Named:
-		// Two named types are identical if their type names originate
-		// in the same type declaration.
-		if y, ok := y.(*Named); ok {
-			return x.obj == y.obj
-		}
-
-	default:
-		unreachable()
-	}
-
-	return false
-}
-
-// 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.
-//
-func defaultType(typ Type) Type {
-	if t, ok := typ.(*Basic); ok {
-		switch t.kind {
-		case UntypedBool:
-			return Typ[Bool]
-		case UntypedInt:
-			return Typ[Int]
-		case UntypedRune:
-			return universeRune // use 'rune' name
-		case UntypedFloat:
-			return Typ[Float64]
-		case UntypedComplex:
-			return Typ[Complex128]
-		case UntypedString:
-			return Typ[String]
-		}
-	}
-	return typ
-}
diff --git a/vendor/golang.org/x/tools/go/types/resolver.go b/vendor/golang.org/x/tools/go/types/resolver.go
deleted file mode 100644
index 374ffc2..0000000
--- a/vendor/golang.org/x/tools/go/types/resolver.go
+++ /dev/null
@@ -1,453 +0,0 @@
-// 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 types
-
-import (
-	"errors"
-	"fmt"
-	"go/ast"
-	"go/token"
-	pathLib "path"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// A declInfo describes a package-level const, type, var, or func declaration.
-type declInfo struct {
-	file  *Scope        // scope of file containing this declaration
-	lhs   []*Var        // lhs of n:1 variable declarations, or nil
-	typ   ast.Expr      // type, or nil
-	init  ast.Expr      // init expression, or nil
-	fdecl *ast.FuncDecl // func declaration, or nil
-
-	deps map[Object]bool // type and init dependencies; lazily allocated
-	mark int             // for dependency analysis
-}
-
-// hasInitializer reports whether the declared object has an initialization
-// expression or function body.
-func (d *declInfo) hasInitializer() bool {
-	return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
-}
-
-// addDep adds obj as a dependency to d.
-func (d *declInfo) addDep(obj Object) {
-	m := d.deps
-	if m == nil {
-		m = make(map[Object]bool)
-		d.deps = m
-	}
-	m[obj] = true
-}
-
-// arityMatch checks that the lhs and rhs of a const or var decl
-// have the appropriate number of names and init exprs. For const
-// decls, init is the value spec providing the init exprs; for
-// var decls, init is nil (the init exprs are in s in this case).
-func (check *Checker) arityMatch(s, init *ast.ValueSpec) {
-	l := len(s.Names)
-	r := len(s.Values)
-	if init != nil {
-		r = len(init.Values)
-	}
-
-	switch {
-	case init == nil && r == 0:
-		// var decl w/o init expr
-		if s.Type == nil {
-			check.errorf(s.Pos(), "missing type or init expr")
-		}
-	case l < r:
-		if l < len(s.Values) {
-			// init exprs from s
-			n := s.Values[l]
-			check.errorf(n.Pos(), "extra init expr %s", n)
-			// TODO(gri) avoid declared but not used error here
-		} else {
-			// init exprs "inherited"
-			check.errorf(s.Pos(), "extra init expr at %s", init.Pos())
-			// TODO(gri) avoid declared but not used error here
-		}
-	case l > r && (init != nil || r != 1):
-		n := s.Names[r]
-		check.errorf(n.Pos(), "missing init expr for %s", n)
-	}
-}
-
-func validatedImportPath(path string) (string, error) {
-	s, err := strconv.Unquote(path)
-	if err != nil {
-		return "", err
-	}
-	if s == "" {
-		return "", fmt.Errorf("empty string")
-	}
-	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
-	for _, r := range s {
-		if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
-			return s, fmt.Errorf("invalid character %#U", r)
-		}
-	}
-	return s, nil
-}
-
-// declarePkgObj declares obj in the package scope, records its ident -> obj mapping,
-// and updates check.objMap. The object must not be a function or method.
-func (check *Checker) declarePkgObj(ident *ast.Ident, obj Object, d *declInfo) {
-	assert(ident.Name == obj.Name())
-
-	// spec: "A package-scope or file-scope identifier with name init
-	// may only be declared to be a function with this (func()) signature."
-	if ident.Name == "init" {
-		check.errorf(ident.Pos(), "cannot declare init - must be func")
-		return
-	}
-
-	check.declare(check.pkg.scope, ident, obj, token.NoPos)
-	check.objMap[obj] = d
-	obj.setOrder(uint32(len(check.objMap)))
-}
-
-// filename returns a filename suitable for debugging output.
-func (check *Checker) filename(fileNo int) string {
-	file := check.files[fileNo]
-	if pos := file.Pos(); pos.IsValid() {
-		return check.fset.File(pos).Name()
-	}
-	return fmt.Sprintf("file[%d]", fileNo)
-}
-
-// collectObjects collects all file and package objects and inserts them
-// into their respective scopes. It also performs imports and associates
-// methods with receiver base type names.
-func (check *Checker) collectObjects() {
-	pkg := check.pkg
-
-	importer := check.conf.Import
-	if importer == nil {
-		if DefaultImport != nil {
-			importer = DefaultImport
-		} else {
-			// Panic if we encounter an import.
-			importer = func(map[string]*Package, string) (*Package, error) {
-				panic(`no Config.Import or DefaultImport (missing import _ "golang.org/x/tools/go/gcimporter"?)`)
-			}
-		}
-	}
-
-	// pkgImports is the set of packages already imported by any package file seen
-	// so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate
-	// it (pkg.imports may not be empty if we are checking test files incrementally).
-	var pkgImports = make(map[*Package]bool)
-	for _, imp := range pkg.imports {
-		pkgImports[imp] = true
-	}
-
-	for fileNo, file := range check.files {
-		// The package identifier denotes the current package,
-		// but there is no corresponding package object.
-		check.recordDef(file.Name, nil)
-
-		// Use the actual source file extent rather than *ast.File extent since the
-		// latter doesn't include comments which appear at the start or end of the file.
-		// Be conservative and use the *ast.File extent if we don't have a *token.File.
-		pos, end := file.Pos(), file.End()
-		if f := check.fset.File(file.Pos()); f != nil {
-			pos, end = token.Pos(f.Base()), token.Pos(f.Base()+f.Size())
-		}
-		fileScope := NewScope(check.pkg.scope, pos, end, check.filename(fileNo))
-		check.recordScope(file, fileScope)
-
-		for _, decl := range file.Decls {
-			switch d := decl.(type) {
-			case *ast.BadDecl:
-				// ignore
-
-			case *ast.GenDecl:
-				var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-				for iota, spec := range d.Specs {
-					switch s := spec.(type) {
-					case *ast.ImportSpec:
-						// import package
-						var imp *Package
-						path, err := validatedImportPath(s.Path.Value)
-						if err != nil {
-							check.errorf(s.Path.Pos(), "invalid import path (%s)", err)
-							continue
-						}
-						if path == "C" && check.conf.FakeImportC {
-							// TODO(gri) shouldn't create a new one each time
-							imp = NewPackage("C", "C")
-							imp.fake = true
-						} else {
-							var err error
-							imp, err = importer(check.conf.Packages, path)
-							if imp == nil && err == nil {
-								err = errors.New("Config.Import returned nil but no error")
-							}
-							if err != nil {
-								check.errorf(s.Path.Pos(), "could not import %s (%s)", path, err)
-								continue
-							}
-						}
-
-						// add package to list of explicit imports
-						// (this functionality is provided as a convenience
-						// for clients; it is not needed for type-checking)
-						if !pkgImports[imp] {
-							pkgImports[imp] = true
-							if imp != Unsafe {
-								pkg.imports = append(pkg.imports, imp)
-							}
-						}
-
-						// local name overrides imported package name
-						name := imp.name
-						if s.Name != nil {
-							name = s.Name.Name
-							if name == "init" {
-								check.errorf(s.Name.Pos(), "cannot declare init - must be func")
-								continue
-							}
-						}
-
-						obj := NewPkgName(s.Pos(), pkg, name, imp)
-						if s.Name != nil {
-							// in a dot-import, the dot represents the package
-							check.recordDef(s.Name, obj)
-						} else {
-							check.recordImplicit(s, obj)
-						}
-
-						// add import to file scope
-						if name == "." {
-							// merge imported scope with file scope
-							for _, obj := range imp.scope.elems {
-								// A package scope may contain non-exported objects,
-								// do not import them!
-								if obj.Exported() {
-									// TODO(gri) When we import a package, we create
-									// a new local package object. We should do the
-									// same for each dot-imported object. That way
-									// they can have correct position information.
-									// (We must not modify their existing position
-									// information because the same package - found
-									// via Config.Packages - may be dot-imported in
-									// another package!)
-									check.declare(fileScope, nil, obj, token.NoPos)
-									check.recordImplicit(s, obj)
-								}
-							}
-							// add position to set of dot-import positions for this file
-							// (this is only needed for "imported but not used" errors)
-							check.addUnusedDotImport(fileScope, imp, s.Pos())
-						} else {
-							// declare imported package object in file scope
-							check.declare(fileScope, nil, obj, token.NoPos)
-						}
-
-					case *ast.ValueSpec:
-						switch d.Tok {
-						case token.CONST:
-							// determine which initialization expressions to use
-							switch {
-							case s.Type != nil || len(s.Values) > 0:
-								last = s
-							case last == nil:
-								last = new(ast.ValueSpec) // make sure last exists
-							}
-
-							// declare all constants
-							for i, name := range s.Names {
-								obj := NewConst(name.Pos(), pkg, name.Name, nil, exact.MakeInt64(int64(iota)))
-
-								var init ast.Expr
-								if i < len(last.Values) {
-									init = last.Values[i]
-								}
-
-								d := &declInfo{file: fileScope, typ: last.Type, init: init}
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, last)
-
-						case token.VAR:
-							lhs := make([]*Var, len(s.Names))
-							// If there's exactly one rhs initializer, use
-							// the same declInfo d1 for all lhs variables
-							// so that each lhs variable depends on the same
-							// rhs initializer (n:1 var declaration).
-							var d1 *declInfo
-							if len(s.Values) == 1 {
-								// The lhs elements are only set up after the for loop below,
-								// but that's ok because declareVar only collects the declInfo
-								// for a later phase.
-								d1 = &declInfo{file: fileScope, lhs: lhs, typ: s.Type, init: s.Values[0]}
-							}
-
-							// declare all variables
-							for i, name := range s.Names {
-								obj := NewVar(name.Pos(), pkg, name.Name, nil)
-								lhs[i] = obj
-
-								d := d1
-								if d == nil {
-									// individual assignments
-									var init ast.Expr
-									if i < len(s.Values) {
-										init = s.Values[i]
-									}
-									d = &declInfo{file: fileScope, typ: s.Type, init: init}
-								}
-
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, nil)
-
-						default:
-							check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
-						}
-
-					case *ast.TypeSpec:
-						obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-						check.declarePkgObj(s.Name, obj, &declInfo{file: fileScope, typ: s.Type})
-
-					default:
-						check.invalidAST(s.Pos(), "unknown ast.Spec node %T", s)
-					}
-				}
-
-			case *ast.FuncDecl:
-				name := d.Name.Name
-				obj := NewFunc(d.Name.Pos(), pkg, name, nil)
-				if d.Recv == nil {
-					// regular function
-					if name == "init" {
-						// don't declare init functions in the package scope - they are invisible
-						obj.parent = pkg.scope
-						check.recordDef(d.Name, obj)
-						// init functions must have a body
-						if d.Body == nil {
-							check.softErrorf(obj.pos, "missing function body")
-						}
-					} else {
-						check.declare(pkg.scope, d.Name, obj, token.NoPos)
-					}
-				} else {
-					// method
-					check.recordDef(d.Name, obj)
-					// Associate method with receiver base type name, if possible.
-					// Ignore methods that have an invalid receiver, or a blank _
-					// receiver name. They will be type-checked later, with regular
-					// functions.
-					if list := d.Recv.List; len(list) > 0 {
-						typ := list[0].Type
-						if ptr, _ := typ.(*ast.StarExpr); ptr != nil {
-							typ = ptr.X
-						}
-						if base, _ := typ.(*ast.Ident); base != nil && base.Name != "_" {
-							check.assocMethod(base.Name, obj)
-						}
-					}
-				}
-				info := &declInfo{file: fileScope, fdecl: d}
-				check.objMap[obj] = info
-				obj.setOrder(uint32(len(check.objMap)))
-
-			default:
-				check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
-			}
-		}
-	}
-
-	// verify that objects in package and file scopes have different names
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
-				if pkg, ok := obj.(*PkgName); ok {
-					check.errorf(alt.Pos(), "%s already declared through import of %s", alt.Name(), pkg.Imported())
-					check.reportAltDecl(pkg)
-				} else {
-					check.errorf(alt.Pos(), "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
-					// TODO(gri) dot-imported objects don't have a position; reportAltDecl won't print anything
-					check.reportAltDecl(obj)
-				}
-			}
-		}
-	}
-}
-
-// packageObjects typechecks all package objects in objList, but not function bodies.
-func (check *Checker) packageObjects(objList []Object) {
-	// add new methods to already type-checked types (from a prior Checker.Files call)
-	for _, obj := range objList {
-		if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
-			check.addMethodDecls(obj)
-		}
-	}
-
-	// pre-allocate space for type declaration paths so that the underlying array is reused
-	typePath := make([]*TypeName, 0, 8)
-
-	for _, obj := range objList {
-		check.objDecl(obj, nil, typePath)
-	}
-
-	// At this point we may have a non-empty check.methods map; this means that not all
-	// entries were deleted at the end of typeDecl because the respective receiver base
-	// types were not found. In that case, an error was reported when declaring those
-	// methods. We can now safely discard this map.
-	check.methods = nil
-}
-
-// functionBodies typechecks all function bodies.
-func (check *Checker) functionBodies() {
-	for _, f := range check.funcs {
-		check.funcBody(f.decl, f.name, f.sig, f.body)
-	}
-}
-
-// unusedImports checks for unused imports.
-func (check *Checker) unusedImports() {
-	// if function bodies are not checked, packages' uses are likely missing - don't check
-	if check.conf.IgnoreFuncBodies {
-		return
-	}
-
-	// spec: "It is illegal (...) to directly import a package without referring to
-	// any of its exported identifiers. To import a package solely for its side-effects
-	// (initialization), use the blank identifier as explicit package name."
-
-	// check use of regular imported packages
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if obj, ok := obj.(*PkgName); ok {
-				// Unused "blank imports" are automatically ignored
-				// since _ identifiers are not entered into scopes.
-				if !obj.used {
-					path := obj.imported.path
-					base := pathLib.Base(path)
-					if obj.name == base {
-						check.softErrorf(obj.pos, "%q imported but not used", path)
-					} else {
-						check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
-					}
-				}
-			}
-		}
-	}
-
-	// check use of dot-imported packages
-	for _, unusedDotImports := range check.unusedDotImports {
-		for pkg, pos := range unusedDotImports {
-			check.softErrorf(pos, "%q imported but not used", pkg.path)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/return.go b/vendor/golang.org/x/tools/go/types/return.go
deleted file mode 100644
index 6628985..0000000
--- a/vendor/golang.org/x/tools/go/types/return.go
+++ /dev/null
@@ -1,185 +0,0 @@
-// 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.
-
-// This file implements isTerminating.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-)
-
-// isTerminating reports if s is a terminating statement.
-// If s is labeled, label is the label name; otherwise s
-// is "".
-func (check *Checker) isTerminating(s ast.Stmt, label string) bool {
-	switch s := s.(type) {
-	default:
-		unreachable()
-
-	case *ast.BadStmt, *ast.DeclStmt, *ast.EmptyStmt, *ast.SendStmt,
-		*ast.IncDecStmt, *ast.AssignStmt, *ast.GoStmt, *ast.DeferStmt,
-		*ast.RangeStmt:
-		// no chance
-
-	case *ast.LabeledStmt:
-		return check.isTerminating(s.Stmt, s.Label.Name)
-
-	case *ast.ExprStmt:
-		// the predeclared (possibly parenthesized) panic() function is terminating
-		if call, _ := unparen(s.X).(*ast.CallExpr); call != nil {
-			if id, _ := call.Fun.(*ast.Ident); id != nil {
-				if _, obj := check.scope.LookupParent(id.Name, token.NoPos); obj != nil {
-					if b, _ := obj.(*Builtin); b != nil && b.id == _Panic {
-						return true
-					}
-				}
-			}
-		}
-
-	case *ast.ReturnStmt:
-		return true
-
-	case *ast.BranchStmt:
-		if s.Tok == token.GOTO || s.Tok == token.FALLTHROUGH {
-			return true
-		}
-
-	case *ast.BlockStmt:
-		return check.isTerminatingList(s.List, "")
-
-	case *ast.IfStmt:
-		if s.Else != nil &&
-			check.isTerminating(s.Body, "") &&
-			check.isTerminating(s.Else, "") {
-			return true
-		}
-
-	case *ast.SwitchStmt:
-		return check.isTerminatingSwitch(s.Body, label)
-
-	case *ast.TypeSwitchStmt:
-		return check.isTerminatingSwitch(s.Body, label)
-
-	case *ast.SelectStmt:
-		for _, s := range s.Body.List {
-			cc := s.(*ast.CommClause)
-			if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
-				return false
-			}
-
-		}
-		return true
-
-	case *ast.ForStmt:
-		if s.Cond == nil && !hasBreak(s.Body, label, true) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (check *Checker) isTerminatingList(list []ast.Stmt, label string) bool {
-	n := len(list)
-	return n > 0 && check.isTerminating(list[n-1], label)
-}
-
-func (check *Checker) isTerminatingSwitch(body *ast.BlockStmt, label string) bool {
-	hasDefault := false
-	for _, s := range body.List {
-		cc := s.(*ast.CaseClause)
-		if cc.List == nil {
-			hasDefault = true
-		}
-		if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
-			return false
-		}
-	}
-	return hasDefault
-}
-
-// TODO(gri) For nested breakable statements, the current implementation of hasBreak
-//	     will traverse the same subtree repeatedly, once for each label. Replace
-//           with a single-pass label/break matching phase.
-
-// hasBreak reports if s is or contains a break statement
-// referring to the label-ed statement or implicit-ly the
-// closest outer breakable statement.
-func hasBreak(s ast.Stmt, label string, implicit bool) bool {
-	switch s := s.(type) {
-	default:
-		unreachable()
-
-	case *ast.BadStmt, *ast.DeclStmt, *ast.EmptyStmt, *ast.ExprStmt,
-		*ast.SendStmt, *ast.IncDecStmt, *ast.AssignStmt, *ast.GoStmt,
-		*ast.DeferStmt, *ast.ReturnStmt:
-		// no chance
-
-	case *ast.LabeledStmt:
-		return hasBreak(s.Stmt, label, implicit)
-
-	case *ast.BranchStmt:
-		if s.Tok == token.BREAK {
-			if s.Label == nil {
-				return implicit
-			}
-			if s.Label.Name == label {
-				return true
-			}
-		}
-
-	case *ast.BlockStmt:
-		return hasBreakList(s.List, label, implicit)
-
-	case *ast.IfStmt:
-		if hasBreak(s.Body, label, implicit) ||
-			s.Else != nil && hasBreak(s.Else, label, implicit) {
-			return true
-		}
-
-	case *ast.CaseClause:
-		return hasBreakList(s.Body, label, implicit)
-
-	case *ast.SwitchStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.TypeSwitchStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.CommClause:
-		return hasBreakList(s.Body, label, implicit)
-
-	case *ast.SelectStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.ForStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.RangeStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func hasBreakList(list []ast.Stmt, label string, implicit bool) bool {
-	for _, s := range list {
-		if hasBreak(s, label, implicit) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/vendor/golang.org/x/tools/go/types/scope.go b/vendor/golang.org/x/tools/go/types/scope.go
deleted file mode 100644
index 3502840..0000000
--- a/vendor/golang.org/x/tools/go/types/scope.go
+++ /dev/null
@@ -1,190 +0,0 @@
-// 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.
-
-// This file implements Scopes.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"go/token"
-	"io"
-	"sort"
-	"strings"
-)
-
-// TODO(gri) Provide scopes with a name or other mechanism so that
-//           objects can use that information for better printing.
-
-// A Scope maintains a set of objects and links to its containing
-// (parent) and contained (children) scopes. Objects may be inserted
-// and looked up by name. The zero value for Scope is a ready-to-use
-// empty scope.
-type Scope struct {
-	parent   *Scope
-	children []*Scope
-	elems    map[string]Object // lazily allocated
-	pos, end token.Pos         // scope extent; may be invalid
-	comment  string            // for debugging only
-}
-
-// NewScope returns a new, empty scope contained in the given parent
-// scope, if any.  The comment is for debugging only.
-func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
-	s := &Scope{parent, nil, nil, pos, end, comment}
-	// don't add children to Universe scope!
-	if parent != nil && parent != Universe {
-		parent.children = append(parent.children, s)
-	}
-	return s
-}
-
-// Parent returns the scope's containing (parent) scope.
-func (s *Scope) Parent() *Scope { return s.parent }
-
-// Len() returns the number of scope elements.
-func (s *Scope) Len() int { return len(s.elems) }
-
-// Names returns the scope's element names in sorted order.
-func (s *Scope) Names() []string {
-	names := make([]string, len(s.elems))
-	i := 0
-	for name := range s.elems {
-		names[i] = name
-		i++
-	}
-	sort.Strings(names)
-	return names
-}
-
-// NumChildren() returns the number of scopes nested in s.
-func (s *Scope) NumChildren() int { return len(s.children) }
-
-// Child returns the i'th child scope for 0 <= i < NumChildren().
-func (s *Scope) Child(i int) *Scope { return s.children[i] }
-
-// Lookup returns the object in scope s with the given name if such an
-// object exists; otherwise the result is nil.
-func (s *Scope) Lookup(name string) Object {
-	return s.elems[name]
-}
-
-// LookupParent follows the parent chain of scopes starting with s until
-// it finds a scope where Lookup(name) returns a non-nil object, and then
-// returns that scope and object. If a valid position pos is provided,
-// only objects that were declared at or before pos are considered.
-// If no such scope and object exists, the result is (nil, nil).
-//
-// Note that obj.Parent() may be different from the returned scope if the
-// object was inserted into the scope and already had a parent at that
-// time (see Insert, below). This can only happen for dot-imported objects
-// whose scope is the scope of the package that exported them.
-func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object) {
-	for ; s != nil; s = s.parent {
-		if obj := s.elems[name]; obj != nil && (!pos.IsValid() || obj.scopePos() <= pos) {
-			return s, obj
-		}
-	}
-	return nil, nil
-}
-
-// Insert attempts to insert an object obj into scope s.
-// If s already contains an alternative object alt with
-// the same name, Insert leaves s unchanged and returns alt.
-// Otherwise it inserts obj, sets the object's parent scope
-// if not already set, and returns nil.
-func (s *Scope) Insert(obj Object) Object {
-	name := obj.Name()
-	if alt := s.elems[name]; alt != nil {
-		return alt
-	}
-	if s.elems == nil {
-		s.elems = make(map[string]Object)
-	}
-	s.elems[name] = obj
-	if obj.Parent() == nil {
-		obj.setParent(s)
-	}
-	return nil
-}
-
-// Pos and End describe the scope's source code extent [pos, end).
-// The results are guaranteed to be valid only if the type-checked
-// AST has complete position information. The extent is undefined
-// for Universe and package scopes.
-func (s *Scope) Pos() token.Pos { return s.pos }
-func (s *Scope) End() token.Pos { return s.end }
-
-// Contains returns true if pos is within the scope's extent.
-// The result is guaranteed to be valid only if the type-checked
-// AST has complete position information.
-func (s *Scope) Contains(pos token.Pos) bool {
-	return s.pos <= pos && pos < s.end
-}
-
-// Innermost returns the innermost (child) scope containing
-// pos. If pos is not within any scope, the result is nil.
-// The result is also nil for the Universe scope.
-// The result is guaranteed to be valid only if the type-checked
-// AST has complete position information.
-func (s *Scope) Innermost(pos token.Pos) *Scope {
-	// Package scopes do not have extents since they may be
-	// discontiguous, so iterate over the package's files.
-	if s.parent == Universe {
-		for _, s := range s.children {
-			if inner := s.Innermost(pos); inner != nil {
-				return inner
-			}
-		}
-	}
-
-	if s.Contains(pos) {
-		for _, s := range s.children {
-			if s.Contains(pos) {
-				return s.Innermost(pos)
-			}
-		}
-		return s
-	}
-	return nil
-}
-
-// WriteTo writes a string representation of the scope to w,
-// with the scope elements sorted by name.
-// The level of indentation is controlled by n >= 0, with
-// n == 0 for no indentation.
-// If recurse is set, it also writes nested (children) scopes.
-func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
-	const ind = ".  "
-	indn := strings.Repeat(ind, n)
-
-	fmt.Fprintf(w, "%s%s scope %p {", indn, s.comment, s)
-	if len(s.elems) == 0 {
-		fmt.Fprintf(w, "}\n")
-		return
-	}
-
-	fmt.Fprintln(w)
-	indn1 := indn + ind
-	for _, name := range s.Names() {
-		fmt.Fprintf(w, "%s%s\n", indn1, s.elems[name])
-	}
-
-	if recurse {
-		for _, s := range s.children {
-			fmt.Fprintln(w)
-			s.WriteTo(w, n+1, recurse)
-		}
-	}
-
-	fmt.Fprintf(w, "%s}", indn)
-}
-
-// String returns a string representation of the scope, for debugging.
-func (s *Scope) String() string {
-	var buf bytes.Buffer
-	s.WriteTo(&buf, 0, false)
-	return buf.String()
-}
diff --git a/vendor/golang.org/x/tools/go/types/selection.go b/vendor/golang.org/x/tools/go/types/selection.go
deleted file mode 100644
index 124e0d3..0000000
--- a/vendor/golang.org/x/tools/go/types/selection.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// 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.
-
-// This file implements Selections.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// SelectionKind describes the kind of a selector expression x.f
-// (excluding qualified identifiers).
-type SelectionKind int
-
-const (
-	FieldVal   SelectionKind = iota // x.f is a struct field selector
-	MethodVal                       // x.f is a method selector
-	MethodExpr                      // x.f is a method expression
-)
-
-// A Selection describes a selector expression x.f.
-// For the declarations:
-//
-//	type T struct{ x int; E }
-//	type E struct{}
-//	func (e E) m() {}
-//	var p *T
-//
-// the following relations exist:
-//
-//	Selector    Kind          Recv    Obj    Type               Index     Indirect
-//
-//	p.x         FieldVal      T       x      int                {0}       true
-//	p.m         MethodVal     *T      m      func (e *T) m()    {1, 0}    true
-//	T.m         MethodExpr    T       m      func m(_ T)        {1, 0}    false
-//
-type Selection struct {
-	kind     SelectionKind
-	recv     Type   // type of x
-	obj      Object // object denoted by x.f
-	index    []int  // path from x to x.f
-	indirect bool   // set if there was any pointer indirection on the path
-}
-
-// Kind returns the selection kind.
-func (s *Selection) Kind() SelectionKind { return s.kind }
-
-// Recv returns the type of x in x.f.
-func (s *Selection) Recv() Type { return s.recv }
-
-// Obj returns the object denoted by x.f; a *Var for
-// a field selection, and a *Func in all other cases.
-func (s *Selection) Obj() Object { return s.obj }
-
-// Type returns the type of x.f, which may be different from the type of f.
-// See Selection for more information.
-func (s *Selection) Type() Type {
-	switch s.kind {
-	case MethodVal:
-		// The type of x.f is a method with its receiver type set
-		// to the type of x.
-		sig := *s.obj.(*Func).typ.(*Signature)
-		recv := *sig.recv
-		recv.typ = s.recv
-		sig.recv = &recv
-		return &sig
-
-	case MethodExpr:
-		// The type of x.f is a function (without receiver)
-		// and an additional first argument with the same type as x.
-		// TODO(gri) Similar code is already in call.go - factor!
-		// TODO(gri) Compute this eagerly to avoid allocations.
-		sig := *s.obj.(*Func).typ.(*Signature)
-		arg0 := *sig.recv
-		sig.recv = nil
-		arg0.typ = s.recv
-		var params []*Var
-		if sig.params != nil {
-			params = sig.params.vars
-		}
-		sig.params = NewTuple(append([]*Var{&arg0}, params...)...)
-		return &sig
-	}
-
-	// In all other cases, the type of x.f is the type of x.
-	return s.obj.Type()
-}
-
-// Index describes the path from x to f in x.f.
-// The last index entry is the field or method index of the type declaring f;
-// either:
-//
-//	1) the list of declared methods of a named type; or
-//	2) the list of methods of an interface type; or
-//	3) the list of fields of a struct type.
-//
-// The earlier index entries are the indices of the embedded fields implicitly
-// traversed to get from (the type of) x to f, starting at embedding depth 0.
-func (s *Selection) Index() []int { return s.index }
-
-// Indirect reports whether any pointer indirection was required to get from
-// x to f in x.f.
-func (s *Selection) Indirect() bool { return s.indirect }
-
-func (s *Selection) String() string { return SelectionString(s, nil) }
-
-// SelectionString returns the string form of s.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-//
-// Examples:
-//	"field (T) f int"
-//	"method (T) f(X) Y"
-//	"method expr (T) f(X) Y"
-//
-func SelectionString(s *Selection, qf Qualifier) string {
-	var k string
-	switch s.kind {
-	case FieldVal:
-		k = "field "
-	case MethodVal:
-		k = "method "
-	case MethodExpr:
-		k = "method expr "
-	default:
-		unreachable()
-	}
-	var buf bytes.Buffer
-	buf.WriteString(k)
-	buf.WriteByte('(')
-	WriteType(&buf, s.Recv(), qf)
-	fmt.Fprintf(&buf, ") %s", s.obj.Name())
-	if T := s.Type(); s.kind == FieldVal {
-		buf.WriteByte(' ')
-		WriteType(&buf, T, qf)
-	} else {
-		WriteSignature(&buf, T.(*Signature), qf)
-	}
-	return buf.String()
-}
diff --git a/vendor/golang.org/x/tools/go/types/sizes.go b/vendor/golang.org/x/tools/go/types/sizes.go
deleted file mode 100644
index 56fb310..0000000
--- a/vendor/golang.org/x/tools/go/types/sizes.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// 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.
-
-// This file implements Sizes.
-
-package types
-
-// Sizes defines the sizing functions for package unsafe.
-type Sizes interface {
-	// Alignof returns the alignment of a variable of type T.
-	// Alignof must implement the alignment guarantees required by the spec.
-	Alignof(T Type) int64
-
-	// Offsetsof returns the offsets of the given struct fields, in bytes.
-	// Offsetsof must implement the offset guarantees required by the spec.
-	Offsetsof(fields []*Var) []int64
-
-	// Sizeof returns the size of a variable of type T.
-	// Sizeof must implement the size guarantees required by the spec.
-	Sizeof(T Type) int64
-}
-
-// StdSizes is a convenience type for creating commonly used Sizes.
-// It makes the following simplifying assumptions:
-//
-//	- The size of explicitly sized basic types (int16, etc.) is the
-//	  specified size.
-//	- The size of strings and interfaces is 2*WordSize.
-//	- The size of slices is 3*WordSize.
-//	- The size of an array of n elements corresponds to the size of
-//	  a struct of n consecutive fields of the array's element type.
-//      - The size of a struct is the offset of the last field plus that
-//	  field's size. As with all element types, if the struct is used
-//	  in an array its size must first be aligned to a multiple of the
-//	  struct's alignment.
-//	- All other types have size WordSize.
-//	- Arrays and structs are aligned per spec definition; all other
-//	  types are naturally aligned with a maximum alignment MaxAlign.
-//
-// *StdSizes implements Sizes.
-//
-type StdSizes struct {
-	WordSize int64 // word size in bytes - must be >= 4 (32bits)
-	MaxAlign int64 // maximum alignment in bytes - must be >= 1
-}
-
-func (s *StdSizes) Alignof(T Type) int64 {
-	// For arrays and structs, alignment is defined in terms
-	// of alignment of the elements and fields, respectively.
-	switch t := T.Underlying().(type) {
-	case *Array:
-		// spec: "For a variable x of array type: unsafe.Alignof(x)
-		// is the same as unsafe.Alignof(x[0]), but at least 1."
-		return s.Alignof(t.elem)
-	case *Struct:
-		// spec: "For a variable x of struct type: unsafe.Alignof(x)
-		// is the largest of the values unsafe.Alignof(x.f) for each
-		// field f of x, but at least 1."
-		max := int64(1)
-		for _, f := range t.fields {
-			if a := s.Alignof(f.typ); a > max {
-				max = a
-			}
-		}
-		return max
-	}
-	a := s.Sizeof(T) // may be 0
-	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
-	if a < 1 {
-		return 1
-	}
-	if a > s.MaxAlign {
-		return s.MaxAlign
-	}
-	return a
-}
-
-func (s *StdSizes) Offsetsof(fields []*Var) []int64 {
-	offsets := make([]int64, len(fields))
-	var o int64
-	for i, f := range fields {
-		a := s.Alignof(f.typ)
-		o = align(o, a)
-		offsets[i] = o
-		o += s.Sizeof(f.typ)
-	}
-	return offsets
-}
-
-var basicSizes = [...]byte{
-	Bool:       1,
-	Int8:       1,
-	Int16:      2,
-	Int32:      4,
-	Int64:      8,
-	Uint8:      1,
-	Uint16:     2,
-	Uint32:     4,
-	Uint64:     8,
-	Float32:    4,
-	Float64:    8,
-	Complex64:  8,
-	Complex128: 16,
-}
-
-func (s *StdSizes) Sizeof(T Type) int64 {
-	switch t := T.Underlying().(type) {
-	case *Basic:
-		assert(isTyped(T))
-		k := t.kind
-		if int(k) < len(basicSizes) {
-			if s := basicSizes[k]; s > 0 {
-				return int64(s)
-			}
-		}
-		if k == String {
-			return s.WordSize * 2
-		}
-	case *Array:
-		n := t.len
-		if n == 0 {
-			return 0
-		}
-		a := s.Alignof(t.elem)
-		z := s.Sizeof(t.elem)
-		return align(z, a)*(n-1) + z
-	case *Slice:
-		return s.WordSize * 3
-	case *Struct:
-		n := t.NumFields()
-		if n == 0 {
-			return 0
-		}
-		offsets := t.offsets
-		if t.offsets == nil {
-			// compute offsets on demand
-			offsets = s.Offsetsof(t.fields)
-			t.offsets = offsets
-		}
-		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
-	case *Interface:
-		return s.WordSize * 2
-	}
-	return s.WordSize // catch-all
-}
-
-// stdSizes is used if Config.Sizes == nil.
-var stdSizes = StdSizes{8, 8}
-
-func (conf *Config) alignof(T Type) int64 {
-	if s := conf.Sizes; s != nil {
-		if a := s.Alignof(T); a >= 1 {
-			return a
-		}
-		panic("Config.Sizes.Alignof returned an alignment < 1")
-	}
-	return stdSizes.Alignof(T)
-}
-
-func (conf *Config) offsetsof(T *Struct) []int64 {
-	offsets := T.offsets
-	if offsets == nil && T.NumFields() > 0 {
-		// compute offsets on demand
-		if s := conf.Sizes; s != nil {
-			offsets = s.Offsetsof(T.fields)
-			// sanity checks
-			if len(offsets) != T.NumFields() {
-				panic("Config.Sizes.Offsetsof returned the wrong number of offsets")
-			}
-			for _, o := range offsets {
-				if o < 0 {
-					panic("Config.Sizes.Offsetsof returned an offset < 0")
-				}
-			}
-		} else {
-			offsets = stdSizes.Offsetsof(T.fields)
-		}
-		T.offsets = offsets
-	}
-	return offsets
-}
-
-// offsetof returns the offset of the field specified via
-// the index sequence relative to typ. All embedded fields
-// must be structs (rather than pointer to structs).
-func (conf *Config) offsetof(typ Type, index []int) int64 {
-	var o int64
-	for _, i := range index {
-		s := typ.Underlying().(*Struct)
-		o += conf.offsetsof(s)[i]
-		typ = s.fields[i].typ
-	}
-	return o
-}
-
-func (conf *Config) sizeof(T Type) int64 {
-	if s := conf.Sizes; s != nil {
-		if z := s.Sizeof(T); z >= 0 {
-			return z
-		}
-		panic("Config.Sizes.Sizeof returned a size < 0")
-	}
-	return stdSizes.Sizeof(T)
-}
-
-// align returns the smallest y >= x such that y % a == 0.
-func align(x, a int64) int64 {
-	y := x + a - 1
-	return y - y%a
-}
diff --git a/vendor/golang.org/x/tools/go/types/stmt.go b/vendor/golang.org/x/tools/go/types/stmt.go
deleted file mode 100644
index eeb2c31..0000000
--- a/vendor/golang.org/x/tools/go/types/stmt.go
+++ /dev/null
@@ -1,745 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of statements.
-
-package types
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/exact"
-)
-
-func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt) {
-	if trace {
-		if name == "" {
-			name = "<function literal>"
-		}
-		fmt.Printf("--- %s: %s {\n", name, sig)
-		defer fmt.Println("--- <end>")
-	}
-
-	// set function scope extent
-	sig.scope.pos = body.Pos()
-	sig.scope.end = body.End()
-
-	// save/restore current context and setup function context
-	// (and use 0 indentation at function start)
-	defer func(ctxt context, indent int) {
-		check.context = ctxt
-		check.indent = indent
-	}(check.context, check.indent)
-	check.context = context{
-		decl:  decl,
-		scope: sig.scope,
-		sig:   sig,
-	}
-	check.indent = 0
-
-	check.stmtList(0, body.List)
-
-	if check.hasLabel {
-		check.labels(body)
-	}
-
-	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
-		check.error(body.Rbrace, "missing return")
-	}
-
-	// spec: "Implementation restriction: A compiler may make it illegal to
-	// declare a variable inside a function body if the variable is never used."
-	// (One could check each scope after use, but that distributes this check
-	// over several places because CloseScope is not always called explicitly.)
-	check.usage(sig.scope)
-}
-
-func (check *Checker) usage(scope *Scope) {
-	for _, obj := range scope.elems {
-		if v, _ := obj.(*Var); v != nil && !v.used {
-			check.softErrorf(v.pos, "%s declared but not used", v.name)
-		}
-	}
-	for _, scope := range scope.children {
-		check.usage(scope)
-	}
-}
-
-// stmtContext is a bitset describing which
-// control-flow statements are permissible.
-type stmtContext uint
-
-const (
-	breakOk stmtContext = 1 << iota
-	continueOk
-	fallthroughOk
-)
-
-func (check *Checker) simpleStmt(s ast.Stmt) {
-	if s != nil {
-		check.stmt(0, s)
-	}
-}
-
-func (check *Checker) stmtList(ctxt stmtContext, list []ast.Stmt) {
-	ok := ctxt&fallthroughOk != 0
-	inner := ctxt &^ fallthroughOk
-	for i, s := range list {
-		inner := inner
-		if ok && i+1 == len(list) {
-			inner |= fallthroughOk
-		}
-		check.stmt(inner, s)
-	}
-}
-
-func (check *Checker) multipleDefaults(list []ast.Stmt) {
-	var first ast.Stmt
-	for _, s := range list {
-		var d ast.Stmt
-		switch c := s.(type) {
-		case *ast.CaseClause:
-			if len(c.List) == 0 {
-				d = s
-			}
-		case *ast.CommClause:
-			if c.Comm == nil {
-				d = s
-			}
-		default:
-			check.invalidAST(s.Pos(), "case/communication clause expected")
-		}
-		if d != nil {
-			if first != nil {
-				check.errorf(d.Pos(), "multiple defaults (first at %s)", first.Pos())
-			} else {
-				first = d
-			}
-		}
-	}
-}
-
-func (check *Checker) openScope(s ast.Stmt, comment string) {
-	scope := NewScope(check.scope, s.Pos(), s.End(), comment)
-	check.recordScope(s, scope)
-	check.scope = scope
-}
-
-func (check *Checker) closeScope() {
-	check.scope = check.scope.Parent()
-}
-
-func assignOp(op token.Token) token.Token {
-	// token_test.go verifies the token ordering this function relies on
-	if token.ADD_ASSIGN <= op && op <= token.AND_NOT_ASSIGN {
-		return op + (token.ADD - token.ADD_ASSIGN)
-	}
-	return token.ILLEGAL
-}
-
-func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) {
-	var x operand
-	var msg string
-	switch check.rawExpr(&x, call, nil) {
-	case conversion:
-		msg = "requires function call, not conversion"
-	case expression:
-		msg = "discards result of"
-	case statement:
-		return
-	default:
-		unreachable()
-	}
-	check.errorf(x.pos(), "%s %s %s", keyword, msg, &x)
-}
-
-func (check *Checker) caseValues(x operand /* copy argument (not *operand!) */, values []ast.Expr) {
-	// No duplicate checking for now. See issue 4524.
-	for _, e := range values {
-		var y operand
-		check.expr(&y, e)
-		if y.mode == invalid {
-			return
-		}
-		// TODO(gri) The convertUntyped call pair below appears in other places. Factor!
-		// Order matters: By comparing y against x, error positions are at the case values.
-		check.convertUntyped(&y, x.typ)
-		if y.mode == invalid {
-			return
-		}
-		check.convertUntyped(&x, y.typ)
-		if x.mode == invalid {
-			return
-		}
-		check.comparison(&y, &x, token.EQL)
-	}
-}
-
-func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]token.Pos) (T Type) {
-L:
-	for _, e := range types {
-		T = check.typOrNil(e)
-		if T == Typ[Invalid] {
-			continue
-		}
-		// complain about duplicate types
-		// TODO(gri) use a type hash to avoid quadratic algorithm
-		for t, pos := range seen {
-			if T == nil && t == nil || T != nil && t != nil && Identical(T, t) {
-				// talk about "case" rather than "type" because of nil case
-				check.error(e.Pos(), "duplicate case in type switch")
-				check.errorf(pos, "\tprevious case %s", T) // secondary error, \t indented
-				continue L
-			}
-		}
-		seen[T] = e.Pos()
-		if T != nil {
-			check.typeAssertion(e.Pos(), x, xtyp, T)
-		}
-	}
-	return
-}
-
-// stmt typechecks statement s.
-func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
-	// statements cannot use iota in general
-	// (constant declarations set it explicitly)
-	assert(check.iota == nil)
-
-	// statements must end with the same top scope as they started with
-	if debug {
-		defer func(scope *Scope) {
-			// don't check if code is panicking
-			if p := recover(); p != nil {
-				panic(p)
-			}
-			assert(scope == check.scope)
-		}(check.scope)
-	}
-
-	inner := ctxt &^ fallthroughOk
-	switch s := s.(type) {
-	case *ast.BadStmt, *ast.EmptyStmt:
-		// ignore
-
-	case *ast.DeclStmt:
-		check.declStmt(s.Decl)
-
-	case *ast.LabeledStmt:
-		check.hasLabel = true
-		check.stmt(ctxt, s.Stmt)
-
-	case *ast.ExprStmt:
-		// spec: "With the exception of specific built-in functions,
-		// function and method calls and receive operations can appear
-		// in statement context. Such statements may be parenthesized."
-		var x operand
-		kind := check.rawExpr(&x, s.X, nil)
-		var msg string
-		switch x.mode {
-		default:
-			if kind == statement {
-				return
-			}
-			msg = "is not used"
-		case builtin:
-			msg = "must be called"
-		case typexpr:
-			msg = "is not an expression"
-		}
-		check.errorf(x.pos(), "%s %s", &x, msg)
-
-	case *ast.SendStmt:
-		var ch, x operand
-		check.expr(&ch, s.Chan)
-		check.expr(&x, s.Value)
-		if ch.mode == invalid || x.mode == invalid {
-			return
-		}
-		if tch, ok := ch.typ.Underlying().(*Chan); !ok || tch.dir == RecvOnly || !check.assignment(&x, tch.elem) {
-			if x.mode != invalid {
-				check.invalidOp(ch.pos(), "cannot send %s to channel %s", &x, &ch)
-			}
-		}
-
-	case *ast.IncDecStmt:
-		var op token.Token
-		switch s.Tok {
-		case token.INC:
-			op = token.ADD
-		case token.DEC:
-			op = token.SUB
-		default:
-			check.invalidAST(s.TokPos, "unknown inc/dec operation %s", s.Tok)
-			return
-		}
-		var x operand
-		Y := &ast.BasicLit{ValuePos: s.X.Pos(), Kind: token.INT, Value: "1"} // use x's position
-		check.binary(&x, nil, s.X, Y, op)
-		if x.mode == invalid {
-			return
-		}
-		check.assignVar(s.X, &x)
-
-	case *ast.AssignStmt:
-		switch s.Tok {
-		case token.ASSIGN, token.DEFINE:
-			if len(s.Lhs) == 0 {
-				check.invalidAST(s.Pos(), "missing lhs in assignment")
-				return
-			}
-			if s.Tok == token.DEFINE {
-				check.shortVarDecl(s.TokPos, s.Lhs, s.Rhs)
-			} else {
-				// regular assignment
-				check.assignVars(s.Lhs, s.Rhs)
-			}
-
-		default:
-			// assignment operations
-			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {
-				check.errorf(s.TokPos, "assignment operation %s requires single-valued expressions", s.Tok)
-				return
-			}
-			op := assignOp(s.Tok)
-			if op == token.ILLEGAL {
-				check.invalidAST(s.TokPos, "unknown assignment operation %s", s.Tok)
-				return
-			}
-			var x operand
-			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op)
-			if x.mode == invalid {
-				return
-			}
-			check.assignVar(s.Lhs[0], &x)
-		}
-
-	case *ast.GoStmt:
-		check.suspendedCall("go", s.Call)
-
-	case *ast.DeferStmt:
-		check.suspendedCall("defer", s.Call)
-
-	case *ast.ReturnStmt:
-		res := check.sig.results
-		if res.Len() > 0 {
-			// function returns results
-			// (if one, say the first, result parameter is named, all of them are named)
-			if len(s.Results) == 0 && res.vars[0].name != "" {
-				// spec: "Implementation restriction: A compiler may disallow an empty expression
-				// list in a "return" statement if a different entity (constant, type, or variable)
-				// with the same name as a result parameter is in scope at the place of the return."
-				for _, obj := range res.vars {
-					if _, alt := check.scope.LookupParent(obj.name, check.pos); alt != nil && alt != obj {
-						check.errorf(s.Pos(), "result parameter %s not in scope at return", obj.name)
-						check.errorf(alt.Pos(), "\tinner declaration of %s", obj)
-						// ok to continue
-					}
-				}
-			} else {
-				// return has results or result parameters are unnamed
-				check.initVars(res.vars, s.Results, s.Return)
-			}
-		} else if len(s.Results) > 0 {
-			check.error(s.Results[0].Pos(), "no result values expected")
-			check.use(s.Results...)
-		}
-
-	case *ast.BranchStmt:
-		if s.Label != nil {
-			check.hasLabel = true
-			return // checked in 2nd pass (check.labels)
-		}
-		switch s.Tok {
-		case token.BREAK:
-			if ctxt&breakOk == 0 {
-				check.error(s.Pos(), "break not in for, switch, or select statement")
-			}
-		case token.CONTINUE:
-			if ctxt&continueOk == 0 {
-				check.error(s.Pos(), "continue not in for statement")
-			}
-		case token.FALLTHROUGH:
-			if ctxt&fallthroughOk == 0 {
-				check.error(s.Pos(), "fallthrough statement out of place")
-			}
-		default:
-			check.invalidAST(s.Pos(), "branch statement: %s", s.Tok)
-		}
-
-	case *ast.BlockStmt:
-		check.openScope(s, "block")
-		defer check.closeScope()
-
-		check.stmtList(inner, s.List)
-
-	case *ast.IfStmt:
-		check.openScope(s, "if")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		var x operand
-		check.expr(&x, s.Cond)
-		if x.mode != invalid && !isBoolean(x.typ) {
-			check.error(s.Cond.Pos(), "non-boolean condition in if statement")
-		}
-		check.stmt(inner, s.Body)
-		if s.Else != nil {
-			check.stmt(inner, s.Else)
-		}
-
-	case *ast.SwitchStmt:
-		inner |= breakOk
-		check.openScope(s, "switch")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		var x operand
-		if s.Tag != nil {
-			check.expr(&x, s.Tag)
-		} else {
-			// spec: "A missing switch expression is
-			// equivalent to the boolean value true."
-			x.mode = constant
-			x.typ = Typ[Bool]
-			x.val = exact.MakeBool(true)
-			x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
-		}
-
-		check.multipleDefaults(s.Body.List)
-
-		for i, c := range s.Body.List {
-			clause, _ := c.(*ast.CaseClause)
-			if clause == nil {
-				check.invalidAST(c.Pos(), "incorrect expression switch case")
-				continue
-			}
-			if x.mode != invalid {
-				check.caseValues(x, clause.List)
-			}
-			check.openScope(clause, "case")
-			inner := inner
-			if i+1 < len(s.Body.List) {
-				inner |= fallthroughOk
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-	case *ast.TypeSwitchStmt:
-		inner |= breakOk
-		check.openScope(s, "type switch")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-
-		// A type switch guard must be of the form:
-		//
-		//     TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
-		//
-		// The parser is checking syntactic correctness;
-		// remaining syntactic errors are considered AST errors here.
-		// TODO(gri) better factoring of error handling (invalid ASTs)
-		//
-		var lhs *ast.Ident // lhs identifier or nil
-		var rhs ast.Expr
-		switch guard := s.Assign.(type) {
-		case *ast.ExprStmt:
-			rhs = guard.X
-		case *ast.AssignStmt:
-			if len(guard.Lhs) != 1 || guard.Tok != token.DEFINE || len(guard.Rhs) != 1 {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-				return
-			}
-
-			lhs, _ = guard.Lhs[0].(*ast.Ident)
-			if lhs == nil {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-				return
-			}
-
-			if lhs.Name == "_" {
-				// _ := x.(type) is an invalid short variable declaration
-				check.softErrorf(lhs.Pos(), "no new variable on left side of :=")
-				lhs = nil // avoid declared but not used error below
-			} else {
-				check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
-			}
-
-			rhs = guard.Rhs[0]
-
-		default:
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-			return
-		}
-
-		// rhs must be of the form: expr.(type) and expr must be an interface
-		expr, _ := rhs.(*ast.TypeAssertExpr)
-		if expr == nil || expr.Type != nil {
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-			return
-		}
-		var x operand
-		check.expr(&x, expr.X)
-		if x.mode == invalid {
-			return
-		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
-		if xtyp == nil {
-			check.errorf(x.pos(), "%s is not an interface", &x)
-			return
-		}
-
-		check.multipleDefaults(s.Body.List)
-
-		var lhsVars []*Var               // list of implicitly declared lhs variables
-		seen := make(map[Type]token.Pos) // map of seen types to positions
-		for _, s := range s.Body.List {
-			clause, _ := s.(*ast.CaseClause)
-			if clause == nil {
-				check.invalidAST(s.Pos(), "incorrect type switch case")
-				continue
-			}
-			// Check each type in this type switch case.
-			T := check.caseTypes(&x, xtyp, clause.List, seen)
-			check.openScope(clause, "case")
-			// If lhs exists, declare a corresponding variable in the case-local scope.
-			if lhs != nil {
-				// spec: "The TypeSwitchGuard may include a short variable declaration.
-				// When that form is used, the variable is declared at the beginning of
-				// the implicit block in each clause. In clauses with a case listing
-				// exactly one type, the variable has that type; otherwise, the variable
-				// has the type of the expression in the TypeSwitchGuard."
-				if len(clause.List) != 1 || T == nil {
-					T = x.typ
-				}
-				obj := NewVar(lhs.Pos(), check.pkg, lhs.Name, T)
-				scopePos := clause.End()
-				if len(clause.Body) > 0 {
-					scopePos = clause.Body[0].Pos()
-				}
-				check.declare(check.scope, nil, obj, scopePos)
-				check.recordImplicit(clause, obj)
-				// For the "declared but not used" error, all lhs variables act as
-				// one; i.e., if any one of them is 'used', all of them are 'used'.
-				// Collect them for later analysis.
-				lhsVars = append(lhsVars, obj)
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-		// If lhs exists, we must have at least one lhs variable that was used.
-		if lhs != nil {
-			var used bool
-			for _, v := range lhsVars {
-				if v.used {
-					used = true
-				}
-				v.used = true // avoid usage error when checking entire function
-			}
-			if !used {
-				check.softErrorf(lhs.Pos(), "%s declared but not used", lhs.Name)
-			}
-		}
-
-	case *ast.SelectStmt:
-		inner |= breakOk
-
-		check.multipleDefaults(s.Body.List)
-
-		for _, s := range s.Body.List {
-			clause, _ := s.(*ast.CommClause)
-			if clause == nil {
-				continue // error reported before
-			}
-
-			// clause.Comm must be a SendStmt, RecvStmt, or default case
-			valid := false
-			var rhs ast.Expr // rhs of RecvStmt, or nil
-			switch s := clause.Comm.(type) {
-			case nil, *ast.SendStmt:
-				valid = true
-			case *ast.AssignStmt:
-				if len(s.Rhs) == 1 {
-					rhs = s.Rhs[0]
-				}
-			case *ast.ExprStmt:
-				rhs = s.X
-			}
-
-			// if present, rhs must be a receive operation
-			if rhs != nil {
-				if x, _ := unparen(rhs).(*ast.UnaryExpr); x != nil && x.Op == token.ARROW {
-					valid = true
-				}
-			}
-
-			if !valid {
-				check.error(clause.Comm.Pos(), "select case must be send or receive (possibly with assignment)")
-				continue
-			}
-
-			check.openScope(s, "case")
-			if clause.Comm != nil {
-				check.stmt(inner, clause.Comm)
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-	case *ast.ForStmt:
-		inner |= breakOk | continueOk
-		check.openScope(s, "for")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		if s.Cond != nil {
-			var x operand
-			check.expr(&x, s.Cond)
-			if x.mode != invalid && !isBoolean(x.typ) {
-				check.error(s.Cond.Pos(), "non-boolean condition in for statement")
-			}
-		}
-		check.simpleStmt(s.Post)
-		// spec: "The init statement may be a short variable
-		// declaration, but the post statement must not."
-		if s, _ := s.Post.(*ast.AssignStmt); s != nil && s.Tok == token.DEFINE {
-			check.softErrorf(s.Pos(), "cannot declare in post statement")
-			check.use(s.Lhs...) // avoid follow-up errors
-		}
-		check.stmt(inner, s.Body)
-
-	case *ast.RangeStmt:
-		inner |= breakOk | continueOk
-		check.openScope(s, "for")
-		defer check.closeScope()
-
-		// check expression to iterate over
-		var x operand
-		check.expr(&x, s.X)
-
-		// determine key/value types
-		var key, val Type
-		if x.mode != invalid {
-			switch typ := x.typ.Underlying().(type) {
-			case *Basic:
-				if isString(typ) {
-					key = Typ[Int]
-					val = universeRune // use 'rune' name
-				}
-			case *Array:
-				key = Typ[Int]
-				val = typ.elem
-			case *Slice:
-				key = Typ[Int]
-				val = typ.elem
-			case *Pointer:
-				if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-					key = Typ[Int]
-					val = typ.elem
-				}
-			case *Map:
-				key = typ.key
-				val = typ.elem
-			case *Chan:
-				key = typ.elem
-				val = Typ[Invalid]
-				if typ.dir == SendOnly {
-					check.errorf(x.pos(), "cannot range over send-only channel %s", &x)
-					// ok to continue
-				}
-				if s.Value != nil {
-					check.errorf(s.Value.Pos(), "iteration over %s permits only one iteration variable", &x)
-					// ok to continue
-				}
-			}
-		}
-
-		if key == nil {
-			check.errorf(x.pos(), "cannot range over %s", &x)
-			// ok to continue
-		}
-
-		// check assignment to/declaration of iteration variables
-		// (irregular assignment, cannot easily map to existing assignment checks)
-
-		// lhs expressions and initialization value (rhs) types
-		lhs := [2]ast.Expr{s.Key, s.Value}
-		rhs := [2]Type{key, val} // key, val may be nil
-
-		if s.Tok == token.DEFINE {
-			// short variable declaration; variable scope starts after the range clause
-			// (the for loop opens a new scope, so variables on the lhs never redeclare
-			// previously declared variables)
-			var vars []*Var
-			for i, lhs := range lhs {
-				if lhs == nil {
-					continue
-				}
-
-				// determine lhs variable
-				var obj *Var
-				if ident, _ := lhs.(*ast.Ident); ident != nil {
-					// declare new variable
-					name := ident.Name
-					obj = NewVar(ident.Pos(), check.pkg, name, nil)
-					check.recordDef(ident, obj)
-					// _ variables don't count as new variables
-					if name != "_" {
-						vars = append(vars, obj)
-					}
-				} else {
-					check.errorf(lhs.Pos(), "cannot declare %s", lhs)
-					obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
-				}
-
-				// initialize lhs variable
-				if typ := rhs[i]; typ != nil {
-					x.mode = value
-					x.expr = lhs // we don't have a better rhs expression to use here
-					x.typ = typ
-					check.initVar(obj, &x, false)
-				} else {
-					obj.typ = Typ[Invalid]
-					obj.used = true // don't complain about unused variable
-				}
-			}
-
-			// declare variables
-			if len(vars) > 0 {
-				for _, obj := range vars {
-					// spec: "The scope of a constant or variable identifier declared inside
-					// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-					// for short variable declarations) and ends at the end of the innermost
-					// containing block."
-					scopePos := s.End()
-					check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
-				}
-			} else {
-				check.error(s.TokPos, "no new variables on left side of :=")
-			}
-		} else {
-			// ordinary assignment
-			for i, lhs := range lhs {
-				if lhs == nil {
-					continue
-				}
-				if typ := rhs[i]; typ != nil {
-					x.mode = value
-					x.expr = lhs // we don't have a better rhs expression to use here
-					x.typ = typ
-					check.assignVar(lhs, &x)
-				}
-			}
-		}
-
-		check.stmt(inner, s.Body)
-
-	default:
-		check.error(s.Pos(), "invalid statement")
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/types/type.go b/vendor/golang.org/x/tools/go/types/type.go
deleted file mode 100644
index 1df8b45..0000000
--- a/vendor/golang.org/x/tools/go/types/type.go
+++ /dev/null
@@ -1,454 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import "sort"
-
-// TODO(gri) Revisit factory functions - make sure they have all relevant parameters.
-
-// A Type represents a type of Go.
-// All types implement the Type interface.
-type Type interface {
-	// Underlying returns the underlying type of a type.
-	Underlying() Type
-
-	// String returns a string representation of a type.
-	String() string
-}
-
-// BasicKind describes the kind of basic type.
-type BasicKind int
-
-const (
-	Invalid BasicKind = iota // type is invalid
-
-	// predeclared types
-	Bool
-	Int
-	Int8
-	Int16
-	Int32
-	Int64
-	Uint
-	Uint8
-	Uint16
-	Uint32
-	Uint64
-	Uintptr
-	Float32
-	Float64
-	Complex64
-	Complex128
-	String
-	UnsafePointer
-
-	// types for untyped values
-	UntypedBool
-	UntypedInt
-	UntypedRune
-	UntypedFloat
-	UntypedComplex
-	UntypedString
-	UntypedNil
-
-	// aliases
-	Byte = Uint8
-	Rune = Int32
-)
-
-// BasicInfo is a set of flags describing properties of a basic type.
-type BasicInfo int
-
-// Properties of basic types.
-const (
-	IsBoolean BasicInfo = 1 << iota
-	IsInteger
-	IsUnsigned
-	IsFloat
-	IsComplex
-	IsString
-	IsUntyped
-
-	IsOrdered   = IsInteger | IsFloat | IsString
-	IsNumeric   = IsInteger | IsFloat | IsComplex
-	IsConstType = IsBoolean | IsNumeric | IsString
-)
-
-// A Basic represents a basic type.
-type Basic struct {
-	kind BasicKind
-	info BasicInfo
-	name string
-}
-
-// Kind returns the kind of basic type b.
-func (b *Basic) Kind() BasicKind { return b.kind }
-
-// Info returns information about properties of basic type b.
-func (b *Basic) Info() BasicInfo { return b.info }
-
-// Name returns the name of basic type b.
-func (b *Basic) Name() string { return b.name }
-
-// An Array represents an array type.
-type Array struct {
-	len  int64
-	elem Type
-}
-
-// NewArray returns a new array type for the given element type and length.
-func NewArray(elem Type, len int64) *Array { return &Array{len, elem} }
-
-// Len returns the length of array a.
-func (a *Array) Len() int64 { return a.len }
-
-// Elem returns element type of array a.
-func (a *Array) Elem() Type { return a.elem }
-
-// A Slice represents a slice type.
-type Slice struct {
-	elem Type
-}
-
-// NewSlice returns a new slice type for the given element type.
-func NewSlice(elem Type) *Slice { return &Slice{elem} }
-
-// Elem returns the element type of slice s.
-func (s *Slice) Elem() Type { return s.elem }
-
-// A Struct represents a struct type.
-type Struct struct {
-	fields []*Var
-	tags   []string // field tags; nil if there are no tags
-	// TODO(gri) access to offsets is not threadsafe - fix this
-	offsets []int64 // field offsets in bytes, lazily initialized
-}
-
-// NewStruct returns a new struct with the given fields and corresponding field tags.
-// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
-// only as long as required to hold the tag with the largest index i. Consequently,
-// if no field has a tag, tags may be nil.
-func NewStruct(fields []*Var, tags []string) *Struct {
-	var fset objset
-	for _, f := range fields {
-		if f.name != "_" && fset.insert(f) != nil {
-			panic("multiple fields with the same name")
-		}
-	}
-	if len(tags) > len(fields) {
-		panic("more tags than fields")
-	}
-	return &Struct{fields: fields, tags: tags}
-}
-
-// NumFields returns the number of fields in the struct (including blank and anonymous fields).
-func (s *Struct) NumFields() int { return len(s.fields) }
-
-// Field returns the i'th field for 0 <= i < NumFields().
-func (s *Struct) Field(i int) *Var { return s.fields[i] }
-
-// Tag returns the i'th field tag for 0 <= i < NumFields().
-func (s *Struct) Tag(i int) string {
-	if i < len(s.tags) {
-		return s.tags[i]
-	}
-	return ""
-}
-
-// A Pointer represents a pointer type.
-type Pointer struct {
-	base Type // element type
-}
-
-// NewPointer returns a new pointer type for the given element (base) type.
-func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} }
-
-// Elem returns the element type for the given pointer p.
-func (p *Pointer) Elem() Type { return p.base }
-
-// A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple.
-// Tuples are used as components of signatures and to represent the type of multiple
-// assignments; they are not first class types of Go.
-type Tuple struct {
-	vars []*Var
-}
-
-// NewTuple returns a new tuple for the given variables.
-func NewTuple(x ...*Var) *Tuple {
-	if len(x) > 0 {
-		return &Tuple{x}
-	}
-	return nil
-}
-
-// Len returns the number variables of tuple t.
-func (t *Tuple) Len() int {
-	if t != nil {
-		return len(t.vars)
-	}
-	return 0
-}
-
-// At returns the i'th variable of tuple t.
-func (t *Tuple) At(i int) *Var { return t.vars[i] }
-
-// A Signature represents a (non-builtin) function or method type.
-type Signature struct {
-	// We need to keep the scope in Signature (rather than passing it around
-	// and store it in the Func Object) because when type-checking a function
-	// literal we call the general type checker which returns a general Type.
-	// We then unpack the *Signature and use the scope for the literal body.
-	scope    *Scope // function scope, present for package-local signatures
-	recv     *Var   // nil if not a method
-	params   *Tuple // (incoming) parameters from left to right; or nil
-	results  *Tuple // (outgoing) results from left to right; or nil
-	variadic bool   // true if the last parameter's type is of the form ...T (or string, for append built-in only)
-}
-
-// NewSignature returns a new function type for the given receiver, parameters,
-// and results, either of which may be nil. If variadic is set, the function
-// is variadic, it must have at least one parameter, and the last parameter
-// must be of unnamed slice type.
-func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
-	if variadic {
-		n := params.Len()
-		if n == 0 {
-			panic("types.NewSignature: variadic function must have at least one parameter")
-		}
-		if _, ok := params.At(n - 1).typ.(*Slice); !ok {
-			panic("types.NewSignature: variadic parameter must be of unnamed slice type")
-		}
-	}
-	return &Signature{nil, recv, params, results, variadic}
-}
-
-// Recv returns the receiver of signature s (if a method), or nil if a
-// function.
-//
-// For an abstract method, Recv returns the enclosing interface either
-// as a *Named or an *Interface.  Due to embedding, an interface may
-// contain methods whose receiver type is a different interface.
-func (s *Signature) Recv() *Var { return s.recv }
-
-// Params returns the parameters of signature s, or nil.
-func (s *Signature) Params() *Tuple { return s.params }
-
-// Results returns the results of signature s, or nil.
-func (s *Signature) Results() *Tuple { return s.results }
-
-// Variadic reports whether the signature s is variadic.
-func (s *Signature) Variadic() bool { return s.variadic }
-
-// An Interface represents an interface type.
-type Interface struct {
-	methods   []*Func  // ordered list of explicitly declared methods
-	embeddeds []*Named // ordered list of explicitly embedded types
-
-	allMethods []*Func // ordered list of methods declared with or embedded in this interface (TODO(gri): replace with mset)
-}
-
-// NewInterface returns a new interface for the given methods and embedded types.
-func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
-	typ := new(Interface)
-
-	var mset objset
-	for _, m := range methods {
-		if mset.insert(m) != nil {
-			panic("multiple methods with the same name")
-		}
-		// set receiver
-		// TODO(gri) Ideally, we should use a named type here instead of
-		// typ, for less verbose printing of interface method signatures.
-		m.typ.(*Signature).recv = NewVar(m.pos, m.pkg, "", typ)
-	}
-	sort.Sort(byUniqueMethodName(methods))
-
-	if embeddeds == nil {
-		sort.Sort(byUniqueTypeName(embeddeds))
-	}
-
-	typ.methods = methods
-	typ.embeddeds = embeddeds
-	return typ
-}
-
-// NumExplicitMethods returns the number of explicitly declared methods of interface t.
-func (t *Interface) NumExplicitMethods() int { return len(t.methods) }
-
-// ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods().
-// The methods are ordered by their unique Id.
-func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] }
-
-// NumEmbeddeds returns the number of embedded types in interface t.
-func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) }
-
-// Embedded returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds().
-// The types are ordered by the corresponding TypeName's unique Id.
-func (t *Interface) Embedded(i int) *Named { return t.embeddeds[i] }
-
-// NumMethods returns the total number of methods of interface t.
-func (t *Interface) NumMethods() int { return len(t.allMethods) }
-
-// Method returns the i'th method of interface t for 0 <= i < t.NumMethods().
-// The methods are ordered by their unique Id.
-func (t *Interface) Method(i int) *Func { return t.allMethods[i] }
-
-// Empty returns true if t is the empty interface.
-func (t *Interface) Empty() bool { return len(t.allMethods) == 0 }
-
-// Complete computes the interface's method set. It must be called by users of
-// NewInterface after the interface's embedded types are fully defined and
-// before using the interface type in any way other than to form other types.
-// Complete returns the receiver.
-func (t *Interface) Complete() *Interface {
-	if t.allMethods != nil {
-		return t
-	}
-
-	var allMethods []*Func
-	if t.embeddeds == nil {
-		if t.methods == nil {
-			allMethods = make([]*Func, 0, 1)
-		} else {
-			allMethods = t.methods
-		}
-	} else {
-		allMethods = append(allMethods, t.methods...)
-		for _, et := range t.embeddeds {
-			it := et.Underlying().(*Interface)
-			it.Complete()
-			for _, tm := range it.allMethods {
-				// Make a copy of the method and adjust its receiver type.
-				newm := *tm
-				newmtyp := *tm.typ.(*Signature)
-				newm.typ = &newmtyp
-				newmtyp.recv = NewVar(newm.pos, newm.pkg, "", t)
-				allMethods = append(allMethods, &newm)
-			}
-		}
-		sort.Sort(byUniqueMethodName(allMethods))
-	}
-	t.allMethods = allMethods
-
-	return t
-}
-
-// A Map represents a map type.
-type Map struct {
-	key, elem Type
-}
-
-// NewMap returns a new map for the given key and element types.
-func NewMap(key, elem Type) *Map {
-	return &Map{key, elem}
-}
-
-// Key returns the key type of map m.
-func (m *Map) Key() Type { return m.key }
-
-// Elem returns the element type of map m.
-func (m *Map) Elem() Type { return m.elem }
-
-// A Chan represents a channel type.
-type Chan struct {
-	dir  ChanDir
-	elem Type
-}
-
-// A ChanDir value indicates a channel direction.
-type ChanDir int
-
-// The direction of a channel is indicated by one of the following constants.
-const (
-	SendRecv ChanDir = iota
-	SendOnly
-	RecvOnly
-)
-
-// NewChan returns a new channel type for the given direction and element type.
-func NewChan(dir ChanDir, elem Type) *Chan {
-	return &Chan{dir, elem}
-}
-
-// Dir returns the direction of channel c.
-func (c *Chan) Dir() ChanDir { return c.dir }
-
-// Elem returns the element type of channel c.
-func (c *Chan) Elem() Type { return c.elem }
-
-// A Named represents a named type.
-type Named struct {
-	obj        *TypeName // corresponding declared object
-	underlying Type      // possibly a *Named during setup; never a *Named once set up completely
-	methods    []*Func   // methods declared for this type (not the method set of this type)
-}
-
-// NewNamed returns a new named type for the given type name, underlying type, and associated methods.
-// The underlying type must not be a *Named.
-func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
-	if _, ok := underlying.(*Named); ok {
-		panic("types.NewNamed: underlying type must not be *Named")
-	}
-	typ := &Named{obj: obj, underlying: underlying, methods: methods}
-	if obj.typ == nil {
-		obj.typ = typ
-	}
-	return typ
-}
-
-// TypeName returns the type name for the named type t.
-func (t *Named) Obj() *TypeName { return t.obj }
-
-// NumMethods returns the number of explicit methods whose receiver is named type t.
-func (t *Named) NumMethods() int { return len(t.methods) }
-
-// Method returns the i'th method of named type t for 0 <= i < t.NumMethods().
-func (t *Named) Method(i int) *Func { return t.methods[i] }
-
-// SetUnderlying sets the underlying type and marks t as complete.
-// TODO(gri) determine if there's a better solution rather than providing this function
-func (t *Named) SetUnderlying(underlying Type) {
-	if underlying == nil {
-		panic("types.Named.SetUnderlying: underlying type must not be nil")
-	}
-	if _, ok := underlying.(*Named); ok {
-		panic("types.Named.SetUnderlying: underlying type must not be *Named")
-	}
-	t.underlying = underlying
-}
-
-// AddMethod adds method m unless it is already in the method list.
-// TODO(gri) find a better solution instead of providing this function
-func (t *Named) AddMethod(m *Func) {
-	if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 {
-		t.methods = append(t.methods, m)
-	}
-}
-
-// Implementations for Type methods.
-
-func (t *Basic) Underlying() Type     { return t }
-func (t *Array) Underlying() Type     { return t }
-func (t *Slice) Underlying() Type     { return t }
-func (t *Struct) Underlying() Type    { return t }
-func (t *Pointer) Underlying() Type   { return t }
-func (t *Tuple) Underlying() Type     { return t }
-func (t *Signature) Underlying() Type { return t }
-func (t *Interface) Underlying() Type { return t }
-func (t *Map) Underlying() Type       { return t }
-func (t *Chan) Underlying() Type      { return t }
-func (t *Named) Underlying() Type     { return t.underlying }
-
-func (t *Basic) String() string     { return TypeString(t, nil) }
-func (t *Array) String() string     { return TypeString(t, nil) }
-func (t *Slice) String() string     { return TypeString(t, nil) }
-func (t *Struct) String() string    { return TypeString(t, nil) }
-func (t *Pointer) String() string   { return TypeString(t, nil) }
-func (t *Tuple) String() string     { return TypeString(t, nil) }
-func (t *Signature) String() string { return TypeString(t, nil) }
-func (t *Interface) String() string { return TypeString(t, nil) }
-func (t *Map) String() string       { return TypeString(t, nil) }
-func (t *Chan) String() string      { return TypeString(t, nil) }
-func (t *Named) String() string     { return TypeString(t, nil) }
diff --git a/vendor/golang.org/x/tools/go/types/typestring.go b/vendor/golang.org/x/tools/go/types/typestring.go
deleted file mode 100644
index abee8ab..0000000
--- a/vendor/golang.org/x/tools/go/types/typestring.go
+++ /dev/null
@@ -1,292 +0,0 @@
-// 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.
-
-// This file implements printing of types.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// A Qualifier controls how named package-level objects are printed in
-// calls to TypeString, ObjectString, and SelectionString.
-//
-// These three formatting routines call the Qualifier for each
-// package-level object O, and if the Qualifier returns a non-empty
-// string p, the object is printed in the form p.O.
-// If it returns an empty string, only the object name O is printed.
-//
-// Using a nil Qualifier is equivalent to using (*Package).Path: the
-// object is qualified by the import path, e.g., "encoding/json.Marshal".
-//
-type Qualifier func(*Package) string
-
-// RelativeTo(pkg) returns a Qualifier that fully qualifies members of
-// all packages other than pkg.
-func RelativeTo(pkg *Package) Qualifier {
-	if pkg == nil {
-		return nil
-	}
-	return func(other *Package) string {
-		if pkg == other {
-			return "" // same package; unqualified
-		}
-		return other.Path()
-	}
-}
-
-// If GcCompatibilityMode is set, printing of types is modified
-// to match the representation of some types in the gc compiler:
-//
-//	- byte and rune lose their alias name and simply stand for
-//	  uint8 and int32 respectively
-//	- embedded interfaces get flattened (the embedding info is lost,
-//	  and certain recursive interface types cannot be printed anymore)
-//
-// This makes it easier to compare packages computed with the type-
-// checker vs packages imported from gc export data.
-//
-// Caution: This flag affects all uses of WriteType, globally.
-// It is only provided for testing in conjunction with
-// gc-generated data. It may be removed at any time.
-var GcCompatibilityMode bool
-
-// TypeString returns the string representation of typ.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func TypeString(typ Type, qf Qualifier) string {
-	var buf bytes.Buffer
-	WriteType(&buf, typ, qf)
-	return buf.String()
-}
-
-// WriteType writes the string representation of typ to buf.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) {
-	writeType(buf, typ, qf, make([]Type, 8))
-}
-
-func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
-	// Theoretically, this is a quadratic lookup algorithm, but in
-	// practice deeply nested composite types with unnamed component
-	// types are uncommon. This code is likely more efficient than
-	// using a map.
-	for _, t := range visited {
-		if t == typ {
-			fmt.Fprintf(buf, "○%T", typ) // cycle to typ
-			return
-		}
-	}
-	visited = append(visited, typ)
-
-	switch t := typ.(type) {
-	case nil:
-		buf.WriteString("<nil>")
-
-	case *Basic:
-		if t.kind == UnsafePointer {
-			buf.WriteString("unsafe.")
-		}
-		if GcCompatibilityMode {
-			// forget the alias names
-			switch t.kind {
-			case Byte:
-				t = Typ[Uint8]
-			case Rune:
-				t = Typ[Int32]
-			}
-		}
-		buf.WriteString(t.name)
-
-	case *Array:
-		fmt.Fprintf(buf, "[%d]", t.len)
-		writeType(buf, t.elem, qf, visited)
-
-	case *Slice:
-		buf.WriteString("[]")
-		writeType(buf, t.elem, qf, visited)
-
-	case *Struct:
-		buf.WriteString("struct{")
-		for i, f := range t.fields {
-			if i > 0 {
-				buf.WriteString("; ")
-			}
-			if !f.anonymous {
-				buf.WriteString(f.name)
-				buf.WriteByte(' ')
-			}
-			writeType(buf, f.typ, qf, visited)
-			if tag := t.Tag(i); tag != "" {
-				fmt.Fprintf(buf, " %q", tag)
-			}
-		}
-		buf.WriteByte('}')
-
-	case *Pointer:
-		buf.WriteByte('*')
-		writeType(buf, t.base, qf, visited)
-
-	case *Tuple:
-		writeTuple(buf, t, false, qf, visited)
-
-	case *Signature:
-		buf.WriteString("func")
-		writeSignature(buf, t, qf, visited)
-
-	case *Interface:
-		// We write the source-level methods and embedded types rather
-		// than the actual method set since resolved method signatures
-		// may have non-printable cycles if parameters have anonymous
-		// interface types that (directly or indirectly) embed the
-		// current interface. For instance, consider the result type
-		// of m:
-		//
-		//     type T interface{
-		//         m() interface{ T }
-		//     }
-		//
-		buf.WriteString("interface{")
-		if GcCompatibilityMode {
-			// print flattened interface
-			// (useful to compare against gc-generated interfaces)
-			for i, m := range t.allMethods {
-				if i > 0 {
-					buf.WriteString("; ")
-				}
-				buf.WriteString(m.name)
-				writeSignature(buf, m.typ.(*Signature), qf, visited)
-			}
-		} else {
-			// print explicit interface methods and embedded types
-			for i, m := range t.methods {
-				if i > 0 {
-					buf.WriteString("; ")
-				}
-				buf.WriteString(m.name)
-				writeSignature(buf, m.typ.(*Signature), qf, visited)
-			}
-			for i, typ := range t.embeddeds {
-				if i > 0 || len(t.methods) > 0 {
-					buf.WriteString("; ")
-				}
-				writeType(buf, typ, qf, visited)
-			}
-		}
-		buf.WriteByte('}')
-
-	case *Map:
-		buf.WriteString("map[")
-		writeType(buf, t.key, qf, visited)
-		buf.WriteByte(']')
-		writeType(buf, t.elem, qf, visited)
-
-	case *Chan:
-		var s string
-		var parens bool
-		switch t.dir {
-		case SendRecv:
-			s = "chan "
-			// chan (<-chan T) requires parentheses
-			if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly {
-				parens = true
-			}
-		case SendOnly:
-			s = "chan<- "
-		case RecvOnly:
-			s = "<-chan "
-		default:
-			panic("unreachable")
-		}
-		buf.WriteString(s)
-		if parens {
-			buf.WriteByte('(')
-		}
-		writeType(buf, t.elem, qf, visited)
-		if parens {
-			buf.WriteByte(')')
-		}
-
-	case *Named:
-		s := "<Named w/o object>"
-		if obj := t.obj; obj != nil {
-			if obj.pkg != nil {
-				writePackage(buf, obj.pkg, qf)
-			}
-			// TODO(gri): function-local named types should be displayed
-			// differently from named types at package level to avoid
-			// ambiguity.
-			s = obj.name
-		}
-		buf.WriteString(s)
-
-	default:
-		// For externally defined implementations of Type.
-		buf.WriteString(t.String())
-	}
-}
-
-func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visited []Type) {
-	buf.WriteByte('(')
-	if tup != nil {
-		for i, v := range tup.vars {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			if v.name != "" {
-				buf.WriteString(v.name)
-				buf.WriteByte(' ')
-			}
-			typ := v.typ
-			if variadic && i == len(tup.vars)-1 {
-				if s, ok := typ.(*Slice); ok {
-					buf.WriteString("...")
-					typ = s.elem
-				} else {
-					// special case:
-					// append(s, "foo"...) leads to signature func([]byte, string...)
-					if t, ok := typ.Underlying().(*Basic); !ok || t.kind != String {
-						panic("internal error: string type expected")
-					}
-					writeType(buf, typ, qf, visited)
-					buf.WriteString("...")
-					continue
-				}
-			}
-			writeType(buf, typ, qf, visited)
-		}
-	}
-	buf.WriteByte(')')
-}
-
-// WriteSignature writes the representation of the signature sig to buf,
-// without a leading "func" keyword.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
-	writeSignature(buf, sig, qf, make([]Type, 8))
-}
-
-func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []Type) {
-	writeTuple(buf, sig.params, sig.variadic, qf, visited)
-
-	n := sig.results.Len()
-	if n == 0 {
-		// no result
-		return
-	}
-
-	buf.WriteByte(' ')
-	if n == 1 && sig.results.vars[0].name == "" {
-		// single unnamed result
-		writeType(buf, sig.results.vars[0].typ, qf, visited)
-		return
-	}
-
-	// multiple or named result(s)
-	writeTuple(buf, sig.results, false, qf, visited)
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/example_test.go b/vendor/golang.org/x/tools/go/types/typeutil/example_test.go
new file mode 100644
index 0000000..86c4d44
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/example_test.go
@@ -0,0 +1,67 @@
+// 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_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+func ExampleMap() {
+	const source = `package P
+
+var X []string
+var Y []string
+
+const p, q = 1.0, 2.0
+
+func f(offset int32) (value byte, ok bool)
+func g(rune) (uint8, bool)
+`
+
+	// Parse and type-check the package.
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "P.go", source, 0)
+	if err != nil {
+		panic(err)
+	}
+	pkg, err := new(types.Config).Check("P", fset, []*ast.File{f}, nil)
+	if err != nil {
+		panic(err)
+	}
+
+	scope := pkg.Scope()
+
+	// Group names of package-level objects by their type.
+	var namesByType typeutil.Map // value is []string
+	for _, name := range scope.Names() {
+		T := scope.Lookup(name).Type()
+
+		names, _ := namesByType.At(T).([]string)
+		names = append(names, name)
+		namesByType.Set(T, names)
+	}
+
+	// Format, sort, and print the map entries.
+	var lines []string
+	namesByType.Iterate(func(T types.Type, names interface{}) {
+		lines = append(lines, fmt.Sprintf("%s   %s", names, T))
+	})
+	sort.Strings(lines)
+	for _, line := range lines {
+		fmt.Println(line)
+	}
+
+	// Output:
+	// [X Y]   []string
+	// [f g]   func(offset int32) (value byte, ok bool)
+	// [p q]   untyped float
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
index 967fe1e..9c441db 100644
--- a/vendor/golang.org/x/tools/go/types/typeutil/imports.go
+++ b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
@@ -4,7 +4,7 @@
 
 package typeutil
 
-import "golang.org/x/tools/go/types"
+import "go/types"
 
 // Dependencies returns all dependencies of the specified packages.
 //
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go b/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go
new file mode 100644
index 0000000..c8ef6d6
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go
@@ -0,0 +1,80 @@
+// 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_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+type closure map[string]*types.Package
+
+func (c closure) Import(path string) (*types.Package, error) { return c[path], nil }
+
+func TestDependencies(t *testing.T) {
+	packages := make(map[string]*types.Package)
+	conf := types.Config{
+		Importer: closure(packages),
+	}
+	fset := token.NewFileSet()
+
+	// All edges go to the right.
+	//  /--D--B--A
+	// F    \_C_/
+	//  \__E_/
+	for i, content := range []string{
+		`package a`,
+		`package c; import (_ "a")`,
+		`package b; import (_ "a")`,
+		`package e; import (_ "c")`,
+		`package d; import (_ "b"; _ "c")`,
+		`package f; import (_ "d"; _ "e")`,
+	} {
+		f, err := parser.ParseFile(fset, fmt.Sprintf("%d.go", i), content, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		packages[pkg.Path()] = pkg
+	}
+
+	for _, test := range []struct {
+		roots, want string
+	}{
+		{"a", "a"},
+		{"b", "ab"},
+		{"c", "ac"},
+		{"d", "abcd"},
+		{"e", "ace"},
+		{"f", "abcdef"},
+
+		{"be", "abce"},
+		{"eb", "aceb"},
+		{"de", "abcde"},
+		{"ed", "acebd"},
+		{"ef", "acebdf"},
+	} {
+		var pkgs []*types.Package
+		for _, r := range test.roots {
+			pkgs = append(pkgs, packages[string(r)])
+		}
+		var got string
+		for _, p := range typeutil.Dependencies(pkgs...) {
+			got += p.Path()
+		}
+		if got != test.want {
+			t.Errorf("Dependencies(%q) = %q, want %q", test.roots, got, test.want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go
index b3a04cc..c7f7545 100644
--- a/vendor/golang.org/x/tools/go/types/typeutil/map.go
+++ b/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -9,9 +9,8 @@ package typeutil // import "golang.org/x/tools/go/types/typeutil"
 import (
 	"bytes"
 	"fmt"
+	"go/types"
 	"reflect"
-
-	"golang.org/x/tools/go/types"
 )
 
 // Map is a hash-table-based mapping from types (types.Type) to
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map_test.go b/vendor/golang.org/x/tools/go/types/typeutil/map_test.go
new file mode 100644
index 0000000..34facbe
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/map_test.go
@@ -0,0 +1,174 @@
+// 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_test
+
+// TODO(adonovan):
+// - test use of explicit hasher across two maps.
+// - test hashcodes are consistent with equals for a range of types
+//   (e.g. all types generated by type-checking some body of real code).
+
+import (
+	"go/types"
+	"testing"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+var (
+	tStr      = types.Typ[types.String]             // string
+	tPStr1    = types.NewPointer(tStr)              // *string
+	tPStr2    = types.NewPointer(tStr)              // *string, again
+	tInt      = types.Typ[types.Int]                // int
+	tChanInt1 = types.NewChan(types.RecvOnly, tInt) // <-chan int
+	tChanInt2 = types.NewChan(types.RecvOnly, tInt) // <-chan int, again
+)
+
+func checkEqualButNotIdentical(t *testing.T, x, y types.Type, comment string) {
+	if !types.Identical(x, y) {
+		t.Errorf("%s: not equal: %s, %s", comment, x, y)
+	}
+	if x == y {
+		t.Errorf("%s: identical: %v, %v", comment, x, y)
+	}
+}
+
+func TestAxioms(t *testing.T) {
+	checkEqualButNotIdentical(t, tPStr1, tPStr2, "tPstr{1,2}")
+	checkEqualButNotIdentical(t, tChanInt1, tChanInt2, "tChanInt{1,2}")
+}
+
+func TestMap(t *testing.T) {
+	var tmap *typeutil.Map
+
+	// All methods but Set are safe on on (*T)(nil).
+	tmap.Len()
+	tmap.At(tPStr1)
+	tmap.Delete(tPStr1)
+	tmap.KeysString()
+	tmap.String()
+
+	tmap = new(typeutil.Map)
+
+	// Length of empty map.
+	if l := tmap.Len(); l != 0 {
+		t.Errorf("Len() on empty Map: got %d, want 0", l)
+	}
+	// At of missing key.
+	if v := tmap.At(tPStr1); v != nil {
+		t.Errorf("At() on empty Map: got %v, want nil", v)
+	}
+	// Deletion of missing key.
+	if tmap.Delete(tPStr1) {
+		t.Errorf("Delete() on empty Map: got true, want false")
+	}
+	// Set of new key.
+	if prev := tmap.Set(tPStr1, "*string"); prev != nil {
+		t.Errorf("Set() on empty Map returned non-nil previous value %s", prev)
+	}
+
+	// Now: {*string: "*string"}
+
+	// Length of non-empty map.
+	if l := tmap.Len(); l != 1 {
+		t.Errorf("Len(): got %d, want 1", l)
+	}
+	// At via insertion key.
+	if v := tmap.At(tPStr1); v != "*string" {
+		t.Errorf("At(): got %q, want \"*string\"", v)
+	}
+	// At via equal key.
+	if v := tmap.At(tPStr2); v != "*string" {
+		t.Errorf("At(): got %q, want \"*string\"", v)
+	}
+	// Iteration over sole entry.
+	tmap.Iterate(func(key types.Type, value interface{}) {
+		if key != tPStr1 {
+			t.Errorf("Iterate: key: got %s, want %s", key, tPStr1)
+		}
+		if want := "*string"; value != want {
+			t.Errorf("Iterate: value: got %s, want %s", value, want)
+		}
+	})
+
+	// Setion with key equal to present one.
+	if prev := tmap.Set(tPStr2, "*string again"); prev != "*string" {
+		t.Errorf("Set() previous value: got %s, want \"*string\"", prev)
+	}
+
+	// Setion of another association.
+	if prev := tmap.Set(tChanInt1, "<-chan int"); prev != nil {
+		t.Errorf("Set() previous value: got %s, want nil", prev)
+	}
+
+	// Now: {*string: "*string again", <-chan int: "<-chan int"}
+
+	want1 := "{*string: \"*string again\", <-chan int: \"<-chan int\"}"
+	want2 := "{<-chan int: \"<-chan int\", *string: \"*string again\"}"
+	if s := tmap.String(); s != want1 && s != want2 {
+		t.Errorf("String(): got %s, want %s", s, want1)
+	}
+
+	want1 = "{*string, <-chan int}"
+	want2 = "{<-chan int, *string}"
+	if s := tmap.KeysString(); s != want1 && s != want2 {
+		t.Errorf("KeysString(): got %s, want %s", s, want1)
+	}
+
+	// Keys().
+	I := types.Identical
+	switch k := tmap.Keys(); {
+	case I(k[0], tChanInt1) && I(k[1], tPStr1): // ok
+	case I(k[1], tChanInt1) && I(k[0], tPStr1): // ok
+	default:
+		t.Errorf("Keys(): got %v, want %s", k, want2)
+	}
+
+	if l := tmap.Len(); l != 2 {
+		t.Errorf("Len(): got %d, want 1", l)
+	}
+	// At via original key.
+	if v := tmap.At(tPStr1); v != "*string again" {
+		t.Errorf("At(): got %q, want \"*string again\"", v)
+	}
+	hamming := 1
+	tmap.Iterate(func(key types.Type, value interface{}) {
+		switch {
+		case I(key, tChanInt1):
+			hamming *= 2 // ok
+		case I(key, tPStr1):
+			hamming *= 3 // ok
+		}
+	})
+	if hamming != 6 {
+		t.Errorf("Iterate: hamming: got %d, want %d", hamming, 6)
+	}
+
+	if v := tmap.At(tChanInt2); v != "<-chan int" {
+		t.Errorf("At(): got %q, want \"<-chan int\"", v)
+	}
+	// Deletion with key equal to present one.
+	if !tmap.Delete(tChanInt2) {
+		t.Errorf("Delete() of existing key: got false, want true")
+	}
+
+	// Now: {*string: "*string again"}
+
+	if l := tmap.Len(); l != 1 {
+		t.Errorf("Len(): got %d, want 1", l)
+	}
+	// Deletion again.
+	if !tmap.Delete(tPStr2) {
+		t.Errorf("Delete() of existing key: got false, want true")
+	}
+
+	// Now: {}
+
+	if l := tmap.Len(); l != 0 {
+		t.Errorf("Len(): got %d, want %d", l, 0)
+	}
+	if s := tmap.String(); s != "{}" {
+		t.Errorf("Len(): got %q, want %q", s, "")
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
index daad644..3208461 100644
--- a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
+++ b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
@@ -7,9 +7,8 @@
 package typeutil
 
 import (
+	"go/types"
 	"sync"
-
-	"golang.org/x/tools/go/types"
 )
 
 // A MethodSetCache records the method set of each type T for which
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
index 20c5249..9849c24 100644
--- a/vendor/golang.org/x/tools/go/types/typeutil/ui.go
+++ b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
@@ -6,25 +6,38 @@ package typeutil
 
 // This file defines utilities for user interfaces that display types.
 
-import "golang.org/x/tools/go/types"
+import "go/types"
 
-// IntuitiveMethodSet returns the intuitive method set of a type, T.
+// 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 contains MethodSet(T) and additionally, if T is a
-// concrete type, methods 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 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 _, ok := T.Underlying().(*types.Interface); ok {
+	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)
@@ -33,6 +46,7 @@ func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection
 			}
 			result = append(result, meth)
 		}
+
 	}
 	return result
 }
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go b/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go
new file mode 100644
index 0000000..b5064ac
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go
@@ -0,0 +1,61 @@
+package typeutil_test
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+func TestIntuitiveMethodSet(t *testing.T) {
+	const source = `
+package P
+type A int
+func (A) f()
+func (*A) g()
+`
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "hello.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var conf types.Config
+	pkg, err := conf.Check("P", fset, []*ast.File{f}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	qual := types.RelativeTo(pkg)
+
+	for _, test := range []struct {
+		expr string // type expression
+		want string // intuitive method set
+	}{
+		{"A", "(A).f (*A).g"},
+		{"*A", "(*A).f (*A).g"},
+		{"error", "(error).Error"},
+		{"*error", ""},
+		{"struct{A}", "(struct{A}).f (*struct{A}).g"},
+		{"*struct{A}", "(*struct{A}).f (*struct{A}).g"},
+	} {
+		tv, err := types.Eval(fset, pkg, 0, test.expr)
+		if err != nil {
+			t.Errorf("Eval(%s) failed: %v", test.expr, err)
+		}
+		var names []string
+		for _, m := range typeutil.IntuitiveMethodSet(tv.Type, nil) {
+			name := fmt.Sprintf("(%s).%s", types.TypeString(m.Recv(), qual), m.Obj().Name())
+			names = append(names, name)
+		}
+		got := strings.Join(names, " ")
+		if got != test.want {
+			t.Errorf("IntuitiveMethodSet(%s) = %q, want %q", test.expr, got, test.want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/types/typexpr.go b/vendor/golang.org/x/tools/go/types/typexpr.go
deleted file mode 100644
index bd2d7ba..0000000
--- a/vendor/golang.org/x/tools/go/types/typexpr.go
+++ /dev/null
@@ -1,713 +0,0 @@
-// 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.
-
-// This file implements type-checking of identifiers and type expressions.
-
-package types
-
-import (
-	"go/ast"
-	"go/token"
-	"sort"
-	"strconv"
-
-	"golang.org/x/tools/go/exact"
-)
-
-// ident type-checks identifier e and initializes x with the value or type of e.
-// If an error occurred, x.mode is set to invalid.
-// For the meaning of def and path, see check.typ, below.
-//
-func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, path []*TypeName) {
-	x.mode = invalid
-	x.expr = e
-
-	scope, obj := check.scope.LookupParent(e.Name, check.pos)
-	if obj == nil {
-		if e.Name == "_" {
-			check.errorf(e.Pos(), "cannot use _ as value or type")
-		} else {
-			check.errorf(e.Pos(), "undeclared name: %s", e.Name)
-		}
-		return
-	}
-	check.recordUse(e, obj)
-
-	check.objDecl(obj, def, path)
-	typ := obj.Type()
-	assert(typ != nil)
-
-	// The object may be dot-imported: If so, remove its package from
-	// the map of unused dot imports for the respective file scope.
-	// (This code is only needed for dot-imports. Without them,
-	// we only have to mark variables, see *Var case below).
-	if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
-		delete(check.unusedDotImports[scope], pkg)
-	}
-
-	switch obj := obj.(type) {
-	case *PkgName:
-		check.errorf(e.Pos(), "use of package %s not in selector", obj.name)
-		return
-
-	case *Const:
-		check.addDeclDep(obj)
-		if typ == Typ[Invalid] {
-			return
-		}
-		if obj == universeIota {
-			if check.iota == nil {
-				check.errorf(e.Pos(), "cannot use iota outside constant declaration")
-				return
-			}
-			x.val = check.iota
-		} else {
-			x.val = obj.val
-		}
-		assert(x.val != nil)
-		x.mode = constant
-
-	case *TypeName:
-		x.mode = typexpr
-		// check for cycle
-		// (it's ok to iterate forward because each named type appears at most once in path)
-		for i, prev := range path {
-			if prev == obj {
-				check.errorf(obj.pos, "illegal cycle in declaration of %s", obj.name)
-				// print cycle
-				for _, obj := range path[i:] {
-					check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
-				}
-				check.errorf(obj.Pos(), "\t%s", obj.Name())
-				// maintain x.mode == typexpr despite error
-				typ = Typ[Invalid]
-				break
-			}
-		}
-
-	case *Var:
-		if obj.pkg == check.pkg {
-			obj.used = true
-		}
-		check.addDeclDep(obj)
-		if typ == Typ[Invalid] {
-			return
-		}
-		x.mode = variable
-
-	case *Func:
-		check.addDeclDep(obj)
-		x.mode = value
-
-	case *Builtin:
-		x.id = obj.id
-		x.mode = builtin
-
-	case *Nil:
-		x.mode = value
-
-	default:
-		unreachable()
-	}
-
-	x.typ = typ
-}
-
-// typExpr type-checks the type expression e and returns its type, or Typ[Invalid].
-// If def != nil, e is the type specification for the named type def, declared
-// in a type declaration, and def.underlying will be set to the type of e before
-// any components of e are type-checked. Path contains the path of named types
-// referring to this type.
-//
-func (check *Checker) typExpr(e ast.Expr, def *Named, path []*TypeName) (T Type) {
-	if trace {
-		check.trace(e.Pos(), "%s", e)
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(e.Pos(), "=> %s", T)
-		}()
-	}
-
-	T = check.typExprInternal(e, def, path)
-	assert(isTyped(T))
-	check.recordTypeAndValue(e, typexpr, T, nil)
-
-	return
-}
-
-func (check *Checker) typ(e ast.Expr) Type {
-	return check.typExpr(e, nil, nil)
-}
-
-// funcType type-checks a function or method type.
-func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
-	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function")
-	check.recordScope(ftyp, scope)
-
-	recvList, _ := check.collectParams(scope, recvPar, false)
-	params, variadic := check.collectParams(scope, ftyp.Params, true)
-	results, _ := check.collectParams(scope, ftyp.Results, false)
-
-	if recvPar != nil {
-		// recv parameter list present (may be empty)
-		// spec: "The receiver is specified via an extra parameter section preceeding the
-		// method name. That parameter section must declare a single parameter, the receiver."
-		var recv *Var
-		switch len(recvList) {
-		case 0:
-			check.error(recvPar.Pos(), "method is missing receiver")
-			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
-		default:
-			// more than one receiver
-			check.error(recvList[len(recvList)-1].Pos(), "method must have exactly one receiver")
-			fallthrough // continue with first receiver
-		case 1:
-			recv = recvList[0]
-		}
-		// spec: "The receiver type must be of the form T or *T where T is a type name."
-		// (ignore invalid types - error was reported before)
-		if t, _ := deref(recv.typ); t != Typ[Invalid] {
-			var err string
-			if T, _ := t.(*Named); T != nil {
-				// spec: "The type denoted by T is called the receiver base type; it must not
-				// be a pointer or interface type and it must be declared in the same package
-				// as the method."
-				if T.obj.pkg != check.pkg {
-					err = "type not defined in this package"
-				} else {
-					// TODO(gri) This is not correct if the underlying type is unknown yet.
-					switch u := T.underlying.(type) {
-					case *Basic:
-						// unsafe.Pointer is treated like a regular pointer
-						if u.kind == UnsafePointer {
-							err = "unsafe.Pointer"
-						}
-					case *Pointer, *Interface:
-						err = "pointer or interface type"
-					}
-				}
-			} else {
-				err = "basic or unnamed type"
-			}
-			if err != "" {
-				check.errorf(recv.pos, "invalid receiver %s (%s)", recv.typ, err)
-				// ok to continue
-			}
-		}
-		sig.recv = recv
-	}
-
-	sig.scope = scope
-	sig.params = NewTuple(params...)
-	sig.results = NewTuple(results...)
-	sig.variadic = variadic
-}
-
-// typExprInternal drives type checking of types.
-// Must only be called by typExpr.
-//
-func (check *Checker) typExprInternal(e ast.Expr, def *Named, path []*TypeName) Type {
-	switch e := e.(type) {
-	case *ast.BadExpr:
-		// ignore - error reported before
-
-	case *ast.Ident:
-		var x operand
-		check.ident(&x, e, def, path)
-
-		switch x.mode {
-		case typexpr:
-			typ := x.typ
-			def.setUnderlying(typ)
-			return typ
-		case invalid:
-			// ignore - error reported before
-		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
-		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
-		}
-
-	case *ast.SelectorExpr:
-		var x operand
-		check.selector(&x, e)
-
-		switch x.mode {
-		case typexpr:
-			typ := x.typ
-			def.setUnderlying(typ)
-			return typ
-		case invalid:
-			// ignore - error reported before
-		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
-		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
-		}
-
-	case *ast.ParenExpr:
-		return check.typExpr(e.X, def, path)
-
-	case *ast.ArrayType:
-		if e.Len != nil {
-			typ := new(Array)
-			def.setUnderlying(typ)
-			typ.len = check.arrayLength(e.Len)
-			typ.elem = check.typExpr(e.Elt, nil, path)
-			return typ
-
-		} else {
-			typ := new(Slice)
-			def.setUnderlying(typ)
-			typ.elem = check.typ(e.Elt)
-			return typ
-		}
-
-	case *ast.StructType:
-		typ := new(Struct)
-		def.setUnderlying(typ)
-		check.structType(typ, e, path)
-		return typ
-
-	case *ast.StarExpr:
-		typ := new(Pointer)
-		def.setUnderlying(typ)
-		typ.base = check.typ(e.X)
-		return typ
-
-	case *ast.FuncType:
-		typ := new(Signature)
-		def.setUnderlying(typ)
-		check.funcType(typ, nil, e)
-		return typ
-
-	case *ast.InterfaceType:
-		typ := new(Interface)
-		def.setUnderlying(typ)
-		check.interfaceType(typ, e, def, path)
-		return typ
-
-	case *ast.MapType:
-		typ := new(Map)
-		def.setUnderlying(typ)
-
-		typ.key = check.typ(e.Key)
-		typ.elem = check.typ(e.Value)
-
-		// spec: "The comparison operators == and != must be fully defined
-		// for operands of the key type; thus the key type must not be a
-		// function, map, or slice."
-		//
-		// Delay this check because it requires fully setup types;
-		// it is safe to continue in any case (was issue 6667).
-		check.delay(func() {
-			if !Comparable(typ.key) {
-				check.errorf(e.Key.Pos(), "invalid map key type %s", typ.key)
-			}
-		})
-
-		return typ
-
-	case *ast.ChanType:
-		typ := new(Chan)
-		def.setUnderlying(typ)
-
-		dir := SendRecv
-		switch e.Dir {
-		case ast.SEND | ast.RECV:
-			// nothing to do
-		case ast.SEND:
-			dir = SendOnly
-		case ast.RECV:
-			dir = RecvOnly
-		default:
-			check.invalidAST(e.Pos(), "unknown channel direction %d", e.Dir)
-			// ok to continue
-		}
-
-		typ.dir = dir
-		typ.elem = check.typ(e.Value)
-		return typ
-
-	default:
-		check.errorf(e.Pos(), "%s is not a type", e)
-	}
-
-	typ := Typ[Invalid]
-	def.setUnderlying(typ)
-	return typ
-}
-
-// typeOrNil type-checks the type expression (or nil value) e
-// and returns the typ of e, or nil.
-// If e is neither a type nor nil, typOrNil returns Typ[Invalid].
-//
-func (check *Checker) typOrNil(e ast.Expr) Type {
-	var x operand
-	check.rawExpr(&x, e, nil)
-	switch x.mode {
-	case invalid:
-		// ignore - error reported before
-	case novalue:
-		check.errorf(x.pos(), "%s used as type", &x)
-	case typexpr:
-		return x.typ
-	case value:
-		if x.isNil() {
-			return nil
-		}
-		fallthrough
-	default:
-		check.errorf(x.pos(), "%s is not a type", &x)
-	}
-	return Typ[Invalid]
-}
-
-func (check *Checker) arrayLength(e ast.Expr) int64 {
-	var x operand
-	check.expr(&x, e)
-	if x.mode != constant {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "array length %s must be constant", &x)
-		}
-		return 0
-	}
-	if !x.isInteger() {
-		check.errorf(x.pos(), "array length %s must be integer", &x)
-		return 0
-	}
-	n, ok := exact.Int64Val(x.val)
-	if !ok || n < 0 {
-		check.errorf(x.pos(), "invalid array length %s", &x)
-		return 0
-	}
-	return n
-}
-
-func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicOk bool) (params []*Var, variadic bool) {
-	if list == nil {
-		return
-	}
-
-	var named, anonymous bool
-	for i, field := range list.List {
-		ftype := field.Type
-		if t, _ := ftype.(*ast.Ellipsis); t != nil {
-			ftype = t.Elt
-			if variadicOk && i == len(list.List)-1 {
-				variadic = true
-			} else {
-				check.invalidAST(field.Pos(), "... not permitted")
-				// ignore ... and continue
-			}
-		}
-		typ := check.typ(ftype)
-		// The parser ensures that f.Tag is nil and we don't
-		// care if a constructed AST contains a non-nil tag.
-		if len(field.Names) > 0 {
-			// named parameter
-			for _, name := range field.Names {
-				if name.Name == "" {
-					check.invalidAST(name.Pos(), "anonymous parameter")
-					// ok to continue
-				}
-				par := NewParam(name.Pos(), check.pkg, name.Name, typ)
-				check.declare(scope, name, par, scope.pos)
-				params = append(params, par)
-			}
-			named = true
-		} else {
-			// anonymous parameter
-			par := NewParam(ftype.Pos(), check.pkg, "", typ)
-			check.recordImplicit(field, par)
-			params = append(params, par)
-			anonymous = true
-		}
-	}
-
-	if named && anonymous {
-		check.invalidAST(list.Pos(), "list contains both named and anonymous parameters")
-		// ok to continue
-	}
-
-	// For a variadic function, change the last parameter's type from T to []T.
-	if variadic && len(params) > 0 {
-		last := params[len(params)-1]
-		last.typ = &Slice{elem: last.typ}
-	}
-
-	return
-}
-
-func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool {
-	if alt := oset.insert(obj); alt != nil {
-		check.errorf(pos, "%s redeclared", obj.Name())
-		check.reportAltDecl(alt)
-		return false
-	}
-	return true
-}
-
-func (check *Checker) interfaceType(iface *Interface, ityp *ast.InterfaceType, def *Named, path []*TypeName) {
-	// empty interface: common case
-	if ityp.Methods == nil {
-		return
-	}
-
-	// The parser ensures that field tags are nil and we don't
-	// care if a constructed AST contains non-nil tags.
-
-	// use named receiver type if available (for better error messages)
-	var recvTyp Type = iface
-	if def != nil {
-		recvTyp = def
-	}
-
-	// Phase 1: Collect explicitly declared methods, the corresponding
-	//          signature (AST) expressions, and the list of embedded
-	//          type (AST) expressions. Do not resolve signatures or
-	//          embedded types yet to avoid cycles referring to this
-	//          interface.
-
-	var (
-		mset       objset
-		signatures []ast.Expr // list of corresponding method signatures
-		embedded   []ast.Expr // list of embedded types
-	)
-	for _, f := range ityp.Methods.List {
-		if len(f.Names) > 0 {
-			// The parser ensures that there's only one method
-			// and we don't care if a constructed AST has more.
-			name := f.Names[0]
-			pos := name.Pos()
-			// spec: "As with all method sets, in an interface type,
-			// each method must have a unique non-blank name."
-			if name.Name == "_" {
-				check.errorf(pos, "invalid method name _")
-				continue
-			}
-			// Don't type-check signature yet - use an
-			// empty signature now and update it later.
-			// Since we know the receiver, set it up now
-			// (required to avoid crash in ptrRecv; see
-			// e.g. test case for issue 6638).
-			// TODO(gri) Consider marking methods signatures
-			// as incomplete, for better error messages. See
-			// also the T4 and T5 tests in testdata/cycles2.src.
-			sig := new(Signature)
-			sig.recv = NewVar(pos, check.pkg, "", recvTyp)
-			m := NewFunc(pos, check.pkg, name.Name, sig)
-			if check.declareInSet(&mset, pos, m) {
-				iface.methods = append(iface.methods, m)
-				iface.allMethods = append(iface.allMethods, m)
-				signatures = append(signatures, f.Type)
-				check.recordDef(name, m)
-			}
-		} else {
-			// embedded type
-			embedded = append(embedded, f.Type)
-		}
-	}
-
-	// Phase 2: Resolve embedded interfaces. Because an interface must not
-	//          embed itself (directly or indirectly), each embedded interface
-	//          can be fully resolved without depending on any method of this
-	//          interface (if there is a cycle or another error, the embedded
-	//          type resolves to an invalid type and is ignored).
-	//          In particular, the list of methods for each embedded interface
-	//          must be complete (it cannot depend on this interface), and so
-	//          those methods can be added to the list of all methods of this
-	//          interface.
-
-	for _, e := range embedded {
-		pos := e.Pos()
-		typ := check.typExpr(e, nil, path)
-		// Determine underlying embedded (possibly incomplete) type
-		// by following its forward chain.
-		named, _ := typ.(*Named)
-		under := underlying(named)
-		embed, _ := under.(*Interface)
-		if embed == nil {
-			if typ != Typ[Invalid] {
-				check.errorf(pos, "%s is not an interface", typ)
-			}
-			continue
-		}
-		iface.embeddeds = append(iface.embeddeds, named)
-		// collect embedded methods
-		for _, m := range embed.allMethods {
-			if check.declareInSet(&mset, pos, m) {
-				iface.allMethods = append(iface.allMethods, m)
-			}
-		}
-	}
-
-	// Phase 3: At this point all methods have been collected for this interface.
-	//          It is now safe to type-check the signatures of all explicitly
-	//          declared methods, even if they refer to this interface via a cycle
-	//          and embed the methods of this interface in a parameter of interface
-	//          type.
-
-	for i, m := range iface.methods {
-		expr := signatures[i]
-		typ := check.typ(expr)
-		sig, _ := typ.(*Signature)
-		if sig == nil {
-			if typ != Typ[Invalid] {
-				check.invalidAST(expr.Pos(), "%s is not a method signature", typ)
-			}
-			continue // keep method with empty method signature
-		}
-		// update signature, but keep recv that was set up before
-		old := m.typ.(*Signature)
-		sig.recv = old.recv
-		*old = *sig // update signature (don't replace it!)
-	}
-
-	// TODO(gri) The list of explicit methods is only sorted for now to
-	// produce the same Interface as NewInterface. We may be able to
-	// claim source order in the future. Revisit.
-	sort.Sort(byUniqueMethodName(iface.methods))
-
-	// TODO(gri) The list of embedded types is only sorted for now to
-	// produce the same Interface as NewInterface. We may be able to
-	// claim source order in the future. Revisit.
-	sort.Sort(byUniqueTypeName(iface.embeddeds))
-
-	sort.Sort(byUniqueMethodName(iface.allMethods))
-}
-
-// byUniqueTypeName named type lists can be sorted by their unique type names.
-type byUniqueTypeName []*Named
-
-func (a byUniqueTypeName) Len() int           { return len(a) }
-func (a byUniqueTypeName) Less(i, j int) bool { return a[i].obj.Id() < a[j].obj.Id() }
-func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
-// byUniqueMethodName method lists can be sorted by their unique method names.
-type byUniqueMethodName []*Func
-
-func (a byUniqueMethodName) Len() int           { return len(a) }
-func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
-func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
-func (check *Checker) tag(t *ast.BasicLit) string {
-	if t != nil {
-		if t.Kind == token.STRING {
-			if val, err := strconv.Unquote(t.Value); err == nil {
-				return val
-			}
-		}
-		check.invalidAST(t.Pos(), "incorrect tag syntax: %q", t.Value)
-	}
-	return ""
-}
-
-func (check *Checker) structType(styp *Struct, e *ast.StructType, path []*TypeName) {
-	list := e.Fields
-	if list == nil {
-		return
-	}
-
-	// struct fields and tags
-	var fields []*Var
-	var tags []string
-
-	// for double-declaration checks
-	var fset objset
-
-	// current field typ and tag
-	var typ Type
-	var tag string
-	// anonymous != nil indicates an anonymous field.
-	add := func(field *ast.Field, ident *ast.Ident, anonymous *TypeName, pos token.Pos) {
-		if tag != "" && tags == nil {
-			tags = make([]string, len(fields))
-		}
-		if tags != nil {
-			tags = append(tags, tag)
-		}
-
-		name := ident.Name
-		fld := NewField(pos, check.pkg, name, typ, anonymous != nil)
-		// spec: "Within a struct, non-blank field names must be unique."
-		if name == "_" || check.declareInSet(&fset, pos, fld) {
-			fields = append(fields, fld)
-			check.recordDef(ident, fld)
-		}
-		if anonymous != nil {
-			check.recordUse(ident, anonymous)
-		}
-	}
-
-	for _, f := range list.List {
-		typ = check.typExpr(f.Type, nil, path)
-		tag = check.tag(f.Tag)
-		if len(f.Names) > 0 {
-			// named fields
-			for _, name := range f.Names {
-				add(f, name, nil, name.Pos())
-			}
-		} else {
-			// anonymous field
-			name := anonymousFieldIdent(f.Type)
-			pos := f.Type.Pos()
-			t, isPtr := deref(typ)
-			switch t := t.(type) {
-			case *Basic:
-				if t == Typ[Invalid] {
-					// error was reported before
-					continue
-				}
-				// unsafe.Pointer is treated like a regular pointer
-				if t.kind == UnsafePointer {
-					check.errorf(pos, "anonymous field type cannot be unsafe.Pointer")
-					continue
-				}
-				add(f, name, Universe.Lookup(t.name).(*TypeName), pos)
-
-			case *Named:
-				// spec: "An embedded type must be specified as a type name
-				// T or as a pointer to a non-interface type name *T, and T
-				// itself may not be a pointer type."
-				switch u := t.underlying.(type) {
-				case *Basic:
-					// unsafe.Pointer is treated like a regular pointer
-					if u.kind == UnsafePointer {
-						check.errorf(pos, "anonymous field type cannot be unsafe.Pointer")
-						continue
-					}
-				case *Pointer:
-					check.errorf(pos, "anonymous field type cannot be a pointer")
-					continue
-				case *Interface:
-					if isPtr {
-						check.errorf(pos, "anonymous field type cannot be a pointer to an interface")
-						continue
-					}
-				}
-				add(f, name, t.obj, pos)
-
-			default:
-				check.invalidAST(pos, "anonymous field type %s must be named", typ)
-			}
-		}
-	}
-
-	styp.fields = fields
-	styp.tags = tags
-}
-
-func anonymousFieldIdent(e ast.Expr) *ast.Ident {
-	switch e := e.(type) {
-	case *ast.Ident:
-		return e
-	case *ast.StarExpr:
-		return anonymousFieldIdent(e.X)
-	case *ast.SelectorExpr:
-		return e.Sel
-	}
-	return nil // invalid anonymous field
-}
diff --git a/vendor/golang.org/x/tools/go/types/universe.go b/vendor/golang.org/x/tools/go/types/universe.go
deleted file mode 100644
index 12a34ef..0000000
--- a/vendor/golang.org/x/tools/go/types/universe.go
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file sets up the universe scope and the unsafe package.
-
-package types
-
-import (
-	"go/token"
-	"strings"
-
-	"golang.org/x/tools/go/exact"
-)
-
-var (
-	Universe     *Scope
-	Unsafe       *Package
-	universeIota *Const
-	universeByte *Basic // uint8 alias, but has name "byte"
-	universeRune *Basic // int32 alias, but has name "rune"
-)
-
-var Typ = []*Basic{
-	Invalid: {Invalid, 0, "invalid type"},
-
-	Bool:          {Bool, IsBoolean, "bool"},
-	Int:           {Int, IsInteger, "int"},
-	Int8:          {Int8, IsInteger, "int8"},
-	Int16:         {Int16, IsInteger, "int16"},
-	Int32:         {Int32, IsInteger, "int32"},
-	Int64:         {Int64, IsInteger, "int64"},
-	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},
-	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8"},
-	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16"},
-	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
-	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
-	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
-	Float32:       {Float32, IsFloat, "float32"},
-	Float64:       {Float64, IsFloat, "float64"},
-	Complex64:     {Complex64, IsComplex, "complex64"},
-	Complex128:    {Complex128, IsComplex, "complex128"},
-	String:        {String, IsString, "string"},
-	UnsafePointer: {UnsafePointer, 0, "Pointer"},
-
-	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
-	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int"},
-	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
-	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
-	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
-	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string"},
-	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil"},
-}
-
-var aliases = [...]*Basic{
-	{Byte, IsInteger | IsUnsigned, "byte"},
-	{Rune, IsInteger, "rune"},
-}
-
-func defPredeclaredTypes() {
-	for _, t := range Typ {
-		def(NewTypeName(token.NoPos, nil, t.name, t))
-	}
-	for _, t := range aliases {
-		def(NewTypeName(token.NoPos, nil, t.name, t))
-	}
-
-	// Error has a nil package in its qualified name since it is in no package
-	res := NewVar(token.NoPos, nil, "", Typ[String])
-	sig := &Signature{results: NewTuple(res)}
-	err := NewFunc(token.NoPos, nil, "Error", sig)
-	typ := &Named{underlying: NewInterface([]*Func{err}, nil).Complete()}
-	sig.recv = NewVar(token.NoPos, nil, "", typ)
-	def(NewTypeName(token.NoPos, nil, "error", typ))
-}
-
-var predeclaredConsts = [...]struct {
-	name string
-	kind BasicKind
-	val  exact.Value
-}{
-	{"true", UntypedBool, exact.MakeBool(true)},
-	{"false", UntypedBool, exact.MakeBool(false)},
-	{"iota", UntypedInt, exact.MakeInt64(0)},
-}
-
-func defPredeclaredConsts() {
-	for _, c := range predeclaredConsts {
-		def(NewConst(token.NoPos, nil, c.name, Typ[c.kind], c.val))
-	}
-}
-
-func defPredeclaredNil() {
-	def(&Nil{object{name: "nil", typ: Typ[UntypedNil]}})
-}
-
-// A builtinId is the id of a builtin function.
-type builtinId int
-
-const (
-	// universe scope
-	_Append builtinId = iota
-	_Cap
-	_Close
-	_Complex
-	_Copy
-	_Delete
-	_Imag
-	_Len
-	_Make
-	_New
-	_Panic
-	_Print
-	_Println
-	_Real
-	_Recover
-
-	// package unsafe
-	_Alignof
-	_Offsetof
-	_Sizeof
-
-	// testing support
-	_Assert
-	_Trace
-)
-
-var predeclaredFuncs = [...]struct {
-	name     string
-	nargs    int
-	variadic bool
-	kind     exprKind
-}{
-	_Append:  {"append", 1, true, expression},
-	_Cap:     {"cap", 1, false, expression},
-	_Close:   {"close", 1, false, statement},
-	_Complex: {"complex", 2, false, expression},
-	_Copy:    {"copy", 2, false, statement},
-	_Delete:  {"delete", 2, false, statement},
-	_Imag:    {"imag", 1, false, expression},
-	_Len:     {"len", 1, false, expression},
-	_Make:    {"make", 1, true, expression},
-	_New:     {"new", 1, false, expression},
-	_Panic:   {"panic", 1, false, statement},
-	_Print:   {"print", 0, true, statement},
-	_Println: {"println", 0, true, statement},
-	_Real:    {"real", 1, false, expression},
-	_Recover: {"recover", 0, false, statement},
-
-	_Alignof:  {"Alignof", 1, false, expression},
-	_Offsetof: {"Offsetof", 1, false, expression},
-	_Sizeof:   {"Sizeof", 1, false, expression},
-
-	_Assert: {"assert", 1, false, statement},
-	_Trace:  {"trace", 0, true, statement},
-}
-
-func defPredeclaredFuncs() {
-	for i := range predeclaredFuncs {
-		id := builtinId(i)
-		if id == _Assert || id == _Trace {
-			continue // only define these in testing environment
-		}
-		def(newBuiltin(id))
-	}
-}
-
-// DefPredeclaredTestFuncs defines the assert and trace built-ins.
-// These built-ins are intended for debugging and testing of this
-// package only.
-func DefPredeclaredTestFuncs() {
-	if Universe.Lookup("assert") != nil {
-		return // already defined
-	}
-	def(newBuiltin(_Assert))
-	def(newBuiltin(_Trace))
-}
-
-func init() {
-	Universe = NewScope(nil, token.NoPos, token.NoPos, "universe")
-	Unsafe = NewPackage("unsafe", "unsafe")
-	Unsafe.complete = true
-
-	defPredeclaredTypes()
-	defPredeclaredConsts()
-	defPredeclaredNil()
-	defPredeclaredFuncs()
-
-	universeIota = Universe.Lookup("iota").(*Const)
-	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
-	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
-}
-
-// Objects with names containing blanks are internal and not entered into
-// a scope. Objects with exported names are inserted in the unsafe package
-// scope; other objects are inserted in the universe scope.
-//
-func def(obj Object) {
-	name := obj.Name()
-	if strings.Index(name, " ") >= 0 {
-		return // nothing to do
-	}
-	// fix Obj link for named types
-	if typ, ok := obj.Type().(*Named); ok {
-		typ.obj = obj.(*TypeName)
-	}
-	// exported identifiers go into package unsafe
-	scope := Universe
-	if obj.Exported() {
-		scope = Unsafe.scope
-		// set Pkg field
-		switch obj := obj.(type) {
-		case *TypeName:
-			obj.pkg = Unsafe
-		case *Builtin:
-			obj.pkg = Unsafe
-		default:
-			unreachable()
-		}
-	}
-	if scope.Insert(obj) != nil {
-		panic("internal error: double declaration")
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/vcs/discovery.go b/vendor/golang.org/x/tools/go/vcs/discovery.go
new file mode 100644
index 0000000..f431dc1
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/vcs/discovery.go
@@ -0,0 +1,76 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vcs
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// charsetReader returns a reader for the given charset. Currently
+// it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful
+// error which is printed by go get, so the user can find why the package
+// wasn't downloaded if the encoding is not supported. Note that, in
+// order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters
+// greater than 0x7f are not rejected).
+func charsetReader(charset string, input io.Reader) (io.Reader, error) {
+	switch strings.ToLower(charset) {
+	case "ascii":
+		return input, nil
+	default:
+		return nil, fmt.Errorf("can't decode XML document using charset %q", charset)
+	}
+}
+
+// parseMetaGoImports returns meta imports from the HTML in r.
+// Parsing ends at the end of the <head> section or the beginning of the <body>.
+func parseMetaGoImports(r io.Reader) (imports []metaImport, err error) {
+	d := xml.NewDecoder(r)
+	d.CharsetReader = charsetReader
+	d.Strict = false
+	var t xml.Token
+	for {
+		t, err = d.Token()
+		if err != nil {
+			if err == io.EOF || len(imports) > 0 {
+				err = nil
+			}
+			return
+		}
+		if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
+			return
+		}
+		if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
+			return
+		}
+		e, ok := t.(xml.StartElement)
+		if !ok || !strings.EqualFold(e.Name.Local, "meta") {
+			continue
+		}
+		if attrValue(e.Attr, "name") != "go-import" {
+			continue
+		}
+		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
+			imports = append(imports, metaImport{
+				Prefix:   f[0],
+				VCS:      f[1],
+				RepoRoot: f[2],
+			})
+		}
+	}
+}
+
+// attrValue returns the attribute value for the case-insensitive key
+// `name', or the empty string if nothing is found.
+func attrValue(attrs []xml.Attr, name string) string {
+	for _, a := range attrs {
+		if strings.EqualFold(a.Name.Local, name) {
+			return a.Value
+		}
+	}
+	return ""
+}
diff --git a/vendor/golang.org/x/tools/go/vcs/env.go b/vendor/golang.org/x/tools/go/vcs/env.go
new file mode 100644
index 0000000..e846f5b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/vcs/env.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 vcs
+
+import (
+	"os"
+	"strings"
+)
+
+// envForDir returns a copy of the environment
+// suitable for running in the given directory.
+// The environment is the current process's environment
+// but with an updated $PWD, so that an os.Getwd in the
+// child will be faster.
+func envForDir(dir string) []string {
+	env := os.Environ()
+	// Internally we only use rooted paths, so dir is rooted.
+	// Even if dir is not rooted, no harm done.
+	return mergeEnvLists([]string{"PWD=" + dir}, env)
+}
+
+// mergeEnvLists merges the two environment lists such that
+// variables with the same name in "in" replace those in "out".
+func mergeEnvLists(in, out []string) []string {
+NextVar:
+	for _, inkv := range in {
+		k := strings.SplitAfterN(inkv, "=", 2)[0]
+		for i, outkv := range out {
+			if strings.HasPrefix(outkv, k) {
+				out[i] = inkv
+				continue NextVar
+			}
+		}
+		out = append(out, inkv)
+	}
+	return out
+}
diff --git a/vendor/golang.org/x/tools/go/vcs/http.go b/vendor/golang.org/x/tools/go/vcs/http.go
new file mode 100644
index 0000000..9618818
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/vcs/http.go
@@ -0,0 +1,80 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vcs
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+)
+
+// httpClient is the default HTTP client, but a variable so it can be
+// changed by tests, without modifying http.DefaultClient.
+var httpClient = http.DefaultClient
+
+// httpGET returns the data from an HTTP GET request for the given URL.
+func httpGET(url string) ([]byte, error) {
+	resp, err := httpClient.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("%s: %s", url, resp.Status)
+	}
+	b, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %v", url, err)
+	}
+	return b, nil
+}
+
+// httpsOrHTTP returns the body of either the importPath's
+// https resource or, if unavailable, the http resource.
+func httpsOrHTTP(importPath string) (urlStr string, body io.ReadCloser, err error) {
+	fetch := func(scheme string) (urlStr string, res *http.Response, err error) {
+		u, err := url.Parse(scheme + "://" + importPath)
+		if err != nil {
+			return "", nil, err
+		}
+		u.RawQuery = "go-get=1"
+		urlStr = u.String()
+		if Verbose {
+			log.Printf("Fetching %s", urlStr)
+		}
+		res, err = httpClient.Get(urlStr)
+		return
+	}
+	closeBody := func(res *http.Response) {
+		if res != nil {
+			res.Body.Close()
+		}
+	}
+	urlStr, res, err := fetch("https")
+	if err != nil || res.StatusCode != 200 {
+		if Verbose {
+			if err != nil {
+				log.Printf("https fetch failed.")
+			} else {
+				log.Printf("ignoring https fetch with status code %d", res.StatusCode)
+			}
+		}
+		closeBody(res)
+		urlStr, res, err = fetch("http")
+	}
+	if err != nil {
+		closeBody(res)
+		return "", nil, err
+	}
+	// Note: accepting a non-200 OK here, so people can serve a
+	// meta import in their http 404 page.
+	if Verbose {
+		log.Printf("Parsing meta tags from %s (status code %d)", urlStr, res.StatusCode)
+	}
+	return urlStr, res.Body, nil
+}
diff --git a/vendor/golang.org/x/tools/go/vcs/vcs.go b/vendor/golang.org/x/tools/go/vcs/vcs.go
new file mode 100644
index 0000000..89319be
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/vcs/vcs.go
@@ -0,0 +1,755 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package vcs exposes functions for resolving import paths
+// and using version control systems, which can be used to
+// implement behavior similar to the standard "go get" command.
+//
+// This package is a copy of internal code in package cmd/go/internal/get,
+// modified to make the identifiers exported. It's provided here
+// for developers who want to write tools with similar semantics.
+// It needs to be manually kept in sync with upstream when changes are
+// made to cmd/go/internal/get; see https://golang.org/issues/11490.
+//
+package vcs // import "golang.org/x/tools/go/vcs"
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// Verbose enables verbose operation logging.
+var Verbose bool
+
+// ShowCmd controls whether VCS commands are printed.
+var ShowCmd bool
+
+// A Cmd describes how to use a version control system
+// like Mercurial, Git, or Subversion.
+type Cmd struct {
+	Name string
+	Cmd  string // name of binary to invoke command
+
+	CreateCmd   string // command to download a fresh copy of a repository
+	DownloadCmd string // command to download updates into an existing repository
+
+	TagCmd         []TagCmd // commands to list tags
+	TagLookupCmd   []TagCmd // commands to lookup tags before running tagSyncCmd
+	TagSyncCmd     string   // command to sync to specific tag
+	TagSyncDefault string   // command to sync to default tag
+
+	LogCmd string // command to list repository changelogs in an XML format
+
+	Scheme  []string
+	PingCmd string
+}
+
+// A TagCmd describes a command to list available tags
+// that can be passed to Cmd.TagSyncCmd.
+type TagCmd struct {
+	Cmd     string // command to list tags
+	Pattern string // regexp to extract tags from list
+}
+
+// vcsList lists the known version control systems
+var vcsList = []*Cmd{
+	vcsHg,
+	vcsGit,
+	vcsSvn,
+	vcsBzr,
+}
+
+// ByCmd returns the version control system for the given
+// command name (hg, git, svn, bzr).
+func ByCmd(cmd string) *Cmd {
+	for _, vcs := range vcsList {
+		if vcs.Cmd == cmd {
+			return vcs
+		}
+	}
+	return nil
+}
+
+// vcsHg describes how to use Mercurial.
+var vcsHg = &Cmd{
+	Name: "Mercurial",
+	Cmd:  "hg",
+
+	CreateCmd:   "clone -U {repo} {dir}",
+	DownloadCmd: "pull",
+
+	// We allow both tag and branch names as 'tags'
+	// for selecting a version.  This lets people have
+	// a go.release.r60 branch and a go1 branch
+	// and make changes in both, without constantly
+	// editing .hgtags.
+	TagCmd: []TagCmd{
+		{"tags", `^(\S+)`},
+		{"branches", `^(\S+)`},
+	},
+	TagSyncCmd:     "update -r {tag}",
+	TagSyncDefault: "update default",
+
+	LogCmd: "log --encoding=utf-8 --limit={limit} --template={template}",
+
+	Scheme:  []string{"https", "http", "ssh"},
+	PingCmd: "identify {scheme}://{repo}",
+}
+
+// vcsGit describes how to use Git.
+var vcsGit = &Cmd{
+	Name: "Git",
+	Cmd:  "git",
+
+	CreateCmd:   "clone {repo} {dir}",
+	DownloadCmd: "pull --ff-only",
+
+	TagCmd: []TagCmd{
+		// tags/xxx matches a git tag named xxx
+		// origin/xxx matches a git branch named xxx on the default remote repository
+		{"show-ref", `(?:tags|origin)/(\S+)$`},
+	},
+	TagLookupCmd: []TagCmd{
+		{"show-ref tags/{tag} origin/{tag}", `((?:tags|origin)/\S+)$`},
+	},
+	TagSyncCmd:     "checkout {tag}",
+	TagSyncDefault: "checkout master",
+
+	Scheme:  []string{"git", "https", "http", "git+ssh"},
+	PingCmd: "ls-remote {scheme}://{repo}",
+}
+
+// vcsBzr describes how to use Bazaar.
+var vcsBzr = &Cmd{
+	Name: "Bazaar",
+	Cmd:  "bzr",
+
+	CreateCmd: "branch {repo} {dir}",
+
+	// Without --overwrite bzr will not pull tags that changed.
+	// Replace by --overwrite-tags after http://pad.lv/681792 goes in.
+	DownloadCmd: "pull --overwrite",
+
+	TagCmd:         []TagCmd{{"tags", `^(\S+)`}},
+	TagSyncCmd:     "update -r {tag}",
+	TagSyncDefault: "update -r revno:-1",
+
+	Scheme:  []string{"https", "http", "bzr", "bzr+ssh"},
+	PingCmd: "info {scheme}://{repo}",
+}
+
+// vcsSvn describes how to use Subversion.
+var vcsSvn = &Cmd{
+	Name: "Subversion",
+	Cmd:  "svn",
+
+	CreateCmd:   "checkout {repo} {dir}",
+	DownloadCmd: "update",
+
+	// There is no tag command in subversion.
+	// The branch information is all in the path names.
+
+	LogCmd: "log --xml --limit={limit}",
+
+	Scheme:  []string{"https", "http", "svn", "svn+ssh"},
+	PingCmd: "info {scheme}://{repo}",
+}
+
+func (v *Cmd) String() string {
+	return v.Name
+}
+
+// run runs the command line cmd in the given directory.
+// keyval is a list of key, value pairs.  run expands
+// instances of {key} in cmd into value, but only after
+// splitting cmd into individual arguments.
+// If an error occurs, run prints the command line and the
+// command's combined stdout+stderr to standard error.
+// Otherwise run discards the command's output.
+func (v *Cmd) run(dir string, cmd string, keyval ...string) error {
+	_, err := v.run1(dir, cmd, keyval, true)
+	return err
+}
+
+// runVerboseOnly is like run but only generates error output to standard error in verbose mode.
+func (v *Cmd) runVerboseOnly(dir string, cmd string, keyval ...string) error {
+	_, err := v.run1(dir, cmd, keyval, false)
+	return err
+}
+
+// runOutput is like run but returns the output of the command.
+func (v *Cmd) runOutput(dir string, cmd string, keyval ...string) ([]byte, error) {
+	return v.run1(dir, cmd, keyval, true)
+}
+
+// run1 is the generalized implementation of run and runOutput.
+func (v *Cmd) run1(dir string, cmdline string, keyval []string, verbose bool) ([]byte, error) {
+	m := make(map[string]string)
+	for i := 0; i < len(keyval); i += 2 {
+		m[keyval[i]] = keyval[i+1]
+	}
+	args := strings.Fields(cmdline)
+	for i, arg := range args {
+		args[i] = expand(m, arg)
+	}
+
+	_, err := exec.LookPath(v.Cmd)
+	if err != nil {
+		fmt.Fprintf(os.Stderr,
+			"go: missing %s command. See http://golang.org/s/gogetcmd\n",
+			v.Name)
+		return nil, err
+	}
+
+	cmd := exec.Command(v.Cmd, args...)
+	cmd.Dir = dir
+	cmd.Env = envForDir(cmd.Dir)
+	if ShowCmd {
+		fmt.Printf("cd %s\n", dir)
+		fmt.Printf("%s %s\n", v.Cmd, strings.Join(args, " "))
+	}
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+	err = cmd.Run()
+	out := buf.Bytes()
+	if err != nil {
+		if verbose || Verbose {
+			fmt.Fprintf(os.Stderr, "# cd %s; %s %s\n", dir, v.Cmd, strings.Join(args, " "))
+			os.Stderr.Write(out)
+		}
+		return nil, err
+	}
+	return out, nil
+}
+
+// Ping pings the repo to determine if scheme used is valid.
+// This repo must be pingable with this scheme and VCS.
+func (v *Cmd) Ping(scheme, repo string) error {
+	return v.runVerboseOnly(".", v.PingCmd, "scheme", scheme, "repo", repo)
+}
+
+// Create creates a new copy of repo in dir.
+// The parent of dir must exist; dir must not.
+func (v *Cmd) Create(dir, repo string) error {
+	return v.run(".", v.CreateCmd, "dir", dir, "repo", repo)
+}
+
+// CreateAtRev creates a new copy of repo in dir at revision rev.
+// The parent of dir must exist; dir must not.
+// rev must be a valid revision in repo.
+func (v *Cmd) CreateAtRev(dir, repo, rev string) error {
+	if err := v.Create(dir, repo); err != nil {
+		return err
+	}
+	return v.run(dir, v.TagSyncCmd, "tag", rev)
+}
+
+// Download downloads any new changes for the repo in dir.
+// dir must be a valid VCS repo compatible with v.
+func (v *Cmd) Download(dir string) error {
+	return v.run(dir, v.DownloadCmd)
+}
+
+// Tags returns the list of available tags for the repo in dir.
+// dir must be a valid VCS repo compatible with v.
+func (v *Cmd) Tags(dir string) ([]string, error) {
+	var tags []string
+	for _, tc := range v.TagCmd {
+		out, err := v.runOutput(dir, tc.Cmd)
+		if err != nil {
+			return nil, err
+		}
+		re := regexp.MustCompile(`(?m-s)` + tc.Pattern)
+		for _, m := range re.FindAllStringSubmatch(string(out), -1) {
+			tags = append(tags, m[1])
+		}
+	}
+	return tags, nil
+}
+
+// TagSync syncs the repo in dir to the named tag, which is either a
+// tag returned by Tags or the empty string (the default tag).
+// dir must be a valid VCS repo compatible with v and the tag must exist.
+func (v *Cmd) TagSync(dir, tag string) error {
+	if v.TagSyncCmd == "" {
+		return nil
+	}
+	if tag != "" {
+		for _, tc := range v.TagLookupCmd {
+			out, err := v.runOutput(dir, tc.Cmd, "tag", tag)
+			if err != nil {
+				return err
+			}
+			re := regexp.MustCompile(`(?m-s)` + tc.Pattern)
+			m := re.FindStringSubmatch(string(out))
+			if len(m) > 1 {
+				tag = m[1]
+				break
+			}
+		}
+	}
+	if tag == "" && v.TagSyncDefault != "" {
+		return v.run(dir, v.TagSyncDefault)
+	}
+	return v.run(dir, v.TagSyncCmd, "tag", tag)
+}
+
+// Log logs the changes for the repo in dir.
+// dir must be a valid VCS repo compatible with v.
+func (v *Cmd) Log(dir, logTemplate string) ([]byte, error) {
+	if err := v.Download(dir); err != nil {
+		return []byte{}, err
+	}
+
+	const N = 50 // how many revisions to grab
+	return v.runOutput(dir, v.LogCmd, "limit", strconv.Itoa(N), "template", logTemplate)
+}
+
+// LogAtRev logs the change for repo in dir at the rev revision.
+// dir must be a valid VCS repo compatible with v.
+// rev must be a valid revision for the repo in dir.
+func (v *Cmd) LogAtRev(dir, rev, logTemplate string) ([]byte, error) {
+	if err := v.Download(dir); err != nil {
+		return []byte{}, err
+	}
+
+	// Append revision flag to LogCmd.
+	logAtRevCmd := v.LogCmd + " --rev=" + rev
+	return v.runOutput(dir, logAtRevCmd, "limit", strconv.Itoa(1), "template", logTemplate)
+}
+
+// A vcsPath describes how to convert an import path into a
+// version control system and repository name.
+type vcsPath struct {
+	prefix string                              // prefix this description applies to
+	re     string                              // pattern for import path
+	repo   string                              // repository to use (expand with match of re)
+	vcs    string                              // version control system to use (expand with match of re)
+	check  func(match map[string]string) error // additional checks
+	ping   bool                                // ping for scheme to use to download repo
+
+	regexp *regexp.Regexp // cached compiled form of re
+}
+
+// FromDir inspects dir and its parents to determine the
+// version control system and code repository to use.
+// On return, root is the import path
+// corresponding to the root of the repository.
+func FromDir(dir, srcRoot string) (vcs *Cmd, root string, err error) {
+	// Clean and double-check that dir is in (a subdirectory of) srcRoot.
+	dir = filepath.Clean(dir)
+	srcRoot = filepath.Clean(srcRoot)
+	if len(dir) <= len(srcRoot) || dir[len(srcRoot)] != filepath.Separator {
+		return nil, "", fmt.Errorf("directory %q is outside source root %q", dir, srcRoot)
+	}
+
+	var vcsRet *Cmd
+	var rootRet string
+
+	origDir := dir
+	for len(dir) > len(srcRoot) {
+		for _, vcs := range vcsList {
+			if _, err := os.Stat(filepath.Join(dir, "."+vcs.Cmd)); err == nil {
+				root := filepath.ToSlash(dir[len(srcRoot)+1:])
+				// Record first VCS we find, but keep looking,
+				// to detect mistakes like one kind of VCS inside another.
+				if vcsRet == nil {
+					vcsRet = vcs
+					rootRet = root
+					continue
+				}
+				// Allow .git inside .git, which can arise due to submodules.
+				if vcsRet == vcs && vcs.Cmd == "git" {
+					continue
+				}
+				// Otherwise, we have one VCS inside a different VCS.
+				return nil, "", fmt.Errorf("directory %q uses %s, but parent %q uses %s",
+					filepath.Join(srcRoot, rootRet), vcsRet.Cmd, filepath.Join(srcRoot, root), vcs.Cmd)
+			}
+		}
+
+		// Move to parent.
+		ndir := filepath.Dir(dir)
+		if len(ndir) >= len(dir) {
+			// Shouldn't happen, but just in case, stop.
+			break
+		}
+		dir = ndir
+	}
+
+	if vcsRet != nil {
+		return vcsRet, rootRet, nil
+	}
+
+	return nil, "", fmt.Errorf("directory %q is not using a known version control system", origDir)
+}
+
+// RepoRoot represents a version control system, a repo, and a root of
+// where to put it on disk.
+type RepoRoot struct {
+	VCS *Cmd
+
+	// Repo is the repository URL, including scheme.
+	Repo string
+
+	// Root is the import path corresponding to the root of the
+	// repository.
+	Root string
+}
+
+// RepoRootForImportPath analyzes importPath to determine the
+// version control system, and code repository to use.
+func RepoRootForImportPath(importPath string, verbose bool) (*RepoRoot, error) {
+	rr, err := RepoRootForImportPathStatic(importPath, "")
+	if err == errUnknownSite {
+		rr, err = RepoRootForImportDynamic(importPath, verbose)
+
+		// RepoRootForImportDynamic returns error detail
+		// that is irrelevant if the user didn't intend to use a
+		// dynamic import in the first place.
+		// Squelch it.
+		if err != nil {
+			if Verbose {
+				log.Printf("import %q: %v", importPath, err)
+			}
+			err = fmt.Errorf("unrecognized import path %q", importPath)
+		}
+	}
+
+	if err == nil && strings.Contains(importPath, "...") && strings.Contains(rr.Root, "...") {
+		// Do not allow wildcards in the repo root.
+		rr = nil
+		err = fmt.Errorf("cannot expand ... in %q", importPath)
+	}
+	return rr, err
+}
+
+var errUnknownSite = errors.New("dynamic lookup required to find mapping")
+
+// RepoRootForImportPathStatic attempts to map importPath to a
+// RepoRoot using the commonly-used VCS hosting sites in vcsPaths
+// (github.com/user/dir), or from a fully-qualified importPath already
+// containing its VCS type (foo.com/repo.git/dir)
+//
+// If scheme is non-empty, that scheme is forced.
+func RepoRootForImportPathStatic(importPath, scheme string) (*RepoRoot, error) {
+	if strings.Contains(importPath, "://") {
+		return nil, fmt.Errorf("invalid import path %q", importPath)
+	}
+	for _, srv := range vcsPaths {
+		if !strings.HasPrefix(importPath, srv.prefix) {
+			continue
+		}
+		m := srv.regexp.FindStringSubmatch(importPath)
+		if m == nil {
+			if srv.prefix != "" {
+				return nil, fmt.Errorf("invalid %s import path %q", srv.prefix, importPath)
+			}
+			continue
+		}
+
+		// Build map of named subexpression matches for expand.
+		match := map[string]string{
+			"prefix": srv.prefix,
+			"import": importPath,
+		}
+		for i, name := range srv.regexp.SubexpNames() {
+			if name != "" && match[name] == "" {
+				match[name] = m[i]
+			}
+		}
+		if srv.vcs != "" {
+			match["vcs"] = expand(match, srv.vcs)
+		}
+		if srv.repo != "" {
+			match["repo"] = expand(match, srv.repo)
+		}
+		if srv.check != nil {
+			if err := srv.check(match); err != nil {
+				return nil, err
+			}
+		}
+		vcs := ByCmd(match["vcs"])
+		if vcs == nil {
+			return nil, fmt.Errorf("unknown version control system %q", match["vcs"])
+		}
+		if srv.ping {
+			if scheme != "" {
+				match["repo"] = scheme + "://" + match["repo"]
+			} else {
+				for _, scheme := range vcs.Scheme {
+					if vcs.Ping(scheme, match["repo"]) == nil {
+						match["repo"] = scheme + "://" + match["repo"]
+						break
+					}
+				}
+			}
+		}
+		rr := &RepoRoot{
+			VCS:  vcs,
+			Repo: match["repo"],
+			Root: match["root"],
+		}
+		return rr, nil
+	}
+	return nil, errUnknownSite
+}
+
+// RepoRootForImportDynamic finds a *RepoRoot for a custom domain that's not
+// statically known by RepoRootForImportPathStatic.
+//
+// This handles custom import paths like "name.tld/pkg/foo" or just "name.tld".
+func RepoRootForImportDynamic(importPath string, verbose bool) (*RepoRoot, error) {
+	slash := strings.Index(importPath, "/")
+	if slash < 0 {
+		slash = len(importPath)
+	}
+	host := importPath[:slash]
+	if !strings.Contains(host, ".") {
+		return nil, errors.New("import path doesn't contain a hostname")
+	}
+	urlStr, body, err := httpsOrHTTP(importPath)
+	if err != nil {
+		return nil, fmt.Errorf("http/https fetch: %v", err)
+	}
+	defer body.Close()
+	imports, err := parseMetaGoImports(body)
+	if err != nil {
+		return nil, fmt.Errorf("parsing %s: %v", importPath, err)
+	}
+	metaImport, err := matchGoImport(imports, importPath)
+	if err != nil {
+		if err != errNoMatch {
+			return nil, fmt.Errorf("parse %s: %v", urlStr, err)
+		}
+		return nil, fmt.Errorf("parse %s: no go-import meta tags", urlStr)
+	}
+	if verbose {
+		log.Printf("get %q: found meta tag %#v at %s", importPath, metaImport, urlStr)
+	}
+	// If the import was "uni.edu/bob/project", which said the
+	// prefix was "uni.edu" and the RepoRoot was "evilroot.com",
+	// make sure we don't trust Bob and check out evilroot.com to
+	// "uni.edu" yet (possibly overwriting/preempting another
+	// non-evil student).  Instead, first verify the root and see
+	// if it matches Bob's claim.
+	if metaImport.Prefix != importPath {
+		if verbose {
+			log.Printf("get %q: verifying non-authoritative meta tag", importPath)
+		}
+		urlStr0 := urlStr
+		urlStr, body, err = httpsOrHTTP(metaImport.Prefix)
+		if err != nil {
+			return nil, fmt.Errorf("fetch %s: %v", urlStr, err)
+		}
+		imports, err := parseMetaGoImports(body)
+		if err != nil {
+			return nil, fmt.Errorf("parsing %s: %v", importPath, err)
+		}
+		if len(imports) == 0 {
+			return nil, fmt.Errorf("fetch %s: no go-import meta tag", urlStr)
+		}
+		metaImport2, err := matchGoImport(imports, importPath)
+		if err != nil || metaImport != metaImport2 {
+			return nil, fmt.Errorf("%s and %s disagree about go-import for %s", urlStr0, urlStr, metaImport.Prefix)
+		}
+	}
+
+	if err := validateRepoRoot(metaImport.RepoRoot); err != nil {
+		return nil, fmt.Errorf("%s: invalid repo root %q: %v", urlStr, metaImport.RepoRoot, err)
+	}
+	rr := &RepoRoot{
+		VCS:  ByCmd(metaImport.VCS),
+		Repo: metaImport.RepoRoot,
+		Root: metaImport.Prefix,
+	}
+	if rr.VCS == nil {
+		return nil, fmt.Errorf("%s: unknown vcs %q", urlStr, metaImport.VCS)
+	}
+	return rr, nil
+}
+
+// validateRepoRoot returns an error if repoRoot does not seem to be
+// a valid URL with scheme.
+func validateRepoRoot(repoRoot string) error {
+	url, err := url.Parse(repoRoot)
+	if err != nil {
+		return err
+	}
+	if url.Scheme == "" {
+		return errors.New("no scheme")
+	}
+	return nil
+}
+
+// metaImport represents the parsed <meta name="go-import"
+// content="prefix vcs reporoot" /> tags from HTML files.
+type metaImport struct {
+	Prefix, VCS, RepoRoot string
+}
+
+// errNoMatch is returned from matchGoImport when there's no applicable match.
+var errNoMatch = errors.New("no import match")
+
+// matchGoImport returns the metaImport from imports matching importPath.
+// An error is returned if there are multiple matches.
+// errNoMatch is returned if none match.
+func matchGoImport(imports []metaImport, importPath string) (_ metaImport, err error) {
+	match := -1
+	for i, im := range imports {
+		if !strings.HasPrefix(importPath, im.Prefix) {
+			continue
+		}
+		if match != -1 {
+			err = fmt.Errorf("multiple meta tags match import path %q", importPath)
+			return
+		}
+		match = i
+	}
+	if match == -1 {
+		err = errNoMatch
+		return
+	}
+	return imports[match], nil
+}
+
+// expand rewrites s to replace {k} with match[k] for each key k in match.
+func expand(match map[string]string, s string) string {
+	for k, v := range match {
+		s = strings.Replace(s, "{"+k+"}", v, -1)
+	}
+	return s
+}
+
+// vcsPaths lists the known vcs paths.
+var vcsPaths = []*vcsPath{
+	// go.googlesource.com
+	{
+		prefix: "go.googlesource.com",
+		re:     `^(?P<root>go\.googlesource\.com/[A-Za-z0-9_.\-]+/?)$`,
+		vcs:    "git",
+		repo:   "https://{root}",
+		check:  noVCSSuffix,
+	},
+
+	// Github
+	{
+		prefix: "github.com/",
+		re:     `^(?P<root>github\.com/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(/[\p{L}0-9_.\-]+)*$`,
+		vcs:    "git",
+		repo:   "https://{root}",
+		check:  noVCSSuffix,
+	},
+
+	// Bitbucket
+	{
+		prefix: "bitbucket.org/",
+		re:     `^(?P<root>bitbucket\.org/(?P<bitname>[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`,
+		repo:   "https://{root}",
+		check:  bitbucketVCS,
+	},
+
+	// Launchpad
+	{
+		prefix: "launchpad.net/",
+		re:     `^(?P<root>launchpad\.net/((?P<project>[A-Za-z0-9_.\-]+)(?P<series>/[A-Za-z0-9_.\-]+)?|~[A-Za-z0-9_.\-]+/(\+junk|[A-Za-z0-9_.\-]+)/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`,
+		vcs:    "bzr",
+		repo:   "https://{root}",
+		check:  launchpadVCS,
+	},
+
+	// Git at OpenStack
+	{
+		prefix: "git.openstack.org",
+		re:     `^(?P<root>git\.openstack\.org/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(\.git)?(/[A-Za-z0-9_.\-]+)*$`,
+		vcs:    "git",
+		repo:   "https://{root}",
+		check:  noVCSSuffix,
+	},
+
+	// General syntax for any server.
+	{
+		re:   `^(?P<root>(?P<repo>([a-z0-9.\-]+\.)+[a-z0-9.\-]+(:[0-9]+)?/[A-Za-z0-9_.\-/]*?)\.(?P<vcs>bzr|git|hg|svn))(/[A-Za-z0-9_.\-]+)*$`,
+		ping: true,
+	},
+}
+
+func init() {
+	// fill in cached regexps.
+	// Doing this eagerly discovers invalid regexp syntax
+	// without having to run a command that needs that regexp.
+	for _, srv := range vcsPaths {
+		srv.regexp = regexp.MustCompile(srv.re)
+	}
+}
+
+// noVCSSuffix checks that the repository name does not
+// end in .foo for any version control system foo.
+// The usual culprit is ".git".
+func noVCSSuffix(match map[string]string) error {
+	repo := match["repo"]
+	for _, vcs := range vcsList {
+		if strings.HasSuffix(repo, "."+vcs.Cmd) {
+			return fmt.Errorf("invalid version control suffix in %s path", match["prefix"])
+		}
+	}
+	return nil
+}
+
+// bitbucketVCS determines the version control system for a
+// Bitbucket repository, by using the Bitbucket API.
+func bitbucketVCS(match map[string]string) error {
+	if err := noVCSSuffix(match); err != nil {
+		return err
+	}
+
+	var resp struct {
+		SCM string `json:"scm"`
+	}
+	url := expand(match, "https://api.bitbucket.org/1.0/repositories/{bitname}")
+	data, err := httpGET(url)
+	if err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &resp); err != nil {
+		return fmt.Errorf("decoding %s: %v", url, err)
+	}
+
+	if ByCmd(resp.SCM) != nil {
+		match["vcs"] = resp.SCM
+		if resp.SCM == "git" {
+			match["repo"] += ".git"
+		}
+		return nil
+	}
+
+	return fmt.Errorf("unable to detect version control system for bitbucket.org/ path")
+}
+
+// launchpadVCS solves the ambiguity for "lp.net/project/foo". In this case,
+// "foo" could be a series name registered in Launchpad with its own branch,
+// and it could also be the name of a directory within the main project
+// branch one level up.
+func launchpadVCS(match map[string]string) error {
+	if match["project"] == "" || match["series"] == "" {
+		return nil
+	}
+	_, err := httpGET(expand(match, "https://code.launchpad.net/{project}{series}/.bzr/branch-format"))
+	if err != nil {
+		match["root"] = expand(match, "launchpad.net/{project}")
+		match["repo"] = expand(match, "https://{root}")
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/go/vcs/vcs_test.go b/vendor/golang.org/x/tools/go/vcs/vcs_test.go
new file mode 100644
index 0000000..ee422e8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/vcs/vcs_test.go
@@ -0,0 +1,186 @@
+// 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 vcs
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Test that RepoRootForImportPath creates the correct RepoRoot for a given importPath.
+// TODO(cmang): Add tests for SVN and BZR.
+func TestRepoRootForImportPath(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skipf("incomplete source tree on %s", runtime.GOOS)
+	}
+
+	tests := []struct {
+		path string
+		want *RepoRoot
+	}{
+		{
+			"github.com/golang/groupcache",
+			&RepoRoot{
+				VCS:  vcsGit,
+				Repo: "https://github.com/golang/groupcache",
+			},
+		},
+		// Unicode letters in directories (issue 18660).
+		{
+			"github.com/user/unicode/испытание",
+			&RepoRoot{
+				VCS:  vcsGit,
+				Repo: "https://github.com/user/unicode",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		got, err := RepoRootForImportPath(test.path, false)
+		if err != nil {
+			t.Errorf("RepoRootForImportPath(%q): %v", test.path, err)
+			continue
+		}
+		want := test.want
+		if got.VCS.Name != want.VCS.Name || got.Repo != want.Repo {
+			t.Errorf("RepoRootForImportPath(%q) = VCS(%s) Repo(%s), want VCS(%s) Repo(%s)", test.path, got.VCS, got.Repo, want.VCS, want.Repo)
+		}
+	}
+}
+
+// Test that FromDir correctly inspects a given directory and returns the right VCS and root.
+func TestFromDir(t *testing.T) {
+	tempDir, err := ioutil.TempDir("", "vcstest")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	for j, vcs := range vcsList {
+		dir := filepath.Join(tempDir, "example.com", vcs.Name, "."+vcs.Cmd)
+		if j&1 == 0 {
+			err := os.MkdirAll(dir, 0755)
+			if err != nil {
+				t.Fatal(err)
+			}
+		} else {
+			err := os.MkdirAll(filepath.Dir(dir), 0755)
+			if err != nil {
+				t.Fatal(err)
+			}
+			f, err := os.Create(dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			f.Close()
+		}
+
+		want := RepoRoot{
+			VCS:  vcs,
+			Root: path.Join("example.com", vcs.Name),
+		}
+		var got RepoRoot
+		got.VCS, got.Root, err = FromDir(dir, tempDir)
+		if err != nil {
+			t.Errorf("FromDir(%q, %q): %v", dir, tempDir, err)
+			continue
+		}
+		if got.VCS.Name != want.VCS.Name || got.Root != want.Root {
+			t.Errorf("FromDir(%q, %q) = VCS(%s) Root(%s), want VCS(%s) Root(%s)", dir, tempDir, got.VCS, got.Root, want.VCS, want.Root)
+		}
+	}
+}
+
+var parseMetaGoImportsTests = []struct {
+	in  string
+	out []metaImport
+}{
+	{
+		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+	},
+	{
+		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
+		<meta name="go-import" content="baz/quux git http://github.com/rsc/baz/quux">`,
+		[]metaImport{
+			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
+			{"baz/quux", "git", "http://github.com/rsc/baz/quux"},
+		},
+	},
+	{
+		`<head>
+		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
+		</head>`,
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+	},
+	{
+		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
+		<body>`,
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+	},
+}
+
+func TestParseMetaGoImports(t *testing.T) {
+	for i, tt := range parseMetaGoImportsTests {
+		out, err := parseMetaGoImports(strings.NewReader(tt.in))
+		if err != nil {
+			t.Errorf("test#%d: %v", i, err)
+			continue
+		}
+		if !reflect.DeepEqual(out, tt.out) {
+			t.Errorf("test#%d:\n\thave %q\n\twant %q", i, out, tt.out)
+		}
+	}
+}
+
+func TestValidateRepoRoot(t *testing.T) {
+	tests := []struct {
+		root string
+		ok   bool
+	}{
+		{
+			root: "",
+			ok:   false,
+		},
+		{
+			root: "http://",
+			ok:   true,
+		},
+		{
+			root: "git+ssh://",
+			ok:   true,
+		},
+		{
+			root: "http#://",
+			ok:   false,
+		},
+		{
+			root: "-config",
+			ok:   false,
+		},
+		{
+			root: "-config://",
+			ok:   false,
+		},
+	}
+
+	for _, test := range tests {
+		err := validateRepoRoot(test.root)
+		ok := err == nil
+		if ok != test.ok {
+			want := "error"
+			if test.ok {
+				want = "nil"
+			}
+			t.Errorf("validateRepoRoot(%q) = %q, want %s", test.root, err, want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/README.md b/vendor/golang.org/x/tools/godoc/README.md
new file mode 100644
index 0000000..52bc8a4
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/README.md
@@ -0,0 +1,31 @@
+# godoc
+
+This directory contains most of the code for running a godoc server. The
+executable lives at golang.org/x/tools/cmd/godoc.
+
+## Development mode
+
+In production, CSS/JS/template assets need to be compiled into the godoc
+binary. It can be tedious to recompile assets every time, but you can pass a
+flag to load CSS/JS/templates from disk every time a page loads:
+
+```
+godoc -templates=$GOPATH/src/golang.org/x/tools/godoc/static -http=:6060
+```
+
+## Recompiling static assets
+
+The files that live at `static/style.css`, `static/jquery.js` and so on are not
+present in the final binary. They are placed into `static/static.go` by running
+`go generate`. So to compile a change and test it in your browser:
+
+1) Make changes to e.g. `static/style.css`.
+
+2) Run `go generate golang.org/x/tools/godoc/static` so `static/static.go` picks
+up the change.
+
+3) Run `go install golang.org/x/tools/cmd/godoc` so the compiled `godoc` binary
+picks up the change.
+
+4) Run `godoc -http=:6060` and view your changes in the browser. You may need
+to disable your browser's cache to avoid reloading a stale file.
diff --git a/vendor/golang.org/x/tools/godoc/analysis/README b/vendor/golang.org/x/tools/godoc/analysis/README
new file mode 100644
index 0000000..5b29a32
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/README
@@ -0,0 +1,111 @@
+
+Type and Pointer Analysis to-do list
+====================================
+
+Alan Donovan <adonovan@google.com>
+
+
+Overall design
+--------------
+
+We should re-run the type and pointer analyses periodically,
+as we do with the indexer.
+
+Version skew: how to mitigate the bad effects of stale URLs in old pages?
+We could record the file's length/CRC32/mtime in the go/loader, and
+refuse to decorate it with links unless they match at serving time.
+
+Use the VFS mechanism when (a) enumerating packages and (b) loading
+them.  (Requires planned changes to go/loader.)
+
+Future work: shard this using map/reduce for larger corpora.
+
+Testing: how does one test that a web page "looks right"?
+
+
+Bugs
+----
+
+(*ssa.Program).Create requires transitively error-free packages.  We
+can make this more robust by making the requirement transitively free
+of "hard" errors; soft errors are fine.
+
+Markup of compiler errors is slightly buggy because they overlap with
+other selections (e.g. Idents).  Fix.
+
+
+User Interface
+--------------
+
+CALLGRAPH:
+- Add a search box: given a search node, expand path from each entry
+  point to it.
+- Cause hovering over a given node to highlight that node, and all
+  nodes that are logically identical to it.
+- Initially expand the callgraph trees (but not their toggle divs).
+
+CALLEES:
+- The '(' links are not very discoverable.  Highlight them?
+
+Type info:
+- In the source viewer's lower pane, use a toggle div around the
+  IMPLEMENTS and METHODSETS lists, like we do in the pacakge view.
+  Only expand them initially if short.
+- Include IMPLEMENTS and METHOD SETS information in search index.
+- URLs in IMPLEMENTS/METHOD SETS always link to source, even from the
+  package docs view.  This makes sense for links to non-exported
+  types, but links to exported types and funcs should probably go to
+  other package docs.
+- Suppress toggle divs for empty method sets.
+
+Misc:
+- The [X] button in the lower pane is subject to scrolling.
+- Should the lower pane be floating?  An iframe?
+  When we change document.location by clicking on a link, it will go away.
+  How do we prevent that (a la Gmail's chat windows)?
+- Progress/status: for each file, display its analysis status, one of:
+   - not in analysis scope
+   - type analysis running...
+   - type analysis complete
+     (+ optionally: there were type errors in this file)
+   And if PTA requested:
+   - type analysis complete; PTA not attempted due to type errors
+   - PTA running...
+   - PTA complete
+- Scroll the selection into view, e.g. the vertical center, or better
+  still, under the pointer (assuming we have a mouse).
+
+
+More features
+-------------
+
+Display the REFERRERS relation?  (Useful but potentially large.)
+
+Display the INSTANTIATIONS relation? i.e. given a type T, show the set of
+syntactic constructs that can instantiate it:
+    var x T
+    x := T{...}
+    x = new(T)
+    x = make([]T, n)
+    etc
+    + all INSTANTIATIONS of all S defined as struct{t T} or [n]T
+(Potentially a lot of information.)
+(Add this to guru too.)
+
+
+Optimisations
+-------------
+
+Each call to addLink takes a (per-file) lock.  The locking is
+fine-grained so server latency isn't terrible, but overall it makes
+the link computation quite slow.  Batch update might be better.
+
+Memory usage is now about 1.5GB for GOROOT + go.tools.  It used to be 700MB.
+
+Optimize for time and space.  The main slowdown is the network I/O
+time caused by an increase in page size of about 3x: about 2x from
+HTML, and 0.7--2.1x from JSON (unindented vs indented).  The JSON
+contains a lot of filenames (e.g. 820 copies of 16 distinct
+filenames).  20% of the HTML is L%d spans (now disabled).  The HTML
+also contains lots of tooltips for long struct/interface types.
+De-dup or just abbreviate?  The actual formatting is very fast.
diff --git a/vendor/golang.org/x/tools/godoc/analysis/analysis.go b/vendor/golang.org/x/tools/godoc/analysis/analysis.go
new file mode 100644
index 0000000..b79286c
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/analysis.go
@@ -0,0 +1,613 @@
+// 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 analysis performs type and pointer analysis
+// and generates mark-up for the Go source view.
+//
+// The Run method populates a Result object by running type and
+// (optionally) pointer analysis.  The Result object is thread-safe
+// and at all times may be accessed by a serving thread, even as it is
+// progressively populated as analysis facts are derived.
+//
+// The Result is a mapping from each godoc file URL
+// (e.g. /src/fmt/print.go) to information about that file.  The
+// information is a list of HTML markup links and a JSON array of
+// structured data values.  Some of the links call client-side
+// JavaScript functions that index this array.
+//
+// The analysis computes mark-up for the following relations:
+//
+// IMPORTS: for each ast.ImportSpec, the package that it denotes.
+//
+// RESOLUTION: for each ast.Ident, its kind and type, and the location
+// of its definition.
+//
+// METHOD SETS, IMPLEMENTS: for each ast.Ident defining a named type,
+// its method-set, the set of interfaces it implements or is
+// implemented by, and its size/align values.
+//
+// CALLERS, CALLEES: for each function declaration ('func' token), its
+// callers, and for each call-site ('(' token), its callees.
+//
+// CALLGRAPH: the package docs include an interactive viewer for the
+// intra-package call graph of "fmt".
+//
+// CHANNEL PEERS: for each channel operation make/<-/close, the set of
+// other channel ops that alias the same channel(s).
+//
+// ERRORS: for each locus of a frontend (scanner/parser/type) error, the
+// location is highlighted in red and hover text provides the compiler
+// error message.
+//
+package analysis // import "golang.org/x/tools/godoc/analysis"
+
+import (
+	"fmt"
+	"go/build"
+	"go/scanner"
+	"go/token"
+	"go/types"
+	"html"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+
+	"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"
+)
+
+// -- links ------------------------------------------------------------
+
+// A Link is an HTML decoration of the bytes [Start, End) of a file.
+// Write is called before/after those bytes to emit the mark-up.
+type Link interface {
+	Start() int
+	End() int
+	Write(w io.Writer, _ int, start bool) // the godoc.LinkWriter signature
+}
+
+// An <a> element.
+type aLink struct {
+	start, end int    // =godoc.Segment
+	title      string // hover text
+	onclick    string // JS code (NB: trusted)
+	href       string // URL     (NB: trusted)
+}
+
+func (a aLink) Start() int { return a.start }
+func (a aLink) End() int   { return a.end }
+func (a aLink) Write(w io.Writer, _ int, start bool) {
+	if start {
+		fmt.Fprintf(w, `<a title='%s'`, html.EscapeString(a.title))
+		if a.onclick != "" {
+			fmt.Fprintf(w, ` onclick='%s'`, html.EscapeString(a.onclick))
+		}
+		if a.href != "" {
+			// TODO(adonovan): I think that in principle, a.href must first be
+			// url.QueryEscape'd, but if I do that, a leading slash becomes "%2F",
+			// which causes the browser to treat the path as relative, not absolute.
+			// WTF?
+			fmt.Fprintf(w, ` href='%s'`, html.EscapeString(a.href))
+		}
+		fmt.Fprintf(w, ">")
+	} else {
+		fmt.Fprintf(w, "</a>")
+	}
+}
+
+// An <a class='error'> element.
+type errorLink struct {
+	start int
+	msg   string
+}
+
+func (e errorLink) Start() int { return e.start }
+func (e errorLink) End() int   { return e.start + 1 }
+
+func (e errorLink) Write(w io.Writer, _ int, start bool) {
+	// <span> causes havoc, not sure why, so use <a>.
+	if start {
+		fmt.Fprintf(w, `<a class='error' title='%s'>`, html.EscapeString(e.msg))
+	} else {
+		fmt.Fprintf(w, "</a>")
+	}
+}
+
+// -- fileInfo ---------------------------------------------------------
+
+// FileInfo holds analysis information for the source file view.
+// Clients must not mutate it.
+type FileInfo struct {
+	Data  []interface{} // JSON serializable values
+	Links []Link        // HTML link markup
+}
+
+// A fileInfo is the server's store of hyperlinks and JSON data for a
+// particular file.
+type fileInfo struct {
+	mu        sync.Mutex
+	data      []interface{} // JSON objects
+	links     []Link
+	sorted    bool
+	hasErrors bool // TODO(adonovan): surface this in the UI
+}
+
+// addLink adds a link to the Go source file fi.
+func (fi *fileInfo) addLink(link Link) {
+	fi.mu.Lock()
+	fi.links = append(fi.links, link)
+	fi.sorted = false
+	if _, ok := link.(errorLink); ok {
+		fi.hasErrors = true
+	}
+	fi.mu.Unlock()
+}
+
+// addData adds the structured value x to the JSON data for the Go
+// source file fi.  Its index is returned.
+func (fi *fileInfo) addData(x interface{}) int {
+	fi.mu.Lock()
+	index := len(fi.data)
+	fi.data = append(fi.data, x)
+	fi.mu.Unlock()
+	return index
+}
+
+// get returns the file info in external form.
+// Callers must not mutate its fields.
+func (fi *fileInfo) get() FileInfo {
+	var r FileInfo
+	// Copy slices, to avoid races.
+	fi.mu.Lock()
+	r.Data = append(r.Data, fi.data...)
+	if !fi.sorted {
+		sort.Sort(linksByStart(fi.links))
+		fi.sorted = true
+	}
+	r.Links = append(r.Links, fi.links...)
+	fi.mu.Unlock()
+	return r
+}
+
+// PackageInfo holds analysis information for the package view.
+// Clients must not mutate it.
+type PackageInfo struct {
+	CallGraph      []*PCGNodeJSON
+	CallGraphIndex map[string]int
+	Types          []*TypeInfoJSON
+}
+
+type pkgInfo struct {
+	mu             sync.Mutex
+	callGraph      []*PCGNodeJSON
+	callGraphIndex map[string]int  // keys are (*ssa.Function).RelString()
+	types          []*TypeInfoJSON // type info for exported types
+}
+
+func (pi *pkgInfo) setCallGraph(callGraph []*PCGNodeJSON, callGraphIndex map[string]int) {
+	pi.mu.Lock()
+	pi.callGraph = callGraph
+	pi.callGraphIndex = callGraphIndex
+	pi.mu.Unlock()
+}
+
+func (pi *pkgInfo) addType(t *TypeInfoJSON) {
+	pi.mu.Lock()
+	pi.types = append(pi.types, t)
+	pi.mu.Unlock()
+}
+
+// get returns the package info in external form.
+// Callers must not mutate its fields.
+func (pi *pkgInfo) get() PackageInfo {
+	var r PackageInfo
+	// Copy slices, to avoid races.
+	pi.mu.Lock()
+	r.CallGraph = append(r.CallGraph, pi.callGraph...)
+	r.CallGraphIndex = pi.callGraphIndex
+	r.Types = append(r.Types, pi.types...)
+	pi.mu.Unlock()
+	return r
+}
+
+// -- Result -----------------------------------------------------------
+
+// Result contains the results of analysis.
+// The result contains a mapping from filenames to a set of HTML links
+// and JavaScript data referenced by the links.
+type Result struct {
+	mu        sync.Mutex           // guards maps (but not their contents)
+	status    string               // global analysis status
+	fileInfos map[string]*fileInfo // keys are godoc file URLs
+	pkgInfos  map[string]*pkgInfo  // keys are import paths
+}
+
+// fileInfo returns the fileInfo for the specified godoc file URL,
+// constructing it as needed.  Thread-safe.
+func (res *Result) fileInfo(url string) *fileInfo {
+	res.mu.Lock()
+	fi, ok := res.fileInfos[url]
+	if !ok {
+		if res.fileInfos == nil {
+			res.fileInfos = make(map[string]*fileInfo)
+		}
+		fi = new(fileInfo)
+		res.fileInfos[url] = fi
+	}
+	res.mu.Unlock()
+	return fi
+}
+
+// Status returns a human-readable description of the current analysis status.
+func (res *Result) Status() string {
+	res.mu.Lock()
+	defer res.mu.Unlock()
+	return res.status
+}
+
+func (res *Result) setStatusf(format string, args ...interface{}) {
+	res.mu.Lock()
+	res.status = fmt.Sprintf(format, args...)
+	log.Printf(format, args...)
+	res.mu.Unlock()
+}
+
+// FileInfo returns new slices containing opaque JSON values and the
+// HTML link markup for the specified godoc file URL.  Thread-safe.
+// Callers must not mutate the elements.
+// It returns "zero" if no data is available.
+//
+func (res *Result) FileInfo(url string) (fi FileInfo) {
+	return res.fileInfo(url).get()
+}
+
+// pkgInfo returns the pkgInfo for the specified import path,
+// constructing it as needed.  Thread-safe.
+func (res *Result) pkgInfo(importPath string) *pkgInfo {
+	res.mu.Lock()
+	pi, ok := res.pkgInfos[importPath]
+	if !ok {
+		if res.pkgInfos == nil {
+			res.pkgInfos = make(map[string]*pkgInfo)
+		}
+		pi = new(pkgInfo)
+		res.pkgInfos[importPath] = pi
+	}
+	res.mu.Unlock()
+	return pi
+}
+
+// PackageInfo returns new slices of JSON values for the callgraph and
+// type info for the specified package.  Thread-safe.
+// Callers must not mutate its fields.
+// PackageInfo returns "zero" if no data is available.
+//
+func (res *Result) PackageInfo(importPath string) PackageInfo {
+	return res.pkgInfo(importPath).get()
+}
+
+// -- analysis ---------------------------------------------------------
+
+type analysis struct {
+	result    *Result
+	prog      *ssa.Program
+	ops       []chanOp       // all channel ops in program
+	allNamed  []*types.Named // all "defined" (formerly "named") types in the program
+	ptaConfig pointer.Config
+	path2url  map[string]string // maps openable path to godoc file URL (/src/fmt/print.go)
+	pcgs      map[*ssa.Package]*packageCallGraph
+}
+
+// fileAndOffset returns the file and offset for a given pos.
+func (a *analysis) fileAndOffset(pos token.Pos) (fi *fileInfo, offset int) {
+	return a.fileAndOffsetPosn(a.prog.Fset.Position(pos))
+}
+
+// fileAndOffsetPosn returns the file and offset for a given position.
+func (a *analysis) fileAndOffsetPosn(posn token.Position) (fi *fileInfo, offset int) {
+	url := a.path2url[posn.Filename]
+	return a.result.fileInfo(url), posn.Offset
+}
+
+// posURL returns the URL of the source extent [pos, pos+len).
+func (a *analysis) posURL(pos token.Pos, len int) string {
+	if pos == token.NoPos {
+		return ""
+	}
+	posn := a.prog.Fset.Position(pos)
+	url := a.path2url[posn.Filename]
+	return fmt.Sprintf("%s?s=%d:%d#L%d",
+		url, posn.Offset, posn.Offset+len, posn.Line)
+}
+
+// ----------------------------------------------------------------------
+
+// Run runs program analysis and computes the resulting markup,
+// populating *result in a thread-safe manner, first with type
+// information then later with pointer analysis information if
+// enabled by the pta flag.
+//
+func Run(pta bool, result *Result) {
+	conf := loader.Config{
+		AllowErrors: true,
+	}
+
+	// Silence the default error handler.
+	// Don't print all errors; we'll report just
+	// one per errant package later.
+	conf.TypeChecker.Error = func(e error) {}
+
+	var roots, args []string // roots[i] ends with os.PathSeparator
+
+	// Enumerate packages in $GOROOT.
+	root := filepath.Join(build.Default.GOROOT, "src") + string(os.PathSeparator)
+	roots = append(roots, root)
+	args = allPackages(root)
+	log.Printf("GOROOT=%s: %s\n", root, args)
+
+	// Enumerate packages in $GOPATH.
+	for i, dir := range filepath.SplitList(build.Default.GOPATH) {
+		root := filepath.Join(dir, "src") + string(os.PathSeparator)
+		roots = append(roots, root)
+		pkgs := allPackages(root)
+		log.Printf("GOPATH[%d]=%s: %s\n", i, root, pkgs)
+		args = append(args, pkgs...)
+	}
+
+	// Uncomment to make startup quicker during debugging.
+	//args = []string{"golang.org/x/tools/cmd/godoc"}
+	//args = []string{"fmt"}
+
+	if _, err := conf.FromArgs(args, true); err != nil {
+		// TODO(adonovan): degrade gracefully, not fail totally.
+		// (The crippling case is a parse error in an external test file.)
+		result.setStatusf("Analysis failed: %s.", err) // import error
+		return
+	}
+
+	result.setStatusf("Loading and type-checking packages...")
+	iprog, err := conf.Load()
+	if iprog != nil {
+		// Report only the first error of each package.
+		for _, info := range iprog.AllPackages {
+			for _, err := range info.Errors {
+				fmt.Fprintln(os.Stderr, err)
+				break
+			}
+		}
+		log.Printf("Loaded %d packages.", len(iprog.AllPackages))
+	}
+	if err != nil {
+		result.setStatusf("Loading failed: %s.\n", err)
+		return
+	}
+
+	// Create SSA-form program representation.
+	// Only the transitively error-free packages are used.
+	prog := ssautil.CreateProgram(iprog, ssa.GlobalDebug)
+
+	// Create a "testmain" package for each package with tests.
+	for _, pkg := range prog.AllPackages() {
+		if testmain := prog.CreateTestMainPackage(pkg); testmain != nil {
+			log.Printf("Adding tests for %s", pkg.Pkg.Path())
+		}
+	}
+
+	// Build SSA code for bodies of all functions in the whole program.
+	result.setStatusf("Constructing SSA form...")
+	prog.Build()
+	log.Print("SSA construction complete")
+
+	a := analysis{
+		result: result,
+		prog:   prog,
+		pcgs:   make(map[*ssa.Package]*packageCallGraph),
+	}
+
+	// Build a mapping from openable filenames to godoc file URLs,
+	// i.e. "/src/" plus path relative to GOROOT/src or GOPATH[i]/src.
+	a.path2url = make(map[string]string)
+	for _, info := range iprog.AllPackages {
+	nextfile:
+		for _, f := range info.Files {
+			if f.Pos() == 0 {
+				continue // e.g. files generated by cgo
+			}
+			abs := iprog.Fset.File(f.Pos()).Name()
+			// Find the root to which this file belongs.
+			for _, root := range roots {
+				rel := strings.TrimPrefix(abs, root)
+				if len(rel) < len(abs) {
+					a.path2url[abs] = "/src/" + filepath.ToSlash(rel)
+					continue nextfile
+				}
+			}
+
+			log.Printf("Can't locate file %s (package %q) beneath any root",
+				abs, info.Pkg.Path())
+		}
+	}
+
+	// Add links for scanner, parser, type-checker errors.
+	// TODO(adonovan): fix: these links can overlap with
+	// identifier markup, causing the renderer to emit some
+	// characters twice.
+	errors := make(map[token.Position][]string)
+	for _, info := range iprog.AllPackages {
+		for _, err := range info.Errors {
+			switch err := err.(type) {
+			case types.Error:
+				posn := a.prog.Fset.Position(err.Pos)
+				errors[posn] = append(errors[posn], err.Msg)
+			case scanner.ErrorList:
+				for _, e := range err {
+					errors[e.Pos] = append(errors[e.Pos], e.Msg)
+				}
+			default:
+				log.Printf("Package %q has error (%T) without position: %v\n",
+					info.Pkg.Path(), err, err)
+			}
+		}
+	}
+	for posn, errs := range errors {
+		fi, offset := a.fileAndOffsetPosn(posn)
+		fi.addLink(errorLink{
+			start: offset,
+			msg:   strings.Join(errs, "\n"),
+		})
+	}
+
+	// ---------- type-based analyses ----------
+
+	// Compute the all-pairs IMPLEMENTS relation.
+	// Collect all named types, even local types
+	// (which can have methods via promotion)
+	// and the built-in "error".
+	errorType := types.Universe.Lookup("error").Type().(*types.Named)
+	a.allNamed = append(a.allNamed, errorType)
+	for _, info := range iprog.AllPackages {
+		for _, obj := range info.Defs {
+			if obj, ok := obj.(*types.TypeName); ok {
+				if named, ok := obj.Type().(*types.Named); ok {
+					a.allNamed = append(a.allNamed, named)
+				}
+			}
+		}
+	}
+	log.Print("Computing implements relation...")
+	facts := computeImplements(&a.prog.MethodSets, a.allNamed)
+
+	// Add the type-based analysis results.
+	log.Print("Extracting type info...")
+	for _, info := range iprog.AllPackages {
+		a.doTypeInfo(info, facts)
+	}
+
+	a.visitInstrs(pta)
+
+	result.setStatusf("Type analysis complete.")
+
+	if pta {
+		mainPkgs := ssautil.MainPackages(prog.AllPackages())
+		log.Print("Transitively error-free main packages: ", mainPkgs)
+		a.pointer(mainPkgs)
+	}
+}
+
+// visitInstrs visits all SSA instructions in the program.
+func (a *analysis) visitInstrs(pta bool) {
+	log.Print("Visit instructions...")
+	for fn := range ssautil.AllFunctions(a.prog) {
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				// CALLEES (static)
+				// (Dynamic calls require pointer analysis.)
+				//
+				// We use the SSA representation to find the static callee,
+				// since in many cases it does better than the
+				// types.Info.{Refs,Selection} information.  For example:
+				//
+				//   defer func(){}()      // static call to anon function
+				//   f := func(){}; f()    // static call to anon function
+				//   f := fmt.Println; f() // static call to named function
+				//
+				// The downside is that we get no static callee information
+				// for packages that (transitively) contain errors.
+				if site, ok := instr.(ssa.CallInstruction); ok {
+					if callee := site.Common().StaticCallee(); callee != nil {
+						// TODO(adonovan): callgraph: elide wrappers.
+						// (Do static calls ever go to wrappers?)
+						if site.Common().Pos() != token.NoPos {
+							a.addCallees(site, []*ssa.Function{callee})
+						}
+					}
+				}
+
+				if !pta {
+					continue
+				}
+
+				// CHANNEL PEERS
+				// Collect send/receive/close instructions in the whole ssa.Program.
+				for _, op := range chanOps(instr) {
+					a.ops = append(a.ops, op)
+					a.ptaConfig.AddQuery(op.ch) // add channel ssa.Value to PTA query
+				}
+			}
+		}
+	}
+	log.Print("Visit instructions complete")
+}
+
+// pointer runs the pointer analysis.
+func (a *analysis) pointer(mainPkgs []*ssa.Package) {
+	// Run the pointer analysis and build the complete callgraph.
+	a.ptaConfig.Mains = mainPkgs
+	a.ptaConfig.BuildCallGraph = true
+	a.ptaConfig.Reflection = false // (for now)
+
+	a.result.setStatusf("Pointer analysis running...")
+
+	ptares, err := pointer.Analyze(&a.ptaConfig)
+	if err != nil {
+		// If this happens, it indicates a bug.
+		a.result.setStatusf("Pointer analysis failed: %s.", err)
+		return
+	}
+	log.Print("Pointer analysis complete.")
+
+	// Add the results of pointer analysis.
+
+	a.result.setStatusf("Computing channel peers...")
+	a.doChannelPeers(ptares.Queries)
+	a.result.setStatusf("Computing dynamic call graph edges...")
+	a.doCallgraph(ptares.CallGraph)
+
+	a.result.setStatusf("Analysis complete.")
+}
+
+type linksByStart []Link
+
+func (a linksByStart) Less(i, j int) bool { return a[i].Start() < a[j].Start() }
+func (a linksByStart) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a linksByStart) Len() int           { return len(a) }
+
+// allPackages returns a new sorted slice of all packages beneath the
+// specified package root directory, e.g. $GOROOT/src or $GOPATH/src.
+// Derived from from go/ssa/stdlib_test.go
+// root must end with os.PathSeparator.
+//
+// TODO(adonovan): use buildutil.AllPackages when the tree thaws.
+func allPackages(root string) []string {
+	var pkgs []string
+	filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if info == nil {
+			return nil // non-existent root directory?
+		}
+		if !info.IsDir() {
+			return nil // not a directory
+		}
+		// Prune the search if we encounter any of these names:
+		base := filepath.Base(path)
+		if base == "testdata" || strings.HasPrefix(base, ".") {
+			return filepath.SkipDir
+		}
+		pkg := filepath.ToSlash(strings.TrimPrefix(path, root))
+		switch pkg {
+		case "builtin":
+			return filepath.SkipDir
+		case "":
+			return nil // ignore root of tree
+		}
+		pkgs = append(pkgs, pkg)
+		return nil
+	})
+	return pkgs
+}
diff --git a/vendor/golang.org/x/tools/godoc/analysis/callgraph.go b/vendor/golang.org/x/tools/godoc/analysis/callgraph.go
new file mode 100644
index 0000000..492022d
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/callgraph.go
@@ -0,0 +1,351 @@
+// 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 analysis
+
+// This file computes the CALLERS and CALLEES relations from the call
+// graph.  CALLERS/CALLEES information is displayed in the lower pane
+// when a "func" token or ast.CallExpr.Lparen is clicked, respectively.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"log"
+	"math/big"
+	"sort"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+)
+
+// doCallgraph computes the CALLEES and CALLERS relations.
+func (a *analysis) doCallgraph(cg *callgraph.Graph) {
+	log.Print("Deleting synthetic nodes...")
+	// TODO(adonovan): opt: DeleteSyntheticNodes is asymptotically
+	// inefficient and can be (unpredictably) slow.
+	cg.DeleteSyntheticNodes()
+	log.Print("Synthetic nodes deleted")
+
+	// Populate nodes of package call graphs (PCGs).
+	for _, n := range cg.Nodes {
+		a.pcgAddNode(n.Func)
+	}
+	// Within each PCG, sort funcs by name.
+	for _, pcg := range a.pcgs {
+		pcg.sortNodes()
+	}
+
+	calledFuncs := make(map[ssa.CallInstruction]map[*ssa.Function]bool)
+	callingSites := make(map[*ssa.Function]map[ssa.CallInstruction]bool)
+	for _, n := range cg.Nodes {
+		for _, e := range n.Out {
+			if e.Site == nil {
+				continue // a call from a synthetic node such as <root>
+			}
+
+			// Add (site pos, callee) to calledFuncs.
+			// (Dynamic calls only.)
+			callee := e.Callee.Func
+
+			a.pcgAddEdge(n.Func, callee)
+
+			if callee.Synthetic != "" {
+				continue // call of a package initializer
+			}
+
+			if e.Site.Common().StaticCallee() == nil {
+				// dynamic call
+				// (CALLEES information for static calls
+				// is computed using SSA information.)
+				lparen := e.Site.Common().Pos()
+				if lparen != token.NoPos {
+					fns := calledFuncs[e.Site]
+					if fns == nil {
+						fns = make(map[*ssa.Function]bool)
+						calledFuncs[e.Site] = fns
+					}
+					fns[callee] = true
+				}
+			}
+
+			// Add (callee, site) to callingSites.
+			fns := callingSites[callee]
+			if fns == nil {
+				fns = make(map[ssa.CallInstruction]bool)
+				callingSites[callee] = fns
+			}
+			fns[e.Site] = true
+		}
+	}
+
+	// CALLEES.
+	log.Print("Callees...")
+	for site, fns := range calledFuncs {
+		var funcs funcsByPos
+		for fn := range fns {
+			funcs = append(funcs, fn)
+		}
+		sort.Sort(funcs)
+
+		a.addCallees(site, funcs)
+	}
+
+	// CALLERS
+	log.Print("Callers...")
+	for callee, sites := range callingSites {
+		pos := funcToken(callee)
+		if pos == token.NoPos {
+			log.Printf("CALLERS: skipping %s: no pos", callee)
+			continue
+		}
+
+		var this *types.Package // for relativizing names
+		if callee.Pkg != nil {
+			this = callee.Pkg.Pkg
+		}
+
+		// Compute sites grouped by parent, with text and URLs.
+		sitesByParent := make(map[*ssa.Function]sitesByPos)
+		for site := range sites {
+			fn := site.Parent()
+			sitesByParent[fn] = append(sitesByParent[fn], site)
+		}
+		var funcs funcsByPos
+		for fn := range sitesByParent {
+			funcs = append(funcs, fn)
+		}
+		sort.Sort(funcs)
+
+		v := callersJSON{
+			Callee:  callee.String(),
+			Callers: []callerJSON{}, // (JS wants non-nil)
+		}
+		for _, fn := range funcs {
+			caller := callerJSON{
+				Func:  prettyFunc(this, fn),
+				Sites: []anchorJSON{}, // (JS wants non-nil)
+			}
+			sites := sitesByParent[fn]
+			sort.Sort(sites)
+			for _, site := range sites {
+				pos := site.Common().Pos()
+				if pos != token.NoPos {
+					caller.Sites = append(caller.Sites, anchorJSON{
+						Text: fmt.Sprintf("%d", a.prog.Fset.Position(pos).Line),
+						Href: a.posURL(pos, len("(")),
+					})
+				}
+			}
+			v.Callers = append(v.Callers, caller)
+		}
+
+		fi, offset := a.fileAndOffset(pos)
+		fi.addLink(aLink{
+			start:   offset,
+			end:     offset + len("func"),
+			title:   fmt.Sprintf("%d callers", len(sites)),
+			onclick: fmt.Sprintf("onClickCallers(%d)", fi.addData(v)),
+		})
+	}
+
+	// PACKAGE CALLGRAPH
+	log.Print("Package call graph...")
+	for pkg, pcg := range a.pcgs {
+		// Maps (*ssa.Function).RelString() to index in JSON CALLGRAPH array.
+		index := make(map[string]int)
+
+		// Treat exported functions (and exported methods of
+		// exported named types) as roots even if they aren't
+		// actually called from outside the package.
+		for i, n := range pcg.nodes {
+			if i == 0 || n.fn.Object() == nil || !n.fn.Object().Exported() {
+				continue
+			}
+			recv := n.fn.Signature.Recv()
+			if recv == nil || deref(recv.Type()).(*types.Named).Obj().Exported() {
+				roots := &pcg.nodes[0].edges
+				roots.SetBit(roots, i, 1)
+			}
+			index[n.fn.RelString(pkg.Pkg)] = i
+		}
+
+		json := a.pcgJSON(pcg)
+
+		// TODO(adonovan): pkg.Path() is not unique!
+		// It is possible to declare a non-test package called x_test.
+		a.result.pkgInfo(pkg.Pkg.Path()).setCallGraph(json, index)
+	}
+}
+
+// addCallees adds client data and links for the facts that site calls fns.
+func (a *analysis) addCallees(site ssa.CallInstruction, fns []*ssa.Function) {
+	v := calleesJSON{
+		Descr:   site.Common().Description(),
+		Callees: []anchorJSON{}, // (JS wants non-nil)
+	}
+	var this *types.Package // for relativizing names
+	if p := site.Parent().Package(); p != nil {
+		this = p.Pkg
+	}
+
+	for _, fn := range fns {
+		v.Callees = append(v.Callees, anchorJSON{
+			Text: prettyFunc(this, fn),
+			Href: a.posURL(funcToken(fn), len("func")),
+		})
+	}
+
+	fi, offset := a.fileAndOffset(site.Common().Pos())
+	fi.addLink(aLink{
+		start:   offset,
+		end:     offset + len("("),
+		title:   fmt.Sprintf("%d callees", len(v.Callees)),
+		onclick: fmt.Sprintf("onClickCallees(%d)", fi.addData(v)),
+	})
+}
+
+// -- utilities --------------------------------------------------------
+
+// stable order within packages but undefined across packages.
+type funcsByPos []*ssa.Function
+
+func (a funcsByPos) Less(i, j int) bool { return a[i].Pos() < a[j].Pos() }
+func (a funcsByPos) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a funcsByPos) Len() int           { return len(a) }
+
+type sitesByPos []ssa.CallInstruction
+
+func (a sitesByPos) Less(i, j int) bool { return a[i].Common().Pos() < a[j].Common().Pos() }
+func (a sitesByPos) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a sitesByPos) Len() int           { return len(a) }
+
+func funcToken(fn *ssa.Function) token.Pos {
+	switch syntax := fn.Syntax().(type) {
+	case *ast.FuncLit:
+		return syntax.Type.Func
+	case *ast.FuncDecl:
+		return syntax.Type.Func
+	}
+	return token.NoPos
+}
+
+// prettyFunc pretty-prints fn for the user interface.
+// TODO(adonovan): return HTML so we have more markup freedom.
+func prettyFunc(this *types.Package, fn *ssa.Function) string {
+	if fn.Parent() != nil {
+		return fmt.Sprintf("%s in %s",
+			types.TypeString(fn.Signature, types.RelativeTo(this)),
+			prettyFunc(this, fn.Parent()))
+	}
+	if fn.Synthetic != "" && fn.Name() == "init" {
+		// (This is the actual initializer, not a declared 'func init').
+		if fn.Pkg.Pkg == this {
+			return "package initializer"
+		}
+		return fmt.Sprintf("%q package initializer", fn.Pkg.Pkg.Path())
+	}
+	return fn.RelString(this)
+}
+
+// -- intra-package callgraph ------------------------------------------
+
+// pcgNode represents a node in the package call graph (PCG).
+type pcgNode struct {
+	fn     *ssa.Function
+	pretty string  // cache of prettyFunc(fn)
+	edges  big.Int // set of callee func indices
+}
+
+// A packageCallGraph represents the intra-package edges of the global call graph.
+// The zeroth node indicates "all external functions".
+type packageCallGraph struct {
+	nodeIndex map[*ssa.Function]int // maps func to node index (a small int)
+	nodes     []*pcgNode            // maps node index to node
+}
+
+// sortNodes populates pcg.nodes in name order and updates the nodeIndex.
+func (pcg *packageCallGraph) sortNodes() {
+	nodes := make([]*pcgNode, 0, len(pcg.nodeIndex))
+	nodes = append(nodes, &pcgNode{fn: nil, pretty: "<external>"})
+	for fn := range pcg.nodeIndex {
+		nodes = append(nodes, &pcgNode{
+			fn:     fn,
+			pretty: prettyFunc(fn.Pkg.Pkg, fn),
+		})
+	}
+	sort.Sort(pcgNodesByPretty(nodes[1:]))
+	for i, n := range nodes {
+		pcg.nodeIndex[n.fn] = i
+	}
+	pcg.nodes = nodes
+}
+
+func (pcg *packageCallGraph) addEdge(caller, callee *ssa.Function) {
+	var callerIndex int
+	if caller.Pkg == callee.Pkg {
+		// intra-package edge
+		callerIndex = pcg.nodeIndex[caller]
+		if callerIndex < 1 {
+			panic(caller)
+		}
+	}
+	edges := &pcg.nodes[callerIndex].edges
+	edges.SetBit(edges, pcg.nodeIndex[callee], 1)
+}
+
+func (a *analysis) pcgAddNode(fn *ssa.Function) {
+	if fn.Pkg == nil {
+		return
+	}
+	pcg, ok := a.pcgs[fn.Pkg]
+	if !ok {
+		pcg = &packageCallGraph{nodeIndex: make(map[*ssa.Function]int)}
+		a.pcgs[fn.Pkg] = pcg
+	}
+	pcg.nodeIndex[fn] = -1
+}
+
+func (a *analysis) pcgAddEdge(caller, callee *ssa.Function) {
+	if callee.Pkg != nil {
+		a.pcgs[callee.Pkg].addEdge(caller, callee)
+	}
+}
+
+// pcgJSON returns a new slice of callgraph JSON values.
+func (a *analysis) pcgJSON(pcg *packageCallGraph) []*PCGNodeJSON {
+	var nodes []*PCGNodeJSON
+	for _, n := range pcg.nodes {
+
+		// TODO(adonovan): why is there no good way to iterate
+		// over the set bits of a big.Int?
+		var callees []int
+		nbits := n.edges.BitLen()
+		for j := 0; j < nbits; j++ {
+			if n.edges.Bit(j) == 1 {
+				callees = append(callees, j)
+			}
+		}
+
+		var pos token.Pos
+		if n.fn != nil {
+			pos = funcToken(n.fn)
+		}
+		nodes = append(nodes, &PCGNodeJSON{
+			Func: anchorJSON{
+				Text: n.pretty,
+				Href: a.posURL(pos, len("func")),
+			},
+			Callees: callees,
+		})
+	}
+	return nodes
+}
+
+type pcgNodesByPretty []*pcgNode
+
+func (a pcgNodesByPretty) Less(i, j int) bool { return a[i].pretty < a[j].pretty }
+func (a pcgNodesByPretty) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a pcgNodesByPretty) Len() int           { return len(a) }
diff --git a/vendor/golang.org/x/tools/godoc/analysis/implements.go b/vendor/golang.org/x/tools/godoc/analysis/implements.go
new file mode 100644
index 0000000..5a29579
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/implements.go
@@ -0,0 +1,195 @@
+// 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 analysis
+
+// This file computes the "implements" relation over all pairs of
+// named types in the program.  (The mark-up is done by typeinfo.go.)
+
+// TODO(adonovan): do we want to report implements(C, I) where C and I
+// belong to different packages and at least one is not exported?
+
+import (
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// computeImplements computes the "implements" relation over all pairs
+// of named types in allNamed.
+func computeImplements(cache *typeutil.MethodSetCache, allNamed []*types.Named) map[*types.Named]implementsFacts {
+	// Information about a single type's method set.
+	type msetInfo struct {
+		typ          types.Type
+		mset         *types.MethodSet
+		mask1, mask2 uint64
+	}
+
+	initMsetInfo := func(info *msetInfo, typ types.Type) {
+		info.typ = typ
+		info.mset = cache.MethodSet(typ)
+		for i := 0; i < info.mset.Len(); i++ {
+			name := info.mset.At(i).Obj().Name()
+			info.mask1 |= 1 << methodBit(name[0])
+			info.mask2 |= 1 << methodBit(name[len(name)-1])
+		}
+	}
+
+	// satisfies(T, U) reports whether type T satisfies type U.
+	// U must be an interface.
+	//
+	// Since there are thousands of types (and thus millions of
+	// pairs of types) and types.Assignable(T, U) is relatively
+	// expensive, we compute assignability directly from the
+	// method sets.  (At least one of T and U must be an
+	// interface.)
+	//
+	// We use a trick (thanks gri!) related to a Bloom filter to
+	// quickly reject most tests, which are false.  For each
+	// method set, we precompute a mask, a set of bits, one per
+	// distinct initial byte of each method name.  Thus the mask
+	// for io.ReadWriter would be {'R','W'}.  AssignableTo(T, U)
+	// cannot be true unless mask(T)&mask(U)==mask(U).
+	//
+	// As with a Bloom filter, we can improve precision by testing
+	// additional hashes, e.g. using the last letter of each
+	// method name, so long as the subset mask property holds.
+	//
+	// When analyzing the standard library, there are about 1e6
+	// calls to satisfies(), of which 0.6% return true.  With a
+	// 1-hash filter, 95% of calls avoid the expensive check; with
+	// a 2-hash filter, this grows to 98.2%.
+	satisfies := func(T, U *msetInfo) bool {
+		return T.mask1&U.mask1 == U.mask1 &&
+			T.mask2&U.mask2 == U.mask2 &&
+			containsAllIdsOf(T.mset, U.mset)
+	}
+
+	// Information about a named type N, and perhaps also *N.
+	type namedInfo struct {
+		isInterface bool
+		base        msetInfo // N
+		ptr         msetInfo // *N, iff N !isInterface
+	}
+
+	var infos []namedInfo
+
+	// Precompute the method sets and their masks.
+	for _, N := range allNamed {
+		var info namedInfo
+		initMsetInfo(&info.base, N)
+		_, info.isInterface = N.Underlying().(*types.Interface)
+		if !info.isInterface {
+			initMsetInfo(&info.ptr, types.NewPointer(N))
+		}
+
+		if info.base.mask1|info.ptr.mask1 == 0 {
+			continue // neither N nor *N has methods
+		}
+
+		infos = append(infos, info)
+	}
+
+	facts := make(map[*types.Named]implementsFacts)
+
+	// Test all pairs of distinct named types (T, U).
+	// TODO(adonovan): opt: compute (U, T) at the same time.
+	for t := range infos {
+		T := &infos[t]
+		var to, from, fromPtr []types.Type
+		for u := range infos {
+			if t == u {
+				continue
+			}
+			U := &infos[u]
+			switch {
+			case T.isInterface && U.isInterface:
+				if satisfies(&U.base, &T.base) {
+					to = append(to, U.base.typ)
+				}
+				if satisfies(&T.base, &U.base) {
+					from = append(from, U.base.typ)
+				}
+			case T.isInterface: // U concrete
+				if satisfies(&U.base, &T.base) {
+					to = append(to, U.base.typ)
+				} else if satisfies(&U.ptr, &T.base) {
+					to = append(to, U.ptr.typ)
+				}
+			case U.isInterface: // T concrete
+				if satisfies(&T.base, &U.base) {
+					from = append(from, U.base.typ)
+				} else if satisfies(&T.ptr, &U.base) {
+					fromPtr = append(fromPtr, U.base.typ)
+				}
+			}
+		}
+
+		// Sort types (arbitrarily) to avoid nondeterminism.
+		sort.Sort(typesByString(to))
+		sort.Sort(typesByString(from))
+		sort.Sort(typesByString(fromPtr))
+
+		facts[T.base.typ.(*types.Named)] = implementsFacts{to, from, fromPtr}
+	}
+
+	return facts
+}
+
+type implementsFacts struct {
+	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
+}
+
+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] }
+
+// methodBit returns the index of x in [a-zA-Z], or 52 if not found.
+func methodBit(x byte) uint64 {
+	switch {
+	case 'a' <= x && x <= 'z':
+		return uint64(x - 'a')
+	case 'A' <= x && x <= 'Z':
+		return uint64(26 + x - 'A')
+	}
+	return 52 // all other bytes
+}
+
+// containsAllIdsOf reports whether the method identifiers of T are a
+// superset of those in U.  If U belongs to an interface type, the
+// result is equal to types.Assignable(T, U), but is cheaper to compute.
+//
+// TODO(gri): make this a method of *types.MethodSet.
+//
+func containsAllIdsOf(T, U *types.MethodSet) bool {
+	t, tlen := 0, T.Len()
+	u, ulen := 0, U.Len()
+	for t < tlen && u < ulen {
+		tMeth := T.At(t).Obj()
+		uMeth := U.At(u).Obj()
+		tId := tMeth.Id()
+		uId := uMeth.Id()
+		if tId > uId {
+			// U has a method T lacks: fail.
+			return false
+		}
+		if tId < uId {
+			// T has a method U lacks: ignore it.
+			t++
+			continue
+		}
+		// U and T both have a method of this Id.  Check types.
+		if !types.Identical(tMeth.Type(), uMeth.Type()) {
+			return false // type mismatch
+		}
+		u++
+		t++
+	}
+	return u == ulen
+}
diff --git a/vendor/golang.org/x/tools/godoc/analysis/json.go b/vendor/golang.org/x/tools/godoc/analysis/json.go
new file mode 100644
index 0000000..f897618
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/json.go
@@ -0,0 +1,69 @@
+// 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 analysis
+
+// This file defines types used by client-side JavaScript.
+
+type anchorJSON struct {
+	Text string // HTML
+	Href string // URL
+}
+
+type commOpJSON struct {
+	Op anchorJSON
+	Fn string
+}
+
+// JavaScript's onClickComm() expects a commJSON.
+type commJSON struct {
+	Ops []commOpJSON
+}
+
+// Indicates one of these forms of fact about a type T:
+// T "is implemented by <ByKind> type <Other>"  (ByKind != "", e.g. "array")
+// T "implements <Other>"                       (ByKind == "")
+type implFactJSON struct {
+	ByKind string `json:",omitempty"`
+	Other  anchorJSON
+}
+
+// Implements facts are grouped by form, for ease of reading.
+type implGroupJSON struct {
+	Descr string
+	Facts []implFactJSON
+}
+
+// JavaScript's onClickIdent() expects a TypeInfoJSON.
+type TypeInfoJSON struct {
+	Name        string // type name
+	Size, Align int64
+	Methods     []anchorJSON
+	ImplGroups  []implGroupJSON
+}
+
+// JavaScript's onClickCallees() expects a calleesJSON.
+type calleesJSON struct {
+	Descr   string
+	Callees []anchorJSON // markup for called function
+}
+
+type callerJSON struct {
+	Func  string
+	Sites []anchorJSON
+}
+
+// JavaScript's onClickCallers() expects a callersJSON.
+type callersJSON struct {
+	Callee  string
+	Callers []callerJSON
+}
+
+// JavaScript's cgAddChild requires a global array of PCGNodeJSON
+// called CALLGRAPH, representing the intra-package call graph.
+// The first element is special and represents "all external callers".
+type PCGNodeJSON struct {
+	Func    anchorJSON
+	Callees []int // indices within CALLGRAPH of nodes called by this one
+}
diff --git a/vendor/golang.org/x/tools/godoc/analysis/peers.go b/vendor/golang.org/x/tools/godoc/analysis/peers.go
new file mode 100644
index 0000000..a742f06
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/peers.go
@@ -0,0 +1,154 @@
+// 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 analysis
+
+// This file computes the channel "peers" relation over all pairs of
+// channel operations in the program.  The peers are displayed in the
+// lower pane when a channel operation (make, <-, close) is clicked.
+
+// TODO(adonovan): handle calls to reflect.{Select,Recv,Send,Close} too,
+// then enable reflection in PTA.
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/pointer"
+	"golang.org/x/tools/go/ssa"
+)
+
+func (a *analysis) doChannelPeers(ptsets map[ssa.Value]pointer.Pointer) {
+	addSendRecv := func(j *commJSON, op chanOp) {
+		j.Ops = append(j.Ops, commOpJSON{
+			Op: anchorJSON{
+				Text: op.mode,
+				Href: a.posURL(op.pos, op.len),
+			},
+			Fn: prettyFunc(nil, op.fn),
+		})
+	}
+
+	// Build an undirected bipartite multigraph (binary relation)
+	// of MakeChan ops and send/recv/close ops.
+	//
+	// TODO(adonovan): opt: use channel element types to partition
+	// the O(n^2) problem into subproblems.
+	aliasedOps := make(map[*ssa.MakeChan][]chanOp)
+	opToMakes := make(map[chanOp][]*ssa.MakeChan)
+	for _, op := range a.ops {
+		// Combine the PT sets from all contexts.
+		var makes []*ssa.MakeChan // aliased ops
+		ptr, ok := ptsets[op.ch]
+		if !ok {
+			continue // e.g. channel op in dead code
+		}
+		for _, label := range ptr.PointsTo().Labels() {
+			makechan, ok := label.Value().(*ssa.MakeChan)
+			if !ok {
+				continue // skip intrinsically-created channels for now
+			}
+			if makechan.Pos() == token.NoPos {
+				continue // not possible?
+			}
+			makes = append(makes, makechan)
+			aliasedOps[makechan] = append(aliasedOps[makechan], op)
+		}
+		opToMakes[op] = makes
+	}
+
+	// Now that complete relation is built, build links for ops.
+	for _, op := range a.ops {
+		v := commJSON{
+			Ops: []commOpJSON{}, // (JS wants non-nil)
+		}
+		ops := make(map[chanOp]bool)
+		for _, makechan := range opToMakes[op] {
+			v.Ops = append(v.Ops, commOpJSON{
+				Op: anchorJSON{
+					Text: "made",
+					Href: a.posURL(makechan.Pos()-token.Pos(len("make")),
+						len("make")),
+				},
+				Fn: makechan.Parent().RelString(op.fn.Package().Pkg),
+			})
+			for _, op := range aliasedOps[makechan] {
+				ops[op] = true
+			}
+		}
+		for op := range ops {
+			addSendRecv(&v, op)
+		}
+
+		// Add links for each aliased op.
+		fi, offset := a.fileAndOffset(op.pos)
+		fi.addLink(aLink{
+			start:   offset,
+			end:     offset + op.len,
+			title:   "show channel ops",
+			onclick: fmt.Sprintf("onClickComm(%d)", fi.addData(v)),
+		})
+	}
+	// Add links for makechan ops themselves.
+	for makechan, ops := range aliasedOps {
+		v := commJSON{
+			Ops: []commOpJSON{}, // (JS wants non-nil)
+		}
+		for _, op := range ops {
+			addSendRecv(&v, op)
+		}
+
+		fi, offset := a.fileAndOffset(makechan.Pos())
+		fi.addLink(aLink{
+			start:   offset - len("make"),
+			end:     offset,
+			title:   "show channel ops",
+			onclick: fmt.Sprintf("onClickComm(%d)", fi.addData(v)),
+		})
+	}
+}
+
+// -- utilities --------------------------------------------------------
+
+// chanOp abstracts an ssa.Send, ssa.Unop(ARROW), close(), or a SelectState.
+// Derived from cmd/guru/peers.go.
+type chanOp struct {
+	ch   ssa.Value
+	mode string // sent|received|closed
+	pos  token.Pos
+	len  int
+	fn   *ssa.Function
+}
+
+// chanOps returns a slice of all the channel operations in the instruction.
+// Derived from cmd/guru/peers.go.
+func chanOps(instr ssa.Instruction) []chanOp {
+	fn := instr.Parent()
+	var ops []chanOp
+	switch instr := instr.(type) {
+	case *ssa.UnOp:
+		if instr.Op == token.ARROW {
+			// TODO(adonovan): don't assume <-ch; could be 'range ch'.
+			ops = append(ops, chanOp{instr.X, "received", instr.Pos(), len("<-"), fn})
+		}
+	case *ssa.Send:
+		ops = append(ops, chanOp{instr.Chan, "sent", instr.Pos(), len("<-"), fn})
+	case *ssa.Select:
+		for _, st := range instr.States {
+			mode := "received"
+			if st.Dir == types.SendOnly {
+				mode = "sent"
+			}
+			ops = append(ops, chanOp{st.Chan, mode, st.Pos, len("<-"), fn})
+		}
+	case ssa.CallInstruction:
+		call := instr.Common()
+		if blt, ok := call.Value.(*ssa.Builtin); ok && blt.Name() == "close" {
+			pos := instr.Common().Pos()
+			ops = append(ops, chanOp{call.Args[0], "closed", pos - token.Pos(len("close")), len("close("), fn})
+		}
+	}
+	return ops
+}
diff --git a/vendor/golang.org/x/tools/godoc/analysis/typeinfo.go b/vendor/golang.org/x/tools/godoc/analysis/typeinfo.go
new file mode 100644
index 0000000..e57683f
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/analysis/typeinfo.go
@@ -0,0 +1,234 @@
+// 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 analysis
+
+// This file computes the markup for information from go/types:
+// IMPORTS, identifier RESOLUTION, METHOD SETS, size/alignment, and
+// the IMPLEMENTS relation.
+//
+// IMPORTS links connect import specs to the documentation for the
+// imported package.
+//
+// RESOLUTION links referring identifiers to their defining
+// identifier, and adds tooltips for kind and type.
+//
+// METHOD SETS, size/alignment, and the IMPLEMENTS relation are
+// displayed in the lower pane when a type's defining identifier is
+// clicked.
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// TODO(adonovan): audit to make sure it's safe on ill-typed packages.
+
+// TODO(adonovan): use same Sizes as loader.Config.
+var sizes = types.StdSizes{WordSize: 8, MaxAlign: 8}
+
+func (a *analysis) doTypeInfo(info *loader.PackageInfo, implements map[*types.Named]implementsFacts) {
+	// We must not assume the corresponding SSA packages were
+	// created (i.e. were transitively error-free).
+
+	// IMPORTS
+	for _, f := range info.Files {
+		// Package decl.
+		fi, offset := a.fileAndOffset(f.Name.Pos())
+		fi.addLink(aLink{
+			start: offset,
+			end:   offset + len(f.Name.Name),
+			title: "Package docs for " + info.Pkg.Path(),
+			// TODO(adonovan): fix: we're putting the untrusted Path()
+			// into a trusted field.  What's the appropriate sanitizer?
+			href: "/pkg/" + info.Pkg.Path(),
+		})
+
+		// Import specs.
+		for _, imp := range f.Imports {
+			// Remove quotes.
+			L := int(imp.End()-imp.Path.Pos()) - len(`""`)
+			path, _ := strconv.Unquote(imp.Path.Value)
+			fi, offset := a.fileAndOffset(imp.Path.Pos())
+			fi.addLink(aLink{
+				start: offset + 1,
+				end:   offset + 1 + L,
+				title: "Package docs for " + path,
+				// TODO(adonovan): fix: we're putting the untrusted path
+				// into a trusted field.  What's the appropriate sanitizer?
+				href: "/pkg/" + path,
+			})
+		}
+	}
+
+	// RESOLUTION
+	qualifier := types.RelativeTo(info.Pkg)
+	for id, obj := range info.Uses {
+		// Position of the object definition.
+		pos := obj.Pos()
+		Len := len(obj.Name())
+
+		// Correct the position for non-renaming import specs.
+		//  import "sync/atomic"
+		//          ^^^^^^^^^^^
+		if obj, ok := obj.(*types.PkgName); ok && id.Name == obj.Imported().Name() {
+			// Assume this is a non-renaming import.
+			// NB: not true for degenerate renamings: `import foo "foo"`.
+			pos++
+			Len = len(obj.Imported().Path())
+		}
+
+		if obj.Pkg() == nil {
+			continue // don't mark up built-ins.
+		}
+
+		fi, offset := a.fileAndOffset(id.NamePos)
+		fi.addLink(aLink{
+			start: offset,
+			end:   offset + len(id.Name),
+			title: types.ObjectString(obj, qualifier),
+			href:  a.posURL(pos, Len),
+		})
+	}
+
+	// IMPLEMENTS & METHOD SETS
+	for _, obj := range info.Defs {
+		if obj, ok := obj.(*types.TypeName); ok {
+			if named, ok := obj.Type().(*types.Named); ok {
+				a.namedType(named, implements)
+			}
+		}
+	}
+}
+
+func (a *analysis) namedType(T *types.Named, implements map[*types.Named]implementsFacts) {
+	obj := T.Obj()
+	qualifier := types.RelativeTo(obj.Pkg())
+	v := &TypeInfoJSON{
+		Name:    obj.Name(),
+		Size:    sizes.Sizeof(T),
+		Align:   sizes.Alignof(T),
+		Methods: []anchorJSON{}, // (JS wants non-nil)
+	}
+
+	// addFact adds the fact "is implemented by T" (by) or
+	// "implements T" (!by) to group.
+	addFact := func(group *implGroupJSON, T types.Type, by bool) {
+		Tobj := deref(T).(*types.Named).Obj()
+		var byKind string
+		if by {
+			// Show underlying kind of implementing type,
+			// e.g. "slice", "array", "struct".
+			s := reflect.TypeOf(T.Underlying()).String()
+			byKind = strings.ToLower(strings.TrimPrefix(s, "*types."))
+		}
+		group.Facts = append(group.Facts, implFactJSON{
+			ByKind: byKind,
+			Other: anchorJSON{
+				Href: a.posURL(Tobj.Pos(), len(Tobj.Name())),
+				Text: types.TypeString(T, qualifier),
+			},
+		})
+	}
+
+	// IMPLEMENTS
+	if r, ok := implements[T]; ok {
+		if isInterface(T) {
+			// "T is implemented by <conc>" ...
+			// "T is implemented by <iface>"...
+			// "T implements        <iface>"...
+			group := implGroupJSON{
+				Descr: types.TypeString(T, qualifier),
+			}
+			// Show concrete types first; use two passes.
+			for _, sub := range r.to {
+				if !isInterface(sub) {
+					addFact(&group, sub, true)
+				}
+			}
+			for _, sub := range r.to {
+				if isInterface(sub) {
+					addFact(&group, sub, true)
+				}
+			}
+			for _, super := range r.from {
+				addFact(&group, super, false)
+			}
+			v.ImplGroups = append(v.ImplGroups, group)
+		} else {
+			// T is concrete.
+			if r.from != nil {
+				// "T implements <iface>"...
+				group := implGroupJSON{
+					Descr: types.TypeString(T, qualifier),
+				}
+				for _, super := range r.from {
+					addFact(&group, super, false)
+				}
+				v.ImplGroups = append(v.ImplGroups, group)
+			}
+			if r.fromPtr != nil {
+				// "*C implements <iface>"...
+				group := implGroupJSON{
+					Descr: "*" + types.TypeString(T, qualifier),
+				}
+				for _, psuper := range r.fromPtr {
+					addFact(&group, psuper, false)
+				}
+				v.ImplGroups = append(v.ImplGroups, group)
+			}
+		}
+	}
+
+	// METHOD SETS
+	for _, sel := range typeutil.IntuitiveMethodSet(T, &a.prog.MethodSets) {
+		meth := sel.Obj().(*types.Func)
+		pos := meth.Pos() // may be 0 for error.Error
+		v.Methods = append(v.Methods, anchorJSON{
+			Href: a.posURL(pos, len(meth.Name())),
+			Text: types.SelectionString(sel, qualifier),
+		})
+	}
+
+	// Since there can be many specs per decl, we
+	// can't attach the link to the keyword 'type'
+	// (as we do with 'func'); we use the Ident.
+	fi, offset := a.fileAndOffset(obj.Pos())
+	fi.addLink(aLink{
+		start:   offset,
+		end:     offset + len(obj.Name()),
+		title:   fmt.Sprintf("type info for %s", obj.Name()),
+		onclick: fmt.Sprintf("onClickTypeInfo(%d)", fi.addData(v)),
+	})
+
+	// Add info for exported package-level types to the package info.
+	if obj.Exported() && isPackageLevel(obj) {
+		// TODO(adonovan): Path is not unique!
+		// It is possible to declare a non-test package called x_test.
+		a.result.pkgInfo(obj.Pkg().Path()).addType(v)
+	}
+}
+
+// -- utilities --------------------------------------------------------
+
+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
+}
+
+// isPackageLevel reports whether obj is a package-level object.
+func isPackageLevel(obj types.Object) bool {
+	return obj.Pkg().Scope().Lookup(obj.Name()) == obj
+}
diff --git a/vendor/golang.org/x/tools/godoc/appengine.go b/vendor/golang.org/x/tools/godoc/appengine.go
new file mode 100644
index 0000000..fe5e687
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/appengine.go
@@ -0,0 +1,13 @@
+// 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 appengine
+
+package godoc
+
+import "google.golang.org/appengine"
+
+func init() {
+	onAppengine = !appengine.IsDevAppServer()
+}
diff --git a/vendor/golang.org/x/tools/godoc/cmdline.go b/vendor/golang.org/x/tools/godoc/cmdline.go
new file mode 100644
index 0000000..7c53681
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/cmdline.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 godoc
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"io"
+	"log"
+	"os"
+	pathpkg "path"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+const (
+	target    = "/target"
+	cmdPrefix = "cmd/"
+	srcPrefix = "src/"
+	toolsPath = "golang.org/x/tools/cmd/"
+)
+
+// CommandLine returns godoc results to w.
+// Note that it may add a /target path to fs.
+func CommandLine(w io.Writer, fs vfs.NameSpace, pres *Presentation, args []string) error {
+	path := args[0]
+	srcMode := pres.SrcMode
+	cmdMode := strings.HasPrefix(path, cmdPrefix)
+	if strings.HasPrefix(path, srcPrefix) {
+		path = strings.TrimPrefix(path, srcPrefix)
+		srcMode = true
+	}
+	var abspath, relpath string
+	if cmdMode {
+		path = strings.TrimPrefix(path, cmdPrefix)
+	} else {
+		abspath, relpath = paths(fs, pres, path)
+	}
+
+	var mode PageInfoMode
+	if relpath == builtinPkgPath {
+		// the fake built-in package contains unexported identifiers
+		mode = NoFiltering | NoTypeAssoc
+	}
+	if srcMode {
+		// only filter exports if we don't have explicit command-line filter arguments
+		if len(args) > 1 {
+			mode |= NoFiltering
+		}
+		mode |= ShowSource
+	}
+
+	// First, try as package unless forced as command.
+	var info *PageInfo
+	if !cmdMode {
+		info = pres.GetPkgPageInfo(abspath, relpath, mode)
+	}
+
+	// Second, try as command (if the path is not absolute).
+	var cinfo *PageInfo
+	if !filepath.IsAbs(path) {
+		// First try go.tools/cmd.
+		abspath = pathpkg.Join(pres.PkgFSRoot(), toolsPath+path)
+		cinfo = pres.GetCmdPageInfo(abspath, relpath, mode)
+		if cinfo.IsEmpty() {
+			// Then try $GOROOT/cmd.
+			abspath = pathpkg.Join(pres.CmdFSRoot(), path)
+			cinfo = pres.GetCmdPageInfo(abspath, relpath, mode)
+		}
+	}
+
+	// determine what to use
+	if info == nil || info.IsEmpty() {
+		if cinfo != nil && !cinfo.IsEmpty() {
+			// only cinfo exists - switch to cinfo
+			info = cinfo
+		}
+	} else if cinfo != nil && !cinfo.IsEmpty() {
+		// both info and cinfo exist - use cinfo if info
+		// contains only subdirectory information
+		if info.PAst == nil && info.PDoc == nil {
+			info = cinfo
+		} else if relpath != target {
+			// The above check handles the case where an operating system path
+			// is provided (see documentation for paths below).  In that case,
+			// relpath is set to "/target" (in anticipation of accessing packages there),
+			// and is therefore not expected to match a command.
+			fmt.Fprintf(w, "use 'godoc %s%s' for documentation on the %s command \n\n", cmdPrefix, relpath, relpath)
+		}
+	}
+
+	if info == nil {
+		return fmt.Errorf("%s: no such directory or package", args[0])
+	}
+	if info.Err != nil {
+		return info.Err
+	}
+
+	if info.PDoc != nil && info.PDoc.ImportPath == target {
+		// Replace virtual /target with actual argument from command line.
+		info.PDoc.ImportPath = args[0]
+	}
+
+	// If we have more than one argument, use the remaining arguments for filtering.
+	if len(args) > 1 {
+		info.IsFiltered = true
+		filterInfo(args[1:], info)
+	}
+
+	packageText := pres.PackageText
+	if pres.HTMLMode {
+		packageText = pres.PackageHTML
+	}
+	if err := packageText.Execute(w, info); err != nil {
+		return err
+	}
+	return nil
+}
+
+// paths determines the paths to use.
+//
+// If we are passed an operating system path like . or ./foo or /foo/bar or c:\mysrc,
+// we need to map that path somewhere in the fs name space so that routines
+// like getPageInfo will see it.  We use the arbitrarily-chosen virtual path "/target"
+// for this.  That is, if we get passed a directory like the above, we map that
+// directory so that getPageInfo sees it as /target.
+// Returns the absolute and relative paths.
+func paths(fs vfs.NameSpace, pres *Presentation, path string) (string, string) {
+	if filepath.IsAbs(path) {
+		fs.Bind(target, vfs.OS(path), "/", vfs.BindReplace)
+		return target, target
+	}
+	if build.IsLocalImport(path) {
+		cwd, _ := os.Getwd() // ignore errors
+		path = filepath.Join(cwd, path)
+		fs.Bind(target, vfs.OS(path), "/", vfs.BindReplace)
+		return target, target
+	}
+	if bp, _ := build.Import(path, "", build.FindOnly); bp.Dir != "" && bp.ImportPath != "" {
+		fs.Bind(target, vfs.OS(bp.Dir), "/", vfs.BindReplace)
+		return target, bp.ImportPath
+	}
+	return pathpkg.Join(pres.PkgFSRoot(), path), path
+}
+
+// filterInfo updates info to include only the nodes that match the given
+// filter args.
+func filterInfo(args []string, info *PageInfo) {
+	rx, err := makeRx(args)
+	if err != nil {
+		log.Fatalf("illegal regular expression from %v: %v", args, err)
+	}
+
+	filter := func(s string) bool { return rx.MatchString(s) }
+	switch {
+	case info.PAst != nil:
+		newPAst := map[string]*ast.File{}
+		for name, a := range info.PAst {
+			cmap := ast.NewCommentMap(info.FSet, a, a.Comments)
+			a.Comments = []*ast.CommentGroup{} // remove all comments.
+			ast.FilterFile(a, filter)
+			if len(a.Decls) > 0 {
+				newPAst[name] = a
+			}
+			for _, d := range a.Decls {
+				// add back the comments associated with d only
+				comments := cmap.Filter(d).Comments()
+				a.Comments = append(a.Comments, comments...)
+			}
+		}
+		info.PAst = newPAst // add only matching files.
+	case info.PDoc != nil:
+		info.PDoc.Filter(filter)
+	}
+}
+
+// Does s look like a regular expression?
+func isRegexp(s string) bool {
+	return strings.ContainsAny(s, ".(|)*+?^$[]")
+}
+
+// Make a regular expression of the form
+// names[0]|names[1]|...names[len(names)-1].
+// Returns an error if the regular expression is illegal.
+func makeRx(names []string) (*regexp.Regexp, error) {
+	if len(names) == 0 {
+		return nil, fmt.Errorf("no expression provided")
+	}
+	s := ""
+	for i, name := range names {
+		if i > 0 {
+			s += "|"
+		}
+		if isRegexp(name) {
+			s += name
+		} else {
+			s += "^" + name + "$" // must match exactly
+		}
+	}
+	return regexp.Compile(s)
+}
diff --git a/vendor/golang.org/x/tools/godoc/cmdline_test.go b/vendor/golang.org/x/tools/godoc/cmdline_test.go
new file mode 100644
index 0000000..602f2bb
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/cmdline_test.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 godoc
+
+import (
+	"bytes"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"testing"
+	"text/template"
+
+	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/godoc/vfs/mapfs"
+)
+
+// setupGoroot creates temporary directory to act as GOROOT when running tests
+// that depend upon the build package.  It updates build.Default to point to the
+// new GOROOT.
+// It returns a function that can be called to reset build.Default and remove
+// the temporary directory.
+func setupGoroot(t *testing.T) (cleanup func()) {
+	var stdLib = map[string]string{
+		"src/fmt/fmt.go": `// Package fmt implements formatted I/O.
+package fmt
+
+type Stringer interface {
+	String() string
+}
+`,
+	}
+	goroot, err := ioutil.TempDir("", "cmdline_test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	origContext := build.Default
+	build.Default = build.Context{
+		GOROOT:   goroot,
+		Compiler: "gc",
+	}
+	for relname, contents := range stdLib {
+		name := filepath.Join(goroot, relname)
+		if err := os.MkdirAll(filepath.Dir(name), 0770); err != nil {
+			t.Fatal(err)
+		}
+		if err := ioutil.WriteFile(name, []byte(contents), 0770); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	return func() {
+		if err := os.RemoveAll(goroot); err != nil {
+			t.Log(err)
+		}
+		build.Default = origContext
+	}
+}
+
+func TestPaths(t *testing.T) {
+	cleanup := setupGoroot(t)
+	defer cleanup()
+
+	pres := &Presentation{
+		pkgHandler: handlerServer{
+			fsRoot: "/fsroot",
+		},
+	}
+	fs := make(vfs.NameSpace)
+
+	absPath := "/foo/fmt"
+	if runtime.GOOS == "windows" {
+		absPath = `c:\foo\fmt`
+	}
+
+	for _, tc := range []struct {
+		desc   string
+		path   string
+		expAbs string
+		expRel string
+	}{
+		{
+			"Absolute path",
+			absPath,
+			"/target",
+			"/target",
+		},
+		{
+			"Local import",
+			"../foo/fmt",
+			"/target",
+			"/target",
+		},
+		{
+			"Import",
+			"fmt",
+			"/target",
+			"fmt",
+		},
+		{
+			"Default",
+			"unknownpkg",
+			"/fsroot/unknownpkg",
+			"unknownpkg",
+		},
+	} {
+		abs, rel := paths(fs, pres, tc.path)
+		if abs != tc.expAbs || rel != tc.expRel {
+			t.Errorf("%s: paths(%q) = %s,%s; want %s,%s", tc.desc, tc.path, abs, rel, tc.expAbs, tc.expRel)
+		}
+	}
+}
+
+func TestMakeRx(t *testing.T) {
+	for _, tc := range []struct {
+		desc  string
+		names []string
+		exp   string
+	}{
+		{
+			desc:  "empty string",
+			names: []string{""},
+			exp:   `^$`,
+		},
+		{
+			desc:  "simple text",
+			names: []string{"a"},
+			exp:   `^a$`,
+		},
+		{
+			desc:  "two words",
+			names: []string{"foo", "bar"},
+			exp:   `^foo$|^bar$`,
+		},
+		{
+			desc:  "word & non-trivial",
+			names: []string{"foo", `ab?c`},
+			exp:   `^foo$|ab?c`,
+		},
+		{
+			desc:  "bad regexp",
+			names: []string{`(."`},
+			exp:   `(."`,
+		},
+	} {
+		expRE, expErr := regexp.Compile(tc.exp)
+		if re, err := makeRx(tc.names); !reflect.DeepEqual(err, expErr) && !reflect.DeepEqual(re, expRE) {
+			t.Errorf("%s: makeRx(%v) = %q,%q; want %q,%q", tc.desc, tc.names, re, err, expRE, expErr)
+		}
+	}
+}
+
+func TestCommandLine(t *testing.T) {
+	cleanup := setupGoroot(t)
+	defer cleanup()
+	mfs := mapfs.New(map[string]string{
+		"src/bar/bar.go": `// Package bar is an example.
+package bar
+`,
+		"src/foo/foo.go": `// Package foo.
+package foo
+
+// First function is first.
+func First() {
+}
+
+// Second function is second.
+func Second() {
+}
+`,
+		"src/gen/gen.go": `// Package gen
+package gen
+
+//line notgen.go:3
+// F doc //line 1 should appear
+// line 2 should appear
+func F()
+//line foo.go:100`, // no newline on end to check corner cases!
+		"src/vet/vet.go": `// Package vet
+package vet
+`,
+		"src/cmd/go/doc.go": `// The go command
+package main
+`,
+		"src/cmd/gofmt/doc.go": `// The gofmt command
+package main
+`,
+		"src/cmd/vet/vet.go": `// The vet command
+package main
+`,
+	})
+	fs := make(vfs.NameSpace)
+	fs.Bind("/", mfs, "/", vfs.BindReplace)
+	c := NewCorpus(fs)
+	p := &Presentation{Corpus: c}
+	p.cmdHandler = handlerServer{
+		p:       p,
+		c:       c,
+		pattern: "/cmd/",
+		fsRoot:  "/src/cmd",
+	}
+	p.pkgHandler = handlerServer{
+		p:       p,
+		c:       c,
+		pattern: "/pkg/",
+		fsRoot:  "/src",
+		exclude: []string{"/src/cmd"},
+	}
+	p.initFuncMap()
+	p.PackageText = template.Must(template.New("PackageText").Funcs(p.FuncMap()).Parse(`{{$info := .}}{{$filtered := .IsFiltered}}{{if $filtered}}{{range .PAst}}{{range .Decls}}{{node $info .}}{{end}}{{end}}{{else}}{{with .PAst}}{{range $filename, $ast := .}}{{$filename}}:
+{{node $ $ast}}{{end}}{{end}}{{end}}{{with .PDoc}}{{if $.IsMain}}COMMAND {{.Doc}}{{else}}PACKAGE {{.Doc}}{{end}}{{with .Funcs}}
+{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}{{end}}{{end}}{{end}}`))
+
+	for _, tc := range []struct {
+		desc string
+		args []string
+		exp  string
+		err  bool
+	}{
+		{
+			desc: "standard package",
+			args: []string{"fmt"},
+			exp:  "PACKAGE Package fmt implements formatted I/O.\n",
+		},
+		{
+			desc: "package",
+			args: []string{"bar"},
+			exp:  "PACKAGE Package bar is an example.\n",
+		},
+		{
+			desc: "package w. filter",
+			args: []string{"foo", "First"},
+			exp:  "PACKAGE \nfunc First()\n    First function is first.\n",
+		},
+		{
+			desc: "package w. bad filter",
+			args: []string{"foo", "DNE"},
+			exp:  "PACKAGE ",
+		},
+		{
+			desc: "source mode",
+			args: []string{"src/bar"},
+			exp:  "bar/bar.go:\n// Package bar is an example.\npackage bar\n",
+		},
+		{
+			desc: "source mode w. filter",
+			args: []string{"src/foo", "Second"},
+			exp:  "// Second function is second.\nfunc Second() {\n}",
+		},
+		{
+			desc: "package w. //line comments",
+			args: []string{"gen", "F"},
+			exp:  "PACKAGE \nfunc F()\n    F doc //line 1 should appear line 2 should appear\n",
+		},
+		{
+			desc: "command",
+			args: []string{"go"},
+			exp:  "COMMAND The go command\n",
+		},
+		{
+			desc: "forced command",
+			args: []string{"cmd/gofmt"},
+			exp:  "COMMAND The gofmt command\n",
+		},
+		{
+			desc: "bad arg",
+			args: []string{"doesnotexist"},
+			err:  true,
+		},
+		{
+			desc: "both command and package",
+			args: []string{"vet"},
+			exp:  "use 'godoc cmd/vet' for documentation on the vet command \n\nPACKAGE Package vet\n",
+		},
+		{
+			desc: "root directory",
+			args: []string{"/"},
+			exp:  "",
+		},
+	} {
+		w := new(bytes.Buffer)
+		err := CommandLine(w, fs, p, tc.args)
+		if got, want := w.String(), tc.exp; got != want || tc.err == (err == nil) {
+			t.Errorf("%s: CommandLine(%v) = %q (%v); want %q (%v)",
+				tc.desc, tc.args, got, err, want, tc.err)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/corpus.go b/vendor/golang.org/x/tools/godoc/corpus.go
new file mode 100644
index 0000000..8e38365
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/corpus.go
@@ -0,0 +1,164 @@
+// 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 godoc
+
+import (
+	"errors"
+	pathpkg "path"
+	"sync"
+	"time"
+
+	"golang.org/x/tools/godoc/analysis"
+	"golang.org/x/tools/godoc/util"
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// A Corpus holds all the state related to serving and indexing a
+// collection of Go code.
+//
+// Construct a new Corpus with NewCorpus, then modify options,
+// then call its Init method.
+type Corpus struct {
+	fs vfs.FileSystem
+
+	// Verbose logging.
+	Verbose bool
+
+	// IndexEnabled controls whether indexing is enabled.
+	IndexEnabled bool
+
+	// IndexFiles specifies a glob pattern specifying index files.
+	// If not empty, the index is read from these files in sorted
+	// order.
+	IndexFiles string
+
+	// IndexThrottle specifies the indexing throttle value
+	// between 0.0 and 1.0. At 0.0, the indexer always sleeps.
+	// At 1.0, the indexer never sleeps. Because 0.0 is useless
+	// and redundant with setting IndexEnabled to false, the
+	// zero value for IndexThrottle means 0.9.
+	IndexThrottle float64
+
+	// IndexInterval specifies the time to sleep between reindexing
+	// all the sources.
+	// If zero, a default is used. If negative, the index is only
+	// built once.
+	IndexInterval time.Duration
+
+	// IndexDocs enables indexing of Go documentation.
+	// This will produce search results for exported types, functions,
+	// methods, variables, and constants, and will link to the godoc
+	// documentation for those identifiers.
+	IndexDocs bool
+
+	// IndexGoCode enables indexing of Go source code.
+	// This will produce search results for internal and external identifiers
+	// and will link to both declarations and uses of those identifiers in
+	// source code.
+	IndexGoCode bool
+
+	// IndexFullText enables full-text indexing.
+	// This will provide search results for any matching text in any file that
+	// is indexed, including non-Go files (see whitelisted in index.go).
+	// Regexp searching is supported via full-text indexing.
+	IndexFullText bool
+
+	// MaxResults optionally specifies the maximum results for indexing.
+	MaxResults int
+
+	// SummarizePackage optionally specifies a function to
+	// summarize a package. It exists as an optimization to
+	// avoid reading files to parse package comments.
+	//
+	// If SummarizePackage returns false for ok, the caller
+	// ignores all return values and parses the files in the package
+	// as if SummarizePackage were nil.
+	//
+	// If showList is false, the package is hidden from the
+	// package listing.
+	SummarizePackage func(pkg string) (summary string, showList, ok bool)
+
+	// IndexDirectory optionally specifies a function to determine
+	// whether the provided directory should be indexed.  The dir
+	// will be of the form "/src/cmd/6a", "/doc/play",
+	// "/src/io", etc.
+	// If nil, all directories are indexed if indexing is enabled.
+	IndexDirectory func(dir string) bool
+
+	testDir string // TODO(bradfitz,adg): migrate old godoc flag? looks unused.
+
+	// Send a value on this channel to trigger a metadata refresh.
+	// It is buffered so that if a signal is not lost if sent
+	// during a refresh.
+	refreshMetadataSignal chan bool
+
+	// file system information
+	fsTree      util.RWValue // *Directory tree of packages, updated with each sync (but sync code is removed now)
+	fsModified  util.RWValue // timestamp of last call to invalidateIndex
+	docMetadata util.RWValue // mapping from paths to *Metadata
+
+	// SearchIndex is the search index in use.
+	searchIndex util.RWValue
+
+	// Analysis is the result of type and pointer analysis.
+	Analysis analysis.Result
+
+	// flag to check whether a corpus is initialized or not
+	initMu   sync.RWMutex
+	initDone bool
+}
+
+// NewCorpus returns a new Corpus from a filesystem.
+// The returned corpus has all indexing enabled and MaxResults set to 1000.
+// Change or set any options on Corpus before calling the Corpus.Init method.
+func NewCorpus(fs vfs.FileSystem) *Corpus {
+	c := &Corpus{
+		fs: fs,
+		refreshMetadataSignal: make(chan bool, 1),
+
+		MaxResults:    1000,
+		IndexEnabled:  true,
+		IndexDocs:     true,
+		IndexGoCode:   true,
+		IndexFullText: true,
+	}
+	return c
+}
+
+func (c *Corpus) CurrentIndex() (*Index, time.Time) {
+	v, t := c.searchIndex.Get()
+	idx, _ := v.(*Index)
+	return idx, t
+}
+
+func (c *Corpus) FSModifiedTime() time.Time {
+	_, ts := c.fsModified.Get()
+	return ts
+}
+
+// Init initializes Corpus, once options on Corpus are set.
+// It must be called before any subsequent method calls.
+func (c *Corpus) Init() error {
+	if err := c.initFSTree(); err != nil {
+		return err
+	}
+	c.updateMetadata()
+	go c.refreshMetadataLoop()
+
+	c.initMu.Lock()
+	c.initDone = true
+	c.initMu.Unlock()
+	return nil
+}
+
+func (c *Corpus) initFSTree() error {
+	dir := c.newDirectory(pathpkg.Join("/", c.testDir), -1)
+	if dir == nil {
+		return errors.New("godoc: corpus fstree is nil")
+	}
+	c.fsTree.Set(dir)
+	c.invalidateIndex()
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/godoc/dirtrees.go b/vendor/golang.org/x/tools/godoc/dirtrees.go
new file mode 100644
index 0000000..2b14a41
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/dirtrees.go
@@ -0,0 +1,342 @@
+// Copyright 2010 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 contains the code dealing with package directory trees.
+
+package godoc
+
+import (
+	"go/doc"
+	"go/parser"
+	"go/token"
+	"log"
+	"os"
+	pathpkg "path"
+	"strings"
+)
+
+// Conventional name for directories containing test data.
+// Excluded from directory trees.
+//
+const testdataDirName = "testdata"
+
+type Directory struct {
+	Depth    int
+	Path     string       // directory path; includes Name
+	Name     string       // directory name
+	HasPkg   bool         // true if the directory contains at least one package
+	Synopsis string       // package documentation, if any
+	Dirs     []*Directory // subdirectories
+}
+
+func isGoFile(fi os.FileInfo) bool {
+	name := fi.Name()
+	return !fi.IsDir() &&
+		len(name) > 0 && name[0] != '.' && // ignore .files
+		pathpkg.Ext(name) == ".go"
+}
+
+func isPkgFile(fi os.FileInfo) bool {
+	return isGoFile(fi) &&
+		!strings.HasSuffix(fi.Name(), "_test.go") // ignore test files
+}
+
+func isPkgDir(fi os.FileInfo) bool {
+	name := fi.Name()
+	return fi.IsDir() && len(name) > 0 &&
+		name[0] != '_' && name[0] != '.' // ignore _files and .files
+}
+
+type treeBuilder struct {
+	c        *Corpus
+	maxDepth int
+}
+
+// ioGate is a semaphore controlling VFS activity (ReadDir, parseFile, etc).
+// Send before an operation and receive after.
+var ioGate = make(chan bool, 20)
+
+func (b *treeBuilder) newDirTree(fset *token.FileSet, path, name string, depth int) *Directory {
+	if name == testdataDirName {
+		return nil
+	}
+
+	if depth >= b.maxDepth {
+		// return a dummy directory so that the parent directory
+		// doesn't get discarded just because we reached the max
+		// directory depth
+		return &Directory{
+			Depth: depth,
+			Path:  path,
+			Name:  name,
+		}
+	}
+
+	var synopses [3]string // prioritized package documentation (0 == highest priority)
+
+	show := true // show in package listing
+	hasPkgFiles := false
+	haveSummary := false
+
+	if hook := b.c.SummarizePackage; hook != nil {
+		if summary, show0, ok := hook(strings.TrimPrefix(path, "/src/")); ok {
+			hasPkgFiles = true
+			show = show0
+			synopses[0] = summary
+			haveSummary = true
+		}
+	}
+
+	ioGate <- true
+	list, err := b.c.fs.ReadDir(path)
+	<-ioGate
+	if err != nil {
+		// TODO: propagate more. See golang.org/issue/14252.
+		// For now:
+		if b.c.Verbose {
+			log.Printf("newDirTree reading %s: %v", path, err)
+		}
+	}
+
+	// determine number of subdirectories and if there are package files
+	var dirchs []chan *Directory
+
+	for _, d := range list {
+		filename := pathpkg.Join(path, d.Name())
+		switch {
+		case isPkgDir(d):
+			ch := make(chan *Directory, 1)
+			dirchs = append(dirchs, ch)
+			name := d.Name()
+			go func() {
+				ch <- b.newDirTree(fset, filename, name, depth+1)
+			}()
+		case !haveSummary && isPkgFile(d):
+			// looks like a package file, but may just be a file ending in ".go";
+			// don't just count it yet (otherwise we may end up with hasPkgFiles even
+			// though the directory doesn't contain any real package files - was bug)
+			// no "optimal" package synopsis yet; continue to collect synopses
+			ioGate <- true
+			const flags = parser.ParseComments | parser.PackageClauseOnly
+			file, err := b.c.parseFile(fset, filename, flags)
+			<-ioGate
+			if err != nil {
+				if b.c.Verbose {
+					log.Printf("Error parsing %v: %v", filename, err)
+				}
+				break
+			}
+
+			hasPkgFiles = true
+			if file.Doc != nil {
+				// prioritize documentation
+				i := -1
+				switch file.Name.Name {
+				case name:
+					i = 0 // normal case: directory name matches package name
+				case "main":
+					i = 1 // directory contains a main package
+				default:
+					i = 2 // none of the above
+				}
+				if 0 <= i && i < len(synopses) && synopses[i] == "" {
+					synopses[i] = doc.Synopsis(file.Doc.Text())
+				}
+			}
+			haveSummary = synopses[0] != ""
+		}
+	}
+
+	// create subdirectory tree
+	var dirs []*Directory
+	for _, ch := range dirchs {
+		if d := <-ch; d != nil {
+			dirs = append(dirs, d)
+		}
+	}
+
+	// if there are no package files and no subdirectories
+	// containing package files, ignore the directory
+	if !hasPkgFiles && len(dirs) == 0 {
+		return nil
+	}
+
+	// select the highest-priority synopsis for the directory entry, if any
+	synopsis := ""
+	for _, synopsis = range synopses {
+		if synopsis != "" {
+			break
+		}
+	}
+
+	return &Directory{
+		Depth:    depth,
+		Path:     path,
+		Name:     name,
+		HasPkg:   hasPkgFiles && show, // TODO(bradfitz): add proper Hide field?
+		Synopsis: synopsis,
+		Dirs:     dirs,
+	}
+}
+
+// newDirectory creates a new package directory tree with at most maxDepth
+// levels, anchored at root. The result tree is pruned such that it only
+// contains directories that contain package files or that contain
+// subdirectories containing package files (transitively). If a non-nil
+// pathFilter is provided, directory paths additionally must be accepted
+// by the filter (i.e., pathFilter(path) must be true). If a value >= 0 is
+// provided for maxDepth, nodes at larger depths are pruned as well; they
+// are assumed to contain package files even if their contents are not known
+// (i.e., in this case the tree may contain directories w/o any package files).
+//
+func (c *Corpus) newDirectory(root string, maxDepth int) *Directory {
+	// The root could be a symbolic link so use Stat not Lstat.
+	d, err := c.fs.Stat(root)
+	// If we fail here, report detailed error messages; otherwise
+	// is is hard to see why a directory tree was not built.
+	switch {
+	case err != nil:
+		log.Printf("newDirectory(%s): %s", root, err)
+		return nil
+	case root != "/" && !isPkgDir(d):
+		log.Printf("newDirectory(%s): not a package directory", root)
+		return nil
+	case root == "/" && !d.IsDir():
+		log.Printf("newDirectory(%s): not a directory", root)
+		return nil
+	}
+	if maxDepth < 0 {
+		maxDepth = 1e6 // "infinity"
+	}
+	b := treeBuilder{c, maxDepth}
+	// the file set provided is only for local parsing, no position
+	// information escapes and thus we don't need to save the set
+	return b.newDirTree(token.NewFileSet(), root, d.Name(), 0)
+}
+
+func (dir *Directory) walk(c chan<- *Directory, skipRoot bool) {
+	if dir != nil {
+		if !skipRoot {
+			c <- dir
+		}
+		for _, d := range dir.Dirs {
+			d.walk(c, false)
+		}
+	}
+}
+
+func (dir *Directory) iter(skipRoot bool) <-chan *Directory {
+	c := make(chan *Directory)
+	go func() {
+		dir.walk(c, skipRoot)
+		close(c)
+	}()
+	return c
+}
+
+func (dir *Directory) lookupLocal(name string) *Directory {
+	for _, d := range dir.Dirs {
+		if d.Name == name {
+			return d
+		}
+	}
+	return nil
+}
+
+func splitPath(p string) []string {
+	p = strings.TrimPrefix(p, "/")
+	if p == "" {
+		return nil
+	}
+	return strings.Split(p, "/")
+}
+
+// lookup looks for the *Directory for a given path, relative to dir.
+func (dir *Directory) lookup(path string) *Directory {
+	d := splitPath(dir.Path)
+	p := splitPath(path)
+	i := 0
+	for i < len(d) {
+		if i >= len(p) || d[i] != p[i] {
+			return nil
+		}
+		i++
+	}
+	for dir != nil && i < len(p) {
+		dir = dir.lookupLocal(p[i])
+		i++
+	}
+	return dir
+}
+
+// DirEntry describes a directory entry. The Depth and Height values
+// are useful for presenting an entry in an indented fashion.
+//
+type DirEntry struct {
+	Depth    int    // >= 0
+	Height   int    // = DirList.MaxHeight - Depth, > 0
+	Path     string // directory path; includes Name, relative to DirList root
+	Name     string // directory name
+	HasPkg   bool   // true if the directory contains at least one package
+	Synopsis string // package documentation, if any
+}
+
+type DirList struct {
+	MaxHeight int // directory tree height, > 0
+	List      []DirEntry
+}
+
+// listing creates a (linear) directory listing from a directory tree.
+// If skipRoot is set, the root directory itself is excluded from the list.
+// If filter is set, only the directory entries whose paths match the filter
+// are included.
+//
+func (root *Directory) listing(skipRoot bool, filter func(string) bool) *DirList {
+	if root == nil {
+		return nil
+	}
+
+	// determine number of entries n and maximum height
+	n := 0
+	minDepth := 1 << 30 // infinity
+	maxDepth := 0
+	for d := range root.iter(skipRoot) {
+		n++
+		if minDepth > d.Depth {
+			minDepth = d.Depth
+		}
+		if maxDepth < d.Depth {
+			maxDepth = d.Depth
+		}
+	}
+	maxHeight := maxDepth - minDepth + 1
+
+	if n == 0 {
+		return nil
+	}
+
+	// create list
+	list := make([]DirEntry, 0, n)
+	for d := range root.iter(skipRoot) {
+		if filter != nil && !filter(d.Path) {
+			continue
+		}
+		var p DirEntry
+		p.Depth = d.Depth - minDepth
+		p.Height = maxHeight - p.Depth
+		// the path is relative to root.Path - remove the root.Path
+		// prefix (the prefix should always be present but avoid
+		// crashes and check)
+		path := strings.TrimPrefix(d.Path, root.Path)
+		// remove leading separator if any - path must be relative
+		path = strings.TrimPrefix(path, "/")
+		p.Path = path
+		p.Name = d.Name
+		p.HasPkg = d.HasPkg
+		p.Synopsis = d.Synopsis
+		list = append(list, p)
+	}
+
+	return &DirList{maxHeight, list}
+}
diff --git a/vendor/golang.org/x/tools/godoc/dl/dl.go b/vendor/golang.org/x/tools/godoc/dl/dl.go
new file mode 100644
index 0000000..f5e6320
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/dl/dl.go
@@ -0,0 +1,558 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+// Package dl implements a simple downloads frontend server.
+//
+// It accepts HTTP POST requests to create a new download metadata entity, and
+// lists entities with sorting and filtering.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package dl
+
+import (
+	"crypto/hmac"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io"
+	"net/http"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/net/context"
+
+	"google.golang.org/appengine"
+	"google.golang.org/appengine/datastore"
+	"google.golang.org/appengine/log"
+	"google.golang.org/appengine/memcache"
+)
+
+const (
+	downloadBaseURL = "https://dl.google.com/go/"
+	cacheKey        = "download_list_3" // increment if listTemplateData changes
+	cacheDuration   = time.Hour
+)
+
+func RegisterHandlers(mux *http.ServeMux) {
+	mux.Handle("/dl", http.RedirectHandler("/dl/", http.StatusFound))
+	mux.HandleFunc("/dl/", getHandler) // also serves listHandler
+	mux.HandleFunc("/dl/upload", uploadHandler)
+	mux.HandleFunc("/dl/init", initHandler)
+}
+
+type File struct {
+	Filename       string    `json:"filename"`
+	OS             string    `json:"os"`
+	Arch           string    `json:"arch"`
+	Version        string    `json:"-"`
+	Checksum       string    `json:"-" datastore:",noindex"` // SHA1; deprecated
+	ChecksumSHA256 string    `json:"sha256" datastore:",noindex"`
+	Size           int64     `json:"size" datastore:",noindex"`
+	Kind           string    `json:"kind"` // "archive", "installer", "source"
+	Uploaded       time.Time `json:"-"`
+}
+
+func (f File) ChecksumType() string {
+	if f.ChecksumSHA256 != "" {
+		return "SHA256"
+	}
+	return "SHA1"
+}
+
+func (f File) PrettyChecksum() string {
+	if f.ChecksumSHA256 != "" {
+		return f.ChecksumSHA256
+	}
+	return f.Checksum
+}
+
+func (f File) PrettyOS() string {
+	if f.OS == "darwin" {
+		switch {
+		case strings.Contains(f.Filename, "osx10.8"):
+			return "OS X 10.8+"
+		case strings.Contains(f.Filename, "osx10.6"):
+			return "OS X 10.6+"
+		}
+	}
+	return pretty(f.OS)
+}
+
+func (f File) PrettySize() string {
+	const mb = 1 << 20
+	if f.Size == 0 {
+		return ""
+	}
+	if f.Size < mb {
+		// All Go releases are >1mb, but handle this case anyway.
+		return fmt.Sprintf("%v bytes", f.Size)
+	}
+	return fmt.Sprintf("%.0fMB", float64(f.Size)/mb)
+}
+
+var primaryPorts = map[string]bool{
+	"darwin/amd64":  true,
+	"linux/386":     true,
+	"linux/amd64":   true,
+	"linux/armv6l":  true,
+	"windows/386":   true,
+	"windows/amd64": true,
+}
+
+func (f File) PrimaryPort() bool {
+	if f.Kind == "source" {
+		return true
+	}
+	return primaryPorts[f.OS+"/"+f.Arch]
+}
+
+func (f File) Highlight() bool {
+	switch {
+	case f.Kind == "source":
+		return true
+	case f.Arch == "amd64" && f.OS == "linux":
+		return true
+	case f.Arch == "amd64" && f.Kind == "installer":
+		switch f.OS {
+		case "windows":
+			return true
+		case "darwin":
+			if !strings.Contains(f.Filename, "osx10.6") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (f File) URL() string {
+	return downloadBaseURL + f.Filename
+}
+
+type Release struct {
+	Version        string `json:"version"`
+	Stable         bool   `json:"stable"`
+	Files          []File `json:"files"`
+	Visible        bool   `json:"-"` // show files on page load
+	SplitPortTable bool   `json:"-"` // whether files should be split by primary/other ports.
+}
+
+type Feature struct {
+	// The File field will be filled in by the first stable File
+	// whose name matches the given fileRE.
+	File
+	fileRE *regexp.Regexp
+
+	Platform     string // "Microsoft Windows", "Apple macOS", "Linux"
+	Requirements string // "Windows XP and above, 64-bit Intel Processor"
+}
+
+// featuredFiles lists the platforms and files to be featured
+// at the top of the downloads page.
+var featuredFiles = []Feature{
+	{
+		Platform:     "Microsoft Windows",
+		Requirements: "Windows XP SP3 or later, Intel 64-bit processor",
+		fileRE:       regexp.MustCompile(`\.windows-amd64\.msi$`),
+	},
+	{
+		Platform:     "Apple macOS",
+		Requirements: "macOS 10.8 or later, Intel 64-bit processor",
+		fileRE:       regexp.MustCompile(`\.darwin-amd64(-osx10\.8)?\.pkg$`),
+	},
+	{
+		Platform:     "Linux",
+		Requirements: "Linux 2.6.23 or later, Intel 64-bit processor",
+		fileRE:       regexp.MustCompile(`\.linux-amd64\.tar\.gz$`),
+	},
+	{
+		Platform: "Source",
+		fileRE:   regexp.MustCompile(`\.src\.tar\.gz$`),
+	},
+}
+
+// data to send to the template; increment cacheKey if you change this.
+type listTemplateData struct {
+	Featured                  []Feature
+	Stable, Unstable, Archive []Release
+}
+
+var (
+	listTemplate  = template.Must(template.New("").Funcs(templateFuncs).Parse(templateHTML))
+	templateFuncs = template.FuncMap{"pretty": pretty}
+)
+
+func listHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var (
+		c = appengine.NewContext(r)
+		d listTemplateData
+	)
+	if _, err := memcache.Gob.Get(c, cacheKey, &d); err != nil {
+		if err == memcache.ErrCacheMiss {
+			log.Debugf(c, "cache miss")
+		} else {
+			log.Errorf(c, "cache get error: %v", err)
+		}
+
+		var fs []File
+		_, err := datastore.NewQuery("File").Ancestor(rootKey(c)).GetAll(c, &fs)
+		if err != nil {
+			log.Errorf(c, "error listing: %v", err)
+			return
+		}
+		d.Stable, d.Unstable, d.Archive = filesToReleases(fs)
+		if len(d.Stable) > 0 {
+			d.Featured = filesToFeatured(d.Stable[0].Files)
+		}
+
+		item := &memcache.Item{Key: cacheKey, Object: &d, Expiration: cacheDuration}
+		if err := memcache.Gob.Set(c, item); err != nil {
+			log.Errorf(c, "cache set error: %v", err)
+		}
+	}
+
+	if r.URL.Query().Get("mode") == "json" {
+		w.Header().Set("Content-Type", "application/json")
+		enc := json.NewEncoder(w)
+		enc.SetIndent("", " ")
+		if err := enc.Encode(d.Stable); err != nil {
+			log.Errorf(c, "failed rendering JSON for releases: %v", err)
+		}
+		return
+	}
+
+	if err := listTemplate.ExecuteTemplate(w, "root", d); err != nil {
+		log.Errorf(c, "error executing template: %v", err)
+	}
+}
+
+func filesToFeatured(fs []File) (featured []Feature) {
+	for _, feature := range featuredFiles {
+		for _, file := range fs {
+			if feature.fileRE.MatchString(file.Filename) {
+				feature.File = file
+				featured = append(featured, feature)
+				break
+			}
+		}
+	}
+	return
+}
+
+func filesToReleases(fs []File) (stable, unstable, archive []Release) {
+	sort.Sort(fileOrder(fs))
+
+	var r *Release
+	var stableMaj, stableMin int
+	add := func() {
+		if r == nil {
+			return
+		}
+		if !r.Stable {
+			if len(unstable) != 0 {
+				// Only show one (latest) unstable version.
+				return
+			}
+			maj, min, _ := parseVersion(r.Version)
+			if maj < stableMaj || maj == stableMaj && min <= stableMin {
+				// Display unstable version only if newer than the
+				// latest stable release.
+				return
+			}
+			unstable = append(unstable, *r)
+		}
+
+		// Reports whether the release is the most recent minor version of the
+		// two most recent major versions.
+		shouldAddStable := func() bool {
+			if len(stable) >= 2 {
+				// Show up to two stable versions.
+				return false
+			}
+			if len(stable) == 0 {
+				// Most recent stable version.
+				stableMaj, stableMin, _ = parseVersion(r.Version)
+				return true
+			}
+			if maj, _, _ := parseVersion(r.Version); maj == stableMaj {
+				// Older minor version of most recent major version.
+				return false
+			}
+			// Second most recent stable version.
+			return true
+		}
+		if !shouldAddStable() {
+			archive = append(archive, *r)
+			return
+		}
+
+		// Split the file list into primary/other ports for the stable releases.
+		// NOTE(cbro): This is only done for stable releases because maintaining the historical
+		// nature of primary/other ports for older versions is infeasible.
+		// If freebsd is considered primary some time in the future, we'd not want to
+		// mark all of the older freebsd binaries as "primary".
+		// It might be better if we set that as a flag when uploading.
+		r.SplitPortTable = true
+		r.Visible = true // Toggle open all stable releases.
+		stable = append(stable, *r)
+	}
+	for _, f := range fs {
+		if r == nil || f.Version != r.Version {
+			add()
+			r = &Release{
+				Version: f.Version,
+				Stable:  isStable(f.Version),
+			}
+		}
+		r.Files = append(r.Files, f)
+	}
+	add()
+	return
+}
+
+// isStable reports whether the version string v is a stable version.
+func isStable(v string) bool {
+	return !strings.Contains(v, "beta") && !strings.Contains(v, "rc")
+}
+
+type fileOrder []File
+
+func (s fileOrder) Len() int      { return len(s) }
+func (s fileOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s fileOrder) Less(i, j int) bool {
+	a, b := s[i], s[j]
+	if av, bv := a.Version, b.Version; av != bv {
+		return versionLess(av, bv)
+	}
+	if a.OS != b.OS {
+		return a.OS < b.OS
+	}
+	if a.Arch != b.Arch {
+		return a.Arch < b.Arch
+	}
+	if a.Kind != b.Kind {
+		return a.Kind < b.Kind
+	}
+	return a.Filename < b.Filename
+}
+
+func versionLess(a, b string) bool {
+	// Put stable releases first.
+	if isStable(a) != isStable(b) {
+		return isStable(a)
+	}
+	maja, mina, ta := parseVersion(a)
+	majb, minb, tb := parseVersion(b)
+	if maja == majb {
+		if mina == minb {
+			return ta >= tb
+		}
+		return mina >= minb
+	}
+	return maja >= majb
+}
+
+func parseVersion(v string) (maj, min int, tail string) {
+	if i := strings.Index(v, "beta"); i > 0 {
+		tail = v[i:]
+		v = v[:i]
+	}
+	if i := strings.Index(v, "rc"); i > 0 {
+		tail = v[i:]
+		v = v[:i]
+	}
+	p := strings.Split(strings.TrimPrefix(v, "go1."), ".")
+	maj, _ = strconv.Atoi(p[0])
+	if len(p) < 2 {
+		return
+	}
+	min, _ = strconv.Atoi(p[1])
+	return
+}
+
+func uploadHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	c := appengine.NewContext(r)
+
+	// Authenticate using a user token (same as gomote).
+	user := r.FormValue("user")
+	if !validUser(user) {
+		http.Error(w, "bad user", http.StatusForbidden)
+		return
+	}
+	if r.FormValue("key") != userKey(c, user) {
+		http.Error(w, "bad key", http.StatusForbidden)
+		return
+	}
+
+	var f File
+	defer r.Body.Close()
+	if err := json.NewDecoder(r.Body).Decode(&f); err != nil {
+		log.Errorf(c, "error decoding upload JSON: %v", err)
+		http.Error(w, "Something broke", http.StatusInternalServerError)
+		return
+	}
+	if f.Filename == "" {
+		http.Error(w, "Must provide Filename", http.StatusBadRequest)
+		return
+	}
+	if f.Uploaded.IsZero() {
+		f.Uploaded = time.Now()
+	}
+	k := datastore.NewKey(c, "File", f.Filename, 0, rootKey(c))
+	if _, err := datastore.Put(c, k, &f); err != nil {
+		log.Errorf(c, "putting File entity: %v", err)
+		http.Error(w, "could not put File entity", http.StatusInternalServerError)
+		return
+	}
+	if err := memcache.Delete(c, cacheKey); err != nil {
+		log.Errorf(c, "cache delete error: %v", err)
+	}
+	io.WriteString(w, "OK")
+}
+
+func getHandler(w http.ResponseWriter, r *http.Request) {
+	name := strings.TrimPrefix(r.URL.Path, "/dl/")
+	if name == "" {
+		listHandler(w, r)
+		return
+	}
+	if !fileRe.MatchString(name) {
+		http.NotFound(w, r)
+		return
+	}
+	http.Redirect(w, r, downloadBaseURL+name, http.StatusFound)
+}
+
+func validUser(user string) bool {
+	switch user {
+	case "adg", "bradfitz", "cbro", "andybons":
+		return true
+	}
+	return false
+}
+
+func userKey(c context.Context, user string) string {
+	h := hmac.New(md5.New, []byte(secret(c)))
+	h.Write([]byte("user-" + user))
+	return fmt.Sprintf("%x", h.Sum(nil))
+}
+
+var fileRe = regexp.MustCompile(`^go[0-9a-z.]+\.[0-9a-z.-]+\.(tar\.gz|pkg|msi|zip)$`)
+
+func initHandler(w http.ResponseWriter, r *http.Request) {
+	var fileRoot struct {
+		Root string
+	}
+	c := appengine.NewContext(r)
+	k := rootKey(c)
+	err := datastore.RunInTransaction(c, func(c context.Context) error {
+		err := datastore.Get(c, k, &fileRoot)
+		if err != nil && err != datastore.ErrNoSuchEntity {
+			return err
+		}
+		_, err = datastore.Put(c, k, &fileRoot)
+		return err
+	}, nil)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+	io.WriteString(w, "OK")
+}
+
+// rootKey is the ancestor of all File entities.
+func rootKey(c context.Context) *datastore.Key {
+	return datastore.NewKey(c, "FileRoot", "root", 0, nil)
+}
+
+// pretty returns a human-readable version of the given OS, Arch, or Kind.
+func pretty(s string) string {
+	t, ok := prettyStrings[s]
+	if !ok {
+		return s
+	}
+	return t
+}
+
+var prettyStrings = map[string]string{
+	"darwin":  "macOS",
+	"freebsd": "FreeBSD",
+	"linux":   "Linux",
+	"windows": "Windows",
+
+	"386":    "x86",
+	"amd64":  "x86-64",
+	"armv6l": "ARMv6",
+	"arm64":  "ARMv8",
+
+	"archive":   "Archive",
+	"installer": "Installer",
+	"source":    "Source",
+}
+
+// Code below copied from x/build/app/key
+
+var theKey struct {
+	sync.RWMutex
+	builderKey
+}
+
+type builderKey struct {
+	Secret string
+}
+
+func (k *builderKey) Key(c context.Context) *datastore.Key {
+	return datastore.NewKey(c, "BuilderKey", "root", 0, nil)
+}
+
+func secret(c context.Context) string {
+	// check with rlock
+	theKey.RLock()
+	k := theKey.Secret
+	theKey.RUnlock()
+	if k != "" {
+		return k
+	}
+
+	// prepare to fill; check with lock and keep lock
+	theKey.Lock()
+	defer theKey.Unlock()
+	if theKey.Secret != "" {
+		return theKey.Secret
+	}
+
+	// fill
+	if err := datastore.Get(c, theKey.Key(c), &theKey.builderKey); err != nil {
+		if err == datastore.ErrNoSuchEntity {
+			// If the key is not stored in datastore, write it.
+			// This only happens at the beginning of a new deployment.
+			// The code is left here for SDK use and in case a fresh
+			// deployment is ever needed.  "gophers rule" is not the
+			// real key.
+			if !appengine.IsDevAppServer() {
+				panic("lost key from datastore")
+			}
+			theKey.Secret = "gophers rule"
+			datastore.Put(c, theKey.Key(c), &theKey.builderKey)
+			return theKey.Secret
+		}
+		panic("cannot load builder key: " + err.Error())
+	}
+
+	return theKey.Secret
+}
diff --git a/vendor/golang.org/x/tools/godoc/dl/dl_test.go b/vendor/golang.org/x/tools/godoc/dl/dl_test.go
new file mode 100644
index 0000000..3f61fe9
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/dl/dl_test.go
@@ -0,0 +1,137 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package dl
+
+import (
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestParseVersion(t *testing.T) {
+	for _, c := range []struct {
+		in       string
+		maj, min int
+		tail     string
+	}{
+		{"go1.5", 5, 0, ""},
+		{"go1.5beta1", 5, 0, "beta1"},
+		{"go1.5.1", 5, 1, ""},
+		{"go1.5.1rc1", 5, 1, "rc1"},
+	} {
+		maj, min, tail := parseVersion(c.in)
+		if maj != c.maj || min != c.min || tail != c.tail {
+			t.Errorf("parseVersion(%q) = %v, %v, %q; want %v, %v, %q",
+				c.in, maj, min, tail, c.maj, c.min, c.tail)
+		}
+	}
+}
+
+func TestFileOrder(t *testing.T) {
+	fs := []File{
+		{Filename: "go1.3.src.tar.gz", Version: "go1.3", OS: "", Arch: "", Kind: "source"},
+		{Filename: "go1.3.1.src.tar.gz", Version: "go1.3.1", OS: "", Arch: "", Kind: "source"},
+		{Filename: "go1.3.linux-amd64.tar.gz", Version: "go1.3", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.3.1.linux-amd64.tar.gz", Version: "go1.3.1", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.3.darwin-amd64.tar.gz", Version: "go1.3", OS: "darwin", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.3.darwin-amd64.pkg", Version: "go1.3", OS: "darwin", Arch: "amd64", Kind: "installer"},
+		{Filename: "go1.3.darwin-386.tar.gz", Version: "go1.3", OS: "darwin", Arch: "386", Kind: "archive"},
+		{Filename: "go1.3beta1.linux-amd64.tar.gz", Version: "go1.3beta1", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.3beta2.linux-amd64.tar.gz", Version: "go1.3beta2", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.3rc1.linux-amd64.tar.gz", Version: "go1.3rc1", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.2.linux-amd64.tar.gz", Version: "go1.2", OS: "linux", Arch: "amd64", Kind: "archive"},
+		{Filename: "go1.2.2.linux-amd64.tar.gz", Version: "go1.2.2", OS: "linux", Arch: "amd64", Kind: "archive"},
+	}
+	sort.Sort(fileOrder(fs))
+	var s []string
+	for _, f := range fs {
+		s = append(s, f.Filename)
+	}
+	got := strings.Join(s, "\n")
+	want := strings.Join([]string{
+		"go1.3.1.src.tar.gz",
+		"go1.3.1.linux-amd64.tar.gz",
+		"go1.3.src.tar.gz",
+		"go1.3.darwin-386.tar.gz",
+		"go1.3.darwin-amd64.tar.gz",
+		"go1.3.darwin-amd64.pkg",
+		"go1.3.linux-amd64.tar.gz",
+		"go1.2.2.linux-amd64.tar.gz",
+		"go1.2.linux-amd64.tar.gz",
+		"go1.3rc1.linux-amd64.tar.gz",
+		"go1.3beta2.linux-amd64.tar.gz",
+		"go1.3beta1.linux-amd64.tar.gz",
+	}, "\n")
+	if got != want {
+		t.Errorf("sort order is\n%s\nwant:\n%s", got, want)
+	}
+}
+
+func TestFilesToReleases(t *testing.T) {
+	fs := []File{
+		{Version: "go1.7.4", OS: "darwin"},
+		{Version: "go1.7.4", OS: "windows"},
+		{Version: "go1.7", OS: "darwin"},
+		{Version: "go1.7", OS: "windows"},
+		{Version: "go1.6.2", OS: "darwin"},
+		{Version: "go1.6.2", OS: "windows"},
+		{Version: "go1.6", OS: "darwin"},
+		{Version: "go1.6", OS: "windows"},
+		{Version: "go1.5.2", OS: "darwin"},
+		{Version: "go1.5.2", OS: "windows"},
+		{Version: "go1.5", OS: "darwin"},
+		{Version: "go1.5", OS: "windows"},
+		{Version: "go1.5beta1", OS: "windows"},
+	}
+	stable, unstable, archive := filesToReleases(fs)
+	if got, want := len(stable), 2; want != got {
+		t.Errorf("len(stable): got %v, want %v", got, want)
+	} else {
+		if got, want := stable[0].Version, "go1.7.4"; want != got {
+			t.Errorf("stable[0].Version: got %v, want %v", got, want)
+		}
+		if got, want := stable[1].Version, "go1.6.2"; want != got {
+			t.Errorf("stable[1].Version: got %v, want %v", got, want)
+		}
+	}
+	if got, want := len(unstable), 0; want != got {
+		t.Errorf("len(unstable): got %v, want %v", got, want)
+	}
+	if got, want := len(archive), 4; want != got {
+		t.Errorf("len(archive): got %v, want %v", got, want)
+	}
+}
+
+func TestOldUnstableNotShown(t *testing.T) {
+	fs := []File{
+		{Version: "go1.7.4"},
+		{Version: "go1.7"},
+		{Version: "go1.7beta1"},
+	}
+	_, unstable, _ := filesToReleases(fs)
+	if len(unstable) != 0 {
+		t.Errorf("got unstable, want none")
+	}
+}
+
+func TestUnstableShown(t *testing.T) {
+	fs := []File{
+		{Version: "go1.8beta2"},
+		{Version: "go1.8rc1"},
+		{Version: "go1.7.4"},
+		{Version: "go1.7"},
+		{Version: "go1.7beta1"},
+	}
+	_, unstable, _ := filesToReleases(fs)
+	if got, want := len(unstable), 1; got != want {
+		t.Fatalf("len(unstable): got %v, want %v", got, want)
+	}
+	// show rcs ahead of betas.
+	if got, want := unstable[0].Version, "go1.8rc1"; got != want {
+		t.Fatalf("unstable[0].Version: got %v, want %v", got, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/dl/tmpl.go b/vendor/golang.org/x/tools/godoc/dl/tmpl.go
new file mode 100644
index 0000000..c5df742
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/dl/tmpl.go
@@ -0,0 +1,279 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package dl
+
+// TODO(adg): refactor this to use the tools/godoc/static template.
+
+const templateHTML = `
+{{define "root"}}
+<!DOCTYPE html>
+<html>
+<head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+        <title>Downloads - The Go Programming Language</title>
+        <link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+        <script type="text/javascript">window.initFuncs = [];</script>
+	<style>
+		table.codetable {
+			margin-left: 20px; margin-right: 20px;
+			border-collapse: collapse;
+		}
+		table.codetable tr {
+			background-color: #f0f0f0;
+		}
+		table.codetable tr:nth-child(2n), table.codetable tr.first {
+			background-color: white;
+		}
+		table.codetable td, table.codetable th {
+			white-space: nowrap;
+			padding: 6px 10px;
+		}
+		table.codetable tt {
+			font-size: xx-small;
+		}
+		table.codetable tr.highlight td {
+			font-weight: bold;
+		}
+		a.downloadBox {
+			display: block;
+			color: #222;
+			border: 1px solid #375EAB;
+			border-radius: 5px;
+			background: #E0EBF5;
+			width: 280px;
+			float: left;
+			margin-left: 10px;
+			margin-bottom: 10px;
+			padding: 10px;
+		}
+		a.downloadBox:hover {
+			text-decoration: none;
+		}
+		.downloadBox .platform {
+			font-size: large;
+		}
+		.downloadBox .filename {
+			color: #375EAB;
+			font-weight: bold;
+			line-height: 1.5em;
+		}
+		a.downloadBox:hover .filename {
+			text-decoration: underline;
+		}
+		.downloadBox .size {
+			font-size: small;
+			font-weight: normal;
+		}
+		.downloadBox .reqs {
+			font-size: small;
+			font-style: italic;
+		}
+		.downloadBox .checksum {
+			font-size: 5pt;
+		}
+	</style>
+</head>
+<body>
+
+<div id="topbar"><div class="container">
+
+<div class="top-heading"><a href="/">The Go Programming Language</a></div>
+<form method="GET" action="/search">
+<div id="menu">
+<a href="/doc/">Documents</a>
+<a href="/pkg/">Packages</a>
+<a href="/project/">The Project</a>
+<a href="/help/">Help</a>
+<a href="/blog/">Blog</a>
+<span class="search-box"><input type="search" id="search" name="q" placeholder="Search" aria-label="Search" required><button type="submit"><span><!-- magnifying glass: --><svg width="24" height="24" viewBox="0 0 24 24"><title>submit search</title><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/><path d="M0 0h24v24H0z" fill="none"/></svg></span></button></span>
+</div>
+</form>
+
+</div></div>
+
+<div id="page">
+<div class="container">
+
+<h1>Downloads</h1>
+
+<p>
+After downloading a binary release suitable for your system,
+please follow the <a href="/doc/install">installation instructions</a>.
+</p>
+
+<p>
+If you are building from source,
+follow the <a href="/doc/install/source">source installation instructions</a>.
+</p>
+
+<p>
+See the <a href="/doc/devel/release.html">release history</a> for more
+information about Go releases.
+</p>
+
+{{with .Featured}}
+<h3 id="featured">Featured downloads</h3>
+{{range .}}
+{{template "download" .}}
+{{end}}
+{{end}}
+
+<div style="clear: both;"></div>
+
+{{with .Stable}}
+<h3 id="stable">Stable versions</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Unstable}}
+<h3 id="unstable">Unstable version</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Archive}}
+<div class="toggle" id="archive">
+  <div class="collapsed">
+    <h3 class="toggleButton" title="Click to show versions">Archived versions▹</h3>
+  </div>
+  <div class="expanded">
+    <h3 class="toggleButton" title="Click to hide versions">Archived versions▾</h3>
+    {{template "releases" .}}
+  </div>
+</div>
+{{end}}
+
+<div id="footer">
+        <p>
+        Except as
+        <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
+        the content of this page is licensed under the Creative Commons
+        Attribution 3.0 License,<br>
+        and code is licensed under a <a href="http://golang.org/LICENSE">BSD license</a>.<br>
+        <a href="http://golang.org/doc/tos.html">Terms of Service</a> |
+        <a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
+        </p>
+</div><!-- #footer -->
+
+</div><!-- .container -->
+</div><!-- #page -->
+<script>
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+  ga('create', 'UA-11222381-2', 'auto');
+  ga('send', 'pageview');
+
+</script>
+</body>
+<script src="/lib/godoc/jquery.js"></script>
+<script src="/lib/godoc/godocs.js"></script>
+<script>
+$(document).ready(function() {
+  $('a.download').click(function(e) {
+    // Try using the link text as the file name,
+    // unless there's a child element of class 'filename'.
+    var filename = $(this).text();
+    var child = $(this).find('.filename');
+    if (child.length > 0) {
+      filename = child.text();
+    }
+
+    // This must be kept in sync with the filenameRE in godocs.js.
+    var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+    var m = filenameRE.exec(filename);
+    if (!m) {
+      // Don't redirect to the download page if it won't recognize this file.
+      // (Should not happen.)
+      return;
+    }
+
+    var dest = "/doc/install";
+    if (filename.indexOf(".src.") != -1) {
+      dest += "/source";
+    }
+    dest += "?download=" + filename;
+
+    e.preventDefault();
+    e.stopPropagation();
+    window.location = dest;
+  });
+});
+</script>
+</html>
+{{end}}
+
+{{define "releases"}}
+{{range .}}
+<div class="toggle{{if .Visible}}Visible{{end}}" id="{{.Version}}">
+	<div class="collapsed">
+		<h2 class="toggleButton" title="Click to show downloads for this version">{{.Version}} ▹</h2>
+	</div>
+	<div class="expanded">
+		<h2 class="toggleButton" title="Click to hide downloads for this version">{{.Version}} ▾</h2>
+		{{if .Stable}}{{else}}
+			<p>This is an <b>unstable</b> version of Go. Use with caution.</p>
+			<p>If you already have Go installed, you can install this version by running:</p>
+<pre>
+go get golang.org/x/build/version/{{.Version}}
+</pre>
+			<p>Then, use the <code>{{.Version}}</code> command instead of the <code>go</code> command to use {{.Version}}.</p>
+		{{end}}
+		{{template "files" .}}
+	</div>
+</div>
+{{end}}
+{{end}}
+
+{{define "files"}}
+<table class="codetable">
+<thead>
+<tr class="first">
+  <th>File name</th>
+  <th>Kind</th>
+  <th>OS</th>
+  <th>Arch</th>
+  <th>Size</th>
+  {{/* Use the checksum type of the first file for the column heading. */}}
+  <th>{{(index .Files 0).ChecksumType}} Checksum</th>
+</tr>
+</thead>
+{{if .SplitPortTable}}
+  {{range .Files}}{{if .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+
+  {{/* TODO(cbro): add a link to an explanatory doc page */}}
+  <tr class="first"><th colspan="6" class="first">Other Ports</th></tr>
+  {{range .Files}}{{if not .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+{{else}}
+  {{range .Files}}{{template "file" .}}{{end}}
+{{end}}
+</table>
+{{end}}
+
+{{define "file"}}
+<tr{{if .Highlight}} class="highlight"{{end}}>
+  <td class="filename"><a class="download" href="{{.URL}}">{{.Filename}}</a></td>
+  <td>{{pretty .Kind}}</td>
+  <td>{{.PrettyOS}}</td>
+  <td>{{pretty .Arch}}</td>
+  <td>{{.PrettySize}}</td>
+  <td><tt>{{.PrettyChecksum}}</tt></td>
+</tr>
+{{end}}
+
+{{define "download"}}
+<a class="download downloadBox" href="{{.URL}}">
+<div class="platform">{{.Platform}}</div>
+{{with .Requirements}}<div class="reqs">{{.}}</div>{{end}}
+<div>
+  <span class="filename">{{.Filename}}</span>
+  {{if .Size}}<span class="size">({{.PrettySize}})</span>{{end}}
+</div>
+</a>
+{{end}}
+`
diff --git a/vendor/golang.org/x/tools/godoc/format.go b/vendor/golang.org/x/tools/godoc/format.go
new file mode 100644
index 0000000..6013238
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/format.go
@@ -0,0 +1,371 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements FormatSelections and FormatText.
+// FormatText is used to HTML-format Go and non-Go source
+// text with line numbers and highlighted sections. It is
+// built on top of FormatSelections, a generic formatter
+// for "selected" text.
+
+package godoc
+
+import (
+	"fmt"
+	"go/scanner"
+	"go/token"
+	"io"
+	"regexp"
+	"strconv"
+	"text/template"
+)
+
+// ----------------------------------------------------------------------------
+// Implementation of FormatSelections
+
+// A Segment describes a text segment [start, end).
+// The zero value of a Segment is a ready-to-use empty segment.
+//
+type Segment struct {
+	start, end int
+}
+
+func (seg *Segment) isEmpty() bool { return seg.start >= seg.end }
+
+// A Selection is an "iterator" function returning a text segment.
+// Repeated calls to a selection return consecutive, non-overlapping,
+// non-empty segments, followed by an infinite sequence of empty
+// segments. The first empty segment marks the end of the selection.
+//
+type Selection func() Segment
+
+// A LinkWriter writes some start or end "tag" to w for the text offset offs.
+// It is called by FormatSelections at the start or end of each link segment.
+//
+type LinkWriter func(w io.Writer, offs int, start bool)
+
+// A SegmentWriter formats a text according to selections and writes it to w.
+// The selections parameter is a bit set indicating which selections provided
+// to FormatSelections overlap with the text segment: If the n'th bit is set
+// in selections, the n'th selection provided to FormatSelections is overlapping
+// with the text.
+//
+type SegmentWriter func(w io.Writer, text []byte, selections int)
+
+// FormatSelections takes a text and writes it to w using link and segment
+// writers lw and sw as follows: lw is invoked for consecutive segment starts
+// and ends as specified through the links selection, and sw is invoked for
+// consecutive segments of text overlapped by the same selections as specified
+// by selections. The link writer lw may be nil, in which case the links
+// Selection is ignored.
+//
+func FormatSelections(w io.Writer, text []byte, lw LinkWriter, links Selection, sw SegmentWriter, selections ...Selection) {
+	// If we have a link writer, make the links
+	// selection the last entry in selections
+	if lw != nil {
+		selections = append(selections, links)
+	}
+
+	// compute the sequence of consecutive segment changes
+	changes := newMerger(selections)
+
+	// The i'th bit in bitset indicates that the text
+	// at the current offset is covered by selections[i].
+	bitset := 0
+	lastOffs := 0
+
+	// Text segments are written in a delayed fashion
+	// such that consecutive segments belonging to the
+	// same selection can be combined (peephole optimization).
+	// last describes the last segment which has not yet been written.
+	var last struct {
+		begin, end int // valid if begin < end
+		bitset     int
+	}
+
+	// flush writes the last delayed text segment
+	flush := func() {
+		if last.begin < last.end {
+			sw(w, text[last.begin:last.end], last.bitset)
+		}
+		last.begin = last.end // invalidate last
+	}
+
+	// segment runs the segment [lastOffs, end) with the selection
+	// indicated by bitset through the segment peephole optimizer.
+	segment := func(end int) {
+		if lastOffs < end { // ignore empty segments
+			if last.end != lastOffs || last.bitset != bitset {
+				// the last segment is not adjacent to or
+				// differs from the new one
+				flush()
+				// start a new segment
+				last.begin = lastOffs
+			}
+			last.end = end
+			last.bitset = bitset
+		}
+	}
+
+	for {
+		// get the next segment change
+		index, offs, start := changes.next()
+		if index < 0 || offs > len(text) {
+			// no more segment changes or the next change
+			// is past the end of the text - we're done
+			break
+		}
+		// determine the kind of segment change
+		if lw != nil && index == len(selections)-1 {
+			// we have a link segment change (see start of this function):
+			// format the previous selection segment, write the
+			// link tag and start a new selection segment
+			segment(offs)
+			flush()
+			lastOffs = offs
+			lw(w, offs, start)
+		} else {
+			// we have a selection change:
+			// format the previous selection segment, determine
+			// the new selection bitset and start a new segment
+			segment(offs)
+			lastOffs = offs
+			mask := 1 << uint(index)
+			if start {
+				bitset |= mask
+			} else {
+				bitset &^= mask
+			}
+		}
+	}
+	segment(len(text))
+	flush()
+}
+
+// A merger merges a slice of Selections and produces a sequence of
+// consecutive segment change events through repeated next() calls.
+//
+type merger struct {
+	selections []Selection
+	segments   []Segment // segments[i] is the next segment of selections[i]
+}
+
+const infinity int = 2e9
+
+func newMerger(selections []Selection) *merger {
+	segments := make([]Segment, len(selections))
+	for i, sel := range selections {
+		segments[i] = Segment{infinity, infinity}
+		if sel != nil {
+			if seg := sel(); !seg.isEmpty() {
+				segments[i] = seg
+			}
+		}
+	}
+	return &merger{selections, segments}
+}
+
+// next returns the next segment change: index specifies the Selection
+// to which the segment belongs, offs is the segment start or end offset
+// as determined by the start value. If there are no more segment changes,
+// next returns an index value < 0.
+//
+func (m *merger) next() (index, offs int, start bool) {
+	// find the next smallest offset where a segment starts or ends
+	offs = infinity
+	index = -1
+	for i, seg := range m.segments {
+		switch {
+		case seg.start < offs:
+			offs = seg.start
+			index = i
+			start = true
+		case seg.end < offs:
+			offs = seg.end
+			index = i
+			start = false
+		}
+	}
+	if index < 0 {
+		// no offset found => all selections merged
+		return
+	}
+	// offset found - it's either the start or end offset but
+	// either way it is ok to consume the start offset: set it
+	// to infinity so it won't be considered in the following
+	// next call
+	m.segments[index].start = infinity
+	if start {
+		return
+	}
+	// end offset found - consume it
+	m.segments[index].end = infinity
+	// advance to the next segment for that selection
+	seg := m.selections[index]()
+	if !seg.isEmpty() {
+		m.segments[index] = seg
+	}
+	return
+}
+
+// ----------------------------------------------------------------------------
+// Implementation of FormatText
+
+// lineSelection returns the line segments for text as a Selection.
+func lineSelection(text []byte) Selection {
+	i, j := 0, 0
+	return func() (seg Segment) {
+		// find next newline, if any
+		for j < len(text) {
+			j++
+			if text[j-1] == '\n' {
+				break
+			}
+		}
+		if i < j {
+			// text[i:j] constitutes a line
+			seg = Segment{i, j}
+			i = j
+		}
+		return
+	}
+}
+
+// tokenSelection returns, as a selection, the sequence of
+// consecutive occurrences of token sel in the Go src text.
+//
+func tokenSelection(src []byte, sel token.Token) Selection {
+	var s scanner.Scanner
+	fset := token.NewFileSet()
+	file := fset.AddFile("", fset.Base(), len(src))
+	s.Init(file, src, nil, scanner.ScanComments)
+	return func() (seg Segment) {
+		for {
+			pos, tok, lit := s.Scan()
+			if tok == token.EOF {
+				break
+			}
+			offs := file.Offset(pos)
+			if tok == sel {
+				seg = Segment{offs, offs + len(lit)}
+				break
+			}
+		}
+		return
+	}
+}
+
+// makeSelection is a helper function to make a Selection from a slice of pairs.
+// Pairs describing empty segments are ignored.
+//
+func makeSelection(matches [][]int) Selection {
+	i := 0
+	return func() Segment {
+		for i < len(matches) {
+			m := matches[i]
+			i++
+			if m[0] < m[1] {
+				// non-empty segment
+				return Segment{m[0], m[1]}
+			}
+		}
+		return Segment{}
+	}
+}
+
+// regexpSelection computes the Selection for the regular expression expr in text.
+func regexpSelection(text []byte, expr string) Selection {
+	var matches [][]int
+	if rx, err := regexp.Compile(expr); err == nil {
+		matches = rx.FindAllIndex(text, -1)
+	}
+	return makeSelection(matches)
+}
+
+var selRx = regexp.MustCompile(`^([0-9]+):([0-9]+)`)
+
+// RangeSelection computes the Selection for a text range described
+// by the argument str; the range description must match the selRx
+// regular expression.
+func RangeSelection(str string) Selection {
+	m := selRx.FindStringSubmatch(str)
+	if len(m) >= 2 {
+		from, _ := strconv.Atoi(m[1])
+		to, _ := strconv.Atoi(m[2])
+		if from < to {
+			return makeSelection([][]int{{from, to}})
+		}
+	}
+	return nil
+}
+
+// Span tags for all the possible selection combinations that may
+// be generated by FormatText. Selections are indicated by a bitset,
+// and the value of the bitset specifies the tag to be used.
+//
+// bit 0: comments
+// bit 1: highlights
+// bit 2: selections
+//
+var startTags = [][]byte{
+	/* 000 */ []byte(``),
+	/* 001 */ []byte(`<span class="comment">`),
+	/* 010 */ []byte(`<span class="highlight">`),
+	/* 011 */ []byte(`<span class="highlight-comment">`),
+	/* 100 */ []byte(`<span class="selection">`),
+	/* 101 */ []byte(`<span class="selection-comment">`),
+	/* 110 */ []byte(`<span class="selection-highlight">`),
+	/* 111 */ []byte(`<span class="selection-highlight-comment">`),
+}
+
+var endTag = []byte(`</span>`)
+
+func selectionTag(w io.Writer, text []byte, selections int) {
+	if selections < len(startTags) {
+		if tag := startTags[selections]; len(tag) > 0 {
+			w.Write(tag)
+			template.HTMLEscape(w, text)
+			w.Write(endTag)
+			return
+		}
+	}
+	template.HTMLEscape(w, text)
+}
+
+// FormatText HTML-escapes text and writes it to w.
+// Consecutive text segments are wrapped in HTML spans (with tags as
+// defined by startTags and endTag) as follows:
+//
+//	- if line >= 0, line number (ln) spans are inserted before each line,
+//	  starting with the value of line
+//	- if the text is Go source, comments get the "comment" span class
+//	- each occurrence of the regular expression pattern gets the "highlight"
+//	  span class
+//	- text segments covered by selection get the "selection" span class
+//
+// Comments, highlights, and selections may overlap arbitrarily; the respective
+// HTML span classes are specified in the startTags variable.
+//
+func FormatText(w io.Writer, text []byte, line int, goSource bool, pattern string, selection Selection) {
+	var comments, highlights Selection
+	if goSource {
+		comments = tokenSelection(text, token.COMMENT)
+	}
+	if pattern != "" {
+		highlights = regexpSelection(text, pattern)
+	}
+	if line >= 0 || comments != nil || highlights != nil || selection != nil {
+		var lineTag LinkWriter
+		if line >= 0 {
+			lineTag = func(w io.Writer, _ int, start bool) {
+				if start {
+					fmt.Fprintf(w, "<span id=\"L%d\" class=\"ln\">%6d</span>\t", line, line)
+					line++
+				}
+			}
+		}
+		FormatSelections(w, text, lineTag, lineSelection(text), selectionTag, comments, highlights, selection)
+	} else {
+		template.HTMLEscape(w, text)
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/godoc.go b/vendor/golang.org/x/tools/godoc/godoc.go
new file mode 100644
index 0000000..d6c27d0
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/godoc.go
@@ -0,0 +1,911 @@
+// 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 godoc is a work-in-progress (2013-07-17) package to
+// begin splitting up the godoc binary into multiple pieces.
+//
+// This package comment will evolve over time as this package splits
+// into smaller pieces.
+package godoc // import "golang.org/x/tools/godoc"
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/doc"
+	"go/format"
+	"go/printer"
+	"go/token"
+	htmltemplate "html/template"
+	"io"
+	"log"
+	"os"
+	pathpkg "path"
+	"regexp"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Fake relative package path for built-ins. Documentation for all globals
+// (not just exported ones) will be shown for packages in this directory.
+const builtinPkgPath = "builtin"
+
+// FuncMap defines template functions used in godoc templates.
+//
+// Convention: template function names ending in "_html" or "_url" produce
+//             HTML- or URL-escaped strings; all other function results may
+//             require explicit escaping in the template.
+func (p *Presentation) FuncMap() template.FuncMap {
+	p.initFuncMapOnce.Do(p.initFuncMap)
+	return p.funcMap
+}
+
+func (p *Presentation) TemplateFuncs() template.FuncMap {
+	p.initFuncMapOnce.Do(p.initFuncMap)
+	return p.templateFuncs
+}
+
+func (p *Presentation) initFuncMap() {
+	if p.Corpus == nil {
+		panic("nil Presentation.Corpus")
+	}
+	p.templateFuncs = template.FuncMap{
+		"code": p.code,
+	}
+	p.funcMap = template.FuncMap{
+		// various helpers
+		"filename": filenameFunc,
+		"repeat":   strings.Repeat,
+
+		// access to FileInfos (directory listings)
+		"fileInfoName": fileInfoNameFunc,
+		"fileInfoTime": fileInfoTimeFunc,
+
+		// access to search result information
+		"infoKind_html":    infoKind_htmlFunc,
+		"infoLine":         p.infoLineFunc,
+		"infoSnippet_html": p.infoSnippet_htmlFunc,
+
+		// formatting of AST nodes
+		"node":         p.nodeFunc,
+		"node_html":    p.node_htmlFunc,
+		"comment_html": comment_htmlFunc,
+		"comment_text": comment_textFunc,
+		"sanitize":     sanitizeFunc,
+
+		// support for URL attributes
+		"pkgLink":       pkgLinkFunc,
+		"srcLink":       srcLinkFunc,
+		"posLink_url":   newPosLink_urlFunc(srcPosLinkFunc),
+		"docLink":       docLinkFunc,
+		"queryLink":     queryLinkFunc,
+		"srcBreadcrumb": srcBreadcrumbFunc,
+		"srcToPkgLink":  srcToPkgLinkFunc,
+
+		// formatting of Examples
+		"example_html":   p.example_htmlFunc,
+		"example_text":   p.example_textFunc,
+		"example_name":   p.example_nameFunc,
+		"example_suffix": p.example_suffixFunc,
+
+		// formatting of analysis information
+		"callgraph_html":  p.callgraph_htmlFunc,
+		"implements_html": p.implements_htmlFunc,
+		"methodset_html":  p.methodset_htmlFunc,
+
+		// formatting of Notes
+		"noteTitle": noteTitle,
+
+		// Number operation
+		"multiply": multiply,
+
+		// formatting of PageInfoMode query string
+		"modeQueryString": modeQueryString,
+	}
+	if p.URLForSrc != nil {
+		p.funcMap["srcLink"] = p.URLForSrc
+	}
+	if p.URLForSrcPos != nil {
+		p.funcMap["posLink_url"] = newPosLink_urlFunc(p.URLForSrcPos)
+	}
+	if p.URLForSrcQuery != nil {
+		p.funcMap["queryLink"] = p.URLForSrcQuery
+	}
+}
+
+func multiply(a, b int) int { return a * b }
+
+func filenameFunc(path string) string {
+	_, localname := pathpkg.Split(path)
+	return localname
+}
+
+func fileInfoNameFunc(fi os.FileInfo) string {
+	name := fi.Name()
+	if fi.IsDir() {
+		name += "/"
+	}
+	return name
+}
+
+func fileInfoTimeFunc(fi os.FileInfo) string {
+	if t := fi.ModTime(); t.Unix() != 0 {
+		return t.Local().String()
+	}
+	return "" // don't return epoch if time is obviously not set
+}
+
+// The strings in infoKinds must be properly html-escaped.
+var infoKinds = [nKinds]string{
+	PackageClause: "package&nbsp;clause",
+	ImportDecl:    "import&nbsp;decl",
+	ConstDecl:     "const&nbsp;decl",
+	TypeDecl:      "type&nbsp;decl",
+	VarDecl:       "var&nbsp;decl",
+	FuncDecl:      "func&nbsp;decl",
+	MethodDecl:    "method&nbsp;decl",
+	Use:           "use",
+}
+
+func infoKind_htmlFunc(info SpotInfo) string {
+	return infoKinds[info.Kind()] // infoKind entries are html-escaped
+}
+
+func (p *Presentation) infoLineFunc(info SpotInfo) int {
+	line := info.Lori()
+	if info.IsIndex() {
+		index, _ := p.Corpus.searchIndex.Get()
+		if index != nil {
+			line = index.(*Index).Snippet(line).Line
+		} else {
+			// no line information available because
+			// we don't have an index - this should
+			// never happen; be conservative and don't
+			// crash
+			line = 0
+		}
+	}
+	return line
+}
+
+func (p *Presentation) infoSnippet_htmlFunc(info SpotInfo) string {
+	if info.IsIndex() {
+		index, _ := p.Corpus.searchIndex.Get()
+		// Snippet.Text was HTML-escaped when it was generated
+		return index.(*Index).Snippet(info.Lori()).Text
+	}
+	return `<span class="alert">no snippet text available</span>`
+}
+
+func (p *Presentation) nodeFunc(info *PageInfo, node interface{}) string {
+	var buf bytes.Buffer
+	p.writeNode(&buf, info.FSet, node)
+	return buf.String()
+}
+
+func (p *Presentation) node_htmlFunc(info *PageInfo, node interface{}, linkify bool) string {
+	var buf1 bytes.Buffer
+	p.writeNode(&buf1, info.FSet, node)
+
+	var buf2 bytes.Buffer
+	if n, _ := node.(ast.Node); n != nil && linkify && p.DeclLinks {
+		LinkifyText(&buf2, buf1.Bytes(), n)
+		if st, name := isStructTypeDecl(n); st != nil {
+			addStructFieldIDAttributes(&buf2, name, st)
+		}
+	} else {
+		FormatText(&buf2, buf1.Bytes(), -1, true, "", nil)
+	}
+
+	return buf2.String()
+}
+
+// isStructTypeDecl checks whether n is a struct declaration.
+// It either returns a non-nil StructType and its name, or zero values.
+func isStructTypeDecl(n ast.Node) (st *ast.StructType, name string) {
+	gd, ok := n.(*ast.GenDecl)
+	if !ok || gd.Tok != token.TYPE {
+		return nil, ""
+	}
+	if gd.Lparen > 0 {
+		// Parenthesized type. Who does that, anyway?
+		// TODO: Reportedly gri does. Fix this to handle that too.
+		return nil, ""
+	}
+	if len(gd.Specs) != 1 {
+		return nil, ""
+	}
+	ts, ok := gd.Specs[0].(*ast.TypeSpec)
+	if !ok {
+		return nil, ""
+	}
+	st, ok = ts.Type.(*ast.StructType)
+	if !ok {
+		return nil, ""
+	}
+	return st, ts.Name.Name
+}
+
+// addStructFieldIDAttributes modifies the contents of buf such that
+// all struct fields of the named struct have <span id='name.Field'>
+// in them, so people can link to /#Struct.Field.
+func addStructFieldIDAttributes(buf *bytes.Buffer, name string, st *ast.StructType) {
+	if st.Fields == nil {
+		return
+	}
+	// needsLink is a set of identifiers that still need to be
+	// linked, where value == key, to avoid an allocation in func
+	// linkedField.
+	needsLink := make(map[string]string)
+
+	for _, f := range st.Fields.List {
+		if len(f.Names) == 0 {
+			continue
+		}
+		fieldName := f.Names[0].Name
+		needsLink[fieldName] = fieldName
+	}
+	var newBuf bytes.Buffer
+	foreachLine(buf.Bytes(), func(line []byte) {
+		if fieldName := linkedField(line, needsLink); fieldName != "" {
+			fmt.Fprintf(&newBuf, `<span id="%s.%s"></span>`, name, fieldName)
+			delete(needsLink, fieldName)
+		}
+		newBuf.Write(line)
+	})
+	buf.Reset()
+	buf.Write(newBuf.Bytes())
+}
+
+// foreachLine calls fn for each line of in, where a line includes
+// the trailing "\n", except on the last line, if it doesn't exist.
+func foreachLine(in []byte, fn func(line []byte)) {
+	for len(in) > 0 {
+		nl := bytes.IndexByte(in, '\n')
+		if nl == -1 {
+			fn(in)
+			return
+		}
+		fn(in[:nl+1])
+		in = in[nl+1:]
+	}
+}
+
+// commentPrefix is the line prefix for comments after they've been HTMLified.
+var commentPrefix = []byte(`<span class="comment">// `)
+
+// linkedField determines whether the given line starts with an
+// identifer in the provided ids map (mapping from identifier to the
+// same identifier). The line can start with either an identifier or
+// an identifier in a comment. If one matches, it returns the
+// identifier that matched. Otherwise it returns the empty string.
+func linkedField(line []byte, ids map[string]string) string {
+	line = bytes.TrimSpace(line)
+
+	// For fields with a doc string of the
+	// conventional form, we put the new span into
+	// the comment instead of the field.
+	// The "conventional" form is a complete sentence
+	// per https://golang.org/s/style#comment-sentences like:
+	//
+	//    // Foo is an optional Fooer to foo the foos.
+	//    Foo Fooer
+	//
+	// In this case, we want the #StructName.Foo
+	// link to make the browser go to the comment
+	// line "Foo is an optional Fooer" instead of
+	// the "Foo Fooer" line, which could otherwise
+	// obscure the docs above the browser's "fold".
+	//
+	// TODO: do this better, so it works for all
+	// comments, including unconventional ones.
+	if bytes.HasPrefix(line, commentPrefix) {
+		line = line[len(commentPrefix):]
+	}
+	id := scanIdentifier(line)
+	if len(id) == 0 {
+		// No leading identifier. Avoid map lookup for
+		// somewhat common case.
+		return ""
+	}
+	return ids[string(id)]
+}
+
+// scanIdentifier scans a valid Go identifier off the front of v and
+// either returns a subslice of v if there's a valid identifier, or
+// returns a zero-length slice.
+func scanIdentifier(v []byte) []byte {
+	var n int // number of leading bytes of v belonging to an identifier
+	for {
+		r, width := utf8.DecodeRune(v[n:])
+		if !(isLetter(r) || n > 0 && isDigit(r)) {
+			break
+		}
+		n += width
+	}
+	return v[:n]
+}
+
+func isLetter(ch rune) bool {
+	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
+}
+
+func isDigit(ch rune) bool {
+	return '0' <= ch && ch <= '9' || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
+}
+
+func comment_htmlFunc(comment string) string {
+	var buf bytes.Buffer
+	// TODO(gri) Provide list of words (e.g. function parameters)
+	//           to be emphasized by ToHTML.
+	doc.ToHTML(&buf, comment, nil) // does html-escaping
+	return buf.String()
+}
+
+// punchCardWidth is the number of columns of fixed-width
+// characters to assume when wrapping text.  Very few people
+// use terminals or cards smaller than 80 characters, so 80 it is.
+// We do not try to sniff the environment or the tty to adapt to
+// the situation; instead, by using a constant we make sure that
+// godoc always produces the same output regardless of context,
+// a consistency that is lost otherwise.  For example, if we sniffed
+// the environment or tty, then http://golang.org/pkg/math/?m=text
+// would depend on the width of the terminal where godoc started,
+// which is clearly bogus.  More generally, the Unix tools that behave
+// differently when writing to a tty than when writing to a file have
+// a history of causing confusion (compare `ls` and `ls | cat`), and we
+// want to avoid that mistake here.
+const punchCardWidth = 80
+
+func containsOnlySpace(buf []byte) bool {
+	isNotSpace := func(r rune) bool { return !unicode.IsSpace(r) }
+	return bytes.IndexFunc(buf, isNotSpace) == -1
+}
+
+func comment_textFunc(comment, indent, preIndent string) string {
+	var buf bytes.Buffer
+	doc.ToText(&buf, comment, indent, preIndent, punchCardWidth-2*len(indent))
+	if containsOnlySpace(buf.Bytes()) {
+		return ""
+	}
+	return buf.String()
+}
+
+// sanitizeFunc sanitizes the argument src by replacing newlines with
+// blanks, removing extra blanks, and by removing trailing whitespace
+// and commas before closing parentheses.
+func sanitizeFunc(src string) string {
+	buf := make([]byte, len(src))
+	j := 0      // buf index
+	comma := -1 // comma index if >= 0
+	for i := 0; i < len(src); i++ {
+		ch := src[i]
+		switch ch {
+		case '\t', '\n', ' ':
+			// ignore whitespace at the beginning, after a blank, or after opening parentheses
+			if j == 0 {
+				continue
+			}
+			if p := buf[j-1]; p == ' ' || p == '(' || p == '{' || p == '[' {
+				continue
+			}
+			// replace all whitespace with blanks
+			ch = ' '
+		case ',':
+			comma = j
+		case ')', '}', ']':
+			// remove any trailing comma
+			if comma >= 0 {
+				j = comma
+			}
+			// remove any trailing whitespace
+			if j > 0 && buf[j-1] == ' ' {
+				j--
+			}
+		default:
+			comma = -1
+		}
+		buf[j] = ch
+		j++
+	}
+	// remove trailing blank, if any
+	if j > 0 && buf[j-1] == ' ' {
+		j--
+	}
+	return string(buf[:j])
+}
+
+type PageInfo struct {
+	Dirname  string // directory containing the package
+	Err      error  // error or nil
+	GoogleCN bool   // page is being served from golang.google.cn
+
+	Mode PageInfoMode // display metadata from query string
+
+	// package info
+	FSet       *token.FileSet         // nil if no package documentation
+	PDoc       *doc.Package           // nil if no package documentation
+	Examples   []*doc.Example         // nil if no example code
+	Notes      map[string][]*doc.Note // nil if no package Notes
+	PAst       map[string]*ast.File   // nil if no AST with package exports
+	IsMain     bool                   // true for package main
+	IsFiltered bool                   // true if results were filtered
+
+	// analysis info
+	TypeInfoIndex  map[string]int  // index of JSON datum for type T (if -analysis=type)
+	AnalysisData   htmltemplate.JS // array of TypeInfoJSON values
+	CallGraph      htmltemplate.JS // array of PCGNodeJSON values    (if -analysis=pointer)
+	CallGraphIndex map[string]int  // maps func name to index in CallGraph
+
+	// directory info
+	Dirs    *DirList  // nil if no directory information
+	DirTime time.Time // directory time stamp
+	DirFlat bool      // if set, show directory in a flat (non-indented) manner
+}
+
+func (info *PageInfo) IsEmpty() bool {
+	return info.Err != nil || info.PAst == nil && info.PDoc == nil && info.Dirs == nil
+}
+
+func pkgLinkFunc(path string) string {
+	// because of the irregular mapping under goroot
+	// we need to correct certain relative paths
+	path = strings.TrimPrefix(path, "/")
+	path = strings.TrimPrefix(path, "src/")
+	path = strings.TrimPrefix(path, "pkg/")
+	return "pkg/" + path
+}
+
+// srcToPkgLinkFunc builds an <a> tag linking to the package
+// documentation of relpath.
+func srcToPkgLinkFunc(relpath string) string {
+	relpath = pkgLinkFunc(relpath)
+	relpath = pathpkg.Dir(relpath)
+	if relpath == "pkg" {
+		return `<a href="/pkg">Index</a>`
+	}
+	return fmt.Sprintf(`<a href="/%s">%s</a>`, relpath, relpath[len("pkg/"):])
+}
+
+// srcBreadcrumbFun converts each segment of relpath to a HTML <a>.
+// Each segment links to its corresponding src directories.
+func srcBreadcrumbFunc(relpath string) string {
+	segments := strings.Split(relpath, "/")
+	var buf bytes.Buffer
+	var selectedSegment string
+	var selectedIndex int
+
+	if strings.HasSuffix(relpath, "/") {
+		// relpath is a directory ending with a "/".
+		// Selected segment is the segment before the last slash.
+		selectedIndex = len(segments) - 2
+		selectedSegment = segments[selectedIndex] + "/"
+	} else {
+		selectedIndex = len(segments) - 1
+		selectedSegment = segments[selectedIndex]
+	}
+
+	for i := range segments[:selectedIndex] {
+		buf.WriteString(fmt.Sprintf(`<a href="/%s">%s</a>/`,
+			strings.Join(segments[:i+1], "/"),
+			segments[i],
+		))
+	}
+
+	buf.WriteString(`<span class="text-muted">`)
+	buf.WriteString(selectedSegment)
+	buf.WriteString(`</span>`)
+	return buf.String()
+}
+
+func newPosLink_urlFunc(srcPosLinkFunc func(s string, line, low, high int) string) func(info *PageInfo, n interface{}) string {
+	// n must be an ast.Node or a *doc.Note
+	return func(info *PageInfo, n interface{}) string {
+		var pos, end token.Pos
+
+		switch n := n.(type) {
+		case ast.Node:
+			pos = n.Pos()
+			end = n.End()
+		case *doc.Note:
+			pos = n.Pos
+			end = n.End
+		default:
+			panic(fmt.Sprintf("wrong type for posLink_url template formatter: %T", n))
+		}
+
+		var relpath string
+		var line int
+		var low, high int // selection offset range
+
+		if pos.IsValid() {
+			p := info.FSet.Position(pos)
+			relpath = p.Filename
+			line = p.Line
+			low = p.Offset
+		}
+		if end.IsValid() {
+			high = info.FSet.Position(end).Offset
+		}
+
+		return srcPosLinkFunc(relpath, line, low, high)
+	}
+}
+
+func srcPosLinkFunc(s string, line, low, high int) string {
+	s = srcLinkFunc(s)
+	var buf bytes.Buffer
+	template.HTMLEscape(&buf, []byte(s))
+	// selection ranges are of form "s=low:high"
+	if low < high {
+		fmt.Fprintf(&buf, "?s=%d:%d", low, high) // no need for URL escaping
+		// if we have a selection, position the page
+		// such that the selection is a bit below the top
+		line -= 10
+		if line < 1 {
+			line = 1
+		}
+	}
+	// line id's in html-printed source are of the
+	// form "L%d" where %d stands for the line number
+	if line > 0 {
+		fmt.Fprintf(&buf, "#L%d", line) // no need for URL escaping
+	}
+	return buf.String()
+}
+
+func srcLinkFunc(s string) string {
+	s = pathpkg.Clean("/" + s)
+	if !strings.HasPrefix(s, "/src/") {
+		s = "/src" + s
+	}
+	return s
+}
+
+// queryLinkFunc returns a URL for a line in a source file with a highlighted
+// query term.
+// s is expected to be a path to a source file.
+// query is expected to be a string that has already been appropriately escaped
+// for use in a URL query.
+func queryLinkFunc(s, query string, line int) string {
+	url := pathpkg.Clean("/"+s) + "?h=" + query
+	if line > 0 {
+		url += "#L" + strconv.Itoa(line)
+	}
+	return url
+}
+
+func docLinkFunc(s string, ident string) string {
+	return pathpkg.Clean("/pkg/"+s) + "/#" + ident
+}
+
+func (p *Presentation) example_textFunc(info *PageInfo, funcName, indent string) string {
+	if !p.ShowExamples {
+		return ""
+	}
+
+	var buf bytes.Buffer
+	first := true
+	for _, eg := range info.Examples {
+		name := stripExampleSuffix(eg.Name)
+		if name != funcName {
+			continue
+		}
+
+		if !first {
+			buf.WriteString("\n")
+		}
+		first = false
+
+		// print code
+		cnode := &printer.CommentedNode{Node: eg.Code, Comments: eg.Comments}
+		config := &printer.Config{Mode: printer.UseSpaces, Tabwidth: p.TabWidth}
+		var buf1 bytes.Buffer
+		config.Fprint(&buf1, info.FSet, cnode)
+		code := buf1.String()
+
+		// Additional formatting if this is a function body. Unfortunately, we
+		// can't print statements individually because we would lose comments
+		// on later statements.
+		if n := len(code); n >= 2 && code[0] == '{' && code[n-1] == '}' {
+			// remove surrounding braces
+			code = code[1 : n-1]
+			// unindent
+			code = replaceLeadingIndentation(code, strings.Repeat(" ", p.TabWidth), indent)
+		}
+		code = strings.Trim(code, "\n")
+
+		buf.WriteString(indent)
+		buf.WriteString("Example:\n")
+		buf.WriteString(code)
+		buf.WriteString("\n\n")
+	}
+	return buf.String()
+}
+
+func (p *Presentation) example_htmlFunc(info *PageInfo, funcName string) string {
+	var buf bytes.Buffer
+	for _, eg := range info.Examples {
+		name := stripExampleSuffix(eg.Name)
+
+		if name != funcName {
+			continue
+		}
+
+		// print code
+		cnode := &printer.CommentedNode{Node: eg.Code, Comments: eg.Comments}
+		code := p.node_htmlFunc(info, cnode, true)
+		out := eg.Output
+		wholeFile := true
+
+		// Additional formatting if this is a function body.
+		if n := len(code); n >= 2 && code[0] == '{' && code[n-1] == '}' {
+			wholeFile = false
+			// remove surrounding braces
+			code = code[1 : n-1]
+			// unindent
+			code = replaceLeadingIndentation(code, strings.Repeat(" ", p.TabWidth), "")
+			// remove output comment
+			if loc := exampleOutputRx.FindStringIndex(code); loc != nil {
+				code = strings.TrimSpace(code[:loc[0]])
+			}
+		}
+
+		// Write out the playground code in standard Go style
+		// (use tabs, no comment highlight, etc).
+		play := ""
+		if eg.Play != nil && p.ShowPlayground {
+			var buf bytes.Buffer
+			if err := format.Node(&buf, info.FSet, eg.Play); err != nil {
+				log.Print(err)
+			} else {
+				play = buf.String()
+			}
+		}
+
+		// Drop output, as the output comment will appear in the code.
+		if wholeFile && play == "" {
+			out = ""
+		}
+
+		if p.ExampleHTML == nil {
+			out = ""
+			return ""
+		}
+
+		err := p.ExampleHTML.Execute(&buf, struct {
+			Name, Doc, Code, Play, Output string
+			GoogleCN                      bool
+		}{eg.Name, eg.Doc, code, play, out, info.GoogleCN})
+		if err != nil {
+			log.Print(err)
+		}
+	}
+	return buf.String()
+}
+
+// example_nameFunc takes an example function name and returns its display
+// name. For example, "Foo_Bar_quux" becomes "Foo.Bar (Quux)".
+func (p *Presentation) example_nameFunc(s string) string {
+	name, suffix := splitExampleName(s)
+	// replace _ with . for method names
+	name = strings.Replace(name, "_", ".", 1)
+	// use "Package" if no name provided
+	if name == "" {
+		name = "Package"
+	}
+	return name + suffix
+}
+
+// example_suffixFunc takes an example function name and returns its suffix in
+// parenthesized form. For example, "Foo_Bar_quux" becomes " (Quux)".
+func (p *Presentation) example_suffixFunc(name string) string {
+	_, suffix := splitExampleName(name)
+	return suffix
+}
+
+// implements_html returns the "> Implements" toggle for a package-level named type.
+// Its contents are populated from JSON data by client-side JS at load time.
+func (p *Presentation) implements_htmlFunc(info *PageInfo, typeName string) string {
+	if p.ImplementsHTML == nil {
+		return ""
+	}
+	index, ok := info.TypeInfoIndex[typeName]
+	if !ok {
+		return ""
+	}
+	var buf bytes.Buffer
+	err := p.ImplementsHTML.Execute(&buf, struct{ Index int }{index})
+	if err != nil {
+		log.Print(err)
+	}
+	return buf.String()
+}
+
+// methodset_html returns the "> Method set" toggle for a package-level named type.
+// Its contents are populated from JSON data by client-side JS at load time.
+func (p *Presentation) methodset_htmlFunc(info *PageInfo, typeName string) string {
+	if p.MethodSetHTML == nil {
+		return ""
+	}
+	index, ok := info.TypeInfoIndex[typeName]
+	if !ok {
+		return ""
+	}
+	var buf bytes.Buffer
+	err := p.MethodSetHTML.Execute(&buf, struct{ Index int }{index})
+	if err != nil {
+		log.Print(err)
+	}
+	return buf.String()
+}
+
+// callgraph_html returns the "> Call graph" toggle for a package-level func.
+// Its contents are populated from JSON data by client-side JS at load time.
+func (p *Presentation) callgraph_htmlFunc(info *PageInfo, recv, name string) string {
+	if p.CallGraphHTML == nil {
+		return ""
+	}
+	if recv != "" {
+		// Format must match (*ssa.Function).RelString().
+		name = fmt.Sprintf("(%s).%s", recv, name)
+	}
+	index, ok := info.CallGraphIndex[name]
+	if !ok {
+		return ""
+	}
+	var buf bytes.Buffer
+	err := p.CallGraphHTML.Execute(&buf, struct{ Index int }{index})
+	if err != nil {
+		log.Print(err)
+	}
+	return buf.String()
+}
+
+func noteTitle(note string) string {
+	return strings.Title(strings.ToLower(note))
+}
+
+func startsWithUppercase(s string) bool {
+	r, _ := utf8.DecodeRuneInString(s)
+	return unicode.IsUpper(r)
+}
+
+var exampleOutputRx = regexp.MustCompile(`(?i)//[[:space:]]*(unordered )?output:`)
+
+// stripExampleSuffix strips lowercase braz in Foo_braz or Foo_Bar_braz from name
+// while keeping uppercase Braz in Foo_Braz.
+func stripExampleSuffix(name string) string {
+	if i := strings.LastIndex(name, "_"); i != -1 {
+		if i < len(name)-1 && !startsWithUppercase(name[i+1:]) {
+			name = name[:i]
+		}
+	}
+	return name
+}
+
+func splitExampleName(s string) (name, suffix string) {
+	i := strings.LastIndex(s, "_")
+	if 0 <= i && i < len(s)-1 && !startsWithUppercase(s[i+1:]) {
+		name = s[:i]
+		suffix = " (" + strings.Title(s[i+1:]) + ")"
+		return
+	}
+	name = s
+	return
+}
+
+// replaceLeadingIndentation replaces oldIndent at the beginning of each line
+// with newIndent. This is used for formatting examples. Raw strings that
+// span multiple lines are handled specially: oldIndent is not removed (since
+// go/printer will not add any indentation there), but newIndent is added
+// (since we may still want leading indentation).
+func replaceLeadingIndentation(body, oldIndent, newIndent string) string {
+	// Handle indent at the beginning of the first line. After this, we handle
+	// indentation only after a newline.
+	var buf bytes.Buffer
+	if strings.HasPrefix(body, oldIndent) {
+		buf.WriteString(newIndent)
+		body = body[len(oldIndent):]
+	}
+
+	// Use a state machine to keep track of whether we're in a string or
+	// rune literal while we process the rest of the code.
+	const (
+		codeState = iota
+		runeState
+		interpretedStringState
+		rawStringState
+	)
+	searchChars := []string{
+		"'\"`\n", // codeState
+		`\'`,     // runeState
+		`\"`,     // interpretedStringState
+		"`\n",    // rawStringState
+		// newlineState does not need to search
+	}
+	state := codeState
+	for {
+		i := strings.IndexAny(body, searchChars[state])
+		if i < 0 {
+			buf.WriteString(body)
+			break
+		}
+		c := body[i]
+		buf.WriteString(body[:i+1])
+		body = body[i+1:]
+		switch state {
+		case codeState:
+			switch c {
+			case '\'':
+				state = runeState
+			case '"':
+				state = interpretedStringState
+			case '`':
+				state = rawStringState
+			case '\n':
+				if strings.HasPrefix(body, oldIndent) {
+					buf.WriteString(newIndent)
+					body = body[len(oldIndent):]
+				}
+			}
+
+		case runeState:
+			switch c {
+			case '\\':
+				r, size := utf8.DecodeRuneInString(body)
+				buf.WriteRune(r)
+				body = body[size:]
+			case '\'':
+				state = codeState
+			}
+
+		case interpretedStringState:
+			switch c {
+			case '\\':
+				r, size := utf8.DecodeRuneInString(body)
+				buf.WriteRune(r)
+				body = body[size:]
+			case '"':
+				state = codeState
+			}
+
+		case rawStringState:
+			switch c {
+			case '`':
+				state = codeState
+			case '\n':
+				buf.WriteString(newIndent)
+			}
+		}
+	}
+	return buf.String()
+}
+
+// Write an AST node to w.
+func (p *Presentation) writeNode(w io.Writer, fset *token.FileSet, x interface{}) {
+	// convert trailing tabs into spaces using a tconv filter
+	// to ensure a good outcome in most browsers (there may still
+	// be tabs in comments and strings, but converting those into
+	// the right number of spaces is much harder)
+	//
+	// TODO(gri) rethink printer flags - perhaps tconv can be eliminated
+	//           with an another printer mode (which is more efficiently
+	//           implemented in the printer than here with another layer)
+	mode := printer.TabIndent | printer.UseSpaces
+	err := (&printer.Config{Mode: mode, Tabwidth: p.TabWidth}).Fprint(&tconv{p: p, output: w}, fset, x)
+	if err != nil {
+		log.Print(err)
+	}
+}
+
+// WriteNode writes x to w.
+// TODO(bgarcia) Is this method needed? It's just a wrapper for p.writeNode.
+func (p *Presentation) WriteNode(w io.Writer, fset *token.FileSet, x interface{}) {
+	p.writeNode(w, fset, x)
+}
diff --git a/vendor/golang.org/x/tools/godoc/godoc17_test.go b/vendor/golang.org/x/tools/godoc/godoc17_test.go
new file mode 100644
index 0000000..d153991
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/godoc17_test.go
@@ -0,0 +1,35 @@
+// 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.7
+
+package godoc
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+)
+
+// Verify that scanIdentifier isn't quadratic.
+// This doesn't actually measure and fail on its own, but it was previously
+// very obvious when running by hand.
+//
+// TODO: if there's a reliable and non-flaky way to test this, do so.
+// Maybe count user CPU time instead of wall time? But that's not easy
+// to do portably in Go.
+func TestStructField(t *testing.T) {
+	for _, n := range []int{10, 100, 1000, 10000} {
+		n := n
+		t.Run(fmt.Sprint(n), func(t *testing.T) {
+			var buf bytes.Buffer
+			fmt.Fprintf(&buf, "package foo\n\ntype T struct {\n")
+			for i := 0; i < n; i++ {
+				fmt.Fprintf(&buf, "\t// Field%d is foo.\n\tField%d int\n\n", i, i)
+			}
+			fmt.Fprintf(&buf, "}\n")
+			linkifySource(t, buf.Bytes())
+		})
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/godoc_test.go b/vendor/golang.org/x/tools/godoc/godoc_test.go
new file mode 100644
index 0000000..c1d631c
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/godoc_test.go
@@ -0,0 +1,323 @@
+// 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 godoc
+
+import (
+	"bytes"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func TestPkgLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		path string
+		want string
+	}{
+		{"/src/fmt", "pkg/fmt"},
+		{"src/fmt", "pkg/fmt"},
+		{"/fmt", "pkg/fmt"},
+		{"fmt", "pkg/fmt"},
+	} {
+		if got := pkgLinkFunc(tc.path); got != tc.want {
+			t.Errorf("pkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want)
+		}
+	}
+}
+
+func TestSrcPosLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		src  string
+		line int
+		low  int
+		high int
+		want string
+	}{
+		{"/src/fmt/print.go", 42, 30, 50, "/src/fmt/print.go?s=30:50#L32"},
+		{"/src/fmt/print.go", 2, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+		{"/src/fmt/print.go", 2, 0, 0, "/src/fmt/print.go#L2"},
+		{"/src/fmt/print.go", 0, 0, 0, "/src/fmt/print.go"},
+		{"/src/fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+		{"fmt/print.go", 0, 0, 0, "/src/fmt/print.go"},
+		{"fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+	} {
+		if got := srcPosLinkFunc(tc.src, tc.line, tc.low, tc.high); got != tc.want {
+			t.Errorf("srcLinkFunc(%v, %v, %v, %v) = %v; want %v", tc.src, tc.line, tc.low, tc.high, got, tc.want)
+		}
+	}
+}
+
+func TestSrcLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		src  string
+		want string
+	}{
+		{"/src/fmt/print.go", "/src/fmt/print.go"},
+		{"src/fmt/print.go", "/src/fmt/print.go"},
+		{"/fmt/print.go", "/src/fmt/print.go"},
+		{"fmt/print.go", "/src/fmt/print.go"},
+	} {
+		if got := srcLinkFunc(tc.src); got != tc.want {
+			t.Errorf("srcLinkFunc(%v) = %v; want %v", tc.src, got, tc.want)
+		}
+	}
+}
+
+func TestQueryLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		src   string
+		query string
+		line  int
+		want  string
+	}{
+		{"/src/fmt/print.go", "Sprintf", 33, "/src/fmt/print.go?h=Sprintf#L33"},
+		{"/src/fmt/print.go", "Sprintf", 0, "/src/fmt/print.go?h=Sprintf"},
+		{"src/fmt/print.go", "EOF", 33, "/src/fmt/print.go?h=EOF#L33"},
+		{"src/fmt/print.go", "a%3f+%26b", 1, "/src/fmt/print.go?h=a%3f+%26b#L1"},
+	} {
+		if got := queryLinkFunc(tc.src, tc.query, tc.line); got != tc.want {
+			t.Errorf("queryLinkFunc(%v, %v, %v) = %v; want %v", tc.src, tc.query, tc.line, got, tc.want)
+		}
+	}
+}
+
+func TestDocLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		src   string
+		ident string
+		want  string
+	}{
+		{"fmt", "Sprintf", "/pkg/fmt/#Sprintf"},
+		{"fmt", "EOF", "/pkg/fmt/#EOF"},
+	} {
+		if got := docLinkFunc(tc.src, tc.ident); got != tc.want {
+			t.Errorf("docLinkFunc(%v, %v) = %v; want %v", tc.src, tc.ident, got, tc.want)
+		}
+	}
+}
+
+func TestSanitizeFunc(t *testing.T) {
+	for _, tc := range []struct {
+		src  string
+		want string
+	}{
+		{},
+		{"foo", "foo"},
+		{"func   f()", "func f()"},
+		{"func f(a int,)", "func f(a int)"},
+		{"func f(a int,\n)", "func f(a int)"},
+		{"func f(\n\ta int,\n\tb int,\n\tc int,\n)", "func f(a int, b int, c int)"},
+		{"  (   a,   b,  c  )  ", "(a, b, c)"},
+		{"(  a,  b, c    int, foo   bar  ,  )", "(a, b, c int, foo bar)"},
+		{"{   a,   b}", "{a, b}"},
+		{"[   a,   b]", "[a, b]"},
+	} {
+		if got := sanitizeFunc(tc.src); got != tc.want {
+			t.Errorf("sanitizeFunc(%v) = %v; want %v", tc.src, got, tc.want)
+		}
+	}
+}
+
+// Test that we add <span id="StructName.FieldName"> elements
+// to the HTML of struct fields.
+func TestStructFieldsIDAttributes(t *testing.T) {
+	got := linkifySource(t, []byte(`
+package foo
+
+type T struct {
+	NoDoc string
+
+	// Doc has a comment.
+	Doc string
+
+	// Opt, if non-nil, is an option.
+	Opt *int
+
+	// Опция - другое поле.
+	Опция bool
+}
+`))
+	want := `type T struct {
+<span id="T.NoDoc"></span>NoDoc <a href="/pkg/builtin/#string">string</a>
+
+<span id="T.Doc"></span><span class="comment">// Doc has a comment.</span>
+Doc <a href="/pkg/builtin/#string">string</a>
+
+<span id="T.Opt"></span><span class="comment">// Opt, if non-nil, is an option.</span>
+Opt *<a href="/pkg/builtin/#int">int</a>
+
+<span id="T.Опция"></span><span class="comment">// Опция - другое поле.</span>
+Опция <a href="/pkg/builtin/#bool">bool</a>
+}`
+	if got != want {
+		t.Errorf("got: %s\n\nwant: %s\n", got, want)
+	}
+}
+
+// Test that we add <span id="ConstName"> elements to the HTML
+// of definitions in const and var specs.
+func TestValueSpecIDAttributes(t *testing.T) {
+	got := linkifySource(t, []byte(`
+package foo
+
+const (
+	NoDoc string = "NoDoc"
+
+	// Doc has a comment
+	Doc = "Doc"
+
+	NoVal
+)`))
+	want := `const (
+<span id="NoDoc">NoDoc</span> <a href="/pkg/builtin/#string">string</a> = &#34;NoDoc&#34;
+
+<span class="comment">// Doc has a comment</span>
+<span id="Doc">Doc</span> = &#34;Doc&#34;
+
+<span id="NoVal">NoVal</span>
+)`
+	if got != want {
+		t.Errorf("got: %s\n\nwant: %s\n", got, want)
+	}
+}
+
+func TestCompositeLitLinkFields(t *testing.T) {
+	got := linkifySource(t, []byte(`
+package foo
+
+type T struct {
+	X int
+}
+
+var S T = T{X: 12}`))
+	want := `type T struct {
+<span id="T.X"></span>X <a href="/pkg/builtin/#int">int</a>
+}
+var <span id="S">S</span> <a href="#T">T</a> = <a href="#T">T</a>{<a href="#T.X">X</a>: 12}`
+	if got != want {
+		t.Errorf("got: %s\n\nwant: %s\n", got, want)
+	}
+}
+
+func TestFuncDeclNotLink(t *testing.T) {
+	// Function.
+	got := linkifySource(t, []byte(`
+package http
+
+func Get(url string) (resp *Response, err error)`))
+	want := `func Get(url <a href="/pkg/builtin/#string">string</a>) (resp *<a href="#Response">Response</a>, err <a href="/pkg/builtin/#error">error</a>)`
+	if got != want {
+		t.Errorf("got: %s\n\nwant: %s\n", got, want)
+	}
+
+	// Method.
+	got = linkifySource(t, []byte(`
+package http
+
+func (h Header) Get(key string) string`))
+	want = `func (h <a href="#Header">Header</a>) Get(key <a href="/pkg/builtin/#string">string</a>) <a href="/pkg/builtin/#string">string</a>`
+	if got != want {
+		t.Errorf("got: %s\n\nwant: %s\n", got, want)
+	}
+}
+
+func linkifySource(t *testing.T, src []byte) string {
+	p := &Presentation{
+		DeclLinks: true,
+	}
+	fset := token.NewFileSet()
+	af, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var buf bytes.Buffer
+	pi := &PageInfo{
+		FSet: fset,
+	}
+	sep := ""
+	for _, decl := range af.Decls {
+		buf.WriteString(sep)
+		sep = "\n"
+		buf.WriteString(p.node_htmlFunc(pi, decl, true))
+	}
+	return buf.String()
+}
+
+func TestScanIdentifier(t *testing.T) {
+	tests := []struct {
+		in, want string
+	}{
+		{"foo bar", "foo"},
+		{"foo/bar", "foo"},
+		{" foo", ""},
+		{"фоо", "фоо"},
+		{"f123", "f123"},
+		{"123f", ""},
+	}
+	for _, tt := range tests {
+		got := scanIdentifier([]byte(tt.in))
+		if string(got) != tt.want {
+			t.Errorf("scanIdentifier(%q) = %q; want %q", tt.in, got, tt.want)
+		}
+	}
+}
+
+func TestReplaceLeadingIndentation(t *testing.T) {
+	oldIndent := strings.Repeat(" ", 2)
+	newIndent := strings.Repeat(" ", 4)
+	tests := []struct {
+		src, want string
+	}{
+		{"  foo\n    bar\n  baz", "    foo\n      bar\n    baz"},
+		{"  '`'\n  '`'\n", "    '`'\n    '`'\n"},
+		{"  '\\''\n  '`'\n", "    '\\''\n    '`'\n"},
+		{"  \"`\"\n  \"`\"\n", "    \"`\"\n    \"`\"\n"},
+		{"  `foo\n  bar`", "    `foo\n      bar`"},
+		{"  `foo\\`\n  bar", "    `foo\\`\n    bar"},
+		{"  '\\`'`foo\n  bar", "    '\\`'`foo\n      bar"},
+		{
+			"  if true {\n    foo := `One\n    \tTwo\nThree`\n  }\n",
+			"    if true {\n      foo := `One\n        \tTwo\n    Three`\n    }\n",
+		},
+	}
+	for _, tc := range tests {
+		if got := replaceLeadingIndentation(tc.src, oldIndent, newIndent); got != tc.want {
+			t.Errorf("replaceLeadingIndentation:\n%v\n---\nhave:\n%v\n---\nwant:\n%v\n",
+				tc.src, got, tc.want)
+		}
+	}
+}
+
+func TestSrcBreadcrumbFunc(t *testing.T) {
+	for _, tc := range []struct {
+		path string
+		want string
+	}{
+		{"src/", `<span class="text-muted">src/</span>`},
+		{"src/fmt/", `<a href="/src">src</a>/<span class="text-muted">fmt/</span>`},
+		{"src/fmt/print.go", `<a href="/src">src</a>/<a href="/src/fmt">fmt</a>/<span class="text-muted">print.go</span>`},
+	} {
+		if got := srcBreadcrumbFunc(tc.path); got != tc.want {
+			t.Errorf("srcBreadcrumbFunc(%v) = %v; want %v", tc.path, got, tc.want)
+		}
+	}
+}
+
+func TestSrcToPkgLinkFunc(t *testing.T) {
+	for _, tc := range []struct {
+		path string
+		want string
+	}{
+		{"src/", `<a href="/pkg">Index</a>`},
+		{"src/fmt/", `<a href="/pkg/fmt">fmt</a>`},
+		{"pkg/", `<a href="/pkg">Index</a>`},
+		{"pkg/LICENSE", `<a href="/pkg">Index</a>`},
+	} {
+		if got := srcToPkgLinkFunc(tc.path); got != tc.want {
+			t.Errorf("srcToPkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/index.go b/vendor/golang.org/x/tools/godoc/index.go
new file mode 100644
index 0000000..8cefd14
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/index.go
@@ -0,0 +1,1581 @@
+// Copyright 2009 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 contains the infrastructure to create an
+// identifier and full-text index for a set of Go files.
+//
+// Algorithm for identifier index:
+// - traverse all .go files of the file tree specified by root
+// - for each identifier (word) encountered, collect all occurrences (spots)
+//   into a list; this produces a list of spots for each word
+// - reduce the lists: from a list of spots to a list of FileRuns,
+//   and from a list of FileRuns into a list of PakRuns
+// - make a HitList from the PakRuns
+//
+// Details:
+// - keep two lists per word: one containing package-level declarations
+//   that have snippets, and one containing all other spots
+// - keep the snippets in a separate table indexed by snippet index
+//   and store the snippet index in place of the line number in a SpotInfo
+//   (the line number for spots with snippets is stored in the snippet)
+// - at the end, create lists of alternative spellings for a given
+//   word
+//
+// Algorithm for full text index:
+// - concatenate all source code in a byte buffer (in memory)
+// - add the files to a file set in lockstep as they are added to the byte
+//   buffer such that a byte buffer offset corresponds to the Pos value for
+//   that file location
+// - create a suffix array from the concatenated sources
+//
+// String lookup in full text index:
+// - use the suffix array to lookup a string's offsets - the offsets
+//   correspond to the Pos values relative to the file set
+// - translate the Pos values back into file and line information and
+//   sort the result
+
+package godoc
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/gob"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/doc"
+	"go/parser"
+	"go/token"
+	"index/suffixarray"
+	"io"
+	"log"
+	"os"
+	pathpkg "path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+
+	"golang.org/x/tools/godoc/util"
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// ----------------------------------------------------------------------------
+// InterfaceSlice is a helper type for sorting interface
+// slices according to some slice-specific sort criteria.
+
+type comparer func(x, y interface{}) bool
+
+type interfaceSlice struct {
+	slice []interface{}
+	less  comparer
+}
+
+// ----------------------------------------------------------------------------
+// RunList
+
+// A RunList is a list of entries that can be sorted according to some
+// criteria. A RunList may be compressed by grouping "runs" of entries
+// which are equal (according to the sort critera) into a new RunList of
+// runs. For instance, a RunList containing pairs (x, y) may be compressed
+// into a RunList containing pair runs (x, {y}) where each run consists of
+// a list of y's with the same x.
+type RunList []interface{}
+
+func (h RunList) sort(less comparer) {
+	sort.Sort(&interfaceSlice{h, less})
+}
+
+func (p *interfaceSlice) Len() int           { return len(p.slice) }
+func (p *interfaceSlice) Less(i, j int) bool { return p.less(p.slice[i], p.slice[j]) }
+func (p *interfaceSlice) Swap(i, j int)      { p.slice[i], p.slice[j] = p.slice[j], p.slice[i] }
+
+// Compress entries which are the same according to a sort criteria
+// (specified by less) into "runs".
+func (h RunList) reduce(less comparer, newRun func(h RunList) interface{}) RunList {
+	if len(h) == 0 {
+		return nil
+	}
+	// len(h) > 0
+
+	// create runs of entries with equal values
+	h.sort(less)
+
+	// for each run, make a new run object and collect them in a new RunList
+	var hh RunList
+	i, x := 0, h[0]
+	for j, y := range h {
+		if less(x, y) {
+			hh = append(hh, newRun(h[i:j]))
+			i, x = j, h[j] // start a new run
+		}
+	}
+	// add final run, if any
+	if i < len(h) {
+		hh = append(hh, newRun(h[i:]))
+	}
+
+	return hh
+}
+
+// ----------------------------------------------------------------------------
+// KindRun
+
+// Debugging support. Disable to see multiple entries per line.
+const removeDuplicates = true
+
+// A KindRun is a run of SpotInfos of the same kind in a given file.
+// The kind (3 bits) is stored in each SpotInfo element; to find the
+// kind of a KindRun, look at any of its elements.
+type KindRun []SpotInfo
+
+// KindRuns are sorted by line number or index. Since the isIndex bit
+// is always the same for all infos in one list we can compare lori's.
+func (k KindRun) Len() int           { return len(k) }
+func (k KindRun) Less(i, j int) bool { return k[i].Lori() < k[j].Lori() }
+func (k KindRun) Swap(i, j int)      { k[i], k[j] = k[j], k[i] }
+
+// FileRun contents are sorted by Kind for the reduction into KindRuns.
+func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() }
+
+// newKindRun allocates a new KindRun from the SpotInfo run h.
+func newKindRun(h RunList) interface{} {
+	run := make(KindRun, len(h))
+	for i, x := range h {
+		run[i] = x.(SpotInfo)
+	}
+
+	// Spots were sorted by file and kind to create this run.
+	// Within this run, sort them by line number or index.
+	sort.Sort(run)
+
+	if removeDuplicates {
+		// Since both the lori and kind field must be
+		// same for duplicates, and since the isIndex
+		// bit is always the same for all infos in one
+		// list we can simply compare the entire info.
+		k := 0
+		prev := SpotInfo(1<<32 - 1) // an unlikely value
+		for _, x := range run {
+			if x != prev {
+				run[k] = x
+				k++
+				prev = x
+			}
+		}
+		run = run[0:k]
+	}
+
+	return run
+}
+
+// ----------------------------------------------------------------------------
+// FileRun
+
+// A Pak describes a Go package.
+type Pak struct {
+	Path string // path of directory containing the package
+	Name string // package name as declared by package clause
+}
+
+// Paks are sorted by name (primary key) and by import path (secondary key).
+func (p *Pak) less(q *Pak) bool {
+	return p.Name < q.Name || p.Name == q.Name && p.Path < q.Path
+}
+
+// A File describes a Go file.
+type File struct {
+	Name string // directory-local file name
+	Pak  *Pak   // the package to which the file belongs
+}
+
+// Path returns the file path of f.
+func (f *File) Path() string {
+	return pathpkg.Join(f.Pak.Path, f.Name)
+}
+
+// A Spot describes a single occurrence of a word.
+type Spot struct {
+	File *File
+	Info SpotInfo
+}
+
+// A FileRun is a list of KindRuns belonging to the same file.
+type FileRun struct {
+	File   *File
+	Groups []KindRun
+}
+
+// Spots are sorted by file path for the reduction into FileRuns.
+func lessSpot(x, y interface{}) bool {
+	fx := x.(Spot).File
+	fy := y.(Spot).File
+	// same as "return fx.Path() < fy.Path()" but w/o computing the file path first
+	px := fx.Pak.Path
+	py := fy.Pak.Path
+	return px < py || px == py && fx.Name < fy.Name
+}
+
+// newFileRun allocates a new FileRun from the Spot run h.
+func newFileRun(h RunList) interface{} {
+	file := h[0].(Spot).File
+
+	// reduce the list of Spots into a list of KindRuns
+	h1 := make(RunList, len(h))
+	for i, x := range h {
+		h1[i] = x.(Spot).Info
+	}
+	h2 := h1.reduce(lessKind, newKindRun)
+
+	// create the FileRun
+	groups := make([]KindRun, len(h2))
+	for i, x := range h2 {
+		groups[i] = x.(KindRun)
+	}
+	return &FileRun{file, groups}
+}
+
+// ----------------------------------------------------------------------------
+// PakRun
+
+// A PakRun describes a run of *FileRuns of a package.
+type PakRun struct {
+	Pak   *Pak
+	Files []*FileRun
+}
+
+// Sorting support for files within a PakRun.
+func (p *PakRun) Len() int           { return len(p.Files) }
+func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Name < p.Files[j].File.Name }
+func (p *PakRun) Swap(i, j int)      { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] }
+
+// FileRuns are sorted by package for the reduction into PakRuns.
+func lessFileRun(x, y interface{}) bool {
+	return x.(*FileRun).File.Pak.less(y.(*FileRun).File.Pak)
+}
+
+// newPakRun allocates a new PakRun from the *FileRun run h.
+func newPakRun(h RunList) interface{} {
+	pak := h[0].(*FileRun).File.Pak
+	files := make([]*FileRun, len(h))
+	for i, x := range h {
+		files[i] = x.(*FileRun)
+	}
+	run := &PakRun{pak, files}
+	sort.Sort(run) // files were sorted by package; sort them by file now
+	return run
+}
+
+// ----------------------------------------------------------------------------
+// HitList
+
+// A HitList describes a list of PakRuns.
+type HitList []*PakRun
+
+// PakRuns are sorted by package.
+func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(y.(*PakRun).Pak) }
+
+func reduce(h0 RunList) HitList {
+	// reduce a list of Spots into a list of FileRuns
+	h1 := h0.reduce(lessSpot, newFileRun)
+	// reduce a list of FileRuns into a list of PakRuns
+	h2 := h1.reduce(lessFileRun, newPakRun)
+	// sort the list of PakRuns by package
+	h2.sort(lessPakRun)
+	// create a HitList
+	h := make(HitList, len(h2))
+	for i, p := range h2 {
+		h[i] = p.(*PakRun)
+	}
+	return h
+}
+
+// filter returns a new HitList created by filtering
+// all PakRuns from h that have a matching pakname.
+func (h HitList) filter(pakname string) HitList {
+	var hh HitList
+	for _, p := range h {
+		if p.Pak.Name == pakname {
+			hh = append(hh, p)
+		}
+	}
+	return hh
+}
+
+// ----------------------------------------------------------------------------
+// AltWords
+
+type wordPair struct {
+	canon string // canonical word spelling (all lowercase)
+	alt   string // alternative spelling
+}
+
+// An AltWords describes a list of alternative spellings for a
+// canonical (all lowercase) spelling of a word.
+type AltWords struct {
+	Canon string   // canonical word spelling (all lowercase)
+	Alts  []string // alternative spelling for the same word
+}
+
+// wordPairs are sorted by their canonical spelling.
+func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon }
+
+// newAltWords allocates a new AltWords from the *wordPair run h.
+func newAltWords(h RunList) interface{} {
+	canon := h[0].(*wordPair).canon
+	alts := make([]string, len(h))
+	for i, x := range h {
+		alts[i] = x.(*wordPair).alt
+	}
+	return &AltWords{canon, alts}
+}
+
+func (a *AltWords) filter(s string) *AltWords {
+	var alts []string
+	for _, w := range a.Alts {
+		if w != s {
+			alts = append(alts, w)
+		}
+	}
+	if len(alts) > 0 {
+		return &AltWords{a.Canon, alts}
+	}
+	return nil
+}
+
+// Ident stores information about external identifiers in order to create
+// links to package documentation.
+type Ident struct {
+	Path    string // e.g. "net/http"
+	Package string // e.g. "http"
+	Name    string // e.g. "NewRequest"
+	Doc     string // e.g. "NewRequest returns a new Request..."
+}
+
+// byImportCount sorts the given slice of Idents by the import
+// counts of the packages to which they belong.
+type byImportCount struct {
+	Idents      []Ident
+	ImportCount map[string]int
+}
+
+func (ic byImportCount) Len() int {
+	return len(ic.Idents)
+}
+
+func (ic byImportCount) Less(i, j int) bool {
+	ri := ic.ImportCount[ic.Idents[i].Path]
+	rj := ic.ImportCount[ic.Idents[j].Path]
+	if ri == rj {
+		return ic.Idents[i].Path < ic.Idents[j].Path
+	}
+	return ri > rj
+}
+
+func (ic byImportCount) Swap(i, j int) {
+	ic.Idents[i], ic.Idents[j] = ic.Idents[j], ic.Idents[i]
+}
+
+func (ic byImportCount) String() string {
+	buf := bytes.NewBuffer([]byte("["))
+	for _, v := range ic.Idents {
+		buf.WriteString(fmt.Sprintf("\n\t%s, %s (%d)", v.Path, v.Name, ic.ImportCount[v.Path]))
+	}
+	buf.WriteString("\n]")
+	return buf.String()
+}
+
+// filter creates a new Ident list where the results match the given
+// package name.
+func (ic byImportCount) filter(pakname string) []Ident {
+	if ic.Idents == nil {
+		return nil
+	}
+	var res []Ident
+	for _, i := range ic.Idents {
+		if i.Package == pakname {
+			res = append(res, i)
+		}
+	}
+	return res
+}
+
+// top returns the top n identifiers.
+func (ic byImportCount) top(n int) []Ident {
+	if len(ic.Idents) > n {
+		return ic.Idents[:n]
+	}
+	return ic.Idents
+}
+
+// ----------------------------------------------------------------------------
+// Indexer
+
+type IndexResult struct {
+	Decls  RunList // package-level declarations (with snippets)
+	Others RunList // all other occurrences
+}
+
+// Statistics provides statistics information for an index.
+type Statistics struct {
+	Bytes int // total size of indexed source files
+	Files int // number of indexed source files
+	Lines int // number of lines (all files)
+	Words int // number of different identifiers
+	Spots int // number of identifier occurrences
+}
+
+// An Indexer maintains the data structures and provides the machinery
+// for indexing .go files under a file tree. It implements the path.Visitor
+// interface for walking file trees, and the ast.Visitor interface for
+// walking Go ASTs.
+type Indexer struct {
+	c          *Corpus
+	fset       *token.FileSet // file set for all indexed files
+	fsOpenGate chan bool      // send pre fs.Open; receive on close
+
+	mu            sync.Mutex              // guards all the following
+	sources       bytes.Buffer            // concatenated sources
+	strings       map[string]string       // interned string
+	packages      map[Pak]*Pak            // interned *Paks
+	words         map[string]*IndexResult // RunLists of Spots
+	snippets      []*Snippet              // indices are stored in SpotInfos
+	current       *token.File             // last file added to file set
+	file          *File                   // AST for current file
+	decl          ast.Decl                // AST for current decl
+	stats         Statistics
+	throttle      *util.Throttle
+	importCount   map[string]int                 // package path ("net/http") => count
+	packagePath   map[string]map[string]bool     // "template" => "text/template" => true
+	exports       map[string]map[string]SpotKind // "net/http" => "ListenAndServe" => FuncDecl
+	curPkgExports map[string]SpotKind
+	idents        map[SpotKind]map[string][]Ident // kind => name => list of Idents
+}
+
+func (x *Indexer) intern(s string) string {
+	if s, ok := x.strings[s]; ok {
+		return s
+	}
+	x.strings[s] = s
+	return s
+}
+
+func (x *Indexer) lookupPackage(path, name string) *Pak {
+	// In the source directory tree, more than one package may
+	// live in the same directory. For the packages map, construct
+	// a key that includes both the directory path and the package
+	// name.
+	key := Pak{Path: x.intern(path), Name: x.intern(name)}
+	pak := x.packages[key]
+	if pak == nil {
+		pak = &key
+		x.packages[key] = pak
+	}
+	return pak
+}
+
+func (x *Indexer) addSnippet(s *Snippet) int {
+	index := len(x.snippets)
+	x.snippets = append(x.snippets, s)
+	return index
+}
+
+func (x *Indexer) visitIdent(kind SpotKind, id *ast.Ident) {
+	if id == nil {
+		return
+	}
+	name := x.intern(id.Name)
+
+	switch kind {
+	case TypeDecl, FuncDecl, ConstDecl, VarDecl:
+		x.curPkgExports[name] = kind
+	}
+
+	lists, found := x.words[name]
+	if !found {
+		lists = new(IndexResult)
+		x.words[name] = lists
+	}
+
+	if kind == Use || x.decl == nil {
+		if x.c.IndexGoCode {
+			// not a declaration or no snippet required
+			info := makeSpotInfo(kind, x.current.Line(id.Pos()), false)
+			lists.Others = append(lists.Others, Spot{x.file, info})
+		}
+	} else {
+		// a declaration with snippet
+		index := x.addSnippet(NewSnippet(x.fset, x.decl, id))
+		info := makeSpotInfo(kind, index, true)
+		lists.Decls = append(lists.Decls, Spot{x.file, info})
+	}
+
+	x.stats.Spots++
+}
+
+func (x *Indexer) visitFieldList(kind SpotKind, flist *ast.FieldList) {
+	for _, f := range flist.List {
+		x.decl = nil // no snippets for fields
+		for _, name := range f.Names {
+			x.visitIdent(kind, name)
+		}
+		ast.Walk(x, f.Type)
+		// ignore tag - not indexed at the moment
+	}
+}
+
+func (x *Indexer) visitSpec(kind SpotKind, spec ast.Spec) {
+	switch n := spec.(type) {
+	case *ast.ImportSpec:
+		x.visitIdent(ImportDecl, n.Name)
+		if n.Path != nil {
+			if imp, err := strconv.Unquote(n.Path.Value); err == nil {
+				x.importCount[x.intern(imp)]++
+			}
+		}
+
+	case *ast.ValueSpec:
+		for _, n := range n.Names {
+			x.visitIdent(kind, n)
+		}
+		ast.Walk(x, n.Type)
+		for _, v := range n.Values {
+			ast.Walk(x, v)
+		}
+
+	case *ast.TypeSpec:
+		x.visitIdent(TypeDecl, n.Name)
+		ast.Walk(x, n.Type)
+	}
+}
+
+func (x *Indexer) visitGenDecl(decl *ast.GenDecl) {
+	kind := VarDecl
+	if decl.Tok == token.CONST {
+		kind = ConstDecl
+	}
+	x.decl = decl
+	for _, s := range decl.Specs {
+		x.visitSpec(kind, s)
+	}
+}
+
+func (x *Indexer) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case nil:
+		// nothing to do
+
+	case *ast.Ident:
+		x.visitIdent(Use, n)
+
+	case *ast.FieldList:
+		x.visitFieldList(VarDecl, n)
+
+	case *ast.InterfaceType:
+		x.visitFieldList(MethodDecl, n.Methods)
+
+	case *ast.DeclStmt:
+		// local declarations should only be *ast.GenDecls;
+		// ignore incorrect ASTs
+		if decl, ok := n.Decl.(*ast.GenDecl); ok {
+			x.decl = nil // no snippets for local declarations
+			x.visitGenDecl(decl)
+		}
+
+	case *ast.GenDecl:
+		x.decl = n
+		x.visitGenDecl(n)
+
+	case *ast.FuncDecl:
+		kind := FuncDecl
+		if n.Recv != nil {
+			kind = MethodDecl
+			ast.Walk(x, n.Recv)
+		}
+		x.decl = n
+		x.visitIdent(kind, n.Name)
+		ast.Walk(x, n.Type)
+		if n.Body != nil {
+			ast.Walk(x, n.Body)
+		}
+
+	case *ast.File:
+		x.decl = nil
+		x.visitIdent(PackageClause, n.Name)
+		for _, d := range n.Decls {
+			ast.Walk(x, d)
+		}
+
+	default:
+		return x
+	}
+
+	return nil
+}
+
+// addFile adds a file to the index if possible and returns the file set file
+// and the file's AST if it was successfully parsed as a Go file. If addFile
+// failed (that is, if the file was not added), it returns file == nil.
+func (x *Indexer) addFile(f vfs.ReadSeekCloser, filename string, goFile bool) (file *token.File, ast *ast.File) {
+	defer f.Close()
+
+	// The file set's base offset and x.sources size must be in lock-step;
+	// this permits the direct mapping of suffix array lookup results to
+	// to corresponding Pos values.
+	//
+	// When a file is added to the file set, its offset base increases by
+	// the size of the file + 1; and the initial base offset is 1. Add an
+	// extra byte to the sources here.
+	x.sources.WriteByte(0)
+
+	// If the sources length doesn't match the file set base at this point
+	// the file set implementation changed or we have another error.
+	base := x.fset.Base()
+	if x.sources.Len() != base {
+		panic("internal error: file base incorrect")
+	}
+
+	// append file contents (src) to x.sources
+	if _, err := x.sources.ReadFrom(f); err == nil {
+		src := x.sources.Bytes()[base:]
+
+		if goFile {
+			// parse the file and in the process add it to the file set
+			if ast, err = parser.ParseFile(x.fset, filename, src, parser.ParseComments); err == nil {
+				file = x.fset.File(ast.Pos()) // ast.Pos() is inside the file
+				return
+			}
+			// file has parse errors, and the AST may be incorrect -
+			// set lines information explicitly and index as ordinary
+			// text file (cannot fall through to the text case below
+			// because the file has already been added to the file set
+			// by the parser)
+			file = x.fset.File(token.Pos(base)) // token.Pos(base) is inside the file
+			file.SetLinesForContent(src)
+			ast = nil
+			return
+		}
+
+		if util.IsText(src) {
+			// only add the file to the file set (for the full text index)
+			file = x.fset.AddFile(filename, x.fset.Base(), len(src))
+			file.SetLinesForContent(src)
+			return
+		}
+	}
+
+	// discard possibly added data
+	x.sources.Truncate(base - 1) // -1 to remove added byte 0 since no file was added
+	return
+}
+
+// Design note: Using an explicit white list of permitted files for indexing
+// makes sure that the important files are included and massively reduces the
+// number of files to index. The advantage over a blacklist is that unexpected
+// (non-blacklisted) files won't suddenly explode the index.
+
+// Files are whitelisted if they have a file name or extension
+// present as key in whitelisted.
+var whitelisted = map[string]bool{
+	".bash":        true,
+	".c":           true,
+	".cc":          true,
+	".cpp":         true,
+	".cxx":         true,
+	".css":         true,
+	".go":          true,
+	".goc":         true,
+	".h":           true,
+	".hh":          true,
+	".hpp":         true,
+	".hxx":         true,
+	".html":        true,
+	".js":          true,
+	".out":         true,
+	".py":          true,
+	".s":           true,
+	".sh":          true,
+	".txt":         true,
+	".xml":         true,
+	"AUTHORS":      true,
+	"CONTRIBUTORS": true,
+	"LICENSE":      true,
+	"Makefile":     true,
+	"PATENTS":      true,
+	"README":       true,
+}
+
+// isWhitelisted returns true if a file is on the list
+// of "permitted" files for indexing. The filename must
+// be the directory-local name of the file.
+func isWhitelisted(filename string) bool {
+	key := pathpkg.Ext(filename)
+	if key == "" {
+		// file has no extension - use entire filename
+		key = filename
+	}
+	return whitelisted[key]
+}
+
+func (x *Indexer) indexDocs(dirname string, filename string, astFile *ast.File) {
+	pkgName := x.intern(astFile.Name.Name)
+	if pkgName == "main" {
+		return
+	}
+	pkgPath := x.intern(strings.TrimPrefix(strings.TrimPrefix(dirname, "/src/"), "pkg/"))
+	astPkg := ast.Package{
+		Name: pkgName,
+		Files: map[string]*ast.File{
+			filename: astFile,
+		},
+	}
+	var m doc.Mode
+	docPkg := doc.New(&astPkg, dirname, m)
+	addIdent := func(sk SpotKind, name string, docstr string) {
+		if x.idents[sk] == nil {
+			x.idents[sk] = make(map[string][]Ident)
+		}
+		name = x.intern(name)
+		x.idents[sk][name] = append(x.idents[sk][name], Ident{
+			Path:    pkgPath,
+			Package: pkgName,
+			Name:    name,
+			Doc:     doc.Synopsis(docstr),
+		})
+	}
+
+	if x.idents[PackageClause] == nil {
+		x.idents[PackageClause] = make(map[string][]Ident)
+	}
+	// List of words under which the package identifier will be stored.
+	// This includes the package name and the components of the directory
+	// in which it resides.
+	words := strings.Split(pathpkg.Dir(pkgPath), "/")
+	if words[0] == "." {
+		words = []string{}
+	}
+	name := x.intern(docPkg.Name)
+	synopsis := doc.Synopsis(docPkg.Doc)
+	words = append(words, name)
+	pkgIdent := Ident{
+		Path:    pkgPath,
+		Package: pkgName,
+		Name:    name,
+		Doc:     synopsis,
+	}
+	for _, word := range words {
+		word = x.intern(word)
+		found := false
+		pkgs := x.idents[PackageClause][word]
+		for i, p := range pkgs {
+			if p.Path == pkgPath {
+				if docPkg.Doc != "" {
+					p.Doc = synopsis
+					pkgs[i] = p
+				}
+				found = true
+				break
+			}
+		}
+		if !found {
+			x.idents[PackageClause][word] = append(x.idents[PackageClause][word], pkgIdent)
+		}
+	}
+
+	for _, c := range docPkg.Consts {
+		for _, name := range c.Names {
+			addIdent(ConstDecl, name, c.Doc)
+		}
+	}
+	for _, t := range docPkg.Types {
+		addIdent(TypeDecl, t.Name, t.Doc)
+		for _, c := range t.Consts {
+			for _, name := range c.Names {
+				addIdent(ConstDecl, name, c.Doc)
+			}
+		}
+		for _, v := range t.Vars {
+			for _, name := range v.Names {
+				addIdent(VarDecl, name, v.Doc)
+			}
+		}
+		for _, f := range t.Funcs {
+			addIdent(FuncDecl, f.Name, f.Doc)
+		}
+		for _, f := range t.Methods {
+			addIdent(MethodDecl, f.Name, f.Doc)
+			// Change the name of methods to be "<typename>.<methodname>".
+			// They will still be indexed as <methodname>.
+			idents := x.idents[MethodDecl][f.Name]
+			idents[len(idents)-1].Name = x.intern(t.Name + "." + f.Name)
+		}
+	}
+	for _, v := range docPkg.Vars {
+		for _, name := range v.Names {
+			addIdent(VarDecl, name, v.Doc)
+		}
+	}
+	for _, f := range docPkg.Funcs {
+		addIdent(FuncDecl, f.Name, f.Doc)
+	}
+}
+
+func (x *Indexer) indexGoFile(dirname string, filename string, file *token.File, astFile *ast.File) {
+	pkgName := astFile.Name.Name
+
+	if x.c.IndexGoCode {
+		x.current = file
+		pak := x.lookupPackage(dirname, pkgName)
+		x.file = &File{filename, pak}
+		ast.Walk(x, astFile)
+	}
+
+	if x.c.IndexDocs {
+		// Test files are already filtered out in visitFile if IndexGoCode and
+		// IndexFullText are false.  Otherwise, check here.
+		isTestFile := (x.c.IndexGoCode || x.c.IndexFullText) &&
+			(strings.HasSuffix(filename, "_test.go") || strings.HasPrefix(dirname, "/test/"))
+		if !isTestFile {
+			x.indexDocs(dirname, filename, astFile)
+		}
+	}
+
+	ppKey := x.intern(pkgName)
+	if _, ok := x.packagePath[ppKey]; !ok {
+		x.packagePath[ppKey] = make(map[string]bool)
+	}
+	pkgPath := x.intern(strings.TrimPrefix(strings.TrimPrefix(dirname, "/src/"), "pkg/"))
+	x.packagePath[ppKey][pkgPath] = true
+
+	// Merge in exported symbols found walking this file into
+	// the map for that package.
+	if len(x.curPkgExports) > 0 {
+		dest, ok := x.exports[pkgPath]
+		if !ok {
+			dest = make(map[string]SpotKind)
+			x.exports[pkgPath] = dest
+		}
+		for k, v := range x.curPkgExports {
+			dest[k] = v
+		}
+	}
+}
+
+func (x *Indexer) visitFile(dirname string, fi os.FileInfo) {
+	if fi.IsDir() || !x.c.IndexEnabled {
+		return
+	}
+
+	filename := pathpkg.Join(dirname, fi.Name())
+	goFile := isGoFile(fi)
+
+	switch {
+	case x.c.IndexFullText:
+		if !isWhitelisted(fi.Name()) {
+			return
+		}
+	case x.c.IndexGoCode:
+		if !goFile {
+			return
+		}
+	case x.c.IndexDocs:
+		if !goFile ||
+			strings.HasSuffix(fi.Name(), "_test.go") ||
+			strings.HasPrefix(dirname, "/test/") {
+			return
+		}
+	default:
+		// No indexing turned on.
+		return
+	}
+
+	x.fsOpenGate <- true
+	defer func() { <-x.fsOpenGate }()
+
+	// open file
+	f, err := x.c.fs.Open(filename)
+	if err != nil {
+		return
+	}
+
+	x.mu.Lock()
+	defer x.mu.Unlock()
+
+	x.throttle.Throttle()
+
+	x.curPkgExports = make(map[string]SpotKind)
+	file, fast := x.addFile(f, filename, goFile)
+	if file == nil {
+		return // addFile failed
+	}
+
+	if fast != nil {
+		x.indexGoFile(dirname, fi.Name(), file, fast)
+	}
+
+	// update statistics
+	x.stats.Bytes += file.Size()
+	x.stats.Files++
+	x.stats.Lines += file.LineCount()
+}
+
+// indexOptions contains information that affects the contents of an index.
+type indexOptions struct {
+	// Docs provides documentation search results.
+	// It is only consulted if IndexEnabled is true.
+	// The default values is true.
+	Docs bool
+
+	// GoCode provides Go source code search results.
+	// It is only consulted if IndexEnabled is true.
+	// The default values is true.
+	GoCode bool
+
+	// FullText provides search results from all files.
+	// It is only consulted if IndexEnabled is true.
+	// The default values is true.
+	FullText bool
+
+	// MaxResults optionally specifies the maximum results for indexing.
+	// The default is 1000.
+	MaxResults int
+}
+
+// ----------------------------------------------------------------------------
+// Index
+
+type LookupResult struct {
+	Decls  HitList // package-level declarations (with snippets)
+	Others HitList // all other occurrences
+}
+
+type Index struct {
+	fset        *token.FileSet           // file set used during indexing; nil if no textindex
+	suffixes    *suffixarray.Index       // suffixes for concatenated sources; nil if no textindex
+	words       map[string]*LookupResult // maps words to hit lists
+	alts        map[string]*AltWords     // maps canonical(words) to lists of alternative spellings
+	snippets    []*Snippet               // all snippets, indexed by snippet index
+	stats       Statistics
+	importCount map[string]int                 // package path ("net/http") => count
+	packagePath map[string]map[string]bool     // "template" => "text/template" => true
+	exports     map[string]map[string]SpotKind // "net/http" => "ListenAndServe" => FuncDecl
+	idents      map[SpotKind]map[string][]Ident
+	opts        indexOptions
+}
+
+func canonical(w string) string { return strings.ToLower(w) }
+
+// Somewhat arbitrary, but I figure low enough to not hurt disk-based filesystems
+// consuming file descriptors, where some systems have low 256 or 512 limits.
+// Go should have a built-in way to cap fd usage under the ulimit.
+const (
+	maxOpenFiles = 200
+	maxOpenDirs  = 50
+)
+
+func (c *Corpus) throttle() float64 {
+	if c.IndexThrottle <= 0 {
+		return 0.9
+	}
+	if c.IndexThrottle > 1.0 {
+		return 1.0
+	}
+	return c.IndexThrottle
+}
+
+// NewIndex creates a new index for the .go files provided by the corpus.
+func (c *Corpus) NewIndex() *Index {
+	// initialize Indexer
+	// (use some reasonably sized maps to start)
+	x := &Indexer{
+		c:           c,
+		fset:        token.NewFileSet(),
+		fsOpenGate:  make(chan bool, maxOpenFiles),
+		strings:     make(map[string]string),
+		packages:    make(map[Pak]*Pak, 256),
+		words:       make(map[string]*IndexResult, 8192),
+		throttle:    util.NewThrottle(c.throttle(), 100*time.Millisecond), // run at least 0.1s at a time
+		importCount: make(map[string]int),
+		packagePath: make(map[string]map[string]bool),
+		exports:     make(map[string]map[string]SpotKind),
+		idents:      make(map[SpotKind]map[string][]Ident, 4),
+	}
+
+	// index all files in the directories given by dirnames
+	var wg sync.WaitGroup // outstanding ReadDir + visitFile
+	dirGate := make(chan bool, maxOpenDirs)
+	for dirname := range c.fsDirnames() {
+		if c.IndexDirectory != nil && !c.IndexDirectory(dirname) {
+			continue
+		}
+		dirGate <- true
+		wg.Add(1)
+		go func(dirname string) {
+			defer func() { <-dirGate }()
+			defer wg.Done()
+
+			list, err := c.fs.ReadDir(dirname)
+			if err != nil {
+				log.Printf("ReadDir(%q): %v; skipping directory", dirname, err)
+				return // ignore this directory
+			}
+			for _, fi := range list {
+				wg.Add(1)
+				go func(fi os.FileInfo) {
+					defer wg.Done()
+					x.visitFile(dirname, fi)
+				}(fi)
+			}
+		}(dirname)
+	}
+	wg.Wait()
+
+	if !c.IndexFullText {
+		// the file set, the current file, and the sources are
+		// not needed after indexing if no text index is built -
+		// help GC and clear them
+		x.fset = nil
+		x.sources.Reset()
+		x.current = nil // contains reference to fset!
+	}
+
+	// for each word, reduce the RunLists into a LookupResult;
+	// also collect the word with its canonical spelling in a
+	// word list for later computation of alternative spellings
+	words := make(map[string]*LookupResult)
+	var wlist RunList
+	for w, h := range x.words {
+		decls := reduce(h.Decls)
+		others := reduce(h.Others)
+		words[w] = &LookupResult{
+			Decls:  decls,
+			Others: others,
+		}
+		wlist = append(wlist, &wordPair{canonical(w), w})
+		x.throttle.Throttle()
+	}
+	x.stats.Words = len(words)
+
+	// reduce the word list {canonical(w), w} into
+	// a list of AltWords runs {canonical(w), {w}}
+	alist := wlist.reduce(lessWordPair, newAltWords)
+
+	// convert alist into a map of alternative spellings
+	alts := make(map[string]*AltWords)
+	for i := 0; i < len(alist); i++ {
+		a := alist[i].(*AltWords)
+		alts[a.Canon] = a
+	}
+
+	// create text index
+	var suffixes *suffixarray.Index
+	if c.IndexFullText {
+		suffixes = suffixarray.New(x.sources.Bytes())
+	}
+
+	// sort idents by the number of imports of their respective packages
+	for _, idMap := range x.idents {
+		for _, ir := range idMap {
+			sort.Sort(byImportCount{ir, x.importCount})
+		}
+	}
+
+	return &Index{
+		fset:        x.fset,
+		suffixes:    suffixes,
+		words:       words,
+		alts:        alts,
+		snippets:    x.snippets,
+		stats:       x.stats,
+		importCount: x.importCount,
+		packagePath: x.packagePath,
+		exports:     x.exports,
+		idents:      x.idents,
+		opts: indexOptions{
+			Docs:       x.c.IndexDocs,
+			GoCode:     x.c.IndexGoCode,
+			FullText:   x.c.IndexFullText,
+			MaxResults: x.c.MaxResults,
+		},
+	}
+}
+
+var ErrFileIndexVersion = errors.New("file index version out of date")
+
+const fileIndexVersion = 3
+
+// fileIndex is the subset of Index that's gob-encoded for use by
+// Index.Write and Index.Read.
+type fileIndex struct {
+	Version     int
+	Words       map[string]*LookupResult
+	Alts        map[string]*AltWords
+	Snippets    []*Snippet
+	Fulltext    bool
+	Stats       Statistics
+	ImportCount map[string]int
+	PackagePath map[string]map[string]bool
+	Exports     map[string]map[string]SpotKind
+	Idents      map[SpotKind]map[string][]Ident
+	Opts        indexOptions
+}
+
+func (x *fileIndex) Write(w io.Writer) error {
+	return gob.NewEncoder(w).Encode(x)
+}
+
+func (x *fileIndex) Read(r io.Reader) error {
+	return gob.NewDecoder(r).Decode(x)
+}
+
+// WriteTo writes the index x to w.
+func (x *Index) WriteTo(w io.Writer) (n int64, err error) {
+	w = countingWriter{&n, w}
+	fulltext := false
+	if x.suffixes != nil {
+		fulltext = true
+	}
+	fx := fileIndex{
+		Version:     fileIndexVersion,
+		Words:       x.words,
+		Alts:        x.alts,
+		Snippets:    x.snippets,
+		Fulltext:    fulltext,
+		Stats:       x.stats,
+		ImportCount: x.importCount,
+		PackagePath: x.packagePath,
+		Exports:     x.exports,
+		Idents:      x.idents,
+		Opts:        x.opts,
+	}
+	if err := fx.Write(w); err != nil {
+		return 0, err
+	}
+	if fulltext {
+		encode := func(x interface{}) error {
+			return gob.NewEncoder(w).Encode(x)
+		}
+		if err := x.fset.Write(encode); err != nil {
+			return 0, err
+		}
+		if err := x.suffixes.Write(w); err != nil {
+			return 0, err
+		}
+	}
+	return n, nil
+}
+
+// ReadFrom reads the index from r into x; x must not be nil.
+// If r does not also implement io.ByteReader, it will be wrapped in a bufio.Reader.
+// If the index is from an old version, the error is ErrFileIndexVersion.
+func (x *Index) ReadFrom(r io.Reader) (n int64, err error) {
+	// We use the ability to read bytes as a plausible surrogate for buffering.
+	if _, ok := r.(io.ByteReader); !ok {
+		r = bufio.NewReader(r)
+	}
+	r = countingReader{&n, r.(byteReader)}
+	var fx fileIndex
+	if err := fx.Read(r); err != nil {
+		return n, err
+	}
+	if fx.Version != fileIndexVersion {
+		return 0, ErrFileIndexVersion
+	}
+	x.words = fx.Words
+	x.alts = fx.Alts
+	x.snippets = fx.Snippets
+	x.stats = fx.Stats
+	x.importCount = fx.ImportCount
+	x.packagePath = fx.PackagePath
+	x.exports = fx.Exports
+	x.idents = fx.Idents
+	x.opts = fx.Opts
+	if fx.Fulltext {
+		x.fset = token.NewFileSet()
+		decode := func(x interface{}) error {
+			return gob.NewDecoder(r).Decode(x)
+		}
+		if err := x.fset.Read(decode); err != nil {
+			return n, err
+		}
+		x.suffixes = new(suffixarray.Index)
+		if err := x.suffixes.Read(r); err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+// Stats returns index statistics.
+func (x *Index) Stats() Statistics {
+	return x.stats
+}
+
+// ImportCount returns a map from import paths to how many times they were seen.
+func (x *Index) ImportCount() map[string]int {
+	return x.importCount
+}
+
+// PackagePath returns a map from short package name to a set
+// of full package path names that use that short package name.
+func (x *Index) PackagePath() map[string]map[string]bool {
+	return x.packagePath
+}
+
+// Exports returns a map from full package path to exported
+// symbol name to its type.
+func (x *Index) Exports() map[string]map[string]SpotKind {
+	return x.exports
+}
+
+// Idents returns a map from identifier type to exported
+// symbol name to the list of identifiers matching that name.
+func (x *Index) Idents() map[SpotKind]map[string][]Ident {
+	return x.idents
+}
+
+func (x *Index) lookupWord(w string) (match *LookupResult, alt *AltWords) {
+	match = x.words[w]
+	alt = x.alts[canonical(w)]
+	// remove current spelling from alternatives
+	// (if there is no match, the alternatives do
+	// not contain the current spelling)
+	if match != nil && alt != nil {
+		alt = alt.filter(w)
+	}
+	return
+}
+
+// isIdentifier reports whether s is a Go identifier.
+func isIdentifier(s string) bool {
+	for i, ch := range s {
+		if unicode.IsLetter(ch) || ch == '_' || i > 0 && unicode.IsDigit(ch) {
+			continue
+		}
+		return false
+	}
+	return len(s) > 0
+}
+
+// For a given query, which is either a single identifier or a qualified
+// identifier, Lookup returns a SearchResult containing packages, a LookupResult, a
+// list of alternative spellings, and identifiers, if any. Any and all results
+// may be nil.  If the query syntax is wrong, an error is reported.
+func (x *Index) Lookup(query string) (*SearchResult, error) {
+	ss := strings.Split(query, ".")
+
+	// check query syntax
+	for _, s := range ss {
+		if !isIdentifier(s) {
+			return nil, errors.New("all query parts must be identifiers")
+		}
+	}
+	rslt := &SearchResult{
+		Query:  query,
+		Idents: make(map[SpotKind][]Ident, 5),
+	}
+	// handle simple and qualified identifiers
+	switch len(ss) {
+	case 1:
+		ident := ss[0]
+		rslt.Hit, rslt.Alt = x.lookupWord(ident)
+		if rslt.Hit != nil {
+			// found a match - filter packages with same name
+			// for the list of packages called ident, if any
+			rslt.Pak = rslt.Hit.Others.filter(ident)
+		}
+		for k, v := range x.idents {
+			const rsltLimit = 50
+			ids := byImportCount{v[ident], x.importCount}
+			rslt.Idents[k] = ids.top(rsltLimit)
+		}
+
+	case 2:
+		pakname, ident := ss[0], ss[1]
+		rslt.Hit, rslt.Alt = x.lookupWord(ident)
+		if rslt.Hit != nil {
+			// found a match - filter by package name
+			// (no paks - package names are not qualified)
+			decls := rslt.Hit.Decls.filter(pakname)
+			others := rslt.Hit.Others.filter(pakname)
+			rslt.Hit = &LookupResult{decls, others}
+		}
+		for k, v := range x.idents {
+			ids := byImportCount{v[ident], x.importCount}
+			rslt.Idents[k] = ids.filter(pakname)
+		}
+
+	default:
+		return nil, errors.New("query is not a (qualified) identifier")
+	}
+
+	return rslt, nil
+}
+
+func (x *Index) Snippet(i int) *Snippet {
+	// handle illegal snippet indices gracefully
+	if 0 <= i && i < len(x.snippets) {
+		return x.snippets[i]
+	}
+	return nil
+}
+
+type positionList []struct {
+	filename string
+	line     int
+}
+
+func (list positionList) Len() int           { return len(list) }
+func (list positionList) Less(i, j int) bool { return list[i].filename < list[j].filename }
+func (list positionList) Swap(i, j int)      { list[i], list[j] = list[j], list[i] }
+
+// unique returns the list sorted and with duplicate entries removed
+func unique(list []int) []int {
+	sort.Ints(list)
+	var last int
+	i := 0
+	for _, x := range list {
+		if i == 0 || x != last {
+			last = x
+			list[i] = x
+			i++
+		}
+	}
+	return list[0:i]
+}
+
+// A FileLines value specifies a file and line numbers within that file.
+type FileLines struct {
+	Filename string
+	Lines    []int
+}
+
+// LookupRegexp returns the number of matches and the matches where a regular
+// expression r is found in the full text index. At most n matches are
+// returned (thus found <= n).
+//
+func (x *Index) LookupRegexp(r *regexp.Regexp, n int) (found int, result []FileLines) {
+	if x.suffixes == nil || n <= 0 {
+		return
+	}
+	// n > 0
+
+	var list positionList
+	// FindAllIndex may returns matches that span across file boundaries.
+	// Such matches are unlikely, buf after eliminating them we may end up
+	// with fewer than n matches. If we don't have enough at the end, redo
+	// the search with an increased value n1, but only if FindAllIndex
+	// returned all the requested matches in the first place (if it
+	// returned fewer than that there cannot be more).
+	for n1 := n; found < n; n1 += n - found {
+		found = 0
+		matches := x.suffixes.FindAllIndex(r, n1)
+		// compute files, exclude matches that span file boundaries,
+		// and map offsets to file-local offsets
+		list = make(positionList, len(matches))
+		for _, m := range matches {
+			// by construction, an offset corresponds to the Pos value
+			// for the file set - use it to get the file and line
+			p := token.Pos(m[0])
+			if file := x.fset.File(p); file != nil {
+				if base := file.Base(); base <= m[1] && m[1] <= base+file.Size() {
+					// match [m[0], m[1]) is within the file boundaries
+					list[found].filename = file.Name()
+					list[found].line = file.Line(p)
+					found++
+				}
+			}
+		}
+		if found == n || len(matches) < n1 {
+			// found all matches or there's no chance to find more
+			break
+		}
+	}
+	list = list[0:found]
+	sort.Sort(list) // sort by filename
+
+	// collect matches belonging to the same file
+	var last string
+	var lines []int
+	addLines := func() {
+		if len(lines) > 0 {
+			// remove duplicate lines
+			result = append(result, FileLines{last, unique(lines)})
+			lines = nil
+		}
+	}
+	for _, m := range list {
+		if m.filename != last {
+			addLines()
+			last = m.filename
+		}
+		lines = append(lines, m.line)
+	}
+	addLines()
+
+	return
+}
+
+// InvalidateIndex should be called whenever any of the file systems
+// under godoc's observation change so that the indexer is kicked on.
+func (c *Corpus) invalidateIndex() {
+	c.fsModified.Set(nil)
+	c.refreshMetadata()
+}
+
+// feedDirnames feeds the directory names of all directories
+// under the file system given by root to channel c.
+//
+func (c *Corpus) feedDirnames(ch chan<- string) {
+	if dir, _ := c.fsTree.Get(); dir != nil {
+		for d := range dir.(*Directory).iter(false) {
+			ch <- d.Path
+		}
+	}
+}
+
+// fsDirnames() returns a channel sending all directory names
+// of all the file systems under godoc's observation.
+//
+func (c *Corpus) fsDirnames() <-chan string {
+	ch := make(chan string, 256) // buffered for fewer context switches
+	go func() {
+		c.feedDirnames(ch)
+		close(ch)
+	}()
+	return ch
+}
+
+// CompatibleWith reports whether the Index x is compatible with the corpus
+// indexing options set in c.
+func (x *Index) CompatibleWith(c *Corpus) bool {
+	return x.opts.Docs == c.IndexDocs &&
+		x.opts.GoCode == c.IndexGoCode &&
+		x.opts.FullText == c.IndexFullText &&
+		x.opts.MaxResults == c.MaxResults
+}
+
+func (c *Corpus) readIndex(filenames string) error {
+	matches, err := filepath.Glob(filenames)
+	if err != nil {
+		return err
+	} else if matches == nil {
+		return fmt.Errorf("no index files match %q", filenames)
+	}
+	sort.Strings(matches) // make sure files are in the right order
+	files := make([]io.Reader, 0, len(matches))
+	for _, filename := range matches {
+		f, err := os.Open(filename)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		files = append(files, f)
+	}
+	return c.ReadIndexFrom(io.MultiReader(files...))
+}
+
+// ReadIndexFrom sets the current index from the serialized version found in r.
+func (c *Corpus) ReadIndexFrom(r io.Reader) error {
+	x := new(Index)
+	if _, err := x.ReadFrom(r); err != nil {
+		return err
+	}
+	if !x.CompatibleWith(c) {
+		return fmt.Errorf("index file options are incompatible: %v", x.opts)
+	}
+	c.searchIndex.Set(x)
+	return nil
+}
+
+func (c *Corpus) UpdateIndex() {
+	if c.Verbose {
+		log.Printf("updating index...")
+	}
+	start := time.Now()
+	index := c.NewIndex()
+	stop := time.Now()
+	c.searchIndex.Set(index)
+	if c.Verbose {
+		secs := stop.Sub(start).Seconds()
+		stats := index.Stats()
+		log.Printf("index updated (%gs, %d bytes of source, %d files, %d lines, %d unique words, %d spots)",
+			secs, stats.Bytes, stats.Files, stats.Lines, stats.Words, stats.Spots)
+	}
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(memstats)
+	if c.Verbose {
+		log.Printf("before GC: bytes = %d footprint = %d", memstats.HeapAlloc, memstats.Sys)
+	}
+	runtime.GC()
+	runtime.ReadMemStats(memstats)
+	if c.Verbose {
+		log.Printf("after  GC: bytes = %d footprint = %d", memstats.HeapAlloc, memstats.Sys)
+	}
+}
+
+// RunIndexer runs forever, indexing.
+func (c *Corpus) RunIndexer() {
+	// initialize the index from disk if possible
+	if c.IndexFiles != "" {
+		c.initFSTree()
+		if err := c.readIndex(c.IndexFiles); err != nil {
+			log.Printf("error reading index from file %s: %v", c.IndexFiles, err)
+		}
+		return
+	}
+
+	// Repeatedly update the package directory tree and index.
+	// TODO(bgarcia): Use fsnotify to only update when notified of a filesystem change.
+	for {
+		c.initFSTree()
+		c.UpdateIndex()
+		if c.IndexInterval < 0 {
+			return
+		}
+		delay := 5 * time.Minute // by default, reindex every 5 minutes
+		if c.IndexInterval > 0 {
+			delay = c.IndexInterval
+		}
+		time.Sleep(delay)
+	}
+}
+
+type countingWriter struct {
+	n *int64
+	w io.Writer
+}
+
+func (c countingWriter) Write(p []byte) (n int, err error) {
+	n, err = c.w.Write(p)
+	*c.n += int64(n)
+	return
+}
+
+type byteReader interface {
+	io.Reader
+	io.ByteReader
+}
+
+type countingReader struct {
+	n *int64
+	r byteReader
+}
+
+func (c countingReader) Read(p []byte) (n int, err error) {
+	n, err = c.r.Read(p)
+	*c.n += int64(n)
+	return
+}
+
+func (c countingReader) ReadByte() (b byte, err error) {
+	b, err = c.r.ReadByte()
+	*c.n += 1
+	return
+}
diff --git a/vendor/golang.org/x/tools/godoc/index_test.go b/vendor/golang.org/x/tools/godoc/index_test.go
new file mode 100644
index 0000000..97f31e7
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/index_test.go
@@ -0,0 +1,323 @@
+// 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 godoc
+
+import (
+	"bytes"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/godoc/vfs/mapfs"
+)
+
+func newCorpus(t *testing.T) *Corpus {
+	c := NewCorpus(mapfs.New(map[string]string{
+		"src/foo/foo.go": `// Package foo is an example.
+package foo
+
+import "bar"
+
+const Pi = 3.1415
+
+var Foos []Foo
+
+// Foo is stuff.
+type Foo struct{}
+
+func New() *Foo {
+   return new(Foo)
+}
+`,
+		"src/bar/bar.go": `// Package bar is another example to test races.
+package bar
+`,
+		"src/other/bar/bar.go": `// Package bar is another bar package.
+package bar
+func X() {}
+`,
+		"src/skip/skip.go": `// Package skip should be skipped.
+package skip
+func Skip() {}
+`,
+		"src/bar/readme.txt": `Whitelisted text file.
+`,
+		"src/bar/baz.zzz": `Text file not whitelisted.
+`,
+	}))
+	c.IndexEnabled = true
+	c.IndexDirectory = func(dir string) bool {
+		return !strings.Contains(dir, "skip")
+	}
+
+	if err := c.Init(); err != nil {
+		t.Fatal(err)
+	}
+	return c
+}
+
+func TestIndex(t *testing.T) {
+	for _, docs := range []bool{true, false} {
+		for _, goCode := range []bool{true, false} {
+			for _, fullText := range []bool{true, false} {
+				c := newCorpus(t)
+				c.IndexDocs = docs
+				c.IndexGoCode = goCode
+				c.IndexFullText = fullText
+				c.UpdateIndex()
+				ix, _ := c.CurrentIndex()
+				if ix == nil {
+					t.Fatal("no index")
+				}
+				t.Logf("docs, goCode, fullText = %v,%v,%v", docs, goCode, fullText)
+				testIndex(t, c, ix)
+			}
+		}
+	}
+}
+
+func TestIndexWriteRead(t *testing.T) {
+	type key struct {
+		docs, goCode, fullText bool
+	}
+	type val struct {
+		buf *bytes.Buffer
+		c   *Corpus
+	}
+	m := map[key]val{}
+
+	for _, docs := range []bool{true, false} {
+		for _, goCode := range []bool{true, false} {
+			for _, fullText := range []bool{true, false} {
+				k := key{docs, goCode, fullText}
+				c := newCorpus(t)
+				c.IndexDocs = docs
+				c.IndexGoCode = goCode
+				c.IndexFullText = fullText
+				c.UpdateIndex()
+				ix, _ := c.CurrentIndex()
+				if ix == nil {
+					t.Fatal("no index")
+				}
+				var buf bytes.Buffer
+				nw, err := ix.WriteTo(&buf)
+				if err != nil {
+					t.Fatalf("Index.WriteTo: %v", err)
+				}
+				m[k] = val{bytes.NewBuffer(buf.Bytes()), c}
+				ix2 := new(Index)
+				nr, err := ix2.ReadFrom(&buf)
+				if err != nil {
+					t.Fatalf("Index.ReadFrom: %v", err)
+				}
+				if nr != nw {
+					t.Errorf("Wrote %d bytes to index but read %d", nw, nr)
+				}
+				testIndex(t, c, ix)
+			}
+		}
+	}
+	// Test CompatibleWith
+	for k1, v1 := range m {
+		ix := new(Index)
+		if _, err := ix.ReadFrom(v1.buf); err != nil {
+			t.Fatalf("Index.ReadFrom: %v", err)
+		}
+		for k2, v2 := range m {
+			if got, want := ix.CompatibleWith(v2.c), k1 == k2; got != want {
+				t.Errorf("CompatibleWith = %v; want %v for %v, %v", got, want, k1, k2)
+			}
+		}
+	}
+}
+
+func testIndex(t *testing.T, c *Corpus, ix *Index) {
+	if _, ok := ix.words["Skip"]; ok {
+		t.Errorf("the word Skip was found; expected it to be skipped")
+	}
+	checkStats(t, c, ix)
+	checkImportCount(t, c, ix)
+	checkPackagePath(t, c, ix)
+	checkExports(t, c, ix)
+	checkIdents(t, c, ix)
+}
+
+// checkStats checks the Index's statistics.
+// Some statistics are only set when we're indexing Go code.
+func checkStats(t *testing.T, c *Corpus, ix *Index) {
+	want := Statistics{}
+	if c.IndexFullText {
+		want.Bytes = 314
+		want.Files = 4
+		want.Lines = 21
+	} else if c.IndexDocs || c.IndexGoCode {
+		want.Bytes = 291
+		want.Files = 3
+		want.Lines = 20
+	}
+	if c.IndexGoCode {
+		want.Words = 8
+		want.Spots = 12
+	}
+	if got := ix.Stats(); !reflect.DeepEqual(got, want) {
+		t.Errorf("Stats = %#v; want %#v", got, want)
+	}
+}
+
+// checkImportCount checks the Index's import count map.
+// It is only set when we're indexing Go code.
+func checkImportCount(t *testing.T, c *Corpus, ix *Index) {
+	want := map[string]int{}
+	if c.IndexGoCode {
+		want = map[string]int{
+			"bar": 1,
+		}
+	}
+	if got := ix.ImportCount(); !reflect.DeepEqual(got, want) {
+		t.Errorf("ImportCount = %v; want %v", got, want)
+	}
+}
+
+// checkPackagePath checks the Index's package path map.
+// It is set if at least one of the indexing options is enabled.
+func checkPackagePath(t *testing.T, c *Corpus, ix *Index) {
+	want := map[string]map[string]bool{}
+	if c.IndexDocs || c.IndexGoCode || c.IndexFullText {
+		want = map[string]map[string]bool{
+			"foo": {
+				"foo": true,
+			},
+			"bar": {
+				"bar":       true,
+				"other/bar": true,
+			},
+		}
+	}
+	if got := ix.PackagePath(); !reflect.DeepEqual(got, want) {
+		t.Errorf("PackagePath = %v; want %v", got, want)
+	}
+}
+
+// checkExports checks the Index's exports map.
+// It is only set when we're indexing Go code.
+func checkExports(t *testing.T, c *Corpus, ix *Index) {
+	want := map[string]map[string]SpotKind{}
+	if c.IndexGoCode {
+		want = map[string]map[string]SpotKind{
+			"foo": {
+				"Pi":   ConstDecl,
+				"Foos": VarDecl,
+				"Foo":  TypeDecl,
+				"New":  FuncDecl,
+			},
+			"other/bar": {
+				"X": FuncDecl,
+			},
+		}
+	}
+	if got := ix.Exports(); !reflect.DeepEqual(got, want) {
+		t.Errorf("Exports = %v; want %v", got, want)
+	}
+}
+
+// checkIdents checks the Index's indents map.
+// It is only set when we're indexing documentation.
+func checkIdents(t *testing.T, c *Corpus, ix *Index) {
+	want := map[SpotKind]map[string][]Ident{}
+	if c.IndexDocs {
+		want = map[SpotKind]map[string][]Ident{
+			PackageClause: {
+				"bar": {
+					{"bar", "bar", "bar", "Package bar is another example to test races."},
+					{"other/bar", "bar", "bar", "Package bar is another bar package."},
+				},
+				"foo":   {{"foo", "foo", "foo", "Package foo is an example."}},
+				"other": {{"other/bar", "bar", "bar", "Package bar is another bar package."}},
+			},
+			ConstDecl: {
+				"Pi": {{"foo", "foo", "Pi", ""}},
+			},
+			VarDecl: {
+				"Foos": {{"foo", "foo", "Foos", ""}},
+			},
+			TypeDecl: {
+				"Foo": {{"foo", "foo", "Foo", "Foo is stuff."}},
+			},
+			FuncDecl: {
+				"New": {{"foo", "foo", "New", ""}},
+				"X":   {{"other/bar", "bar", "X", ""}},
+			},
+		}
+	}
+	if got := ix.Idents(); !reflect.DeepEqual(got, want) {
+		t.Errorf("Idents = %v; want %v", got, want)
+	}
+}
+
+func TestIdentResultSort(t *testing.T) {
+	ic := map[string]int{
+		"/a/b/pkg1": 10,
+		"/a/b/pkg2": 2,
+		"/b/d/pkg3": 20,
+	}
+	for _, tc := range []struct {
+		ir  []Ident
+		exp []Ident
+	}{
+		{
+			ir: []Ident{
+				{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
+				{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
+				{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
+			},
+			exp: []Ident{
+				{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
+				{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
+				{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
+			},
+		},
+		{
+			ir: []Ident{
+				{"/a/a/pkg1", "pkg1", "MyFunc1", ""},
+				{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
+			},
+			exp: []Ident{
+				{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
+				{"/a/a/pkg1", "pkg1", "MyFunc1", ""},
+			},
+		},
+	} {
+		if sort.Sort(byImportCount{tc.ir, ic}); !reflect.DeepEqual(tc.ir, tc.exp) {
+			t.Errorf("got: %v, want %v", tc.ir, tc.exp)
+		}
+	}
+}
+
+func TestIdentFilter(t *testing.T) {
+	ic := map[string]int{}
+	for _, tc := range []struct {
+		ir  []Ident
+		pak string
+		exp []Ident
+	}{
+		{
+			ir: []Ident{
+				{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
+				{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
+				{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
+			},
+			pak: "pkg2",
+			exp: []Ident{
+				{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
+			},
+		},
+	} {
+		res := byImportCount{tc.ir, ic}.filter(tc.pak)
+		if !reflect.DeepEqual(res, tc.exp) {
+			t.Errorf("got: %v, want %v", res, tc.exp)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/linkify.go b/vendor/golang.org/x/tools/godoc/linkify.go
new file mode 100644
index 0000000..e4add22
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/linkify.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.
+
+// This file implements LinkifyText which introduces
+// links for identifiers pointing to their declarations.
+// The approach does not cover all cases because godoc
+// doesn't have complete type information, but it's
+// reasonably good for browsing.
+
+package godoc
+
+import (
+	"fmt"
+	"go/ast"
+	"go/doc"
+	"go/token"
+	"io"
+	"strconv"
+)
+
+// LinkifyText HTML-escapes source text and writes it to w.
+// Identifiers that are in a "use" position (i.e., that are
+// not being declared), are wrapped with HTML links pointing
+// to the respective declaration, if possible. Comments are
+// formatted the same way as with FormatText.
+//
+func LinkifyText(w io.Writer, text []byte, n ast.Node) {
+	links := linksFor(n)
+
+	i := 0     // links index
+	prev := "" // prev HTML tag
+	linkWriter := func(w io.Writer, _ int, start bool) {
+		// end tag
+		if !start {
+			if prev != "" {
+				fmt.Fprintf(w, `</%s>`, prev)
+				prev = ""
+			}
+			return
+		}
+
+		// start tag
+		prev = ""
+		if i < len(links) {
+			switch info := links[i]; {
+			case info.path != "" && info.name == "":
+				// package path
+				fmt.Fprintf(w, `<a href="/pkg/%s/">`, info.path)
+				prev = "a"
+			case info.path != "" && info.name != "":
+				// qualified identifier
+				fmt.Fprintf(w, `<a href="/pkg/%s/#%s">`, info.path, info.name)
+				prev = "a"
+			case info.path == "" && info.name != "":
+				// local identifier
+				if info.isVal {
+					fmt.Fprintf(w, `<span id="%s">`, info.name)
+					prev = "span"
+				} else if ast.IsExported(info.name) {
+					fmt.Fprintf(w, `<a href="#%s">`, info.name)
+					prev = "a"
+				}
+			}
+			i++
+		}
+	}
+
+	idents := tokenSelection(text, token.IDENT)
+	comments := tokenSelection(text, token.COMMENT)
+	FormatSelections(w, text, linkWriter, idents, selectionTag, comments)
+}
+
+// A link describes the (HTML) link information for an identifier.
+// The zero value of a link represents "no link".
+//
+type link struct {
+	path, name string // package path, identifier name
+	isVal      bool   // identifier is defined in a const or var declaration
+}
+
+// linksFor returns the list of links for the identifiers used
+// by node in the same order as they appear in the source.
+//
+func linksFor(node ast.Node) (links []link) {
+	// linkMap tracks link information for each ast.Ident node. Entries may
+	// be created out of source order (for example, when we visit a parent
+	// definition node). These links are appended to the returned slice when
+	// their ast.Ident nodes are visited.
+	linkMap := make(map[*ast.Ident]link)
+
+	ast.Inspect(node, func(node ast.Node) bool {
+		switch n := node.(type) {
+		case *ast.Field:
+			for _, n := range n.Names {
+				linkMap[n] = link{}
+			}
+		case *ast.ImportSpec:
+			if name := n.Name; name != nil {
+				linkMap[name] = link{}
+			}
+		case *ast.ValueSpec:
+			for _, n := range n.Names {
+				linkMap[n] = link{name: n.Name, isVal: true}
+			}
+		case *ast.FuncDecl:
+			linkMap[n.Name] = link{}
+		case *ast.TypeSpec:
+			linkMap[n.Name] = link{}
+		case *ast.AssignStmt:
+			// Short variable declarations only show up if we apply
+			// this code to all source code (as opposed to exported
+			// declarations only).
+			if n.Tok == token.DEFINE {
+				// Some of the lhs variables may be re-declared,
+				// so technically they are not defs. We don't
+				// care for now.
+				for _, x := range n.Lhs {
+					// Each lhs expression should be an
+					// ident, but we are conservative and check.
+					if n, _ := x.(*ast.Ident); n != nil {
+						linkMap[n] = link{isVal: true}
+					}
+				}
+			}
+		case *ast.SelectorExpr:
+			// Detect qualified identifiers of the form pkg.ident.
+			// If anything fails we return true and collect individual
+			// identifiers instead.
+			if x, _ := n.X.(*ast.Ident); x != nil {
+				// Create links only if x is a qualified identifier.
+				if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
+					if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
+						// spec.Path.Value is the import path
+						if path, err := strconv.Unquote(spec.Path.Value); err == nil {
+							// Register two links, one for the package
+							// and one for the qualified identifier.
+							linkMap[x] = link{path: path}
+							linkMap[n.Sel] = link{path: path, name: n.Sel.Name}
+						}
+					}
+				}
+			}
+		case *ast.CompositeLit:
+			// Detect field names within composite literals. These links should
+			// be prefixed by the type name.
+			fieldPath := ""
+			prefix := ""
+			switch typ := n.Type.(type) {
+			case *ast.Ident:
+				prefix = typ.Name + "."
+			case *ast.SelectorExpr:
+				if x, _ := typ.X.(*ast.Ident); x != nil {
+					// Create links only if x is a qualified identifier.
+					if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
+						if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
+							// spec.Path.Value is the import path
+							if path, err := strconv.Unquote(spec.Path.Value); err == nil {
+								// Register two links, one for the package
+								// and one for the qualified identifier.
+								linkMap[x] = link{path: path}
+								linkMap[typ.Sel] = link{path: path, name: typ.Sel.Name}
+								fieldPath = path
+								prefix = typ.Sel.Name + "."
+							}
+						}
+					}
+				}
+			}
+			for _, e := range n.Elts {
+				if kv, ok := e.(*ast.KeyValueExpr); ok {
+					if k, ok := kv.Key.(*ast.Ident); ok {
+						// Note: there is some syntactic ambiguity here. We cannot determine
+						// if this is a struct literal or a map literal without type
+						// information. We assume struct literal.
+						name := prefix + k.Name
+						linkMap[k] = link{path: fieldPath, name: name}
+					}
+				}
+			}
+		case *ast.Ident:
+			if l, ok := linkMap[n]; ok {
+				links = append(links, l)
+			} else {
+				l := link{name: n.Name}
+				if n.Obj == nil && doc.IsPredeclared(n.Name) {
+					l.path = builtinPkgPath
+				}
+				links = append(links, l)
+			}
+		}
+		return true
+	})
+	return
+}
diff --git a/vendor/golang.org/x/tools/godoc/meta.go b/vendor/golang.org/x/tools/godoc/meta.go
new file mode 100644
index 0000000..41ade39
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/meta.go
@@ -0,0 +1,144 @@
+// Copyright 2009 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 godoc
+
+import (
+	"bytes"
+	"encoding/json"
+	"log"
+	pathpkg "path"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+var (
+	doctype   = []byte("<!DOCTYPE ")
+	jsonStart = []byte("<!--{")
+	jsonEnd   = []byte("}-->")
+)
+
+// ----------------------------------------------------------------------------
+// Documentation Metadata
+
+// TODO(adg): why are some exported and some aren't? -brad
+type Metadata struct {
+	Title    string
+	Subtitle string
+	Template bool   // execute as template
+	Path     string // canonical path for this page
+	filePath string // filesystem path relative to goroot
+}
+
+func (m *Metadata) FilePath() string { return m.filePath }
+
+// extractMetadata extracts the Metadata from a byte slice.
+// It returns the Metadata value and the remaining data.
+// If no metadata is present the original byte slice is returned.
+//
+func extractMetadata(b []byte) (meta Metadata, tail []byte, err error) {
+	tail = b
+	if !bytes.HasPrefix(b, jsonStart) {
+		return
+	}
+	end := bytes.Index(b, jsonEnd)
+	if end < 0 {
+		return
+	}
+	b = b[len(jsonStart)-1 : end+1] // drop leading <!-- and include trailing }
+	if err = json.Unmarshal(b, &meta); err != nil {
+		return
+	}
+	tail = tail[end+len(jsonEnd):]
+	return
+}
+
+// UpdateMetadata scans $GOROOT/doc for HTML files, reads their metadata,
+// and updates the DocMetadata map.
+func (c *Corpus) updateMetadata() {
+	metadata := make(map[string]*Metadata)
+	var scan func(string) // scan is recursive
+	scan = func(dir string) {
+		fis, err := c.fs.ReadDir(dir)
+		if err != nil {
+			log.Println("updateMetadata:", err)
+			return
+		}
+		for _, fi := range fis {
+			name := pathpkg.Join(dir, fi.Name())
+			if fi.IsDir() {
+				scan(name) // recurse
+				continue
+			}
+			if !strings.HasSuffix(name, ".html") {
+				continue
+			}
+			// Extract metadata from the file.
+			b, err := vfs.ReadFile(c.fs, name)
+			if err != nil {
+				log.Printf("updateMetadata %s: %v", name, err)
+				continue
+			}
+			meta, _, err := extractMetadata(b)
+			if err != nil {
+				log.Printf("updateMetadata: %s: %v", name, err)
+				continue
+			}
+			// Store relative filesystem path in Metadata.
+			meta.filePath = name
+			if meta.Path == "" {
+				// If no Path, canonical path is actual path.
+				meta.Path = meta.filePath
+			}
+			// Store under both paths.
+			metadata[meta.Path] = &meta
+			metadata[meta.filePath] = &meta
+		}
+	}
+	scan("/doc")
+	c.docMetadata.Set(metadata)
+}
+
+// MetadataFor returns the *Metadata for a given relative path or nil if none
+// exists.
+//
+func (c *Corpus) MetadataFor(relpath string) *Metadata {
+	if m, _ := c.docMetadata.Get(); m != nil {
+		meta := m.(map[string]*Metadata)
+		// If metadata for this relpath exists, return it.
+		if p := meta[relpath]; p != nil {
+			return p
+		}
+		// Try with or without trailing slash.
+		if strings.HasSuffix(relpath, "/") {
+			relpath = relpath[:len(relpath)-1]
+		} else {
+			relpath = relpath + "/"
+		}
+		return meta[relpath]
+	}
+	return nil
+}
+
+// refreshMetadata sends a signal to update DocMetadata. If a refresh is in
+// progress the metadata will be refreshed again afterward.
+//
+func (c *Corpus) refreshMetadata() {
+	select {
+	case c.refreshMetadataSignal <- true:
+	default:
+	}
+}
+
+// RefreshMetadataLoop runs forever, updating DocMetadata when the underlying
+// file system changes. It should be launched in a goroutine.
+func (c *Corpus) refreshMetadataLoop() {
+	for {
+		<-c.refreshMetadataSignal
+		c.updateMetadata()
+		time.Sleep(10 * time.Second) // at most once every 10 seconds
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/page.go b/vendor/golang.org/x/tools/godoc/page.go
new file mode 100644
index 0000000..10e86e5
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/page.go
@@ -0,0 +1,76 @@
+// Copyright 2009 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 godoc
+
+import (
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// Page describes the contents of the top-level godoc webpage.
+type Page struct {
+	Title    string
+	Tabtitle string
+	Subtitle string
+	SrcPath  string
+	Query    string
+	Body     []byte
+	GoogleCN bool // page is being served from golang.google.cn
+
+	// filled in by servePage
+	SearchBox  bool
+	Playground bool
+	Version    string
+}
+
+func (p *Presentation) ServePage(w http.ResponseWriter, page Page) {
+	if page.Tabtitle == "" {
+		page.Tabtitle = page.Title
+	}
+	page.SearchBox = p.Corpus.IndexEnabled
+	page.Playground = p.ShowPlayground
+	page.Version = runtime.Version()
+	applyTemplateToResponseWriter(w, p.GodocHTML, page)
+}
+
+func (p *Presentation) ServeError(w http.ResponseWriter, r *http.Request, relpath string, err error) {
+	w.WriteHeader(http.StatusNotFound)
+	if perr, ok := err.(*os.PathError); ok {
+		rel, err := filepath.Rel(runtime.GOROOT(), perr.Path)
+		if err != nil {
+			perr.Path = "REDACTED"
+		} else {
+			perr.Path = filepath.Join("$GOROOT", rel)
+		}
+	}
+	p.ServePage(w, Page{
+		Title:    "File " + relpath,
+		Subtitle: relpath,
+		Body:     applyTemplate(p.ErrorHTML, "errorHTML", err),
+		GoogleCN: googleCN(r),
+	})
+}
+
+var onAppengine = false // overridden in appengine.go when on app engine
+
+func googleCN(r *http.Request) bool {
+	if r.FormValue("googlecn") != "" {
+		return true
+	}
+	if !onAppengine {
+		return false
+	}
+	if strings.HasSuffix(r.Host, ".cn") {
+		return true
+	}
+	switch r.Header.Get("X-AppEngine-Country") {
+	case "", "ZZ", "CN":
+		return true
+	}
+	return false
+}
diff --git a/vendor/golang.org/x/tools/godoc/parser.go b/vendor/golang.org/x/tools/godoc/parser.go
new file mode 100644
index 0000000..4e644d6
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/parser.go
@@ -0,0 +1,74 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains support functions for parsing .go files
+// accessed via godoc's file system fs.
+
+package godoc
+
+import (
+	"bytes"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	pathpkg "path"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+var linePrefix = []byte("//line ")
+
+// This function replaces source lines starting with "//line " with a blank line.
+// It does this irrespective of whether the line is truly a line comment or not;
+// e.g., the line may be inside a string, or a /*-style comment; however that is
+// rather unlikely (proper testing would require a full Go scan which we want to
+// avoid for performance).
+func replaceLinePrefixCommentsWithBlankLine(src []byte) {
+	for {
+		i := bytes.Index(src, linePrefix)
+		if i < 0 {
+			break // we're done
+		}
+		// 0 <= i && i+len(linePrefix) <= len(src)
+		if i == 0 || src[i-1] == '\n' {
+			// at beginning of line: blank out line
+			for i < len(src) && src[i] != '\n' {
+				src[i] = ' '
+				i++
+			}
+		} else {
+			// not at beginning of line: skip over prefix
+			i += len(linePrefix)
+		}
+		// i <= len(src)
+		src = src[i:]
+	}
+}
+
+func (c *Corpus) parseFile(fset *token.FileSet, filename string, mode parser.Mode) (*ast.File, error) {
+	src, err := vfs.ReadFile(c.fs, filename)
+	if err != nil {
+		return nil, err
+	}
+
+	// Temporary ad-hoc fix for issue 5247.
+	// TODO(gri) Remove this in favor of a better fix, eventually (see issue 7702).
+	replaceLinePrefixCommentsWithBlankLine(src)
+
+	return parser.ParseFile(fset, filename, src, mode)
+}
+
+func (c *Corpus) parseFiles(fset *token.FileSet, relpath string, abspath string, localnames []string) (map[string]*ast.File, error) {
+	files := make(map[string]*ast.File)
+	for _, f := range localnames {
+		absname := pathpkg.Join(abspath, f)
+		file, err := c.parseFile(fset, absname, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		files[pathpkg.Join(relpath, f)] = file
+	}
+
+	return files, nil
+}
diff --git a/vendor/golang.org/x/tools/godoc/pres.go b/vendor/golang.org/x/tools/godoc/pres.go
new file mode 100644
index 0000000..8551177
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/pres.go
@@ -0,0 +1,166 @@
+// 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 godoc
+
+import (
+	"net/http"
+	"regexp"
+	"sync"
+	"text/template"
+
+	"golang.org/x/tools/godoc/vfs/httpfs"
+)
+
+// SearchResultFunc functions return an HTML body for displaying search results.
+type SearchResultFunc func(p *Presentation, result SearchResult) []byte
+
+// Presentation generates output from a corpus.
+type Presentation struct {
+	Corpus *Corpus
+
+	mux        *http.ServeMux
+	fileServer http.Handler
+	cmdHandler handlerServer
+	pkgHandler handlerServer
+
+	CallGraphHTML,
+	DirlistHTML,
+	ErrorHTML,
+	ExampleHTML,
+	GodocHTML,
+	ImplementsHTML,
+	MethodSetHTML,
+	PackageHTML,
+	PackageText,
+	SearchHTML,
+	SearchDocHTML,
+	SearchCodeHTML,
+	SearchTxtHTML,
+	SearchText,
+	SearchDescXML *template.Template
+
+	// TabWidth optionally specifies the tab width.
+	TabWidth int
+
+	ShowTimestamps bool
+	ShowPlayground bool
+	ShowExamples   bool
+	DeclLinks      bool
+
+	// SrcMode outputs source code instead of documentation in command-line mode.
+	SrcMode bool
+	// HTMLMode outputs HTML instead of plain text in command-line mode.
+	HTMLMode bool
+
+	// NotesRx optionally specifies a regexp to match
+	// notes to render in the output.
+	NotesRx *regexp.Regexp
+
+	// AdjustPageInfoMode optionally specifies a function to
+	// modify the PageInfoMode of a request. The default chosen
+	// value is provided.
+	AdjustPageInfoMode func(req *http.Request, mode PageInfoMode) PageInfoMode
+
+	// URLForSrc optionally specifies a function that takes a source file and
+	// returns a URL for it.
+	// The source file argument has the form /src/<path>/<filename>.
+	URLForSrc func(src string) string
+
+	// URLForSrcPos optionally specifies a function to create a URL given a
+	// source file, a line from the source file (1-based), and low & high offset
+	// positions (0-based, bytes from beginning of file). Ideally, the returned
+	// URL will be for the specified line of the file, while the high & low
+	// positions will be used to highlight a section of the file.
+	// The source file argument has the form /src/<path>/<filename>.
+	URLForSrcPos func(src string, line, low, high int) string
+
+	// URLForSrcQuery optionally specifies a function to create a URL given a
+	// source file, a query string, and a line from the source file (1-based).
+	// The source file argument has the form /src/<path>/<filename>.
+	// The query argument will be escaped for the purposes of embedding in a URL
+	// query parameter.
+	// Ideally, the returned URL will be for the specified line of the file with
+	// the query string highlighted.
+	URLForSrcQuery func(src, query string, line int) string
+
+	// SearchResults optionally specifies a list of functions returning an HTML
+	// body for displaying search results.
+	SearchResults []SearchResultFunc
+
+	initFuncMapOnce sync.Once
+	funcMap         template.FuncMap
+	templateFuncs   template.FuncMap
+}
+
+// NewPresentation returns a new Presentation from a corpus.
+// It sets SearchResults to:
+// [SearchResultDoc SearchResultCode SearchResultTxt].
+func NewPresentation(c *Corpus) *Presentation {
+	if c == nil {
+		panic("nil Corpus")
+	}
+	p := &Presentation{
+		Corpus:     c,
+		mux:        http.NewServeMux(),
+		fileServer: http.FileServer(httpfs.New(c.fs)),
+
+		TabWidth:     4,
+		ShowExamples: true,
+		DeclLinks:    true,
+		SearchResults: []SearchResultFunc{
+			(*Presentation).SearchResultDoc,
+			(*Presentation).SearchResultCode,
+			(*Presentation).SearchResultTxt,
+		},
+	}
+	p.cmdHandler = handlerServer{
+		p:       p,
+		c:       c,
+		pattern: "/cmd/",
+		fsRoot:  "/src",
+	}
+	p.pkgHandler = handlerServer{
+		p:           p,
+		c:           c,
+		pattern:     "/pkg/",
+		stripPrefix: "pkg/",
+		fsRoot:      "/src",
+		exclude:     []string{"/src/cmd"},
+	}
+	p.cmdHandler.registerWithMux(p.mux)
+	p.pkgHandler.registerWithMux(p.mux)
+	p.mux.HandleFunc("/", p.ServeFile)
+	p.mux.HandleFunc("/search", p.HandleSearch)
+	p.mux.HandleFunc("/opensearch.xml", p.serveSearchDesc)
+	return p
+}
+
+func (p *Presentation) FileServer() http.Handler {
+	return p.fileServer
+}
+
+func (p *Presentation) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	p.mux.ServeHTTP(w, r)
+}
+
+func (p *Presentation) PkgFSRoot() string {
+	return p.pkgHandler.fsRoot
+}
+
+func (p *Presentation) CmdFSRoot() string {
+	return p.cmdHandler.fsRoot
+}
+
+// TODO(bradfitz): move this to be a method on Corpus. Just moving code around for now,
+// but this doesn't feel right.
+func (p *Presentation) GetPkgPageInfo(abspath, relpath string, mode PageInfoMode) *PageInfo {
+	return p.pkgHandler.GetPageInfo(abspath, relpath, mode, "", "")
+}
+
+// TODO(bradfitz): move this to be a method on Corpus. Just moving code around for now,
+// but this doesn't feel right.
+func (p *Presentation) GetCmdPageInfo(abspath, relpath string, mode PageInfoMode) *PageInfo {
+	return p.cmdHandler.GetPageInfo(abspath, relpath, mode, "", "")
+}
diff --git a/vendor/golang.org/x/tools/godoc/proxy/proxy.go b/vendor/golang.org/x/tools/godoc/proxy/proxy.go
new file mode 100644
index 0000000..cdac3bf
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/proxy/proxy.go
@@ -0,0 +1,148 @@
+// 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 appengine
+
+// Package proxy proxies requests to the playground's compile and share handlers.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package proxy
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
+	"time"
+
+	"golang.org/x/net/context"
+
+	"google.golang.org/appengine"
+	"google.golang.org/appengine/log"
+	"google.golang.org/appengine/urlfetch"
+)
+
+type Request struct {
+	Body string
+}
+
+type Response struct {
+	Errors string
+	Events []Event
+}
+
+type Event struct {
+	Message string
+	Kind    string        // "stdout" or "stderr"
+	Delay   time.Duration // time to wait before printing Message
+}
+
+const playgroundURL = "https://play.golang.org"
+
+const expires = 7 * 24 * time.Hour // 1 week
+var cacheControlHeader = fmt.Sprintf("public, max-age=%d", int(expires.Seconds()))
+
+func RegisterHandlers(mux *http.ServeMux) {
+	mux.HandleFunc("/compile", compile)
+	mux.HandleFunc("/share", share)
+}
+
+func compile(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "I only answer to POST requests.", http.StatusMethodNotAllowed)
+		return
+	}
+
+	ctx := appengine.NewContext(r)
+
+	body := r.FormValue("body")
+	res := &Response{}
+	req := &Request{Body: body}
+	if err := makeCompileRequest(ctx, req, res); err != nil {
+		log.Errorf(ctx, "compile error: %v", err)
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	expiresTime := time.Now().Add(expires).UTC()
+	w.Header().Set("Expires", expiresTime.Format(time.RFC1123))
+	w.Header().Set("Cache-Control", cacheControlHeader)
+
+	var out interface{}
+	switch r.FormValue("version") {
+	case "2":
+		out = res
+	default: // "1"
+		out = struct {
+			CompileErrors string `json:"compile_errors"`
+			Output        string `json:"output"`
+		}{res.Errors, flatten(res.Events)}
+	}
+	if err := json.NewEncoder(w).Encode(out); err != nil {
+		log.Errorf(ctx, "encoding response: %v", err)
+	}
+}
+
+// makePlaygroundRequest sends the given Request to the playground compile
+// endpoint and stores the response in the given Response.
+func makeCompileRequest(ctx context.Context, req *Request, res *Response) error {
+	reqJ, err := json.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("marshalling request: %v", err)
+	}
+	r, err := urlfetch.Client(ctx).Post(playgroundURL+"/compile", "application/json", bytes.NewReader(reqJ))
+	if err != nil {
+		return fmt.Errorf("making request: %v", err)
+	}
+	defer r.Body.Close()
+	if r.StatusCode != http.StatusOK {
+		b, _ := ioutil.ReadAll(r.Body)
+		return fmt.Errorf("bad status: %v body:\n%s", r.Status, b)
+	}
+	err = json.NewDecoder(r.Body).Decode(res)
+	if err != nil {
+		return fmt.Errorf("unmarshalling response: %v", err)
+	}
+	return nil
+}
+
+// flatten takes a sequence of Events and returns their contents, concatenated.
+func flatten(seq []Event) string {
+	var buf bytes.Buffer
+	for _, e := range seq {
+		buf.WriteString(e.Message)
+	}
+	return buf.String()
+}
+
+func share(w http.ResponseWriter, r *http.Request) {
+	if googleCN(r) {
+		http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+		return
+	}
+	target, _ := url.Parse(playgroundURL)
+	p := httputil.NewSingleHostReverseProxy(target)
+	p.Transport = &urlfetch.Transport{Context: appengine.NewContext(r)}
+	p.ServeHTTP(w, r)
+}
+
+func googleCN(r *http.Request) bool {
+	if r.FormValue("googlecn") != "" {
+		return true
+	}
+	if appengine.IsDevAppServer() {
+		return false
+	}
+	if strings.HasSuffix(r.Host, ".cn") {
+		return true
+	}
+	switch r.Header.Get("X-AppEngine-Country") {
+	case "", "ZZ", "CN":
+		return true
+	}
+	return false
+}
diff --git a/vendor/golang.org/x/tools/godoc/redirect/hash.go b/vendor/golang.org/x/tools/godoc/redirect/hash.go
new file mode 100644
index 0000000..d5a1e3e
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/redirect/hash.go
@@ -0,0 +1,138 @@
+// 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 provides a compact encoding of
+// a map of Mercurial hashes to Git hashes.
+
+package redirect
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// hashMap is a map of Mercurial hashes to Git hashes.
+type hashMap struct {
+	file    *os.File
+	entries int
+}
+
+// newHashMap takes a file handle that contains a map of Mercurial to Git
+// hashes. The file should be a sequence of pairs of little-endian encoded
+// uint32s, representing a hgHash and a gitHash respectively.
+// The sequence must be sorted by hgHash.
+// The file must remain open for as long as the returned hashMap is used.
+func newHashMap(f *os.File) (*hashMap, error) {
+	fi, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+	return &hashMap{file: f, entries: int(fi.Size() / 8)}, nil
+}
+
+// Lookup finds an hgHash in the map that matches the given prefix, and returns
+// its corresponding gitHash. The prefix must be at least 8 characters long.
+func (m *hashMap) Lookup(s string) gitHash {
+	if m == nil {
+		return 0
+	}
+	hg, err := hgHashFromString(s)
+	if err != nil {
+		return 0
+	}
+	var git gitHash
+	b := make([]byte, 8)
+	sort.Search(m.entries, func(i int) bool {
+		n, err := m.file.ReadAt(b, int64(i*8))
+		if err != nil {
+			panic(err)
+		}
+		if n != 8 {
+			panic(io.ErrUnexpectedEOF)
+		}
+		v := hgHash(binary.LittleEndian.Uint32(b[:4]))
+		if v == hg {
+			git = gitHash(binary.LittleEndian.Uint32(b[4:]))
+		}
+		return v >= hg
+	})
+	return git
+}
+
+// hgHash represents the lower (leftmost) 32 bits of a Mercurial hash.
+type hgHash uint32
+
+func (h hgHash) String() string {
+	return intToHash(int64(h))
+}
+
+func hgHashFromString(s string) (hgHash, error) {
+	if len(s) < 8 {
+		return 0, fmt.Errorf("string too small: len(s) = %d", len(s))
+	}
+	hash := s[:8]
+	i, err := strconv.ParseInt(hash, 16, 64)
+	if err != nil {
+		return 0, err
+	}
+	return hgHash(i), nil
+}
+
+// gitHash represents the leftmost 28 bits of a Git hash in its upper 28 bits,
+// and it encodes hash's repository in the lower 4  bits.
+type gitHash uint32
+
+func (h gitHash) Hash() string {
+	return intToHash(int64(h))[:7]
+}
+
+func (h gitHash) Repo() string {
+	return repo(h & 0xF).String()
+}
+
+func intToHash(i int64) string {
+	s := strconv.FormatInt(i, 16)
+	if len(s) < 8 {
+		s = strings.Repeat("0", 8-len(s)) + s
+	}
+	return s
+}
+
+// repo represents a Go Git repository.
+type repo byte
+
+const (
+	repoGo repo = iota
+	repoBlog
+	repoCrypto
+	repoExp
+	repoImage
+	repoMobile
+	repoNet
+	repoSys
+	repoTalks
+	repoText
+	repoTools
+)
+
+func (r repo) String() string {
+	return map[repo]string{
+		repoGo:     "go",
+		repoBlog:   "blog",
+		repoCrypto: "crypto",
+		repoExp:    "exp",
+		repoImage:  "image",
+		repoMobile: "mobile",
+		repoNet:    "net",
+		repoSys:    "sys",
+		repoTalks:  "talks",
+		repoText:   "text",
+		repoTools:  "tools",
+	}[r]
+}
diff --git a/vendor/golang.org/x/tools/godoc/redirect/redirect.go b/vendor/golang.org/x/tools/godoc/redirect/redirect.go
new file mode 100644
index 0000000..f86e0ad
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/redirect/redirect.go
@@ -0,0 +1,250 @@
+// 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 redirect provides hooks to register HTTP handlers that redirect old
+// godoc paths to their new equivalents and assist in accessing the issue
+// tracker, wiki, code review system, etc.
+package redirect // import "golang.org/x/tools/godoc/redirect"
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// Register registers HTTP handlers that redirect old godoc paths to their new
+// equivalents and assist in accessing the issue tracker, wiki, code review
+// system, etc. If mux is nil it uses http.DefaultServeMux.
+func Register(mux *http.ServeMux) {
+	if mux == nil {
+		mux = http.DefaultServeMux
+	}
+	handlePathRedirects(mux, pkgRedirects, "/pkg/")
+	handlePathRedirects(mux, cmdRedirects, "/cmd/")
+	for prefix, redirect := range prefixHelpers {
+		p := "/" + prefix + "/"
+		mux.Handle(p, PrefixHandler(p, redirect))
+	}
+	for path, redirect := range redirects {
+		mux.Handle(path, Handler(redirect))
+	}
+	// NB: /src/pkg (sans trailing slash) is the index of packages.
+	mux.HandleFunc("/src/pkg/", srcPkgHandler)
+	mux.HandleFunc("/cl/", clHandler)
+	mux.HandleFunc("/change/", changeHandler)
+	mux.HandleFunc("/design/", designHandler)
+}
+
+func handlePathRedirects(mux *http.ServeMux, redirects map[string]string, prefix string) {
+	for source, target := range redirects {
+		h := Handler(prefix + target + "/")
+		p := prefix + source
+		mux.Handle(p, h)
+		mux.Handle(p+"/", h)
+	}
+}
+
+// Packages that were renamed between r60 and go1.
+var pkgRedirects = map[string]string{
+	"asn1":              "encoding/asn1",
+	"big":               "math/big",
+	"cmath":             "math/cmplx",
+	"csv":               "encoding/csv",
+	"exec":              "os/exec",
+	"exp/template/html": "html/template",
+	"gob":               "encoding/gob",
+	"http":              "net/http",
+	"http/cgi":          "net/http/cgi",
+	"http/fcgi":         "net/http/fcgi",
+	"http/httptest":     "net/http/httptest",
+	"http/pprof":        "net/http/pprof",
+	"json":              "encoding/json",
+	"mail":              "net/mail",
+	"rand":              "math/rand",
+	"rpc":               "net/rpc",
+	"rpc/jsonrpc":       "net/rpc/jsonrpc",
+	"scanner":           "text/scanner",
+	"smtp":              "net/smtp",
+	"tabwriter":         "text/tabwriter",
+	"template":          "text/template",
+	"template/parse":    "text/template/parse",
+	"url":               "net/url",
+	"utf16":             "unicode/utf16",
+	"utf8":              "unicode/utf8",
+	"xml":               "encoding/xml",
+}
+
+// Commands that were renamed between r60 and go1.
+var cmdRedirects = map[string]string{
+	"gofix":     "fix",
+	"goinstall": "go",
+	"gopack":    "pack",
+	"gotest":    "go",
+	"govet":     "vet",
+	"goyacc":    "yacc",
+}
+
+var redirects = map[string]string{
+	"/blog":       "/blog/",
+	"/build":      "http://build.golang.org",
+	"/change":     "https://go.googlesource.com/go",
+	"/cl":         "https://go-review.googlesource.com",
+	"/cmd/godoc/": "http://godoc.org/golang.org/x/tools/cmd/godoc/",
+	"/issue":      "https://github.com/golang/go/issues",
+	"/issue/new":  "https://github.com/golang/go/issues/new",
+	"/issues":     "https://github.com/golang/go/issues",
+	"/issues/new": "https://github.com/golang/go/issues/new",
+	"/play":       "http://play.golang.org",
+	"/design":     "https://github.com/golang/proposal/tree/master/design",
+
+	// In Go 1.2 the references page is part of /doc/.
+	"/ref": "/doc/#references",
+	// This next rule clobbers /ref/spec and /ref/mem.
+	// TODO(adg): figure out what to do here, if anything.
+	// "/ref/": "/doc/#references",
+
+	// Be nice to people who are looking in the wrong place.
+	"/doc/mem":  "/ref/mem",
+	"/doc/spec": "/ref/spec",
+
+	"/talks": "http://talks.golang.org",
+	"/tour":  "http://tour.golang.org",
+	"/wiki":  "https://github.com/golang/go/wiki",
+
+	"/doc/articles/c_go_cgo.html":                    "/blog/c-go-cgo",
+	"/doc/articles/concurrency_patterns.html":        "/blog/go-concurrency-patterns-timing-out-and",
+	"/doc/articles/defer_panic_recover.html":         "/blog/defer-panic-and-recover",
+	"/doc/articles/error_handling.html":              "/blog/error-handling-and-go",
+	"/doc/articles/gobs_of_data.html":                "/blog/gobs-of-data",
+	"/doc/articles/godoc_documenting_go_code.html":   "/blog/godoc-documenting-go-code",
+	"/doc/articles/gos_declaration_syntax.html":      "/blog/gos-declaration-syntax",
+	"/doc/articles/image_draw.html":                  "/blog/go-imagedraw-package",
+	"/doc/articles/image_package.html":               "/blog/go-image-package",
+	"/doc/articles/json_and_go.html":                 "/blog/json-and-go",
+	"/doc/articles/json_rpc_tale_of_interfaces.html": "/blog/json-rpc-tale-of-interfaces",
+	"/doc/articles/laws_of_reflection.html":          "/blog/laws-of-reflection",
+	"/doc/articles/slices_usage_and_internals.html":  "/blog/go-slices-usage-and-internals",
+	"/doc/go_for_cpp_programmers.html":               "/wiki/GoForCPPProgrammers",
+	"/doc/go_tutorial.html":                          "http://tour.golang.org/",
+}
+
+var prefixHelpers = map[string]string{
+	"issue":  "https://github.com/golang/go/issues/",
+	"issues": "https://github.com/golang/go/issues/",
+	"play":   "http://play.golang.org/",
+	"talks":  "http://talks.golang.org/",
+	"wiki":   "https://github.com/golang/go/wiki/",
+}
+
+func Handler(target string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		url := target
+		if qs := r.URL.RawQuery; qs != "" {
+			url += "?" + qs
+		}
+		http.Redirect(w, r, url, http.StatusMovedPermanently)
+	})
+}
+
+var validId = regexp.MustCompile(`^[A-Za-z0-9-]*/?$`)
+
+func PrefixHandler(prefix, baseURL string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if p := r.URL.Path; p == prefix {
+			// redirect /prefix/ to /prefix
+			http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+			return
+		}
+		id := r.URL.Path[len(prefix):]
+		if !validId.MatchString(id) {
+			http.Error(w, "Not found", http.StatusNotFound)
+			return
+		}
+		target := baseURL + id
+		http.Redirect(w, r, target, http.StatusFound)
+	})
+}
+
+// Redirect requests from the old "/src/pkg/foo" to the new "/src/foo".
+// See http://golang.org/s/go14nopkg
+func srcPkgHandler(w http.ResponseWriter, r *http.Request) {
+	r.URL.Path = "/src/" + r.URL.Path[len("/src/pkg/"):]
+	http.Redirect(w, r, r.URL.String(), http.StatusMovedPermanently)
+}
+
+func clHandler(w http.ResponseWriter, r *http.Request) {
+	const prefix = "/cl/"
+	if p := r.URL.Path; p == prefix {
+		// redirect /prefix/ to /prefix
+		http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+		return
+	}
+	id := r.URL.Path[len(prefix):]
+	// support /cl/152700045/, which is used in commit 0edafefc36.
+	id = strings.TrimSuffix(id, "/")
+	if !validId.MatchString(id) {
+		http.Error(w, "Not found", http.StatusNotFound)
+		return
+	}
+	target := ""
+	// the first CL in rietveld is about 152046, so only treat the id as
+	// a rietveld CL if it is larger than 150000.
+	if n, err := strconv.Atoi(id); err == nil && n > 150000 {
+		target = "https://codereview.appspot.com/" + id
+	} else {
+		target = "https://go-review.googlesource.com/" + id
+	}
+	http.Redirect(w, r, target, http.StatusFound)
+}
+
+var changeMap *hashMap
+
+// LoadChangeMap loads the specified map of Mercurial to Git revisions,
+// which is used by the /change/ handler to intelligently map old hg
+// revisions to their new git equivalents.
+// It should be called before calling Register.
+// The file should remain open as long as the process is running.
+// See the implementation of this package for details.
+func LoadChangeMap(filename string) error {
+	f, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	m, err := newHashMap(f)
+	if err != nil {
+		return err
+	}
+	changeMap = m
+	return nil
+}
+
+func changeHandler(w http.ResponseWriter, r *http.Request) {
+	const prefix = "/change/"
+	if p := r.URL.Path; p == prefix {
+		// redirect /prefix/ to /prefix
+		http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+		return
+	}
+	hash := r.URL.Path[len(prefix):]
+	target := "https://go.googlesource.com/go/+/" + hash
+	if git := changeMap.Lookup(hash); git > 0 {
+		target = fmt.Sprintf("https://go.googlesource.com/%v/+/%v", git.Repo(), git.Hash())
+	}
+	http.Redirect(w, r, target, http.StatusFound)
+}
+
+func designHandler(w http.ResponseWriter, r *http.Request) {
+	const prefix = "/design/"
+	if p := r.URL.Path; p == prefix {
+		// redirect /prefix/ to /prefix
+		http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+		return
+	}
+	name := r.URL.Path[len(prefix):]
+	target := "https://github.com/golang/proposal/blob/master/design/" + name + ".md"
+	http.Redirect(w, r, target, http.StatusFound)
+}
diff --git a/vendor/golang.org/x/tools/godoc/redirect/redirect_test.go b/vendor/golang.org/x/tools/godoc/redirect/redirect_test.go
new file mode 100644
index 0000000..cfc2f97
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/redirect/redirect_test.go
@@ -0,0 +1,104 @@
+// 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 redirect
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+type redirectResult struct {
+	status int
+	path   string
+}
+
+func errorResult(status int) redirectResult {
+	return redirectResult{status, ""}
+}
+
+func TestRedirects(t *testing.T) {
+	var tests = map[string]redirectResult{
+		"/build":    {301, "http://build.golang.org"},
+		"/ref":      {301, "/doc/#references"},
+		"/doc/mem":  {301, "/ref/mem"},
+		"/doc/spec": {301, "/ref/spec"},
+		"/tour":     {301, "http://tour.golang.org"},
+		"/foo":      errorResult(404),
+
+		"/pkg/asn1":           {301, "/pkg/encoding/asn1/"},
+		"/pkg/template/parse": {301, "/pkg/text/template/parse/"},
+
+		"/src/pkg/foo": {301, "/src/foo"},
+
+		"/cmd/gofix": {301, "/cmd/fix/"},
+
+		// git commits (/change)
+		// TODO: mercurial tags and LoadChangeMap.
+		"/change":   {301, "https://go.googlesource.com/go"},
+		"/change/a": {302, "https://go.googlesource.com/go/+/a"},
+
+		"/issue":                    {301, "https://github.com/golang/go/issues"},
+		"/issue?":                   {301, "https://github.com/golang/go/issues"},
+		"/issue/1":                  {302, "https://github.com/golang/go/issues/1"},
+		"/issue/new":                {301, "https://github.com/golang/go/issues/new"},
+		"/issue/new?a=b&c=d%20&e=f": {301, "https://github.com/golang/go/issues/new?a=b&c=d%20&e=f"},
+		"/issues":                   {301, "https://github.com/golang/go/issues"},
+		"/issues/1":                 {302, "https://github.com/golang/go/issues/1"},
+		"/issues/new":               {301, "https://github.com/golang/go/issues/new"},
+		"/issues/1/2/3":             errorResult(404),
+
+		"/wiki/foo":  {302, "https://github.com/golang/go/wiki/foo"},
+		"/wiki/foo/": {302, "https://github.com/golang/go/wiki/foo/"},
+
+		"/design":              {301, "https://github.com/golang/proposal/tree/master/design"},
+		"/design/":             {302, "/design"},
+		"/design/123-foo":      {302, "https://github.com/golang/proposal/blob/master/design/123-foo.md"},
+		"/design/text/123-foo": {302, "https://github.com/golang/proposal/blob/master/design/text/123-foo.md"},
+
+		"/cl/1":          {302, "https://go-review.googlesource.com/1"},
+		"/cl/1/":         {302, "https://go-review.googlesource.com/1"},
+		"/cl/267120043":  {302, "https://codereview.appspot.com/267120043"},
+		"/cl/267120043/": {302, "https://codereview.appspot.com/267120043"},
+	}
+
+	mux := http.NewServeMux()
+	Register(mux)
+	ts := httptest.NewServer(mux)
+	defer ts.Close()
+
+	for path, want := range tests {
+		if want.path != "" && want.path[0] == '/' {
+			// All redirects are absolute.
+			want.path = ts.URL + want.path
+		}
+
+		req, err := http.NewRequest("GET", ts.URL+path, nil)
+		if err != nil {
+			t.Errorf("(path: %q) unexpected error: %v", path, err)
+			continue
+		}
+
+		resp, err := http.DefaultTransport.RoundTrip(req)
+		if err != nil {
+			t.Errorf("(path: %q) unexpected error: %v", path, err)
+			continue
+		}
+
+		if resp.StatusCode != want.status {
+			t.Errorf("(path: %q) got status %d, want %d", path, resp.StatusCode, want.status)
+		}
+
+		if want.status != 301 && want.status != 302 {
+			// Not a redirect. Just check status.
+			continue
+		}
+
+		out, _ := resp.Location()
+		if got := out.String(); got != want.path {
+			t.Errorf("(path: %q) got %s, want %s", path, got, want.path)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/search.go b/vendor/golang.org/x/tools/godoc/search.go
new file mode 100644
index 0000000..d61193f
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/search.go
@@ -0,0 +1,139 @@
+// Copyright 2009 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 godoc
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type SearchResult struct {
+	Query string
+	Alert string // error or warning message
+
+	// identifier matches
+	Pak HitList       // packages matching Query
+	Hit *LookupResult // identifier matches of Query
+	Alt *AltWords     // alternative identifiers to look for
+
+	// textual matches
+	Found    int         // number of textual occurrences found
+	Textual  []FileLines // textual matches of Query
+	Complete bool        // true if all textual occurrences of Query are reported
+	Idents   map[SpotKind][]Ident
+}
+
+func (c *Corpus) Lookup(query string) SearchResult {
+	result := &SearchResult{Query: query}
+
+	index, timestamp := c.CurrentIndex()
+	if index != nil {
+		// identifier search
+		if r, err := index.Lookup(query); err == nil {
+			result = r
+		} else if err != nil && !c.IndexFullText {
+			// ignore the error if full text search is enabled
+			// since the query may be a valid regular expression
+			result.Alert = "Error in query string: " + err.Error()
+			return *result
+		}
+
+		// full text search
+		if c.IndexFullText && query != "" {
+			rx, err := regexp.Compile(query)
+			if err != nil {
+				result.Alert = "Error in query regular expression: " + err.Error()
+				return *result
+			}
+			// If we get maxResults+1 results we know that there are more than
+			// maxResults results and thus the result may be incomplete (to be
+			// precise, we should remove one result from the result set, but
+			// nobody is going to count the results on the result page).
+			result.Found, result.Textual = index.LookupRegexp(rx, c.MaxResults+1)
+			result.Complete = result.Found <= c.MaxResults
+			if !result.Complete {
+				result.Found-- // since we looked for maxResults+1
+			}
+		}
+	}
+
+	// is the result accurate?
+	if c.IndexEnabled {
+		if ts := c.FSModifiedTime(); timestamp.Before(ts) {
+			// The index is older than the latest file system change under godoc's observation.
+			result.Alert = "Indexing in progress: result may be inaccurate"
+		}
+	} else {
+		result.Alert = "Search index disabled: no results available"
+	}
+
+	return *result
+}
+
+// SearchResultDoc optionally specifies a function returning an HTML body
+// displaying search results matching godoc documentation.
+func (p *Presentation) SearchResultDoc(result SearchResult) []byte {
+	return applyTemplate(p.SearchDocHTML, "searchDocHTML", result)
+}
+
+// SearchResultCode optionally specifies a function returning an HTML body
+// displaying search results matching source code.
+func (p *Presentation) SearchResultCode(result SearchResult) []byte {
+	return applyTemplate(p.SearchCodeHTML, "searchCodeHTML", result)
+}
+
+// SearchResultTxt optionally specifies a function returning an HTML body
+// displaying search results of textual matches.
+func (p *Presentation) SearchResultTxt(result SearchResult) []byte {
+	return applyTemplate(p.SearchTxtHTML, "searchTxtHTML", result)
+}
+
+// HandleSearch obtains results for the requested search and returns a page
+// to display them.
+func (p *Presentation) HandleSearch(w http.ResponseWriter, r *http.Request) {
+	query := strings.TrimSpace(r.FormValue("q"))
+	result := p.Corpus.Lookup(query)
+
+	if p.GetPageInfoMode(r)&NoHTML != 0 {
+		p.ServeText(w, applyTemplate(p.SearchText, "searchText", result))
+		return
+	}
+	contents := bytes.Buffer{}
+	for _, f := range p.SearchResults {
+		contents.Write(f(p, result))
+	}
+
+	var title string
+	if haveResults := contents.Len() > 0; haveResults {
+		title = fmt.Sprintf(`Results for query: %v`, query)
+		if !p.Corpus.IndexEnabled {
+			result.Alert = ""
+		}
+	} else {
+		title = fmt.Sprintf(`No results found for query %q`, query)
+	}
+
+	body := bytes.NewBuffer(applyTemplate(p.SearchHTML, "searchHTML", result))
+	body.Write(contents.Bytes())
+
+	p.ServePage(w, Page{
+		Title:    title,
+		Tabtitle: query,
+		Query:    query,
+		Body:     body.Bytes(),
+		GoogleCN: googleCN(r),
+	})
+}
+
+func (p *Presentation) serveSearchDesc(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/opensearchdescription+xml")
+	data := map[string]interface{}{
+		"BaseURL": fmt.Sprintf("http://%s", r.Host),
+	}
+	applyTemplateToResponseWriter(w, p.SearchDescXML, &data)
+}
diff --git a/vendor/golang.org/x/tools/godoc/server.go b/vendor/golang.org/x/tools/godoc/server.go
new file mode 100644
index 0000000..2c56465
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/server.go
@@ -0,0 +1,816 @@
+// 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 godoc
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/doc"
+	"go/token"
+	htmlpkg "html"
+	htmltemplate "html/template"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	pathpkg "path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"text/template"
+	"time"
+
+	"golang.org/x/tools/godoc/analysis"
+	"golang.org/x/tools/godoc/util"
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// handlerServer is a migration from an old godoc http Handler type.
+// This should probably merge into something else.
+type handlerServer struct {
+	p           *Presentation
+	c           *Corpus  // copy of p.Corpus
+	pattern     string   // url pattern; e.g. "/pkg/"
+	stripPrefix string   // prefix to strip from import path; e.g. "pkg/"
+	fsRoot      string   // file system root to which the pattern is mapped; e.g. "/src"
+	exclude     []string // file system paths to exclude; e.g. "/src/cmd"
+}
+
+func (s *handlerServer) registerWithMux(mux *http.ServeMux) {
+	mux.Handle(s.pattern, s)
+}
+
+// getPageInfo returns the PageInfo for a package directory abspath. If the
+// parameter genAST is set, an AST containing only the package exports is
+// computed (PageInfo.PAst), otherwise package documentation (PageInfo.Doc)
+// is extracted from the AST. If there is no corresponding package in the
+// directory, PageInfo.PAst and PageInfo.PDoc are nil. If there are no sub-
+// directories, PageInfo.Dirs is nil. If an error occurred, PageInfo.Err is
+// set to the respective error but the error is not logged.
+//
+func (h *handlerServer) GetPageInfo(abspath, relpath string, mode PageInfoMode, goos, goarch string) *PageInfo {
+	info := &PageInfo{Dirname: abspath, Mode: mode}
+
+	// Restrict to the package files that would be used when building
+	// the package on this system.  This makes sure that if there are
+	// separate implementations for, say, Windows vs Unix, we don't
+	// jumble them all together.
+	// Note: If goos/goarch aren't set, the current binary's GOOS/GOARCH
+	// are used.
+	ctxt := build.Default
+	ctxt.IsAbsPath = pathpkg.IsAbs
+	ctxt.IsDir = func(path string) bool {
+		fi, err := h.c.fs.Stat(filepath.ToSlash(path))
+		return err == nil && fi.IsDir()
+	}
+	ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
+		f, err := h.c.fs.ReadDir(filepath.ToSlash(dir))
+		filtered := make([]os.FileInfo, 0, len(f))
+		for _, i := range f {
+			if mode&NoFiltering != 0 || i.Name() != "internal" {
+				filtered = append(filtered, i)
+			}
+		}
+		return filtered, err
+	}
+	ctxt.OpenFile = func(name string) (r io.ReadCloser, err error) {
+		data, err := vfs.ReadFile(h.c.fs, filepath.ToSlash(name))
+		if err != nil {
+			return nil, err
+		}
+		return ioutil.NopCloser(bytes.NewReader(data)), nil
+	}
+
+	if goos != "" {
+		ctxt.GOOS = goos
+	}
+	if goarch != "" {
+		ctxt.GOARCH = goarch
+	}
+
+	pkginfo, err := ctxt.ImportDir(abspath, 0)
+	// continue if there are no Go source files; we still want the directory info
+	if _, nogo := err.(*build.NoGoError); err != nil && !nogo {
+		info.Err = err
+		return info
+	}
+
+	// collect package files
+	pkgname := pkginfo.Name
+	pkgfiles := append(pkginfo.GoFiles, pkginfo.CgoFiles...)
+	if len(pkgfiles) == 0 {
+		// Commands written in C have no .go files in the build.
+		// Instead, documentation may be found in an ignored file.
+		// The file may be ignored via an explicit +build ignore
+		// constraint (recommended), or by defining the package
+		// documentation (historic).
+		pkgname = "main" // assume package main since pkginfo.Name == ""
+		pkgfiles = pkginfo.IgnoredGoFiles
+	}
+
+	// get package information, if any
+	if len(pkgfiles) > 0 {
+		// build package AST
+		fset := token.NewFileSet()
+		files, err := h.c.parseFiles(fset, relpath, abspath, pkgfiles)
+		if err != nil {
+			info.Err = err
+			return info
+		}
+
+		// ignore any errors - they are due to unresolved identifiers
+		pkg, _ := ast.NewPackage(fset, files, poorMansImporter, nil)
+
+		// extract package documentation
+		info.FSet = fset
+		if mode&ShowSource == 0 {
+			// show extracted documentation
+			var m doc.Mode
+			if mode&NoFiltering != 0 {
+				m |= doc.AllDecls
+			}
+			if mode&AllMethods != 0 {
+				m |= doc.AllMethods
+			}
+			info.PDoc = doc.New(pkg, pathpkg.Clean(relpath), m) // no trailing '/' in importpath
+			if mode&NoTypeAssoc != 0 {
+				for _, t := range info.PDoc.Types {
+					info.PDoc.Consts = append(info.PDoc.Consts, t.Consts...)
+					info.PDoc.Vars = append(info.PDoc.Vars, t.Vars...)
+					info.PDoc.Funcs = append(info.PDoc.Funcs, t.Funcs...)
+					t.Consts = nil
+					t.Vars = nil
+					t.Funcs = nil
+				}
+				// for now we cannot easily sort consts and vars since
+				// go/doc.Value doesn't export the order information
+				sort.Sort(funcsByName(info.PDoc.Funcs))
+			}
+
+			// collect examples
+			testfiles := append(pkginfo.TestGoFiles, pkginfo.XTestGoFiles...)
+			files, err = h.c.parseFiles(fset, relpath, abspath, testfiles)
+			if err != nil {
+				log.Println("parsing examples:", err)
+			}
+			info.Examples = collectExamples(h.c, pkg, files)
+
+			// collect any notes that we want to show
+			if info.PDoc.Notes != nil {
+				// could regexp.Compile only once per godoc, but probably not worth it
+				if rx := h.p.NotesRx; rx != nil {
+					for m, n := range info.PDoc.Notes {
+						if rx.MatchString(m) {
+							if info.Notes == nil {
+								info.Notes = make(map[string][]*doc.Note)
+							}
+							info.Notes[m] = n
+						}
+					}
+				}
+			}
+
+		} else {
+			// show source code
+			// TODO(gri) Consider eliminating export filtering in this mode,
+			//           or perhaps eliminating the mode altogether.
+			if mode&NoFiltering == 0 {
+				packageExports(fset, pkg)
+			}
+			info.PAst = files
+		}
+		info.IsMain = pkgname == "main"
+	}
+
+	// get directory information, if any
+	var dir *Directory
+	var timestamp time.Time
+	if tree, ts := h.c.fsTree.Get(); tree != nil && tree.(*Directory) != nil {
+		// directory tree is present; lookup respective directory
+		// (may still fail if the file system was updated and the
+		// new directory tree has not yet been computed)
+		dir = tree.(*Directory).lookup(abspath)
+		timestamp = ts
+	}
+	if dir == nil {
+		// no directory tree present (happens in command-line mode);
+		// compute 2 levels for this page. The second level is to
+		// get the synopses of sub-directories.
+		// note: cannot use path filter here because in general
+		// it doesn't contain the FSTree path
+		dir = h.c.newDirectory(abspath, 2)
+		timestamp = time.Now()
+	}
+	info.Dirs = dir.listing(true, func(path string) bool { return h.includePath(path, mode) })
+
+	info.DirTime = timestamp
+	info.DirFlat = mode&FlatDir != 0
+
+	return info
+}
+
+func (h *handlerServer) includePath(path string, mode PageInfoMode) (r bool) {
+	// if the path is under one of the exclusion paths, don't list.
+	for _, e := range h.exclude {
+		if strings.HasPrefix(path, e) {
+			return false
+		}
+	}
+
+	// if the path includes 'internal', don't list unless we are in the NoFiltering mode.
+	if mode&NoFiltering != 0 {
+		return true
+	}
+	if strings.Contains(path, "internal") || strings.Contains(path, "vendor") {
+		for _, c := range strings.Split(filepath.Clean(path), string(os.PathSeparator)) {
+			if c == "internal" || c == "vendor" {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+type funcsByName []*doc.Func
+
+func (s funcsByName) Len() int           { return len(s) }
+func (s funcsByName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s funcsByName) Less(i, j int) bool { return s[i].Name < s[j].Name }
+
+func (h *handlerServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if redirect(w, r) {
+		return
+	}
+
+	relpath := pathpkg.Clean(r.URL.Path[len(h.stripPrefix)+1:])
+
+	if !h.corpusInitialized() {
+		h.p.ServeError(w, r, relpath, errors.New("Scan is not yet complete. Please retry after a few moments"))
+		return
+	}
+
+	abspath := pathpkg.Join(h.fsRoot, relpath)
+	mode := h.p.GetPageInfoMode(r)
+	if relpath == builtinPkgPath {
+		mode = NoFiltering | NoTypeAssoc
+	}
+	info := h.GetPageInfo(abspath, relpath, mode, r.FormValue("GOOS"), r.FormValue("GOARCH"))
+	if info.Err != nil {
+		log.Print(info.Err)
+		h.p.ServeError(w, r, relpath, info.Err)
+		return
+	}
+
+	if mode&NoHTML != 0 {
+		h.p.ServeText(w, applyTemplate(h.p.PackageText, "packageText", info))
+		return
+	}
+
+	var tabtitle, title, subtitle string
+	switch {
+	case info.PAst != nil:
+		for _, ast := range info.PAst {
+			tabtitle = ast.Name.Name
+			break
+		}
+	case info.PDoc != nil:
+		tabtitle = info.PDoc.Name
+	default:
+		tabtitle = info.Dirname
+		title = "Directory "
+		if h.p.ShowTimestamps {
+			subtitle = "Last update: " + info.DirTime.String()
+		}
+	}
+	if title == "" {
+		if info.IsMain {
+			// assume that the directory name is the command name
+			_, tabtitle = pathpkg.Split(relpath)
+			title = "Command "
+		} else {
+			title = "Package "
+		}
+	}
+	title += tabtitle
+
+	// special cases for top-level package/command directories
+	switch tabtitle {
+	case "/src":
+		title = "Packages"
+		tabtitle = "Packages"
+	case "/src/cmd":
+		title = "Commands"
+		tabtitle = "Commands"
+	}
+
+	// Emit JSON array for type information.
+	pi := h.c.Analysis.PackageInfo(relpath)
+	info.CallGraphIndex = pi.CallGraphIndex
+	info.CallGraph = htmltemplate.JS(marshalJSON(pi.CallGraph))
+	info.AnalysisData = htmltemplate.JS(marshalJSON(pi.Types))
+	info.TypeInfoIndex = make(map[string]int)
+	for i, ti := range pi.Types {
+		info.TypeInfoIndex[ti.Name] = i
+	}
+
+	info.GoogleCN = googleCN(r)
+	h.p.ServePage(w, Page{
+		Title:    title,
+		Tabtitle: tabtitle,
+		Subtitle: subtitle,
+		Body:     applyTemplate(h.p.PackageHTML, "packageHTML", info),
+		GoogleCN: info.GoogleCN,
+	})
+}
+
+func (h *handlerServer) corpusInitialized() bool {
+	h.c.initMu.RLock()
+	defer h.c.initMu.RUnlock()
+	return h.c.initDone
+}
+
+type PageInfoMode uint
+
+const (
+	PageInfoModeQueryString = "m" // query string where PageInfoMode is stored
+
+	NoFiltering PageInfoMode = 1 << iota // do not filter exports
+	AllMethods                           // show all embedded methods
+	ShowSource                           // show source code, do not extract documentation
+	NoHTML                               // show result in textual form, do not generate HTML
+	FlatDir                              // show directory in a flat (non-indented) manner
+	NoTypeAssoc                          // don't associate consts, vars, and factory functions with types
+)
+
+// modeNames defines names for each PageInfoMode flag.
+var modeNames = map[string]PageInfoMode{
+	"all":     NoFiltering,
+	"methods": AllMethods,
+	"src":     ShowSource,
+	"text":    NoHTML,
+	"flat":    FlatDir,
+}
+
+// generate a query string for persisting PageInfoMode between pages.
+func modeQueryString(mode PageInfoMode) string {
+	if modeNames := mode.names(); len(modeNames) > 0 {
+		return "?m=" + strings.Join(modeNames, ",")
+	}
+	return ""
+}
+
+// alphabetically sorted names of active flags for a PageInfoMode.
+func (m PageInfoMode) names() []string {
+	var names []string
+	for name, mode := range modeNames {
+		if m&mode != 0 {
+			names = append(names, name)
+		}
+	}
+	sort.Strings(names)
+	return names
+}
+
+// GetPageInfoMode computes the PageInfoMode flags by analyzing the request
+// URL form value "m". It is value is a comma-separated list of mode names
+// as defined by modeNames (e.g.: m=src,text).
+func (p *Presentation) GetPageInfoMode(r *http.Request) PageInfoMode {
+	var mode PageInfoMode
+	for _, k := range strings.Split(r.FormValue(PageInfoModeQueryString), ",") {
+		if m, found := modeNames[strings.TrimSpace(k)]; found {
+			mode |= m
+		}
+	}
+	if p.AdjustPageInfoMode != nil {
+		mode = p.AdjustPageInfoMode(r, mode)
+	}
+	return mode
+}
+
+// poorMansImporter returns a (dummy) package object named
+// by the last path component of the provided package path
+// (as is the convention for packages). This is sufficient
+// to resolve package identifiers without doing an actual
+// import. It never returns an error.
+//
+func poorMansImporter(imports map[string]*ast.Object, path string) (*ast.Object, error) {
+	pkg := imports[path]
+	if pkg == nil {
+		// note that strings.LastIndex returns -1 if there is no "/"
+		pkg = ast.NewObj(ast.Pkg, path[strings.LastIndex(path, "/")+1:])
+		pkg.Data = ast.NewScope(nil) // required by ast.NewPackage for dot-import
+		imports[path] = pkg
+	}
+	return pkg, nil
+}
+
+// globalNames returns a set of the names declared by all package-level
+// declarations. Method names are returned in the form Receiver_Method.
+func globalNames(pkg *ast.Package) map[string]bool {
+	names := make(map[string]bool)
+	for _, file := range pkg.Files {
+		for _, decl := range file.Decls {
+			addNames(names, decl)
+		}
+	}
+	return names
+}
+
+// collectExamples collects examples for pkg from testfiles.
+func collectExamples(c *Corpus, pkg *ast.Package, testfiles map[string]*ast.File) []*doc.Example {
+	var files []*ast.File
+	for _, f := range testfiles {
+		files = append(files, f)
+	}
+
+	var examples []*doc.Example
+	globals := globalNames(pkg)
+	for _, e := range doc.Examples(files...) {
+		name := stripExampleSuffix(e.Name)
+		if name == "" || globals[name] {
+			examples = append(examples, e)
+		} else if c.Verbose {
+			log.Printf("skipping example 'Example%s' because '%s' is not a known function or type", e.Name, e.Name)
+		}
+	}
+
+	return examples
+}
+
+// addNames adds the names declared by decl to the names set.
+// Method names are added in the form ReceiverTypeName_Method.
+func addNames(names map[string]bool, decl ast.Decl) {
+	switch d := decl.(type) {
+	case *ast.FuncDecl:
+		name := d.Name.Name
+		if d.Recv != nil {
+			var typeName string
+			switch r := d.Recv.List[0].Type.(type) {
+			case *ast.StarExpr:
+				typeName = r.X.(*ast.Ident).Name
+			case *ast.Ident:
+				typeName = r.Name
+			}
+			name = typeName + "_" + name
+		}
+		names[name] = true
+	case *ast.GenDecl:
+		for _, spec := range d.Specs {
+			switch s := spec.(type) {
+			case *ast.TypeSpec:
+				names[s.Name.Name] = true
+			case *ast.ValueSpec:
+				for _, id := range s.Names {
+					names[id.Name] = true
+				}
+			}
+		}
+	}
+}
+
+// packageExports is a local implementation of ast.PackageExports
+// which correctly updates each package file's comment list.
+// (The ast.PackageExports signature is frozen, hence the local
+// implementation).
+//
+func packageExports(fset *token.FileSet, pkg *ast.Package) {
+	for _, src := range pkg.Files {
+		cmap := ast.NewCommentMap(fset, src, src.Comments)
+		ast.FileExports(src)
+		src.Comments = cmap.Filter(src).Comments()
+	}
+}
+
+func applyTemplate(t *template.Template, name string, data interface{}) []byte {
+	var buf bytes.Buffer
+	if err := t.Execute(&buf, data); err != nil {
+		log.Printf("%s.Execute: %s", name, err)
+	}
+	return buf.Bytes()
+}
+
+type writerCapturesErr struct {
+	w   io.Writer
+	err error
+}
+
+func (w *writerCapturesErr) Write(p []byte) (int, error) {
+	n, err := w.w.Write(p)
+	if err != nil {
+		w.err = err
+	}
+	return n, err
+}
+
+// applyTemplateToResponseWriter uses an http.ResponseWriter as the io.Writer
+// for the call to template.Execute.  It uses an io.Writer wrapper to capture
+// errors from the underlying http.ResponseWriter.  Errors are logged only when
+// they come from the template processing and not the Writer; this avoid
+// polluting log files with error messages due to networking issues, such as
+// client disconnects and http HEAD protocol violations.
+func applyTemplateToResponseWriter(rw http.ResponseWriter, t *template.Template, data interface{}) {
+	w := &writerCapturesErr{w: rw}
+	err := t.Execute(w, data)
+	// There are some cases where template.Execute does not return an error when
+	// rw returns an error, and some where it does.  So check w.err first.
+	if w.err == nil && err != nil {
+		// Log template errors.
+		log.Printf("%s.Execute: %s", t.Name(), err)
+	}
+}
+
+func redirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
+	canonical := pathpkg.Clean(r.URL.Path)
+	if !strings.HasSuffix(canonical, "/") {
+		canonical += "/"
+	}
+	if r.URL.Path != canonical {
+		url := *r.URL
+		url.Path = canonical
+		http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+		redirected = true
+	}
+	return
+}
+
+func redirectFile(w http.ResponseWriter, r *http.Request) (redirected bool) {
+	c := pathpkg.Clean(r.URL.Path)
+	c = strings.TrimRight(c, "/")
+	if r.URL.Path != c {
+		url := *r.URL
+		url.Path = c
+		http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+		redirected = true
+	}
+	return
+}
+
+func (p *Presentation) serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath, title string) {
+	src, err := vfs.ReadFile(p.Corpus.fs, abspath)
+	if err != nil {
+		log.Printf("ReadFile: %s", err)
+		p.ServeError(w, r, relpath, err)
+		return
+	}
+
+	if r.FormValue(PageInfoModeQueryString) == "text" {
+		p.ServeText(w, src)
+		return
+	}
+
+	h := r.FormValue("h")
+	s := RangeSelection(r.FormValue("s"))
+
+	var buf bytes.Buffer
+	if pathpkg.Ext(abspath) == ".go" {
+		// Find markup links for this file (e.g. "/src/fmt/print.go").
+		fi := p.Corpus.Analysis.FileInfo(abspath)
+		buf.WriteString("<script type='text/javascript'>document.ANALYSIS_DATA = ")
+		buf.Write(marshalJSON(fi.Data))
+		buf.WriteString(";</script>\n")
+
+		if status := p.Corpus.Analysis.Status(); status != "" {
+			buf.WriteString("<a href='/lib/godoc/analysis/help.html'>Static analysis features</a> ")
+			// TODO(adonovan): show analysis status at per-file granularity.
+			fmt.Fprintf(&buf, "<span style='color: grey'>[%s]</span><br/>", htmlpkg.EscapeString(status))
+		}
+
+		buf.WriteString("<pre>")
+		formatGoSource(&buf, src, fi.Links, h, s)
+		buf.WriteString("</pre>")
+	} else {
+		buf.WriteString("<pre>")
+		FormatText(&buf, src, 1, false, h, s)
+		buf.WriteString("</pre>")
+	}
+	fmt.Fprintf(&buf, `<p><a href="/%s?m=text">View as plain text</a></p>`, htmlpkg.EscapeString(relpath))
+
+	p.ServePage(w, Page{
+		Title:    title,
+		SrcPath:  relpath,
+		Tabtitle: relpath,
+		Body:     buf.Bytes(),
+		GoogleCN: googleCN(r),
+	})
+}
+
+// formatGoSource HTML-escapes Go source text and writes it to w,
+// decorating it with the specified analysis links.
+//
+func formatGoSource(buf *bytes.Buffer, text []byte, links []analysis.Link, pattern string, selection Selection) {
+	// Emit to a temp buffer so that we can add line anchors at the end.
+	saved, buf := buf, new(bytes.Buffer)
+
+	var i int
+	var link analysis.Link // shared state of the two funcs below
+	segmentIter := func() (seg Segment) {
+		if i < len(links) {
+			link = links[i]
+			i++
+			seg = Segment{link.Start(), link.End()}
+		}
+		return
+	}
+	linkWriter := func(w io.Writer, offs int, start bool) {
+		link.Write(w, offs, start)
+	}
+
+	comments := tokenSelection(text, token.COMMENT)
+	var highlights Selection
+	if pattern != "" {
+		highlights = regexpSelection(text, pattern)
+	}
+
+	FormatSelections(buf, text, linkWriter, segmentIter, selectionTag, comments, highlights, selection)
+
+	// Now copy buf to saved, adding line anchors.
+
+	// The lineSelection mechanism can't be composed with our
+	// linkWriter, so we have to add line spans as another pass.
+	n := 1
+	for _, line := range bytes.Split(buf.Bytes(), []byte("\n")) {
+		// The line numbers are inserted into the document via a CSS ::before
+		// pseudo-element. This prevents them from being copied when users
+		// highlight and copy text.
+		// ::before is supported in 98% of browsers: https://caniuse.com/#feat=css-gencontent
+		// This is also the trick Github uses to hide line numbers.
+		//
+		// The first tab for the code snippet needs to start in column 9, so
+		// it indents a full 8 spaces, hence the two nbsp's. Otherwise the tab
+		// character only indents about two spaces.
+		fmt.Fprintf(saved, `<span id="L%d" class="ln">%6d&nbsp;&nbsp;</span>`, n, n)
+		n++
+		saved.Write(line)
+		saved.WriteByte('\n')
+	}
+}
+
+func (p *Presentation) serveDirectory(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+	if redirect(w, r) {
+		return
+	}
+
+	list, err := p.Corpus.fs.ReadDir(abspath)
+	if err != nil {
+		p.ServeError(w, r, relpath, err)
+		return
+	}
+
+	p.ServePage(w, Page{
+		Title:    "Directory",
+		SrcPath:  relpath,
+		Tabtitle: relpath,
+		Body:     applyTemplate(p.DirlistHTML, "dirlistHTML", list),
+		GoogleCN: googleCN(r),
+	})
+}
+
+func (p *Presentation) ServeHTMLDoc(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+	// get HTML body contents
+	src, err := vfs.ReadFile(p.Corpus.fs, abspath)
+	if err != nil {
+		log.Printf("ReadFile: %s", err)
+		p.ServeError(w, r, relpath, err)
+		return
+	}
+
+	// if it begins with "<!DOCTYPE " assume it is standalone
+	// html that doesn't need the template wrapping.
+	if bytes.HasPrefix(src, doctype) {
+		w.Write(src)
+		return
+	}
+
+	// if it begins with a JSON blob, read in the metadata.
+	meta, src, err := extractMetadata(src)
+	if err != nil {
+		log.Printf("decoding metadata %s: %v", relpath, err)
+	}
+
+	page := Page{
+		Title:    meta.Title,
+		Subtitle: meta.Subtitle,
+		GoogleCN: googleCN(r),
+	}
+
+	// evaluate as template if indicated
+	if meta.Template {
+		tmpl, err := template.New("main").Funcs(p.TemplateFuncs()).Parse(string(src))
+		if err != nil {
+			log.Printf("parsing template %s: %v", relpath, err)
+			p.ServeError(w, r, relpath, err)
+			return
+		}
+		var buf bytes.Buffer
+		if err := tmpl.Execute(&buf, page); err != nil {
+			log.Printf("executing template %s: %v", relpath, err)
+			p.ServeError(w, r, relpath, err)
+			return
+		}
+		src = buf.Bytes()
+	}
+
+	// if it's the language spec, add tags to EBNF productions
+	if strings.HasSuffix(abspath, "go_spec.html") {
+		var buf bytes.Buffer
+		Linkify(&buf, src)
+		src = buf.Bytes()
+	}
+
+	page.Body = src
+	p.ServePage(w, page)
+}
+
+func (p *Presentation) ServeFile(w http.ResponseWriter, r *http.Request) {
+	p.serveFile(w, r)
+}
+
+func (p *Presentation) serveFile(w http.ResponseWriter, r *http.Request) {
+	relpath := r.URL.Path
+
+	// Check to see if we need to redirect or serve another file.
+	if m := p.Corpus.MetadataFor(relpath); m != nil {
+		if m.Path != relpath {
+			// Redirect to canonical path.
+			http.Redirect(w, r, m.Path, http.StatusMovedPermanently)
+			return
+		}
+		// Serve from the actual filesystem path.
+		relpath = m.filePath
+	}
+
+	abspath := relpath
+	relpath = relpath[1:] // strip leading slash
+
+	switch pathpkg.Ext(relpath) {
+	case ".html":
+		if strings.HasSuffix(relpath, "/index.html") {
+			// We'll show index.html for the directory.
+			// Use the dir/ version as canonical instead of dir/index.html.
+			http.Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
+			return
+		}
+		p.ServeHTMLDoc(w, r, abspath, relpath)
+		return
+
+	case ".go":
+		p.serveTextFile(w, r, abspath, relpath, "Source file")
+		return
+	}
+
+	dir, err := p.Corpus.fs.Lstat(abspath)
+	if err != nil {
+		log.Print(err)
+		p.ServeError(w, r, relpath, err)
+		return
+	}
+
+	if dir != nil && dir.IsDir() {
+		if redirect(w, r) {
+			return
+		}
+		if index := pathpkg.Join(abspath, "index.html"); util.IsTextFile(p.Corpus.fs, index) {
+			p.ServeHTMLDoc(w, r, index, index)
+			return
+		}
+		p.serveDirectory(w, r, abspath, relpath)
+		return
+	}
+
+	if util.IsTextFile(p.Corpus.fs, abspath) {
+		if redirectFile(w, r) {
+			return
+		}
+		p.serveTextFile(w, r, abspath, relpath, "Text file")
+		return
+	}
+
+	p.fileServer.ServeHTTP(w, r)
+}
+
+func (p *Presentation) ServeText(w http.ResponseWriter, text []byte) {
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+	w.Write(text)
+}
+
+func marshalJSON(x interface{}) []byte {
+	var data []byte
+	var err error
+	const indentJSON = false // for easier debugging
+	if indentJSON {
+		data, err = json.MarshalIndent(x, "", "    ")
+	} else {
+		data, err = json.Marshal(x)
+	}
+	if err != nil {
+		panic(fmt.Sprintf("json.Marshal failed: %s", err))
+	}
+	return data
+}
diff --git a/vendor/golang.org/x/tools/godoc/short/short.go b/vendor/golang.org/x/tools/godoc/short/short.go
new file mode 100644
index 0000000..44d3c93
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/short/short.go
@@ -0,0 +1,173 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+// Package short implements a simple URL shortener, serving an administrative
+// interface at /s and shortened urls from /s/key.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package short
+
+// TODO(adg): collect statistics on URL visits
+
+import (
+	"errors"
+	"fmt"
+	"html/template"
+	"net/http"
+	"net/url"
+	"regexp"
+
+	"golang.org/x/net/context"
+
+	"google.golang.org/appengine"
+	"google.golang.org/appengine/datastore"
+	"google.golang.org/appengine/log"
+	"google.golang.org/appengine/memcache"
+	"google.golang.org/appengine/user"
+)
+
+const (
+	prefix  = "/s"
+	kind    = "Link"
+	baseURL = "https://golang.org" + prefix
+)
+
+// Link represents a short link.
+type Link struct {
+	Key, Target string
+}
+
+var validKey = regexp.MustCompile(`^[a-zA-Z0-9-_.]+$`)
+
+func RegisterHandlers(mux *http.ServeMux) {
+	mux.HandleFunc(prefix, adminHandler)
+	mux.HandleFunc(prefix+"/", linkHandler)
+}
+
+// linkHandler services requests to short URLs.
+//   http://golang.org/s/key
+// It consults memcache and datastore for the Link for key.
+// It then sends a redirects or an error message.
+func linkHandler(w http.ResponseWriter, r *http.Request) {
+	c := appengine.NewContext(r)
+
+	key := r.URL.Path[len(prefix)+1:]
+	if !validKey.MatchString(key) {
+		http.Error(w, "not found", http.StatusNotFound)
+		return
+	}
+
+	var link Link
+	_, err := memcache.JSON.Get(c, cacheKey(key), &link)
+	if err != nil {
+		k := datastore.NewKey(c, kind, key, 0, nil)
+		err = datastore.Get(c, k, &link)
+		switch err {
+		case datastore.ErrNoSuchEntity:
+			http.Error(w, "not found", http.StatusNotFound)
+			return
+		default: // != nil
+			log.Errorf(c, "%q: %v", key, err)
+			http.Error(w, "internal server error", http.StatusInternalServerError)
+			return
+		case nil:
+			item := &memcache.Item{
+				Key:    cacheKey(key),
+				Object: &link,
+			}
+			if err := memcache.JSON.Set(c, item); err != nil {
+				log.Warningf(c, "%q: %v", key, err)
+			}
+		}
+	}
+
+	http.Redirect(w, r, link.Target, http.StatusFound)
+}
+
+var adminTemplate = template.Must(template.New("admin").Parse(templateHTML))
+
+// adminHandler serves an administrative interface.
+func adminHandler(w http.ResponseWriter, r *http.Request) {
+	c := appengine.NewContext(r)
+
+	if !user.IsAdmin(c) {
+		http.Error(w, "forbidden", http.StatusForbidden)
+		return
+	}
+
+	var newLink *Link
+	var doErr error
+	if r.Method == "POST" {
+		key := r.FormValue("key")
+		switch r.FormValue("do") {
+		case "Add":
+			newLink = &Link{key, r.FormValue("target")}
+			doErr = putLink(c, newLink)
+		case "Delete":
+			k := datastore.NewKey(c, kind, key, 0, nil)
+			doErr = datastore.Delete(c, k)
+		default:
+			http.Error(w, "unknown action", http.StatusBadRequest)
+		}
+		err := memcache.Delete(c, cacheKey(key))
+		if err != nil && err != memcache.ErrCacheMiss {
+			log.Warningf(c, "%q: %v", key, err)
+		}
+	}
+
+	var links []*Link
+	_, err := datastore.NewQuery(kind).Order("Key").GetAll(c, &links)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		log.Errorf(c, "%v", err)
+		return
+	}
+
+	// Put the new link in the list if it's not there already.
+	// (Eventual consistency means that it might not show up
+	// immediately, which might be confusing for the user.)
+	if newLink != nil && doErr == nil {
+		found := false
+		for i := range links {
+			if links[i].Key == newLink.Key {
+				found = true
+				break
+			}
+		}
+		if !found {
+			links = append([]*Link{newLink}, links...)
+		}
+		newLink = nil
+	}
+
+	var data = struct {
+		BaseURL string
+		Prefix  string
+		Links   []*Link
+		New     *Link
+		Error   error
+	}{baseURL, prefix, links, newLink, doErr}
+	if err := adminTemplate.Execute(w, &data); err != nil {
+		log.Criticalf(c, "adminTemplate: %v", err)
+	}
+}
+
+// putLink validates the provided link and puts it into the datastore.
+func putLink(c context.Context, link *Link) error {
+	if !validKey.MatchString(link.Key) {
+		return errors.New("invalid key; must match " + validKey.String())
+	}
+	if _, err := url.Parse(link.Target); err != nil {
+		return fmt.Errorf("bad target: %v", err)
+	}
+	k := datastore.NewKey(c, kind, link.Key, 0, nil)
+	_, err := datastore.Put(c, k, link)
+	return err
+}
+
+// cacheKey returns a short URL key as a memcache key.
+func cacheKey(key string) string {
+	return "link-" + key
+}
diff --git a/vendor/golang.org/x/tools/godoc/short/tmpl.go b/vendor/golang.org/x/tools/godoc/short/tmpl.go
new file mode 100644
index 0000000..95e4c2a
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/short/tmpl.go
@@ -0,0 +1,121 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package short
+
+const templateHTML = `
+<!doctype HTML>
+<html>
+<head>
+<title>golang.org URL shortener</title>
+<style>
+body {
+	background: white;
+}
+input {
+	border: 1px solid #ccc;
+}
+input[type=text] {
+	width: 400px;
+}
+input, td, th {
+	color: #333;
+	font-family: Georgia, Times New Roman, serif;
+}
+input, td {
+	font-size: 14pt;
+}
+th {
+	font-size: 16pt;
+	text-align: left;
+	padding-top: 10px;
+}
+.autoselect {
+	border: none;
+}
+.error {
+	color: #900;
+}
+table {
+	margin-left: auto;
+	margin-right: auto;
+}
+</style>
+</head>
+<body>
+
+<table>
+
+{{with .Error}}
+<tr>
+	<th colspan="3">Error</th>
+</tr>
+<tr>
+	<td class="error" colspan="3">{{.}}</td>
+</tr>
+{{end}}
+
+<tr>
+	<th>Key</th>
+	<th>Target</th>
+	<th></th>
+</tr>
+
+<form method="POST" action="{{.Prefix}}">
+<tr>
+	<td><input type="text" name="key"{{with .New}} value="{{.Key}}"{{end}}></td>
+	<td><input type="text" name="target"{{with .New}} value="{{.Target}}"{{end}}></td>
+	<td><input type="submit" name="do" value="Add">
+</tr>
+</form>
+
+{{with .Links}}
+<tr>
+	<th>Short Link</th>
+	<th>&nbsp;</th>
+	<th>&nbsp;</th>
+</tr>
+{{range .}}
+<tr>
+	<td><input class="autoselect" type="text" orig="{{$.BaseURL}}/{{.Key}}" value="{{$.BaseURL}}/{{.Key}}"></td>
+	<td><input class="autoselect" type="text" orig="{{.Target}}" value="{{.Target}}"></td>
+	<td>
+		<form method="POST" action="{{$.Prefix}}">
+			<input type="hidden" name="key" value="{{.Key}}">
+			<input type="submit" name="do" value="Delete" class="delete">
+		</form>
+	</td>
+</tr>
+{{end}}
+{{end}}
+
+</table>
+
+</body>
+<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
+<script type="text/javascript">window.jQuery || document.write(unescape("%3Cscript src='/doc/jquery.js' type='text/javascript'%3E%3C/script%3E"));</script>
+<script>
+$(document).ready(function() {
+	$('.autoselect').each(function() {
+		$(this).click(function() {
+			$(this).select();
+		});
+		$(this).change(function() {
+			$(this).val($(this).attr('orig'));
+		});
+	});
+	$('.delete').click(function(e) {
+		var link = $(this).closest('tr').find('input').first().val();
+		var ok = confirm('Delete this link?\n' + link);
+		if (!ok) {
+			e.preventDefault();
+			return false;
+		}
+	});
+});
+</script>
+</html>
+`
diff --git a/vendor/golang.org/x/tools/godoc/snippet.go b/vendor/golang.org/x/tools/godoc/snippet.go
new file mode 100644
index 0000000..dd9c822
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/snippet.go
@@ -0,0 +1,123 @@
+// Copyright 2009 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 contains the infrastructure to create a code
+// snippet for search results.
+//
+// Note: At the moment, this only creates HTML snippets.
+
+package godoc
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/token"
+)
+
+type Snippet struct {
+	Line int
+	Text string // HTML-escaped
+}
+
+func (p *Presentation) newSnippet(fset *token.FileSet, decl ast.Decl, id *ast.Ident) *Snippet {
+	// TODO instead of pretty-printing the node, should use the original source instead
+	var buf1 bytes.Buffer
+	p.writeNode(&buf1, fset, decl)
+	// wrap text with <pre> tag
+	var buf2 bytes.Buffer
+	buf2.WriteString("<pre>")
+	FormatText(&buf2, buf1.Bytes(), -1, true, id.Name, nil)
+	buf2.WriteString("</pre>")
+	return &Snippet{fset.Position(id.Pos()).Line, buf2.String()}
+}
+
+func findSpec(list []ast.Spec, id *ast.Ident) ast.Spec {
+	for _, spec := range list {
+		switch s := spec.(type) {
+		case *ast.ImportSpec:
+			if s.Name == id {
+				return s
+			}
+		case *ast.ValueSpec:
+			for _, n := range s.Names {
+				if n == id {
+					return s
+				}
+			}
+		case *ast.TypeSpec:
+			if s.Name == id {
+				return s
+			}
+		}
+	}
+	return nil
+}
+
+func (p *Presentation) genSnippet(fset *token.FileSet, d *ast.GenDecl, id *ast.Ident) *Snippet {
+	s := findSpec(d.Specs, id)
+	if s == nil {
+		return nil //  declaration doesn't contain id - exit gracefully
+	}
+
+	// only use the spec containing the id for the snippet
+	dd := &ast.GenDecl{
+		Doc:    d.Doc,
+		TokPos: d.Pos(),
+		Tok:    d.Tok,
+		Lparen: d.Lparen,
+		Specs:  []ast.Spec{s},
+		Rparen: d.Rparen,
+	}
+
+	return p.newSnippet(fset, dd, id)
+}
+
+func (p *Presentation) funcSnippet(fset *token.FileSet, d *ast.FuncDecl, id *ast.Ident) *Snippet {
+	if d.Name != id {
+		return nil //  declaration doesn't contain id - exit gracefully
+	}
+
+	// only use the function signature for the snippet
+	dd := &ast.FuncDecl{
+		Doc:  d.Doc,
+		Recv: d.Recv,
+		Name: d.Name,
+		Type: d.Type,
+	}
+
+	return p.newSnippet(fset, dd, id)
+}
+
+// NewSnippet creates a text snippet from a declaration decl containing an
+// identifier id. Parts of the declaration not containing the identifier
+// may be removed for a more compact snippet.
+func NewSnippet(fset *token.FileSet, decl ast.Decl, id *ast.Ident) *Snippet {
+	// TODO(bradfitz, adg): remove this function.  But it's used by indexer, which
+	// doesn't have a *Presentation, and NewSnippet needs a TabWidth.
+	var p Presentation
+	p.TabWidth = 4
+	return p.NewSnippet(fset, decl, id)
+}
+
+// NewSnippet creates a text snippet from a declaration decl containing an
+// identifier id. Parts of the declaration not containing the identifier
+// may be removed for a more compact snippet.
+func (p *Presentation) NewSnippet(fset *token.FileSet, decl ast.Decl, id *ast.Ident) *Snippet {
+	var s *Snippet
+	switch d := decl.(type) {
+	case *ast.GenDecl:
+		s = p.genSnippet(fset, d, id)
+	case *ast.FuncDecl:
+		s = p.funcSnippet(fset, d, id)
+	}
+
+	// handle failure gracefully
+	if s == nil {
+		var buf bytes.Buffer
+		fmt.Fprintf(&buf, `<span class="alert">could not generate a snippet for <span class="highlight">%s</span></span>`, id.Name)
+		s = &Snippet{fset.Position(id.Pos()).Line, buf.String()}
+	}
+	return s
+}
diff --git a/vendor/golang.org/x/tools/godoc/spec.go b/vendor/golang.org/x/tools/godoc/spec.go
new file mode 100644
index 0000000..6d6b9c2
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/spec.go
@@ -0,0 +1,179 @@
+// Copyright 2009 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 godoc
+
+// This file contains the mechanism to "linkify" html source
+// text containing EBNF sections (as found in go_spec.html).
+// The result is the input source text with the EBNF sections
+// modified such that identifiers are linked to the respective
+// definitions.
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"text/scanner"
+)
+
+type ebnfParser struct {
+	out     io.Writer // parser output
+	src     []byte    // parser input
+	scanner scanner.Scanner
+	prev    int    // offset of previous token
+	pos     int    // offset of current token
+	tok     rune   // one token look-ahead
+	lit     string // token literal
+}
+
+func (p *ebnfParser) flush() {
+	p.out.Write(p.src[p.prev:p.pos])
+	p.prev = p.pos
+}
+
+func (p *ebnfParser) next() {
+	p.tok = p.scanner.Scan()
+	p.pos = p.scanner.Position.Offset
+	p.lit = p.scanner.TokenText()
+}
+
+func (p *ebnfParser) printf(format string, args ...interface{}) {
+	p.flush()
+	fmt.Fprintf(p.out, format, args...)
+}
+
+func (p *ebnfParser) errorExpected(msg string) {
+	p.printf(`<span class="highlight">error: expected %s, found %s</span>`, msg, scanner.TokenString(p.tok))
+}
+
+func (p *ebnfParser) expect(tok rune) {
+	if p.tok != tok {
+		p.errorExpected(scanner.TokenString(tok))
+	}
+	p.next() // make progress in any case
+}
+
+func (p *ebnfParser) parseIdentifier(def bool) {
+	if p.tok == scanner.Ident {
+		name := p.lit
+		if def {
+			p.printf(`<a id="%s">%s</a>`, name, name)
+		} else {
+			p.printf(`<a href="#%s" class="noline">%s</a>`, name, name)
+		}
+		p.prev += len(name) // skip identifier when printing next time
+		p.next()
+	} else {
+		p.expect(scanner.Ident)
+	}
+}
+
+func (p *ebnfParser) parseTerm() bool {
+	switch p.tok {
+	case scanner.Ident:
+		p.parseIdentifier(false)
+
+	case scanner.String:
+		p.next()
+		const ellipsis = '…' // U+2026, the horizontal ellipsis character
+		if p.tok == ellipsis {
+			p.next()
+			p.expect(scanner.String)
+		}
+
+	case '(':
+		p.next()
+		p.parseExpression()
+		p.expect(')')
+
+	case '[':
+		p.next()
+		p.parseExpression()
+		p.expect(']')
+
+	case '{':
+		p.next()
+		p.parseExpression()
+		p.expect('}')
+
+	default:
+		return false // no term found
+	}
+
+	return true
+}
+
+func (p *ebnfParser) parseSequence() {
+	if !p.parseTerm() {
+		p.errorExpected("term")
+	}
+	for p.parseTerm() {
+	}
+}
+
+func (p *ebnfParser) parseExpression() {
+	for {
+		p.parseSequence()
+		if p.tok != '|' {
+			break
+		}
+		p.next()
+	}
+}
+
+func (p *ebnfParser) parseProduction() {
+	p.parseIdentifier(true)
+	p.expect('=')
+	if p.tok != '.' {
+		p.parseExpression()
+	}
+	p.expect('.')
+}
+
+func (p *ebnfParser) parse(out io.Writer, src []byte) {
+	// initialize ebnfParser
+	p.out = out
+	p.src = src
+	p.scanner.Init(bytes.NewBuffer(src))
+	p.next() // initializes pos, tok, lit
+
+	// process source
+	for p.tok != scanner.EOF {
+		p.parseProduction()
+	}
+	p.flush()
+}
+
+// Markers around EBNF sections
+var (
+	openTag  = []byte(`<pre class="ebnf">`)
+	closeTag = []byte(`</pre>`)
+)
+
+func Linkify(out io.Writer, src []byte) {
+	for len(src) > 0 {
+		// i: beginning of EBNF text (or end of source)
+		i := bytes.Index(src, openTag)
+		if i < 0 {
+			i = len(src) - len(openTag)
+		}
+		i += len(openTag)
+
+		// j: end of EBNF text (or end of source)
+		j := bytes.Index(src[i:], closeTag) // close marker
+		if j < 0 {
+			j = len(src) - i
+		}
+		j += i
+
+		// write text before EBNF
+		out.Write(src[0:i])
+		// process EBNF
+		var p ebnfParser
+		p.parse(out, src[i:j])
+
+		// advance
+		src = src[j:]
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/spot.go b/vendor/golang.org/x/tools/godoc/spot.go
new file mode 100644
index 0000000..95ffa4b
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/spot.go
@@ -0,0 +1,83 @@
+// 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 godoc
+
+// ----------------------------------------------------------------------------
+// SpotInfo
+
+// A SpotInfo value describes a particular identifier spot in a given file;
+// It encodes three values: the SpotKind (declaration or use), a line or
+// snippet index "lori", and whether it's a line or index.
+//
+// The following encoding is used:
+//
+//   bits    32   4    1       0
+//   value    [lori|kind|isIndex]
+//
+type SpotInfo uint32
+
+// SpotKind describes whether an identifier is declared (and what kind of
+// declaration) or used.
+type SpotKind uint32
+
+const (
+	PackageClause SpotKind = iota
+	ImportDecl
+	ConstDecl
+	TypeDecl
+	VarDecl
+	FuncDecl
+	MethodDecl
+	Use
+	nKinds
+)
+
+var (
+	// These must match the SpotKind values above.
+	name = []string{
+		"Packages",
+		"Imports",
+		"Constants",
+		"Types",
+		"Variables",
+		"Functions",
+		"Methods",
+		"Uses",
+		"Unknown",
+	}
+)
+
+func (x SpotKind) Name() string { return name[x] }
+
+func init() {
+	// sanity check: if nKinds is too large, the SpotInfo
+	// accessor functions may need to be updated
+	if nKinds > 8 {
+		panic("internal error: nKinds > 8")
+	}
+}
+
+// makeSpotInfo makes a SpotInfo.
+func makeSpotInfo(kind SpotKind, lori int, isIndex bool) SpotInfo {
+	// encode lori: bits [4..32)
+	x := SpotInfo(lori) << 4
+	if int(x>>4) != lori {
+		// lori value doesn't fit - since snippet indices are
+		// most certainly always smaller then 1<<28, this can
+		// only happen for line numbers; give it no line number (= 0)
+		x = 0
+	}
+	// encode kind: bits [1..4)
+	x |= SpotInfo(kind) << 1
+	// encode isIndex: bit 0
+	if isIndex {
+		x |= 1
+	}
+	return x
+}
+
+func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) }
+func (x SpotInfo) Lori() int      { return int(x >> 4) }
+func (x SpotInfo) IsIndex() bool  { return x&1 != 0 }
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/call-eg.png b/vendor/golang.org/x/tools/godoc/static/analysis/call-eg.png
new file mode 100644
index 0000000..c48bf4d
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/call-eg.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/call3.png b/vendor/golang.org/x/tools/godoc/static/analysis/call3.png
new file mode 100644
index 0000000..387a38c
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/call3.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/callers1.png b/vendor/golang.org/x/tools/godoc/static/analysis/callers1.png
new file mode 100644
index 0000000..80fbc62
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/callers1.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/callers2.png b/vendor/golang.org/x/tools/godoc/static/analysis/callers2.png
new file mode 100644
index 0000000..59a84ed
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/callers2.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/chan1.png b/vendor/golang.org/x/tools/godoc/static/analysis/chan1.png
new file mode 100644
index 0000000..5eb2811
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/chan1.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/chan2a.png b/vendor/golang.org/x/tools/godoc/static/analysis/chan2a.png
new file mode 100644
index 0000000..b757504
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/chan2a.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/chan2b.png b/vendor/golang.org/x/tools/godoc/static/analysis/chan2b.png
new file mode 100644
index 0000000..d197862
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/chan2b.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/error1.png b/vendor/golang.org/x/tools/godoc/static/analysis/error1.png
new file mode 100644
index 0000000..69550b9
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/error1.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/help.html b/vendor/golang.org/x/tools/godoc/static/analysis/help.html
new file mode 100644
index 0000000..023c07d
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/analysis/help.html
@@ -0,0 +1,254 @@
+<!--{
+        "Title": "Static analysis features of godoc"
+}-->
+
+<style>
+  span.err { 'font-size:120%; color:darkred; background-color: yellow; }
+  img.ss { margin-left: 1in; } /* screenshot */
+  img.dotted { border: thin dotted; }
+</style>
+
+<!-- Images were grabbed from Chrome/Linux at 150% zoom, and are
+     displayed at 66% of natural size.  This allows users to zoom a
+     little before seeing pixels. -->
+
+<p>
+  When invoked with the <code>-analysis</code> flag, godoc performs
+  static analysis on the Go packages it indexes and displays the
+  results in the source and package views.  This document provides a
+  brief tour of these features.
+</p>
+
+<h2>Type analysis features</h2>
+<p>
+  <code>godoc -analysis=type</code> performs static checking similar
+  to that done by a compiler: it detects ill-formed programs, resolves
+  each identifier to the entity it denotes, computes the type of each
+  expression and the method set of each type, and determines which
+  types are assignable to each interface type.
+
+  <b>Type analysis</b> is relatively quick, requiring about 10 seconds for
+  the &gt;200 packages of the standard library, for example.
+</p>
+
+<h3>Compiler errors</h3>
+<p>
+  If any source file contains a compilation error, the source view
+  will highlight the errant location in red.  Hovering over it
+  displays the error message.
+</p>
+<img class="ss" width='811' src='error1.png'><br/>
+
+<h3>Identifier resolution</h3>
+<p>
+  In the source view, every referring identifier is annotated with
+  information about the language entity it refers to: a package,
+  constant, variable, type, function or statement label.
+
+  Hovering over the identifier reveals the entity's kind and type
+  (e.g. <code>var x int</code> or <code>func f
+  func(int) string</code>).
+</p>
+<img class="ss" width='652' src='ident-field.png'><br/>
+<br/>
+<img class="ss" width='652' src='ident-func.png'>
+<p>
+  Clicking the link takes you to the entity's definition.
+</p>
+<img class="ss" width='652' src='ident-def.png'><br/>
+
+<h3>Type information: size/alignment, method set, interfaces</h3>
+<p>
+  Clicking on the identifier that defines a named type causes a panel
+  to appear, displaying information about the named type, including
+  its size and alignment in bytes, its
+  <a href='http://golang.org/ref/spec#Method_sets'>method set</a>, and its
+  <i>implements</i> relation: the set of types T that are assignable to
+  or from this type U where at least one of T or U is an interface.
+
+  This example shows information about <code>net/rpc.methodType</code>.
+</p>
+<img class="ss" width='470' src='typeinfo-src.png'>
+<p>
+  The method set includes not only the declared methods of the type,
+  but also any methods "promoted" from anonymous fields of structs,
+  such as <code>sync.Mutex</code> in this example.
+
+  In addition, the receiver type is displayed as <code>*T</code> or
+  <code>T</code> depending on whether it requires the address or just
+  a copy of the receiver value.
+</p>
+<p>
+  The method set and <i>implements</i> relation are also available
+  via the package view.
+</p>
+<img class="ss dotted" width='716' src='typeinfo-pkg.png'>
+
+<h2>Pointer analysis features</h2>
+<p>
+  <code>godoc -analysis=pointer</code> additionally performs a precise
+  whole-program <b>pointer analysis</b>.  In other words, it
+  approximates the set of memory locations to which each
+  reference&mdash;not just vars of kind <code>*T</code>, but also
+  <code>[]T</code>, <code>func</code>, <code>map</code>,
+  <code>chan</code>, and <code>interface</code>&mdash;may refer.  This
+  information reveals the possible destinations of each dynamic call
+  (via a <code>func</code> variable or interface method), and the
+  relationship between send and receive operations on the same
+  channel.
+</p>
+<p>
+  Compared to type analysis, pointer analysis requires more time and
+  memory, and is impractical for code bases exceeding a million lines.
+</p>
+
+<h3>Call graph navigation</h3>
+<p>
+  When pointer analysis is complete, the source view annotates the
+  code with <b>callers</b> and <b>callees</b> information: callers
+  information is associated with the <code>func</code> keyword that
+  declares a function, and callees information is associated with the
+  open paren '<span style="color: dark-blue"><code>(</code></span>' of
+  a function call.
+</p>
+<p>
+  In this example, hovering over the declaration of the
+  <code>rot13</code> function (defined in strings/strings_test.go)
+  reveals that it is called in exactly one place.
+</p>
+<img class="ss" width='612' src='callers1.png'>
+<p>
+  Clicking the link navigates to the sole caller.  (If there were
+  multiple callers, a list of choices would be displayed first.)
+</p>
+<img class="ss" width='680' src='callers2.png'>
+<p>
+  Notice that hovering over this call reveals that there are 19
+  possible callees at this site, of which our <code>rot13</code>
+  function was just one: this is a dynamic call through a variable of
+  type <code>func(rune) rune</code>.
+
+  Clicking on the call brings up the list of all 19 potential callees,
+  shown truncated.  Many of them are anonymous functions.
+</p>
+<img class="ss" width='564' src='call3.png'>
+<p>
+  Pointer analysis gives a very precise approximation of the call
+  graph compared to type-based techniques.
+
+  As a case in point, the next example shows the dynamic call inside
+  the <code>testing</code> package responsible for calling all
+  user-defined functions named <code>Example<i>XYZ</i></code>.
+</p>
+<img class="ss" width='361' src='call-eg.png'>
+<p>
+  Recall that all such functions have type <code>func()</code>,
+  i.e. no arguments and no results.  A type-based approximation could
+  only conclude that this call might dispatch to any function matching
+  that type&mdash;and these are very numerous in most
+  programs&mdash;but pointer analysis can track the flow of specific
+  <code>func</code> values through the testing package.
+
+  As an indication of its precision, the result contains only
+  functions whose name starts with <code>Example</code>.
+</p>
+
+<h3>Intra-package call graph</h3>
+<p>
+  The same call graph information is presented in a very different way
+  in the package view.  For each package, an interactive tree view
+  allows exploration of the call graph as it relates to just that
+  package; all functions from other packages are elided.
+
+  The roots of the tree are the external entry points of the package:
+  not only its exported functions, but also any unexported or
+  anonymous functions that are called (dynamically) from outside the
+  package.
+</p>
+<p>
+  This example shows the entry points of the
+  <code>path/filepath</code> package, with the call graph for
+  <code>Glob</code> expanded several levels
+</p>
+<img class="ss dotted" width='501' src='ipcg-pkg.png'>
+<p>
+  Notice that the nodes for Glob and Join appear multiple times: the
+  tree is a partial unrolling of a cyclic graph; the full unrolling
+  is in general infinite.
+</p>
+<p>
+  For each function documented in the package view, another
+  interactive tree view allows exploration of the same graph starting
+  at that function.
+
+  This is a portion of the internal graph of
+  <code>net/http.ListenAndServe</code>.
+</p>
+<img class="ss dotted" width='455' src='ipcg-func.png'>
+
+<h3>Channel peers (send ↔ receive)</h3>
+<p>
+  Because concurrent Go programs use channels to pass not just values
+  but also control between different goroutines, it is natural when
+  reading Go code to want to navigate from a channel send to the
+  corresponding receive so as to understand the sequence of events.
+</p>
+<p>
+  Godoc annotates every channel operation&mdash;make, send, range,
+  receive, close&mdash;with a link to a panel displaying information
+  about other operations that might alias the same channel.
+</p>
+<p>
+  This example, from the tests of <code>net/http</code>, shows a send
+  operation on a <code>chan bool</code>.
+</p>
+<img class="ss" width='811' src='chan1.png'>
+<p>
+  Clicking on the <code>&lt;-</code> send operator reveals that this
+  channel is made at a unique location (line 332) and that there are
+  three receive operations that might read this value.
+
+  It hardly needs pointing out that some channel element types are
+  very widely used (e.g. struct{}, bool, int, interface{}) and that a
+  typical Go program might contain dozens of receive operations on a
+  value of type <code>chan bool</code>; yet the pointer analysis is
+  able to distinguish operations on channels at a much finer precision
+  than based on their type alone.
+</p>
+<p>
+  Notice also that the send occurs in a different (anonymous) function
+  from the outer one containing the <code>make</code> and the receive
+  operations.
+</p>
+<p>
+  Here's another example of send on a different <code>chan
+  bool</code>, also in package <code>net/http</code>:
+</p>
+<img class="ss" width='774' src='chan2a.png'>
+<p>
+  The analysis finds just one receive operation that might receive
+  from this channel, in the test for this feature.
+</p>
+<img class="ss" width='737' src='chan2b.png'>
+
+<h2>Known issues</h2>
+<p>
+  All analysis results pertain to exactly
+  one configuration (e.g. amd64 linux).  Files that are conditionally
+  compiled based on different platforms or build tags are not visible
+  to the analysis.
+</p>
+<p>
+  Files that <code>import "C"</code> require
+  preprocessing by the cgo tool.  The file offsets after preprocessing
+  do not align with the unpreprocessed file, so markup is misaligned.
+</p>
+<p>
+  Files are not periodically re-analyzed.
+  If the files change underneath the running server, the displayed
+  markup is misaligned.
+</p>
+<p>
+  Additional issues are listed at
+  <a href='https://go.googlesource.com/tools/+/master/godoc/analysis/README'>tools/godoc/analysis/README</a>.
+</p>
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/ident-def.png b/vendor/golang.org/x/tools/godoc/static/analysis/ident-def.png
new file mode 100644
index 0000000..b0d9e55
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/ident-def.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/ident-field.png b/vendor/golang.org/x/tools/godoc/static/analysis/ident-field.png
new file mode 100644
index 0000000..76cbe5a
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/ident-field.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/ident-func.png b/vendor/golang.org/x/tools/godoc/static/analysis/ident-func.png
new file mode 100644
index 0000000..69670fa
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/ident-func.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-func.png b/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-func.png
new file mode 100644
index 0000000..523318d
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-func.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-pkg.png b/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-pkg.png
new file mode 100644
index 0000000..e029068
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/ipcg-pkg.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-pkg.png b/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-pkg.png
new file mode 100644
index 0000000..91bd5f7
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-pkg.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-src.png b/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-src.png
new file mode 100644
index 0000000..6e5b147
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/analysis/typeinfo-src.png differ
diff --git a/vendor/golang.org/x/tools/godoc/static/callgraph.html b/vendor/golang.org/x/tools/godoc/static/callgraph.html
new file mode 100644
index 0000000..c56b2ef
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/callgraph.html
@@ -0,0 +1,15 @@
+<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Internal call graph</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Internal call graph</span></p>
+		<p>
+		  This viewer shows the portion of the internal call
+		  graph of this package that is reachable from this function.
+		  See the <a href='#pkg-callgraph'>package's call
+		  graph</a> for more information.
+		</p>
+		<ul style="margin-left: 0.5in" id="callgraph-{{.Index}}" class="treeview"></ul>
+	</div>
+</div>
diff --git a/vendor/golang.org/x/tools/godoc/static/codewalk.html b/vendor/golang.org/x/tools/godoc/static/codewalk.html
new file mode 100644
index 0000000..0f3d22a
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/codewalk.html
@@ -0,0 +1,56 @@
+<!--
+	Copyright 2010 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.
+-->
+
+<style type='text/css'>@import "/doc/codewalk/codewalk.css";</style>
+<script type="text/javascript" src="/doc/codewalk/codewalk.js"></script>
+
+<div id="codewalk-main">
+  <div class="left" id="code-column">
+    <div id='sizer'></div>
+    <div id="code-area">
+      <div id="code-header" align="center">
+        <a id="code-popout-link" href="" target="_blank">
+          <img title="View code in new window" alt="Pop Out Code" src="/doc/codewalk/popout.png" style="display: block; float: right;"/>
+        </a>
+        <select id="code-selector">
+          {{range .File}}
+          <option value="/doc/codewalk/?fileprint=/{{urlquery .}}">{{html .}}</option>
+          {{end}}
+        </select>
+      </div>
+      <div id="code">
+        <iframe class="code-display" name="code-display" id="code-display"></iframe>
+      </div>
+    </div>
+    <div id="code-options" class="setting">
+      <span>code on <a id="set-code-left" class="selected" href="#">left</a> &bull; <a id="set-code-right" href="#">right</a></span>
+      <span>code width <span id="code-column-width">70%</span></span>
+      <span>filepaths <a id="show-filepaths" class="selected" href="#">shown</a> &bull; <a id="hide-filepaths" href="#">hidden</a></span>
+    </div>
+  </div>
+  <div class="right" id="comment-column">
+    <div id="comment-area">
+      {{range .Step}}
+      <div class="comment first last">
+        <a class="comment-link" href="/doc/codewalk/?fileprint=/{{urlquery .File}}&amp;lo={{urlquery .Lo}}&amp;hi={{urlquery .Hi}}#mark" target="code-display"></a>
+        <div class="comment-title">{{html .Title}}</div>
+        <div class="comment-text">
+	{{with .Err}}
+	ERROR LOADING FILE: {{html .}}<br/><br/>
+	{{end}}
+        {{.XML}}
+        </div>
+        <div class="comment-text file-name"><span class="path-file">{{html .}}</span></div>
+      </div>
+      {{end}}
+    </div>
+    <div id="comment-options" class="setting">
+      <a id="prev-comment" href="#"><span class="hotkey">p</span>revious step</a>
+      &bull;
+      <a id="next-comment" href="#"><span class="hotkey">n</span>ext step</a>
+    </div>
+  </div>
+</div>
diff --git a/vendor/golang.org/x/tools/godoc/static/codewalkdir.html b/vendor/golang.org/x/tools/godoc/static/codewalkdir.html
new file mode 100644
index 0000000..b7674c6
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/codewalkdir.html
@@ -0,0 +1,16 @@
+<!--
+	Copyright 2010 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.
+-->
+
+<table class="layout">
+{{range .}}
+<tr>
+	{{$name_html := html .Name}}
+	<td><a href="{{$name_html}}">{{$name_html}}</a></td>
+	<td width="25">&nbsp;</td>
+	<td>{{html .Title}}</td>
+</tr>
+{{end}}
+</table>
diff --git a/vendor/golang.org/x/tools/godoc/static/dirlist.html b/vendor/golang.org/x/tools/godoc/static/dirlist.html
new file mode 100644
index 0000000..a3e1a2f
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/dirlist.html
@@ -0,0 +1,31 @@
+<!--
+	Copyright 2009 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.
+-->
+
+<p>
+<table class="layout">
+<tr>
+	<th align="left">File</th>
+	<td width="25">&nbsp;</td>
+	<th align="right">Bytes</th>
+	<td width="25">&nbsp;</td>
+	<th align="left">Modified</th>
+</tr>
+<tr>
+	<td><a href="..">..</a></td>
+</tr>
+{{range .}}
+<tr>
+	{{$name_html := fileInfoName . | html}}
+	<td align="left"><a href="{{$name_html}}">{{$name_html}}</a></td>
+	<td></td>
+	<td align="right">{{html .Size}}</td>
+	<td></td>
+	<td align="left">{{fileInfoTime . | html}}</td>
+</tr>
+{{end}}
+
+</table>
+</p>
diff --git a/vendor/golang.org/x/tools/godoc/static/doc.go b/vendor/golang.org/x/tools/godoc/static/doc.go
new file mode 100644
index 0000000..b3d8bcf
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/doc.go
@@ -0,0 +1,8 @@
+// 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 static exports a map of static file content that supports the godoc
+// user interface. The map should be used with the mapfs package, see
+// golang.org/x/tools/godoc/vfs/mapfs.
+package static // import "golang.org/x/tools/godoc/static"
diff --git a/vendor/golang.org/x/tools/godoc/static/error.html b/vendor/golang.org/x/tools/godoc/static/error.html
new file mode 100644
index 0000000..7573aa2
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/error.html
@@ -0,0 +1,9 @@
+<!--
+	Copyright 2009 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.
+-->
+
+<p>
+<span class="alert" style="font-size:120%">{{html .}}</span>
+</p>
diff --git a/vendor/golang.org/x/tools/godoc/static/example.html b/vendor/golang.org/x/tools/godoc/static/example.html
new file mode 100644
index 0000000..1e86b25
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/example.html
@@ -0,0 +1,30 @@
+<div id="example_{{.Name}}" class="toggle">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Example{{example_suffix .Name}}</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Example{{example_suffix .Name}}</span></p>
+		{{with .Doc}}<p>{{html .}}</p>{{end}}
+		{{$output := .Output}}
+		{{with .Play}}
+			<div class="play">
+				<div class="input"><textarea class="code" spellcheck="false">{{html .}}</textarea></div>
+				<div class="output"><pre>{{html $output}}</pre></div>
+				<div class="buttons">
+					<a class="run" title="Run this code [shift-enter]">Run</a>
+					<a class="fmt" title="Format this code">Format</a>
+					{{if not $.GoogleCN}}
+					<a class="share" title="Share this code">Share</a>
+					{{end}}
+				</div>
+			</div>
+		{{else}}
+			<p>Code:</p>
+			<pre class="code">{{.Code}}</pre>
+			{{with .Output}}
+			<p>Output:</p>
+			<pre class="output">{{html .}}</pre>
+			{{end}}
+		{{end}}
+	</div>
+</div>
diff --git a/vendor/golang.org/x/tools/godoc/static/gen.go b/vendor/golang.org/x/tools/godoc/static/gen.go
new file mode 100644
index 0000000..4226821
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/gen.go
@@ -0,0 +1,7 @@
+// 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 static
+
+//go:generate go run makestatic.go
diff --git a/vendor/golang.org/x/tools/godoc/static/godoc.html b/vendor/golang.org/x/tools/godoc/static/godoc.html
new file mode 100644
index 0000000..fb26901
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/godoc.html
@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#375EAB">
+{{with .Tabtitle}}
+  <title>{{html .}} - The Go Programming Language</title>
+{{else}}
+  <title>The Go Programming Language</title>
+{{end}}
+<link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+{{if .SearchBox}}
+<link rel="search" type="application/opensearchdescription+xml" title="godoc" href="/opensearch.xml" />
+{{end}}
+<link rel="stylesheet" href="/lib/godoc/jquery.treeview.css">
+<script type="text/javascript">window.initFuncs = [];</script>
+</head>
+<body>
+
+<div id='lowframe' style="position: fixed; bottom: 0; left: 0; height: 0; width: 100%; border-top: thin solid grey; background-color: white; overflow: auto;">
+...
+</div><!-- #lowframe -->
+
+<div id="topbar"{{if .Title}} class="wide"{{end}}><div class="container">
+<div class="top-heading" id="heading-wide"><a href="/">The Go Programming Language</a></div>
+<div class="top-heading" id="heading-narrow"><a href="/">Go</a></div>
+<a href="#" id="menu-button"><span id="menu-button-arrow">&#9661;</span></a>
+<form method="GET" action="/search">
+<div id="menu">
+<a href="/doc/">Documents</a>
+<a href="/pkg/">Packages</a>
+<a href="/project/">The Project</a>
+<a href="/help/">Help</a>
+{{if not .GoogleCN}}
+<a href="/blog/">Blog</a>
+{{end}}
+{{if .Playground}}
+<a id="playgroundButton" href="http://play.golang.org/" title="Show Go Playground">Play</a>
+{{end}}
+<span class="search-box"><input type="search" id="search" name="q" placeholder="Search" aria-label="Search" required><button type="submit"><span><!-- magnifying glass: --><svg width="24" height="24" viewBox="0 0 24 24"><title>submit search</title><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/><path d="M0 0h24v24H0z" fill="none"/></svg></span></button></span>
+</div>
+</form>
+
+</div></div>
+
+{{if .Playground}}
+<div id="playground" class="play">
+	<div class="input"><textarea class="code" spellcheck="false">package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, 世界")
+}</textarea></div>
+	<div class="output"></div>
+	<div class="buttons">
+		<a class="run" title="Run this code [shift-enter]">Run</a>
+		<a class="fmt" title="Format this code">Format</a>
+		{{if not $.GoogleCN}}
+		<a class="share" title="Share this code">Share</a>
+		{{end}}
+	</div>
+</div>
+{{end}}
+
+<div id="page"{{if .Title}} class="wide"{{end}}>
+<div class="container">
+
+{{if or .Title .SrcPath}}
+  <h1>
+    {{html .Title}}
+    {{html .SrcPath | srcBreadcrumb}}
+  </h1>
+{{end}}
+
+{{with .Subtitle}}
+  <h2>{{html .}}</h2>
+{{end}}
+
+{{with .SrcPath}}
+  <h2>
+    Documentation: {{html . | srcToPkgLink}}
+  </h2>
+{{end}}
+
+{{/* The Table of Contents is automatically inserted in this <div>.
+     Do not delete this <div>. */}}
+<div id="nav"></div>
+
+{{/* Body is HTML-escaped elsewhere */}}
+{{printf "%s" .Body}}
+
+<div id="footer">
+Build version {{html .Version}}.<br>
+Except as <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
+the content of this page is licensed under the
+Creative Commons Attribution 3.0 License,
+and code is licensed under a <a href="/LICENSE">BSD license</a>.<br>
+<a href="/doc/tos.html">Terms of Service</a> |
+<a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
+</div>
+
+</div><!-- .container -->
+</div><!-- #page -->
+
+<!-- TODO(adonovan): load these from <head> using "defer" attribute? -->
+<script type="text/javascript" src="/lib/godoc/jquery.js"></script>
+<script type="text/javascript" src="/lib/godoc/jquery.treeview.js"></script>
+<script type="text/javascript" src="/lib/godoc/jquery.treeview.edit.js"></script>
+
+{{if .Playground}}
+<script type="text/javascript" src="/lib/godoc/playground.js"></script>
+{{end}}
+{{with .Version}}<script>var goVersion = {{printf "%q" .}};</script>{{end}}
+<script type="text/javascript" src="/lib/godoc/godocs.js"></script>
+
+</body>
+</html>
+
diff --git a/vendor/golang.org/x/tools/godoc/static/godocs.js b/vendor/golang.org/x/tools/godoc/static/godocs.js
new file mode 100644
index 0000000..e39ea74
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/godocs.js
@@ -0,0 +1,604 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/* A little code to ease navigation of these documents.
+ *
+ * On window load we:
+ *  + Generate a table of contents (generateTOC)
+ *  + Bind foldable sections (bindToggles)
+ *  + Bind links to foldable sections (bindToggleLinks)
+ */
+
+(function() {
+'use strict';
+
+// Mobile-friendly topbar menu
+$(function() {
+  var menu = $('#menu');
+  var menuButton = $('#menu-button');
+  var menuButtonArrow = $('#menu-button-arrow');
+  menuButton.click(function(event) {
+    menu.toggleClass('menu-visible');
+    menuButtonArrow.toggleClass('vertical-flip');
+    event.preventDefault();
+    return false;
+  });
+});
+
+/* Generates a table of contents: looks for h2 and h3 elements and generates
+ * links. "Decorates" the element with id=="nav" with this table of contents.
+ */
+function generateTOC() {
+  if ($('#manual-nav').length > 0) {
+    return;
+  }
+
+  var nav = $('#nav');
+  if (nav.length === 0) {
+    return;
+  }
+
+  var toc_items = [];
+  $(nav).nextAll('h2, h3').each(function() {
+    var node = this;
+    if (node.id == '')
+      node.id = 'tmp_' + toc_items.length;
+    var link = $('<a/>').attr('href', '#' + node.id).text($(node).text());
+    var item;
+    if ($(node).is('h2')) {
+      item = $('<dt/>');
+    } else { // h3
+      item = $('<dd class="indent"/>');
+    }
+    item.append(link);
+    toc_items.push(item);
+  });
+  if (toc_items.length <= 1) {
+    return;
+  }
+
+  var dl1 = $('<dl/>');
+  var dl2 = $('<dl/>');
+
+  var split_index = (toc_items.length / 2) + 1;
+  if (split_index < 8) {
+    split_index = toc_items.length;
+  }
+  for (var i = 0; i < split_index; i++) {
+    dl1.append(toc_items[i]);
+  }
+  for (/* keep using i */; i < toc_items.length; i++) {
+    dl2.append(toc_items[i]);
+  }
+
+  var tocTable = $('<table class="unruled"/>').appendTo(nav);
+  var tocBody = $('<tbody/>').appendTo(tocTable);
+  var tocRow = $('<tr/>').appendTo(tocBody);
+
+  // 1st column
+  $('<td class="first"/>').appendTo(tocRow).append(dl1);
+  // 2nd column
+  $('<td/>').appendTo(tocRow).append(dl2);
+}
+
+function bindToggle(el) {
+  $('.toggleButton', el).click(function() {
+    if ($(this).closest(".toggle, .toggleVisible")[0] != el) {
+      // Only trigger the closest toggle header.
+      return;
+    }
+
+    if ($(el).is('.toggle')) {
+      $(el).addClass('toggleVisible').removeClass('toggle');
+    } else {
+      $(el).addClass('toggle').removeClass('toggleVisible');
+    }
+  });
+}
+
+function bindToggles(selector) {
+  $(selector).each(function(i, el) {
+    bindToggle(el);
+  });
+}
+
+function bindToggleLink(el, prefix) {
+  $(el).click(function() {
+    var href = $(el).attr('href');
+    var i = href.indexOf('#'+prefix);
+    if (i < 0) {
+      return;
+    }
+    var id = '#' + prefix + href.slice(i+1+prefix.length);
+    if ($(id).is('.toggle')) {
+      $(id).find('.toggleButton').first().click();
+    }
+  });
+}
+function bindToggleLinks(selector, prefix) {
+  $(selector).each(function(i, el) {
+    bindToggleLink(el, prefix);
+  });
+}
+
+function setupDropdownPlayground() {
+  if (!$('#page').is('.wide')) {
+    return; // don't show on front page
+  }
+  var button = $('#playgroundButton');
+  var div = $('#playground');
+  var setup = false;
+  button.toggle(function() {
+    button.addClass('active');
+    div.show();
+    if (setup) {
+      return;
+    }
+    setup = true;
+    playground({
+      'codeEl': $('.code', div),
+      'outputEl': $('.output', div),
+      'runEl': $('.run', div),
+      'fmtEl': $('.fmt', div),
+      'shareEl': $('.share', div),
+      'shareRedirect': '//play.golang.org/p/'
+    });
+  },
+  function() {
+    button.removeClass('active');
+    div.hide();
+  });
+  button.show();
+  $('#menu').css('min-width', '+=60');
+}
+
+function setupInlinePlayground() {
+	'use strict';
+	// Set up playground when each element is toggled.
+	$('div.play').each(function (i, el) {
+		// Set up playground for this example.
+		var setup = function() {
+			var code = $('.code', el);
+			playground({
+				'codeEl':   code,
+				'outputEl': $('.output', el),
+				'runEl':    $('.run', el),
+				'fmtEl':    $('.fmt', el),
+				'shareEl':  $('.share', el),
+				'shareRedirect': '//play.golang.org/p/'
+			});
+
+			// Make the code textarea resize to fit content.
+			var resize = function() {
+				code.height(0);
+				var h = code[0].scrollHeight;
+				code.height(h+20); // minimize bouncing.
+				code.closest('.input').height(h);
+			};
+			code.on('keydown', resize);
+			code.on('keyup', resize);
+			code.keyup(); // resize now.
+		};
+
+		// If example already visible, set up playground now.
+		if ($(el).is(':visible')) {
+			setup();
+			return;
+		}
+
+		// Otherwise, set up playground when example is expanded.
+		var built = false;
+		$(el).closest('.toggle').click(function() {
+			// Only set up once.
+			if (!built) {
+				setup();
+				built = true;
+			}
+		});
+	});
+}
+
+// fixFocus tries to put focus to div#page so that keyboard navigation works.
+function fixFocus() {
+  var page = $('div#page');
+  var topbar = $('div#topbar');
+  page.css('outline', 0); // disable outline when focused
+  page.attr('tabindex', -1); // and set tabindex so that it is focusable
+  $(window).resize(function (evt) {
+    // only focus page when the topbar is at fixed position (that is, it's in
+    // front of page, and keyboard event will go to the former by default.)
+    // by focusing page, keyboard event will go to page so that up/down arrow,
+    // space, etc. will work as expected.
+    if (topbar.css('position') == "fixed")
+      page.focus();
+  }).resize();
+}
+
+function toggleHash() {
+  var id = window.location.hash.substring(1);
+  // Open all of the toggles for a particular hash.
+  var els = $(
+    document.getElementById(id),
+    $('a[name]').filter(function() {
+      return $(this).attr('name') == id;
+    })
+  );
+
+  while (els.length) {
+    for (var i = 0; i < els.length; i++) {
+      var el = $(els[i]);
+      if (el.is('.toggle')) {
+        el.find('.toggleButton').first().click();
+      }
+    }
+    els = el.parent();
+  }
+}
+
+function personalizeInstallInstructions() {
+  var prefix = '?download=';
+  var s = window.location.search;
+  if (s.indexOf(prefix) != 0) {
+    // No 'download' query string; detect "test" instructions from User Agent.
+    if (navigator.platform.indexOf('Win') != -1) {
+      $('.testUnix').hide();
+      $('.testWindows').show();
+    } else {
+      $('.testUnix').show();
+      $('.testWindows').hide();
+    }
+    return;
+  }
+
+  var filename = s.substr(prefix.length);
+  var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+  $('.downloadFilename').text(filename);
+  $('.hideFromDownload').hide();
+  var m = filenameRE.exec(filename);
+  if (!m) {
+    // Can't interpret file name; bail.
+    return;
+  }
+
+  var os = m[3];
+  var ext = m[6];
+  if (ext != 'tar.gz') {
+    $('#tarballInstructions').hide();
+  }
+  if (os != 'darwin' || ext != 'pkg') {
+    $('#darwinPackageInstructions').hide();
+  }
+  if (os != 'windows') {
+    $('#windowsInstructions').hide();
+    $('.testUnix').show();
+    $('.testWindows').hide();
+  } else {
+    if (ext != 'msi') {
+      $('#windowsInstallerInstructions').hide();
+    }
+    if (ext != 'zip') {
+      $('#windowsZipInstructions').hide();
+    }
+    $('.testUnix').hide();
+    $('.testWindows').show();
+  }
+
+  var download = "https://dl.google.com/go/" + filename;
+
+  var message = $('<p class="downloading">'+
+    'Your download should begin shortly. '+
+    'If it does not, click <a>this link</a>.</p>');
+  message.find('a').attr('href', download);
+  message.insertAfter('#nav');
+
+  window.location = download;
+}
+
+function updateVersionTags() {
+  var v = window.goVersion;
+  if (/^go[0-9.]+$/.test(v)) {
+    $(".versionTag").empty().text(v);
+    $(".whereTag").hide();
+  }
+}
+
+function addPermalinks() {
+  function addPermalink(source, parent) {
+    var id = source.attr("id");
+    if (id == "" || id.indexOf("tmp_") === 0) {
+      // Auto-generated permalink.
+      return;
+    }
+    if (parent.find("> .permalink").length) {
+      // Already attached.
+      return;
+    }
+    parent.append(" ").append($("<a class='permalink'>&#xb6;</a>").attr("href", "#" + id));
+  }
+
+  $("#page .container").find("h2[id], h3[id]").each(function() {
+    var el = $(this);
+    addPermalink(el, el);
+  });
+
+  $("#page .container").find("dl[id]").each(function() {
+    var el = $(this);
+    // Add the anchor to the "dt" element.
+    addPermalink(el, el.find("> dt").first());
+  });
+}
+
+$(document).ready(function() {
+  generateTOC();
+  addPermalinks();
+  bindToggles(".toggle");
+  bindToggles(".toggleVisible");
+  bindToggleLinks(".exampleLink", "example_");
+  bindToggleLinks(".overviewLink", "");
+  bindToggleLinks(".examplesLink", "");
+  bindToggleLinks(".indexLink", "");
+  setupDropdownPlayground();
+  setupInlinePlayground();
+  fixFocus();
+  setupTypeInfo();
+  setupCallgraphs();
+  toggleHash();
+  personalizeInstallInstructions();
+  updateVersionTags();
+
+  // godoc.html defines window.initFuncs in the <head> tag, and root.html and
+  // codewalk.js push their on-page-ready functions to the list.
+  // We execute those functions here, to avoid loading jQuery until the page
+  // content is loaded.
+  for (var i = 0; i < window.initFuncs.length; i++) window.initFuncs[i]();
+});
+
+// -- analysis ---------------------------------------------------------
+
+// escapeHTML returns HTML for s, with metacharacters quoted.
+// It is safe for use in both elements and attributes
+// (unlike the "set innerText, read innerHTML" trick).
+function escapeHTML(s) {
+    return s.replace(/&/g, '&amp;').
+             replace(/\"/g, '&quot;').
+             replace(/\'/g, '&#39;').
+             replace(/</g, '&lt;').
+             replace(/>/g, '&gt;');
+}
+
+// makeAnchor returns HTML for an <a> element, given an anchorJSON object.
+function makeAnchor(json) {
+  var html = escapeHTML(json.Text);
+  if (json.Href != "") {
+      html = "<a href='" + escapeHTML(json.Href) + "'>" + html + "</a>";
+  }
+  return html;
+}
+
+function showLowFrame(html) {
+  var lowframe = document.getElementById('lowframe');
+  lowframe.style.height = "200px";
+  lowframe.innerHTML = "<p style='text-align: left;'>" + html + "</p>\n" +
+      "<div onclick='hideLowFrame()' style='position: absolute; top: 0; right: 0; cursor: pointer;'>✘</div>"
+};
+
+document.hideLowFrame = function() {
+  var lowframe = document.getElementById('lowframe');
+  lowframe.style.height = "0px";
+}
+
+// onClickCallers is the onclick action for the 'func' tokens of a
+// function declaration.
+document.onClickCallers = function(index) {
+  var data = document.ANALYSIS_DATA[index]
+  if (data.Callers.length == 1 && data.Callers[0].Sites.length == 1) {
+    document.location = data.Callers[0].Sites[0].Href; // jump to sole caller
+    return;
+  }
+
+  var html = "Callers of <code>" + escapeHTML(data.Callee) + "</code>:<br/>\n";
+  for (var i = 0; i < data.Callers.length; i++) {
+    var caller = data.Callers[i];
+    html += "<code>" + escapeHTML(caller.Func) + "</code>";
+    var sites = caller.Sites;
+    if (sites != null && sites.length > 0) {
+      html += " at line ";
+      for (var j = 0; j < sites.length; j++) {
+        if (j > 0) {
+          html += ", ";
+        }
+        html += "<code>" + makeAnchor(sites[j]) + "</code>";
+      }
+    }
+    html += "<br/>\n";
+  }
+  showLowFrame(html);
+};
+
+// onClickCallees is the onclick action for the '(' token of a function call.
+document.onClickCallees = function(index) {
+  var data = document.ANALYSIS_DATA[index]
+  if (data.Callees.length == 1) {
+    document.location = data.Callees[0].Href; // jump to sole callee
+    return;
+  }
+
+  var html = "Callees of this " + escapeHTML(data.Descr) + ":<br/>\n";
+  for (var i = 0; i < data.Callees.length; i++) {
+    html += "<code>" + makeAnchor(data.Callees[i]) + "</code><br/>\n";
+  }
+  showLowFrame(html);
+};
+
+// onClickTypeInfo is the onclick action for identifiers declaring a named type.
+document.onClickTypeInfo = function(index) {
+  var data = document.ANALYSIS_DATA[index];
+  var html = "Type <code>" + data.Name + "</code>: " +
+  "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<small>(size=" + data.Size + ", align=" + data.Align + ")</small><br/>\n";
+  html += implementsHTML(data);
+  html += methodsetHTML(data);
+  showLowFrame(html);
+};
+
+// implementsHTML returns HTML for the implements relation of the
+// specified TypeInfoJSON value.
+function implementsHTML(info) {
+  var html = "";
+  if (info.ImplGroups != null) {
+    for (var i = 0; i < info.ImplGroups.length; i++) {
+      var group = info.ImplGroups[i];
+      var x = "<code>" + escapeHTML(group.Descr) + "</code> ";
+      for (var j = 0; j < group.Facts.length; j++) {
+        var fact = group.Facts[j];
+        var y = "<code>" + makeAnchor(fact.Other) + "</code>";
+        if (fact.ByKind != null) {
+          html += escapeHTML(fact.ByKind) + " type " + y + " implements " + x;
+        } else {
+          html += x + " implements " + y;
+        }
+        html += "<br/>\n";
+      }
+    }
+  }
+  return html;
+}
+
+
+// methodsetHTML returns HTML for the methodset of the specified
+// TypeInfoJSON value.
+function methodsetHTML(info) {
+  var html = "";
+  if (info.Methods != null) {
+    for (var i = 0; i < info.Methods.length; i++) {
+      html += "<code>" + makeAnchor(info.Methods[i]) + "</code><br/>\n";
+    }
+  }
+  return html;
+}
+
+// onClickComm is the onclick action for channel "make" and "<-"
+// send/receive tokens.
+document.onClickComm = function(index) {
+  var ops = document.ANALYSIS_DATA[index].Ops
+  if (ops.length == 1) {
+    document.location = ops[0].Op.Href; // jump to sole element
+    return;
+  }
+
+  var html = "Operations on this channel:<br/>\n";
+  for (var i = 0; i < ops.length; i++) {
+    html += makeAnchor(ops[i].Op) + " by <code>" + escapeHTML(ops[i].Fn) + "</code><br/>\n";
+  }
+  if (ops.length == 0) {
+    html += "(none)<br/>\n";
+  }
+  showLowFrame(html);
+};
+
+$(window).load(function() {
+    // Scroll window so that first selection is visible.
+    // (This means we don't need to emit id='L%d' spans for each line.)
+    // TODO(adonovan): ideally, scroll it so that it's under the pointer,
+    // but I don't know how to get the pointer y coordinate.
+    var elts = document.getElementsByClassName("selection");
+    if (elts.length > 0) {
+	elts[0].scrollIntoView()
+    }
+});
+
+// setupTypeInfo populates the "Implements" and "Method set" toggle for
+// each type in the package doc.
+function setupTypeInfo() {
+  for (var i in document.ANALYSIS_DATA) {
+    var data = document.ANALYSIS_DATA[i];
+
+    var el = document.getElementById("implements-" + i);
+    if (el != null) {
+      // el != null => data is TypeInfoJSON.
+      if (data.ImplGroups != null) {
+        el.innerHTML = implementsHTML(data);
+        el.parentNode.parentNode.style.display = "block";
+      }
+    }
+
+    var el = document.getElementById("methodset-" + i);
+    if (el != null) {
+      // el != null => data is TypeInfoJSON.
+      if (data.Methods != null) {
+        el.innerHTML = methodsetHTML(data);
+        el.parentNode.parentNode.style.display = "block";
+      }
+    }
+  }
+}
+
+function setupCallgraphs() {
+  if (document.CALLGRAPH == null) {
+    return
+  }
+  document.getElementById("pkg-callgraph").style.display = "block";
+
+  var treeviews = document.getElementsByClassName("treeview");
+  for (var i = 0; i < treeviews.length; i++) {
+    var tree = treeviews[i];
+    if (tree.id == null || tree.id.indexOf("callgraph-") != 0) {
+      continue;
+    }
+    var id = tree.id.substring("callgraph-".length);
+    $(tree).treeview({collapsed: true, animated: "fast"});
+    document.cgAddChildren(tree, tree, [id]);
+    tree.parentNode.parentNode.style.display = "block";
+  }
+}
+
+document.cgAddChildren = function(tree, ul, indices) {
+  if (indices != null) {
+    for (var i = 0; i < indices.length; i++) {
+      var li = cgAddChild(tree, ul, document.CALLGRAPH[indices[i]]);
+      if (i == indices.length - 1) {
+        $(li).addClass("last");
+      }
+    }
+  }
+  $(tree).treeview({animated: "fast", add: ul});
+}
+
+// cgAddChild adds an <li> element for document.CALLGRAPH node cgn to
+// the parent <ul> element ul. tree is the tree's root <ul> element.
+function cgAddChild(tree, ul, cgn) {
+   var li = document.createElement("li");
+   ul.appendChild(li);
+   li.className = "closed";
+
+   var code = document.createElement("code");
+
+   if (cgn.Callees != null) {
+     $(li).addClass("expandable");
+
+     // Event handlers and innerHTML updates don't play nicely together,
+     // hence all this explicit DOM manipulation.
+     var hitarea = document.createElement("div");
+     hitarea.className = "hitarea expandable-hitarea";
+     li.appendChild(hitarea);
+
+     li.appendChild(code);
+
+     var childUL = document.createElement("ul");
+     li.appendChild(childUL);
+     childUL.setAttribute('style', "display: none;");
+
+     var onClick = function() {
+       document.cgAddChildren(tree, childUL, cgn.Callees);
+       hitarea.removeEventListener('click', onClick)
+     };
+     hitarea.addEventListener('click', onClick);
+
+   } else {
+     li.appendChild(code);
+   }
+   code.innerHTML += "&nbsp;" + makeAnchor(cgn.Func);
+   return li
+}
+
+})();
diff --git a/vendor/golang.org/x/tools/godoc/static/images/minus.gif b/vendor/golang.org/x/tools/godoc/static/images/minus.gif
new file mode 100644
index 0000000..47fb7b7
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/minus.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/plus.gif b/vendor/golang.org/x/tools/godoc/static/images/plus.gif
new file mode 100644
index 0000000..6906621
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/plus.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-black-line.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-black-line.gif
new file mode 100644
index 0000000..e549687
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-black-line.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-black.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-black.gif
new file mode 100644
index 0000000..b718d17
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-black.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-default-line.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-default-line.gif
new file mode 100644
index 0000000..37114d3
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-default-line.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-default.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-default.gif
new file mode 100644
index 0000000..76eee60
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-default.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-gray-line.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-gray-line.gif
new file mode 100644
index 0000000..3760044
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-gray-line.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/images/treeview-gray.gif b/vendor/golang.org/x/tools/godoc/static/images/treeview-gray.gif
new file mode 100644
index 0000000..cfdf1ab
Binary files /dev/null and b/vendor/golang.org/x/tools/godoc/static/images/treeview-gray.gif differ
diff --git a/vendor/golang.org/x/tools/godoc/static/implements.html b/vendor/golang.org/x/tools/godoc/static/implements.html
new file mode 100644
index 0000000..5f65b86
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/implements.html
@@ -0,0 +1,9 @@
+<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Implements</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Implements</span></p>
+		<div style="margin-left: 1in" id='implements-{{.Index}}'>...</div>
+	</div>
+</div>
diff --git a/vendor/golang.org/x/tools/godoc/static/jquery.js b/vendor/golang.org/x/tools/godoc/static/jquery.js
new file mode 100644
index 0000000..bc3fbc8
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/jquery.js
@@ -0,0 +1,2 @@
+/*! jQuery v1.8.2 jquery.com | jquery.org/license */
+(function(a,b){function G(a){var b=F[a]={};return p.each(a.split(s),function(a,c){b[c]=!0}),b}function J(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(I,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:+d+""===d?+d:H.test(d)?p.parseJSON(d):d}catch(f){}p.data(a,c,d)}else d=b}return d}function K(a){var b;for(b in a){if(b==="data"&&p.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function ba(){return!1}function bb(){return!0}function bh(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function bi(a,b){do a=a[b];while(a&&a.nodeType!==1);return a}function bj(a,b,c){b=b||0;if(p.isFunction(b))return p.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return p.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=p.grep(a,function(a){return a.nodeType===1});if(be.test(b))return p.filter(b,d,!c);b=p.filter(b,d)}return p.grep(a,function(a,d){return p.inArray(a,b)>=0===c})}function bk(a){var b=bl.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function bC(a,b){return a.getElementsByTagName(b)[0]||a.appendChild(a.ownerDocument.createElement(b))}function bD(a,b){if(b.nodeType!==1||!p.hasData(a))return;var c,d,e,f=p._data(a),g=p._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;d<e;d++)p.event.add(b,c,h[c][d])}g.data&&(g.data=p.extend({},g.data))}function bE(a,b){var c;if(b.nodeType!==1)return;b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase(),c==="object"?(b.parentNode&&(b.outerHTML=a.outerHTML),p.support.html5Clone&&a.innerHTML&&!p.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):c==="input"&&bv.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):c==="option"?b.selected=a.defaultSelected:c==="input"||c==="textarea"?b.defaultValue=a.defaultValue:c==="script"&&b.text!==a.text&&(b.text=a.text),b.removeAttribute(p.expando)}function bF(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bG(a){bv.test(a.type)&&(a.defaultChecked=a.checked)}function bY(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=bW.length;while(e--){b=bW[e]+c;if(b in a)return b}return d}function bZ(a,b){return a=b||a,p.css(a,"display")==="none"||!p.contains(a.ownerDocument,a)}function b$(a,b){var c,d,e=[],f=0,g=a.length;for(;f<g;f++){c=a[f];if(!c.style)continue;e[f]=p._data(c,"olddisplay"),b?(!e[f]&&c.style.display==="none"&&(c.style.display=""),c.style.display===""&&bZ(c)&&(e[f]=p._data(c,"olddisplay",cc(c.nodeName)))):(d=bH(c,"display"),!e[f]&&d!=="none"&&p._data(c,"olddisplay",d))}for(f=0;f<g;f++){c=a[f];if(!c.style)continue;if(!b||c.style.display==="none"||c.style.display==="")c.style.display=b?e[f]||"":"none"}return a}function b_(a,b,c){var d=bP.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function ca(a,b,c,d){var e=c===(d?"border":"content")?4:b==="width"?1:0,f=0;for(;e<4;e+=2)c==="margin"&&(f+=p.css(a,c+bV[e],!0)),d?(c==="content"&&(f-=parseFloat(bH(a,"padding"+bV[e]))||0),c!=="margin"&&(f-=parseFloat(bH(a,"border"+bV[e]+"Width"))||0)):(f+=parseFloat(bH(a,"padding"+bV[e]))||0,c!=="padding"&&(f+=parseFloat(bH(a,"border"+bV[e]+"Width"))||0));return f}function cb(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=!0,f=p.support.boxSizing&&p.css(a,"boxSizing")==="border-box";if(d<=0||d==null){d=bH(a,b);if(d<0||d==null)d=a.style[b];if(bQ.test(d))return d;e=f&&(p.support.boxSizingReliable||d===a.style[b]),d=parseFloat(d)||0}return d+ca(a,b,c||(f?"border":"content"),e)+"px"}function cc(a){if(bS[a])return bS[a];var b=p("<"+a+">").appendTo(e.body),c=b.css("display");b.remove();if(c==="none"||c===""){bI=e.body.appendChild(bI||p.extend(e.createElement("iframe"),{frameBorder:0,width:0,height:0}));if(!bJ||!bI.createElement)bJ=(bI.contentWindow||bI.contentDocument).document,bJ.write("<!doctype html><html><body>"),bJ.close();b=bJ.body.appendChild(bJ.createElement(a)),c=bH(b,"display"),e.body.removeChild(bI)}return bS[a]=c,c}function ci(a,b,c,d){var e;if(p.isArray(b))p.each(b,function(b,e){c||ce.test(a)?d(a,e):ci(a+"["+(typeof e=="object"?b:"")+"]",e,c,d)});else if(!c&&p.type(b)==="object")for(e in b)ci(a+"["+e+"]",b[e],c,d);else d(a,b)}function cz(a){return function(b,c){typeof b!="string"&&(c=b,b="*");var d,e,f,g=b.toLowerCase().split(s),h=0,i=g.length;if(p.isFunction(c))for(;h<i;h++)d=g[h],f=/^\+/.test(d),f&&(d=d.substr(1)||"*"),e=a[d]=a[d]||[],e[f?"unshift":"push"](c)}}function cA(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h,i=a[f],j=0,k=i?i.length:0,l=a===cv;for(;j<k&&(l||!h);j++)h=i[j](c,d,e),typeof h=="string"&&(!l||g[h]?h=b:(c.dataTypes.unshift(h),h=cA(a,c,d,e,h,g)));return(l||!h)&&!g["*"]&&(h=cA(a,c,d,e,"*",g)),h}function cB(a,c){var d,e,f=p.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((f[d]?a:e||(e={}))[d]=c[d]);e&&p.extend(!0,a,e)}function cC(a,c,d){var e,f,g,h,i=a.contents,j=a.dataTypes,k=a.responseFields;for(f in k)f in d&&(c[k[f]]=d[f]);while(j[0]==="*")j.shift(),e===b&&(e=a.mimeType||c.getResponseHeader("content-type"));if(e)for(f in i)if(i[f]&&i[f].test(e)){j.unshift(f);break}if(j[0]in d)g=j[0];else{for(f in d){if(!j[0]||a.converters[f+" "+j[0]]){g=f;break}h||(h=f)}g=g||h}if(g)return g!==j[0]&&j.unshift(g),d[g]}function cD(a,b){var c,d,e,f,g=a.dataTypes.slice(),h=g[0],i={},j=0;a.dataFilter&&(b=a.dataFilter(b,a.dataType));if(g[1])for(c in a.converters)i[c.toLowerCase()]=a.converters[c];for(;e=g[++j];)if(e!=="*"){if(h!=="*"&&h!==e){c=i[h+" "+e]||i["* "+e];if(!c)for(d in i){f=d.split(" ");if(f[1]===e){c=i[h+" "+f[0]]||i["* "+f[0]];if(c){c===!0?c=i[d]:i[d]!==!0&&(e=f[0],g.splice(j--,0,e));break}}}if(c!==!0)if(c&&a["throws"])b=c(b);else try{b=c(b)}catch(k){return{state:"parsererror",error:c?k:"No conversion from "+h+" to "+e}}}h=e}return{state:"success",data:b}}function cL(){try{return new a.XMLHttpRequest}catch(b){}}function cM(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function cU(){return setTimeout(function(){cN=b},0),cN=p.now()}function cV(a,b){p.each(b,function(b,c){var d=(cT[b]||[]).concat(cT["*"]),e=0,f=d.length;for(;e<f;e++)if(d[e].call(a,b,c))return})}function cW(a,b,c){var d,e=0,f=0,g=cS.length,h=p.Deferred().always(function(){delete i.elem}),i=function(){var b=cN||cU(),c=Math.max(0,j.startTime+j.duration-b),d=1-(c/j.duration||0),e=0,f=j.tweens.length;for(;e<f;e++)j.tweens[e].run(d);return h.notifyWith(a,[j,d,c]),d<1&&f?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:p.extend({},b),opts:p.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:cN||cU(),duration:c.duration,tweens:[],createTween:function(b,c,d){var e=p.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(e),e},stop:function(b){var c=0,d=b?j.tweens.length:0;for(;c<d;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;cX(k,j.opts.specialEasing);for(;e<g;e++){d=cS[e].call(j,a,k,j.opts);if(d)return d}return cV(j,k),p.isFunction(j.opts.start)&&j.opts.start.call(a,j),p.fx.timer(p.extend(i,{anim:j,queue:j.opts.queue,elem:a})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}function cX(a,b){var c,d,e,f,g;for(c in a){d=p.camelCase(c),e=b[d],f=a[c],p.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=p.cssHooks[d];if(g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}}function cY(a,b,c){var d,e,f,g,h,i,j,k,l=this,m=a.style,n={},o=[],q=a.nodeType&&bZ(a);c.queue||(j=p._queueHooks(a,"fx"),j.unqueued==null&&(j.unqueued=0,k=j.empty.fire,j.empty.fire=function(){j.unqueued||k()}),j.unqueued++,l.always(function(){l.always(function(){j.unqueued--,p.queue(a,"fx").length||j.empty.fire()})})),a.nodeType===1&&("height"in b||"width"in b)&&(c.overflow=[m.overflow,m.overflowX,m.overflowY],p.css(a,"display")==="inline"&&p.css(a,"float")==="none"&&(!p.support.inlineBlockNeedsLayout||cc(a.nodeName)==="inline"?m.display="inline-block":m.zoom=1)),c.overflow&&(m.overflow="hidden",p.support.shrinkWrapBlocks||l.done(function(){m.overflow=c.overflow[0],m.overflowX=c.overflow[1],m.overflowY=c.overflow[2]}));for(d in b){f=b[d];if(cP.exec(f)){delete b[d];if(f===(q?"hide":"show"))continue;o.push(d)}}g=o.length;if(g){h=p._data(a,"fxshow")||p._data(a,"fxshow",{}),q?p(a).show():l.done(function(){p(a).hide()}),l.done(function(){var b;p.removeData(a,"fxshow",!0);for(b in n)p.style(a,b,n[b])});for(d=0;d<g;d++)e=o[d],i=l.createTween(e,q?h[e]:0),n[e]=h[e]||p.style(a,e),e in h||(h[e]=i.start,q&&(i.end=i.start,i.start=e==="width"||e==="height"?1:0))}}function cZ(a,b,c,d,e){return new cZ.prototype.init(a,b,c,d,e)}function c$(a,b){var c,d={height:a},e=0;b=b?1:0;for(;e<4;e+=2-b)c=bV[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function da(a){return p.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}var c,d,e=a.document,f=a.location,g=a.navigator,h=a.jQuery,i=a.$,j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf,m=Object.prototype.toString,n=Object.prototype.hasOwnProperty,o=String.prototype.trim,p=function(a,b){return new p.fn.init(a,b,c)},q=/[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,r=/\S/,s=/\s+/,t=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,u=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^[\],:{}\s]*$/,x=/(?:^|:|,)(?:\s*\[)+/g,y=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,z=/"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,A=/^-ms-/,B=/-([\da-z])/gi,C=function(a,b){return(b+"").toUpperCase()},D=function(){e.addEventListener?(e.removeEventListener("DOMContentLoaded",D,!1),p.ready()):e.readyState==="complete"&&(e.detachEvent("onreadystatechange",D),p.ready())},E={};p.fn=p.prototype={constructor:p,init:function(a,c,d){var f,g,h,i;if(!a)return this;if(a.nodeType)return this.context=this[0]=a,this.length=1,this;if(typeof a=="string"){a.charAt(0)==="<"&&a.charAt(a.length-1)===">"&&a.length>=3?f=[null,a,null]:f=u.exec(a);if(f&&(f[1]||!c)){if(f[1])return c=c instanceof p?c[0]:c,i=c&&c.nodeType?c.ownerDocument||c:e,a=p.parseHTML(f[1],i,!0),v.test(f[1])&&p.isPlainObject(c)&&this.attr.call(a,c,!0),p.merge(this,a);g=e.getElementById(f[2]);if(g&&g.parentNode){if(g.id!==f[2])return d.find(a);this.length=1,this[0]=g}return this.context=e,this.selector=a,this}return!c||c.jquery?(c||d).find(a):this.constructor(c).find(a)}return p.isFunction(a)?d.ready(a):(a.selector!==b&&(this.selector=a.selector,this.context=a.context),p.makeArray(a,this))},selector:"",jquery:"1.8.2",length:0,size:function(){return this.length},toArray:function(){return k.call(this)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=p.merge(this.constructor(),a);return d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")"),d},each:function(a,b){return p.each(this,a,b)},ready:function(a){return p.ready.promise().done(a),this},eq:function(a){return a=+a,a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(k.apply(this,arguments),"slice",k.call(arguments).join(","))},map:function(a){return this.pushStack(p.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:j,sort:[].sort,splice:[].splice},p.fn.init.prototype=p.fn,p.extend=p.fn.extend=function(){var a,c,d,e,f,g,h=arguments[0]||{},i=1,j=arguments.length,k=!1;typeof h=="boolean"&&(k=h,h=arguments[1]||{},i=2),typeof h!="object"&&!p.isFunction(h)&&(h={}),j===i&&(h=this,--i);for(;i<j;i++)if((a=arguments[i])!=null)for(c in a){d=h[c],e=a[c];if(h===e)continue;k&&e&&(p.isPlainObject(e)||(f=p.isArray(e)))?(f?(f=!1,g=d&&p.isArray(d)?d:[]):g=d&&p.isPlainObject(d)?d:{},h[c]=p.extend(k,g,e)):e!==b&&(h[c]=e)}return h},p.extend({noConflict:function(b){return a.$===p&&(a.$=i),b&&a.jQuery===p&&(a.jQuery=h),p},isReady:!1,readyWait:1,holdReady:function(a){a?p.readyWait++:p.ready(!0)},ready:function(a){if(a===!0?--p.readyWait:p.isReady)return;if(!e.body)return setTimeout(p.ready,1);p.isReady=!0;if(a!==!0&&--p.readyWait>0)return;d.resolveWith(e,[p]),p.fn.trigger&&p(e).trigger("ready").off("ready")},isFunction:function(a){return p.type(a)==="function"},isArray:Array.isArray||function(a){return p.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):E[m.call(a)]||"object"},isPlainObject:function(a){if(!a||p.type(a)!=="object"||a.nodeType||p.isWindow(a))return!1;try{if(a.constructor&&!n.call(a,"constructor")&&!n.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||n.call(a,d)},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},error:function(a){throw new Error(a)},parseHTML:function(a,b,c){var d;return!a||typeof a!="string"?null:(typeof b=="boolean"&&(c=b,b=0),b=b||e,(d=v.exec(a))?[b.createElement(d[1])]:(d=p.buildFragment([a],b,c?null:[]),p.merge([],(d.cacheable?p.clone(d.fragment):d.fragment).childNodes)))},parseJSON:function(b){if(!b||typeof b!="string")return null;b=p.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(w.test(b.replace(y,"@").replace(z,"]").replace(x,"")))return(new Function("return "+b))();p.error("Invalid JSON: "+b)},parseXML:function(c){var d,e;if(!c||typeof c!="string")return null;try{a.DOMParser?(e=new DOMParser,d=e.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(f){d=b}return(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&p.error("Invalid XML: "+c),d},noop:function(){},globalEval:function(b){b&&r.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(A,"ms-").replace(B,C)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,c,d){var e,f=0,g=a.length,h=g===b||p.isFunction(a);if(d){if(h){for(e in a)if(c.apply(a[e],d)===!1)break}else for(;f<g;)if(c.apply(a[f++],d)===!1)break}else if(h){for(e in a)if(c.call(a[e],e,a[e])===!1)break}else for(;f<g;)if(c.call(a[f],f,a[f++])===!1)break;return a},trim:o&&!o.call(" ")?function(a){return a==null?"":o.call(a)}:function(a){return a==null?"":(a+"").replace(t,"")},makeArray:function(a,b){var c,d=b||[];return a!=null&&(c=p.type(a),a.length==null||c==="string"||c==="function"||c==="regexp"||p.isWindow(a)?j.call(d,a):p.merge(d,a)),d},inArray:function(a,b,c){var d;if(b){if(l)return l.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=c.length,e=a.length,f=0;if(typeof d=="number")for(;f<d;f++)a[e++]=c[f];else while(c[f]!==b)a[e++]=c[f++];return a.length=e,a},grep:function(a,b,c){var d,e=[],f=0,g=a.length;c=!!c;for(;f<g;f++)d=!!b(a[f],f),c!==d&&e.push(a[f]);return e},map:function(a,c,d){var e,f,g=[],h=0,i=a.length,j=a instanceof p||i!==b&&typeof i=="number"&&(i>0&&a[0]&&a[i-1]||i===0||p.isArray(a));if(j)for(;h<i;h++)e=c(a[h],h,d),e!=null&&(g[g.length]=e);else for(f in a)e=c(a[f],f,d),e!=null&&(g[g.length]=e);return g.concat.apply([],g)},guid:1,proxy:function(a,c){var d,e,f;return typeof c=="string"&&(d=a[c],c=a,a=d),p.isFunction(a)?(e=k.call(arguments,2),f=function(){return a.apply(c,e.concat(k.call(arguments)))},f.guid=a.guid=a.guid||p.guid++,f):b},access:function(a,c,d,e,f,g,h){var i,j=d==null,k=0,l=a.length;if(d&&typeof d=="object"){for(k in d)p.access(a,c,k,d[k],1,g,e);f=1}else if(e!==b){i=h===b&&p.isFunction(e),j&&(i?(i=c,c=function(a,b,c){return i.call(p(a),c)}):(c.call(a,e),c=null));if(c)for(;k<l;k++)c(a[k],d,i?e.call(a[k],k,c(a[k],d)):e,h);f=1}return f?a:j?c.call(a):l?c(a[0],d):g},now:function(){return(new Date).getTime()}}),p.ready.promise=function(b){if(!d){d=p.Deferred();if(e.readyState==="complete")setTimeout(p.ready,1);else if(e.addEventListener)e.addEventListener("DOMContentLoaded",D,!1),a.addEventListener("load",p.ready,!1);else{e.attachEvent("onreadystatechange",D),a.attachEvent("onload",p.ready);var c=!1;try{c=a.frameElement==null&&e.documentElement}catch(f){}c&&c.doScroll&&function g(){if(!p.isReady){try{c.doScroll("left")}catch(a){return setTimeout(g,50)}p.ready()}}()}}return d.promise(b)},p.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){E["[object "+b+"]"]=b.toLowerCase()}),c=p(e);var F={};p.Callbacks=function(a){a=typeof a=="string"?F[a]||G(a):p.extend({},a);var c,d,e,f,g,h,i=[],j=!a.once&&[],k=function(b){c=a.memory&&b,d=!0,h=f||0,f=0,g=i.length,e=!0;for(;i&&h<g;h++)if(i[h].apply(b[0],b[1])===!1&&a.stopOnFalse){c=!1;break}e=!1,i&&(j?j.length&&k(j.shift()):c?i=[]:l.disable())},l={add:function(){if(i){var b=i.length;(function d(b){p.each(b,function(b,c){var e=p.type(c);e==="function"&&(!a.unique||!l.has(c))?i.push(c):c&&c.length&&e!=="string"&&d(c)})})(arguments),e?g=i.length:c&&(f=b,k(c))}return this},remove:function(){return i&&p.each(arguments,function(a,b){var c;while((c=p.inArray(b,i,c))>-1)i.splice(c,1),e&&(c<=g&&g--,c<=h&&h--)}),this},has:function(a){return p.inArray(a,i)>-1},empty:function(){return i=[],this},disable:function(){return i=j=c=b,this},disabled:function(){return!i},lock:function(){return j=b,c||l.disable(),this},locked:function(){return!j},fireWith:function(a,b){return b=b||[],b=[a,b.slice?b.slice():b],i&&(!d||j)&&(e?j.push(b):k(b)),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!d}};return l},p.extend({Deferred:function(a){var b=[["resolve","done",p.Callbacks("once memory"),"resolved"],["reject","fail",p.Callbacks("once memory"),"rejected"],["notify","progress",p.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return p.Deferred(function(c){p.each(b,function(b,d){var f=d[0],g=a[b];e[d[1]](p.isFunction(g)?function(){var a=g.apply(this,arguments);a&&p.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f+"With"](this===e?c:this,[a])}:c[f])}),a=null}).promise()},promise:function(a){return a!=null?p.extend(a,d):d}},e={};return d.pipe=d.then,p.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[a^1][2].disable,b[2][2].lock),e[f[0]]=g.fire,e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=k.call(arguments),d=c.length,e=d!==1||a&&p.isFunction(a.promise)?d:0,f=e===1?a:p.Deferred(),g=function(a,b,c){return function(d){b[a]=this,c[a]=arguments.length>1?k.call(arguments):d,c===h?f.notifyWith(b,c):--e||f.resolveWith(b,c)}},h,i,j;if(d>1){h=new Array(d),i=new Array(d),j=new Array(d);for(;b<d;b++)c[b]&&p.isFunction(c[b].promise)?c[b].promise().done(g(b,j,c)).fail(f.reject).progress(g(b,i,h)):--e}return e||f.resolveWith(j,c),f.promise()}}),p.support=function(){var b,c,d,f,g,h,i,j,k,l,m,n=e.createElement("div");n.setAttribute("className","t"),n.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",c=n.getElementsByTagName("*"),d=n.getElementsByTagName("a")[0],d.style.cssText="top:1px;float:left;opacity:.5";if(!c||!c.length)return{};f=e.createElement("select"),g=f.appendChild(e.createElement("option")),h=n.getElementsByTagName("input")[0],b={leadingWhitespace:n.firstChild.nodeType===3,tbody:!n.getElementsByTagName("tbody").length,htmlSerialize:!!n.getElementsByTagName("link").length,style:/top/.test(d.getAttribute("style")),hrefNormalized:d.getAttribute("href")==="/a",opacity:/^0.5/.test(d.style.opacity),cssFloat:!!d.style.cssFloat,checkOn:h.value==="on",optSelected:g.selected,getSetAttribute:n.className!=="t",enctype:!!e.createElement("form").enctype,html5Clone:e.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",boxModel:e.compatMode==="CSS1Compat",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,boxSizingReliable:!0,pixelPosition:!1},h.checked=!0,b.noCloneChecked=h.cloneNode(!0).checked,f.disabled=!0,b.optDisabled=!g.disabled;try{delete n.test}catch(o){b.deleteExpando=!1}!n.addEventListener&&n.attachEvent&&n.fireEvent&&(n.attachEvent("onclick",m=function(){b.noCloneEvent=!1}),n.cloneNode(!0).fireEvent("onclick"),n.detachEvent("onclick",m)),h=e.createElement("input"),h.value="t",h.setAttribute("type","radio"),b.radioValue=h.value==="t",h.setAttribute("checked","checked"),h.setAttribute("name","t"),n.appendChild(h),i=e.createDocumentFragment(),i.appendChild(n.lastChild),b.checkClone=i.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=h.checked,i.removeChild(h),i.appendChild(n);if(n.attachEvent)for(k in{submit:!0,change:!0,focusin:!0})j="on"+k,l=j in n,l||(n.setAttribute(j,"return;"),l=typeof n[j]=="function"),b[k+"Bubbles"]=l;return p(function(){var c,d,f,g,h="padding:0;margin:0;border:0;display:block;overflow:hidden;",i=e.getElementsByTagName("body")[0];if(!i)return;c=e.createElement("div"),c.style.cssText="visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px",i.insertBefore(c,i.firstChild),d=e.createElement("div"),c.appendChild(d),d.innerHTML="<table><tr><td></td><td>t</td></tr></table>",f=d.getElementsByTagName("td"),f[0].style.cssText="padding:0;margin:0;border:0;display:none",l=f[0].offsetHeight===0,f[0].style.display="",f[1].style.display="none",b.reliableHiddenOffsets=l&&f[0].offsetHeight===0,d.innerHTML="",d.style.cssText="box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;",b.boxSizing=d.offsetWidth===4,b.doesNotIncludeMarginInBodyOffset=i.offsetTop!==1,a.getComputedStyle&&(b.pixelPosition=(a.getComputedStyle(d,null)||{}).top!=="1%",b.boxSizingReliable=(a.getComputedStyle(d,null)||{width:"4px"}).width==="4px",g=e.createElement("div"),g.style.cssText=d.style.cssText=h,g.style.marginRight=g.style.width="0",d.style.width="1px",d.appendChild(g),b.reliableMarginRight=!parseFloat((a.getComputedStyle(g,null)||{}).marginRight)),typeof d.style.zoom!="undefined"&&(d.innerHTML="",d.style.cssText=h+"width:1px;padding:1px;display:inline;zoom:1",b.inlineBlockNeedsLayout=d.offsetWidth===3,d.style.display="block",d.style.overflow="visible",d.innerHTML="<div></div>",d.firstChild.style.width="5px",b.shrinkWrapBlocks=d.offsetWidth!==3,c.style.zoom=1),i.removeChild(c),c=d=f=g=null}),i.removeChild(n),c=d=f=g=h=i=n=null,b}();var H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,I=/([A-Z])/g;p.extend({cache:{},deletedIds:[],uuid:0,expando:"jQuery"+(p.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){return a=a.nodeType?p.cache[a[p.expando]]:a[p.expando],!!a&&!K(a)},data:function(a,c,d,e){if(!p.acceptData(a))return;var f,g,h=p.expando,i=typeof c=="string",j=a.nodeType,k=j?p.cache:a,l=j?a[h]:a[h]&&h;if((!l||!k[l]||!e&&!k[l].data)&&i&&d===b)return;l||(j?a[h]=l=p.deletedIds.pop()||p.guid++:l=h),k[l]||(k[l]={},j||(k[l].toJSON=p.noop));if(typeof c=="object"||typeof c=="function")e?k[l]=p.extend(k[l],c):k[l].data=p.extend(k[l].data,c);return f=k[l],e||(f.data||(f.data={}),f=f.data),d!==b&&(f[p.camelCase(c)]=d),i?(g=f[c],g==null&&(g=f[p.camelCase(c)])):g=f,g},removeData:function(a,b,c){if(!p.acceptData(a))return;var d,e,f,g=a.nodeType,h=g?p.cache:a,i=g?a[p.expando]:p.expando;if(!h[i])return;if(b){d=c?h[i]:h[i].data;if(d){p.isArray(b)||(b in d?b=[b]:(b=p.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,f=b.length;e<f;e++)delete d[b[e]];if(!(c?K:p.isEmptyObject)(d))return}}if(!c){delete h[i].data;if(!K(h[i]))return}g?p.cleanData([a],!0):p.support.deleteExpando||h!=h.window?delete h[i]:h[i]=null},_data:function(a,b,c){return p.data(a,b,c,!0)},acceptData:function(a){var b=a.nodeName&&p.noData[a.nodeName.toLowerCase()];return!b||b!==!0&&a.getAttribute("classid")===b}}),p.fn.extend({data:function(a,c){var d,e,f,g,h,i=this[0],j=0,k=null;if(a===b){if(this.length){k=p.data(i);if(i.nodeType===1&&!p._data(i,"parsedAttrs")){f=i.attributes;for(h=f.length;j<h;j++)g=f[j].name,g.indexOf("data-")||(g=p.camelCase(g.substring(5)),J(i,g,k[g]));p._data(i,"parsedAttrs",!0)}}return k}return typeof a=="object"?this.each(function(){p.data(this,a)}):(d=a.split(".",2),d[1]=d[1]?"."+d[1]:"",e=d[1]+"!",p.access(this,function(c){if(c===b)return k=this.triggerHandler("getData"+e,[d[0]]),k===b&&i&&(k=p.data(i,a),k=J(i,a,k)),k===b&&d[1]?this.data(d[0]):k;d[1]=c,this.each(function(){var b=p(this);b.triggerHandler("setData"+e,d),p.data(this,a,c),b.triggerHandler("changeData"+e,d)})},null,c,arguments.length>1,null,!1))},removeData:function(a){return this.each(function(){p.removeData(this,a)})}}),p.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=p._data(a,b),c&&(!d||p.isArray(c)?d=p._data(a,b,p.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=p.queue(a,b),d=c.length,e=c.shift(),f=p._queueHooks(a,b),g=function(){p.dequeue(a,b)};e==="inprogress"&&(e=c.shift(),d--),e&&(b==="fx"&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return p._data(a,c)||p._data(a,c,{empty:p.Callbacks("once memory").add(function(){p.removeData(a,b+"queue",!0),p.removeData(a,c,!0)})})}}),p.fn.extend({queue:function(a,c){var d=2;return typeof a!="string"&&(c=a,a="fx",d--),arguments.length<d?p.queue(this[0],a):c===b?this:this.each(function(){var b=p.queue(this,a,c);p._queueHooks(this,a),a==="fx"&&b[0]!=="inprogress"&&p.dequeue(this,a)})},dequeue:function(a){return this.each(function(){p.dequeue(this,a)})},delay:function(a,b){return a=p.fx?p.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){var d,e=1,f=p.Deferred(),g=this,h=this.length,i=function(){--e||f.resolveWith(g,[g])};typeof a!="string"&&(c=a,a=b),a=a||"fx";while(h--)d=p._data(g[h],a+"queueHooks"),d&&d.empty&&(e++,d.empty.add(i));return i(),f.promise(c)}});var L,M,N,O=/[\t\r\n]/g,P=/\r/g,Q=/^(?:button|input)$/i,R=/^(?:button|input|object|select|textarea)$/i,S=/^a(?:rea|)$/i,T=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,U=p.support.getSetAttribute;p.fn.extend({attr:function(a,b){return p.access(this,p.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){p.removeAttr(this,a)})},prop:function(a,b){return p.access(this,p.prop,a,b,arguments.length>1)},removeProp:function(a){return a=p.propFix[a]||a,this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,f,g,h;if(p.isFunction(a))return this.each(function(b){p(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(s);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{f=" "+e.className+" ";for(g=0,h=b.length;g<h;g++)f.indexOf(" "+b[g]+" ")<0&&(f+=b[g]+" ");e.className=p.trim(f)}}}return this},removeClass:function(a){var c,d,e,f,g,h,i;if(p.isFunction(a))return this.each(function(b){p(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(s);for(h=0,i=this.length;h<i;h++){e=this[h];if(e.nodeType===1&&e.className){d=(" "+e.className+" ").replace(O," ");for(f=0,g=c.length;f<g;f++)while(d.indexOf(" "+c[f]+" ")>=0)d=d.replace(" "+c[f]+" "," ");e.className=a?p.trim(d):""}}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";return p.isFunction(a)?this.each(function(c){p(this).toggleClass(a.call(this,c,this.className,b),b)}):this.each(function(){if(c==="string"){var e,f=0,g=p(this),h=b,i=a.split(s);while(e=i[f++])h=d?h:!g.hasClass(e),g[h?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&p._data(this,"__className__",this.className),this.className=this.className||a===!1?"":p._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(O," ").indexOf(b)>=0)return!0;return!1},val:function(a){var c,d,e,f=this[0];if(!arguments.length){if(f)return c=p.valHooks[f.type]||p.valHooks[f.nodeName.toLowerCase()],c&&"get"in c&&(d=c.get(f,"value"))!==b?d:(d=f.value,typeof d=="string"?d.replace(P,""):d==null?"":d);return}return e=p.isFunction(a),this.each(function(d){var f,g=p(this);if(this.nodeType!==1)return;e?f=a.call(this,d,g.val()):f=a,f==null?f="":typeof f=="number"?f+="":p.isArray(f)&&(f=p.map(f,function(a){return a==null?"":a+""})),c=p.valHooks[this.type]||p.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,f,"value")===b)this.value=f})}}),p.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,f=a.selectedIndex,g=[],h=a.options,i=a.type==="select-one";if(f<0)return null;c=i?f:0,d=i?f+1:h.length;for(;c<d;c++){e=h[c];if(e.selected&&(p.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!p.nodeName(e.parentNode,"optgroup"))){b=p(e).val();if(i)return b;g.push(b)}}return i&&!g.length&&h.length?p(h[f]).val():g},set:function(a,b){var c=p.makeArray(b);return p(a).find("option").each(function(){this.selected=p.inArray(p(this).val(),c)>=0}),c.length||(a.selectedIndex=-1),c}}},attrFn:{},attr:function(a,c,d,e){var f,g,h,i=a.nodeType;if(!a||i===3||i===8||i===2)return;if(e&&p.isFunction(p.fn[c]))return p(a)[c](d);if(typeof a.getAttribute=="undefined")return p.prop(a,c,d);h=i!==1||!p.isXMLDoc(a),h&&(c=c.toLowerCase(),g=p.attrHooks[c]||(T.test(c)?M:L));if(d!==b){if(d===null){p.removeAttr(a,c);return}return g&&"set"in g&&h&&(f=g.set(a,d,c))!==b?f:(a.setAttribute(c,d+""),d)}return g&&"get"in g&&h&&(f=g.get(a,c))!==null?f:(f=a.getAttribute(c),f===null?b:f)},removeAttr:function(a,b){var c,d,e,f,g=0;if(b&&a.nodeType===1){d=b.split(s);for(;g<d.length;g++)e=d[g],e&&(c=p.propFix[e]||e,f=T.test(e),f||p.attr(a,e,""),a.removeAttribute(U?e:c),f&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(Q.test(a.nodeName)&&a.parentNode)p.error("type property can't be changed");else if(!p.support.radioValue&&b==="radio"&&p.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}},value:{get:function(a,b){return L&&p.nodeName(a,"button")?L.get(a,b):b in a?a.value:null},set:function(a,b,c){if(L&&p.nodeName(a,"button"))return L.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,f,g,h=a.nodeType;if(!a||h===3||h===8||h===2)return;return g=h!==1||!p.isXMLDoc(a),g&&(c=p.propFix[c]||c,f=p.propHooks[c]),d!==b?f&&"set"in f&&(e=f.set(a,d,c))!==b?e:a[c]=d:f&&"get"in f&&(e=f.get(a,c))!==null?e:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):R.test(a.nodeName)||S.test(a.nodeName)&&a.href?0:b}}}}),M={get:function(a,c){var d,e=p.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;return b===!1?p.removeAttr(a,c):(d=p.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase())),c}},U||(N={name:!0,id:!0,coords:!0},L=p.valHooks.button={get:function(a,c){var d;return d=a.getAttributeNode(c),d&&(N[c]?d.value!=="":d.specified)?d.value:b},set:function(a,b,c){var d=a.getAttributeNode(c);return d||(d=e.createAttribute(c),a.setAttributeNode(d)),d.value=b+""}},p.each(["width","height"],function(a,b){p.attrHooks[b]=p.extend(p.attrHooks[b],{set:function(a,c){if(c==="")return a.setAttribute(b,"auto"),c}})}),p.attrHooks.contenteditable={get:L.get,set:function(a,b,c){b===""&&(b="false"),L.set(a,b,c)}}),p.support.hrefNormalized||p.each(["href","src","width","height"],function(a,c){p.attrHooks[c]=p.extend(p.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),p.support.style||(p.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=b+""}}),p.support.optSelected||(p.propHooks.selected=p.extend(p.propHooks.selected,{get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}})),p.support.enctype||(p.propFix.enctype="encoding"),p.support.checkOn||p.each(["radio","checkbox"],function(){p.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),p.each(["radio","checkbox"],function(){p.valHooks[this]=p.extend(p.valHooks[this],{set:function(a,b){if(p.isArray(b))return a.checked=p.inArray(p(a).val(),b)>=0}})});var V=/^(?:textarea|input|select)$/i,W=/^([^\.]*|)(?:\.(.+)|)$/,X=/(?:^|\s)hover(\.\S+|)\b/,Y=/^key/,Z=/^(?:mouse|contextmenu)|click/,$=/^(?:focusinfocus|focusoutblur)$/,_=function(a){return p.event.special.hover?a:a.replace(X,"mouseenter$1 mouseleave$1")};p.event={add:function(a,c,d,e,f){var g,h,i,j,k,l,m,n,o,q,r;if(a.nodeType===3||a.nodeType===8||!c||!d||!(g=p._data(a)))return;d.handler&&(o=d,d=o.handler,f=o.selector),d.guid||(d.guid=p.guid++),i=g.events,i||(g.events=i={}),h=g.handle,h||(g.handle=h=function(a){return typeof p!="undefined"&&(!a||p.event.triggered!==a.type)?p.event.dispatch.apply(h.elem,arguments):b},h.elem=a),c=p.trim(_(c)).split(" ");for(j=0;j<c.length;j++){k=W.exec(c[j])||[],l=k[1],m=(k[2]||"").split(".").sort(),r=p.event.special[l]||{},l=(f?r.delegateType:r.bindType)||l,r=p.event.special[l]||{},n=p.extend({type:l,origType:k[1],data:e,handler:d,guid:d.guid,selector:f,needsContext:f&&p.expr.match.needsContext.test(f),namespace:m.join(".")},o),q=i[l];if(!q){q=i[l]=[],q.delegateCount=0;if(!r.setup||r.setup.call(a,e,m,h)===!1)a.addEventListener?a.addEventListener(l,h,!1):a.attachEvent&&a.attachEvent("on"+l,h)}r.add&&(r.add.call(a,n),n.handler.guid||(n.handler.guid=d.guid)),f?q.splice(q.delegateCount++,0,n):q.push(n),p.event.global[l]=!0}a=null},global:{},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,q,r=p.hasData(a)&&p._data(a);if(!r||!(m=r.events))return;b=p.trim(_(b||"")).split(" ");for(f=0;f<b.length;f++){g=W.exec(b[f])||[],h=i=g[1],j=g[2];if(!h){for(h in m)p.event.remove(a,h+b[f],c,d,!0);continue}n=p.event.special[h]||{},h=(d?n.delegateType:n.bindType)||h,o=m[h]||[],k=o.length,j=j?new RegExp("(^|\\.)"+j.split(".").sort().join("\\.(?:.*\\.|)")+"(\\.|$)"):null;for(l=0;l<o.length;l++)q=o[l],(e||i===q.origType)&&(!c||c.guid===q.guid)&&(!j||j.test(q.namespace))&&(!d||d===q.selector||d==="**"&&q.selector)&&(o.splice(l--,1),q.selector&&o.delegateCount--,n.remove&&n.remove.call(a,q));o.length===0&&k!==o.length&&((!n.teardown||n.teardown.call(a,j,r.handle)===!1)&&p.removeEvent(a,h,r.handle),delete m[h])}p.isEmptyObject(m)&&(delete r.handle,p.removeData(a,"events",!0))},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,f,g){if(!f||f.nodeType!==3&&f.nodeType!==8){var h,i,j,k,l,m,n,o,q,r,s=c.type||c,t=[];if($.test(s+p.event.triggered))return;s.indexOf("!")>=0&&(s=s.slice(0,-1),i=!0),s.indexOf(".")>=0&&(t=s.split("."),s=t.shift(),t.sort());if((!f||p.event.customEvent[s])&&!p.event.global[s])return;c=typeof c=="object"?c[p.expando]?c:new p.Event(s,c):new p.Event(s),c.type=s,c.isTrigger=!0,c.exclusive=i,c.namespace=t.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,m=s.indexOf(":")<0?"on"+s:"";if(!f){h=p.cache;for(j in h)h[j].events&&h[j].events[s]&&p.event.trigger(c,d,h[j].handle.elem,!0);return}c.result=b,c.target||(c.target=f),d=d!=null?p.makeArray(d):[],d.unshift(c),n=p.event.special[s]||{};if(n.trigger&&n.trigger.apply(f,d)===!1)return;q=[[f,n.bindType||s]];if(!g&&!n.noBubble&&!p.isWindow(f)){r=n.delegateType||s,k=$.test(r+s)?f:f.parentNode;for(l=f;k;k=k.parentNode)q.push([k,r]),l=k;l===(f.ownerDocument||e)&&q.push([l.defaultView||l.parentWindow||a,r])}for(j=0;j<q.length&&!c.isPropagationStopped();j++)k=q[j][0],c.type=q[j][1],o=(p._data(k,"events")||{})[c.type]&&p._data(k,"handle"),o&&o.apply(k,d),o=m&&k[m],o&&p.acceptData(k)&&o.apply&&o.apply(k,d)===!1&&c.preventDefault();return c.type=s,!g&&!c.isDefaultPrevented()&&(!n._default||n._default.apply(f.ownerDocument,d)===!1)&&(s!=="click"||!p.nodeName(f,"a"))&&p.acceptData(f)&&m&&f[s]&&(s!=="focus"&&s!=="blur"||c.target.offsetWidth!==0)&&!p.isWindow(f)&&(l=f[m],l&&(f[m]=null),p.event.triggered=s,f[s](),p.event.triggered=b,l&&(f[m]=l)),c.result}return},dispatch:function(c){c=p.event.fix(c||a.event);var d,e,f,g,h,i,j,l,m,n,o=(p._data(this,"events")||{})[c.type]||[],q=o.delegateCount,r=k.call(arguments),s=!c.exclusive&&!c.namespace,t=p.event.special[c.type]||{},u=[];r[0]=c,c.delegateTarget=this;if(t.preDispatch&&t.preDispatch.call(this,c)===!1)return;if(q&&(!c.button||c.type!=="click"))for(f=c.target;f!=this;f=f.parentNode||this)if(f.disabled!==!0||c.type!=="click"){h={},j=[];for(d=0;d<q;d++)l=o[d],m=l.selector,h[m]===b&&(h[m]=l.needsContext?p(m,this).index(f)>=0:p.find(m,this,null,[f]).length),h[m]&&j.push(l);j.length&&u.push({elem:f,matches:j})}o.length>q&&u.push({elem:this,matches:o.slice(q)});for(d=0;d<u.length&&!c.isPropagationStopped();d++){i=u[d],c.currentTarget=i.elem;for(e=0;e<i.matches.length&&!c.isImmediatePropagationStopped();e++){l=i.matches[e];if(s||!c.namespace&&!l.namespace||c.namespace_re&&c.namespace_re.test(l.namespace))c.data=l.data,c.handleObj=l,g=((p.event.special[l.origType]||{}).handle||l.handler).apply(i.elem,r),g!==b&&(c.result=g,g===!1&&(c.preventDefault(),c.stopPropagation()))}}return t.postDispatch&&t.postDispatch.call(this,c),c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,c){var d,f,g,h=c.button,i=c.fromElement;return a.pageX==null&&c.clientX!=null&&(d=a.target.ownerDocument||e,f=d.documentElement,g=d.body,a.pageX=c.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=c.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?c.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0),a}},fix:function(a){if(a[p.expando])return a;var b,c,d=a,f=p.event.fixHooks[a.type]||{},g=f.props?this.props.concat(f.props):this.props;a=p.Event(d);for(b=g.length;b;)c=g[--b],a[c]=d[c];return a.target||(a.target=d.srcElement||e),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,f.filter?f.filter(a,d):a},special:{load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){p.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=p.extend(new p.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?p.event.trigger(e,null,b):p.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},p.event.handle=p.event.dispatch,p.removeEvent=e.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]=="undefined"&&(a[d]=null),a.detachEvent(d,c))},p.Event=function(a,b){if(this instanceof p.Event)a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?bb:ba):this.type=a,b&&p.extend(this,b),this.timeStamp=a&&a.timeStamp||p.now(),this[p.expando]=!0;else return new p.Event(a,b)},p.Event.prototype={preventDefault:function(){this.isDefaultPrevented=bb;var a=this.originalEvent;if(!a)return;a.preventDefault?a.preventDefault():a.returnValue=!1},stopPropagation:function(){this.isPropagationStopped=bb;var a=this.originalEvent;if(!a)return;a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()},isDefaultPrevented:ba,isPropagationStopped:ba,isImmediatePropagationStopped:ba},p.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){p.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj,g=f.selector;if(!e||e!==d&&!p.contains(d,e))a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b;return c}}}),p.support.submitBubbles||(p.event.special.submit={setup:function(){if(p.nodeName(this,"form"))return!1;p.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=p.nodeName(c,"input")||p.nodeName(c,"button")?c.form:b;d&&!p._data(d,"_submit_attached")&&(p.event.add(d,"submit._submit",function(a){a._submit_bubble=!0}),p._data(d,"_submit_attached",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&p.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){if(p.nodeName(this,"form"))return!1;p.event.remove(this,"._submit")}}),p.support.changeBubbles||(p.event.special.change={setup:function(){if(V.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")p.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),p.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),p.event.simulate("change",this,a,!0)});return!1}p.event.add(this,"beforeactivate._change",function(a){var b=a.target;V.test(b.nodeName)&&!p._data(b,"_change_attached")&&(p.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&p.event.simulate("change",this.parentNode,a,!0)}),p._data(b,"_change_attached",!0))})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){return p.event.remove(this,"._change"),!V.test(this.nodeName)}}),p.support.focusinBubbles||p.each({focus:"focusin",blur:"focusout"},function(a,b){var c=0,d=function(a){p.event.simulate(b,a.target,p.event.fix(a),!0)};p.event.special[b]={setup:function(){c++===0&&e.addEventListener(a,d,!0)},teardown:function(){--c===0&&e.removeEventListener(a,d,!0)}}}),p.fn.extend({on:function(a,c,d,e,f){var g,h;if(typeof a=="object"){typeof c!="string"&&(d=d||c,c=b);for(h in a)this.on(h,c,d,a[h],f);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=ba;else if(!e)return this;return f===1&&(g=e,e=function(a){return p().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=p.guid++)),this.each(function(){p.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,c,d){var e,f;if(a&&a.preventDefault&&a.handleObj)return e=a.handleObj,p(a.delegateTarget).off(e.namespace?e.origType+"."+e.namespace:e.origType,e.selector,e.handler),this;if(typeof a=="object"){for(f in a)this.off(f,c,a[f]);return this}if(c===!1||typeof c=="function")d=c,c=b;return d===!1&&(d=ba),this.each(function(){p.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){return p(this.context).on(a,this.selector,b,c),this},die:function(a,b){return p(this.context).off(a,this.selector||"**",b),this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length===1?this.off(a,"**"):this.off(b,a||"**",c)},trigger:function(a,b){return this.each(function(){p.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return p.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||p.guid++,d=0,e=function(c){var e=(p._data(this,"lastToggle"+a.guid)||0)%d;return p._data(this,"lastToggle"+a.guid,e+1),c.preventDefault(),b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),p.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){p.fn[b]=function(a,c){return c==null&&(c=a,a=null),arguments.length>0?this.on(b,null,a,c):this.trigger(b)},Y.test(b)&&(p.event.fixHooks[b]=p.event.keyHooks),Z.test(b)&&(p.event.fixHooks[b]=p.event.mouseHooks)}),function(a,b){function bc(a,b,c,d){c=c||[],b=b||r;var e,f,i,j,k=b.nodeType;if(!a||typeof a!="string")return c;if(k!==1&&k!==9)return[];i=g(b);if(!i&&!d)if(e=P.exec(a))if(j=e[1]){if(k===9){f=b.getElementById(j);if(!f||!f.parentNode)return c;if(f.id===j)return c.push(f),c}else if(b.ownerDocument&&(f=b.ownerDocument.getElementById(j))&&h(b,f)&&f.id===j)return c.push(f),c}else{if(e[2])return w.apply(c,x.call(b.getElementsByTagName(a),0)),c;if((j=e[3])&&_&&b.getElementsByClassName)return w.apply(c,x.call(b.getElementsByClassName(j),0)),c}return bp(a.replace(L,"$1"),b,c,d,i)}function bd(a){return function(b){var c=b.nodeName.toLowerCase();return c==="input"&&b.type===a}}function be(a){return function(b){var c=b.nodeName.toLowerCase();return(c==="input"||c==="button")&&b.type===a}}function bf(a){return z(function(b){return b=+b,z(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function bg(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}function bh(a,b){var c,d,f,g,h,i,j,k=C[o][a];if(k)return b?0:k.slice(0);h=a,i=[],j=e.preFilter;while(h){if(!c||(d=M.exec(h)))d&&(h=h.slice(d[0].length)),i.push(f=[]);c=!1;if(d=N.exec(h))f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=d[0].replace(L," ");for(g in e.filter)(d=W[g].exec(h))&&(!j[g]||(d=j[g](d,r,!0)))&&(f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=g,c.matches=d);if(!c)break}return b?h.length:h?bc.error(a):C(a,i).slice(0)}function bi(a,b,d){var e=b.dir,f=d&&b.dir==="parentNode",g=u++;return b.first?function(b,c,d){while(b=b[e])if(f||b.nodeType===1)return a(b,c,d)}:function(b,d,h){if(!h){var i,j=t+" "+g+" ",k=j+c;while(b=b[e])if(f||b.nodeType===1){if((i=b[o])===k)return b.sizset;if(typeof i=="string"&&i.indexOf(j)===0){if(b.sizset)return b}else{b[o]=k;if(a(b,d,h))return b.sizset=!0,b;b.sizset=!1}}}else while(b=b[e])if(f||b.nodeType===1)if(a(b,d,h))return b}}function bj(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function bk(a,b,c,d,e){var f,g=[],h=0,i=a.length,j=b!=null;for(;h<i;h++)if(f=a[h])if(!c||c(f,d,e))g.push(f),j&&b.push(h);return g}function bl(a,b,c,d,e,f){return d&&!d[o]&&(d=bl(d)),e&&!e[o]&&(e=bl(e,f)),z(function(f,g,h,i){if(f&&e)return;var j,k,l,m=[],n=[],o=g.length,p=f||bo(b||"*",h.nodeType?[h]:h,[],f),q=a&&(f||!b)?bk(p,m,a,h,i):p,r=c?e||(f?a:o||d)?[]:g:q;c&&c(q,r,h,i);if(d){l=bk(r,n),d(l,[],h,i),j=l.length;while(j--)if(k=l[j])r[n[j]]=!(q[n[j]]=k)}if(f){j=a&&r.length;while(j--)if(k=r[j])f[m[j]]=!(g[m[j]]=k)}else r=bk(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):w.apply(g,r)})}function bm(a){var b,c,d,f=a.length,g=e.relative[a[0].type],h=g||e.relative[" "],i=g?1:0,j=bi(function(a){return a===b},h,!0),k=bi(function(a){return y.call(b,a)>-1},h,!0),m=[function(a,c,d){return!g&&(d||c!==l)||((b=c).nodeType?j(a,c,d):k(a,c,d))}];for(;i<f;i++)if(c=e.relative[a[i].type])m=[bi(bj(m),c)];else{c=e.filter[a[i].type].apply(null,a[i].matches);if(c[o]){d=++i;for(;d<f;d++)if(e.relative[a[d].type])break;return bl(i>1&&bj(m),i>1&&a.slice(0,i-1).join("").replace(L,"$1"),c,i<d&&bm(a.slice(i,d)),d<f&&bm(a=a.slice(d)),d<f&&a.join(""))}m.push(c)}return bj(m)}function bn(a,b){var d=b.length>0,f=a.length>0,g=function(h,i,j,k,m){var n,o,p,q=[],s=0,u="0",x=h&&[],y=m!=null,z=l,A=h||f&&e.find.TAG("*",m&&i.parentNode||i),B=t+=z==null?1:Math.E;y&&(l=i!==r&&i,c=g.el);for(;(n=A[u])!=null;u++){if(f&&n){for(o=0;p=a[o];o++)if(p(n,i,j)){k.push(n);break}y&&(t=B,c=++g.el)}d&&((n=!p&&n)&&s--,h&&x.push(n))}s+=u;if(d&&u!==s){for(o=0;p=b[o];o++)p(x,q,i,j);if(h){if(s>0)while(u--)!x[u]&&!q[u]&&(q[u]=v.call(k));q=bk(q)}w.apply(k,q),y&&!h&&q.length>0&&s+b.length>1&&bc.uniqueSort(k)}return y&&(t=B,l=z),x};return g.el=0,d?z(g):g}function bo(a,b,c,d){var e=0,f=b.length;for(;e<f;e++)bc(a,b[e],c,d);return c}function bp(a,b,c,d,f){var g,h,j,k,l,m=bh(a),n=m.length;if(!d&&m.length===1){h=m[0]=m[0].slice(0);if(h.length>2&&(j=h[0]).type==="ID"&&b.nodeType===9&&!f&&e.relative[h[1].type]){b=e.find.ID(j.matches[0].replace(V,""),b,f)[0];if(!b)return c;a=a.slice(h.shift().length)}for(g=W.POS.test(a)?-1:h.length-1;g>=0;g--){j=h[g];if(e.relative[k=j.type])break;if(l=e.find[k])if(d=l(j.matches[0].replace(V,""),R.test(h[0].type)&&b.parentNode||b,f)){h.splice(g,1),a=d.length&&h.join("");if(!a)return w.apply(c,x.call(d,0)),c;break}}}return i(a,m)(d,b,f,c,R.test(a)),c}function bq(){}var c,d,e,f,g,h,i,j,k,l,m=!0,n="undefined",o=("sizcache"+Math.random()).replace(".",""),q=String,r=a.document,s=r.documentElement,t=0,u=0,v=[].pop,w=[].push,x=[].slice,y=[].indexOf||function(a){var b=0,c=this.length;for(;b<c;b++)if(this[b]===a)return b;return-1},z=function(a,b){return a[o]=b==null||b,a},A=function(){var a={},b=[];return z(function(c,d){return b.push(c)>e.cacheLength&&delete a[b.shift()],a[c]=d},a)},B=A(),C=A(),D=A(),E="[\\x20\\t\\r\\n\\f]",F="(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",G=F.replace("w","w#"),H="([*^$|!~]?=)",I="\\["+E+"*("+F+")"+E+"*(?:"+H+E+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+G+")|)|)"+E+"*\\]",J=":("+F+")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:"+I+")|[^:]|\\\\.)*|.*))\\)|)",K=":(even|odd|eq|gt|lt|nth|first|last)(?:\\("+E+"*((?:-\\d)?\\d*)"+E+"*\\)|)(?=[^-]|$)",L=new RegExp("^"+E+"+|((?:^|[^\\\\])(?:\\\\.)*)"+E+"+$","g"),M=new RegExp("^"+E+"*,"+E+"*"),N=new RegExp("^"+E+"*([\\x20\\t\\r\\n\\f>+~])"+E+"*"),O=new RegExp(J),P=/^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,Q=/^:not/,R=/[\x20\t\r\n\f]*[+~]/,S=/:not\($/,T=/h\d/i,U=/input|select|textarea|button/i,V=/\\(?!\\)/g,W={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),NAME:new RegExp("^\\[name=['\"]?("+F+")['\"]?\\]"),TAG:new RegExp("^("+F.replace("w","w*")+")"),ATTR:new RegExp("^"+I),PSEUDO:new RegExp("^"+J),POS:new RegExp(K,"i"),CHILD:new RegExp("^:(only|nth|first|last)-child(?:\\("+E+"*(even|odd|(([+-]|)(\\d*)n|)"+E+"*(?:([+-]|)"+E+"*(\\d+)|))"+E+"*\\)|)","i"),needsContext:new RegExp("^"+E+"*[>+~]|"+K,"i")},X=function(a){var b=r.createElement("div");try{return a(b)}catch(c){return!1}finally{b=null}},Y=X(function(a){return a.appendChild(r.createComment("")),!a.getElementsByTagName("*").length}),Z=X(function(a){return a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!==n&&a.firstChild.getAttribute("href")==="#"}),$=X(function(a){a.innerHTML="<select></select>";var b=typeof a.lastChild.getAttribute("multiple");return b!=="boolean"&&b!=="string"}),_=X(function(a){return a.innerHTML="<div class='hidden e'></div><div class='hidden'></div>",!a.getElementsByClassName||!a.getElementsByClassName("e").length?!1:(a.lastChild.className="e",a.getElementsByClassName("e").length===2)}),ba=X(function(a){a.id=o+0,a.innerHTML="<a name='"+o+"'></a><div name='"+o+"'></div>",s.insertBefore(a,s.firstChild);var b=r.getElementsByName&&r.getElementsByName(o).length===2+r.getElementsByName(o+0).length;return d=!r.getElementById(o),s.removeChild(a),b});try{x.call(s.childNodes,0)[0].nodeType}catch(bb){x=function(a){var b,c=[];for(;b=this[a];a++)c.push(b);return c}}bc.matches=function(a,b){return bc(a,null,null,b)},bc.matchesSelector=function(a,b){return bc(b,null,null,[a]).length>0},f=bc.getText=function(a){var b,c="",d=0,e=a.nodeType;if(e){if(e===1||e===9||e===11){if(typeof a.textContent=="string")return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=f(a)}else if(e===3||e===4)return a.nodeValue}else for(;b=a[d];d++)c+=f(b);return c},g=bc.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?b.nodeName!=="HTML":!1},h=bc.contains=s.contains?function(a,b){var c=a.nodeType===9?a.documentElement:a,d=b&&b.parentNode;return a===d||!!(d&&d.nodeType===1&&c.contains&&c.contains(d))}:s.compareDocumentPosition?function(a,b){return b&&!!(a.compareDocumentPosition(b)&16)}:function(a,b){while(b=b.parentNode)if(b===a)return!0;return!1},bc.attr=function(a,b){var c,d=g(a);return d||(b=b.toLowerCase()),(c=e.attrHandle[b])?c(a):d||$?a.getAttribute(b):(c=a.getAttributeNode(b),c?typeof a[b]=="boolean"?a[b]?b:null:c.specified?c.value:null:null)},e=bc.selectors={cacheLength:50,createPseudo:z,match:W,attrHandle:Z?{}:{href:function(a){return a.getAttribute("href",2)},type:function(a){return a.getAttribute("type")}},find:{ID:d?function(a,b,c){if(typeof b.getElementById!==n&&!c){var d=b.getElementById(a);return d&&d.parentNode?[d]:[]}}:function(a,c,d){if(typeof c.getElementById!==n&&!d){var e=c.getElementById(a);return e?e.id===a||typeof e.getAttributeNode!==n&&e.getAttributeNode("id").value===a?[e]:b:[]}},TAG:Y?function(a,b){if(typeof b.getElementsByTagName!==n)return b.getElementsByTagName(a)}:function(a,b){var c=b.getElementsByTagName(a);if(a==="*"){var d,e=[],f=0;for(;d=c[f];f++)d.nodeType===1&&e.push(d);return e}return c},NAME:ba&&function(a,b){if(typeof b.getElementsByName!==n)return b.getElementsByName(name)},CLASS:_&&function(a,b,c){if(typeof b.getElementsByClassName!==n&&!c)return b.getElementsByClassName(a)}},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(V,""),a[3]=(a[4]||a[5]||"").replace(V,""),a[2]==="~="&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),a[1]==="nth"?(a[2]||bc.error(a[0]),a[3]=+(a[3]?a[4]+(a[5]||1):2*(a[2]==="even"||a[2]==="odd")),a[4]=+(a[6]+a[7]||a[2]==="odd")):a[2]&&bc.error(a[0]),a},PSEUDO:function(a){var b,c;if(W.CHILD.test(a[0]))return null;if(a[3])a[2]=a[3];else if(b=a[4])O.test(b)&&(c=bh(b,!0))&&(c=b.indexOf(")",b.length-c)-b.length)&&(b=b.slice(0,c),a[0]=a[0].slice(0,c)),a[2]=b;return a.slice(0,3)}},filter:{ID:d?function(a){return a=a.replace(V,""),function(b){return b.getAttribute("id")===a}}:function(a){return a=a.replace(V,""),function(b){var c=typeof b.getAttributeNode!==n&&b.getAttributeNode("id");return c&&c.value===a}},TAG:function(a){return a==="*"?function(){return!0}:(a=a.replace(V,"").toLowerCase(),function(b){return b.nodeName&&b.nodeName.toLowerCase()===a})},CLASS:function(a){var b=B[o][a];return b||(b=B(a,new RegExp("(^|"+E+")"+a+"("+E+"|$)"))),function(a){return b.test(a.className||typeof a.getAttribute!==n&&a.getAttribute("class")||"")}},ATTR:function(a,b,c){return function(d,e){var f=bc.attr(d,a);return f==null?b==="!=":b?(f+="",b==="="?f===c:b==="!="?f!==c:b==="^="?c&&f.indexOf(c)===0:b==="*="?c&&f.indexOf(c)>-1:b==="$="?c&&f.substr(f.length-c.length)===c:b==="~="?(" "+f+" ").indexOf(c)>-1:b==="|="?f===c||f.substr(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d){return a==="nth"?function(a){var b,e,f=a.parentNode;if(c===1&&d===0)return!0;if(f){e=0;for(b=f.firstChild;b;b=b.nextSibling)if(b.nodeType===1){e++;if(a===b)break}}return e-=d,e===c||e%c===0&&e/c>=0}:function(b){var c=b;switch(a){case"only":case"first":while(c=c.previousSibling)if(c.nodeType===1)return!1;if(a==="first")return!0;c=b;case"last":while(c=c.nextSibling)if(c.nodeType===1)return!1;return!0}}},PSEUDO:function(a,b){var c,d=e.pseudos[a]||e.setFilters[a.toLowerCase()]||bc.error("unsupported pseudo: "+a);return d[o]?d(b):d.length>1?(c=[a,a,"",b],e.setFilters.hasOwnProperty(a.toLowerCase())?z(function(a,c){var e,f=d(a,b),g=f.length;while(g--)e=y.call(a,f[g]),a[e]=!(c[e]=f[g])}):function(a){return d(a,0,c)}):d}},pseudos:{not:z(function(a){var b=[],c=[],d=i(a.replace(L,"$1"));return d[o]?z(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)if(f=g[h])a[h]=!(b[h]=f)}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:z(function(a){return function(b){return bc(a,b).length>0}}),contains:z(function(a){return function(b){return(b.textContent||b.innerText||f(b)).indexOf(a)>-1}}),enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&!!a.checked||b==="option"&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},parent:function(a){return!e.pseudos.empty(a)},empty:function(a){var b;a=a.firstChild;while(a){if(a.nodeName>"@"||(b=a.nodeType)===3||b===4)return!1;a=a.nextSibling}return!0},header:function(a){return T.test(a.nodeName)},text:function(a){var b,c;return a.nodeName.toLowerCase()==="input"&&(b=a.type)==="text"&&((c=a.getAttribute("type"))==null||c.toLowerCase()===b)},radio:bd("radio"),checkbox:bd("checkbox"),file:bd("file"),password:bd("password"),image:bd("image"),submit:be("submit"),reset:be("reset"),button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&a.type==="button"||b==="button"},input:function(a){return U.test(a.nodeName)},focus:function(a){var b=a.ownerDocument;return a===b.activeElement&&(!b.hasFocus||b.hasFocus())&&(!!a.type||!!a.href)},active:function(a){return a===a.ownerDocument.activeElement},first:bf(function(a,b,c){return[0]}),last:bf(function(a,b,c){return[b-1]}),eq:bf(function(a,b,c){return[c<0?c+b:c]}),even:bf(function(a,b,c){for(var d=0;d<b;d+=2)a.push(d);return a}),odd:bf(function(a,b,c){for(var d=1;d<b;d+=2)a.push(d);return a}),lt:bf(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:bf(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},j=s.compareDocumentPosition?function(a,b){return a===b?(k=!0,0):(!a.compareDocumentPosition||!b.compareDocumentPosition?a.compareDocumentPosition:a.compareDocumentPosition(b)&4)?-1:1}:function(a,b){if(a===b)return k=!0,0;if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,h=b.parentNode,i=g;if(g===h)return bg(a,b);if(!g)return-1;if(!h)return 1;while(i)e.unshift(i),i=i.parentNode;i=h;while(i)f.unshift(i),i=i.parentNode;c=e.length,d=f.length;for(var j=0;j<c&&j<d;j++)if(e[j]!==f[j])return bg(e[j],f[j]);return j===c?bg(a,f[j],-1):bg(e[j],b,1)},[0,0].sort(j),m=!k,bc.uniqueSort=function(a){var b,c=1;k=m,a.sort(j);if(k)for(;b=a[c];c++)b===a[c-1]&&a.splice(c--,1);return a},bc.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},i=bc.compile=function(a,b){var c,d=[],e=[],f=D[o][a];if(!f){b||(b=bh(a)),c=b.length;while(c--)f=bm(b[c]),f[o]?d.push(f):e.push(f);f=D(a,bn(e,d))}return f},r.querySelectorAll&&function(){var a,b=bp,c=/'|\\/g,d=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,e=[":focus"],f=[":active",":focus"],h=s.matchesSelector||s.mozMatchesSelector||s.webkitMatchesSelector||s.oMatchesSelector||s.msMatchesSelector;X(function(a){a.innerHTML="<select><option selected=''></option></select>",a.querySelectorAll("[selected]").length||e.push("\\["+E+"*(?:checked|disabled|ismap|multiple|readonly|selected|value)"),a.querySelectorAll(":checked").length||e.push(":checked")}),X(function(a){a.innerHTML="<p test=''></p>",a.querySelectorAll("[test^='']").length&&e.push("[*^$]="+E+"*(?:\"\"|'')"),a.innerHTML="<input type='hidden'/>",a.querySelectorAll(":enabled").length||e.push(":enabled",":disabled")}),e=new RegExp(e.join("|")),bp=function(a,d,f,g,h){if(!g&&!h&&(!e||!e.test(a))){var i,j,k=!0,l=o,m=d,n=d.nodeType===9&&a;if(d.nodeType===1&&d.nodeName.toLowerCase()!=="object"){i=bh(a),(k=d.getAttribute("id"))?l=k.replace(c,"\\$&"):d.setAttribute("id",l),l="[id='"+l+"'] ",j=i.length;while(j--)i[j]=l+i[j].join("");m=R.test(a)&&d.parentNode||d,n=i.join(",")}if(n)try{return w.apply(f,x.call(m.querySelectorAll(n),0)),f}catch(p){}finally{k||d.removeAttribute("id")}}return b(a,d,f,g,h)},h&&(X(function(b){a=h.call(b,"div");try{h.call(b,"[test!='']:sizzle"),f.push("!=",J)}catch(c){}}),f=new RegExp(f.join("|")),bc.matchesSelector=function(b,c){c=c.replace(d,"='$1']");if(!g(b)&&!f.test(c)&&(!e||!e.test(c)))try{var i=h.call(b,c);if(i||a||b.document&&b.document.nodeType!==11)return i}catch(j){}return bc(c,null,null,[b]).length>0})}(),e.pseudos.nth=e.pseudos.eq,e.filters=bq.prototype=e.pseudos,e.setFilters=new bq,bc.attr=p.attr,p.find=bc,p.expr=bc.selectors,p.expr[":"]=p.expr.pseudos,p.unique=bc.uniqueSort,p.text=bc.getText,p.isXMLDoc=bc.isXML,p.contains=bc.contains}(a);var bc=/Until$/,bd=/^(?:parents|prev(?:Until|All))/,be=/^.[^:#\[\.,]*$/,bf=p.expr.match.needsContext,bg={children:!0,contents:!0,next:!0,prev:!0};p.fn.extend({find:function(a){var b,c,d,e,f,g,h=this;if(typeof a!="string")return p(a).filter(function(){for(b=0,c=h.length;b<c;b++)if(p.contains(h[b],this))return!0});g=this.pushStack("","find",a);for(b=0,c=this.length;b<c;b++){d=g.length,p.find(a,this[b],g);if(b>0)for(e=d;e<g.length;e++)for(f=0;f<d;f++)if(g[f]===g[e]){g.splice(e--,1);break}}return g},has:function(a){var b,c=p(a,this),d=c.length;return this.filter(function(){for(b=0;b<d;b++)if(p.contains(this,c[b]))return!0})},not:function(a){return this.pushStack(bj(this,a,!1),"not",a)},filter:function(a){return this.pushStack(bj(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?bf.test(a)?p(a,this.context).index(this[0])>=0:p.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c,d=0,e=this.length,f=[],g=bf.test(a)||typeof a!="string"?p(a,b||this.context):0;for(;d<e;d++){c=this[d];while(c&&c.ownerDocument&&c!==b&&c.nodeType!==11){if(g?g.index(c)>-1:p.find.matchesSelector(c,a)){f.push(c);break}c=c.parentNode}}return f=f.length>1?p.unique(f):f,this.pushStack(f,"closest",a)},index:function(a){return a?typeof a=="string"?p.inArray(this[0],p(a)):p.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.prevAll().length:-1},add:function(a,b){var c=typeof a=="string"?p(a,b):p.makeArray(a&&a.nodeType?[a]:a),d=p.merge(this.get(),c);return this.pushStack(bh(c[0])||bh(d[0])?d:p.unique(d))},addBack:function(a){return this.add(a==null?this.prevObject:this.prevObject.filter(a))}}),p.fn.andSelf=p.fn.addBack,p.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return p.dir(a,"parentNode")},parentsUntil:function(a,b,c){return p.dir(a,"parentNode",c)},next:function(a){return bi(a,"nextSibling")},prev:function(a){return bi(a,"previousSibling")},nextAll:function(a){return p.dir(a,"nextSibling")},prevAll:function(a){return p.dir(a,"previousSibling")},nextUntil:function(a,b,c){return p.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return p.dir(a,"previousSibling",c)},siblings:function(a){return p.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return p.sibling(a.firstChild)},contents:function(a){return p.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:p.merge([],a.childNodes)}},function(a,b){p.fn[a]=function(c,d){var e=p.map(this,b,c);return bc.test(a)||(d=c),d&&typeof d=="string"&&(e=p.filter(d,e)),e=this.length>1&&!bg[a]?p.unique(e):e,this.length>1&&bd.test(a)&&(e=e.reverse()),this.pushStack(e,a,k.call(arguments).join(","))}}),p.extend({filter:function(a,b,c){return c&&(a=":not("+a+")"),b.length===1?p.find.matchesSelector(b[0],a)?[b[0]]:[]:p.find.matches(a,b)},dir:function(a,c,d){var e=[],f=a[c];while(f&&f.nodeType!==9&&(d===b||f.nodeType!==1||!p(f).is(d)))f.nodeType===1&&e.push(f),f=f[c];return e},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var bl="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",bm=/ jQuery\d+="(?:null|\d+)"/g,bn=/^\s+/,bo=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,bp=/<([\w:]+)/,bq=/<tbody/i,br=/<|&#?\w+;/,bs=/<(?:script|style|link)/i,bt=/<(?:script|object|embed|option|style)/i,bu=new RegExp("<(?:"+bl+")[\\s/>]","i"),bv=/^(?:checkbox|radio)$/,bw=/checked\s*(?:[^=]|=\s*.checked.)/i,bx=/\/(java|ecma)script/i,by=/^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,bz={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bA=bk(e),bB=bA.appendChild(e.createElement("div"));bz.optgroup=bz.option,bz.tbody=bz.tfoot=bz.colgroup=bz.caption=bz.thead,bz.th=bz.td,p.support.htmlSerialize||(bz._default=[1,"X<div>","</div>"]),p.fn.extend({text:function(a){return p.access(this,function(a){return a===b?p.text(this):this.empty().append((this[0]&&this[0].ownerDocument||e).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(p.isFunction(a))return this.each(function(b){p(this).wrapAll(a.call(this,b))});if(this[0]){var b=p(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return p.isFunction(a)?this.each(function(b){p(this).wrapInner(a.call(this,b))}):this.each(function(){var b=p(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=p.isFunction(a);return this.each(function(c){p(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){p.nodeName(this,"body")||p(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.insertBefore(a,this.firstChild)})},before:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(a,this),"before",this.selector)}},after:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(this,a),"after",this.selector)}},remove:function(a,b){var c,d=0;for(;(c=this[d])!=null;d++)if(!a||p.filter(a,[c]).length)!b&&c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),p.cleanData([c])),c.parentNode&&c.parentNode.removeChild(c);return this},empty:function(){var a,b=0;for(;(a=this[b])!=null;b++){a.nodeType===1&&p.cleanData(a.getElementsByTagName("*"));while(a.firstChild)a.removeChild(a.firstChild)}return this},clone:function(a,b){return a=a==null?!1:a,b=b==null?a:b,this.map(function(){return p.clone(this,a,b)})},html:function(a){return p.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(bm,""):b;if(typeof a=="string"&&!bs.test(a)&&(p.support.htmlSerialize||!bu.test(a))&&(p.support.leadingWhitespace||!bn.test(a))&&!bz[(bp.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(bo,"<$1></$2>");try{for(;d<e;d++)c=this[d]||{},c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),c.innerHTML=a);c=0}catch(f){}}c&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(a){return bh(this[0])?this.length?this.pushStack(p(p.isFunction(a)?a():a),"replaceWith",a):this:p.isFunction(a)?this.each(function(b){var c=p(this),d=c.html();c.replaceWith(a.call(this,b,d))}):(typeof a!="string"&&(a=p(a).detach()),this.each(function(){var b=this.nextSibling,c=this.parentNode;p(this).remove(),b?p(b).before(a):p(c).append(a)}))},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){a=[].concat.apply([],a);var e,f,g,h,i=0,j=a[0],k=[],l=this.length;if(!p.support.checkClone&&l>1&&typeof j=="string"&&bw.test(j))return this.each(function(){p(this).domManip(a,c,d)});if(p.isFunction(j))return this.each(function(e){var f=p(this);a[0]=j.call(this,e,c?f.html():b),f.domManip(a,c,d)});if(this[0]){e=p.buildFragment(a,this,k),g=e.fragment,f=g.firstChild,g.childNodes.length===1&&(g=f);if(f){c=c&&p.nodeName(f,"tr");for(h=e.cacheable||l-1;i<l;i++)d.call(c&&p.nodeName(this[i],"table")?bC(this[i],"tbody"):this[i],i===h?g:p.clone(g,!0,!0))}g=f=null,k.length&&p.each(k,function(a,b){b.src?p.ajax?p.ajax({url:b.src,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0}):p.error("no ajax"):p.globalEval((b.text||b.textContent||b.innerHTML||"").replace(by,"")),b.parentNode&&b.parentNode.removeChild(b)})}return this}}),p.buildFragment=function(a,c,d){var f,g,h,i=a[0];return c=c||e,c=!c.nodeType&&c[0]||c,c=c.ownerDocument||c,a.length===1&&typeof i=="string"&&i.length<512&&c===e&&i.charAt(0)==="<"&&!bt.test(i)&&(p.support.checkClone||!bw.test(i))&&(p.support.html5Clone||!bu.test(i))&&(g=!0,f=p.fragments[i],h=f!==b),f||(f=c.createDocumentFragment(),p.clean(a,c,f,d),g&&(p.fragments[i]=h&&f)),{fragment:f,cacheable:g}},p.fragments={},p.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){p.fn[a]=function(c){var d,e=0,f=[],g=p(c),h=g.length,i=this.length===1&&this[0].parentNode;if((i==null||i&&i.nodeType===11&&i.childNodes.length===1)&&h===1)return g[b](this[0]),this;for(;e<h;e++)d=(e>0?this.clone(!0):this).get(),p(g[e])[b](d),f=f.concat(d);return this.pushStack(f,a,g.selector)}}),p.extend({clone:function(a,b,c){var d,e,f,g;p.support.html5Clone||p.isXMLDoc(a)||!bu.test("<"+a.nodeName+">")?g=a.cloneNode(!0):(bB.innerHTML=a.outerHTML,bB.removeChild(g=bB.firstChild));if((!p.support.noCloneEvent||!p.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!p.isXMLDoc(a)){bE(a,g),d=bF(a),e=bF(g);for(f=0;d[f];++f)e[f]&&bE(d[f],e[f])}if(b){bD(a,g);if(c){d=bF(a),e=bF(g);for(f=0;d[f];++f)bD(d[f],e[f])}}return d=e=null,g},clean:function(a,b,c,d){var f,g,h,i,j,k,l,m,n,o,q,r,s=b===e&&bA,t=[];if(!b||typeof b.createDocumentFragment=="undefined")b=e;for(f=0;(h=a[f])!=null;f++){typeof h=="number"&&(h+="");if(!h)continue;if(typeof h=="string")if(!br.test(h))h=b.createTextNode(h);else{s=s||bk(b),l=b.createElement("div"),s.appendChild(l),h=h.replace(bo,"<$1></$2>"),i=(bp.exec(h)||["",""])[1].toLowerCase(),j=bz[i]||bz._default,k=j[0],l.innerHTML=j[1]+h+j[2];while(k--)l=l.lastChild;if(!p.support.tbody){m=bq.test(h),n=i==="table"&&!m?l.firstChild&&l.firstChild.childNodes:j[1]==="<table>"&&!m?l.childNodes:[];for(g=n.length-1;g>=0;--g)p.nodeName(n[g],"tbody")&&!n[g].childNodes.length&&n[g].parentNode.removeChild(n[g])}!p.support.leadingWhitespace&&bn.test(h)&&l.insertBefore(b.createTextNode(bn.exec(h)[0]),l.firstChild),h=l.childNodes,l.parentNode.removeChild(l)}h.nodeType?t.push(h):p.merge(t,h)}l&&(h=l=s=null);if(!p.support.appendChecked)for(f=0;(h=t[f])!=null;f++)p.nodeName(h,"input")?bG(h):typeof h.getElementsByTagName!="undefined"&&p.grep(h.getElementsByTagName("input"),bG);if(c){q=function(a){if(!a.type||bx.test(a.type))return d?d.push(a.parentNode?a.parentNode.removeChild(a):a):c.appendChild(a)};for(f=0;(h=t[f])!=null;f++)if(!p.nodeName(h,"script")||!q(h))c.appendChild(h),typeof h.getElementsByTagName!="undefined"&&(r=p.grep(p.merge([],h.getElementsByTagName("script")),q),t.splice.apply(t,[f+1,0].concat(r)),f+=r.length)}return t},cleanData:function(a,b){var c,d,e,f,g=0,h=p.expando,i=p.cache,j=p.support.deleteExpando,k=p.event.special;for(;(e=a[g])!=null;g++)if(b||p.acceptData(e)){d=e[h],c=d&&i[d];if(c){if(c.events)for(f in c.events)k[f]?p.event.remove(e,f):p.removeEvent(e,f,c.handle);i[d]&&(delete i[d],j?delete e[h]:e.removeAttribute?e.removeAttribute(h):e[h]=null,p.deletedIds.push(d))}}}}),function(){var a,b;p.uaMatch=function(a){a=a.toLowerCase();var b=/(chrome)[ \/]([\w.]+)/.exec(a)||/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||a.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},a=p.uaMatch(g.userAgent),b={},a.browser&&(b[a.browser]=!0,b.version=a.version),b.chrome?b.webkit=!0:b.webkit&&(b.safari=!0),p.browser=b,p.sub=function(){function a(b,c){return new a.fn.init(b,c)}p.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function c(c,d){return d&&d instanceof p&&!(d instanceof a)&&(d=a(d)),p.fn.init.call(this,c,d,b)},a.fn.init.prototype=a.fn;var b=a(e);return a}}();var bH,bI,bJ,bK=/alpha\([^)]*\)/i,bL=/opacity=([^)]*)/,bM=/^(top|right|bottom|left)$/,bN=/^(none|table(?!-c[ea]).+)/,bO=/^margin/,bP=new RegExp("^("+q+")(.*)$","i"),bQ=new RegExp("^("+q+")(?!px)[a-z%]+$","i"),bR=new RegExp("^([-+])=("+q+")","i"),bS={},bT={position:"absolute",visibility:"hidden",display:"block"},bU={letterSpacing:0,fontWeight:400},bV=["Top","Right","Bottom","Left"],bW=["Webkit","O","Moz","ms"],bX=p.fn.toggle;p.fn.extend({css:function(a,c){return p.access(this,function(a,c,d){return d!==b?p.style(a,c,d):p.css(a,c)},a,c,arguments.length>1)},show:function(){return b$(this,!0)},hide:function(){return b$(this)},toggle:function(a,b){var c=typeof a=="boolean";return p.isFunction(a)&&p.isFunction(b)?bX.apply(this,arguments):this.each(function(){(c?a:bZ(this))?p(this).show():p(this).hide()})}}),p.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bH(a,"opacity");return c===""?"1":c}}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":p.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!a||a.nodeType===3||a.nodeType===8||!a.style)return;var f,g,h,i=p.camelCase(c),j=a.style;c=p.cssProps[i]||(p.cssProps[i]=bY(j,i)),h=p.cssHooks[c]||p.cssHooks[i];if(d===b)return h&&"get"in h&&(f=h.get(a,!1,e))!==b?f:j[c];g=typeof d,g==="string"&&(f=bR.exec(d))&&(d=(f[1]+1)*f[2]+parseFloat(p.css(a,c)),g="number");if(d==null||g==="number"&&isNaN(d))return;g==="number"&&!p.cssNumber[i]&&(d+="px");if(!h||!("set"in h)||(d=h.set(a,d,e))!==b)try{j[c]=d}catch(k){}},css:function(a,c,d,e){var f,g,h,i=p.camelCase(c);return c=p.cssProps[i]||(p.cssProps[i]=bY(a.style,i)),h=p.cssHooks[c]||p.cssHooks[i],h&&"get"in h&&(f=h.get(a,!0,e)),f===b&&(f=bH(a,c)),f==="normal"&&c in bU&&(f=bU[c]),d||e!==b?(g=parseFloat(f),d||p.isNumeric(g)?g||0:f):f},swap:function(a,b,c){var d,e,f={};for(e in b)f[e]=a.style[e],a.style[e]=b[e];d=c.call(a);for(e in b)a.style[e]=f[e];return d}}),a.getComputedStyle?bH=function(b,c){var d,e,f,g,h=a.getComputedStyle(b,null),i=b.style;return h&&(d=h[c],d===""&&!p.contains(b.ownerDocument,b)&&(d=p.style(b,c)),bQ.test(d)&&bO.test(c)&&(e=i.width,f=i.minWidth,g=i.maxWidth,i.minWidth=i.maxWidth=i.width=d,d=h.width,i.width=e,i.minWidth=f,i.maxWidth=g)),d}:e.documentElement.currentStyle&&(bH=function(a,b){var c,d,e=a.currentStyle&&a.currentStyle[b],f=a.style;return e==null&&f&&f[b]&&(e=f[b]),bQ.test(e)&&!bM.test(b)&&(c=f.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":e,e=f.pixelLeft+"px",f.left=c,d&&(a.runtimeStyle.left=d)),e===""?"auto":e}),p.each(["height","width"],function(a,b){p.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth===0&&bN.test(bH(a,"display"))?p.swap(a,bT,function(){return cb(a,b,d)}):cb(a,b,d)},set:function(a,c,d){return b_(a,c,d?ca(a,b,d,p.support.boxSizing&&p.css(a,"boxSizing")==="border-box"):0)}}}),p.support.opacity||(p.cssHooks.opacity={get:function(a,b){return bL.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=p.isNumeric(b)?"alpha(opacity="+b*100+")":"",f=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&p.trim(f.replace(bK,""))===""&&c.removeAttribute){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bK.test(f)?f.replace(bK,e):f+" "+e}}),p(function(){p.support.reliableMarginRight||(p.cssHooks.marginRight={get:function(a,b){return p.swap(a,{display:"inline-block"},function(){if(b)return bH(a,"marginRight")})}}),!p.support.pixelPosition&&p.fn.position&&p.each(["top","left"],function(a,b){p.cssHooks[b]={get:function(a,c){if(c){var d=bH(a,b);return bQ.test(d)?p(a).position()[b]+"px":d}}}})}),p.expr&&p.expr.filters&&(p.expr.filters.hidden=function(a){return a.offsetWidth===0&&a.offsetHeight===0||!p.support.reliableHiddenOffsets&&(a.style&&a.style.display||bH(a,"display"))==="none"},p.expr.filters.visible=function(a){return!p.expr.filters.hidden(a)}),p.each({margin:"",padding:"",border:"Width"},function(a,b){p.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bV[d]+b]=e[d]||e[d-2]||e[0];return f}},bO.test(a)||(p.cssHooks[a+b].set=b_)});var cd=/%20/g,ce=/\[\]$/,cf=/\r?\n/g,cg=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,ch=/^(?:select|textarea)/i;p.fn.extend({serialize:function(){return p.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?p.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ch.test(this.nodeName)||cg.test(this.type))}).map(function(a,b){var c=p(this).val();return c==null?null:p.isArray(c)?p.map(c,function(a,c){return{name:b.name,value:a.replace(cf,"\r\n")}}):{name:b.name,value:c.replace(cf,"\r\n")}}).get()}}),p.param=function(a,c){var d,e=[],f=function(a,b){b=p.isFunction(b)?b():b==null?"":b,e[e.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=p.ajaxSettings&&p.ajaxSettings.traditional);if(p.isArray(a)||a.jquery&&!p.isPlainObject(a))p.each(a,function(){f(this.name,this.value)});else for(d in a)ci(d,a[d],c,f);return e.join("&").replace(cd,"+")};var cj,ck,cl=/#.*$/,cm=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,cn=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,co=/^(?:GET|HEAD)$/,cp=/^\/\//,cq=/\?/,cr=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,cs=/([?&])_=[^&]*/,ct=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,cu=p.fn.load,cv={},cw={},cx=["*/"]+["*"];try{ck=f.href}catch(cy){ck=e.createElement("a"),ck.href="",ck=ck.href}cj=ct.exec(ck.toLowerCase())||[],p.fn.load=function(a,c,d){if(typeof a!="string"&&cu)return cu.apply(this,arguments);if(!this.length)return this;var e,f,g,h=this,i=a.indexOf(" ");return i>=0&&(e=a.slice(i,a.length),a=a.slice(0,i)),p.isFunction(c)?(d=c,c=b):c&&typeof c=="object"&&(f="POST"),p.ajax({url:a,type:f,dataType:"html",data:c,complete:function(a,b){d&&h.each(d,g||[a.responseText,b,a])}}).done(function(a){g=arguments,h.html(e?p("<div>").append(a.replace(cr,"")).find(e):a)}),this},p.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){p.fn[b]=function(a){return this.on(b,a)}}),p.each(["get","post"],function(a,c){p[c]=function(a,d,e,f){return p.isFunction(d)&&(f=f||e,e=d,d=b),p.ajax({type:c,url:a,data:d,success:e,dataType:f})}}),p.extend({getScript:function(a,c){return p.get(a,b,c,"script")},getJSON:function(a,b,c){return p.get(a,b,c,"json")},ajaxSetup:function(a,b){return b?cB(a,p.ajaxSettings):(b=a,a=p.ajaxSettings),cB(a,b),a},ajaxSettings:{url:ck,isLocal:cn.test(cj[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":cx},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":p.parseJSON,"text xml":p.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:cz(cv),ajaxTransport:cz(cw),ajax:function(a,c){function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeout(h),g=b,e=i||"",x.readyState=a>0?4:0,f&&(u=cC(l,x,f));if(a>=200&&a<300||a===304)l.ifModified&&(w=x.getResponseHeader("Last-Modified"),w&&(p.lastModified[d]=w),w=x.getResponseHeader("Etag"),w&&(p.etag[d]=w)),a===304?(y="notmodified",k=!0):(k=cD(l,u),y=k.state,s=k.data,t=k.error,k=!t);else{t=y;if(!y||a)y="error",a<0&&(a=0)}x.status=a,x.statusText=(c||y)+"",k?o.resolveWith(m,[s,y,x]):o.rejectWith(m,[x,y,t]),x.statusCode(r),r=b,j&&n.trigger("ajax"+(k?"Success":"Error"),[x,l,k?s:t]),q.fireWith(m,[x,y]),j&&(n.trigger("ajaxComplete",[x,l]),--p.active||p.event.trigger("ajaxStop"))}typeof a=="object"&&(c=a,a=b),c=c||{};var d,e,f,g,h,i,j,k,l=p.ajaxSetup({},c),m=l.context||l,n=m!==l&&(m.nodeType||m instanceof p)?p(m):p.event,o=p.Deferred(),q=p.Callbacks("once memory"),r=l.statusCode||{},t={},u={},v=0,w="canceled",x={readyState:0,setRequestHeader:function(a,b){if(!v){var c=a.toLowerCase();a=u[c]=u[c]||a,t[a]=b}return this},getAllResponseHeaders:function(){return v===2?e:null},getResponseHeader:function(a){var c;if(v===2){if(!f){f={};while(c=cm.exec(e))f[c[1].toLowerCase()]=c[2]}c=f[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){return v||(l.mimeType=a),this},abort:function(a){return a=a||w,g&&g.abort(a),y(0,a),this}};o.promise(x),x.success=x.done,x.error=x.fail,x.complete=q.add,x.statusCode=function(a){if(a){var b;if(v<2)for(b in a)r[b]=[r[b],a[b]];else b=a[x.status],x.always(b)}return this},l.url=((a||l.url)+"").replace(cl,"").replace(cp,cj[1]+"//"),l.dataTypes=p.trim(l.dataType||"*").toLowerCase().split(s),l.crossDomain==null&&(i=ct.exec(l.url.toLowerCase())||!1,l.crossDomain=i&&i.join(":")+(i[3]?"":i[1]==="http:"?80:443)!==cj.join(":")+(cj[3]?"":cj[1]==="http:"?80:443)),l.data&&l.processData&&typeof l.data!="string"&&(l.data=p.param(l.data,l.traditional)),cA(cv,l,c,x);if(v===2)return x;j=l.global,l.type=l.type.toUpperCase(),l.hasContent=!co.test(l.type),j&&p.active++===0&&p.event.trigger("ajaxStart");if(!l.hasContent){l.data&&(l.url+=(cq.test(l.url)?"&":"?")+l.data,delete l.data),d=l.url;if(l.cache===!1){var z=p.now(),A=l.url.replace(cs,"$1_="+z);l.url=A+(A===l.url?(cq.test(l.url)?"&":"?")+"_="+z:"")}}(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&x.setRequestHeader("Content-Type",l.contentType),l.ifModified&&(d=d||l.url,p.lastModified[d]&&x.setRequestHeader("If-Modified-Since",p.lastModified[d]),p.etag[d]&&x.setRequestHeader("If-None-Match",p.etag[d])),x.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+(l.dataTypes[0]!=="*"?", "+cx+"; q=0.01":""):l.accepts["*"]);for(k in l.headers)x.setRequestHeader(k,l.headers[k]);if(!l.beforeSend||l.beforeSend.call(m,x,l)!==!1&&v!==2){w="abort";for(k in{success:1,error:1,complete:1})x[k](l[k]);g=cA(cw,l,c,x);if(!g)y(-1,"No Transport");else{x.readyState=1,j&&n.trigger("ajaxSend",[x,l]),l.async&&l.timeout>0&&(h=setTimeout(function(){x.abort("timeout")},l.timeout));try{v=1,g.send(t,y)}catch(B){if(v<2)y(-1,B);else throw B}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var cE=[],cF=/\?/,cG=/(=)\?(?=&|$)|\?\?/,cH=p.now();p.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=cE.pop()||p.expando+"_"+cH++;return this[a]=!0,a}}),p.ajaxPrefilter("json jsonp",function(c,d,e){var f,g,h,i=c.data,j=c.url,k=c.jsonp!==!1,l=k&&cG.test(j),m=k&&!l&&typeof i=="string"&&!(c.contentType||"").indexOf("application/x-www-form-urlencoded")&&cG.test(i);if(c.dataTypes[0]==="jsonp"||l||m)return f=c.jsonpCallback=p.isFunction(c.jsonpCallback)?c.jsonpCallback():c.jsonpCallback,g=a[f],l?c.url=j.replace(cG,"$1"+f):m?c.data=i.replace(cG,"$1"+f):k&&(c.url+=(cF.test(j)?"&":"?")+c.jsonp+"="+f),c.converters["script json"]=function(){return h||p.error(f+" was not called"),h[0]},c.dataTypes[0]="json",a[f]=function(){h=arguments},e.always(function(){a[f]=g,c[f]&&(c.jsonpCallback=d.jsonpCallback,cE.push(f)),h&&p.isFunction(g)&&g(h[0]),h=g=b}),"script"}),p.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){return p.globalEval(a),a}}}),p.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),p.ajaxTransport("script",function(a){if(a.crossDomain){var c,d=e.head||e.getElementsByTagName("head")[0]||e.documentElement;return{send:function(f,g){c=e.createElement("script"),c.async="async",a.scriptCharset&&(c.charset=a.scriptCharset),c.src=a.url,c.onload=c.onreadystatechange=function(a,e){if(e||!c.readyState||/loaded|complete/.test(c.readyState))c.onload=c.onreadystatechange=null,d&&c.parentNode&&d.removeChild(c),c=b,e||g(200,"success")},d.insertBefore(c,d.firstChild)},abort:function(){c&&c.onload(0,1)}}}});var cI,cJ=a.ActiveXObject?function(){for(var a in cI)cI[a](0,1)}:!1,cK=0;p.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&cL()||cM()}:cL,function(a){p.extend(p.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(p.ajaxSettings.xhr()),p.support.ajax&&p.ajaxTransport(function(c){if(!c.crossDomain||p.support.cors){var d;return{send:function(e,f){var g,h,i=c.xhr();c.username?i.open(c.type,c.url,c.async,c.username,c.password):i.open(c.type,c.url,c.async);if(c.xhrFields)for(h in c.xhrFields)i[h]=c.xhrFields[h];c.mimeType&&i.overrideMimeType&&i.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(h in e)i.setRequestHeader(h,e[h])}catch(j){}i.send(c.hasContent&&c.data||null),d=function(a,e){var h,j,k,l,m;try{if(d&&(e||i.readyState===4)){d=b,g&&(i.onreadystatechange=p.noop,cJ&&delete cI[g]);if(e)i.readyState!==4&&i.abort();else{h=i.status,k=i.getAllResponseHeaders(),l={},m=i.responseXML,m&&m.documentElement&&(l.xml=m);try{l.text=i.responseText}catch(a){}try{j=i.statusText}catch(n){j=""}!h&&c.isLocal&&!c.crossDomain?h=l.text?200:404:h===1223&&(h=204)}}}catch(o){e||f(-1,o)}l&&f(h,j,l,k)},c.async?i.readyState===4?setTimeout(d,0):(g=++cK,cJ&&(cI||(cI={},p(a).unload(cJ)),cI[g]=d),i.onreadystatechange=d):d()},abort:function(){d&&d(0,1)}}}});var cN,cO,cP=/^(?:toggle|show|hide)$/,cQ=new RegExp("^(?:([-+])=|)("+q+")([a-z%]*)$","i"),cR=/queueHooks$/,cS=[cY],cT={"*":[function(a,b){var c,d,e=this.createTween(a,b),f=cQ.exec(b),g=e.cur(),h=+g||0,i=1,j=20;if(f){c=+f[2],d=f[3]||(p.cssNumber[a]?"":"px");if(d!=="px"&&h){h=p.css(e.elem,a,!0)||c||1;do i=i||".5",h=h/i,p.style(e.elem,a,h+d);while(i!==(i=e.cur()/g)&&i!==1&&--j)}e.unit=d,e.start=h,e.end=f[1]?h+(f[1]+1)*c:c}return e}]};p.Animation=p.extend(cW,{tweener:function(a,b){p.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");var c,d=0,e=a.length;for(;d<e;d++)c=a[d],cT[c]=cT[c]||[],cT[c].unshift(b)},prefilter:function(a,b){b?cS.unshift(a):cS.push(a)}}),p.Tween=cZ,cZ.prototype={constructor:cZ,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(p.cssNumber[c]?"":"px")},cur:function(){var a=cZ.propHooks[this.prop];return a&&a.get?a.get(this):cZ.propHooks._default.get(this)},run:function(a){var b,c=cZ.propHooks[this.prop];return this.options.duration?this.pos=b=p.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):cZ.propHooks._default.set(this),this}},cZ.prototype.init.prototype=cZ.prototype,cZ.propHooks={_default:{get:function(a){var b;return a.elem[a.prop]==null||!!a.elem.style&&a.elem.style[a.prop]!=null?(b=p.css(a.elem,a.prop,!1,""),!b||b==="auto"?0:b):a.elem[a.prop]},set:function(a){p.fx.step[a.prop]?p.fx.step[a.prop](a):a.elem.style&&(a.elem.style[p.cssProps[a.prop]]!=null||p.cssHooks[a.prop])?p.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},cZ.propHooks.scrollTop=cZ.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},p.each(["toggle","show","hide"],function(a,b){var c=p.fn[b];p.fn[b]=function(d,e,f){return d==null||typeof d=="boolean"||!a&&p.isFunction(d)&&p.isFunction(e)?c.apply(this,arguments):this.animate(c$(b,!0),d,e,f)}}),p.fn.extend({fadeTo:function(a,b,c,d){return this.filter(bZ).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=p.isEmptyObject(a),f=p.speed(b,c,d),g=function(){var b=cW(this,p.extend({},a),f);e&&b.stop(!0)};return e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,c,d){var e=function(a){var b=a.stop;delete a.stop,b(d)};return typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,c=a!=null&&a+"queueHooks",f=p.timers,g=p._data(this);if(c)g[c]&&g[c].stop&&e(g[c]);else for(c in g)g[c]&&g[c].stop&&cR.test(c)&&e(g[c]);for(c=f.length;c--;)f[c].elem===this&&(a==null||f[c].queue===a)&&(f[c].anim.stop(d),b=!1,f.splice(c,1));(b||!d)&&p.dequeue(this,a)})}}),p.each({slideDown:c$("show"),slideUp:c$("hide"),slideToggle:c$("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){p.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),p.speed=function(a,b,c){var d=a&&typeof a=="object"?p.extend({},a):{complete:c||!c&&b||p.isFunction(a)&&a,duration:a,easing:c&&b||b&&!p.isFunction(b)&&b};d.duration=p.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in p.fx.speeds?p.fx.speeds[d.duration]:p.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";return d.old=d.complete,d.complete=function(){p.isFunction(d.old)&&d.old.call(this),d.queue&&p.dequeue(this,d.queue)},d},p.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},p.timers=[],p.fx=cZ.prototype.init,p.fx.tick=function(){var a,b=p.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||p.fx.stop()},p.fx.timer=function(a){a()&&p.timers.push(a)&&!cO&&(cO=setInterval(p.fx.tick,p.fx.interval))},p.fx.interval=13,p.fx.stop=function(){clearInterval(cO),cO=null},p.fx.speeds={slow:600,fast:200,_default:400},p.fx.step={},p.expr&&p.expr.filters&&(p.expr.filters.animated=function(a){return p.grep(p.timers,function(b){return a===b.elem}).length});var c_=/^(?:body|html)$/i;p.fn.offset=function(a){if(arguments.length)return a===b?this:this.each(function(b){p.offset.setOffset(this,a,b)});var c,d,e,f,g,h,i,j={top:0,left:0},k=this[0],l=k&&k.ownerDocument;if(!l)return;return(d=l.body)===k?p.offset.bodyOffset(k):(c=l.documentElement,p.contains(c,k)?(typeof k.getBoundingClientRect!="undefined"&&(j=k.getBoundingClientRect()),e=da(l),f=c.clientTop||d.clientTop||0,g=c.clientLeft||d.clientLeft||0,h=e.pageYOffset||c.scrollTop,i=e.pageXOffset||c.scrollLeft,{top:j.top+h-f,left:j.left+i-g}):j)},p.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;return p.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(p.css(a,"marginTop"))||0,c+=parseFloat(p.css(a,"marginLeft"))||0),{top:b,left:c}},setOffset:function(a,b,c){var d=p.css(a,"position");d==="static"&&(a.style.position="relative");var e=p(a),f=e.offset(),g=p.css(a,"top"),h=p.css(a,"left"),i=(d==="absolute"||d==="fixed")&&p.inArray("auto",[g,h])>-1,j={},k={},l,m;i?(k=e.position(),l=k.top,m=k.left):(l=parseFloat(g)||0,m=parseFloat(h)||0),p.isFunction(b)&&(b=b.call(a,c,f)),b.top!=null&&(j.top=b.top-f.top+l),b.left!=null&&(j.left=b.left-f.left+m),"using"in b?b.using.call(a,j):e.css(j)}},p.fn.extend({position:function(){if(!this[0])return;var a=this[0],b=this.offsetParent(),c=this.offset(),d=c_.test(b[0].nodeName)?{top:0,left:0}:b.offset();return c.top-=parseFloat(p.css(a,"marginTop"))||0,c.left-=parseFloat(p.css(a,"marginLeft"))||0,d.top+=parseFloat(p.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(p.css(b[0],"borderLeftWidth"))||0,{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||e.body;while(a&&!c_.test(a.nodeName)&&p.css(a,"position")==="static")a=a.offsetParent;return a||e.body})}}),p.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);p.fn[a]=function(e){return p.access(this,function(a,e,f){var g=da(a);if(f===b)return g?c in g?g[c]:g.document.documentElement[e]:a[e];g?g.scrollTo(d?p(g).scrollLeft():f,d?f:p(g).scrollTop()):a[e]=f},a,e,arguments.length,null)}}),p.each({Height:"height",Width:"width"},function(a,c){p.each({padding:"inner"+a,content:c,"":"outer"+a},function(d,e){p.fn[e]=function(e,f){var g=arguments.length&&(d||typeof e!="boolean"),h=d||(e===!0||f===!0?"margin":"border");return p.access(this,function(c,d,e){var f;return p.isWindow(c)?c.document.documentElement["client"+a]:c.nodeType===9?(f=c.documentElement,Math.max(c.body["scroll"+a],f["scroll"+a],c.body["offset"+a],f["offset"+a],f["client"+a])):e===b?p.css(c,d,e,h):p.style(c,d,e,h)},c,g?e:b,g,null)}})}),a.jQuery=a.$=p,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return p})})(window);
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/godoc/static/jquery.treeview.css b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.css
new file mode 100644
index 0000000..ac33361
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.css
@@ -0,0 +1,76 @@
+/* https://github.com/jzaefferer/jquery-treeview/blob/master/jquery.treeview.css */
+/* License: MIT. */
+.treeview, .treeview ul {
+	padding: 0;
+	margin: 0;
+	list-style: none;
+}
+
+.treeview ul {
+	background-color: white;
+	margin-top: 4px;
+}
+
+.treeview .hitarea {
+	background: url(images/treeview-default.gif) -64px -25px no-repeat;
+	height: 16px;
+	width: 16px;
+	margin-left: -16px;
+	float: left;
+	cursor: pointer;
+}
+/* fix for IE6 */
+* html .hitarea {
+	display: inline;
+	float:none;
+}
+
+.treeview li {
+	margin: 0;
+	padding: 3px 0pt 3px 16px;
+}
+
+.treeview a.selected {
+	background-color: #eee;
+}
+
+#treecontrol { margin: 1em 0; display: none; }
+
+.treeview .hover { color: red; cursor: pointer; }
+
+.treeview li { background: url(images/treeview-default-line.gif) 0 0 no-repeat; }
+.treeview li.collapsable, .treeview li.expandable { background-position: 0 -176px; }
+
+.treeview .expandable-hitarea { background-position: -80px -3px; }
+
+.treeview li.last { background-position: 0 -1766px }
+.treeview li.lastCollapsable, .treeview li.lastExpandable { background-image: url(images/treeview-default.gif); }
+.treeview li.lastCollapsable { background-position: 0 -111px }
+.treeview li.lastExpandable { background-position: -32px -67px }
+
+.treeview div.lastCollapsable-hitarea, .treeview div.lastExpandable-hitarea { background-position: 0; }
+
+.treeview-red li { background-image: url(images/treeview-red-line.gif); }
+.treeview-red .hitarea, .treeview-red li.lastCollapsable, .treeview-red li.lastExpandable { background-image: url(images/treeview-red.gif); }
+
+.treeview-black li { background-image: url(images/treeview-black-line.gif); }
+.treeview-black .hitarea, .treeview-black li.lastCollapsable, .treeview-black li.lastExpandable { background-image: url(images/treeview-black.gif); }
+
+.treeview-gray li { background-image: url(images/treeview-gray-line.gif); }
+.treeview-gray .hitarea, .treeview-gray li.lastCollapsable, .treeview-gray li.lastExpandable { background-image: url(images/treeview-gray.gif); }
+
+.treeview-famfamfam li { background-image: url(images/treeview-famfamfam-line.gif); }
+.treeview-famfamfam .hitarea, .treeview-famfamfam li.lastCollapsable, .treeview-famfamfam li.lastExpandable { background-image: url(images/treeview-famfamfam.gif); }
+
+.treeview .placeholder {
+	background: url(images/ajax-loader.gif) 0 0 no-repeat;
+	height: 16px;
+	width: 16px;
+	display: block;
+}
+
+.filetree li { padding: 3px 0 2px 16px; }
+.filetree span.folder, .filetree span.file { padding: 1px 0 1px 16px; display: block; }
+.filetree span.folder { background: url(images/folder.gif) 0 0 no-repeat; }
+.filetree li.expandable span.folder { background: url(images/folder-closed.gif) 0 0 no-repeat; }
+.filetree span.file { background: url(images/file.gif) 0 0 no-repeat; }
diff --git a/vendor/golang.org/x/tools/godoc/static/jquery.treeview.edit.js b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.edit.js
new file mode 100644
index 0000000..9895b02
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.edit.js
@@ -0,0 +1,39 @@
+/* https://github.com/jzaefferer/jquery-treeview/blob/master/jquery.treeview.edit.js */
+/* License: MIT. */
+(function($) {
+	var CLASSES = $.treeview.classes;
+	var proxied = $.fn.treeview;
+	$.fn.treeview = function(settings) {
+		settings = $.extend({}, settings);
+		if (settings.add) {
+			return this.trigger("add", [settings.add]);
+		}
+		if (settings.remove) {
+			return this.trigger("remove", [settings.remove]);
+		}
+		return proxied.apply(this, arguments).bind("add", function(event, branches) {
+			$(branches).prev()
+				.removeClass(CLASSES.last)
+				.removeClass(CLASSES.lastCollapsable)
+				.removeClass(CLASSES.lastExpandable)
+			.find(">.hitarea")
+				.removeClass(CLASSES.lastCollapsableHitarea)
+				.removeClass(CLASSES.lastExpandableHitarea);
+			$(branches).find("li").andSelf().prepareBranches(settings).applyClasses(settings, $(this).data("toggler"));
+		}).bind("remove", function(event, branches) {
+			var prev = $(branches).prev();
+			var parent = $(branches).parent();
+			$(branches).remove();
+			prev.filter(":last-child").addClass(CLASSES.last)
+				.filter("." + CLASSES.expandable).replaceClass(CLASSES.last, CLASSES.lastExpandable).end()
+				.find(">.hitarea").replaceClass(CLASSES.expandableHitarea, CLASSES.lastExpandableHitarea).end()
+				.filter("." + CLASSES.collapsable).replaceClass(CLASSES.last, CLASSES.lastCollapsable).end()
+				.find(">.hitarea").replaceClass(CLASSES.collapsableHitarea, CLASSES.lastCollapsableHitarea);
+			if (parent.is(":not(:has(>))") && parent[0] != this) {
+				parent.parent().removeClass(CLASSES.collapsable).removeClass(CLASSES.expandable)
+				parent.siblings(".hitarea").andSelf().remove();
+			}
+		});
+	};
+	
+})(jQuery);
diff --git a/vendor/golang.org/x/tools/godoc/static/jquery.treeview.js b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.js
new file mode 100644
index 0000000..356af23
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/jquery.treeview.js
@@ -0,0 +1,256 @@
+/*
+ * Treeview 1.4.1 - jQuery plugin to hide and show branches of a tree
+ * 
+ * http://bassistance.de/jquery-plugins/jquery-plugin-treeview/
+ * http://docs.jquery.com/Plugins/Treeview
+ *
+ * Copyright (c) 2007 Jörn Zaefferer
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Revision: $Id: jquery.treeview.js 5759 2008-07-01 07:50:28Z joern.zaefferer $
+ *
+ */
+
+;(function($) {
+
+	// TODO rewrite as a widget, removing all the extra plugins
+	$.extend($.fn, {
+		swapClass: function(c1, c2) {
+			var c1Elements = this.filter('.' + c1);
+			this.filter('.' + c2).removeClass(c2).addClass(c1);
+			c1Elements.removeClass(c1).addClass(c2);
+			return this;
+		},
+		replaceClass: function(c1, c2) {
+			return this.filter('.' + c1).removeClass(c1).addClass(c2).end();
+		},
+		hoverClass: function(className) {
+			className = className || "hover";
+			return this.hover(function() {
+				$(this).addClass(className);
+			}, function() {
+				$(this).removeClass(className);
+			});
+		},
+		heightToggle: function(animated, callback) {
+			animated ?
+				this.animate({ height: "toggle" }, animated, callback) :
+				this.each(function(){
+					jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
+					if(callback)
+						callback.apply(this, arguments);
+				});
+		},
+		heightHide: function(animated, callback) {
+			if (animated) {
+				this.animate({ height: "hide" }, animated, callback);
+			} else {
+				this.hide();
+				if (callback)
+					this.each(callback);				
+			}
+		},
+		prepareBranches: function(settings) {
+			if (!settings.prerendered) {
+				// mark last tree items
+				this.filter(":last-child:not(ul)").addClass(CLASSES.last);
+				// collapse whole tree, or only those marked as closed, anyway except those marked as open
+				this.filter((settings.collapsed ? "" : "." + CLASSES.closed) + ":not(." + CLASSES.open + ")").find(">ul").hide();
+			}
+			// return all items with sublists
+			return this.filter(":has(>ul)");
+		},
+		applyClasses: function(settings, toggler) {
+			// TODO use event delegation
+			this.filter(":has(>ul):not(:has(>a))").find(">span").unbind("click.treeview").bind("click.treeview", function(event) {
+				// don't handle click events on children, eg. checkboxes
+				if ( this == event.target )
+					toggler.apply($(this).next());
+			}).add( $("a", this) ).hoverClass();
+			
+			if (!settings.prerendered) {
+				// handle closed ones first
+				this.filter(":has(>ul:hidden)")
+						.addClass(CLASSES.expandable)
+						.replaceClass(CLASSES.last, CLASSES.lastExpandable);
+						
+				// handle open ones
+				this.not(":has(>ul:hidden)")
+						.addClass(CLASSES.collapsable)
+						.replaceClass(CLASSES.last, CLASSES.lastCollapsable);
+						
+	            // create hitarea if not present
+				var hitarea = this.find("div." + CLASSES.hitarea);
+				if (!hitarea.length)
+					hitarea = this.prepend("<div class=\"" + CLASSES.hitarea + "\"/>").find("div." + CLASSES.hitarea);
+				hitarea.removeClass().addClass(CLASSES.hitarea).each(function() {
+					var classes = "";
+					$.each($(this).parent().attr("class").split(" "), function() {
+						classes += this + "-hitarea ";
+					});
+					$(this).addClass( classes );
+				})
+			}
+			
+			// apply event to hitarea
+			this.find("div." + CLASSES.hitarea).click( toggler );
+		},
+		treeview: function(settings) {
+			
+			settings = $.extend({
+				cookieId: "treeview"
+			}, settings);
+			
+			if ( settings.toggle ) {
+				var callback = settings.toggle;
+				settings.toggle = function() {
+					return callback.apply($(this).parent()[0], arguments);
+				};
+			}
+		
+			// factory for treecontroller
+			function treeController(tree, control) {
+				// factory for click handlers
+				function handler(filter) {
+					return function() {
+						// reuse toggle event handler, applying the elements to toggle
+						// start searching for all hitareas
+						toggler.apply( $("div." + CLASSES.hitarea, tree).filter(function() {
+							// for plain toggle, no filter is provided, otherwise we need to check the parent element
+							return filter ? $(this).parent("." + filter).length : true;
+						}) );
+						return false;
+					};
+				}
+				// click on first element to collapse tree
+				$("a:eq(0)", control).click( handler(CLASSES.collapsable) );
+				// click on second to expand tree
+				$("a:eq(1)", control).click( handler(CLASSES.expandable) );
+				// click on third to toggle tree
+				$("a:eq(2)", control).click( handler() ); 
+			}
+		
+			// handle toggle event
+			function toggler() {
+				$(this)
+					.parent()
+					// swap classes for hitarea
+					.find(">.hitarea")
+						.swapClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+						.swapClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea )
+					.end()
+					// swap classes for parent li
+					.swapClass( CLASSES.collapsable, CLASSES.expandable )
+					.swapClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+					// find child lists
+					.find( ">ul" )
+					// toggle them
+					.heightToggle( settings.animated, settings.toggle );
+				if ( settings.unique ) {
+					$(this).parent()
+						.siblings()
+						// swap classes for hitarea
+						.find(">.hitarea")
+							.replaceClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+							.replaceClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea )
+						.end()
+						.replaceClass( CLASSES.collapsable, CLASSES.expandable )
+						.replaceClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+						.find( ">ul" )
+						.heightHide( settings.animated, settings.toggle );
+				}
+			}
+			this.data("toggler", toggler);
+			
+			function serialize() {
+				function binary(arg) {
+					return arg ? 1 : 0;
+				}
+				var data = [];
+				branches.each(function(i, e) {
+					data[i] = $(e).is(":has(>ul:visible)") ? 1 : 0;
+				});
+				$.cookie(settings.cookieId, data.join(""), settings.cookieOptions );
+			}
+			
+			function deserialize() {
+				var stored = $.cookie(settings.cookieId);
+				if ( stored ) {
+					var data = stored.split("");
+					branches.each(function(i, e) {
+						$(e).find(">ul")[ parseInt(data[i]) ? "show" : "hide" ]();
+					});
+				}
+			}
+			
+			// add treeview class to activate styles
+			this.addClass("treeview");
+			
+			// prepare branches and find all tree items with child lists
+			var branches = this.find("li").prepareBranches(settings);
+			
+			switch(settings.persist) {
+			case "cookie":
+				var toggleCallback = settings.toggle;
+				settings.toggle = function() {
+					serialize();
+					if (toggleCallback) {
+						toggleCallback.apply(this, arguments);
+					}
+				};
+				deserialize();
+				break;
+			case "location":
+				var current = this.find("a").filter(function() {
+					return this.href.toLowerCase() == location.href.toLowerCase();
+				});
+				if ( current.length ) {
+					// TODO update the open/closed classes
+					var items = current.addClass("selected").parents("ul, li").add( current.next() ).show();
+					if (settings.prerendered) {
+						// if prerendered is on, replicate the basic class swapping
+						items.filter("li")
+							.swapClass( CLASSES.collapsable, CLASSES.expandable )
+							.swapClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+							.find(">.hitarea")
+								.swapClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+								.swapClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea );
+					}
+				}
+				break;
+			}
+			
+			branches.applyClasses(settings, toggler);
+				
+			// if control option is set, create the treecontroller and show it
+			if ( settings.control ) {
+				treeController(this, settings.control);
+				$(settings.control).show();
+			}
+			
+			return this;
+		}
+	});
+	
+	// classes used by the plugin
+	// need to be styled via external stylesheet, see first example
+	$.treeview = {};
+	var CLASSES = ($.treeview.classes = {
+		open: "open",
+		closed: "closed",
+		expandable: "expandable",
+		expandableHitarea: "expandable-hitarea",
+		lastExpandableHitarea: "lastExpandable-hitarea",
+		collapsable: "collapsable",
+		collapsableHitarea: "collapsable-hitarea",
+		lastCollapsableHitarea: "lastCollapsable-hitarea",
+		lastCollapsable: "lastCollapsable",
+		lastExpandable: "lastExpandable",
+		last: "last",
+		hitarea: "hitarea"
+	});
+	
+})(jQuery);
diff --git a/vendor/golang.org/x/tools/godoc/static/makestatic.go b/vendor/golang.org/x/tools/godoc/static/makestatic.go
new file mode 100644
index 0000000..8ee8e55
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/makestatic.go
@@ -0,0 +1,127 @@
+// 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.
+
+// +build ignore
+
+// Command makestatic reads a set of files and writes a Go source file to "static.go"
+// that declares a map of string constants containing contents of the input files.
+// It is intended to be invoked via "go generate" (directive in "gen.go").
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"time"
+	"unicode/utf8"
+)
+
+var files = []string{
+	"analysis/call3.png",
+	"analysis/call-eg.png",
+	"analysis/callers1.png",
+	"analysis/callers2.png",
+	"analysis/chan1.png",
+	"analysis/chan2a.png",
+	"analysis/chan2b.png",
+	"analysis/error1.png",
+	"analysis/help.html",
+	"analysis/ident-def.png",
+	"analysis/ident-field.png",
+	"analysis/ident-func.png",
+	"analysis/ipcg-func.png",
+	"analysis/ipcg-pkg.png",
+	"analysis/typeinfo-pkg.png",
+	"analysis/typeinfo-src.png",
+	"callgraph.html",
+	"codewalk.html",
+	"codewalkdir.html",
+	"dirlist.html",
+	"error.html",
+	"example.html",
+	"godoc.html",
+	"godocs.js",
+	"images/minus.gif",
+	"images/plus.gif",
+	"images/treeview-black-line.gif",
+	"images/treeview-black.gif",
+	"images/treeview-default-line.gif",
+	"images/treeview-default.gif",
+	"images/treeview-gray-line.gif",
+	"images/treeview-gray.gif",
+	"implements.html",
+	"jquery.js",
+	"jquery.treeview.css",
+	"jquery.treeview.edit.js",
+	"jquery.treeview.js",
+	"methodset.html",
+	"opensearch.xml",
+	"package.html",
+	"package.txt",
+	"play.js",
+	"playground.js",
+	"search.html",
+	"search.txt",
+	"searchcode.html",
+	"searchdoc.html",
+	"searchtxt.html",
+	"style.css",
+}
+
+func main() {
+	if err := makestatic(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func makestatic() error {
+	f, err := os.Create("static.go")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	buf := new(bytes.Buffer)
+	fmt.Fprintf(buf, "%v\n\n%v\n\npackage static\n\n", license, warning)
+	fmt.Fprintf(buf, "var Files = map[string]string{\n")
+	for _, fn := range files {
+		b, err := ioutil.ReadFile(fn)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(buf, "\t%q: ", fn)
+		if utf8.Valid(b) {
+			fmt.Fprintf(buf, "`%s`", sanitize(b))
+		} else {
+			fmt.Fprintf(buf, "%q", b)
+		}
+		fmt.Fprintln(buf, ",\n")
+	}
+	fmt.Fprintln(buf, "}")
+	fmtbuf, err := format.Source(buf.Bytes())
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile("static.go", fmtbuf, 0666)
+}
+
+// sanitize prepares a valid UTF-8 string as a raw string constant.
+func sanitize(b []byte) []byte {
+	// Replace ` with `+"`"+`
+	b = bytes.Replace(b, []byte("`"), []byte("`+\"`\"+`"), -1)
+
+	// Replace BOM with `+"\xEF\xBB\xBF"+`
+	// (A BOM is valid UTF-8 but not permitted in Go source files.
+	// I wouldn't bother handling this, but for some insane reason
+	// jquery.js has a BOM somewhere in the middle.)
+	return bytes.Replace(b, []byte("\xEF\xBB\xBF"), []byte("`+\"\\xEF\\xBB\\xBF\"+`"), -1)
+}
+
+const warning = `// Code generated by "makestatic"; DO NOT EDIT.`
+
+var license = fmt.Sprintf(`// Copyright %d 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.`, time.Now().UTC().Year())
diff --git a/vendor/golang.org/x/tools/godoc/static/methodset.html b/vendor/golang.org/x/tools/godoc/static/methodset.html
new file mode 100644
index 0000000..1b339e3
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/methodset.html
@@ -0,0 +1,9 @@
+<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Method set</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Method set</span></p>
+		<div style="margin-left: 1in" id='methodset-{{.Index}}'>...</div>
+	</div>
+</div>
diff --git a/vendor/golang.org/x/tools/godoc/static/opensearch.xml b/vendor/golang.org/x/tools/godoc/static/opensearch.xml
new file mode 100644
index 0000000..1b652db
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/opensearch.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
+  <ShortName>godoc</ShortName>
+  <Description>The Go Programming Language</Description>
+  <Tags>go golang</Tags>
+  <Contact />
+  <Url type="text/html" template="{{.BaseURL}}/search?q={searchTerms}" />
+  <Image height="15" width="16" type="image/x-icon">/favicon.ico</Image>
+  <OutputEncoding>UTF-8</OutputEncoding>
+  <InputEncoding>UTF-8</InputEncoding>
+</OpenSearchDescription>
diff --git a/vendor/golang.org/x/tools/godoc/static/package.html b/vendor/golang.org/x/tools/godoc/static/package.html
new file mode 100644
index 0000000..9c81890
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/package.html
@@ -0,0 +1,337 @@
+<!--
+	Copyright 2009 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.
+-->
+<!--
+	Note: Static (i.e., not template-generated) href and id
+	attributes start with "pkg-" to make it impossible for
+	them to conflict with generated attributes (some of which
+	correspond to Go identifiers).
+-->
+{{with .PDoc}}
+	<script type='text/javascript'>
+	document.ANALYSIS_DATA = {{$.AnalysisData}};
+	document.CALLGRAPH = {{$.CallGraph}};
+	</script>
+
+	{{if $.IsMain}}
+		{{/* command documentation */}}
+		{{comment_html .Doc}}
+	{{else}}
+		{{/* package documentation */}}
+		<div id="short-nav">
+			<dl>
+			<dd><code>import "{{html .ImportPath}}"</code></dd>
+			</dl>
+			<dl>
+			<dd><a href="#pkg-overview" class="overviewLink">Overview</a></dd>
+			<dd><a href="#pkg-index" class="indexLink">Index</a></dd>
+			{{if $.Examples}}
+				<dd><a href="#pkg-examples" class="examplesLink">Examples</a></dd>
+			{{end}}
+			{{if $.Dirs}}
+				<dd><a href="#pkg-subdirectories">Subdirectories</a></dd>
+			{{end}}
+			</dl>
+		</div>
+		<!-- The package's Name is printed as title by the top-level template -->
+		<div id="pkg-overview" class="toggleVisible">
+			<div class="collapsed">
+				<h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
+			</div>
+			<div class="expanded">
+				<h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
+				{{comment_html .Doc}}
+				{{example_html $ ""}}
+			</div>
+		</div>
+
+		<div id="pkg-index" class="toggleVisible">
+		<div class="collapsed">
+			<h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
+		</div>
+		<div class="expanded">
+			<h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>
+
+		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
+			<div id="manual-nav">
+			<dl>
+			{{if .Consts}}
+				<dd><a href="#pkg-constants">Constants</a></dd>
+			{{end}}
+			{{if .Vars}}
+				<dd><a href="#pkg-variables">Variables</a></dd>
+			{{end}}
+			{{range .Funcs}}
+				{{$name_html := html .Name}}
+				<dd><a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+			{{end}}
+			{{range .Types}}
+				{{$tname_html := html .Name}}
+				<dd><a href="#{{$tname_html}}">type {{$tname_html}}</a></dd>
+				{{range .Funcs}}
+					{{$name_html := html .Name}}
+					<dd>&nbsp; &nbsp; <a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+				{{end}}
+				{{range .Methods}}
+					{{$name_html := html .Name}}
+					<dd>&nbsp; &nbsp; <a href="#{{$tname_html}}.{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+				{{end}}
+			{{end}}
+			{{if $.Notes}}
+				{{range $marker, $item := $.Notes}}
+				<dd><a href="#pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</a></dd>
+				{{end}}
+			{{end}}
+			</dl>
+			</div><!-- #manual-nav -->
+
+		{{if $.Examples}}
+		<div id="pkg-examples">
+			<h3>Examples</h3>
+			<dl>
+			{{range $.Examples}}
+			<dd><a class="exampleLink" href="#example_{{.Name}}">{{example_name .Name}}</a></dd>
+			{{end}}
+			</dl>
+		</div>
+		{{end}}
+
+		{{with .Filenames}}
+			<h3>Package files</h3>
+			<p>
+			<span style="font-size:90%">
+			{{range .}}
+				<a href="{{.|srcLink|html}}">{{.|filename|html}}</a>
+			{{end}}
+			</span>
+			</p>
+		{{end}}
+		</div><!-- .expanded -->
+		</div><!-- #pkg-index -->
+
+		<div id="pkg-callgraph" class="toggle" style="display: none">
+		<div class="collapsed">
+			<h2 class="toggleButton" title="Click to show Internal Call Graph section">Internal call graph ▹</h2>
+		</div> <!-- .expanded -->
+		<div class="expanded">
+			<h2 class="toggleButton" title="Click to hide Internal Call Graph section">Internal call graph ▾</h2>
+			<p>
+			  In the call graph viewer below, each node
+			  is a function belonging to this package
+			  and its children are the functions it
+			  calls&mdash;perhaps dynamically.
+			</p>
+			<p>
+			  The root nodes are the entry points of the
+			  package: functions that may be called from
+			  outside the package.
+			  There may be non-exported or anonymous
+			  functions among them if they are called
+			  dynamically from another package.
+			</p>
+			<p>
+			  Click a node to visit that function's source code.
+			  From there you can visit its callers by
+			  clicking its declaring <code>func</code>
+			  token.
+			</p>
+			<p>
+			  Functions may be omitted if they were
+			  determined to be unreachable in the
+			  particular programs or tests that were
+			  analyzed.
+			</p>
+			<!-- Zero means show all package entry points. -->
+			<ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
+		</div>
+		</div> <!-- #pkg-callgraph -->
+
+		{{with .Consts}}
+			<h2 id="pkg-constants">Constants</h2>
+			{{range .}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+		{{end}}
+		{{with .Vars}}
+			<h2 id="pkg-variables">Variables</h2>
+			{{range .}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+		{{end}}
+		{{range .Funcs}}
+			{{/* Name is a string - no need for FSet */}}
+			{{$name_html := html .Name}}
+			<h2 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+				<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
+			</h2>
+			<pre>{{node_html $ .Decl true}}</pre>
+			{{comment_html .Doc}}
+			{{example_html $ .Name}}
+			{{callgraph_html $ "" .Name}}
+
+		{{end}}
+		{{range .Types}}
+			{{$tname := .Name}}
+			{{$tname_html := html .Name}}
+			<h2 id="{{$tname_html}}">type <a href="{{posLink_url $ .Decl}}">{{$tname_html}}</a>
+				<a class="permalink" href="#{{$tname_html}}">&#xb6;</a>
+			</h2>
+			{{comment_html .Doc}}
+			<pre>{{node_html $ .Decl true}}</pre>
+
+			{{range .Consts}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+
+			{{range .Vars}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+
+			{{example_html $ $tname}}
+			{{implements_html $ $tname}}
+			{{methodset_html $ $tname}}
+
+			{{range .Funcs}}
+				{{$name_html := html .Name}}
+				<h3 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+					<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
+				</h3>
+				<pre>{{node_html $ .Decl true}}</pre>
+				{{comment_html .Doc}}
+				{{example_html $ .Name}}
+				{{callgraph_html $ "" .Name}}
+			{{end}}
+
+			{{range .Methods}}
+				{{$name_html := html .Name}}
+				<h3 id="{{$tname_html}}.{{$name_html}}">func ({{html .Recv}}) <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+					<a class="permalink" href="#{{$tname_html}}.{{$name_html}}">&#xb6;</a>
+				</h3>
+				<pre>{{node_html $ .Decl true}}</pre>
+				{{comment_html .Doc}}
+				{{$name := printf "%s_%s" $tname .Name}}
+				{{example_html $ $name}}
+				{{callgraph_html $ .Recv .Name}}
+			{{end}}
+		{{end}}
+	{{end}}
+
+	{{with $.Notes}}
+		{{range $marker, $content := .}}
+			<h2 id="pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</h2>
+			<ul style="list-style: none; padding: 0;">
+			{{range .}}
+			<li><a href="{{posLink_url $ .}}" style="float: left;">&#x261e;</a> {{comment_html .Body}}</li>
+			{{end}}
+			</ul>
+		{{end}}
+	{{end}}
+{{end}}
+
+{{with .PAst}}
+	{{range $filename, $ast := .}}
+		<a href="{{$filename|srcLink|html}}">{{$filename|filename|html}}</a>:<pre>{{node_html $ $ast false}}</pre>
+	{{end}}
+{{end}}
+
+{{with .Dirs}}
+	{{/* DirList entries are numbers and strings - no need for FSet */}}
+	{{if $.PDoc}}
+		<h2 id="pkg-subdirectories">Subdirectories</h2>
+	{{end}}
+	{{if eq $.Dirname "/src"}}
+		<div id="manual-nav">
+			<dl>
+				<dt><a href="#stdlib">Standard library</a></dt>
+				<dt><a href="#other">Other packages</a></dt>
+				<dd><a href="#subrepo">Sub-repositories</a></dd>
+				<dd><a href="#community">Community</a></dd>
+			</dl>
+		</div>
+		<h2 id="stdlib">Standard library</h2>
+		<img alt="" class="gopher" src="/doc/gopher/pkg.png"/>
+	{{end}}
+
+
+	<div class="pkg-dir">
+		<table>
+			<tr>
+				<th class="pkg-name">Name</th>
+				<th class="pkg-synopsis">Synopsis</th>
+			</tr>
+
+			{{if not (or (eq $.Dirname "/src") (eq $.Dirname "/src/cmd") $.DirFlat)}}
+			<tr>
+				<td colspan="2"><a href="..">..</a></td>
+			</tr>
+			{{end}}
+
+			{{range .List}}
+				{{if $.DirFlat}}
+					{{if .HasPkg}}
+						<tr>
+							<td class="pkg-name">
+								<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Path}}</a>
+							</td>
+							<td class="pkg-synopsis">
+								{{html .Synopsis}}
+							</td>
+						</tr>
+					{{end}}
+				{{else}}
+					<tr>
+						<td class="pkg-name" style="padding-left: {{multiply .Depth 20}}px;">
+							<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
+						</td>
+						<td class="pkg-synopsis">
+							{{html .Synopsis}}
+						</td>
+					</tr>
+				{{end}}
+			{{end}}
+		</table>
+	</div>
+
+
+	{{if eq $.Dirname "/src"}}
+	<h2 id="other">Other packages</h2>
+
+	<h3 id="subrepo">Sub-repositories</h3>
+	<p>
+	These packages are part of the Go Project but outside the main Go tree.
+	They are developed under looser <a href="/doc/go1compat">compatibility requirements</a> than the Go core.
+	Install them with "<a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies">go get</a>".
+	</p>
+	<ul>
+		<li><a href="//godoc.org/golang.org/x/benchmarks">benchmarks</a> — benchmarks to measure Go as it is developed.</li>
+		<li><a href="//godoc.org/golang.org/x/blog">blog</a> — <a href="//blog.golang.org">blog.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/build">build</a> — <a href="//build.golang.org">build.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/crypto">crypto</a> — additional cryptography packages.</li>
+		<li><a href="//godoc.org/golang.org/x/debug">debug</a> — an experimental debugger for Go.</li>
+		<li><a href="//godoc.org/golang.org/x/image">image</a> — additional imaging packages.</li>
+		<li><a href="//godoc.org/golang.org/x/mobile">mobile</a> — experimental support for Go on mobile platforms.</li>
+		<li><a href="//godoc.org/golang.org/x/net">net</a> — additional networking packages.</li>
+		<li><a href="//godoc.org/golang.org/x/sys">sys</a> — packages for making system calls.</li>
+		<li><a href="//godoc.org/golang.org/x/text">text</a> — packages for working with text.</li>
+		<li><a href="//godoc.org/golang.org/x/tools">tools</a> — godoc, goimports, gorename, and other tools.</li>
+		<li><a href="//godoc.org/golang.org/x/tour">tour</a> — <a href="//tour.golang.org">tour.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/exp">exp</a> — experimental and deprecated packages (handle with care; may change without warning).</li>
+	</ul>
+
+	<h3 id="community">Community</h3>
+	<p>
+	These services can help you find Open Source packages provided by the community.
+	</p>
+	<ul>
+		<li><a href="//godoc.org">GoDoc</a> - a package index and search engine.</li>
+		<li><a href="http://go-search.org">Go Search</a> - a code search engine.</li>
+		<li><a href="/wiki/Projects">Projects at the Go Wiki</a> - a curated list of Go projects.</li>
+	</ul>
+	{{end}}
+{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/package.txt b/vendor/golang.org/x/tools/godoc/static/package.txt
new file mode 100644
index 0000000..e53fa6e
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/package.txt
@@ -0,0 +1,116 @@
+{{$info := .}}{{$filtered := .IsFiltered}}{{/*
+
+---------------------------------------
+
+*/}}{{if $filtered}}{{range .PAst}}{{range .Decls}}{{node $info .}}
+
+{{end}}{{end}}{{else}}{{with .PAst}}{{range $filename, $ast := .}}{{$filename}}:
+{{node $ $ast}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if and $filtered (not (or .PDoc .PAst))}}No match found.
+{{end}}{{with .PDoc}}{{if $.IsMain}}COMMAND DOCUMENTATION
+
+{{comment_text .Doc "    " "\t"}}
+{{else}}{{if not $filtered}}PACKAGE DOCUMENTATION
+
+package {{.Name}}
+    import "{{.ImportPath}}"
+
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ "" "    "}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Consts}}{{if not $filtered}}CONSTANTS
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Vars}}{{if not $filtered}}VARIABLES
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Funcs}}{{if not $filtered}}FUNCTIONS
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ .Name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Types}}{{if not $filtered}}TYPES
+
+{{end}}{{range .}}{{$tname := .Name}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{/*
+
+---------------------------------------
+
+*/}}{{if .Consts}}{{range .Consts}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Vars}}{{range .Vars}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{range $name := .Names}}{{example_text $ $name "    "}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Funcs}}{{range .Funcs}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ .Name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Methods}}{{range .Methods}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{$name := printf "%s_%s" $tname .Name}}{{example_text $ $name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if and $filtered (not (or .Consts (or .Vars (or .Funcs .Types))))}}No match found.
+{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with $.Notes}}
+{{range $marker, $content := .}}
+{{$marker}}S
+
+{{range $content}}{{comment_text .Body "   " "\t"}}
+{{end}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if not $filtered}}{{with .Dirs}}SUBDIRECTORIES
+{{if $.DirFlat}}{{range .List}}{{if .HasPkg}}
+	{{.Path}}{{end}}{{end}}
+{{else}}{{range .List}}
+	{{repeat `. ` .Depth}}{{.Name}}{{end}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{/*
+Make sure there is no newline at the end of this file.
+perl -i -pe 'chomp if eof' package.txt
+*/}}
diff --git a/vendor/golang.org/x/tools/godoc/static/play.js b/vendor/golang.org/x/tools/godoc/static/play.js
new file mode 100644
index 0000000..6adbd6c
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/play.js
@@ -0,0 +1,114 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+function initPlayground(transport) {
+	'use strict';
+
+	function text(node) {
+		var s = '';
+		for (var i = 0; i < node.childNodes.length; i++) {
+			var n = node.childNodes[i];
+			if (n.nodeType === 1) {
+				if (n.tagName === 'BUTTON') continue
+				if (n.tagName === 'SPAN' && n.className === 'number') continue;
+				if (n.tagName === 'DIV' || n.tagName == 'BR') {
+					s += "\n";
+				}
+				s += text(n);
+				continue;
+			}
+			if (n.nodeType === 3) {
+				s += n.nodeValue;
+			}
+		}
+		return s.replace('\xA0', ' '); // replace non-breaking spaces
+	}
+
+	// When presenter notes are enabled, the index passed
+	// here will identify the playground to be synced
+	function init(code, index) {
+		var output = document.createElement('div');
+		var outpre = document.createElement('pre');
+		var running;
+
+		if ($ && $(output).resizable) {
+			$(output).resizable({
+				handles: 	'n,w,nw',
+				minHeight:	27,
+				minWidth:	135,
+				maxHeight:	608,
+				maxWidth:	990
+			});
+		}
+
+		function onKill() {
+			if (running) running.Kill();
+			if (window.notesEnabled) updatePlayStorage('onKill', index);
+		}
+
+		function onRun(e) {
+			var sk = e.shiftKey || localStorage.getItem('play-shiftKey') === 'true';
+			if (running) running.Kill();
+			output.style.display = 'block';
+			outpre.innerHTML = '';
+			run1.style.display = 'none';
+			var options = {Race: sk};
+			running = transport.Run(text(code), PlaygroundOutput(outpre), options);
+			if (window.notesEnabled) updatePlayStorage('onRun', index, e);
+		}
+
+		function onClose() {
+			if (running) running.Kill();
+			output.style.display = 'none';
+			run1.style.display = 'inline-block';
+			if (window.notesEnabled) updatePlayStorage('onClose', index);
+		}
+
+		if (window.notesEnabled) {
+			playgroundHandlers.onRun.push(onRun);
+			playgroundHandlers.onClose.push(onClose);
+			playgroundHandlers.onKill.push(onKill);
+		}
+
+		var run1 = document.createElement('button');
+		run1.innerHTML = 'Run';
+		run1.className = 'run';
+		run1.addEventListener("click", onRun, false);
+		var run2 = document.createElement('button');
+		run2.className = 'run';
+		run2.innerHTML = 'Run';
+		run2.addEventListener("click", onRun, false);
+		var kill = document.createElement('button');
+		kill.className = 'kill';
+		kill.innerHTML = 'Kill';
+		kill.addEventListener("click", onKill, false);
+		var close = document.createElement('button');
+		close.className = 'close';
+		close.innerHTML = 'Close';
+		close.addEventListener("click", onClose, false);
+
+		var button = document.createElement('div');
+		button.classList.add('buttons');
+		button.appendChild(run1);
+		// Hack to simulate insertAfter
+		code.parentNode.insertBefore(button, code.nextSibling);
+
+		var buttons = document.createElement('div');
+		buttons.classList.add('buttons');
+		buttons.appendChild(run2);
+		buttons.appendChild(kill);
+		buttons.appendChild(close);
+
+		output.classList.add('output');
+		output.appendChild(buttons);
+		output.appendChild(outpre);
+		output.style.display = 'none';
+		code.parentNode.insertBefore(output, button.nextSibling);
+	}
+
+	var play = document.querySelectorAll('div.playground');
+	for (var i = 0; i < play.length; i++) {
+		init(play[i], i);
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/static/playground.js b/vendor/golang.org/x/tools/godoc/static/playground.js
new file mode 100644
index 0000000..e8242a0
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/playground.js
@@ -0,0 +1,473 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+In the absence of any formal way to specify interfaces in JavaScript,
+here's a skeleton implementation of a playground transport.
+
+        function Transport() {
+                // Set up any transport state (eg, make a websocket connection).
+                return {
+                        Run: function(body, output, options) {
+                                // Compile and run the program 'body' with 'options'.
+				// Call the 'output' callback to display program output.
+                                return {
+                                        Kill: function() {
+                                                // Kill the running program.
+                                        }
+                                };
+                        }
+                };
+        }
+
+	// The output callback is called multiple times, and each time it is
+	// passed an object of this form.
+        var write = {
+                Kind: 'string', // 'start', 'stdout', 'stderr', 'end'
+                Body: 'string'  // content of write or end status message
+        }
+
+	// The first call must be of Kind 'start' with no body.
+	// Subsequent calls may be of Kind 'stdout' or 'stderr'
+	// and must have a non-null Body string.
+	// The final call should be of Kind 'end' with an optional
+	// Body string, signifying a failure ("killed", for example).
+
+	// The output callback must be of this form.
+	// See PlaygroundOutput (below) for an implementation.
+        function outputCallback(write) {
+        }
+*/
+
+function HTTPTransport() {
+	'use strict';
+
+	// TODO(adg): support stderr
+
+	function playback(output, events) {
+		var timeout;
+		output({Kind: 'start'});
+		function next() {
+			if (!events || events.length === 0) {
+				output({Kind: 'end'});
+				return;
+			}
+			var e = events.shift();
+			if (e.Delay === 0) {
+				output({Kind: 'stdout', Body: e.Message});
+				next();
+				return;
+			}
+			timeout = setTimeout(function() {
+				output({Kind: 'stdout', Body: e.Message});
+				next();
+			}, e.Delay / 1000000);
+		}
+		next();
+		return {
+			Stop: function() {
+				clearTimeout(timeout);
+			}
+		}
+	}
+
+	function error(output, msg) {
+		output({Kind: 'start'});
+		output({Kind: 'stderr', Body: msg});
+		output({Kind: 'end'});
+	}
+
+	var seq = 0;
+	return {
+		Run: function(body, output, options) {
+			seq++;
+			var cur = seq;
+			var playing;
+			$.ajax('/compile', {
+				type: 'POST',
+				data: {'version': 2, 'body': body},
+				dataType: 'json',
+				success: function(data) {
+					if (seq != cur) return;
+					if (!data) return;
+					if (playing != null) playing.Stop();
+					if (data.Errors) {
+						error(output, data.Errors);
+						return;
+					}
+					playing = playback(output, data.Events);
+				},
+				error: function() {
+					error(output, 'Error communicating with remote server.');
+				}
+			});
+			return {
+				Kill: function() {
+					if (playing != null) playing.Stop();
+					output({Kind: 'end', Body: 'killed'});
+				}
+			};
+		}
+	};
+}
+
+function SocketTransport() {
+	'use strict';
+
+	var id = 0;
+	var outputs = {};
+	var started = {};
+	var websocket;
+	if (window.location.protocol == "http:") {
+		websocket = new WebSocket('ws://' + window.location.host + '/socket');
+	} else if (window.location.protocol == "https:") {
+		websocket = new WebSocket('wss://' + window.location.host + '/socket');
+	}
+
+	websocket.onclose = function() {
+		console.log('websocket connection closed');
+	}
+
+	websocket.onmessage = function(e) {
+		var m = JSON.parse(e.data);
+		var output = outputs[m.Id];
+		if (output === null)
+			return;
+		if (!started[m.Id]) {
+			output({Kind: 'start'});
+			started[m.Id] = true;
+		}
+		output({Kind: m.Kind, Body: m.Body});
+	}
+
+	function send(m) {
+		websocket.send(JSON.stringify(m));
+	}
+
+	return {
+		Run: function(body, output, options) {
+			var thisID = id+'';
+			id++;
+			outputs[thisID] = output;
+			send({Id: thisID, Kind: 'run', Body: body, Options: options});
+			return {
+				Kill: function() {
+					send({Id: thisID, Kind: 'kill'});
+				}
+			};
+		}
+	};
+}
+
+function PlaygroundOutput(el) {
+	'use strict';
+
+	return function(write) {
+		if (write.Kind == 'start') {
+			el.innerHTML = '';
+			return;
+		}
+
+		var cl = 'system';
+		if (write.Kind == 'stdout' || write.Kind == 'stderr')
+			cl = write.Kind;
+
+		var m = write.Body;
+		if (write.Kind == 'end') {
+			m = '\nProgram exited' + (m?(': '+m):'.');
+		}
+
+		if (m.indexOf('IMAGE:') === 0) {
+			// TODO(adg): buffer all writes before creating image
+			var url = 'data:image/png;base64,' + m.substr(6);
+			var img = document.createElement('img');
+			img.src = url;
+			el.appendChild(img);
+			return;
+		}
+
+		// ^L clears the screen.
+		var s = m.split('\x0c');
+		if (s.length > 1) {
+			el.innerHTML = '';
+			m = s.pop();
+		}
+
+		m = m.replace(/&/g, '&amp;');
+		m = m.replace(/</g, '&lt;');
+		m = m.replace(/>/g, '&gt;');
+
+		var needScroll = (el.scrollTop + el.offsetHeight) == el.scrollHeight;
+
+		var span = document.createElement('span');
+		span.className = cl;
+		span.innerHTML = m;
+		el.appendChild(span);
+
+		if (needScroll)
+			el.scrollTop = el.scrollHeight - el.offsetHeight;
+	}
+}
+
+(function() {
+  function lineHighlight(error) {
+    var regex = /prog.go:([0-9]+)/g;
+    var r = regex.exec(error);
+    while (r) {
+      $(".lines div").eq(r[1]-1).addClass("lineerror");
+      r = regex.exec(error);
+    }
+  }
+  function highlightOutput(wrappedOutput) {
+    return function(write) {
+      if (write.Body) lineHighlight(write.Body);
+      wrappedOutput(write);
+    }
+  }
+  function lineClear() {
+    $(".lineerror").removeClass("lineerror");
+  }
+
+  // opts is an object with these keys
+  //  codeEl - code editor element
+  //  outputEl - program output element
+  //  runEl - run button element
+  //  fmtEl - fmt button element (optional)
+  //  fmtImportEl - fmt "imports" checkbox element (optional)
+  //  shareEl - share button element (optional)
+  //  shareURLEl - share URL text input element (optional)
+  //  shareRedirect - base URL to redirect to on share (optional)
+  //  toysEl - toys select element (optional)
+  //  enableHistory - enable using HTML5 history API (optional)
+  //  transport - playground transport to use (default is HTTPTransport)
+  //  enableShortcuts - whether to enable shortcuts (Ctrl+S/Cmd+S to save) (default is false)
+  function playground(opts) {
+    var code = $(opts.codeEl);
+    var transport = opts['transport'] || new HTTPTransport();
+    var running;
+
+    // autoindent helpers.
+    function insertTabs(n) {
+      // find the selection start and end
+      var start = code[0].selectionStart;
+      var end   = code[0].selectionEnd;
+      // split the textarea content into two, and insert n tabs
+      var v = code[0].value;
+      var u = v.substr(0, start);
+      for (var i=0; i<n; i++) {
+        u += "\t";
+      }
+      u += v.substr(end);
+      // set revised content
+      code[0].value = u;
+      // reset caret position after inserted tabs
+      code[0].selectionStart = start+n;
+      code[0].selectionEnd = start+n;
+    }
+    function autoindent(el) {
+      var curpos = el.selectionStart;
+      var tabs = 0;
+      while (curpos > 0) {
+        curpos--;
+        if (el.value[curpos] == "\t") {
+          tabs++;
+        } else if (tabs > 0 || el.value[curpos] == "\n") {
+          break;
+        }
+      }
+      setTimeout(function() {
+        insertTabs(tabs);
+      }, 1);
+    }
+
+    // NOTE(cbro): e is a jQuery event, not a DOM event.
+    function handleSaveShortcut(e) {
+      if (e.isDefaultPrevented()) return false;
+      if (!e.metaKey && !e.ctrlKey) return false;
+      if (e.key != "S" && e.key != "s") return false;
+
+      e.preventDefault();
+
+      // Share and save
+      share(function(url) {
+        window.location.href = url + ".go?download=true";
+      });
+
+      return true;
+    }
+
+    function keyHandler(e) {
+      if (opts.enableShortcuts && handleSaveShortcut(e)) return;
+
+      if (e.keyCode == 9 && !e.ctrlKey) { // tab (but not ctrl-tab)
+        insertTabs(1);
+        e.preventDefault();
+        return false;
+      }
+      if (e.keyCode == 13) { // enter
+        if (e.shiftKey) { // +shift
+          run();
+          e.preventDefault();
+          return false;
+        } if (e.ctrlKey) { // +control
+          fmt();
+          e.preventDefault();
+        } else {
+          autoindent(e.target);
+        }
+      }
+      return true;
+    }
+    code.unbind('keydown').bind('keydown', keyHandler);
+    var outdiv = $(opts.outputEl).empty();
+    var output = $('<pre/>').appendTo(outdiv);
+
+    function body() {
+      return $(opts.codeEl).val();
+    }
+    function setBody(text) {
+      $(opts.codeEl).val(text);
+    }
+    function origin(href) {
+      return (""+href).split("/").slice(0, 3).join("/");
+    }
+
+    var pushedEmpty = (window.location.pathname == "/");
+    function inputChanged() {
+      if (pushedEmpty) {
+        return;
+      }
+      pushedEmpty = true;
+      $(opts.shareURLEl).hide();
+      window.history.pushState(null, "", "/");
+    }
+    function popState(e) {
+      if (e === null) {
+        return;
+      }
+      if (e && e.state && e.state.code) {
+        setBody(e.state.code);
+      }
+    }
+    var rewriteHistory = false;
+    if (window.history && window.history.pushState && window.addEventListener && opts.enableHistory) {
+      rewriteHistory = true;
+      code[0].addEventListener('input', inputChanged);
+      window.addEventListener('popstate', popState);
+    }
+
+    function setError(error) {
+      if (running) running.Kill();
+      lineClear();
+      lineHighlight(error);
+      output.empty().addClass("error").text(error);
+    }
+    function loading() {
+      lineClear();
+      if (running) running.Kill();
+      output.removeClass("error").text('Waiting for remote server...');
+    }
+    function run() {
+      loading();
+      running = transport.Run(body(), highlightOutput(PlaygroundOutput(output[0])));
+    }
+
+    function fmt() {
+      loading();
+      var data = {"body": body()};
+      if ($(opts.fmtImportEl).is(":checked")) {
+        data["imports"] = "true";
+      }
+      $.ajax("/fmt", {
+        data: data,
+        type: "POST",
+        dataType: "json",
+        success: function(data) {
+          if (data.Error) {
+            setError(data.Error);
+          } else {
+            setBody(data.Body);
+            setError("");
+          }
+        }
+      });
+    }
+
+    var shareURL; // jQuery element to show the shared URL.
+    var sharing = false; // true if there is a pending request.
+    var shareCallbacks = [];
+    function share(opt_callback) {
+      if (opt_callback) shareCallbacks.push(opt_callback);
+
+      if (sharing) return;
+      sharing = true;
+
+      var sharingData = body();
+      $.ajax("/share", {
+        processData: false,
+        data: sharingData,
+        type: "POST",
+        contentType: "text/plain; charset=utf-8",
+        complete: function(xhr) {
+          sharing = false;
+          if (xhr.status != 200) {
+            alert("Server error; try again.");
+            return;
+          }
+          if (opts.shareRedirect) {
+            window.location = opts.shareRedirect + xhr.responseText;
+          }
+          var path = "/p/" + xhr.responseText;
+          var url = origin(window.location) + path;
+
+          for (var i = 0; i < shareCallbacks.length; i++) {
+            shareCallbacks[i](url);
+          }
+          shareCallbacks = [];
+
+          if (shareURL) {
+            shareURL.show().val(url).focus().select();
+
+            if (rewriteHistory) {
+              var historyData = {"code": sharingData};
+              window.history.pushState(historyData, "", path);
+              pushedEmpty = false;
+            }
+          }
+        }
+      });
+    }
+
+    $(opts.runEl).click(run);
+    $(opts.fmtEl).click(fmt);
+
+    if (opts.shareEl !== null && (opts.shareURLEl !== null || opts.shareRedirect !== null)) {
+      if (opts.shareURLEl) {
+        shareURL = $(opts.shareURLEl).hide();
+      }
+      $(opts.shareEl).click(function() {
+        share();
+      });
+    }
+
+    if (opts.toysEl !== null) {
+      $(opts.toysEl).bind('change', function() {
+        var toy = $(this).val();
+        $.ajax("/doc/play/"+toy, {
+          processData: false,
+          type: "GET",
+          complete: function(xhr) {
+            if (xhr.status != 200) {
+              alert("Server error; try again.");
+              return;
+            }
+            setBody(xhr.responseText);
+          }
+        });
+      });
+    }
+  }
+
+  window.playground = playground;
+})();
diff --git a/vendor/golang.org/x/tools/godoc/static/search.html b/vendor/golang.org/x/tools/godoc/static/search.html
new file mode 100644
index 0000000..e0d13b9
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/search.html
@@ -0,0 +1,18 @@
+<!--
+	Copyright 2009 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.
+-->
+{{with .Alert}}
+	<p>
+	<span class="alert" style="font-size:120%">{{html .}}</span>
+	</p>
+{{end}}
+{{with .Alt}}
+	<p>
+	<span class="alert" style="font-size:120%">Did you mean: </span>
+	{{range .Alts}}
+		<a href="search?q={{urlquery .}}" style="font-size:120%">{{html .}}</a>
+	{{end}}
+	</p>
+{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/search.txt b/vendor/golang.org/x/tools/godoc/static/search.txt
new file mode 100644
index 0000000..0ae0c08
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/search.txt
@@ -0,0 +1,54 @@
+QUERY
+	{{.Query}}
+
+{{with .Alert}}{{.}}
+{{end}}{{/* .Alert */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Alt}}DID YOU MEAN
+
+{{range .Alts}}	{{.}}
+{{end}}
+{{end}}{{/* .Alt */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Pak}}PACKAGE {{$.Query}}
+
+{{range .}}	{{pkgLink .Pak.Path}}
+{{end}}
+{{end}}{{/* .Pak */}}{{/*
+
+---------------------------------------
+
+*/}}{{range $key, $val := .Idents}}{{if $val}}{{$key.Name}}
+{{range $val}}    {{.Path}}.{{.Name}}
+{{end}}
+{{end}}{{end}}{{/* .Idents */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Hit}}{{with .Decls}}PACKAGE-LEVEL DECLARATIONS
+
+{{range .}}package {{.Pak.Name}}
+{{range $file := .Files}}{{range .Groups}}{{range .}}	{{srcLink $file.File.Path}}:{{infoLine .}}{{end}}
+{{end}}{{end}}{{/* .Files */}}
+{{end}}{{end}}{{/* .Decls */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Others}}LOCAL DECLARATIONS AND USES
+
+{{range .}}package {{.Pak.Name}}
+{{range $file := .Files}}{{range .Groups}}{{range .}}	{{srcLink $file.File.Path}}:{{infoLine .}}
+{{end}}{{end}}{{end}}{{/* .Files */}}
+{{end}}{{end}}{{/* .Others */}}{{end}}{{/* .Hit */}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Textual}}{{if .Complete}}{{.Found}} TEXTUAL OCCURRENCES{{else}}MORE THAN {{.Found}} TEXTUAL OCCURRENCES{{end}}
+
+{{range .Textual}}{{len .Lines}}	{{srcLink .Filename}}
+{{end}}{{if not .Complete}}...	...
+{{end}}{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/searchcode.html b/vendor/golang.org/x/tools/godoc/static/searchcode.html
new file mode 100644
index 0000000..a032e64
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/searchcode.html
@@ -0,0 +1,64 @@
+<!--
+	Copyright 2009 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.
+-->
+{{$query_url := urlquery .Query}}
+{{if not .Idents}}
+	{{with .Pak}}
+		<h2 id="Packages">Package {{html $.Query}}</h2>
+		<p>
+		<table class="layout">
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<tr><td><a href="/{{$pkg_html}}">{{$pkg_html}}</a></td></tr>
+		{{end}}
+		</table>
+		</p>
+	{{end}}
+{{end}}
+{{with .Hit}}
+	{{with .Decls}}
+		<h2 id="Global">Package-level declarations</h2>
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<h3 id="Global_{{$pkg_html}}">package <a href="/{{$pkg_html}}">{{html .Pak.Name}}</a></h3>
+			{{range .Files}}
+				{{$file := .File.Path}}
+				{{range .Groups}}
+					{{range .}}
+						{{$line := infoLine .}}
+						<a href="{{queryLink $file $query_url $line | html}}">{{$file}}:{{$line}}</a>
+						{{infoSnippet_html .}}
+					{{end}}
+				{{end}}
+			{{end}}
+		{{end}}
+	{{end}}
+	{{with .Others}}
+		<h2 id="Local">Local declarations and uses</h2>
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<h3 id="Local_{{$pkg_html}}">package <a href="/{{$pkg_html}}">{{html .Pak.Name}}</a></h3>
+			{{range .Files}}
+				{{$file := .File.Path}}
+				<a href="{{queryLink $file $query_url 0 | html}}">{{$file}}</a>
+				<table class="layout">
+				{{range .Groups}}
+					<tr>
+					<td width="25"></td>
+					<th align="left" valign="top">{{index . 0 | infoKind_html}}</th>
+					<td align="left" width="4"></td>
+					<td>
+					{{range .}}
+						{{$line := infoLine .}}
+						<a href="{{queryLink $file $query_url $line | html}}">{{$line}}</a>
+					{{end}}
+					</td>
+					</tr>
+				{{end}}
+				</table>
+			{{end}}
+		{{end}}
+	{{end}}
+{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/searchdoc.html b/vendor/golang.org/x/tools/godoc/static/searchdoc.html
new file mode 100644
index 0000000..679c02c
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/searchdoc.html
@@ -0,0 +1,24 @@
+<!--
+	Copyright 2009 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.
+-->
+{{range $key, $val := .Idents}}
+	{{if $val}}
+		<h2 id="{{$key.Name}}">{{$key.Name}}</h2>
+		{{range $val}}
+			{{$pkg_html := pkgLink .Path | html}}
+			{{if eq "Packages" $key.Name}}
+				<a href="/{{$pkg_html}}">{{html .Path}}</a>
+			{{else}}
+				{{$doc_html := docLink .Path .Name| html}}
+				<a href="/{{$pkg_html}}">{{html .Package}}</a>.<a href="{{$doc_html}}">{{.Name}}</a>
+			{{end}}
+			{{if .Doc}}
+				<p>{{comment_html .Doc}}</p>
+			{{else}}
+				<p><em>No documentation available</em></p>
+			{{end}}
+		{{end}}
+	{{end}}
+{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/searchtxt.html b/vendor/golang.org/x/tools/godoc/static/searchtxt.html
new file mode 100644
index 0000000..7e4a978
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/searchtxt.html
@@ -0,0 +1,42 @@
+<!--
+	Copyright 2009 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.
+-->
+{{$query_url := urlquery .Query}}
+{{with .Textual}}
+	{{if $.Complete}}
+		<h2 id="Textual">{{html $.Found}} textual occurrences</h2>
+	{{else}}
+		<h2 id="Textual">More than {{html $.Found}} textual occurrences</h2>
+		<p>
+		<span class="alert" style="font-size:120%">Not all files or lines containing "{{html $.Query}}" are shown.</span>
+		</p>
+	{{end}}
+	<p>
+	<table class="layout">
+	{{range .}}
+		{{$file := .Filename}}
+		<tr>
+		<td align="left" valign="top">
+		<a href="{{queryLink $file $query_url 0}}">{{$file}}</a>:
+		</td>
+		<td align="left" width="4"></td>
+		<th align="left" valign="top">{{len .Lines}}</th>
+		<td align="left" width="4"></td>
+		<td align="left">
+		{{range .Lines}}
+			<a href="{{queryLink $file $query_url .}}">{{html .}}</a>
+		{{end}}
+		{{if not $.Complete}}
+			...
+		{{end}}
+		</td>
+		</tr>
+	{{end}}
+	{{if not $.Complete}}
+		<tr><td align="left">...</td></tr>
+	{{end}}
+	</table>
+	</p>
+{{end}}
diff --git a/vendor/golang.org/x/tools/godoc/static/static.go b/vendor/golang.org/x/tools/godoc/static/static.go
new file mode 100644
index 0000000..d450f47
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/static.go
@@ -0,0 +1,3722 @@
+// Copyright 2018 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.
+
+// Code generated by "makestatic"; DO NOT EDIT.
+
+package static
+
+var Files = map[string]string{
+	"analysis/call3.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03N\x00\x00\x01\xea\b\x03\x00\x00\x00\x04l\xeeb\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x04\x06\x03\x06\t\x05\x0e\x10\r\x16\x17\x15$\x18\x0f\x1e\x1d\x17!# #$\"$%#&(%)(\"()'-+\x1f*+),-+-/,41&J-\x1202/241S/\x0e564,7M796<:.:<9!?p=?<B@4@B?DECLH9?JVHIGvD\x13JLIMOLVQ@QRPUWT_ZHY[X,`\xae7]\xaduWG8`\xaa\\^[A`\xa5:b\xab;b\xac<c\xad_a^=d\xae@f\xb0bdaRe\x99lfP\x90^8Ci\xb4egdMj\xafhjgFm\xb1Ol\xb2fj\x90Ip\xb4\xa7c\"}iflnkKr\xb7oqnNu\xba\xb3h\"{s[Xv\xb6tvs\u007fr\u007fZx\xb8ry\x81]{\xbb\\}\xb6y{x_}\xbeX\x80\xbf`\x80\xba\x96xpb\x80\xc0}\u007f|\x89\x80eb\x83\xbd\u007f\x81~\x9a{oe\x85\xc0\x82\x83\x81k\x85\xbb\xa7}fh\x88\xc3m\x88\xbdj\x8aľ~G\x87\x89\x86q\x8c\xc1\x8a\x8c\x89\xbe\x82Y\x96\x8cnt\x8e\xc4z\x8f\xc0\x8f\x91\x8ex\x92\xc8~\x93\xc3x\x95\xc4z\x94ʒ\x94\x91\x80\x95\xc5ӊJz\x98ǂ\x96Ǡ\x96w|\x99ȕ\x97\x94\x83\x98ɂ\x9aė\x99\x96\x86\x9a\xcc\xe4\x8dA\x80\x9d̅\x9dǚ\x9c\x98\x83\xa0Ϝ\x9e\x9b\xa8\x9e\u007f\x88\xa0\xcb\xf3\x915\x8a\xa2̙\xa0\xb5\x9f\xa1\x9e\x8e\xa2Nj\xa3Ρ\xa3\xa0\xfa\x95/\xa2\xa4\xa1\x8e\xa6\xd0\xff\x952\x92\xa6˳\xa6\x82\xa5\xa7\xa4\x91\xa9ԧ\xa9\xa6\x94\xac֙\xacҪ\xac\xa8\xb9\xac\x88\x9e\xaeΛ\xafԭ\xaf\xac\x9d\xb1֢\xb1ѯ\xb1\xae\xa1\xb5ڥ\xb5ճ\xb5\xb2µ\x90\xa3\xb7ݵ\xb7\xb4\xac\xb7Ҫ\xb9ٷ\xb9\xb6\xac\xbcܺ\xbc\xb9\xb1\xbd\u05ef\xbe\xdf˾\x98\xbd\xbf\xbc\xb1\xc0\xe0\xba\xc1\xd6\xc0¾\xb7\xc2\xdd\xc2\xc4\xc1\xb9\xc5\xe0\xbd\xc5\xda\xc4\xc6û\xc7\xe2\xd6ǝ\xbc\xc8\xe3\xbb\xca\xde\xc7\xc9ƿ\xca\xe5\xc6\xca\xda\xc0\xcc\xda\xca\xcc\xc8\xc1\xcc\xe7\xbf\xcf\xe2\xc2\xce\xe9\xcd\xcf\xcc\xc4\xd0\xde\xcb\xcf\xdf\xc8\xd0\xe5\xcf\xd1\xce\xdfѥ\xca\xd1\xe7\xcc\xd3\xe9\xd2\xd4\xd1\xcc\xd5\xdd\xd3\xd3\xde\xce\xd6\xeb\xd6\xd8\xd5\xd0\xd8\xed\xe7ج\xd2\xda\xe2\xcb\xdb\xee\xd5\xd9\xe9\xd9\xd9\xe4\xd7\xdb\xeb\xda\xdc\xd9\xd8\xdc\xec\xd2\xde\xec\xd9\xdd\xed\xdc\xdd\xe7\xdd\xdf\xdc\xd4\xe0\xef\xdb\xdf\xef\xf0\xe0\xb3\xdc\xe1\xe4\xdd\xe1\xf1\xe0\xe2\xdf\xd9\xe5\xf4\xe0\xe5\xe8\xe0\xe4\xf4\xe3\xe5\xe2\xde\xe6\xef\xe7\xe5\xe9\xe5\xe7\xe4\xe6\xe7\xf1\xe0\xe9\xf1\xe4\xe9\xeb\xe7\xe9\xe6\xe3\xec\xf4\xeb\xed\xea\xe6\xee\xf7\xec\xed\xf7\xe8\xf0\xf9\xf0\xf0\xfb\xf0\xf3\xef\xf4\xf2\xf6\xee\xf4\xf6\xf0\xf6\xf8\xf4\xf7\xf3\xf2\xf7\xfa\xf5\xfa\xfd\xf8\xfa\xf7\xfd\xfb\xff\xf7\xfd\xff\xf9\xff\xff\xfe\xff\xfc\x9cx\xeb\xab\x00\x00 \x00IDATx^\xed\x9d\x0fp\x14ׁ\xa7C\x9c\xf3\x83\x89-\x94\x95V\xa7\xb0\x04r\xac8\x14\xd37l\tF\\N\xa0\xd1\xe9N\xb27\xd2q\x0e\x845\xc1+\xbc\xb6N\xb0\x11\xb2\x1d\xd8(K!\x8e\x15\n\xa9S \"\x18\bZ\x82\x10QJ\x12\b,\x84A\x90\n\x10\xe1\"\xe0\x80b\xc9v\xe2\x12Nd\x1bk\x89\xd6\xc4j;\x80\x8d\x8d\xf0\xd4Խ\xd7\xdd3\xf3\xba\xa7{zz\xd4j\x8dF\xbf\xaf\xa8\xa1\xe7\xe9\xbd\xd7\u007f\xa6\xbf\xe9\xee7=\xbf\xf9\x8c?fD\x00\x80\x8aϘIc\x8cY\xd7\x00L4\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:%27\xcc*\x00{\x81N\tKwA\x1aYhV\t\xd8\ntJXfάj|ɬ\x12\xb0\x15Gu\xea\xde_[]w\xa8\x9fM\xde8\xb1\xa7z\xd7\x19m\xa9\xd3\xf4\x15\xa7%͋\xf2\x8c\xa81\xb5ެJ\\q\x82\xec7\xab\x02\xec\xc6I\x9dz\xab\xea\xcft\x9f\xd9U;@\xa7\xebk\x8e_h\xafnה:Mfچ\x82\xa4>\xb3Z2\xf5Sw\x99U\x89+\xdaI\xb3Y\x15`7N\xea\xd4U\xd5M\x1f\a\xaa\xe8A\xe9x5ۉ\xbb\xaa\xfbU\xa5N\xd3G։\xe2\x98\x1c\x16\x1d\xa0\x8d\xb4\x99U\x01v\xe3\xa4N\xa2t\x00\xeae\xfa\xd4\xcb'\"\xb5\xed\xaaR\xa7\xe9\"\xe3\xeb\xfc\xcd\x12\xd0i\fpT'\xca@w\x1dۅw\xc9'\"{\xeaU\xa5\x8e2\x98J$\x96J\xcf6d$el\xa0\xff\x9f\x98BȪ\xae\xdc\xe9I\xf3\x06\xf9\xca}I\x84L\xae\xd5\xeb&H\xd7\xc2TWڼ\xb07\x85\x9a\xb4*\xf6_w\xb2<7\x92\xcc\xd7\xe0\xe7ֿ(\xdd5m\xc1\tZZL\\UKg$=$\xd5\xec\xcdMM_\xba4uj\x1d\x9d\xae\x9d3u\xc6R\xedѴ\xf3\x89|\xf7\xe2\xa7\xf2\x874\xc5b\x13tr\x1egu\uab6a\xaa\xaaa\xfbáZ\xb6\xb7\x0e\xd4\xecR\x95:\xcb\xf1\xe6\xed\xa4\xac\xb9Y\xdai\v\\\xab\xeaW\xb9r\xe9\"\xd5\xd5N\x9b\x91<mi.Q\x0f\x8a\xb577\xbb\xcat\xbbQh\x9a\x9aQ\xd1XF*\xb4\xe5\v\xc9<\xf6\xdf`\xcd:\x99\x1a^S~n\xf5\xe4ᦺ\x05\x93\xa9\x03gj\xa7\x90Բ\x8ad6\xca=83}C\x99+\xa9\xfa!\xdaq\xc1\xe4\xe2\xfau\xa9\x19ꡓ_\xce}\xa6\xa5\xe3\xc0b\xe1]U\xe9`o\xd3\xec\x14\xe77\xe9\x84\xc7Y\x9d\xc4\xde\xeeSu\xb5\xf4e\uebe9\xef\x1d\xe8\xdeSU\xa7*u\x9a\xe0\xc9\xde~i\x14L~\x143Hf\xbf\xde%UR$\x9d\x06\xa6ͣ'\xad\x83ua\xe3\x1a\x17\xd6\\\x90\xfe\xef\xbd ӫ\xf9{pn\x03ul\x96\xb3\xa4O\x8a\\)T\xf2\xdcT:\xb5\x9d\xd0\xe3\xd5\x06r\x8aN֓\x1a\x91\x9d\xc3mW\xb5?\xe0e\"\xed\xcbQ\x1f\x9d\x16\xd2\xe3\xa0\xe3\xc7{\xe0\xb4N\"\xdb\xe5\x1a\xe9c_==$\xb5\xd5\xefQ\x97:LP\xa7\x82Y\xd2\u007f3\v\xd8c\x86K\xffӚ\x88:Փ\xe3\x11\xfeJ\xad\"\x01.\xa8\xff\x10\x9a[\xef\x86yӓ\x89\xb4$.\xb6 e.\xfa\xb0\"Ed\xcbɶӢ郌\xf4\x02U\xfb\u05fc\x85\x1b\x0f\xfcjHs\xae\xf7\xd2\xfe\xaa\x998:9\x8f\x93:)C\xe1'\xaa\xe4g}7\xc4\xdaC\xdaRG\t\xea4g\x81\xf4\u07fc\xd9\xec1c\xb6~\xed\x88:\xad#&\x03\xfd\xcd\xf52\xda\xd1\xeb\xe0\xdc\xdaҦ\xad\xd8՜)\xeb\xc4f%\xe9TAz\xd9a\x93\x1d\x9d2\x14\x1f5w:\\;P^$\xe4\xed\r\xbbvjƵ\x93\xf38\xa9Sm\x93\xf4\xdf\xf1j\xfa ]AHc\xe4|\xa9Ä\x8eNӥ\xff\xa6\xcbG'\x83;s\"\xea\xd4hrt2$8\xb7\x99s\x98\x90\v5:\xbd4y\xdeK'f\xcca\x85\xb9\xd3\xdb%ԧ\x8b\xe7\xb6R\x91\xae\xb5\xcc? j\xc0\xc8\xde\x18\xe0\xa8Nҥ\x89tZw\xa6\x8a\xee\x14\xfd\x92I\\\xa9\xd3\x04u\xaa\x97.H\xb6\xcbO3\x16\xe9\xd7\x0e\xe9t\xa1,̝\xfe\xf4L\xf6\x0eQ\xbcT\xfb\x87\xc0\xb5\x93\x11\xc1\xb9Mc^\xdd\xc8\xd0\xe8\xd4N\xd2\bɔ\x86K\xf6\x13\xe9J\xf3\xf15\xaa\xf6;\x85\x0e\xf6\xdf\xcagE\r\xd0i\fpR\xa7\xae\xaa\xc63\xddg\xea\xd8\xfd\x0f]U\xed\xdd\xc7k\xeb\aԥ\xce\"\x8f\xec\xc9\xfb\\\xee\xe4\x15\xf5+&\xe7R\xadۚgd67k\x15\xa0\xc5ͮ\x82\xe6f\xf9rd\x01\x99\x1a6\xe4\xd0\xf4\xc0\xcc\r\xf5\xc5$\xec\x18\xbb@\x1e\xd9Ӈ\x9f[\x19Y\xb4aM\x06I\xadh릳j\x13\xdb\v\\\xcd\xdd\xe2qWc}\xb32\xb6\xbe\x82,\xaa\xdbS@\xd4\xe3\xf5;\x05\xcf\x0f\x8e\x1cyF\x96\x8a\xa7\x9d\x1c\xd2\x16\x81\xd1\xc6I\x9d\xc4\ue9ba\xea]m\x927\xc7\xebjꏇ\x95:\xc9@\x8at%2E\xbe\x1bcݬ\xa4Y\xd2\xe7N\x93\xa5R\xad\x02\xedr1\x91/\xf0\xaa\xa7\xea\xbc\xf3w-JO\x9e\x1d~\x1fRMj\x84\x8bB~n7*f\xb8R\x17\xd5Lwe\x16\xd3\"ש\xa9\xf4\xb1X<\xe4b\x15\\\x99\xec\xe2Iܟ\x99\x9a2Gs'\xdeO\x97\xef\xccw{W\x86\xd9$\xf6NYt\xa27\xca\xfb\x11\x81M8\xaaS°\x8784j\xd6;\xb5\xb8wp\xb0\xaf}a\f\xc3t{f\x86\r[\x80Q\x06:\xc5@M\xca\xc3fUlbO\x8a2\x11\xd3\xed\xec\xbd'\xc6\xe0έ\t\rt\xb2Nw\xeaR\xa7NM\xdb'Kgy\xe2\xa9\xc91\x0e\x1c\x02G\x81N\xf1MA\xd2\xc3ۛ\xb6?\x9c\xe4\xd4\xe1\x10\x8c\b\xe8\x14\xe7\xd4?\x94\xeeJ\x9f\x17˩\x1ep\x1e\xe8\x04\x80m@\xa7D\xe4G!̪\x02;\x81N\x89\bt\x1a#\xa0S\"\x02\x9d\xc6\b蔈@\xa71\x02:%\"\xd0i\x8c\x80N\x89\bt\x1a#\xa0S\"\x02\x9d\xc6\b蔈(*\xfd\xe3\u007f\xff\xbeJ\xa7\xbe9{D0\x9a8\xaa\x93~\xa82\xe5T\x15>\xf6\xb7H\x87\xf7\x88\xf1\x1fe\x9b\xfeA\xf8{\xcdѩb\xb2\xfa\xbb\x87\xc0f\x9c\xd4I?T\x99\xd2W}(r\x86\x1d\b㈧\xc5\xf8\x8f\xb2M\xee\u007f\f;٫\x9f\xb2N\xbf\x05\xb0\x05'u\xd2\x0fU\xa6\xd47vC'\xab\x84e\xadp0\x9b\xfe\xaf\xfb\xeft\xae\x9dV\xb9\xf0\x9d\x8dQ\xc4I\x9d\fB\x95\xc5S5\x03\xd0\xc9V\x98G\xff\xeb\xbf~\xffG?\xfcяn\f\xaa\xbe\x91ۯ\xc9\x15\x03\xb6\xe2\xa8N\xa2n\xa8r\u007fu\x97\x98@:\x19\xc42\x8b\x91\xf3\x95\xdf\xcdso\xf5z;6欼&\x8a\xd7ʽ\xee\xfc\xa7.\xd2\xe2\u007f\x16\xdc\xfb\xd6{s\x9e\xfa\x8djR\xbc\xe6\x11\x04A:٣\xa5\a6\x16y\x9ex\x9d=\xb9\xb6v\xb1\xf7_\xfee\xb1\xa7\x85\xda\xf4ÿ\xf9\x9f\u007f\xf9\x17\u007f\xf1\xd7\u007f9s\xe6\xd2߬^\xec\xf6>\xf5\xba<\xa3UIN}Wk\"\xe2\xacN\xba\xa1\xca\xf5\x8db\"\xe9d\x14\xcbl\x92\xafܑ-l,\x11\x16\xef\xcc\xdbG\xaf\x8b\x84\xf5\x1d-O\t\xe7D\xf1b\x8b[\xc8߹3\xdfs\x91\x9f\x14\xc5s\x9d\x9d\xf3w\xb2f\xacԻso\xf6j:=T\xe4\xdd\xf7\x83\xf9\x9e\x03O\xec\xa3:\xfd\x93\xfb?L\xce̜\x94\x949{\xd2_}}o\xc7Na\x9f<\x9fC\b8\x1aE\x9c\xd5I/T\xf9\f\xf3+\x81t\x12\rc\x99#\xe7+{\u05ca\x1d\xc2\x11\xf1\x99\xf5\xa2x\xbd\x85\x1e\xa2\x86\x960EĬBv\xb8\xca_\xae\x9e\xa4\xc8:\xd1\xd2\x1cz\xdcY\xeb\xa5S-\x025m\x1f{`\x83\xe4\xee\xfb\xd6\xf8\xfdg>\xf4\u07fb\xef?\xd2\x19\r\xb1.\x19\xddd|\xfdL\xd5\xf8\xc2a\x9dİP\xe5\xfe\xea37n\xdcx\xa96\x912w\x8cb\x99e\f\xf2\x95\xbd-\xe29ᚸu\xadȒ]\x9f(\xcc\x16\x96\xb0⬭\xecq\x1f\xfd\v?)r:=C\x1fvfч\xad9\xf4\xe1e\xaa\xa4\xac\xd3_L\x9a4I\\4i\xd2g\xfe7\x9fb֭\xc98\av\xe2\xa4N\xba\xa1\xca\x17\xaa\x02$ΐ\x93Q,\xb3\x82~\xbe\xb2\xb7C<\xe7\x16%\x9d\xcey\xf3\xb7\x1e\xe9,\x91u\x92\xac\xe9dg~ܤ\xc8\xe9\xc4\xfe\x97t\xda7\x97\x8a֡\x1c\x9d\xfeI\xf8?\u007f\xfd\x97T\xa7\xcf\xfd\xa7\xbf:şT\xb6!~o\x14qR'\xfdP\xe5^Ʃ\x9a^\xedOK\x8cc\x8cb\x99#\xc2tʒu*Z~\x9d\x16\x94\xcb:md\x8f\a\xa4\xa3ShR\xd4\xd3\xe95\xe1\x89\xd7.\x16-\x1f\x92t\xfa\xbe\xfb\xef\xbf\xff?\xa8NS\xfe\x9f\xfb\x1c?\x9b2\x97\xf5\x881\x10-\x8e\xea\xa4\x1b\xaa,\x91`\xd7N\xfa\xb1̑\xf3\x959\x9d\xf2\xcb\xe9\xf3\xa1Ge\x9d\xf2\xd8\x05S\xe1J\xf5\xa4\xa8\xa7\xd39!O\x10J\xd8\b\x9e<P\xfeÿe:\x9d\xf2\xaed\x1fQm\x94\\\x14ǒ\x10J\vF\x8a\x93:\xe9\x87*Snt\x9f\xaa\xe9\x8e\xf2\x17\x9f\xe3\x1e\x83Xf\xd1$_\xf9bξ\xeb-\xee\x8b\xd7\xd7R\x1fv\n\xe5\av>*,\xde\xdbIm\x11\xbe\xder\xa0(\xe7e\x91\x9f\x1c\xea\xec\xec\x9c\xfflg\xe75\xf1\xb5N\xf7\xb3\x9dC\xbf|\xd6\xdd\xf9\x9axn~GG\xe7\xeb\xcc\x1d\xf9c\xdc\u007f\x90t\xea\xea\x98_t\xa0c\xa3 \xff&@\x05i7^\x060R\x9c\xd4\xc9 T\x99\x96\xb3K\xa7D9>\x19\xc42\x8b\x91\xf3\x95\x87聥%[\xf0\xb4\b\xc2jqh_Q\x96w\xed\x81\"\xf7Jv\x86\xf7L\xb6w\xedk\xacNh\xf2\x97\x82\xcc\x01\xf1;\xf4\xd1\xfd+\xf61\xd4w\xc4N7+s/\xbf(\xdfd\xf4\xf7\u007f\xf3\xdf$\x9d\x06_.\xf7f/\x97\xef\xf0kN\n\xfbM\x02`#\x8e\xea\x04\xac\x93\xb5SoR\x8f?x\x9e\xfdû\xef^\xfb\xe5\xea\x9ck\xf2-\xb0\u007f\xf7W\xb2N\xa1*\xdb]\x05\xdaϖ\x81\x9d@\xa78'z\x9d\x8e(?\xe89\xb4\xb8C\xd6\xe9G\xffE\xa3S_:n(\x1f]\xa0S\x9c\x13\xbdN\xe7\xd8\x109\xe5\xa2\xf0+\xe5\\0\xec\xe8\x04F\x19\xe8\x14\u05fc.\x8d4h'\xf5\x19z\xc6\xf3lKG˳\x9e\xf5C\xd0i\x8c\x80Nq\x8d4\xd2\xf0\x9avҀ\xa1#Ox\xdd\xde'\x8e\f\x05\xbe\x8d\xfb\xb7\xd0\xc9a\xa0S\"\x02\x9d\xc6\b蔈@\xa71\x02:%0u\xd0\xc9a\xa0S\xc22\xb8a!\xbb\x05v\xc5!\xf8\xe4\x18\xd0)a\x99\xa3|A㳻\xe0\x93S@\xa7De\x80}}\xf0C\xbf\xff\xde}\v\x13\xe5v\xc8\xf8\a:%*\x03\x84dfޗ\x969{\xd2\xc3\xd0\xc9)\xa0S\xa22\xb8\xe7s\x9f\x9dt\u007fJJJf;\xc2V\x9c\x02:%,3\xa6\x97U\x1f\xba\xd0\xd5\xf5\x12\xbe/\xe8\x18\x8e\xea\xa4\x1b\xaa<P#}\xb5\xbd&\x91\xae\x97\x1bS\x83!\xd1}\xc5iI\xf3TA\x18\xdfQ2\xbdFF`\x16\x05\x84\x90\xa4.\x9d\n'\xc8~\x96\xb1\xa7\xc9\xd9\x03\xa3\x8a\x93:\xe9\x87*\xf7U\x1d\xef\xa6$\xd0w\xdb\xe9\xdaM\r\xc6\x05e\xa6m(HR]\xbc\xbc\xde\xe9\x8e|/kT\x04f\xd1\xddܼA7뫝\xa8\xb3(\x80\x038\xa9\x93~\xa8r_U\xa4؟\xf1N\x1fY\x17\x1e\x11frk\xb8U\xdatu\xd2/\x05\xa3\x8a\x93:\xe9\x87*'\xb6N]D\xe7\xb7A\xa0S\xa2\xe2\xa8N\xa2^\xa8r\xc2\xe9ԗD\xc8d\xe9\xab\xfa\x83\xa9r\x9e\x9e\xf6\v\xe5Y\x1b\x9fQґCpQ˺\xa9\xcbb1qU-\x9d\x91\xf4\x10+\v͂\xa1/N\x13tr\x1egu\xd2\vU\xee\xabj\xdcUUۜ@\x83\xb9\xed\xcdͮ2i\xeax\xf3vR\xd6ܬM\x10d\x19*-K<\x17\xf92.jY?u\xf9L\xed\x14\x92ZV\x91,\x85\x8e\x85f!\xea\xea4\xd8\xdb4;EgDo\x92m\x84\xf7\r\x9c\xd6I/T\xb9\xbf\xaa\xf6D\xf7\x99\xba\xed\t\xe4\x93(&\x05\xf6u\xfd\x93\xbd\xa2\xeb\xa2x\xbdh\xb9\xaa\x90\x8bZ\xd6O]\x16])\xd4\xcb\xdcT\xe5YR$\x9d\x16\xd2c\x9b\xde/\xd0Mz\xdb&\xa0\x93.\x0e\xeb$\x86\x85*\x8b\xe2)&\xd2@MB\x9d\x9a\x98\xe8$\xa5#\a\xf2'e\xb8\xa8e\x83\xd4e\xd1\xc5~K\xa6̥<\x8b\xa8\xd3K\xfb\xabf\xea\x1e\x9d\xcc4\x89\x16褋\x93:\xe9\x86*\ahN\xa8$z\x13\x9dT\xe9\xc8\n\\Բ~\xea\xb2(\x9d\xdeE\xa7\x13\xa5Y\xaf\x14:\x8d.N\xea\xa4\x1f\xaa\xdc(\xefoM\t\xf5\xeb\xb8&:\xa9ґ\xa3ƚN\xba\xa5\xd0itqT'\xddP\xe5z\xe9\xb0\xd4W\x13\f\xb1L\x04Lt\xf2^g\xbfƴ2\xfc/\x11qR\xa7Iҿ\b\u007f\x0f\xef\x1b8\xab\x93~\xa8rw\xd5\xfe\xae\x97ګ\x13\xe7\xe04\xd8\xd6\xdc\xec*hn\xee\x0f\x8c\xec\x85\xed\xd6Y\xc2\x13\xbf\xe8X.\x05%GO7\xed\xb4Ml/p5w\xf3\xb3\x90\xee\x8aX\xd7\xdc\x1c\xf6iC\xbb\xdeOe0E\x9e\xfb\x82,ʫ_\xbb\u007f҃\xdf3\xd2\x05:ł\x93:\x19\x84*\xf76\xd6\xd6ԟ\x8a\xd4n|\xd1.\xa7*\x93*q E\x9a\x98rFS\xa3hgy (9z\x8aiO\xaeSS\xe9c17\v\xe9\x9e=Fد\f\xf4NYt\xa2W{\xbf\x1eS\xe4\x8b\xcfɢ|\xf5\x8bϿ\xfa\xfc\x97~f\xa0\vt\x8a\x05Gu\x02N\xb2g&!\xda_ƙ\x14p\x85\xf2\xb9\x9fӇ\x9f\xffgŏ\xef=8\xe9\xfeo\xbd\xfd\xf6\xf3_\xbe\xef\xbe/\xff:\xa8\xd3\xf7>?\xe9\xfe\xaf\xbd\xcdM<\xff\xe5\xcfMz\xf0\xbb\xd0\xc9\x00\xe8\x94\xc0\xf4\x9e\xd0~\x80\x1c\xae\xd3\xfd\x8aM\x9f\xfbޫ\xcfS\xb5\x1e|\xee\xd5_\u007f\xe5+\x01\x9d\xfe\xf5\xc1\u007f\xa5\a\xb0\xafq\x13\x0f~\xf3\u05ef\xfe\xec\xcb\xd0\xc9\x00\xe84\xa1\xe0u\x92O\xf6\x94S\xba/|\xf7\xed \xbf\xbe?\xa0\xd3\x17\u007f\xa6\x18\x17\x9c\xf8\xec\xcf\xe5:\xd0I\x17\xe84\xa1\xe0ubC\x11\xf7\u007fK\xd1iү\xe5\xff\u007fNO\xe6&M\n\xe8t\x9f|C\x117\xf1\xd5\xfb\xbe\xf2\xad\x9fC'#\xa0ӄ\x82\xd7I\xe2\xb9\xcf\xcb\xffߧ\xe8\xf4ů\xfe\xfc\xedW\x83:MR\x8eE\xa1\x89\xb7\u007f\xf6\xb5/\xdf\xf7M\xe8d\x00t\x9aP\x84\xe9\xf4\xe5\xaf)\x1a)'{\x9f}\x95^(\x05u\xfa\xc27\x95j\xc1\t\xc6\xf3\xf7A'\x03\xa0ӄ\x82\xd7\xe9K?{\xf5\xf9\xaf|\xe1UY\x91\xe7\xeeW\x86\"\xbe\xf9\xea\xcf>\x1f\xd4\xe9\xb9\xfb\xbe\xf5\xebW\x9f\xfb\x127\xf1\xa5\xef\xbd\xfa\xea7\x1f\x84N\x06@\xa7\t\x05\x13I\xb9\nz\xfb\xbb\x9f\xff\xcc\xfd_}5p\xc8\xf9\xee祁\xf2\x9f=8\xe9\xfeo\x06uz\xfb\xb9/~v\xd2\x17\x9f\xe3&\xbe\xf7\xc5I\xf7}\xf9y\xe8d\x00t\x9aPp\xa7y#\x03:\xe9\x02\x9d&\x14\xd0it\x81N\x13\n\xe84\xba@\xa7\t\x05t\x1a]\xa0ӄ\x02:\x8d.\xd0iB\xa1\x1f\xa3\x12\vfs\x9a\x988\xaa\x93n\xa82\xe5\xcc\xfe\x9a\xba\xf6\b\xed\x80Bİf\xdb9A\xf6\x9bU\x01j\x9c\xd4I?TY\x1cl\xacj\xbb\xd0^\xa5\x97\xb3\r\xd4D\fk\xb6\x1d\xc42[\xc6I\x9d\xf4C\x95\xc5\xc6\xean\xa6\x9a\xf6;v \x12\xbaa\xcd6\x83\x1cY\xcb8\xa9\x93~\xa8rw\x95\xf4\xad\xdcQ\xde5\x12\r\xdd\f\n\x9b\x81N\x96qT'Q/T\xb9\xad:\x91~\x8af\x141\vk\xbe\xe8\x16\x84\xad\xbfY[8\xff\x89w\xb9RӰf\xcao\xca\x17\xbb\xbdO\xbd.j@,\xb3e\x9c\xd5I/TyO\xfd\x99]U\xb5\x87\x12*\x04vt0\tk\xbe\xdeҒ_\x94\xedݸv.\x9fBa\x1a\xd6,\x8a\x1d\x9e\xaf\xef\xed\xd8)\xecS\x15\x1a\xc52\x83H8\xab\x93^\xa8r\x9d\x14\xaa\\[\x87cT\x14D\x0e\x1c\x13\x1f\x15J\xae\x89C\xea\xf8>Ӱ\xe6\xeb\xf9O\xb0\x9c\xb2\x16u3\xa3Xf\x10\t\x87u\x12\xc3C\x95\xeb\xa5\xf1\x88\xfe\xc4\nU\x1e-\xcct\xca\n\x8bG2\x0fk\xee\x10~\xa5m$\x1a\xc72\x83H8\xa9\x93~\xa8r\x93<\xf6۴Ǩ\x19\ba\xa6\xd3\xd7\xc3\xcbLÚ\xf7\t\xd7\xc3[I-q\xedd\x15'u\xd2\x0fUn\xaf\x91>\x8clęE\x14\x98\xe9T\xaeShF\x87:+=\x04F\xf6,\xe3\xa8N\xba\xa1\xca}\xd2@y\u007f5n\x8b\x88\x82\xd1\xd0\xe9\x9aw\xe5\x10\xfdo\xe3F\xed\x1f\xa0\x93e\x9c\xd4I?TYl\xafn\xef>U\xbb\vC\x11&\x98\x855\xbf\xfb\x8b\u03a2\x95\x9d\x9d\x16\xc3e)\x1d\xf3\x8b\x0etl\x14\x0eh\xcbuc\x99A$\x9c\xd4\xc9 TY\xec\xdaS\xb3\xab\x1d6\x99a\x16\xd6|Q\x90xʠy\x04^.\xf7f/?\x12V\xac\x1b\xcb\f\"\xe1\xa8N`|\xa1\x17\xcb\f\"\x01\x9d@\x04\xc2c\x99A$\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\xc3Q\x9d\xf4B\x95\ak\xabdjM\x1a\x83\xf8\x80\vv\x06Z\x9c\xd4I7Ty\xa0\xaa\xbd\x9b\xd2^u¬9\x183\x9a\xb8\xafJs\xc1\xce@\x8b\x93:\xe9\x87*\x9fbv\r\xd4⋟q\xcc\xecEf5\x80\x84\x93:\xe9\x87*K\xd4\xe3\xbb\xed\xf1L\x06t\x8a\x0eGu\x12\xf5B\x95\x19R\x12\v\x18+\xba\x16\xa6\xba\xd2\xe6I_\x14ܐ\x91\x94\xb1\x81\xfe_L\\UKg$=\xc4\xde\xfa\x94p\xbe\f\x91\x0fv\xe6*\x14\xb3\xa2\v.2S\xea\xacv\xce\xd4\x19K'j@\x9f\xb3:\xe9\x85*3\xa4$K0F4Mͨh,#\x15t\xb2\xc0\xb5\xaa~\x95+\x97\xbe\xc1\xd5N!\xa9e\x15\xc9\vE\xb1\xffP\xf3\x8c\xcc\xe6\xe6f)\x99\"\x18\xec\xccU薊\xda\n\\\xac\xbc`rq\xfd\xbaԌ\t\x1a1\xe1\xacNz\xa1ʔ\vU\xf8\n\xf5\xd810m\xde\x00\xcbk\xa3W\xb3\xfb\xa5\x1fH\x93\x1f])\xf4E\xc9M\x95\xaa\xa8N\xf6\x02\xe1d\\\x05ɰ2\xa6S=\xa9\x11Y\xa4\xd8vqB\xe2\xb0Nbx\xa82\xa5\xb1.r\x130\x9aԓ@\xa4\x94X0K\xfaof\x01}p\xb1\aI\x11#\x9dB\x15B:-\x9a>\xc8H/\x10'$N\xea\xa4\x1f\xaaL\xa9Ad\xe5\x18\xb2\x8e\x04\u007f\xbdd\xce\x02\xe9\xbfy\xb3E^\x11#\x9dB\x15B\x93\x19ʅ\xd6\x04\r@rR'\xfdPe\x96\x03\xab\x8a\xa0\a\xce\xd2\xc8\x1d\x9d\xa6K\xffM\x97\x8eNZ\x9d\xaa_\x92+\x19鴊M\xe6No\x97\x98\xa0CK\x8e\xea\xa4\x1b\xaa\xcc.\x9dF\xf77^AD\xfa\xd33ٛ[\xf1Rv\xdeǮy\xb6K\x81ͼN\x99\x99\xf4\xb2\x97(\xa7\xe4::%\xad\x10\xc5\x1b\xb3\xd9\xe4~\xb9\xd6\xe3k\xc4\t\x89\x93:\x19\x84*S\xb7\xf0[icI\xd3\x0337\xd4\x17\x13vҐ;yE\xfd\x8aɹ\xd2h]A\x9b\xd8^\xe0\x92~\x93\xad\xccU\xb1'sj7\x1f쬪0'u͚9dJ\xcd\x19Q\\A\x16\xd5\xed) \x13\xf4\x961'u2\nU\xbe\x80\xbbVƖ\xaeE\xe9ɳ\xe5\x17aݬ\xa4Y\xf2\xe7N\x84\xb8NM\xa5\x8f\xc5\xf4\xd9@qJR&\x8bD\x0f\x05;\xab*te&%?\xf4\xb8\\w\u007ffjʜ\xfdF\xb3Jp\x1c\xd5\t\x80\xc4\x06:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x1a7,\"\xa9\xb9g\xcc*\x811\x05:\x8d\x1b\xba\x9bjf\xa6NԈ\xa0q\x82\xa3:\xe9\x85*\xb3\xa4\x9c]ջ\x0ea?\x89\x82&\x82\xacܸ\xc6I\x9dtC\x95ž\xda]R)\xbe\x91kN\x1bi3\xab\x02\xc6\x12'u\xd2\x0fUn\xaec_\xad\x1e\xack6i\r\xa0S\xdc\xe3\xa4N\xfa\xa1ʍr8\xd8\x1e$W\x9a\x03\x9d\xe2\x1cGu\x12\xf5B\x95\xfbj\x9b\xfa\x06\xfb\x9aq\xb2\x17\x05'H\x93Y\x150\x968\xab\x93n\xa8\xf2@#-ݏ\xf4\x95(\x18L\x9d}\xa8{\x82\xe6\x15\x8f\v\x9c\xd5I/Ty\xb0\xb1\x8e\xe5\x1b5\xe2'4\xa2`?!d\x81Y%0f8\xac\x93\x18\x1e\xaa\xdc\\7 \x95\xe2\a\x9e\xcc\xe9O\x9d\xbe\xae\t\x19\x9f\xf1\x8b\x93:\xe9\x87*W\xcb\xf9`R6,\x88L\x1b\xc1\x80M\\\xe3\xa4N\xfa\xa1\xca\xd0)z0\xb2\x17\xe78\xaa\x93n\xa8r\x93t\xb27P\x871+s\xa0S\x9c\xe3\xa4N\xfa\xa1\xca\x03\xdb\xebNu\x9f\xaaێ\xa1=s\xa0S\x9c\xe3\xa4N\x06\xa1ʃm\xbbjv\xb5a`ό\xc1\xee\xf6E.\xfc\xae\\\\\xe3\xa8N`$,$d\xda\x1e\xb3J`L\x81N\xe3\x86\xee\xe384\xc5;\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN@\xcd\xe0\xc0\xc0\xc0`\xf0?`\t\xe8\x04T\x1c\x9aL\bI\xea\xefO\xa2\xffMFX\x9bE\xa0\x13\x90\xd83\xa7W\xfa\xbf\x8eԷ\xb5\x9d\x12\xc5Smm\xf5\xa4Τ\xd1X\xd37'\xce\xee\tvT'\xfdPen\x12\x18\xf3\x1dAh1\xab\x13\x99\rd\xf2v\xa3\xbfU\x902y\xa2\x8e\x04o\xb4\xed\x96u*&\x93G[\xab\x98\u05edb\xf2\x1a\xb3*\x8e\xe2\xa4N\xfa\xa1\xca\xfc$0\xe6\xf5N\xf7N\xb3:\x91\xe9k\x9e]f\xf0\xa7u\x93k\x94\xa9p\x9d\xba\x9b]\xfa͚l{\xcd\f\u05ed\xe3\x9cnq\x88\xfa)\xebLj8\x8a\x93:\xe9\x87*s\x93 \"Y#\xd4I\x14\x17\x18\xe8t\xc1\xb5\"0\x19\xae\x93(\x1a\xe84{\x91nqL\x18\xac\xdb\xf2r\xddb\x8eUq\xf5\x8dJ'u\xd2\x0fU\xe6&ADFO\xa7\x82\xf4\xe0\x9b\x99\x05\x9d2F_\xa7GMu\xeaO/0\xab\xe2 \x8e\xea$\xea\x85*s\x93 \"Y\x1b\x9f\xf1\xe6<\xf5\x1bUYw2\x91I\xe6ޤ\a\xd3\\\x8f\xa7\xa77\x15\xa7d\xb2\x84\xd0E\xe9\xaei\v\xe4\x1f\xb2\xa1:\x15Ӻ\x0f\xb0Q\x87\xda9Sg,\x95-\x1aL\x0e\x1e\x9c\xf4u*~8=eA\x17}룍\x1f\x17\xcb\xe8c]\xbd2\xdf\f\xa9\x06\xd7Y8\xef湷z\xbd\x1d\x1bsV^\x13\xc5k\xe5^w\xfeS\x17i\xf1E\xb7 <5\xe4\x15\x84\x9c\xebܺ\x1d\x11\x04a\xab\xb8\x93>\xb6\xb0I\xc6\xd7Y'C?]\xee)\xdax\x9dMv>\x91\xef^\xfcT\xfe\x90\xdc\xfb\xaa\xa48J\x19qV'\xbdPe>_\x19D\"K\xf8zK\xcb\x12\xcfE\xbel\xb0f\x9dL\r\xff!QS2Y\x9aIRפU0\x05\x1en\xaa[0Y\xcal\xa1:u\xe7N^Ǧ\v&\x17\u05efK͐\x12\x9a۹\xe8s]\x9dH\xc6\xf6\xed\x19I\xa7\xc4\xfeCӊ{\xc5\u07b2\xe4\xe6\xfe\xfeC\xcd32\x9b\x9b\x9b\xa51$\xbe3\x1d:\xb2\x85\x8d%\xc2\xe2\x9dy\xfb\x98.\xeb;Z\x9e\x12\xe85\xd1\xd0/v\n\xbf\x10\u007f:\xf7\xa7\xbf\x12\xb9u\xbbޙ\xff\xec\x1f\xc4?\xfc \xbb\xf3ڵ\xce\u03a2\x95\x9d\x9d\x9d/\xb3>\x9e\x116v\xec\xf3>J\x1d\xfa\xe5\xdcgZ:\x0e,\x16ޕ;?\x14Oq4\xce\xea\xa4\x17\xaa\xccM\x82\x88d\x15\xd17\xe7\xebE\xcbU\x85\xbd\x17dzU\xa5\xe9\xb9T\xa3z\xb1\xe0a\x16\xb9\xc6\u07bff-d\xc5T\xa7\n\x97t\x1aPO\xd8\xd8C\x1b\xd9.?\t%\xcb\xea\xea4\x93\x1e\x00\x06f̡\x93e\xechT \x9f_\x05O\xf6T\x9d\xe9\xe1]+v\bG\xc4g\xd6\xd3\xe5o\xa1\x87\xa8\xa1%\xabY\xf1\xd03˯y\xe5\xb3<n\xddv\xb2\xa3\xd13\xcfH\xc5\xc1\x93\xbd#\xc2\x01\xfax\x8e\r\x00\x1e\xf02\x91\xf6\xe5(G\xa7n\x12Go\xc4\x0e\xeb$\x86\x87*\xf3\x93 \x12Y[\xd9\xe3\x01\xe1\x1aWv\x81\x04Pe-\xa7o\xa7{w\xbf\xb8\x82\xed\xf0\xbd\x1b\xe6MO&\xb3X\xf1\x82\xb2UD>\xa9^4}\x90!_x\xec1\xd3\xe9q\xf6\xb8\x81\xf4\xb1\xb2S\xe2@\xb2\x9cE\x1b\xd4Iՙ\x1e\xde\x16j\xc25q\xebZ:}\xed\xc0\x13\x85\xd9\xc2\x12\xa9\xfc\xfa\xa3yO\xc9Vp\xeb\xf6\xfa\xdc_\x89׳;\xa4\xe2\xa0Nk\v\x87ޥx\xa9e\xafy\v7\x1e\xf8Րb\x13]\"C\x8b\x9d\xc7I\x9d\xf4C\x95Փ\xc0\x18\xf9r\xbdSP\r\x1e7\xd7˨o`H\xdf/\xb6\xb9DI\xa7\xb6\xb4i+v5g\xca:\xa5%ϔ\x0eSb\x86\"\xa1\xf4\x8c\x8f\xef3\x1e\x8ah&l\xb4h\xdeRq\u007f\x8a|b\x19\xd4Iՙ\x1e\xde\x0e\xf1\x9c[\x94t:\xe7\xcd\xdfz\xa4\xb3D\xd6Il\x11:\xe5\t~ݞ\xf8\x17\xb1C9\xf6\x04uZ\xa2\\G=%2!ˋ\x84\xbc\xbd\x8aOm$\x8e\xf6\x1c'u\xd2\x0fU\xe6'A$\xb26\xb2G\xf5\xd1\xc9\x00N\xa7\x99s\xd8\xdb\xd8BY\xa7\xd4S\x17\x92+\xd8T\xee\xf4v\t\xe9\x1c\xb1\x9f\x1b\xba\xd3\xd5i){\xac&쬱>uP9דu\xaa~Iә\x1eL\xa7,Y\xa7\xa2\xe5l8\xa1\\\xd6\xe9u\xef\xd6|\xf9\x12\x88_\xb7#9Cʹ\x9e\xacӁ\xd7\xd8\xd1\xe9\x9c\x04\xfd\xfb\xb9\xadT\xa4k-\xf3\x0f\xc8U\xca\\q\xf4\x11\x8b\xa3:\xe9\x86*s\x93 \"Y^\xba'\x0e\x15\xad4\xab'\xaat\x9aƎ\x1972\x94\x93=Q\xdc\xefb\x87\xa2\xfd\xb2*\x8f\xcb7\x15,\x9a\x1e\x1cE\xd0\xd5)\x9d\x1a983\x93M\x0f\xa6֧(\xafU&-\xe8euԝ](;.j\xe0t\xcag\x82\f=*\xe94\xb4\xfc\a\xe2\xb3%\xd2Q\x86_\xb7\xa1\xc5Gr\xe4s=q%-\xf8\x03\xbb`\xea\x90o\x9b\xd8J\x0fb;\x05\xe9\x8f+\x9f\x95jܘ9O;\xb71\xc4I\x9d\xf4C\x95\xb9I\x10\x91,\xe1\x89_t,\xcfy٬\x1e}\x8bJ\xa9\xe8\xdf\xee:џ\x9b\xd9-\x96\x91E\x1b\xd6d\x90Ԋ\xb6\xfe\xe6\xd9\x05m\x83\xfd\xf3қ\xe8\x1b\xd8\n\xb2\xa8nO\x01\xa9\x95\xeawM\xae\b4\xd5\x1fٛ\xd7\xd64'E\xbe\xc0Z1]9ףDž\x8a=\x99SYuUg\v\xc8T\xcd/I^\xcc\xd9w\xbd\xc5}\xf1\xfaڒש\f\xe5\av>*,\xde\xdby\xbd\xf3;\xde\xd7\xc5\xdfdo켮Y\xb7\xad\x859ʰ\xddά}GJ<\xaf\xb1\xb2\xb9k[\x8e<ä\xda)x~p\x84N\xca\xc6U\x90x\xfa\xc0\xd2I\x9d\fB\x95\xb9I\x10\x89\xa2\x9d\xe5\xd9\u07b5\xaf\x99U\xa3\xef\xd8i\x84\xd4&\x93\xa9u\xecr\xe6F\xc5\fWꢚ\xe9\xae\xcc\r\xec&\xf1\xf6Z\xfa\xb8\x8aVڟ\x99\x9a2g\xbf\xd2b\xd5\x03\x81\v\x90:\xd2\x15\xf8\x82FW@\xa7\x99e\x8b\x92\xd3s\x15ͺ\xc8\xc3JՁ┤L\xf9\xaa\x8b\xef\xacz\xaaf\xe8z(O\x10Z\xb2\x05O\x8b \xac\x16\x87\xf6\x15ey\xd7\x1e(r\xaf젗B\x1bō\x820\xb7C\xb3n/\v땦\xd77\xe6\xcc_)_+v\x94,\xceY\xce\x14\xfa\xe9\xf2\x9d\xf9n\xefJ٦椥b\x1c\xe1\xa8N nY\xeaRԑ>\x9eU\xbe\xa0A\xf4>Z\xefw\x99\x9d\x97\xef!#\xbc\x9a\xb9\x96\xd5aVEa\xbb\xab \xae\xbe\x94\x05\x9d\x80DE\xba<\x900x\xa2-\xf0\x05\x8d\xb6\x13z\xbbj]\xaa\xc9\x0e\\\x93\xf2\xb082Z\x16\xbfkVE\xa6/=\xben(\x87N\xc0\neMb\xa6\xd1]\xe9\nݩKGt\x1d\xbc\xb3c\xa8\xe4\af\x95\xe2\x15\xe8\x04\xa2g\x80d\x14\xa7k\xc6\x19l\xe6\xba\xf0\xf5\u007f\xf6F\xf1Q@|\x02\x9d\x80\x05ʦf\x8e\xf6\x17=\u007f\xe0)y٬N\xdc\x02\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\x8e\x131\xb0y\\\xa79C'\xe04Jn\xb3\xfe\x1f\xc7w\x9a3t\x02#!\x90\xc5l\x85@n\xb3>\\\x9as\xdce&\x9b\xe2\xb4N\xa7\xaa\x94\xbb\x94\xbb\xf7\xd4\xec\xef\x0e\x9b\x04\xd1\x10s\x06\xb1\xedHY\xccV\x17\x87\xfbJ\x15G\x87\xf7H`2\xf8E\xabx\xcbL6\xc5a\x9d\xfa\xaa\x0f\xc9\xdf1\xeb\xaen\xeej\xae\xee\xd6L\x82\xa8\x88=\x83\xd8f\xe4,f\xabq\xcf\xfa:\x1d\xf1\x04\x9d\f\xea\x14o\x99ɦ8\xacS}c\xb7\xa4\xd3\r)i\xe5P\xed\r\xd5$\x88\x96\x983\x88m%\x98\xc5l-\x9fV_'q(8\x15\xd2)\xce2\x93MqV\xa7S5\x03\xb2Ng\xaa\xd9M\xfc\x03\xd5gT\x93 Zb\xce \xb6\x95`\x16\xb3-:\x85\xe0t\x8a\xaf\xccdS\x1cթ\xbf\xbaK\x94uj\x94\xbf\b]ߤ\x9a\x04\x11\xf8g\xc1}`c\x91\xe7\x89\xd7ٓ\xd83\x88et\xb3\x98\x19]\vS]i\xf3\xa4\xc2\r\x19I\x19\x1bD\xf6\x834Sօ\x87*\x8b|\x16\xb3^ܳ\n\xd52p:դ\xc9)q\xd7<\x02w\x01\xc6\xe9\x14_\x99ɦ8\xaaS}\xa3\xa8\xe8\xb4K\x8e&8\xb4G5\t\"p\xb1\xc5-xw\xee͖\xf2Sc\xcf \x96\xd1\xcfb\x16Ŧ\xa9\x19\x15\x8de\xa4\x82N\x16\xb8Vկr\xe5\xd2Ӈ\xda)dښ\xb2i\xeaPe\x91\xcfb\u058b{\xe6Q/\x03\xa7\xd3B\xa2\xe4\x10\x9d\xeb\xec\x9c\x1f<\xc4\xf1:\xc5Uf\xb2)\x9fy\x1c\x00`\x13#8:\x01\x00\xd4@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m\x98\xeb4\xb0f\xf6TW\xfa\xc2C\xe1\u007f\xd9@\x1eV\x1eF\xc0\xbd\x8ai\xae\xf4\xc6\xe0Ӂ{\xf4\xa1\x96,\nU\xa8#\v\xc3\x1a\xf1\xac#\xc5\x11\xffn\x82a\xf7\x9a\x053AZn\xb3E5\xc1\x96\xed\t\xc6\x12S\x9dj\\ʏ\x12\xcf\xfbP\xfb'[^\xfe\n\xd6w{\xe0ن$6\x97\xb8\xd0I\xbd`&\xc8\xcbm\xb6\xa8&ز=\xc1Xb\xa6\xd3RB\x16\x9e\x10?\xe9]\xe5\"\x99\xf74\u007f\xb3\xe5\xe5\x9fE\x96~r/\xd0\xf3=B\xc2t\xea\xdeЬ\xd7.\xc8\bu2\xec^\xb5`&(\xcbm\xb6\xa8&ز=\xc1Xb\xa2S\x13!\xdb\xe5\xa9\xe3\x84\xd4h\xfeh\xcb˟N\xbaBO\xf4t2c\x84:\x19\xa2Z0\x13\x94\xe5\x1e!\xb6lO0\x96D\xd6\xe9^Zh_-&\xd35\u007f\xb5\xe5\xe5O#ݡ'\xf1\xa4\x93j\xc1L\x80N@\"\xb2Nm\x84\f\x04\xa6\xfb6tIE\x8b\xd2]I3W\x89~\xf5\xcb?\xb0t\xba+e\xe1q\xb9*\xff\xa4\xbfx\x9a+yN\x8dꬩ\x97\x96\xa5,d\xd7%s\xa4˲\x80\x0f+\xa4g\xddL'qi\xbakzY\xe8\x82D\xaf\x9bS\vR\xa7λ\xc0t\xaa%\xb3\xe4\xa2\n\xe9ɺ\x0fX\xebU\x1fHE\xdc\x02ג\r\x83\xc5i\x0fd4\xd2\xc9Y\xae\xb4\x9b\xacD(\x00\x00\x1e\xe5IDAT\xa5\xdc\xf5N\xff\n\xb6\xc8g\x82}\a\x16,\xb0wK\xd2jz\x0e\xb6\t,\xb7\xd2Wh\xf5\xb4-\x14\xf8\x99\xe9o\xcfYd\x85\x1f\x8c?\"봊\xccД\x14\x13\x92\x9e\x91F\x1f>P\xbd\xfcǧ\x12\u05ec鄬\xf1k\x9e\xf4&\x93\x94\xd93\by\x88\xeb\xa3\xdeE\xa6\xb2>\xe8\x1e\xb3&\xd7E\xe6\xe5\xd6)\u007fس\x88^\xa9\xe5\x0e0;\xd2HZ\n!\xb3\xee)\xfb\xbb^7U\x84\xa4\xcdrMɤ;\xfa\a.\xd2+\x95\xcd gh\xeb\xa5\xe9$\x99\xb6\x9e\xf9\x89f\x81kIq*Is\x11\xd2XL\x1e\xa0e\x99\xfe\x80N\x87\x92\xc8\xd4ٴ$x\xed\x13X0\x8dN|ϡ6\x81\xe5\x96\xfb\xe2VO\xd3B\x81\x9f\x99\xc1\xf6\x84N\xe3\x93\xc8:- \x05\xea\x826\x92\xc4\x0e:\xa7\xa6\x92\r\xfc\xcb?\x90LV\xd0\xfd\xe5T\ni\xd4<YHVQ%^J&\x87\x82}\xbc4\x99\xac\xa1e\xfb]\xa4\xd6ot\xb2G\xa6wљ\xb9\xc8\x1ee\u007f\xd7\xeb\x86\x10\xaa\xe1\a\xf3\xa4\x83\xdbBY\xe4\x97\xc84\xa9\xf5\f\xfa\xce\xdf\xec\"\xbb4\vL\xff2\xb3\xd7\u007f/\x97\xb8\x1e\xa8\xbfǮ\v/(\xdd\x0fNe\xfd߫ \x0f\x84\x8e\"\xf2\x82it\xe2z\xe6\xdb(\xcb-\xf5\xa5Z=U\v\x05\xbe\xa1\xc1\xf6\xf4\xd7W\x9d\xf2\x83\xf1Gd\x9d\xe6h\xdf$W\x902\xe5\xffb\xfe\xe5_A\x16H\xc5\xfb\xd9\xd1L\xf5d\x9alKun[\xb0\x8f\x85\xca\x1eZGR\xef\x19\xea$\x1dl\x8a\xd9\\\xa4}T\xa7\x9b\\y\xd9>Le\x95\x9a\xe5\v\xbbǙU\xb4u_\xb0\xb5j\x81\x95~{\t\xa9`e\xb3\xd9>.u_F\xe6I\xb52I\xe0@i\xa4S\xa8g\xbe\r\xaf\x93j\xf5T-\x14\xf8\x86\x06\xdb\x13\x8cS\"\xeb\xf4\x10Y\xaa)Q\x86\x8e+\xd8a+\xf4\xf2O#MR\xf1'\x93I\xbf\xfa\xc9Cd\xce\x19\xf5h\xf3\xbd$e\xc8\xec\xdeTzff\xa0\x93|)T͆$\xa4}4\xbc\x1b\u007f2;\xb6\xf8\x95=\xf1^\n\xeb\xf4^\x1a\xdbyk\xc9\xccPk\xd5\x02\xd7\xca箟\x10y\x9e\xb9\xa4Z\xe9~\xa6\xb2ȃ\x83\xa1\xfeuu\xe2z\xe6\xdbp:\xa9WO\xbd,2\xaa\x99\xe9oO0N\x89\xac\xd3\xc3$W[t\xef̮\xb2Eӈ\xea\xe5\xff\x90^\xe5̑p\x91v\xd5\x13\xff\x19z\xa5\x92\x9c\xbb\x87\xbb\x12\x1f D\xb9\x8e\x98\xc3\xce\xe5\xf4u\x92\x8fo{\xd8\xff\xd2\xfe\x1e\xde\xcd\a\x81n\xf6Ho\xfcKٱ\xaa\x9d\xcc\xe6Z+\x03\x03\xdc\x02\xd7\xca\xc7\x05:\x17v\xe5\xef/ UJ\xad\xc0\xa5\x17\x8f\xaeN\\\xcf|\x1bN'\xf5\xeai\x96EB=3\xbd\xed\t\xc6+\x91u\xaa\xe0\x87\"\x8e\xb3=\xa6:\x8d\rbe\xccQ\xbd\xfc\"\tѨzBϬ\n\x92\xe8Ĕ\xe2\xe0\xa5x7\x99\xa2L-`\x9fdE\x1a(\x0f\xe9\x14\xdeM?!\xf2D\xb3\xa4S\x17I\xbbG\xed\xaf\xe5Z\xcb\r\xf9\x05V\xfe\x12\xa6\x13=\\q\x87%\x05]\x9dB=\xab\xdap:\xa9WO\xbd,\x12\xea\x99\xe9nO0^\x89\xacS7\xf7\xd2\xf7\x93\xc9]\xecΛ\xe2\xfa\v\x1fjNN>T\xae\x10$TO\x18\xf7N\xad\x99EB;I\u007f4G\xa70\x9dº\xf9 \xf0Q\xcf~\xf9\xb2d\x069q/i\xca\a~\x8dN\xaa\x056\xd2ɯ]d\x86Z\xa75Z\x9dTm8\x9d\xfa5G\xa70\x9dT\r\xf5\xb7'\x18\xaf\x98\xdc\x151-t\xf1\xb4\x82^Z\xd3\xeb\x01\xf9Z}\xa9\xfa\xe5Oe\xc7!Ʃ\xfe{\xea'\x03\xf2\xa7+\xb5dJ\xf0F\xa2\a\xa2\xb8v\xd2\xea\x14ލ?E\xe9f\x8d\xacS\x05Y\xd1.\xef\xb3\xfc.\xac^`C\x9df(#\xe4M\x0fU\a\xbaW\x16\xacJ\xe9\xec\xe10\x9d\xf86\xfc\xb5\x93j\xf5\xf4t\xe2\x1a\x1amO0N1\xd1i\x17!\xf5\xf2\xd4!B6\xb0\xb3:\xe9\xbc\xff\xc3tvQ\x15z\xf9\x8b\xc9li7o#\xae\x0fTODe\xcf\xed#\x93\x83\x1e\x04\x86\xbev\x91\xe4O\xa2\xd4I\xaf\x9bb\xb9\x9b{\xd3e\x9d\x06ȴ\x15\xf25>\xbf\v\xab\x17\xd8P\xa7\x15\xca\u07be@\x1e\xf2\x93\x90\x17\xac^>\xdd\xfd0-L'\xbe\x8d\xdeȞ\xb4zz:q\r\x8d\xb6'\x18\xa7\x98\xdd\x02\xbb\x90^$\x9f\xf9\xf0^\xef\xe3\x84̹翗,\x8dNߘG؎\x1ez\xf9\xfb\\\xa4\x98\xeeO])\xec`\xa6z\xf2\x10y\x88\xee\xba\x1f.R\x06\x87\x19\x17\xa6\x90\n*ES\x12\x1bX\xd3\xdc\xcb\xe3\"\x8d\x9f\xdc\xd39:\xe9t\xd3\xef\"\x1b\xee\xf9?\xcc\r\xdcT\x91I\x92\x92\xa5\xd3,\xd5\xd1I\xb5\xc0\x86:\xf5'\xb1E\xba\xb7\x8eL\x15\x83\xfd\xcb\vF\xcf\xdd\xe8_\xfa3I\x98N\xaa6\xf2rK\xe5\xaa\xd5\xd3Ӊkh\xb4=\xf1\xb9\xd38\xc5L\xa7O\n\x02\xc3\n\v\xa4\x91\bB\xa6-\x98=9\xa5\x8c\res/\u007f\x93\x8b<0{:\x91\xef:\xe7\x9f\f\xa4\x10\xd7\xccYI$\xad?\xd4g\xfd\x14\x92<;\x9d\xc8\xe7\x91j\x9df\x13\xf6\xa5\b\x9d\x93=\x9dn\x1a]$mv\x12Y\xa8\xe8\xb4'\xe0\x95j\x17V-\xb0\xa1N\xecs֔\xd9t\x1e\xdc\x1d\xe1ʂ\x15\x13\x92\x9cN\x92*\xc2tR\xb5\x91\x97[.\xe7WOO'\xbe\xa1\xd1\xf6\xc4]\x11\xe3\x133\x9d\xfc\xfe3\xc53\x1ep\xa5/R>?m\xcbLu\xcd,\xfb\xe0C\x17\x19T\x9d\x9c\xf4/\x9d\xeeJ\x9a]-\x9f\x8a\xf1O\x06\x96\xcep=@[\xf0]v?\x9c\xeeJ\x97oj\xd3\xe8ԗ\xf9@\xf2~\xbd\xa1\b\xddnrӒ\xe6\xb45*\x16\xd1E\n\\`\xf1\xbb0\xbf\xc0\xc6:\xf9\xfb\x8aӧ\xa4\xe6\xf2\x8b\xa2,ؽ\xdaY\xae\x94ܾ\x13\xe1:\xf1m\xe4\xe5Vʹ\xd5\xd3Չoh\xb0=\xa1\xd3\xf8\xc4\\\xa7\xf1\xc2\x00\xbb\xc1\b\x80\xb1$qt\xaa\xe0\x86\x11\x00\x18\x13\x12D\xa7\xbe\xc1\xc6\a\\\xa1a\x04\x00Ƅ\x04\xd1)\x97\x10\x1c\x9c\xc0\x98\x93 :U'\xa5\xc1&0\xe6$\x88N\x00\xc4\x03\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1bv\xebt\xb6\xe4\xb6Y\x95h\xb8Sr֬\n\x00q\x87\xa9N\x1fm\xc9\xf3\x94\xfb\xccj\x058(4D]7\x12\xbe\x83\xc2A\xb3:V\xb8\xec=oVń\x91\xf7\x10-\x97\xe6\n2^k\x9br3m\xe2yOS\xd8 \xb8\xd9\x1bӋ\x1e\xa1A\xaf\r\xb0\x17S\x9dJ\xbdG7y>6\xab\xa5\xd0*\xbc`V%Z^t\xb7\x9aU\xb1\xc0\xf9쨏vW~\xaf[l\xa1\a\x0e\x83\xce\"V\x18~Ž\xb9\x87\xb2[\xb0v\xa0\xbf\xd9\xd3sX\xf8\x9d\xa6\xf0N\xa5\xa7\x94\xfeWꩼ\xa3\xd7\x06؋\x99Nw\x84V\xbf\xef\xaeI\xa5\x00\xef\xbbw\x9bU\x89\x9e\xbdY7ͪX \xfa7\xfa\x95\xeb\xf5ˣ\xef\x81è\xb3\xc8\x15\xb2\xa4#\xc9\v\x82e\x03\xae\x86\xe9\xe4\xdf]N\xdf\f\xefx\xcam|e\x80!f:\xbd'X8\xc7\xd9\xec\x1d6\xab\x12=\xc3\xde\xcdfUF\x85\xc7\xcc\f\xb0\x82ig\xba\x15d\x9d\xde\xdba\xd9`=\x9d*KO\xfb_X]\t\x9d\x9c \xa2N\xbe\xc5\xf2I\xfc\x0e\xbf\u007f\xab@\xcf\xe3\xdew\vKؤ\xfb؎%\x9e\xd5\xf2\xc1\xe3\xbdo繽\xe5Ҵ/[~\xcd\xder\v\xc2\xde\xf7*\v=\xab?\xe5:\xe3J\x8d:\xf3\xbdP\x92\xbddG@ɽ\x1e\x8d\x9c\x96{P\xf8\xd8C\xd7\xe1$\x9bR/z\x88\x9eՅ\xee\xbc\xf2B\x9f\xff\xbcrٲ\\\xbd\x16\x06=ܩ\\\\\xb8c\xc7\xe2\xec\xd3\\\x0f\x1c\\g\xaa%ӛ\x9b\x8a\xac\xc0u\xce\x1f\xe92\x94\xfb\n\x05!\xc7翻>\xdf]X\xfe\x96\xdf\xffi\x9e\xfbDž\xf9W\xb6\xe5\x94\xdee\x8bӺ%?\xa7\\\xb9d\n\xea\x14\x9a\xdb\xee\xca\xc3O\xfbˏ2\x9d\x82=h\x9b\x01\xbb\x88|tz\xb3\xe7\xa4\xd0\xd0\xd3s\x8b\x9d\x98\xbb\x1b\xfc\xbe\xab\x9b\xb3\xe8k|\xd2-x\x1b\x0e\xe6<\xcdj\\\xc9^~\xf0r\x83 ]\xe7\xbc)\xf4H\xad\x86O\x9f,,\xca.\xdcQ9\xf7\xcf\\_\\\xa9Qg\x9b\x85m/\xb6z\x1fS\xf6\xc9W\x84\xdf\xfaUX\xee!\xc0՞\x9e\xf9\xd2\x1e\xaa\xaa\x1b⍹\x9b\xce^>\x96'|J\xaf[z\x8a\x9e\xa4\xd7-\xff\xaeY\v\xdd\x1e|\x8fz\x0f7\xcc\xf7\x1c[\xdd\xca\xf5\xc0\xc1u\xc6/\x99\xee\xdcTd\xed\x1d\x1e^\xbf\x83\xcd\xe1\xb7\rt#\xbc0\xf7\x857\x99\x9c[\xae\x9c.\x17\xae\xd2m\x9e#\xec(\x15\x16\x1f\xcck\x95\x16\xa7\xb0\xa1\xa1\xd0\xf3\x8e\xd40\xa8Shn\xbb+of\u007f4\xff\x16\xd3)ԃ\xa6\x19\xb0\x8b\xe8O\xf6\xa4\xb7̆,i2\x87\xbe9Wz\xe9\xd4p\xe1j\xfa\x92\xf9NKg\xf9/\n\u007f\n4{L\xa0o\x9da\xd7\\\xa1R\xdd\xce\xceK\x03\x19W\xe5\xc3\x005X\b\xbf\xf8\xb7\xd6\x03\x87Gy\xc3\x0f\xd5\xe58\xece\x1a\x1cΑ,\xe4N\xbfTk\x11\xde\xc3i\x81\xbe\xd3\x1f\x16\xde\xd1\xf6\xc0\x11\xec\x8c[2\xa3\xb9\x85\xc8b\x87\xacriҷ\xa9\xe4N\xa14\xc89|\x92.\x88o\x19\xf3\xd8[I\xb7\xf5y\xff\xa6-\xacn!-\xfe\xb8\xb0D\xaa\x1dЉ\x9b\xdb\xeeJ\xff\xb2-+\xfdL'\xae\au3`\x17\xb1\xe9\xb4)0yIx3T\xf7\xac\xf0~`\xf2\xb1,\xfe\xc0\x14^\xaa\xdb\xd9\xfaG|\x9fR\n7\xcbun\n\xa7G\xd8\x03GP\x86`]\x8e?\xe7\x17n;\xf6\xa6Ov\x81\u05c9_\x8b\xf0\x1ev\xe7Ї?Iҫz\xe0\bv\xc6-\x99\xd1\xdcBdm\xb9zu\x99\xac\x93\u007f\xf8\x1by\xca\xe7\x14w\x0e\xaf~$GXF\xa7\xbc'\xa9*\xc3\xcc\x14ZW:\xc1>,\x0f[\x04t\xe2\xe6F+\xb1\x0f\x1d\xa4k\xa7P\x0f\xeaf\xc0.b\xd3)8\xd9*p\xd7)܅\xf0c\xda\xcb\x01M\xa9ng˔K\t\xe5T\xec\xaa\xf0\xca\b{\xe0\b\xca\x10j\xc6\xf1\xf1\xd1\xf5K\x84\xbc\x83aG'~-\xc2{h\x9d{\x87\xbd\xa1\xbc\xa3\xed\x81#\xd8\x19\xbfd\x06s\v\xc1fq\xe9\xb2\xf2䬲\x19\xaez\vw\x9f\xed)\x95t\xba\xe4\xbf\xea\xf6+:I\x8b\xd5#H\x03\xee\x81W\x80\x9b\x1b\xadtg\xc7mI'\xae\au3`\x17\x16uګ\xd9\u007f/\xf3\xaf\xc7p\xf0\x12\xda\xffط\xfd:\x84Ju;\xab|\xe4\xf7\x12\xca;f\x83;|\x80\xdeZ\x0f\x1c\x11u\xba\xba\x9b\xee\xda\x1f\x9f\xf4\x1cfO\xa4\x1d\xfc\x98tXR\xadEx\x0f\u007f\x16\xca\xff\xfcVQ\x89O\xdb\x03G\xb03nɌ\xe6\x16Bَo\xb1ո\xe9\xdd[\xf8\x11{\xb6\xa4\x84\xbds};\xa0SV@\xa7m\xec\x8f\xc7\x04i[\x05t\xe2\xe6&U\xf2K:q=\xa8\x9b\x01\xbb\x88^'\x0f}A|+5\xfb\xef]o)ۛ\xb6I/\x8e\xff\xdbE\x81wg\xfd\x01\xe2P\xa9ng\x97\xe4k\x9e\xbd\xf2\xfd\x10\xbe%\xe5#\xec\x81'\xa2N\r\xc2%\xf6_\xe9\x16\xe9\xb1\xd4\xef\xbf-\xf7\xa3Z\x8b\xf0\x1e~/\xe4\tB\xe9Ͱ\x1e8\x82\x9dqKf47\xff\xfb\a\xdf\xe7fA\xada\xabX\xb2\u05ffE\xdaƅ\xccm\xdf7\xc2tʣF\f?R*\xb5\b\xe8\xc4͍Ӊ\xebA\xdd\f\xd8E4#{W%IJ\xbc\a\x1bJ\x04\xf7\v\u007f\xbc\xd5\xe3\xde|\xd5\xf7\xe6f7\x1b\xf1\xbb2\xffѣ\x97\xb6\tǤ\xea\xef\xc9w\x06}\xfa[i\xc0*x!%\xa3*\xd5\xefl\xf7\xdcʳg7+wV\xb4\x86\x9d\x88X\xed!\x80\xefw==\xf37\xf7\xf4\xdc\xf5\xab\xea\x86h\x10\xb2\u007fr\x9e6\xbb\"=\xc9j=[\x9a\xfdg\xd5\xdc\xf4{\xf8\xfd\xfc\xcb/\xf6\xdc\xf4\x85\xf5\xc0\xf7\xact\xc6/\x99\xee\xdc\x18O\xcb\xc3\x0f\x81\xbb\"zrv\f\xbf\xb2\xd5{\xd3\xff~ζW|\xb4\xd9\xfa\xc3\r\x8fѓī\u007f\xcci\x1d>\xe9~k\xb8\x92\xa9\x9c%,?y\xac(\xe7O\xf4`\xc9\xee\x8ah\xed\xe9Q\xcd\xed\xa3\xcaR\xb6\xaa\xb7J+?\xe2z\xe0\x9b\x01\x1b\x89\xfc\xb9S\x8et\x06\xee\x96\x06r\xdf+\xf5d\xaf\xfe\xb1 l\xddʊ\xfe-\x9b>n\xa5\xc5\u007fZ_\x98\x1d\xbc_u\xef|v\x9e\xff\x96|\xe2\xae9\xb8\xa8J\r:\xbbT\xba8\xe7I\xe9\xbd\xdb\xdf\xe3\xd9\xe1\xd7`\xb1\x87 o(W\x12G\xfd\xea\xbaA^x\xb2\xa1\xd0\xed-\x95]\xf0m\xcb\xf1<yU=7\xfd\x1e^q\xb32\xf7\x93\xefhz\xe0\bt\xe6\xe7\x96Lwn\x8ccޣRE!@+\x9b\xdc\xe6\xdf&\bs\xaf\xf8}\xadEY\xde\xf5NJ\xdcO\xd2c\xe2\xc9l!\xfb\xa4tm\x94\xb5csN~%Sf\x93\xd2j=?\xb7\x06A\xd8D\x9fn\x11\x84\x86P\x0f\xa5|3`#f'{\xd6\xf0ms\x9f4\xab\x13\x1d\xa7ݛU\x9f\xe1\xc4!\xb7\xb3\xb7\xdc\xfe\xf4ӏ\xdfx:'\xda[\x1aG\x83\xd0\xf5\xaa%bl\x06\"c\xafN\xf4\r\xb0Ж\xa1\xd7;ްA\xb2\xb8\xe3\xac\xf2)\x93/Ou4\x1c~_\xc6\xc6\xfb\xad\"\x11\xa3\x1716\x03\x91\xb1Y\xa7\x89\xc4\xef\xe5!r\xff;\xfcgo~\xff\x93\xca9ד\xba\x8dl'F/bl\x06\"\x03\x9dbƷٳ\xe5\xf4\x95\xd3[<[T\a\xd2?\x9d\x97q\xe4*\xff\xa642bV+\x8c\x18\x9b\x013\xa0S\xec\xf8ί\xcew\xe7\xaf>?\x86\xfb\xa542\xa2\x19B\x8d\x82\x18\x9b\x013\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6a\xb7N\xc8(\a\x13\x18S\x9d\x90Q.3\xf2\x1e\xa2\xe5\xa4t\a\xed⧣\xb9\th\xab\xa0\x93\xdad\xc0\xd1P]+\xb3\xb0Rw\xc2'\xa2\x9bꄌr\x19\v=pĒQ~\xf7\xbc\xf0㞞\x17\x96\xe5}\xa4S_\x83\x947\x18%\x1f\xf7\x94\x04\xea\x1a\xce\xc2\xca\xe2\xe8ԝ\xf0\x89\xe8f:!\xa3<@\xf4=pĔQ~K:\x8a\xdc\xf1D%\x8a\x95oZ\x94\a\xeb\x1a\xcd\xc2\xca\xe2\xe8՝\xe8\x89\xe8f:!\xa3|D\x98v\xa6WA\xde\u007f\xfd\xcb\xcc\xdaJ\x8cD\xa7\xf0YXY\x1c\xbd\xba\x13=\x11=rV\x042\xca\xc7\"\xa3\\\xde\u007foK)\xce\xc1fF[=k\x87\\\xca'\x97si\xe4\xaaׂ괍\xcen\xfe\x1dn\x16l\x19~\xcc\"%\x84\xd3\x06\xcbk\xa5\xeeDOD\x8f&\xc9\b\x19\xe5\xcef\x94\xdf\x12\x8e\r\xdf\xfdݲ%w\xf9fF[=KXr\xf2l\xdeӪ\xe4r.\x8d\\\xb5\x16T\xa7\x9b\x95B\xebU~\x16ï\x14n\xb9\xed\xbf\xfd\x93\x9c\x9e\xbb\x06\xcbk\xa5\xeeDOD\x8f\xfed\x8f\x8f]EF\xf9hf\x94ߒ\xde\xf7\x8bn\xaa\x9b\x19l\xf5,\xefG\xec,ۯJ.\xe7\xd3ȹ\xb5\xa0:\xb5f\x9d\xd7\xcc\xc2\xdf\xc0\x8e0\x9b6\xcbuu\x96\xd7J݉\x9e\x88\x1e\x9bN\x9b\x02\x93\xc8(\x1f\x85\x8c\xf2[\xc2O\xae^\xbd\xb4i\xf1\x1b\xea\x15\xd2\xdf\xeaY[\x02\xa5|r9\x97FέEy\xc3^\xe5\xe5\xe4f\xe1\xbf9\xf7\xdf\xfc\xbe\x1c9\xc3Yoy\xadԝ\xe8\x89\xe8\xb1\xe9\x14\x9cDF\xf9(d\x94+\xd7\xfe\xeb\x8b|\xaaf\xfa[=T\xca%\x97\xf3i\xe4\xdcZ\x94{s\x96<\xed\xd3̂\x16\xef\xf0_\xca\xd1\xd8\xcd\xcd\xd8J݉\x9e\x88nQ'd\x94s=\x8cVF\xb9\xb2\xff\x1e\xa3o\xe6\xfc\n\xe9ou\xb5NY\xb2N|\x1a9\xb7\x16\xe5\xdew\xde\xcfi\xd5̂\x9e\xac\xe5\xf9\x94\xf37\xdd\xe5\xb5Rw\xa2'\xa2G\xaf\x132ʵ=\x8cVF\xb9\xb2\xffn\xca\xf6\xa9VH\u007f\xab\xeb\xeaħ\x91sk\xc1\x06\xca/\xb9\xaf\xaag\xc1\x82\x02\xcf+\xe7o\xba\xcbk\xa5\xeeDOD\x8ffd\x0f\x19\xe5\x8ef\x94˷!\x9c\xad\x946f\xb0\x99\xfeV\xe7J\xf9\xe4\xf2P\x1a9\xb7\x16\x1f\xf7\x94l\xfe\x9d\xefn\xb9\xf7\xcam\xd5,\xe8L\x1e\xc9\xf9\xd4py\xadԝ\xf0\x89\xe8\x91?wBF\xf9\x18d\x94\xcb7ɹ\x97\x1d\xf3\xf1\xcd\xf4\xb7z\xa8t\v\x9f\\\x1eJ#\xe7\xd6\xe2(\x9bx\x83\xf5\xbeW=\v\xff\x9f\x84\xc0QUgy\xadԝ\xf0\x89\xe8f'{\xd6@F\xf9\xb8\xe4nV\xd8\xfb\x80!V\xea\x06\t]T'8\xf6ꄌr\xc73\xca\xed\xe0\xf4\xe2\xe8ߺ\xac\xd4\r\x02\x9d\x80\x19\xf1\x91Q>b\x1a\xae\xf8J\u007fbVI\xc1J]\x1e\xe8\x04̈\x87\x8c\xf2\x913,,\xdf\xea\x8d\xf2l\xd5J]\x8e\t\x94\x88\x0e\x9db'\x0e2\xcam\xa0!\xbbTsϠ1Vꆘ@\x89\xe8\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\xc6\xc8ur.\xbc;:\xd6\x1f\x95\xff\xbf\xb2:\xcf]\xb8yb\xdc\xdb\x02\xe2\x04\v:\x8dyx\xb7!|\xdd7\x84\xdd\xd2\xffW\xe7\x96\x1c\xbb|\xb4(o\x02|g\r\xc4\r\x16t\x1a\xfb\xf0n#Bu}=\xf9\x8aNg\x05\x16ipS\xf9\xda=\x00N`A'Ӽm+\x98vfZ\x81#Tw\xbd\xb0\xde#\xeb\xe4\x93\x0eKz\xe1b\x00\x8c\x16&:\xc5Ux\xb7*o\xdbwt\xb9\xe7\x1b\x87}\x9a\xcen\xdf\xf2\xe7\xec\x0e\xd4\xf7ݹT\xf8\x8d\x98\x8e\x9d\x00\xc4Dd\x9d\xe2+\xbc[5\xe3MY{_ܛ\xb5\xd9\x1fV7\xa8ӛԱl\fE\x00\a\x89\xacS\x9c\x85ws3\xbe$\x85\xd5ɏ\xea\xbaA\x9d|W\xaf\xb4\x16z\xe1\x13p\x8e\xc8:\xc5Yx77\xe3\xcdr$㣛\xc3\xea\x86N\xf6(\x1f\xe7\xebd_\x020J\x98\\;\xc5Wx77\xe3\x12Y\x93\U00092c3a\x8aNw\xe496\xb8q\xf1\x04\x1c#\xb2Nq\x16\xde\xcd\xcdx\xf3#\xacw_ᦰ\xba\xb2N\xbe\x1c\xb9f\x83'\x86\x1c+\x00b#\xb2Nq\x16\xde\xcd\xcd\xf8E\xe9O'\x85\x17\xb5u\x03:屟@\xf2\u007f\\\x18\xfec\x1a\x00\x8c\x16f:\xc5Sx\xb7*\xa3\xbcR\xd8}~\xb7P\xa9\xe9\xecNOO\xf6z)T\xfd\x05\xa1\xfc\xe8\xe5\xd6\xc2<;\u007f\xaf\x1a\x80\xc8D\xd6)\xbe»U\x19\xe5\xbe\xd6e\x9ee\x87}\x9a\xba{\xa5\x1an\xf6+\xac\xbf}\xbap\xfe\x92m\xb6d\xd2\x02\x10\x1d\x16\ue288\x9a\xc4\t\xef\x06\xc0\x12\xa3\xa1S\xe2\x84w\x03`\x89\xd1\xd0)A»\x01\xb0\xcah\xe8\x94\x18\xe1\xdd\x00Xf4tJ\x90\xf0n\x00\xac2*:\x0101\x81N\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00۰[\xa7\xb3%\xb7ͪ\xa8\xb9S\x12K\x88,\x00\xf1\x88\xa9N\x1fm\xc9\xf3\x94G}\xb7\xd0A\xa1!\xea\xba2\xbe\x83\xc2A\xb3:V\x18yd\xfa\xc8{\x88\x96\xb3n\xe5\xae`\xb7\xf9[J\x83\\\xe9E\x8f\xd0`V\x15\x8c\x19\xa6:\x95z\x8fn\xf2D\xfb\xbd\xa5V)\xe5\xcb\"/\xba[ͪX\xc0Bd\xfa\x98\x87\xae\x1f\x14zz\x0e\v\xad==s\x8d\xdfQ\x02\xcd\xeeTzJ\xe9\u007f\xa5\x9eJ|#2~1\xd3\xe9\x8e\xd0\x1a\f\xd43\xe5}7\x1f\xca\x155{\xb3\xec\xfc\x06z\xf4G\xc71\x0f]ou\xb3\x84\xc1\xdf\xf9\xfd\x1e\xe37\x94`\xb3\xdd\xe5\xf4]펧<\xa6M\f\x9c\xc1L\xa7\xf7\x04\vg>\x9b\xbd1}5pػ٬ʨ`%\x06\xdd\x14\xd3\xcet*\xf8\xdeStz\xcf\xd8\xe0`\xb3ݕ\xa5\xa7\xfd/\xac\xae\x84NqLD\x9d|\x8b\xe5S\xfb\x1d,\x82\x9c\x9eǽ\xef\x16\x96h\xd2\xc8\xfd\xef};\xcf\xed-\x97\xa6}\xd9\xf2K\xcde\x89\x1b5\xe3\x82\xc9){=\x1a\r-\xf7\xa0`\x10\x99\xce\x11W\xa1\xeb\fI\xa7h\x9a\xed\xae<\xfc\xb4\xbf\xfc(\xd3\xe9\xee\xfa|wa\xf9[~i![\xb7\xe4甿\x17\xd6/\x18\v\"\x1f\x9d\xde\xec9)4\xf4\xf4\xdc\xf2\xfbo\xf6\xb8\x1b\xfc\xbe\xab\x9b\xb3\xd4i\xe4\xfe+\xd9\xcb\x0f^n\x10\xa4\x93\x957\x85\x1e\xa9\x15\x97%n\xd4,\x14L\xcexE\xf8\xadz\xbe\x96{\b\xa0\x1b\x99\xce\x11_\xa1댠Nf\xcdvW\xde\xcc\xfeh\xfe-\xa6\xd3ya˕\xd3\xe5\xc2Uy!\v\x1b\x1a\n=\xef\x84u\fƀ\xe8O\xf6B1z\\\x1a\xf9p!\x8b\xb3\xf3\x9d\x96.\x8f_\x14\x82_\xb4\r\x85\x98\xeb6\xe3\x82\xc9\x197\x85\xf0\x8b\u007fk=p\x84G\xa6s\xc4]\xe8zP'\xd3f\xbb+\xfd˶\xac\xf43\x9d\x86O\xd2%\xf5-\x93\xde*\xb2\n\xef\xb28\xc1\x12\xbd\xbe\x81\xd3ĦӦ\xc0\xe4%>\x0e\xe2\xac\x10\xcc\xd7\x0f\x85\x98\xeb6\xe3\x82\xc9\x197\x85\xd3~-\xd6z\xe0\b\x8fL爻\xd0\xf5\xa0N\xa6ͨN\xec3\x05\xe9\xda\xe9\xce\xe1Տ\xe4\bRL{\x96t\x82}X\xc0x_<\x10\x9bN\xc1\xc9V\x81\xbbz\t\x9e\xb7\xf0!\xe6\xba\xcd\xf8`r\xbf\xfe\x8f\x9aY\xeb\x81#<\x94\x96'\xdeB׃\x1bʹ\x19\xd5\xe9ΎےNW\xbd\x85\xbb\xcf\xf6\x94\xca:I\v\xdb#\x98\x8d\xd3\x03'\xb0\xa8\xd3^\xcd^}\x99\u007f\x19\x87\xb3\x1a\x02\x93\xa1\x10s\xddf\\09\xa3\xc1\x1d>\x14o\xad\a\x8e\x88:\xc5]\xe8zP'\xd3f\xbb\xe5\xc4[\xa6Ӓ\x12\xf6&\xf6mY\xa7m\xec\xf1\x98\x10\xed\x87\x19`4\x89^'\xf6#\x99\xbe\x95\x9a\xbd\xfa\xae\xb7\x94\xedcۤ\xd7\xd4\xff\xed\xa2\xc0{v\xe8\xadX\xb7\x19\x17LN\xf1-\xd1\xf9\xd5\x18K=\xf0D\xd4)\xeeB׃:\x996\xe3t*d\xf2\xfb\xbe!\xeb\x94GE\x1a~\xa4\xd4\x0f\xe2\x80hF\xf6\xaeJ\x92\x94x\x0f6\x94\b\xee\x17\xfeȧ\x91\xfb\xaf\xcc\u007f\xf4\xe8\xa5m\xca\x0f:\xbf'\xdf/\xa4\xca\x12\xd7o\x16\n&\xf7\xb33F홊\xd5\x1e\x02\xe8G\xa6s\xc4W\xe8:\xe5\xcd\xc3B\xab\x1c\x1dm\xd2\xec\xa3\xcaR\xb6&\xb7J+?\xa2\x15\xd6\x1fnx\x8c\x9e\x0eҖY\xc2\xf2\x93NJr\x90\xb6\x16\x17D\xfe\xdc)G:\x9dwKû\xef\x95z\xb2W\xffX\x10\xb6\xf2i\xe4\xf4\x02}}av\xf0.ֽ\xf3\xd9E\x90*KܠY0\x98\x9c\x9e\xf7{vhgl\xb1\x87 \xfa\x91\xe9\x1c\xf1\x15\xbaN\x0f+\xac\u007f\xcf\xdd(\x9a5\b\xc2&\xfat\x8b 4\xf8}\xadEY\xde\xf5NJ\xdc\xf4\x98\x94\xb5csN~\xa5\xea=\x03\x8c\x19f'{\xd6\xf0ms\x87\x8f\\\x9bpڽ9\xde\u007f\x82)\x9eC\xd7C\u05eb`\xec\xb1W'\xfa\xbeYhq\xc4\xf6\x8e7l\x90,\xee\x88\xe7\xd0u\xe8\x14OجSb\x12ϡ\xeb\xd0)\x9e\x80NQ\x10\xbf\xa1\xeb7\xa5\xf1\x12\xb3Z\xc0)\xa0S4\xc4m\xe8\xba4^\xf2\xbe\x1f\xc4\t\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00۰['d\x94\x83\t\x8c\xa9N\xc8(\x1f=\x90Q\x9eh\x98ꄌ\xf2\xe8@F90\xd7\t\x19\xe5Q\x82\x8cr`\xae\x132ʣĴ3d\x94O\x00\"gE \xa3\x1c\x19\xe5\xc0\x02\xd1$\x19!\xa3\x1c\x19\xe5 *\xa2?\xd9CF92ʁ\t\xb1\xe9\xb4)0\x89\x8c\xf2`\x0f\x81\xceL\xc3\xc6\xd5 \xa3<\x91\x88M\xa7\xe0$2ʃ=\x04:3\r\x1bW\x83\x8c\xf2D¢N\xc8(GF90&z\x9d\x90Q\x8e\x8cr`B4#{\xc8(GF9\x88\x8aȟ;!\xa3\x1c\x19\xe5\xc0\x02f'{\xd6@F\xb9\xe3 \x056\x9e\xb0W'd\x94;\x0et\x8a'l\xd6)1AF9\x88\x0e\xe8\x14\x05\xc8(\a\xd1\x01\x9d\xa2\x01\x19\xe5 *\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6a\xb7N\x963\xca\xf5Ar9\x18\x8f\x98\xea4\xda\x19\xe5\xfa \xb9\\@r\xf98\xc4T\xa7\xd1\xcf(\xd7\a\xc9\xe5H.\x1f\u007f\x98\xe9\xe4DF\xb9>H.Gr\xf9\xb8\xc3L''2\xca\xf5Ar9\x92\xcb\xc7\x1d\x91\xb3\"F\x9cQ\xceuf9w\x1c\xc9\xe5Q4Cry\\\x11M\x92\xd1\b2ʹ\xbe,\xe7\x8e#\xb9<\x8afH.\x8f+\xa2?ً1\xa3\x9c\xc7Z\xee8\x92ˣh\x86\xe4\xf2\xb8\"6\x9d6\x05&\xcd3\xcay\xac\xe5\x8e#\xb9<\x8afH.\x8f+b\xd3)8i\x9eQ\xcec-w\x1c\xc9\xe5Q4Cry\\aQ'\xeb\x19\xe5<\xd6rǑ\\\x1eE3$\x97\xc7\x15\xd1\xeb\x14cF9\x8f\xa5\xdcq$\x97\xfb\xa3h\x86\xe4\xf2\xb8\"\x9a\x91\xbd\x11e\x94\a\xb1\x9a;\x8e\xe4r\xbfy3$\x97\xc7\x17\x91?w\xb2!\xa3<\x88\xc5\xdcq$\x97#\xb9|\xfcav\xb2g\x8dX2\xca\xf5Ar\xf9\x88@6\xec\xd8`\xafN1d\x94\xeb\x83\xe4\xf2\x91\x01\x9d\xc6\x06\x9bu\x9aH \xb9\x1ch\x81N1\x83\xe4r\xa0\x05:\xc5\x0e\x92ˁ\x06\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80mح\x132\xca\xc1\x04\xc6T'd\x94ˌ\xbc\x87hAF\xf9\xf8\xc5T'd\x94\xcbX\xe8\x81\x03\x19\xe5\x13\v3\x9d\x90Q\x1e \xfa\x1e8\x90Q>\xb10\xd3\t\x19\xe5#´3d\x94'\x14\x91\xb3\"\x90Q\x8e\x8cr`\x81h\x92\x8c\x90Q\x8e\x8cr\x10\x15џ\xec!\xa3\\\xdb\x032ʁ\x86\xd8t\xda\x14\x98DF92\xcaA\x88\xd8t\nN\"\xa3\x1c\x19\xe5 \x84E\x9d\x90Q\x8e\x8cr`L\xf4:!\xa3\\\xdb\x032ʁ\x86hF\xf6\x90Q\x8e\x8cr\x10\x15\x91?wBF92ʁ\x05\xccN\xf6\xac\x81\x8c\xf28\x01)\xb0c\x83\xbd:!\xa3\x1c\x19\xe5\x13\x1a\x9bu\x9aH \xa3\x1ch\x81N1\x83\x8cr\xa0\x05:\xc5\x0e2ʁ\x06\xe8\x04\x80m@'\x00l\x03:\x01`\x1b\xd0\t\x00ۀN\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80mح\x132\xca\xc1\x04\xc6T'd\x94ˌ\xbc\x87h9)\xddA\xbb\xf8\xe9h\xee\x12\xda*\xe8\xa46\x19p4T\xd74ڼg\xaeP\xe2\xf3\x9f\x15\x84\xb9\x97\xd5\u007fxgu\xb6\xb7\xf2\x8a\xf7\xb6\x95\x19O LuBF\xb9\x8c\x85\x1e8b\xc9(\xbf{^\xf8qO\xcf\v\xcb\xf2>ҩ\xafA\xca\x1b\x8c\x92\x8f{J\x02uM\xa3͇/\v\x9e\x1e\xffݳ\xc2e\xf5\xf7L.e\xaf<vr\x99 \xfc\xbb\x95\x19O \xcctBFy\x80\xe8{\xe0\x88%\xa3\xdc\u007fKz\xe3\xbf\xe3\x89j\u007f\xb5\xf2U\x8c\xf2`]\xd3h\xf3\xbbB\xe5f\xfa\x82j\xb2[\xee\xe4<M7\xc3p\x91\xf0\xef\xd6f<a0\xd3\t\x19\xe5#´3\xbd\n\xb2N\xfeefm%\xac\xec՜Nf\xd1\xe6w\x85\xcb\xd9\xc3a:\xed\xf6Hߗo\x15\u07b36\xe3\tC\xe4\xac\bd\x94\x8fEF\xb9\xac\xd3m)\xc59\xd8\xcch\xabg\xed\x90K?\xcds\xff\xb80\xffʶ\x9cһ|\\\xb9굠:m\xa3\xb3\x9b\u007f\xc7<\xda\xfc\xae\xf0\xfecg\x15\x9d|G\x97{\xbeq\x98\xadZ\xd1&i\xeewZ}\xa1\x19kz\xd0\xdd:z+\x9f\x90D\x93d\x84\x8crg3\xcao\tdž\xef\xfenْ\xbb|3\xa3\xad\x9e%,9y6\x8f\x96^\xc9\x11v\x94\n\x8b\x0f\xe6\xb5\xf2q媵\xa0:ݬ\x942\x92L\xa3ͩN\xad\xe5\x8aN\x9b\xb2\xf6\xbe\xb87k3]a\x81\xbb\x9e\r\xceXӃ\xce\xd6\xd1]\xf9\x84$\xfa\x93=>v\x15\x19壙Q~K:d\x15\xddT73\xd8\xeaYޏ\xd8Y6\x9d\xf2V\xd2W\xe0\xbc\u007f\xd3\x16u\\9\xb7\x16T\xa7\xd6,\xe9\xf54\x8d6\xa7:ݙ\u007fG\xd2\xe9\x92\x14\xf0\xc7\x1e\xdf\xe7_\x91ЌU=\xe8m\x1d\xa3\x95O<b\xd3iS`\x12\x19壐Q~K\xf8\xc9ի\x976-~C\xbdB\xfa[=kK\xa0\xd4{\x92\xee\xb1\xc3r\x90%\x17WέEy\xc3^\xe5\xe54\x8d6\xa7:\xf9\xcb[%\x9d6\xcb\xdd<\xba\xd9\xef\xe3G[C3V\xf5\xa0\xb7u\x8cV>\xf1\x88M\xa7\xe0$2\xcaG!\xa3\\\x19\x8aX_\xe4S5\xd3\xdf\xea\xa1R\xef%\xffU\xb7\x9c\v\xcbǕskQ\xee\xcdY\xf2\xb44[\xd3hs\xa6\xd3\xd9oH:\x95\xc8\xc1\x86\xe5%\xc1k'\xdf%Ռ\xc3z\xd0n\x1d\xa3\x95O<,ꄌr\xae\x87\xd1\xca(Wt:F\x0f\x12\xfc\n\xe9ou\xb5NY\xb2N|\\9\xb7\x16\xe5\xdew\xdeϑ\x0e0\xa6\xd1\xe6L\xa7\xe1\xec\xcb\xd2\xd1\xe9\x11\xb6\x86\xbe\xc2MldOڲ'\x85\xdb\xfc\x8cU=\xe8m\x1d\xa3\x95O<\xa2\xd7\t\x19\xe5\xda\x1eF+\xa3\\\xd1iS\xb6O\xb5B\xfa[]W'>\xae\x9c[\v6P~\xc9\xcd2gM\xa3͙N\xfeM\x95L\xa7\x17\xa5e8)\xbc\x18\xf8\xdc\xc9WZ\xa8\x9a\xb1\xaa\a\xbd\xadc\xb4\xf2\x89G4#{\xc8(w4\xa3\\\xbe+\xe2l\xa5\xb41\x83\xcd\xf4\xb7:W\xfaǜ\xd6\xe1\x93\uedc6+\xe9.\x1c\x8a+\xe7\xd6\xe2㞒Ϳ\xf3\xdd-\xf7^\xb9m\x1am>|Y8{\xd7\xdf\xe3\x91F\xf6*\x85\xdd\xe7w\v\x92\x80\x97<%/\x9c]\xed~E\xb58\xa1\x1e\f\xb6\x8e\xd1\xca'\x1e\x91?wBF\xf9\x18d\x94\xcb\xf7칗\x1d\xf3\xf1\xcd\xf4\xb7z\xa8t\v=\x16\x9c\xcc\x16\xb2O\xb2K\x94P\\9\xb7\x16G\xd9\xc4\x1b\xac\xf7\xbd\xa6\xd1\xe6W\xe6\n\xc2i\xbf\xaf\xc4+\x9d\xe7\xb5.\xf3,;,\x8b\xf1\xcejO\xde\xd3\xff\xa6^\x9cP\x0f\x06[\xc7h\xe5\x13\x0f\xb3\x93=k \xa3||\x13\xba\xf8\x1d1\t\xb8u\xa2\xc0^\x9d\x90Q\x1e'\x19\xe51b\xa3N\x06['\xc1\xb1Y\xa7\x89D<g\x94Lj\x8d:\x19l\x9d\x04\a:\xc5L\xfcf\x94Lj\xad\xd1\xe6\x06['\xc1\x81N\xb1\x13\xb7\x19\xe51bo\xb4y\xa2m\x9d\xa8\x80N\x00\xd8\x06t\x02\xc06\xa0\x13\x00\xb6\x01\x9d\x00\xb0\r\xe8\x04\x80m\xfc\u007f\xe7\xbd\xe7\x84\xdaB\xea\xf4\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/call-eg.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\x1e\x00\x00\x01\xc8\b\x03\x00\x00\x006\x92\x13\xd7\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x05\a\x03\n\r\t\r\x12\x14\x0e\x12\x1d\x11\x13\x10\x1b\x1a\x14  \x19\x15\"6\x1f#%!# $%#&(&+)\x1e++$*,*0.\"-/,\x1c0Z120463/6B;8-8:7<>;C@4#Cx@B?AFHDFDKH<MH7\x00f\x00IJH\x00i\x01\x00j\x02LNK8P|0R\x95\am\x06PROYTC\x0fp\vTVS/Z\xa3\x0es\x18,`\xae7]\xad\x15v\x1c[]Zb]K9a\xab\x19y\x1e;b\xac_a^=d\xae@f\xb0*{!bdaBh\xb3efdDi\xb4fheMj\xaf.\x81.Fm\xb1qjROl\xb2Ho\xb3kmj0\x859Jq\xb5Kr\xb7npmMs\xb8;\x86:cr\x8fNu\xba|t]Xv\xb6sur?\x8a>Zx\xb8vxu]{\xbb_}\xbez|y\x84|dX\x80\xbfL\x91K`\x81\xbbb\x80\xc0}\u007f|\u007f\x81~c\x83\xbdN\x95Ue\x85\xbf\u007f\x83\x92W\x95V\x82\x84\x81\x8d\x84fg\x88\xc2m\x87\xbci\x89\xc3j\x8a\xc4[\x9aZ\x87\x89\x86q\x8c\xc1\x8a\x8b\x88\\\x9dc\x96\x8cnt\x8e\xc4v\x90\xc6g\xa0g}\x91\u008f\x91\x8ey\x93ɒ\x94\x91\x80\x95\xc6z\x97Ƃ\x96\xc7s\xa4l\xa1\x96x\x95\x97\x94\x83\x98ɂ\x9aė\x99\x96\u007f\x9d\xcct\xa9v\x86\x9b́\x9eΚ\x9c\x99\x82\xa0Ϩ\x9d\u007f\x9c\x9e\x9b\x88\xa0\xca\u007f\xabz\x8a\xa2̟\xa1\x9e\x9e\xa3\xa5\xa1\xa3\xa0\x8d\xa6Ђ\xb1\x85\xa3\xa5\xa2\xb3\xa7\x83\x91\xa9ԧ\xa9\xa6\x8d\xb5\x8a\x94\xac֙\xacѪ\xac\xa9\xa4\xac\xc0\x9e\xad͍\xb8\x93\x9b\xafԻ\xae\x89\x9d\xb1֯\xb1\xae\x97\xbb\x97\x9f\xb3ء\xb5\xdaµ\x90\xb4\xb6\xb3\xa3\xbf\x9d\xac\xb7Ң\xc0\xa4\xa9\xb9ٷ\xb9\xb6\xac\xbcܺ\xbc\xb9\xa6Ũ\xb1\xbd\u05ef\xbe\u07fd\xbf\xbc̿\x9a\xb1\xc0\xe1\xb8\xc0ձȭ\xc0¿\xb7\xc2ݹ\xc5\xe0\xbd\xc5ڲͷ\xc2\xc6ֻ\xc7\xe2\xd6ǝ\xc6\xc8ż\xc8\xe3\xbf\xca\xe5\xbdм\xc6\xcb\xdb\xca\xcc\xc8\xc1\xcc\xe7\xc2\xcd\xe9\xbf\xcf\xe2\xc7\xce\xe4\xca\xcf\xdf\xce\xd0\xcd\xc8\xd3\xc1\xc8\xd0\xe6\xdfѥ\xca\xd1\xe7\xcb\xd3\xe9\xca\xd8\xcc\xd3\xd5\xd1\xce\xd6\xeb\xd3\xd7\xe0\xd6\xd8\xd4\xd0\xd8\xed\xe7ج\xd5\xdb\xd0\xcb\xdb\xee\xd5\xd9\xe9\xd9\xdb\xd8\xd7\xdb\xeb\xd8\xdc\xec\xd2\xde\xec\xd5\xdf\xda\xd9\xdd\xed\xdc\xdd\xe7\xdd\xdf\xdc\xd7\xe1\xdb\xdb\xdf\xef\xd5\xe1\xef\xf0\xe0\xb3\xdd\xe1\xf1\xe0\xe2\xdf\xde\xe3\xe6\xd9\xe5\xf4\xe0\xe4\xf4\xe3\xe5\xe2\xde\xe6\xef\xe8\xe5\xea\xe5\xe7\xe4\xe6\xe7\xf1\xe0\xe9\xf1\xe3\xe9\xeb\xe7\xe9\xe6\xe3\xec\xf4\xeb\xed\xea\xe6\xee\xf7\xec\xed\xf7\xe8\xf0\xf9\xef\xf0\xfb\xf0\xf3\xef\xf4\xf2\xf6\xef\xf4\xf7\xf4\xf7\xf3\xf2\xf7\xfa\xf5\xfa\xfd\xf8\xfa\xf7\xfd\xfb\xff\xf7\xfd\xff\xf9\xfe\xff\xfe\xff\xfcA\x10\x8d\xd1\x00\x00 \x00IDATx^\xed\x9d\x0ft\x14U\xbe\xe7\awqv+\xfd^\xcc&O\x98\xe51\xd3@vaȆ\x82\x89M\"\x98`^\xc0\x13a} \b\x0e\x88\x99l\x1c=A\x98\xe1\xafg2\xcf3YI\x8eA\xf2@$\x98\xacsL\x00\xb3J\x88\x12\x91\x80\xae\xe6\x80ᨼ#\x90LD\x87\x93\x991\x83о\xc9L\xc4RQD\x12\xfb\xd4\xd9{oUu\xdd[\xa9\xbe71\xe9\xaa\xea\xee\xdf\xe7p\x92ە[\xb7nU}\xba\xeaVu\u007f\xa9\xef\xa9#@\x01\xe2\x9c\xef\x89\x14\xe0!j\x1c\x88u@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\xb8\xa7G_kMeM\x9b\xfe\xa2\xad\xaejG\v\xaf6\xe0\n\xee\xe9QW\xd5z\xaa\xa5\xb2\x05\x17{\x1bʛO\xb5\x94\xb7\v\xe6\x00\x1c\xc75=Z+\xbb\xd0\xcf\xf6\xca\x1e\xf4\xb3\xa1\xb2CQ\xbaʍC\t\xe0\x19\\ӣ\xae\x81\xfc\xaanQ\x94\x8e\xf2V\\\xec\xe1U\a\\\xc15=j\x1a\xb5_u\x8a\xd2\\\xd9+\xa8\f\xb8\x84kz4Uc'\x82U\xbb\xb0\"m5\xe5\xd5MA\xd1,\x80㸦GOU]W\xb0\xa3\xa6|\x87\xa2\xec(\xafn\xedh\xab\xde\x01\xc7\x10\xcf\xe1\x9a\x1e\xca\xf9\xba\xf2\xf2\xf2\xe6\xba\x1a4\f!\xe3Ӟ\xaaf\xd1,\x80Ӹ\xa7\a:\xb3\x9c\xefS\xaa\x9b\x14\xa5\xb1\x86\xbc\xd4\u007f\x01\x1e\xc2==ȩ\xa4\xbd\x1c]ҶT\xf5\xe1rC\x1d\u007f\x06\xc0y\\ӣ\xad\xbc\v\x9dP\xaa\xf1\xf5\xcbyraۣ\xdd\"\x03\xbc\x84kz\xb4\x97\xb7t\xb4Vב˕\x96\xca\x1644\xad\x81\xa1\xa9\xe7pM\x0f\xa5uWU]\xab^n\xaf\xa9\xda\xd5\x02vx\x0f\xf7\xf4\x00b\x00\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x14e\xcd\x1a\xbb\"\xa0\xb8\xa9G8D\xd9[]\xaeQ-\x9a%:\xfc\x9b\u007f\xa3M\x11\xb3Ǐȼ\xfb\xc4\xe0yF\x8f\x12\xb4\x88\xa9gE\xb5\xdc\xc2==\xc2!\xca`yK\a\xa2\xa5\xbcUq\x85\x92)\xef\xdb\x141=\xbf\xf5?qd\xcf\"\xff\x8b\x83g\x1a5\xce\x1e9\xb2\xc7\u007fDT\xcb-\\Ӄ\nQ\xb6ᯌ\x05\xf1\x97\x92\xdd\xe0\xacy\xc48\xcb\x1e<\x14\xe5\x041cѭJTy\r\xf4\x18\x04\x15\xa2\xd4^\xefr\xe9\xdbb\x91\x0f\x1e\x86\x1eO\xfa\xa3\x9b\xd0\x02=\x06C\x85(1\xe4\x9b\xc9npv\xf2F\x9b\xa2\x8e\xa6G\xc9LE\xf9\x85\u07ff\x17U\xf0ߎ\x8b\x93\xf7l\xbcu\xea݃\x06\f{\x17M\xbdu#2\xe9\xc4d\xbf\u007f\xa52\xd3\xef\x9fޫ\xf4\xac\x9c9y\xe6J4z\xe9˜\xfc\xeb\x993_\xdc8}Q\x10\xb7\xf0䚙\xd3W\xea-\x98z\x18-x\x06\xd7\xf4\xa0B\x94\x98]\r\xdc\xda\xd1c\xcd\xe4\xb36E\x9d\x13\xfe\x17\x82g7\xfa\x9fP\x94\xf7\x8fL~\f\xedȒ)h\xfc\xbaw\xb2?\xf3\xb1'\xa7\xae\xb4T.\xf1o|\xe1\xc9\xcc\xdb\xfb\x94\xbe\xd7\x1e\xf3\xbf\xa6\xfcֿ\x17Y\xf1\x82\u007f͋{W\xa2\x97ʋ\xd3\xfd\x1b\xef\xf6g>\x91\xf9$ia\xe6\x13\x8f͜\xaa\rz\xc3z\x84[\xf0\f\xae\xe9A\x85(\x11\xa7p\xde\xc5\r\xceN^cS48\x81/]\xfc%\xa4<\x05\xe9\xa1<6\x85\x14\xa7#\x8fJ2ٺ/\xf8\u007f\xab\xe0]\xbd\x17\xbf(\xb9\xe3\x8f3\x9f\xc0\x85\xe0^|0\xb8\x1d\xab\x94Y\x82\xea\xfc_\xa5\x04/e\xca-h\xcc\xf5\xe7\x99w\x909\r=\x98\x16\xbc\x81kzP!JD\xc3.A\xedh\xf1\v\xf3\x88\xf1\x8bA\a\x0f\xa4Ǔ\xaf\xbd\xb0h\n\x99N\xebQ\x12.\x9a\xac\xbc\xa5\xb7\x0f1\x93\xc8\x14\xbc=S?\xb8\xfcq\xcfݷL\xc7\xe7$%s/\xda\xf5Ae\xe3\xcfp\v\xe44\xb6\xc7\xffg\xfc\xcbЃi\xc1\x1b\xb8\xa7\x87\x19\xa2DT\xb5\xf0\xabF\x8b\xf7\xa7\xac\xb1)\x86!c\x8f?\xfb\xf7\xe02\xad\x87Y4\xb9ݯ\xa1i\xb1W\xdf\xe5\xafe\xceܸ\xf7\xc8\xddD\x8f\x17\x95\xd7&+\xba\x1e\xb8\x05刟\x9c]\f=\xd8\x16<\x81{z\x98!J\xfc?\x03\x9d\xe2W\x8e\x16\x1b\xfdgm\x8aa\xb4\xa1\xe9t\xb2/Ez\x94\xdcr\x82\xf0G\xfc\xe2\xfd\xcc\xc7f\x92\xc2\xedw\xe0\x93\xcbJC\x8f)\n{\xf4 \xff卡\aӂ7pM\x0f*D\x89\x87\x1e\xe7\x05գ\xc3\xfbSJl\x8a&\x9a\x1e\x99\x1bO\xa0q\xc4T\xb4G\xfb\ue22cNjژ\xe11<\xe4\xe8\xbd\xe31e\xcd\xddx\x889\x13\x1f\n\xfan\x1f\xa4G&\xb2&x\xcb\"2\xa7\xa1\a\xdd\x02\x1a\n=\xe1\x81{\xa9\xae\xe9A\x87(\x91+\xee\\\xcd\t\x0e\x1e\xf8\xca\x05\xfd\xbc{e\tڽ\x8b2\x9fx\xe2\x0e\xff\xe4ߞ@\x171%\xaf)'J&\x1fa\xef\x92l\xf4\xffl\xef\xde\x12\xb4\x8b\x83G\xd6d\x9eU\xceN\xdfx\xa4Wy̿r\xcf\x13\xb7\xa3\v\x96\xd7NL\u007f2\xb8w\xf2\x89\xe0\xcf\xf0\x15\xf1\x14\xff\xed{\xf7܊G\xb8\xe4\xae\xe9\x93G\x8e\x9c\xa5[\xc0\xac\xf4\xc2I\xc65=\x98\x10\xe5)wF\xa6\xefO-\xb1)\x9a\xecE\x03\x01\xf4V>qk&\xb2\xe4\xec\xa2)S\xef\xfe\xb5\u07fff\r\x9a:\xf9\xc4T\xf4\xd32Xy\xf1\xee\xcc\xe9\x8b^\xc0G\x01\xbf\u007f#\xda\xd7~t\xec\xe9{\xf2\xd6)\x99+\xf7\xdc:yQ\xa6\u07ffw\xaa\u007f\xea^2\xb6\x98\xb2\xb1d\xfa\xcc\x12\xacW\t=\xe00Z\xc0\xec\xc9ܣ\xb8\x8e{zx\x80_\xfb\xffͦ\xe8\x04\xda\xd0\xd4\xfb$\xb4\x1e\xee}\x92\x0fz\x00\x1c@\x0f \"\xda\xe06\x16\x00=\\\x80\fn=p\xd9*\x06\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x18\x16/\xad\xfaPQ\xceOK\x98\x87\x03\xb8\xa7\a\xf5$ʞ\xa6]\x95\xbb\x9a\xbc\xf7\xb0\xb0Wg\xc8\x1a\x81w\xb4\t\xb5r\xed\xa7\xe8\xd7\xe6\xa4u\xdc\xf9\xe2\a\xf7\xf40\x9fDy\xbe\xba\xa6\xad\xa3mW\xb5;\xdf\x18\xe3\xf0\xf1\xab\xf9\x0f\xbd\x8a8 \xbfB^?#\x1f\xd0\xfeP\x97\xf4\bg\xb68\xc25=\xa8\x10e#y\x0eT\xef\x0e\x97R\x94<\n\u007f\x85\u007f\xfeN\xd3\xe3wY\xbf\xe9\xeb\xeb\xeb\xc5\xdf\x11|\xc0\xe7R\xf0\xc2a\\Ӄ\nQ6h\xa7\xf2\x1a\xb7\x92P\x1c4=>}\xe6c\xf4\xb3\xfd\x1f\xfe\xd3?Κ4q\xe2\ndtϸ;\x05s\xc6\a\xae\xe9A\x85(\xcfW7v\xf5v5V;\x1f\xa3\xfc\xf4\xc0\xaa\xecſ\xc1\xfb^\xf9xӼ\xf9\xbf\xf9ͼ\xec\xe7\x99\n\x9a\x1e\x84^\xdf\u007f\xce\xc8\x18\x93\x9c\x91>\xe6\x81 :|$\xbb\xf3\xedX\x87qM\x0f:D\x19l(//opa{o\x92\u007f\xf3\xca3\xf9\xf7\xa0\xe1構\xf3\x9f\xa9\rd?\xf3\xd03L\x85\xc2M\x1f\u007f\xfc\xcc*R\f\xfe\x87u\xaa\xdavU\x1d\xb8a6\xf2\xb8IJ\x88'߹\xa6\a\x15\xa2\xecm\u0601\x86\xa6;\x1a\x1c\x8f\xe8\xbfD\x86\x9ao\xca\xe8\x88\xf1\xbc\xfc\x0e\x1ez\xbec\xa9Q\x88\xaf[\xf2I1\xf8\x0fcƌQ\xf2ƌ\xb9a\x1d\x1aCwH\xee|{\xdaa\\Ӄ\nQ6\xed\xc0\a\x0e\x17\x86\xa6\x9b\n?\xfd\x1bb\xfe&E\xd96W\xc1CЗ,5\n\x1fz\xf3\xcdM\x9a\x1e\xca\xff\xf9/\xff\x88\xf4\x18;g]{/\xd6c\x87\xb5\xb5x\xc4==\xcc\x10e\xa5\x96gh\xad\x14\xd4\x1fu\x96\xea\xb75\x1eB\a\x8e\x19h\x04\xf2\xca\xe0\xa3\a\x1a{\xbc\xa3\x9fo\xfe\xdf\xff\xf8_H\x8f\xa4\xd6.|\x94k\x96\x1c\x97\xd9\r\xdc\xd3\xc3\fQ\xba\xa6Ǧ\xc27\t\x1f\xe3\x03\xc7C\xbf{g\xf1\xaaO-5\xa8\xa1\xa9\xf2q\xe0\u007fb=\xdaI\xc7\xd7\xf9\xbcw\x17/\n\xb8\xa6\a\x15\xa2l '\x97\xe0\x0e\xc7/l_\x91\xc9uʶZ<\x00)\x90\xe5\xa2\x0f\xf5?\x9cZ\u05ee\x15h=\x94\xf5\xff-\xacG\xdf\xc4YJ\"\xe0\x9a\x1eT\x882\xb8\x83\fMw8\u007f\xe9\xb2mƦ\xe7_ڄ%y3\xf0\xca+\xaf~h\x1c<fKd\uf4fb\xa6\x1f\x87k\xff\uefc6\xf5\xd8,\xb5\fn-\x0eqM\x0f:D\xd9ۼ\xab\xaa\xa6\xd9\xf1\v\x17\xc4+E\xf3\xe6\x16\xe1[\xa2\xaff\xe1AHV\x916\xf8\xa8J+ǿ\xc8g.ԍ\x90\xf0ɥ)y\x85]k\xf1\x87{zx\x8a\x0f\xb3\u007f\xf5\xe1\xdf\xfe\xf6\xf1\x9bks̓\xc5`\xfeU\xd7c\x87\xefN7\\v\x01Ѓ\xf0\xd2\\\xed\xbc\xf2\xe9\xbcW8\xb5vhz\x9c\x1f\x97(\x1f\u0602\x1e\x1aoꗴ\xef\f\xba\xb4\xd5!\x17\xc0x\xec\xf1\x1f\xff{\x82\x1c8\b\xa0\a\xe1\xd3Mٿz\xfe\xd5\xe7\u007f\x95]f\xbd\xb4\xd5\x01=\x86\x8f\xa8\xf1\x18\xe2ӗ\x1e\xca\xcf\xca\u007f\xe8\xa5\bvh\xec0\xef{$\b\xa0\xc70\x00=\x86\x85\xa8\xf1x\x03\xf4\x18\x16\xa2\xc6\xe3\x8b\xdeGoCzܸ\xba)\x81\xfc\x00=\x86\xcc4\xe3\x03}\xb7\x1e\x0e\xe0\x02\xa0\xc7P\t\x8e]\xa7\xaaWUu`\xec\x1c\xcf}g:j\x80\x1eC%(I\x19\x19c\xd32\xd2\xc7\xdc\xe9\xfc\xb7\x1e\xdd\x02\xf4\x18*\xbdM\xe3RS'\xa4\xa6\xa6f\xb48\xff١[\x80\x1eC\xa6\xb7\xa3\xbd\xbd\xfd\x14\xfa\x97\x10\xdf\xf4\xd0\x00=\x86\x01θh9\x97D\xc1==\xa8\x10%U\x04<\x85{z\x98!J\xba\xe8\t\x1a[D5\x12\x05\xd7\xf4\xa0B\x94T\xd1\x1b\xa4\xe7\x89j\xe8\x8c\x19}D\x8bt\x16\xd7\xf4\xa0B\x94ևR\xbaN\xfam\xa2\x1a:c.\x8e6\xa0\x87\x06\x15\xa2\xb4<\x94\xd21Z\x93$\xe9\x81\xf6\x05\xe3\x93g\xe1۠\xd5Ӓ'\xe0\xf8l\x9d\xa4\x91\xae(K\xa4\xa4j\xe5\x94O\x9a\xc8\xd4ES˗MH\x9e\xd5\x01z\xf0\x115\u0383\nQZ\x1eJ\xe9\x18\xc1\x1d\xd5\xe3'\xa4\x8c[\x96'\x9dR\x94;\x93\x96\xd5=\x92\x96ާ\xf445N\xc8hllDC\xe5\x8eƤ\x87\x15\xa5y\x81\x8f\xa9\xdbV\x9d$\xa5=\xbc9e\x0e\xe8\xc1G\xd48\x0f*D\xc9>\x94\xd2Qҥ\f\x9c\xb7\xc7nj*\x05\x87\x9bH\x1f̓\x8b\x0f\xe9\xa1<\xecc\xeb*\xbeTt\xe4X\x90\x06z\xf0\x115΅z\x12%\xf3PJGI\xf7\xe9\x0f\xb1\xcb\x1bߋ\xd1\xfe_\x86\bz\x18u\x15\xdf\x02}\xea\xf0\xf5\x18C\xfeq\xfe\xaex\n\xf7\xf4`\x9eDI\x15\x1d%=]/L\xd2G\x1cs\xc8T{=\x8c\xba\xe6T\xbc\xa7\x9f\xbaI\xdb\xdfڅ\xc7X\xaa`\xbb\xfbA\x8f\xa1A=\x89\x92~(\xa5\xb3\x84E\xc8\x1b\xdfB\xe8\nO\xad\xc4\xc7\n\"\xc2\x03>\xb6.\xab\xc7\xcdOQ\xfb\xfb'\xf7Z\v\x16@\x8f\xa1A\x85(\x99\x87R:Kx\x977h\xa3\x8e\xfbID!#CQ\xbaȄ\xe4Պҗ\xceՃ\xde\xdf/\xdfx\xceR\xb8\xf8\xf8Mcn\xfc%\x9a\xf0\xa3\xb17\xfc\xe8ݰ\x1e\x8f\xff\xfd\x98\xef\xff\xf3E\xaa\x80\xfe>\xe6\xa6\u007f\x01=\f\xa8\x10%\xf3PJ\a\xe9m&\xd7(ڈb\xb5\x94\xb7\xab\xe6N\xa9\x1a\x97\x1f\xf6m\xae\xc9H\xc6\a\xb3ii\xeb\xd6M\x93\x92\xaaڨ\xba\xe8zfA\xb3Ҳ \xa9\xb1êǏ\xef\xb5\x16\x1e\x1f\xfb\xf8\xb9\x97\u007f|\xf1\xe2\xdf=u\xeeݟ\xfc\xd8\xd0\xe3ٿ{\xf6\xdc\xcb?\xf8g\xaapӽ\xef\x9e{\xf6\x87\xa0G\x18*DI?\x94\xd2A\xf0\xbd\f\x84\x1e\xa6n\xc8HM\xcd\xd0n\xbd\x04\x97\xa5&g\x90\xff\xfd\xa7=#9e\xd6\xfd\x92\xb4\x84\xaa\xbb\x04\xfdNjKF?\x97X\xf4\xb09x\xe0#\x82\xc1\xbb7\x1az\xdc\xfc\x1cz\xf9\xc6\xf7\xa9\xc2\rohu@\x8f8¢Ǐ~n-\\\x1c\xf3\xae\xf6\xfb\x8d\x1f\x8eE\xe3UC\x8f\xb1\xda\xf0\x95*\xfc\xd3؟\xfc\xf2\r\xd0#\xbe`\xf5x\xce8f\x84\vh\xff\xebz\xdc\xfcOo\\<\x17\xd6c\xcc\x1b\x86=F\xe1\xe2s\xf7\xfe\xe8\x86{A\x8f\xb8\x82\xd5\xe3\a\xbf\xb4\x16\x90\x16\xfa\xc9\xe5\x06$̳a=n6\x8e.\xe1\x02\xe6\xe5\x1b@\x8f\xb8\x82\xd1\xe3\xd9\xef_\xb4\x14\x10Oݨ\rMo\xba\xf7\xdcs\xdf\x0f\xeb\xf1\xd4\xd8_\xbe{\xee\xa9\x1fP\x85\x1f<~\xee\xdc\xcfo\x02=\xe2\n,\x86>x@G\x02\xe3\x98q\xb3y\xf0\xb8x\xf1_\xfe\x9e\\\xd8>\x87\xaeo\u007f\x1e\xd6\xe3\xe2S7\xdf0\xe6槨\xc2\xe37\x8f\x19\xfb×A\x8f\xb8\"<(\x1d5@\x8f8\x02\xf4\xe0!j<\xee\x01=x\x88\x1a\x8f{@\x0f\x1e\xa2\xc6\xe3\x1eЃ\x87\xa8\xf1\xb8g\xcc\xe8#Z\xa4\xb3\x80\x1e\x00\x87\x98\xd0#OJ]\x00))7\x88\t=:\x1a\xab&\xa6z&\x05\x93H8\xafG\xa3q\x1c訩j\xe8\x18T\x8c@\xa3\xe4\xc2'\xfe\x80\xe3zt\x95\xb7h\x85\x8e\xca\xc6\xf6\xc6\xca\x0eK1\x12͉\xf1\xf4%\xaf\xe1\xb4\x1e\x1d;t=\xfa\xc87\x8f\x9b\xaa\xfb\x98bD@\x0fWpX\x8f\xc6\xf2F=j\xddVI\x1e\xc6P\xd9\xc6\x14#\x02z\xb8\x82\xc3z\x04\x83F\x94\xb6A\xfb\xde^]#S\x8cH\xab\xe4\xc67\x95\x13\x1e\x87\xf5P\xc2I\xeb\x1a-\xd5\xd2T\xc3\x14#қ:\xad\xa9#\x91\xfe\xe3\x15o\xe0\x9a\x1e\xfa\xaf\x96j\xa6\x18\x19\x9c\x8c\x9eͫ\x00D\x01\xd7\xf4\xd0c\xf9\x8d5L1\"=i\xe3\x1fi8\xa5\x00\xce\xe2\x9a\x1e\xfa\x80\x03?\x19\x9d*F\xa4Yr\xfcIs\x80\x8bz\xb4\x95\xe3۠=\xe5mL1\"p\xe5\xe2\n\xae\xe9\xd1GB\x93\x8d\xda}\x8fp1\"\xa0\x87+8\xacG\xb0\xa3\xa3\xaa\xb1\x83\xe4\x9c\xe1\xaei\f\xe0\xb0\x1e-\xe5\x04\xf2\xf1ZGCe\x8d\xf1\x99\x8bY\xb4\xa3\xb7\xa3%\xcf\xe7B~\x1fpX\x8f\xef\xc6\x1cI\x1a\xef\xc2\xff\r\x03Ć\x1e\x1d\xadp\xe8p\x87\x98\xd0\x03p\v\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x83\xf3z\u0605(\xa9\xa9\x80\x97p\\\x0f\xbb\x10%5\x15\xf0\x14N\xeba\x17\xa2\xa4\xa6\x02\xde\xc2a=lC\x94\xd4T\xc0[8\xac\x87m\x88\x92\x9a\nx\v\x87\xf5P\xecB\x94\xd4T\xc0[\xb8\xa6\x87%9\tzx\x12\xd7\xf4\xb0$'A\x0fO\xe2\x9a\x1e\x96\xe4$\xe8\xe1I\\\xd3Ò\x9c\x04=<\x89kzX\x92\x93\xa0\x87'qX\x0f\xfb\x10%5\x15\xf0\x14\x0e\xeba\x1f\xa2\xa4\xa7\x02^\xc2a=\x80\xd8\x02\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\xc3\xf7\xee\a\x80\x88\x8c\xe8\xe8\x01\xc4;\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0eC\xd1#\xb8.=%)\xed\xb6\xa6\xc1\u007fyT\xbaS\xff1\x02\x066\x8f\xf7\x8dk\b\xbf\f\x0e\xa0\x1f\xd5\xd2mf\x85]Ҝ\xc1sQ<\"-\xe3\xfe]@\xc4\xe6-\x1d\x13@\xfa-ꪀQٞ\xa3\xc9\x10\xf4\xa8J\x924f]\xb5\xfeiTVg3n\xbb\xc5x\xf5h2^\x8a'\xf4`;&@뷨\xab\x02Fe{\x8e&b=VHҜV囮\a|Rƀ\xe5o\xa3\xb2:\x93\xa4\x15\xdf\f\x18-\x0fH\xd2 =:\x1em\xb4\x9b/\xcc\b\xf5\x88\xd8<\xd31\x01z\xbfE]\x150*\xdbs4\x11\xea\xd1(I;\xb4R\xab$UY\xfe8*\xab3Nj7_\xd8\xe9!b\x84zD\x84\xe9\x98\x00\xbd\xdf#dT\xb6\xe7h\"\xd2c \xcd\xdc\xf6ˤ\U00056fce\xca\xea\xa4I\x1d\xe6\v/\xe9\xc1tL@\x82\xea\xd1,IA\xa3|\xfeQ\xf2nj\xce\x1b\xe7K\x9e\xf8\x80\xa2\xb2\xab\x13\\1ޗ:\xa7U\xabJ\xbf\xe8Y2>)eZ\x15s\x94\xeeZ2.)u\x0e>\xafO#\xc3\x1ac\xff\xae&\xaf:\xb0\x1eʊq\xbe\xf1\x0f\x98't\xbbf\xdaf\xa7\xa6\xccj\xc7zTK\x13\xb5I\x9bɋG>'s\u007fN&Q\x1d\xae\x96\x1e\xed]\x92曄\x06\x9c\xd5\x13}i+\xa8\xf1B\xcfj\xdc\xe5\xb6p\xdbFnj\xbd\xf5\x88\xb4D\xb5\xb6\x1c\x9e\xc7\xe8\xb7ޖ\xb9z\xd69t\xe8\x85\xd9oω\xd2j\xd5}Dz< M\xb0LY&I\xe3&\xa5\xa1\x1f\x9f3\xabӚ,\xf9&\x8d\x97\xa4u\xaa\xe5EW\x8a\x94\x9a>\x01\rl\xa96꒤\x94t\xd4\x06\xda\x02\xeb\xf2|Ҭ\xbc]\xfa\x1fj\xf2$鶼 ڨh\x11i\xa9\x924q@\xdf\u007fv͔KR\xda$_R\x06ډ\x9f'I]d\xda\x04\xa9\rͽb\x9c\x94\x82\xe7\xfe\xc6\xd2\xe1jiY\xaa\x94擤\x86%\x92\x0fM\xcbP\r=\x9a\x92\xb5.\x85\xafό\x8eY\xf4\xa0[6\xe71\xfa\xad\xb5E\xad\x9ee\x0e\x1dza\x11\xb6gl\xe81[Z\xc0Nh\x96\x92\xf1A\xa1-Ez\x94^\x9d`\x8a\xb4\x1a\xad\u007f[\xaa\xd4`y1Gz\x00\xed\xe2S)\xe6\x86WO%I\xebд\x06\x9fT\xadF:\xb9H\xe3ѡ\xaa9I\xaa\xd1\xf7\x9f]3\x92\x84\xb4\xfa|\x169\xf8ܦ\x89y\n\x9f\x00\xd1\xdc\x13\xd0;\xb3ɇ\xff\xcet\x18\xfdeb\x97:\x90'\xf9|u\x03j\x83$\x9dқ\xefM\xc1\xed\x0fl\x96|\xe6\xbb\\\xeb\x98E\x0f\xaaez\x1e\xbdߤ-f\xf5\x989t\xe8\x19#lO\xb5\xae\xdc<\x90\xb9\x87H\x8fiV\x89WK\x0f뿗ѫ\xb3Z\x9aM&\xd7\xe1\xa3\r\xf3b\xbc\xb6\xf7+\xf3\x9a\xc3mܦo\xf1]R\xea@D=\xc8\xc1`\t^\n\xd9\xe66\xcd,\xd0\xfav\x95\f\x8f\x9a\xb4\x81\xd1\xfd\xd8\x124\xf7ym\xee%\x96\x0e\xeb\xedvI\xd2f<m\x1a\xdeg\xa4\xf9\x87\xf5\xc3R\x06\xb5\x17\xed\xf50[\xa6\xe7\xa1\xf5`V\x8f\x99C\x87\x9e1\xc2\xf6\xf4\b\"=fI+,S\xf4K\xbd\xcd\xe15!?\xc6I\xda\x15\xdd7IR\x0f\xfbb\x964\xad\x8d\xbd:\x1cH\xd6/\t\x06RЙ \x82\x1e\xdaP\xa2\x12\x0fQ\xc96\x1f܌\x9a\x82\xdf\xfb\xaa\xbeeQ[\xedd$}\x9e\x9e;Oe;\\\xad\x9d+\xbf\x91\xb4e\xe6I\x95z\xf3\x13%\xed\xfeWo\xafپ\xad\x1eT\xcb\xf4<\x94\x1e\xec\xea\xb1}\xd1`\x16f\xbf==\x82H\x8f;\xa9\xb5\xd2\x19h۵.\x0f\r,\x16P\xabsU\x92&M#$I-\xcc\v\xb5\r\x9d\xe9S\xf2j\xa8\x91YP\x92\xf4\xf3p\x06>w\xd8\xeb\xa1\x1d\u007fj\xf0o\xb2\xff\x067\xf3\xb9\xd1L\r\x19ٮ\xc0ǒ\x16)\x9d\x9a[\x1f(R\x1d\xae\xd6\u07b7h)x$\x88\x8e?\xe5z-\x9f>t\xa1\xb1Ճj\x99\x9e\x87҃]=K_\b\xec\xc2춧W\x10鱙\x1e\x9a\xb6\xe2-P\x99\x86\a铦1\xab\xa3H&\r\xcc\vt$_\x90\x8c\nI\xcb\xc2C\xb3\x0e)I/\xcd\xc6wRx\x17\xb6\xa6\x1e\x83\x9b\xe9\x91$\xad\xd0H\xf4h\x97\xd2\x06\x90\xcd\xd5\xd4\xdcڌt\x87\xf5\xbf\f\xd2\x03\x1dN\xa8Æ\x8e\xad\x1ef\xcb\xcc<\x94\x1e\xec\xea\xb1}!\xb0\v\xb3ݞ^A\xa4G\a\xb5*=RR;\xbeӼ\xa4\xee\xd4U\xf4\xdbr\xf48\x1f\x9e\x87y\x81\x19h[7I2W\xba'\xfc\xf6\x9a\x16\xf9\xe81H\x8fA\xcd|n\xdcj\xa8Ӯ\x8b'H\xad\x03\xc9I\x9f\xab\x16=\x98\x0eG\xd2C\x95\x84G\x8fuV=\x98y(=\xd8ճу\x99\xd1~{z\x05\x91\x1ehH\x18\xbe\xe7\xb4\x1a\r\xb5\xd0\xf9T\x1b\xbb\xad`W'M?\x9d\xaam=\x03신6\x02\xaf\x96\x92\x8c\xa1Ào\bc\x0f\xab\x1e\x83\x9bQS\xf5f\xd6i]\xdc,\xadn\xd1\xf6\x01\xbdK\xd8\x0eG\xd4c\x82>\\j\x98Ui4\xafw\xac\\?\xbd.\x19\xa4\a=\x0f\xa5\a\xbbzvzP3Fڞ\x1eA\xa8G\x8d$\xd5i\xa5&\t]{)\xba\xf9W\xc7\xe1\xadf\xae\xce\x12)\x9d\xec\xb6f|\xb1F\xbfP\xf4=\xd1E\xedWch_#\xa5|3D=\xec\x9a\xd1/\x06\x06t\x83\x83\xd2\xf8՚\x97\xf4.a;\x1cQ\x8f\xd5\xfaޛ\xad]\xd2\x10\xb4\x8e\xd5i\xa7Wt}dՃ\x9e\x87҃]=;=\xa8\x19#mO\x8f \xd4C\x9d\x83\x06MmW\a\xba\xee\x97\xf0Gr\xc8v|5\xd97K\xc2;\xce\\\x9d.\x9f\xb4\fm\x9f\xf6T|\xa5ü\x98%\xcdB\xbb\xe2j\x1euC\xebT\x92\xb4\x19\xed\xe4\xc6d|\xe1`\xb9w\x9d$5|3`s\xf4\xb0i\xa6\xc7'=:\x80'\xe9\a\xb8\f)9\x85\x1c\xd6-G\x0f\xaa\xc3\x11\xf5\xe8I\xc6]\x1axDJV\xc2\xedk\x1dC\xe7\n\xf4\x97\x9e\fi\x90\x1e\xcc<Z\xbf\xc9tf\xf5\xec\xf4\xa0f\x8c\xb4=c\xe4\xbe\a\x1aH-0\x86\x99\xb3\xc9\xc8T\x92\xc6\xcfNOJyX\x9aĬN\xa3O\xf2Ớ\xe4S]\xfaE0U\xf2M\x9c\x94,\xa5\xf5\x98m\x92ۊ\xe3$\xed\xa2\x99\xd5#]\xc2\x1f\xa2ۜ\\l\x9aiH\x92\xd2ғ\xa5\xdbt=j\fO\x98]\xc2t8\xa2\x1e\xf8\xbeUJz\xaa\x94D}\xabE\xef\xd8\x12t\xc94NJ\xde<H\x0ff\x1e\xad\xdf\xdatz\xf5\xec\xf4\xa0g\x8c\xb4=c\xe3\xae)\xa6m\xc9\x04_\xd28\xe3~TsF\x9ao\xe2ß_\xf5\xa11+}0\xecY6ޗ\x9c^\xa9\x1d\xfa\xe9\x17\xc1\x15\x13|x\x0e\xbaɎ;\xc7\xf9\xd2nӾK\xc1\xeaѕ\xe1K\xa9\xb3\xd1þ\x99\xbc\xb4\xe4i\xcd\r\xba\x15\xa8K\xda;\x8e\xdd%t\x87#\xebA>'I[@wE\xef\xd8@\xf5$_j\xde\xf9\xd6\xc1z\xd0\xf3h\xfd֧S\xabg\xab\a=c\x84\xed\x19;z\xc4\n\xc1A\x9f(\x03#$\x9e\xf4\xd8L\r+\x81Q!n\xf48\xdf\xdb\xe0\xf3\x99\xc3J`T\x88\x1b=\xf0\x00\x1a\x0e\x1e\xa3M\xdc\xe8Q\x99\x9c\x06v\x8c:q\xa3\a\x10\r@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c\xdcУ\xa2BT\x03\xf0\b#\xd5c\x9b,\x1f\xa3^\x9e\xce?\x19\xb1\xaa\xc1_\xe5ݢ*\xa3\xc1\xdb3d\x8d\xfc\x90\xa8*C\x05\x9a%\xfb\xb2\xa8V\x820R=\xaetf\xd5S/O\xe6\x1c\x8fX\u0560,p\x05\xff:\xf3'QE\x13a]\x9b\n\xfd\xefeUt\"v\xcb_\xd9\xcc\x10\x99+\x9d\x9d\a\xe5ߋj%\b#\xd5CU\x03\xb4\x1e\xaa\xf8\x9dzy\xc6N\xf2\xbb\xa8LP\x91BX\u05f6\x82ֳ\xa3\xf25\x9b\xbfq\xe9\x06=tF[\x0f1[\x03_\x92\xdf\xf7\x89v9\x85\xb0\xaem\x05\xadg\x97w\x8a\x95\xb5\x00z\x18\x88\xf4\xb8^V\x98U\xb8\xe1\x02*]Ȓ\xe5\xda\xcbe\v\xb3\xd7~\x8b^]\xdeR\x90\x95\xbf\x1e\x9f%\x02\xbbw.\xcd^\x8bKײe}$\xf2:*ԫ\xf5\xe8\xe7\xeb\xe8\x80r\xb48g\xe9\xce~\xbd\xc1ϲ\xb6\xa3\x9f'\xf5q\xc1*\xce\"\f\xe8\xbatc\x9dk\v\xb3\n\xd6/\f\xb1\x15(\xc2\xe2\xfe\x05\xb5\xbb!T(˹!si\xdf\x16d=]Xxf{n\xe9u4\x82\xca:XQ\x98\xbbA\x1fr\x84\xf5`\xbb\x9e\x80\x88\xf48)W\x9cy}\x83܍\xce\xe5\xaf\x1f[\xb88\xa7pgٌ/й>g\xd5\xfe\xd3\xf5\xf2\x01T# /=v\xbc`\v\xae\xdc\xdd٩\xed\x92\xeb\x9dsk\xbfR\xbf\xaa\xcd\xed\xbc\x8e\xc7z\xdb\xdf:\x98\u007f\x9f\xfe\x1e\xae\xc8\xc2&\xf5\xbf\u05f9\xf8A40\xf8k\xe4E\x84\xa1\xebR\x8d\xfda\xc6\xd6\xe3\xa7\x0f\x15\xc8߲\x15(\x02\xb5\xfd\xfde\xf8L\x16\xfa\xa0^\xfe@=:\xe3\xe8G\xf4\xd2\xce̕w\x96\xca\xf3\xf6\x15\x1cP\xffr,K^\xb8\xaf~a\xf6%2cX\x0f\xb6\xeb\t\x88H\x8f\xfech\a\x87\x96o /\xee\x93\xd1;-\x84&\xf4\x17\xaeE\x9b,\xf4:>\xab\a\xf2\xbfF\xdb1_\xaf\x9f\xad\xbfc+\xf0Ѿl\xab\x8a\xf7\xc7Q\x15oq\xed\x02糬mz\xcd\xf0\xf9\xc0~\x11\f\xe1\xbaTc\a\xf3\xf1!\xe6`n\x88\xa9@\x13\xc0\x87\x94\xf5\xa4\x18\xdaZt\xadp\x1f.QK\x9b_\xa6\xbe%\x9fT\xb7\xe2\xeb\xec\xc0B4\xf9Za\x11\xa9m\xe8\xc1v=\x11\x11\xe9\xa1^;\xb8\xf6\xae\xb9\xf2rR\xbe/\xa0\xbf\xabߖ?\nW\b\xe0\xad[\x1f\xd0_\x19z\x9c\xc9\xeeW\xfb\xb3;Q\xa9\xec\xaeз\x88B\xedfǶ\xac\xcf\xf4\x9a\xe6\x1e\xb5]\x04C\xb8.\xd5\xd8\x17\x85\v\xb7\x1f\xfa(\x14b+\xd0\x04*\xba\xbbu\xeb\xd4\xfe\x9f\x16\xacת\x9aK\x9b\u007f\f\xed\xfa~u7\x9e7@.\xb6\x0fj\xc3XC\x0f\xb6뉈H\x8f\xee\xfc\xc2\xdd\xc7;K\xf5}W\xa4O= \x9b\xe7cr:\x19\xa4Ƿ\x05\xc7\xd5\xe3\x05x\x87,\xd7G\x06d?]\tl5\xe6\v\xefQ\xfbE0\x84\xebҍ];T\xb6T.\xd8\xcf9z\xa0\xbe\xbc}Z\u007fq\\~\x8f\xfc\xa6\x966\xff\xb4ڝ\xa5\xeaz\x90~w\xca\xe4\x02\xd9Ѓ\xe9zB\"\xd2ci\x11\x16a\x8b\xbe\xef\xb6\xe8SO\xcb\xe6}\x06{=\xd4\xed\x1b\xd4-x\x10\x8aނ\u007f\"\x90\xf7\xe5N\xd98xh{\xf4\xf0\x17\x91\x16\xc1\x10\xaeK5ֽ\x1b\x89q\xedX\xf6A\xa6\x02\x8d>4\xbd\x80\x97|e~\xed¯\xf1+jiX\x8f\x80\xa1\a\xb9\xda>$\x93Ӛy\xf4\xa0\xba\x9e\x90\x88\xf4(Ļ+\xf4S}\xdf\x19\xef\xd1\xeb\xf3K\xf1\x9bv;ަ\x11\xf4\xf8 \xf0e\xe0\x03\\8\xad\x9d\xbak\xf1\x99\xffK\xf3ࡖ\x96\xa2\x9d\x86\xfff\xbf\b\x86p]\xaa\xb1z\x99\x1c\x18J+\x98\n\x88\xcf\xf6\xe9\n\xeaz\xccG\xe7\x8dPQ\xadZA\xfaL-\x8dѣ\x00\x0f\xa9\xee*%s\x18z\xd0]OLDz\xd4\xcbe\a\xf7݇\x8e\xe1\xdd\xdf~@\xae\x0f\xb4M\u007f&pϡ\xb7\xb7ˇ\xd5/;\xb3*\xbaC\x1fUdu~\xa9\x86~\x8f\xae\\*:;\xc9;0T\xb8\xb6P;\xd9\xef\x9eQv\xfcx\x05\x19\xe5\xed\x9caޭ\xae\x0f\x1c8^\x9a\xf3E\xc4E0\xbd0\xeaR\x8d\xd5\xcb9\xb5'Q\xf1\f[AU7h\xc3Q\xe3\xaei\xe7ܝ\xfd\xefm˿\xa2~6w\xfb{!ji\u007f\xc9=\xd0\u007f,\xebB\u007fY\xe9\x15<\x8c]u\xec\xf0\xe2\xdcOИ\x06\xdf5=\xd0\xd9\xc9.-A\x11\xe9\x11:\xb08\x90_vxqV\xe9\x05\xed<\xac]\t\xa8\x9f\x94\x15\xe6\x14\x1d'\x9f\xb9\xc8Y\xff\x9e\x83~nS\xff\xa0\x9f\xaa\x0f\x91\x1a\a\x02\a\xf46N\x97\xce\xcb-~[\xc57F\xa8cCh{n\xf6\x83ݜEP\x84\xebR\x8d\x1d}\xb0\xbe0k~\xe9\x19k\x05\xf5p>\xe9\xc0۲\xc1\x81\xd3\xe8\xc7Nu\xbb,\xcf8c.\xad\xb8@\x96\x8f\xe5\xc89\xc7\xc8\xd8\"\xb0\xb3bna\x19\xbea\xb7U\x9f\xab\x8cYZ\x82\"\xd2cTyZ\xb6ޚ\xf0\fý\xf7\x9b 8\xaa\xc7\xd6a\\!\xf6\u007f\xa6\xe1\xd0-K\xd0\xc3\x16G\xf5\x18\x0e\x0f\xea\xc7\xf8\aE\x15G\a\xd0\xc3\x16\xcf\xea\xf1\xc9I\x8dOD\x15G\x83+d\x80-\xaa\x95\x80xV\x0fG!\x03\xec\xc1\x17L\x00\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01ppC\x0f\xc8\xd8\xc6\f#\xd5ct2\xb6C\x99m\xb8\x8cj\xc6\x16M\xc4\xdf^9 \xcbV\xb5\xa3\xd1u\xef0R=\xbe{ƖF4\x9b\xeb\x19\xdb/r\xf6\xe3/\x9c^۟c\xfd\"\xbd\xd9ua'c\x90\x91\xea\xf1\xdd3\xb6\f\x82\xd9\xdc\xcf\xd8.?L~\x1d^>\xa8r\xb8\xeb\xc2N\xc6 \xa3\xad\x87\x18#c;\x1c\xdc\xcf\xd8n\xa9%\xbfjm\xbfH\xaf!\xecd\f\"\xd2#J\x19[u\xa9>0(\xa6g\xb3D]u<\x91\xb1ݭ\xed\xfb\xb2\xdd\xccv0\xbbn\xdfI\xfb\xd0p\f!\xd2#J\x19[5@\xc6\x05E\xf2~z6K\xd4U\xc7\x13\x19\xdb\xc3Ejw\xe1\xef\xd5\xfb\x0e\xb1\xdb!\xdcu\xfbNڇ\x86c\b\x91\x1e\xd1\xca\xd8֣q\\\xa8B>h\x99\x8d\x89\xba\x9a\xb8\x9f\xb1\xed,Pwg\xedV\vp,\x94\r\x02\x87\x93=v\x9d\x8c\x14\x1a\x8e\x15DzD/c\xab\x86\xcaf\x84\x03$a=訫\x89\xfb\x19\xdb/\xe4\xfe\a\xb7\x16_\xd7B~L\x10x\xb0\x1e\xcc\x1aۇ\x86c\x05\x91\x1e\xd1\xcb\xd8\xf6\xaf\xcf2\xaff\xc3z\x90ߝ\xb2\xe5\x1a\xd1\xfd\x8cm(p)\xe7O9\x97\xb2\xb4\xa5\x15QK\x19\xac\a\xb3\xc6LݘC\xa4G\xd42\xb6\xd7\x1f\fP\xf1\xa2\xb0\x1et\xd4\xd5\xc4\x03\x19\xdb\xc5\xfb\v\xd5\xc2\x03\x8b\xc9t&\b\xcc\xeaa\xe9d\xa4\xd0p\xac \xd2#Z\x19\xdbkE\xe4\xccs\xb2\x94\x9d\x8d\x89\xba\x9ax c\xbb\xbex\x8b\xba\xa5x-\x99\xce\x1c\xab\xc2kl\xd7\xc9X\xbf\xdc\x15\xe9\x11\xa5\x8c\xed\xb5\xe5\xf2>|\xe9\xb2\x15\xed\x1ez63\xea\xca\xf6\xc2\xfd\x8c\xed\xce\x19\xfb\xd5\xfd3\xd0\xf1\x90\xde\x0e\xcc\x1a\xdbt2bh8V\x10\xe9\x11\xa5\x8c\xedGYz݅*3\x9b\x19ue\xf0@\xc6\xf6\xad\xec\v\xea%|\x03\x9d\xde\x0e\xcc\x1a\xdbt2bh8V\x10\xe91\xaa\x883\xb6ý\x05;j\xb8\xb6`o\xe3\xa8\x1e⌭\xb9\x97 c\xeb\x05\x1c\xd5C\x8c\xb9\x97 c\xeb\x05<\xa5\a\x1du\x85\x8c\xad\x17\xf0\x94\x1e\xaeE]][\xb0\xd7\xf1\x94\x1e\x80\xd7\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01ppC\x0f\xc8\xd8\xc6\f#\xd5#A2\xb6\x87qC\x05k\xcd/`\xdb\xf2Y\x96\xbc\x94_#\xd6\x18\xa9\x1e\t\x92\xb1\xbd~T\xde\xd7y\xb8x\xc6\x19\xdbY\fB\xdd\x15\x015\xae\x18\xa9\x1e֏\xc2\xc5\xef\xd4\xd8\xcc\xd8^\xc2\xdfl\r\x15/\xb6\xabNQ\x0fzX\x18\xee7%b3cK\xf4P\x0fʂo'%\x9a\x1e\x90\xb1Ֆ\xa6\xe9QV\xc8N5\xb7\x0e:)\x95\x15\xe6n\xd1N.\x90\xb1M\xb4\x8c\xed%\xf9\xad\xfe\xbf\xee\x96\xf7\xb1S\xcd\xc6\xd4\xcbs\x97\x1e>\xbeV\x0e0\x15 c\x9b \x19\xdbK\xe4\xf8T\x16b\xa7R\x8d\x15/\xee\xc7ŀjYc\xc8ت\t\x90\xb1\xbd$\xef\xef>Y\x9c\xfd\x19;\xd5l\xec\x9a\x16f\xa8\rX*@\xc6\x16\xefٸ\xcfؒ\xb1\x87\xe6\x005\xd5l\xac[&\xd9}\xb2\x1d c\x9bp\x19[mh:\xb7\x96\x9dj6\xf6\xb5v\x9e\xdc\x1aP-k\f\x19[5\x012\xb6\x9a\x1e\xf9;/죧R\x8d\x15\x15\"\x1b>\t\x04\xd8نpM\xeeiDz@\xc6V[\xda\x05\x19\x1f\xebJ\xd7W,g\xfb`4\xa6^\xca.\xac\xaf͕\xb3\x8e\xfe\x052\xb6\t\x97\xb1E\x95\xf05\xf8\x85\xc5\x05'\xe9>\x98[\a]\xd9n\xc8]\xb8\xfbh\x96\xbc\x8d\xaa\x00\x19\xdb\xe1\x00\x19\xdbX\xc3Q= c\x1bk8\xaa>o5\x06\x00\x00\t\x1cIDAT\x87\x18\xc8\xd8z\vO\xe9\x01\x19[\xaf\xe1)=\\\x8b\xba\xba\xb6`\xaf\xe3)=\x00\xaf\x01z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c\x04zX\"\xb4\x14_W\x14d\xeb_\xee\xf5|B6Q\x9fB;r\x04zX\"\xb4\x14\xa5\xf9\x87\xb6fk_(\xf7|B6Q\x9fB;r\x84'\x97\b\x9ft_\x93\x0f\x9a\xe9\r\xc1\x1b\xdc\xfd\x84l\x82>\x85v\xe4|W=.\xcbC?*\v\xbf\x8d\x1b\xf5\x84l\x82>\x85v\xe4\x88\xf5ؾU\v\x9f\xa2a\xc8Q\xfd\u007f\xb0\b\xcd\xd3\xc6\x05\xf8\x8b\xeafB\x16M?\xb4*\xfb\xa7\a\xd9\xfd鉄l\x82>\x85v\xe4\x88\xf5\x90W\xbd~ly\xf6%m\x18\xa2\xff\x0f\x16\x1fu\x1e\x93\xeb;;\xc9W\x86\xc3\tY\x9c\xf2\xa8}\xab6\xf0\xbf\x99\xf9=\x91\x90MЧЎ\x1c\xb1\x1eK\xd1\xfb\xa8\u007fq\x91\xca&Z\x98\x93\x8b\x9eR9M\xb2 \xa7e*\xdeDp?!\x9b\xa0O\xa1\x1d9b=\x9e\xc6?\x0f\xe1\x11\xa2H\x8f\nm\xe4w\x8f\xf5\xea\xd1\xfd\x84l\x82>\x85v\xe4\x88\xf5 ۏ\x84OEz\x14k\xef\xf5\xf5E*\x8b\xfb\t\xd9\x04}\n\xed\xc8\x11\xebA§\x87q\xf8\x94\xec\x84Z\xce\xd1\xe3.\xbc\xf9C\v\xc3)k\x1d\xf7\x13\xb2\t\xfa\x14ڑ#\xd6\x03G!C\xf7\xe0\xf0i6\t\xabF\xd6\xe3-r\xbe>&\xbfei\xc2\xfd\x84l\x82>\x85v\xe4\x88\xf5\x90\xd7~p\xba\x98\xa4^\x8b\xf3\xf7\xef+\")R\xedʅ|\xf5\x9fNȖɻO\xee\x96\amQ\xf7\x13\xb2\t\xfa\x14ڑ#\xd4\xe3\x9e\xfa\xb2\x1c=\xf5z\xb94;g\xedӲ\xbc-\x94K\xce\xceY\xf8:\x90NȆ\x0e.\xcf^n\xb9\xef\xa1z !\x9b\xa8O\xa1\x1d9B=b\x02ȸE\x89(\xe9\x01\t\xd9\xf8 Jz@B6>\x88\x92\x1e\x90\x90\x8d\x0f\xa2\xa4\x87\xa3@B6jă\x1e@\xd4\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\x02=\xe2#c\xab\xaa\x17\xd6\x17\xcc}\xf0\xcc\xf2\xf7l\xe6\x18\t\xecҢ\xb1\x1d\\F\xa0G|dl\xd5?e\xad?~t\vy\xf0\xe1\xa8\xc2.M\xb4\x1db\x10\xe1\xc9%.2\xb6k\xf1\x17UC\x15\xa3\xae\x87\xca.mx\a\xbaX\xe0\xbb\xea\x11[\x19ۅ$c{A\x8e»\xdbfiq\x84X\x8fx\xc8ؖ\xcd\xc7\xf9\xca\xd0[\xe4p\x17~\x04\xaf\xf9\x14Z\xd4\xc2!\xfdi\xbcTqHq[ci\xcc\xd3xmZ\xa0\xd68\x86\x10\xeb\x11\x0f\x19\xdb\xcf\n\xe5\xb5\xf5\x1fh;\xc6|\x04\xaf\xd9\x18n!\xbf~\xff\xdc-LqHq\xdb\xf0Ҙ\xa7\xf1\x0en\x81Z\xe3\x18B\xacG<dl\xd5k\xfb\x8a\xb2\xe4\\\\\xa2\x1e\xc1K?\xa37\x90\x8b\xde\xece\xf9lq(q[\xfa\xe4\x12~\"\x9e]\v\xcc\x1a\xc7\nb=\x9e\xc6?c<c\x8b\t\x9d^\x8f\x03Z\xf4#x\xa9g\xf4\x92g j\xebf\x16\x87\x12\xb7\xb5\xd5î\x05f\x8dc\x05\xb1\x1ed\x95c<cۭ\x8d\x03\x8a70\x8fय़\xd1K\xad\x9bY\x1cJ\xdc\xd6V\x0f\xdb\x16\xe85\x8e\x15\xc4z\xc4C\xc6v>y\xa2\xaeZ\xbb\x98y\x04/\xfd\x8c^[=\x86\x12\xb7\xe5\xeb\x11i\x8dc\x05\xb1\x1e\xf1\x90\xb1-\xc0\x0f\x99UCx\x0fS\x8fय़\xd1k\xab\xc7P\xe2\xb6|=\"\xadq\xac \xd6#\x1e2\xb6\x05\xf2\xfc\xfa\xd3\xc7K\xb3\xf1Z\x84\x1f\xc1K5F=\x8d\x97~0\xaf0nK-\xcd\xdc\x0e\xf6-\xb0k\x1c+\b\xf5\x88\x8b\x8cm\xd1\xe1ڥ9\xf9\x1b\xb4ԍ\xf1\b^\xea)\xb4\xd4\xd3x\xe9\a\xf3\n\xe3\xb6\xd4\xd2\xcc\xed`\xdf\x02\xbbƱ\x82P\x8f\x98\x00RrQ\"Jz\xc4s\xc6\xd6\xe1us\x95(\xe9\x11\xcf\x19[\x87\xd7\xcdU\xa2\xa4G<gl\x1d]7\x97\x89\x92\x1e\x8e\x02\x19ۨ\x11\x0fz\x00Q\x03\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\b\xf4\x80\x8c\xed\xc8ѲA\xb1\x89@\x0f\xc8؎\x1c=\x1b\x14\x93\bO.\x90\xb1\x1d9\xf5\t\xa7\adl\x87A<\xeb\x01\x19ۈ\x19\xdbZ\xb2\xea\xc7\xd0\xcfZj噺W\xca\ns\xb7h'\x17\xc8\xd8&X\xc6\xf6\xab\xb2\xe2\xce\xeb\xea\xf5\xf7\x8aˮQ+O\u05fd<w\xe9\xe1\xe3ke\xbc\xcd c\x9bp\x19ۣ\xda%\xc9\U000a3595\x0f\xd7-^\u070f\x17\x81\xb7\x19dlI\xa0(\x912\xb6\x17\xe4P\xff\xd1k\xdf\x06.XVި{M{\x10\x19I\x16B\xc66\xe12\xb6\xa1\xac\v\a\xe4ڿ\xca!\xcb\xca\x1bu\xbbe\xf2\xdcm\xad]\xc8\xd8\xe2UO\xa8\x8c\xed\xd2c\xa5\xc5K\x8f\xe3S\f\xb3\xf2Fݯe\xb2~[qc\x90\xb1M\xbc\x8cm\xd9\xf6\xac\xd3\xf26\xfc\x17f\xe5\xc3u\x8b\xf0\x82?\t\xe0\xc6 c\x9bp\x19[u_\xf6\xdc\xd0\xe2l\xa2Ox\xe5麗\xb2\v\xebks\xc96\x83\x8cm\xc2el\xd5\xee\xdcZu\u007f\x0e\xe9zx噺\x977\xe4.\xdc}4\v5\x06\x19[\xd7p4%\x97HDI\x0f\x87s\xa8\x8e\xea\xe1\xf0\xba\xb9J\x94\xf4p8\x87\xea\xa8\x1e\x0e\xaf\x9b\xabDI\x0fGs\xa8\x90\xb1\x8d\x1aQ\xd2\xc3Q c\x1b5\xe2A\x0f j\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\x81\x1e\x90\xb1Ml\x04z@\xc6v\xa4\bW\xde\xd3\bO.\x90\xb1\x1d\x19\u0095\xf74\xdfU\x0f\xc8\xd8\x0e\x11\xe1\xca{\x1a\xb1\x1e\x90\xb1\xe5=\xc7\xd6h\x8c\xda:\x91\xd6\xcd\xd8:t\u05fd\x8eX\x0f\xc8\xd8r\x9ec\x1bn\x8c\xde:\x11\xd6-\xbcu\xa8\xae{\x1d\xb1\x1e\x90\xb1\x8d\x9c\xb1\xa5\x1a\xa3\xb6\x8e\xfd\xbaQ[\x87\ueeb7\x11\xeb\x01\x19\xdb\xc8\x19[\xba1s\xebد\x1b\xb5u\xe8\xae{\x1b\xb1\x1ed\xd7C\xc6\xd66cK5F\xb7`\xbbn\xd4֡\xbb\xeem\xc4z@\xc66rƖj\x8c\xda:\xf6\xebFm\x1d\xba\xeb\xdeF\xac\adl#gl\xa9ƨ\xadc\xbfn\xd4։'= c\xcb\xc9ؚ\x8dQ['º\x85\xb7\x0e\xd3uo#\xd4\x032\xb6\xbc\x8c\xad٘\xb9u\"\xad\x9b\xb1uBL\u05fd\x8dP\x8f\x98\xc0є\\\"\x11%=\x1cΡ:\xaa\x87\xc3\xeb\xe6*Q\xd2\xc3\xe1\x1c\xaa\xa3z8\xbcn\xae\x12%=\x1c͡B\xc66jDI\x0fG\x81\x8cmԈ\a=\x80\xa8\x01z\x00\x1c@\x0f\x80\x03\xe8\x01p\x00=\x00\x0e\xa0\a\xc0\x01\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c\x04zD\xce\xd8F\x99Q\xcd\xd8\x1e#-\xcd\xdb0\xf8\xc6;\x95\x14\xa6\x8a\x80\x81@\x8f\x88\x19\xdb\xe1DG\x85u\xa3\x9d\xb1\xbd~R~\xba\xb3\xf3\xe8\U00082bedթ\xa40U\x04\f\x84'\x97\b\x9f\x95\x0f':*\xac\x1b\xf5\x8c\xed\x97Z\xd8%ۺ.TR\x98\t\r\x03:\xdfU\x8f\xe1DG\x85u\xa3\x9e\xb1\xd5\xf4P\x97[\x97C}\xa1z8\xa1\xe1\xc4A\xac\x87\x91\xb1\xc5yѧ\xd5z\xf4\xf3uan\x96BX\u05c9\x8c\xad\xa6Ǖ\xc0\xbe\bIa:4<\x84`m\xe2 \xd6\xc3\xc8\xd8\xf6\xbfWXqE\xfd\xaavn\xe7uan\x96BX\u05c9\x8c\xed\x97\xf2\xe1\xfe\xeb\xbf_\xbe\xf4z\xa4\xa40\x1d\x1a\x16\x06k\x13\b\xb1\x1efƶ\x1e\xbf\xc1\xf5`\xa807K!\xac\x1b\xf5\x8c\xed\x97\xe4ذ\x98\xe4\x06\"d\xfd\xc2Ea\xb06\x91\x10\xebafl\xaf\xcc\xf8w54W\xcb5\ns\xb3\x14ºQ\xcf\xd8~)\xd7vw\x9f\xde:\xef\x0f\xaaX\x0fa\xb06\x91\x10\xebA\x86\x00Z|u\xfdN\xf5t\xaee\x8fF\xca\xcdR\b\xebF=c\xab\x0fM\xcb\x16\x87\xc4z\b\x83\xb5\x89\x84X\x0f3c\xab\x9e,\b\x19\xff\xe9\x8007K!\xac\x1b\xf5\x8c\xad\xae\xc7\xe1\xf0\xff308)L\x1d=D\x0f\xafM \xc4z\x98\x19[5Tp2W\u007f?\vs\xb3\x14ºQ\xcf\xd8\xeazl\xcd\tEL\n\x87\x8b\xc2`m\"!\xd6\xc3\xccآ}qW\xae~Y\"\xcc\xcdR\b\xebF;c\xab\xdd5=^&\xefW#$\x85\xa9\xa28X\x9b@\b\xf5\xa02\xb6\xaa\xfa\x89l\x1c\x19\x84\xb9Y\na\xddhgl\xb5\xcf\\\xb2\x96\x1f»\xdf.)L\x87\x86\x87\x10\xacM\x1c\x84z0\\\x0fx\xf3)\xbd\x8e\xa6\xe4\x12\x89\xe1\xe9\xf1\xfa\xbc!\xde?t8\x87\nzD\x89a\xe8Q\u007f&TZ+\xaa\xa4\xe3p\x0e\x15\xf4\x88\x12Cף_^\xb5m\xfeP?>u4\x87\xeap\xc66\x91\x18\xba\x1ej}N\xa9\xf5s\x11o\x00\x19ۨ1\f=\x80\xc4\x03\xf4\x008\x80\x1e\x00\a\xd0\x03\xe0\x00z\x00\x1c@\x0f\x80\xc3\xff\a'\xa7c\x12\x8d\x96\rF\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/callers1.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03\xa2\x00\x00\x01.\b\x03\x00\x00\x00\xa3\xcb_?\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x04\a\x03\x06\f\x0f\n\r\t\x10\x12\x0f\x17\x17\x13\x1a\x1a\x14 \x1f\x19!# #$\"%$\x1d$%#&'%'(&+)\x1e()'++$*+)+-*/-!,-+-.,02/52'241574796<9-9;8:;C;=:=?<B@4?@>#CxAB@CDBDFCKH<MH7HIG\x00f\x00\x00h\x00\x00i\x01JLI\x00j\x02MOL\x05m\x05PRO\fo\t\x0fq\vTVSZVD\fr\x17WXV\x11t\x19,`\xae7]\xad\x15v\x1c[]Z\x19y\x1e]_\\d_M:b\xac_`^<c\xad>e\xafac`*{!Ag\xb2ceb)|*dfcfgeghfLi\xafDl\xb0hjgqjR\\k\x88/\x82/jkiHo\xb3/\x858Jq\xb5mol;\x86:pqoUt\xb4>\x89=|t]tvs@\x8b?swzB\x8c@vxu@\x8dG\\{\xbbxzw]~\xb7K\x8fJ{}z\x85}d}\u007f|O\x93N\u007f\x81~c\x83\xbdN\x95Uu\x84\x96\x81\x83\x80W\x95V\x8e\x85gm\x87\xbcZ\x98Y\x87\x89\x86]\x9c\\\x89\x8b\x88\x95\x8bm\\\x9dcs\x8d\xc3d\x9dd\x8c\x8e\x8bf\x9fg{\x90\xc0\x8e\x90\x8d\x90\x92\x8f\u007f\x93\xc4j\xa3jz\x97Ɠ\x95\x92s\xa4l\xa1\x96xq\xa5s\x81\x9a×\x99\x96\x84\x9cƙ\x9b\x98u\xaaw\x9b\x9d\x99~\xaay\x9c\x9e\x9b\xa8\x9e\u007f\x88\xa0˞\xa0\x9d\x80\xad|\xa0\xa2\x9f\xa1\xa3\xa0\xa2\xa4\xa1\x92\xa5ʮ\xa4\x85\x82\xb1\x86\xa4\xa6\xa3\xa5\xa7\xa4\xb4\xa7\x82\xa6\xa8\xa5\x8b\xb3\x88\x95\xa9Ψ\xaa\xa7\x8d\xb5\x8a\x98\xabѩ\xab\xa8\x8e\xb6\x8c\x8d\xb8\x93\xab\xad\xaa\xb9\xad\x88\x9f\xaeέ\xaf\xac\x96\xba\x96\xaf\xb1\xae\xa3\xb2Ҙ\xbc\x98\xb1\xb3\xaf\xb2\xb4\xb1\x9b\xbe\x9bµ\x90\xb4\xb6\xb3\xb5\xb7\xb4\xa3\xbf\x9d\xac\xb7Ң\xc0\xa4\xb7\xb9\xb6\xb8\xba\xb7\xb9\xbb\xb8\xa5ħ\xb1\xbc\u05fb\xbd\xba\xbc\xbe\xbb\xbd\xbf\xbc\xafƫ\xa9ȫ\xb8\xc0տ\xc1\xbe\xce\xc1\x9b\xc1ÿ\xb2ʮ\xc2\xc4\xc1\xbc\xc4ٲ̷\xc4\xc6ú\u0379\xd7Ȝ\xc1\xc8\u07bb\xca\xde\xc7\xc9Ƽϻ\xc9\xcb\xc8\xc0\xcc\xda\xc7\xcb\xdb\xca\xccɿҾ\xcc\xce\xcb\xc4\xcf\xdd\xca\xce\xde\xce\xd0\xcc\xc8\xd3\xc1\xe0Ф\xcf\xd2\xce\xc8\xd6\xc9\xd1\xd3\xd0\xd1\xd2\xdc\xd2\xd4\xd1\xdeէ\xca\xd8\xcc\xd3\xd5\xd2\xcd\xd6\xde\xcc\xda\xce\xd5\xd7\xd4\xe7\u05eb\xd6\xd8\xd5\xd1\xd9\xe1\xd5\xdb\xd1\xd8\xda\xd6\xd8\xd9\xe3\xd3\xdc\xe4\xda\xdc\xd9\xe6ݯ\xd5\xdf\xda\xdc\xdf\xdb\xd7\xe1\xdc\xde\xe0\xdd\xf0\xe0\xb3\xdc\xe1\xe4\xdf\xe1\xde\xe1\xe3\xe0\xe3\xe5\xe1\xe1\xe6\xe8\xe4\xe6\xe3\xe8\xe5\xea\xe5\xe7\xe4\xe6\xe8\xe5\xe4\xe9\xec\xe7\xe9\xe6\xef\xf2\xee\xf7\xf9\xf6\xfe\xff\xfc\xbd\bi5\x00\x00 \x00IDATx^\xed\x9d\x0fp\x13\u05fd\xef\xe1%\xb7\xf7\xf8Y\xba\xbdvjW&\xbevs=n\xb1\xc7\xf6\x98\xa8@\x84\xc3s\x80\x90\xe0\x10\xee\x03'J\xe19\xaf\xb9\x81\xa4\x80\xfb\x9cb\x87ۄ\xbf\xc1m\xd0\x00Uq\xc1<BL\x9d\xa7)\xc5@\xf0\xad\x15p\x9c8&\xb8Ԏi\xeb\xe4\xc6!\xb85\x93\xb9Q\xe2LP:\xb7ʄ\x99e2\xe2ܛy{ή\xa4]\xedY\xadd죕\xfc\xfb\f#\xfdt\xf6\xecٳF\xdf=\u007fvu\xbe3\xbe\x9a8\x18\x00\x80\xa9f\x86\x91\x0ec`T6\x00\x007\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00LM\nI\xb4\xb1\x91\x15\x02@z\xc3]\xa2C.\x8f\x14\xf8\xda\xdd\x1d\xbePjװ^\xfe0\u007f*y\x8e\x11\x12\x1e)))9\x81O\x88\xaf\x8fhw3\xe0\xc3Ғ\xfb5\x89\u007f}zn\xf9?\ai\xf8\xda\xdcW4\x9b\xd50K`\xd0(֯\xfcJ\xe8\x93\xe2\x10\n\x8c\x8f6\xf5$R\a\xf6Y\x18\x92\xc8!\x00\xde\x12\r\xecy\xb5\x85\x06c\xfb\xbc\x97\xbc\xfbƤ\xd4q\xd7\x1b1\xf6\x91x\xaa\xfc*#$\\\xd9Z\U000a6005s%[\xaf\xe0\x84y\xab\xb1\\\x93\xb6f\xee\xd1\xc6\xf2\xcfix\xb6\xfce\xcd\xe6(X%0\xf8\xf8ܹ\xa3%\xbf\v}R\x1cBA\x1cG\x9br\x12\xa9\x03\xfb,\x98\xbcy1\x12'r\b\x80\xb7D=\xa7ǨD\x83\a^\x15__=@/\xc1\xbeVc\x89^)\xdd\xca\b%\x0e\x97\b\xe2k\xb0\xe40\x9e\x00{5\x02\xfb\\,((\xc8\x1f\xe2h#\xb4%\xe8\xf0VX\xa2\xaaC(\x88\xe3hSN\xfcu\xd0;\v\x16+7(>\xc4\u007f\b\x80\xb7D\x87\xdc\x01\x1f\x95\xe8\xf0\x1e\xf2_\x1b\xd8C:\xb8]\xae\xae}\x86\x12m\x8c\xb4\x9c\x8d\xeaFt\xd2%z\xa5$\xb1~\xd8\x04$\x9a\xe8!\xccI\"g\xa1\x92(\x90\x00|%\x1a\xd87\x82%\x89\x9e>F\x13\x8eu\x8a/B\x00\xb7\x18I\xf4\xc3\xd2g\x19\xa1\x8cR\xa2\xe7\x1e]P:\xf7\x9f\x17\xd0\xf4\x13\x8f\x94\u07fbU\xdc\xf4viI\xc9\xf3W\x9e\xba\xbb\xfc\xfb\xea\xcb\xf7է\xe6\xcf\xd9 wSCy\x85\xb9%\x14\xd2P\u007f^^RRz\x82l\xfdqI\xe9K[\xef-\u007f\xf4cU^u\t\x11Xu \xc8\x12U\x1eB\x01\xf3hd\x84\xbd\x17北m\x9d\x13\xd2;\x9aDpn\xe9O\x16\xcc\u007f\xf3\xd99k\x02\xe2\xdf\u007f\xc3\xfc\xd2\x05O\xbc-\x1d\xe2p\xe3\x82;\x9f\xb8\xa2\n\xf5\xce\xf8\xafO\xcd]\xb0u\xeb\xdc9'\x14\x05+\xce\xe2\xc7d\x1fiL\xae\xfeC]\xd90W\xac\xdaU\xfc\x8a\x94\xb5d\xa5\xea\x10\"GW\x96\xaf<\x1a}4@\x05_\x89zNbY\xa2m\xaf҄\xee6i\x83\xa1D\x1bK?f\x842\n\x89^,}\xea\xe5\xd7^\x9a[\x12\xa4\x19\x9f={x\xee\xca \x16N\x9cXp\xef\x9c\x05[\x9f*\xfd\x10\v\x1fJ\x88{\\\x99s\xefK\xaf<ZR\x8e\x95y\xf1\xdb\xe7N\x94\xec=w\x8e6\xd4\x17ϝ+\xdfK\x82?\x9d(-\x99\xbb\xf7\xf0\x9c\r\xea\xbc\xca\x12\"0\xeb@\b\xb5\xa2\x8aC(\xaa\xc3<\x9apn\xce\xf3W\xf1\xd5\xe7\xe7\x9c\x13tNH\xf7h2o\xce)ٺ\xa6d\xee\xcf\xe6\x8a\u007f\x9d\xb3%\x8do\x9ex\xa2\xf4-\xe9\x10\v~\xb6wA\xf9{\xcaP猅\xfb\xe7\x1f}\xbe\xbc\xfc\xa5GUݔ\xc8Y\\=W\xbaW\x1e\x93\xab\xfePo\xceY\xf9\x8b\xd7\xf6\x8a\xff-\x81ߝ\xbbw\u0379s\xe7\xe8\\A\xf8\x10\xa4?\xf4\xfc\xd9\xe7˟\x8a\xda\rP\xc1U\xa2\xc3\xee@H\xa2\xb2&ߐ\xe6\x8e\f%\xfaa\xe9ӌ0\x84B\xa2G\xe7\x92\xef\xe7\xd19A\xf2}\xfc\x15&\xb2\xa0W\xec\x95%\xb4\x15\xc1x\x8d|A\u007f\x04\xe3G\xee\x15w\v\xae$\x02S\xe5U\xf5\xdfBߦ\xf29\xe2\x85᩹꼊\x12\x14\xe8Ձ\xd5\xd1UT\x87\x1eEs4\xdcH\xbe\xb6?$w\x99\xd8'\xa4{\xb4\x10\xf3\x9f\x127\xbcBoT\t'\xc8\x1fj\xe5\x13\xf4\x10w\x8b;\u007f\xbe\xe0!uȬÉ\x12\xb1\xe1=Z\xf2\x1e\x8e\"\xf2\x87\xa2\xfbH\x1d\xfe\xc8n\u0082\xef\x93n\xc9\t:\x9f\xa4\xea\xe8ʇx\xad\xe45\xfazV\xb5\x1b\xa0\x86\xa7D\x03\xfb\x86\x83\xc1\xe0XKP\xfc6\xb5yiRW\x9c\xad\xe8\x8f\xc5\xe6B\x1b\x86PH\xf4\xe3\xf9w\xff\xf8\xa5\xb7\xe9\x1cƆ\xbb\x05\xf1p\xc1\x05\xf4\x1e\xea\xcary\xaf+\xafH\\\xc1\x9f\x97\xbcD\x12\x9e/\x8f\xce˖(ٴW\x9dWY\x82\x02\xbd:\xb0$\x1a\xa9\x0eE{4\xfcf\xb9\x80\x85\xf2sх\x85OH\xf7h!\xe6\x9f\x10\x0f\x1c\xc0\xcf\xfdP\x8c\xffz\xf4\xfbwϡ\xfdM\\No\\\x1d-\xf9\\\x15bV\x1d\x9e\x9b\x83I\x95\xff\x15G\xc1\x96hx\xb7\xb3D\xd9!X\x12m\x94\xeeV\xddߨ\xda\rP\xc3S\xa2\xa3\xae\x10>|Z\xba;\xda\xde)m2\x90\xe8\xd5\xf2FF\x18F\xfar\t%G\xc5\xd7\xcf_\xdap\u007f\xc9\xdc_`\xd2\xceH\xd06c\xe5J\xcd^\x17K\xc8\xf7^\xfaZ\xa8\xf2\xb2%\x1a\xfe\x12F\xf2*KP\xa2S\x878\xa6\x8b\xb4G\x13\a\x93/\xe3\x97iK\xa9sBzG\v1\xff5\xfcV)\xa6\x12}k\xee\x82\xe7^>\xb7fe\xe4P\xe7J.\xaaB̪\xc3\xe1ҿ\x92\xc6.\xceV4\xb2[\x89bT̒\xe8#RE\x9fxH]\x02\xa0\x82\xa7D\x83~\u0090\xdb\xef\x0f\xe2a\x97ط\xc2\x01\x97\xfcȂ\x81D\x9f-\xbd\xc2\b\xc3H_.*\x98\x8b\xa4A\xf8\xfcD\xf9Q\xb1\xd7t\xf7E\xca_I\x16Ƅ\xe2_\xa9\xa41\x9d\xecQ\xe55\x90h$\xaf\xb2\x04\x05zu\x98\x98D\xf1\xb3O\xe0'\xe8\x04\x19\xfb\x84t\x8f\x16\x82H\xb4\\\x92\xe8\xfd\x0f\xd1\xc6V\x92(-\xf3%\xb1}U\x86\x98U\x87\x0fK\xbf\xff\xe1\xdb\xf7>\xa2\xb9U\x12%\xd1\xe7\xa3$\xfa\x9a\xa6\x15}\xe9CEv\xf1\x0fw7}\xbb\xbb\x11\xab\xcf\x18P\xc2S\xa2\x12>\xf9\xbeh\x97\xf8\xday@\xfeo\x8f-Q\x83F\x14\a\xee$\x89\x8dw\x8a_\xb1\xbdtx\x83\xd7<M\xbe!tL\xf6\xfc\xcf\xc8+k\xce\xff\xa1\x05b\xe3{\xa5\\\xfa6)\xf2\x1aHT\x91WQ\x82\x02\xbd:LP\xa2o\x95_-\u007f\x8b\x04\xec\x13\xd2=Z\b\x85D\x17\x90\x9d\x82R\x03\\>W\x94k\xe0\xee5\xea\x10\xb3\xeap\xb1dnIɚ\xa8;]X%Q\xf1:\x11|(J\xa2\xc2\xfc5\xe4\x8a\xf0,\xbd\x00\xac\x11K\xbf\x1a\x1a%ˇ8+MSKcQ\x90\xa8\x0e\xbc%\x1a\xf4\r\xb9}~1\x18\xdb\xd3y\xa9Kz\xbaH\xf0\xf9ܝ\xbeq\xfd\x9d\xb6FZέ\x8cF\x94\xfc/?}\xf6i\xfa\xff\xbd\xb7d\xce\xf3g_n,yS\x8c\x9f+\xfd\xe1\xcb\xff\xda(&\aߢ\x13\x8a\xd1c\xd8\xf7\xca\x17\xec}\xfe\xce\xd2\xd2_\xbd\xa7\xc8+OT\xbeE\xae\x1d\xc2\xefΝ+o<w.@\xe6,\x1b\xdf\xc2\x17\x1bK\xc9\x04f$\xaf\xb2\x84\b\xcc:HO\x17\x1d\xa6\xb5P\x1cB\x81\xce\xd1pp\xfe\xa3\xf3\xa5\xac\xcc\x13b\x1f-\xc2{w\x1e\x16N\x94\xbe'\xfcp\xcd\xc7b\xde\rG\u007f\xb6R\xec\x15\x8b\x92//Yy\xe2\xa5{\xe7\x90?g$d\xd7\xe1\xed\xf2\xd7Ξ\xbb\x1a݈*\xcf⑹\xbf\xf8\xd9C%\xe2\xdfAU\xf57\xcb\xef?z\xf6Yi\xc0\xbe\xb7\xfc\xf0\xcbk\xca?V\x1eBl\xf6K\x9f;\xfb\\\xe9S8\xea\x8c\x01%\xbc%\xea#C\xd1\x034\xea\xd8\xd7.=\xa3\xdb'\rP\x03z\xfb\\%\xd3\xf2\x9aP\xc5ٕ\xe5+ɵ\x18\x9fxd\xef\x82\xd2\xf9kޤ\xa9\xaf\xad\x99;瑳\xd2mD\xcd\x10M\xe4\xca\x13w\u07bd\xf5W\xa5%O+\xf2\nsh^z%\xb8(\xed'~Ǟ&I\uf54b\xafʼ\xea\x12\xc20\xeb@\x9f\xd1%lP\x1dB\x81\xde\xd1\xf0\xe1\xf2\xd0\xcd\x0e\xd6\t\xb1\x8f\x16&(6\x80'攔\x9f ك\x87\xef-\x9f\xbb\xe1\xa5{K\xc5&\xad|k\xe3\x9c\xf9OQEDBv\x1d~GSK\x1fQ]\x88TgqeM\xf9\x9cG\u007f\"\xe6UW\xfdʆ\x05s\x1e\x92\x1e\xf6\x13\x9e\xbd\xb3|\xcd[\xaaC\x88\x95;L\ue2ca\"\x8f:c@\x01o\x89N\x84\x9f\x94\xfc\x89\x11\x027G\xa8?\xab\x0eY\\\x9d\xf3\xf4\xd5`\xf0\xf3\x8b\x1b\xee\x8c\xefq\\`RI\x05\x89¯Ц\x82\xf8%\xfa\xf2\x1c\xa9\x8f\x1b\x9c\xabj\x9f\x01>\xa4\x82D\x81\xa9 ~\x89^,\x95z\xb8\xef\x95*fh\x01^\x80D\xa7'\xd2\xfcLt\xc8&\xd8X\xdex\xe2\xcd\x13\x8d\xac\xc9t`\xca\x01\x89NO\xe8\xfċѡ\x1e\xaf<:\xbft\xfe\xf7\xa1\x9b\x9b\x14@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2)\x87\xe67a@Z\x03\x12M-|\xce<\xb4\xc4(\x13\x90N\x80DٴW\xfa\x8d\xb2ă\xbf\xb2\xdd(KB\x04\x8b\x8b]\xa7njr\x01\xe9\x04w\x892\f#\x02\xde\xd6}\xed\x031\x97L\xfer\xd7\xf2E\x9bn\xc4\xca1A\x965K\xef\x9dUy\x96\x02\xe7h(y\vj\xd2\xdb#1\xb6dl1ʒ\b\x03\xa8\xc3(\v\x90f\xf0\x96(\xc30\"\xe0n\x1f\x1a\xeds\xb7\xc5\xd2h\xfd\x83\xc7w.\xba\x16#\x83H0H\x16\xd7\x12\f\x87j\x9d\xfd\x91\xf8\r\xb4\x9e\xbe\xf7\xa2J\xf7IWQ\x9el2Ӝ\xe1f\xec8!<\x99\xcdFY\x12\xe0\r\xe45\xca\x02\xa4\x19\xbc%\xca0\x8c\xe8l%\xaa\xf2\xef\xeb\xd3\xdf\xeb\x9a\xe38\xbea\xa0\xd0w*\x8a\x8b\x17\xce..^\xab\xfb\xd3p\x99\x8a\x9ap\xe8͗%\xfa\x02:)\xbe\xfa\x90\x8b~\xbadY\xcf\xdaqb4X'\xb1cڋz\x8c\xb2\x00i\x06g\x89\xb2\f#\xdaZ\xe9\xa6N\x8f\xfen\x1f9^\xd7\xdf(!X\x90\xdd>3\xdb^1\xa3\xc1\xc0e\xa4lY(Z\x86\x1eȖ\xc5H\x97e\xe9C\xdd\xf4\x83s\x96\x91\xcc\x13 0\xcbi\x94%~@\xa2\xd3\x0f\xbe\x12e\x1aF\xf8\xa4V\xa6\xfb\x05\x9d\x9d\xae/wPvc\xbc\xcb\xe18\x83?\xadv\xac&a\xf5\xa9ݫ\x17m\xfa\x8c\xe6\xf9\xf4\x99\xe5\xffm\xf3W_\r\xff\xe7W\xffu\xcb=\xd2D\xcf@&B\r#\xab\n\xb2\xaa\x88d\x9b˲\xcbH\x8fӃ$\xcaH\x96q\x1f\xce\r\xb7\x97A\u007fGA\x19U\xb7\x90\xf3$\xa3\x84\x10\x8a\xd4:\x94тG-\xa8\x18\xe3:dq\xad-ʮ\x92Υ\xa52\xbb(ܚ7dE]3\x12.!B\x17Ht\xda\xc1W\xa2\xba\x86\x11\xa4\xe7\xab;\xcaz\u007f\xf0\x8c\xe3\xd0\xe0\xe0_0\xfel\xb0\xfa\x10\xbe\xf1\x87]\xd5\x18_>S\xedx\xf0\xd0\xff[\xfa\f\xc91\xb8xݡ\u007f\x981cF\xb0fƌ[\x9a\xa4o\xb6\xd0z\xa0\xa0('\u007f\xed\n$~\xe9\x9d\xd6\x06O\x83u\x95x\x91\xe8\xf6\x16ٽ^o\xc8\xcf4,\xd1\v\xa2n\xbfq\x89\x86\xfd\xa8K[B\x18E\xaa\xcfki¸\xc7i\x15{\x05\a2\x91\xadi{\xce}$\x8b3\xa3\xce\xd3l+\x93G\xc5\xddѲJ\xb8\x84\xd0~\xe3]\x15\xb9\x93ؾ\x03)\x01W\x89\xea\x1bF\x88_dw\x8c\xbb\x1c\x91\x8e\xae(Q\x8c\x0fU\xd3p\xa9\u0602n{P\x8c\xae\xd7n\xba\x1e\xf4\xfd\xef\u007f\x10%\xfa7K\xb6\xbc\x13n\xb4\xcaм\x005U\xe8\xa0\x13\xa1\x1d\x886ݑ\x8e.VH4\xd8۵=?\x8fjԃ.iJP\x11I\xb5\x92\x89\xdf&+I\xb4\xe6\x8aB^e\xa3\xfb\x93ɦ^tP\xca=\x86\xb4\xfd\x83\xc4J\x90Y\"^Eb\x8c\x06\x80\xf4\x84\xa7Dc\x18F\xe0\x1eW\xf8\x86\a\x03\xb6Dw\x86\xc2\xf3\x8e\xf7E\x8d\x05\\\xa2D3\xfb\xfd\x91neYh\xa6\xc6YLߊ騐-QB \xbf\x8a\xbc\xb5\xa1p]ʘs=\x91T\xa5\xc0\x9c\xa1\xf0\x81B\x81\x90/\x8fAǢ\x94\x96x\t2c\x1d\xaebhE\xa7\x1d<%\xaao\x18!t\x86\x96\xa5gÖh8<\xee\xb8N\x12Z\x89DG\x14\x03\xbf\xb2\n9\xa8\xbc\x87\xbe-\xac\xa4\xa9\f\x89ʺn\xca$\xef=\x91\x9ei\xb8\x04\x15\x91T\xa5\xc0\xc2a\x99<ޕ\x9f\x02\xea\x95'\xa1&^B\x04/\xea\x8dN\x02\xd2\x1c\x9e\x12\xd55\x8c\bxZ|1\xf7\x8c\x92\xe8\xfe(\x89\x9ew\xbcK\x12\xb4\x12\r\x89\xd1YH\xdf\n#\xad\xe8>\xb9\x15\x93$*\xe4J9\x9b\xe8\xccN\xc0\x1a~nA%\xe70\x91T\x9a\xb3!J`+\n\xfb)rϽɢm\xf9\x12+!\x02\xcc\xe8N?xJTBk\x18\xe1?xD\xfc\x12\xc7rd\x8fHt\xd1~\x8co\xd4GI\xf4ڃ\xf5\xa4\x19\xfd\x9f\xba\x12\xf5о\xe6Ai$g\xb7c<\x8e\xa4;=\xa1V4\xaf\x8a\xbc\x06\xf2\xa5f\xab\xe6\x8e\xd0<\x8d\x91D\xb3\x9f\x14+^\x11%\xb0\x0e\xa9\xf0\x8d\x9bi\x96`\xf1\u009b,A\x01Ht\xfa\xc1[\xa2\fÈ\xb1}\aG}>_w\xab\xde>Ҍ\xee\x1f\xe8\xf3\u007f\xf5\x0f\xfe\xf2\xd0:G\xf5\xa9\xcb\u007f\x19\xac\xde\xf5\x87\x1b\xef\xef\xaa&3\xbd\x83\x8bV\x1f?\xbf\xfb\x1fU\x12\x15z\xe8ܭ4\xac\\\x91\xb1\u07b3>c\x05\x8d\x9b\xac\xdb\xdb\xe6e\x93#\x8f{\xbdߨ\xf1\xf6\x88zlAU\xae\x93\xcd\xf9\xf2\xd3E\xefdlה\x10F\x95Zi۲\xb9\x12e\xba\x87}^\x8b\xb3\a\xf7;-^\xb1\x88\xf5\xe8\x81\xd6v'\x92\xa6\xc2v \xc5\xd3L\x13*AA\x1f\xa3\xd3\f\xa47\xbc%\xca0\x8c8&\x0fP\xf5&+\xaf/\xa5\xb7E\xab? \x1f>\xaa_\xb4x\xd3~\x87c\xd7.\x92\xf4\xfeb\xf1u\x97\x98\xfc\xc13\xb5\x8b\xd7\xfd\x1f\x95D\a2\xe8pNj\u0082ͳ\xb3g7Km\xa3P\x97\x9be\xa7C\xba\x06\x9a#sD\f{\x96\xe4[\x8b\x1f\vu,\x1b\xbe\xde\x1d]B\x18U\xea\x88=+\xa7j#Buub\x92e([|\xad\x13\x93;\xec\xb6\\\xbbt\xe7כ\xf5$\x8e\"\xc1\x12\x94\x8cg.\x1b\x187|\xc4\x11H'xKt*ьE'\xcec\x16\xdd6=1\x0eZ\x9c\x93R\xa1\x10mŌI$ \x9d\x01\x89\xb2ّ\x1fé-~\xfc\xb3&\xf5\x87.\x84\xf1\x81\xd8Sk@\x9a\x91\x02\x12u\xc4\xcb?N\xa2D\x01\xc0$\x80D\x01\xc0Ԥ\x80D\xe3f2;\xba\x00`\x12@\xa2\x00`j\xd2G\xa2B\xf32\xf2\x18\xfd\xfan\xd0(\x90N\xa4\x8dD\x83\x95\xa1\x1f\xa3\x1d\x01\x8d\x02iD\xdaHT\xb8u\xf3W_\xfd\xe7W_\xfd\u05edK\xe0\xc7 @\x1a\x916\x12\r d\xb7ߚg\xaf\x98᜔\xe55\x01\xc0\x1c\xa4\x8dD\x05o~n\xee\x1d\xb9\xb9\xb9\xf3ހ\x8e.\x90F\xa4\x8dD\xb1\xe0\xbbt\xe9\xd2\xe8\xa5Kc\xd0\xcf\x05҉\xf4\x91h\xdc\xeb\xe8\x02@*\x91F\x12Mab\xd8SL\xb6\xe5\x04\x90jp\x97(\xc30\xc2\xd7q`Ok\xf74\xee\x9fF\xec)\x18\xfe\x15\x93l9\x01\xa4\x1a\xbc%\xca0\x8c\x18wy\x86dž\x8f\x1c\x98|\x8dθ\x19\x8c\n\x9f<\"\xf6\x14L\xff\x8aɵ\x9c\x00R\r\xde\x12e\x18F\\rQg\x97\xd8\v\x8cM\x88\x19_L\x1c~\x12\x8d\xd8S\xe8\xf8WL\xaa\xe5\x04\x90jp\x96(\xcb0BZ\xa6\xd6\xef\x9a\xfc\x9fA\xa6\x86D\xc3\xf6\x14z\xfe\x15\x93j9\x01\xa4\x1a|%\xca4\x8c \bc\xad\x9eɟ\x8a\xbdI\x89֡\xcc\xe6\xef\xe5\xe7\xde3\xa2)\u061dG۷\xb1\x1cy1\xcd\x1ce3\x97\xa0\x1fDȞB\u05ff\x82a9\x01L#\xf8JT\xc70\xc2\xefr\xb9ܓ?\x14\xbd9\x89\x06\xa9\x85C\xc1概\xec\xa1肗\xa0*\xf2&\xb8\x9b%\xdcJ\t%\xe8\a\x11\xb2\xa7\xa0\xb0\xfc+\x18\x96\x13\xc04\x82\xabDu\r#\xfc\xbe\xa1֩\x98.2\x92!\xfd\xa7\xb3\x8d,\xebi-\b\x90\xa5;+\xa3\v\x1e\xdd,\xa9g|T\"z\x11\x95D\xfc \x14\xf6\x14l\xff\n\xb6\xe5\x040]\xe0)\xd1X\x86\x11b\xdbsRwljB\xf4\xf7\xe27\xf5\x85\x1aS\xa2d\xfcg\xddH\x8aiF:w-GQ\x88\xa8\x85<\x13\xf1\x83hS\xee\xcc\xf2\xaf`[N\x00\xd3\x05\x9e\x12\xd51\x8c\x90\x9f\a\x1apM\xfa`\x94\xe8\xef\xf6\x17'(Q\xb2Ξ\xb4,}\x97f%\xdc\x10^\x8fD\xb4\xa9[\"~\x10=\xca^,˿\x82m9\x01L\x17xJ\x94m\x18\x11l\x91\xa6\x8c.\xec\x9b\x12\x89\xaaT\xf8\xf3\xdbf~\xed_\xbe\xf8\xe2\xb7߹\xf5\x96\xef\xfc9,џ\xff\xfd̿\xfd_$\xe3\x0f\xbe6\x93l\x9by\xdbO\xc5\x0f\xa4\xe5\xb4>F\x8aq\xa1D\xfb\xe0\x89\xf8A(\xec)\xd8\xfe\x15l\xcb\t`\xba\xc0S\xa2\x12\x1aÈ\x03\xc4XP\xec螎\xb9\xdbD\x88\x96\xe8\xcf\xff\xe6\xe7\x9f\xfc\xf6\xbb_|\xf1w/~\xf2\xef\xff\xe3\xbb!\x89\xfe\xfa\xef~\xfd\xc9o\xbf%jt\xc6\xed\xbf\xff\xe2\x8b\xdb~\xf0\xe7\xff\xf8\xf5\xb7\xc5\x0fĬ\xc1\x9aG\x86\x94\x85\xf6\xe8\x82G\xb7(Ə\f\x12\xf2\x83\x88\xd8S\xe8\xf8W0-'\x80\xe9\x02o\x892\f#\xdeq\x9d\x1c\x1e\x1b\x9e\xba颈D\xbf\xf9\xd3H\x83\xfa\xef_\vI\xf4\xf6߈\x1f\u007f\xff\xb7bL\x82[~/m\x9fA\xae$VTֺ\xe7\x8e\\\x8d\x1e\xe5\x19]6\x89\xfaA\xc8\xf6\x14\xfa\xfe\x15Z\xcb\t`\x1a\xc1[\xa2\f\xc3\b\xec\xebl\xdd\xd7\xd63\x05\xb7\xfe\xa2%:\xf3\xcf\xd2\xfb\xef\xbf}\xeb\x8c\x193C\x12\xbdu\xa6\b\xfd\xf8\x1f\xe2\xb6\u007f\xba\xf5\xbb\xffBTJ\x1f]\xb0\xaeu\xe6\xccZ\xa5}\xa6\xc2msi\xd2\xc2$\xec\a!\xd9S\xe8\xfaW0,'\x80i\x04o\x89r%Z\xa2\xb7\xca\x12\xbd\xfd\x9f~\xff\xc5'3B\x12\x9d)\xb7\x9br\xc6\xdf\xfc\xe0;\xb7\xfc $Q\xc50q\n\x89iO1ٖ\x13@\x8a1\xad$z\xbb\xdcѽ\xe5\x93/\xbex1,\xd1o\xfeH%Q\x91\xdf\xde\xc2W\xa2\xb1\xec)\xa6\xc0r\x02H)\xa6\x95D_\xfc\x9a4]t\xdb\x0f>\xf9\xcd\u007f\x0fK\xf4\xc5[\xff\xe5ϟ\xbc\xf8-9\xe3\xb7\xfe\xef'\x9f\xfc\xe86\xce\x12\x05\x00]\xd2^\xa2\xf4\x87e!\x8d\xfe\xf4\xef\xe9M\x97\xdf\xdc6\xf3k?\nK\xf4\x8b\x17o\xbfe\xe6\xed/\xca\x12\xfd\xf9\xed3o\xfd\xf6o\xa9D\xa5\x19\x1e\x00H*i/щB\x1f\xa3G\xc8\x12\xf5\xdc\x10\x00p\x06$\xaa\x03\xbf\x1f\xa3\x01@,@\xa2:\x80D\x01s\x00\x12\xd5\x01$\n\x98\x03\x90\xa8\x0e Q\xc0\x1c\xa4\xb7Do\x06\xa3\xc2\x01\x80\vi-Q\x00H}@\xa2\x80̤\xff\x16\x10\x98\x14@\xa2\x00\xc1\xe7̓~a\x0e\x98\r\x90(\x80\xc9OR\x8b]\xa7a\xb5^S\xc2]\xa2\f\xc3\be*gN\xda\xc2\xc7\xf5\xd7\xe5eUMVg\xefU[_\x9c\xa9\xfey\xb9[\xb4\xe1d\x10\u007f\x1d0\x1e@\x1d\x8cT\xc0\f\xf0\x96(\xc30B\x99\xca\x1bOvxm\xbdyy.gV<?+\xf7őɅX?(e\xa5>Y\xb8%ï\t\xe3$\x10ky\xf0\xf8\xeb@\x9c*\xa2\x97_\x02\xcc\x02o\x892\f#\x14\xa9\xfc\t7\x9b~Ԍ\x83q\x88O\xd4r\xae\xf1Bh/0\x97\xd5d\xa5Vl\xc6\xd9^M\x18\x17AW\xee\xbc\x18\x9b\xe3\xaf\x03Y\xc0\f~/`V8K\x94i\x18\x11IM\"#(ޮ\xf6\xd8\x12T1`\x90\xa7\x13uƙ:\xdb=\x86F4a<\fT\xa0{b\r\x1f\xe3\xaf\x03H\xd4\xcc\xf0\x95(\xdb0\"\x92ʗ@\x16B\x19t\x91\x16\xc1&\xad\x9a\xb9V\xb5\xfdr\xb5ñ\xff\xa3m\x0f/\xda\xf4\xa5z\xc7c\xf9\x19\xd4\xed\x81m\x18A\xe8C}\xf4=\xb0l\x96%\xff\x9e\x90\xa0C\xa9J\xaa\x1a\x96\xcc\x1e\xc8D\x99ê0\x8cn\x1d\x02k3\xf2\xc9EŸ\x0e\xc5r\x06\xbb*UM\x17HԴ\xf0\x95(\xdb0\"\x92ʙ>\xafW\xfe\xd1\xf6\x05\xefA\xd4\xe4\xf5\xaa\x87v\xd7Ϝ\xa9]\xbd\xb8v\xf7\xb6\xbb>\x8d\xda1\xb0>3\uf21ea\x04\xc1g\x93\x8a\xf2\xa0\xefu\xb5ޓѫNU\xb29\xc7\xda'T\xd9ɢb\x8a0\x8c^\x1d\xda\xf22\xd7\xd3n\xb9q\x1d\xacN\xaf\xd7\xdbU\x89\xb6\xa8R\x15\b\xe3]\x15\xb9q\xf5\xf1\x81$\xc0U\xa2l\xc3\bE*\u007f\xb2B\xeb*\xb0;\xba\x8f;\xea\xaf\xe1\x1b״\x1b\x86\xca\xd0c\xfa\x86\x11a\x02\xad\xe4\xab?;\xc6\x1d\xc7-ȅ\x03\xd9ǢB%\xac:ԡ\xb2\x90ьa\x1d\x9a\xfa\xc5a\xab\x13雔.\x11\x9b\xd8x{\xf9\x00wxJ\x94m\x18\xa1L发D\xab\xa3\x1bP\x19wn\x96K\xdf0\"\x82\xbf\xb9\xaa0\a\xcd\xd6ی[Q\xeeZ\xbcc\x96\xa0\x0eU\xb0\xea\xe0\xb6\xe6ʶ\xc1q\xd4Al'\x97!7\xd6e\xac\xc3U\f\xad\xa8i\xe1)Q\xb6a\x842\x95?F\x12]\xc7H\x14\xdb\xd0J\xb4\x90(B\xcf0\"Lo^\xfe\x93m^\xbb\xaeDdz\xd7v~}\xb4\xb0I\x1d\xaaa\xd6\xe1R\x15\xaa\x94\xdaQ\xc3:\x88\n\xad\xb2\x1c\xd1\xdfJ\xf0\xa2\xde\xd8\x19\x80\xa4\xc1S\xa2:\x86\x11\x8aT\xfe\x18I\xf4\x19F\xa28\x12͏\xb3cX\\INs\x99\xaeD\xdbŶﾂ\x9c\x80:Tì\x03\x1d\x8d>\x19_\xd3\x17\xb0[5\xbd\xe7(`F\u05fc\U00014a04\xc60B\x91ʟ\tH\xb43?^m`\x9cO\x9c#\x82e\xba\x12mC#\xf8\x02Z\x81\x83\x05\x97\x14\xa1:\x8f\x8eDɜ\xee\xacx\xdc\xe4\xfc\x15\xf4n\xabGc{\xa1\x00$j^xK\x94a\x18\xa1L\xe5\x8a\xd0\xe3\xf5\x92\xe9\xce@hF\xb7Gݎ\u007f\xf9\xc7\xc1\xd5\xf5\x83\x83\xd1#\xc1ev\x8d%\xb0.MhY\xf3\xe62dۢ\xa3\x80\xf1욶\x82\"K\xddf\x8b_\x11*2\xe8\xd4AbȾ\f\x1b\x12(F[\xbc\"Nk\x8cL}\xe0\xbdfZxK\x94e\x18\xa1L\xe5\xc9\x1b\x92\xb3\x03ra!\x97\x06\xaa;\x92\x18_vP6\xe9\xec\x1e\x0f\xc1\x1dEV\xdb\x03\xee;,zM\xd8\xe9;lu\x81\x93E\xb9ͪ0\xc2\xcd\xd7\xe1B\xa6<\x9dT\x10#\xd3x沁\xf1d\f4\x00CxK\x140'm\xc5\b~\x8cfN@\xa2\x80\xc4\xf8@2f\xd4\x01C@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00`j@\xa2\x00\a\\\xd9\r\xe2kO.\xf7_3\xa5\x01 є\xa0\xbd\xd2\xcf\b͈\xbf\xb2]\x9b\x18\xc8^\x8b\xc60\xbeϦY\xf5\x85\x01\xb3\x84i\fw\x89j\r#\x047]\x16E\xb3\x82\x1d\x10f\vjb\x84\xf1\x93\x88w\xc4Ͳ%C\xebzџ)\xccj\xc7㖍Q\xe9\xa3+\xf2\xb3go\x96\u007f\x1f\xef\xb2\xe7\xe4o$?\x88c\x95\xa0\x0f\xcfsK\n\xbc%\xca0\x8c\b\xb8.\xf8DL\xdd6L\n\x9d\xfdF9th\xcep3\xc2\x04H\xc4;\x02\x1b\xac\xb6=\xf8n\xec\xedؓ\xa9Yl\xb0\xd7\x1a,h\x15\xaf.Q\xebI\x8c|c\xf6v\xcfƜ\xd9t\x8d\x9c\x85\x19u\xed\r\xa8U\xa7\x04)?+1\xa1sKExK\x94a\x18\x11pM\x13K\xae\x8a\x1a\xa3\x1cl.Y\xd63\xc2DH\xc4;b\b\xc5^Tb\x9d\xce:-\x11\x1a\xac\xd1\xff\xa1\xfe\xcc=h(X\x18mo\xb1\xa4\x80\xf4\x9c\x86\xb3I\xe3\xba\xc4\xdaM\xd6gi\xd6)\x81\xc0\xaeY\"疒p\x96(\xcb0b\xdaH\xb4,\x8eeLX8g\x05\x18a\"$\xe2\x1d\xd1c\xb0\x8c\x91\xdeRJ\x11\x02\xb3\x9c\xd1I\x8f\xa1\x85\xe2\xe1\xa2ǘ\xc5\xd2B\x10\xf7U\x90\xa3\xd2\xfe\xfb\x88\xb4\xf2\x03\xa3\x04\xacW\xb3D\xce-%\xe1+Q\xa6aD\xbaIt \x13\xa1\x86\x91U\x05YU\xe4*\xd4R\x99]D\xdc%<\xf2\xf2$ed\x9d\xea\x8c\x16<jAŪ\xbcu\xc8\xe2Z[\x94]\xa5\xf9c\b9OF\x87\xba6\x12:\xc4\xef_\xc1\x16\xc2\xe0\xa6\xda\xea\xe5\x9bjo\xe0ץuZ\x1ct\xdd\xd0\x1b\xa7\xd6-^\xbd\xfb:ƻ\x1c\xd5\xc7w\xd6.\xdd\xf4\x91\x9c\xbd!+z^!8,\xe0e\x9aɢnIF\xceB\xf1ob\t`\xc5fm\tXO\xa2\x89\x9c[J\xc2W\xa2LÈ\x80\xeb\xe4\v\xae\x03\u07b4\x99-\x12Z\x0f\x14\x14\xe5\xe4\xaf]A&1\x9d\x19u\x9ef[Y\x10\a\xba\xbdEv\xaf\xd7+v\x1b|^\x8b\xd8d\xf4\x90\xf5\xbe\x14y\x87\x0fd\"[\xd3\xf6\x9c\xfb\xa2\xcb\xebG]ѡ\x8e\x8d\x84 /L\xaf\xf9S\xc6\xed_\xe1\x1f\x1d=\x82\x8e\x8c\x8e\xaa'\x06\xfe\xed\xae\x9dgΟZ\xee\xf8\x12_\x1b\xa4\xab\x9d\r~@\x92w:v\x9f?\xfe\xe0\xe37\xf0\xe53Վ\xdaC\x87j\x17]\x96\xf2w\xb3\xb4\xa4\x9d,\x92\x11\xf2V\x89=\x8c\x8a=\xc5\x19y\xceВ\xfa\xda\x12\xd85\xc3\t\x9c[\xaa\xc2U\xa2lÈ\x80\xabe`l\xb8\xf5`\xdahT\xfc¡y\xe2\x99Ҷ\x93\xcc\xee\xf4\xa2\x8345\xdcѥN2MVu^l\xcd\x155\xbd\xca\x16]\x98'2ˢ\bY6\x12v\xb9\xa5\xd6]\x8e\xd3ȿBgi\xfb\xe3\x0f\x92\xc6\xfa\xf8\xd2\x1b\xe4C\xb8\xa3\xfb\xba\xe3\x94\xf8\xfa\xae\xe3\x8c\xf8Z\xfd\xb0X\x93k\xb5\xf2\xa2\xdcc\xac\x81\xa0f\xb2H&\xe8\xcc\x12/[\xf9\x19\xb6-\x1d\xcdy\xf9r?^S\x82\xf1\xa2\xfbF疲\xf0\x94(\xdb0\x02\a\x87\x888\x05w\x1a\xad\xe4Z\x16\x9a\xeex\xa0P \xe4ӡ\x95\x8eD\xc3S#Vg$UA[\xe4[\xa9\bY6\x12#\xf2\xc2\xf4\xfas\xb2\x06\xfe\x15\xc1N\x8f\xa7\t5y<\xea\x81ܧ\xb5\x0f\xef>\xf5\xfe\x8d\xeb\xf4CX\xa2\xdb\x1e\xbe\xfe\xa5H\xedN1\xae\xdeOR\x8e;\xa4KƘtIRS\xa8sᨣ\v\x18\x97Y\x89\x80Dz\xe5>\xbd\xa6\x04\x9d\x9a)1\xf2\xe6HUxJ\x94m\x18\x11\xc2ۦ\xb7_\xeaQV\x11\n\xe4K?\xbd\xb6\xebH4\x94W\x95\xaa@1\x04S\x84:V\x16\xb11\xf2\xaf \xb0F|\xd7N=\xb3ڱ\xfc\x97\xeaV\xf4qGd\x01\xd1\xeaC$e\xd0!ݐ\xe9e\xac\xca\xebEm\n\xc3\xe50\x81\x9aLz\x17\xa9\xa6\x98~\\V&%\xb3J0\x98Ȋ\xe7\xdcR\x12\x9e\x12e\x1bF\x84\xd4\xda\x19\xa7\aC*\x10\x16\xe3\x8a\xc2~\x8a?\x9cJo\x05S16X\xd5y\xf5$\x1a\xb061B\xe3\x89U\x06F\xfe\x15\x04\x86\x10\xde\xdd/\x8a\xf3ڙE\xc7\xc9\az\xe0S\x9f\x92V\xf4]\ni9\xabw\x93M\xa7\xe4V\xb4ɢ\x9dw\xae\xb1\t\xd8\x19\xa9\xbe\x8c\xaf,W\xeaN5\xe4\xd0q\xce\x12\xf9z\xc5*\xc1@\xa2\xf1\x9c[J\xc2S\xa2\x12\x1a\xc3\b\x0f\xb5\x04\xf2\xbb/\xc4\xdc-\xa5\bˮC\xba\x17\xbfq3y\xb5\x8b]\xbdq\x9a@\xfas\xc1\x8a8%\x8ak\xee\bj\xc3\tI\xd4ȿ\x82p)G3f<\xe48O\xde\xeaw\xd1\xd7z\x8c?#\x03\xd0\xf3t\x14\x8a\xf7\xffR|\xa9^NƢ\x0f\xd7\xd3\xec\xc1\xe2\x85\xd1%`\xbfe=\xeeGM\x19j\x8bŁYE\x97\x88\xbf)\xb9\xe7IN\xfe\x12}\x94\x97]\x02\xb3f\n\xe29\xb7\x94\x84\xb7D\x19\x86\x11c\xae\x8e\x91\xb1\xbe}\x9etY\f]\xe8\xa1s\xb7Ҩq=z\xa0\xb5݉\xe8e\xa9ɺ\xbdm^69\xe5J͕ۖ(\xd3=\xac\xc8\xeb\xf3Z\x9c=\xb8\xdfi\xf1F\xcfE\xbe\x93\xb1=*\x8ci#\x11\x03#\xff\n\x1d\x0e9\x16\x1fz\xfd\xf5\x9d\x8eA\xfa\xa1\xfa\xf8\xeb\xf5\x8bɡ\xf7ߵ팘J\xa7\x8b\x1c\xebΜZ\xbd\xf4\x03\x9a}\a\xd2>F\xb5\x1d\x8d\xe0\x03\x85A\xab\xea\xc0Dzfy\x88\x95E\xbe\x18o\xb44tl\xb7\x15\atK0b\x82\xe7f~xK\x94e\x181~\xf2\x80\xdb3\x94.\n\xc5\x03\x92\x0f\x85\xdc\x0et\xd8m\xb9v\xe9&\xb0P\x97\x9be\xa77\x05F\xecY9U\x1b\x11\xaaS\xe4\xad\x13\xdf-C\xd9\xe2k]t\x89\r_\xefV\x87\x13\xb5\x910\xf4\xaf`s\xaa\xfePm\xf5\x83\xf5T\xa1\xf8\xfa\ue94b\xea\xa51\xe7\xf9\xfa\xe5K\xebi\x03[\xbd{\xe7\xd2\xdam\u007f\xa1\xa9ެ\xf0}\xdc\bw\x88G\xf4Z<\xea\xf9\xd8\xd0\f4\xedݶ\xce\xce*j\b\xe8\x97`\xc4\x04\xcf\xcd\xfc\xf0\x96(0\x11\x1e\xb3\xb42B\x13!M\x17Q\x0eZ\x9c\xda\xdbg\xe3H\x1c\xcd\x04+\xd1\n\xcd\x16\x06\xcc\x12\xa6/ є`G\xfe8#4\x0f\x11\x89\xfag1\u007f\xa6Bo,\t\xef\xc4\xd3U\xd2)a\xda\x02\x12\x05&\x01E+\nL2 Q\xe0\xa6\xf9l\xb0z\xd7\x1fn\x18\xe5\x02&\x06H\x14\xb8iv9\x1c\x0e\xc6\xc3N\xc0\xa4\x00\x12\x05\x00S\x03\x12\x05\x00S\x03\x12\x05\x00S\x03\x12\x05\x00S\x03\x12\x05\x00S\x03\x12\x05\x00S\x03\x12\x05\x00S3\x9d%Z\x83l\xab\x86\x8d2\x01@r\x99\xce\x12\xf5u\xba\x8bm\x13Z\xf4\x12\x00\xb8\xc1]\xa2Z\xc3\b\x91\xe1c\xee\xd6>\xbd=\xa6\x92.4\x80\x01\xc0\xcc\xf0\x96(\xc30\x02\v']=\xa3\xfd\xaeX?\xa9\x9f*z\r\xd6u\x06\x80d\xc3[\xa2\f\xc3\b|z\x8fؚ\xfa]\xc9\x18\x16\x82D\x01\xb3\xc3Y\xa2,\xc3\b\x9f\x8b\xaeZ\x94\x94A!H\x140;|%\xca4\x8c\xe8\x11\xd5\x1a\xcfO}\xa7\x82\x81\xc8J\xef\x00`J\xf8J\x94i\x18\xd1\xee\x19ns\x1d\xe8N\xcaZ\x18\x82\xad\xb2{,Y\xd7\a\x00\x88\x03\xae\x12e\x1bF\xb4RÈ\x03\xadI\xd1\xe81\x84\xd0=F\x99\x00 y\U00014a0ea\x84g\x0f]\xf5\xda\xdd\x1b{\xef)!`+\xdcѩ\xe7\x12\x02\x00&\x80\xa7Du\f#\xba$\xa7\x88\xaeh\xf7I\x1e\xf4\xa2\x93FY\x00 \xa9\U00014a0eaD\xbf\x9b\x0e\x06O'\xc30\x02ft\x01\xb3\xc3S\xa2\x12\x1a\xc3\b?\xbd\xe9\x12\xd8\xd7\x17s\xb7\xa9\x01$\n\x98\x1d\xde\x12e\x18F\xe0\xbe=}cC-mɘ.2r\x8d\a\x80d\xc3[\xa2,\xc3\b|\xa9\xdd}\xa4\x8f\xbfB\x05_\u007f\x8d5m̜\x814\x85\xb7D\xcd\xc4\x12\x84\n\x921G\x05\x00\t0\x9d%\xea\xeb\x1f\xc3\x00`r\xa6\xb3D\x01 \x05\x00\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x02\x80\xa9\x01\x89\x022\xb0>\x8c9\x01\x89\x02\x04\x9f3\x0f-1\xca\x04$\x03\x90( \x12,.v\x9d\x86'\x96M\tw\x89j\f#\x84\x16y\xb5\x94\x031\xf7\x9b\x1aN\xda\xc2k=\xf8\xeb\xf2\xb2\xaa&\xab\xb3\xf7\xaa\xad/\x14n\xb7ng\xa4\x86\xf1\xcf\xcbݢ\r'\x83\xd0Ѿ\x87$\nU\xa9j\x06P\a#\x150\x03\xbc%\xaa5\x8c\x10\\\xfd>\x91>W2\xdcU<\xd9/\x84\xc2yy.gV<\xebm\xfb\xe2\xc8\xe4B\xaePXf\x99\xcdH\r\xf3d\xe1\x96\f\xbf&\x8c\x93@\xac_\xbb\x86\x8ef\xaf\xf0\x8a\x1c\x94\x17:d\xd5\x01\xe37\x90\x97\x91\n\x98\x01\xde\x12e\x18F\xd0\xe3\xf1\xd4\x00\x00\x0f\xb1IDAT\f\xd1U\x8cZ\xbac\xef8E\x84\x9bM?j\xc6\xc18\xc4'j9\xd7e\xd8ؾ\x80B\xd2\x0fd\xac\xc8\b\x15\x1bI\x8dP\xb1\x19g{5a\\\x04]\xb9\xf3bl\x0e\x1d\xad\x8a\x8e1\xabr\xc6T\xa9j`\x81\x18\xf3\xc2Y\xa2,\xc3\bʱ\x17\xf8\xaf\xba\xa0b\x04Ż\xbc\xd9\xd8\x12Ta\xd4\xe2w\xa2\xcep\xd4\x1f^\xf1>\x92\x1aa\xb6{\f\x8dh\xc2x\x18\xa8@\xf7\xc4\x1a>\x86\x8e6NZf7r\xabSՀD\xcd\v_\x892\r#\bîqݝ\xa6\x8c@\x16B\x19t\x04,ؤ\xe1\xdaZ\xd5\xf6\xcb\xd5\x0e\xc7\xfe\x8f\xb6=\xbchӗ\xea\x1d\x8f\xe5g\xac%-\xe3X\x8e<\xccˉ\x96J\x1fꓣ\xa6|\x9cߤI\x8dPհd\xf6@&\xca\x1cV\x85at\xeb\x10X\x9b\x91O.*\xf1ԁ\xe4\xaab\xa4F\xe8\x02\x89\x9a\x16\xbe\x12e\x1aF\x10ZO\xeb\xee3\x85\xf4y\xbdVI>\x17ıZ\x93\u05eb\x1e\xda]?s\xa6v\xf5\xe2\xda\xdd\xdb\xee\xfa4j\xc7\xc0\xfa̼#\xa2\xb2\xdd\xcd\x12\xee\xe8.\x80\xcf\x16*j^\r^fפF\u061cc\xed\x13\xaa\xec=AU\x18F\xaf\x0emy\x99\xebi\xff9\x9e:D\xba\xb9\xcc:\b\xe3]\x15\xb9q\xf5\xf1\x81$\xc0U\xa2l\xc3\bL\x16\xc1Nք\u007fV\xa8\x85cwt\x1fw\xd4_\xc37\xaei7\f\x95\xa1\xc7\xc4>䨄~\x17 \x98\xbd\x1d\xefȎ1v݂\\8\x90},*TªC\x1d*\x1b\x92C\xe3:(\xba\xb9L\x96\x88mp\xbc\xbd|\x80;<%\xaac\x18!r\xb25\xd6~S\x89\x91D\xab\xa3\x1bP\x19wn\x96\v\x8f\xa2\x10\xba\x9e\x13\x03\xa8[\xe8\x8ea\x05ފr\xd7\xe2\x1d\xb3\x04u\xa8\x82U\a\xb75W\x16]\x1cuPtsٛ;\\\xc5Њ\x9a\x16\x9e\x12\xd51\x8c\x10q\xf7\xc5\xd8mJ1\x92\xe8:F\xa2؆V\xa2\x85D\x11^\x8f\x84\xfe<l3UO\xb3\xde\xe6\xf1쵝_\x1f-lR\x87j\x98u\xb8T\x85*\xa5vԸ\x0e\x8an\xae\x1e^\x94\fG\x1d \x1exJT\xc70\x82\xacG\x9f4\xe7##\x89>\xc3H\x14G\xa2\xf9\xf1v\fk\xcaz{{\xcbj\xf46\xb7\x8bm\xdf}\x059\x01u\xa8\x86Y\a:\x1a}2\xbe\xa6O\xea掮\x8d1g\x0e3\xba慧D%4\x86\x11\xa4y\x8d\xef\xbb6\x05L@\xa2\x9d\xf9\xf1jCd\x16\x99$^;Kos\x1b\x1a\xc1\x17\xd0\n\x1c,\xb8\xa4\b\xd5yt$J\xe6tg\xc5c\x1a%ws[Q\x8c\xe7\x1c@\xa2慷DY\x86\x11b\x93\x9a\x94\x9b\xa2B\x8f\xd7kuz\xbd\x81Ќn\x8fzZ\xe7\xcb?\x0e\xae\xae\x1f\x1c\x8c\x1e\t.\xb3\x0f\xe18\x11\x8e\xa1\x8d\x01\x1c؈\x8e\xe9\x9c\xe0xvM[A\x91\xa5n\xb3ů\b\x15\x19t\xea 1d_\xc6LWs\x0f:H\x1e/j\x88%\xd1>\x94\x9c'G\x00cxK\x94i\x181\xcaz\xe0e\xeay#C\x9agqa!\x97\x06\xaa;\x92\x18_vP6\xe9\xec\x1e\a'\xc5B[\xf1\x11\xf1U\xef\xa6\xd2\xe9;lu\x81\x93E\xb9ͪ0\xc2\xcd\xd7\x01\x17\xc9\xd3I\xb1f\x84\xc63\x97\r\x8c\x1b>3\x05$\x03\xde\x12\x05\xccI[1\x82\x1f\xa3\x99\x13\x90( 1>\x00\x0eT\xa6\x04$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\n\x00\xa6\x06$\np\xc0\x95\xdd \xbe\xf6\xe4&\xb6L0@\x00\x89\xa6\x04\xed\x95~FhF\xfc\x95\xed\xda\xc4@\xf6Z4\x86\xf1}\xb6x~t\xc8,a\x1a\xc3]\xa2\x1a\xc3\b\xf1?\xf0\xd5\x17\xf6\xbd\xf0jܿ\x92\x9e\x86lAM\x8c0~\xe2\xf7\xaf\xb8y\xb6dh]/\xfa3\x85Y\xedxܲ1*}tE~\xf6\xec\xcd\xf2\xff\xbc˞\x93\xbf\x91\xfc \x8eU\x82><\xcf-)\xf0\x96\xa8\xd60\x02\aZچdž\x8f\xb4\xa4\xbdF;\xfb\x8dr\xe8М\xe1f\x84\t\x10\xbf\u007f\x85\x88\xc1jۃ\xef\xc6ގ=\x99\x9a\xa5\x9az\xad\xc1\x82V\xf1\xea\x12\xb5\x9e\xc4\xc87fo\xf7l̙M\xd7\xc8Y\x98Q\xd7ހZuJ\x90\xf2\xb3\x12\x13:\xb7T\x84\xb7D\x19\x86\x11\xdeV\xd2\xfd\x11Z\x13\xf1JHI*t\x970\x8a\xcd%\xcbzF\x98\b\xf1\xfbW\x88\xdd\x1c\x14{Q\x89u:\xeb\xb4Dh\xb0F\xaff\xe6\xcf܃\x86\x82\x85\xd1\xf6\x16K\n\xc8\xff\xfcp6i\\\x97X\xbb\xc9\xfa,\xcd:%\x10\xd85K\xe4\xdcR\x12\xce\x12e\x19F\x9c\x96\x16\xealO\xcaj\xd7<)\x8bg\x19\x13\x06\xceY\x01F\x98\b\xf1\xfbW`\xdcc\xb0\x8c\x91\xdeRJ\x11\x02\xb3\x9c\xd1I\x8f\xa1\x85\xe2\xe1\xa2ǘ\xc5\x05\xf4\xed\xbe\nrT\xda\u007f\x1f\x91V~`\x94\x80\xf5j\x96ȹ\xa5$|%\xca4\x8c\xf0\xb7t\xf9\x05\xbf\xb7\xc5Գ \t0\x90\x89P\xc3Ȫ\x82\xac*r\x15j\xa9\xcc.\"\xee\x12\x1eyy\x922\xb2NuF\v\x1e\xb5\xa0bU\xde:dq\xad-ʮҴ\x1fBΓѡ\xae\x8d\x84\x0e\xf1\xfbW\xb0\x850\xb8\xa9\xb6z\xf9\xa6\xda\x1b\xf8ui\x9d\x16\a]7\xf4Ʃu\x8bWﾎ\xf1.G\xf5\xf1\x9d\xb5K7}$goȊ\x9e\x16\n\x0e\vx\x99f\xb2\xa8[\x92\x91\xb3P\xfc\x9bX\x02X\xb1Y[\x02֓h\"疒\xf0\x95(\xdb0B8\xe9r\xb9:\xe2\x99\xecK\t\x84\xd6\x03\x05E9\xf9kW\x90ILgF\x9d\xa7\xd9V\x16āno\x91\xdd\xeb\xf5\x8a\xdd\x06\x9f\xd7\"~\x93z\x9cVU\xde\xe1\x03\x99\xc8ִ=\xe7\xbe\xe8\xf2\"MC8Ա\x91\x10\xe4\x85\xe95\u007fʸ\xfd+\xfc\xa3\xa3GБ\xd1Q\xf5\xe5\xf2\xdf\xee\xday\xe6\xfc\xa9\xe5\x8e/\xf1\xb5A\xba\xda\xd9\xe0\a$y\xa7c\xf7\xf9\xe3\x0f>~\x03_>S\xed\xa8=t\xa8v\xd1e)\u007f7KK\xda\xc9\"\x19!o\x95\xd8è\xd8S\x9c\x91\xe7\f-\xa9\xaf-\x81]3\x9c\xc0\xb9\xa5*\\%\xca6\x8c\x10N\xb6\x0e\xfb\x86[O\xa6\x8dF\xc5/\x1c\x9a'\x9e)m;\xc9\xecN/:HS\xc3\x1d]\xea$\xd3dU\xe7\xc5\xd6\\Qӫlхy\"\xb3,\x8a\x90e#a\x97[j;\xd6\xc3\xc0\xbfBgi\xfb\xe3\x0f\x92\xc6\xfa\xf8\xd2\x1b\xe4C\xb8\xa3\xfb\xba\xe3\x94\xf8\xfa\xae\xe3\x8c\xf8Z\xfd\xb0X\x93k\xb5\xf2\xa2\xdcc\xac\x81\xa0f\xb2H&\xe8\xcc\x12/[\xf9\x19\xb6-\x1d\xcdy\xf9r?^SB\x1c\x8b\xee\x1bzs\xa4(<%\xaac\x18\x11\x9a.J\xa3e\"\xcbB\xd3\x1d\x0f\x14\n\x84|:\xb4ґhxj\xc4ꌤ*h\x8b|+\x15!\xcbFbD^\x98^\u007fN\xd6\xc0\xbf\"\xd8\xe9\xf14\xa1&\x8fG=\x90\xfb\xb4\xf6\xe1ݧ\u07bfq\x9d~\bKt\xdb\xc3\u05ff\x14\xa9\xdd)\xc6\xd5\xfbI\xcaq\x87t\xc9\x18\x93.Ij\nu.\x1cut\x01\xe32+\x11\xf0X\xb6ܧה\xa0S3%F\xde\x1c\xa9\nO\x89\xb2\r#\x82{.\xd0\xf0¾\xf4\xb9\x00\x96U\x84\x02\xf9\xd2O\x17\xd7ӑh(\xaf*U\x81b\b\xa6\bu\xac,\f0\xf0\xaf \xb0F|\xd7N=\xb3ڱ\xfc\x97\xeaV\xf4qGd\x01\xd1\xeaC$e\xd0!ݐ\xe9e\xac\xca\xebEm\n\xc3\xe50\x81\x9aLz\x17\xa9\xa6\x98~\\V&%\xb3J0\x9aȊ\xe3\xdcR\x12\x9e\x12e\x1bF\x04\xf7I\x12\xedO'\x89\x86ĸ\xa2\xb0\x9f\xe2\x0f\xa7\xd2[\xc1T\x8c\rVu^=\x89\x06\xacM\x8c\xd0xb\x95\x85\x81\u007f\x05\x81!\x84w\xf7\x8b\xe2\xbcvf\xd1q\xf2\x81\x1e\xf8ԧ\xa4\x15}\x97BZ\xce\xea\xddd\xd3)\xb9\x15m\xb2h\xe7\x9dkl\x02vF\xaa/\xe3+˕\xbaS\r9t\x9c\xb3D\xbe^\xb1J0\x92h\x1c疒\U00014a04\xc60\xa2S\xee\xe8\xa6\xcd,\xb9Bv\x1dҽ\xf8\x8d\x9bɫ]\xec\xea\x8d\xd3\x04ҟ\vV\xc4)Q\\sGP\x1bNL\xa2\x06\xfe\x15\x84K9\x9a1\xe3!\xc7y\xf2V\xbf\x8b\xbe\xd6c\xfc\x19\x19\x80\x9e\xa7\xa3P\xbc\xff\x97\xe2K\xf5r2\x16}\xb8\x9ef\x0f\x16/\x8c.\x01\xfb-\xebq?j\xcaP[,\x0e\xcc*\xbaD\xfcM\xc9=Or\xf2\x97裼\xec\x12\x985S\x12ǹ\xa5$\xbc%\xca0\x8c\x10\x0e\xb6\x0e\x8d\r\xb5\x1eL\x97\xe9\"\xa1\x87\xce\xddJ\xa3\xc6\xf5\xe8\x81\xd6v'\xa2\x97\xa5&\xeb\xf6\xb6y\xd9\xe4\x94+m[6W\xa2L\xf7\xb0\"\xaf\xcfkq\xf6\xe0~\xa7\xc5\x1b=\x17\xf9N\xc6\xf6\xa80\xa6\x8d\x84>\x86\xfe\x15:\x1cr,>\xf4\xfa\xeb;\x1d\x83\xf4C\xf5\xf1\xd7\xeb\x17\x93C\xef\xbfk\xdb\x191\x95N\x179֝9\xb5z\xe9\a4\xfb\x0e\xa4}\x8cj;\x1a\xc1\a\n\x83VU;x,k\x96\xc7\xeb\xf5:\xf3\xc5x\xa3\xa5\xa1c\xbb\xad8\xa0[\x82\x01\x13=7\xf3\xc3[\xa2,\xc3\b\xa1\xf7\x88\xbb\xad7m\xfe\xb2\x03\x92\x0f\x85\xdc\x0et\xd8m\xb9v\xe9&\xb0P\x97\x9be\xa7&\x81#\xf6\xac\x9c\xaa\x8d\b\xd5)\xf2։\uf5a1l\xf1\xb5.\xbaĆ\xafw\xab\xc3\t\xdaH\x9cDF\xfe\x15lN\xd5\x1f\xaa\xad~\xb0\x9e*\x14_\u07fdtQ\xbd4\xe6<_\xbf|i=m`\xabw\xef\\Z\xbb\xed/4՛\x15\xbe\x8f\x1b\xe1\x0e\xb1\a\xe1\xb5x\xd4\xf3\xb1\xa1\x19hڻm\x9d\x9dU\xd4\x10\xd0/\xc1\x80\x89\x9e\x9b\xf9\xe1-Q`\"<fie\x84&B\x9a.\xa2\x1c\xb48\xb5W\xdbqtD\xecAU\xa2\x15\x9a-\f\x98%L_@\xa2)\xc1\x8e\xfcqFh\x1e\"\x12\xf5\xcfb\xfeL\x85\xdeX\x12މgFP\xa7\x84i\vH\x14\x98\x04\x14\xad(0ɀD\x81\x9b\xe6\xb3\xc1\xea]\u007f\xb8a\x94\v\x98\x18 Q\xe0\xa6\xd9\xe5p8\x18\x0f;\x01\x93\x02H\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\xcdt\x96h\r\xb2\xad\x1a6\xca\x04\x00\xc9e:K\xd4\xd7\xe9.\xb6Mh\xd1K\x00\xe0\x06w\x892\f#\x82\x03m\xfbڒӜu\xa5\xe1Z7@z\xc1[\xa2\fÈ\xa0\xc7\xdd?ڷ\xa7/\xe6~SD\xaf\xc1\xba\xce\x00\x90lxK\x94a\x18qa\x0fY\x85\xe1\x9d=\xc9\xe8r\x82D\x01\xb3\xc3Y\xa2,\xc3\bO\a\xdd\xd4\xd2\x17c\xbf\xa9\x02$\n\x98\x1d\xbe\x12e\x1aF\xc8K\xea\xb6\x1f\xd3\xdfo\xca\x18\x88\xac\xf4\x0e\x00\xa6\x84\xafD\x99\x86\x11\xdd-t\x05@\xf7\x91X{N\x11\x82\xad\xb2{,\x9e\xa5\x00\x00 Ip\x95(\xdb0\"\xe0\xf6\xf8\x05_\xbb+)k\xf2\x1cC\b\xddc\x94\t\x00\x92\aO\x89\xea\x18F`\xbf\xc7\xe5r\xf5x\x92a\x9f\x1e\xb0\x15\xee\xe8\xd4u\t\x01\x80\xe4\xc3S\xa2l\xc3\b\x82\xe0\x0f\xe2\x96Wc\xed;E\xf4\xa2\x93FY\x00 \xa9\xf0\x94(\xdb0\x02K\xbe\x92#\xaed\xb8\xcd\xc1\x8c.`vxJTBc\x181\xec\xf2\x8bb=\x90\x94\xa9U\x90(`vxK\x94a\x18\xf1\x8e덱\v-\x9ed<\xb9`\xe4\xe4\x03\x00I\x87\xb7DY\x86\x11\xfd\xadnO\u007f\x12\xee|\b\xbe\xfe\x1ak2\xba\xd7\x00\x10?\xbc%j&\x96 T\x90\x8cid\x00H\x80\xe9,Q_\xff\x18\x06\x00\x933\x9d%\n\x00)\x00H\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rw\x89\x86\r#0\xee\n\x99DD\xbc#\x00\x00P\xc3[\xa2a\xc3\b\x8c\xc7]\xd2*\x80\n\xef\bs\xd0\xd9o\x94\x03\x00\xb8\xc1[\xa2!\xc3\b\xb1\xe9l\x95%\xaa\xf0\x8e0\a\x155F9\x00\x80\x1b\x9c%\x1a6\x8c\xc0]\xae\xae}\x92D\x15\xde\x11\xe6\xa0l\x99Q\x0e\x00\xe0\x06_\x89F\f#\xb0\x10\b-w\xad\xf0\x8e\xe0\xca@&B\r#\xab\n\xb2\xaa\xc8%\xa2\xa52\xbbhm@l\xe6\x91D\x19\xc6u(\xa3\x05\x8fZP\xb1*o\x1d\xb2\xb8\xd6\x16eW\xa9;旫\x1d\x8e\xfd\x1fm{xѦ/\xd9G\x03\x80\x89\xc1W\xa2\x11\xc3\b\x82,Q\x85w\x04W\x84\xd6\x03\x05E9\xf9kW QmΌ:O\xb3\xad,\x88\x03\xdd\xde\"\xbb\xd7\xeb\x15\xdbt\x9f\xd7҄q\x8fӪ\xca;| \x13ٚ\xb6\xe7ܧ*\xec\xfa\x993\xb5\xab\x17\xd7\xee\xdevק:\x87\x03\x80\t\xc1U\xa2\n\xc3\b\x82,Q\x85w\x04o\xca\xd0<\xb1F\xb4\xedtc\xb2d\xe7A\x9a\x1a\xee\xe8ZE\x89\xe2&\xab:/\xb6抚^e\x8b.\xecqG\xfd5|\xe3Zt2\x00\xdc\x14<%\xaa4\x8c \x84ZQ\x85w\x04gʬrw\xf5\x81B\x81\x90朗l\x89\x86\xf2b\xab3\x92\xaa\xe0\xf1jh@\x81ɇ\xa7D\x95\x86\x11\x84\xd0XT\xe5\x1d\xc1\x95\xb2\x8aP \x8f@\x97\xd0\x0fl\x89\x86\xf2\xaaR\x15<\xbe.:\x05\x00n\x1e\x9e\x12U\x1aF\x10d\x89*\xbd#8\x13\x16\xe3\x8a\xc2~\x8a?\x9cJ\xef\xd3R16X\xd5yu%\xfaLt\n\x00\xdc<<%*\xa1\x19\x8b*\xbc#x\x13\x96]\a\xa2։\x1b7\x93W\xbb\x1d\xe3q\x9a\x90\xfd\xa4X\xbd\n\x90(\x90DxK4l\x18!\xf8|\xeeN\xdf8I\x8bxGpE\xe8\xa1s\xb7\x92u\xe1z\xf4@k\xbb\x13\xd1\xcbG\x93u{ۼlR\x9fJ͕ۖ(\xd3=\xac\xc8\xeb\xf3Z\x9c=\xb8\xdfi\xf1*\x9fY\xfc\U0008f0eb\xeb\a\aa4\nL6\xbc%\x1a6\x8c\xe8\x93F\xa5\xd4\xc9%\xe2\x1d\xc1\x93\x81\f:\xfc\\(}\xea\xb0\xdbr\xed\xd2\x1dZ\xa1.7\xcb\xdeK\xa2\x11{VN\xd5F\x84\xea\x14y\xeb\xc4w\xcbP\xb6\xf8Z\xa7(첃\xb2\t\x03\xc0\xe4\xc2[\xa2\x00\x00$\x04H\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00L\rH\x14\x00LM*H\xb4\x06\xd9V%\xe1Ǥ\x00`\x06RA\xa2\xbeNw\xb1-`\x94\v\x00\xd2\x12\xee\x12e\x19F\xa8B&]h v\x06\x00HSxK\x94e\x18\xa1\n\xd9\xf4\xa2\x9e\xd8\x19\x00 M\xe1-Q\x86a\x84*\xd4\x01$\nLW8K\x94e\x18\xa1\f\xf5\x00\x89\x02\xd3\x15\xbe\x12e\x1aF(C=\x06PW\xec\f\x00\x90\xa6\xf0\x95(\xd30\"*d\"\xd8*\xbbǒ\xb0D \x00$\x1b\xae\x12e\x1bFD\x85l\x8e!\x84\xee1\xc8\x03\x00i\bO\x89\xea\x18FD\x85L\x02\xb6\xc2\x1d\x9d\xa3\xb1\xf3\x00@:\xc2S\xa2:\x86\x11Q!\x93^t2v\x06\x00HSxJT\xc70\"*d\x023\xba\xc0t\x85\xa7D%&4\x16\x05\x89\x02\xd3\x15\xde\x12e\x19F(B=z@\xa2\xc04\x85\xb7DY\x86\x11J\xef\b\x16\x82\xaf\xbf\xc6\xca\xdfP\x02\x00\xcc\x00o\x89N\x84%\b\x15\xb4\x1be\x02\x80\xf4$\x15$\xea\xeb\xe7\xee\x9a\x06\x00f!\x15$\n\x00\xd3\x18\x90(\x00\x98\x1a\x90(\x00\x98\x1a\x90(\x00\x98\x1a\x90(\x00\x98\x1a\x90(\x00\x98\x9a\xff\x0f5\x16\x1d\x16\xa8\xc9g\xc2\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/callers2.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03\xfc\x00\x00\x01\xb0\b\x03\x00\x00\x00#z\x9e\xf7\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x04\x06\x02\a\t\x05\n\v\x15\a\x0e\x10\x0f\x11\x0e\x0e\x12\x1d\x15\x16\x15%\x19\x10'\x1a\f\x1e\x1d\x17\x16\x1e.!# #$\"$%#%'%'(&)(\"()'-+ *+),-+-.,12053'O.\x0f352786<:.9;8=?<B@4#Cxb<\x1aAB@j=\x11DFCLH9\x00f\x00\x00g\x00\x00h\x00\x00i\x01JLI\x00j\x02\x02k\x03\x04l\x050R\x95OPNVQ@\tn\a\fo\tRTQ\x83L\x1d\x0fq\v\vr\x17UVT\x0fs\x18WYV\x11t\x19_ZH,`\xae\x14v\x1b7]\xad>]\xa1Z\\Y\x16w\x1d\\^[\x19y\x1e:b\xac_a^Ya\x8bac`\x9aZ\x1d*{!@f\xb1Ke\x9e(|*dfclfP+\u007f,fheMj\xaf.\x81.Fm\xb1ikh0\x8301\x841/\x859Jq\xb5mol\x89j_oqn;\x86:>\x88<\xb3h\"{s[Vu\xb5sur?\x8a>@\x8b?uwtB\x8c@@\x8dG\\z\xba\xadq?y{xJ\x8fI^~\xb8L\x90K\x94wq\x85}d~\x80}O\x93Nb\x83\xbdN\x95U\x81\x83\x80W\x95V\xa7|e\x8e\x85gm\x87\xbcZ\x98Y[\x9aZ\x87\x89\x86]\x9b\\^\x9d]\xba\x82Z\\\x9ddr\x8d\u008a\x8c\x89\x96\x8cnd\x9ddf\x9ff{\x90\xc0\x8f\x91\x8eh\xa1h\xe3\x83+ЇK\u007f\x93\xc4j\xa3jz\x97Ɠ\x95\x92s\xa4l\xa0\x96wq\xa5s\x81\x9aė\x99\x96\xe4\x8b@u\xa9w\x9a\x9c\x99\x86\x9eȜ\x9e\x9b\xef\x904~\xaby\xa8\x9e\u007f\x9e\xa0\x9d\x80\xad|\xa0\xa2\x9f\xf9\x94.\xa1\xa3\xa0\xa2\xa4\xa1\x81\xb1\x85\xff\x952\x92\xa6ˤ\xa6\xa3\xb3\xa6\x82\xa5\xa7\xa4\x8b\xb2\x88\xa7\xa9\xa6\x8d\xb5\x8a\x8e\xb6\x8c\xaa\xac\xa8\xb9\xac\x88\x8d\xb8\x93\x9e\xaeΕ\xb8\x95\xad\xaf\xac\x97\xba\x96\xaf\xb1\xae\x98\xbb\x98\xa3\xb2қ\xbe\x9a\xb3\xb5\xb2µ\x90\xb5\xb7\xb4\xa3\xbf\x9d\xac\xb7Ң\xc0\xa4\xb7\xb9\xb6\xb9\xbb\xb8\xa5ħ\xb1\xbc\u05fb\xbd\xba\xa7Ʃ˾\x98\xbd\xbf\xbc\xa9ȫ\xb8\xc0կǫ\xbf\xc1\xbe\xc1ÿ\xb2ʮ\xc2\xc4\xc1\xbd\xc5\xda\xc4\xc6òͷ\xb9̸\xd6ǝ\xc7\xc9ƻκ\xbcϻ\xc4\xca\xd9\xc9\xccȾѽ\xc0ӿ\xca\xce\xde\xcd\xcf\xcc\xc4\xd0\xde\xc8\xd3\xc1\xcf\xd1\xce\xdfѥ\xc7\xd6\xc9\xd1\xd4\xd0\xd2\xd3\xdd\xca\xd8\xcb\xd3\xd5\xd2\xce\xd6\xdf\xcc\xda\xce\xe7\u05eb\xd6\xd8\xd4\xd4\xdb\xd0\xd8\xd8\xe3\xd8\xda\xd6\xd3\xdb\xe4\xda\xdc\xd9\xe6ݯ\xd7\xde\xd3\xd5\xdf\xda\xdd\xdd\xe5\xdc\xdf\xdb\xd7\xe1\xdc\xde\xe0\xdd\xf0\xe0\xb3\xdc\xe1\xe4\xdf\xe1\xde\xe1\xe3\xe0\xe3\xe5\xe1\xe1\xe6\xe9\xe4\xe6\xe3\xe8\xe5\xea\xe5\xe7\xe4\xe6\xe8\xe5\xe4\xe9\xeb\xe7\xe9\xe6\xef\xf2\xee\xfe\xff\xfc(t:\\\x00\x00 \x00IDATx^\xed\xbd\x0fp\x14G\x9e\xe7\xbb\xcc{\xbe}ϯ\x84zf$\xf5\xae4b\xef8M\xb4BB\xc7\x19\x9e%`\xd7z\b\x8b\xf3\xc2C\x1b\x02\xc1\x03\x9d\xe1\x16\xc6\xd8\xf3\b\xb3+0\xecB\x888\x9be,\xeel\xe4\x85~\x92\xb5\x1e\x99\x91X\xd9 \xa2ό\xa4\xc0\x9a6 ,\x06#\xd9H0\xd8\xc6\v\xde\x18\xf5\x10\xb6\xc5ȱ\xf66a\"\xda1\xd1\xe4M\xbcʪ\xee\xaa\xcc\xea\xcc\xca\xeeVw\xb6\xd4\xf5\xfb\x04!\x15\xa9\xac\xac\xac\xac\xfev\xfd\xe9\xea\xfa\xfc\xc1\xef\x93\a\x01\x000{\xf9\x03Q\xc2m\x10\xb5\r\x00\xc0\f\x06\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0fd+aQ\x05\xa7\x03\xe1\a\xb2\x92@c\xa1\U00084a12Á\xf0\xf7.\x9e\x14U\x91I\xc2ݙZ\xdc+\xaa2\xa3\x90\xd3\xdfpI\x89w  \xaa\xe5p\xe4\x86?\xd0w\xbc\xbd\xfbB\x10O\x06/\xbc\xd1\xfe\x86>I\x94\xf2\xf8\xd7#kk\xf7=\xb0\xab\x11C\xb3\x92\x8b_e\xbe<\xa5ٮZ\x8b\xfd\x9f\xd9\f\x14\xfaDU\f\xa6\xb6\x15歈\xfb\b4\x89\xee\xb4\xe4\x1c\x14U\x91\x8b`t\x92\xeeo\"\xa3~U\xe9\x13U\x01\xa4\x86\u007f\xd2\xeb\xbb\x11\xb8q\xf2\xb8\x9a\xf3`\xe7I<\xd9\x19\xa4J\xb9\xecn8\xfbR\xed}\x9b\n\xb1L\xd5\xe7-U\u007f-ͫ\x9f\xb2\xa9՚\xd3a\xf3W\x1e\xbe\xfc7DU\f\x96\x16z\x1b\xf3l\xdf\xd9\b\x92\xea\x8eon\xab\xa8Jz\x18\x1ce\x16\x8bFG\xd8\xdf$\xdb%\x19V\xfc\xa2*\x80\xd4\xf0\xdf\xf6\xe2\x03\xb1\xa0\xf7\x06B\xfe\xee\x90:\x19\xea\xf6S\xa5<\xeeW\x9fA\x0f\x12\xcb>BM+\xd4\xccM\xe5\xadh\xb2\xa9s\xdbe\xf7W>q\xef\xc9єҊ\xc2\xf1f?\xc9\xee\xecqe\xe6\x00wa=\xbb\\4:\xa2\xfe&\xdb.\xc1\xb02$\xaa\x02H\r?\xd2B0\x89\xc3>\xa0\x9f\xf8\xf5\x0eP\xa5<>\xab~\x97\xffG\x1eM\xf5K\xbbP\xe7\xf2z\xbb<5\x16ś\xcbd\xb9\xa9\xc4\u007f\xac\x9alw\x82E\x8d\xa2*i\xa1\xacNT\x83\x8d\xa8\xbfɶK\x00\xe1\x8f\x03\xb9\xe1W\t\x05\xba}\xea;\xf8T\xe7\xe0Th\xca\xdf9E\x952\xf9vm\xb5\xc61\x84\x8eTW\x9fC\x9f\xd5Voœ\xb5g\x8fm\xad\xdd\xf7[\xad\xceg/\xac\xadm\x88LGi\xaao\xadC+\xbc8\xfc\xc1\xba\"W\xf1ʫj\xe16en\xeb\x93\xc5\xee\x957\xb5*\xa1\x02\xed\x9d!T\x98\xdbT\\4\xb8\xdd]\x15\xe4\xd4%g\v\xe6)J\xceq\xa4U\xc8\xf5\ue61f\xb7\\{ۚZ\xef.ޱÝ\xdfMt!\xe4V4v\xe0\xba9\x9d\xea\x9e])\xb1̆n\u05f9s\vW\x04\x88\ue82bs\x15e\xcf\xcd\xf5\xf3\U000961f8\xb3u.Ο\xbf#\xfaV\xb1'/\x84(\x12n\x81\x81\u007fyq\xae{E1\xafԧ\xaf\x9aRF--\xbeщ\xe9o\x8a\xda5\x19\x84\xf0\x8b\x91\x1c\xfe)\xaf\xd7ۡ\xbd\xe0B\x03\xead_\xc8R\xca\xe4ӱs\xd5=cc_\"\xf4۱\xda\x1e\xf4`\xecH-B\xb7\xce\xd5V7\xf4\xf4\xac~\x01\xd7\x18\xab}\xb6\xe7J\x8fzn@\xd2T\x1fȟ\xfa^\x00\x87ߧ<9ؽ2g\x18\xa1\x1b\xc7\xe7*\xc5\a\x9b\x8b\xf3\xc6q\x95QeP\xab:X\xa0\xecX\xaa\xb8\x0f\x16\xb6p\xeaR\xb3]\xf6\xfb]\xdae9\\Z\xd8\xdcR\x80wT\xa1\x92\xa2\xd6fW^\xfb\xf2\x16\xb2\x0f\xef\xfb\xbb\x94f\xbf_}\x9d\x06\xfc\xb9\xea<C\x8d.z64\x98_\xd62Ь\xb4\x90\xdd\tu\x1f/\x9e_P\xbcc\xbd\x12\xe0\xcd֘\xb3\xdd\xd7ZX\x16yü`}\xa9'\xdcB,\xc3\xca\xfa7\x06\xbcn\x85\x8e\xa9Y\x1a\xbc\xe0\x9f_\xe5\xf7\xfboPK\x8botb\xfa\x9b\xa2v#\x84&\a\x17\xba\x93:\x86r\x16\x92Ï&\x03\xe3\xdd\xf8\xd2^h\xa0\xfbF\xe0F\xf7@\x88*\xe5a\x1e\xf6\xab\xe1G\xa8\xa7V\x9b\\\xad\xee\xe9_lP\xa7\xbeݴ\xef[\xf5\xe79\xfa\xaa@S=*۶\x10i{\xfen\xdcx\x99\xf6\xb9\xafk\x1e\u07bd\x17/\xc6\xd3>\xe5\xb6^\xb7h\xbd:\xedC\x8dOr뒳!\x94\x17\xb9&\xefr\xab/\xcb\xf5\x85\xeaT\x97\xa2\x1e,\xb4*\xe3Ȃyد\xbdt\x9b]\xf4l\xa1bu\xaf\xa6\xbeʵ# \xa3;\xea\xf2\x95\xa5A\xfd\x84\x889\x9bO\xc1\x17\x06\x87\x95.\xbdv@\x89\xbd\x14\x96X\v\xb1\xb4\x16\xe2m\xd3\xea\xa6\xdf\x1d\xa8R\xe2\xf0\xdc\\\x1a\x8actb\xfb\x9b\x9av#<\xa1\x1e8$p\xb2\xe5Xd\x87\x1f\xe1W\xfa\x80y\xc1\xef\x02Uʃ\x1d\xfe\x97\xa2\x93W\xaa?e̤\x86\xbfE9\xa8\x85\x1fM\xb5.\x9fW\x80\x8f$\xd5W\x8evhݪ\xe0\xb8\xf5\x1a\xe1\xefBCJ\x10\xcf«K\xceF\xbc\f\xf1ɫ\x96\xab&7\xc2I\x8f\xf9\f\x9b\x1d~c6\x9f\xf2\xbeY\xb7\x97\b\xbfqM\x8c9[\xfd\xbc\x10\xa68r\xee\x1c`d8\xb1\x16b\t\x14\xcd\xdb\xe6}?l9>\xa7Jɐ\x92\xd7\xf0\x84\xa3\x13\xdb\xdfԴ\x1b!\xd0\xe7-\x81=\xbf\x18\xa9\xe1\x0f\xe9{\x91\xab\xdep\xb8]\u007fͿ\xdf\x1e&J\xb93\xb2\xc3oL\x9e\xa9\xfe\x961\x93\x9a\xe4\xa9\x1d\x93Z\xf8\x87\v\x8b\x9bN\xfa\xab\xf4@k\xaf\xa0A\x05\u007f\x9c4\x14=\xfc,\xeaC\xc3.m\x16^]r6\xe2eh\xe4\xaa\x05\xbf-\xf4Ż\xe7'f#\xd2etG}їE\xa7\x98\xb3\x95EN\x8c#\xf7\xb0\r+ƛ\xa8Ab-0\bz\xebJ\x94B\xeax\xdaRJ\x86\xd4X\x1a\x8act\x18\xfdMI\xbb&~e8\xa6\f\xb0 3\xfc\xe1N\xfd\x94VM|4\xfc\xa3\xea\xa4Yʝ\xd3\x12\xfeW-\xe1\xbfR}\x8b1S\x93\xfe\x81\x11\x0e\u007f\xc9b\xbc\x1f\xa8\xd3\x03\xbd\x1d\xff\xf4*\xb8$芼\x9c\x88\xf0s꒳\xb1^\x86\x81\x9c\x15\x81\xab\xf3\x17Ǭ\x83%\xfc{,\x19\x1cP\x88ϴ\x8d\ue42f\u007f\xe6l\xeb\xe7\x8djD\xae\x976\xbbb\xf7s\x89\xb5\x10\xcbe|\xa8\x13\xecʣ?\x93\xa7J\xb5E\xb4\a\x8c\xc9(\xc2щ\xedoj\xda5\x81\xab\xfdq 3\xfc\xe8\xb8vוv\x80?\x189\xec\x1f\xa4Jy\x10\xe1\u007f\x15\xa1\a\xcfZ\xc2\u007f\xbfa7\xde\xf5\x1f;F\xcdD\x84\xbf\x18\xbf\x84\xc2\xfa^\xc4U\x88O\"\xe7U\xe9\u007f\x9c\xa7\xbfn\x88\xf0s\xeaR\xb31^\x86\xa3J\xa1\xa2T\xc5~\\i\x86?O\xedHx\xa1%\x83\xc1\xa2*<\x10۵\xb7\x16\xa3;䋞9[\x9f\xa2]\xdeޣ\xdf+\x17.Y\x81bH\xa8\x85\xdb\xcd1\xf7\xd54\xeb\xf7\xc8Um\xe3\x97V\xa9\xa31\xa9\xb7#\b)=:\x8c\xfe\xa6\xa4]\x02\b\u007f\x1cH\r\xffM\xef\x00\xbeʧ]\xf0\xeb\xea\x1e\x0f\x8cww\x85\xa8R6\x91\xab\xfd\xdaݽ\xbb\x1bzz\x9e\xad\xae={\xeb˱\xda#c\x0f>=R\x8b?\x05\x18\xab\xddz\xf6ʱ\xea\xb3\xe4\\S\xf5ڋ\"PU?\xa5\xbe\xb4\xeaZ\x0f\x96)\xee\x96!\xf5\x95\xa3\x94u\xb7\xcfw\xebg\xd77s\xb4\x03\xcd\x1b\xee\x96`W\xee\xd5 \x9e\x85Sל\f\r\xf9\xfd\xaeF\xbf?\x88\xaf\xe07\x0e\xa1\xd1\xc6\\\u007f\x00\x8d\xba\x06|\xfe\x80u\x17\xa4_\xed\x1fҊ\x17\x17\x1e<\xb8X\x99\xdbq\x83\x9c\r\r~\xaf\xc4\xebۮ\xb4\x93\xddQ\x97\x80/x\xeb]d\xcf֤\xd4w\xf76*\x9dZ\x95\x16\xc5\x1a\xddD[X\xa9\xe4[\x87\xbfY\xc9o\xf6\x9dl\x8c|\x00\xc1,mv\xb5\xf4.\xcd\x0fPK\x8bgtb\xfb\x9b\x9av\t.3N\x84\x00\vRÏ\x02\x83\xdd\xed'\x87\xb4\xb3\xdc\xd0\xf0Ɏ\x93\xc3!K)\x8boWk\x1f\xf3\xd7\xfe\x06\xff\xe7\xb3ݵ\xab\xf7\xbdZ]}\xe4\b.\xfa\xb4V\xfdyD-\xfe\xcd\v\r\xab\x9f\xa5o\x04jV\x14|]h\x9b\xa24\xa3p\xcb|Wa}\xc7<\x97\xbaKq\xedh,(Z\x1f\xddY\xec\xf9\x9e\xfa\"\t\xab\xbb\x8f\xe3\x05J~7>\x05\xe6\xd45'\x87s\xf4\xb3e/n[\xc9\x1d\xcfW\u007fnC\x17\\\xb8,\xb7\x8a:\xfd\x8c|\xce?W\xbby\xf1fU^\xc1\xf2&\xb5.9\x9bZ\\W\\\xb0\xf0$\xd9\x1dtU_\x82\xbe{\xe4\xcc\xd6W\xe5v/\xd6\xf6\x96ȟ\xb7\x03YH\xb0\x05Ԟ\x1fs\x8e\xdcY\xd5\\\x9c[TEg\x9f.\rmw\xe7U\r\xd3K\x8bct\x18\xfdMI\xbb$\x93s\xeb\xaeN2\xde\x14\x00\x02\xb9\xe1\x9f\t\x98\xe7\xd5\x1a\xdb]\xd6\xfbC\b\x88\xba\x96٬L\xe6o\x9b\f\x85\x82\xc3uӼ\xcal\xdb\x1d6]\xaeF\xee\x1bg\xdc\xf4*\xd3\xeb\xb7=\xd4褤\xbf:6\xa3\xde[bw1\x13\xc08>\xfc\xa8\xa5\x98\xff\x1d\xda\xf8\xc3\xdf\x1b\xf9<<\xec\x9e\xe6\a\xccv\xdda2U\x94\xe4\x97\xe4\b\xc2\x1d\xee'Eu\xa6\x039:\xa9\xe8o\x14\xdbQ\x9f\xbcʸ\x16\x00\x10@\xf8\xed\x88?\xfc\xa39\xfa\x91\xe7x\x0e\xf1\xb9\xfd\xac!\xe0ޑ\xaa\x9d1\x93t\x8dN\xba\xdau\bN\v\xbf~\xb5(>\x88\xba\xc2\xd9\u008dyOv\rv=\x99\x97\xd6=\xe8l%]\xa3\x93\xaev\x1d\x82\xd3¯]-\xba\x8d₨\x1b\xc7l\xbe\xe5E\xae\xa2\xe5\xd3<\xe8\xcfZ\xd25:\xe9j\xd7\x118-\xfc\x00\x00D\x80\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\xa3\x03\aX\x93\x00\x90\xed\xc8\r?[ץ2\xee\xcd\xd8MZ\xff\xecy\x991\xa9\xf1\x91G\xe7z\xccL1\x1c\xf0x\xfaEuf\x12\xa9\xe9\xef\xc5\xcawDU2@j\xd6M̝R\xcf\x1aQ\x1d\x9aSt\xcf2=|R\xc3\xcf\xd6u\xa9\x04\xdb/t\n\xe6M\x1b{\x17\xdceLj\x84?\x189\xe591\xf2\x81͗^.}\xa8\xff\xbe;R\xdaƯ\x958\xd1vSM\x92\xfd\xe5t\xe7|\x85\x94\x94%H\x82\xeb\x96<\xd7\xf6\x97\x8b\xaa\xd0\xdc\x1b\xd9H\xf6,\xd3\xc3'5\xfcl]\x97\x8ao \x90\xa9\xf0Ox~\u00984\xb8\xe6\xf9 \xa6\x8c\xe4\xff\xd9\x15\x9d*O\xe9\v\xcel7\xb5$\xd9_^wf\xe8\xe32\x12Z\xb7iЖ`\xf8\x11\xdaI\xf5,\xc3\xc3'5\xfc\x1c]\x17\x1a\xef\bf,\xfc\xfb\xcb\xef2&\rD\xe1ߐ\\\x98\x84lHS\xf8\x93\xeco\xba\xba\x93&\x12Z\xb7i0\xdd\xf0g\x18\xb9\xe1Wa躂\xed7Q\xa6\xc2\u007f\xa7\xf4\x10c\xd2$\x12\xfe\xe7=\xa5\xa7\u007f\xb2\xaa\xe2\xa9ϩ?\xbe\x13\xb9&\xb0\x01\xff\xa7\xfc\xb0Y\xe1\xe7\x9b+V\xfd\x84>Yh\xf3\xe0\xf3\xbd~\xf5\xe7Q\xf5\u007f\xa76T\xac;\xa5\xfe\xfe\xa8T\xfd\xff\xc4ޚ\x05O\xabc2\xf2TMi\xe535\x96vI&vU\x96.yF}\x8b\n\xeeZVZ\xb3\xf3#\xadИ\r1\x17L\x90H\u007f\xd9\xdd!\xfb{\xaf\xc2\x139\x85\xa5F\xe7뽕\x8f\x1d>\\i=\xa2et\x9d=\xa8D\v\xd4\xe8\x18cF\x8fd\x14\xaa\x94\xb5n̥\x85\x97\x94\xbe\xf2زK\x87\x16m\tZzv\xe2\xc0c\x8f\ue720&\x119Pw\xf7.[\xb4\x8b{\xd8\xcfiW\v\xff!\xb5\x8f\v\xbeNp\xf8҂\xe4\xf03u]>u\xf7\x9f\xa9\xf0\x1f(\xfd\x9c1i\x12\t\xff?\xf7\x97z*\xdbN<B\xef\x00\x83\x1f\x8c\xac\xda2222\x81\xffS\xeeY\xd3\xff\xce\x12\xad\xc2~ϡ\xf3'*7P\au_=\xb7y$\xa8α\xf9\xb9\xaf\xf01\xc6\xd1\xf3G\xcb\xf7\xaa\xa3\xd0\xdf_\xb3\xea\x91\xc7~\xb2\xd7s\a]\xf7\xec\xed\xbfx\xba\xd2\x13\xa6\xdb%x\xafb\xc3\xeb\x17\xdb<'ԳEρ\xf7\xfawz\xae\xa9\x85\xe6l\xec\x05\x13$\xd2_vw\xc8\xfe\xa2\xeb##\xfa.\x96\x1c\x9dКe\xa7\xda\xca+N?u\x82j\x8d\xd5u\xf6\xa0\x12-PK3ƌ\x1aI\x03\xaa\x94\xb5n쥽\xb7\xc8\xf3\x93\x1fy*_[\x12ӳ\x9a\xd7\xdaj*>!'Ɂ\x9aX\xb4\xea\xf4;Oy\xb8{~v\xbbZ\xf8\xef\xee\xf5\x9c\xd06\\\x02×\x1e$\x87\x9f\xa5뺁\xdf\r2\x14\xfe;\xa5\a\x18\x93\x04\xc6a\u007f\xf9\"\xf5\xadao\xa5\xf5\xef\xc4a\xf4\x92\xaf\xd5W\a\xaep\xde\xf3\x966'\xfd\xe6\xfd\x96~ex\xdd\xcf\x11\xba蹈\xf0\xcf\xf3Z\v\x9e\x1f\x05\xb5\x13\xa2S\x95\xda\xfemQ\x98n\xd7$T\xf3t\b\xe7\xef\x1e\xfe\x81\xdf6\xd7\xedD\xd4l\xec\x05S\xc4\xdf_^w\x8c\xfeb\x16D\x8eb\xcd\xd1\xe9\xf7|\x84\xafj\u007fB\xb5\xc5\xe9:{P\xa9\x16\x8c\xa5\x11cF\x8c$\x01Y\xca^7\xe6Җ\xedU뼃\xf6\x1f\xb0\xf4\xacF]潚\x8d\xd4$\xd1\xd8\xe6Uj\xdd\xf0:\xfea?\xa7]5\xfc'\xca\xcfG+\xc5;|iBv\xf8\x11\xb2꺂\xed7\xc2\xe1p\xa03\x9c\x89\xab\x1fϗ\xdeaL\x12\x98\xe1ߏX\xe7xD\x98\x0eD+\xecz<\xa4\xaeQ\xf8\xb1\xfdT͏<\xa1\xd0[\xf7\xc2\xe5\xea\xc6ݿN+Y\xa3U\xd8P\x1eY\xee\xe7\xcbj\x9e?\xfdQ\xc4X\xc5\n\xffy\xcfG\xc6\xf4ק\x9e~|\x91g\x1d=\x1b{\xc1\x14\xf1\xf7\x97\xd7\x1d\xa3\xbf\x18\xe3\xd5k\x8c\xceˋ\x10\xbet\xfa6\xa2`w\x9d=\xa8T\v\xc6҈1#F\x92\x80,e\xaf\x1bsi\xcb\xfa\xd5m\x1cD\x87\x9fCtϴ\x0f}Oy\ue453fc\xf7<\xa7q\xe1Q\x9b\xf0\xb3\xdb\xdd\xd9v\xd4c~\xbe\x17\xef\xf0\xa5\t\xa9\xe1g\xea\xban{\xa3\xc8\u007f\xde\xe2\xdd\xf2\x03\x8cI\x123\xfcx;نߨ\xb0.r\x8e\xbc\x93\xaa\x19*\xfd\xe4\x84z\x06\xebQӴY\xff\xcb\u038dZ\vƙ\xfd\xbdӻ\xd6x\x96\xbc\xaeM\xb3\xc2\u007f\xc2c\x9c\x96_[Rs\xf8\xed\x91-\xeb\xe8\xd9\xd8\v\xa6\x88\xbf\xbf\xbc\xee\x98\xfdEī\xd7h\xec\x84\xe7k\xbc\x83\xb6\xec\xba8]g\x0e*Ղ\xb14b̈\x91$ K\xd9\xeb\xc6\\ڲ\x8b\xe8Z\xa9\x1a\xba\xe7\x18=C#\x9e\x0f\xc9I\xb3\xb1\xeb\x9e\x11\xc4hL\xdc\xee\xce%\x8f\xac1\xc72\xde\xe1K\x132\xc3\xcf\xd1uMM\xaa\x8cwLf\xe01\xeb\x87<\x13\x8cI\x92\xb8\xc2\u007f\xfa\x0eUa\xef\xe3\x1fj|MW]ӿe\xf3\x9a\xb7\xf1\xc1\xe9\xfeǵ\x82\x9a\xfdF\v\x98\xebx\x0fs\xaf\u007f\xc1)\xba]\x93K\xe6\xees\xcdFmO\xbf\x8e\x9e\x8d\xb3`\x92\xf8\xfb\xcb\xeb\x0e\xf5\xb6\x14\xfb\xea\xbd\xe3y\xfa\xceG\xab6[\xb6%\xbb\xeb\xecA\xa5Z0\x96F\x8e\x999\x92$D){ݸ\xe1/\xd7CJ\xf5L\xbb\xf8{Z\xddw\x13\x93fc_{\xb4a\xb1\xf9\x9c\x9f\xd3\xee\xce\xcaO\xee,2\xce\xe7\xe3\x1d\xbe4!3\xfc\x1c]\x97FF\xce\xf9\xef\x96\xefgLR\x88¿e\x8b:\xaf~FiT\xb8\xa8\x9f=\x1f}\x8d\xae\xfa\xdc\xf3\xa5\x17=\a\xf0\x8b\xf9\xbcV\xa1?r\xce\x1f}y\xb7ig\xb5h\xcb\x01\xba]\x93в-x\xd0\x0e\xa9/\xc6\x1a<Sx\xdd:z6z\xc1w\xda\xe8\xe3b\x8d\xf8\xfb\xcb\xeb\x8e \xfc\x1fz\x96x<[\xac\x9f\x99\xb2\xbb\xce\x1eT\xaa\x05ci䘙#IB\x94\xb2\xd7M\x14~\xaagK\xd4\xfe\x06\x1f\xdfBM\x12\x8dm\xacQO\b&\x16D\x1ac\f5\xa7]\xfcQ\xdf\xf9\xd2k\x91J\xf1\x0e_\x9a\x90\x1a~\xb6\xaeK%\x1c\x18\xef\bp\x95\x91i㰹\xb7?\xcc\xda\xf1G\xee\xf0\xbb\x16\xc27\x8d\xed\xbf\x86>\xdc_:b\xd9.m\xe5'\xde\xfeQ\xc5\xe7t\x85\x97=\xcf\xf5\xbf\xbd\xdfC_\x90B\xafU,\n\xafZ\xa0%l\xaf\xe7\xe5\xf3/{\xf6\xaaK\xb8\xa6]H\xd7v\xa9m\x9e\x8a\xb6\xf3\xeal\xef\x91\xedR\\Z\xb0\xe6\xd4\xf9C\xf8t\xb3ͳ\xeb\xd4k\x1b<\x95\xaf_\xa3f\xa3\x16\xbc\xd3Sq\x0fY\x89\xbf\xbf\xcc\xee\x90\xfd\r}02R\xbe\u007fd$H5\xf6Q\xf9\xa5\xf3#wc\xf6\\\xac\xaes\x06\xd5l\x81\\\x9a9f\xd4H\x12\x18\xa5\xecuc/\xed\x9f\x1e=\x11\xea/\xfd$\xf4ܖ\xcf\xc9AE\xe5\x9e\r\xfd\xa7W-\x9a@Ԥ9P\x9fT<\xd6v\xf4QO\xe9[\xff\x84[\x89\x1djv\xbb\xf7F6\xee\xff \x14ڹ\xec\xd2W\x89\r_z\x90\x1a~\x8e\xaeK-ǧ\xfc\xc7mfL\v_U\xeceL\x12\x98\xf7\xf6\x1fP\u007f\x96~\x82?\x99\xb5\\\x19\b\x1dzt\xc1\x96k\xc8R\xe1\xe2\x96\xcaE\x9b\x8dk\xba\x11\xae/:\x8a^\xaf\xd0\xde\xf4\xc3'\xd6U\xac;\x156\x96\xa0\x9d\xcf\xfe|s[M\xe9\xb2-\xefQ\xed\xd2L\xecz쑍ok\r\xac*\xaf\xdcuzU\xe9\x16z6r\xc1\xa7+<1\r$\xd0_fw\xc8\xfe^\x8f\x8c\xcei\xaa\xb1\x0fJqY\xe9f\xebY+\xa3\xeb\x9cA5[ \x97f\x8e\x195\x92\x04F){ݘK\v\xab\xfb\xd9\xfeG<\x15\xfdx)Ġ\xa2\xf2\x9f\xec_\xb4l\xaf\xf66AL\x12\x035\xb1\xf3њ\xc3o\x95\xea\x8d\xc5\f5\xa7\xddSxu\xae\xeb7#$6|iAn\xf8g\x16\xafx\xfe\x991\x99=\xbc\xed\x89\xdd\U000e76ef*\x0e|\x15\x0e\u07fb\xbe\xeb\xd1d\x97=\xfd\x16R\x01q\x8f`<\xb7\v\xa6j\xa8宼\x93ß\xdd\xdf\xe5\r\xbf\xb5(\x03+\xf5\xb6~_\x00\nWZ\x0f|\xe2e\xfa-\xa4\x82\x84\u009f\xba\xa1\x96\xbb\xf2N\x0e\u007fvs\xb7\x92\u007f\x9fo\xfa\xf80\xf2)\xd5'\x1e\xc6\xd5Ƹ\x98~\v\xa9 \xa1\xf0\xa7n\xa8\xe5\xae<\x84\x1fH%\xe1\xfd\x15\a\xfa\xdf\xeb?P\x91\xf4\xaep\xfa-L\x1f\xfd\x12\x9cuR\x02rW\x1e\xc2\x0f\xa4\x96w\x9eZV\xba\xec\xe9\xe9\x1c\xb5N\xbf\x85\xe9\xa2]\x82\xbbc\x9d\x94\x82̕\x87\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0\x03\x80C\x81\xf0g\xf9-\xfe\x00\xc0Cn\xf8\x99\xba\xaeP\x87\xf6\x10\xaf\x8e\x14\xdd\x1e\x9d(6\xba.\x93\x03\x12<K\xfb=\x1eOń\xa8V\x8a\xe8\u05feNZ\xb93\xde{\xd7\xd8k\xfcAe\x1c&3\xe9\xa4Fו\x96m\x8c\x12k7ͣ.5\xfcl]W\xd0\xfb~@eR4w\x9a\xb0\xd1uq\xedVi\xf1,}>2rJ\xa0\b\x11\x12\xb7\xe5+\xf8\x8e畑\x91\x9f\xaf\xab\xb4>\xf2K(\xe6\"+\x9c֟c9\xc3H\x8d\xae+-\xdb\x18%\xd6n\x9aG]j\xf8ٺ\xae`\x06\x9e\xdcib\xaf\xeb\xe2٭\xd2\xf4\xa8\x15\x91\x1fHH\xfc\x96/\xfd\xa1\\_WXc\"\x14s\x91\x15\xfaS\xb1\x8bM\x03\xe2/\xe2\xc5A\x9a\xb6qB\xed\xa6wԥ\x86\x9f\xad\xeb\xcal\xf8\xedu]Iڭ\x92e\xda\xe1\x8f_\xab\x15y\"\xdf:\xeb\f\xc2\x16\xc8\n\x97<\x97\xf8\x153\x88\x94\x8d%\x95\xb4\x8c\xba\xdc\xf0\xab\xc4\xea\xba2\x1a~;]\x17\xc7n%\xf6,\x91\x02\xad(\xcf{<?\x8fH\x9d\x89\xd9h\x19\x14\x11~\xc3\v\xc5\x16s1\x9dW\\\xcb\x17\v=\xfcw\x17\xbcF\xf6\x8cӂ\xb9Ɩ\nף\xf6r\xd6\x1aӥQ\xd9\x16\x01i\xe32W\x88vt\t\xc5gL\xd3X\xf9\xa1\x03\xcb\xf4A\xe5\xb4KJ\xb1X-p\xb6\xb1\tǗfL\x9a\x83J\x99\xbbį\x1d\x93dG=~$\x87\x9f\xa5\xeb\nz\a\xde\xf0\x1e\xf7g\xe6z\x9f\x9d\xae\x8bg\xb7\x12y\x96H\x81\x96\x81~\"\xaaI\x9d\x89\xd9(\x19\x14\x11~\xd3\v\xc5\x16s1\x9dW<\xcb\x17\x93\xbb\x9eӡ\xe0\a\xeb\xd6\x04ɞ\xf1Z0\xd6\xd8R\xe1n\xa5~\xac\xc4\\cZ$\x16\x95m\x11\x906.s\x85hG\x97P|\xc6\x14\x94\xe1gn\xf6\xafÃ\xcan\x97\x94b\xb1[`nc\x02\xf6f1'\x89A%\xcd]\xc2\xd7\x0e\xb3\x0f\t\x8dz\x02H\x0e?K\xd7\x15\xf4v^U'\xbb2\x91~\x91\xae\x8be\xb7\xc2\xd8z\x96(ѕ\t\xf1\xe4hB\x1cEx\xa1\xcc\xf0\x13^(\xb6\x98\x8b\xe7\xbc\x12\x1e\xb4\x1b\xdc\xd5\xf6%\xab\xb4\xf7;\xf2\x99ּ\x16\xa2k̬\xc0^c\xa2\x94\x12\x94\x11\x186.r\x85\xccR\xa1\xf8\x8c#(+_\xa3\xb6\x16Z\xb5\x91\xd7.\xb1\xb1\xf8\x8a\xb3\xd8mL\xc0\xde,\xe48\x98\x83J\x98\xbb\xd8\xed\xf2\x1d]I\x8cz\x02\xc8\x0e?BV]\x17\n\x8fk\x93\x1dC\x82\xf9ҁH\xd7Ų[al=K\x94\xe8ʄ\f\xbf)\x8e\"\xbcPf\xf8I\xc9\x14S\xcc\xc5s^%\x12\xfe\xa3\u05ee]<\xa0}j4\xed\xf0\xb3ט(\xa5\x04e\x04\xa6\xfb\x8bX!\xb3T(>\xe3\b\xca\xca_\xc1?\xb5Ae\xb6Kl,\xbe\xe2,v\x1b\x9307\v9\x0eD\xf8\ts\x17\xb3]\xbe\xa3+\x89QO\x00\xa9\xe1g꺢\u007f\xf4\x9fdϔN\x84\xba.\x96\xdd\nc\xefY\"EW&d\xf8-\x93\xba\x17\xca\f?!\x99b\x8b\xb9xΫD¯\xed\xebv\xadB\xf1\xb5`\xfb2䬱YJ\t\xca\b\f\x1b\x17\xb9Bf\xa9P|\xc61\x8d\x99\x83\xcan\x97\xd8X|\xc5Y\xec6&`o\x16r\x92\b\xbfi\xeeb\xb7\xcbwt%3\xea\xf1#3\xfcl]\x17\x1a\xf0i\x93\x83>\xee\x8ciC\xa8\xebb٭0\xb6\x9e%Jte\xa2\xd5=\x1a\x13~\xd3\ve\x86\x9f\x90L\xb1\xc5\\<\xe7\x15\xcb\xf2\xc5&\x12\xfe\xd3\xf8uG\xf4\x8c\xdb\x02\xfd2\xb4T`\xaf1QJ\t\xca\b\x8c\xd74\xb9Bf\xa9P|ƩP\xae}f\x8b\a\x95\xdd.\xb1\xb1\xf8\x8a3\xdb\xf0\xb37\v9\x0e\xe6\xa0\x12\xf2\x1ev\xbb|GW\x12\xa3\x9e\x002\xc3\xcf\xd1u\xf9\xb4]\xfeT\xc7\xfb\xb6\xf3\xa6\x03\xb1\xae\x8be\xb7\xc2\xd8z\x96(ѕI\xc5a\xf5\xfdocL\xf8M/\x94\x19~\xc2\v\xc5\x16s\xf1\x9cW\xa4\xe5\xeb\xcek\x13\x88O\xa4\xd6\xdeG\xc2TϘ\x9e0\x8c\xf12dU`\xaf1QJ\t\xca\b\x8c8\x92+d\x96\n\xc5g\x9c\n\xe5\x8f\xe1s\xfe5[x\xed\x12\x1b\x8b\xd3\x02\x12\x84\x9f\xbdY\xc8q0\aU\x18~\xbe\xa3+\x89QO\x00\xa9\xe1g\xeb\xba\x02\u07be\x9b\x81\xcb\xed\xbe\xa4\xaf[$\x8dHׅ\xb7M\xac\xddJ\xe8Y\xa2DW&\x9b+_\u007fm#\x16<Q\xe2(S\x06\xa5\xdd\xe1wB\xb7S\x99^(\xb6\x98\x8b\xe7\xbc\"-_;=\xcf .!\xed\x0e\xbf\xb7\x9f\xf3\xbcN\xf6\xcc҂Q\xd9XcN\x05\xf6\x1a\x93\xa5\x84lˀv\x95EW\x88rt\t\xc5g\xec\n垧\xaf]ڌ\a\x95\xdd.)\xc5b\xb6\xc0\xde\xc6\x04\xbc\xcdb\xae\xb11\xa8\xa4\xb9K\xf8\xdaa\xf6\x01%2\xea\t 5\xfc\x1c]\xd7\xe4\xc0\xf1\x0e߸\xfc\xec\vu]l\xbb\x95гD\x89\xaeL&\xb6,x\xe4\xa9WԺ\x948ʔA폴\xab\xed\x9e\f/\x14[\xcc\xc5s^\x91\x96\xafӕ6w\x81\xea\xf7\xf6\x97\xaeӪ\x18=\xb3\xb4\x10\xc5\\cN\x05\xf6\x1a\x93\xa5\x84lˀ\xb4q\x99+D9\xba\x84\xe23v\x855m\xbb\x1e\xd1\a\x95\xdd.%\xc5b\xb5\xc0\xde\xc6\x04\xec\xcdB\xae\xb11\xa8\xa4\xb9K\xf8\xdaa\xf6\x01%2\xea\t 7\xfc3\x8bT꺒\xf6,\x95\xb7!@2Io\xac\xf4\x90\xb1\xee89\xfc\xa9\xfc.oҞ%\b\xbf|\x92\xdeX\xe9!c\xddqr\xf8SIҞ%\b\xbf|\x92\xdeX\xe9!c݁\xf0\xa7\x86$=KreP\x80N\x92\x1b+]d\xac;\x10\xfeT\x91\x94gI\xb6\f\n\xd0Ijc\xa5\x8f\fu\a\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\u009f\xd2[\xfc\x01`\xf6 7\xfcL]\x97ʍ\xbe\x8e\xee\xcbv3\xa6\x11{]\xd7\xd7\a\x96,xF\xff\xdeE\"\x9e%\x06\x91\xaf\x94z\x92W-Y|^\xfaӶ\xe3\xab\x1b'|\xd1U\xecʟb\xd6MR\x95\x95\xe8l\xc4f\x89B\xacqr+\x9f6flϤ\x86\x9f\xad\xeb\xc2O\xf1\x1e\xba=\xea\xbd-\x9a==\xd8\xea\xbaЏ\x96\x9c\xda_\xa1\u007f\xd32\x11\xcf\x12\x83\xf0\aڳ:>\xd0\x1ea\x10\xb7V\x8b\xc4\xea\xf3\xd2\x1e\f\x1dg\xdd\xf8\xe0\x8b\xaebW\xfe\xde\xc8FF]n\v\xec5\xe6\xe8\xd0b+X 6K\x14b\x8d\x93[y\x94\xd8f\x89\xbfn*z\x96\x16\xa4\x86\x9f\xad\xebB\x03\xed\x01\xfc\xc6pC0wz\xb0\xd7u\xdd\xf3\x9c@\xc6\xe3Q\xa7\xfd\xb8\x11\xd3\xc9\x11\xbfV\x8b\x86V\xfa\xc4<R\x96\")\xfd\x0f\xf7K\x86\x8c\x95\xdfɬ\xcbi\x81\xbd\xc6<\x1d\x1a\xa3\x02\t\xb5YL\x885Nj\xe5\x13\xda,\x89ԝ~\xcf҂\xd4\xf0\xb3u]\x01\xef\xfb\xc6\xdf\xe4c\xaf\xeb\x9a\xf0L\xebP߂\xb9\xdd\xe3\u007f\xca.M\xe6\xc2\xcf \xa1\xf0\xb3\xd7x\x83(\xfc\xec\xd98\x9be\xda\x11Kd\xb3$Rw\xfa=K\vrï\x12\xab\xeb\x1aj\x0fM\u007f\xa7\x9a,v\xba\xaeP\xa5~\x96\x8e\x8f\ax\xfe&\xa6-\x8aGd\xbbs\xb5Z\x13\xbb*K\x97<\xa3\xbd\x03E\xedV\x84K\x8bhA=N\u07bbl\xd1.\xeba?\xe9\x90\"\xea\n\xacYT\x05\xc3JFڭ8+\xaf\x86\xff\x90\xfa\x87\x05\xf4\x83o\rU\x96P\x03\xc6ѡ\x99k\xc1\x9e\x8d\xdc,\x9c5\xe6\xac<\x01c|\xd9K#ט\xd93\xa2\x05\xb6\u007f\f\x13۳\xf3\xeaܯD\xd4c\x99Br\xf8Y\xba\xae^ߍ\x93\xde\xe3\x17\xe2MPj\xb1\xd3u\xa1\x8fF\xfa=m#\xfa\x93\x1b\xd9\xfe&\xb6\xeb\x89Gd\xbb\xf3\xa4X\xefUlx\xfdb\x9b\a;\x9b\f\xbb\x15\xa1}\"Z@\x13\x8bV\x9d~\xe7)\x8f%\xfc\x84C\x8a\xa8+\xb2fQ\x15\f+\x19e\xcdb\xaf\xbc\x1a\xfe\xbb{=',\xcf#0TYB\r\x18G\x87f\xae\x05g\xa0\x88\xcd\xc2^c\xc4^y\x02\xd6\xf8\xb2\x97F\xae1\xb3gD\vl\xff\x18&\xb6g\xa1\x0fj\x0e\xdcE_\xb5-\x1a\xc9\xcc\v\x1f#9\xfc,]W\xb7\xa6\xeb:ޝ\x89A\x10麨\xe3\xcbX\xcf\x12\xdf\xf5\xc4\xc4\xfe\xb0?T\xf34~\xe0t\xff=\xdanE=9:\xda\xc2\xe6U!\xfc\xe4hK\xf8)7\x95QWh͢$S\x84\x95̰[a\x18\xf2*5\xfc'\xcac\xbe\x84n\xaa\xb2␁\x10\x87\xfdƂiÖ\xfda?{\x8d\x11s\xe5\tx\xe3\xcb\\\x9a\xb9Ɯ\x9eQ-0\xfdc\xccc\x926|\x88\xb1\x97\xf9\xc4xI\xc8\x0e?B1\xba._;~}\x05;\x86E3\xa6\x01\x91\xae\x8b\x1d~ó\xc4w=1\xb1\x0f\xffy\xf3)N\xa4݊\x15\xfe{\xfa#]\x8fZ\xcf\xf9I7\x95\xb14\xa15\x8b\x92L\x11V2ӥ\x85\x98\xf2\xaa\x9dmG\x19\xe7ބ*K\x98+2A\xe6\x82)Ö\xe0\x9c\x9f\xb9ƈ\xb9\xf2\x04\xbc\xf1e\x87\xdf\\cvϨ\x16\x98\xfe1f\xf8?\xf7|\x82B\x8f\xa4ȶ\x9d\x14R\xc3\xcf\xd6u\rꞮ\xc1^\xee|iC\xa8\xebb\x87\xdf\xd8\xd8|\xd7\x13\x13\xfb\xf0\x9f\xf0\x18/Q\xd2n\xc5\n\xffu\xcf\b\"J\xa3Pn*siBk\x16S2\x85L\xbb\x15\x86\xa1\xb0ع\xe4\x915\xb1롟\x1fh\xfe1a\xae\x98\t\xa2\r[\xf6\xe1\xe7\xac1s\xe5\tx\xe3\xcb\x0e\xbf\xa8g\xcc1\x13\xf7\f=}\x18]\\\x94\x89\xe3\xdd(2\xc3\xcf\xd1u\x8dvh\xef\t\x033Q\xd7%\b?\xdf\xf5\xc4\xc4\x12~\x8b}\xe9\x12\xb1\xe7'\xecV\xdaҢ\xfb\xf8H\v_{\xb4\x8bv\xd6\v~\x94\x9b\xca<\xed\x15Y\xb3b$S\xac(\xb0\xc2_\xf9ɝE\xb4U\x1aW0TYT\xd7YkL\x96\x9a\xed\xc6\x1a\xb6bf36\v{\x8d\x11s\xe5\tx\xe3\xcb\\\x9a\xb0g1- k]v\xf8ߩ\f\xed\x8f\xf3\x981=\xc8\f?G\xd75\xa5}\xd4\x17l\x97\u007f\x8b\x9fX\xd7%\b?\xedz\xb2\xf7c!r\xbb\xb3\xecK\xa1e[\xf0\x98\x1c:DۭH\x97\x96\xd1\xc2\xc6\x1a\xf5\xa8zb\x81%\xfc\x94\x9bʨ+\xb4f\x91ڧ\x84¯N\x9e/\xb5>\u007f\xd4Teš\x01c\xe9Ш\xb5`\xcffl\x16\xf6\x1a#\xe6\xca\x13\xf0Ɨ\xb94a\xcf\xc8\x16\x8c1\x13\xf6\f\u007fl\xf1Σѣ~\xe1k'\x1dH\r?[ׅ.\xb7_\x0e\x8cw\x9e\x94\u007f\x00$\xd2u闕\xaf\xe1\x03\x13\x8e\xbf\x89r=\xd9\xfa\xb1\xa2w\xf8]\xd3V\x93e_B\x97\x16\xac9u\xfe\x90v:OحL\x97\x16\xe1\xf3\xfa\xa4ⱶ\xa3\x8fF\f[\x06\x84C\x8a\xa8+\xb2f\x11\x15\x88u#\xedV̕\xbf7\xb2q\xff\a\xa1\xd0\xcee\x97\xbe\xa2Z3UYB\r\x98YJ\x0e*\xb1\x16\xecو\xcd\xc2^c\xce\xca\x130Ǘ\xb9\xb48zf\xb4\xc0\xf6\x8fqz\xa6\xf2\xf2\xe3ƅH\xfb\xd7N\x9a\x90\x1a~\x8e\xae\v\xdd\xee\xed8yY~\xf6E\xba\xae\xd0\"턾t\x02\xf1\xfdM\xa4\xeb\xc9֏E\xdf\xdbϲ/\xe1\xcf\xf9\x1f{d\xa3fi'\xecV\xa6K\x8b\xf4yM\xec|\xb4\xe6\xf0[\xa5\\\x87\x14QWd\xcd\"*\x10\xebFڭ\x98+\u007fJ[\x19\xac\xfd:J\xb5f\xaa\xb2\x84\x1a0\xc4ԡ\x11k\xc1\x9c\x8d\xdc,\xec5\xe6\xac<\x01s|\x99K\x8b\xa3gF\vl\xff\x18\xa7gxFs\xf3ٿv҄\xdc\xf0\xcf,R\xa9\xeb\x02\x80\x84\t\x95'\xef\xd9K\x05N\x0e?|\x97\x17\xc8(\xfd\x95q\xde\x1d\x96&\x9c\x1c~\x00\xc8\x1cm\xef\xa1\x1f\xb5\x89*\xa5\x17\b?\x00d\x80\x90g\xc3\xf3\xcb$[y\xad@\xf8\x01 \x13\xb4Ul\x99\x10\xd5I3\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10~\x00p(\x10\xfeYA\xef\xe2I\xea\xffS\x8bm\x9e{\x04\xdfY\x00\xe2Bn\xf8Y\xba\xaeP\xa7W\xe7\xb8`f\xe9lSr\xbaEu\xa6K\xa3\xa2(y7E\xb5Z\x94fkI\xceAfMd\xeb\x1fK\xce\x16\x15\x97K+V\xa0\x15\xd7l@\x06\x91\x1a~\xa6\xae+\xe4\x1d\r\xa8\\\xf6^\x15\xcd.\x9b\x80?ך9\x9d\xc1Qfq2\x04\xfc\xfeVeHP\xa95\xa7#\xa6\xcc7\xb7\x95Q\x13c\xe3\x1fK\xcc\x16%ti\x91\xc4\n\xb4\xe2\x9a\r\xc8 R\xc3\xcf\xd6u\x8dk\x0f\xef\xed\xbc \x989\x13\xb8\xd8\xe1_X\xcf,N\x92aQ\xf8o\xbb\x9a\x18\xa5{\\\x01F\xa9\xc8?F>PJ\x84ХE\xc0\x14h\x89g\x032\x89\xd4\xf0\xb3u]\x1a\xbe7\xe4?\xc9G\f'\xfceu\xcc\xe2$\x11\x86\xbf\xb1\x88\xa52\v\x1652JE\xfe\xb1D\xc2/ti\x110\x05Z\xe2ـL\"7\xfc*\xb1\xba.\xcc\r/}AK\x02\xa1\xc2ܦ\xe2\xa2\xc1\xed\xee*|\x16RW\xe4*^\x89O<n\xccU\x94\x95\xa8XQ\xdc껑k{c\x91{\xa5zJ\xeeSO͛P\xb3\xfa\xb3\x1bObʴV:\x17\xe7\xcfߡeӿ\xbc8\u05fd\xa28f9\x1d\x85^\xfc+P\x10\x99\xaf\xc0\xba\xc36\xc3\x1fml\x9b\x92\xeb\xdd1?o\xb9^3T\x10\xdd\xf1\x8f\xed\xdbT\xbbvߦ\a\xfa\xff\xf6\xe4\xb1\xde\xfbI\xf1\xdf\x00\x00 \x00IDAT/\xed\xfcc\x183\xfcQ\xd3\x18\xa5\xe0\xfazo\xe5c\x87\x0fWV\xf4s\\Z\x14Q\xe7\x15)\xd0\"1\xcc]\xc0\x8cDr\xf8Y\xba.Lw\xf4\b@\"\x83\x05ʎ\xa5\x8a\xfb`a\v\x0e\xf7\x93\x83\xdd+s\x86\x11\n\x0f5\xe7\f\xa1\x0e\xa5\x13?Rإ\x94uu\x95卣\xe0\x85\xe2m\x93h\xb2\xb9\xc0\x1f\f^\xf0ϯ\xf2\xfb\xfd\x9aT\xb81g\xbb\xaf\xb5\xb0,\x8c#\xbc\xfe\x8d\x01\xaf[\x89\t\xe4\x13\xcar\xfc+\xd4Ѫ\xd3a\xada\x84\xdfh\xec\xc6\xf1\xb9JasK\x81~\x801\xaa\xe8O<G\x1f\xff\xd9K箜][\xfd;\xfd\xbf\x17\x98G\f\xb6\xfe1D\x84\xdf0\x8d\x91B\xaaКe\xa7\xda\xca+N?u\x82\xe3\xd2\"1\xdd_\xa4\u05cc\xc00w\x013\x12\xc9\xe1g\xe9\xbaP\xf4b\x80l\x8a֫\xa1\xf7\xa1\xc6'\xd5=\u007f7~G*{B+o\\8U\xac_Kw\x95\xe0\xc7P\xcf_\xacN6\xe3=\xfdz\xfdH\xdb8\xec\xf7)\xf8Jܰ҅Pk!^\x95Vw̃\x99n\x1f\xbc\xad\xfd\x9e\xbc\xad\x13s\x88\x13\r?\xd1\x18r\xb9\xd5\x01Y_\x18)\xd7\x1b@g\x1ap\xecϬ\x8e\xec\xf9\x03\xca\x1b֦\xc4\xfe1#\xfc\xa4i\xcc\x14R\xf5cw\xc0)\x8f\x1eW\x96K\x8b\x80r\u007f\xb1\x0f\xfbMs\x170\x03\x91\x1d~\x84bt]*\x03i\xffH\x8dEQ\x17\x1aR\x82\xa8\t_\xbe\x9bj]>\xaf r(\x1f*+\\\xa9\xd7Я\xb4y\x95)\x1c\xb5q\xf5\x00\\?@1\xc2_?/\x84)V\xdf\x13\x02E\xf3\xb6y\xdfgH\xe3#\xdcV\xa2ܶ\xfc%\x1a~\xa21\xe4\xc2?\x9a]Zyot\x8e/\x1b6\x1d;\xfb\xe9\x83o#\xf3\x05\xb4\xb7\t\v\"\xff\x98\x11~\xd24f\n\xa9^^\x84p\x90\xb5'\b\xb3]Z&\x94\xfb\x8b\x1d~\xd3\xdc\x05\xcc@\xa4\x86\x9f\xad\xebR\xe9\x90/\xecP)\xeaC\xc3j\xbep\xf8\x87\v\x8b\x9bN\xfa\xab\xf4\xf0\xa37\x94\xc8G\x0f\xfa\x05?\xbf\x82?\xda[\xb1\x03\xf5\xb9\xf5l\x1b\xe1/\x8b\xe4\x19\x1f1\x04\xbdu%\n>\x85\xe0\xe0\xf7\xe9\xf8\xad\u007f\x88\x86\x9flL[p$\xfcC\xc6\xe1\xfd\xfd\xb3/l\xad^\xdb\xf3 :_\xec\a$B\xff\x98\x11~\xd24fj)Nx\xbe\xc6;\xf3\x98=?\xa1\xf20\xa0\xdc_6\x17\xfc4s\x170\x03\x91\x19~\x8e\xae\v_\t\xb0\xee\r\xa5@\x84\xbfd1>\xec\xaf\xd3\xc3\x1f(\xdaS\xac_\x88t\xed\xc0?\xdb\x15\xfcG\x9f;\xd4\x18\xb9\xbe\xae\x85\xbf\x1d\x1f\x98\xcf\x1b\xd5Pk_\xc6\a\t\xc1\xae<ާ\xef|\xa2\xe1'\x1a\xa3\xc2\x1f\x8c~\xe6p\xebU5\xf6\xf7\xcf՞\xd1\xff\xdb\xec\x8a\xfd\x10@\xe8\x1f3\xc2O\x9a\xc6\xccl\xdf\xf1<}\xe7\xa3U\x9b\xf57i\x96K\x8b\x80r\u007f\xb1\xc3o\x9a\xbb\x80\x19\x88\xcc\xf0st]\xf8\x94?#/\x0f\"\xfc\xc58\xce\xe12-\xfc\xa1\xc5{ГK\xb5\u05ff\xab\x18\x9f\xb4\x96Ti\xc5n\x9f;r\xe5\xadJ-\x98T\xd4S\x95>E;_\xd9sP\x8d\xa2\xa2\xad\\\xd56\xebR\xa2\xe7\xfc\\\xa2\xe1'\x1a\xa3¯\x9e\x0f\xe8a쩾\x82\u007f\xed>\xa2\xfd/\\\xb2\x02Y\x11\xfbnj\xf0\x93\xa613\xdb\x1fz\x96x<[\"\x17\xeeX.-\x02\xca\xfd\xc5\x0e\xbfi\xee\x02f R\xc3\xcf\xd1u\xa1\x1b\xdeL|\xc8\u007f\xc3\xdd\x12\xecʽ\x1a\xac\xaf\n\xa8ѭk=X\xa6\xb8[\x86B\x17\xb6\x15\x06\xd0\xed\x82\xed\x17\xf0G}\xca\xf2\xa1\xc1\xc5n=\xbdM\xf3\"G\xfdj*[z\x97\xe6\xe3k\x94MJ}wo\xa3҉ß\xdf\xec;\xd9\x18\xbd2o\xb2R\x89\r\xa9\x89v\x87_\x8b\xdfO5\x16\xf0\xe76\x0e\xa1\xd1\xc6\\\xad\x18\xdd\xcc\xd1O&z\xaak{\xde}\xf7\xa5\xea1\xed\u007f-J\xec}\x86\"\xff\x18i\x8b2Lc\xa4\x90\xea\xa3\xf2K\xe7G\xeeF.Z\xb2\\Z$\xa6\xf3\x8a\x10h\x91\x10\xe6.`\x06\"5\xfc\\]\x17\xe3\xb2u\xda\t\x17*\xca\xf1\x02%\xbf\x1b\x9fe\x87[\xe6\xbb\n\xeb;湪\xfaԳ\xee\x1dh\xbb\xfaS\x8dqIs]A\xd1\xfa\xc8'\x117\x95'#\xb3\x86\xb6\xbb\U000ea1b5ɾ*\xb7{1\xde\xe7wV5\x17\xe7\x16U\xc5d?\xfa9?\x87\xc6ȉ\xbev\xcf`\xb4\xb1mjA\xeex\xbe\xfaS?\x8e\xd8\xf3=\xed\xec\xfe\xec\xee\x9eM\xb5\r\xbb\xf5\xec\xfb\xf3v\xc44&\xf2\x8fѶ\xa8\xa8i\x8c\x14R}P\x8a\xff\\\xbaY;\xe9g\xb9\xb4H\f\xe7\x15)\xd0\"!\xcc]\xc0\fDn\xf8g5AWl\xb2%\xb1\xdde\xfd8\xa4\xcb\xd5\x18{\xb44m\xff\xd8W\x15\a\xbe\n\x87\xef]\xdf\xf5(\\\xa0w\x00\x10\xfe\xb8\xe9v\xc7\xc6M\x16-Ŗ\xaf\xf4\x16\xb1\xbe\xd47\xed\xef\xf2\xbe\x1d\xb1Ɔ+\xcf\vj\x02Y\x00\x84?>\x9a\a\xd1R\xf6\x8d\xfe\xd9ć\x91\x0f\xf9>\xc1\xf7\xfa\x00\xd9\x0e\x84?.\x82J\xd96\xe6\xd7k\xb2\x8b\xf0\xfe\x8a\x03\xfd\xef\xf5\x1f\xa8H\xea\xb8\x01\x98e@\xf8\xe3\xa39\xbfꆨN6\xf0\xceS\xcbJ\x97=\r\a\xfd\x8e\x00\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\xc2\x0f\x00\x0e\x05\u009f}L\xfb\x16\u007f\xc0\x19\xc8\r?K\xd7EMf\b\x19b.\x84.\x94\xe5/\x1f\x12U\x9a>6\xba.\x11\xd30l\xcd\b]םRϚ8K/V2\x9e>\x12%\x03]\xcf\x04R\xc3\xcf\xd4u\x91\x93\x99B\x86\x98\v\r\xb8ֿQ\xefJ\xff3\xcamt]\"\xa6a\xd8J@\xd7\x15Հ\xa5\x81k\xfb-\x8f\x1b▞\xaf\xb0\x89\xf74\xc6a6!5\xfcl]\x171\x999\xd2/\xe6\n\x15\xe2's<Y\x94\xee\xef\x05\vt]\x02\x92\x95\xec$\xa2\xeb25`\xa9\xc7\xfa\xac1~i\xcc3\xd6)\x92\x1d\x87Y\x85\xd4\xf0\xb3u]VsWFH\xbf\x98\xcb\xeb\xc2_\xc9\x0f\xe4\xda=\xd7'\x15\bt]\x02\x92}\xd1'\xa2\xeb\xda0#\xc2oO\xb2\xe30\xab\x90\x1b~\xc4\xd2uY\xcc]Ҡ\xa4X\xe9\x17s=\xa1=\x06\x14U\xa5\xee턉\x9d\xae\x8b\x10s=\xef\xf1\xfc\\?\x19\x0e/)}\xe5\xb1e\x97\x0e-ڂW\x8e4lE}^\x1f\x95z<G'\xf6\xd6,xڲ\xb7\x8c[\xd7u^\xfd\xe3+\xa8M\xfdIk\xc0\x8cE 4\xf2TMi\xe535\x96\x16\xd8N14\xb1\xab\xb2t\xc93\xda;[\xb4\x0f\xea\xb1\xfa\xdee\x8bvE\x0e\xf0\xcdv\xc9R\x83{\xf8\x99d\xdaa?ݮ\x89#Lc\x92\xc3\xcf\xd4u\xd1\xe6.iPR\xac\xf4\x8b\xb9J\xf4'\x006\x96XgK-v\xba.B̥\x9f\xd5j'\xc3\xef-\xf2\xfc\xe4G\x9e\xcaז\x9c@\x94a\xcb\xf0y\x85\xfa\xfbkV=\xf2\xd8O\xf6zh\vH\xfc\xba\xae\xd0\a5\a\ue8af\xda\x16\x8d\x84(\r\x98\xb1\btݳ\xb7\xff\xe2\xe9J\x8f\xe5\xed\x85\xe9\x14C\xefUlx\xfdb\x9b\xe7\x04Շ\x89E\xabN\xbf\U000d49dcn\x97,%\xb8>2\xa2\xef۩v\t\x1ca\x1a\x93\x1c~\x96\xae\x8b6wɄ\x90b\xa5_\xcc\xe5\xd6u\x9bMn\xebl)E\xa0\xeb2\xc5\\\xc4㸗\xedUw\xcd\xef\xa0\xfd\xb8\xbai\xd8\"}^h\x83\xe7G\xc1\xc8Y\x9bAB\xba\xae6\xbc\xa7߫?M\xdc8\xec'\x16q\xaa\x12\x0f\xe7\xa9E\xf4\xa0\xb2\x9db\xa1\x9a\xa7q\xbb\xfd\xf7\xa8>l^\xa5\x16\x86וӳ\x11\xa5\x16\x16D\x0e\xec\x89!!p\x84iLv\xf8Q\xac\xae\x8b6wɄ\x90b\xa5_\xccU\xb2^\xfbU\x9f\xde=\xbf@\xd7e\x8a\xb9\xc8\xf0\xf7\xabA\t\xa2\xc3\xcf!ҰE\xfa\xbcІ\xf2ض\x12\xd2u}\xeeQ\xf7\xff\x8f\\Ҋ\x8d\xf0\x13\x8b\xf8|Y\xcd\xf3\xa7?\xb2\x0e*\xdb)v\xde|Șه{\x9e\xd3x\xeah95\x1bYj\xc1\b\xbf9$\x04\x8e0\x8dI\r?S\xd7e1wɄPc\xa4_\xcc\xf5\x84~\xe9 \"\x03M\x13\"]\x17a\xdf \xc2\u007f\x11]+E\xe8\xe5碥\x9aa\x8b\xf4y\xa1\r\x1bb\xdbJL\xd7\xf5\xf4atq\x91>\xa8F\xf8\xc9E\xdc;\xbdk\x8dg\xc9\xebt\x03<\xa7\x98\xf1\x1ea\xf6\xe1\xbag\x04E+\x98\xb3\x91\xa5\x16\x8c\xf0\xb3\x84$\xce0\x8d\xc9\f?[\xd7E\x9b\xbb\xa4B\x86?\xedb.\xafv pSI\xeb\xd5~\x91\xae\xcb\x1a\xfe\xa3\xd1\xf0\x97G\xc3o\x18\xb6H\x9f\x17\xf3\x02}b\xba\xaew*C\xfb#\x0e!C\x03F,\xe2:\xbe\x1b\xe9^\xff\x82ST\x03l\xa7\xd8%b\xcfo\xf4\xe1k\x8f6\xabviϜ\x8d,\xb5 \b\xbf\x13Lc2\xc3\xcf\xd1uQ\xe6.\xa9\x90\xe1O\xbb\x98+T\x88\xdfH\xea\n\xd3yiC\xa8\xeb\"^\xe9\x15\x87շ\xe3\x8d1\xe17\f[\xa4ϋ\x19\xfe\xc4t]\xa1\xcaw\x1eՏ\xfaM\r\x18\xb1\x886\xed\xe4\x1dm\xa1\x8fV\xd8N\xb1в-x\x10\x0f\x1d\xa2\xfa\xb0\xb1F=D\x9fXPN\xcfF\x94Z\x10\x84\xdf\t\xa61\xa9\xe1g\xeb\xba(s\x97D()V\xfa\xc5\\\xa8\xcfU\u007f\xb2\xde\xd5gWe\xba\bt]\x94wks\xe5\xeb\xafm\xf4\x94\xbe\xf5O\xff\xf4\xe8\x89P\u007f\xe9'\xa1\xe7\xb6|\x8eHÖ\xe1\xf3\n_\xd3.\xd0ǜ\xf5'\xa6\xebz\xf9\xf1\xe8ռ\xa8\x06\x8cX\x84\x1a\xfe\x8a\xb6\xf3\xea\xe4{t\vL\xa7\x18\xba\xb4`ͩ\xf3\x87\xb4\xd3y\xb3\x0f\x9fT<\xd6v\xf4Q\xbcBd\xbbd\xa9I胑\x91\xf2\xfd##A\xae\x8a\xcc\x11\xa61\xa9\xe1\xe7\xe8\xbaHs\x97D()V\xfa\xc5\\\b]X\x9aW\x96\xd6\xdb\x18E\xba.ʻ5\xb1e\xc1#O\xbd\xa2N.\xf1x\xfa\x1f\xf1T\xf4k\xa7֤a+\xea\xf3\xfa\x888\xf9'IL\xd75aȾ\xa2\x1a0d.\x02\xfd|s[M\xe9\xb2-\x96쳝b\xf8s\xfe\xc7\x1e\xd9\xf86\xfe\xbb\xd1\a\xb5p\xe7\xa35\x87\xdf*\xd5*\x18\xedR\xa5\x06\xd7#\x17\x05NsUd\x8e0\x8d\xc9\r\xff,!\x83b\xaei1m]W:\t\x95\xc7$\x1b\xc8,\x10~\x06\x99\x14sM\x87\x19\xfd]\xde\xfeJ\xe9\x17t\x01{ \xfcV\x9c!\xe6\x92L\xdb{\xe8GN\xb8[~v\x01\xe1\xb7\xe0\x101\x97\\B\x9e\r\xcf/\xcb\xea\xfbef%\x10~+N\x11sI\xa5\xadb˄\xa8\x0e \x1b\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b\xff̾#\x1e\x00҆\xdc\xf0\xb3u]\u1afd\xed'3vW\x1d\xdfn\xf5vi䛟\xa5o\xcb\xf57\xf1\x97FH\xb1b\xfdXl\xf8\x8d\xd9\x1a\xab\xf8\x15\xe2.ݯ\x0e]ńM\x05\vlٖ\x90\xf4\xce\x16ז'\xb6\x85x5g\x0eR\xc3\xcf\xd6u\x85}\x1d\xa3\xb7/\xb7_\x16͝&\xf8v\xab\xd7=##\xa7<'FF<\xaf'\xefo\x12\xba\xa9\x18\x15\xf8K#\xa4X\xb1~,6\xfc\xc6l\x8dU\xfc\nf)\xd9uF\xdd\xcf\xf1\xf0}`S\xc1\n[\xb6%$-\xb3E\xd7-\xae-Ol\v\xd1j\n_\x0f\x12\x91\x1a~\xb6\xae\xeb\xfdv\xac\xeb\xb8ٞ\x99o\xd3\xd8حN\x94\xe2\xe7?\xab\xafފ\x13\xd1':&\x8e\xd0MŬ\xc0Y\x1a!\xc5b\xfa\xb1\xd8p\xbb.<n`W0J\xa9\xae3\xeb^3\xc3/^Z2f\x1d\x8dt\xccf\xae\x9bx\xcbS\xdbB\xb0\x9a\xc2׃D\xa4\x86\x9f\xad\xeb\xf2\xe9O\xb6\xea\xcc̮\xdf\xc6n\x15\x9a\x88\xbcz'B\xf1\xbc\x04\xd8\b\xddT\xcc\n\x9c\xa5\x11O\xcac>4\x8fM\xb2]\x17\"\\7*\xfcq\x90\x8e\x14\xf3\xb1\x9dmC\x02\xe1O`[\xc41f\xf2\x90\x1b~\x95X]\xd7I\xfd\xd1V\xbd>\xc1\x9ci\xc1\xcen\x851^\xbd\xe5\x87M\xab\x93)\x83\"\x89\x8a\xa3L\x13\x16\"\xdcT\xcf{JO\x1cxL3@\xb1+P\x18\xb6(\xa2.!Ţ\xfdX\"\xad\x16S=e\x1a\xab8\xaa,\xb6\xd2\xca,%\xbbN4\x16ܵ\xac\xb4fg\xf4\xf1\xba\xd1\xe1#*\xac\x89̷\x19\xffG\xa0\xd5\"\a\x95\xad\xd5b8\xba(\xff\x98\xd9\x1d\xaa\x05\xceҢP\x9bE\xb0\xe5\xc9ma\xae&\xb5-\x8c\xf1\xe5m\xee\f!9\xfc,]ׅN\xed\f\xa0\xe3\xa4\xfd\xac\xe9\xc1\xcen\x851\xc3\xefY\xd3\xff\xce\x12\xedm۔A\x91\x18\xe2(\u0084E\xb8\xa9\xb0\x17\xaa浶\x9a\x8aO8\x15(\f[\x14Q\x97\x94b\x91~,\xa1V\x8b\xad\x9e2\x8cU<U\x16[ie\x94R]7\x1b;\xef9\xf0^\xffN\x8f\xfe\x88>s\xf8\xcc\n\xf8\xc1\x99##\x1b=\xf8\x11\xfdB\xad\x961\xa8\x1c\xad\x16\xd3\xd1E\xfa\xc7\xcc\xee\x90-p\x96f@\xad\x9bh˓\xdb\xc2XMr[\x98\xe3\xcb\xdb\xdc\x19Br\xf8Y\xba\xae`\x87o2\x14\xe8\xf5v\x8b\xe6M\x03\x02\xbb\x15\x19\xfe%_\xab\x1b\x1f[\x9d(\x8f\x95\x01)\xaf\"\x9f\x06M\x1c>֨\xeb}\xaff#\xb7\x02\x01a\x8b\"\xeb\xb2\x0e\xfb\x85Z-\xbez*\xf2\xf4j\xb6*\x8b\xa8`QZEK\xe9\xaeGJC\xfd\xf8\xad|]\xe4i\x9f\xe4a\u007f\xa4B\x9b\xba\x1b\x0e\xef\xd7D{B\xad\x165\xa8,\xad\x16\xdb\xd1E\xf8\xc7\xc8\xee\x98-\xf0%^\x06\xc4v\x13ly\xcba\xbf9:\xd1mA\x8d\xaf\xa3\x0f\xfbQ\x8c\xae\vM\xf9ԃ\x80!_\xafh\xc64 \xb0[\x91\xe1\xc7o\rZ\x06)\x8f\x95\x01)\xaf\xe2\x84_\xfb\x1cQ3@\x89\xc3oڢD\xe1\x17j\xb5\xf8\xea\xa9\xc8딭\xca\"*X\x94V\xb6\xe1G_\x9fz\xfa\xf1E\x1e}4X\xe1W\t\xed\xd2R$\xd6jQ\x83\xca\xd0j\xb1\x1d]\x94\u007f\x8c\xe8\x8eт\x8d\xc4ˀ\xd8n\x82-\xcf\r\u007ft[P\xe3\xeb\xd8\xf03u]\xda\x1f\xa6¨S\xbe\xabOh\xb7\"\xc3od\x90\xf2X\x19\x90\xf2*N\xf8\xb5W\x85f\x80\x12\x87\x9f]\x97\x15~\xa1V\x8b\xaf\x9e\x8a\xbeN\x99\xaa,\xb2\x02-\xb6\xb0\r\xff\xb5%5\x87\xdf\x1e\xd9b\x17\xfe\xd03\xa5\xdac\xb7\xc5Z-ޠFa;\xbaH\xff\x18\xd9\x1d\xa3\x05\x1b\x89\x97\x81e\xbb\xd9lyn\xf8\x8dmA\x8e\xafS\xc3\xcf\xd6u\xa9/\x06<u\xd3K\xd9\xec\xe5 \xb2[1\xc3Oy\xac\fHy\x95V\xf7(\x91m\xec\xa6B\xe5\xda\xf5D\xcd\x00Ů@@آȺ\xac\xf0\v\xb5Z|\xf5T\xe4u\xcaVe\x11\x15l\xc3\x1f\xedz\xa4t\xcdF\xbc9wل?\xb4\xb9\xfc\xbc>%\xd4j\xc5\f\xaa%\xaflG\x17\xa9 \"\xbbc\xb4`#\xf12 \xb6\x9b`\xcbs\xc3\x1f\xdd\x16\xd4\xf827w\x86\x90\x19~\x8e\xae\xeb\x86wR=5:>(\x989\r\b\xedV\xcc\xf0S\x1e+\x03R^e\x9a\xb0\b7\x95z\xee\x88/p<\xbe\x85[\x81\x80\xb0E\x91uY\xe1\x17j\xb5\xf8\xea\xa9\xe8Y8S\x95ET\xe0\x85\x9f\xeaz\xa4\xb4\x06\xf7 \xbc\x8e\x1f\xfe{\x1b*\xf0~\xf7<m\x04ck\xb5\xc8Ae\x85\x9f\xe3\xe8\"\xc2Ov\xc7l\x81^ڝ6\xc3\xfdgBl7\xc1\x96\x17\x86\x9f\x1a_\xe6\xe6\xce\x10R\xc3\xcf\xd6u\xdd\xf4\x0e\a\xde\xef\xf4e\xe0\x1e\x1f\x81\xddJ\xe5\xc3S\x9e\x13בEteʠHLq\x94i\xc2B\xf8U\x13uS\xe1\x8b\xee\xa7W-\x9a\xe0V  lQf]B\x8aE\xfa\xb1\x84Z-\xa6z\xca4VqTYl\xa5\x151\x1b\xd1u\xaa\xb1]\xa7^\xdb\xe0\xa9|\xfd\x9a~\x87\xdf\t\xadCf\x85{\xeb<\xaf\xe1\xcb\xfd\ap\x9aDZ-sP9Z-\xa6\xa3\x8b\xf4\x8f\x99\xdd![\xa0\x97\xb6\xd3øS2\xban\xe2-Ol\vs5\xc9mA\x8d/ssg\b\xa9\xe1\xe7\xe8\xbaF\xbb;|\xa3q\xdc\xff\x95jDv+\xb5\x93\xf8sۊ\xa0\xd5\x16eʠ\bHqTԄ\x85\x9b0\xdcT\xe5?ٿ(b\x80bW  lQF]B\x8aE\xfb\xb1DZ-\xa6z\xca4VqTYl\xa5\x151\x1b\xd1u\xa24|bUy\xe5\xaeӫJ\xb7h\xf7\xf6cv\x91\x15>\x8a~aB\xbb\xad@\xa0\xd52\a\x95\xa7\xd5b8\xba¤\u007f\xcc\xec\x0e\xed*#\x97v\xba\xc2c\x1d\u007fs݄[\x9e\xdc\x16\xc4j\xea\x13ڶ\xa0Ɨ\xb9\xb93\x84\xdc\xf0\xcf,$ۭ\xca\xdb\x100#y;\xf6\x83\x10G\xe0\xe4\xf0K\xfe./\x84\u007ff\x12~k\x91\x84\xad?\x13qr\xf8%\x03៙ܭ\x8c\xbdU\xdb\x19@\xf8%\xa1_8\x02\x80\x99\x03\x84_\x12څ\xa3\x99\xf1\xf1.\x00h@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8e\xdf\xe2\x0f\x003\x04\xb9\xe1't]\xa4\xa3+\xd0\xdbї\x81\xe7\xf8\xe8\xf0u]\x16R&b\x8a\xcb\x00\x95\x02L!\x15\xd1\xf5$\x84_@\x96\"5\xfc\x84\xae\x8btt\x05\xda\xfd\xb7\xfd\xed\x99J?_ׅ\x84B\xaa\xe4\x88\xcb\x00\xc5$Aד!\xa4\"\xba\x9e\x84\xf0\v\xc8R\xa4\x86\x9f\xd0u\x11\x8e\xae\xf0q\xfc\xe8\xce\v\xc73\xb3\x0f\xb2\xd1u\xa1x\x84TI\x91\xec\x17\xfc\x12u=\x19O\xbd2\xba\x9e\x9c\xf0\v\xc8J\xa4\x86\x9f\xd0u\x11\x8e\xae\x1b\xed\xf8\x15\x18lό\xa7\xd7Fׅ\xd2\xf6\xac\xd5dßhwb\x9fO\x9b\x9c\xf0\v\xc8J\xe4\x86_%\xa2\xeb\"\x1c]\x03\xfa\xfb\x80/\x03O\xf0\xb4\xd7u1\x85T\x94\f\x8am\ue88dU&\x13\xbb*K\x97<\x83\xdf`L\x03\x94Y\x97\x14<Q-Dg\xa3]O\"G\x97)\xa42\x1dR\x89\t\xbf\x98\x12/ \x8b\x90\x1c~C\xd7E8\xbaN\xea\x0f쿐\ti\x87\xad\xae\x8b-\xa4\"ePl\u007f\x13m\xac2x\xafb\xc3\xeb\x17\xdb4U\x8di\x802뒂'\xb2\x05c6\xaa;\"G\x17)\xa42UY\x89\b\xbf8\x12/ {\x90\x1c~C\xd7E8\xba:\x87\xb5\xbf\fw\nfM\a\"]\x17KKAȠ\xd8\xfe&\xdaXe\x94\xd6<\x8d\x9f\xa0ݏ\xaf\xb0\x99\x06(\xaa\xae!x\"J\xc9\xd9\xcc\xee\b\x1d]\x16!\x95\xf1<\xe9\xf8\x85_|\x89\x17\x90%\xc8\x0e?\x8a<\xb7\x9fptE\xce\x00\x063!\xea\x14麘\xe17eP\x1c\u007f\x13e\xac\x8ar\xdec\x9e\b\x98\x06(\xaa\xae)\xdb2K\xc9\xd9\xcc\xee\x88\x1c]V!\x95m\xf8ٍ\xf1%^@\x96 5\xfc\xa6\xaeK\xfb_\xc4\xd15\xa0\xbb\xb9{3p\xce/\xd4u1\xc3oʠ\xd8\xfe&\xdaX\x15\xe5\x84\xc7̑遠\xea\x1a\x82'\xa2\x94\x9c\xcd\xec\x8e\xc8\xd1e\x15Rن\x9f\xd3\x18W\xe2\x05d\t2\xc3O\xe8\xba\x10\xe1\xe8\xba\xe1\xc5G\xac\xda\a\x80\xb2\x11\xea\xbaXB*\xc2\a\xc3\xf67\xd1ƪ(\x97\xc8=\xbf\x11~\xaa\xae\x91m\xa2\xf4R̞\x1fwG\xe4\xe8\xb2\n\xa9l\xc3\xcfn\x8c/\xf1\x02\xb2\x04\x99\xe1'u]\x84\xa3+\xac\xfd\x1c\xcc\xc0\xe7\xfcb]\x17KHE\x84\x9f\xedo\xa2\x8dUQB˶\xe0D\x1f\xc2\x1f)\x98\xe1\xa7\xea\x1a\xc1#J\xc9\xd9\xcc\xee\b\x1d]\x16\xfd\x95m\xf8ٍ\xd1\x12\xaf;\xafM  ː\x1a~B\xd7E:\xba\x02탷\a3q\x87\x9fX\xd7\xc5\x10R\x912(\xb6\xbf\x890V\x91\\Z\xb0\xe6\xd4\xf9C\xea\xc98i\x802\xeb҂'\xb3\x05c6\xb2;BG\x17!\xa4\"\\Z\x89\b\xbfh\x89\xd7N\xcf3\b\xc82\xa4\x86\x9f\xd4u\x91\x8e\xae@_{o\x06\xb2/\xd6u1\x84T\x94\f\x8am\xee\"\x8cU\x14\x13\xbb\x1e{d\xe3۴\x01ʬK\n\x9e\xa8\x16\xa2\xb3\x91\xdd\x11;\xbaL!\x95\xe9\x90JH\xf8EK\xbcNW\x9e\xb6.\x01\x98\xed\xc8\r\xff\xccB\xb2\xae\v\x00f\x16N\x0e?|\x97\x17p4N\x0e?\x008\x1a\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b\xfft\ta\x8c_\x000k\x80\xf0O\x93\v9\x8a\xa2\xe4\x05\x83y\xea\xaf\x1c\xbf\xa86\x00\xcc\x1c \xfcӤ[\xf1\r\x0f\x8f#4><\xecS\xbaE\xb5\x01`\xe6 7\xfc\x1c]\x17B\x83\x19x\x8cO\"lSr8\xc1\xeeV\x8c/#\a\xf4\xf0\xf3\xeb\x02\xc0LBj\xf89\xba.\xfc\x87a\xfb93M\xc0\x9f\xdb\xcc\xfeKl\xf8\xb9u\aG\x99\xc5\x00\x90\x19\xa4\x86\x9f\xad\xebR\xe3\xd2=\xd3Ï\x90+\xee\xf0s\xeb.\xacg\x16\x03@f\x90\x1a~\xb6\xae\v\rz\a\u06dd\x10\xfe\xb2:f1\x00d\x06\xb9\xe1G,]\x17\n\x05\xa3\xe2\x0e\xa9t+\x8aҌ\x9a՟\xdd(XW\xe4*^yU-\xbd:WQ\xf6\xdc\\?/o9\xfd\xc1\x9dk{c\x91{\xe5MF+\x8c\xf0G\xeb\xfa\xd4ƛ\xf4E\xe0IL\x99V\xa3sq\xfe\xfc\x1d\xb4f\x03\x00$#9\xfc,]\x17&\x13\xe1\x0f\xfa\v\xf6L\xa2\xc9=n\u007fPM铃\xdd+s\x86\U0007314f\x17\xcf/(ޱ\xde\f\xb5\x86K)\xeb\xea*\xcb\x1b\xb7\xb6\xc2\f\u007f\xb4n\xf0B\xf16u\x11\xcd\x05\xfe`\xf0\x82\u007f~\x95\xdf\xef\u05eel6\xe6l\xf7\xb5\x16\x96\xc9\u007f^1\x00\x98H\x0e?Kׅ\xc9D\xf8\xd5\f\xe2\x93\xf0\xfaF\xf5G\xb0\x1b\xbf#\x95=\xa1\x15\x97)Kc\xf4W\xc8U\x82\xef䙿\xd8\xda\x063\xfcf\xddf\xbc\xa7_ߨ\x15\x1b\x87\xfd>\xa5C\xfd9\xact!\x00\xc8\x1c\xb2Ïbu]\x98̄\u007f0/\x88\x82y\x9aId\xaau\xf9\xbc\x82\xc81y\x99\x8b\xf1(aW\x13\xfe\xe9U\xa6,\xe5\xcc\xf0\x9bu\x03\xca8\n\x15\fh\xc5F\xf8\xeb\xe7i\xf7\x03\x167\"\x00\xc8\x1cR\xc3\xcf\xd6ua2\x13\xfe\x90\xfb$\xeau\xe3\xce\f\x17\x167\x9d\xf4WE\xc2_ƨ\xab_\xc4\xf3+֏\xeb\xf8\x17\xfc\xf4\xba+v\xa0>\xb7~\xf9\xc0\b\u007fY\xe4\xfc\xff\t\x04\x00\x99Cf\xf89\xba.Lf\u008f\xb6?\x81\x9e؎'J\x16\xe3\xa3\xfc\xbaH\xf8YW\xe5];\xf0\xcfv\xc5z\x95\x8e\x19~\xa2\xae\xcf\x1dj\x8c\xec\xe1\xb5v\xb1\x9cd\xfd\xbcQ\r\xebQ\x04\x00\xc8Df\xf89\xba.L\x86\xc2?\xe4\n\xb8\x86\xf0D1\xcee\xb8\xcc.\xfc\xc5\xf8<\xbe\xa4\xcaZ\xce\f?Q7\xe4\xf6\xb9#kY\xa5\x16L\xe2:}z\xc5=\a\xad\x8d\x01\x80D\xa4\x86\x9f\xa3\xeb\n\x05\x02\x1d\x83\x81I\xd1\xdci \\\xb4\xbcH;\x05iV\xeaZ\x0f\x96)\ue5a1АvU\xfe\xb6\xb5\xaaKY>4\xb8\xd8\x1dSξ\xdaO\xd4m\x9a\x179\xeaGͮ\x96ޥ\xf9\xb8z\x93R\xdf\xddۨtZ\x1b\x03\x00\x89H\r?G\xd7u٫\x91\x89\x8f\xbd[\\-\xda\xefp\xcb|Wa}\xc7<W\xd5\xd5\x1c\xedt|\x85\xb5fIs]A\xd1\xfa\xd8+\x81\xdd\xca\xcd\xe8WzoF\xc3Oս\xa9<\x19\xa9\x1a\xda\xeeΫ\xd2\x0fq\xfa\xaa\xdc\xee\xc5}1\x8d\x01\x80D\xe4\x86?\v\xd1nމ|\xa5W\xf11*\x04]\x83\b\x00f \x10\xfei\x12\xba:\x1c\xfdJ\xef\xf0U\xd6\xd3<\xbaݬR\x00\xc88\x10\xfe\xb4\xd2<\x88\x96r\xbe\x14\x00\x00\x19\x06\u009fN\x82Jٶ\xa2L\\\xcb\x00\x001\x10\xfe\xb4Ҝ_5\xc3\x1fS\x028\x17\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\b?\x008\x14\xb9\xe1g뺂\xfe\xee\xf6^\xe6\x97b\x00\x00H\x1bR\xc3\xcf\xd6u\x05;z\xc7o_\xee\xe8\x85\xf4\x03\x80L\xa4\x86\x9f\xad\xeb\x1a\xec\xc6\xcf\xf4\x98\x8az\xfb\x00\x00\x90\x82\xd4\xf0\xb3u]'\xf5\xe7\xdf\f\xb2\x9e\x84\x01\x00@\xba\x90\x1b~\xc4\xd2u\x05\xf4\xe7]]x\xc3n6\x00\x00R\x8c\xe4\xf0\xf3t]\b\x85\x8f\xfb\xf9\xb3\x01\x00\x90r$\x87\x9f\xa7\xebR\xdf\r:\xe0)\xf6\x00 \x13\xd9\xe1Gl]\x17\x1a\xf2\xc6<\x14\x1b\x00\x80t\"5\xfc\\]Wh\xd0\v\x0f\xbc\x01\x00\xb9\xc8\f?W\xd7\x15\xf4u2Ԙ\x00\x00\xa4\x13\x99\xe1\xe7麦\xbaN\xe2\xdb~\xe0&\x1f\x00\x90\x89\xd4\xf0\xb3u]\x81\xf6\xaeہ@\xe0\x82q\xed\x0f\x00\x00\tH\r?[\xd7էۺ\xbcp\x93\x0f\x00\xc8Dn\xf8\x01\x00\x981@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\xb3\x9a\xb0\xa8\x02\xe0` \xfc\xd9K\xa0\xb1PyBT\tp.\x10\xfe\xac%\\R\xe2\x1d\x80\x87\xa4\x00\\䆟\xad\xeb\"Je3\xb5\xad0oE\x9c\xc7\xc6\x03\x85\xb3\xebK\xc7W\x95>Q\x15\xc0\xd1H\r?[\xd7E\x94Jgi\xa1\xb71/\xce\x05\xfb\xf2g\x97Y`X\x81\x87\xa1\x03vH\r?[\xd7E\x94\xcafJiE\xe18\xb3?뮞\r+C\xa2*\x80\xa3\x91\x1a~\xb6\xae\x8b(\x95\xcdMev\x1d\xc9'\x04\x84\x1f\xb0Gn\xf8\x11K\xd7E\x94J%\xe4V4vh\xffk-\xcb+kU\u007f_\x9d\xab({n\xae\x9f\x97\xb7\x9cz\xa0h0OQr\x8e3Z1\xb9]\xe7\xce-\\\x11\xf3\x16\xd6Q\xe8ſ\x02\x05\xfaҔ\x02\xb2\x06\xb9\xb4`]\x91\xabx\xe5U\xb5t\x9b\x92\xeb\xdd1?o\xb9Vsj\xbd\xbbx\xc7\x0ew>~\xc4a\xe7\xe2\xfc\xf9;\xacG*c\xfb6ծݷ遥\x18\rB\xf8\x01[$\x87\x9f\xad\xeb2J\xe5\xf2\xbe\xbfKi\xf6\xfb\xb5\x885\xba\xf6\xf8\xf6\xb8\xd6\xe3g\v\x1f/\x9e_P\xbcc\xbdB\xc7\xf8\xb2\xdf\xefjf6\x13a0\xbf\xace\xa0Yi\xb1\x96?\xa1,ǿB\x1d\xad:\x1d\xe4\x9b\n\xb94\x9f\xf2\xe4`\xf7ʜa\x84n\x1c\x9f\xab\x146\xb7\x14\xd4\xe1\x1a%E\xadͮ\xbc\xf6\xe5jÍ9\xdb}\xad\x85e\xf4\xbb\xe4\xc7\u007f\xf6ҹ+g\xd7V\xff\x8e*\rM\x0e.t\xcb\x1fR`6!9\xfc\x1c]W\xb4T6\xc6a\u007f\x9fve\\\xff\x89ʔ\xa5\xc1\xc8\xc9\bE\x9e]\xf8C\xc5\xf8P!\xd4\x1d#\x1d\xbb}Pw\x11M\xde֙\xb4\xfc\xddXZ\xb0\x1b/\xb2L\xfbd\xde\xe5V\xdfz\xd6\x17\xaaS]\x8az,Ъ\x8c\xab\x93>\xa5\x03\xe1\xa3\xf9.j\xfe3\r8\xf6gV\xd3{\xfe'\xd4c\x8c,>\xa5\x01R\x81\xec\xf0#\x8e\xae+R*\x19#\xfc\x8d%گ\x92F\xfc\xb3\xccž\xfc`\x1b~\x9f\xf2\xbe\xcd_\xd5\xf7\x00%\x8a\xc5Kf.m\xaau\xf9\xbc\x02\xa5\fO\xbapG\x9a]\xea\x8f&7\xc2\xfd\xc4\xe3T?/\x84)n\xa4\xe6\xff\xb2aӱ\xb3\x9f>\xf8\x96*D\x81>o\t\xec\xf9\x01[\xa4\x86\x9f\xad\xeb\xa2K\xa5b\x84\u007f\xf1J\xed\u05ca\x85\xf8gY\x19\xbb\xb6m\xf8[\x14\x81t\xc4\xefӱ~\xfef,m\xb8\xb0\xb8餿J\x0f?^\x94\x16\xfe\x16e\n\x1f\x92\xe0=\u007fY\xe4\xdd\xc3r\xd7\xde\xfd\xb3/l\xad^\xdb\x13s\xce\xefW\x86\xadE\x00@ 3\xfcl]\x17U*\x19s\xcf?O\xfb5O\xdf\xf3ױkۆ\u007f@\x19\xb5\xf9\xab\r\xc6\xd2J\x16\xe3=u\x9d%\xfc\x81\x9c\x15\x81\xab\xf3\x17\xe3\xb1Y?oT\x83>\xb3\xb8\xf5\xaa\x1a\xfb\xfb\xe7j\xcf \vp\xb5\x1f\xb0Gf\xf89\xba.\xa2T6F\xf8}ډt\x97\xfe_q\xf8o7\xc7$=XT\x85\xdf϶o\xb7\xfe!z\xce\xcf\xc3XZ1\x9e\b\x97Y\xc2?\xaa\x14*J\x95vfЧhWH\xf6\x1c\xa4\xe6奄\x82\u007f\xed>\x82,@\xf8\x01{\xa4\x86\x9f\xad\xeb\"J\xe5\xa2_\xed\x1f\xd2\x0e8\xd6\xe74\xf9\x9ar\xf0\xd5\xfe!\xff\xfc*\xbf\xdf\x1aX\xb5\xd8\xefj\xf4\xfb\xf5N\xaeT\xf2cz;\xf8\xbd\x12\xafo\xbb\xd2n-_\xa9\xac\xb0\x16\x99\x90KkV\xeaZ\x0f\x96)\ue5a1\x80?\xb7q\b\x8d6\xe6\xfa\x03h\xd45\xe0\xf3\a\xf4\x83\xa2&\xa5\xbe\xbb\xb7Q餚詮\xedy\xf7ݗ\xaaǬm_V.X\x8b\x00\x80@j\xf8ٺ.\xb2T&\x91\xcf\xf9\xe7jw\x16\x86\xb5\xcf\xf9\xd5\xfe\\\xcd\xd1J\xad\x81\x1d\u058b\x15\xed3{Ԟ\xcf8\x9f\xbeYW\\\xb0\xf0dLq\xe4s~6\xe4\xd2\xc2-\xf3]\x85\xf5\x1d\xf3\\U\xdbԢ\xdc\xf1|\xf5\xe76t\xc1\x85+\xe4V\xe1\x93~\xd4W\xe5v/\xb6ܱ\u007fvwϦچ\xdd1\xd9G\x93s\xeb\xaeN\xca?\x95\x02f\rrß5\xf4*\x92\x8eS&\xf3\xb7M\x86B\xc1\xe1\xba$.\xdd\xf7\x96\xc4\\\x1c\x04\x00\x13\b\u007f\x12\x84;\xdcO\x8a꤈^\xb7\xbe\xef\x0e\xbb\x93\xf9\xd4~\xf2j\x06\xee\x99\x06f\v\x10\xfe$\b\xb8w\xc8:I\x19\xcdю\xf7\xd1x\x8e\xfdm\x04\x00\x900\x10\xfe\x99M\xb81\xefɮ\xc1\xae'\xf3d\x1dj\x00\xce\x01\xc2?\xd3\xf1-/r\x15-O\xe6\xa0\x1f\x00l\x81\xf0\x03\x80C\x81\xf0g%\xffh\"\xaa\n8\x16\b\u007fV\x02\xe1\a\xc4@\xf8\xb3\x12\b? \x06\u009f\x95@\xf8\x011\x10\xfe\xac\x04\xc2\x0f\x88\x81\xf0g%\x10~@\f\x84?+\x81\xf0\x03b \xfcYI$\xf8\xff\xf5?\xfd\x03\x15\xfe\xa9Ž\b\x00\"\xc8\r?[ץ2\xee\x85[\xd8\x12\xe4Jû\xfc?\xea\xd9\xff\x9b꿲\xec\xf9[r\xe8'\x81\x00NFj\xf8ٺ.\x95`\xfb\x05\xfa\t\x15\x80\x90wk\xcf\xf1\xff\xa8g\xbf\xf6\xbf\xc6\x1c\xf6\xfb液\xe7\x00\x9c\x87\xd4\xf0\xb3u]*\xbe\x81\x00\x84?Qb\x9e\xd8i\x12\xfeǟ\xfd\xe3?\xfe\u007f\xb5\u007f\xc58\xe7\xdf\xc3y41\xe0<\xa4\x86\x9f\xa3\xebB\xe3\x1dA\b\u007f\n\xb9Y\xf6\xc7\u007f\xfc\xef\xff8\xe7\xff\xf8?\u007f\x16\x1b\xfe`\x11\xfd\xe4o\xc0\xb9\xc8\r?b꺂\xed7Q\x16\x85\x9f#\xfcB\xf6\xe6\xae߭\xad}\xb5\xa1a\xec\xd8\xea\xdd\xf7\x11\xba\xffBC\xed\xa6}\xb7\xd4\xe2#յg^jX\xbd\xef3j\x12ݯ\xad\xae\xae\xd6\x0e\xfb\xd5ҳǶ\xd6\xee\xfb-\xfe\xcf\xfd\x17\xd76\xbc\xfa\xea\xda\u007f\xa3TU\xcdɫZ8\xe7\xcf\u007f\xa6\x85\xff\xb3\x17\xd6\xd66\xe85\xd4]\u007f\x9e\xacg\x11\x003\x1c\xc9\xe1g\xea\xba|\x03(\x9b\xc2\xcf\x13~\t\xcc]c\xab\xab\x8f\xed\xae^۳\xf6\x8cz>_\xfd\xd2ع}\xd5\x1f#t\xeb\\m\xf5\xa6\x9e\x9eM\xb5\xb7\xc8I\xb5|l\xac\xb6\aφK\x1bzzV\xbf\xa0N\u007f\xbb\xb5\xe1LOm\xed\x99\xff\xf5\xe0\xef\u007f\u007f\xe3\u007f\xfe\xfe\xf7\x0f\xfd\xfb\u007f\xc0\xe1\x1f\xab}\xb6\xe7JOu\xe4\xd9\xde\x17\u087e\x80\x8e\xe4\xf0\xb3t]7\xf0\xbbA\x16\x85\x1fq\x85_\xf6殆\x17ѕ\xeaw\xd1K/\xe1\xc7\xf0\xab\xbb\xff\a?ƁF\xb5\x9b\xf0\xa1\xc0\xa6g\xe9I\xfc\xbf\x9e\xc8\xef\xd5\xea>\xfd\xc5\x06u\xea\\\xb5\xfa\xbep\xa6\xfa\xe3\x929s\xe6\x84\xeb\xe7\xcc\xf9Ο\xe3\xf0\u007f\xbbi߷\xea\x1b\x03n\x12\x13P\xde@\x00\x80\xe4\x87\x1f\xc5躂\xed7\xc2\xe1\xf5殛\x00\x00\r\xefIDATp\xa03\x9cE\x0f\x9a\xe5\t\xbft8殆s\xe8\xe3\xea\xfb\xe8\xd5\x17\xd5\xe9\xfbg\xf6mZ]\xfdc\\\\\xfb*\xfeyF\xfd\v9\x89\x88\xf0\xab\xef\x16\xa8\xa7V\xfd\xf1\xeaj\xf5\xc7o\xaa\xdf\rl\xffc5\xfc\xff˿\xfb\xf3\xff\x86\x0f\xfb\xafT\u007fJ.&`q\xfd\x01\x8eEj\xf8\x99\xba\xae\xdb\xde(\xd9s\x19\x9a'\xfc\x8a\xc06w5\\A\x1f\xab\x11\xc6\xe1\xff\xb8aӫ\xef\x8e\xed\xd6ïe|\f\xefԉID\x84\x1f\xff\xd6\xc2\u007f\xe6\xcfԷ\x85+շ\xc2\xc1?W\xc3\xffo\xfe\xdf\u007f\xd0.\xf8\x9d\xa9\xa6<~\xc3\xf08\u007f@Gf\xf89\xba\xae\xa9I\x95\xf1\x8e\xc9,z\xc6<\xcf\xf9c\v\x11\xfe\xad\xcf\xe2\x9d\xfb\vz\xf8\x8f\xe1\x9fg\xb5=\xbf9\x89X\xe1\xff\xb2zߗ\xb7\xb6\xee~\x80\xd0\u007f\xc1\xe1\xff\xcf?\xd3>\xea\xbb\x12y\xb3\x88\xd0\xecJ\xfc!\xe0@V\"3\xfc\x1c]\x97F\x96\x9d\xf3\xb3\xc3oo\xee\"¿\t\x9f\xed?\xf8\xb1\x1e\xfe\xb5ډ\xfenz\x12\xb1\xc2\u007f\xabzmu\xf5n|U\x1f\x87\xff\x0f\xff\x93\x1e\xfe\xfb\r\xbb\xf1\xae\xff\x98\xf6\u0381\xc2%6\x02!\xc0QH\r?[ץ\x12\x0e\x8cw\x04b\xcc\xf6\xb3\x14\x8e\xf0\v\t\xcc]\xb7V\x9f\xb9\u007f\xae\xf6\xd6\xfd\x17\xd5\xf4\xf6T\xbfp\xa6\xe7\xc7\xd5k{\xc6\xd4lW?{\xee\xec\xd6տA\xe4\xe4\xb7ccc\xb5G\xc6\xc6\xee\xa3/\xf1\xef\a\x9f\x1e\xa9\x1d\xfb\x12ݪ\xbdre\xec\xb7\xf8\xe6\x1f\x1c\xfe\xff\xed?\xfc\x8d~\x93\xcfX\xedֳW\x8eU\x9f\xd5\x16Ӓ\xacP\x14\xc8:\xa4\x86\x9f\xa3\xebR\xcb\xf1)\xffq\xfe|\xb3\n\x8e\xf0\vٛ\xbb\x1e\xa8;\xeds\xab\xabk\xcfUW\xbf\x80\x1e\x9c\xd9Z\xdb\xf0\xe2٭\xb5\xbb\xf1\xb1\xfeK\xab\x1b^\xfc\x12\xd71'?\xae\xd69\x8b\x8e\xa8?k?\xc5\x1f\xfb\x1fQS\x8e\xcbjw\xdf\xd2\xc2\xff\xbf\xff\xe7\xff\xeb\xbf\xeb7\xf9\xfc慆\xd5\xcf\xea\xdf\x04\xf0\xe7\xed\xe0v\x01p\x18r\xc3\x0f$N\xf4螞d\xf1\xaf\xb5G\xfe\xf5w\xbf\xbb\xff\xf1\v\xab\xefk\xe1\xffo\u007f\x85o\ue9eat\xb9\x1a\xe1\x16\x1f \x02\x84\u007f\xa6\x13\u007f\xf8\xdf]\xad\xdf\xee\xff`\xed\x15=\xfc?\xfb\x9b\xff\xdb\xf2\x95\xde\"\xf8R\x1f`\x00\xe1\x9f\xe9\xc4\x1f\xfe[\x91\xcb\xfa\xb7\xaa?\xfd\xb7\xf8j\xff\u007f\xd0\xce\x02lg\x01\x9c\f\x84\u007ff\xf3[\xedz\x9eu\x92̓\x97j\x8f\x9c\x1b;w\xa4\xf6\xa5\a\x10~@\f\x84\u007ff\xa3]\xcf\xfb\xcc:\xc9\xe1\xc1\xbb\xfb\x1aj\x1b\xf6\xbd\xfb\x00E\x0e\xfb\xe11^\x80\r\x10\xfe\xac\x04\xc2\x0f\x88\x81\xf0g%\x10~@\f\x84?\v\t\xb5\xd6\xe1;\xfc\x9a.\xc0\xc7z\x80\r\x10\xfe\xec#\xbc8\xfa\x95ޓ\x90~\x80\x0f\x84?\xfb\b=t\xf0\xf7\xbf\xff\x9f\xea\x06z\xe8\t\xf8\x0e\x0f\xc0\a\u009f}\x04\x15\xa5\xaa\xea\xa1ª\x85s\x1a\xb3\xe5\xfb\x12@:\x80\xf0g\x1f!\u007f\xb1\xdb=\xdf\xedv/\x1d\x86=?\xc0\a\u009f\x85\x84\x02\xdaS\u0086\xea\n\x95'Du\x01\xe7\x02\xe1\xcfF\xc2\xe1\x90\xfao\xfe|\xef@\xf6<\x1d\tH9r\xc3\xcf\xd4u\x85:\xb4\x87xudӕ\xe9\x81BC?6\xb5\xad0o\x05\xf5\x90\xa2#\x91\xa7nO\x8f\xe8\"\x1a\x15EɻɨpU\xe9c\x94\x02@\x14\xa9\xe1g뺂\xde\xf7\x03*\xf4\xa3lg9\xbe|\xe3\x11\xb9K\v\xbd\x8dyԹ\xf7o\xc7\x04\xdfЉ\x8b\xe8\"\x02~\u007f+\xf3i\xdc\xc3\n\xfd\x8c@\x00\xa0\x91\x1a~\xb6\xae+\x98EO\xee40v\xf5SJ+\n[\xaf\xbb\xa5\"\xfc\xe6\"Ԙ\x0f1\xfe\xce,\x9d\x932b\xdb\x06f\x19R\xc3\xcf\xd6uee\xf8\rn*\f\xffpJ\xc2o\x92H\xf8\xbfI\x11\x10\xfeُ\xdc\xf0#\x96\xae+\xeb\xc2\x1f\xccS\x94\x9c\xe3x*\xe4֟\xcfo}tV\xed\xb1\xa8w˄\x90x1}^h\x9b\x92\xeb\xdd1?o\xb9v\xf4d,\x02\xc3\x0e\xff \x84\x1f\xb0Er\xf8Y\xba\xae\xa0w\xe0\r\xefq\u007f\x16]\xef\xbb\xec\xf7\xbb\x9a\xb5\xa9\xf7\xfd]J\xb3\xdfo}w\xc3O\xe2<\xf7\xe3Z\xea\x91ڄċ\xed\xf3\xbaq|\xaeR\xd8\xdcR\xa0=\x19\xd8\\\x04b\x86?49\xb8\xd0\xcd\xf8\x94\x1f\xc2\x0f\x18H\x0e?K\xd7\x15\xf4v^\r\xdc\xe8\xeeʢ\xf4#\x94\x17M&\xfb\xb0\u007f+\x16hm}\x96*$$^l\x9f\x17r\xb9\xd5w\x91\xf5\x85\x91\xff\xe5م\xff\t\xf5\xb8\x81\xb1`\b?`\";\xfc(Fׅ\xc2\xe3\xfaA\xc0\x90`\xbeY\x85 \xfc\x9aw+j\xdf\xd0!$^\x1c\x9f\x17ra\xbbv\xb3+\xf2?\xdb\xf0\a\xfa\xbc%\xd3\xda\xf3\xcf\xd1\xfe\xd9\xfc=\xb6m`\x96!5\xfcL]W\x14\xffI\xf6L\xb3\x13A\xf8)\xefV\x04B\xe2\xc5\xf6y!\xed@?\xbe\xf0\xab\xf8\x95\xe1\xd8B\x1c\xe87\xffH\x8f\xf5\xbf\xfc\xe5\xc3s\xbe\xffS^\xb8!\xfcY\x8f\xcc\xf0\xb3u]h@O\xc7 \xeb(u\xd6\"\b?\xe5݊\x9b\xc4\xc2Ͻ\xda\xff\x837\xf5X\xff\xc5\x0f~\xf9\xc5/\xff\xe4\x17\x9cpC\xf8\xb3\x1e\x99\xe1\xe7\xe8\xba|\xda.\u007f\xaa\xe3}\xdbyg\x19\x82\xf07h\xe7\xfc\xbbc\xffbK\x8a\xc2\x1f\x8d\xf5\x1f\xfeJ\xfd\xf1\xab\xff\x18I\xf3O\xbf?\xe7\xe1\xbf\xfb\xe6\x9b_\xfe\xf0\xa1\xef\xfc\xf0\xd7F\xf8\u007f\xfa\xdd9\x0f\xff\xe57Ą\xfa\xf79\xdf\xff{\b\u007f6 5\xfcl]W\xc0\xdbw3p\xb9ݗ5\x9e\xceА\xdf\xefj\xf4\xfb\x83ѫ\xfdC\xd6U\xab\xad\xde76\xf6\xac\xa6\xe0\x8a\x9f\x80?\xb7q\b\x8d6\xe6\xfa\x03\xe4\"\xb4;\xfcZb?Q@\x97Y:\xde\xd8\xf0?\x1c\xc9\xfe\x1f\xfe\xf4\x8b_\xaao\x04\xdf\u007f\xf3\x8b_\xff\xe9\x9fF\xc3\xff?\xbe\xff?ԃ\x83\xbf$&\xbe\xff\u05ff\xfe\x97_\xfc\x10\u009f\rH\r?G\xd759p\xbc\xc37\x9e5\xd9Gú\xafK\xf1F?\xe7\x9f{\xc3Rck\xcf\vQ\x05W\xfclS[\xca\x1d\xcfW\u007fn#\x16\xa1\xddۏ\xa9\xb7֟\x9c[w5\xc6|L\x86_?\xec\x8f\x1c\xdc\xff\xd1\xdf\u007fc\xf0뇣\xe1\xff\xc1/\"\xef\x0f\xc6\xc4w~\xa5ׁ\xf0\xcf~\xe4\x86\x1f\x90Io\x89\x12\xf3\x95^2\xfc\xf8\x82\xdf\xc3\u007f\x17\t\xff\x9c_\xeb\xbf\u007f\xa5\x1e\xd6ϙ\x13\r\xffC\xfa\xad\xbc\xc4\xc4_<\xf4\xa7\u007f\xf7+\b\u007fV\x00\xe1\xcff&\xafZO\x06\xc8\xf0k\xbc\xf9]\xfd\xf7C\x91\xf0\xff\xe0/~\xf5\xcd\x17F\xf8\xe7D\xf6\xf3\xe6\xc47\xbf\xf8\xeb\x1f>\xf4\xd7\x10\xfel\x00\xc2\xef,b\xc2\xffÿ\x8c\x84>r\xd8\xff\x9d/\xd4\x13|#\xfc\u007f\xf4\xb7\x91j\xc6\x04\xe6\x97߁\xf0g\x03\x10~gA\x86\xffO~\xf1/\xbf\xfc\xd3?\xfa\x17=\xd0o>\x1c\xb9\xe0\xf7\xd7_\xfc\xe2\xbbF\xf8\xdf|\xe8\xef~\xfdś\u007fBL\xfc\xc9O\xbf\xf8\xe2o\xbf\x0f\xe1\xcf\x06 \xfc\xce\x02\xc7>r\xf6\xfe\xcd\xdf\u007f\xf7\x0f\x1e\xfe\x8b/\xa2\xbb\xf3\xbf\xff\xae\xf6Q\xdf/\xbe?\xe7\xe1\xbf5\xc2\xff͛?\xf8Μ\x1f\xbcIL\xfc\xf4\as\x1e\xfa\xe1/!\xfc\xd9\x00\x84\xdfY\x10\a\xfc\xd3\x03\xc2?\xfb\x81\xf0;\v\b?`\x00\xe1w\x16\x10~\xc0\x00\xc2\xef, \xfc\x80\x01\x84\xdfY@\xf8\x01\x03\b\xbf\xb3`?\x8c3\x19DK\x02f<\x10~\xc0\x96\xec\xf9\xca\x05`\x05\xc2\x0f\xf0\t4\x82\xf0+\x8b\x81\xf0\x03\\\xc2%% \xfc\xcab䆟\xa9\xebR\xb9\xd1\xd7\xd1}\xd9f> \x82\xad\x06,\xe5\x80\xf0+\xbb\x91\x1a~\xb6\xae\v\x85\x06\xbcC\xb7G\xbd\xf4\xc3*\x01\x16\xb6\x1a\xb0\x94\x03¯\xecFj\xf8ٺ.4\xd0\x1e\xc0o\f\xd6'^\x00\f\xec5`)\x86\xfdx0 [\x90\x1a~\xb6\xae+\xe0}\xdf\xf8\x1b\x10/\xccg\x03\xa6\x18\b\u007fv#7\xfc\x88\xa5\xeb\x1aj\x0f\xc1\aJ\xf1 Ҁݪ\xad\xae~\xf5\xb3\x177\xd5\xee\xfb\x1dQ*Ԁ\xa9|\xf6\xc2\xdaچ}\xbfE\x16\x98\xc2/ k\x90\x1c~\x96\xae\xab\xd7w\xe3\xa4\xf7\xf8\x85\xac\x12\xf6\xa4\a\x81\x06\xec\xdbs\xe76m]\xddp\xec\xc5?#\x9f\x0e(Ԁ!4V\xfblϕ\x9e\xea3T!O\xf8\x05d\r\x92\xc3\xcf\xd2uuk\xba\xae\xe3ݐ\xfe8\xb0\u007f$8\xfaq\xf5\xee\xfb\xe8\x01\xad\x03\x10j\xc0\xbeݴ\x0f?I\xfc\x1c=\x1bO\xf8\x05d\r\xb2Ïbu]>\xed\xaa_\xb0\x83\xe1\x97\x01\xac\x88\xc2_\x1b\xf3H`\xb1\x06\xecJ\xf5\xa7֙\x10_\xf8\x05d\rR\xc3\xcf\xd6u\rꞮ\xc1^\xfe\x8c@\x14Q\xf8i\xf7\xa7\x86P\x03v\xa6\xfa\xdbع\xb49Y\xc2/ k\x90\x19~\x8e\xaek\xb4C{/\x18\x80c\xcc8\x10\x85\xff\x05F\xa1\x88+\xb43\xd0\x04\xae\xf6g72\xc3\xcf\xd1uMi\x1f\xf5\x05\xdb\xe1\x16\xbf8HG\xf8\xef7\xecƻ\xfecǬ\u007f\x80\xf0g7R\xc3\xcf\xd6u\xa1\xcb\xed\x97\x03\xe3\x9d'႟\x00\x91\x06\xecwcc[w\x8f\x8d}ƙ\x9d\xcfX\xedֳW\x8eU\x9f\xb5\x963\x85_@\xd6 5\xfc\x1c]\x17\xba\xdd\xdbq\xf22d_\x84H\x03v\xabZc\x1fgv\x1b~\xf3B\xc3\xeagߍ)f\n\xbf\x80\xacAn\xf8\x81\xd9\x05K\xf8\x05d\r\x10~\xc0\x8eX\xe1\x17\x905@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1\xc8\r?K\xd7\x15\xea\xf4\xea\x1c\xb7\x9f\x17\x98!\x10\xca0`V#5\xfcL]W\xc8;\x1aP\xb9\xec\xbd*\x9a\x1d\xc8\x18\x83\xa3\xe64\xa1\f\x03f5R\xc3\xcf\xd6u\x8dk\x0f\xef턇\xc6\xcc`\x16\xd6\x13\xff\x81\xc7{d\tR\xc3\xcf\xd6ui\xf8ހ'\xf9\xcc`\xca\xeaD5\x80ه\xdc\xf0#\x96\xae\v\xa3=\xcf\x13\xc8\x14\xb7\xebܹ\x85+\xb4\xc7v\xb4\x96啵\xaa\xbf\xb7)\xb9\xde\x1d\xf3\xf3\x96\xe37\xea\xc8\xc3\xfe\xcb\x10\xa9\f#*lSr:\xd1m\x97R\xa25ֹ8\u007f\xfe\x0ex\xe0\xff,@r\xf8Y\xba.\x8c\xe6\xf1\x002\xc4`~Y\xcb@\xb3ҢN6\xba\xf6\xf8\xf6\xb8֫o\xc7\xc7\xe7*\x85\xcd-\x05\xea.?x\xc1?\xbf\xca\xef\xf7kO\f4\x94aD\x85\x80?W-\x1ajt\xe1\xf2Ɯ\xed\xbe\xd6\xc2287\x98\xf9H\x0e?Kׅ\xa2\x17\x03\x80\xcc\x10*^\x1e\xc2OT\x9fB\xa8O\xc1\xa7c\xfaO\x97[\xdd(\xeb\v\xb5*\xd4a\u007f\xf4\xf1\xe1D\x05\xed\xfd\xa0\x19\x87ߧt \xfc\xd0\xef.\x04\xcctd\x87\x1f\xc5\xea\xbaT\x06\xba\xedg\x01҉Oy?:٨\x1f\xb9\x974\xaa?\\\xf8\x87\x16h^\xf8\xcd\nf\xf8\xeb\xe7\x850ō\b\x98\xe9H\r?[ץ\xd2\x01\u008e\fҢ\x18\x17[\x17\xaf\xd4~\xadX\x88\xc8@\xf3\xc2oV0'\xcb\"\x17\b\u087f3\x1f\x99\xe1\xe7\xe8\xba\xf0\x95\x00J\x1c\t\xc8e@1>\xc5o\x9c\xa7\xfd\x9a\xa7\xed\xf9\xad\xe1o\x8f\x9c\x9b\xf1¿\aO\xae\x9f7\xaa1\x85\x80\x99\x8e\xcc\xf0st]\xf8\x94\x1f.\x0eg\x90`Q\x15~+\u07be\x1d\x9f\x01\xe0s\xf5.M\x05F\x86\xbf\xaa\n\xa1I%rr\xc6\b\u007f^\x93\xfa\u07be\x10O\xf6\xe9\xb5\xf6\x1cD\xc0LGj\xf89\xba.\xf5\x9d\x00>\xe4\xcf$\x83\xdf+\xf1\xfa\xb6+\xed\xea\xe4\xfa\x9c&_S\xcez\xed\n~\xe3\x10\x1am\xcc\xf5\xe3\xfd}\xb3\xab\xa5wi~\x80T\x86Q\x15\x16\x17\x1e<\xb8X\x99\xdbq\x03\xa1&\xa5\xbe\xbb\xb7Q\xe9\x14-\x14\xc88R\xc3\xcf\xd5u\xc1\xfd\xa2\x99\xe5f]q\xc1B\xedSװ\xf69\u007f\x18\u007fv\xaf(\xb9\xe3\xf9\xea\xcfmjqh\xbb;\xaf\n\xfb\xbaMe\x18U\xe1fU^\xc1\xf2&\xbdn_\x95۽\xb8\xcfvy\xc0\x8c@n\xf8\x01\x00\x981@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8\x01\xc0\xa1@\xf8g\x0f\xf5\x8a{\xfd\rQ%\x00\x88\x17\b\xff\xec!0\xd8Q\xe2\x86'\x1f\x00\xa9Bn\xf8Y\xba.\xfct\xd87\xda߸\x00\xaf\xea8\x18T\xc0k\x04\xa4\n\xa9\xe1g\xea\xbaP\xb0\xf3$.\xed\x84\xf4\x8b\x19V\x86DU\x00 N\xa4\x86\x9f\xad\xeb\xf2wk\x8f\xf0\xef\xf6\v\xe6\x06 \xfc@*\x91\x1a~\xb6\xaek@\u007f|w/x;\xc4@\xf8\x81\xd4!7\xfc\x88\xa5\xeb\x9a\xea\x1c\x9c\nM\xf9;\xe1y\xafb\xae*\x83\xa2*\x00\x10'\x92\xc3\xcf\xd4u\x85\x06\xd4\xd2>x\x86g\x1c\x84\xdc\v/\x04\xc0\x84\x05\xa4\x04\xc9\xe1g\xe9\xbaB\x03\xdd\xf8\x99\xbe\x03\x90\xfe8\xe8S\x14e\xa5\xa8\x12\x00ă\xec\xf0\xa3X]W\xf4\x82\xdf\x05ь\x00\n\x16\xcek\x19\x04\xc3\t\x90\x12\xa4\x86\x9f\xa9\xeb\n\xb7\xeb\xa68\xcd\xe3\x03\xd83\xac\xc0eQ U\xc8\f?[\xd7\x15\r\xff(\x84_\f\\\xed\aR\x87\xcc\xf0st]\x83\x91\xc3~\xb8\x8e-\x06\xc2\x0f\xa4\x0e\xa9\xe1g\xeb\xbaB]\xdd\xe3\x81\xf1\xee.\xb8\xe0'f\b\xc2\x0f\xa4\f\xa9\xe1\xe7\xe8\xbaB\xc3';N\x0eC\xf6E\x84\x02\xa3\xf5\xae\x80\xa8\x16\x00ĉ\xdc\xf0\x03\xd3\xe1\tE)\xee\x15U\x02\x80x\x81\xf0\xcf\x1e\x02\xa3\xb0\xdb\aR\b\x84\x1f\x00\x1c\n\x84\x1f\x00\x1c\n\x84\x1f\x00\x1c\n\x84\x1f\x00\x1c\n\x84\x1f\x00\x1c\xca\xff\x0fL\f\x1em+\xfdz{\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/chan1.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x04\xc0\x00\x00\x02n\b\x03\x00\x00\x00aR\x8e\x00\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\a\n\a\x0f\x11\x0e\x1a\x1a\x14\x1f\x1f\x18!# #$\"\x15%D$%#%'%'(&+)\x1e()'*+)/,!+-*,-+-/,02/63(241564796<9.9;8#?r@=2<>;>@=C@4DA5AB@DFCFHELH:IKHKLJNOMUP?PRORTQTVSVWU]XGWYV_ZI,`\xaeZ[Y7]\xad[]Z\\^[9a\xab;b\xac<c\xad_a^faO>e\xafac`hcQcdbAg\xb2efdCi\xb4fheDl\xb0Mj\xafqjRikhGn\xb2Ip\xb4lmkKr\xb7npmUt\xb4{s\\rtqWv\xb6tvsuwt[y\xb9\\{\xbbxzw]~\xb8e|\xb8\x84|dX\x80\xbf{}za\u007f\xbf|~{~\x80}b\x82\xbc\u007f\x81~d\x84\xbf\x81\x83\x80|\x83\x97\x83\x85\x82l\x86\xbch\x88Ð\x86hn\x88\xbej\x8ać\x88\x86q\x8b\xc1\x89\x8a\x87t\x8e×\x8doz\x8e\xbf\x8c\x8e\x8b|\x90\xc1\x8e\x90\x8dx\x92Ȑ\x92\x8f~\x93ĝ\x93ux\x96Œ\x94\x90\x81\x95Ɠ\x95\x92{\x98Ȕ\x96\x94\xa2\x97y\x96\x98\x95\x81\x9aė\x99\x96\x84\x9cƇ\x9b̙\x9b\x98\x80\x9eͦ\x9c}\x87\x9fɜ\x9e\x9b\x89\xa1˞\xa0\x9d\xa0\xa2\x9f\xa1\xa3\xa0\xa2\xa4\xa1\x91\xa5ʏ\xa7Ѥ\xa6\xa3\x94\xa7̥\xa7\xa4\xb3\xa7\x83\x92\xaaԧ\xa9\xa6\x97\xaaϩ\xab\xa8\x9d\xac̫\xad\xaa\x9b\xaeӟ\xafλ\xae\x89\xad\xaf\xac\x9e\xb1ע\xb1ѯ\xb1\xae\xb1\xb3\xaf\xa5\xb4Ԣ\xb5۳\xb5\xb2ö\x91\xab\xb7ѵ\xb7\xb4\xa8\xb8ح\xb9ӷ\xb9\xb6\xb9\xbb\xb8\xb0\xbc\u05ed\xbdݻ\xbd\xba\xb3\xbeٽ\xbf\xbc\xb7\xbf\xd4\xcd\xc0\x9a\xbf\xc1\xbe\xb6\xc1ܹ\xc1\xd6\xc1ÿ\xbb\xc3\xd8\xc2\xc4\xc1\xbd\xc4ں\xc5\xe0\xc4\xc6\xc3\xc6\xc8\xc5\xc0\xc8\xdd\xd7ȝ\xbb\xca\u07bd\xc9\xe4\xc5\xc9\xd9\xc0\xcb\xe6\xca\xcc\xc8\xc7\xcb\xdb\xc2\xceܿ\xcf\xe2\xc9\xcd\xdd\xcd\xcf\xcc\xc9\xd0\xe6\xcc\xd0\xe0\xc6\xd2\xe0\xdfѤ\xcf\xd2\xce\xd1\xd3\xd0\xd2\xd3\xdd\xd3\xd5\xd2\xcd\xd5\xea\xce\xd7\xdf\xd5\xd7\xd4\xe6ת\xd6\xd8\xd5\xd1\xda\xe2\xd8\xda\xd6\xd9\xd9\xe4\xd3\xdc\xe4\xd5\xdb\xea\xda\xdc\xd9\xd8\xdd\xe0\xdc\xdd\xe7\xdc\xdf\xdb\xda\xdf\xe2\xe0\xde\xe2\xde\xe0\xdd\xf0\xe0\xb3\xd6\xe2\xf0\xdc\xe2\xe4\xe0\xe2\xdf\xde\xe3\xe6\xde\xe2\xf2\xe2\xe4\xe1\xe1\xe6\xe9\xe4\xe6\xe3\xde\xe7\xef\xe8\xe5\xea\xe5\xe7\xe4\xe6\xe8\xe5\xe4\xe9\xeb\xe7\xe9\xe6\xe8\xe8\xf3\xe8\xea\xe7\xe2\xeb\xf3\xe9\xeb\xe8\xec\xee\xeb\xe6\xef\xf7\xe8\xf1\xf9\xef\xf1\xee\xf0\xf0\xfb\xf1\xf3\xf0\xf1\xf6\xf9\xf4\xf6\xf3\xf7\xfa\xf6\xf5\xfa\xfd\xf9\xfb\xf8\xfa\xfc\xf9\xfd\xfb\xff\xf9\xfe\xff\xfc\xfe\xfb\xfe\xff\xfc\xc5\xe5[\xa2\x00\x00 \x00IDATx^\xec\xbdqLS[\xda\xef\xef93\x8b\xab}\x87Ax+\xc3}\xf5^8#\xbe\x1c\xbc^gk\xa9\x17\u007f\xe2A.U\xe1u^\x05މ9\xf6\xe8}\xc9\x18\xc5\x174z\x8fg<W\xb7i\x86\x1e\xa0D\x99`1\xbcD0\f\rp\x022\x04\xa5i\x99\x89\xa9F\xc2;\x8d\x8d\x9c\xd83\x89\xf6L\x8c\x90BL\xbb\xfe\xfc\xe5\x97\xdc\xff&\xbf\xb5\xd6\xdem\xf7nw[@\xd9Px>\t\xddk\xaf\xfd\xac\xb5\xf7j\xd9߮\xf5\xec\xd5\xf5l\xf8\xdb{\x80\x01\x00\x00V\x8e\xbfmH&R\x89HV;\x00\x00\xc02\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\xac\v\x02\xc9\f\x80\x94\x04\x04\fX\xfbx*\xb6\xa0\xfdɌ\x80T\x04\x04\fxO\xda\v\xbc\xc9L\xd4\xc1[Ю| \x90\x97\xc7\xf7\xb8\x95\x8f\x01\xa9\x8d\xda\x02\xe6\xe9j6Y\x06|\xb2\xe4|\x13/М\xa0\xe0_\xaf\x95\xe9k\x83\t\fbiۈ\x046\xb6%3]\x94\xed\x12\xa9C\x9b\xe8\rf\xcd@u\xca\x06w\xd9\x05d\xeds)\x1f\xc6\xd8L\x0eבz\x102\xc53\x890\x9aƪK{ \xecNnByds\x84de(\x9c\xc0\xb1'#\xbb\xb47{:\xf6H2\x1aйd&K`\xec\xd0p2\x13F\xbf\x8e\x13\xd0\xf5\x93KIkP4\x1aG]\x8a\xf9@ꣲ\x80M\xf3V\xa7\xdb\xd9\xd6\xec\x93&g\xf8Q\x0f\xe1\x01?\x9e\xa0\xe4\xe9C\x9d\x17\xf5o\x13\x18\xc4Ҁl\xb6\xaf\xd1e\x9b\r)\xff_SzG\x17n\xbbDB\xa7\xf0\x96f\xec\"\x9b]\xe9\xa5qz,\xbe\x81MGl\xbd\xbfٖ\xeeT>\x8e}f\xd4\xe0\xc5\xde\x06d\xf6ű\x88\x9c\r\xcf\x0f\xb2\x06\r\xfa\xc5\xfd\xc1#\x1a\xf2\xea\xa6\xcd\x1c\x8c)Օ\xb1\x83oَP\xbc3\xc7\xe77if!\x11>q<\x1e=Y\x84\xc1pq\u007f|C\tw8\xbb\xbd\x93\xeb\xb0\xdbw\xdf!{֍W\x95\x8c\x86\x90M)\x1bX\x03\xa8,`.\x9e\xf6\xe4}\xbcS\x96t\xd0\xfb\xd1\xd74\x90\xa0\xe0\x0f\\'\x0e\xce&0Pಆ\xfe\uf4bb5\xfdr\\\x9b\x1d\xa5\v\xb7]\"\xa1S\xe0S{3|؛\xbe\xf7T\\S\r\xed\x9b\xf9r\xf6\xc4;\xee`]\x89^\xe4\x88g 9\x1b\x16\x1b\x14\xa6N\xa3\x94\xcb\xf0f\xee':\xe7۶x\x01\x9bԄZ#=\xb1\x04oaH\xaek.(\x1aD\x90\x19,\xb0\xb3ݡ\xc3\xf817\x81\xb1\xbe\x83\xee\x9e\xd1(\x8d\x14\x15Z\f\xac\x11T\x160̺\x0e^\xde#OR\xeeޚW.\xc2x\xc1-lH!\xc5\xef\x12\xffw]~\x1c\x8f\xfc\x83\v\xb7]\"\xa1S\xe0S\xa5\xbbZp\xd3/J\x93\b\x18>\x97\x1e\xef\x91\xd9\x02\x04,|6\xbc\b\x01;\x95\xceƎ\x97P\xdc\xd1k<*\xb2C\x9dA\xe9\x89%8\xc2\x17[\x95L\xc0\x92\x1a(0\xf7B\x14\xb0\x17stח]\xa1`\x04\x02\xb6vQ[\xc0\b3n\x8b5\x10\x93t\xf2\xf1\xfd/se\x82\x9f\xe3&\xc6\xd78\xae\x0f\xbf\xd0q\xbf\xa4Iݽ\x9b\x95\xfa\xda\xef\x99͋\ve\xbaCbZB\xe4\u007f\xb7\xa9 #\xb7\x9a\xddm\xb6=9\x9b\xb4{\xb7\x92\x11\x87\xe8\xf7ʗَoD茫|k\xfa\x9ey\xec;\x98\xad\xc9\xd9G\x87\xb6\xc7\xd0&\xbe:7c\x8f[V\xc31\xb4\xf1jEN\xc8mu=?c\xfbuy\r\xd2S\x9c*\xbd~\x00\xef\xbdN\x05,R\xaf\x93\xd8\xee\xc39\be\xf9C\x02ְ\xd1/\xb9^\xe9\xe5\xc8\x04,t\xb6\xa4\r\xc2\xd8S\x9e\x9du\x80\r!\xb1\xe2[\xb2M\xb8\xed\xbd\x97\xfc\x92z%-Vn<\xc1\x9f\xf99\xdbF\x9d8\xc4\xd5\\\xab\x139\xad\xb9\xd7\xf1\xb0說\xa1\xd9\xc1\xfb5ŕ7Y\u007f\xda^{XWV{8(3x\xab\xe7\xe8nj\xa3>\xe3W\x17\xcb\f7o\x96\x15\xf7\xc9O\"\b\x98ș\xf4\x19\x1cC/\bؚEu\x01\xf3\xf2</\xbap$I\x8c-=\xf1\xcb\xe0\xa7\xf6>\xae\xd5n\xff\v\xc6\xdf\xdbu\xad88\xf1e\x11\xc6S}:\xeeP띒\xf3\xd4\xe2Qq͝\xb1V\xae#\xbad\xf8n\xadH;n\xbd\xaa\xcd\x0fЬ#\xb7\xbay-\"\xf24`\xcb-\xb4\xd9lN\x99팥yknfNu9r\x93\x1b\xb3\xa2ײ/m\x88\bM\xf3F\xa4\xad\xbb\x94y\x00Kk\xa0\xb9[\xeb\xea\xb6fPI9\xa29c=\xa3)\x97\xd5 =ũRw\x86\xf7'\x1e*`\x91z\x03\x83ui\x83،\x9a\x1ebQ\xc0\x02\xf9ۥ\xd7+\xbd\x1c\a\xb2\xce\xcc\xcc\xdcE\xb2\xb3%m\x10ve\xe6\x9a\xdb\u007f\x814\xf1\xde\x12\u007f\x9ad\xdc\x1c\xaeW\xd2b\xe5\xc6\x13FQ/+\x14u\xe2\x10\x9er\x94\x87>A\xa5n<;a\xaf4\xda\xed\xf6\xe74\xfb\nwc\xa4\xf3P\x15\x19%>\xdd}\xb1\u007f\xec^\x19\xf7Nn\xf0\xd8n\u05f7҄\xf43\x9e;a\xe8l\xd5\xeb\xef\xd5F\u007f\xc8R\x01\x1b\x88Ѫ\xf9\xe9\xde\x1dY\xf1}\x86@j\xa3\xba\x80a\xaf\xc7ai\xf6E'\xdd|\xe2\xc7ܑ!d\x11\xfd\xcfn-b\xc9\x12\xf2\xcd|\xf1\x10I\xcd\x1d\xae%C\x88\xb9\xbe\x1f\xa2˅\xeeV+2\xb3\xbd\x16\xd2\xc3\xd0\xd2{\xef\xeb,\xd6\xf5S\x1eq\xe5\xa3]>6\xc6\xf5Y\xe8\xe5}\xc2\xe6\x10i\xb2\xc8%\x96k\xb1\xbc\x06\xcdVj\x96S\x80q\x17\xeb\x1eu\xa1\xbb\xb2\x1adCH\xfcɱ\x1d\x98\xf5\xc0$\xf5\xe2#\x05\xde\x1c\xe1с\xe6_g|\xe3\aP\x8f\xecz%\x959Ď\x8eCv\xb6\xa4\r\xfat\x1b)\x1bخ\x91\xe7FN\xe1F\x91\xf9\a\xd2VDZ\x1c\xa7\xf1\xa4\x8e\xc9PA\xe5!d\xd7&\xb4鮐\f\x8f\x10\x87\xb9\xfb\x98\xca\x0e\xe9Iu\x1ezG\x92\x9d%A\x99\x01E\x100\xe9g\xdc\xc7=#\xa6\xdc\x14\x8eF*`nt+\xea\xe8~\xf2~Y1\xb0FQ_\xc0\b~Kwt\xb2\xdb\x12ך\xa1,`\x17C\xc9\x11\xee\xa9r\xb9\xd0\xddZ\xba\xcd?O\xc8!c%w\xf6\xd6\u007f\xe6\x1f\x06\x04_W\x1c\x01\v\xfb\x82\xbd\xd7\xf7l\xcbD\xb4K\x845G\xc8\xcb9\r\x96נ\xf9\x82\xbe~\x8d\xbc\xb8\xe2\x13V\"\uf23c\x06\x99\x805\xa0\x06&`\xd2z\xf1\xcc\xf6-\xfb\x04\v\rU'-U\x13\xc9\xf5J*s\xa0KCCC\x97\xa9\x80IΖ\xacA>\xc4\xd3\xcd\x19\x8d,Wr\n\xff\xc6H\x0fLڊH\x8b\xe34\x1e\xb7'\x160o\xb5&\aekN2?~X\x9f\xea\x8fν#\x18\xae`\xfc\xd2p\xf4ƽ\xa7A濊#`\xe1ϸ\xb1\x84\xbc<\xe7\xbe\xc5\xd1\xc8\x05\xac%\uaa3b\x8bσ\x1eؚEe\x01\xf3\v\x1e\xafq> M\x12\xcc\x0f\xe2\x96a(\vX8\xd9\xc1\xcd)\x97\vݭ\xdbž\v\xed\xf3\xf8\xf8\x83yh\x8b\xd0\xe7\x89#`;BY[r>o\xb3\xed\x14\x04\xec\x1c\x0ey\xc2%5\bn\xab^4\x8a?\x15Tho\x81\xac\x06\xb9\x80yɽL\x05LZ/Ʒ\x90\xf8\x00VS14$\xb8Ӥ\xd7\x1b\xa9L\xe2\x03\x93\x9e-I\x83\x1e\b\xb3\b\x04%R|KD\x1f\x98\xbfK^\xaf\xa4\xc5ʍǃ\x91\x11\x9b\x92\x805hy'r\xfeF\xcbޣ\xb0>\x9d\x10\xdd]gI\xfa\xed\xbd\v\x95\\ٝ\x04=\xb0\xc8g\xbc\xfb\x15\xfd\xa6J\xdc\x03\x1b\n\xbd\x95Rlh(6\x13X\x13\xa8+`\x81&\xc1e\xf2\xd0\x14\x90$1u\x87%\x99(\x1d%`\xdfD\t\xd8\x18\x1d^(\x11\xba[˷\x8d2H_\xe0\x01\xed\x01\xf9Zҙ\x03\x9c\xddv&\xb7̖\xe4\x1e\x10\x13y\x05\xf4\xbb\xfb\x80 `\xf46d\xf7\xb0\xb4\x06M5=\xc6#\x1f\xae\xd8Ɗl=\"\xabAr\x8aS\xc2D\x03*`\xd2z\xb1'\xfb\x8b\xad\xc2\\\x03Mx\x8a\xab\xe4z%\x95I\x04Lr\xb6d\r\xf2\"v$ډ/9\x85\xf8\x14\xd2B\xfb\x91\x92VDZ\x1c\xa7\xf1\xd8DŽ\x8d!=q\x18?{\n)\xf4֘>\xdd{I{`O\x18D\x8f\x1e7\x12\xe9zۧ\xef\x94\x19Pb\x05\xec%W\xfb\xf2Y\xa51v~\x85T\xc0\xea4\n\x9d-x\n\xb9vQW\xc0p3\x9b\x12\xed\xa7\x1e{I\x12\xe3I>I'?\"`\xfaF\x8c\x83\xff\x12%`\xb3\x06#\xed\x82ݸ\x11].\xf4\xbfۅ\xd8\x18\xf5\x8b::#\x9e\x9d\xb9\xf0\x18{-\xc4xZ8&\x15\xb0Po\"\x87JG`{\x94\x80Ik\xd0l\xa1\xee\xa9m\x85\xd4\x1fDG/-\x82\xc3E\xd2\x1f\t\x9fB\"`\xd2z\xfd\x05g\xf0\xb1]\x81\xf0)\x18\x92\xeb\x95T&\x110\xc9ْ6\xa8 \x87\x88\x94\xeb'\x1a,˕\x9c\u009by\x80\x88L\xa0p\xab\xbc\x15\x8a\x02&;\x1b\x19\x87\n\x1di\xf9\x89%\xb8\xb3B\x9af4b\xfc\x9a:\xbeƄ'\x8c\x8d\xb7ɇǍ\xb0C\xd7d\x06\x94X\x01{\u0095q\xdc\xe9\xd0sfwCx\xf0*\x11\xb0@\xde^\x1c\v\b\xd8\xdaEe\x01s\xf1\xddN\xb7\x93y\xee%I:\x89\"\xe1\xf4+\xe1)\xe4\x04\xfb\xf25\x1e\xbas\xbb\x86\xd3ݟ\xfa\x8b]\xf7\xe5D\xf0\xe9\x97:\xfat\xf2\x91\xfeD\xe7\xc8\r\xee^T\xc1ѯ\xd1\xe5\a,u\n\x95Z\xda+P\x13\xbd\x037\x9f\xb3\xb6U\b\xcf\xcf\xcei.\xb5\xef\xcapKm\xe7\a\xd9\x135v\u007fԡ\x83\xd7\xeb\xf2\x91\xb6a\xd0c\xdbtd\x10\x8f\x1e\xd9d\xf3\xc8jР|\x8b)7\x8bZ\x97\xa7\x9d\xb2\x9eJ+\x97\xd7\x109\x85\xb7t\xa7\x87\xeczv\x96z%\xf5\xce\f\x1cӺ\xf1df\xf5\x80\x9f\xce\xc4\x0f?\xc6\v_\xaf\xa42\xd9L\xfc\xf0\xd9\xe24H2\x13ߑ\x91Sw&+m\xa3\xd9)\xccĿl\xb3\xb9eo\t\xee\xca(0\xb7\xffb〴\x15\x92\x16\xc7k<\xf9\x14\xd3.ay3\xe3\xd2Z\xd4\xd1\u007f\xba\x98v\xb0\x1aw\xd7\xf7\u007f{\x85JU+W\xdc:\xdc\u007f\x85{$3\x98\x9b\xb0\xdb\xf5_\xda\xedo\xb1\xf43~\xa6\x1f\x1b\xb1\u007f\x1f\xea\x80\xedC!\xa9z\xda\xc9u<\x16ӗ\x91\xd2\xef\x01\x1e(\x8d+\x815\x81\xca\x02\x86==\x16S\x9b\xf0\xf3\x16I\x12\xbbo%*4W\"\xfc܍=b\u007fa\xd4\x17\xd7~\xc3q\u05eeѬ\xff(&\xaf\xf4\xfb\xfb\xf9\x05CqM\xf4\xcfO|\x9b\x11B\xe9B\xe7\xaek\xa76\xebS\xfa@\xac\xa9\xb0.gSv\xa1p\x03\xfa\x8fg\xa5\x17\x0e\xc9lDž\x1f\x11\xb2\xfb#p9W\xa3-5o\xd3\x14\x1e#Y\x9b\x1c\x19\xe4\xf5\x98\xac\x06MuEfv\xb9\x87\x19\xfff{\xc6\xf6\xaf\x03\xf2\x1a\"\xa7\xa8C\x88\xba\x9a\x8e\xd1\xdf3F\xea\xed\"\x86\xd5\xf88y\xed\xa5\xbf\x85\xcc\v_{\xe8z%\x95E~\v\xc9K\xce\x16\xa7A\x0f%\xbf\x85t\xed\xcb\xdazҼ\x91\\\xfa\x11\xd1\xf1U*=\x05\xc1\xf1\x8b\x8c-\xfb\x1c\xb2VHZ\x1c\xaf\xf1\x843?\x19\x9073.s7>\xd3\x1b\x05\xa5\x19;]Vb\xa4}\xaf\xfb\xc6ۇu\x06\xe3#\xb9\xc1S\xd1Iv\x0fK?\xe3\t\xf6\xb3G\x9dQp\x82\x99\xb5\xbcP\xed,=*\xfe\xc8̖~2\xfa\xac\x94\xe9\x8d\aǧ\x03\x18X\x83\xa8-`k\x8eȨo\x9dR\xad\x89\x196.\v\xaf\x8b\xaf\xbd~\xf7\xee\xed\xd3\xf3\x9f\xc5\xfdEl\x8b\xa6B\xf9\xd7\x1c\xedy\b\x96\xd3Y\x9b\x80\x80\xbd'\xeb^\xc0\xf0\xe5\x9c%\xaca\xb1x\xfa\x85\xc9b8X6\x12\xc7\u009b\x1d\xff\x87\xf8\xd3㞸ǀ\x14\x06\x04\xec=\x01\x01S\x89'\xe2\x04\x8a\xa9xS\xfe\x80\xf5\b\b\xd8{!x\xb7\x01\x15\b^\xd1_\xeb{\xd4wM\xff\xd5\x02\x17\xaa\x00\xd6\x03 `\xef\x05\xf3nOb@\x05\x82õ\x06\x9d\xa1v\x18\xf4\v\x88\x00\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x96\"\f\u05fc\x96\xed{\v\"\xeb\xd8\x03\xc0zEm\x01\xf3t5\x9b,\x03\xbe\xa8\xa4o\xe0\x96\xe9\xd6\xc0\xca,\\>\xb9I\xb2\x86M\b\xef\xb1-\xe9{\x17\xbf\x00\xcb_\xaf\x95\xe9k\x170S\xbc_'.\x18\xa3[X\xfci\x1a\x81\xba5\xaaކ\xb4\x0f\x1eC\x1c\x00R\r\x95\x05l\x9a\xb7:\xdd\xce6\xba\x8a\xa1$\xe9kj\xa3ɦ\x95Q\xb0\xc1\xd0Z\xcb\x12vm\xb9~$}\xf1\x97s\xfaP\xe7Eai\xaaGO\x12\xd9\xdd\xe1\xec\xf6N\xae\xc3n\xdf}'\xae\x8d\xac\x86N\x16\xc8G\x9ek\xddx\x15\x03\xc0\xfaFe\x01s\xb1\xb5\xef}\xbcS\x96\xb4Y\xe82N\xf3\x16[\x92\xd2\xcbD(du\x04/\xba\x8a\x03\x8b\u05ef\x1f\xb8N\x1cd\xf1Zq\x8d4@E\f\x1d:q!d}L \xcb0\xd2\x1a^\xe8\x1a\x15r\xcfh\x12\xac\u007f\n\x00\xeb\x01\x95\x05L\x88\x94\xe8\xe5=\xb2d\x8f\xe0\xceiO\x14\xdbv\x19\x89\x150\xd7\xd2\"\tF\x16\xee\x97G؉a\xee\x85(`/\xe2\x04S\xc2\xf2\x1a\xae\x18f\x15r}\xd9\x15\x18\x00\xd65j\v\x18a\xc6m\xb1\x06dIoS\xaf\xd7\xef\xb55y\x13\x17\\\x06<\xe5\xd9Y\a\xc4!dSAFn5QU\xbfVXu\xb9Z\x96;\xbe\x11\xa13\xae\xf2\xad\xe9{d\x8b~\xbe\xbd`\xd0\x1d>KC\"͕\tn\xad\x9b4r\xab@\r\xb5\bޯ)\xae\xbcI\x04虎\xe3\xbeyq\U00068f96\x06s\x8d\x84\xa2\b\x1b`l\xaf=\xac+\xab=\x1c\x94׀犅\x0e\x98<\x97t\xc1\xd2g0\x00\xacgT\x170/\xcf\xf3f_Tr\xa6\x9b$\xbbԿ\x1b]\x99\xb9\xe6\xf6_ \rMW\xa4\x1d\xb7^\xd5\xe6\x13=}hkAu6\x9bG\x96;ciޚ\x9b\x99S]\x8ed\xe3\xb6a\xee\xabG}g9\xb6\x92;\x8b<B#\x8c\xccN\xd8+\x8dv\xbb\x9d\xad\xe1\u007f\x85\xbb1\xd2y\xa8*\x88\xe7\xfa\xfa\x0eW\x16\x1bn\xd6\xeff\x91\xc3\xc2\x02\x166\xc0Ow_\xec\x1f\xbbWƽ\x93׀\x9frv\xb6\x95\xe7b<\x00\xd1v\x80u\x8e\xea\x02\x86\xbd\x1e\x87\x18\x8a(\x9c\xf4w[\x9c\x1e\xa7\xa5[yA\xf3e\xe4\xd3m>\x1a\xddL\x83i813\xa6\x01\xb8X`\xe7\xf0\x10R\x96\x9b\x8fv\xf9đo\x98\xd9>\xd2u\n\x9e8\xcfv\x94\x86\x90\xc3\xcc\xfd\xfeX\x88\x16Vŝ~\x8b\x83\u009a\xee!\x01\x93\x18t\x1e\xa2}\xb3Β\xe80\xaf#\\H\xb2\xe4CS7\xba\x85\x01`=\xa3\xbe\x80a\x1a\f\xb2[\x96\xb4Y\xfc,\xa9v\xf0+\x1fb\x91m\xceh0\rp\xe8\x9f'\xe40\xb7RX\xc0d\xb9\xf9JN\xf3W\x9d\xb5GK\xb8\x13,\xad$`\xf5G\xe7\xde\x11\fWXn\xd1\xcbp\xc1\x90\x80I\f^\x1a\x8e\u07b8\xf748'\xaf\x01\xe3~\xeeE(\x19%`-\x18\x00\xd63*\v\x98_p~\x8d\xf3\x01I2`zȒB\x90n\x15y\x80\xd8s\xcfs\x1a\xf2\xb2]\x8c7Ƃׄ\x05L\x96\x9b\xbf#\xb6\x8aLJ\x0e7\xf6\xdbO\xc7\x17\xb0\x13\xa2\xdf\xea,\xcb\ry\xafpD\xc0\xa4\x06o\xef]\xa8\xe4\xca\xeeD\xf7\xc0&\"\x91[e\x026\x04\xf1\x0e\x81u\x8e\xba\x02\x16h\x12\xc2\t\x12\xa9\x92&E\x01\x1bU[\xc0\xbc\xe8:\xdd0'~\xf9\xb6Q\x06{\x90\x10\x160Yn\xfe\x81\xd8**k\xa8\xf7\xfd\x82\xb2\x80\xdd{I;XO\x18\xaf¹\"\x91\x1eX\xd8\xe0q#\x91\xae\xb7}\xfaNY\rd\x9c\xca\xc2S\xcb\xeb\xa5\xd4i\x16?\xd5\x03\x00\xd6\x12\xea\n\x18nfa\xe9\xfd\x96\x1eY\xb2G\x1cB\xaa>\x8d\xa2 \x87(\x93\xeb'\x1a\x92\xecB,\xbc\xe1\x17,\xc8PX\xc0d\xb9\xf9\ack8L\x05%X\x15#`F#Ư\xa9_kL\xf0~5ަ\xafJ\x02&1h\xe5X\xc40\xe35Y\r\x84\v\x95\xa1i\xf8\xd2\xdc@^(85\x00\xacST\x160\x17\xdf\xedt;\x99\xe7^\x92\x9ci\xb18\xdc\x0eK\x8b\xea\x8f!\x1d\x199ug\xb2\xd26\x9a\x9d\x18\x9fB\xa5\x96\xf6\n\xd4\x14z\n9Ⱥ\x83\xe1\xdc\xf9A[n\xa1\xcd\x16\x1d\xc0\xa3\x95\xbb\xd0y\xbb\x8a\f\xfb&ħ\x90\x13\x82Դ\x16u\xf4\x9f.\xa6=\xa5\xc6\xdd\xf5\xfd\xdf^!\x9a\xf3\xeeO\xec\x19\xa2\xe8\xcez\xda\xc9u\ba\xaa\xc3\x06\xa4\xb2\xe2\xd6\xe1\xfe+\xdc#y\r\x18?\xe7B3\xf6\xa5\xb9\x97\xd1(\x06\x80u\x8d\xca\x02\x86==\x16S۠?*\xe9\x1fj3\xb7\r\xf9\x13\x17]\x0e\\\xfb\xb2\xb6\x9e4oD\xc7H\xbak\xa76\xebӻ\xe4b\xb2\x98\xdbk\xa3\x93Y\x84r\xc7\xd3Xnt\x9f'\xd8QYt\xa8\xfe~\xa5\xce8W\"\xfc\xbaQx`8w\xe33\xbdQ\x10\xa8\xb1\xd3e%Fҵz&\xf8\xbajY\xe6l1I\n\xbf:\n\x1b\xe0\xfb\xc6ۇu\x06\xe3\xa3\xe8\x1a\x88n\xe9E/\x98$ז~\x12\x03\xc0\xfaFm\x01\x03\x96D\xf0\x86\xae/*\xabES\xa1\xfa\xb4\x13\x00Xe\x80\x80\xa5\x06\xc1\x0e\xc3+Y\x867\x1b\x16\xa3\x00\x00\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x10\xb0UG{\x81\xfaљ\"x\vړ\x99\x00\xc0\xaaAm\x01\xf3t5\x9b,\x03\xbe\xa8d`\xbc\xdd\xd4\xe6L\\r\x859\x86\xd2,\xc9l\x16L'\xc7E/.\x11\xa6\x01\x9d\x93\xed\u007f\xd0\x13S\xba\xb5\t\x83^6\xa4\xc1\xafā\x94Ae\x01\x9b\xe6\xadN\xb7\xb3\x8d\xaeb(I\x06\xac\xe6Q\xf7\x03Ӄd\xa5W\x12\x8fmS]2\x9b\x05\xf3\xd6^ӊ\x95\xf9M\x9aY\x9e\xb1\xf4\x13\xf7*\xafwh\u0378\xa5\x98\x1f>\xbe\xf1j\xc2\xe3\x00\xb0zPY\xc0\\<\r\xec\xe3㝲\xe4C\x13\x1d4\xb9L\xab{\x85w\xcd\x12uD\x91\xb3q\x04lRs*&o\xa9'\xdeQ\xaa\x9c\x9f,\xf2\xc0\x19\xa5\xe8K\x00\xb0\x1aQY\xc0\x84\xa8\x8a^\xde#KZ\xd9\xf2\xf8\xb8\xe9A\x9cB\xab\x83\xa5\xea\x88\"\xf1\x04\xac\";Vŗzb\xa55\xfc\x17\x82/\xbb\"\x99\t\x00\xac\x0e\xd4\x160\u008c\xdbb\rȒm,\xba\x19n\xbf\x9b\xa0\xd4r0\xbe\x11\xa13\xae\xf2\xad\xe9{\xe8ڦM\x05\x19\xb9\xd5L>l{r6i\xf7ne6\xae\x03\xdaM[\xf6zHJs\xb2:7cOl\xe7ļ\x85E\x97tg\x8a!\xd82%&\xef\xcat\x8d\x06ã\x1b%\xc6Y2p\xbc`\xd0\x1d>\xfb\x8c\x1d \x02v\x83.*\xfd\n\xe3\xe0\xfd\x9a\xe2ʛ\xb3,۟\xf9y\xa8\xa8҉}\a\xb359\xfb\xc61\xf5\x8cm\xe2\x95.'|\xe9V\xf1j\xf2\xe5\xcd\xf4\xa5#\x94\u058c\xa3k\xf0\x96ksN\x9e\xd4n\x16\xbcmg\xd2U\x8fN\x00\x00KBu\x01\xf3\xf2<o\xf6ɓ\x03M,*\x91\xb9-a\xc9\x0fό\xa5yknfNu9\"wqE\xdaq\xebUm~\x80\x86[<r\xab\x9b\xd7\"\xaaj\xbd\x9b\xf3\x1b\xbaϡ\xcb$\xa9Ay\xcd\xed[bC\xab\xedG{\xe8\xc6o\xbe*`\x96\xae\xed\xff\xa8\x84\xbby\x9a+\xbb]\xd6Acp\u007f\xf5\xa8\xef,\xc7V\xb4'\x02\xf6}\xbd\x10\xd6\xe3\nwc\xa4\xf3P\x15\v\x062\x8azł\x8a'\xb6\xa2\x8a^˾\xb4!\x8c\x9d\xcd\x1b\x91\xb6\xeeRf\xd4\xe5D.\xdd7\xc0\x82\x90\u061cQ\xcd|`\xb3\t=:i\r\xfe\xbc\xec\xaf\xcfi\xd2M\xbf\xb8\xccj\x19@\x83\x18\x00R\x01\xd5\x05\f{=\x0e\x16\x8aH\x92\xf4\x99\xad\xde\x19O;\xffa\x9f\xb6-\x88|\xb4\xcb\xc7F\xb3VD\x9d\xe7C4\xd6\xf5u-\x95\xae\xaf\xb3\x88\x96\xcd\xe4\xec\xf1Ӏo\xd4G\xa7\xd9B^+\xb41UL\xd6\t\xa1\x8a\xa6'\x05\xa6eG\r\x17\xf1\b7\x8c/~\x85\xf1l\x1f\xe9f\x05O\x9c\xa7\xd9D\xc0:\x8aX\x10\xb6a\xee>\xa6A\xd6\xd8cI+\x12\xc3\x1e)\x9f\xd8g\xa1o\xdc',̮&\x8b\xc8Qy\xd4\xe5H.]6\x84\f7\x93\x92.\x0eI#5\xb4 ҫ\xfb\x1a9Dk7\xba\x85\x01 \x15P_\xc00\xbd/\xbb\xe5I\xaf\x95t\xc6\x06\xad+0\x03)?\xe4\xb0.\xdd\xe6\x9f'\xe4T\x90\xfb7{\xeb?\xf3\x0f\x03\xb4#u\x17=\f\x9bj\xa8g\x88E\xf1Vd\x12\x85\x90\r\xeb\f}D\x9cfqc=I\xbf\xea\xac=Z±\x18\x92g[[\xc5 \x92\xf5G\xe7\xde\x11\fW\xe8N{H\xc0\xe2\x9c\xd8{}϶L\xb4\x9d\xe5\x1e\xc1\xb1\x97#\xb9t\xb9\x80I\xfd\xf2a\x01\v\xd7p*\v\xd3`\x98\xa1\xf7\xdfMe\x1c\x00R\x00\x95\x05\xcc/8\xbf\xc6\xf9\x804I\x98\xf1\x06p\xd3@\xfc\x82\xcbE\xfe\x0e1\xb1]T\x1fڻ\xf1\xf1\a\xf3\xd0\x16:\x1d\xea2\x8ax\x834t~V\x9d&\xb6\x0e\x11\x9bU\xc0&\xcb5\x8c\xe0\xc7:\xcc\x04\xec\xf1\xa1Í\xfd\xf6ӂ\x80\x1d*\xa9<\xcfF\x8d'\x84hk\xdcY\xba3\x18\x1a\xbc)\x9fxhK\xce\xe7m\xb6\x9d\xdb\xe5\xb9R\"\x97.\x17\xb0\x1d8BX\xc0\xc25\\F^\x1a\xc47\xd4\x03\x1bB+\xf0I\x00\xc0\x12PW\xc0\x02M\x82\x8b\xe7\xa1) Ib\xcc\u20f9سI\x95\xc9\x0f9\x91ʷ\x8d2ȝ\xfc\x80\xced\xf0\xb5\xa4_ǸG\x12;\x96\xb9\x8e\x12\b\x982\x861\xfc\xb8H\x10\xb0\xca\x1aꩿ \n\xd8ԋ\x92\x0e\x9a\xaa?\xfa\x84\xc1\x82\x0e\xf94\xe2,V\xe5\x13\xe7\x15\xd0Q\xe0\x81\xed\xf2\\\t\x92K\x17\x05\xccĺ^\xf9R_YX\xc0\xc25\xb8\xd3\xf6\xba\xc7s\vB\xf3+\xea4\xab{B\v\x00\x84PW\xc0p3\x9b0\xe1\xb7\xf4ȒN\x9eȆ\xaf9\xe4\xbfV\x93p/\xa5\v1\x0f\xdc\x17䦮C\xec\xd2\n\x8f\xd1\x19\x05\x85t8v\xbc\x1a\xc7\x170wCt\xb8n)\x12\x01;|\x81\xec\a\xab\xc4!$\xc6#:\xea\xc3\x1f\x13\xbc_\x8d\xb7\x99y\xe96AE\x94O\x9cCu(\xb0=\xbe\x80I.\x9d\xbc\x16b<-4K6\xa3\"V\xc0F\xd1\x16\x84vz\xc4ぼ\xe8\xf0\xbd\x00\xb0JQY\xc0\\|\xb7\xd3\xedd\x9e{Yr\xc8\xfd\xb0ɪ\xfa\xd7\xfe\xfc {R'\xe8\xcf)Tji\xaf@MT\x056\x9f\xb3\xb6U\xb0\a\x82\xbd?ɻ~\xf782\xd1\t\xf1G\x06\xf1\xe8\x91M6OT-\xfbb\xc2uK\x98\xfa\xacc\xb6O75[\u007f\xfa{\xdc\xca]\xe8\xbc]ŕݙxk\xaf\xf9rbn\xb6\xd6\xf0\xe85\x91\xae\xdd\xf5\xfd\xdf^\x11\u007f[\xe4J\xbb$\x14T<q\x1d:x\xbd.\x1fi\x1b\x06\xe3\\\x8e\xf4\xd2\xf19ͥ\xf6]\x19nY3\xfd\x836\x9b\xe6\x88\xcd\xe6\x93\xd5;\xaa\xe9\xb1\xda<\xa1\x0e\xd8e\xa4<\x85\x1f\x00V\x1d*\v\x18\xf6\xf4XLm\x83\xfe\xa8\xe4\xa8\xc5l\x1dM6A\xfc\xc33\x9e\xc6\xdc^\xa2\xfet\xed\xd4f}J\xa7\xa25\x15\xd6\xe5l\xca.\x14:\x84\xae\x839\x99\x05mt\xda\x14B\x9b\x1c\x19\xe4\xf5XT-f-\x8f\xe3\x11,㸾b\xae\xb8\x8f\xe3\xce\xe3`Geѡ\xfa\xfb\x95:c'uz=%\x99\x1c\x9d\xcf:v\xba\xac\xc48\"\x968\xf3\x13\xd1\xff\xa4t\xe2\xc0\xe5\\\x8d\xb6ԼMS\x18\xe7rd\x97\xee?\x9e\x95^8$o搐F\xbc\xac\xde\x01\r\xcd\xdbTȜ`\xb6\xf4\x93\x18\x00R\x03\xb5\x05\fHF\xb5F\xf5\xd9$\xde\xcdǼ\xf3\xf3\xbe\xa1\x03Y\xa4\x13ܢ\xa9\x98OV\x00\x00V\t `\xab\x8e\xcb9\xf2\x99d\xcbO\xbb0o\f\a\xb4w\xb17\x1b\x16\xa3\x00R\a\x100\x00\x8f\xa6\t\x13(\x1ci\x91\xc9g\x00\x90\n\x80\x80\x018P\x91~\xac\xa5\xb7\xe5X:\xfc\x88\x1bH1@\xc0\x00\x82uO\xb6&{O\u0085\x0e\x01`\x15\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\xb6\x9ai/\xf0&3\xf9 x\vV`5o\x00x\u007f\xd4\x160OW\xb3\xc92\x10Z\xf9\xcb\xc1\x8b\x93\xbf=\xed\xe6.O\xbc2+\x87\x99\xae2\xa3ݳ\x9c\xcbcur\xe2J`\n4\xa0s\xb2\xfdc(m\xc1+U$\xb7=Bږ\xe1\x12\xd2\ri\xf0\x13n \x15QY\xc0\xa6y\xab\xd3\xedl\x13\xa3\x12\xf9L\x03M,\xe16\xd9\\6\x93,\x18Ɗ\xd2+J\x96ό\x1az\xcd\x05\xe1Xg\xcb\xc0[{M\x9c\x18\xb7\xf87ify\x86Ƕ\xa9N\xd94\x96\xe4\xb6n\x9b\xed\xebp\xfc4\xebƫ\t\x8d\x01`U\xa2\xb2\x80\xb9x\xaaR>\xde\xc9\xf6\xac=n&`\x81f\xba\x88\xdf@\xb3\xfaK\x1a\xc6aG\xa9\x98p\xd0%\x9a\x03\x9f\xe6&\xb4~O\xe2\x05\xe9\x9eԜ\x8a\xc9[L\x90\xee\x05\xd8\x0eE\x02@\x9eѬ\x9e\xef\x0f\x00X(*\v\x98\x10\x9a\xd0+\x84\xefp\x98}\x1e&`N\x13\r\xc1\xe339\xe3\x97S\x97\xf0\x12\xf2L\xc0\xf0o\xd0r\xaev\x1dO\xc0*\xb2cϺ\x00Q\n\xb3\x00[\x89\x80\xf9\xb2a)\n \xf5P[\xc0\b3n\x8b\x95\xf6\xb5|&\x17\x16\x04\xac\xe7.;pw\x19Gjq\xf0\x96ksN\x9e\xd4n\xa6\xee\xa2\xeb\xf9\x19\xdbi4\x1f\xab\x18`-\x1f\x87\x04\xac<\x87\x197\x15d\xe4V3Q\xf1}\x9e\xb7\xb9p0\xe7ntu\xe6-luiw\xa6XE\xa6\xa4W\xf3\xaeL\xd7h0<\xbaQb\x9c%\x03\xc7\v\x06\xdd\xe1\xb3\xcf\xd8\x01\"`78\x8eӿ\xc28x\xbf\xa6\xb8\xf2\xe6,\xcb\xf6g~\x1e*\xea:\xa0ݴe\xaf\x87\xa44'\xabs3\xf6\xb0^\xec\xc1lMξqL\xbd]\x9b\xf8P\xae\x14\xcd\xf1\x8a\xec\xac}\x82\x93+\xd46yR*`\xf8Lz$\x90\x1b\x00\xa4\b\xaa\v\x98\x97\xe7y3S\x01k7\x16\x05\xacMX\x06~@\xf5Ga\xfe\xbc\xec\xaf\xcfi\xd2M\xbf\xb8\x8c\xf1\x11\xcd\x19\xeb\x19M9\x91\x86\x01\x16\x03\xc3F\xfb\x83\x0ed\xf59?G\xac/S\x91v\xdczU\x9bO\xb4\u05f7M{\xe9\xee1\x84B:\x10f?\xdaê5_\x150\xfb%\a\x1f\x95p7Ose\xb7\xcb:h8\xee\xaf\x1e\xf5\x9d\xe5hT\"*`\xdf\xd7s\x1d4}\x85\xbb1\xd2y\xa8\x8aŋ\x1c\r{\xdez7\xe77t\x9fC\xe4\x1a\xb1\x06\xe55\xb7o\xa1\xb1\x89\xac\xa8\xa2ײ/m\x88\xf4_\x9b7\"mݥLi\xe44\xccl\xf3[Z\xb6gе\n\xc3m\x93%\xe5\x026 I\x03@\x8a\xa0\xba\x80a\xaf\xc7\xc1B\x119\xa9\x8c\t\x02\xd64Ď\f5%,\xb8\f\xb4 ҅\xf9\x9a\x05t\xedb}\xad.\xc4zU\x92!$\x85\xdd\xeeVD]\xeaC4huy\x96\x87$\xabc\x05l\xb2N\x88p4=) _\x1b\xdap\x11\x8fp\xc3\xf8\xe2W\x18\xcf\xf6\x91nV\xf0\xc4y\x9aM\x04\xac\xa3\x88E\xe9\x1e\xe6\xee\x93\xd7\xc7\xc2cIk(H\xf7L\xce\x1e?\x8d?GgTh\xb6\x90\xd7\n-I\xf9,\xf4[\xe0\x13\x1a\x87\x17k\xb2H\xef\xab\\\x8b\xe5h\xf2H\x97j&\xb7@\xd66Y3e\x02\xe6F\xb70\x00\xa4\x18\xea\v\x18\xa67c7\xf5x\x05\x02\x01wS\x80\xf4hڄ`ֽmI\xca}pNe\x91\x17\x17\xa2=\xbf\x8aOXN\xde\x11\xfa*\x11\xb0K\x83ւt*%\xa5\xdb\xfc\xf3\x84\x9c\n\x1c\xc8`\xb3\x1b\x9c\xb1\x02&2\x89BȆu\x86>\"N\xb3,D$~\xd5Y{\xb4\x84\x13CD\xb6rL\xbfp\xfdѹw\x04\xc3\x15\xba\xd3\x1e\x12\xb0\xbb(\xb2г\x86:\xaa\xceih\xd2{}϶L$\x84\x88<\x12Ε\xa0\xf9\x82\xbe^G^i\xdbd͌\x12\xb0\x16\f\x00)\x86\xca\x02\xe6\x17\x1e4\x8e\xf3\x81I>\x84\a\xf7\b\xb3\xc1\xda{\x12\x15]\x0e.\x93\xbb\x9btGh\x0f\xec\xd3},go\x01}\x95;\xf1}iԳ\xb5]Ԥ\xfd\xe4VgJ\xeb\x8b+`\xd8f\x15\xb0\xc9r\r#\xf8\xb1N\x88q\xfb\xf8\xd0\xe1\xc6~\xfbi1HwI\xe5y6j<\xc1\t\x9c\xa5;\x83!q\xb9\x8c\"\xce)\x16\xb8\x9bŢ\x1dڒ\xf3y\x9bm\xe7vy\xae\x14\xc1\x89oC\xa3Ҷɚ)\x13\xb0!4\x80\x01 \xc5PW\xc0\x02M\x82_\xe7\xa1)\x10\xf0R\x1cf\xaf7\x80\x9d<\x1d\x0e\x85&W\xa8\x88;m\xaf{<\xb7\x80\xaaj\xc56\x96\xb35\xd2\x03\xa3\xf3\xd2\x04'~&\x15\x88\xf2m\xa3\f/\x0e\b\xa1\xad\x1d\xf1\x05L\x19I\x90\xee\xca\x1aꩿ \n\xd8ԋ\x92\x0e\x9a\xaa?\xfa\x84\xf1\x8a\xee\xf84\xe2,\xd6\x1eI\x9c\xd9H0\xed\xbc\x02\xfa\x9e\x1d\x88\x1f\xa4\x1bkhTolB>i\xdbd͔\tX\x9df9\x1f\xb5\x02\xc0\xb2\xa0\xae\x80\xe1f\xaa\ad\b\x19\xeaky\xc4y`T\xd7z՟\a6\x8a\xb6 \xb4\xd3C\x93V6\x82jA\xac3XX\x88\xf14\xb2\x84\x04lK\xf5x\x1d騱\x99\xed_\x10\xb1(\xd5R\u007fTy\xac\x80\xb9\x1b&\xa3\xb3$H\x04\xec\xf0\x05\xb2\x1f\xac\x12\x87\x90\x18\x8f\xe8\xa8\x0f\u007fL\xf0~5\xdef\xe6\xa5ۄ\xf7×]H\x9f\x05\x1c\xa7z\x14\x91\xaa\x1c\xea\xb3\x0flO$`9\xd4u\x96W(k\x9b\xac\x99R\x01\v\xe4%\x88/\x0e\x00\xab\x14\x95\x05\xcc\xc5w;\xddN\x8b8\x13?\xe0q\x98=T\vܦ\xde\xc9\xde\x15\x98\x89?\xaa\xe9\xb1\xda<\x82N\x94\xa7\x9d\xb2\x9eJ\x13\x1eϝ\xd3\\jߕA\xaeg\x9cy\xbbw\xee=\xf2\tƧP\xa9\xa5\xbd\x02\x11\xc9\xf5d\xe7\\oۯ\x89\x15\xb0}(\x81\nL}\xd61ۧ\x9b\x9a\xad?\xfd=n\xe5.tޮ\xe2\xca\xeeL\xbc\xb5\xd7|917[kx\xf4\x9aH\xd7\xee\xfa\xfeo\xaf\x88\xbf-r\xa5]\x12\n\xf6\xfe$\xef\xfa\xdd\xe3\xc8Dg\xd7\x1f\x19ģG6\xd9<\xb8\x0e\x1d\xbc^\x97\x8f\xb4\r\x83\xd2\\)\x1a\xb4g\xb0\xa7 \x8bJ\xaa\xa4m\x91$\x9b\x89\u007f\xd9f\x13\xde\xf6\xcbh9\u007f0\x05\x00˃\xca\x02\x86==\x16S۠8\xbb\xc0C]`\xcd,\xd5ej\xf7$(\xb6L\fh\xa8WkS!u\x82\x05~\xb3=c\xfbׂ\x98\xf9\x8fg\xa5\x17\x0eal!G\x1b\x88\x8c\xe5ji\x8f\xa5k\xa76\xebS\xf6\xf8\xce[\x91\x93\xbe\xebA\xac\x80\x99\xb5|tV\x98`\x19\xc7\xf5\x15s\xc5}\x1cw\x1e\a;*\x8b\x0e\xd5߯\xd4\x19;\xa9\xd3\xeb)\xc9\xe4\xe8|ֱ\xd3e%\xc6\x11\xb1ę\x9f\x88^)\xd7\xc1\x9ĉ6:\xe3\x8b\\\xac#\x83\xbc\x1eÁ˹\x1am\xa9y\x9b\xa6P\x9a+%\xaf\xee`fv\xb9\x87&%m\x8b$\x8f\x88N=\xf6\xab\x03[\xfaI\f\x00)\x87\xda\x02\xb6\xaa\xf0n>束\xf7\r\x1d\xc8Z\x8a\xfb'\x81\x13\xff\x03Q\xad\xb1$3\xf9@\xb4h*\xe6\x93\xd9\x00\xc0\xeac]\vX{\x96\xd0\xe1\nhc\xe6\xd4/\x80\xe5\x170|9G>\x93l\xb9\xf0f\xc3b\x14@J\xb2\xae\x05l4\xcd\xc1\xb6\x8e\xb4\xc8L\xab\x85\xa3\x82\x80\x01\x00\x90q~\xef\xa6\x00\x00 \x00IDAT\x90u-`\x81\x8a\xf4c-\xbd-\xc7җ\xf2;fW\x17\xaa\x1eT\xfd\xb9)\x00\x00\x12ֵ\x80alݓ\xad\xc9\xdecMf\xa6ħ\b\xa1\x8d\xaedV\x00\x00,#\xeb\\\xc0\x00\x00He@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00P$\x15f9\x82\x80\x01\x00\x10\x8b\xa7b\vڟ\xcch\xe5\x01\x01\x03B\f\u05fcNf\xb2\xec\xb4\x17x\x93\x99(\xb1\xc4b\x80\xb7 N$\x9d@^\x1eߣ\xfe\x02W\x8bFm\x01\xf3t5\x9b,\x03\xa1\xc5\x1f\x1c|x\x12|\xaf\xea˱~\b\xaeq\xe2\xe2]\xcbǣݜ1\x88\xfb9n\xf7\xa3x&S\xb5\x9f\x95\x18\x1f\x9d\x98\x88w|a\xdc\xe1Z\x83\xf8>\xc7q\xb7\xf1m\xf2z/\x81\xe9\v\x1d\xf7K\xb2\xf9\x92F\x83{\x11\xdf̾[\\#[\xff,\xbe\x91\x8c\x06$.C\xfb\xd7ke\xfa\xda`b\xe3\b\xe1b\xb1\xd0\x06q\x9f\xd5>\x8dw|\xa9|\xc5qt\x15\xdd\x0e\x8e\xfb*\xea\xc8ءa\xa5\x02\x1f\x8a\x0fܠ\x864\xe5\xdf\U0004fce5<W?*\v\xd84ou\xba\x9dm₆>\xd3@S\xf8\xc0P\xfcR\xcbH\xef\xfb-\xe3\xf7\xbd]'\tK\xfb\xe8\x89RR\x82rnb\x83\xb91Nodz\xfd\xdc\u061cB\x01\xca\x13\xdd\xd9\xfe\xbe\xf3\xef+\xa5\x9d,$\xd2\xdb\xfb\xdc\xed\xd7\xf8\xf5\x1d\xee\xfe\xdb\x04\xb6\xc1\x89/\x8b0m\xbd\xbd\x93K \x9bs\x13\x87j\xed\x84\xfb\xdc\b^\x10\xbfI3\x8b\xa9Ӈ:/\xea\x13]\x82\x94H\xb1Xh\x83\x1eݯ\x89\xaf\xfeK\xe4e\xf1\x9d\x1f\xc8\xe6\x87;\xc5/\xa3\x8e\f\x17\xf7\x8b\xa9\xa4\x1f\xf7R\xf8 \r\x92\\\x99u\xe3U%\x8b!$\x0f\xe8\xb0ZQY\xc0\\<\v\xca*\xae~o\xedq\x8b\x02汬\x90\x80\xed(Mf\x91\x84\"\x89\x80\xd5\\PJJP\xceMb0\xcb]\xfc\x92tz\xb8\xd9\xd8C\x02\xb5\xa7IW%\xf8\xe5\xfb\t\xd8\v]#\xdbNqc\xe4\xf5\x117\x95ؼ\xb5H\xd8>N$`\x18\x1f\xbdF_\x9f/P\xc0&5\xa7\xc4\xd4\x0f\\'\x0e\xc6mp\x14\x91bJ\xb0\x06\x05\x8d\x95\tL\x96\xc4\t\xa1\x8bz\xefD̑p\xc71\xe9ǽ(\xbc\x85\xc20\xf9C4Hzeg4J#š\x14\t\x13\xaa\xb2\x80a\xd6\xf5\xf2\xf2\x1e\xbaq\x98}\u009a\xf8\xb8\x97\xef5\xad\x8c\x80\x85\xe3\x0f-\x15\xa9\x80U]PJJP\xceMb0\xcb=*\x9eM$`G\x99\xf4Lq\xa1/\xfe%q\xc5 Կ\x1c\x026\u05f9\xb0\xbeTEvȷ\xf0\x82[\xc40,RL\t\xa1A\x9d\xf1\u07fe%r\xfe\x1b\xb6i<\x1f\xdf$\xe9ǽ(\x1cHX\xfc\xe9C4Hze\xbel\xa5\xc5X@\xc0\xe22\xe3\xb6X\xe9\x03Z\x9f\xc9%\x06\xf5\xc03\xbePp[U\xb1\x8a\x8b*\xe7\xd3\x1d۞\x9cMڽ[c\x8c\xcc[\xd82\xd1\xeeL\xd18S\xfe}U\xd4x\xb3R_\xfb=\x8dJ+P#K^\xe3t\x9d_\x19>;\xfbB\x96K\xbeA\xef\xd7\x14W\xded\xff\x83\xf6\xdaú\xb2\xda\xc3A\xb9A\x84Y\xeeEU\xbf(`\xe1b\xad\x1c\x1d2\n+Q\xd7\x1b\xa8\xda\x04Gd\x06\xcft\x1c\xf7͋\x8bG\xf5\xb5凞\xe0\xd7\xeaS6 \xe5抅\x0e\x98T\xc0\xde^0\xe8\x0e\x9f\xa5\xee+Ҋ{b3\xc9\xc0\xb1\xdePr\xe1\xcbh\x01S\xaeW\x100,:\v\x05י\xac2\xfc\xe2B\x99\ue410\xf6g~β\xe6ʄ\xf7\xe1\xe6⊝#\x1fN3n&\xafg\xb0\x04\xa1A\xf5\x06\x9aVz\xd7%\x9f\x101\xe8\xac\xd1Wu\x06\xa3\xce\x16\xb6\x95\xd6\xc0\xc2{b|\xa1Q\xd6\xe2\xb7zN\x1c\xcb+\u007f\xdc\xf2w]\x81\xf1\x8d\xe4\xfa]\xe5[\xd3\xf7ȖȽ\x9aku\"\xa75\xf7z\xdc\x06\xcd6\xfe\xb2\xd88a\x18\x91\xbeg\v\xfb?;\x93\x1e\x89\xdb\x17\xa6\x17\x04L\x19/\xcf\xf3f\xf6\x8di\xed\x0eE%\xa2\xac\x84\x80\xf9\x06l\xb9\x856\x9b\x8d\x0eh\x87Б[ݼ\x16Ŭ\xac\xbc\x1f\xed\xa1\x1b\xbf\xf9\xaa\x80\xd9/;\\\xc4U\xf6\r\x97\x91\xaf\xe1\xd9\t{\xa5\xd1n\xb7?\x97%\xa7\xfat\xdc\xe1۷\x0f매\xb9\xa4\xc3\xc3\xdd\x18\xe9<TE\ue267\xbb/\xf6\x8f\xdd+\xe3\xde\xc9\r\"\x10\x01\xeb\xac\x15\x05,\\\xecu}\x8d}\x96\x940ֿ\xc2/\x0fs\xb5\xb7\xff$x\xc8\xc2\x06s}}\x87+\x8b\r7\xebw\xbf\x9c\xb5\x97\xb4\xbeƯ[KH\tE\x03R\xee)g\x17\xce6ō\xcc\xcd͍P\x01\x1b\xe6\xbez\xd4w\x96{,\xb4\xe2P\xeb\x9d\x12\xda\xdbxQRy\u007f\xb8\x96\x8b\x160\xe5z\x8f^\x99\x9b\xeb0b\xd1Y(\xb8Τ\x95\xe1G\xc55w\xc6Z\x99?\x1c\x8f\xa2^\xa1\xae\xa7\xf6>\xae\xd5n\xff\xcb\xe2\x8ayK\vl>\xf2\x99~Z*[Ɩ4h\xf6y#w[v\x91\x92w]\xf2\ta|\xb1蛑o\x8a.\xca\xcf\x16\xb1\x95\xd6p\xaf\x06O\x18&p\xd5=y\x8b\x1f\xdb\xedz\xd6)W\xfe\xb8\xe5\xef\xba\x023\x96歹\x999\xd5\xe5\xf2\xa0Ȟr\x94\x87>A\xa5\xeex\rz{\xf4\xb3\x8e\x11\xa2]\x9d\xd2\xf7la\xffg\x031Z5?ݻcIˬ\xab\x8f\xea\x02\x86\xbd\x1e\a\x8bJ\xe4\xa42\xb6\xb2\x02\x86%C\xc8\xebZ*]_g\xc5Lޛ\xac\x13B\xa5MO\nD-\xf2\\t\xe8\xaf\xe4\xdf\xe4\x10K+\x0e!\x8b\x8e\x92\xf1\xd3\xdb\xc35\xb2\xdca\xe61\u007fL\xbf\xab;\x0f\xd1\x1b\xa3\xb3$\x18UC\x18\"`\xaf\xf4\xaf\x98\x80I\x8a\xddg_\xb0\xf8\x04\xcd\xf8\xe1\xf6\xbf踒>y\xbd\xa42\xee\xf4[\x1c\xa4\xa3\xb7+\xf5\xe4\xa5\xfeJ|\x03<\u0089\xff\xceS\xe2\xd73\xb9\x9dg\xfb\xc8)\x83'\x98b\x14\x95\x90\xbe\xc8E\xdaLc%ˍ\x12\xb08\xf5\x1e\xa5U\xb1\xbe\x820\xd6\x16F\x9e\x91\xca\xe6\x0e\xd7\x12\xe1\x9d\xeb\xa3\xfep\xd2!\x0e\a\xa5\x8b\f!\x17Q̜\xc76\x9f\x84\xff\xa7\x18B\x83.ҷ7λ\x1e\xf9\x84FX\xe7f\x8c\xb9\xec\"g\x93\xd8Jj\xb0\x97\xe1F]#\xfe\x8c\t\xbf\xe4\x9d\xc4X\x1f\xf2*(}\xdcQ\xb6J\xe4\xa3]>\xd1\xd9\"\xa1k\x13\xda\xc4V>Wn\xd0Ez\xb9\xf8\x06\x110\xe9{\xb6\xa0\xff37\xba\x85\xe5\xec'\xdd\xd8%-\x92\xa7>\xea\v\x18\xa6q!\xbb\xc9\x00\xd2\x19\b\x04\xdcM\x01Q1VZ\xc0\xdc\xd9[\xff\x99\u007f\x18\x90w\xaf$L\xa2\x10QCH\xfa\x14]\xf4\b)\v\x18\x1b\x9bur?Hs\xeb\x8fν#\x18\x88\xa6\xbc4\x1c\xbdq\xefip.\xba\x860D\xc0pm\a\x130I\xb1g\xdc\xdc\xec\xfd\xb7\xef\x8a\xc4\t\nsc\xb5\xf4\xb6\x93\x18\x90ʊB\xdf\xf2\x8f\xf4\xa4\xb7\xa6\u007f\x84\xe3\x1a\xe0~N\x9c\x0e1\xc5\xddy\xfc\xf8q\a\xf3\x81\xbd\xea\xac=Z\xc21/5핰f\xbe\x15\xe6W|\x13%`q\xea=z\xf6\xf1㋱\x02\x16\xaa\x8c(\x86d:@{2\x01KRl<\xcd\xef3\xfb\xe65\xe3X\nm\xd0p\r\x9b\xed\x11\xe7]\x8f|BW\x04\x8f\xfc\x89/\xb1\xf4l\x12[i\rܬ\xf1\xa2q\x96cM\x95\xbc\x93J\x02\x16\xef]W&_\xc1\xab\xee\xad\xd6\xe4\xa0l\xcdIo\x9c\x06\x05\x85\x93NE\t\u0602\xfe\xcf\xdc,V\xa8\x14w\x17\x9f\a=0%\xfc\x82\\\x8d\xf3\x81I>\x84\x87e\xad\xb4\x80a\x1f\u007f0\x0fm\x89\x1f\xdc\xc2f\x15\x88z\xba,\xb9\xc1\xe2\b\x18\xfbϲsO\xa4\xb9'\xc4~\xceY\x92~{\xefB%Wv'Q\x0f\f\xf7W1\x01\x93\x14\x9b\xd3Mup\xad\xcf9\xf2\x0f\xf9\x989j\x82Ƴ\xf2zqUؙ\xf6\xee\xb3~\xdc_\x16\xc4q\r\xf0Dh((\xf1\x81=>t\xb8\xb1\xdf~Z\x10\xb0P3\x1f\vc\xcdh'~\x9cz\xa9\x0flJx\\'U\xa2p\xb2\x83\x93\xcc\r\x19\x8c\fe\x94\x05,I1\xff\xc6\xf1\xcb\xe8_\x9di\xf2/!\xd6 Av\xe3\xbc\xeb\x91O\xc8\xc8.\x1f\xd7\xd6`ى#\xb6\x92\x1a\x82ES\xc5ϊ\xa7t\xc2\xe7&\xf5[\xc6\nX\xbcw]\x99\xfc\x1d\xb1y\rZމ\x9c\xbf\xd1\xd6\xc5i\xd0\xf7\xc2#\x9c\xd9(\x01[\xd0\xff\xd9\x10\x1a\x88>\x1d\xf9wG+sC.\x16u\x05,\xd0$\xb8+\x1e\x9a\x02\x01/\xc5a\xf6z\x05M[I\x01\xa3!u\x1f\xd0G\xf1\xbe\x96\xf4\xc5\x06\xea\x88\x11\xb0{/\xe5ɢ\x1bt\xff\x1e\xf7V\x9a[\u007f\xf4\t\xe3\x15\x91\x80F\xea\xc1\xe8\xd3wF\xd5\x10\x86\n\xd8l\xf1\x98\xd0\x03\v\x17Õ}\xa7\x8d\x95\xfdt i`g\xc0\x8d\x95r\x03\xe9\u007f\xe9\x8d\xf3\xf8<\xb3\x8ag0\x1bz\x9a*\x11\xb0\xca\x1a\xeav\xbb \x17\xb0\xbf\xb2[\x04_\x8c\xe9\x81)\xd6\x1bv\xe2\x8b5|\x13\xa5Dc\x9cd\x8a\xabO\x13\x9e\x8e\x1a%`\v,\x96\u05fc\xf3Ӽ\xf6<,ChP\t-\x1b\xe7]\x8f|BW\x8e2G\xfdQ\xda\xf9\x8a\x9cMb+\xfb\x00\xee\x18\xb0\xa1\xa3\x92\x9dD&\br\x01\x8b\xfa\xb8\x95\xbf\xa4d\xe4\x1fP\xc8\xf4\xb3\xa7\x90T\x9b\x15\x1b\x14\xd43\x9f\xd8\u007fD\x04\xec\x9b\"\x1c\xb7\xc5\xf2\xff\xb3:\x8dBg\v\x9eB*\xd2̦\xf7\xfa-=\xe2\xfe\x8a\xfb\xc0\n\v1\x9eF\x16\xf2)\n3\x8f\v\xe5\xc1a\t\xee\x86I\x9c\x00\xa9\x80\x19\x8d\x18\xbf\x16\x1c\x1d\x91dQ\x19\x91\x81٣FY\xee\x98`\xd5x\x9b>Od\x93\xa4\x8cעj\b\x9f\x98\n\x18\xbeXO\x05LR\f\xd7\xdfЍp\xd7\xe8?b\x99\x81\x0eO\x83\xf4\x9fRj \xbdS\xfe\xa4\xff\x8b\xfeO4\x11\xcf\x00_\xa8d_\xcdR\x01;|\x81U+\x170\\s\x98\x9c\xed\xb9>J\xc0\xe2\xd4+\x110=\x19\xa8\x05\xff%J\x89f\rFڗ\xba!Hp鶀h\x1c\x11\xb0\xc5\x14+\xfdgM\x17:\x165\xb3OhС\x1bS\xb7\xe3\xbd\xeb\x91Oh\x84\x19\xf4\t>\xb0\xf0\xd9$\xb6\xd2f\xd6\u0590o\x05c-;\x89\xb2\x80)}\xdcr\xdb\xc9:\x85\x89\xd4q\xa6\xf6\xb8\xb3\x84\x91\xa5r\x83.\x94\x11\x91\n^d\x02\x16y\xcf\x16\xf2\u007f\x16\xc8\xdb\x1bs.\x10\xb08\xb8\xf8n\xa7\xdbi\x11g\xe2\a<\x0e\xb3\x87\xceΛ\xf1x̽\x1eub \xca9\xa7\xb9Ծ+\xc3M\x05l\xf39k[E\xe8AX\x84}H\xe9\xf3\x15\xf9\x8b]\xf7\xe5D\xf0\xe9\x97:\xfaȌ\xfc\xbbw\xf4\x9f\x16ffG\x92E\\M\u07fdʒ\xe7\xf2\xdc\xc6\xdd\xf5\xfd\xdf^\xa1\xffB\xad\\q\xebp\xff\x15\xee\x91\xdc |\xe2\xb91\xae\u007f\x16?ҳ\xa7\x90\x91b\xf8\xb6\xbe$Xɾw\xcb8C\xebH\xffi\xfds\xa9\xc1\xbb?\xb1GM\xa2g+h\xa85\b\x02\x15\xc7\x00?\xe7\xeeЍt&~+w\xa1\xf3v\x15\x19uLH\x9b9\xa57\xdc\xfe\xe63Nw\u007f\n\xbf\xa43\xf1;\xec\xf6\x97q\xea\xa53\xf1'f\xc5\x13\x18\x0fݹ]C\x8b\xc9\u07b3G\xfa\x13\x9d#7\xc4\xdf-\xb9\xd2.\xb1\xad\xf0\x14r\"\xb8\xc8b\xb8!#3\x90\x9b^\x87eL\xb1\x1b\xf7t\xed\x97'\xe2\xbd\xeb\x92O\xa8\x9ek\x1cn\xe4\xea\xe5\x1f\xac\xd4V\xf2\x01\xdc\xd8}\a\xdf\xd9M4T\xfaN\xceM\xd8\xed\xfa/\xedv\xe6\xa3W\xf8\xb8\xa3\xde\xf5}hsT\xefg~\x90=\x19O\xf0\xa5\xa9ܠ\xbf\x18\x0ew\xf6\x9f\xd73\x01\v\xbfg\v\xfa?\xbb\x8c\x94~\x8d\xf2@i\\\xb9\nQY\xc0\xb0\xa7\xc7bj\x1b\x14\xbd\x14\x1e\xea\x02k&\x89\a\x827l\x05܆\xfe\xe3Y酴\xf3\xd7TX\x97\xb3)\xbb0F\xbf\xb0Y\xcb\xc7\x16\vq\x8d\xe38\xdd\u007f\x14\x93W\xfa\xc56w\xe33\xbd\xf11;\x10I\x16ݼRb\xb8\xf8\x97\xa8\\<v\xba\xac\xc4H\xff\x13\xef\x1bo\x1f\xd6\x19\x8c\x8f\xa2\rB'~\xb4\x9b\xce\xeb\t\xd6\b\x02\x14.\x86\x1f\x93Aĝbj\xfb/\xf7\x1a\u007fY|\xe8\xecsY\xbd\xcf\x04\xe7\x87\xd0A\xc0\xb8\xa3\xa8CL\xc51\xc0\xadzڗ\x12~\vIg\x99\xdd\xc3\xc1\x8eʢC\xf5\xf7+uFY3_\x9c\xfd\xech\xe3}\x1dI^\x14=,\x17\xe2\xd4\xcb~\v\xd9'\xd6\xff¨/\xae\xfd\x86\xd4 \u007fϞ_0\x14ׄ\xa6\xe0\x9e\xf9\t\xbdk\xe6JX\r\xba\xe7\x8b+F\xfe\x8d\xb2\xfe\x157l\x96w\xe5\xe9$8\"\xcdS\x95e\xb4O\xa7\xf8\xaeK>\xa1`\xe7\t\"\x8dA\xf9\a+\xfb\x84\"\x1f\xc0\x88\xfe\x19\x9e*\x1e\x96\xbf\x93Oŷ\x84I\xab\xc2\xc7\x1d\xf5\xae\x9b6G\xbb\x9a\xc6\xd3ؓ\xa2\xf8_\x9aq\x1a\x84_]9\xac?\xfd\x98\tX\xf8=\xc3qZ,\xbd2[\xfaI\xa5\xd3Lo<8>\x1d\xc0\xab\x1e\xb5\x05l\xfd!\x9d\xaa\xbf\x9a\t\xde\xd0\xf5ᕦZcIf\xa2\xc4\x12\x8b\x89\xac\xe4'Ԏ>跶\xe0\xc4_\f-\x9a\x8a\x98\xa9\x8f\x8c\xf6<\x04\xcb\xe9\x00+{{,\x8a`\x87\xe1U2\x9be\xe7rΒ\x1c\tK,&\xb0r\x9fP\xc0\x9c\x15\xe3s}/\x16-`\xde\xec\xf8\xcfݧ\xc7=q\x8f\xad\x1a@\xc0\x96\x9b\x95\xbb=\x80\x85\xb1r\x9f\x90G[\x1dw\xe2\xe1\x92X\xb4\x80\xa5< `\xcb\xcb\xf7\xcc\x19\x9c\xcc\nX9\xd6\xd2'\xf4b\x84\xbb\xf9\xa75Җ\x05\x02\x02\xb6\xbc0gp\x825\xff\x80\x95f-}B\xc65Ԗ\x05\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x96j\x04\x02\xf3\x01\xfa\x97\xcc\x0e\x00\xd6\x01 `)\x86kG^\xde\xdeO\xf2\xf2\xaa?\xe8o\xe8\x00 5\x01\x01K-\xe65hg\xe1G\x19;wl\xf8W\x85P2\x00\xb0\xceP[\xc0<]\xcd&\xcb@\xa8\xf7\xe0\xe0\x85\xd0\x01>\x9b\xc5\xd4>\xae\xfc\xab\xf8\xb5\xc8\xd2\xc3\xc3\xfb>\xae\xfb\xdbߜ\xff\xdf\xdf\xfe\xef\xc7\xfb\xbc\xc9l\x01`ͣ\xb2\x80M\xf3V\xa7\xdb\xd9&.h\xe83\r\xb0\x15Y}\xe6v\x87\xfb\x81\xb9}\xcd+X(\xa2\xfbR\xc2ÿe\vV\xcd|\xb2aÆ@\xe9\x86\r\x1f\xd5IƐ\xbdJK\xd2\x01\xc0\xdaGe\x01s\xf1tY\\\x1f\xefd{\xd6\x1e7\x13\xb0\x1e\vuI{M\x0f\xe2\x17\\\x1b\x84#\xba/:<|\xf0^\xc9i\xba\rx\xaa\xf3\x89\x80\xfdh\u007f\x83K\xb2\x8e\xc1\x8e\xa8e\x94\x01`\x9d\xa0\xb2\x80\t\xd1\xee\xbcB$\"\x87\xd9'\xac\x89\xdf&,Gכ\"\xa1\xe8\x96N\x95L\xc0\x16\x11\x1e~\xaa\x86;+\x84\xa4\x0e\xf8x\"`\x1bG\xbd\xd2uX⬢\x0e\x00k\x1d\xb5\x05\x8c0\xe3\xb6Xi\x8f\xcbgr\x89A=<B\xb4\x82\x81[\tJ\xa5\x16\xaf.\x96\x19n\xde,+\xee\x93D\xab\x97FtO\x16\x1e^\xce\xecM\xce0\x1c\u07b3P\x01sE\x86\xdbV1^e\xbe,.\xfd1\x94ք'5(\x8f\xd94\x15d\xe4\xc2sK`\xed\xa1\xba\x80yy\x9e7\xb3[\xc9\xda-\x8dJD\xfa\x16\xcdQ!\x17S\x97\xb9\x13\x86\xceV\xbd\xfe^m\x87$Z\xbd4\xa2{\xb2\xf0\xf0R\x82\xfd\x06]\xa3\xd0U\x9b{A\xf8:J\xc0|\x03,\f\x84\xcd)\x8bK\xef\xb1m\xaa\xc3x\xf0\x88\x86\x9aT\xa4\x1d\xb7^\xd5\xe6\xc3\xdc1`\xad\xa1\xba\x80a\xaf\xc7\xc1\xa2\x129\xa9\x8cI\x05l\xc0\xbcf\x9e\xab\xf5Ѹ\x85\x9d,\xba\xb54Z\xbdt\bII\x14\x1e>\xc25\xaejJL\xd2\xf5\x9e\xb8\xff\x1c%`X6\x84\x8cĥ\xd7\xd0\xf0<u\x1aL\xfbhfL\x03eE\a`\x06\x80TG}\x01\xc34.d7\x19@:\x03\x81\x80\xbb)\x10\xea\x16\f\xf2\xb1\x01\xd5S\x95\xc6\x12L\x03\x95}K^\xa5\xd1\xea\xa5\x02\x96,<|\x84\xfbE\x9f\xdd\x17W\xd9|>L\xf8_\x89\x05,\x1c\x97>\"`\xa5\xdb\xfc\xf3\x84\x9c\n\f\x00k\v\x95\x05\xcc/\xc8\xd58\x1f\x98\xe4Cxh\xce|\xaf\xf8drMб\xfb\x15\xed{ю\x934Z}\x94\x13?axx\t/j\xb9\x9a\xa9\xc8n\xb4\x0f\f\xcb\x05,\x1c\x97>\"`\xdbE/Y\n\x04\x99\x01\x80E\xa1\xae\x80\x05\x9a\x84\xb8\x8b\x0fM\x81\x80\x97\xe20{\xbd̡om\xf2$,\x99Z\xbc\xe4j_>\xab4\xd2~\x934Z}$\xa2{\xf2\xf0\xf0R$^0\x1c_\xc0L\xac\xeb\x15\x89K\xcf\x04쌆\xbc\x94o\x1be\xac\x99!:\x00\x88\xa8+`\xb8\xb9\x8b\xbe\xfa-=\xe2\xbe\xe8\x03\xf3\xb6\xb4\xf9\x88\xbc\xad\x99\x1f\xc7<\xe1\xca8\xee4\x9b\xf7 \x8dV\x1f\x89\xe8\x9e<<\xbc\x1c\xfa\x1crLL+\bXa!\xc6ӈMF\x89t\xc62>'o\xe9\x0e\rIu\t\x87\xbe\x88\x8aY\r\x00)\x8f\xca\x02\xe6⻝n\xa7E\x9c\x89\x1f\xf08\xcc\x1e\xd2-p\x9bZ\xdc\x1e\x8fg\xe0}\xa2\x93\xae*\x9e\xe9\xc7F\xec\xdf\v\x8e\xabp\xb4z,\x89\xe8\x9e<<|4S\xc6\xd0\xf0SA\xc0\xcei.\xb5\xef\xcap\xcb\xe3\xd2\u007f\xaam\xa8+@\x1b\xcddh~\n\x95Z\xda+\x90\xe4\x89\t\x00\xac\tT\x160\xec鱘\xda\x06\xc5I\x98\x1e\xea\x02k\xc6\xf8\xae\xe8\r[3\x13Y'tԫ\xa53R\xcfU8Z=\x8eDt_@x\xf8\xf8(\b\x98\xffxVz\xe1PT\\zWaz\xe6\x9e/\x10\xa2\xa1S\xbbvj\xb3>\xbd\xabT\x1b\x00\xa42j\vغ\xe0u\xf1\xb5\xd7\xef\u07bd}z\xfe\xb3\xb7\xc9L\x15H\x16\x9cTA\xc0\x00`\x9d\x02\x02\xb6\f\xf4\x97\b\x1d\xae`Y\xf4\x9c\xfa\x85\x00\x02\x06\x00\v\x05\x04l\x19x\xc2\t\xb3\x1e\xa6\xb8%,\x98\x13-`\\\x14\xff\xf9?\xd1\xd5(>\x1f\xf8\xb01\xe9\x01 %\x01\x01[\x06\x82W\xf4\xd7\xfa\x1e\xf5]\xd3\u007f\xb5\x840\xef\xd1\xe1\xe1\xa3\xf4\xeb?\x85\x96\xd3i\x03\x05\x03\x00\x10\xb0\xe5 8\\k\xd0\x19j\x87\x97\xa0_I\xc2\xc3\xcf\xd0\x05\r\xff\u07ff\xfd\xed\xff~\xbc\x1f~\x9b\r\x00 `\xa9\x85\x0f\xa1\x9d;?\u07b2sdž\n\x98\x96\n\x00 `\xa9ż-'++7++k\xd7К\x99\xf6\v\x00K\x06\x04,\xc5\xf0{&]\x93\x93.\x97\x1bF\x90\x00\x00\x02\x96r@\\H\x00\b\x03\x02\x06\x00@\xca\x02\x02\x06\x00@\xca\x02\x02\x96\xfalXq\x92]!\x00,\x13 `\xa9φ7+\f\b\x18\xb0R\x80\x80\xa5> `\xc0\xbaEm\x01\xf3t5\x9b,\x03\xa1)\x00\x0eq\x05\x1dy.\xb08@\xc0\x80u\x8b\xca\x026\xcd[\x9dng\x9b\xb8\xa0\xa1\xcf4\xd0\x14\x9b\v(\xf2\xf6/\U0004e000\x01\xeb\x16\x95\x05\xcc\xc5B\x0f\xf9\xc4\x00\x1e\xd6\x1ewSl.\xa0@\xf0^\xc9\xe9x\xc7$\x02\xb6`-[\xb0\xe1\x9b\x05\u0602\x80\x01+\x85\xca\x02\xc6\x02\x16b\xaf\x10\x89\xc8a\xf6\x89k\xe2Ks\x01\x05\xa6j\xb8\xb3\xdf\xc7;\b\x02\x06\xac[\xd4\x160\u008c\xdbbe\x91\x88L.I`\xdbP\xee\x1a`~˦/r\xb2{\x8fg\x15Ra\xb6\xed\xc9٤ݻ\x95\x1e\xf0\x96ksN\x9e\xd4n\x8e^\xfb\u07fc\x85\xa7\x1bw\xa6\x18\xfe,3*B&\r\xe91,\xcfz\xa6\xe3\xb8o^\\<\xaa\xaf}\a\x02\x06\xac_T\x170/\xcf\xf3f\xd6\xe3\xb2vG\"sGr\xd7\x02\xbd\x99\xa8z\x17\xd26l\xb9L\xe3a\x1f\xb9\xd5\xcdk\xd1<\xc6\xfe\xbc\xec\xaf\xcfi\xd2M\xbf\xb8\x1ce\xbf\x1f\xed\xa1\x1b\xbf\xf9\xaa\x80Y\xb6ԗ$\xa8\xda\xdc\v\x819<\xd7\xd7w\xb8\xb2\xd8p\xb3~\xf7K*`\u007f\xf8\xf9\xc7\x1f\xfd\xf4\u007f\x13)\xf9\xdf?\xfd\xe8\xe3\u007f\xfc3\x11\x95_\xffxÏ\u007fM\x0e|L\xd2\xffH\xfe>\xfe\xa3 6\xbf\xfd\xe9G?\xfa7\x89!)\xf9\xf1\xcf\xff,ɈT\xf1ۿ\xfb\xe8\xc7\xff\xf4&\"`b\x95o6\xd0\x04\xa9#rV\f\x00+\x83\xea\x02\x86\xbd\x1e\a\x8bJ䤂\x15\ue045r\xd7\x06\xd9\xe5؊\xac\xf8H\x05\xc6\u05f5t\xf1篳H\xef\xb2\x05\x8d\x93\x14rĘO\xd6\tq\x84\xa6'\x05\xa6eG\xafqU\xa1\xb0\xb6FqUC#ݩ\xe2N\xbf\xc5\xc1\xb7l\b\xf9\xd3_\xfd\xf9\xbb\u007f\xff9\x91\x92\xbf\xfb\xddw\u007f\xfcG\"X\xff\xe7G\xbf\xfb\xf3\xef~\xf4\xdb7o~\xfc\xfb7\u007f\xd8\xf0\xc77\xff\xfecQ\xbf>\xfe\xedw\u007f\xf8G\x89!\xd9\xfe\xf9\u007f\xfc7IF8\xf1\xef\u007f\xf7\xef\xdf\xfd\xe1\xbf\xfcSX\xc0\xc2Un\xf8\xd1\xef\xbec\x89\xf0Y1\x00\xac\f\xea\v\x18\xa6q!\xbb\xc9\x00\xd2\x19\b\x04\xdcM\x81\x804w\x8d\x90݂\a\x91\x0f\u007f^Jƅ\xd9[\xff\x99\u007f\x18\xa0}\xaaSY\xe4Ņ\xda㕚D!dC\xc8\xfbE\x9f\xdd\x17WF|>,\xf0\x9c\xeeT\x15\xbd\x14r\x89\xc0|$\xf6\xaf6\xfc\x9e\xbc\xfc\x99\xf4\xba\xfe\xfe\xffP\xc9\xf9\xfb7o\xfeǯ\xde\xfcjÿ\xbd\xf9\xa7\xffG0`\xf9RCʟ\u007f$\xc9\b'\xfe\x81&\xfe\xf8㰀\x85\xab\xdc\xf0[\x9a\xf8\x99\xe4\xac\x18\x00V\x06\x95\x05\xcc/\xc8\xd58\x1f\x98\xe4Cx$\xb9\x89ʦ\x10\xd9]xHC\x14\x8b\b\x18\xf6\xf1\a\xf3Ж\x06\x92\xba\x8c\xbc4\xc8ll\x0f,\x84\xcd*`\x93g\xbf\xa8\xe5j\xa6p\fU5b\x82\b\xcc\xff\xfc\xf8\xbf\xff\x1bU\x13Ak\xc8\xeb\xc7\u007f\x16e\xe8\xb7\xff\xf5\xcd\xcf\xfe\xdb\xcf\xdf\xfc\xfdo\x05\xad\xf9\xe8\xcfoB&\xc2\xeb\x1f\u007f\xfe\xf1\x86\r\x1fI2\"U|\xf4\x11\xfd\x99PX\xc0\xc2Un\b%\xc2g\x8d\xbd8\x00P\x05u\x05,\xd0\xd4˶\x0fM\x81\x80\x97\xe20{\xbd\x01In\xa2\xc2)\x84D\xc0\x1e\x9c\"\xfb\xbe\x96\xf4\xeb\xa43\x96\xb6\xd7=\x9e[\xb0\xf8FJ\xbc`\x12\xaaB\x91n\xa9\xc0\xfc\xfeW?\xff\xf8WJ\x02\xf6\xdd\xc7\u007f\xfc\xe8\x8f\xe4\xef;\x89\nI\x05\xecg\xff\xf3\x8fo\xbe\x93\xeaV8\x11\xea_\xc5\x17\xb0\xf0Y\xa3/\r\x00TB]\x01\xc3\xcd]\xf4\xd5o\xe9\x11\xf7\x05\x1fXtn\xca#\x11\xb0:\xc4\x1aWx\f\xe3Q\xb4\x05\xa1\x9d\x9eXsw\xc3dl\xa6\f\xfa\x1cr,*O&`o\x04\u007f}X}X\x8f\x8b\x8e\xf7\xde\xfc\xc3\u007f\xff\a\xf6'\xf0\xb3\xd0\x102\xf4J\x95\xed\xdf\x15\x05\xec\xef\u007f\xfdFj\x1b\xa92<\x84\xa4\xb0\xb3F_.\x00\xa8\x84\xca\x02\xe6⻝ng\xc8]\x1f\xf08\xcc\x1eotn\xea\xe3̺\xeck\xd94\xee+\xdd\xe9&\x02\xb6\xf9\x9c\xb5\xad\x02\x91N樦\xc7j\xf3(t\xc0\xf6\x89\xb1\xb4\x131e\xbc\x80%\xbc\xfb\x93\xbd\xd2h\xb7\xb3\xe0\x1fD`\xfe\xcb\xef\xbe\xfb\xee\xd7?\x95\xa8\xcf\xff\t9\xda\xdf\xfcjï؟\x00\xc9\x13\x9c\xf8!ß\xfe\xea\xbb\xdf\xffXQ\xc0~\xf7\xf1\xbf\xfd\xf9\xbb\xdf\xfdװ\x80\x85\xab\f;\xf1\xc3gU\xbed\x00XvT\x160\xec鱘\xda\x06\xc5i\x02\x1e\xea\x02k\x8e\xceMy\x02\xa4\xa3՜\x892,\b\xed\xc7M\x85u9\x9b\xb2\v\xe9 y@C\x1d\xf4\x9b\nc\x9c`f-\xafPMB\x9e\t\x8f#ki\x9a\b\xcco\u007f\xf6\xd1\xc7?\xff\x83D}\xde\xfc\xfa\xc7\x1f\xb19\x0fo~\xbf\xe1\x0fo\xfe\xc0<\xf3\x82\f\xfd\xddGt\nD\xd8\xf0\xf7?\xfd\xe8G\xbfV\x14\xb07\xbf\xfb\xd9G\x1f\xfd\xecwa\x01\vW\xb9\x81&\xe84\x8a\xf0Y\x93]-\x00,\x13j\v\xd8:ƻ\xf9\x98w~\xde7t \xeb\x03\xf74C\x02\xa3\x161\xe7\x03\x01\x03V\n\x100\xd5h\xcf\x12F\x8f\x01\xed\xdd$\x96\x8b\x04\x04\fX\xb7\x80\x80\xa9\xc6h\x9a0vt\xa4=Lb\xb9H@\xc0\x80u\v\b\x98j\x04*ҏ\xb5\xf4\xb6\x1cK\xafHf\xb9H\xd4\x16\xb0\x18@\xc0\x80\x95\x02\x04LE\xac{\xb25\xd9{\xac\xc9\xcc\x16\v\b\x18\xb0n\x01\x01K}\x92\x85\xdcX~\x92]!\x00,\x13 `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `@\"\xfc333\xf3\x18ϓ\xcdZ\xf9\xa9*\xb0\x96\x00\x01\x03\x120\x90\x86\x10J\xf7\xf9\xd2\xc9&-j\x9dE\x00Xy@\xc0\x00\x05\x86k^\xb3\xad\x05Y\x87\x86\x1c\x18;\x86\x86\xac(:\x98\xd2Bi/\xf0&3!x\v\xda\x15\x92\x00\x90\x10\xb5\x05\xcc\xd3\xd5l\xb2\f\x84\x96cp\xf0\xe1i\xe9\x92$\xf0\x01\xf8\x8a\xe3:Ȧ\x83㾊:2v(*D[,w\xb8Va\x15~Kdy~\xb7 `\xc7P\xda\"\x85\xac\x01\x9dKf\xc2hHkPH\x02@\"T\x16\xb0i\xde\xeat;\xdbĥ\v}\xa6\x81PT\"I\x12\xf8\x10\xbc,\xbe\xf3\x03\xd9\xfcp\xa7\xf8eԑ\xe1\xe2~1\xf5\xe8\tV\xa4\x93\xbb/\xa6b\x05\xccc\xdbT\xa7X\xa8wT1\x1b\xff&ͬ| \x06\xebƫ\nI\x00H\x80\xca\x02\xe6\xe2\xe9\r\xe1\xe3\x9dl\xcf\xda\xe3\x0e\xa9\x96$\t|\x10N\xdcc\x9b{'b\x8e\x04C\x89\x1a\xd9\"\xafa^\xe8\x1aC\xc9X\x01\xc3X\xa3,`;J\x15\xb3'5\xa7\x14\xf3\x958\xa3q+$\x01 >*\v\x18f]//\xef\xa1\x1b\x87\xd9\x17\x8a\v)I\x02\x1f\x86\xf3߰M\xe3\xf9\xf8&U\xca\x02v\xc5\x10\x0e \xb2\b\x01\xcb?\xa8\x98]\x91\xbd\xf0\xe5\x1b}\xd9\x15\nI\x00\x88\x8f\xda\x02F\x98q[\xacti?\x9f\xc9\x15\nl+I\xae\x17\x9a\n2r\xabɽ=\xbe\x11\xa13\xae\xf2\xad\xe9{\xe6%\xc9(c\xf3\x16\xb6\xe6\xb4;S\x8c\x1b\x99)ힴr\x1cׇ\xfb\xc8k\xab\xb4Lc=\xdb\\h\xc4\xcft\x1c\xf7͋\x8bG\xf5\xb5\xef\xf0[=\xb3&\f\x8bArYp\xb6\xe0\xfd\x9a\xe2ʛb\xf8\xef\xe2p\aLY\xc0\x8eWdg\xeds\x91^3\xb9\x92/p\x1dy\xb5X\xc5\v\xcbg\x16\xa1\xb6\x11\xfc\x99\x9f\xd3ͻ2]\xa3\xc1\xf0\xe8F\x89\x91\x9e\xc3^{XWV{\x98\xf6\x04_],3ܼYV\xcc.\t\x9fI\x9f\t\x9dN\x92\x04\x80\xb8\xa8.`^\x9e\xe7\xcd\xec\x9f\xdb\xda\x1d\x8e\xcc-I\xae\x13*Ҏ[\xafj\xf3\x03x\xc6Ҽ573\xa7\xba\x1c\xb9%\xc9(\xeb\xfdh\x0f\xdd\xf8\xcdW\x05\xcc\xd29Y\xaf\xebk\xec\xb3xv\xc2X\xffJZ\xe6^\r\x9e0L\xe0\xaa{x\xae\xaf\xefpe\xb1\xe1f\xfd\xee\x97\x18?\xb6\xdb\xf5L\xe8f'XX\x10;\v\x92{\x85\xbb1\xd2y\xa8\x8a\r.\x9fr\xf6p%\x8a\x02\x86\xf2[Z\xb6g8\xb0o \xe7\xd84\xf6\x9e˴\xf9|\x03\xb6\xdcB\x9b\xcd\xc6\\\x03\xe1\xb6a\x1a\x89I\b\x99\xf7\xa8\x84\xbby\x9a+\xbb]\xd6AN\xb0\xfbb\xffؽ2\xee\x1d\x11\xcb\x13\x86\xceV\xbd\xfe^m\a\xb3\x1a@\x83\xa1\xd3I\x92\x00\x10\x17\xd5\x05\f{=\x0e\x16\u007f\xc8IeLP-Ir\x9d`EԳ=\x84Z\xe8N>\xda\xe5\x13\aג\xa4\x94\xc9:!\xee\xda\xf4\xa4\xc0\xb4\xec\xe8\xfd_\xb2͉\x90\xe7]\xc0^\x86\x1bu\x8d\xf83\xa6FU\xdc\xe9\xb78\xf8V8\xa2\x0f\xf5\xd4\xc2C\xc8a\xe6\xb5\u007f,t\xcdF\xb8\xe7\xe1J\x14\x05,\x8f\xf4\x8dfr\vH\xb2\x8e\xf6\xb8\x8e\b\x83\xbd\xf0\x10R\xd66+\x12#\xc6\x19.\x92\x8a\x87\xf1ů0\xee<D\xa4\vw\x96\x10\xb9\xec\xe3\x9e\xd1g\x06\xa1\xb0\xbdnt\v\xc7&\x01 .\xea\v\x18\xa6\x11 \xbbɨ\xd1\x19\b\x04\xdcM\x81\x804\xb9^(\xdd\xe6\x9f'\xe4\xb0{??\xe2\xb0\xceO軞D!dVϸ\xb9\xd9\xfbo\xdf\x15=\x93\x19\xbf\xe4f\x8d\x17\x8d\xb3\x1c{\bYU$y\x16\x19+`\xf5G\xe7\xde\x11\fW\xe8N?\xf7\"l\xaa(`_\xd0\xd7\xeb4̸\x1b9\xc8 Q\b\xe7\x19\x160Y\xdb\xda\xc3\x02\xd6G\x04r\x96\rl_\x1a\x8e\u07b8\xf748Gr\x1bK\xc8\xcbs\xee\xdb\xf09Zpl\x12\x00⢲\x80\xf9\x05\x8d\x1a\xe7\x03\x93|\b\x8f$\x99\xb8\xf4\xdaa\xbb(D\xfb\xe9N\xfe\x8ep\xbe$\xa9\x84\xcd* \x9f\x13?\xa7\x9b\xea\xe0Z\x9fss\xb2\xdc`\xd1T\xf1\xb3\xe2)\x1d\x1b\x16V\xd5H\x8e\xc4\n\xd8\t\xd1\x1fv\x96\xeeLp\x13a\xd3\xf8N|\x1b\xa2\xd3&\xf6\x9e\xc4]Y\xc2x6,`\xb2\xb6\r\x86F\x82\x86\x11\xfcX'z\xe6\xde\u07bbPɕ\xdd!Wֱ\xfb\x15\xed\xf2\x85z`Ch\x00\xc7&\x01 .\xea\nX\xa0I\xf0\x88<4\x05\x02^\x8a\xc3\xec\xf5J\x93Iʯ\x19ʷ\x8d2\xd8\x14\xf5\xfc\x03\xe1|Ir\x11T\xf6\x9d6V\xf6\xff2:\xf7\x8e\x01\x1b:*YZ\xf6\xbcQ.`\xf7^\xd2\x1e\xd8\x13\x06s\xa2\xcd\x16E\x1e\x06(\nX5}5!:еj\xfd\xe2\bR\x100\x93;\xaam>\x8d8\x8b\xd50\x86\x1f\x17\t\x02\xf6\xb8\x91H\xd7\xdb>}'\xed&־|Vi\fM\xec\xa8ӄGϒ$\x00\xc4E]\x01\xc3\xcd]\xf4\xd5o\xe9\x11\xf7%\x8e\xaf\xb5\xeb\x03\x9b\xac\x8b\x99\xe3\xd9%\xa8\xc1\x17\xac3#\x99\x80\x10g.\x82\xbbaR1_\xa4\xfe\x86n\x84\xbbv!ʶ\xb6\xe6<>od\xa1o\xe3\b\x98ш\xf1k\xea\xf8\x1a\x13\xbc_\x8d\xb7Y\xf6\x85\xca\xf0L1E\x01\xcb!].\u007f^!M\xfb\xb5\xd6,\xf1\xb3,$\x19\xd3\xd4F\xd662\xa0\x14\xbe\x95$\x02\xd6ʍ\xd0\x1c\xe35\x8c\x9fpe\x1cw\xfa{\xf1\x14\x81\xbcp\x84rI\x12\x00⣲\x80\xb9\xf8n\xa7\xdbi\x11g\xe2\a<\x0e\xb3\xc7\x1b\x9d\\s\xecC\x9bcz\x13\xa7P\xa9\xa5\xbd\x025\xe1\xf9A\xf6\xfc\x8e\x8a\x8e$\x19SC\xc2\xdb\xf9\xb6\xbe$X\xa9\xbf\x1de{c\xf7\x1d|g\xf7\r\x8c\xdf\xfd\x89=od\x9e\xad\xb9\t\xbb]\xff\xa5\xdd\xce\xfc\xf9\xadE\x1d\xfd\xa7\xd9L\xfd\xc6\xdd\xf5\xfd\xdf^\x11d\f?\xe7\xee\x84jV~\n\xb9g\xb0\xa7 K\xb8\xccS۲\xc49\x1f\xe74\x97\xdaweP\xf3p\xdb(\xae\xb4Kt3\xf5Y\xc7l\x9fnj\xb6\x9e\xa8U+W\xdc:\xdc\u007f\x85{\x84\xf13\xfd؈\xfd\xfb\x90^^Fa\xa5\x97$\x01 >*\v\x18\xf6\xf4XLm\x83\xe2,\x00\x0f\xf5{5G'\xd7\x1c\xa6\xcdh(&\xb3k\xa76\xebӻ\x18\x8f\xa71\x87\x11\x15\x1dI2\n\xb3\x96\x8f͌\xf0\xb8\xa4\x15\xdf)~\x1ce;\xa2\u007f\x86\xa7\x8a\x87\xa9\x93\x9f\xc1\xfabOEo\x17\x9b\xa6?w\xe33\xbdQ(6v\xba\xac\xc48\"\xd6ת\x0fy\xc1,\xc8\x15ZN\xc7\x15\x12\xb0\xbc\xba\x83\x99\xd9\xe5\x1eaDžB\x13N\xfddz\xd2\v\x85v\x86\xda\xc68\xf3\x93\x01\x8c\x83\xa4\xa3\xd5W\xcc\x15\xf7q\xdcy|\xdfx\xfb\xb0\xce`$\xfa\x85't\xf4btF\xe6\x04\xb3\xa5\x9f\x14\xcbH\x93\x00\x90\x00\xb5\x05l]ҎR˟\x13\xbc\xa1\x13\xfabl\xaejh9\x1d\xa4\x14Pܧ\xe9UȕQ\xad\xb1\xc4;\xf4\xba\xf8\xda\xebw\xef\xde>=\xff\x19\xe9\x11\xb6h*B\x13x%I\x00H\x04\b\xd8r0#\xce\xd7b\x93\xc9\x03\xe6\xacc\xc9\n\xac2\x82\x1d\x06aR\xec\xfc\xf8Ph9\x9d\xa1q%M\xb1h\x93+\xcd\xe5\x1c\xf9\xbc\xb5\b\xfd%\xc2\xe81X6\x82\xbd\xd9\xe1\x15($I\x00H\b\b\xd8rP(\xce$`\x8en\x8f\xb6z\x8d.fZ\u05cbw-l\xa9\x9c\x89'\xb4\x8b\x00\x00 \x00IDAT8<\x11'PLqO\x93X\x02\x80\" `ˁK\x9c\xaf\xe5Jf\x98\xd2\xf8P\xfe\xb1E\xfcT[\x81\xe0\x15\xfd\xb5\xbeG}\xd7\xf4_\x051\x00,\x01\x100`ɜۼә\xcc&1\xc1\xe1Z\x83\xceP;\f\xfa\x05,\r\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x100\x00\x00R\x16\x10\xb0uɺY\xb7\bX\u3000\xad?<\x15[\x84\xd5\x06\x01 \xd5\x01\x01[w\x04\xf2\xf2\xf8\x9eD+W\x03@ʠ\xb6\x80y\xba\x9aM\x96\x81\xd0\xefO\x1c\xbc\x95nf\xcclAi\xf3Z\xfa\xc9`\xb7\xd6\x1aJz\x8fmI\xdf\xfb^\x836k\x96\x15/\x94Љ\x8f \x842\x94~\xcb4\x8e\xba\x14r\x01 \x15QY\xc0\xa6y\xab\xd3\xedl\x13\x174\xf4\x99\x06تw>\xfe\xa1\x87\xb0\xa6\xd63\xb4f\xdc\n%wm\xb9~$\xfd\xbd~3\xf89\xfa<\x99I\x98Љ\xdd6\xdb\u05ca\xa1Ɇ\x90|I}\x00H]T\x160\x17O\xc7.>^\xf8\t\x9d\xb5\xc7-\n\xd8\x1a\x1cф\xbb\\^t\x15\a\xdeK\xbf\xf0\x19t&\x99I\x84H_o(\x8e\x80A\xc4E`\xad\xa0\xb2\x80\t!\x0f\xbdB\xf8!\x87\xd9\xe7Y\xbb\x02\x16ƅ\x16>\xfe\x8bC\x1d\xaaKf\xa2\x04\b\x18\xb0\xd6Q[\xc0\b3n\x8b\x95\xf6\x12|&\x17^\xa3\x02FW0Mc\vd\xfb\xb5\xc2\xca`\xd5Q\x16\xc1\xfb5ŕ7g1~\xa6\xe3\xb8o^\\<\xaa\xaf}'IFY7 \xb6\u009f;S\\g,S\xfa~\x1dC\x9b\xf8\xea܌=\xaco\x1b>1EY\xaazA\xc0\x805\x83\xea\x02\xe6\xa5\xdez\xd6\x0f\xb3v㰀u\xdf\xe2\x9bm3\x89K\xa6\x12\x0fl6!|\"~hkAu6\x9b'\xca\xe0\nwc\xa4\xf3PU\x10\xcf\xf5\xf5\x1d\xae,6ܬ\xdf\xfdR\x92\x8c\xb2\xbe\x8a.Ӎ\xdf|U@\xf6\xb8\xc3ټ\x11i\xeb.e\xb2\x88l\x91\x13cE\x01\x9b\x9f\xeeݑ\xf5~\xe3Y\x00X=\xa8.`\xd8\xebq\xb0\xa8DN*c!\x01k\x1aw;--k\xe9)$N\x0f\xe9\x88\xd2\x10r\x98\xbbO^\x1f\va\x80\xaa\xb8\xd3oq\xf0mTR\n\x8f\x84@\x1d\xd3\xe2R\xd5QK4k\xb2h8F\xad\xb8\x97\x9eH\xc0\xf6\x93\xfe\xdb{\x8fh\x01`\xb5\xa0\xbe\x80a\x1a\x17\xb2\x9b\f \x9d\x81@\xc0\xdd\x14 \xa3ɀ\x83v\xbef\xcckjh\x93P\xc0\xea\x8fν#\x18\xaeН\xaa\xa2p\x8fK\x92\x94bFf\xba\x99D!\xe4Cn\xcd\x11LÚ\x89{\t\x05\xcc\xdd\xc5\xe7A\x0f\fX3\xa8,`~\xe1\x11\xd98\x1f\x98\xe4CxB\amm\xf1\x8a\xa5\"\t\x05\xec\x84\x18\xdd\xec,ݩ\xaa\t\xe7K\x92R\x06\xb2\x04%\xb2\x89KUG̓`ѯ\xeb4\xe2^B\x01#\xd8\x14\x82\xbc\x01@j\xa2\xae\x80\x05\x9a\x84 \\\x0fM\x81\x80\x97\xe20{\xbd\x01\xdc#\xdc\xe1\xbdkjl\x93\xa4\a\xf6\x84\xc1b\xffH\xc2f\xcb\"h/\x18\xe6\xf5Z\xb0\x80\xc1SH`\xed\xa0\xae\x80\xe1f6\t\xdco\x11\xc3ы>0+\xebzy\xcd\x0f\xe3\x94JI\x12\nؘ\xe0\xfdjdѴ\x17 `\x89\xe7\xf1\x83\x80\x01\xeb\x15\x95\x05\xcc\xc5w;\xddN\x8b8\x13?\xe0q\x98\xe9\xfc{7\xdf\xe5r?0Y\xdf\xeb\xe76\xab\t\xff\xa0ͦ9b\xb3\xf9BO!\a\xa3\x9bָ\xbb\xbe\xff\xdb+D\xc6\xde\xfd\xc9^i\xb4\xdb_\x90<I2\n\xeb\xe6\x04\x9dS\x8fmӑA<zd\x93\xcd#=1\x9b\x89\u007f\xd9f\x8b\x99\xa1\xf2\x00\r(U\x03\x00)\x88\xca\x02\x86==\x16S۠\xf8\xb8\xd1C]`t\xd6\xd2tw\xb3\xd9\xeaX3\xfa\x85\x87\xd2\x04_;\x8f\xfdY,\xb11&z\xcf\xd8\xe9\xb2\x12\xe3\b\xc6\xcf\x04gX-\x96%\xa3\xb8\xabU\x8a\x8a-r\x8cԿɑA^\x8fIN\xcc~\vI)\x8d\xb6\x9f\xdexp|z\xed\xbc\xd7\xc0\xbaFm\x01\x03V\x9e\xf6<\x04\xcb\xe9\x00k\x03\x10\xb0\xf5\xc8\xf4\xb8'\x99\t\x00\xa4\x02 `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x00\x00\xa4, `\x80*\\Ϡ\x91\xe1\x06\xb3\xd6T\xf0O`\xc5\x01\x01\x03B\f\u05fcNf\xb2d|\x19\xd5t\x1d\xec\x03\xda\xf9d\x96\x8b\xc4[О\xcc\x04Xè-`\x9e\xaef\x93e \xb4(\xbb\x83\x0f\xads\xe5\xbck\xb6<\x88S\x06H\x88}\xb7\xb8>\xb5\xfeY2S\x8c\xbf\xa4v\xe1\x15\xc7\xfez\xadL_\x1b\x14w\xeep\xad4\xe9Ԛ\xb1I\xeb¸\x02\xa1Kd\xff\x12B\x15Q\x95tk\x17\xbdv\xee\xe8F\u007fv;\x9e\xde\xf4ET~\xf8lK\xa6!\xad!\x99\t\xb0vQY\xc0\xa6y\xab\xd3\xedl\x13\x174\xf4\x99\x06؊\xac\xd8\xdf\xcd\x0fN\x8e\xf2\xef\xf3\u007f\xbcNx\xf4$&kn\xe2P\xad\x9dp\x9f\x1bIj\x8b\xbf\xb7\xdb;\xb9\x89\xd0\xde\xe9C\x9d\x17\xf5b\f\xa4N\x16(\t\xe3\x1eT\x8d\xabQ\x0f\xc6\xee\xcd\rt\xbc\xe7mȌ^\x13њqKL\xf5\x8e\xe2\x851\xa4\tl\xb5\xe0\x064\x19\x95\x1f>\xdbұn\xbc\x9a\xcc\x04X\xb3\xa8,`.\x16\xc2\xd6\xc7\v\xeb\xfbY{܂\x80\xf5\x98<4bd̪\u007f@45JkN\x1f\xbdF_\x9fG\v\x98\xa2-\r\xe6\x16\x12\xb0\x1f\xb8N\x1c\x9c\x15\xd2/t\x8dB\xe2\x01:\x87\xcf!*L\x9f\x98X\x86i{L\x15\xe1\xe5\x10w\xc4,\x97\x18\a\xefF\x13r\x04\xb6\xee\x8aΏ\x9cm\xe9\x9cѬ\xb1\xb8\xc8\xc0\xc2QY\xc00\xebzy\x85HD\x0e\xb3OX\x13\xdf\xc3?\f\x1f\x03\x12\xa2\xb8h\xbe `s\x9dQ\xf1$\xe3,\xb0\x1f\x11\xb0\x17\xdcp8\xf7\x8aAT2\x17\xba\x8c\xaf\"\xda\x19>p\x86e|q\x00\xc7%\xff`\xfccr\x8e\xa3\xbd\xb8\x17\xc5\xf8\xab\"g[:\xbe\xec\xe81.\xb0nP[\xc0\b3n\v[\xfd\xdegr\x89A=\x06M\xf3I\xc2V\x00\x94a\xd1\xd9\x15\x1d{M\x100\xca\xdb\v\x06\xdd\xe1\xb3Ϣl#\xb9\x14Q\xc0\xe6\xca\x04\x83\x9b,s\xaeX\xec\x80a/j\xc2\x16D\a\x8f_\bݫ\xd2/\xf0\xf8F\x84θʷ\xa6\xef\x99Ǿt\x84\xd2\xe8:\xe0\xd8*.Z\x9d\xcf̚\n2r\xab\xc5\xef \xf3\x16\x1eG\x11p\xce\xe3\x83Z\xba\x96\xb8\x85\x14\xa9\xc3u\xe4\xd5\"=[\x1c\x82\xf7k\x8a+o\x12q}\xa6\xe3\xb8o^\\<\xaa\xaf}'I2\x9b3\xe9k(\xa8;\xb0(T\x170/\xcf\xf3f\xf6\u007fn\xed\x0eE%j\xb7:\xdb\xf8\xe6\x01\xf8/L\xc2\xec\x04\x8b\xfaa\u007f\x1e\x95\u007f\xf4\xca\xdc\\\x87\x91\xa6\x86\xb9\xaf\x1e\xf5\x9d\xe5\x1e\xcbm#\xb9\x94P\x0f쩽\x8fk\xb5\xdb\xff\"\xecpv\xb1\xb2@\xce \x1eʡ\xdf'\xa6\x1dx\x90\xec\xe4\xf3x\xc6Ҽ573\xa7\xba\x9c>I|`\xb3\xb10H\xd87`\xcb-\xb4\xd9ll\xe4_\x91v\xdczU\x9b/|\x0f\xedG{p,\xa2\v\xdfg\xcb<\xe3\xc5\xde\u007f͢\xa1G\"g\x8b\xc3\x15\xee\xc6H硪 \x9e\xeb\xeb;\\Yl\xb8Y\xbf\xfb\xa5$\xc9l\x06 \xceҺEu\x01\xc3^\x8f\x83E%rR\x19\x13\x04\xcc\xc27\x8d\xbb\x9d\xcd\x16\u007f\xb2\xb2\x80\xf2\x10\x92\xf6\xa4\f45\xdbG\xfa*\xc1\x13\xe7嶲\\\xe5!\xe4\b\x17\xad\x8a\x18۴\xf8s\xcdI\xace\xb1<\xf3\xd1._x\x94\x1f\x8e\xdc\x16\x1eBZY\xec\xf0!\xd4\xc2\xf6&뢝\xf5\x94\xb0\v\xbf\x82v\xedJ\x174\xee\x1bf\x8f\x16\x1e\vQ誸\xd3oq\xf0mT\x12c7\xba\x15\xaf<\xb0\xc6Q_\xc00\x8d\v\xd9M\x06\x90\xce@ \xe0n\n\x90o_\xab\x89\xde\x18>3D\x8cN\x8a\xb2\x80\x9d}\xfc\xf8\"\x130\xfc\xaa\xb3\xf6h\tw\"\xcaV\x9a\xab,`\xfd\\l477\xf2\x15\x1e\xf9ԇ\x98\x8b<_\xea)\x8f\x15\xb0\xd2m\xfeyBN\"UڶSL\xf4\xa6\xfb\xb0/\xa37\x81i\x98\xfa\xa3s\xef\b\x86+t\xa7\xaa\xe8e(_\x92\xa4\x17\xda\x12[\x12X\x17\xa8,`~a\xb00\xce\a&\xf9\x10\x1e\xdc\xcb\x02\xdb\xe2^\x98\x92\x98\x94\xb8N\xfc\xa9{4\xf5\xf8\xd0\xe1\xc6~\xfb\xe9(\x01\x93\xe5*\v\xd8DdnE\x98\x80Ʊyt\xb3c\x13\xfb\xcc\xf2wH\x8e\xc4\n\xd8v\xd1\x1f\x96 ڑ\r\xb5\x89\xcf/\xe7\xb5m\xb8]\xbb \xaf\xe7\tѕw\x96\xeeTE\x9c\u007fUR?\xe0\x10D\xba\\\xb7\xa8+`\x81&\xe1k\xf7\xa1)\x10\xf0R\x1cf\xaf7\x80G\xcd쟹g\xd1\xd3#\xd7\x1fL\x94\xeeIz\x1f\x94\x88\x13\xbf\xb2\x86>K\xbc \x110j+\xcbU\x16\xb0٢V\x1cCnC6ι\xb4\x8d\xa5\xf3\xa5\xcf\"\xe5\x02f\"}\xb3\xf2m\xa3\x8c\x04\xee\xf8R\xad\x1fW\b\u07b3\xe3\xfb\xf1\xfe\xe3\xf1-%\xd4\x1f}\xc2xEw\xe2\x850\xaf\xd3\xc0\x03\xec\xf5\x8a\xba\x02\x86\x9b\xbb\xe8\xab\xdf\x12\x9a\xb9(\xf8\xc0\xbcl\x1a\x85\xcf\xf4 N) \x8cш\xf1k\xc1#\x84\xdd\r\xa2O)\"`\x87\xe9}\x1d\xac:!\xb7\x95\xe5ƙFq\xa12\x88\xa3\xd9[\xb0\x1f\x1f(\x10\xfc\xf1\xb2\t\x13a\x01+,\xc4x\x9a>M\xec\xa2/\x18\u007f!\x1c\b_\x99\x04\xaf\xe6s<\x8aΥM\x93\xf4\xa0ƣQ\xf0\xbbO\xd6\xc5L\b\x1b\x13\xda\xdax\x9b\xbe\xc6\x11\xb0@\xde^\f\xacST\x160\x17\xdf\xedt;-\xe2L\xfc\x80\xc7a\xf6\xd0\xef\xec\a\xa6\anGSۇ\xfe\x9d\xdc\x1a\xa4\xb5\xa8\xa3\xfft\xb1\xd0\x03ۇ؍Kg\xe2O\x88\x93\xb8Z\xb9\v\x9d\xb7\xab\xb8\xb2;\x13R[I\xeeK:\x13\xbf\xc3n\u007f\x19z\n9!\xea\xd6s\xeeN\xccɪQ\x03n@\xa4\xab4?Ȟ72U\xf2\x0f\xdal\x9a#6\x1b\xfb\b\xcfi.\xb5\xefʠޱS\xa8\xd4\xd2^\x81\x84\x89\xc9\xe2\x95ɸ\x84\\\xb8yk\x80\tW {O\xb6\xc2\br\x1f\xda\x1cӕj\xdc]\xdf\xff\xed\x15\"c\xef\xfe\xc4\x1e\xabRW\x9d$I\xb9\xfc\x9e\x13a\x81\x14Fe\x01Þ\x1e\x8b\xa9mP|\xdc\xe8\xa1.06\xa5\xc8\xd5nn{\x00\xfa\x95\x9c\xb9\x1b\x9f\xe9\x8d\xe2|\b\xb3\x96Ͷb\xbf\x85\x14\xfad8\xd8QYt\xa8\xfe~\xa5\xce(\xb5\x95\xe4^\x14}J\x17\xf0\\\tK\xe8BO\x1f[\xf51^0k\xc68vd\xb4c<\x9e\xc6\x1c\\L\x95\x86\x844b\xe7\xf6\x1f\xcfJ/\x14\x9e\xbdt\xed\xd4f}zW((^\x99\x8cm\xa4\xb3f\xd3X\x85G\x02\x975\x97c\f\xc8Xt3\x8a}\x8e3v\xba\xac\xc48\x82\xf13\xe1\xc2k\xb1,I\xb0\xa5\x9f\x8c)\x04\xac\x17\xd4\x160`\xb5\x12\xbc\xa1\xebKf\xf3\x1eL3\x17~\x01J\xf8ۣv\xb4xgV\x8b\xa6\x02\xbe\xf9\xd6/ `\x80H\xb0\xc3\xf0*\x99\xcd{\xc0z^~W\x82g\x8f\x01sֱ\xf8G\xe3\xe0͆\xc5(\xd63 `\xc0j\xc1\xa3\xad\x86\xa9\xcc\xc0\xe2\x00\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01[\x0eJ\x91\xb6\x1cb\xc4\x01\xc0\xb2\x03\x02\xb6\x1cxz\xcdy\xda\xc5\xff.\x19\x00\x80š\xb6\x80y\xba\x9aM\x96\x81н\xed\xe0\xe9\"\xac\xf3M\xe2\xe2\xd2͉J\xa6\x18\xbdh<\x99\t\x00\x00\xef\x89\xca\x026\xcd[\x9dng\x9b\xb8\xa0\xa1\xcf4@\x17\xc0\x9b\xe1G=\x84\a\xfcZ\xba\xe5\x87 \xd4\x17\x00,;*\v\x98\x8b\xa7\xab\xaa\xf8x\xc1Ad\xedq\xb3\x15<\x1d,(QӚ\x8a\xcc\x00\x02\x06\x00ˏ\xca\x02&\x04\x16\xf4\xf2\x1e\xbaq\x98}\u009a\xf8\x8c\xbb\xb7\xd6Ժt `\x00\xb0\xfc\xa8-`\x84\x19\xb7\xc5J\x97\xb5\xf3\x99\\8\"`N~:A\x99\xd4c\x1c-(\xee!\x00\x00\xef\x81\xea\x02\xe6\xe5y\xde\xcc\xfaa\xd6n,\x11\xb0p\xa0\xa25\x82_[0\xe0^P\xe8C\x00\x00\x96\x8a\xea\x02\x86\xbd\x1e\a\x8bJ\xe4\xa42\x16\x1607/\t\xfc\xbc&\xb8\x8b\x10ڗ\xcc\b\x00\x80\xf7A}\x01\xc34.d7\x19@:\x03\x81\x80\xbb) \xf4R\xba-Iʤ\x1a>\xed\xd6\xcb=kM\x94\x01`\x95\xa1\xb2\x80\xf9\x05\xb9\x1a\xe7\x03\x93|\b\x0f\xcd1?HP*\x15\x19B\xdd\xc9L\x00\x00xO\xd4\x15\xb0@\x93\xe0\xd9~h\n\x04\xbc\x14\x87\xd9륚\xe6]s#Hx\n\t\x00ˏ\xba\x02\x86\x9b\xbb\xe8\xab?\xec\xb1\x0f\xf9\xc0&\xf9\xb5\xf6\xc3\x1b\x100\x00X~T\x160\x17\xdf\xedt;-\xe2L\xfc\x80\xc7a\xf6xi\xcaɯ\xb5\x80Z\x83 `\x00\xb0\xec\xa8,`\xd8\xd3c1\xb5\r\x8aj\xe5\t\xff\x00\xd2}+A\x99\xd4\xc3\xef\x19-\xd5x\x92Y\x01\x00\xf0\x9e\xa8-`\xeb\x83\xfd\bmmOf\x04\x00\xc0\xfb\x02\x02\xb6\x1cxF\xd7\xda3\t\x00X\x95\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\x80\x80\x01\x00\x90\xb2\xaco\x01+E\xdarg2#\x00\x00V+\xeb[\xc0<\xbd\xe6<\xad\xb0\xb4\x8f\xb7 \xfc\xebkI\x12\x00\x80Ռ\xda\x02\xe6\xe9j6Y\x06B\xab\x17:x+\xdb\xfa\x06n\x99n\r\xacȚ\x86\xbdH\x8c\aސ\xd6\x10ʓ$\x01\x00XŨ,`Ӽ\xd5\xe9v\xb6\x89\v\x1a\xfaL\x03lEV_S\x1b\xcdmZ\t\x05\x8b\xac\x9cj\xddx\x15\xc7&\x01\x00X\xbd\xa8,`.\xb6\xf6\xbd\x8f\x17\x1cO\xd6\x1e7\x130\x9b\x85\x06垷\xd8\x12\x94\\.$K?\x9fѸ\x15\x92\x00\x00\xacZT\x160\xcc:Y^!\x12\x91\xc3\xec\x13\xd6\xc4\xef\x11|N\xed+\x11\xdbV\"`\xbe\xec\n\x85$\x00\x00\xab\x16\xb5\x05\x8c0\xe3\xb6Xi$\"\x9f\xc9%\x06\xf5\xf06\xf5z\xfd^[\x937I\xc9\xe5`\x1c\xf5\x86\xd3g\xd2g\x14\x92\x00\x00\xacVT\x170/\xcf\xf3f\xd6\x0f\xb3v\x87\xa3\x12\xcdt\x93ܮ\x15\x91\f\xbf\xb6`\xc0-D\xab\xc4\x03\x91\xde\xd8\x00\xc4\xe4\x00\x80Տ\xea\x02\x86\xbd\x1e\a\x8bJ\xe4\xa42&\b\x98\xbf\xdb\xe2\xf48-\xdd\xf3\xc9\xca.\aw\x11B\xfb\x84\xa4\x1b\xdd\n\xe5J\x92\x00\x00\xacV\xd4\x170L\xe3Bv\x93\x01\xa43\x10\b\xb8\x9b\x02\x01\xea\xc4\xf7\xb3܁d\x05\x97\x01\x9fv\xeb\xe5\x1e\xd1c\xefF-\xa1lI\x12\x00\x80Պ\xca\x02\xe6\x17\x06k\xe3|`\x92\x0f\xe1\t\x98\x1e\xb2܇\xa6@\xa2\xb2\xcb\xc3\x10ꖤ\a\x14\x92\x00\x00\xacV\xd4\x15\xb0@\x93\xe01'R\x15\xf0R\x1cf\xaf7\x10\x12\xb0ѕ\x11\xb0\x88\xb3\xabN\xe3SH\x02\x00\xb0ZQW\xc0ps\x17}\xf5[B\x13&\xc4i\x14\xe2\x10r\x85\xa7Q\x04\xf2\xf6*$\x01\x00X\xb5\xa8,`.\xbe\xdb\xe9vZę\xf8\x01\x8f\xc3\xec\xf1b<\xd3bq\xb8\x1d\x96\x96\x95x\f9\x18\x11\xb0\xcbhT!\t\x00\xc0\xaaEe\x01Þ\x1e\x8b\xa9m\xd0/\xeeP\x17X3I\xf8\x87\xda\xccmC\xfe\x84%\x97\x03\xbfg\xb4T\xe3\x11wl\xe9'ql\x12\x00\x80Ջ\xda\x02\xb6\xba؏\xd0\xd6\xd0\xca\x13-\x9a\x8a\xf9\xd8$\x00\x00\xab\x98\xf5-`\x9e\xd1\xf0O\x1e\xbd\xd9\r\nI\x00\x00V3\xeb[\xc0\x00\x00Hi@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0\x00\x00HY@\xc0V3\xc35\xaf1\xf6\x16\xb4c\x00\x00\x94P[\xc0<]\xcd&\xcb@h\xb5S\aoe\xdb\xc0x\xbb\xa9\xcd\x19\xbf\xd4r2\xb9\t\xe5\xc5dz\x8fmI\xdf\xfb\x81և\x9d\xaa-6\xd4?2\xbc\xc6_r\x1c\xa7\u007f\x91\xcc\\\xc2\x1d\xae5H6\ri\xf0\xe3r\x00PDe\x01\x9b\xe6\xadN\xb7\xb3M\\\xd0\xd0g\x1a`+\xb2\x06\xac\xe6Q\xf7\x03ӃD%\x97\x8f\xc1#\x9a\x98\xbc][\xae\x1fI_آҏ\x9e$>>V\xfc/\xf7\xfaNp\xdc\u007f\xe0\xef\xed\xf6Nn\"\xb1\xb5\x94N\uef90\xb0n\xbc\x9a\xd8\x12\x00\xd6)*\v\x98\x8b\xa7\xeb\xd7\xf8x\xa1\xb7e\xedq3\x01{h\xa2!m]\xa6\x85)\xc6\a\xa7N\x13\x9d\xe3EWq`\x81WSs!\xe1\xe1\x1fJ\xce\xcea<[I\x04\x8c\xf0x\x11\x02\xf6B\xd7\x18J\x9eф\x97\xfd\x01\x00 \x82\xca\x02\x86\x99*xy\x0f\xdd8\xcc>aM|+[)\x1f7=\x88Sh\x99\x89\x150\x17\xb2*\xd8)S\x95X\xc0\x1a\xf5\u007f\xa1\x9b\x0e\xee9\xdd,F\xc0\xae\x18fCI_vE\"K\x00X\xaf\xa8-`\x84\x19\xb7\xc5J\xddK>\x93K\f\xea\xd1fc\a\xda\xef&*\xb6,xʳ\xb3\x0e\x88CȦ\x82\x8c\xdcj\x1f\x8dՍ\x18ղ\xdc\xf1\x8d\b\x9dq\x95oM\xdf#]\xacu\x98\x13\xa8\xa1;\xf6\xdaú\xb2\xda\xc3A\xd9\x19*\xaf\xb0ͫ\x8e9\xba\t\vX\xb0\xb3F_\xd5\x19\x8c*\x16\xbc_S\\ySЭ\xb9\xe2p\a\x8ct\xc1\xd2W\"^\x00\x00\xacvT\x170/\xcf\xf3f\xd6\x0f\xb3v\x87\xa2\x12\r4\xb1\xa8D涄%\x97\x01Wf\xae\xb9\xfd\x17HC\xd3\x15iǭW\xb5\xf9DZ\x1f\xdaZP\x9d\xcd\xe6\x91\xe5\xceX\x9a\xb7\xe6f\xe6T\x97#\xe9hnv\xc2^i\xb4\xdb\xed\xb4{\xf5t\xf7\xc5\xfe\xb1{e\xdc;\xe9\x19\xe6\xb8\x0e\xe9nX\xc0.\x16}3\xf2M\xd1ŨbW\xb8\x1b#\x9d\x87\xaa\x98\xae=\xe5\xec\x91r\x03\x92\xe0o\x00\x00\x84P]\xc0\xb0\xd7\xe3`Q\x89\x9cT\xc6\x04\x01\xf3\x99\xad\xde\x19O;oIV\xf6C\xf3\xe96r\r\x81\xed\x1a\x92\xb4\"3\xa6A\xd6X@\xee\xf0\x10R\x96\x9b\x8fv\xf9\xc4A\xb0\x84\xf0\x10\xb2\xf3\x10\u0560\xce\x12Y\x0f\xec\x05\xf7\xadt7$`#\xdc\x18y\x1d\xe3Fdņ\x99\xd7\xfe1\xd7'\x98<\x8f\x94s\xa3[\x18\x00\x80h\xd4\x170L#@v\x93\x01\xa43\x10\b\xb8\x9b\x02t4鵒~٠U\xed\xf9N>\xc4\xd3\xcd\x19\ry)\xdd\xe6\x9f'\xe40gSX\xc0d\xb9\xf9\x8a\xae\xf4\xb0\x80\xbd4\x1c\xbdq\xefipNvtN\xa7\xd8\x03\xbbr\x82mN|)+V\u007ft\xee\x1d\xc1\xc0F\x9d\xfd\x9cdƅ[\x90P\x00\x00d\xa8,`~an\xd58\x1f\x98\xe4CxhΌ7\x80\x9b\x06\x12\x15]\x06\x1e \xe6|;\xa7!/\xdb\x05\xc7\x17\xdaOs\xc2\x02&\xcb\xcdߡTIĉ\xff\xf6ޅJ\xae쎢\x0fln\x8cmB\x02f<\xcb6\xb55\xb2b'D\x8f\x1a;8!\xf5\xf7\x0f!\xb5\xdf\x1b\x00H\x05\xd4\x15\xb0@S/\xdb>4\x05\x02^\x8a\xc3\xec%ʅ\x99_\xdc%H\x99\x8ax\xd1u\xbaaN\xfc\xf2m\xa3\f:\xa1#\"`\xb2\xdc\xfc\x03J\x950\x01\xbb\xf7\x92\x88S#Ѡ\xb7}\xfaN\xd9\xe1F\xfd+\xba\xe9\xe3^\xd3M\xb8\av\x94\xf9\xec\x8f^\x94\x15\xab?\xfa\x84\xc1J\xcc\x16\xb5Fj\xa9\xd3,pR\a\x00\xac+\xd4\x150\xdc\xcc&L\xf8-=\xe2\xbe\xe0\x03s\xf2D |ͽq\x8b-\x17\x059\xe4Į\x9fhH\xb2\v1\x0f\xdc\x17u\xf45,`\xb2\xdc\xfc\x83Ju\x18\x8d\x18\xbf\xa6n\xabV\xea\xd1\"\xfb\xd7X\xb6\xbba\x92m\u007f(9OF\x87A\xe3Q\xb6\x17\xf1\x81Q?W\x1f-!)6&x\xbf\x1ao3\x9b\v\x95\xe1\xbe\\ o/\x06\x00 \x06\x95\x05\xcc\xc5w;\xddN\x8b8\x13?\xe0q\x98=TB\xf8!\xf7\xc3&\xab\xfa\x9d\fGFNݙ\xac\xb4\x8df'ƧP\xa9\xa5\xbd\x025\x85\x9eB\x0e\xb2\xd1n8w~Ж[h\xb3M\xc6\xd4\xd1Z\xd4\xd1\u007f\xba\xf8%U\xa2\xe2\xd6\xe1\xfe+\xdc#\x96\xbd\x0f\x89\x9a3\xa27\xde\x1f\xae\xd5\x11\xe1zIg\xe2w\xd8\xed\xc4\x16\xd7s\x8dÍ\\=\x96\x17k\xdc]\xdf\xff\xed\x15A\xc6\xf0s\xeeN\xe8\x1c\x97\xd1(\x06\x00 \x06\x95\x05\f{z,\xa6\xb6A\xbf\xb8C]`\xcd$1j1[G?\xd0O\x0f\x17\x85k_\xd6֓\xe6\x8d\xe8\x18Iw\xed\xd4f}z\x97\xf4\x0f\xb3\x98\xdbk\xa3\xf0k\x81P\xeex\x1aˍ\xed\t\xcd\xdd\xf8Lo|L\x12\xf7\x8d\xb7\x0f\xeb\fFA\xbf\xb0Yˋ\x06S\xb5\xfa\xb2\xb3t\x1e\xfeE\xd1\xc5Eǜ\xc1\xce\x13\xfa\x13l\x1e\x98\xac\xd8\xd8\xe9\xb2\x12\xe3\x88X\xb0U/z\xc1l\xe9'1\x00\x00\xb1\xa8-`\xc0\xc2\t\xdeб\xbeX\x8b\xa6B:y\x16\x00\x80\x10 `\xab\x98`\x87\xe1\x15\xc6\xdelX\x8c\x02\x00\x94\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 e\x01\x01\x03\x00 eQ[\xc0<]\xcd&\xcb\x00]\xf9k\xc6\xcc\x16\x946\xb3\xa5u<\xed\xe6.O\xe2\x92+¨\xb0\x88N\xda\x03awr\x13\xca#\x9b#$+\xc3\x15k\xedؓ\x91]ڛ=\x1d{\xe4C\xe1.\xcf\xc9\xf8\xa4N\xfd\x85\xd3\x00`u\xa2\xb2\x80M\xf3V\xa7\xdb\xd9F\x174\xf4\xf1\x0f=\x04\xb6X\xb3\xdbds\xd9L\xab0\xfa\xf4\xfc\xa0\xedkt\xd9\x16Z\xc0\f\x0f\xb2\xe5\xa7\xdd6\x92\x1b\x1b\xe7\xac+c\a߲\x1d!g̑\x0f\x85k\xf3'\x97\xac_d~\x02\n\x06\x00\f\x95\x05\xcc\xc5S\x95\xf2\xf1N\xfa\x12\x16\xac@3\rY1м\x12K\x1a&eH&U\xa1(\xdeC\xb1\x02\xe6\xcd\xdcOtηm\x19\x05l\xffV\x1a\xdf֙\xf1E2C\x00X\x1f\xa8,`BTE/\r\xdf!\x110\xa7\x89ޗ>\xd3\xf2\xdd\xf9\xef\xc1\x82\x05\xecT:\x1b;^B\n\x83\xcb\x0fD\xdeV\xb69\xa0\x18\x1e\t\x00\xd6\x1fj\v\x18a\xc6m\xb1\x06d\x02\xd6s\x97m\xee\xaa\x1c\xd5c~˦/r\xb2{\x8fg\x15\xd2\x11\xed\xc1lMξq\x92\xed܈\xd0>\x9c\x83P\x16\x1b8\x86\xa5\xcaS\x9e\x9du\x80\r!\xa5\xb9\xb8\xa9 #\xf7\xffo\xef\xfcc\xe28\xee\xfe\xff\xfdg\x10\xac\x8c\x0eN\x1cB:\xa4\x039\b\x13Y\xc9`|',\x1cS\x041\x17\xd1`\x93\xafj\xe3\x1f(\xa9\x12\xfb,\x13\x9b\xa8NS94D\xc6`\xf2\x03\xc5%ND\x83c\x14\x1axL\x1d\x91\x1fv\xb8\xa8\x8ay\xda\xe2|\x85\x1e\x92HϵV{\xcf#5\x8e\xb1]\xe1m\x1cR\x82}\x86Z\xa3\xef\xce쯙\xe5\x8e=(\x06\xce\xf9\xbc\x12\xf9\xf6n?\xf3\x99\x99ݝ73\xb3\xb3\xfb\xa9\xa1\xba\x9c͂Gʡ\x034\xd9\xe1\xfb\x1c\xabiȣ*\x94\xd2X\xe3q\x14\x8e\b\x9b\xb2\xdcS\x98\x95\x92\xb1\xce-[iv\xb17Q\x8f\xa4k\xf1\xdc҅qu\xaf\x1a\fes\xf6\xact\x00\xf0\x83d\xc9\x05,D'\xeei{\x0f7v\xbd\xd2\xd8\xdaC\xfb^\xedj\xd0\xc3ޥ\x0el\u06dd\x8ej֢\x8czW\x03\x8d\xc1\xed\xefn\xf3%\xf5+\x03ھ@R\x9f܌Z>dF\xbaT\r\xa5{\x9a\x8f?\x88$Y\xf8U\xf6'Uw\x1cʸo\\\x1eKj0=o\x96\xea:\xea\xa4rE\r[\x93QF\xe0@z\x89\xb0\xa9$\xdf\xfcJWc\x06\x9a\xf5\xaa\xe8\r\xa8\x90~\x8c5\x1fRi\xd6g\xdf8.\xb9\xcag\xff\b\x00?D\x96\\\xc0\xe4\xd0\xe8`\x9b:\x89\xdfrv$\xd8vLi\xa1-\xfdlO\u007f\x8bM\xd2E'\xb3\\\x11\xae\x0ey\xb3\xd2w\n\xb7QU\xcde\x11l\xe5\xcd\xf9\xa1,\xfd=κT\xad\xc9V\f\xc6WK\xe2\xaf\x1d\xa8\x99};&\x8f S\u007f;Q'\xfb\x97\xf6,%\xa7҉*ϐ\x85\xcd\xc3\x19T\xba~\xe1\x9c5\xeb7\x1cP\xe3\x1e}9\xac\x12\xe5\x8e\xe6\xf8\xe6\xd4\x159\xd6\x06\x80\xa5g\xe9\x05L\xa6q!\xbb\x94v8H;_\x97\x9a\x15!hg\x01\xb2\xe5\xee\xf6\xb9\x93->\x99\xc7\xe4>\x14\x96kK\x95\xed\xd0\xe1\xc2\xect\xb4\x9a\xfd~i\xb5˧\xdbhR\x15FllW'\t\xbfʥ\xd9cW\x15\xb2\xfc\xf2X\xb2\xd9\x03\xf3粏\x9c\xcd\xca?\x12\xfd\x87\x05\xff\xe66G2ݏ6~8\x1e\xa5{\xa52\x8ctfߚ}T\x0fZ\t\x00?x\x96X\xc0\xc6\xd4.\xc7\xd9F\xa3\xebѣ\xa8\xd6I\xb5E\x1e\xd7\xc3\xdd.\x19\x99\x9dr\xbf$\xcb;\x14\x01\xebweն\xf7ܯ\n\x98\xfc\n\xea\xd5m4\xa9:\x83\x98ʪJd\n\xd8jMg6\x18s`cJ\xe7k\x8d*\u007f\xeb\xf2\x95\u007f\xa4=\xb2>\xf7\xcfm\x86\x1b\x1f\xcaA\xae\xd8\xd1:z:Tz\xac;¥\xc9\xcd\xd1\x12\x00\xc0\x0f\x91\xa5\x15\xb0\xf1\x16u\x9e\xfeæq]\xb5\xba;hdnuRl\xc9GF\x9c\x80\xe5\xe4\xd32\x94\xa8\x026\x9a\xb9\xcb\x1d\xd2l4\xa9\n!:'/['\xf1˳\a\x18!\xe3.d\x1b\n\xc9~u\x96\xdd\xcdz`4\xaa\xb7&`\xc6\xe6\x99\x1d\xca?\xe1c\xa9\x87\xe5y2z\x9fs\x96\xa6\x01\xc0\x0f\x96\xa5\x150\xb9\x95\xce\r)CH\xa5\xaf\xd5\xc1\x06\x8c\xa1\xe6\x0f\xe9:0\xaak\xddK\xbf\x0e\x8c\x13\xb0,:\xb7>\xbe\x9a\t\xd8X~\x9d\\\xb5V+\x8d.U\xf9Y4\x86\xf8*I\xfc\xb5\x13\xb5я]\x01\xba\x0e\xacD\x19\x12\x8e\x17\xb8\xe9\xcc\xd81\xe5\xc7cl\xac\x17U\xc0\x02l\x92L.\xa8\x92-\x8c\xd4ώ\xfd\xcdq6\xd33\xa4\x94\xef.\xae\xf5\a\x80Db\x89\x05l\xa8\xb1+8\x12d\x93\xf8#\x8d\x9dC#g\x9a\xe8\x8a\ny\xa4\xa9{\xb8{\xe9W\xe2\a\x9d\r\xe1c)gå\xf7\x8f(\x92\xf2\xd0\xe1\xc0}(\xa3\xbe\xefRoUƈ<\x9c^\xd3;Ư\xc4\x1ftd\x05\xea\x9cI\xc9\xcdAu%~CO\x0f-\xf0\x0eT\xdav\u070f\xe8\xfd\x87NG~\xf3\xf1\a\x93\xe9\xe0\xb3<iGǎ\xa4r\xa5\xc7ԓ\xb2\xb9O\x1e\u061c\xd23\xcam*\xb9\xa5\xed\xe9h\xf7\xa3Y\vG|Qb\u007f\x9b\x9cH\xcd\xec\xe8\xe9\xe9\xf1g\xcda\x03\x00? \x96X\xc0\xe4ѓmM\xed\xea\x939_v\xb56w\f\xaa\xfd\x9c\xd1Φ\xe3\xa3s\xa5\xbb\x1b\x8c\xbb\x10jMG\x8e6:\x855\xde\xe0\x912J\x9b\xb3\xa5\x82N\x84P\x8d\\\xad\xfc\xdb-\u007f\xc8=\v9\xe4s\xba\xb75'\xa3*\xf6,$\x85\xce\xfd˝\xf7g8ר\v\xd9\x06\x1ft\xb8|\x83\xcc\xf5\xcfW;V\xffb\x9c.\xfeB(eС\xfc[\xc5m\xca-\x05\x81\xac\x94̂\xd9\vߚ3\x1ag\xfdfR\xa0e\f\vY\x01\x80\xb1\xd4\x02\x06\x00\x00\xb0h\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80\x01\x00\x90\xb0\x80\x80% K\xfe\xd6\x0e\x00X\xa1\x80\x80%\x1a\xa3~\x17\xda`g\x04\x00KD)\xca(_\xf2\x17\xf9\x99\x80\x80%\x18\xe399\x8d'\x97\xfc\xc5C\x00\x10\x83\xd1\xee朌勴\xbc\xd4\x026\xda\xd9\xda\xd4\xd6K\xeb{\xa9\xb9\x91\xa2\x87\xdd\xe9^F\x15\xffw\b\xadu\xaa/\x86~\xb7\b\xab\x14\xbdk\x93\xe4\xdf\xe2\xac\xfa*\xc4\xd7iN\x0f<\xf2\xd6u\xf5\xd7\x0f~\xf4\xdb\xd8I\x9e\xc3\xf8\x1d}\xfbgJ2\xef\x17\x16\x83\xf7\x1e\xc0\xf8S\xf9\x13e\xcfWr<\xbc\xee\xfd\x15\xfb\x14\x9d\xcdY\x86\xb8\bU\xb9R\u05c9\xe3c\xfa\xe6\"Ǽ\x03m\xbe\x8a\x8bhY\xde\xf3\xe2WcX\xfcQ;Y\x9f\xaa_\xbf(\xc2?\x96c\x1c\x1d\x85Ϟ(\xae\xd8\xffQ\xc5_g\xef\x89\r=\xa8\x18oz\xf2\xbfb\x19\xbc\xad\xec~U)*\xc6o\xc52\xf9\xb7\xb9\xfbդt\xa3\xb3v&w\x8d%\x16\xb0/\x1b;\x82#\xc1v5*ч\xa3\n!}G\xff\xdc)\xef\x12\xdd\x03v\x166lˮObu\xf8\x15>w\xeeM\xfc\xfa\xb9s\x0f\xfc\xca.\xcd|\xf9\xe8?\xcd\xed~\xf5\xdd\xfc\xff\xf3+\xfc\xf6\xb9\xf7\xf6\xe3\x97\xd4_\u007f[<\x87j\xfe\xe9\\\xd1K\xe6\xb6R\xc8O,\x06_\xbf\x8b?\xba\"_y\xe4\xb1?\xcaq\xb1\xa5h\v\xfb\x14\x9d\xcdY\x86\xb8X\xeb:\xbc9U\xfcc\xce\xde\x1d9+\x86\xb0\x1d\u007f\xd9\xefݭ|\xec\xf6\xee\xffK\f\x8b\xbf\u007f\xc2N\xd6'Wԯ\xd7?\xf9\xd9z9\xc6\xd1Q\xa4\xb9\xf8\xff\xbe\xf5\xce\x16\x8c\xff߬=s\xf0\xf5'E?;\xf7ћ\x8fx?\x8ba\xf0\xd5\xdb\xf8տ\xca\u007fUNd\xec?\x1b\xfc\x99_\bw\xbf\x9a\x94(Q\x9e\x97\x8c%\x16\xb0!\x16͖\xbd\xfd\x9e\vl\xabt\xccږI\xc0\xf2J\xed,l\xc8\v\xc8\x0e&)\xaf\x17\xc9\xf2\xa7\xf4\xb2\xf0\xben\x97f\xbe<\xb6\xcf\xdc\xd6/\x96\x0f\xb0\xd20\xae?\x87\xb5?\xf0ף$3Y\xff\x92\xb9\xad\x16R\xe4\v\xfc\xb5,\xbfT\xf6\xdf\xd6ߣ\xf35\xdeO\xed\x19\xbc\xb3\xb9\xcb`O\b\x1d\x92\xc7g\x0fF\x16\xd2<\x8e<\xa1t&\xff\xc7\xfbđ9l\xc4\xe3\xf0\xd2\xfah\xbf2\xfeg㓊\x00|\xfd\xc8|[6;\xea_W<\x11k\xffg\xf8\x03\xe5ߏp,\x85\x93\xc53\xbf@\xeez5\x17v\x86\x16\x8b%\x160\x99]\x9f\xa1\xc6QQ\xc0\xba\x1b\xbb\x9b\x96G\xc0\xee{\xc8\xce\u0086\xdc\xe6\x11Ć8W\xbe\xd0.\x8b/\xaeإ\x99/[c\t\x98|e\xe3sѓ\x88\xc4#`\x1f\x14}d\xfd9\x06\x1f\xe1?b\xdd6\x8a\xb3\x053\x14=^\xdcB\x9aǑ\xfd\xbbߑ\xdf~b\xff\xa2\b\xd8\x11\xef\x9f\xe9\xc7\xeb8\xe6h0:\xeaQ\u007f\xc9\x1bK\xd8\xe3\x10\xb0\xadK(`\v\xad\xe6\xc2\xce\xd0b\xb1\xd4\x02\xa6pi\xa4\x8d\xbe\b\x9f\x17\xb0Ka=\xb8\xed\x92ҡ\xbd\xa1\xf9>Y>\x9b\x8cP\xddP\xb9;\xb5\xd0\x1a,\xbb\xd9\xc5^\xf2<\x92\xae\x19\xa7\x8b3\xe8\xeb\xea6\xe4*\x89\x93\xd9\x14\x9evY\xfc\xb1\b\xe3\xa3_<]\xe9}\xe2\xef\xf2W\xfb*\x8a\x1e~\x92\x8e͞\xc3Eo\xfd\xf2\x11\xef\x13\u007f\xa2&\xe7\x9ex\xb8\xa8쉇\xaf\xd3_\xdf|\xb6bӓlJ\xe2\xfa\x9b\x8fy\xb7\xbey]\xf0\xf0[m\x1a\xe315\xbfnA\xc0\xe4\xe7ʔ\xb1\x88\x17\x1b\xb3\\\x86_.c\xa5)=\xff\x8c\x9e\x05w\xed^\u007f\xfb\xb1\xe2G~I\xfbR\x8a\x80}\xb1\xf1U\xeb\xaf\xe6\xa6PH\xf9\xa5\n\xb9BWDݙY\x86w\x8c\xa9\x9dw\x04gf\xc9d\xe3\xa0r\x8ce\xa8\x87\xb7F\xd9\x0e?\x94)e\xf9\xf4y\x15\xa3y\xf4\x14f\xa5d\xacs\xb3\xed\x96|\x87\xa7&\xf6\xd4\xf1\x91\xfdo\ue55fx\x93\n\x98y\x1c>S\x0e\xea\x93\xd7+0\xde\xc8\xfe\xc4\x18\xc7\xe1O\xfb+6\xee\xfb\x99\xb5e\x9bE\u007f\xe4\x19\xf6\xc3_^\xbf\u009d!\xeelF?\xb1\xba\x80\xfd\xaa\xe8\n猿4x\x013\xfcr\x1e\xaa6\xf9\v\x00\x00 \x00IDAT,g~\xd61\xfb{Yё\x8a\x8a\x8f\x9e߸\xf3\xeb\xe5\xac&\x9d\x97\x9d\xfdn\xf4\xa5b\xc9\x05,D'\xee\xd5(j]\xaf4\xb6\xf6\\\xd2~_\x0e\x01\v\xf7\xf6x\nzzz\x14\xf1\xb9\xd4\xd6\xea\xf6\xa4gՔϊ$\xbb\x01\x15ҏ\xb1\xe6C*\xcdb4\xda@\xbat\xe6꺂>6\xf7\xac]\x16W\xdey\xe7\xe1G\x8a+~\xb9\xff\x81\xffV\xae\xc2g?z\xe7I:\x8b\xfa\xd9;E\xf8G/\xfdj\xe3^\xc5\xe2\xf7\x0f<\xfd\xee\ao\x95ῳ_\x1f~\xf5Շ\xd9T\xc9\xd3돾wt\xfdӂ\x87\xaf?9\xf7\xc8\xces\xe7\xceѿ\x8bW\xbf\xec\xces\xaa\xcdV\x13\xb0\xb7\xe8`\xee\xd3s缪\xa2\x98~\xb9\x8c\x95\xa6\x84\x1f{\xe7\x9d-\xdal\x8cq\xed>\x83\x9f\u007f\xef\xcd\x1fm\xbdN\x05\xec\xaf[\x8a\xafX\u007f57\x85Bʻ\xf7\xc9\xfbv\xabƦ3\xa3\f_\x9f\xdb\xf8\xd2_忾\xb4\xf1\xdc\u05fc3\xaed\xb2qPy>\xec9\x86\x02==\xa32\xfd\xc3\xe2\xefn\xf3%iW\x84.`\xfdh\xf3+]\x8d\x19\x88\xfe\x85\xf1'Uw\x1cʸ/悸#\xfb\xffT\xfc\xbf\xde?S\x013\x8f\xc3\xf5\u07fd\x84\u007f'\xbf\xfd\xc0ۿg6zѿ\xd8\xf8\xc8ۿ}\x02[[\xb6Q\xf4+\x98\x9b\x130\xce\x10w6\xa3\x9fXM\xc0\xae?\xb6Ep\xc6]\x1a\x9f\xe1\xf7\xae\\\xb9\xf2\x1e\x16\xce<\xe7\x81?\xf3r\xb4c\xf6\xd1F\xfc\xcbݸ\xecղח\xb3\x9a\xf4\x8fO~\xef\xc82-N\\r\x01\x93C\xa3\x83m\xea$~\xcbّ`\xdb1M\x0f\x96C\xc0da\by\x1fZ\x1b\xd6Ƹ<\xc3\x015\xd0ٗ\xc3*\x96\x90f\xf5\xa8Q\x0e;Ԡ\x1e\\\xc7|+\xde\xfd\x95|\xfd+\xa5=\xbf\xa3\xb4\xe3\xeb[\xe8Y\x97\xd7oT\xfez=\xfd#e\xeb\xcd\x1f\xd1S\xff\xe6F\xf6\x87\xbaR1\xfb\xeaa\xe5\xef\xec{\xecO\xf2\a\xf8=\xc1\x037\x90ؠtQ\xb4a\x96&`\xefi\x1d~M\xc08\xbfB\xc6?V\xd4\xe9\xca#\xea\x9fr\xbd\x90\xbf\xc5o\xb3o\xefP\x01\xdb\xffȏ\u07b4\xfe\xcamr\x85\x94\xaf\x17\xbf.\xbf^\xac\x8d\x8b\xf8\xa1\x88V\x06\xf9\x99\xfd\xca?\xfb\x9f\x11\x9d\xf156\x0f\xaa\x801\x84\f\xb7ѳ\x90\xab\xadv\xd3\x05\xecp\x06\x95\xae_8ǩ\xc25\xb3\x1d\xc7f;Q9\xb2_\xde\xf2\xdcc2\x150\xfe8\\\u007f\xfa\xb1\xbfT\xe87&\xf5\xa2\xef|\x84\x19XZ\xb6Y\xf4/\xf0\u007f\x18~\xf93d\x9e\xcdX'\xf6\xa5+_\xffq/M\xc1\x1fI\xf3\xc4~\xa6\xf5\xb0>\x13\xfc\n\a\x8a\x1fBF9f\x15O+)\u007f+?\xfd\xecrVS\xe1\x84r]\x1a\xa1엖\xa5\x170\x99ƅ\xec\x92\xe5\xf1A\xda\xf9\xbaԬ\x8d\x0fV\x80\x80Is-\xaf\x1aF:\x82U\x1br\xd6\xc8\r\x99ڸ\x93\x13\xb0\xf5\xfa\x8c\xf8_\xde|\xa2r#f\xb7\xed\xd8_X6\v\xf1\xdf\x15\x95Ͽ\xf5\xfb\xeb\xacӳ\x9eMԼ\x89\xffG~F\xbd\xb9\xb7\xe5g\xa2\a\xf32\x1e\xe9l\xcc\x11{`o+\xc9(\x9ax\xf0~\xf9\x8c\x8f\xd2\u007f\xdfTm\xf5B\uebfc\xf2w\x85\x8ag\xa8\x80y?{\xab\xec+˯\xdc&WH\xf9\x8f\xf8\x93+\x9f`\xed\x86e4\x01\xfb\xc8\xfb\xb5\xfc\xb5\xf7#\xd1\x19_\xb2\x18\x98s`\xa1Å\xd9\xe9H\x8b\x92\xae\v\xd8H\xa6\xfb\xd1\xc6\x0f\xc7\xe9\x1f\xbc\xd2챫\nY\xfe\xa8~d&`\xbf¿b\x02\xc6\x1f\a\xf9\xcaֲ'\xf5))\xad\xe8_\xa9\xab\x18\x8eZZ\xb6Y\xf4+Efׄ?C\xe6ٌub\xd9:\x8a\xff\x90\xc5#i\x9e\xd8\xcf\xf0\xaf>\xfd\xf4\xd3\xd7\xe9\x89\xe4\xfc\n\a\xcaf\x0e\xac\xe2\x1d\xa5\xbc_\xd3\xda.c5\x95?8\x19\xee\x86\xe5Z\x9b\xb8\xc4\x026\xa6v4\xcf6\x1a\x1dΞv\xf5s\x05\b\xd8\xdc\xc1\xcaz:T\x84\xc0\xd8_:j\xbaW\rg\a\xb4\xaf\x9c\x80=\xa6\xff\xf4\xa3\x87\x8f\xbc{n\xb7\xaa#\xb4\x85\xab\xd7\xc2Wo\xed{\x04\x97\xfdʜ*9\x87\xffS\xde\xf9$K\xf2\xc4c\x82\a\xf12\xeeA\xea\x81\xd2\x04\xec\xc8F\xf5g]<L\xbf\xb32fY\xc8f!\xb7h\x1d\x80'\xa9\x80\xbd#\xff\xfd\x91#\x96_\xb9M\xdeÛ\xecG\xb5\xbf\x16U\xc0\xfe\xbe\xe9]\xf9ݲ\xeb\xa23\xbe\xc610\x04\xacߕU\xdb\xdes\xbfE\xc0\x94>\xfbC9\xc8EWݭ\xd6\xfe\x96\xc4|\"Ai\xd2\u007f9\xf2W&`\xfcq\x90\xe5w\xcd\xf2jE\xff\x14\x9f\xa3\x1f\xd6\xd9m\xae\xe8\xda\xe4\xd0\x15\xa5W\u009f!\xeel\xc68\xb1\xcf~\xfa\xe9\x17\xd7-θ\x13\xcb́\xf1~\xf9\x03e'`\xefɟ\x16\xb1\xda.c5\xe9\x19꒗\x8b\xa5\x15\xb0\xf1\x16u\xb6\xefæq\xf9\xa4z\xb5vk\x17\xedr\n\x98\x1aR\xf7\xbe\x12\x1b\xdb(\x1cG\xc3r\x89;]\x1fwr\x02\xa6_y\x8f<F'H\xf7Y\x04\xec\xd3#t\x9a\xfd\x1d/\x95\x81\xf5\xcf\xd3}o\xe1\xaf\xe4g*\xe9\x05q\xbd\xf2i\xc1\x83\xb6\xf9\x96\xfaw\xdbr\x17\xf2G\x9a\x95&\x1e\x9c_!c#\v\x99\xff\xe3\xfb\x9f\x8c\xbfh\xcb(\xde\xf3\xfe\xb7\xf8+\xb7\xc9{\xd8\xf7\x98\xd2o\xd0\xef\xefG\x130\xf9\xf9\xbd\xf2\xde\xe7-Y\xf05\x8e\x81!`9\xf9\xf4\x80\x96X\x04\xec\xcc\x0e\xe5\x9f\xf0\xb1\xd4ò\\\x9e=\xc0\bE\xf5#\xabMZ\x81\n\x18\u007f\x1c\xe4?U\x1cy\xf8\u007f5\x1b\xad\xe8\xff\xabj\xf1ӳ\xba&Fяx\xd9j\xb2w\xf0_\x853\x14\xb5e\v'V?\x1e\u00914O,'`\x9c_\xe1@\xf1g>\n\x15\x1fȟ\xaeWk\xbb|\xd5\xfcA݅l\xed\xa4\xff\x8e\xb5\x9d\x94\xe5\x0e\xd6\xf5\n5\u007f\xa8\xeeY&\x01+(P\xbaQ\xa8\x8dn\xc6XQ1R\x1fe\xbaF\xa7\x1d\r\xc9\x1f\xa2Ry\xdc͌\xa2\b\xd8\xc3t\xe3\xfaV\x8b\x80\xbd\xa4\xces\xed\xa4\x8b ֗)\x97\xdeו;\xe9\xd4\x03\x9d$yG\x9b\x033\x05l\xa7\xb2\xef\xaf\xda}FQ\xc0\x8e\xe8C9M<8\xbfB\xc6\x15t\x0el\xcbNf\xa3\x17\xf2\x03\xd5\xe3\x91W5\x01\xbb\xbe\xf3g\xe2\xaf\xdc&WH\xb9\xe2\x97\xca?\xbf\xac\x90\x05g\x14C\xc0~\xe7\xfd\xb3\xf7w\x96,\xf8\x1a\xc78\xa8\x86\x80e\xd1?%\xe3\xab-\x02\x16P\x9fA(\xa8\x92\xe5N\xf5\x8c\xedR{\xbeÁY\xab\x919\x01\xe3\x8fÕ\xc7^\x92\x9f\xdbm\x99\xbe{\xecae\\\xfc_^K\xcb\xe6\x8a\xfe?\x1b\xf7\xd2\x1bs;+\xc53\x14\xb5e\v'\xd6\x100\xfeHF\x150ίp\xa0\xf83\x1f\xe5\x98q\x02\xb6|\xd5\xfcA\t\xd8PcWp$\xc8&\xf1G\x1a;\x87F\xce4\xd1\x15\x15\xf2\xa5\xd1\xd1\xe6\xeeQ\xcb\xf4\xf8\x92\xb0G:p|\xadcD\xbe\xda\xc7nHFiV>\xb4n\xf6\x8f:_:J\xdb\xdd\x1e\xa9:\x90B;\x03\xbf\u007f\x13\xbfN\xef\xfa\xfd\xfdw\xec\xf6\x11[t\xf0\x12\xde\xf7\xe6\xab[\x95\xde\xf6'\u007f>W\xf4\xb3O\xae\xff\xfegE\xe7\xfe\xac\xfcZ\xfc\xd2o\xdf}\x86-\xa7\xa2\xb7\b\xdfzd#\x9d\x8cߏ\x8f\xfc\xf6\b\xde/z\xa0\xd7\xcc\xeb\xef\xee.V\xff\x0e\x9fA\xbd\xf4C]\x89\xff4[\x89\u007f\xe5\x93s\xe7\xbc?;w\xee+\x99\xf7kfL\xb3x\xe2w\x1f=F\xb3\xf8o\xedq\x01\xea\xec\xc8\x03\xfb\xdf\xfd\x8fg\x94kU]\x89/\xbf\xfb\xc0{W\xb8_\x85M\xa3\x90W\xde\xc3G\xbe\x96\xbf>\x82\x15[\xce\x19W\x06\xa5\x11T<Q\xa16\x1f\xd3\x03_\xe3\xa8\aU\xbd\v\xc9\xee\xe6\x06\xd0C\x87\x03\xf7\xa1\x8c\xfa>u%~CO\xcf\b\xfd5mOG\xbb\x9fݲ߁Jێ\xfbQ\x8b\xe6,\xcdr\xeb\xe5\u007f\xf7\xef\xa6k\x9a\xfe\xbc{\xff\xffr\xc7\xe1\xca'\xcf\xfd\xe8O\xf2\x17\x1b\x9f\xff䊾D\xfdwJ\x85?\xf3V\xbczt\x13.z\xfb\xb3\xe8G\x87\xf6Mw\xbe\xfd\xdb'\x8ah\x937\xce\x10w6\xa3\x9fX\xba\x12\xff\xbf\xf4\x02\x19θ\x13+\xac\xc47\xfc\x8a\a\x8a?\xf3\xb3\x8f\xd9g\x9b^\xff\xfa\x9d\xa2Ͼ\u07bf\xfbO\xcbVMJ\xdf\x0fG\xc0\xe4ѓmM\xed}\xec\xce\xe3\x97]\xad\xcd\x1d\x83\xf4\x82\x95ϰ\xc7\"\x1b\x97\xe1\x91бjgj\x81\xd2\xf9;\x9b\xc4&U\xa2hUs\x86u\xc9\x12\xcf\xc9쌪p\x97ǩ\x8ck䯋\xb1\xfa8\xa1\xf6\x04\xda\x13\xd4\xe0\xfa돬\xff\xd1\xfe\xb7\x1f)\xda\xf9\x9c\xf2S\xd1\xff\xa36\xcf\xc9o\xef|\xf5ᢊ\x9d\xec\xfc\xaf\xff\xe53\x1b+\x9ef\x8b\b\xaf\xbf\xb9Ż\x85\xad\x03\xe3<(\xea\xf0\xfc&\xefN\xedq\xb6/\x93\x1f:\xfb\xe5\xb8\xfa,$\xaed\x13\xb3\xbf\xd7\xe61\x94/\x9c_3cY\xde\xf2\xea\xbeb5\x8b\xa75[\xd6\v\xf8`w\xd9Ɲ\xef\xd1?\xb8\xeci\xb9\x9d\xf8\x81O\xb8_\x85M\xa3\x90\x1f<@\x17x\xbd\x8b\xf1\x03\x1f\xf0θ2(\xbc\xbe^\x9f\x106<\xf05\x8evPǜ\xec\x04\xb0\xf5t\xe3\r\x1e)\xa3\xb49[*`\xcfBRJ\x95>zA +%\xb3@\x9d\x84\xe8\xbc?ùF\xbb\xf7۔\x86,\xdd\xf7\x970\xa6\x13:\xcf\xd1\x15i\xe6q\xf8@)\xdf\xf3\xf2\xf3J\xd1?2\xcaK\x8f\xea\x17On\xaa<\xf2v\x91rZ\xa2\x1e\x1d\x99>$\xe8-{\x92-P7\xce\x10w6\xa3\x9fXzP\xb7\x18%ҝq'V}\x16\xf2%\xf5\xa0\x19~\xc5\x03ş\xf9Y\xc7\xecz\x99r*\x8aq\xf1;\x18\xef]\xb6j\xcac\xa3\x03\xa5Ҩ\xbc\\,\xb5\x80\x01\xb3\x10\x96\xc9\xdbs<g\x8e\xc9\xeb\xbb\xc6<\v\xb9\xb4\x1cG\xcb\xf0\xa7\x0fPـ\x90\xfb\xb8\x9d\xd1\xdd\x03\x04lٙ\xb76|yv\xd4\xcedљw!\x97\x8e\xf1fg\x95\x9d\rp\xd7\x18\x1dX\xa6\x05\x14* `\xcb\xce\n\xd6\x06\x93\x15\\\xc8ь\x1a\xf1\xe1\b\xe0\a\x04\b\xd82\xf3'65jg\xb5\xcc$D!\x81\x1f\" `\xcb\f\x9b\x1a\x8d\xf2r\xb9\x15EB\x14\x12\xf8!\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\xb6B\x18\xb73\x00\x00`\x16\xe4\xff\xec\x02\x00\x00HP\xfe\xad\x1e\x18\x00\x00\xc0r\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x02\x02\x06\x00@\xc2\x12\x8f\x80\xc9\xf5\xf9\x19)\xaeu\xafD\xec\fc0F\x13\xb6\xa1\rvv\xf3\x87ynE\x0f\x99\xbfē\x8d\x90`!\x1cF~;\x13\x00\x00\x96\x808\x04\xac9\x15\xa9\xb8G\xecL\xa3r8u\x92ħ,\xf3E\xf5\f\x02\x06\x00?T\xec\x05l\x0fB\x05\xbd\xdfF\xc2\xcdYH\xea\xb73\x8eB\x04!*3\xa3\x87{\xec,\xe7\x8b\xe6YУx\xb2\x01\x01\x03\x80{\x04[\x01\xebA\xe8\x17\xea\xd6\xe4\xfd\xc8\xf9\xed\xdc\xc6\xd1\xd0d\xe6.\x10M\xc0\xe2a\xde\t\xac\x80\x80\x01\xc0\xca\xc0V\xc0\xb2Q\x8d\xbe9\xe9B\xd5s\x99F\a\x04\f\x00\x80\xbb\x84\x9d\x80\x9dAIW\x8d/-(-B\xdb\xff\x81P\x893=\xff\x84\xfa\xe3\xd86\xb7\xe4\xdc0@7\x9bQ\xe3@vj^\x98\x90\xbe\xd2LɑS\xf7\r!\xb5l\xfalT\x9f\x9c\nUe\xa587\xb0\xa1h+j\xf8v[\x96䮛\xa0\xdf\u008f\xbaS\xd2\xd74\v7\nb\x1a3tϊ\x1e}\xb3-Sr?>E\xf49\xb0h\xceµ\xd9J9\x83\xcc\x17\x97\x80/\xab\x98\x8b%K\xae\x9e\xaa\x80\xe5\xa2Z\x02\x00\xc0rb'`{\xd0}\xe6\x97q\x84\xfai\xc3.M\x93\n\v\x92P\x15\xfdm\xc0\x81\xa4\xd5n\x84\x02\x84\nضU\b9\"\xa4\x1a\xa1\xcc\xd5.\xe5\x9f\tr\xbc\x14\xa1\x92\xd21MY:RP\xda}\xca\x0e\xda\xf4[QM&Jw\"\x94\xa3\b͗\xe9ș\xe7A\xe8A.\xef\x98\xc6*\xba\xe7V\x94\xebB.eWnD\x13\xb0h\xcezSQZ\x9e⬇\x88\t\xf8\xb2\x8a\xb9\x88Y\xf2\xf5\x04\x01\x03\x80\x95\x81\x9d\x80\xad\x13F\x8dY\xa8\x996l\xe4Q:Y#Nt\\闤\xa3\xda[\x84\f:Q\x17\x15\xb0$Ow\xff+\xa4\x1f\xa5~\xa8X\x0f\xa6\xa1\xc3\xc6@\x8f)\xcbH\x12\n(j\xd0)\xa1\x16Տ\xd2!\xea\x91P;!\x1bPݴ\xb2?\x1d\xf5\x1a\x99\xc56\xd60\x86\x90({H\xe9H\xa5\xd0\xf2\xb0l\xa28\xbb\x9a\x86\xea\"d\xe6\x00Z5!&\x10\xca*\xe4\"|\x11\xea\xa9\nXG\xe3 \x01\x00`9\xb1\x13\xb0<\xb4\xc7\xfa\xad\x95\x8e\xdb\x14N 7\x1d\xc7\xf9\x88\xfa\xc5C\x05\f\x85\xe8\x97\x1dZ\xa2\x1dT\xfdx\x01+\xd1&\x8f\xdaPF\x84\xfaa\xd6U\xb4+\xe7V}6\x95\xf7\x19\x99\xc56\xd60\x05L\xdbU\xade\x13\xc5\xd9\x1e\xb4\x8e}\x16\xa061\x81PV!\x17\xe1\x8bPO\x98\x03\x03\x80\x95\x81\x9d\x80\xadF\xf5ܷ|\xb4\x8b6\xec5\xecKDR\x1ax\x16\xeaV\xbf$\xa1\xb0\"`n\xd5.\xa2\x8e\xf3\xeaiC\xe7\x04,\x92\x8a\x86\xd4\xfdi(\xa8\xf8\xc9a_\x9aP)!\x85(?8Mx\xe60\xd6-t\x01\xcb\xd5v=\xa4\t\xd8lg$\a\x9dd\x9fcW-\t\x84\xb2\n\xb9\b_\x84z\x82\x80\x01\xc0\xca\xc0N\xc06\b\x13=٨\x816\xec]\xea\xb7\\\xd47\x85Pn>#\x05\xf5+\x02\xb6N3\x8c\x04\xdb\x03\xa5n\x846\v\x02\x16FH\x9b\xc1Z\xa3\x8c\xdeZ\xb5N\rӜ\xa0\x84Pz\xe9qn\x99\xc6\x1c\xc6z&\xba\x80\xa9\xbb\x8e\xd3\xcf\x18Έ\xa4\xf6\xa6\x18B\x02\xa1\xacB.\xfc\x17\xb1\x9e `\x00\xb02\xb0\x13\xb0:\x94o~\x99DtV\xa9U\xef\x94\xe5\xa3\x13\xe3ȤK\x110\xad{\xd4\xe4\xa2?\xac^c\x11\xb0Q\x94\xacy\xf2\xa1f\xa2\xaffP5)\xb4١$I\xae\xbe\xa5g6\x97\xb1\x8ae\x19\x85)`\xb3\x9d\xddBh\xccH'$\x10\xca*\xe4\xc2\u007f\x11\xeb\t\x02\x06\x00+\x03;\x01\x1bBIf\xcb?\x8eR&iîS\xbf\xe6\xa03\x8a\xa4\x85Mc]\xc0\x0e \xf4h\xc7\xf0\x14i\x88\xd9\x03\xcbg\x9d*Q\x93\"\x83\x81\\dJ\xc3\xdc\xc6,AL\x01\x9b\xe5\x8c \xa1\a\xc6%\x10\xca\x1aS\xc0\xc4z\x82\x80\x01\xc0\xca\xc0N\xc0\x88\xc7l\xacS\xd9l\xbbU\x1b(\xdeJQz5\x19\xf4\xae\x1ce0<\xad\v\xd8t\x1ajc\xbfm\xb3\b\xd8\xf4*qZ\x8bS\x8bp\x90m\xb7\xa0d}\xf2j\x0ec\x8d\x98\x026ۙR\r\xf5\x11\xa3\x93\x85MB\x02\xb1\xac1\x05L\xac'\b\x18\x00\xac\fl\x05l\x10\xa1\x03\xea\xd6-\x1fJ\xbdDh\xc3Na\x9d\xb2ct\x89X\x15ʛ\xa1_\xfa\x904\xa1\v\x98\xacuw\xa62\xe9\xf7hw!\xdbQzD\x10\b%\x89L\xb7C(\xc9X\xe7\x15\xd3X'\x96\x80EsV\x8bJاO\xa9\r\x9f@,kl\x01\x13\xea\t\x02\x06\x00+\x03[\x01\xa3c\xac\a\xfb'\xc9\xf8\xf1l\x94\xd4M\u007fhE\xe8>E\xc1\xfaR\xe9\xaa\u0590\x84\xaa\xa7\x94\x91\xa6\x13m3\x86\x90\xd3\xe9l\xe6\u007f\xbc\x10\xb1I\xa6\x14\xd4ukZ\x95\x81\x91dT\xafhJw*j\xb2\bă\xa8P\x11\x9d\xa9R\xe36\xc0\\\xc6:\xaa\xe7\xd9=\xb0(\xce©\xa8~\x9a\xcc\x1cB\x8eq\xb1\a&\x945\xb6\x80\t\xf5\x84u`\x00\xb02\xb0\x170ҡ\xbfN'\x93=G\xa34\xec\xecU\xc9\xf7ek=\xb3n\t\xad\xcaS\xbe\xdc\x1f1\xe7\xc0\x9a\x10r\xfb\xf2\x92\x9c\x01\xb6^!OI:\xa0)OG2J\xcf\xcbDT\x05D\x81\xb8\xe4DR\xce\xeaT\xe4⦚b\x1a먞g\vX4g=\x12r\xe69QJ\x8f\xa5\xcb&\x945\xb6\x80\t\xf5\x84\x95\xf8\x00\xb02\x88C\xc0\x88| ?=)c]\x9bvOOiأ\xbe4\xa7\xef\xac\xfa5\\\xe3\x96R\xf3\x9a\xe8`\u0378\v\xd9\u007f\u007f\x86\x94\xb3\xe7\xdb)\x89\xde\xfb\v\x15\xacJ?\xa1+Ϩ?S\xca,\x19\xd0\xfc0cu\xcf\xd86\x8f\xb4JI\xc3g\x1c\xd3XC\xf5\x1ce\x12?\x9a\xb3PUfrF\xf9(\xb1\b\x98P\xd69\x04\x8c\xaf'\b\x18\x00\xac\f\xe2\x110\vz\xc3\x06\x00\x00X^@\xc0\x00\x00HX@\xc0\x00\x00HX@\xc0\x00\x00HX@\xc0\x00\x00HX\x16 `\x00\x00\x00+\x03\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x96E\x13\xb07\xf0\x8b\xd1w\xc0MK\x00\x00\xee\x12 `\x00\x00$, `\x00\x00$, `\x00\x00$, `\x00\x00$,v\x02v\x1a\xff\xfa\xbb\xe7ʼ[?&wNoY_\xf1\xe2M\xf6\xeb\x1f\x0eV\x14y\xb7\xbc\xfcO\xf6\xe5\U000fd6ca\x9f\xba\xa8\t؍\x17+\x8b6\xed\xbd\xc0yP\x04,\\\xeet\xe4w\x10\xfa\x96z5\"#9`\x04\xfc\xeeI\xd6^\x97\x98\xdcM옏\xed\x029\x84Rh8\xef>\a:\x14ݠ\x9f\x15 \xe3!\xee]\x89\"\x1d\xca\xeeC\x8a\x1fD\xe3~\xdb1\x92\xc4\xdc%\x8d\xa8_\xc7R\xd8\x01\xaaV~rD\xc9 \xe4K\xcb\xf4\x0ff\n\xaf9\x03\x80\x1f2\xf6\x02\xf6\xe2&\\\xb6\x1e㏟\xc5\xde2\x8cw\xd3\x1f_ĸbk\x85\xf2\x0f\x95\xb3S\xf4KQ\xd1n&`\x17\x8a\xb1wk%Ư\x99\x1eZQ\xae\x13\xe5z\x10*'d\"E\v\x0e\xe4AAmw#\n\x06\xdbPK0\x88\x1aI,Ύ\xc4o\xbb@\xf4,&\xfc\x0e\xfa\x96C\x9f\xc3?\x11\xdd0\x12L\xa9\x0e\x0e\x1e\xf38\xcc(G\"S\x1d\xe8\xf0\x04\x99hB\x1dS1,\xcc\xdc\xc8\xf4\x10\xabА\x1e|d\xa8ZR\xfe\x1d\xa7\xd5\x1c\x9a\x95j m\xcd\xf1\xce<!>\x12\x00\xfc\xb0\xb1\x170\xbc\xe52\xb9}\x10{\xbd\xa7\uf40f1\xbe\xa8\xa8\x14\xf6~\xae\xec\xfa\xbc\x18\x9f\"\xe4\"~@\xd9\xf1\xfdS\x98\n؍b|\xf4\xb6\xb2g\x13\xfe\xd8\xf0ЊP\xb6\xd2\xd8\a\x1c4\xfcO\t\n\xd0\xdfF\xf4\x10\xdeJ\xa7Li\xb1ô\xb5\xa6\xb6\xcc\xce]c\x8d?~\xdb\x05\xa2gA\x02%\x8e)2\xe9(\t\xc44\x95\x1a\x94\u007f\xa6\xdcܛaEB\x88\xbeC\xf6,\x8a\xa5p\x84ˍh\x152h\x90\xa2\xfdʘL/\x8d\x10r\xcb\x03\x02\x06\x00:q\b\xd8e\xe5\xe32\xc6oЯ;\xf1iB\x8e>\xf02\xdbw\x14\xbf@\xc8A|\x94n\xdf,\xa3\x02v\x14\xefe{\xde\xc7?6<\xb4jq\u007f\x8e\xa1le\x10\xa8*\xd7.d\xe8C$\xac\xb5ְ\x11Ah\x16\xf9\x9b\xe3\xb7] z\x16$\xe0\xf7u\x91\x13>\xbf\x8d\x80\x91\x86ԙ\x18\xfb\xe3\x100#72\x0f\x01\v\xa4\xb2\xb1c3\b\x18\x00\xe8\xd8\vX%\xfd\xb8\x8d\xf1\xdf\xe8\xe7A\xda\xe9\"\xb7o\xb3}o\xe0gɝ\x8d\xb4OF\xa8v)\x02\xf6\xb0\xd6\xf3R̯\xe9\x1eZ\xd1Z\xf69\x95\xa4\xb4\xbc\x88\x936\xcc\x19\x97\xd8\b\xcd\xd6z\xa2 -\xe7q\xf6\xee\xfd\xa0ϝ\xe2*Q4\xafW\x9b\xf7\xca\x17lG\x93\x11\xaa\x0fWe;6L\x93\xa9\xcdY\x92\xbb\x94\xbe\xed\xbe\x16\xa5\xb4\xd7\xe58|ょZ\x94\xdcZ\xe3\xce(U\xf3l\xcbw䵉\x1e\xf8,\x02\xfe\xb6rR\xf2\n\x150\xd3oH\xb1-%n\x84\x9c\x11]\xc0\x1a\x93#\\y\xf9\xe2\b\x02\xa6\xe7f[!B\xe4\xaa,gy\xf5,\x013\x0e\x89\xa7\x86}\x9fh\x8ep~\xb9\x1aG\xaf<\x00\xdc\xcb\xd8\v\xd8S\xf4\xe3_\x18\u007fO?\x9fe\x02Fn\u007f~\xfa\xb5\x83\x95X\x11\xb0\xef1\xbe\xad\x19\xbeHn*\xe3\xcd\xed\x8c\"l\xcc\xe3\x1b\x81\xbc\xb3i\x18\xb6mh\x872\x9cDyB&Fk\xadI\xda\xd1\xd7\xeaʟ\xa1\x83\xccG\xbb\a\xda]h\x9a\xdc\n\x06s\x1e\f\x06\x83a\xc16r\xb23;'\xdd]W\x85\xae\x92>T3x\xb24iX\x11\x9a\xced\xe4jhN/'\xbc\a\xfak\xf6\xe1\x9fg\xb3i\xabj\xa9\xbe\xaf^\xaa\x12<\xf0Y\x04\xfc\xe3i\x93\xabd*`\xa6ߙ\xa1\x86\xa4!ҁNP5S\x05,?\x8f//_\x9c\x10\xea\x8bD\"\xfdH\xc8ͶB$\xec\xcc\xe9\xe8\xf5!\xab\x80\x99Y$q\xe3f\xc3/W\xe3\xe8\x95\a\x80{\x19{\x01\xdbG?\x14\x01c\xb7\x1c\x99\x80\xdd9U\x861~`\xebNE\xc0\xaea\xac\x1a\x9eW\x04\xec;lbL\x82\xb5\xa2zuc5\xea&d\b\xb9f\x88\x1f\x89sXzk\xedC\x1d\xec[\xa7\xd2\xc3pѶ\xd7\xe6d\xbfG\x1fq\xe5#ߔ\xd2MR\xa4\xa8\x8bN\x97籈H\x92S\xe9\x80T\xb9\x88\xe8A\xcaV,&\xdd\x05\x84\x9caݣ\x01\xaa\xa5\x9c\aa\bI\xf2\xb6\xad!T\xc0x\xbf\xa4\xba`\xc2}\x98mI\xf5\x91[\xa3\xe5\xe8C\xa1\xbc\x9c\xb3\x90\xd6\xc3\n\t\xb9\xd9Vh\xadG\xe9f\xcd\xe4Y\x04\xcc\xccb\f\xf5\x1ai\xf8Z\x985\x8eQy\x00\xb8wY\x88\x80\xbd\x81\x1fx\xe1\xf4śl\b\xa9t\xbaԕ\x15\xef\xab=0c\xe4hЊ\x1eW7ܴ\xcd\x13\x0f:\x1bq$\x8b+\x01\xf4\xd6\xea\xf7LS\xdcՄ\x8cgyj\x8f\x8f\x12\xb5\a\x11C\xc0\xa4\xab\xda\xd6D\xdb\x06\x8fS\xed\xd5Ity\x06\x9bH\xe2=HlF\xab\rM\x92\x9a\xd5,\xc5\xeajу `M\xa8\x91\t\x18\xef\x97D\xf22\x1fR-$\xaaN.\xaa&\\y9g!\xd4<<<\xdcB\x05\x8c\xcbͮB\x93ꪋz\x8b\x80\x99YL'\x9b\xaa\xcf\xd7¬q\x8c\xca\x03\xc0\xbd\xcb\x02\x04\xecv1\x9d\xc9't5ų\xe4\xce&\xfc9\xfb\xf2\x1a\x9d\x03+\xd3;^\x9f\xff\xe3_\xba\x87V-\x92\xe3$Btv\xa6\x01\xd5\xf6\xf3\xb1\x1d)zk\xcd\xd3\xfa.\xb4\xcf3پ9\x17e\xaa\xcb%b\bX\xbe\xfeS\xa6{OOp\x9d*`t|\xa76g\u0383:\xea\x1bD#d\xad\xaaB%\x05\x82\aQ\xc0&\xf6L0\x01\xe3\xfd\x12ҭ\xaf\xfc\x90j\x86\x87\xd5\xe1\x1f_^\xd3\x197\a\xc6\xe7fS\xa1\x11սu\x12\x9f\xcbB\x9b\x03\x9b\x1e\x10\xfdr5\x8e^y\x00\xb8wY\x80\x80\xfdS\xbd1InV\xe0\x83\x84\xbc\xa0\xa8\x98\xc2\xedJ*`\xcf\xe1\xedw\xe8\xb7?`\xef\xf7\xba\x87V\xb4\x8aM+\xff\x02\xb1n\xc3\x18rע\x93b&zk\xad\xf2\x8c0&\x94\xf6L{@S\x9d\x0e6\x01\xce\xda{\xc7U\xc1V\xf9\xb5\\\xdb\xc8-\xa0\xd3\xda\xe5\x16\x01\xe3=Hl\x1a\xae\x1dM\x91j\x0fK\xe2\xa9\x16<pY\x04\xd4\x15\x0eT\xc0x\xbfDάϞ$F\x16\f\xae\xbc\x9c3N\xc0\xb8\xdc\xec*4\x89\xd8\x1e\xeb$>\x97E\xc0\xc1\xfa\xad]hB\xa8ET\x01\x13r\x03\x80{\x96\x05\bؿ6⣊Lѥ_{\t\xb9\xb6\x1e\xff\xfa\x0e\xb9y\x90\xad\x03\xbb\xec\xc5/(#ʋ\x9b\xb8\xe7\x8aZ\x11\xcaS\x14줤\xcd\xe1\u070f\x1c\xe9\x96U\x10zk\x1d@]\xf4\xa3\xfe0\xed\xa8\x9d\xa1\x9b\x85\xdbؿ\x85\x84|\xab\xee\xe3\x05L\xefƸ\xa9t\xcc\xe4Y\x04\x8c\xf7 eN\xd1\x15T\x85tN\x89NXu\xa2>\xc1\x03\x97\x05'`\xbc\xdf\xe9\x82z\xb2\xcd7cd\xc1\xe0\xca\xcb9\xe3\x04\x8c\xcbͶB\x05nE\x1fë,\x02\xc6e1\x99^\xae\f\tg\n=b-\xa2\n\x98\x90\x1b\x00ܳ,@\xc0\xc8\xdb\x18W>\xf5\x13\xbc\xf1e\xbcU\xf9\xe9\xe3\"\\\xf6\x13/\xde\xc74\xeb\xfcz\xec\xdd^\x89\xf1\xeeۆ\x87V\xe4KM\xb9ύ\xf4\xb9\xfc\xe3\xc8x\x8cHc\xa4\r\xb5\x8c\xb0\xad\x00\xf2\x9f\xec\xadF'h\vL?\xd0\xd7S\x8d\x06\xe9\xcf\rRs\x8f/m\x9c\xb7\x9d\x1eb\xb7\xf2\xc6\xd8n\xb4\xb9\xedp>r5\r\xc9\xc1\x94\xea!2R\x9d\x12\x94\x05\x0f\x12\xca\xef:\x9e\xe3\xa4\x03\xbf\xaa\xa4@_ \xa9J\xf4`f1\xe9_\xf7\x8d\xf2\xf5\x9bu\xfeI\xceo$X\xeb\x1a'\x97\x9c\xbb\x82\x11\xba\x12\xdfX\x03b\x94\x97s&\xac\xc47r\x8bQ!n%~\xc8\xe1>T\x9f\x91\x94\xdc\x11RW\xe2\xb7\x04\x83W\x85CB\xce8\xee\xef\xe8\xf5%\a\xf9Zp5\x8eUy\x00\xb8wY\x88\x80\x91\v\xbb˼[^\xfe\xfef\xd1\x037\x94o\u007f;X\xe6\xdd~\xe1c\xb5\xd3u\xed\x85\xca\"\xef\xf6S\xa6~)\x02\x16\x18\xf5\xa59\xd6\xf6kߧ$\xe31\"\x95[\xe9\b\xa1T\xf5\xb9\x9b\x81u\x19Nfy\xa2\xf0\x90;%\xb3Pm\x80\x91\x1d\x19\x8e\a\x87\x05\xdbQ\xf5!\xc2\x12\xfa\xe3LK\x8e\xe4\xf2wx\xa4\xc2Z委P\x9a\xf2o\xad\xe0Az\xbcڙU%3g\xc7\xf2\xb4u`\x9c\a3\x8b\x06\x84\xe8T\xd36\xfa<\xa3\xe9w@1\xac#;\x94\u007f\xcf\xd2g!W\x1be\xd7\xcb\xcb9S\x9f\x85T\xfc\xb0Yy=\xb7\x18\x15\x1a垅\f\x97fd\xef\xe9HV\x8a^\xadM|\xf9\xf9,\b}\x16ґY\x1a\x12j\xc1\xd58V\xe5\x01\xe0\xde\xc5N\xc0\x16\x9fK\xe6cDK\x869\xea\x03\x00\xe0\x1eb\xe9\x05\xac\x1e\x1d\xb03Yt@\xc0\x00\xe0\x9ed\x89\x05,4ֵJ\x92\xed\xac\x16\x1d\x100\x00\xb8'Yb\x01+G\b-\xb9\x98\xa8\xb3\xdb\x00\x00\xdcs,\xb1\x805\xa5\xba\x96~\x00\xc9f\xb7\xc7\xec\xac\x00\x00H8\x96X\xc0\x00\x00\x00\x16\x0f\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x96\xc5\x12\xb0\x1b\xc2\xc3C\x0f\xc56\x04\x00\x00X,\x16G\xc0\xee\x9c\xf2\xde4\xbf\x81\x80\x01\x00\xb0$,\x8e\x80\xdd\xd6\xdf\xcb\xca\x00\x01\x03\x00`I\x00\x01\x03\x00 aI\f\x01\xeb-\x88\x11';~\xb6\xd5\xd8Y\x00VV\xca1\x9b\xbcߌgr\x17X)\xd5\x04\x16\x80\xad\x80]{\xe1ᢍ;\u007f\xa3\xce\xd1\xdfx\xb1\xb2h\xd3^\x161\xed4~\xe3\xfb\x17+\x8a*_\xfe\x9eƄ\xa4\\֓(\x02\x16.w:\xf2i<\x9d\x16\x94\xab\xfex@x\x8d\xe1\xe4\xb6LGI\xacȰ\xb3h\xfc\xf7\x9f\x9f\f\xa3\x00\xa9EI]vvQ\xa0/\xf8B\xae\r#vv\xf3\xa5\x06\xa1fB\x03\xd5\"k\x03\x1ap\xdd\xd5\x06\x1b/+\xe7\x985%\x1d\x8e\xfa\xfb\xa2\x1c\xa8\u007f\xa3\x9a\v\xa4'Y{\xe1[r\xb7\x9d\xe9\xbcl\x17\xc8!\x94B\x0fc\x9f\x03\x1d\x8an\xd0\xcf\n\x90\xf1P̈\xca\xea;\xf0\x0e!\xf5\x1dx6\x8cp\xef\xc0S\x18Ka\x12A߁爒Aȗ\x96\xe9\x1f\xcc\x14\xa3\x00q\xd8\t\xd8\xe5b\xbci\xfb\x8f1\xfe)}\xd7\xfd\x85b\xec\xddZ\x89\xf1k\x84Ł\xac\xc0ś0\xder\x9b\x9c>\x88\xf1\xbe\x837\xf44\xad(\u05c9r=\b\x95\x132\x91\xa2E\xa8\xf6\b\xaf1\xf4e\xbeR\x9d:I\xe2\xe3XR\x87\x9d\xc9lΊ\x8d\xa7jշ\xf4\xa1nN\b9\x83\xb3s64\xfa\x8a\xd5\xc1\x8e\x82E\u007f\xbb\xe9xz\x13=\x02\x93M\xe9\xe3\x96=}i\xdd\xda\xd6\xdc%[lV\xd81\xe3\xb2\xe8Kn\x8dfa\x1e\xa8\xf9\xb0x\xd5\\\xa0A#\xd2^\xb9\x8bbG]ѓ\xc5c\xbb@\xf4,&\xfc\x0e\x9f\xf2\xe1s\xf8c\x8cs\xe8[\x88\x83\x83\xc7<\x8eP\xf4\xfd\xe2[\x88c`\x1c\a\xee-Č!\x16\a\x82\xbd\x85x\xf6+\x17\x06\xd2\xd6\x1c\xef\xccC\xb1\xa3\xd1\xdb\t\xd8>\xfc\xb2\xd2\xf9\xba\xb8\x11\x9fW\xfa_\xc5\xf8\xa8\xf2\xe5\xf3M4\xf6\xd0i\x8c\u007f\xfc9!\xe7\x8bh\x88\"\xeb\x10\x12e+U\x1dp\xd08\x15%\x88Ɨ #\xc2k\f'Q\xab\x16\x8f1\x0e.\xa9A\xd1\xe6\xc9\x1a?\xff-\xacF\xd7\xe5_\xab\xc3\x19\x88\xb6\xb3P_r\xbf6gN\xa3\x05\x90\xa7\xea\xf2q1ʯ\x80M\xc9\xe6\xc9D\xe1\xdc#\xf1\x15v\xcc\xf8,\xea%\xab\xca/\x9cE\xac\xe6\xc2\fZ$-\xe8A\xaa\x18\x1f\x95GO\x16\x8f\xed\x021J\x16(qL\x91IGI\xecvƎΔ\xdb\x12M\xccD\x88F\x1f\x1d\xfe8\f\vRe\x8d\xc4\xc51\x99^\x1a\xa1\xd1,\x16.`\x95\xea\xc8\xf0\xed\x83\u007f\xa0#Ž\xec\xb7\xf7\U0004f640\xb1=\xcf\xe1\xe7\xa2\b\x18\xab\xc81\x94\xadt\x81U\xe5څ\xf8\xa3\x13F\xf3\xe8\xfaWgݲ3\x89\x02\x1f\xb9\x8c\x06\xfba/!\xe3\xafR\xce@\xb4\x9d\x85zv\x8e\xa1\x85\x14c.\xca\xd5(\x01\xf5fl\xa4Yؔl\x9e|9\xd7\x05FV\xdc1㳸\x95e\t\xa4\xf0o\xb0\x88\xd5\\\x98A$\xac\xb5ְ%\xba\r\x87\x9e,\x1e\xdb\x05\u0085\x12\xf4u\x91\x13>\xbf\x8d\x80\x91\x86\xd4X\xb3>q\bX\xf4؈\x949\x04,\x90\xcaƎ\xcd\v\x17\xb0\x9f❟\xeb!\x1e\x1f֢>ަ\xf1kO\xe3-\xec\xcb)\xfa\xd2|\xab\x80\xade\x9fSIJ\xbe\x11'-\u058c\xcb,\xc2t\x86:\xa8\xaf\xa3/\xbaI:A\xc6$:\b\xaeE)\xedu9\x0e\x9f\xfa\x876\\\xeeJ\xc9\xdc\xc0\xae\xac\xe9\xf4=\xec\xa7\x03J\x92N҉\x8c\xe8 \f1ى\x82\xb4\x9cǕ6ӫ\xcd\x1b\xe4kVcɻا\xb4G\xb3\xe5\f\xb8\xcdZ\x94\xdcZ\xe3\xce(\xb5\x1c-\xf5\xecT\xb9\x85,\b\t\xfa\xdc)\xae\x92lk\xb2\xb6|\xfdm\xf5\\\xc9\f[ރ\x19\x00i4Y\xa9U\xb8*۱a\x9aL\xa6\"\x94\xc4b}\x8b\xb5Г\xf1\xb6Q\x89aК\xd3\x17Fᾜ\xb6\xe5<fS{r\xd3\x1f\x1cr\xf7\xf3g\x9eD=\xa8\xd6\xe2ԧZ\x1b\xb0y\xa0\xc4\n\xe9,A5\xa3\x9f\xa19jab\xb6V\xfbd\x9a-\u007fb\xa76gI\xee\xd2Q\x12\xeb:\x8b~Mr\x1e\xf8,\x02\xfe\xb6rR\xf2\n\x150\xd3o(\x99F#u#\xe4\x8c\xe8\x02֘\x1c!\xd1/DA\xc0\xf4\xdcl+D\x88\\\x95\xe5,\xb7\x86\x12\xe4\x0e\x89\x16\vu\xa29B\xa2\xb6\xacZd'`\x9f\x17a\xbc\xf1\xe0i*O71\u07b2\x9dQ\x84/(\x02\xa6v\xc7NG\x13\xb0:u#\x1b\xf5\xd3\xf8\x18;ht0n\x9c4\x1a\xecD\r\xc1\xe07D\x9bz`\x83\xe0Pg2r54\xa7\xb3\xee\xc8`z~\xd3@\x03b\x9d\xe6\x11m\"e\xc2_\x10\x9c\"S\xc1\xb5~~BOHV\x93\xb4\xa3\xafՕ?Cn\x05Y\x90\xa0\xa0~\xb9\xd5h\x03\x10\xa5\xc1t\xf6f*\xb6\x9c\x01\xb7I\x9de\x1f\xfey\xb6e\xac\x1fB}\x91\xf0\x1etX\xc8B)ף\xdd\x03\xed.4-&\xab\x96\xea\xfb\xea\xa5*\xb1d\xa6-\xef\xe1\xf8\x1a2\xe4\x1e\"\xf9\xc7I\xe4dgvN\xba\xbb\xae\n]U\x8c\x83A\xf5z\x11ja$\x13l\xa3\x11\xc3@\xaeB\xab\x95\xff6\x8f/\xe31\x9b\xf4\xb8\x9a\xfak\x11j\xe3\xcf|\xf4\x97\xdcG\xa5\x00\x00 \x00IDAT\x83j-Np\xf6\x9fg\xe3@\t\x152X\x82jF?Cs\xd4\xc2\xc4h\xadq$\xd3l\xf9\x13ۇj\x06O\x96&\rǺ\u03a2_\x93\x9c\a>\x8b\x80\u007f<mr\x95L\x05\xcc\xf4;3Ԑ4D:\xd0\t\xaaf\xeaq\xce\xcf\xe3\xcb\xcb\x17\x87\x9e\xeeH\xa4\x1f\t\xb9\xd9V\x88\x84\x9d9\x1d\xbd>d\x1503\x8b$n\xdc\x1c\xade\x85:\xed\x04\x8c\\>\xe8\xc5\x18\x17\xbdx\x9b|\x87M>\xd6\xc3\x15E\x170\xad\x8f\xb4\x1au+\x17)r\xcd\x10?\x12F\xf0\xe6\x10\x92\x8fj\xe8T.\xa5*\x97\xb2\x15qoP\x14w\xfa$\x9b\xe5\xef\xd3\xfbn\x1d\xea_\xeb\xd5'\x88\x80\x99\xac\x0f\xd1I\xa5a\x163Q\xe8\xb1^M\xa9\xd5l3\x15\x975.b107\xa5\xec)\xa5\x99\xb9\v\bO\x88\xfd\xf1\xa0g\x84Ϣ\xcdE\xe5\xa8\xcd)&;\xc3\xfe\x14\rP\xe5\xe6J\xc6\xd9r\x1e\x82.\xb2G\xdaC\\L\xa0\xf3\x91oʘ\x17t\xe8\xe3\x19\xa3db\xddx\xdbhD78\x93\x82R\xfa\xd9\xd6r\x1d\xb3*'\xedTױ\x18\xbe晏qP\xc5\xc1\xd78\xbd\x96f\xa1\x1f(\xb3B<w\xbf\x9a\xd1\xcfP\xecZ\x98\xe8\xad5\x9ed\\,T\xfd\xc4F\xba\xe8\xd9\xcdc1\xe1\xa3^g1\xaeI\xfe\xd2\xe0\x86\x90$o\xdb\x1a\x16\v\x95\xf7K\xaa\v&\xdc\xea\xed_\xa9>rk\xb4\x1c}\x18\xebB\fi=\xac\x90\x90\x9bm\x85\xd6zn\xd1ȫ\x16\x013\xb3\x18㦚\xa2\xb7,\xdb!\xa4\xc2\xed\xcf_ۊ\xf1\xb3\xb4\av\xcd\xfcuN\x01{\\\xddp\xd3\x1a\x13\x0f:\x1bq$\v\xf7A\xa3\vX\xb5\xbeُFM\xdb\x1e\xa4\xbdLu4)r\xabcrZ\xe2\xf6\x89\xc9\xfc\x9ei\x8a[\x8d\xba\xcd\x1d\xafZ\xfd}\xacR\r1\x86\xdcѯR6\rІ\x84\x1b\xa4!\xd4<\xd4W\xe0\xa0>\xb8,Ƴ<\xb5\xc7Gɴ\x98\xacF\r\xb9\xb6\x9a\xc5\xcc6J\xc6\xd9r\x1e\xae\xa2[\x0f>\xbavJ\xed(\xe5K\\\u007fi\xb6\x80\x89u\x93\x84\xbe\xd5l\xa2\x19L\xd6In\x94%\xed\xa1U[\xaec\xe68\xa0\xee\x13\x05,\xc6A\xb5\nX\xb4u\x0e\x86\x80\x19\x15\xe2\xb9\xfbՌ~\x86b\xd7\xc2Do\xad\xf1$\xe3\x04\xcc8\xb1\x13m\x1b<Nu\\\x13\xf5:\x8bqM\xf2\x97\x06/`M\xa8\x91\t\x18\xef\x97D\xf22\xb5\x15\x9d\x12U'\xb6f%\xfa\x85\xa8\x9c\xee\xe1\xe1\xe1\x16*`\\nv\x15\x9aTW]\xd4[\x04\xcc\xccb:\xd9\xec\xf7DoYv\x02v\xe7\x1f\x9f\xb3\xcf\xdf\xe0\xa2\u007f\x912m\x0e\x8c|\xfe\x8f\u007f\xcd-`\xea݊I\x84h\xf7\xbc\x01\xd5\xf6#\xf1\xfeEt\x0136[\x107\xdf1\xa4\x9f\xbdH\xf2h\xb32\xe8N\xb2̅\x98\xc9\xf2\xb4?\x03\xec\xcf\aw\xbcd\xa9f\x96m\xac\xab\x945\x88A4B8\xd8\x00\u007f2\xa9\x9d\x88YL\xb6o\xceE\x99\x8db\xb2\xb5\xea\x19/) Bn\xa6-\xefA\n\xa5\x8f\xa4\x87R\xd8\xcch>?M2[\xc0ĺ͞R\x11\x89f\xd0\xe8j\x0f\xa1\xd01\x17\xfd\x93\xbaL\xc7l\x1c\xf5\xd0}S\x16\x01\x8bqPŦ?l\x89&\xaab\b\x18WH\x93\xbb_\xcd\x18g(f-L\xf4\xd6\x1aO2N\xc0\xf4\x13;\x9c\xe9\xde\xd3\x13\\g\x89Fo\u007fM\xf2\x97\x06/`\x13{&\x98\x80\xf1~\t\xe9\xd6\x0f\xbaT3<\xac\x0e\x84\xc4#\xa9;\xe3\xe6\xc0\xf8\xdcl*4\xa2\xba\xb7N\xe2sYhs`\xd3\x03$V˲\x11\xb0\xef\xf1\x03\xff\xa4\x9f\x971\xbeM\x9e\xc3\xdb\xe9j0\xf2\a\xec\xfd~n\x01[\xc5\xe6\x15~\xa1F\x80\x1dC\xeeZtRpk\x11\xb0z\x8b\x80}\xc8_%\xb7\x8c\xfbC\xb9\x9d\xeb\xd6\xe6\xf6\xe4\x12\x113Y\x95g\x841A\u007ffǫ\x83\xfd\x81\xa8K\xba4\xcbV007%6{\u05ce\x84їzv\x9c\xb4\xf7\xc0e1B\xff^Mu:ڄd\xd5\x1e\x96\xc4S-\xe4\xc6\xd9\xf2\x85\xcci\xca\"\xeef5E>?\x81#\n\x18-\x99X\xb79\xee[\x92\x98\x06t\xaa5\xa4\xfdu^\x9ec6\x93\xfasu\x9f!`\xf5\x962\xf0\a\x95ύ\x90CR\xb4!s\xbc\x02v\xb7\xaa\x19\xfd\fŮ\x85\x89\xdeZ\xe3I\xc6\t\x98~bs\v\xe8\xdf\xf1r\x8b\x80\xd9_\x93\xfc\xa5ada\xdeM\x12\xfc\x129\xb3>[\xedp\x1am0ƅ\xc8\t\x18\x97\x9b]\x85&م@\xac\x93\xf8\\\x16\x01\a\x1b\xb9u\xa1\x89\x18-\xcbN\xc0\xc8O\xf1O\x15\x05\xbby\x10?\xa5\xa8\x98\x17\xbf\xa0\xe8\xd4\xc5M4\b\xb7 `\xa4\b\u007f|[\xbfYI\x97Q\xe4)\nvR\xd2d\xea~\xe4H\x17\xbbM\xa6\x809\xf6(\x83\xe05\x16\x01\x9b\xca,\xa4\xedl\x17;\x05d\xb3G\xbby믕ΠZ?\x111\x93\r\xa8\xa3\x8cz6l/,$\xe4[\xf6\xc37\x92q\a\x9e\xbfJM\x03nSʜ\xa2\xcbN\n\x99\xc5\xd8a\xf5\xeaV\xcfNf\xdd\xe8/\xf8,\x1a\xd0\x19\x96v\x9b\x90\xac\x8fM\x0et\xa2>!7Ζ/䆂rR~\xbf\x8fe\"\xfc\xa16\x04\xcc(\x99P7\xdev\xac\xc1\xd2%\xb0\x1ap\x8c;\xd5\t\xebe;f\x9b]\xf4\xba\xafb\u05edy\xe6c\x1cT>72\x93\xab\x85P\x17\x89W\xc0\x16\xbb\x9a&\xd1\xceP\xccZ\xe8G\x87\x98\xad5\x9ed\x9c\x80\xe9'\xd6M\xa5c&\xcf\"`\xf6\xd7$\u007fi\x18Yp\x02\xc6\xfb\x9d.\xa8'\xdb|3F\x16\x8c\xe8\x17\"'`\\n\xb6\x15*p+\xfa\x18^e\x110.\x8b\xc9\xf4rE\tf\n=\xb1Z\x96\xad\x80\xdd\u0604\x8b\xb6l\xf5\xe22:\xfdu~=\xf6n\xaf\xc4x\xf7m\xab\x80m\xc7\x18_\xd0Ӵ\"_j\xca}nc\xbd\xc3q$<F\xa4݅Ԧ\xf1\\\x8d\x87\vPrGH\x8d}6R\x9d\x12\x94\x95#\xb1j\xf5+\xfd;\xb4\xe7\x12\xc2I\xcdj\xba\xc3\x0e\xe7L\x8e\xe30\xef\x8a\b\xc9\x02\xc8\u007f\xb2\xb7\x1a\xb1Y\xfe\x06\xa9\xb9ǗF\x1b\xec\xe3\xfa]\x00\xc1\x963\xe06%\x94\xdfu<ǩ&(\xd5\x06\xbe\xa3l\xe2p݆\xea\xfb\xf8,\x1aP\xfa\x81\xbe\x9ejv\x8f\x94KV\x95\x14\xe8\v$U\x89\xb9\xf1\xb6\\!\xebP#i\xa27i\xa7\x87\xd8M\x1a6\x1d\xa3l\a\xa5\xea`pJ,\x99\x91\x8c\xb7e\x85L\xb7\xcc\xcaX\ff\xb3|\xc7\xec\x9bLw[w\xa9\xc4\x04\xcc8\xf3\xb1\x0e*\x9f\x1bi\xb1\x0e\xdd\xf8\x03%\x16R\xe7nV\xd3$\xca\x19\x8a]\x8bRc*e\xa4\r\xb5\xa85\xb2O\xa6\xdb\xf2'\xb6\x01mn;\x9c\x8f\\MC\xb1\xae\xb3hפxi\xe8YL\xfa\xd7}\xa3|\xfdf\x9d\u007f\x92\xf3\x1b\tֺ\xc6\xc9%\xe7\xae`\x84\xae\xc47\xea\x1d\xedB\x14V\xe2\x1b\xb9Ũ\x10\xb7\x12?\xe4p\x1f\xaa\xcfH\xa2\x17\xc1\xb8\xf6\xc0\xc1Uᐐ3\x8e\xfb;z}\xc9A\x12\xbde\xc9A;\x01c\x8f?z\xb7\xbc\xac\x8e\x10\xaf\xbd\xa0|\xd9~J\xd1/\x8b\x80]\xde\xed\xdd\xf8\xbe\x9e\xa4\x15\x05F}i\x8e\xb5\xfd\xda\xf7)I\x98\xbf\x888\xd9\b7\x99\x1d\x92p\xa1#\xdd\x17@\xa8\x96\xc5>\v\xa5)\xff\xd2\xdbB\xe1\xcd\xee\xf4\x82\x1e-A\xfd*5\xf9\x882\"iL\x1f&<b\xb2\x81u\x19N-\xdbȎ\fǃ\xd4\xf6\xdbԪ\xa8\xb6\x86\x01\xbf)=^\xed̪ҚA\x87\x8bN\xe1(\xfdW\x84\x9a\x94&\x99\xe3\xea\xe3\xb38Qxȝ\x92Y8hMv,O_\xadb\xe6\xc6\xdbr\x85\xecs\x8c\x92PZ/\xbd?\xc1\x0e\t\xebdh\x8f\x8a\xa1v\xb1dF2ޖ\x162\x1d\x89G\xc4j0\x9b\xe5;fd\xa2\xda\xed\xf0\x8d0\x013\xce<\x89qP\xf9܂\x8e=Ċy\xa0\xc4B\xea\xdc\xcdj\x9aD9C1k\xa1\x1f\x1d\xa5g\x94\xaed\x95:\x15W2Ö?\xb13-9\x92\xcb\xdf\xe1\x91\nc]gѮI\xf1\xd2гhP\x9f\xc6\xddF\x9fg4\xfd\x0e \xbaTs\x87\xf2\xefY\xfa,\xa4:\x85Η\x97s\xa6>\v\xa9\xf8a}\x0e=\xb7\x18\x15\x1a垅\f\x97fd\xef\xe9HV\x8a^\xad\x9eL\xe4\xe7\xb3P\b\xf9\x1c\x99\xa5!\xa1\x16\\\x8d\xedׁ-\x06\x97\x84Lj\x16\xc0.)\xda\x1d\xa88\t\xc4^\xc5;\x1b\xb3\xab</\x16\x98lQ\xe8\xb1\xce\xca,\x02w\xf7\x98\xa9\x93\xf8\xf3\xa1K\xaa\x9e\xb6\xb3Y\x00w\xb7\x9a\xcbL\xa2\x95w\x81,\x85\x80գ\u007f7\x98m\x8b\xfb[;\x93\x98\xd4Ԑ\xf8Y\xe0Y_`\xb2Šù\xcd\xced\xfe\xdc\xddc6o\x01\x9b\xcc\x12\xe7\r\x16\x8b\x05V32\xa6\xb2\xe8\xcf\xf6,*\xf3>-\x89\xc9]\x17\xb0\xd0X\xd7*iV\xc7{\xa5\xb2\xc0\xb3\xbe\xc0d\x8b\x80\xec\xaa[\xeev4\xef\xca\xcf[\xc0V\x04f5\x1f\xd4F;\xd6\xf9\xfc\x95żOKbr\xd7\x05\xac\\9Ӊr(\xd5\xd9\xc1y\xb3\xc0d\xf7\x06\xf3\xaf|\xf8\f\xaa\x9b_\x8a\x15\x00_\xcdp\xaf\xca<ƟK\xce\xfcOK\x82r\xd7\x05\xac)\xd5\xf5\xef\x0e \x97\f6;\x18\xfb\xee],\x16\x98\xec\xde`\xfe\x95_\x8b\xf4;8\t\xc4\xfc\xab\xb9\xbc$Zy\x17\xcc]\x170\x00\x00\x80\xbb\x05\b\x18\x00\x00\t\v\b\x18\x00\x00\t\v\b\x18\x00\x00\t\v\b\x18\x00\x00\t\xcb\xe2\n\x98\xfe|\xd1ܼA\x1f\x06\xd7X\xfc\x18\x92\x00\x00\xfc`\x00\x01\x03\x00 aY\\\x01\xbb\xfc\xeb\xf3v&\x04\x04\f\x00\x80Ebq\x05,>@\xc0\x00\x00X\x14\xee\x15\x01\xdb6\x9f\xe7r\x01\x00\xb87\xb0\x13\xb0\xdf\xe0S\x17*\xbd?\xb9\xa6\xbe\x18l\xd3^\xed\xad\x85\u05ceT\xaeߴO}_>\xb7\x83\u0381\xbd\xa1σ=\x8b_&\x96d\x9f\xef\xddT\xfc\xd4E\x8b\x80\x85˝\x8e\xfc\x0eB_Z\xa7\xbd.\xfa\x80\xf8\x02\xc48\b\xa3\x00\r5\xf8o\xbcug\xbe\xf4$k\x8f\xf4&wۙ\xce\xcbv\x81\x1cB)\xf4%\xb7}\x0et(\xbaA?+@\xc6C1\x9f\xe1Q\xdf\xe9t\b!\xed=\x92s2½\xd3Ia,\x85\x9d:\xfaN'G\x94\fB\xbe\xb4L\xff`\xe6\xc2\xdf(\x02\x001\xb0\x17\xb0\x17\xbd\x18\x17\xdf&\x17\x8a\xb1wk%Ư\xd1_\xcf{q\xf1\xf62\x8c\xe9\x8c\x17\xbf\x83\n\xd8?p\x11{\xfb\xe1\xedb\x1a\xba[Hv\n㊭EE\xbb\x05\x01\xcbu\xa2\\\x0fB\xe5\x84L\xa4h\x91}=Q\x038\b\x9c\x15_\xd0Y\xb5\xea[-\xd4`\x14\x03\x8b\xedl\x16bЈ\xb4WH\xa2\xc6(\tT\xf4d\xf1\xd8.\x10=\x8b\t\xbf\x83\xbe\x9a\xda\xe7\xf0OD7\xa4o\xd5\f\x0e\x1e\xf3X\xe27\x9a\boՌ\x81q\x1c\xb8\xb7j2\xd4\x00\x8f쭚\xb3\x1f!\x1eH[s\xbc3\x0f\xcd\xe7\xe5[\x00\x10\x1f\xf6\x02\x86+\xcf_8Mn\x14㣷\x95.\xd4&\x1a\x99\xe8\xbbb\xfc\xf2mr\xe7\r\x1a\xdcC\xd8\xc1\xeeB\xeeħi\xca\xf3x+\x11\xf7^\xc4\x0f\x9c\xbeC\xbe\u007f\n\v\x02\x86\xb2\x95&5\u082fX)A4\n\x00\x19\x89\xe3\x05\x88k\xfc\xfc\xb7\xb0\x1aJ\x97\u007f\x83\bg \xdaFa!\x06-\x92\xf6\x12\xefT3\xf2\x93\x15=Y<\xb6\v\xc4(Y\xa0\xc41E&\x1d%\x81\x98\xa6\xec\xe8L\xb9\xc5\xf8P\x1cq\x84\x87\xe7\x8fC\xdc\xe1\xe1'\xd3K#\xf4\xed\xec `\xc0\xe2\x13\x87\x80]\xa6\x9fG\xb5@\xdc\xef\xe3\x1f\x13\xf22\r\xf1\xa1\xb0[\x91*a\a\x13\xb0\xd3\xeaރ\xf8\x94%\xd9A|\x94n\xdf,\x13\x05\x8c5\x98c(\x9b\xbe\\\x94)\xd7.\x14\xbb\x15\xea\x88a+\xaa\xd57\x8e\xf1\x02\x1654V\f\x16b\x10\tk\xad5\x1c\xfb}\\z\xb2xl\x17\b\x17\x1a\xcb\xd7EN\xf8\xfc6\x02F\x1aRgb\xec\x8fC\xc0\xa2\xc7\xfa\xa2\xcc!`\x81T6vl\x06\x01\x03\x16\x1f{\x01\xabd\x9f\x0fk1!o\xd3\xe8\xb6[\xb4/7n\xdc\x11w0\x01\xbbY\x84\xff\xa9\xfc\xeb\xa5\xff\xf2{\xefl\xc4\x17ٗ\xa3\x82\x80\xade\x9fSI\xca\xf5\x1dq\xd2\xcb\u007f\xc6e^\xea\xb5(\xa5\xbd.\xc7\xe1c\xc1\rȉ\x82\xb4\x9c\xc7o\x11ҫM)\xe5kVcɻا\xb4G\xb3\xe5\f\xb8\xcdZ\x94\xdcZ\xe3\xce(\x15\x1b\x92\xe8Lς\x90\xa0ϝ\xe2*ɞ\x9d\x9b\x89\xd9Z\xed\x93i\xb6\xa3\xc9\bՇ\xab\xb2\x1d\x1b\xa6\xc9\xd4\xe6,\xc9]:J,\xd54<\x88\xe5m\xcb\xd7\xdeknz\xe0\xb3\b\xf8\xdb\xcaI\xc9+T\xc0L\xbf\xa1d\x1a]ύ\x903\xa2\vXcr\x84+/_\x1cA\xc0\xf4\xdcl+D\x88\\\x95\xe5,\xb7\x86\xc6\xe2\x0e\x89\x16\xdbo\xa29\xc2\xf9\xe5j\x1c\xbd\xf2\x00\x10\x0f\xf6\x02ƺS71\u07b2\x9dQ\x84/\x90\xf5\xf8o\xfa~q\x87\xba\x90u\x1f\x1dC\xbeO\x13\n{\xbf\xa7\xb1%)\xa7\x05\x01\xabS7\xb2i\x18\x9bm4Dπ\x16\x17\x98\x12\xeaLF\xae\x86\xe6t\x16\u007f\xae&iG_\xab+\u007f\x86\xdc\n\xb2x(A]\x89j$U\xe0$\x94\xdbٛ\xa9\xd8r\x06\xdc&u\x96}\xf8\xe7\xd9\xe24\x90\xe0\xcc\xc8B\x19\xc7>\xda=\xd0\xeeBӳr31Zk\x1c\xc94\xdb\xc8\xc9\xce\xec\x9ctw]\x15\xbaJ\xfaP\xcd\xe0\xc9Ҥa\xb1\x9a\xa6\a\xa1\xbc\xd5R}_\xbdT%x\xe0\xb3\b\xf8\xc7\xd3&W\xc9T\xc0L\xbf3C\rIC\xa4\x03\x9d\xa0j\xa6\nX~\x1e_^\xbe8!\xd4\x17\x89D\xfa\x91\x90\x9bm\x85Hؙ\xd3\xd1\xebCV\x013\xb3H\xe2\xc6͆_\xae\xc6\xd1+\x0f\x00\xf1`/`\a\xe9\xc7w\xd8\xe4c\xa5;uC\xdf/\xec\xd0\x04\xec<\xdeM\xc8S\xf8}\xcb\xdek\x18\xabi\xce\v\x02\xa6\xc5^[\x8d\xbai\x14n\xd7\f\xf1#~\xa6H\xa2\xb1\f\xab\\\x84\xb6Kz\xabr\x98\x85\x87\x13\x063WS\xb4`4R\xe6\xa4\xd2r\\\xc4b`nJ\xd9S\x84L\xba\v\x88\x88a\xc0e\xd1梍\xa8\xcdi\xf1 \xa0\xb7\xd6x\x92q\xb1\xfd\x90O)\x85\xf2\u007f\xa4\x8bN\x97\xe7\xb1\x18\xc7f5y\x0ffyϰ\xee\xd1\x00\vVfz\x10\x86\x90$o\xdb\x1a\x16ۏ\xf7K\xaa\v&\xdc\xea\x1b\xe5\xa5\xfaȭ\xd1r\xf4\xa1\xf5H\xea\xceBZ\x0f+$\xe4f[\xa1\xb5\x9e[4\x92\xa0E\xc0\xcc,ƌ\x18\xa0b-\xcc\x1aǨ<\x00\xd8\x13\xa7\x80ݤ\x03D\x9d;ڼج\x1d\x9a\x80\xddވ\xbf\xff'\xf6\u07b4콩\x87\xef~_\x10\xb0\xc7\xd5\r7mYă\xceF\x1c\xc9\xfc\xfdv\x16z\x94Ͱ\xf8=\xd3\x14\xb7\x1a`\x98kJ\xb5\xfa\xab'Y\x9c\xf89\xc3ó\x19\xa26d\x89\xa4h\x18pY\x8cgyj\x8f\x8f\xaa\x81\xac\xed\x04,\x9ed\x9c\x80Iz\x98扶\r\x1e\xa7\xda\xdf4\xab\xc9{0\xcb[\xa3\x86\xb5Z]-z\x10\x04\xac\t52\x01\xe3\xfd\x92H^\xa6\xb6\xd2N\xa2\xea\xe4\xa2j\"\x1eI\xddY\b5\x0f\x0f\x0f\xb7P\x01\xe3r\xb3\xabФ\xba\xea\xa2\xde\"`f\x16\xd3\xc9\xe6\xdf#\xbe\x16f\x8dcT\x1e\x00\xec\x89S\xc0H\x996\x99E>\xffǿH%V\x9f\x18\xfa\xf8\xa7\xa7\xc4\x1dڳ\x90/\xe2ӧ\xf1\xb3\xd6dw6au\xe1\xd8k\x82\x80\xa9w\xc5&\x11\xa2\xc3\xc0\x06T\xdbo\x04\xffd\x98Ax\xf3\xb4\x1e\x02\xebYpMI\x96\xf4E\xac|t\xe5\xe8\x02\xc6FQ\x83\xd6 \xa9\x86\x01\x9f\xc5d\xfb\xe6\\\x94\xd9h\xf1 \xa0\xb7\xd6x\x92q\x02\xa6O\xa6\rg\xba\xf7\xf4\x04\xd7Y\xa2+\xf3\x1e\xcc\xf2\xaeUU\xa8\xa4@\xf0 \n\xd8Ğ\t&`\xbc_B\xba\xf55)R\xcd\xf0\xb0:\xfc\x13\x8f\xa4\ue31b\x03\xe3s\xb3\xa9Ј\xea\xde:\x89\xcfe\xa1́M\x0f\x88~\xb9\x1aG\xaf<\x00\xd8\x13\xaf\x80=\x87\xb7ߡ\x9f\u007f\xa0K'\x8ejkU\xf7\xe27\xc4\x1d\x9a\x80]\xc4O=\xa5\x06\xea\x16\xf6\xbe\xa0\x8a\xda\xedJA\xc0V\xb1\xf9\xab_\xa8\x913ǐ\xbb\x16\x9d$\x1c\xe6\xc5]\xe5\x19a\xb0\x85N\xac)u\xb0\xbeC]\x92\x1e\xaf}\x96\x80\xa9\x06\xe6\xa6\xc4&\xdcڭ\x91\x14\r\x03.\x8b\x11ڕ\x99\xeat\xb4Y\x9c\xf1\xe8\xad5\x9ed\x9c\x80\x95k\x1b\xb9\x05tZ\xbb\xdc\"`\xbc\a\xb3\xbc\xd5\x1e\x96\xc4S-x\xe0\xb2\xe0\xc2\xc3\xf3~\x89\x9cY\x9f\xadv8\xcd{\xb4\xe2\x91ԝq\x02\xc6\xe5fW\xa1I5Đu\x12\x9f\xcb\"\xe0`=\xea.4!\xd4\"\xaa\x80\t\xb9\x01\x80-\xf1\n\xd8e/~A\x19\x00^\xdcD\xc5\xe7\x86\x17\xbf\xc1ց\x15\u007f'\xee\xd0\xdfFQYTTqgV\xb2k\xeb\xf1\xaf\uf41b\a-\xeb\xc0\xf2\x14\x05;)i3%\xf7#G\xba\xb0\xd6\xc0\xbc\xb8\a\x10[h_\xcfft\n\v\t\xf9\x96\xfd\xf0\x8dd,\xdb\xe7\x05\xcc4\xe06\xa5\xcc)\xba\"\xc9\x1a\x0f\xcb0\xe0\xb2h@gخm\x16gd찮\x97Fk\x8d'\x19'`z7\xc6M\xa5c&\xcf\"`\xbc\a\xb3\xbc}lª\x13\xf5\t\x1e\xb8,8\x01\xe3\xfdN\x17ԓm\xbe\x19#\v\x86p$\rg\x9c\x80q\xb9\xd9V\xa8\xc0\xad\xe8cx\x95E\xc0\xb8,&\xd3˕!\xe1L\xa1G\xacET\x01\x13r\x03\x00[\xe2\x150r~=\xf6n\xaf\xc4x7\xbd\x93x\xbe\boܾ\t\x17\x9d\xb7\xec\xd0\x05\xec\r\xcc\x1e#\xb2&\xfb\xb8\b\x97\xfdċ\xf7\t\x02\xe6KM\xb9ύ\xf4\xb9\xfc\xe3Hx\x8cH\x8d\x0e5R\x9d\x12\x94i e\xff\xc9\xdejt\x82\xeeh\x90\x9a{|i\xb4\xf3\xf6\xb8\xbe\xe8B\xb0\xe5\f\xb8M\t\xe5w\x1d\xcfqZ\xef'\x9a\x06f\x16\r(\xfd@_O5\x1a\x14\r\b)5\x86\xb8#m\xa8E\x1d\x8c\xda'\xd3m\xa7\x87ح<6i׀6\xb7\x1d\xceG\xae\xa6!\xbe\xe8\xbc\a\xae\xbcUI\x81\xbe@R\x95\xe8\xc1\xccbҿ\xee\x1b\xe5\xeb7\xeb\xfc\x93\x9c\xdfH\xb0\xd65N.9w\x05#t%\xbeQo\xa3\xbc\x9c3a%\xbe\x91[\x8c\nq+\xf1C\x0e\xf7\xa1\xfa\x8c\xa4䎐\xba\x12\xbf%\x18\xbc*\x1c\x12r\xc6q\u007fG\xaf/9\xc8ׂ\xabq\xac\xca\x03\x80=q\v\x18\xb9\xf6Be\x91w\xfb)u%\xc4\xe5g+\x8a\xca\x0e^\xb6\xee\xd0\x05\xec\x869\xcd/$\xfb\xdb\xc12\xef\xf6\v\x1f\v\x02\x16\x18\xf5\xa59\xd6\xf6kߧ$\xe11\"\x16\x1d*\x94\xa6\xfcKo4\x0e\xac\xcbpj\x96\x91\x1d\x19\x8e\a\x87\x95\x8doS\xab\xa2\xda\x1a\x06\xfc\xa6\xf4x\xb53\xabJ&\x168[#\x8b\x13\x85\x87\xdc)\x99\x85\x83V\x03\xd2\xe1jW7n\xa5+Y\xa5Nŕ̰\x1dU\x1f\",\xa1?δ\xe4H.\u007f\x87G*\xe4\x8b\xce{\xe0\xcb{,O[\a\xc6y0\xb3h@\x88N5m\xa3\xcf3\x9a~\a\x14\xc3:\xb2C\xf9\xf7,}\x16R\x9dB\xe7\xcb\xcb9S\x9f\x85T\xfc\xb0Yy=\xb7\x18\x15\x1a垅\f\x97fd\xef\xe9HV\x8a^\xadM|\xf9\xf9,\b}\x16ґY\x1a\x12j\xc1\xd58V\xe5\x01\xc0\x1e;\x01[j.\xc5\xf1\x18\x91@`>\v\xbc\x13-Zq\xa2\x95\x17\x00\x96\x98\x95&`\xf5h\x9eapkjH\xfc\x98\x82\x10\x19SY\xf4g{\x16\x15\x100\x00\x98\x93\x15%`\xa1\xb1\xaeUҬ\x01\xde\"b\n\u0083\xdah\xc7:\x9f\xbf\xb2\x00\x01\x03\x809YQ\x02V\xae(\xca]l\xb2\xeal\xb1J\xb8We\x1e\xe3\xcf%\x87//\x00\x00QXQ\x02֔\xea\x9a\xe7\x00r^\xb0\xd9\xe21;\xab\x95C\xa2\x95\x17\x00\x96\x9c\x15%`\x00\x00\x00\xf3\x01\x04\f\x00\x80\x84\x05\x04\f\x00\x80\x84\x05\x04\f\x00\x80\x84\x05\x04\f\x00\x80\x84eq\x05L\u007f\x94hn\xeeF\\H\x00\x00~\x80\x80\x80\x01\x00\x90\xb0,\xae\x80]\xfe\xf5y;\x13\x02\x02\x06\x00\xc0\"\xb1\xb8\x02\x16\x1f `\x00\x00,\n\xf7\x8a\x80m\x9b\xcf3\xdd\x00\x00\xdc\x1b\xd8\t\xd8o\xf0\xa9\v\x95ޟ\\#\xe4Ƌ\x95E\x9b\xf6^P\u007f\xbev\xa4r\xfd\xa6}\xea+\xee\xb9\x1dt\x0e\xec\r}\x1e\xecY\xf6RC!\xd9\xe7{7\x15?u\xd1\"`\xe1r\xa7#\x9fưiA\xb9\xea\x8f\a\x84\x97\x1a\xc6C\x18\x05H-J겳[<z\x92\xb5\xc7\xc1\x93\xbb\xedL\xe7e\xbb@\x0e\xa1\x14\xfaJ\xdb>\a:\x14ݠ\x9f\x15 㡘\x0f\u007f\xaa\xef\x03;\x84\xd4\xf7\x81\xd90½\x0fLa,\x85\x9d:\xfa>0G\x94\fB\xbe\xb4L\xff`&\x1f\xab\x05\x00\x16\x05{\x01{ыq\xf1mr\xa1\x18{\xb7Vb\xfc\x1a\xfd\xf5\xbc\x17\x17o/\xc3,\xb6\a\xbf\x83\n\xd8?p\x11\v>t\xbb\x98\xbe\xd4PHv\n㊭EE\xbb\x05\x01\xcbu\xa2\\\x0fB\xe5\x84L\xa4hQ\xa1=\xc2K\r\xa3rV\x8c\xcbQ\xb5\xea[\xfa\xec3\xf7$8g`\xb1\x9d\xcdB\f\x1a\x91\xf6\xfaQ\x14;\x02\x85\x9e,\x1e\xdb\x05\xa2g1\xe1w\xf8\x94\x0f\x9f\xc3?\x11ݐ\xbe\x9158x\xcc#\x06\xc5\xe4\x10\xde\xc8\x1a\x03\xe38pode\f\xb1w\xe2\xb37\xb2\xce~\xfc| m\xcd\xf1\xce<4\x9f\x17\xb7\x01@|\xd8\v\x18\xae<\u007f\xe14\xb9Q\x8c\x8f\xdeV\xbaP\x9bh\x98\xa1\xef\x8a\xf1\xcb\xec\x9d\xf8\xde\xef\xc5\x1d\xec.\xe4N\x1aזF\u007f\xdcJĽ\x17\xf1\x03\xa7\xef\x90\uf7f2\xbc\x13?[iR\x03\x0e\x1a\x1b\xa2\x04ј\x0ed$\x8e\x97\x1a\xae\xf1\xf3\xdf\xc2jx\\\xfe\xed3\x9c\x81h\x1b\x85\x85\x18\xb4H\xda\v\xe0S\xf9(\x96\"z\xb2xl\x17\x88Q\xb2@\x89c\x8aL:J\x021M\xd9љr\v1\x9fx\x84\xc8\xdc\xd1\xe1\x8fð U֨D\x1c\x93\xe9\xa5\x11\xfaf\u007f\x100`\xf1\x89C\xc0\xd8ˡ\x8f\xe2\xbd\xec\xfb\xfb\xf8DŽ\xbc\xac\x86\xeb&\xbb\x15\xa9\x12v0\x01;\xad\xee=\x88OY\x92\x1d\xc4G\xe9\xf6\xcd2Q\xc0X\x839\x86\xb2\x95\xa1\x96\xaa\\\xbbP\xecV\xa8#\x06:\xabV\xdf\"\xc6\vX\u0530j1X\x88A$\xac\xb5\xd6p\xecw\"\xea\xc9\xe2\xb1] \\X5_\x179\xe1\xf3\xdb\b\x18iH\x9d\x89\xb1?\x0e\x01\x8b\x1e'\x8e2\x87\x80\x05R\xd9ر\x19\x04\fX|\xec\x05\xac\x92}>\xac\x05x\xbcMC\xd5nѾܸqG\xdc\xc1\x04\xecf\x11\xfe\xa7\xf2\xaf\x97\xfe\xcbｳ\x11_d_\x8e\n\x02\xb6\x96}N%)\xd7w\xc4I/\xff\x19\x97y\xa9ע\x94\xf6\xba\x1c\x87O\x8d\xa7q\xa2 -\xe7\xf1[\x84\xf4jSJ\xf9\x9a\xd5X\xf2.\xf6)\xed\xd1l9\x03n\xb3\x16%\xb7ָ3Jņ$:ӳ $\xe8s\xa7\xb8J\xb2g\xe7fb\xb6V\xfbd\x9a\xedh2B\xf5\xe1\xaaldži2\xb59Kr\x97\x8e\x12K5\r\x0fby\xdb\xf2\xb5w\xe2\x9b\x1e\xf8,\x02\xfe\xb6rR\xf2\n\x150\xd3o(\x99Fft#\xe4\x8c\xe8\x02֘\x1c\xe1\xca\xcb\x17G\x100=7\xdb\n\x11\"We9˭aոC\xa2Ņ\x9ch\x8ep~\xb9\x1aG\xaf<\x00ă\xbd\x80\xb1\xee\xd4M\x8c\xb7lg\x14\xe1\vd=\xfe\x9b\xbe_ܡ.d\xddGǐ\xefӄ\xc2\xde\xef1VC{\x9c\x16\x04\xacN\xddȦ\xf1淡\x1d4\"W\x9e\xb1;ԙ\x8c\\\r\xcd\xe9,vaMҎ\xbeVW\xfe\f\xb9\x15d\xb1t\x82\xba\x12\xd5H\xaa\xc0I(\xb7\xb37S\xb1\xe5\f\xb8M\xea,\xfb\xf0ϳ\xc5i \xc1\x99\x91\x852\x8e}\xb4{\xa0݅\xa6g\xe5fb\xb4\xd68\x92i\xb6\x91\x93\x9d\xd99\xe9\xee\xba*t\x95\xf4\xa1\x9a\xc1\x93\xa5I\xc3b5M\x0fBy\xab\xa5\xfa\xbez\xa9J\xf0\xc0g\x11\xf0\x8f\xa7M\xae\x92\xa9\x80\x99~g\x86\x1a\x92\x86H\a:A\xd5L\x15\xb0\xfc<\xbe\xbc|qB\xa8/\x12\x89\xf4#!7\xdb\n\x91\xb03\xa7\xa3ׇ\xac\x02ff\x91č\x9b\r\xbf\\\x8d\xa3W\x1e\x00\xe2\xc1^\xc0XT\xa2\xef\xb0\xc9\xc7Jwꆾ_ء\t\xd8y\xbc\x9b\x90\xa7\xf0\xfb\x96\xbd\xd70VӜ\x17\x04L\x8b\xa7\xb6\x1au\x132\x84\\3ď\xf8\x99\"ɩ\x88S\x95\x8b\xd0vIoU\x0e\xb3Ђ\xc2`\xe6jJ\xadf\x9b9\xa9\xb4\x1c\x17\xb1\x18p\x91\xb9\xb3\xa7\b\x99t\x17\x10\x11Àˢ\xcdE\x1bQ\x9b\xd3\xe2A@o\xad\xf1$\xe3\xe2B\"\x9fR\n\xe5\xffH\x17\x9d.\xcfc\xf1\xb1\xcdj\xf2\x1e\xcc\xf2\x9eaݣ\x01\xd4/x\x10\x86\x90$o\xdb\x1a\x16\x17\x92\xf7K\xaa\v&\xdc,\xfe#\x91\xea#\xb7F\xcbч\xd6#\xa9;\vi=\xac\x90\x90\x9bm\x85\xd6zn\xd1(\x94\x16\x013\xb3\x18\xd3\"~R\xf8Z\x985\x8eQy\x00\xb0'N\x01\xbbI\a\x88:w̠i\xe2\x0eM\xc0no\xc4\xdf\xff\x13{oZ\xf6*_\xd8\xedI\xa5s\xc6\v\xd8\xe3ꆛ\xb6,\xe2Ag#\x8ed\xfe~;\v[\xcbfX\xfc\x9ei\x8a[\rN\xcd5\xa5Z\xfd\xb5\xa5R\r1fc\xa2\v\x18\x9b!jC\x93D\xc00\xe0\xb2\x18\xcf\xf2\xd4\x1e\x1f%\xd3\x16\x0f\x02zk\x8d'\x19'`\x92\x1e\xe2{\xa2m\x83ǩ\xf67\xcdj\xf2\x1e\xcc\xf2֨!\xd1VW\x8b\x1e\x04\x01kB\x8dL\xc0x\xbf$\x92\x97\xa9\xad\xb4\x93\xa8:\xb9\xa8\x9a\x88GRw\x16B\xcd\xc3\xc3\xc3-T\xc0\xb8\xdc\xec*4\xa9\xae\xba\xa8\xb7\b\x98\x99\xc5t\xb2\xf9\xf7\x88\xaf\x85Y\xe3\x18\x95\a\x00{\xe2\x140R\xa6Mf\x91\xcf\xff\xf1/R\x89\xd5'\x86>\xfe\xe9)q\x87\xf6,\xe4\x8b\xf8\xf4i\xfc\xac5ٝMX]8\xf6\x9a `\xea]\xb1I\x84\xe80\xb0\x01\xd5\xf6\x1b\x81c\x19f\xd4\xe6<\xad\x87\xc0z\x16\\S\x92%}\x11+\x1f\x99;\xba\x80\xb1Q\xd4 \xb2\xac\x8a0\f\xf8,&\xdb7\xe7\xa2\xccF\x8b\a\x01\xbd\xb5Ɠ\x8c\x130}2m8ӽ\xa7'\xb8\xce\x12\x99\x9b\xf7`\x96w\xad\xaaB%\x05\x82\aQ\xc0&\xf6L0\x01\xe3\xfd\x12ҭ\xafI\x91j\x86\x87\xd5\xe1\x9fx$ug\xdc\x1c\x18\x9f\x9bM\x85FT\xf7\xd6I|.\vm\x0elz@\xf4\x1b52\xb7\x90\x1b\x00\xd8\x12\xaf\x80=\x87\xb7ߡ\x9f\u007f\xa0K'\x8ejkU\xf7\xe27\xc4\x1d\x9a\x80]\xc4O=\x85/\xccJ\xf6\x82*j\xb7+\x05\x01[\xc5\xe6\xaf~\xa1F]\x1dC\xeeZt\x92p\x98\x17w\x95g\x84\xc1\x16:\xb1\xa6\xd4\xc1\xfa\x0euI\x97f\xd9\n\x06\xe6\xa6\xc4&\xdcڑe\xa5\x93a\xc0e1B\xbb2S\x9d\x8e6\x8b3\x1e\xbd\xb5Ɠ\x8c\x13\xb0rm#\xb7\x80Nk\x97[\x04\x8c\xf7`\x96\xb7\xdaÒx\xaa\x05\x0f\\\x16\x01u\x85\x03\x150\xde/\x913\xeb\xb3\xd5\x0e\xa7y\x8fV<\x92\xba3N\xc0\xb8\xdc\xec*4\x89\xd8\x1e\xeb$>\x97E\xc0\xc1z\xd4]hB\xa8ET\x01\x13r\x03\x00[\xe2\x15\xb0\xcb^\xfc\x822\x00\xbc\xb8\x89\x8a\xcf\r/~\x83\xad\x03+\xfeNܡ\xbf\x8d\xa2\xb2\xa8\xa8\xe2άd\xd7\xd6\xe3_\xdf!7\x0fZց\xe5)\nvR\xd2fJ\xeeG\x8eta\xad\x81yq\x0f \xb6о\x9e\xcd\xe8\x14\x16\x12\xf2-\xfb\xe1\x1b\xc9X\xb6\xcf\v\x98i\xc0mJ\x99StE\x925\x96\x9aa\xc0eрΰ]\xdb,\xce\xc8\xd8a]/\x8d\xd6\x1aO2N\xc0\xf4n\x8c\x9bJ\xc7L\x9eE\xc0x\x0ffy\xfb\u0604U'\xea\x13<pYp\x02\xc6\xfb\x9d.\xa8'\xdb|3F\x16\f\xe1H\x1a\xce8\x01\xe3r\xb3\xadP\x81[\xd1\xc7\xf0*\x8b\x80qYL\xa6\x97+C\u0099B\x8fX\x8b\xa8\x02&\xe4\x06\x00\xb6\xc4+`\xe4\xfcz\xec\xdd^\x89\xf1nz'\xf1|\x11\u07b8}\x13.:o١\v\xd8\x1b\x98=FdM\xf6q\x11.\xfb\x89\x17\xef\x13\x04̗\x9ar\x9f\x1b\xe9s\xf9Ǒ\xf0\x18\x91\x1aYl\xa4:%(\xd3 \xdc\xfe\x93\xbd\xd5\xe8\x04\xdd\xd1 5\xf7\xf8\xd2h\xe7\xedq}х`\xcb\x19p\x9b\x12\xca\xef:\x9e\xe3\xb4\xdeO4\r\xcc,\x1aP\xfa\x81\xbe\x9ej4(\x1a\x10Rj\fqG\xdaP\x8b:\x18\xb5O\xa6\xdbN\x0f\xb1[ylҮ\x01mn;\x9c\x8f\\MC|\xd1y\x0f\\y\xab\x92\x02}\x81\xa4*у\x99Ť\u007f\xdd7\xca\xd7o\xd6\xf9'9\xbf\x91`\xadk\x9c\\r\xee\nF\xe8J|\xa3\xdeFy9g\xc2J|#\xb7\x18\x15\xe2V\xe2\x87\x1c\xeeC\xf5\x19I\xc9\x1d!u%~K0xU8$\xe4\x8c\xe3\xfe\x8e^_r\x90\xaf\x05W\xe3X\x95\a\x00{\xe2\x160r\xed\x85\xca\"\xef\xf6S\xeaJ\x88\xcb\xcfV\x14\x95\x1d\xbclݡ\v\xd8\rs\x9a_H\xf6\xb7\x83e\xde\xed\x17>\x16\x04,0\xeaKs\xac\xed\u05feOI\xc2cD,\xb2X(M\xf9\x97\xdeh\x1cX\x97\xe1\xd4,#;2\x1c\x0f\x0e+\x1bߦVE\xb55\f\xf8M\xe9\xf1jgV\x95L,p\xb6F\x16'\n\x0f\xb9S2\v\a\xad\x06\xa4\xc3ծn\xdcJW\xb2J\x9d\x8a+\x99a;\xaa>DXB\u007f\x9ciɑ\\\xfe\x0e\x8fT\xc8\x17\x9d\xf7\xc0\x97\xf7X\x9e\xb6\x0e\x8c\xf3`fр\x10\x9dj\xdaF\x9fg4\xfd\x0e(\x86ud\x87\xf2\xefY\xfa,\xa4:\x85Η\x97s\xa6>\v\xa9\xf8a\xb3\xf2zn1*4\xca=\v\x19.\xcd\xc8\xdeӑ\xac\x14\xbdZ\x9b\xf8\xf2\xf3Y\x10\xfa,\xa4#\xb34$Ԃ\xabq\xac\xca\x03\x80=v\x02\xb6\xd4\\\x8a\xe31\"\x81\xc0|\x16x'Z\xa4\xebD+/\x00,1+M\xc0\xea\xd1<C\xdb\xd6Ԑ\xf81\x05!2\xa6\xb2\xe8\xcf\xf6,* `\x000'+J\xc0Bc]\xab\xa4Y\x03\xbcE\xc4\x14\x84\a\xb5юu>\u007fe\x01\x02\x06\x00s\xb2\xa2\x04\xac\\Q\x94\xbb\xd8d\xd5\xd9b\x95p\xaf\xca<ƟK\x0e_^\x00\x00\xa2\xb0\xa2\x04\xac)\xd55\xcf\x01\xe4\xbc`\xb3\xc5cvV+\x87D+/\x00,9+J\xc0\x00\x00\x00\xe6\x03\b\x18\x00\x00\t\v\b\x18\x00\x00\t\v\b\x18\x00\x00\t\v\b\x18\x00\x00\t\xcb\xe2\n\x98\xfe(\xd1\xdc܍\xb8\x90\x00\x00\xfc\x00\x01\x01\x03\x00 aY\\\x01\xbb\xfc\xeb\xf3v&\x04\x04\f\x00\x80Ebq\x05,>@\xc0\x00\x00X\x14\xee\x15\x01\xdb6\x9fg\xba\x01\x00\xb87\xb0\x13\xb0\xdf\xe0S\x17*\xbd?\xb9Fȍ\x17+\x8b6\xed\xbd\xa0\xfe|\xedH\xe5\xfaM\xfb\xd4W\xdcs;\xe8\x1c\xd8\x1b\xfa<س쥆B\xb2\xcf\xf7n*~\xea\xa2E\xc0\xc2\xe5NG>\x8daӂr\xd5\x1f\x0f\b/5\x8c\x870\n\x90Z\x94\xd4eg\xb7x\xf4$k\x8f\x83'wۙ\xce\xcbv\x81\x1cB)\xf4\x95\xb6}\x0et(\xbaA?+@\xc6C1\x1f\xfeT\xdf\av\b\xa9\xef\x03\xb3a\x84{\x1f\x98\xc2X\n;u\xf4}`\x8e(\x19\x84|i\x99\xfe\xc1L>V\v\x00,\n\xf6\x02\xf6\xa2\x17\xe3\xe2\xdb\xe4B1\xf6n\xad\xc4\xf85\xfa\xeby/.\xde^\x86Yl\x0f~\a\x15\xb0\u007f\xe0\"\x16|\xe8v1}\xa9\xa1\x90\xec\x14\xc6\x15[\x8b\x8av\v\x02\x96\xebD\xb9\x1e\x84\xca\t\x99HѢB{\x84\x97\x1aF\xe5\xac\x18\x97\xa3jշ\xf4\xd9g\xeeIp\xce\xc0b;\x9b\x85\x184\"\xed\xf5\xa3(v\x04\n=Y<\xb6\vD\xcfb\xc2\xef\xf0)\x1f>\x88\x9f\x8f(\x00\x00\ttIDAT\x87\u007f\"\xba!}#kp\xf0\x98G\f\x8a\xc9!\xbc\x915\x06\xc6q\xe0\xde\xc8\xca\x18b\xef\xc4god\x9d\xfd\xf8\xf9@ښ\xe3\x9dyh>/n\x03\x80\xf8\xb0\x170\\y\xfe\xc2ir\xa3\x18\x1f\xbd\xadt\xa16\xd10C\xdf\x15\xe3\x97\xd9;\xf1\xbdߋ;\xd8]ȝ4\xae-\x8d\xfe\xb8\x95\x88{/\xe2\aN\xdf!\xdf?ey'~\xb6Ҥ\x06\x1c46D\t\xa21\x1d\xc8H\x1c/5\\\xe3翅\xd5\xf0\xb8\xfc\xdbg8\x03\xd16\n\v1h\x91\xb4\x17\xc0\xa7\xf2Q,E\xf4d\xf1\xd8.\x10\xa3d\x81\x12\xc7\x14\x99t\x94\x04b\x9a\xb2\xa33\xe5\x16b>\xf1\b\x91\xb9\xa3\xc3\x1f\x87aA\xaa\xacQ\x898&\xd3K#\xf4\xcd\xfe `\xc0\xe2\x13\x87\x80\xb1\x97C\x1f\xc5{\xd9\xf7\xf7\xf1\x8f\tyY\r\xd7Mv+R%\xec`\x02vZ\xdd{\x10\x9f\xb2$;\x88\x8f\xd2\xed\x9be\xa2\x80\xb1\x06s\fe+C-U\xb9v\xa1حPG\ftV\xad\xbeE\x8c\x17\xb0\xa8a\xd5b\xb0\x10\x83HXk\xad\xe1\xd8\xefDԓ\xc5c\xbb@\xb8\xb0j\xbe.r\xc2\xe7\xb7\x110Ґ:\x13c\u007f\x1c\x02\x16=N\x1ce\x0e\x01\v\xa4\xb2\xb1c3\b\x18\xb0\xf8\xd8\vX%\xfb|X\v\xf0x\x9b\x86\xaaݢ}\xb9q㎸\x83\t\xd8\xcd\"\xfcO\xe5_/\xfd\x97\xdf{g#\xbeȾ\x1c\x15\x04l-\xfb\x9cJR\xae\uf213^\xfe3.\xf3R\xafE)\xedu9\x0e\x9f\x1aO\xe3DAZ\xce\xe3\xb7\b\xe9զ\x94\xf25\xab\xb1\xe4]\xecSڣ\xd9r\x06\xdcf-Jn\xadqg\x94\x8a\rIt\xa6gAH\xd0\xe7Nq\x95d\xcf\xce\xcd\xc4l\xad\xf6\xc94\xdb\xd1d\x84\xea\xc3Uَ\r\xd3djs\x96\xe4.\x1d%\x96j\x1a\x1e\xc4\xf2\xb6\xe5k\xef\xc47=\xf0Y\x04\xfcm\xe5\xa4\xe4\x15*`\xa6\xdfP2\x8d\xcc\xe8F\xc8\x19\xd1\x05\xac19\u0095\x97/\x8e `zn\xb6\x15\"D\xae\xcar\x96[êq\x87D\x8b\v9\xd1\x1c\xe1\xfcr5\x8e^y\x00\x88\a{\x01cݩ\x9b\x18o\xd9\xce(\xc2\x17\xc8z\xfc7}\xbf\xb8C]Ⱥ\x8f\x8e!ߧ\t\x85\xbd\xdfc\xac\x86\xf68-\bX\x9d\xba\x91M\xe3\xcdoC;hD\xae<cw\xa83\x19\xb9\x1a\x9a\xd3Y\xec\u009a\xa4\x1d}\xad\xae\xfc\x19r+\xc8b\xe9\x04u%\xaa\x91T\x81\x93Pngo\xa6b\xcb\x19p\x9b\xd4Y\xf6\xe1\x9fg\x8b\xd3@\x823#\ve\x1c\xfbh\xf7@\xbb\vM\xcf\xca\xcd\xc4h\xadq$\xd3l#';\xb3s\xd2\xdduU\xe8*\xe9C5\x83'K\x93\x86\xc5j\x9a\x1e\x84\xf2VK\xf5}\xf5R\x95\xe0\x81\xcf\"\xe0\x1fO\x9b\\%S\x013\xfd\xce\f5$\r\x91\x0et\x82\xaa\x99*`\xf9y|y\xf9\xe2\x84P_$\x12\xe9GBn\xb6\x15\"agNG\xaf\x0fY\x05\xcc\xcc\"\x89\x1b7\x1b~\xb9\x1aG\xaf<\x00ă\xbd\x80\xb1\xa8D\xdfa\x93\x8f\x95\xee\xd4\r}\xbf\xb0C\x13\xb0\xf3x7!O\xe1\xf7-{\xafa\xac\xa69/\b\x98\x16Om5\xea&d\b\xb9f\x88\x1f\xf13E\x92S\x11\xa7*\x17\xa1\xed\x92ު\x1cf\xa1\x05\x85\xc1\xccՔZ\xcd6sRi9.b1\xe0\"sgO\x112\xe9. \"\x86\x01\x97E\x9b\x8b6\xa26\xa7Ń\x80\xdeZ\xe3I\xc6ŅD>\xa5\x14\xca\xff\x91.:]\x9e\xc7\xe2c\x9b\xd5\xe4=\x98\xe5=úG\x03\xa8_\xf0 \f!I\u07b65,.$\xef\x97T\x17L\xb8Y\xfcG\"\xd5Gn\x8d\x96\xa3\x0f\xadGRw\x16\xd2zX!!7\xdb\n\xad\xf5ܢQ(-\x02ff1\xa6E\xfc\xa4\xf0\xb50k\x1c\xa3\xf2\x00`O\x9c\x02v\x93\x0e\x10u\xee\x98A\xd3\xc4\x1d\x9a\x80\xddވ\xbf\xff'\xf6\u07b4\xecU\xbe\xb0ۓJ\xe7\x8c\x17\xb0\xc7\xd5\r7mYă\xceF\x1c\xc9\xfc\xfdv\x16\xb6\x96Ͱ\xf8=\xd3\x14\xb7\x1a\x9c\x9akJ\xb5\xfakK\xa5\x1ab\xcc\xc6D\x1706CԆ&\x89\x80a\xc0e1\x9e\xe5\xa9=>J\xa6-\x1e\x04\xf4\xd6\x1aO2N\xc0$=\xc4\xf7D\xdb\x06\x8fS\xedo\x9a\xd5\xe4=\x98\xe5\xadQC\xa2\xad\xae\x16=\b\x02ք\x1a\x99\x80\xf1~I$/S[i'QurQ5\x11\x8f\xa4\xee,\x84\x9a\x87\x87\x87[\xa8\x80q\xb9\xd9UhR]uQo\x1103\x8b\xe9d\xf3\xef\x11_\v\xb3\xc61*\x0f\x00\xf6\xc4)`\xa4L\x9b\xcc\"\x9f\xff\xe3_\xa4\x12\xabO\f}\xfc\xd3S\xe2\x0e\xedY\xc8\x17\xf1\xe9\xd3\xf8Yk\xb2;\x9b\xb0\xbap\xec5A\xc0Իb\x93\b\xd1a`\x03\xaa\xed7\x02\xc72̨\xcdyZ\x0f\x81\xf5,\xb8\xa6$K\xfa\"V>2wt\x01c\xa3\xa8AdY\x15a\x18\xf0YL\xb6o\xceE\x99\x8d\x16\x0f\x02zk\x8d'\x19'`\xfad\xdap\xa6{OOp\x9d%27\xef\xc1,\xefZU\x85J\n\x04\x0f\xa2\x80M\xec\x99`\x02\xc6\xfb%\xa4[_\x93\"\xd5\f\x0f\xab\xc3?\xf1H\xeaθ90>7\x9b\n\x8d\xa8\ueb53\xf8\\\x16\xda\x1c\xd8\xf4\x80\xe87jdn!7\x00\xb0%^\x01{\x0eo\xbfC?\xff@\x97N\x1c\xd5֪\xee\xc5o\x88;4\x01\xbb\x88\x9fz\n_\x98\x95\xec\x05U\xd4nW\n\x02\xb6\x8a\xcd_\xfdB\x8d\xba:\x86ܵ\xe8$\xe10/\xee*\xcf\b\x83-tbM\xa9\x83\xf5\x1d\xea\x92.Ͳ\x15\f\xccM\x89M\xb8\xb5#\xcbJ'À\xcbb\x84ve\xa6:\x1dm\x16g<zk\x8d'\x19'`\xe5\xdaFn\x01\x9d\xd6.\xb7\b\x18\xef\xc1,o\xb5\x87%\xf1T\v\x1e\xb8,\x02\xea\n\a*`\xbc_\"g\xd6g\xab\x1dN\xf3\x1e\xadx$ug\x9c\x80q\xb9\xd9Uh\x12\xb1=\xd6I|.\x8b\x80\x83\xf5\xa8\xbbЄP\x8b\xa8\x02&\xe4\x06\x00\xb6\xc4+`\x97\xbd\xf8\x05e\x00xq\x13\x15\x9f\x1b^\xfc\x06[\aV\xfc\x9d\xb8C\u007f\x1bEeQQŝYɮ\xadǿ\xbeCn\x1e\xb4\xac\x03\xcbS\x14줤͔\u070f\x1c\xe9\xc2Z\x03\xf3\xe2\x1e@l\xa1}=\x9b\xd1),$\xe4[\xf6\xc37\x92\xb1l\x9f\x170Ӏ۔2\xa7\xe8\x8a$k,5Àˢ\x01\x9da\xbb\xb6Y\x9c\x91\xb1ú^\x1a\xad5\x9ed\x9c\x80\xe9\xdd\x187\x95\x8e\x99<\x8b\x80\xf1\x1e\xcc\xf2\xf6\xb1\t\xabN\xd4'x\xe0\xb2\xe0\x04\x8c\xf7;]PO\xb6\xf9f\x8c,\x18\u00914\x9cq\x02\xc6\xe5f[\xa1\x02\xb7\xa2\x8f\xe1U\x16\x01㲘L/W\x86\x843\x85\x1e\xb1\x16Q\x05L\xc8\r\x00l\x89W\xc0\xc8\xf9\xf5ػ\xbd\x12\xe3\xdd\xf4N\xe2\xf9\"\xbcq\xfb&\\t\u07b2C\x17\xb070{\x8cȚ\xec\xe3\"\\\xf6\x13/\xde'\b\x98/5\xe5>7\xd2\xe7\xf2\x8f#\xe11\"5\xb2\xd8HuJP\xa6A\xb8\xfd'{\xab\xd1\t\xba\xa3Aj\xee\xf1\xa5\xd1\xce\xdb\xe3\xfa\xa2\v\xc1\x963\xe06%\x94\xdfu<\xc7i\xbd\x9fh\x1a\x98Y4\xa0\xf4\x03}=\xd5hP4 \xa4\xd4\x18⎴\xa1\x16u0j\x9fL\xb7\x9d\x1eb\xb7\xf2ؤ]\x03\xda\xdcv8\x1f\xb9\x9a\x86\xf8\xa2\xf3\x1e\xb8\xf2V%\x05\xfa\x02IU\xa2\a3\x8bI\xff\xbao\x94\xaf߬\xf3Or~#\xc1Z\xd78\xb9\xe4\xdc\x15\x8cЕ\xf8F\xbd\x8d\xf2r΄\x95\xf8Fn1*ĭ\xc4\x0f9܇\xea3\x92\x92;B\xeaJ\xfc\x96`\xf0\xaapH\xc8\x19\xc7\xfd\x1d\xbd\xbe\xe4 _\v\xaeƱ*\x0f\x00\xf6\xc4-`\xe4\xda\v\x95E\xde\xed\xa7ԕ\x10\x97\x9f\xad(*;xٺC\x17\xb0\x1b\xe64\xbf\x90\xeco\a˼\xdb/|,\bX`ԗ\xe6Xۯ}\x9f\x92\x84LjXd\xb1P\x9a\xf2/\xbd\xd18\xb0.éYFvd8\x1e\x1cV6\xbeM\xad\x8ajk\x18\xf0\x9b\xd2\xe3\xd5ά*\x99X\xe0l\x8d,N\x14\x1er\xa7d\x16\x0eZ\rH\x87\xab]ݸ\x95\xaed\x95:\x15W2\xc3vT}\x88\xb0\x84\xfe8Ӓ#\xb9\xfc\x1d\x1e\xa9\x90/:\xef\x81/\xef\xb1<m\x1d\x18\xe7\xc1̢\x01!:մ\x8d>\xcfh\xfa\x1dP\f\xeb\xc8\x0e\xe5߳\xf4YHu\n\x9d//\xe7L}\x16R\xf1\xc3f\xe5\xf5\xdcbTh\x94{\x162\\\x9a\x91\xbd\xa7#Y)z\xb56\xf1\xe5\xe7\xb3 \xf4YHGfiH\xa8\x05W\xe3X\x95\a\x00{\xec\x04l\xa9\xb9\x14\xc7cD\x02\x81\xf9,\xf0N\xb4H\u05c9V^\x00XbV\x9a\x80գy\x86\xb6\xad\xa9!\xf1c\nBdLeџ\xedYT@\xc0\x00`NV\x94\x80\x85ƺVI\xb3\x06x\x8b\x88)\b\x0fj\xa3\x1d\xeb|\xfe\xca\x02\x04\f\x00\xe6dE\tX\xb9\xa2(w\xb1ɪ\xb3\xc5*\xe1^\x95y\x8c?\x97\x1c\xbe\xbc\x00\x00DaE\tXS\xaak\x9e\x03\xc8y\xc1f\x8b\xc7\xec\xacV\x0e\x89V^\x00XrV\x94\x80\x01\x00\x00\xcc\a\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x16\x100\x00\x00\x12\x96\xff\x0f}\xc6-\xc8\xe3>\xf6\xcf\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/chan2a.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x04\x89\x00\x00\x01\x95\b\x03\x00\x00\x00M@Q-\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\n\x03\x01\x04\x06\x02\a\n\x06\x0e\x10\r\r\x12\x14\x0e\x12\x1d\x11\x13\x10\x16\x18\x15\x1b\x1a\x13\x13\x1e7\x1f\x1f\x18!# #$\"%$\x1d%%\x1e$%#%'%'(&+)\x1e()'*+)/,!+-*,-+-/,02/63(241564796<9.9;8<=;=>FA?3>@=#CxDA5AB@DFCFHEKH<MH7IKHKLJNOMUP?PROSTRUVTWXV]XG<Z\xa5_ZIY[Y,`\xae7]\xad[]Z\\^[9a\xab;b\xac<c\xad_a^faO]ao>e\xafac`hcQbdaAg\xb2efdCi\xb3ghfMj\xafEm\xb1qjRikhIp\xb4lmkLr\xb7npm{s\\rtqWv\xb6tvsuwt\\z\xbaxzw]~\xb8e|\xb8\x84|dX\x80\xbf{}za\u007f\xbf|~{~\x80}b\x82\xbc\u007f\x81~d\x85\xbf\x82\x83\x80\x83\x85\x82m\x87\xbdh\x88Ð\x86hj\x8ać\x88\x86r\x8c\xc1\x89\x8b\x88t\x8eė\x8do\x8c\x8e\x8bz\x8f\xc0\x8e\x90\x8dx\x92Ȑ\x92\x8f~\x93\xc3x\x95Ē\x93\x90\x81\x95\xc6{\x98Ȕ\x96\x93\xa0\x96w\x96\x98\x95\x82\x9aė\x99\x96\x83\x9cņ\x9b̀\x9d̚\x9b\x98\xa5\x9b|\x87\x9fɃ\xa0Ϝ\x9e\x9b\x89\xa1̞\xa0\x9d\xaa\xa0\x81\xa0\xa2\x9f\xa1\xa3\xa0\xa2\xa4\xa1\x91\xa5ʮ\xa4\x85\x8f\xa7Ѥ\xa6\xa3\x94\xa7̥\xa7\xa4\xb4\xa7\x83\x92\xaaԧ\xa9\xa6\x97\xabЩ\xab\xa8\x9d\xad̫\xad\xaa\xa5\xad\xc1\x9f\xaeλ\xae\x89\xad\xaf\xac\x9e\xb1ע\xb1ѯ\xb1\xae\xa5\xb4Ԣ\xb5۳\xb5\xb2ö\x91\xb5\xb7\xb4\xac\xb7ҩ\xb8ط\xb9\xb6\xb9\xbb\xb8\xad\xbcܱ\xbc\u05fb\xbd\xba\xb3\xbeٽ\xbf\xbc\xb7\xbfԱ\xc0\xe1\xbf\xc1\xbe\xb6\xc1ܹ\xc1\xd6\xce\xc1\x9b\xc1ÿ\xbb\xc3\xd8\xc2\xc4\xc1\xbd\xc4ں\xc5\xe0\xc4\xc6\xc3\xc6\xc8\xc5\xc0\xc8ݽ\xc9\xe4\xd8ɞ\xc6\xca\xda\xc0\xcb\xe6\xca\xcc\xc9\xc3\xceܿ\xcf\xe2\xc8\xcd\xdc\xcd\xcf\xcc\xc8\xd0\xe6\xcc\xd0\xe0\xcf\xd1\xce\xc6\xd2\xe0\xdbҥ\xe1ѥ\xd1\xd3\xd0\xd2\xd3\xdd\xd3\xd5\xd2\xcd\xd5\xeb\xce\xd7\xdf\xe6\u05eb\xd6\xd8\xd4\xd1\xda\xe2\xd8\xda\xd6\xd8\xd9\xe3\xd6\xda\xea\xd3\xdc\xe4\xda\xdc\xd9\xd8\xdd\xe0\xd2\xde\xec\xdc\xde\xdb\xdc\xdd\xe7\xe0\xde\xe2\xdb\xe0\xe2\xde\xe0\xdd\xf0\xe0\xb3\xd5\xe2\xf0\xe0\xe2\xdf\xde\xe3\xe5\xde\xe2\xf2\xe2\xe4\xe1\xe1\xe6\xe9\xe4\xe6\xe3\xde\xe7\xef\xe8\xe5\xea\xe5\xe7\xe4\xe4\xe9\xec\xe7\xe9\xe6\xe8\xe9\xf3\xe2\xeb\xf3\xe9\xeb\xe8\xec\xee\xea\xe6\xef\xf7\xe8\xf1\xf9\xef\xf1\xee\xf0\xf0\xfb\xf2\xf4\xf1\xf1\xf6\xf9\xf4\xf6\xf3\xf7\xf9\xf6\xf5\xfa\xfd\xf9\xfb\xf8\xfa\xfc\xf9\xfd\xfb\xff\xf9\xfe\xff\xfc\xfe\xfb\xfe\xff\xfc\xfa<^\xc5\x00\x00 \x00IDATx^\xed\xbd\x0fX\x15\u05fd\xef}^\xdb\xf7\xcd\xed\xdb\xc5y`\x1f\xe9\x16\nD\xde\xcb{\xc0s\x94\x83xߛ\x8cA\xbc\xafy\xfd\xcbE\xe5`Qo\x8f1\xb4\xc46\x86T\xebc8\xf14\x98\xee\xa6H\x11o\x12RJ\xbc\x1e\"\t\xdd\x16\"\xd1Rk$\xec<MHKbO\tI(m\xec\xb17x5h\xaa\xd3\xd4\x1eBD=>\xf3\xbc\xb3\xe6\xefZ\xb3g\xefa#\xcc\xf0\xe7\xfbɓ\xbdמ\xf9\xad5k\x96{\xbe\xac\xb5f\xf6\xfa\xfe\x854vD\x00\x00\x18\x17\xfe\xc2In\xa2\xe0T6\x00\x00\x8c\x0e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11и\xec\x14\x00\xc0\xc4\x01%\x02\x94\xbe\xa2T\xb2\xdc)\b\x80\tc\xda+Q}N\x9fSH\x8c\xf4\xe7\xd4;\x85LB\x94v\x88\\\xf5\xac\xac@\xd3\xe9\b\xfb\x00\x98x\\W\xa2\xe6\x10}\xbdT]\xa9R\xa3n\xed\f4D\xcb$\xfe\xcfG\xd7\xe4o\xbb\x125Ğ\x1dd\xbbSH\xcc\xec\x88\xdb\xe1\x14\xe2D\xe7b\u007f\xda\xea\xe6\xb4>q\x1d!\xc4ߥonJ\x89\xde\f\f\xf5Y\xb3\xe7\xd5.\x18u\xb8\xd6\x0e\x91\xaa~\x8a4\xdan\a\xc0%\xdcV\xa2\xbe\xca6\xfav\xbe\xb2\xbdW\xe6X\xe5)e\xeb\x99@Ku\xb4\\\xe2W\v\x0e\xef\xce\xff j\x88-\x15qUN!c\xa0!\xbe\xc2)Ġ\xb9\xddfc\xa3?;\xb0\u007f>!!\xb1'\x18\xdcCZ\xf5\xed\r\xfe\xa7l\xa2M\xcc\xc2*Ha\xfd\x16BF[\x0f\xa3\x1d\"T\xbd\x8d\x04\xed6\x03\xe0\x16.+Qo\xad\xaaDb\xe7\x80\xfc2PݢnnhꉪD\x1f\b\x87\xc4+\x17\xa2E\xd8\xd3\xed\xbb?z@\u007fn\u007f\xf4\x00{\xca|=N!:\xd9+÷\xf5'\xdd;(\x9f}\x06Q\xfa\x87m\xa6\x129a\x14\xd6E\xca\xe4\xd7M\xa3U\"\xa6\x1d\xec\xab\x1eC\x1d\x00\x98\b\xdcU\xa2\xe6\xca\xe6@\x9b\xf9\xf1\xe0S\x97\x94\xf7Ϊ\x81ިJ\xf4\xaep4\xda\xee\x88\x14\xa5\rD\x0f\xe8$\x9d\xd1\x03\xec\x19H+r\n\xd1Y`\xa3D\xf7'*sW\x15D\x19\x96Š\x02Fa\x85)\xb2\x94\x89!\xb2'Z\xb4\t\xd3\x0e\xf6U\x8f\xa1\x0e\x00L\x04\xee*\xd1\xf9\x01\xb1\xba\xcd\xf8\x14\xaaT'\x93\xcf\x06\xba\xc4(Jtq\x8d\xa0\xb0W\x14\x1f\x15\x84#\xe2\xbby\xc2\x06\x9a\xcc;\xbcwC\xfe\xb6\xdf(1\xef>\xb4&\xaf@K\x9b\f&mՓ]+S\x12R\xef\xe9\xe5vWd6\x84H\xa8!s\x0f_\u0095Û\xf37\x1e\xba\xc2\x1d\x82?\x9aܳH<\xcf\x15%\x16\x93\x84\xc0\xa6L\xff\xe2\x1e\xe5Ӟ\x05\xfe\xf9\xb4\xd4\x06\xa2\xb2@\xd9Z\x9d\xe3\xcf\xdcD%!C\x15\x83\xfe\n*'\x86\n\x9cI$$N\x9b73b\x99r\xd9\u0092\xd5\x13\xab8\xcd\x1e\x8d\xaf\x83q4\xae\x1dl\xaaNi\x86\x12\x01oqW\x89d\x18%\xaamR\xdf\x1b\xe4\xf7h}\xa27:\x8e\b\a::\xde\x17\xc5\xdft\xe4\x1d\x10\xaf\xbc\xfa\xc8\x12Q|\xebH\x9ePp\xe0\a+\x1e\xa2\x11//\xdb\xfc\x83\x13\a\x84g-\x19\xdbI\xb3\x96j\x9e\xb3`G\xd3v\xcb`\xa6\xb7\x90d\x91yde\x0f_\xc2\xee%\xfb\x8e\xef[\xb2\x9b;\x04w4\x99\x16\xeb\x95\x1b\xaa\x89')\xdb+\x92\x94;\xe1\xeb|e\re\xbeB\xb9\x03\xd2\x12\xcc\\\x18\f\x06\x95QXQ\\ICEʂ\xcb\xe2`\x1cW\x0f\xa3?r,\x18\xf4i\xf3\xebF,S.S\xd8\x19\xc2L\u007f\x19G\xe3\xea`\x94 \xb2\xed \xdaT]\xbc\xd4ל\x9d\xec\xd0y\x04`b\xf1P\x89\xba+{\x94\xf7P\xd5@t%bGgK\x0e\xc8/\a\x96(\xc9\x15r\x0feg\x81\x9c\xba\xb8v\xdbE\xf9\xf5\x88uJ\xbb\x81t\xab\x89\xf3s\x17\xcbݏ\xc1Z\xeb\xa4Pc\x02I8(\xf2%\x1c\x17N\xc8\x1bN\b\xc7E\xf6\x10lR\xa6\x87\x84M-\xfb\x92{訉\x96\xaa܈j$J\xc9ƀ\xaaAQ\x8f6\xb2_\xec&ܽtvd\x94\xb8\xdd\x12˖k\x16֩\xde\xea:\u007f~\x90?\x9a\x19˖`\xb6\x03%\xbc\xea\xf7\xca\x1d\xadQ߄\x03`B\xf0P\x89\x9aj\x95\xb7\x81@\xe8\xf2\xe5˧\xab\xa3=\xe2k\xafD\xbb\xf5\xe4q\xe1\r\xdbl\xf5\xfa\x15x\x90\x9c\xb4\xd9ݿ\xc97\x97\xa4\xf9\xb6\xf4s%\xecޠ\xbcmxDd\x0f\xc1&Ez9\xef\xb7\x14&\xfa\xd6\xc9/\xdb}\xf2K\xd1<eC\x16\xdd`*\xd1\xea\x8c\xc1K2s\x8b\xc4\xc1x\xfb>\x91h(\x91\x19˖k\x16vVљղ\x824qG3c\xd9\x12\xccv\xa0\x84W\xfdtce\x16\xfaD\xc0[<T\xa2\xaac\xca[w\xa5\x0e?\x8b\xc3b\xafDF\xf2Y\xe1\xa2m\xb6V\xfd\x1a\xaf 6s#⎔\xca\x10\tU\xa4\x94s%\x94nS\u07b6m\x16#\x1c\x8d\xd2FZ,\x85\x89\xca\xc0JQ\x81\x85K\x95\r\xf7\xe4\xd0WC\x89\xe6k\xd3<\xf7\x1a\xf3D\x83\x8dZYaJ\xc4\xc42\xe52\x85\xa5Љ\x9f\xbe:r\xff w43\x96-\xc1l\a\x8aM\xd5E1H\xda\xc27\x02\xe0\x1e\xde)Q\u007f\xa5\xf6\x87\xba\xbfO\xa6\xb3\xaa/ʳ\xd0\x16%\xdagц\x13\xc2/l\xb3\r\xe8\xd3.M\xc4\xee\xa9\x1eqP\xb9wF\xa7\x8d\x99\x12v\xaf\xa7OP^YO\xfb@\x11\x95\xa8\xdcw\xd6Z\x98\xa9\x02E\x19ʆ\f\xb3O\x148-\x0f\x9a2\xda\x15\xfa\x8d{g\xb5Dy\xb3Q\"&6\\\x89\x94\xc2Ri\xad\xeb\xe8\xc4\x17{43\x96-\xc1l\a\x8aM\xd5q\xef\fx\x8ewJ\xd4]y\x86\xd9<\xday\xa2\xfc\xbd\xb2J\xfc7\x8b6\\((\xa5]\x9a\xc7\xf6Z\xf3\xad\xccP\xc7|\x03i\xb9\xf4\xca-\xd9d\r\xe8\xa1\x13+\"W\xc2qሜ:\xa2\xce\x13EP\xa2\xcbY\xf7XKbT\xa0A\x19\xff\xecW\xe7^rs\xe5\xce\v\xa9\xa539\xb5\xf4sY9}\x9eh\xb9\\\x9d˹\xaa\x86\xd8(\x11\x13\xcb)\x91QX\x97\xf2\xc8t.U\"\xf6hf,[\x82\xd9\x0e\xa2}աD\xc0s\xdcU\xa2\xf3\xbd\xbdUͽj\xe7'T9hl\xbf,\xf7\x89z#>c\xa8\xde;{\x95vU\xc4҂\xa7\x9f\xde,\xe4=\xff\xd6\xfb\x1dy\x8f\xbcz\xe5\x8dG\xf2\xe8=\xb5\x97\xf37\x1c>\xfe\x98pؚ\xb3K\xbfK\xd5<;\xeb[\aKH\xc0\x1a`\xc0\x94\xb0Sx\xe2\xa5'\x84\x9d\xa2\xc8\x1c\x82;\x1a\x1d\xedY\xfbX\xbd\xc1\x84u\xadb\xfb\xba\x84\xa0<\xc6,\x8c\xbb\xbf\xe1\xfe\xb8Be\xc7v_E\xfd\"\u007f\x8f\x9c\xba\x9f\xac\xae\xad/\"Tr\x1b\xfd9U\xf5w\xc5\xcb\xc3$\xe5\x19\xeb\x8a`P\xee\xe7\f\xb6\x06\x83\xbeu\xc1\xe0Y6\x96+\x97)\xac\x82\x145\x14\xa9\xcfX\x1bG\xe3b\x99\xa31\xed`Wu\xca1\xbb!\x1b\x00\xee\xe1\xae\x12\x1dS\xe6\x83\x02\xca𠛹\x85\xd3\xcb\xfc\x04-\x8c\x8b+\x94lj\xf2ަ\x1f\xde-\xcd_\xb6m\x9f <\xfa(\xdd\xf4\xcbe\xf2\xeb\xa3\xf2\xe6\xb7\x1f^\xbbl\xb3\xdeob(\x9b\xad]a]+\xe7&\xe5ԅ\a\x18\x98%\\9\xb4Q\u007f\x9e\xc88\x04\u007f\xb4`\xe2\x16k\xf6bBHB\xa7_~-\x96?U\xccW\x9f\xf0\x91\x19,IN\\ئ$\x1bsS\x92\x17*7\xd4\xc4λ\xfc\xa9K\xe9C\x95\xeb\xb4\xf9\x1cy\xd8\xd5\x16\xa7&+\xd9X\xbe\\\xa6\xb0\xfa\xacĜ\x83s\x95\xd2\xf4\xa3\xf1\xb1\xccјv\xb0\xa9:\xa5/~\xe5\xa9>,\v\x02\xbc\xc3]%r\x9fM\xbeZ\xa7\x90\x98\xd9\xef+\xba\xe4\x143\xd9\xd0\xda!b\xd5보\xd9m\x00<a\xba+\x91X1w\xdcW\x05I\xbb\xed\x9f\xe2{\x80\xd2\x0eѪ\xdewj\xbc\x1b\n\x80\xd13\xed\x95\b\x000\x05\x80\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x91\v\x1c\xdd\xfc\xfb\xa9jb\r\x80;\xb8\xaeD\xe1n\xd4竔T\x95\xb9\\Ѥ\xe6\x17t\x89\x92\xddQ\x02\x0e\v\xcaZk&O\v\a\xe8\xdaJ\xe3`b\r\xc0t\xc5m%\xb2q\xa3>Sy\x92\xa6\xa7\xca/\xc1\xff\xf0\xeaƍ\x1d\xbf\x8e\x12\xf0A\xc7\xe6\x03\xec\xe7C\xc2\xf3j\"\x16\x13k\x00f\x16.+\x91\x9d\x1b\xf5\x99\xca\xd3ѲL>\xbeZ\xea\x10\xb0\x8dU\xa2w\xf3\x9eГ1\x98X\x030\xb3pW\x89lݨ\xa7\xb9\x12\xed.\xb8\xa0'c0\xb1\x06`f\xe1\xae\x12ٺQ{\xa8D\xe1&\xd6\u007fX\x93\xb7om\xc1ˏ\xad(\xbd\xc0z_s0Jd8Ws\x85\xc9J\xf4\x98 \b\xf9\xbf\x93\xd3\x17\x971\xeb\xfc\xdb:A\x03\x00\\V\"\xd1\u038d\xfaLe\xd3S\x955A\x0f\xaeQ;\x13\xeb\x97W\b{K\x855O\xafy\x96\xf5\xbe\xe6`\x94\xc8p\xae\xe6\n\x93\x95\xe87;\x85g_\xa3\x9b\xdf\x10:̜\xe1N\xd0\x00\x00\x8a\x87J\xa4\xbbQ\x9f\xad\xac>\xd5\x13\xaa\xdd\xef\xfa\xbd3{\x13낝\xe2qᨸ\xdb\xe2w\xc6`*\x11\xe3\\\xcd\x16&+ѳK^\xd2C\xde6sژX\x03\x00DO\x95Hs\xa3\x16\xc5N\xda\x1d:_\xe5zw\xc1\xdeĺ\xe0\x88\xf8\x9apA|b\xa7\xe8\xacD\x8cs5[ض\x03\a\f\x83\xb6\xa3»fN\x1b\x13k\x00\x80\xe8\xa9\x12in\xd4:\xc1h\x1e@\x13\x82\xbd\x89u\xc1q\xf1\xb5<qtJ\xc48W\xb3\x85m+X\xb1\xe1!u\xf2H|Ux\xd5\xcci\xeb\x04\r\x00\xf0P\x89\f7\xea&\xc5+Uln\xb0\x8d\x9f@\xecM\xac\vN\x88\xaf-a\x95h\x9f\xbd\x12]8\xf0\x01\xeb\\\xcd\x16\xb6\xad\xe0\xadwWh\xb3O\x17\x9607\xd2l\x9d\xa0\x01\x00\x1e*\x91\xe1Fݠt\x86\xfa\xabN\xdag\x988x\x13\xeb\xee\x1d\xaa2\xb2J\xc4x_\x9b\x01\x9a\x12ѩhƹ\x9a-\x8c\xde\xc5?\x9e\xf7\x9a\x1a\xfd\xf0\x86+\xfa\x01흠\x01\x00.+\x91\xad\x1buO\xa0\xb1\xeb\xf4\xb1\x80\xeb]\"\x8b\x89\xf5R\xa2\xc8\xc4[\xab\x9e\xbdp$\xef\xad\v;K\u007f\xc3x_3\x01\u007f\xf8\xf9ƍ\x1d2\x87\xe9M1ù\x9a)샎͏\xbcz\xf1¶\x82\x97\u007fO\xb7\xbf-\xfc@?\x9e\xbd\x134\x00\xc0e%\xb2w\xa3\xeek\xaa\xa9j茜k\xe2`M\xac\xabR\xa8\r\xf4\x955\x82pd\x99\xb0\xec\x88 <\xc4x_\x9b\x01\xe2[\x82F\xfeیs5S\xd8a\xba\xf3\r\xb9\x00A\x1d\x97\x1d\xc8\xd7f\x8a\"8A\x03\x00\\V\xa2\x19ɕ\xbdy\xca/b\xa7\xa2\x895\x00.\x01%\x9ax\xae<\xbb\xf6wS\xd5\xc4\x1a\x00w\x80\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0DS\x18\xb8\\\x83i\x83\xebJ\x14\xeeF-\x13:XU˯%\xeb\x16\xdd\t$+lc\u007fqj\xe2=\x97m\xa2LJR\x81\xda\x17\xd1eC8\xe3\xb4G\xe8J#̢\xd7V\xe0r\r\xa61n+\x91\x8d\x1b\xb58\xd8\x14h\xedn\xaf슞s\x82h]\xe7\v۶(\xf5[\xeb\x12\xcf\xd8\x04\x8f\x0f\xef\xee\x15^\xbe ^\xe8\x10\xf6r\xba\U000db38eC\xec\xa2\xd7V\xe0r\r\xa61.+\x91\x9d\x1b\xb5\xd8\x14\xe8\xa5\x12\x15\x8a\x92o\x02\xd9\x1e\xa6D\xfdD\xbe\xb2\a\xecbljC\xca\xea\xfb\u007f\x10\x0eYw\xbc\x16M\x89\xe0r\r\xa61\xee*\x91\xad\x1bu_\xa5\xb2\x82\xb5Wk͇+Q\x17\x99\xe0\x95l\xc7E\x89\xe0r\r\xa6\x13\xee*\x91\xad\x1buk\xc0\xab\xa5\f{\vӒWj\xa3\xb3\xea\x1c\u007f\xe6&\xb9#4\x98B\x146q[O\xc5\x13R\xd6U\x98\x9e\xb8\xd8R\xd71\xf9Y\x9bJ\xf4\xa8\x90wx\xef\x86|\xbd\x00C\x89\xe0r\rf\x18\xee*\x91h\xe7F]\xdf\x10\xaa\vԴ\xb8\u007f-u%eV\xd5\xdfE\x14%*\x8a+i\xa8HYpY\x14O\x06\xf7\x93\xed\xc1`\x1f\xb7\xf5|mMzf\xd2\xdcM\x85\xe44W\xc4\xd8\xfc\xacM%z\xebH\x9ePp\xe0\a+\x1eRw\x18J\x04\x97k0\xc3\xf0P\x89t7\xea\xda\x00u\xa3\xae\xa9uݍza\x86\xdc۹<\x9f*Q\x03\xa9\x12\xa91\xa2b\xd1j\x8cθ\xad\vȢ\xb3\xd61\xe4\x18\xfd\xac\xd9\xd1ْ\x15rogg\x81\xbaCW\"\xb8\\\x83\x99\x86\x87J\xa4\xbbQ7(^\x1f\x03U\xc6\x0e\x978C\x02\xf4\xad\x8c*\xd1\xea\x8c\xc1K2s\x95\xf9\x16C\x89\xb8\xad\v||w\x882F?kN\x89v3\x01\xba\x12\xc1\xe5\x1a\xcc4<T\"ݍ\xbaY\xb5\xa1nv\xfb\x01\xbdc$Hߔ\x19\xeb\xf9\xea\xe4\x10\xb9\x97n1\x94\x88ۺ ;\xbc\x881\xfaY\x1f\x16h\x0f\xe7\x82b\xb4\xc6\x05\xe8J\x04\x97k0\xd3\xf0N\x89\f7\xea\xf6*\xe5!¦\t\xbea\x15F?\xd9Cߔ\x19\xeb\u008cv\x85~\xba\xc5P\"n낕\xe1E\x8c\xd1ϺCɦ\xce\xf4\xd8*\x11\\\xae\xc1L\xc3;%2ܨ\xfb\x95\xbb\xf8g\x03\xae?d\x9d3W\x96\x98\xae\xd9T\x89\x1aI-\xddRVN_\r%\xe2\xb6\xda)\xd1\x18\xfd\xac/\xac\xa2C\xb2ݫ\xe8mx[%\x82\xcb5\x98i\xb8\xabD\xb6n\xd4\xe2\xb1\xc0\xb1\x9e\xce\xea:\xd7\xef\xe5w\xfa疗%\xc7\xc5W\x85D\xf1~\xb2\xba\xb6\xbe\x88T\xeb\xf7\xce\xd4{Q\xc6\xd6K\xad\xc1̅\xc1`\xb7\xb5\x881\xf9YS\x8dy\xf4\xf8\xa3Tm\xde\xef\xc8{\xe4\xd5+o<\x92\xd7\xf1\xbe\xf8k\xfa\x8c\xf5\xb3\x1d\x1d\xbf\x16\xe1r\rf\x1c\xee*\x91\xbd\x1b\xb5\xd8U_Uw\xccu!\x92\x8f\xbb49}KU<)\x96Ӎ\xb9)\xc9\v\x0f\x8a\xe2`\xb225\x14\xaf>\xf1\xado=\x15\xa7l\r\xefz\x8c\xc5\xcfZ\xe6\xf8\xe6e\x9b\xe5\x0e\x0f}\xe0H\xc8\xfb\xe52\x81\x06\xec\xd6\\\xae\x1f\x16\xe1r\rf\x1c\xee*\x11\x18G\xe0r\r\xa6\x11P\xa2\xa9\v\\\xae\xc1\xf4\x01J\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x98VL\x9cM\x1d\x98P\xa0D`\xfa\xd0W\x94J\x96;\x05\x81I\t\x94\bL\x1f\xb2\xb2\x02M\xe1k\xfc\x82\xa9\x80\xebJ\x14\xe6Fm1\xa6v\x97\xa6\x14c\xa5ȱXP;\x19H3\xbc|\xb7Pz\x85ZP\xdf\xfdr\xe4\xa0\x13\x05\xfa2\xd5\xe2\xff|tM\xfe6c-\xb4\xe84$\x8f~\xbdK\xfd\x8c\xd7\x11B\xfcᶻ\xfd\x8b\x92w\x84'9F}4\xbeu\x98ss\xe2\xe8\x86\xfc\x8dG6\xbe\xe4\x14\x16\xc6)\xd2\xe8\x14\x02&+n+Q\xb8\x1b5gL\xed6\r~c\x95\xa4\xb1XP;\x19H3\\<!\xe4w\x88\x17\x8e\b',K_\xbf\xcc,@\xfbҲ#z\xf2\xab\x05\x87w\xe7\xf3\x9e!\x11\xd9J\xb6:\x85\x18\xe8g\xdc\x13\f\xee\xb1\xf1&ڒ\xb1#\xae/,\xc91\xea\xa3\xf1\xadÜ\x9b-f;\x1c\x12v\x1e\xdd+\x84\xfbR:Ҧ\xaeL\x0e\xa6\".+\x91\x9d\x1b5kL\xed\x1dc\xb5\xa0v\xb0m5\xb9 \xec|D\x14\xdf\x15.\x88<\x9b\x1ff>\x18\x9d\xa0\x0f\xe4\v\xf1\x8a54\x12e\xa4\xcc)Ď6\x1b%\xca.\x17\xfd\xc1\xb0$G,Gc[ǡ\x83g\xb4\xc3\xdbw\xef\x93_\xf7\x8eI\x89`\xfb6eqW\x89lݨ\xadIo\x18\xab\x05u\fJ\xf4\xf2\xb2\v6J\xb4\x91U\"\x83w\x85Q\x8feD\xb1\x9c\x94;\x85\xd8aw\xe1Ϋ\xea!]aI\x8eX\x8e6\xea\xd6a\xdaaw\x01\xed5\xfe\x12J4\xb3pW\x89lݨ-I\xf78\x93HH\x9c2;\xc5[P3\x84\x9bM[\xb7\xda\x19Hwl[\x9b\xb7f\xdbZş\xe3\xf9\xcd\xcb6\xec\xa5\xeasAxw\xe3\x11M\x89\x8cأڊ\xb1\x9b\xe5\x8d\x1f\xe4\v\x82\xb2\x92\xbexq\x8d\xbau\xaf<\xa6\x91\xdf\xf6\x89Ok{\xec\xab#\xee ʄNO\x92抔\xd4\xc3\xec,&\t\x81M\x99\xfe\xc5t\x9by\xc6\x14\xbb\v\xf7\x9e\xb2{睊W\x16\xcfe\x92\x1c\xda\xd1\xc4XZ\xc7<7\xa6I\x18+n\xb6\x1dV=\xa1\x84\x1d\xa2\xeby\x1b\r\xc5\xd9v\x9b\x8d\xca\xd3\f%\x9a\xba\xb8\xabD\xa2\x9d\x1b\xb5%\xe9\"ǂA\xdfv%\xc5ZP3ؙM[\xb6\xda\x18H\xbfq\xf7\xee#'\x0e\xaf\x11\xfe@\xb7\n\x8f\x1d?T\xb0\xf1\x8a\xa2D\x87\xb6iJd\xc4^x\xb5cCiGG\x87\xe2\xe7\xfaZGG\xbe\xbaD\xf5\x1b\x1dG\x84\x03\x1d\x1d\xefӀ\xb5\x8f\xfe^\xfc\xfd\x81\x15\x1d\x17\"U\x87\xae\xa8_A\xdf\x06\xab*T\xaaX;\xddPM<I\xd9^\x91\xa4\xdc\xdd6\xcfX\xb4W\xa2\xf2$߱K\xf7,l\xe5\x93\x1c\xda\xd1bk\x1d\xf3\xdc\xcc&a\xac\xb8\x99v\xf8@x\xde,\xcch(ζ\xdblT\x86K}\xcd\xd9\xc9c\x18^\x83Ɂ\x87J\xa4\xbbQ\xf3I\x97IԯK\xbbљ\xbd\xd94\xbf\xd5\xc6@\xfaP\x01\u0560C+\xae\xd0.\xcd\xf3J\xcc\x11E\x89~\x97\xff;E\x89\x98X\xcb\xe8L\xbfZ\x99\xd1\xd9\x01\xdaOP\x9c\xad\xed\xab#\x13 \xeaJ\xfd}\xdd*\x16A\xf5%\xf7\x88ba\x8a\xf6)1\xaa\x12\xed \x01\xf1\xac\xff\xa0%ɡ\x1f-\x96֡h\xe7\xc64\tgŭ\xb7\xc3/\x95ƹr\xf1\xe2E\xbe\xa1\xccX\xb6\x04\x93{\xe5\xce\xe0\xd8\x06\xd8`2\xe0\xa1\x12\xe9n\xd4|\xd2e\xa2*\x91\xbd\xd94\xbf\xd5\xc6@\xfa\xd7\x05\xeb\x1f;\xfc\xc6\x15:۱s\xfd\xc5?Ȭݭ(\x91\xb8\xedYE\x89\x98Xg%\xfa\xcdݿ\x14/\xae\xa0W\xa4}ud\xaaH\x15}\xeb&:\xbc\x1b\x92o\x9d\xa8Y\xddR\xa2*Q-I\xde$V\xa4]\xe2\x93<\xda\xd1bj\x1d\x8avnL\x93pV\xdcz;\xa8}\xa2\x9d\xf2P\xed\x04\xd7Pf,[\x82\xc9\xe9\xc6\xca,\xf4\x89\xa6.\x1e*\x91\xeeF\xcd']&\xaa\x12ٛM\xf3[m\f\xa4\xc5\x0f\x0e?\xbcAX\xf3\xb4\xdc'ڨ\xcd\u007f<\xa4*ё\x8d\x8a\x12\xb1\xb1\x8eJ$n\xdb+\x1e_A\x0fi_\x1d\x99\x96dUR\x82\r*\x96;^\xcaxlTJ\xd4\xe7\xdf\xd4<\xbb;c;\x9f\xb4\xa0\x1f-\x96֡h\xe7\xc64\tg;i\xb4\xc3\x1a:O\xf4\xfe\x11ቋ\\C\x99\xb1l\t\x1cA\xd2f\xdd\x04\xa6\n\xde)\x91\xe1F\xcd%\xdd&\xaa\x12ٛM\xf3[m\f\xa4_{BN~p$\xff\x10\xfd\xf3\xfd\v\x85ߩJta\xd9\t\xa5Od\xc6jW\xe0\xe1_\xab\xa5\xd9)\xd1\xd1U\x17\x95\xc1Y\x84\xea83z%\xaa\x97{S\xcbӓ\xce\xf0\xc9\b\xc4\xd2:\x14\xa3Od4I\xb8\x12\xd1vؽ\x86j\xd9Qz\xef\x8cm(3\x96-\x81\x03\xf7Φ0\xde)\x91\xe1F\xcd%\xdd&\xaa\x12ٛM\xf3[m\f\xa4\x0f\xa8\x13@\xa5\x8f\xd2\xebR\x99\xcc\xd8\xf7\xb4\xaaD\xe2\xee\x9d\xea<\x91\x11+\x87\x95\x8a\xe2\xef\xf59\x0f;%\xba\xb8\xe6誗\xc3\x0f<zF\xafDu\xa4K<IV\x8b\x97ӻ\x99\xa4hO,\xadC\xd1\u038di\x12N\x89\x8cvx\xfbny\xeb\x95R\xaaDlC\x99\xb1l\t\x1cP\xa2)\x8c\xbbJd\xefF\xcd&\xddd\xb05\x18\xf4\xad\v\x06\xcf\xf2\x16\xd4\fvf\xd3\xecV{\x03\xe9\x03²\x03/\x1d\xdd-P\xf9x\xe2\xee\x9dG\xe4\xe4\x11\xfa\x8c\xf5\x91\vrV\xe5\xde\x19c6-_\\\xcf\x1e\xfd\xea2\xb9\x84\x8b\xafvt\xe4?\xd2\xd1\xf1\x81~\xef\xecU\xed\xe6\xd0\x13\xebW\xfc!\xbc:\f\rs\xa2L\xd5\xf6\x06\x13ֵ\x8a\xed\xeb\x12\x82\xbd\xec\x19+\xcfXW\x04\x83\xdcϴ\xfa\xfc+\xeb\xd23}%\xe5\t}L\xd2R\xa0q\xb4\x18Z\x8797\xb3IX+n\xa6\x1d\xe4\x01\xde\xee\x97v\xab\xcfX\x1b\r\xc5\xc5\x1a%X8F<~<\x16\x8c\x1dw\x95(\x82\x1b5\x93t\x936\xd5b\x9aTZ,\xa8\x19\xc2ͦ\xb9\xad\xf6\x06\xd2ϗ>\xbd6\xaf\xa0T\xfd}ى\xd25+J\x8f+\xbf;\x93/\x9d+\x9b\v\xaep\xb1\xf2E\xfaت\xfc\xd2\xd7\xe4\xc4\x1bZa\x87ŋ+\x94D\xde\xdb\xda\xe1\x04}n\x96\xad\x0e\xc3\xc1\x94\xf0;\\\x06\xc5\xf2\x89%t\xfa\xe5\xd7b挕ߝQVr\xc1M\x19)\xc5\x03M\x99\xc9{\xb8$\x8fy\xb4ѷ\x8eyn\xa2\xd9$\xac\x157\xd3\x0e\xca\xef\xce6\x1f_K;BFC\xf1\xb1z\t\x16\xfa\xe2W\x9e\xea\x8b\xf1\xa7\x83`\x92\xe0\xae\x12\x81\xb1paI\x94\x1f\xcd\x02\x86\xfa,B\xeeu\n\x02\x93\x12(\xd1\xe4\xe7Ț?8\x85\x00\x8d\xbeS\x1e<\xac\x0f\xc6\x01(\xd1$\xe7闯|\xf5\x80\b\xc04\aJ4\xb9\xb9 l~\xb4`\x94\x8b\x83\x000u\x81\x12Mr\x0e,+}\xdb)\x06\x80)\x0f\x94\b\x00\xe0=P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=\xae+Q\x98\x1b\xb5(\x0e\xb4<\x15x\xaae\xc0!\xe34b\x92\x98X\x030yp[\x89\xc2ݨ\xc53\xd5u\xa1\x9eP]\xb5g\xeb6\xba\xce$1\xb1\xa6|\xf0~\xe4}\xcd\xed\x91\xf7\x010\xbe\xb8\xacDvn\xd4\xc1Z\xea\x1fq\xa9vFy\x9a\x8f\xda\x1cu\x02M\xac\xa9\xb1\xe1\x8aR-y\xf9\xd2\xe5\xcb\xf2\xff\xec\xdel~\x155\x00&\x10w\x95\xc8֍\xba\xa9^\xf9P\xef\x89\xf9\xa2WĠD\x13fb-\xbe\xb5YмZ\xbb\xb2\xb3\xb2\ue657\x95\xb5\x89\x1d#/\x80\x12\x01\xd7pW\x89lݨ\xfb\xab\x9b\xfb\a\xfb\x83\xd5\xfd\x91rM=Fo\xd3졉\xf5\x85\xbd\xc2ڗ\xd4\xe4%\x1f\xc9͝\xe5\xcf͞\xf5\xc0ymo\x83\xb6\xba\xec\x02Q<\x15OHYWaz\xe2\xe2K\xc5$\xaeZ\xec\xf6\x91,%\xa6:ǟ\xb9i\x06\xcd\xef\x81\t\xc4]%\x12mݨ\xcf7UVV6\xea\x97\xc04 \x16\x9bf\xafL\xac\xaf\x1c-\xc8{B\xedh]|\xf7\xed\xff\xbd\\\x92B\xc3\xd2\xc8g\x97\xea\u007f\x0f\x06Z\x82\x99\v\x83\xc1`H\xfe\xf7\xa9\xadI\xcfL\x9a\xbb\xa9\x90\x9c\xee\r&l\x17\xc5\xd6u\x8aQHQ\\ICE\xca\x02,\x1c\r\xc6\x01\x0f\x95H\xb7\xa0\x1el\xaa\r\xf5\x86j\x9b\xc2\xddF\xa7(\xb1\xd84{fb\xfd\xa8\xb0\xf1--Y*\xfc?\xff\xe7\xacY\xb3ĕ\xb3f}\xa6\x9c\xb9o\xc0\x8c\xce\x16\x90EgE\x91:!\x98\x96E\r\x8a\x17l\x1b\xd9/\x02p\xdbx\xa8D\xba\x05u\xb0\x96z\f\r\xd6N\x1b\x87\x98Xl\x9a=3\xb1~~ɪ絉\uedcf\x1e\xfd\x1f\xff\xef\xff%+\xd1\u007f\xb8wG\x17\xe3\xf7\xc4*\x91Ow#2\x95hu\xc6\xe0%\x99\xb9E\"\x00\xb7\x8d\x87J\xa4[P\aN*o'\x03v\xe1S\x91Xl\x9a\xbd3\xb1~w\x9b\xb0Y\xef\x15\x89\x97\xcf\x06d%\x8ao\xefg\x8d\xe7X%\xca\xd6S\xa6\x12\xcd\xd7f\x92`\xa6\x01\xc6\x01\xef\x94Ȱ\xa0֔\xa8}\xda(Q,6\xcd\x1e\x9aXә\xa2\xbd\xc6-\xb9Z\xaaD]\xdc\bYQ\xa2\xc0i#\xa9\xa0(Q\x19U\xa2\u008cv\x85it\xa7\x01x\x87wJdXP7k\xa3\xb3\xe6\b9\xa6\x1c\xb1\xd84{jb}a\xafPpBK\xdb(Qn\xae(\xf6\x91Z\x9a4\x95ȿU\xeeAeS%jTw\x95\x95\x8b\x00\xdc6\xee*\x91\xad\x1b\xf5\xf9\xfd\xb5\x9d=\x9d\xb5\xfb\xa7\xcfͳ\x18l\x9a\xbd4\xb1\x96y\xabT\x1f\xe4\xd9(\xd1v_E\xfd\"\u007f\x8fx\xa9U\xb9\x8d\xa6\n\xea\u0094\x1d\xe59$\xbe*$\x8a\xf7\x93յ\xf5E\xa4\xdaZ(\x00\xb1\xe3\xae\x12ٻQ\x0f\xb6\xd5Uյ\xb13\x14S\x9d\xd1\xdb4{ib\xcda\xa3D\x83%ɉ\v\xdbD\xf1\x94\xeaa\xad\njWnb\xd2\xe2\xafPkk\xb9W\x94\x9b\x92\xbc0\x8a\x116\x00\xa3\xc6]%\x02.\x12\x9b\x89\xb5\x8d\x12\x01\xe0\x1eP\xa2iKl&\xd6P\"\xe0)P\xa2鉓\x89\xb5`\xe5\xff\x96\x95\xe8\xff\x80\x12\x01\xaf\x80\x12MK\x1cM\xac\xa1D`r\x01%\x9a\x9e\xc4lb\x8d\xd1\x19\xf0\x14(\x11P\x80\x12\x01O\x81\x12\x01\x05(\x11\xf0\x14(\x11\x90\x19ܳ\x92\xfe\x02vk\xcbtz\xaa\vL%\xa0D@&G_\x15\xa4\x0eR\x04<\x01J\x04D\xf1\xfc\x1d\xe5\x924$I#w,\x9f9\xbe\x06`R\x01%\x02\xa28@Hn\xee\x1d\xa9\xb9ٳ\x8a\xf0\xcbz\xe0\tP\" \x8a\x97\x82s\x93\x933\x93\x93\x93\x17\xb5M\x9f\xdf!\x83)\xc5LV\xa2\x95$\xa50\xe4\x1443\x18\xec\xeb\xee\xea\xee\xee\xea:\x8d\xf5\xf1\x817\xccd%\xeam\xae\xcaJ\xc1\xa5\xa7B\xbd\xce,~g\x00\xb8\x87\xebJd\xe3F}\xf9T}\xa0Λ\xceI39\xe5\x14\x02\x00\x98x\xdcV\"\x1b7j\xb1\xa1\xaa\xbd\xfbX\xe0X\xf4\x8c\x13C\x1biu\n\x01\x00L<.+\x91\x9d\x1b\xf5\xc9\x00\xbd_\xd3\x15\xf0b\x9c\x04%\x8a\xc8,\xcfq\xaa!\x98N\xb8\xabD\xb6n\xd4\r\x8dʇj/:EP\xa2\x88\xcc:\xe71P\xa2\x19\x85\xbbJd\xebF]\x17T>\xd5{\xb1\f\xe9)2m\xd6\xf1\x1fo\xa0D\xc0M\xdcU\"\xd1\u038d\xba\xa5Z\xf1\xf6\xa8\xaa\xb3\xcf0\xa1\f\xa6\xe4\xb4\xf4\xe0\x86\x91\x1dP\"\xe0&\x1e*\x91\xeeF=P\xd5\xd0w\xbe\xb7\xbe\xb2\xd6>\xc3\xc4r\x90\x10\xb2\xd4)hF\x02%\x02n\xe2\xa1\x12\xe9n\xd4b\u007fCee\xa0\xb5\xa1\xde6~b\x19Hɨh\xeev\x8a\x9a\x910J4jQ\x1au\xe0\xb9Q\xc4B\x89f\x14\x1e*Q\x959E}\xbe\xff\xb2\xa8\xdcGs\x9b6\xd2\xe4\x142S\x81\x12\x017\xf1N\x89\f7jQY\x9e\xabK\x9d\xbev\x19\xdc;\x8b\b\x94\b\xb8\x89wJd\xb8Q+\xb7\xd0\xce\xd6xr\x13\vJ\x14\x11Y)~\xfa\xb7w\xcc\xfa\xc2?ɚ\xf0\x8d/̺\xe3\xef~%\xab\xc3\xd7?\xff\xbf}\xfe\xeb\xf2\x8e;\xe4\xf4\xdf\xc9\xff\xdf\xf13U5\xbe\xf3\x85Y\x9f\xfb\x06\x13(\xe7\xfc\xec\xdf\xfe\x8a\xd9`\x16\U0005dfda\xf5\xf9\xbf?g*\x91V\xe4\xb9Y4!\x97a\x1eթ\x86`:\xe1\xae\x12ٺQwU\xb6\xf5\x9c\xacn\xf0\xe2\xc1F\xb1\x15J\x14\tY)\xbe\xf0\xe5_\xbd\xf7\xcf\u007f#k\xc2_>\xf3\xde\xcf\xfeNV\x9e\xef|\xee\x99\u007fy\xe6s\xdf9w\xee/\u007fx\ue9f3~v\xee\x9f\xffRU\x93\xef\xfd\x87\xef\xbd\xf7ӿc\x02\xff\xea\x99\xf7\xfe\xe5\xbf\xfc'f\x83\x91\xf8\xe7\xbf\xfa\xe7\xf7~\xfa\x1f\xff\xdeP\"\xa3\xc8Y\x9f{\xe6\xbdg>\xf7ߙ\xa3:\xd5\x10L'\xdcU\"{7\xea\xf6ڪ\x86\xf6ș&\x8c\xc1\xde\xf6\x95\xbe^\xa7\xa8\x99\x8a\xac\x14\x9f\xd1z<\xb3~(\xbf\xfc\x8b\xdc\x0f\xfa\xe2w\xa8v|\xf1ܹ\xff\xf2\xe5s_\x9e\xf5\x8ds\u007f\xff\xff\xa9\x01_\xfc'K \xe5_>\xc7l0\x12w\xd2\xc4\xcf>o(\x91Q\xe4,%q'sT\xa7\x1a\x82鄻J4\xb9\xb8\x97\x90t/n\xd8M\rd\xa5\xf8\xafw\xfc\xe7oPYPEC~\xfd,\x1d^\xfd\xea\xb3r'\xe8\xaf\xcf\xdd\xf9\x9f\xfe\xe6\xdc\x17\xbf\xa7\x89Ư\xce\xe9!\xea\xeb\xcf\xfe\xe6\x8eY\xb3f1\x1b\x8c\xc4\x1d\xea/9\f%2\x8aT\xca\xf8\xd5\x1d\xccQ\x9dj\b\xa6\x133Y\x89\xfa\xda{\x9cBf0T)~\xf8\xe5\xbf\xfd\xec\x97\xed\x94\xe8\xbd;~\xf6\x99\x9f\xdd\xf1\xb3Y\xef\xa9rr\x87U\x89\xee\xfc\xaf?;\xf7\x9e\xad\x12\xcd\xd2z<\x91\x95\xc88\xaaS\r\xc1tb&+\x11\x88\x86\xa6\x14?\xfd,##\xc6P\xeaܝ\xff\xf9?\xca\xffߩ\xa9ʝ\xfa\xe8L\u007f\xfd\x8c,Q\xcf\xd8*\xd1\x17\xbf~\x8e\x8d\xb5\x19\x9dQ\x94\xa3:\xd5\x10L'\xa0D\xc0\x1eY)\xfe\xfa\xbf\xbf\xf7\xde\u05ff\xc0\xc8\xc8w\x94Ye*\x19_\x9e\xf5e\xe5\u007f\x95g>\xa7\xcdX\xeb\x81_\xf8\xf2{?\xfcK[%z\xe6\x8eo\xfc\xea\xbdg\xfe\xdaP\"\xa3Hu\xc6\xfa{\xccQ\x9dj\b\xa6\x13P\"`\x8f\xac\x14\u07fbs\xd6\x1d\u007f\xf3SFF\xce}\xfd\xf3\xb3\x94[\xee\xe7~8\xeb\xa7\xe7~\xaaLC+\xfc\xd3_\xa9w\xf1\xf5\xc0\x1f~a\xd6\xe7\xben\xabD瞹\xf33\xb3\xee|\xc6P\"\xa3\xc8Y4A\xef\xe2\x1bGu\xaa!\x98N@\x89\x80=\xbaR\xb8E\xd8\xf1\xa0D3\n(\x11\xb0\aJ\x04\xdc\x04J\x04\xec\x81\x12\x017\x81\x12\x01{\xdcV\xa20\xa0D3\n(\x11\xb0\aJ\x04\xdc\x04J\x04쉺ؽ+8\xd5\x10L'\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1eו\xa8Y\xb3\x9d\x1ehy*\xf0T\x8b\xba(Q_}U\xa3\x17+6:\xf1\x88 \b\xf9\xef\xea\x9fN\x14\x1c\x8d\x16\xccrtC\xfe\xc6#\x1b_r\n\x03\x00h\xb8\xadD\x9a\x1b\xb5x\xa6\xba.\xd4\x13\xaa\xab\xa6\xeb6\xf6\x04\x82]\xc1@O\xb4l\xde\U0001b38eC«\xfa\xa7\x97\x96\x1d\x89\x16,\xbe\xfc\v=uH\xd8yt\xaf \x1c\x8a\x16=z\x9a\xbdX\xbb\t\x00wqY\x89\f7\xea`-]\xbd\xfaRmP\x14/\xd7е\xf4[j&\xa5\xed\xd8k\xa6\x12\x89W\xa2\xc4\xc9l~XK\xbc}\xf7>\xf9u\xefx)Q\xf6J\xa7\b\x00\xa6<\xee*\x91\xe9Fݤ.QV\xdf$\x8a\xa1\xc0y95\x10\bE\xce\xe7\x1d\xac\x129\xb0QW\xa2\xdd\x05\x17\xe5\xd7_\x8e\x97\x12-\x80\x12\x81鏻Jd\xbaQ\xf7W7\xf7\x0f\xf6\a\xab\xfbeQRm\xa8\x0fz\xb0\xa4\xfe\xbb\x0f\xad\xc9+\xd8\xf6\x9b([u%\xfa _\x10\x04mtv\xe5\xf9\xcd\xcb6\xec\xbd \x8a\x8f\ny\x87\xf7nȧ\xa1G\x05\x95\xcd\xf2\xfeUO(a\x87~Mc\x0fo\xce\xdfx\xe8\n\x17˔\xc0ГDT\x92z\x98\xad\r\xda\xc6\x05\xa2x*\x9e\x90\xb2\xae\xc2\xf4\xc4ŗ\x8aI\\\xb5\xd8\xed#YJLu\x8e?s\x93'ˀ\x030^\xb8\xabD\xa2\xe9\xedq\xbe\xa9\xb2\xb2\xb2\x91\xf6\x86\xeaT\xa3\xb3\x16\xf7\x17r}y\xd9\xe6\x1f\x9c8 <\x1be\xab\xd1'z\xad\xa3#\xff\x80\x9a\xdc-<v\xfcP\xc1\xc6+\xe2[G\xf2\x84\x82\x03?X\xf1\x90(^x\xb5cCiGG\xc7۲h\tϛ\x85\xed^\xb2\xef\xf8\xbe%\xbbE6\x96)\x81a\xb0\xaaB\xa5j\x90\xd9:\xd0\x12\xcc\\\x18\f\x06\xe5\x0e\xe3\xf9ښ\xf4̤\xb9\x9b\n\xc9\xe9\xde`\xc2vQl]\xe7\xa3!Eq%\r\x15)\v&\xe5\xe0\x16\x80Q\xe2\x95\x12\r6ՆzC\xb5M\x97\x8c-mՑ3M\f\x17\xd7n\x93\x87Q\x17\x8f|\x10e+;:Ӕ\xe8%Ei^SzHKV\xc8}\x9c\x9d\x05\xcav}t\xf6K\xe1\x84\xfcz\xe5\xe2E\xb9\x98\xe3J\xfa\x84p\x9c\x8beK0\xe9\xebV\xb1\xdeEdFg\vȢ\xb3\xa2H\r\t|\xb2\x12\x89۩\x125\x90*\x91\xda%\xed\x17\x01\x98\xbax\xa5D\xc1Z\xfa\x97\xa8\x1c\x16}\x00\x00 \x00IDAT\u007f\xb0V\xee\x0f\xd5\x05\x95-\xcdu\x913M\fDž7\x1c\xb7\xda(\xd1\xce\xf5\x17\xff \xb3V\xee舴\xb7#\x1eX\xa2lוH\xed\x13픇j'\xc4\xdd\x1b\x94M\x1b\x1e\xe1b\xd9\x12\f\xba\x89\x8e\xc5\x1d\x9bU\"\xdfi-e*\xd1\xea\x8c\xc1K2s\x8bD\x00\xa6.^)Q\xe0\xa4\xf2v2 \x8aM\rJ\xb2\xde\xf5y\xa2g\x85\x8b\x8e[m\x94h\xa36%\xf4\x90\x9c^B7Y\x94H\\C\xe7\x89\xde?\"<qQ,ݦlٶ\x99\x8beK0\t6\xa8\x04E\x1eV\x89\xb2\xf5\x94\xa9D\xf35\xfd\xbaW\x04`\xea\xe2\xb1\x12\xb5\a\xa8\x05#\x1dn\x9c\xadt\xfd\xde\xd9\t\xe1\x17b8\xfcV\xdb>\xd1/\x14~'\xda(\xd1\xe1_\x8b\xe2\xee5Tˎ\xd2{g\xbb\xd7ӹ\xa0+\xebws\xb1l\t\xce(J\x148m$\x15\x14%*\xa3JT\x98Ѯ\xd0\x1f!;\x00S\x01\xaf\x94\xa8Y\x1b\x9d5\xd3\xe7\x89ho\xa8\xd9\xfd\xe7\x89.\x14\x94R\xc9xl\xaf\xf2\xa9{G\xb7\xcdV\x1b%:\xa1\xce\xef\xec{Z䕨\xb4T\x14\u007fO\xf7\xbd}\xb7\xbc\xf5J)U\xa2\xe3J\xec\x11u\x9eȈeKp&7W\x14\xfbH-M\x9aJ\xe4\xdf*7\\6U\xa2FuWY\xb9mf\x00\xa6\x06\xee*\x91\xe9F}~\u007fmgOg\xed~z\xf3\xac'\xd0\xdc\xdd\xec\xc53\xd6/\xe7o8|\xfc1\xe1\xb0\xf2a)\xb9Ǻ\xf5\xd7\xf4\x19\xebg;:\xe4~\xce\xc5W;:\xf2\x1f\xe9\xe8\xa0\xf3\xd8Oܽ\xf3\xc8\xd1ݲ\x9a\xbcߑ\xf7ȫW\xdex$\xaf\xe3}\x91\x8a̳G\xbf\xba\x8c\u07ba\u007fV\xd8\xfd\xd2n\xf5\x19\xeb\x9d\xc2\x13/=!\xec\x14\xf9X\xa3\x84Ѱ\xddWQ\xbf\xc8\xdf#^jUn\xa3\xa9z\xb90eGy\x0e\x89\xaf\x92;\x92\xf7\x93յ\xf5E\xc4\xf5\t\u007f\x00\xc6\x11w\x95\x88q\xa3\x1el\xab\xab\xaakSoX\xf76\x06\xea=q\x85~\xfb\xe1\xb5\xcb6k\xbf&\xabJ\xa9\xb4nݭ\xcd\xe7\xc8î7\xb4\xa4\xa2Z'J\u05ec(=N\x9f\x11\x12\x84\xbc_.\x93_\x1f\x95\xb7^|lU~\xe9kJ\tG7\xe4o>\xbe\x96v\x84\xae\x1cڨ?O\xc4\xc6\xea%\x8c\x86\xc1\x92\xe4ąm\xa2x*N\x99\x0fR\xf5\xb2+71i\xf1W\b)\x96Ӎ\xb9)\xc9\v\x0fF-\x03\x80I\x8e\xbbJ\x04\x00\x00v@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=SA\x89V\x92\x94B\xd7\x17/\x02\x00\xb8\xc8TP\xa2\xde檬\x14xW\x000\x8dq]\x89\xecܨͭ\x91h&\xa7\xa2\a\x00\x00\xa62n+\x91\x9d\x1b\xb5\xb95\"m\xa45z\x00\x00`*\xe3\xb2\x12ٹQ3[#\x02%\x02`Z\xe3\xae\x12ٺQ3[#\x02%\x02`Z\xe3\xae\x12ٺQ3[#r\x8a\xb8\xeeA\x04\x00p\x0fw\x95H\xb4s\xa3f\xb7Fb0%\xa7\xa5\xc7u\xf3\x0f\x00\x80Kx\xa5D\x8c\x1b5\xb352\a\t!K\x1db\x00\x00S\x15\xaf\x94\x88q\xa3f\xb6Fd %\xa3\xa2\xd9\xe2\xd2\f\x00\x986x\xa5D\x8c\x1b5\xb35\"m\xa4)z\x00\x00`*\xe3\xb1\x12\xb5\x8fZ\x89p\xef\f\x80i\x8cWJĸQ3[#\x02%\x02`Z\xe3\xae\x12ٻQ\x9b[#\xd2\n%\x02`:\xe3\xae\x12ٻQ3[m\x19\xecm_\xe9\xf3ĭ\x1a\x00\xe0\x0e\xee*\xd1ظ\x97\x90\xf4z\xa7 \x00\xc0\x14f*(Q_{\x8fS\b\x00`J3\x15\x94\b\x000݁\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\\W\"\x1b7\xea\x81`m\xa0\xfeԥh\xb9\x00\x00\xd3\x1a\xb7\x95\xc8ƍ\xfalU}g\xf7\xb1\xaazH\x11\x003\x16\x97\x95\xc8\u038d\xba\xb9\x96\x1a\x99\xf5\a\x8eE\xcb\b\x00\x98θ\xabD\xb6n\xd4u\xb5꾆\b\x99\x00\x00\xd3\x1ew\x95\xc8֍\xba\xb7G\xd9\xd2\xf2T\xe4|\x00\x80鍻J$Fr\xa3\x16\xc5\xcb5A\xfb\f\x00\x80\xe9\x8fWJdq\xa3\x96\xbbDU\xfd\x91\xb2\x00\x00\xa6;^)\x91ōZl\xad\x84\xd74\x003\x17\xaf\x94\x88w\xa3\xbe\xd4\x1c\bE\xca\x00\x00\x98\xfex\xacD\xaa\x1b\xf5@C5\xec\xcc\x00\x98\xc9x\xa5D\xac\x1bu\xff\xfe:\xea\xbah\xce^\x03\x00f\x18\xee*\x91\xad\x1b\xf5\xe9\xc0\xfe\xee\xde\xdeޖZ\xa7\xdc\x00\x80銻Jd\xebF}\xb0R\x05O6\x020cqW\x89\x00\x00\xc0\x0e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xfe\xe2+\x00\x00\xe05\xb7\xd3'\x02\x00\x80\xf1\x01J\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbcg\x14J$\xee\xc8IIH\xbd\xe7\xa9\x11\xa7\xc0\b\fҌ\xb5d\xb9S\\\xec(%א\x95\xe6\x96\xd1\x1c\x86\xcb0\x16\xf6\x90\"\xa7\x10\x00@L8+QU\"QI\xefq\n\xb5eO\xe2\x904:\x89\x88\x15\xb5d(\x11\x00S\x1fG%\xdaNHn\xcbՑ\xb3Us\x89\xaf\xcd)؆\x11B\xa8^\xf4\xee\t:EƊV2',\xa39\f\x94\b\x80I\x87\x93\x12\x05\t٣\xa6\x86rI\xf2\x9f\xa2\aۡ\xe9\xc5\x04`\xa7D\xa3!\xe6\fV\xa0D\x00\x8c7NJ\x94A6\xe9ɡTR\x12-\xd4\x1e(\x11\x00\xc0\x11\a%:F\xe2.\x19\x1f\xaaɜ\x11z!\u007f\xb3\u007ferR\xceAu\xe3\xe0\x96t_\xf2\xbd\xed4YE\x02\xed\x19\x89\xd9\x03\x92Ժ:\xcd\xe7\xcf*\x13%i\xab2\xc5ԫO\xe0\xf4\x15\xcfMH\xbeW\x19\xe5Ր\x8a?m\x99\xebK/\xbbJ?\x9d\xfdRzB\xd2\xc2*nV<b\xb0\x82^\xb2,,\xe2\x964_\xc6\x03Ò>OdW\xd8٭\x19\xbe\xe4\xe5!\xa5,&\x03[W\xfe(\x96C2\xe7\xa9*\xd1<\xb2U\x02\x00\x8c\x0f\x0eJ\xb4\x9d,0?\x88\x84\xb4)\x17\xf2\x1c\xdf\xe2\xdc8RL\xb7\xb5\xfb\x89o~\x06!\xe5\x12U\xa2-\xb3\t\xf1\x8fH%\x84\xa4\xcdO\x95_\xaeJ\xf5\xab\tY\xb9zP\x93\x88\x86\x042g\x81\xbc\x83^\xc35dS\x1aIJ&$KV\x8c\xbe$\x92\x9c\x9dI\xc8]̱#\x06\xab\xe8%אy\xa9$U\xde5oDS\"\xbb\xc2Z\x12ɜl\xb9\xb0\xa0\xc4g`\xeb\xca\x1f\x85?${\x9eP\"\x00\xc6\x1b\a%\xba\x87\x1b\x90\xcd%U\xf4\n%\x99\x03\x92ԝL\xea\xe5\x9eB\x12\xd9zM\x92:\x93I\x13U\xa2\xb8\xcc涧\xa46\x92xR\x8e\xee\x9cC\xbee\x8c\xa1\x14\x898\x1dG\xca\xe5˺\xd1G\xaa\xd5r\xe4.J\xd0G\xea$i9)\xbb!\xefO\"-\xc6\xc1\"\ak\x18\xa33\x92\xd1%wm\x12h}\x94\xc3\xd8\x14vi\x0e)\x1b\x91n~\x93̾\xcag\xe0\xea\xca\x1d\x85\xfb\xc0\x9d\xa7\xaaD\r\x81N\t\x000>8(Q6\xd9n\xfd$_\xa1}\xf4\xc3A\x92A\x87HK%\xf5C&U\"u\xcf\xfdZ\xa6\xfb\xa9\x8c\xb1J\xb4R\x9b`\xa9%)#\xb4\x9c~\xfa\xa1\x98v\xae\xd2\xe5a\x96L\xa0\xb0\xd58X\xe4`\rS\x89\xb4]%\xdaal\n\xdbN\xeeQ\xde\x17\x92Z>\x03WW\xee(\xdc\a\xee<1O\x04\xc0x\xe3\xa0D\xf3\xc9\x0e\xe6S\x0e)\xa3W\xe8B\xe5ÈO\xbeR\xe7\x92f\xf5C\x1c\x19\x90\x95(C\x8d\x1bQ\x87P;\xe8\x15\xcb(\xd1H\"\xe9R\xf7\xcf!!\xb9\x9c,\xe5C\x80N /&9\xa1\x1b\x12K\x94`=BW\xa2y\xe6.E\x89\xc2\v\x93\xb2\xb4z\x0e^\xb2d\xe0\xea\xca\x1d\x85\xfb\xc0\x9d'\x94\b\x80\xf1\xc6A\x89\x96s\x93!\x19\xa4\x82^\xa1_Q?\xcd#\xadÄ\xcc\xcbQH m\xb2\x12ݣ\x05\x8e\x84\xea\xcaW\xa7\x13\xb2\x8eS\xa2\x01B\xb4Y\x9e\x85\xf2\xc0\xa8F\xebf(\xe2\x11\xf2\x11\x92\xb4\xbaޜ\x8f\x8e\x16\xac\x1fDW\"uW=}\x8fP\x98\xe4S\xfb7\n\\\x06\xae\xae\xdcQ\xd8\x0f\xfcyB\x89\x00\x18o\x1c\x94\xa8\x8c\xe4\x98\x1f\x86\b\x9dy\xa9ѻI9\xe4\xa0HL\x9ad%Z\xad\xee\t\xa4\xd2\r\xf3\x17Z\x94\xa8\x8f\xc4k%-%U\x92~3]\x15\x97\xbeu~9K|\xc95\xfd`тU,w\xf1M%\n/\xec\x1a!\x83F>.\x03WW\xee(\xec\a\xfe<\xa1D\x00\x8c7\x0eJ\xd4E\xe2\xccK\xb8\x9e$\f\xd1+\xb4L\xfd\x98E\x8e\xc9\xdat\xc6\f֕蛄|\xa9\xa1{X\xaa\x88\xd8'\xcaQ\xba9\xbc\xb8\x8ct\x96\xcf#\xe65\x1e=X\xc9\x10Q\x89\xc2\n\x93\b\xd7'b2pu\x8d\xa8D\xfcyB\x89\x00\x18o\x9c\x9el\xcc4\xaf\xba\xe1\f%]\xa3\x8d\xc1\xae%\xc8\xfd\x8c\x14z/\x89\xd29pCW\xa2\x1bsH\xad\xb2m\x8bE\x89n\xcc\xe6\xa7~\x98\xcb~ \xa4\xa4\xabI\xbc>\xc1\x13%X#\xa2\x12\x85\x17&\x9f\x86\xfa+\x90\xe6\xc5\x01.\x03_\u05c8Jğ'\x94\b\x80\xf1\xc6I\x89:\t\x9d\x1b\xa2\\[J\x12\xcfK\xf4\nMP\xbaI\xfb\xe9\xa3F\xc5$\xfb&\xfd\xd0J|Wu%\x12\xb5[h\xc3i\xf4\xb3ݽ\xb3:\x924b\x1d\xfd\xd0'\v\xa5~\x12g</\x141X'\x92\x12\xd9\x15\xb6U˷\x94|\x93\xcb\xc0\xd75\xb2\x12q\xe7\t%\x02`\xbcqR\"y\xd8B\xeej\x1b\x92\xc4\xfa\f\x12\xa7\xdc?\xaa!d\x81,E\xad\x89\xf41\xc7~\x1f)\x19\x96\aq\xc9d\x8b1:\xbb\x91\xa4Ls_^L\x94\x89\x98\x04\xd2t\xed\x86z=wǓ\x1d\xb284'\x92\x80\xe5J\xbf\x8b,\x96\xd5cx\xb51\xe7\x1d-XG-9\xbcOdS\xd8@\"\xd9qC\xbaYA\xfc\"\xdf'\xe2\xea\x1aY\x89\xb8\xf3\xc4\xf3D\x00\x8c7\x8eJ$5諂\xa4)?u\x90\xafЌ\xd9\xf1\v2\xb4\xbeR\xb3\x8f\xccΖ?䎘\xf3D\x01Bҗf\xc7%oWn\x97g\xcbY\xdb5\ti\x88'I\xd9i\x84^\xce\xfc\x95~>\x99\xf8\xb2\xe6'\x92\xd4\x01\xe6\xc0\x91\x82uԒÕȮ\xb0\xa0\x8f$g'\x93\x84\xa0\xa5\x13\xc5\xd55\xb2\x12q\xe7\x89g\xac\x01\x18o\x9c\x95H\x12+r\x92\xe2R\xee\xa9\xd5\xeeD\xc9Wh\xef\xd29\xc9KO\xa9\x1f\xcfnJ\xf7%f\a\xe88ȸw֖\x9b\xe2\xcb\xda\xfe\xa7a\x1f\xbdc՟;;\xe9\xa0.!}Ei\xbe\xb4\x95\xedZ9J\xb0\xbagpK\xa6ov\xd6v\xf6\xce{\xe4`\r\xb5d\x9b\x19k\xbb\xc2\xfa\x8b\xd3\xe2S\n{%\x8b\x12qu\x8d\xa2D\xecyB\x89\x00\x18oF\xa1D\x16\xf4+\x14\x00\x00\xc6\v(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x9eؕ\b\x00\x00\xc6\x1b(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x9e\xf1R\xa2\xe7\x84o\xdb\xef\xc0\xad6\x00\x80#P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\xcf$Q\xa2\x96\\n\t\x8f\x98\x18\xcamq\n\x01\x00Ln\x1c\x94\xe8E\xe1\xb9?\u007f{M\xfe\xc6W\xa4[/n\\R\xf0\xddO\x95\xad?ߵ6/\u007fÓ\xff\xa6|x\xe7\xa1U\xcb\x1e\xfc\xad\xa6D\x1f\u007fw}ު\x87\xdedJ\x90\x95h\xa00ٟ\xd3 ѕ\xa5U\xa71\xa9\x82\xb3\x96\xa5\xeb\x95UHc'\x10\xf7\xad\xa8\xfbK\b!\xfe\x81\xa8!:\x9d\x84\xe4JR\xb3\x9c\xe1T\xe4\xa0\xf6TC\xfa\x86\xb6\xa4\xf9\x97ߌ\x1c\n\x00\x18\x15\x8eJ\xf4\xedU\u009a%\x82\xf0\xca\xe3B\xfe\x1aA(\xa5\x1b\xbf-\b\x05\x1b\v\x04a-ե\x17臼\xbc\xaf*J\xf4\xe62!\u007f\xe3zA\xf8\xbeYB\r\x99\x97L\xe6e\x12R(IW\x13\xd4U\xa3\xa5L\x12b\x8f\xb2?\xaeA\xba\x1dZ\xe3k\xa2\xed\xbe\x1c\n\xd5j\xcb\xf3;1r\x92\xf8C\xd2p399\"q\x9c\xea1ӭs\x9a\xf5\xe4Ҵ\xa7J\x12\x87$\x00\xc0\xed\xe1\xa8D\u0086\x0f\xa5뻄\xfc\xfc\x1fߒ^\x11\x84\u007f\x95\xe5Fȧ\x9d\x9ew\x96\t/H\xd2o\x85\xbb_\xbc%}\xf2\xa0@\x95\xe8\xe3e¾\xeb\xf2\x9eU\xc2+F\tԅ\xbe_\xeeG\xf8\xa9\x89\xc6JRN\xb7\x9d&\xe9\xecA\xce\xfb\xca\xf5\xe4\xd5\xc5c\x1a\xa5\xed\xf0]\x8e\x1e\xd0=J%\x92\x86I\xb1\xdc]\x1b$Ö\xed\vm\x17\xd1\x1f\"\xb2\x04ZC\x01\x001\xe3\xacD\x1f\xcao\x1f\n\xc2s\xf4c\xa9\xf0\xa2$\xed\xbb\xfbIe\xdf>\xe1qI\xda%\xec\xa3\xe9O\xd7P%\xda'<\xa4\xec\xf9\x89\xb0\xc1(\xa1Fs\xcf\xd8O\xad\xaa\x83\xaa\x04\x95\x11Cz(%s\x19\xbf\xc5>i\f\\\x9bˏ\xf6\u0088A\x89N%\x8d\xd8(Q\xce:\xbb\xe8\x01\x82)*\x00\xc6\x03G%ZO߮\v\xc2\xff\xa2\xef\xbbh7H\xba~]\xd9\xf7\x03\xe1\x1f\xa5[+h/I\xa2\"$+\xd1Z\xad/$\x87\u007f\xa4\x97PC\x16)\xef\xc3\xd4Q~$\x99*\xc2\xcdT\xd6\xc7P\xba\x91\xb4]\v\xcdj=Cζf)\x0ed\x03\x85\xa9\ti\xcb\x15\xbb\xa0\xda\x1c\u007f6ݶ\x95$ԕe\xf9\x97^\xe6\x92\n;\x12-\xa3)\xbe\x04F\x89\xf4\xc2$)\xb44=!uy\x86\x92>\x98;'\xeb\x01\xaa\x87\xc3d0\xa7YW\"=\xb6E\xf3\x14\xa0~\xb8C\x89\x84\xc45ҽ7Rԭe\xd4|\x88\xc8\xe2Z\xa18\xc4\x02\x00b\xc7Q\x89\x1e\xa4o\xff.\b\x9f\xd0\xf7݊\x12I\xd7\xdfy\xf1\xfb\xbb\xd6\v\xc2n\xe9\x13APe\xe9Dz\x12}*\b\x1b\xefS\xc8\x13\x8cIk\xc326\x83\xba\x12m!\xf7\xcb#5\x92\xcd\x1e\xa3\x87hv=b1\x99/\xff\xb7\x8e\x8aGgRN\xa0\xbd\x82T\xcb\xc9\x12ߎ\xd6\x1d\xbebI\xeao\x8c'\xa9\x15UI\x85\\R!\x14\xde\xe7aJ`\x94\xc8(L\xde\xf4\xa5\xe6\xf6\xbaTB\xdd\x197\xc5\xdd\xdfZ\x93\x9asSQ\xa2\x9a\xe5\x9a\x12\x19\xb1\xd7B\xa1\xac\xbbB\xa1\xd0YZ\xc2\xe9Pȧί\xf7\x86\x1aIE($Ҁ\xf4-\u007f\x92\xaeV$\x870T\x03`,8*\xd1\xc3\xf4MV\"\xe5F\x99\xa2D\xb7^X#\b\xc2\xdd\x1bKe%\xfaH\x10\xd4\xc0\xd7e%\xfa\xb3`bL\x14Ր\x1djb>i\xa6\xee֩7\xa5\"M\x1e4Z\xe5ΒƱ\x04\x92\xd0F\x13#\xe9\xf7ʝ\x9c\x1bMC\xf26B\xdd=ک\x8eI\xbed\xb9\x13T\x9c*\xf1I\x99\xcbĘD\xd6`J\x90L%b\n\xabM\xa5\x1aT\x9b,\xd1\x1a4(1\x8d\x8a\x12]\x9d}UQ\"\xf6\xc0\xfc\xe8̯\xdf\xe93Gg\x15\xb4\xbf\xf4%\x871\"\x00 \x02cP\xa2焻\x1f\xff\xf1o?\x95\xdfw\xd3n\x90zc\xff'j\x9f\xc8\x18\x94\x19Ԑ\a\xd4D\x069)ѻf\xa7F\xfc\xf1ܴt\x90\f\xaa\x89\xa12_:\x99\xeb\xdb.\x8bG\x1b\xe9\xd5wo\x9a\xaf\xbcͧW\xb9\x8f\xbeT\xf8$>)Q%\xb2\x0e\x8b\x98\x12$S\x89\x98\xc2Ĺ\x99[\xeb{%*GE\x997(\xe9%\x8a\x12I˫\x15%b\x0f\xec\xa8D\x97I\xbf4\x92tR\x02\x00\x8c\x85ؕ\xe8\xfa2:m-\xf3]Y\x89n\xad\x12\xdeQ>|\x9f\xce\x13\xadѻB\xef\xfc\xf1\xdf\xf5\x12j4\x87\xb2!\xd5#\xba\x82lmc=\xcb$\xdaO\xd2FN\x81Ժ~ҿ?u\x0f}\xf2Ș\xf7Y\xa4>\x19\xb9r\xa1\xfc\xa2\f\x8b4%2\x93\x12U\x1a\xee\xb1\x00\x89+A2\x95\x88-l\xa8n\xdd<\x92\x16\x90T\vG\xcajU\x89\x9a\xb3\x15%bc\x1d\x95HZ\xfe\x80t,\xf9\x86\x04\x00\x18\v\xb1+ѿ\xa9\xb7ӤO\xd7\n\xbb$\xe9q\xe1\x1f\xe9\x87\xeb\xeb\xa9\x12}[\xb8\xef\x16\xfd\xf4s!\xff\x13\xbd\x84\x1a2[\x994\xdeC\x94.\xc6 I\xdfj\x19I]\xf3\xe9\x17\xf6\r\xe5\xde\x19\xbd\x9cO\x12\xe3\xf9\x9d\x92L\xe5-S\xe9\x13ER\xa2\n\x9fu\x82\x86)A2\x95\x88)\xec4\xbd\u007f7\xdc试\ay\x99=\nWU%\xba6\xa7\x9d*\x11{`U\x89\x1a.\xa9\xa5\xd9)QKꍒM\x12\x00`LĮD\xff\xbeB\xd8'\xeb\xcd\x1f\x1f\x14\xe8=\xfb\x8f\x96\b\xcfݒ>ݥ<O\xf4a\xbe\xf0\xb8<X\xfb\xed*\xe1\xbbF\t5\x84d_\x96\xa4&\x9fv\xd1\xe6\x12\u007f\x92\xe5>\u05faL\xe3)e1Y\xbd\xd75\x9c\xb6\x98\n\xd2W\x94\xfbR\xf4NU#i\x95\"+\xd1\xcdy\xc6OJ\x06\xbfu\xdeZ\x82d*\x11SX\x059F\xb7,\xdeB炔\xb1ݎ=\xaa\x12I%ET\x89\xd8\x03K\x8b\x17Kҟ\xf4!\xa0\x9d\x12\xddHmI\x89\xf2\\6\x00 \x1a\xb1+\x91\xf4#AX\xff\xe0?\b+\x9e\x146ʛ^\xc9\x13\xd6\xfcC\xbe\xf0\xb0\xf2\x8c\xf5\xebK\x84\xfc\xfb\xd6\v\xc2\u05ee\x1b%Ԑ\xa5\x89\t\v҉>q]O,\xbf\xf4\x90\xa4\xb3qU\x92\x95S\xb3\xe7?\xd5v?\xa9\x97\x93\xc5q\xe5\xad\xe5qŲL\x85\x12J\xba\xa4\x9e\x92\x84\x90\xc8$it\xb5\xd9\x01Z\xad\x8f\xfd\xcc\x12D\xfa\x8cuu(t\x89-LV\xa2\xa4\x8a\xd6`\x89r㮜\x145\xb7\x94\x90\x83\xf4\x19\xeb\xe6a\xa93Q\xb9wf\xc6Rͫ\n.\x9d#\x1f\xecFW(\xe4+\tћd\xea\xbd3\xfd\xa6]y&\x06g\x00\x8c\x951(\x91\xf4\xe6\xd7\xd6\xe4ox\xf2\x93O\xf3\xee\xfeX\xfe\xf4\xaf\xbb\xd6\xe4\xdf\xf7\xe6+\xea\xef\xce>z|}^\xfe}/\x98B$+Qy\xdf\xd29\xfeEm\xda\xe7a_ؔ\x8e\xb4cv\xd8&i`]z\xd2\u00a0\x92ܟ\xad?ODHB\xff\x1c\xf9u+\x93\x94w\x84\xfcۍ|\r\xa9u\xd6\x12J\xb4i\xa0\"\xb60\xe9\xe0\xe2\x8a\xf4\x84\xb4\xc5\xea\x13\x04\xed\xf7\xa4$\xd3*v*\x8f\x04\xdd\xccM\xbb\xc9\xc5J\xd2\xc8\xfd)\xfe\xbb\xba\xe5Dw\x9cZX\x1d}8\x8a\x12\u007fV;\x1c\xc1\xe0\f\x80\xb1\xe2\xa0D\xe3\xcfy\xfe\x97\x1e*e\xbe\xdby\"\xb0\xc9W2\tz#þN\xa7\x10\x00@\x04\\W\xa2\x1d\xe4\x9b6[\xab\xd3\xc7\xf4{3\x85\xa1\xb9\xd1\u007f\x8a\xef\x12M)\x93@\x0e\x01\x98\xa2\xb8\xabD\xfd\x83M\xb3}\xa2S\xd4\x14\xa4\xa2SZZ!\x01\x00ƈ\xbbJTH\xc8m\xadD4Y\x19!9[Ӱ8\b\x00c\xc6]%\n$\xa6NG!\x92\xfbDI\xf7\x9cu\x8a\x01\x00D\xc4]%\x02\x00\x00;\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xc6I\x89>\xe6~\xdf1\x1a\x873\x00\x000\x18\x17%\xba\xf5B\xfe\xa7\xe6'(\x11\x00 F\xc6E\x89\xae\xeb+7*@\x89\x00\x001\x02%\x02\x00x\x8fgJԒ;\xb6\u07fcnqg퍡\\8\x99\x01\xe0\x1eNJ\xf4\xd1\xe3k\xf3V\x94\xfeH\x9d\x90f\\\xef_\x14\x9e\xfb\xe4\xbbk\xf3\xd6?\xf9\t\xf5:\xa3|\xa8g\x91\x95h\xa00ٟC\xfd2\xaa\xc9<uc\x85e}\xb4\xc0\x18\u007f\u007fv\x86\x94K[I\xdc\xed,\"2:\x02q\xb7\xfd\v\xff\xbe\xa5sҊ:\xd3\xfe\xa4,\x90\xe4\x1f\xd07\xb7\xa7\x8eZ\xe4Z\xe6\xcd^М\xd3\xea\x14\x06\xc0\x94\xc7A\x89>\\&\xac\xbao\x83 |\x8d\xaeOͺ\u07bf(|\xb7@X\xb6J\x106\\\x97~\xbcK\x10\x1e\xde\xf5\xb1\x9e\xa7\x86\xccK&\xf32\t)\x94\xa4\xab\t\x9a\xa9k&\xbf>\xda\xfe\xb8\x06it\xb0\x86\xf42ų\xffD\xd7ndd\x8c\t\xb0\xc4\xde\x1e\xad\xf15N!\x06\xb6\an\x9f\xb3\xb0\xbe1\x9b\x903\xd2e\xbah\xa4\xbe\xb6\xa3\xd4:\xc7\xea\x88\xc4c\x16\xb6\x9f\x14\xb7l'd\xf4\xf5\x00`\xaa\xe2\xa0D\x0f\vO\xcaݡ߮\x10^\xb7\xb8\u07bf(k\xd0;\x92\xf4z\x1e5\xfa\xb0\x8e\xceHF\xbf|!\xfaI\xad$\xadT\x8d\xa7O\xf3룝\xf7\x19v\xd4W\x17G\x1f\xa5\xf1\x86\xf4\x03\xaa\x8f\xa3\x8fQ\"&\xc0\u07bc~\xac\xec\xf0]\x96F\x89݁\x87\x92V\x8fHҵL\xd5\xefv\xd4v\xd8La\x03ʊ\xbbeP\"0\x03pP\xa2\xf5\xea\xa0\xebG\xbb~nq\xbd\u007fQ\x1b\x8e}\x9b\xae\x1a\x1b\xa6DJ?h?ɠff\x8a\x04\x95\x11Cz(%s\xaf\xe9\xc9>\xad\xd3\x14\tސ\xbeD]݈U\"&\xc0\u07bc~\xac\\\x9bk]p;\"v\a.OT$\xb6\x8a(?ҏA\x89\x8c\u008aS\xa9\xf5\xc0\x19R\x1b-\x1a\x80i\x81\x83\x12}M(}G\xb7.\xe3\\\xef_\xa4r$\xf3\x02]\xe8ڪD\x8b\x94\xf7\xe182@\x17{\x96/\xc1\x9b\xa9j\xcf@\xe3F\x92\xb6\xeetMV\xeb\x19r\xb65\xab\xd6bt\xaf\xdbԳ\x86\xf4\x94\xc1\xf8\xaf(\xef\xbe\xedZ,\x13\xc0$\xb7\x92\xf8\x9aM\xe9)+\a$\v\x03\x85\xa9\ti\xcb\x151\xd3=\xef\x99\x03\xf3u\x90;E\x89\x16\x13\x12>@/\x81\xaf\xa4^u)S\x9dZ\xbfZ\xa5\x14\xa2+\xd1P\"!q\x8dZyz,S.[X\x8a\xdaJ\xfb/\xb1G\xb3o(\x00\xa68\x0eJ\xf4N\x9e \xac\xd8\xf5c\xaa3\xbc\xeb\xfd\x8bZ\a\xe9E;%R\x9d}\xa4\fj伅\xdcOm|\xb2\xd9R{\x88\xb6\xe4\xb3XL\xe6\xcb\xff\xad\x13y\xa3{æ\x9e3\xa4\xa7;\xb4\x01\x93\x8f\xccklI+\xe4\x1c\xeb\x99$-,cOE\x86\xdf\xd2\xdd\xeaL\xca\t\xb4W(^؆\xe7=s`\xae\x0e2!k?\x86\v0J\xe0*iT}$\x8e\xb3\xdc6\xfaD\xa7C!\xbdGg\xc42\xe52\x85\r\x11f.ͮ\xbeL\t\x00Lq\x9c\xee\x9d}\xb8+_\x10\x84\xbco_\xb7\xb8\xdek\xa6\x1f\xaa\"Y\x95H3\x14\x9aO-\x16\xbbH\xeaM\xa9\x88p\x97e\xab\xdcY\xd28\x96@\x12T\xdb\x0f\xd3螱\xa9\xe7\a>\x97\x12\xb6\xaa\t\x1f] qS\xaad\t0\x93\xbe\x8ca\xf9RNϕXF\xd2\xef\x95\xfb'7\x9a\x86x\xcf{\xf3\xc0lR\xa2\x0e\xd3aS\xcbf\x00[\x82y`\xb3ꃄ\xbbCƎ\xce4\xbb4\xf64\xd9\x03\xeb\x85\xf5+G\x90FFF\"\u0557k(\x00\xa62NJ$\xcb\xcc;\xdf\xdf(\b\xffhq\xbd\x8f\xaaD\x0f\xa8\x89\fB}\xe23ɩ\x11\u007f<7-\x1d\xa4\xf6\x86\x94\xa12_:\x99\xeb\xdbN\x17^5\x8d\xee\x19\x9bz^\x89\xb6&h\xf9|\x9b$\xc3v\xd1^\x89\x94i\xa9Z\u00ad\xe8\xdaFz\xf5$\xebyo\x1e\x98MJT\x89\xc2\x1e\x160\x03\xd8\x12\xcc\x03\x9bU\xbf\x11o\xdf'\x92\f%bO\x93=\xb0^ذ\xa23E\xf2P\xedd\x84\xfar\r\x05\xc0T&\xba\x12\xdd\xfa\xa3\xeaz\xff#!\xef\xdfy\xd7\xfb\xa8J\xa4z\x1f\x0e\x11Bgd*\xc8\xd66\xdd\rQ\xa3K\xbf,\x03\xa9u\xfd\xa4\u007f\u007f\xea\x1e\x895uel\xea9\xa1\x11}\xfaS\x8d\xac\x01\xac\xbd\x12)\x17{'\xe7H-U\x13cއ\xf5\xbc\x8fhq\xdd\x1d\xee\xccf\x06\xb0%\x98\af\xaa\xae\xcd\x13\xddh\xd7\xca\nS\"\xf64mOH\x99'\x12\x9bI\xf9H\x84\xfar\r\x05\xc0T&\xba\x12}\"ܭ8.~(\b\xd7y\xd7\xfb\xa8J4[\x99\x13\xdeC\x94?\xe4\x83$}\xabe\x98s\u0378\xf7uC\xb9w\xa6\xd8\xf3\x98\x17\x18cS\xcf\x19җŝײ\x85]\xb8j\x80\x99\xf4)SUu\x8a\x95\xab\xc1IS\x98X\xcf\xfb\x88JT\xe1\xe3\xb2\xf3\x01l\t恙\xaa\x97\xfb\x95\xfa7\x11\xe5\xcdF\x89\xd8Ӵ=\xa1\xe24\xaa\x9cAz\x17\u07fe\xbe\\C\x010\x95q\xbcw\xf65Y\x8a>\xdd%<hq\xbd\xe7\x94H\xca\x13^\xb9\xae\xdfb\xa3w\xf1\xb3/S?Dm\xa6$\x97\xf8\x93,7\xa1\xd6e\x1a\x93\xacb\xb2\xe6:d^`\x8cM=kH/\xfa\x8cQ\b{\xe12\x8e\xf5fҗ6L\x9f\xe5Y\xacD\f~KU\xb0\xe1\xb4\xc5T\xf3\xbeR\xc6{\xdeGR\xa2\x9b\xf3\x8c_\xad\xe8%0\x01l\t恙\xaa\x0f%\x15\xcaG\xbb\xb9X\xd5\x10\x1b%bO\xd3\xf6\x84\x06\x94\xe7\xd0\xef\xa1Jd__\xae\xa1\x00\x98\xca8(\xd1ǫ\x84\xbc\r\x1b\xf3\x855t\x8a\x88u\xbd\xe7\x95\xe8>A\x10\xde\xd4\xf3Ԑ\xa5\x89\t\v҉>q]O,\xbf\xf4\x90\xa4\xb3qU\x96-\x9cѽaS/I\xa6!\xbd\xf4\x80>\xcf\xcd\xc52\x01L\xd2Gr\x9a곒\xd5\f\xab\xf5\xc1\xe1\xa9\xd9\xf3\x9fj\xbb\x9f\xd4K\x8c\xe7=S\x18_\xae<\x983\xbaPZ\t\\\x80Q\x02w`\xa6\xea\xc7\xfc\xb9\r-K\xe3C4_\xa8\x96T\x87Br?\xe7FW(\xe4+\t\x85\x86\xd9\xd8H'TM6\xb5\x96\xa8\xcfX\xdb\u0557o(\x00\xa62N3\xd6\xf4\xa7f\xf9\x1b\x9eT\a_\x8c\xeb=\xafD\x1f\x96\xe6\xaf\xf8\x89\x9e\xa5\x86\x94\xf7-\x9d\xe3_Ԧ}\x1e\xf6\x85Ϸ\xec\x98m\xd9\xc4\x1b\xdd\xeb6\xf5\x12cH\u007f5\xb1\xd86\xd6\b`\x93\xbe\aJ\x92\xe7\x16k\xbd\xad\x86\xd4:-\xe7\xc0\xba\xf4\xa4\x85A%\xa9{\xde3\x85\xf1\xe5\x86\xfc\xdaCOf\t|\x80^\x02w`\xb6\xea}K\xfdi\xab\xfb\xe5D\x896\x9fS$\xf7\x8d\xe2\xd4d\x1d\x1b\x1b\xf1\x84\x82\xf3\x12s\xdb\xd2\xdb\"ԗ?\x1a\x00S\x19'%\x1a\a\xce\xf3\xbf\xf4P)\xf3\xc5\xfa#\xd6r\xee\xe1H\a؇\xb0\xc7F\x93\xaf\x04\xee\xd2\x00\xb8\x85\vJ\xb4\x83|\xd3fkuz\x8c\xf3\xac\x9bbY\x0e䶕hh\xeem\xff\x14\x1f\x000j&Z\x89\xfa\a\x9bf\xfbD\xa7\xa8q綕\b\x00\xe0&\x13\xadD\x85\x84\x8cq%\xa2\xdb@\x9d\xd5\x05\x00L\x19&Z\x89\x02\x89\xa9\xae\v\x91:\xab;\xe8\x14\x05\x00\x984L\xb4\x12\x01\x00\x803P\"\x00\x80\xf7@\x89\x00\x00\xde\x03%\x02\x00x\x0f\x94\b\x00\xe0=\xe3\xaaD\xfaB\x8e\xd1y\x8e.}\xad1:o4\x00\xc04\aJ\x04\x00\xf0\x9eqU\xa2\x0f\x9f{\xdd)D\x82\x12\x01\x00\xc2\x18W%\x1a\x1dP\"\x00\x80\x85i\xa7D-\xb91\xfe\xb26*[b\xf9\xd9-\x88\xc2diɡ\xdcQ{\x81\x8f\x85\xc9r\x9aS\x0f\a%\xfa\x91\xf0\u009b\xeb\xf3\xff\xe1#u\xa1\xa2U\x0fiˡ}\xb4o\xfd\x92U\x0f\xabk\\3;\xe8<\xd1\x0f\xb4\x85\x8b\xa4Dž'%K\xb6w\x1eZ\xb5\xec\xc1\xdfZ\x94h\xa00ٟ\xd3 \xd1u\xc1\xe6\xa9\x1b+\xb8\x95Ն\xb6\xa4\xf9\x97\x8f\xdaG'0\xae\xbfr;Cʥ\xad$.\xd6\x05L(\rt\x15\xa2\xd4{{\xa4qf\x13!t\x95\xb9*B\xac\xdf\xf9\xf6\xd4\t\xbd\xc6n\x8f\xc9Ӓ\x818\xfbU\x16ƥ\xf9n\xe34\xc7H0^[\xfc*>\xbaǹF\xdf\xd29iE\x9di\u007fR\xd6\xcc\xf2\x0f8\x85+t\x12\x92+I\xcdr\x86S\x91\x83\x98\xe6c\xae\xd8\x18\x1a\xd5Q\x89\xbe\x9b/\bˮKo.\x13\xf27\xae\x17\x84\xefӭ\xaf\xe7\v\xcb\xee[#P\x8bjn\aU\xa2?\nyʲjחQ\x93X.\xdb\v\x82P\xb01/\ufadc\x12\xcdK&\xf32\t)\x94\xa4\xab\t\x9a\x1dl&\xb7\xb2\xdaҴ\xa7J\x129\x8f\x8e(\xec\x8fkp\n\x89\x8a\xc5\xe0\xbex\xf6\x9f\xe8\xcfi\x19qc\x02NE\xbd6\x86\x1bȷ:\x1brug\xb7qCL\n\xd0\xc6\x18\n$YW8h\x9d\xa3\u007f\x17\xa3\xd7\xcc\x1d&YK2\x87h\x8d\xb7\xb5\xf76\x9b/\x16\xc6\xef4\xc7\x18\x10 ڂ\xa0$`\x93A\xc5\xcc\xd6>ga}c6!g\xa4\xcb4\xdb\xe8~&>r\x92\xf8C\xd2p39iY\x04\x9a\xad\x0e\xd3|\xcc\x15\x1bC\xa3:*\x91\xb0\xfe\xf57_\x94>^&\xec\xbb.wjVQ\u007f\x8f?/\x13\x9e\xbc.\xddz\x8e\xae\xac\xcf\xedP\ue755\n?\xa69_\x176J\xfc\xde\xdf\nw\xbfxK\xfa\xe4A\x81S\"\x92\xd1/7\x90\x9fZ.\xafT-\xabOs+\xab\r\xd1\xc5S\xc3V\xb6\x8f\xc0y\x1fgz\x1d;\xbc\xc1\xfd\x80\xea!\xc9.1\xc2\x04\xf0\xb1a\xf4)\x16e\x8b\xb2\xa2\x06\x8d\x81lUk\xeb9/K\x1e\x87\x9a\x8d\vW\x17G\x1f\x05O\xb2\x96d\x0f\xb1\xc3wY\x1a/\xc6\xf14\xc7\x16P\xed\xd3\x16IO\xe4\\\xad8\x8clCI\xabG\xe8\xfa\xeeꢃ\xa3vH\x1f&\xc5%\xd4\x1a\xc3z\x19\xda\xd77\xa6+\xd6\xc4Y\x89>\xa4\xef\xfb\xb4\xfb\xf3?\xa1&\xd4O\xd2\xf5\xf5%\xaa9/\xf2;\x14%zQݻKx\xc1\x92m\x97\xb0\x8f\xa6?]\xc3+\x91\xd2\x0f\xdaO2\xa8\x8b\x85\"Ae\x84\x95\x93\x012\xea\xfe\x9d$\x95̽\xe6\x14\x12\x1d\xde\xe0\xbeD]Y\x89\xfdb\xd9z\x1a٢^?\xfb\xc9m\xd6(\x8cBuy\xf0\x1d\xbaS\xad\r\x0e5\x1b\x17\xfa\x88\xc5`\xd7\xc2$kI\xf6\x10\xd7\xe6Z\xd7U\x1f;\xe3x\x9ac\v\x18\x19\xd0$e\xc0\xd2aa0\xb2\x95'*\u007f>\xaa\x88\xe2W\x1c\x83\x12\x9dJ\x1a\xb1Q\"\xfb\xfa\xc6tŚ8*\xd1z\xe5}\xad\xe6uv\x9d\xda/n\xd0>|\xfc\xf1-~\x87\xa2D\x9f\xe6\t\xd4\x0e$\x9f\xbe\xb2{o\xad\x10\xfeU\xf9\xb0\x8fS\xa2E\xca\xfbp\x1c\x19\x90F\x92i\xd3\xdcL5\x97\x89\xbd\x91\xa2\x8e\x81\xcb\xe8J\x1fq\a\xa5A\x1f\x9dK\xe2\xad\xe1\x19\xaf\xfb\x1bI\xea\xd2ӽ\xf2\xd8y\xc7@q\x86\xff\xde\x1b\x15r\xeeF\xa9\x91\x18\xeb\xfb+؛\xcb\xf3\x06\xf7\xf2\x1f\x81\xf8\xaf(\xef\xbe\xed\xe1\xa6\xf5Lr+\x89\xafٔ\x9e\xb2r@\xe2P\xaf\x9f\xe2t\xee\x10\x92\x14Z\x9a\x9e\x90\xba<Ú\xcd\xd6\xf6ވeK(W\xff\x10\x15\x95\xb3\xa7)\r%\x12\x12\xa7x\xc1\xf2g\xa1gccm\xe1\x03\xcc\xfa\x0eo\x9f\x97tW\x97\xba\x96\xb6AMV\xeb\x19r\xb65\xab\xd6˖4j\xc6|5$ۦ\xb6VgG\xa2\xf5\xaa5\x9b\x8f?!\x1d\x17N\xd3\xfe\xdf-\xcaY\x98\x98\x92\xe2\x90M\xf3\xe0\xbbZ5\xc2gӿ}\x11\xber\xc3d0\xa7YW\"=\x96-\xd7l>\xe6\x8ae\xb62\x85E\xfc\":*\x91\xd2\xc1\xf9T\x106ާ\x90'\xbc)-\x11\xfe\x97\xbe\x9fߡ>\xd9\xf8\xb0\xdcU\x92{A\x0fZ\xf6~B=\xd3(?攨LMdP\xa3\xe5-\xe4~j\x9dÌ;zC\x8d\xa4\"Dm,\xd4\xd1wW\x89\xcfb\r\xcfxՄ8\xd0\x00\x00\t)IDAT\xddK=\xda\\\xc2HScFVRFY1\xb9t\xb5(74,\r\x87\x16\x15\xb1\x83\t{sy\xce\xe0\x9e\xee\xd0z\xf1\xf2w\xbc\xb1%\x8d7\xadg\x92\xb4\xb0\x8c=\x15\x19~\xbe\x93\xd0GZG\xcen'{\xb8C\xc8\xff\xfa_jn\xafK%7\xf8l\xb6\xb6\xf7f,[B\xfdB\xa9+\xa3KʩgOS\x1eӆB\xea\x9fb\xee,\x8cl\\\xac\x1d\\\x80y\xb4\xa1\xcc\xd4@\xdbVBj\xb9`\xb1\x98̗\xff['zؒf͘\xaf\x86}S[\xab\x13\n\xef\f\x18\xcdǝ\x90\x81\v\xa7i\xff\xef\x16\xe5,L\fIq\xc86\x12g\xefKl|\xfb\"|\xe5d%\xaaY\xae)\x91\x11\xcbU\xc7h>\xe6\x8ae\xb7\x8e\xe2\x8b\xe8\xa8D\xbb\xe8۟\x05\x93W\xe4\x0e\xce\xc7\xfa~n\x87\xa6D\xaf\v\xa5\x92\xf4\xa0\xf0\x13\xcbޏ\x04A\xcd\xf3:\xa7DZWe>5g\xec\"\xa97\xa5\"\xc25\x97\xd9\xd7c}\xc9\fkx\xc6랺\x82\r\xe8\xd9r\xc8\xd2ae\xb4ڠ\xfe\xa5\x9coq\xe2\x89`.\xcf\xf67/%l\xd5b\xd3\xe4\xd27\xf1\xa6\xf5\\җ!\x1fh(=Wb\xe9S\xfe6(~$\xcc!jS\xe9?rm2\x9f\xcd\xde\xf6\x9e\x89eJ\b\xa5J\xdb}ۥTEt\x8dӤ\xf8\xf5A\x81Q3\xfe\xdc\xd8X;\x8c\x00&[\xb1bGWfQ\"\xb9\xc6\t$A\xed'yՒl\xcdX\x1b:ۦ\xe6\a\x12\x97\x89\xdd<\xaa\xde|\xe6\t\xb1L\xfci\xda\xff\xbbE>\v\x13]R\x9c\xb2\r\xf2\xe3&=\x1b\xf3\xed\xb3\xff\xca\xc9Jtu\xf6UE\x89\xd8o*_\x1d\xe3\xdbǍδ\xad\xa3\xf8\"\x8eN\x89>\xa5c/\x9d[\xda\xdcQ\xd8\x0eM\x89\xae\xaf\x10\xfe\xf8oB\xfe\xa7\x96\xbd\x9f\xeaF\xb1?\xe1\x94\xe8\x015\x91ANJ\xf4\xae٩\x11\u007f<\xdb{\x89\xa0D%z\x92\xf1\xba\xa7\x13M\xc6B\x8d9>Mr{\xe3F\xae5\f\xdd\xf01a|\t\x9c\xb9<۶[\xf5e\x1f\x15\x13\xec\xa8\xde\xd7\xca\xc4V-\xe1\xee\xf0\xf5\x91\xaa\xae\xd6\\?-\x839\x8487sk}\xaf\xe6zkd\xb3\xb7\xbdgb\x99\x12.\x91kw}iѰ\xfa'\xc58MJ\xb8\x12\xf1\xe7\xe6\x8b\xd0\x1d\xd21\x02\x98lj\x99\xfd\x16%\x1a*\U000e54f9\xbe\xed\xf4\x84\xbdjI\xb6f\xe6W#BS[\x95\xc8\xee6\xbb\xa1D\xc6\t\xb1L\xfci\xda\xff\xbbE>\v\x13]R\x9c\xb2݈\xb7\xed\x131\xdf>\xfb\xaf\x9c\xacD\xd2\xf2jE\x89\xd8oj\fJ4\x8a/\xe2\xe8\x94HZ\xa3M\xf8H\xef\xfc\xf1ߥ\xf5\x82\xfa\xa3\x8eW\xbe\xf6\x02\xbfC\xfb\xdd\xd9w\x85\x17_\x14\xfeњ\xed\xd6*A}\x00\xe9\xfb\x9c\x12\xa9\xa6\x88C\x84пp\x15dk\x9bn\x93\xa8a\xafDF\x92\xf1\xba\xa7}*\xa3ם\xa3\x8f\xa6G\xe2\xfb\xaaȎ\xb3q\x96\x99\x01\xb3\x04\xce\\\x9ei[ѧ?\xb0\x13f\x15-Y\x92j\x17\xb4\xd3tj\xa4(\xb3\x1bCq\xd4،=\xc4Pݺy$-\xc0g\xb3\xb7\xbdgb\xd9\x12|}I=I}\t\xca\x03\x1b9\xec\xa4A\xb8\x12\xf1\xe7\x16>\xc1\xc0c\x04\x98\xd9.\x13\xc5\x1dnآD\x81Ժ~ҿ?\x95\xb7\xafu\xb5%\xb9\x9a\xd9ׁij\xfe\xa2\xe9\x0e7\xe0\x93\x18%b*i2\xf1\xa7\x19\xe1\xdf-\xe2Y\x98\xe8\x92\xe2\x98M\x9b'\xba\xd1\xceec\xbf}\xb6_9\xaaD\xcdي\x12\xb1\xb11(\xd1(\xbe\x88\xa3T\xa2o\v\xf7ݢ\xef?\xa7w\xee\xf7i\x0f/>$<\xc7\xefД\xe8\xb7\u0083\x0f\xaa\x96\xb0\xdc\xde\xc7Uu\xba\xbe\x9eS\xa2\xd9ʈr\x0fQ\xb4v\x90\xa4o\xb5\xf4\x9c-J\xb4âD'\xd9\u007f\xcdk\xe6M\x8b\x1cc\x9c?\xaf\xf1\x9eE\xf3\x82\xf3$\x1e\xb3\x04\xce\\^i\xdb\x06E\xb2\xcb\xe2·\xc5r\x01fҧLv\xd5\xf1\xf7\x16\xd4y\xd6d\x9a\x979\xc4i\xfa\xd7p\xb8\xd1_\xcbe\xb3\xb7\xbdgb\xd9Jf\x05\xe6J\xe9Uj\x0e\xf34%\xab\x12њ\xf1\xe7\x16\xe5n\x9b\xc4\x05\x98\xd9n&*eZ\xfbD\xf2\x1fMz\xefL\xed\xd9yӒ\\\xcd̯F\x84\xa6f\x8fFk`7F\x1d\xad\x12M\xd4i\xda\xff\xbbE>\v\x13]R\x1c\xb3\x95\xfb\x95J7\x91\xabl6\xe6\xdbg\xff\x95\xa3JtmN;\xad.\xfbM\xe5\xab\x13U\x89F\xf1E\x1c\xa5\x12}\x98/<.\x8f\xad~\xbbJ\xf8\xae$}\x9c/\xfc@y\x9ehٟ\xf9\x1d\xfao\xf1\xd7\xe7\xe5\x15\xdc\n\xcb\xf6\xd1\x12\xe1\xb9[ҧ\xbb,\xcf\x13e_\xa66\x87Z\xeds\x89?\x89ｘ\xe7E=Yo.\xb4(\x11\xe3u/\xb3.\xf3\xa6\x16l\xcau\xd1V\xdf1\xb2\xd5\xfa\xe4\x83Y\x02g.ox\xd2\xcb\u007f\xe1J\xc2c\xd9\x00&\xe9K\x1b\xa6Oi,V\"\x06\xbf\xa5~!\xd5\xeb'\xad\xaco\x0f{\x88\nrLɻ\x85\xcbfo{\xcfIJ\x95\\\x9e[(\x15\xe6.U\x0eb\xffWɨ\x19wnl\xec`\x85\xe5\xcf1\x17\xc0d[\x97J\xbf<\xc5a\xf3D\x92\xa8L\xd3H\u07b5$[3\xf3\xab\x11\xa1\xa9٣I7\xe7\xa9\u007f\xd8-\x8cV\x89\xc6\xfb4M\xec\xfe\xdd\"\x9e\x85\xde:\x92))\x8eن\x92\n\xe5\xab\xe5\xe6\xe2L.\x1b\xf3\xed\xb3\xff\xcaQ%\x92J\x8a\xc80\xffM\xe5\xaa\x13]\x89\"~\x11MF\xa9D\xd2\xebK\x84\xfc\xfb\xd6\v\xc2\xd7\xe8\xfd\xaf\xd7\xf3\x84\x15\xf7\xad\x12\xf2^\xb7\xecЕ\xe89A\xf9\xa5\x875\xdb+y\u009a\u007f\xc8\x17\x1e\xe6\x94hib\u0082t\xe3\x1e{=\xe1~\xe9\xa1\xcd\xc4k\x9d\xc8\xd4\xca=\xb9$\xbe\xa1\x9f\xb3\x86g\xbc\xee%\xe9l\x1c\xfd%\x045\x9f\xa7\xd3\xfa\xea\xa8\xfd[\xfe\xe4\x9bY\xfe=l\xa9\x91\xcd\xe5MO\xfa\a\xf4\xd9\xefH\xa6\xf5L\xd2Gr\x9a곒\xd5\f\xab\xb5\xe1e\x9f2\xabw\xcf\xf2\x92\x05\xec!*HREk\xb0D\xb9\xc9\xc7d\xb3\xb5\xbdgc\x99J\x96\x91\x80\x14\xa0w\x19\xd9Ӕ\xd3!_I(4\xcc\xd7\xcc\xc8\xc65\t}\x884iH\xe2\xe0\x02̣\x89i\xe9\xb5ͫ}\xe1J\xa4\xe1]K\xb253\xbe\x1a\x91\x9a\x9a=\x9a<\xa2\x0f\x93a\xb3\xf9\xf8J\xeaL\xe4i\x9a\xd8\xfc\xbbE>\x8b\xd5\xc64FO-\xa9>\xad\xa4\x1c\xb3\x1d\xf3\xe76\xb4,\x8d\x0f\xd1Z\xaa\x8ff\xd3\x1e\x8d\xf1\xed\xb3\xffʍ\x9c$\xcd\xc3Rg\xa2҅3c\x99r\x99o\x1fsŲ\xdf\xc9H_D\x93\xd1*\x91\xf4\xd1\xe3\xeb\xf3\xf2\xef{A\xbd\x11\xff\xe1\xe3\x05ykv}hݡ+\xd1\xc7\xe6\x9c6\x97\xed_w\xadɿ\xef\xcdW8%*\xef[:\xc7oX\xbb\x0f\xfb\xb8!\xfcH\xb22\xba\x8cW\xee\x14\x0e,\xf6'--\x0f\xf3\xafg\xbc\xeeeѝM\xb3\xf7\xaa\xe6\xf3\xea_\xbe\xd3\xc9ߔ\x02I\xdd\x12KDsyÓ\xfejb\xb1m,cZo&}\x0f\x94$\xcf-־\xb9\r\xa9tBC\xee\x01\x13\xfa\xfc}_Vj+{\x88\x83\x8b+\xd2\x13\xd2\x16wZ\xb3\xd9\xd9\u07b3\xb1L%[\xfd\xbdRߜ\x16\xfe4\xbb\xd54\xa9\xe3kfd\xe3\x9aD\xaed\x12\xe1[\xc4\x12`\x1e\xedjI\xba\u007f\xe9\xe9\x88J\xe4]K\xb253\xbe\x1aR\x84\xa6f\x8f\x16\xf2o\x97\xac\x98\xcd\xc7WRg\"O\xd3\xc4\xe6\xdf-\xe2Y\xe8\xad#\xf7\xad\x92\xe4C%\x0e\x8f.[\xdfR\u007f\xdajY\xb0\x95ߝQ\x94\xc1\x82\xfe\xed\xb3\xff\xcau\xcaaM\xd2\xcdܴ\x9b\\,S\xae\xd9|\xec\x15\xcb}'#|\x11M\x1c\x94\xc8m\xces\xbf\xf4\x18\x03e\xbe&\xa7\x90QQn>^\xe9\x8c9=\x15\x13c\xcc6.\x04\xc3\x1e\x98\x8d\x86u\xc6:\x16&\xb6%c\xafY\x93\xaf\xe4\x86S\xcc\x18\x98\xd8Ӝ\x01L2%\xdaA\xbe\xe9\x14\xe2@u\xfaU\xa7\x90Ѱi\x934z\xc6\xf8\xc5\x1ac\xb6\xf1\xa0!y\x8bS\bK\xec\u05fb\xc9Ķd\xcc5\x1b\x9ak\xffS\xfc\xdbe\x8c\xa792\xa8\x12\xf9\xa7\x1a3\x85ɤD\xfd\x83M\xb3}a]\xd6)@\xcc\u05cf\xca\x18\xb3\x8d\x03bjYL_\xfd\x98\xaf\xf7\xb1\x12s\x93\xb8V\xb3q\xc5<ͻ\xb4A\x92u\xf2z\xe61\x99\x94\xa8P\xfe\x17\x89\xf5\x9b8\tPg(cf\x8cټ`\xe0\x18)s\xa3\xaa\xb17\x89[5\x1bW\xd8\xd3\x1chQ\x19\x88\x96aF0\x99\x94(\x90\x98:\x05\x85H\x9d\xa1\f\xbf\x17\xe0\xc4\x18\xb3y\xc1\":\a9\xe0\x14u\xfb\xc4\xde$n\xd5l\\\x89\xfd4g\x02\x93I\x89\x00\x003\x15(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\aJ\x04\x00\xf0\x1e(\x11\x00\xc0{\xa0D\x00\x00\xef\x81\x12\x01\x00\xbc\xe7\xff\a\xfd\xa4@\x82&\x8eJ\xdf\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/chan2b.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x04Q\x00\x00\x011\b\x03\x00\x00\x00\x83\v\xcdh\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x03\x06\x02\b\n\x06\x0e\x10\r\x19\x1a\x18!# #$\"$%#%'$&(%'(&()'*+)+-*,-+-.,01/2313425747968:7:;9<>;>@=AB@CEBEGDFHEIKHKLJMOMPROSURUVTVXV,`\xae7]\xad[\\Z8^\xae8`\xaa]^\\:b\xab;b\xac<c\xad_a^Fb\xa1=d\xae?e\xb0ac`Kd\x9dAg\xb2cebefdCi\xb3fheLi\xafDl\xafMk\xb0Fm\xb1ikhei\x8fjliGo\xb3Ip\xb5lnkJq\xb6ll\x8dnolKr\xb7pl\x88Us\xb3Vu\xb4xp\x84Xv\xb6surZx\xb8uwt[z\xba\\{\xbbxzw\\}\xb7\x8evve|\xb8^\u007f\xb9{}z\x95wq_\x80\xba|~{a\x82\xbc~\x80}b\x83\xbd\u007f\x81~c\x84\xbed\x85\xbf\x81\x83\x80k\x86\xbb\x84\x85\x83m\x87\xbdn\x88\xbe\x86\x88\x85p\x8a\xbf\x87\x89\x86\xb3\x81_\x88\x8a\x87q\x8c\xc1\x8a\x8c\x89s\x8dË\x8d\x8ay\x8e\xbe\u0083Wz\x8f\xc0\x8d\x8f\x8c|\x91\xc1\x8f\x91\x8eƇT\x90\x92\x8f~\x93\xc4x\x95Ā\x94Œ\x94\x91z\x97\xc6{\x98Ȕ\x96\x93\x96\x97\x94\u074bE\x81\x9aė\x99\x96\x98\x9a\x97\x84\x9c\xc6\xe1\x8eA\x9a\x9b\x98\xe9\x8e<\x86\x9eț\x9d\x99\x87\x9fʜ\x9e\x9b\x9d\x9f\x9c\x89\xa1˞\xa0\x9d\xf6\x935\xa0\xa2\x9f\x90\xa3ȡ\xa3\xa0\xa2\xa4\xa1\x92\xa5\xca\xff\x952\xa4\xa6\xa3\x94\xa8ͦ\xa8\xa5\x96\xa9Η\xaaϨ\xaa\xa7\x98\xabѩ\xab\xa8\x9d\xac̪\xac\xa9\x9f\xaeά\xae\xab\xa0\xb0Ю\xb0\xad\xa2\xb2Ұ\xb2\xaf\xa4\xb3Բ\xb4\xb1\xa5\xb5ճ\xb5\xb2\xb4\xb6\xb3\xab\xb6ѵ\xb7\xb4\xac\xb7Ҷ\xb8\xb5\xad\xb9ӷ\xb9\xb6\xb9\xbb\xb8\xb0\xbbֻ\xbd\xba\xb2\xbdؼ\xbe\xbb\xb3\xbeٶ\xbeӽ\xbf\xbc\xb8\xc0տ\xc1\xbd\xb9\xc1\xd6\xc1ÿ\xbb\xc3\xd8\xc2\xc4\xc1\xbc\xc4پ\xc5\xdb\xc4\xc6ÿ\xc6\xdc\xc0\xc8ݻ\xca\xde\xc7\xc9\xc6\xc5\xc9\xd9\xc9\xcb\xc7\xc0\xcc\xda\xc7\xcb\xdb\xca\xcc\xc9\xcc\xce\xcb\xc3\xcf\xdd\xca\xce\xde\xce\xd0\xcc\xcc\xd0\xe0\xcf\xd1\xce\xc6\xd2\xe0\xd0\xd2\xcf\xd1\xd3\xd0\xc8\xd4\xe2\xd2\xd2\xdc\xd2\xd4\xd1\xd3\xd5\xd2\xcd\xd6\xde\xd4\xd5\xdf\xd5\xd7\xd4\xcf\xd8\xe0\xd6\xd8\xd5\xd8\xd8\xe3\xd2\xda\xe2\xd8\xda\xd6\xd3\xdc\xe4\xda\xda\xe5\xd9\xdc\xd8\xd8\xdd\xe0\xdb\xdd\xda\xdc\xde\xdb\xdc\xdd\xe7\xd9\xdf\xe1\xdd\xdf\xdc\xe0\xde\xe2\xdb\xe0\xe3\xde\xe0\xdd\xdf\xe1\xde\xdc\xe2\xe4\xe0\xe2\xdf\xdd\xe3\xe5\xe1\xe4\xe0\xdf\xe4\xe6\xe0\xe5\xe8\xe3\xe5\xe1\xe4\xe6\xe3\xe8\xe5\xea\xe2\xe7\xea\xe5\xe7\xe4\xe3\xe8\xeb\xe6\xe8\xe5\xe4\xe9\xec\xe7\xe9\xe6\xe8\xea\xe7\xeb\xed\xea\xf0\xf2\xef\xf4\xf7\xf3\xfa\xfc\xf9\xfe\xff\xfcS\x19\x91\xf7\x00\x00 \x00IDATx^\xed\x9d}P\x14\xd7\xde\xe7\xcdݧQ\t\xa8\xf8\xae\xb9r\x91\xd82\x16\xb8S\xd9I\x14\x1c\xf7֔\x0fٰ\x9aD\xddK\xb6\xa2\\\xa3\x0fX>IH=\x88k\x89Z<P\xeel\x15(W\x85X\x18//F \xa5\x80o1\xbe\x11\x1c\xd1@\xe2\vP\xb7\\ū\xa5\xa4H\x95rE\v\x84\x92\x02\xce>\xcfsS\xdb\xe7\xf4L\xf7\xe9\x99\xd3Ӄ6\r\xcc\xfc>\u007f̜9\xfd;\xa7\xcf\xe9\x9e\xfe\xce\xe9\xd3=\xfd\x1d\xf3\xeb+\x80\x00\x00\x00h\xc6h\xa9\x867\xb4*\a\x00 \xc0\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05xE\xfa\xb5\x02\x80@\x02\x14\x05x\x15Z\xe2\xa7poi\x05\x01\x01\x04(\xca\b\xe6PD\xabV\x881\xb4E\x1cb/\xe8\x9f=\xdb^\xde\xc4^\x06\x04$\x06)ʱzW\xaa\xfe\xf0\xee\xfc\xf38\xd1Q\x95o?t\xa9\xc7-\xa9\xc6\xdfv,\x89I\xee\xf3\x16\xe1A\xe1XNd\xec\x01\xadPL\xdd\xfc\xd0)\x8b\x8fM\xb9\x87\xe2\x85\"\xa1\u05f5\xc2\tG9.\xa2\x1f\x1d\x10\n|\xa3\x1eT>\xb9ȕl]1%dA\xbf{\xae\x1a\x9b\xb9\x8dZ!/AM\xdc\x19\xad\x10\xc2i\x13/b:!4%\xe8\vf\xd0%\xee03\x1f\bX\x8cQ\x94{\xd9߉\x89\x9er\xfb\xa9\xa6\x8b\xd97\x10j\xcf=T\xd7t~wa\x8f\"\xa9\xca'q_\xa7\x9b\x9fx\t\xf0d3WU\x95\xc9m\xad\xaa\xe26\xab\xc6\x1c\xbd\xe8J\x1d\t\x8d\xb0\xef\x9f\xc3q\xf5\xe8\x16.vJ\xb5\bMW9\x17R\x85:\x0ep\xe5]\xca\x05r\xbd\b\x95\x84J\x8a\xf6\xe6\x94\xcc\xf8\x906\xf7\\\x152\x83v\x8b\t\xba2&\xb5\xd7\x06\x11p\xd6|B=\x90\xe2 \xefp\x94\xf2\xc5\x0eǼ\x83§\x92\xb1\xdbYA\xdfq\xc7Y\xd9@\xe0b\x88\xa2\xb4\xe4\xbb\x14\xa5\xdc\xde\"\xfcRg\v#\x96o\xf2\xf1ou\x9b\xfd\xbc\"\xa9\xc6c\xbe\x14\xf5u\xaa/g\xb1u<B\xdfbi\b٪\x1a\xf3\xbb\xc5\xceD\xdbķ\x04Q\xe8\x98ɑ\xc1Է>*\n\xea\xe0\x96\xc6#\xd4\xc4u\xb8\xe5K\xf5b\xa4\xa9\xcb6n;\xeaw\x85jMh\xde\x18\xbf֙RT&\xd3\x1a\xe9:'Z\x9d\xca\f\x90Q\x04\xf88\xd2+6!\xd4\xc0_E\xc8\\\x8c?\xae\x0f\xbe\xc5\b\xf2yC\x01\x81\x82\x11\x8ar,\xfb\x98]T\x94\x96\xec\xef\xf1\x1b\xfe\x95.\xcc'9G\x8b\x14I5\xee\xf2\xbe\r\xd5i\xban8\xbf\xf17\xdc\x06\x10\x14\xe1\xef8\x13kC\xee\xe1\xb7-\u070f\xf8\xcd\xe7\x03\xa5\x83\xfbf\xc2S\x86\xa2H\xf5*\xb8\xcei\x9e\xe9\xc8\xc4OuUʮ\f\xd5qu\xce\xd4J-E\xd1\f`\xd0}ש(w\xbb\xf1ǎ\xa9\xf1\x8c \x9f7\x14\x10(\x18\xa1(]OQ\x9e\xa8(\xa7\xec=\xae\xdf\xe6\x96;\xe4\xed\xe4\x01E\x92Io\xacxB\xbf\v\xa1\x9d|T%\xbao\xe2\x97㤩lW\x82y\xc3\x03\x12s75\xd6\x14\x97\xfc\xc0\xbd\xa8\xfc\x8dϋ\b\x9d\xb5\x8a\x1c\xa3\xc7\xe7O\x1f\x17\xb6`\x06BE\xcey\x96p!s\xa6x\xbc\xb4n\xe9R\x16\xcb\f\x0f\x9d\x93\x89\x14\xc5\xe8\xca:\xb8\xa6\xf0|\x97\xa2\xb8b\xe9z\xdbB8.h/^\xda\x13&\xe6\xaeR\xe4R\x95]\x1a\xcbq\xeb\xaf/\x9d\x112\x1f\x9f\xfe\xf5L\xfc\x98,\xa5+\xa3\xd8>\xab\xa8\x9e\xab/\x99\x95\x89\xce8\xa7;V\xe3쁊Ds®\xe78yy\x83\xcd\x14\x9bl\x1bP\x04<1\xf3x\v\"\xb7\xcd\xf78=֖\x93\x13k\xaeV\xaeDT\x14'\xebC\x18\xc2|\f\x14\x05Pb\x84\xa2\b8\x15\xe5PQ}\xa1}\xefI\xf9\xabٿ\xb7\x8a\x91t禣\x92/p8~F\xe8\x81\xc3T\x80\x06\xaen\x8bF\xa8\xb9\xd2\xc4\xc7\x15\xfc\xd9\xf2\x19\x8e\xa85\xaf\xfe\xaa\xa6\x80/v/)IC|\xd0\a%\xdb'\x87\xf7\xe3S\xff\xf8\x03\xe5\xf60\xae\au\x9c\xac\x9a5\xb7\xaa\xaaJ8\xd1\xe9\nR\x9c\x19\xc9łח\xac\x0f\xfe=\xa2\x8bѕ\t\x8a\xb2}\x81SQ\xa4X\xaa^\x84\xceWU\x05o\"u}_\xb5\x9f\xdbTUբ̕+\xeb\xca\xdf;c\xd6\xc4髖r\xf8\xe2\xc9E\xee\x18Y\xac\xa8L\xa6e)\xf7\x06\xf7[n\xf1\x1d\xd4yő\x90\xe4p8n\xe3쌨\xacs\xa5q+\x85\x13\x9b\x9f楟\xa8)\x8b\xe5_(\x03\x1a\x1c\x8e\x98\x02\x9c\xa07_\xefrk\xe9\xbe\x18s\xd9\x06\xf7\xedG+\xcaI\x0f\xf1\xe8\xb9w\xecw\x93\xdcGg@\x80c\xac\xa2\xe4\xdb\xf3.ݪߛ/\xcd\xc1\x9e\xccmc$=\x91\xcfz\xa2\xf1\xf1P\x10M\x92\x16\xe1\a6=NHuے\x85\xa1yo\xf5c\xf7r.i(\xe2rɧ\xfd\xc2Hb2^{\xe6$2Vr\x9dP4q\x87X\xc5\x0esG\x84\xd7#\xf8\x82\x06U\x8c\xaaLP\x94{\xaf\xdf#\x8aBź\x9d\xa8\x848\xb5Cy\xd6\xe3̥*\x13\x8aqo\xb6\x89'\x85\xa8\x84\xbb\xe1\x8ad\x9f\xf5\x1c\x1eǍs^h\x91Nj\xce\xf2\x15\b\xeb\x800\n)\x8d{!$K-}\x8a\x00\x8c\xa8(\xf4\xe6\xab\xe6\x1b\x85P\xbe\x19\xb9C+\xca-\xce}\f\xf9\x960t\x1a\xc4i\x1c\x10\x10\x18\xab(E\xf6v\xe1\xb5#\xf7[g\xf6\xa9l\xe9^\x06*ɀ\xad(\xe9\xae\xe4\x05\xfe&\xbb\x9cK\x1a\x16\xcf\xec\xc1L\x13\xcem\xeeL\x9d\xb1\xc2\xfe}\xbf(j\xae\x83\xb5g,s\x8c\x12\xff[\xf2\xf6\x86\xb2\x18U\x99\xa0(h\xc1V\xa2(T\xec`\x14\x85\xaaL(\x16,m\x84BNJ\xb2\x14\xa5m\xd5\xf8i\xdc\xd4\xe0\x8f\xc8\xe4\xac$\x18i\xef\xf6\xbe\x10\xb0e \xf4к,\xab\xecf_/R\x04`$E\x916_\x8eEx\xb9͟F\xee(\x15e\xbf\xdbҦ\xc3ٳ\xc3`\x8c\x02(0VQ\x8e\x15\x8ao\x87\xc8[\xcfQ\xbbk,O%\x99\xb0\x15EJ\x16\xf3\xdd\xecr.i\x98㜍\xc0\xb7w\xb6e\xbf3\x9b\x9b\"^Q\x96\x0eV\xe7<J\xcf\x11E\xb1\xb9\v\xc9ۂ\bE1\xaa2\xac(\xf9s\x88\xa2б\x83P\x14\xbae(\\\x9e-9%\x9fd\xb0\x14esXv=W\x9f\x19\xf69\xfe \tƇ\xce)\x93\x14!\xfd\xa4,5\x81_rp@\x11\x80\x91\x14E\xde|\xf3\x1ecU\xf6>F\xf9\x96;\xe9\xb1\x1cUq\xdf\"\x00\xa00VQ.\xee&\xe7\x1a\xe5\xe4\xc0zZ\x94\xd7\xe2\\L%ٸ)\xca\x1e7E\xa9\xe1U\xee\xc8pI\xc3ҙ\x17\t\xc2O\xfay|Q\xb6m\u007f\b\x99o%\a\xab\xbdI\xba֓ϵ\xd2\xc5\xe2g\x92\xb7\x19\xf1\x8abTeXQ:B\xcb\xc9\x18E\x8e\xa5\xea\xc5xU\x14\xaa2\xa1\xd8\xdb\xd2\xe2\x8e`\xe9\xf66Ee.zȵ\x1eq\xa4E\x04\xa3\xe2!\x1e\xa3\\#\b\x02ѐ#hɓʘRE\x00\xc6SQ\x1eF%?lLH\xf4\xbc\xacL+ʧ\xe3\xdb=\x96õ\x1e\xc0\x1dc\x15\xa5\x8d\\=n'w\x9e\xb4\xee? |E\xfb\xbb\x94I\x15dE1\xe7 \xd4\xf7\a7E\xe9\xb4&\xe1\xe1}V\x96{9\xd77\xfe\bG\xaeP\xffQ\xf8I\xdf$\xcetD\xae \xaf\x91\b\xdd\xc3\xcb\xda&\xbe-\x1c\x9d\xfd\x913\x14\xc5J\xc8H\u007f?W\xa2(FU\x86\x15\x05\xc5/ƊB\xc5R\xf5b\xbc*\nU\x99r4\xb2x\xa6\xeb\x8e\x15Ee2w&\xddq\xa6\x92\x92\x10z\xc4Wce%Wkr\x0e\nۅ\xbf@\x16\xedP\x04`<\x15\xe5\x1a\xbf\x84\xe7\u05f9.\x945}!\xcd\xe0P\x8a\xd2?{\x01\xf2\x04\x14\x05p\xc3\bE\xe9ji\xc9=\xdaB\xc6\x00\xe7\xed\xe7o\xd5\xe5\xe1\xbbc\x9b\xec\xfb\x9bZZZN\xe6+\x92l\xc4k=W\xc9ohb\xdc\xc1\x82D\xdeT\xd1\xfc\xb3ô\xed\xea\xc0\xcdm&|\r\xa86f\xf9\xd7\x17\xb2\xf82\xb7\x82\x173\xb9\xad\xe2}sk\xb9\xc5\xf9\x87\xe2\xb9<,\r\x136\x96\x14Ƌ\x97R6\x06o)|3\x14\x1f\x99\x87C#r\x0f\xcd\x1f+\x8c\xec\xef8o\xb5Ń\x82\xa5Ak\x8b\xd6\x06-E\xcabRe]\xe5܁\x0et4\x84\\\xeb\x91c\xa9z{NUU\x05\xc7W\x1dos]\xeb9\x85u\x82ʕ+\x132\xf1U\x1d\xd7X\xe4Ǡ-Δ\xdcH\x15\n\xa2\x8bO\u007fb\xc6C\x90\x9cyi'Ng\xe0\x99\xd9\x02\u07bc\ufb10\xacU\x04\xf4^u8b\xb69.?C\xf4\xe6\xbb\x16Ss\xce\xf1\xc05DYȹ\xb4\xe3f)_\xdc\xe0Lo\xe5Xw\xee\x9eg\x9d\n\x01\x81\x8c\x11\x8ar>\x1bC&eэC\xb9\a\xce\xe3\xb1\xfa\xe1l\x91\"E\x92I\xb7E\xfc\u007f\t\xb9\xfcy7)Ʋa\x0f\xcf\xef܉\xb3\xfeb\x16^w\nٷSm\x96D\xf7\xa9Ŏ\t\x1c\xc79\xefz?\x12\x196i.\x1ef\xe4\xcd\xfdt\xfa\xb8)\x91\xe2\xb5ٮ\x0f\xc2B\xe6\x8aS\x01\xf8\u007f=\v\xf1=c\xf1Ι\r|\xa7j\u007f\xe6\x9c\xd09\x99\xfd\xee\xc5\\\x95\x1d\x13\xc2\xf2Q\u007fĔ~E,U\xefwAbe٨k\x12I\x8c\xadW\xe4R\x95]\x123\xa5\xa1\xc0\xfaםG+\xd5H6\xddY\x8bb\x92\xc4C\xbff]\xace\r\x1e\x9dT\xac)\xb0\x99\xacI\xb5ʀ\x9f\xa2ĉ\x962Do\xbe+\xe4/<\xa65\xe2DJ\xee\xe4l\xb1\xda\xe7x\xa9\xf9\x19I\x1f\x0f\xf9\xc8}\xad\x98{c߹tO\xeb\xee_ \x900BQ\x80\x97c\xd5x\xd5Q\x9b\xae<2\xefx\xf4\xe2œ\x9f>[\xa4\xfaǩ\xfd\xe3\xe3{\x10\x8b\xc2\xd9\x1c<\xcd\x00\xa0\x00E\x19\xc1l\x9dvO+D\x0fN\x8b7\xad\xa0\xbe\xd8\v*\x11mS\xd9\u007f=\xc6ܻ\xe4}R\x1d\b,@Q\x80kQ\xe2\xe9Ns\x94\xca]=\x00\xe03\xa0(@_\x86yGum\xf5\x0esƀV(\x00h\x00\x8a\x02\xa0\x813\x1b\xac&k\xf2Y\x10\x14\xe0\x95\x01E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x19\x1d\x9cI|\xa4\xf8\xac\xea\x1b\n\x00ÊA\x8a\xe2ݥ\xb4\xe5\xc8^{\xfeI\xc6#\xc2\f\xa0i\x1c7\xdb#\x93r\x13\x1d\f\xbeZ\xa9*\f@}\xe2 _\xe0vC\xab\x9ao(\x00\f+\xc6(\x8aw\x97\xd2{\xd9%\xf5w\xea\x0f\xec}꽒!\xe2T|\xb0G\x1e\xe5&:\x18d+UﾡJ\x03P6\x8a\x1aJ\xa3*<rU|C\x01`X1DQ4\\Jod\xe3\xe7\x93=\xcd\xf6\xfa\xec\xea\xa1c\x93\x87\xa2(\xdcD}\x87\xb2R\xf5\xee\x1b\xeaf\x00ʄ\xae\xe1\xae)\x87\x91\xcb\xf6\r\x05\x80a\xc5\bE\xd1r)EdpҚ=L\xcf\xd9\xf0T\x94A\xb9\x89\xcaPV\xaa\xdemA\xdd\f@\x99\xd05dX\x9f3rپ\xa1\x000\xac\x18\xa1(Z.\xa5$\xe6V~\xd1\xe0'.^\x95\x96\xa5S'\xbd\xed<\xebq\x99\x85\xd2n\xa2j\x16\xa2\x12\xcfR\xad&[J#RX\xa9\xb2}C\x1bM<\xbf\xe7n\xfa\xb2\x98dl\xcd%?\x14Z\xcbXT\xa8\xda\"\x0eQ\x94\xb9*\xbe\xa1\x000\xac\x18\xa1(Hӥ\xb45;;;\xd7\xf8\x99\xd9\xeb\x13g\xe5\x1e\x9a\xcf\x11E\x91\x9dGi7Q\x15\vQ\x89\xb3|FmuJ\x14~\x84\xabl\xa5\xca\xf6\r\xed\xae\xae\xb4%Xl\xbb\xd2\xe6\x11\x97\vIQ4\x8dE\xd1M\xdeAޕ\xb9,\xdfP\x00\x18n\x8cU\x14U\x97\xd2֖\xba\xfc\xbd\x86K\xcaܙ\xc2\xe8\xa3\u007f\x0eV\x14\x85Y\xa8t֣f!*\xf1\xbc\xbaS\x18e\xbc\x9fB>\xb0\xcez(\xdfP!\x97\xff\xe4\x19\x1a\x10\x1f\x05\xedR\x14\x1f\x8cE\xcf\xf1\u007f\xf5\xa8\x17\xe3\xe9\x1b\n\x00Í\xb1\x8a\xe2ť\x14\xf5\xe4\x97{\x96\x1bR\xda8;~[\x8f\x15Ea\x16*)\x8a\x9a\x85\xa8\xcc\xe3\xd2\xe4w-\xfc\x87$\xcdR\x14\xca7Tȍ~(\x15t)\x8a\x0fƢ\xa7\xf9\xfb\xae\xa4\x9b\xa2\xb8\xfb\x86\x02\xc0pc\xac\xa2\xb0]J\xbb\xc4\t\x94Kv\x83'R\xces\xe4\x94k#V\x14\x85Y\xa8\xa4(j\x16\xa2\x12\rq\xb6\x9cӎu\xea\x8aB\xfb\x86\xa2\x95\xae\x19\x10$+\x8a\x0fƢWe\x1f.\x85\xa20}C\x01`X1VQ\x98.\xa5\xfdyG\xc9\xc2\xef\x8dV\x94V\x8e8\x95\x92\x99Y\x85Y\xa8\xa4(j\x16\xa2\x12\t\x89xJ5\x95\xad(n\xbe\xa1J=\x90\xc7(\x9aƢϣ\v<\xea\xc50}C\x01`X1VQ\xd8.\xa5{\x89}\xb9\xf1g=(bz\x9b \x1f\xafcEQ\x98\x85J\x8a\xa2j!\xea\u0086\x8f\xf0\xbe\x95\x1e\x8a\xc2\xf2\re+\x8a/Ƣ\xa9\xef\xb9nĥsپ\xa1\x000\xac\x18\xa1(Z.\xa5?f\x97\xd7ߩ\xcf7\xfe\x9eٺ\xd0韮\x0f\v\x1a\x9b[OۘRn\xa2\xaa\x16\xa2.\n\xf8\xd4҂\x95|\xecWW\x15V\xaa,\xdf\xd0\x17?\x90+5\xf7ł\xb2\x01\xa8\x96\xb1\xa8\xc0\xed\xa8?\xbb\xd6G\xe5\xb2}C\x01`X1BQ\xb4\\JQ\xcb7\xf9\xf6\xc2S\xc3ps\xc5\xf5\x85a3>\xca\x1d˭@\xb2Y(\xed&\xaan!꤯8!:.\xad\xe2=S\x92\xc2J\x95\xe5\x1b\xda(\x1a\x84&\x93L\xda\x00T\xc3X\x14\xb3/\xe6\nr\xcfU\xf1\r\x05\x80a\xc5\bE\x01^\x95\x81,S\xb5[\x96\xaao(\x00\f'\xa0(\xa3\x82\x81b\xdb/\x8a\fo\xbe\xa1\x000|\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a2\x829\x14Ѫ\x15b\f\xe0\x89\n\xf8\x8aA\x8a\xe2ݥT\xa0\xce\xfeR\x169CK.~\x80A\xd8\xfc\xa1|\f\xc9\xd7|T\xa5ڲ\xcd\xdcF\xc5\xe7\x15\\P\xbeJ\xa8\aڱ\xf1B\xdfB\xaf{\x8fA\xefd\x8a\xef\xe0\x89\n\xf8\x881\x8a\xe2ݥ\x14ao\xc1\x93y^\xca\x1b\xccQ\xa7\x86\xb4\xe5r_\x1c͍\xe0\x8ey\x0f\u007f\x15\x9e\\N,@l2\x83v+3Z\xaa\xc6mb\x87z\xa2\x1d{\xab\xaa*S˞\xe3;n\xad3\x05\x9e\xa8\x80o\x18\xa2(\x1a.\xa5\x02E\xe5wF\x90\xa2\xfcn\xb13Q\xc7\x1dA\xa8\u007f\xee,\xafѯH\x8a\x8a\xa2\xdc\x18\xbf\x16\xb9\x13쳢\xf8\x14\xfb\xad\x86\xa2\x1c\x9f&)\nx\xa2\x02\xbea\x84\xa2h\xba\x94\xa2\xba\xddO[F\x90\xa2HO\x94%\x8a\x822\xb9\xc1{ \xfb\x8e\x9a\xa2\xc4O\xf5\\\xab\x0f*!\xe1C\xac\x86\xa2\xbc\xc3-\x0e\x95\x14\x05<Q\x01\x9f0BQ4]J\xdb\xed\xd7Ѱ(J\xebҰi\x1f}\x146\x01\xab[fx\xe8\x1c<kP\xe4t\xd4\xc0^\x1a\xa2\xa2,\x9dF\x82]\x86\xa5\xc2\xd1\xf5\xf1\xec\tsOM;\xec^]\xee\x14b\x00tk\xa2\xb3\x8a\x89w\xe4e/\x96\x98rl\xd6\xda,KR'mnJ\x14%\x8b\xe7\xf9\x98\xc7\n\xc3R\xd43\xf1cW\xd1\x1bo\x87\x8d\x9b\xb2\x00\xfb\x06\x04\u007f\xb4jV\xe8|<Xh{g\xea\xf8\xe9\v/!<c2\xce\xeeʥ\t\xfe ~j\xd8Bq\xa2\xc4\xd57eRKQ\ued60I\xf28\t<Q\x01_0BQ\x90\x96KiI9\x1a\x16E\xe9ycJ\xe6\xc6\xe0\x10\xfb\xfc\xad\xd8cc}\xc9\xfa\xe0\xdf\vrq\x92<\xa3\xba\n\xcf%\xd7q%O\xeb?\xe6ȣ\xf0e\x1bӶ\x99a\x9bKVp\x9c\xeb\xc0\x94x\x8b\x9bO\xaaݽ]$\x97~nc\xad\x85ߵ\x8e\x8f=\xb8\xa4Xan\x8a\x15\xe5AZ\x14y\x8c\xb5lX\x8a\xd0Ei\xf6\xe6\u0604\xf0\xcd\xe5\x1b9\xa1\x8d(\x98\x9b\xbd\xf7\xd0\x14\xec\xf2Q\xc4\xc5\x1f\xcb_\x18\xf4-B\xf5{\xc7r\x937m\x99\xe8\xee\xfd\x11̅\xef\xdf?'\xb4\x0eQ}S$5\x15E\x80R\x14\xf0D\x05|\xc1XEa\xbb\x94\xd6\xe7v\f\x8f\xa2\xec\xe7.\xe1s\x1a|\xd0\x1d&\xa3\x91#\x1c\x19wPg=\x98\xa58I\x19\x96\xfe~\x12\x1e/\xac\xf2T\x94\xa6\xcfo\x90\xf7{M\"\xf7\x14K\xad\xe9\xe8\x1c\u007f\x06\xa5g(\xcdM\x05E)\x8e>\x8bS\nG\xd3\x12N\xac\vuM\x9f߅\xbdG\xf0\xa9b\xf0\x94VA\x14&\v\xa9\xa7\xf9x\xb4\xf4[bM\x16<I\x18\x9f,\x9d\x8c\x94\x04\xcf\x16\x8au͊P\xf4M\xd1\xcd\xc1)\nx\xa2\x02\xbe`\xac\xa20]J;\xec\xf5\xfd\xfd\xfdMy\xfd\x06\x1b\x80!\xb4v\x12\xc2\xe6<\x87\x84\xd7\xf8ߒ\x9c7D?RYQ\xb6\x9c*\x89\b\xc1\x9e\x1a\xb2ai\u007f(\xb9\xa8[\xef\xa9(N\x9a8\x17\n3\x0ek\xa5\xa0\x16\x9d('\r)\xccMS\n\xf69}~\x14\x8e\xa6\x85\xae\xc2%\xdc\xf7R\x15\xc1\xb8y\xc4\x03\x11\xb5fΟ9\x91\x9b\xe3\x96K\x11\xfcG\xfc\x9aɵ\xd1}Sts\xb0\x8a\x02\x9e\xa8\x806\xc6*\nӥ\xb4)\xdbE\x8bJ\xe9\xa1b+\u05ca\u007f\xb6\xf1\x18e\xeeB\x92\xb3 \x02\xbf*gfۂ\xb2\x11mXz\x8b#\xbdhWU\x14TU$R\xa5ȵ^@\r&D\x14\x8567M\x89\xb3$|F\x8cI\x15\x8e\xa6\xa7\\G\xfbVN>I\f\xc6Z\xb6\tkǷS\xa6\u007f\\X\x159G\x99K#\xce\xccVq\x17\xe9\xbe)\xba98E\x01OT\xc0\x17\x8cU\x14\xb6Ki+\xa6.\xb7\xb5\xd5\xe8AJSЂ\xa6K\xb3\"\xf0j\xe3g\x92\x9c\x19\xf2\x18\xc5\xde䚙\x9d\x88\x8fXٰ\xb4?\xe4S\x1cT\xa7\xae(l\xac5\xa8!ZT\x14\xda\xdc4%\xae\xf9\xbe\xa5\x18\xa7\x14\x8e\xa6\x1d\xc1\xce\xdb\xdb\xca)\xa3/\xa2\x12D;fG`\xbf\xb4\xb7\xe7(si\x82W\xe1W;\x1e\xa3\xcc$\x19\xb8o\x8an\x0eNQ\xc0\x13\x15\xf0\x05c\x15\x85\xedRJ\x18\x8ey\x94\x8b\xdc\x14\x8e\x8b$\xb2VB\xc6\xf4\xfb\xb9\x12\xfc!2\x12\xa1{ؠTT\x94)\xab.}J\x1b\x96.\x0e\xc37\xc7/ẹ|q\xc3=\x8b\x82R\x14\xda\xdc\x14_=\xbe`\xc2\x13\xb3\nGS\xe14K\x14؎)\x91x\xda\xe9\x03,\x10\xb2vL\xc7\x13\xb1\xfds\xbc)\xca4<\xfd2;R\xd17E7iEi\xdaļ3XV\x14\xf0D\x05|\xc2\bE\xd1r)\x15\xe8o\xa9\xcbmi\xf3Z\xcb\x10p1\xb8\xbc\xa4\xaaE<p\x97\x06\xad-Z\x1bD&a\xd1\xc6\xe0-\x85o\x86\xdeA\xe8\x12\x99\u008c\\\x80\xa7\x1fd\x1bӖ)\xd33\x0f\xbc\x15\xec\xa9(\v=<\a)\x9a\x17\x15?\xaf45>O[\xf7\x8027}r9q\xdb\xd5\xde\xcedk\xed#ڰT\xe0Ǡ-b\xc1\xa3\xaf\xbf\x91Y\xf2\x01g\xc7\xf7\xc1ƟB\x17\xe3\xc7U\xb5\xa0M\xdc;\x99\x9f\x87sa\x9bOѹ4\xc1\xdc\xfcS\xdfDL\xc2\x1aG\xf5MN\xde\xc1\xf7\xccnu\x19\xaf.\xe4&xl\xfe{UU\x13\x16;\xedZ\xc1\x13\x15\xf0\r#\x14Eӥ\x14\xdf\xfa&\xb0\xd7[%C\xc1\xc9\xf1xfd\xdc\\<\x91ҟ9'tN\xa6x\xf4t}\x10\x162\xf7[\x84\U0008595b\x05]\x99\x15\x86\u007f\xd3]\x86\xa5\xc2\xf0*~zț\xe7=\x15%wr\xb6{\x96D\xdf\x12\x9e\xaf\xb4\xf0\xe6j<O\"\x9b\x9b~\xcd\xf3|\xd4O\x95\xc2\xeb>D\x19\x96bֿ\ue738\xb8\xfeδ\x89\x11\x85\xf8\xce\x13\xa1\xb1u\xa1\xc2\xeb\nԿuV\xf0\xe4Ź3\xc7Gҹ4\xb3?}g\xe2ԥ\xe2y\xa5\xdc79\x19\xef\x9c\x18\x12\xef\x0f\xb6O\xe0\\\xd3\xe5\x12\xeb\xc9\xf2\xb1\xe4\x96\x16\xf0D\x05|\xc3\bE\x19\xa9\xb4NX\xd1\xda\xd3\xd3\xf6\xdd\xdba/3:\xea\x18\xec<ʠY5\xde\xe7?\x06\xbe:\x85\x9c\xb7\x8d\x00\x9e\xa8\x80\x8f\x04\xb2\xa2\x14N\x12\x87$\xfda%\x1a\x91,\x86^Q\xd0\xd6i\xca;Z\x86\x8e\xfe\xdcI\xca\x11\x8e\x12\xf0D\x05|%\x90\x15\xe5bP\x1dy\xaf\v\x92\xef\xf8\xf0\x1d\x03\x14\xc58Z\xc2V\xc1=\xf6\x80\x1e\x04\xb2\xa2\xf4LJ\xac\xd8\u007fl\xff\x8a\x90\x97\xf9\x0f\xdc\xf5\xc3ܪSF_\xee\x06\x80\x91N +\nBE\U000e739f:\xff\xa5\x9e\xf54W\x9a\xb4\x04\x00@\"\xb0\x15\x05\x00\x00}\x01E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14e\xd4\x01ޥ\xc0\b\xc6 E\xf1\xeaRڵ\x9b<\xd7 w$\xfe\xbb\xb5n~\xe8\x94\xc5Ǧ\xdc\xf3\xcd\xd4S/\xc0\xbb\x14\x18\xad\x18\xa3(\xde]J۲\xbfo\x11\x18!\xbf\xbc\n\x8e\x84F\xd8\xf7\xcf\xe1\xb8z\x9fL=u\x03\xbcK\x81ъ!\x8a\xa2\xe1Rږ\xadxf\xfc\b\xa2m\xe2[]\xc2hj&G\x86Xڏe\xd5\x0f\xf0.\x05F'F(\x8a\x96K\xe9\xc8U\x94\xb5!\xe4\x01%[\xb8\x1f\xf1\x9b֡\xa6'\xe0]\n\x8cN\x8cP\x14-\x97\xd2\xe1S\x94\xe3\xf3\xa7\x8f\v[0\x03Ѯ\x9f\x1b9\x8eۋ\xf6\n\xaf\xeb\xd1L\xf1xi\xddB\x1e\x1e\"\x1fj\xb2է\\\x03mc\xaa\x00\xbcK\x81\x00\xc2\bEA\x1a.\xa5m\xd9\xe5\a\xb2\xf7\x1e7\xfe\xab\xf9\x1d\x17\u007f\xa0\xdc\x1e\xc6\xf5Ю\x9f\xad\x8b#\x8e\xb7\xa3\xf6\x93s\x17\xdf\xeb\n\xdaJ\x87K\x87\x9al\xf5I\xd5@٘*\x01\xefR \x800VQ\xd8.\xa5m\xd987\u007f\xbfᒒ9\x197$\x13?\x1c\x92r\xfd\xdc=\x9b,\xfcm\x1ej\"v\x83\x12\xaeC\x8d\xb2\xfa\xa4j\xa0lL\x95\x80w)\x10@\x18\xab(L\x97R\xd4_\x87\xb5\xa4k\xb7\xd6\x17Yw\xeeL\x9d\xb1\xc2\xfe}?\xd17\xd9\xf5\xf3RPW\xc7\ued9e\xe0K\xa8g,s\x8cBY}R5\xc86\xa6l\xc0\xbb\x14\b\x04\x8cU\x14\xa6K\xa9\x8b\xe3\x85\xc8hڲߙ\xcdMٌ\x14\xae\x9f]c/m\xe5\xfe\xa9>H\x909\xe7<J\xcf\x11\xf2\xe6:\xd4h\xabO\xb9\x06\xd9\xc6T\x05\xf0.\x05\x02\x00c\x15\x85\xe9R\x8a\xca\xc5G\xd1\x1f}\xa9\xa73\xbe\n\xe7\xf1\x91Ѷ?$S\xe9\xfa9{o\xe4\xdcم\xf8\xdc\xc7y\xad'\x9f#\xf7\xcaHc\x94\x99\xe4\r[}R5\xc86\xa6\x83\x02\xbcK\x01\xbf\xc2XEa\xbb\x94\x96\x90S\xf1\xb6ܗy\"\xfd+\xb1I\x9c9\x88\\\xa1t\xfd\\\xbcb\xfcan\x05v\xc6j\x9b\xf8\xb6pB\xd3\x1f)^\xcbq\x1dj\x94\xd5'U\x03ec\xaa\x04\xbcK\x81\x00\xc2\bE\xd1r)\xbde?|\xbd鼽\xc4\xf0'\xcbo\xe2&l,)\x8c\xc7\xd7Od\xd7O\x84\xbe\b\x9d\xd8?+\x84(\xc3\xe1Ј\xdcC\xf3ǞT\x9az\xcaV\x9fT\r\x94\x8d\xa9\x12\xf0.\x05\x02\b#\x14Eӥ\xf4^\xf9\xdeܢ:\xc3\x05\x05\xe5\xcd\xfdt\xfa\xb8)\x91X\x0ed\xd7O\xa1\xbd\x93\xfe\tm\x9e \xce\x1e\xe3\xff\xf5,$\xd7Z)SO\xd9ꓪ\x81\xb61U\x00ޥ@\x00a\x84\xa2\x00z\x02ޥ\xc0H\x06\x14e\xd4\x01ޥ\xc0\b\x06\x14\x05P\x05\xbcK\x81A\x03\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\xc0K\xc1\xfc'\x1e(\n\x00\x00\x83\xa7%~\n\xf3\xe9b\xa0(\x80\x933\x89\x8f\xb4B\x86\x9c\x97t`}\xc9b\x80&\xaaN\xb4\xfd\xb3g\xdb\xcbY\x1e\x16\x06)\x8aW\x97R:wt\xb1\x93\x8f\xaa֊yEj\xe7\xf1\x89}\xe8\x04\xcfϫU\viL^dYS\xfb\xfe\x15\xb5\xe5\xbeq\x90/\x18@\x15<\xcf\x17\xa0\x02\xe1\xb5\xccK\xe8}\x13\xbf\\x\xdb&\x84\x99慎9\xe69\x1fh\x19Ө\x1e\xa4@r`\xfdێ%1\xc9}ރe܍[\xd9\xe0\xbe\xf1\x8b\x92oj\xc5\r\x96\f\x9e\xc7\x0f\xdb+\xe6\xf9\f\xb7%5qgX\x05\x86\x16\x9d\xbb\xa9\xe6D{\x89\xf3|n\a\xc1\x18E\xf1\xeeRJ\xe5\x1a\xcd\xd1W{`\xd0\x03\x87\x89rꪽ\xc6JR\xb0s\xbd\at\xd7\xf01\x0e\xd4y\x82\xaf\xe9f\x14\xc0\\3\xa5\x9c\xa8\xfc\x8c\xe7_M\xdbJ\xa3\xf0#\xf7\x9fU\xf0\a\x1f\xa1G_\xf1\x15ϼ\xc4\x0e\\\xdd\x16\x8dp\xef\x1d\xa5\xfcU\xf5\xb0\xee+q\xc9\x0e\x81\n\xfe\x02\xf2\tف\xf5\x93\xb8\xaf\xd3\xcdO\xbc\x06\xcbx\x18\xb7\xb2\xc1}\xab\xadHTW\xe6\x97\xe4\xa1\xf9+\xfc\xc4\xce\xc7_Y\x1e\xba-9k>\xe1Li\xeey\xfdХ\x9bT{U\x9ch\xbf㎳\xb2\rR\x14\r\x97R*\xd7h~\xb7X+B\x83hJQV\xa7\xb2\x92\x14\xec\\\x8d\x80N>}\x9b0,\xe0;=\x17\x89lX7 \x1c\xe4\xdb^MQ\xee\x9ar\xc8{3_#\xbc\xd6\xf2\xcd^\xa3QA\xb4\xf8\xde\xe0MQ\x10Z\xb6\x03\xbf\xde\xf6QQd\a\xd6\xc7|)\xeaS\xed\xb0\x1b,\xe3V&\xa4o}k\x12\xb4\xe2\x06\xcb\xfb\x15\xe4\xad\xecC\x8f%\xd2(Ks\xcf\xeb@k\xa4x\xea\xa7G7\xe9\xf6\xb2\x9dhU\x9fFl\x84\xa2h\xb9\x94R\xb9F\x13\xfe\x8eV\x84\x06\xb4\xa2\xacLe%)ع\x1a\x01\x9d|\xad\xf9\xb97EYF\xb4\xa0\x91?\xad\x16\xe0\v\x19VѴp(\x14\xa5\xb7\xd4ۀGFv`\xbd\xcb\x0f\xe2t\x81e\xdc\xcaD\xec[)\xff\\+p\x90|\xb6\x87\xbc\xe5|\xa6\x1e\xa2\xb9\xe7u\xa0\x8e\xab#\xefzt\x93n/ۉvX\x15E˥\x94\xca5\x94\"\xe7\x13\x10\xc3\xf1\a\xdan\x94ƛǨ@tή\x04\xf3\x86\a\b\x9dq\xce\x19\xacV$w\xf2\xa6\xd2\f뢔\xbb\x8a\\\x85\xf3\xe8\xe5\r6Sl\xb2m@\x19 \xd3\xc9\xdf_y©(R\xb1}B\\%\x12\x1f\x1b\x99fŇ\xff\xc09E@\xa3\x89\xe7\xf7\xdcM_\x16\x93\xfc\xa2\x9aw͍T\xb3\x03\x84r\xbd\x16q\x88B+\x8al\x9a*\xf4\xa2\xcc\xd9M\xe1\\'\xcdjI\xdd\xe6\xae(\xeczEE!5DU:\xa7_\x14\x95\xa1\xbb\xa9\xb1\xa6\xb8d\x92v9\xb0\xf6Ɗ\xdba\xd7\xe0\x8a]\x1a\xcbq\xeb\xaf/\x9d\x112\xbf\x876\x9a\xa5\x10\xfb\x96f\xc5i\xd6\x0e\xa0v\x96\x10\xf0\xf5j\xf3\xca\xd2\x01\xb7\x15K\xb1t\r\xc4k\t\xa1\xd4\x1cE矘y\xdcz\xa4\xb6\xe7\x95;\x80\x01\xd5!D[\xe0v|<{\xc2\xdcSӔ\xd3\x18\xdbg\x15\xd5s\xf5%\xb32U\xbbٙ\xb3ܜt\xd5v\x81ި\xbe}\x11\x99N\xb4džSQ\x90\x86K\xa9G\xaeAt\x9c\xac\x9a5\xb7\xaa\xaa\n\x9fm\xd1v\xa3\n\xbcz\x8c\n\x8a\xc2'T\x9eY\"\xfc:u^q$$9\x1c\x8eۊds\xa5\x89\xb7\x15\x14\xd8\xcc\xcdt.\xed<\xfaӼ\xf4\x135e\xb1\xfc\ve\x80\x8c\xa0(\xa5\xc9NE\x91\x8a=JK\xbc\xdc)\x94X\x93\xf6\vzh\x8bJ.\xf8\xa1\x17)\xea\xed\xae\xae\xb4%Xl\xbb\xd2\xe6=\xec\xbcl\xd9\xf7\b=\xdag\x11J0\x03\x84r7y\x87\xb8\xb6f\xfe\\ww\xf7\x05\xac(\xb2i*\xeeE\\\xc1\x9f-\xf8G\xf8\xae%\xa1\xe2\xcc\x06\xde]Q\xd8\xf5.\xcb\xe8\xee.ND\xce\t'q\xfa\x85\xae\f՚W\u007fUS@f6e\a֛\x8eJ\xbe\xc0\xe1\xf8ypź\xf2\xf7Θ5q\xfa\xaa\xa5\\\x13e4\x8b(\x84\xbe=\xbf\x9d\xc3\x17(\xdaK\xed\x00jg!\x94\x1e\xbd\xe7ܞ\xe8t\xe5\x8a\xe5X\xba\x86\xb2\xd5\xe8\xaa\xed*ZY\xa6\xec|\x83\xc3\x11C\xd6\xc5\xde\xf3\xca\x1d\xc0\x80\xea\x10m\x81\xdb63ls\xc9\n\x8e\xcbD4-K\xb97\xb8\xdfr\x8b\xef\xa8u\xf3ɻ\x8b\x8a/\xec\xe4\xf9\xaf\xe9\x8d\xea\xdb\x17\xd1Ӊ\xb6\xe7ޱ\xdfMR\x19\x19\x1a\xab(l\x97R\x8f\\\xe3\x90\xcez(\xbbQ%\xde=FQt\xdc߄\xdd\x12G\xd2̳\x9e\xe8e\u0090\xff\x89-Q\x91K9\x8f\x96\xc6\xe1\xafg\xa9\xa5ϭ\x06\tAQ~\x89\xf9\x85(\nU\xac\x82\xfc\u0088\xa7\xf0\x8f\v\xfe`\xe2-\xd5\xc8\xcd\xd1t%\xff\xc934\x80O82\xf0\x8fhZ\x86z\x00:\xc7\xffU\\[\xb3\xf3\xf7\xa9Yi\x9a\x1am\x11~\xa2\xd3q7\u05fc'\xfc\xa0\xf5}\xe8\xa6(*\xf5.\xc3U\x91\x1fK\xf1\xf4P<Y\x92+\xeb\xb6%w\v\x83\x92j\xe2E$9\xb0\xd2g=\x83*\x16ν\xd9FΞe\xa3Y\x1a\xb1o\xe9x\x80\xa1\xb2\x03\xe4\x9du\x81\xfc\xd0א\x19 y\xc5T,U\x83#\x16\xe5\x98r\xd0\"\"\xca\xd4FE(\xc6uN\xcc\xda\xf3n\xb1,\xa4\x0eQ\x16\xb8\xbf\x9f\x84\x9f;\xbe\xcaMQ\x10:<\x8e\x1bG\xc6-\xecn\xa6\xe3N\xa0,AQ\xe8\x8d\xea\xd3\x17\xd1Ӊ\xf6-a\xf8\xa7\xe6\xaee\xac\xa2\xb0]J\xdds\rDR\x14ڰ\x94\x85\x8a\xc7(\x8a\xc6ǩsV\x81\xad(\xe4t\xa2\x94\u007fL\xe7RΣ\x0f\xad˲\xcan\xf6\xf5\xba\xd7 !(\nJ.&\x8aB\x15k\x8c\xea~^\xf1\xe4E\xb4\xf3\xbalwM2\u007f\xce\xcd\xd1te\xb4\xebǯ6\xe69zn\xaeE\xaa\x01贰\x12B3\xff熆\x86b2\x8fB\x99\xa6\xe2\x1fk\xd2\xcd'\xe2e\xe5=n\x8a\xa2Rﲔ\x86\x86tOEqU&\x1c\xb7\xd4E\xceByӲ\x15E\xb3Xx\xb03)\x1b\xcd\xd2ྜྷM\x8c\xb9\x8fTw\x80\xbc\xb32\xde'E\x96oC\xf4\x8a\xa9X\xba\x06\xfeyR\xfa\x9aN\x9e\xf4\x9aڨ,EQ\xdb\x01l\xa4\x0e\xc9\x16\xb8\xfd\xa1\xe4Jy\xbd\x9b\xa2\xb4\xad\x1a?\x8d\x9b\x1a\xfcQ\xabJ7\xfb\xcc\xd8UAX\xa6T\x14\x9f\xbe\x88\x9eN\xb4M\x87\xb3g\x87\x8d\x881\nۥT\x99k(\xf2̬l7ʆ\xed1J\u007f\xe3U\x14\x85|\xa9\x1c\xfc5:\x97v\x1e}R\x96\x9a\xc0/98\xe0V\x83\x04V\x94\x13+\x89\xa2PźM\x8d\xc5\xfc\xbe\xdbQ\xc2ou\x039\xc3\xefKLqs4])MȼXt\x1a\x9d\x8e\xedC\xaa\x01\xe8\xaa\xeb셚G\xa1MS\xa5n6\x88\xa7G\xee3\xb3*\xf5\xe2y\x94f\xf1J\b-\rR\xb2\x98\xa7.\x89\x9f\x92\a\xd7lE\xd1,\x16\x1e\xeeLPF\xb3\x14\xa4oO\xa2\xb0$\xaa\xec\x00yg%\x92\x9e\xa0\xe4D\xa4h\x83\x1cK\xd5\xd0\x17\xddl\xbefn6\x89\xbf\xee\xf2Fe)\x8a\xda\x0e`#uH\xb6\xc0\xbdő\xa3\xa5\xddMQ6\x87e\xd7s\xf5\x99a\x9f\xabt\xf3\x818q\xdf\xe9\xa6(>}\x11\x99N\xb4U\x9e\xbe+\"\xc6*\nۥT\x91k,DQ\xecM\n\xbb\xd1A\xe1\xa1(\x15\x0f\x95\xc9\xe8,\xfc\xb9\x8c\u007fF\xe7RΣ\r9\xc2.|R\x19S\xeaV\x83\x04V\x94\xe7\xe6\x1aq\x8c\"\x1b\x96&T\xae[\x93p\x1a\x9f\xfbX\xc9\x1aP\xce{n\x8e\xa6Է\"+\x05}F\xa2\xd4\x02\x9e\xbb\xaeYQ\x8aB\x9b\xa6J\xdd\xfc\x1bO\x1a\x9a\xee\xa6(*\xf5J3\xb3\xce\x1a\xf6\xb8IC\rOݧ!9\xb0z(\x8a\xaf\xc5\xc2\xdfv\xa5d\xa3Y\n\xb1o\x16\xfcc\xad\xb2\x03䝕\xf1.\x99}]\xee\x03\xcf]\x00\x00 \x00IDAT\x86\x87'\xf2\x8a\xa9Xž\xf8ʊ\xac\xc5\uf455(\x8eE\xa5\xa2\xb8\xedy\xf6\x0f\x88\x02\xa9C\xb2\x05n\u007fȧ8\xa3\xce\xfd\xac\xa7\x87\\\xeb\xc1clf7\xfb̤)\u007f\x91\x15\x85lT\x9f\xbe\x88L'\xdaa\xbdփ4\\J\xe9\\\x83\x89\x8cD\xe8\x1e\xb6\x17\xa5\xecF\x95x\xf7\x18U(JR\x12B\x8f\xc4\xdbB\xe4d\xf4\x12A\n:\xdfMR\xe4RΣ\x05\xe2\xcd\x1aI;\xdcj\x90V\x8c\x15\x05\xa5\xa7aE\xa1\rKӲL\x17\xf8\x9dx\xc7\xc7Z\xf1׳\x0f\u007f\t\x14\x8e\xa6\xd4\xf7\xf5\x87\x98\x9fc~\xc0\t\xb5\x00\x94\xfa\x9ex\xef\x04\xa5(\xb4i\xaa\xdc\xcdD\x9b\xb0\xb6\xdb1n\x8a\xa2R/\xa5(fᄢ\xef\x0fn\xd2\xd0iM£\xec,Q\x13]\x0e\xac\xb4\xa2\f\xaa\x98<┍f)ľ\xc5e5\x16\xa8\xed\x00yg\x9d#3\x1d\x95\xf8T\x92Z1\x15K\xf789\xf13\xf4Y\xe2\x06\xb2\x12\xb6\xa2\xb0\xf6\xbc2\x96i\b+u\x88\xb2\xc0]\x1c\x86o;Y\xea1\x8f\x82\xeeL\x12/C\xb2\xbb\x99\x1a+췁t\xa2(\xf2F\xf5\xe5\x8b\xc8v\xa2\x1dVE\xd1r)\xa5r\x8dfc\xf0\x96\xc27C\xef(\xedF\x15x\xf5\x18\xfd\xd9a\xdavu\xe0\xe66\x13\xbe0!|\xe9\x8aO\u007fb&\xc2.'\xa3\xf9\xd5\xd5e\t\x96\xbf*se\xe7\xd1\x02\u07bc\ufb10\xacU\x06H+\xee\xae\xe1Ot\xa2Z3\xb9\xd6C\x19\x96\x1e4[\xfa\x12\xc876\x96\xb7\xee\xbb \x14\xbbM\a\xbc\xf8\x81\xcc\xd7\xdf\x17\xdb\xd9g\xdd`\x15\x15C%\x00ݎ\xfa3~\xa3\uf655MS\xe9n6\x9bm\x05{\x16E\x99*\x9a\xd1C|\xcfl\xb1á\xe8\x10Uo\xf7ո\xe4+\xae\xdbh\x12\xe3\x0e\x16$\xf2B1\xc56\xab\x8dY\xfe\xf5\x85,\xe7-\xff.\aV\xf1Z\xcfվ\xc1\x15\xeb9E\xae\xdc5\x91<\xcahV\xa6\x91\x1c3뒷\xbd\xaf\xb6\x03\xa8\x9d\x95\x16\x95s6'*M\xb9\x8f\xe9Xj_d\xcd;\x88\xbe\x9a'\xe8\x1b\xbdQ{\xaf:\x1c1\xdb\x1c\x97\xc9\xc4+cϻ\xed\x00OCXE\x87d\vܖ)\xd33\x0f\xbc\x15\xec\xa9(.\xd8\xdd\xfc\xd9j+=\x91\x12C\x14Eڨ>}\x11\xd9N\xb4\xe7Y\xa7B\x18#\x14EӥT\xce5\x9a\xae\x0f\xc2B\xe6\xe2\x13B\x85\xdd(\x8d7\x8fQ\xb4S8\x055\xfd\xc5,\xbc\xee\x14>ug-\x8aIj \v\xe4d\xf4\xae\f\x8b5\xfdg\xb7\\\xd9y\xb4bM\x81\xcddM\xaau\x0fp\xad\xb8v\x1e\xbe\x8f\xa4/QT\x04ٰ\xb4A\x18\xd6\x1e4\xe3\xd8?\x94\xe5,7ǥ\xdcV\xd4\xdb\x18EΏ\x93źPqt\xb13\xa5\x12\x80\xf6\xc5\xe0\xff\x05\xd1\xff\xeb\x91MS\x15ݼ\x9b\xb2hYN\x85IH\xa6;O\xc2SU\xea%\xff\xeb\xa9t\xd6\u007f7)Ʋa\x8fP\x83r\x9b\xddN\xb5Y\x12]\xf7\xe6\x89\x0e\xac\xdd\x16R\x83\xe9\xf6\xe0\x8a]\n\"3\r\xa2\xfe\xd3F\xb3.\xf0}9_\t\rL\x88=\x8bTv\x00\xb5\xb3\xfaJ?4\u007fXڧ\xdcNJ\x9d%\xef\x8bs\xe6FAi\xcf(7\xeaObZ\x94=ƞw\xdb\x01\x9e\x86\xb0\x8a\x0eQ\x16\xb8\xad\xf1\xd3C\xde<\xaf\xaa(*\xddD\x8f3l1\x9f4\x10E\x916*R\xd9\x0et{U\x9ch\xef\x8d}\xe7ҽ~\xe4\x89\x11\x8a\x12\xd0\xd07Վd\x06\xb2L\xd5Z1C\xceK:\xb0\xbed1O\x86sgy7\x84u\xa7C}\x8c\xe2\rqfv0\xa8:\xd1\x16\xce\xe6\xe0i\x06\xc3\xc1p~I\a\xc5@\xb1\xed\x17\xad\x98!\xe7%\x1dX_\xb2\x98\a÷\xb34\fa=0JQ\xbc9\xd1\u07bb\xd4\xc2\xc8\x05E\x19b\x86\xefK\n\f\x9a\xe1\xdbY\x835\x845JQ\x06\x0f(ʐ\xf2\x80L\xebiE\x01#\x82Q\xb4\xb3\xae\x1f\xe6V\x9db\xcdbx\xe7\xee\x05~\xd7\x0f}hH\x01E\x19Rȴ\xde}\xad(`D0\x8av\xd6\\\x8e\xe3\xc6^\u05ca\xf2`\r\xee\xe1]\xad\xa8W\x03\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd0HQ\xbc\xb9\x94\xf6\xe49\x1fl\xb0W\xbd\xbc\u007f\xa1\xb3\x91$\x00\x8c\x1c\x8cQ\x14\xaf.\xa5]\xd9\x17[\x04\xceg+\x9f3쇸\xbc\x1f_\xc6H\xf2\xd9\xcf\xea\xcb^\xd1k\x15\x00\xf4\xc3\x10E\xd1p)\xad{*\xa4\x9e\xe6\xa9<\x13ʏ\x90\xbc\x1f\am$\xd9WfY\xa7\xbe\xf4\x95\xbdV\x01@/\x8cP\x14-\x97RBɁ\xe1x\x86\x9b\xb1\xacT(\xca \x8c$\x1bW\xf3)\x0f\xd4\x17\xbf\xb2\xd7*\x00\xe8\x85\x11\x8a\xa2\xe5R\x8a\xa9\xcf\xd6\xe7\x999#\x83\xc7鱶\x9c\x9cXs5\xe5vI{?j\x19I*\xe9\xdc\x15e;\x8bԠ\xbcV)_\xcb\x15\\P\x1ej\x1aω\x8f\x83\x97-.\x01`h1BQ\x90\x86K)&\xbf\x9cUl\x94һ\xdcZ\xba/\xc6\\\xb6\xa1\x98r\xbb\xa4\xbd\x1f\xb5\x8c$i\x06N[M9\xe2\xf3\x9f\xbb\xef\x8bPn5\n\xafU\xcaײ\xa5j\xdc&A\xc1\xe3\x83q\x88lq\t\x00C\x8c\xb1\x8a\xc2v)\x15h\xcaV\x1a\x94\x8fn\xaa\xf9F|N\x83}\xf9h\xb7K\xfa\xac\a\xe3\xcdHRf'\xbf\xb2ٙLr\x0es\xd6 %\xd4Y\x8f\xe4k\x89\x82\x05EA\x9b\xb0\xa2P\x16\x97\x000\xc4\x18\xab(l\x97R\x81r\x9d\x1e=<2ȱ\b/\xb7\x89\x8b\x1b\xedvI+\x8a\x96\x91\xa4LE\xf4\xa2\n\xe7\x83\xc5n\x9f\x11q\xf3ZW(\x8a\xcbגR\x14\xd9\xe2\x12\x00\x86\x1ac\x15\x85\xedR*\xb0{\x18ܿ\x86\x8e\xe2y\x8f\xf1\xe8\x04\x0f-h\xb7K\xb7\x99Y\xafF\x92\x14w7\xf0\x89\xcd\xc8\x1b\xb4\xa2\x84\xbbR\xb2\xa2\xc8\x16\x97\x000\xd4\x18\xab(l\x97R|=\xd9\xf5\xcb\xea\x17<\x8cJ~ؘ\x90\x88\x1f\xe8I\xbb]\xcaޏ\xdaF\x924\xd4L\n\x1b\xc9k\x956\xea$\x8a\xb2\x1e+\x8alq\t\x00C\x8d\xb1\x8a\xc2v)\xc5\xd3(\x83\xf1*\x19\xf1\\\xe3\x97\xf0\xfc:r\xb9\x97v\xbb\x94\xbd\x1f\xb5\x8d$\x95t\ue2b2\xd6x\xe4JH^\xab\xf4p%\xf4ca\xebF`E\xa1,.\x01`\x881BQ4]JQ}\xf6\xa0\xac\x05F:\xd7bj\xce9\x1e\x88\xcf\x1c\x97\xdc.\x11\xe5\xfd\xa8m$\xe9N\xf3\x1a\xdaO\xd7\r\x97ת\xc2\xd7r\xee\xe4/>\x8f\xe0\xc6\xe6\xd6\xd3\x16\x97\x000\xc4\x18\xa1(\xda.\xa5M\a\xbcV0ڸb\xc23#\xa65x\xf6Cr\xbbD\xb2\xf7\xa3\x0fF\x92\x83\xc2嵪\xf0\xb5\xbc\x1e\x192q\xfe\x1f9\x0e\x1bK\xc9\x16\x97\x000\xb4\x18\xa1(\x81\xc6#\xf3\x8eG/^<\xf9\xe9\xb3EO\xb4B\x19\x18`\xd2\x04\x00C\x06(\x8a\xfe\x9c\xb6\x88C\x92\xbeX\xf7\xbb_}\x01\x14\x05\x18̀\xa2\xe8ϵ(\xf1bos\xd4\xcb<\xaf\x00\x14\x05\x18̀\xa2\xe8O_\x86yGum\xf5\x0es\xc6KX^\x1aa$\t\x00C\x06(\xca\x100pf\x83\xd5dM>\xfb\x12\x82b\x88\x91$\x00\f\x19\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\xa3\x99C\x11#\xef)Jm\x11\x87\xb4B\x8c\xe7L\xe2\xa3\x11\xda2\xbf\xc3 E\xf1\xe6R\x8a\x1f\xe7~\xc0~\xe0$\xb8?\f\x96\xcd\xdcF\xf2\u07bc\xc1lM\xab\xb5>B\xdbx\x9e7\xfbv\xc3m\xed<>\xb1\x0f\x9d\xe0yoΆ5qg\\ɿ\xedX\x12\x93\xdc\xe7\x9e\xcbbs\xd0\x17\xacl\x83\x1b\xa9\xe0 _\x80\xef_Vi\x19\xa0'\xc6(\x8aW\x97RԖWX\u007f\xab\xfe@\x9e_=\xc7\xcd\x002\x83v\x93\xf7\x1a\xf3\x1f\xca*?\xe4\xf9\xff\x8b\x1e8\x1c\xa5\xfcU\x8db\"\xdd5|\x8c\x03u\x9e\xe0k\x14^\x1d\xb2\x95*\xe6\xac\xf9\x84+\xf9I\xdc\xd7\xe9\xe6'\xee\xb9LJ\xc6n\xf7\xcc4\xba\x914\xa5Q\x15b\x82\xd92@W\fQ\x14\r\x97\xd2*\xe2\xb6ѓ\u007f\xdc[\x1d\x80;7Ư%\xef\x8f-)\xc2\xf1\xd6\xf9\x9ep\xb0\"\xec\xd3\xe1\xdb\xc1\x8a:\xf9\xf4m\b\xdd\xe7\xdd\x1f`\xbb\x9a~X\x9c\xf4{\xff\x98/E}\xaeP\xad?2\xae\x0f\xbe\xe5\x9ee|#e\xee\x9ar\\IF\xcb\x00}1BQ\xb4\\J\xcb\xc5'\xe4\x1f\xf2'\x130\x03\x88\x9f*\x9e'昉\xc9z1OL7\x06q\xb0֚\x9f3\x0e֕\xcc\xc7O\xde彞\xe9(\xe9\x98\xeaa\xe41\x9c\x8d̰Jn\xb0\x8c\x96\x01\xfab\x84\xa2h\xb9\x94\xb6\xe5\x1dk\xedi\xad\xca\x1by\xb3\x8c/͍\xb7\xc3\xc6MY\xd0▤ɝb\xc7o\xb7&:\xad/&\xd2\x16h\x8d&\x9e\xdfs7}YL\xf2\x8b}<\xcfW\xa2J\xe1u\x9f\xb2\x82\x9e\x89\x1f\x8b\x89\xf72\xc8\xdb\xe3brf \x1d\xac\x92=*B\x977\xd8L\xb1\xc96\xf2T~\xc9\x13\xb5\x93\xbf\xbf\xf2\x84\xf3`eZ\xa9>1\xf3|\x14~\xee6\xea\x8d\x15sw)r\xa9ʨ\xf6\x92\x05\xebCܟ\x1blh#\xcf\no{P\x81\xf0\x8a\x9f\n\xdek\x91\x86(\xac\x96\x01\xfab\x84\xa2 -\x97Ү\xf2\xec\xec\xec#~\xb4\xab\x8fM\b\xdf\\\xbe\x91۪L*x\x8b\x9b\x8f\xdfzvo\x17ɥ\x8d仫+m\t\x16ۮ\xb4y\x0f\x1f\xa5%^\xeeD\x9dW֤\xfd\xa2\xac\xe0\"wL\x8c\x8d*\xa6\xb3\xa5\x83U\xb2GE?\xcdK?QS\x16\xcb\xe3\xa3]\xf6D\x15\x0e\xd6\xd2d\xe7\xc1ʴRE\r\x0eG\f1\xfc@7\x1d\x95|\x81\xc3\xf1\xb32W\xae\x8cj/Yp\x92;\x85\x14\x18\xdb\xc8\xe7Wl;\x1e\xa1G\xfb,\x97q\xb9\x9b\xbcC^\xb3G\xcb\x00\x9d1VQ\xd8.\xa5=\xe5\xf9\xf5-\xf5\xf9\xe5\xf415\xaa\xe9\x9a>\xbf\vO\f\xb5)\x92J\x9a>\xbfA\xde\xef5\x89\xb8\x1bɯ\xe4?y\x86\x06\x9e!T\xb1\x9c|~\xbf\xc2-\xa0\x84\x13+\xb8/\x1a\x87\xb9p\x1d\xac\x94=ji\x1c>LK\xf1\xb3*)OT\xe1`\xfd%\xe6\x17r\xb0\xb2\xadT1.\xedP\x9eP8s\xa9ʨ\xf6bnqn\x8f\"7\xba\x91\x05x\xfc\x92.\x8e\x8b\xce\xf1\u007f\x95c=Z\x06茱\x8a\xc2v)=\x9e\x8f\x87'=\xf9'U\n\x8f:J\xb8\xef\x19I&M\x9c\v7\x0f\xb4\x95\xd1\xe2\xcf=j\x8c\xea~^\xf1\xe4Et\xa3[\xc9Bg\x89^\x13\xf3矲G}h]\x96Uv\xb3\xaf\x17ў\xa8\xf8`E\xc9\xc5\xe4`e[\xa9b\xbc*\nU\x19\xd5^\xcc-w\x8fe\xa3\x1b\xf9`\xde_P\xb7\xa5\x86\xa4O\vuHx\xb4\f\xd0\x19c\x15\x85\xe9R\xdao\x17\x0f\xba\xef\xed\xfd\xac\xa2\xa3\x90\xad\\\x17#ɦ\xaaH\xa4\xca-\u007f\xe5jg\xa2\xdb\xd4X\xcc\xef\xbb\x1d\xe5v\xfd\x14\x9dr\x8dߝS\x14\xbd5\xe4\xcdu\xb0\xd2\xf6\xa8O\xcaR\x13\xf8%\a\ahOTr\xb0\x9eXI\x0eV\xb6\x95*ƫ\xa2P\x95Q\xed\xc5|˹\xff:\x18\xdd\xc8\xe4\x1ct\xc1\xd2K\x92W\xe9i`ϖ\x01\xfab\xac\xa20]J]\x8ar\xd1o\x14\xa5\x9c\xbb\xc8H\x0e\x0e\xf9\x98I\xa8\\\xb7&\xe1\xf4r\xf7\x80\x8e`\xf1\xf66\x94\x13CfX\xaa\xf9G\xf8M\xfa\xf9\x97\xedQ\x1br\x84\xe4\x93ʘR\xda\x13\x95\x1c\xac\xcf\xcd5\xe4\xe7\x9fi\xa5\x8a\xd1\x18\xa3H\x95\xb9\x1d㟎oGJ\x8cn\xe4\x99E\xbdΓ\x1e\xf4<ڵ\x1c\xb1Z\x06英\x8a\xc2v)\xfd\x86\x9c\xf5t\xe5\u007f㭆\xd1DǔH<'\xf4\xc1*ERI\xd3\x177<\vR\xc8GhZ\x96\xe9\x02\xbf\xd3\xf9\x91*\xb6x\xa6\xa8\xc0\x8f-\x9f\t?\xc6}I\xcb\xc8'\xd7\xc1J٣\x16\x88s\x0fI;\x10퉊\x0fV\x94\x9e\x86\x0fV\xb6\x95*ƫ\xa2P\x95)\x15\xa5\u007f\xf6\x02W\xd2\xd5^\xa3\x1b\xd9\x1b{f\x91\xeb>\xdb\xd4\xf7\xa4;V\xa8\x96\x01C\x83\x11\x8a\xa2\xe5Rڵ?\xbf\xeeN]\xfe~\xff\xb9\xd8s\xf4\xf572K>\xe0\xecʤ\x82\x85\x9c\x97\xef\xf6\x8b\x1f\xc8Ռ\xfb\xe4\xc3A\xb3\xa5/\xc1u\xd4P\xc5~\f\xda\"&.\x98\x13+\xcel0]A\xe8!\xbe\x1d\xb5\xd8\xe1\xc0?\u07b2=j\x01o\xdew\xf6t\x06\x8f\x8f0\xc9\x13\xb5\xbb\x86?щj\xcd\xe42\n\xd3J\xb5\xf7\xaa\xc3\x11\xb3\xcdq\xf9\x99\xeb2\xcaU|`R\xb9re\x8a\xf6\xe2S=i`&\xb5\xd7\xd0F\xe2:\u07b5\xbcp\xb6\xe1vԟ]\xcd\xd9\xfa\xb2CF\xc0W\x8cP\x14M\x97Ҟo\x0f\xe4\x16~\xeb7\x97z\x04\xae\xbf3mbD\xa1{\x92&wr\xb6G\x9eDc\x14\x99HH&\x1f\x1a,\xfb\x04Ui\xf0,\xb6\xfeu\xe7\x9c@\xf3\x06\U000d253f\b\x89t\xe7\f\x04\x1e/\xc8\xf6\xa8\x15k\nl&k\x92\xf8\x93\xed\xf2D\xad\x9d\x87\xef\xd6\xe8K\xb4\xf6)be+U\xf4\x93\xd8\b\xbe\fu[H\xc2t[\x91KU\xa6h/:\x1e\xf2\x91\xd4F\xb9\xbdF6R\xe06\x9f!5b_\xcc\x151A\xb7\f\x18\x1a\x8cP\x14`\x88X5>_+d\x18\xd8?>~\x04\xfc8tF\xcb\u007f.\x1c\xc82\x91\x13\xa4\x91\xd12?\a\x14e4\xb3u\x9a\xfbm,\xc3O\xdb\xd4\x11\xf1\a\xdf\xea\xd8\x17\xf2\x87\x81b\xdb/#\xa6e~\x0e(\n\xe0\u007f\x14\xd4\x0e|\xe2\xf6\xa7\x05\xc0 @Q\x00\xbf\xe39\xbfz\xa7\xd5\xf3\xa1\x06\x80\x11\x80\xa2\x00\xfe\xc7>\xf3\xba\xdbZ1\xc0\xd0\x00\x8a\x02\x00\x80~\x80\xa2\xe8ϗL\xb4J\x01\x80?\x00\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0\x02\x8a\xa2?\xa0(@\xe0b\x90\xa2xw)\xed\xbfTh/\x94\"F=\xa0(@\xe0b\x8c\xa2xw)\xed/ʽ\xd8t\x9e<\xd8\xcd/piȟ\xfe\x0f(\n\x10h\x18\xa2(\x1a.\xa5\xdf۱\xf7\u05cfv\u007f\xb1RwJ\xc8?\xff\xe7\xff\x06\x8a\x02\x04\x1aF(\x8a\x96Ki\xc9\x11\x92\xcc\xf3\x97A\n\x11\x90\u007f\xfd\xaf\xfc\u007f\x871\n\x10p\x18\xa1(Z.\xa5\x85\xa2\xb3ġ\x12f\xe9ч \x1f\u007f\xfa\x1f\xa6\xff\xf2/_*\x10\x16\xdcM\x8d5\xc5%?@\xca$\x00\xf8\x11F(\n\xd2p)=\x99\x87\xe7g\xbbr\xfd\xc5\xed\xed\xcb/\xff忘\xfe矈\x8e\xfc\xe9\xff\x88\xfcIP\x94Z\xf3\xea\xafj\nx\xec\x85E%\x01\xc0\x9f0VQ\xd8.\xa5\x1d\xbb\x8bZ\xbbZ\x0ee\x8fć\xa6\xbe\f_\xfe\x0f\xfe\xbf\xfe\xabsd\xf2\x8f\xce\xc74\xff㗨ۖ܍Po\xf5cD'\x01\xc0\xaf0VQ\xd8.\xa5\xa8\xad(;\xdb~\xaa\xe8\x10\xbb\xec\xa8\xe3\xcb\u007f6\xfd\xe7\u007fv*\xca\xff\xfe\x17\x91\xff\xfd%\xba\xc0\xdftEPI\x00\xf0+\x8cU\x14\xa6K)\xa6\xab\xad\x1f\xe5\xf9\x8b\u007f\xa4\xa0#\xffM\x1e\xa5H\xf3(żd4J%\x01\xc0\xaf0VQ\x98.\xa5\x82\xb4\xe0\x97\xeb\xd9-̢\xa3\x0f\xac\x1f\xf2L\x8a\xa4(5\xfc5W\x04\x95\x04\x00\xbf\xc2XEa\xbb\x94\xd6g\xb7\n\x8b\xf6\x1e\xf3Z\xc3(\x82\b\b\xbe\xda\xf3\xbf\x14\x8a\xd2iM\xc2\xd6\xdeYY\x88N\x02\x80_a\x84\xa2h\xb9\x94\xfe\x98\xfdݝ\xef\xf3\x8a\x9ej\xd53ZpJȿ\xfe\xe3\u007fW(\n\xaa\x8dY\xfe\xf5\x85,\xe2\xc6G%\x01\xc0\x9f0BQ4]J/\xe6\xe7\x16]\xec\xf7^\xc9(\xe2K&\u0082۩6K\xe2i\x12C%\x01\xc0\x8f0BQ\x02\rUE\x01\x00\xbf\a\x14E\u007f@Q\x80\xc0\x05\x14E\u007f@Q\x80\xc0\x05\x14E\u007f@Q\x80\xc0\x05\x14E\u007f@Q\x80\xc0\x05\x14E\u007f@Q\x80\xc0\x05\x14E\u007f@Q\x80\xc0\x05\x14\x05\x00\x00\xfd\x00E\x01\x00@?@Q\x00\x00\xd0\x0fP\x14\x00\x00\xf4\x03\x14\x05\x00\x00\xfd\x00E\x01\x00#h\xf5\x9f\xbf\xc2z\x05\x14\x05\x00\f\xa0gҍ\xa7\x01\xa1)\x06)\nå\xb4\xe5\xc8^{\xfeI\xf2\x88\x03\xd4r(\xf7\x88\xbf<\xc1\xcd7\x9a7\x98\xadi\xb5\xd6Gh\x1b\xcf\xf3\xe6\xbbZ\xe1\xc0h\xe7\xe9\x98\t\xdfw\x04\x82\xa4\x18\xa3(\f\x97\xd2{\xd9%\xf5w\xea\x0f\xec\xc5\xcfY\xbac\xaf\xbaQe\xbf\xe3\xb5\n\xff\xa2\xc6\xfc\x87\xb2\xca\x0fy\xfe\xff\xa2\a\x0eG)\u007fU+^\x8dg?\xab/;zQ}\x19`4\xedc\xc6L\xbc\xe47\x0f\x15\xf3\x82!\x8a\xc2r)\xbd\x91\x8d\x15\xe4)N\xf6\xef\xc5Ϭ>\xb97\x10\x14\\\xe4\xb1%\xa5\x1b\xa1\xce\xf7\x04E\x11hxYE\xe9+\xb3\xacS_\xfa\xbb\xc5\xea\xcb\x00\xa3i\x1f\x13\xff\x9b\xb0\xfa\x00\x90\x14#\x14\x85\xe9R\x8a\xc8\xc6mŏ\xab\xae\xb7cK\xb0\xa7҃\xf1\xfd\x9f\x1c3\x19[\x14\xf3\xb7\xf1\xdb\xcb*J\xe3j>ŋ+a\xf8;\xea\xcb\x00\xa3i\x1fSx\xfe7S\xebe\xf3;\u007f\xc5\bEa\xba\x94\x92\x05\xb7\U0008b10f\xe5\x87ɧ\x92\xa3\xac£\x92\xcb\x1bl\xa6\xd8dۀpZ\x92j5\xd9R\x1a\x85\xbc}<\xcfW\xa2J\xe1u\x1fz/\x83\x84=.&&\x1b\x92\xa2\f|\xbdڼ\xb2t@Y\x03\x1a\xa8H4'\xecz\uef8e\xce]Q\xb6\xb3\xee\x99\x12E\x9cH8B\x97\xc6r\xdc\xfa\xebKg\x84\xcc\xefY\xc1\x05塦\xf1\xdcl\x12\x93\x17\x11:k\x95\xbf\xd8\u05cft\xda\xc7\x1c\xf8\xf5\xe4k3\u007f\xf4{I1BQ\x10ۥ\xb45;;;\x17\xcf\xcc\x16\x8aF='\v\xd5J\x8f6~\x9a\x97~\xa2\xa6,\x96\u007f\x81\xd0Y>\xa3\xb6:%\xaa\x01\xa1Gi\x89\x97;Q\xe7\x955i\xbftG)\xecI%EI\x8f\xdesnOt\xba\xb2\x06\x94\x11\x95u\xae4ne\x9fb\x15\x03\xa7\xad\xa6\x9cN\x92\xec\xbe/\xa2\xb0\x00\xea8Y5knUU\x950\xee\xeb\xca\xdf;c\xd6\xc4髖rM-U\xe36\t\xba\x1e\x1f\x8cC\xe2\x83>(\xd9>9<p\xce5\x87\x95\xf61\xf9\xbf\xfez\xe4\xb5\xd97\xfc]R\x8cU\x14\xa5KikK]\xfe\xdevi\xe1wy\xaa\xc5G\x19\xa5qX\tJ-\x82\b<\xaf\x16\x0e\xfb\x81\xf7S\x84\xcf\x15\xcb\xc9\xc2\xf7+\xd0}^\xf1\xccj\x97\xa2\\\xe0k\x10\xf6\U000b9828\xe1,_Ab*\xe9\"h'\xbf\xb2ٙLr\x1a\xa1\xaeAJ\xa8\xb3\x9ep\xee\xcd6\xf1d3XP\x14\xb4\t+J\x11\x97+\xbc~\xcb\xedG\x80\x01\xb4\x8f\xd9\xff\xf7_\u007f-|-\xbc\xc9\xcf%\xc5XEqw)E=\xf9\xe5\xc2\x18\xa5\x8a\xa4\x8f\xf9\xcd\x18\xe5\xa1uYV\xd9\xcd>lɃ\x1e\x97&\xbfk\xe1?\x14R\x8dQ\xdd\xcf+\x9e\xbc\x88nD\xbd&\xe6\x18%\xe3}\xf2\xb6|\x9b\xa2\x86\xb4w{_\b\xd82\x14\xab\xa8\x88^T1 &o\x9f\x11\xb9\x8d\x94Њ\x12\xdc\xe4LɊ\xb2xf\x0ffZ<\x02\f\xa0}L\x9e\xa0(\xbf\xe6\xbd6\xb7\xa9\a\xf93\xc6*\n\xe5R\xda%\x8e\xb6/\xd9\xfb\x9d\x16\x83\xe8\xd07̢\xa3\x91'e\xa9\t\xfc\x92\x83\xc2!\xdf\x10g\xcb9\xedX\x87\x15\xa5\xdb\xd4X\xcc\xef\xbb\x1d%\x9c\x9d8\xe7QzkțKQ\x12S\xc8[r\xa2\xa2\x86\x0f\x9dC\x90\x14\xe5*\xeen\xe0\x13\x9b\x917hE\tw\xa5dE\x99\xe3\x9ciy\x8bQ\x14Н\xf61\xbb\xff\x03KJ\xe6\x98\xf9\xfe-)\xc6*\x8a\xecRڟ'\xce\xc3~/(J}6\x1e\xb9\xb4e\xfb͵\x9e\x86\x1cA\t\x9eTƔ\"\x94\x90\x88\xa7TS\xb1\xa2\xa0\x84\xcauk\x12N\xe3s\x9f\x9c\x98_pF5\xff\x88\x84\xbb\xc6(\uf489\xd8e\xe9\x8a\x1a\xd2\u07bdFx\xec\xb6\x12j&\x85\rQ\x14;\x19\x9c\x84\xbf\xed\xca$\x8a\xb2\x1e+\xcaҙ\x17\t\xad*\xc5\x01]i\x1f\x93K\x14\xe5\xd7/Ƽu˟%\xc5XE\xa1\\J\xf7\x1e\xc1\x19䬧\x9f\x18\x94\x1e\xf5\x9f\xfbQ\n\xf0T\bBI;\x10\xb2\xa5\n\x89\xbe\x95DQҲL\x17\xf8\x9d8\xe3\xb1\xe53ᄦ/i\x19\tw)\xca92WRɟS\xd4P\xc3W\xe3d\xceA\x8f\xd5t\ue2b2\xd6x\xe4JDF\"t\x8f\xcb\xc7Iy\xb8\x12\xfa\xb1\xb0\xbd#\xb0\xa2\x1c\x11\x17\xfd\xf1svi@_\xda\xc7\xd8\xff]\x94\x94\xf5c\x96\xde\xf1cI1BQ\x98.\xa5?f\x97\xd7ߩ\xcf'\xf7\xcc\u07b2\x1f\xbdq\xcc~K\xa3\x9a\xd1C\x01o\xdew\xf6t\x06_\x8b\x93\xa9\xa5\x05+\xf9د\x04\xd18h\xb6\xf4%\xc4\x14\xe0\x88\v\xe6Ċ3\x1bLW\x10z\x88\xef\x99-v8\x1e\n\xb9iQ9gs\xa2Ҕ5\xa0\x9cyi'\x84\xa4rfV\xa4yM*#\xd7\xc9\xc6\xe0-\x85o\x86\xdeA=\xa7\xc8e\x1fq&e\xee\xe4/>\x8f\xe0\xc6\xe6\n\xe3\xc1\xb5\xdc\xe2\xfcC\xf1\x9c\xdḟ\x8fl\xda\xc7d;\x15\xe5\xd7U\xaf\xadh\xf1_I1BQ\x98.\xa5\xa8\xe5\x9b|{\xe1)q\xe2\xbb\xe5\xb0\xfd\x90\x1f\xfd\xaf\xa7bM\x81\xcddM\xc2r\xd0W\x9c\x10\x1d\x97V\xf1\x9e)I\x18\x8bX\xf6\t\xaa\xd2@B\x9a7\x98\x97\xa4\xfcEH\xa4;\xa7I\xc8X\xa6\xf4C\xf3\x87\xa5}\xca\x1a\x84QʺX˚\vj+S\xa5냰\x90\xb9\xdf\"t)\x88̗, \x99\xd7#C&\xce\xff#ǭ\x10\xd2G\"\xc3&\xcd=\xec\xbd\x12@'\xda\xc7d\xfeۿ\xff\x87x\xdcĿ\xb6\xca\u007f%\xc5\bE\x01\x80\x80GP\x94\xff\xe7\x1a\xa4\xfc\xfa\xf6kk\xef\xf9\xab\xa4\x80\xa2\x00\x80\x01\xb4\x8f\xd9ޏ\a)\u007f?y\xfc\xf8\xf1c\xaf\xbf\xb6\xb1\xd5O%\x05\x14\x05\x00\f\xa0}\xcc\xd6\x1e2H\x996\x86\xf0\x9b\xedm~s%B\x01(\n\x00\x18@\xfb\x98-]\xe8\xdf\xec\xff\xfek\xf9\x98\x05\xff\xb4y\xf3\x16\xfb7~\xfaP7P\x14\x000\x80\xf61\x9b;z6\xbe\xb6\xf9ￎ\x9ft\xb8\xbe\xa9\xa9\xa9\xd5O\xef\xc6\aE\x01\x00\x03\x10\x14\xa5m\u0558\xff\xf4\x0f\xff\xfe\xeb\xde\xd72[z\xfa\xfb\xfds\x84\x02\x8a\x02\x00\x86 (J\xfc\x987>~-\xf3\xef\u007f\xff\x87Yu~:>\xc1\x80\xa2\x00\x80\x01\xb4\x8f\t\x1d3g\xf7\xa9\xd9\xdc\u007f\xfc\xba\xf97\xf9~:\x87\x82\x01E\x01\x00\x03h\x1f\xf3ZD^]k\xf9k\xb9\u007f\xff\x8f\u07fc\xe5\xc7\u007f\x16\x04E\x01\x00\x03h\u007fma~}G\u007f\xdbl\xee\xdf\xda~\x13Y\x0f\x8a\xc2D\xabr\x00\x00D\x9e\xfe\xd3qAPP\xcf\xe1\xdf\xfc\xa7\xdf\xfcç?\x82\xa20Ѫ\x1c\x00\x00\x91\x9e\xb6V\xf2H\xa0\xf6\xa2\x88\xf9[N\xc2<\n\x1b\xad\xcaG:\x8b\xb9\xb0\xdf\xfb\xcdCY\x80\x91\x8d\xf3rq\u007fۍ\xba\xeb\xfez\a>&\xa0\x15\xa5\xe5h\xee\xec0\xf1a\xf0m\x11\x87\\\xb9T\x12\x00\xf4\xa6\xbf\xa7\xa7\xc7\u007fG(\x86)\x8a\x86K)\x1d`,ǸKbbs\xd0\x17\xae<*\t\x00\xc0\xa00FQ4\\J\xa9\x00\xa3\xf9\x96;\xe5L\x95\x8cݎ<\x93\x00\x00\f\x06C\x14Eå\x94\x0e0\x1aYQ\xd0\xfa\xe0[\x8c$\x00\x00\x83\xc0\bE\xd1r)\xa5\x02\f\x87R\x94\x8e\xa9\xf1\x8c$\x00\x00\x83\xc0\bE\xd1r)\xa5\x02\f\xe7\x12wLJ\xaf\x0f\xe9b$\x01\x00\xf0\x1d#\x14\x05i\xb8\x94R\x01\x86\xd3\x13\x16q\xf2\x8eS\xe4N\xca\xe3\x15*\t\x00\x80\xef\x18\xab(l\x97R*\xc0x\x0es\x1c\xb7PL\xde\xe2\x0e\xb8r\xa9$\x00\x00\xbec\xac\xa2\xb0]J\xa9\x00\xc3\xe9\x98<c\xeb7N\v\xcf[\xb2\a\xf0-\xb0\x03\x06\x80\x97\xc1XEa\xbb\x94R\x01\x86\xf3-WN\xa5O2\x92\x00\x00\xf8\x8e\xb1\x8a\xc2v)\xa5\x02\f\x87\xbaփ>\x1d\xdf\xceH\x02\x00\xe0;\xc6*\nۥ\x94\n0\x1cJQ\xfag/`$\x01\x00\x18\x04F(\x8a\xa6K)\x15`4\xa7dE\xd9\xca]d$\x01\x00\x18\x04F(\x8a\xa6K)\x1d`$=-\x17\x17\a\xbb\xdcQ\x8f\x87|\x84<\x93\x00\x00\f\x06#\x14e\xc4\xf2\x16\xc7\xcd8\xe4L\xef\x1f\x1f\xdf\xe3\x99\x04\x00`P\x04\xb4\xa2\xb4\\\xbc\xe3J\xb6M\xfd\x82\x91\x04\x00`p\x04\xb4\xa2\x00\x00\xa03\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x12(\x9cI|\xa4\x15\x12\x10\x90\xed0\xb4N\xb4\xee\xab\x18ڵ\x8d0\fR\x14\xef.\xa5\x1dU\xf9\xf6C\x97\xe0\xff\xbe\xbeS\xcc\v\xccK(\x1b\x10?\xd6ĝq\x8f\xd8&\x04\x98\xefʟ\x0f\xf2\x058\xb8>,\x17\xd9î\xbbG3\x19L,\x8b\xc6(\xa1\r\x19\xd2GF#u\xa18\xe6\xcfR\xfa\xbe\x89_\ue664qn\a\xb6\x13mc\xf2\"˚\xda\xf7\xaf0\x16\xb9\xf0\xa1\x17\x9e\xab\b$\xdf[c\x14ŻKi{\ue87a\xa6\xf3\xbb\vAR\xd8\xd4^\xf3\xc8z|\x90\xafp\x9cK\xe3\xf7\x89\x1fϚO\xb8G<p8J\xf9\xab\xd2\xc7Ҩ\n\xf2^έB\xab\xb8oH\xfa\xa8\xc6c\xa5\xe8X6\x8c\x96Q\xbc\xb8\xba\xf2}\xc7C\xe9#\xa3\x91Z5\xf8ć\xa6\xf7\xa5\xf4\xc0\xd5mўI\n\xd7v`:\xd1^3\xa5\x9c\xa8\xfc\x8c\xe7\xab\xf1\a\x95\x961{\xa1\x80\xb5\x8a\x00\xf2\xbd5DQ4\\J\xbf\xc9\xc7Ϛm\xb3\x9f\xf7VG\x00\xb3:\xd53\xaf\x86o\x16\x0e\x9a\x9d\xfcm\xf1c\x9fg\x04B\r\xb2\xa2\xdc5刉\xf3\xdcF\xb4\xd1\xf9\x84\xba\xdf-f\x95\x92\xa1cٰZF\xf3I\x12\xfd\x89\xd5H\xad\x1a\xb4\xe9\x8cJ\x8b\xea\x94?\x16D\xb3\x92.\xa4\xed\xc0t\xa2ݰN\x18[\fl\x13\x15E\xade\xccMM\xc1^E\xe0\xf8\xde\x1a\xa1(Z.\xa5\x85\xf9d\xe1\xd1\"v\xf1\x80g\xa5\x9a\xa2\xa0n\xcbN\xcfE\x12\x94\xa2dX\x9f\x8b\x89\xeb\xdcV\xb4\x9d\xbbA\xd2\xe1\xef0\x8bIбlX-\xa3Q*\n\v\xad\x1a\xb4\xa9\xe5\xaf\xf1\xb5\xf2G\xef\x8a\"m\a\xa6\x13\xed2\xa2\x05\x8d\xfci\xfc\xf6\xb2-c\xaf\"p|o\x8dP\x14-\x97\xd2\x16\xf1\xb9G'\x87\xc1t\xeb\xc6\xdba\xe3\xa6, \x0f\x86\xcc\f\x0f\x9d\x93)\xbc\xaf\xe0\xc6\xd9W\xcd\n\x9d\u007fK\x91T%/\"t֪\x0e\x84.\x8d\xe5\xb8\xf5ח\xce\b\x99\xdfC%݂s\xa7\xd8\xf1ۭ\x89\x9c\xc8D\xe9\x89O\x02;ySٮ\x04\xf3\x86\a\xf8\xc3@E\xa29a\x97\xf0\xdd<Ë\xacV\xd6$*\n\xda\x19\x8b\xd0\x133\xcfGU\x92\xdcg\xa9V\x93-\xa5\xd1\x19#+J\xaf\xc5\xf5\xbb\xd9\xca\xe5\xa1|\xae\x15\xa1\"g\x13\xc2I\xb6k;\xac\xe0\xc6n\x8f\x9f\x16\xb6\xf0\xba\"\x96\x8d\xa2e\x977\xd8L\xb1ɶ\x01e\x88\xac(T#\xe5XE\rR\x8f\xd9ۡ\xd1\xc4\xf3{\xee\xa6/\x8bI~\xa1\\G\x81\rYœ\xbf\aiVK\xaax\xaa#%\x95\xc5\xe4\xed\x80XN\xb4iV\xbcQ\a\xceu\xd2-\xa3k\x90{\xa1h\xe4\xe3\xf4X[NN\xac\xb9\xda\xcb*\x02\xc6\xf7\xd6\bEA>\xb8\x94\"Կ\xb7\x8aYt(96!|s\xf9F\xe1\xa7\x18\xa1\xf8\xe0\xf5%\xeb\x83\u007f\x8fP\xfdޱ\xdc\xe4M[&\xbe\xadH\xaa\x11\x1f\xf4A\xc9\xf6\xc9\xe1\xfd\xa8+\u007f\xef\x8cY\x13\xa7\xafZ\xca5QI\xb7跸\xf9\xf8\xadg\xf7v\x91\\Zr\x9a+M|\\\xc1\x9f-\x9f\xe1\x0f\x19QY\xe7J\xe3V\xf6\xa1\xce+\x8e\x84$\x87\xc3q[Y\x93SQ\xcaxa\xc0\xdf\xe0p\xc4\x14\x90ܳ|FmuJT\x83\x18#+\xcaM\xde\xe1L\xf5O;\x85\xbe\x9b&\xc8x\xc7ɪYs\xab\xaa\xaaȔ\xb9\xb4\x1dp\x8fg|\xfe\xe9\x8c\xd0::\x96\rݲ\x9f楟\xa8)\x8b\xe5ݎvj\x8c\"7R\x8eU\xf4M\xea1{;tWW\xda\x12,\xb6]i\xf3\xe4\x99\x19ºT\x94\xba\x0e'\xeeZ\x12*\xcel\xe0\xa3\x15Ie1y; \x96\x13\xedC[Tr\xc1\x0f\xbdH\xd17E\rR/\xe8F\xf6.\xb7\x96\xee\x8b1\x97m(\xf6\xb2\x8a\x80\xf1\xbd5VQ\xd4]J\x85M\x9e\xdb\xc6.;ttM\x9f߅\x1d>ڰY)v\xfb8\xc2\x1d\x16^\x83'\t\x83\x92\xa5\x93\x912ɤ\x88\xcbEآ\x838\x10\x86so\xb69O\xe9\xa8$M\xd3\xe7\xe29Ľ&\x11\xb7\xc7\xffG[\x84\x9f\xbc\xf48\x84\xa5\x01\xcf\xee5\xf0\xe4\xf7P\xfd\xac\a]pN\xa48\x0f\xd6\xe7Ղ\xc0\f\xbc\x9f\"\xc6Ȋr\x8e\xff\xabG\r\xd4Y\x0f\xb5\x1dP\xf0\f\xdc\xf0\xe9\x11\x8cxO\xa4\x96\x95\xc6a-)\xb5\xb8M2(\xcfz\x9c\x8dT\xc4J5\xd0=V\xdb\x0e\xfc'\xcf\xd0\xc03\xa4\xa0\xcf\\\x8c\x8a\u0378\xae5\xef\tC\x99\xbe\x0f\xa3\x95IE1\xc5v`8\xd1>.\xf8\x83\x89\xb7T\x8b\xc5䭮X\xb1\xb3\x17T#\xabyaTX*\xee\x10\xd5U\x04\x8cﭱ\x8a\xa2\xeeR\x8aNe\xbb\xff\xa0\x0f=%\xdc\xf7\xaed\xfco\xc9\xdb\x1b\xf8l7\x18\xbfl\fF\xca$\x93\xc53{0\xd3\xc8Irx\xb0\xd4\x05*ɠ\x89s\xa1\x8c\x8aNGγ\xff\xb4w{_\b\xd8ȵW/\x8aR\xc1?&\x1f]_\xf3ǥ\xc9\xefZ\xf8\x0f\xc5\x0f\xb2\xa2\x9c\xe6\xef#O$E\xa1\xb6\x03\n\xfe#~\xcd\xe4|\x92w\xa9e\x0f\xad˲\xcan\xf6\xf5\xba-g*\x8a\"V\xaa\x81\xee\xb1\xdav\x88v\x1b\x9e`\x1a\xf9+\xddW\xf0!\xfd\x84/ß\xf7D+\x92\xcab\x8a\xed\xc0v\xa2\xed\xaeI\xe6\xcf\xe1\x04\xad(\xf4\x8a%E\x91\x1a\x99c\x11^n\x8b\xb3/\xaa\xab\b\x18\xdf[c\x15Eե\xb4\xe7\xa8]\xbac\xc58\xb6rҹ\xed\\\xd1M}\x01\xfem\x0e\xde(\xbcl\x12\x15EN2\x99\xe3T\x86\xb7\xf0\x87\xf0p)\x9fJ\xb2\xa8*\x12q;ϋ\xc6_V\xf2%\xfd\xd0y\x1eOF\x1b^\x14\x85|\x99\x91\xf45o\x88\xb3\xe5\x9cv\xac\xf3P\x94\xab\xd4ud\x19IQ\xa8퀂7\xe1\xd7c\xbe\x19\x16\xc9-{R\x96\x9a\xc0/9\xa8:\x8f\x82q\x1d\x8bt\xacT\x03\xddc\xb5\xed\xe06\x97D(%\xcbKqo\xc9\xe9\x06.F%\x95\xc5\x14\xdb\xc1Ӊ\xb6\x81̊\xf4%\xbaouŊ%E\x91\x1aY<\xef1\x1e-\x8ac\x14\xb5U\x04\x8cﭱ\x8a\xa2\xe6R\xfa\xb4(\xcfe\x9bc$\xe5\xf2q\x13?\x93\xbc\xcd c\x14|P9\x15EN2Y:\xf3\"\x81L_\x86\xcb\xf3-\xe1^\xa6^ԑ\xbf\xa4i\xef^#\x90\x11\b\xf9nW(\u007f\x9fEE\xe9\x8ds~\xed\x9d_\xf3\x84D|\x9d!\xd5CQ\x9eG\x17 O\x88\xa2؛\x14\xdb\x01\x05\xaf¯\xf6A\x8cQp\xcb\x1ar\x04}xR\x19S\xaa\\.*J\xe7>\xc5@J\x11+\xd5@\xf7\xd8\xdbvp'uuCC\x03\xbe\xd2\xfb7\x9eT\x98\x1e\xadH*\x8b)\xb6\x83\xa7\x13\xad5\x8b\xbc弇_\xa9\xad\xaeX\xb1\xa7\xa2<\x8cJ~ؘ\x90(\x9e\xf1\xa9\xad\"`|o\x8dU\x14\x15\x97\xd2\xd6\xfd\a\x84\xcd\xddo\xf8dxǔHf\b$f\x00\x00\x03\xb5IDAT<\xa3\xf3\xc1*<\xf0ǃ\xd2\xfd\\\tRW\x94\xa6M\x1e?\xdcG8r\xe5\xfb\x8f\x9f\xe3W\xeaj\xacʅ٦/\xbc]\x8b\xa5\xbe\xa45\xe2=\x119\a\xf1k\x92p\\>\x123\xa4\x1aDE\xc9\u1777a9\xbf\xe66\xfc\xd5\xef[\xe9\xa1((\xf5=\xc6m\x14\x91\x91\b\xdd\xc3\x1d\xa0\xb6\x03\n\x9e\xd2!ďt\x0fft\x9ejY\x01\u007f\x81|\xde!ƺ\xba)*\xcaM\xfe2\xf9\xe4l\xa4\"V\xaa\x81\xee\xb1\xcav\xa0\x0fli\x15\xd6]\xc2\xcb.\xab\xf0\x92h\x13t\xe7vL\xb42\xa9,Fm\aʉ\xd6UY\xac\x15+W\x9fX\x80\xda\xea\x1a\x8ar\x8d_\xc2\xf3\xeb\x1e8\x97\xb3W\x118\xbe\xb7F(\x8a\x96Ki\x93}\u007fSKK\xcb\xc9|\xad\x8at\xe7\xe8\xebod\x96|\xc0\xe1K\xbaK\x83\xd6\x16\xad\rZ\x8aPKո\xf8S\xe8b\xfc\xb8\xaa\x16*\x89\xa3\x17r\x13<~\xb9\xd7r\x8b\xf3\x0f\xc5sy\xa8\xe7\x14\xb9v\"\xfc\xe2\xd3I7\x16r^\xbeW?;Lۮ\x0e\xdc\xdcfr\xfc,\x1cC\xf3\xd2N\x9c\xce\x10g$\v\xa2\x8bO\u007fb~H\xd7@\ue67d\x90N\xee\x99\xed\xbd\xeap\xc4ls\\~\x86\x0f\xd6\xd4҂\x95|\xecWW\xd1C|\xcfl\xb1\xc3y\xcf\xea\xed(\xf9Nu\x89\x8d\xc1[\n\xdf\f\xc5\x17\xb0\xa9\xed\x10̅\xe7\xdbgM\xf2P>V\xe7\xe5\x96\x15\xf0\xe6}g\x85\xf6\xd6:cI#_\xfc\xb0\xf2}\x87\xc0\xd7\xc2I\x88\xa2\x91T\xac\xdc7\xa9\xc7\xec\xed\xf0\xe2\ar\xf5\xe5\xbe\xd4\x1c\xb2\x8a\xee\v|N'\xea\xcc\xe1/t\xa3f\xb3\xad`Ϣ(SE3\x95t+Fm\aʉֵ[by\xeb\xbe\vBsn\xd3-\xa3k\x90{A7\xf2ZL\xcd9\xc7\x03\x97\x8e\xb0W\x118\xbe\xb7F(\x8a\x96K\xe9\xe1l\x91a\xb8\xc3\xed\xfa;\xd3&F\x90ɝ\xfe\xcc9\xa1s2\xfb\xf1M(\x1c7\xae.Tx]A%q\x88}\x02'M)K\x1c\x89\f\x9b4\xf70B\x97\x82Ȅ\n\xfejRI7r'g{f\xba\xd8\xc9\xf3\xbc\xe9/f\xe1\x15߶V\xb3.ֲ\x86\xfc\x98\xa3\xee\xacE1I\r\x8a\x1a\xc8\xffz\xf8ed\x02\xf2\xa7(q\xaeA\xf8\xd0W\x9c\x10\x1d\x97V\xf1\x9e)\t\xa5;g \x9c?\xaf\xfbb<\xff\xac\xd2\xf5AX\xc8\\\xb1G\xf2v\b^\x15?q\xeaR\xcfsPf祖U\xac)\xb0\x99\xacI\xce;͜\x8dlt6\x8c\x17\x0eQ\xaa\x91\x8aX\xaao\xae\x1e\xb3\xb7\x83\xb3\xb2d\xa4XE\xcd<|\xcf\xfc\t\x9e\x9fW\x83\xd0ݔE\xcbr*L\xb8\x98\x94t+&o\aډֵ[\xfeP\x96\xb3\xdc\x1c\x97\"^>s\xb5\x8c\xaeA\xee\x05\xdd\xc8+&\x9cgZӬ\xbe\x8a\x00\xf2\xbd5BQ\xfc\x86B\xdff\x17F\"\x03Y\xa6j\xad\x18\x8283\xcb`\x14w\x9eµ\x1dtt\xa2}d\xde\xf1\xe8ŋ'?}\xb6\xe8\t\xf9\xccX\x85\x8ek\x1b\xf1\x80\xa2\xf8L\u007f\xee\xa4\x15Z1#\x97\x81b\xdb/Z1\x18\x15E\x19ݝ\xa7\x10\xb7\x83\x9eN\xb4\xa7\x9dw\xe1\xf4ŊCJ\xcfU蹶\x11\x0f(\x8aϴ\x84\xad2|\xee\xd8xT\x14%0:\xffR\\\x8b\x12Ow\x9a\xa3njD\x06\x04\xa0(\x00\x858\x17\r\f\x86\xbe\f\xf3\x8e\xea\xda\xea\x1d\xe6\f\xb7\xbbq\x02\x13P\x14\x80\x82\xccE3.R\x01^\x188\xb3\xc1j\xb2&\x9f\x05A\xc1\x80\xa2\x00\x00\xa0\x1f\xa0(\x00\x00\xe8\a(\n\x00\x00\xfa\x01\x8a\x02\x00\x80~\x80\xa2\x00\x00\xa0\x1f\xff\x1f\xec\x88D\xdc\xfa\xfa\x88\xfa\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/error1.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x04\xc1\x00\x00\x00\xbd\b\x03\x00\x00\x00\x8d\xa5\x9a\x96\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x02\x05\x01\n\x03\x01\x05\a\x03\x1e\x01\x00\v\r\n\x10\x12\x0f\x16\x17\x13y\x00\x01\x19\x1b\x18\x1b\x1b\x14\x83\x01\x00\x8c\x00\x00\x8c\x00\x04 \x1f\x19!# #$\"%%\x1e$%#&'%'(&+)\x1e()'++$*,)/,!-/,02/63(241\x98\x1b\x1b786;8,\x82%#:;9><0>?=C@4@B@\xa0*,CEB\x9c.-KH<MH7\x00f\x00\x00g\x00\x00h\x00JKI\x00i\x01\x00j\x02MOL\x04l\x05TO>\tn\aPRP\xa9:<WRA\fo\t\x0fp\vTVT\fr\x17\x11t\x19^YG\xaaDCY[X,`\xae7]\xad\x15v\x1c\\^[\x19y\x1e;b\xac_a^faO>e\xaf*{!bda)}*Bh\xb2egdLj\xafpiR.\x81.Em\xb1ikh\xb3XX0\x8301\x841/\x858Jq\xb5mol;\x86:Vu\xb4>\x89={t\\tvs@\x8b?B\x8c@@\x8dG\\z\xbay{xJ\x8eI^~\xb8\x84|d\xbbkkL\x90K~\u007f}O\x93Mb\x83\xbdN\x95UW\x95V\x82\x84\x81\x8f\x85hm\x87\xbdZ\x98Y[\x9aZ\x87\x89\x86\xc0{|]\x9c\\\\\x9dcr\x8d\u0096\x8cnd\x9dd\x8c\x8e\x8b{\x8f\xc0f\x9fg\x90\x92\x8f~\x93\xc4j\xa3jy\x96Ŕ\x96\x93s\xa4l\xa1\x96xq\xa5s\x81\x99×\x99\x96\x83\x9bť\x9b}u\xaaw\x9a\x9c\x98Ǒ\x92\x9c\x9e\x9b~\xaby\x88\xa0ʞ\xa0\x9d\x81\xad|\xab\xa0\x82\x8e\xa2ǡ\xa3\xa0\xa2\xa4\xa1\x81\xb1\x85\x92\xa5ʋ\xb2\x88\xb4\xa7\x83\xa6\xa8\xa5\x8d\xb5\x8a\x97\xabЩ\xab\xa8\x8e\xb6\x8c\x8d\xb8\x93\xab\xad\xaa\xb9\xad\x88\x9f\xaeή\xb0\xad\x96\xba\x96\x98\xbb\x98\xa3\xb2Ұ\xb2\xaf٨\xa6\x9b\xbe\x9aµ\x90\xb4\xb6\xb3\xa3\xbf\x9d\xac\xb7Ҷ\xb8\xb5\xa2\xc0\xa4\xb7\xb9\xb6۰\xb3\xa5ħ\xba\xbc\xb9\xb1\xbdקƩ\xbd\xbf\xbc\xa8ǫ̿\x99\xafƫ\xb8\xc0տ\xc1\xbe\xb2ɮ\xd0Þ\xc2\xc4\xc1\xbc\xc4\xd9⽾\xc4\xc6òͷ\xbb\u0379\xc0\xc8ݻ\xca\xde\xc7\xc9\xc5\xd8ɝ\xbdϻ\xc6\xca\xda\xc0\xcc\xda\xca\xccɿҾ\xd7ϡ\xcd\xcf\xcc\xc4\xd0\xde\xcb\xcf\xdf\xc8\xd3\xc1\xe0ѥ\xd0\xd2\xce\xc8\xd6\xc9\xea\xcc\xcb\xd1\xd3\xd0\xd2\xd3\xdd\xca\xd8\xcb\xd3\xd5\xd2\xdf֨\xcd\xd6\xde\xcc\xda\xce\xe6֪\xd6\xd8\xd5\xd4\xdb\xd0\xeb\xd4\xd2\xd2\xda\xe3\xd8\xd9\xe3\xeaۯ\xda\xdc\xd9\xd7\xde\xd3\xe1\xdb\xda\xd5\xdf\xda\xdc\xdd\xe7\xdc\xdf\xdb\xd7\xe1\xdc\xde\xe0\xdd\xdc\xe1\xe3\xf0\xe0\xb3\xe0\xe2\xdf\xe2\xe4\xe1\xee\xe1\xe2\xdf\xe5\xe7\xe4\xe6\xe3\xe8\xe5\xea\xe5\xe7\xe4\xf2\xe4\xe5\xe6\xe8\xe5\xe3\xe9\xeb\xe7\xe9\xe6\xe8\xea\xe7\xeb\xed\xea\xf6\xf0\xef\xf2\xf4\xf1\xfe\xf8\xf7\xf9\xfb\xf8\xfe\xff\xfc!l\x99S\x00\x00 \x00IDATx^\xed\x9d\x0fXTם\xf7\xf7\xd9\xd9\xd8w\xd3$C\x03\x9b\x12-K^\xd6fm\xfb\xdc\xe1\x19\xa9\xbe+\f\x8d\x1d\x14\xd7?1+\xbeVQ\x8aV1\x1b1\x18\xe7a\x13\xa3\x82ƄL\n\x19%) B\xe6\x89E\x1eY3*\xbe\">\x19Me\xc1\x96hqm\x12\xe8S\xa6ѱ\xb6\xda\xe4\xf2(\xac\xe4y\xaf\xe7\xed\xa6\xe5y\xcf9\xf7߹ý3(\x03\x97\xd1\xdf\xe7\xd1;\x87;\xbf\xf3\xbb眹\xf7;\xe7\xfc\xee\x99{\xfejh\x14 \x00\x00\x00\xf3\x18\x1a\xfa\xabH*\x15\x8eH\xee\x01\x00\x00\xc6\x10P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x173\x15,p\xa0\xaa\xa2\xfa\x18O\x92\u0099\xba\x8a\xba\xceH\x19\x00\x00\x004\x98\xa8`A\xb7\xb7\xb3\xbb\xb3\xae\nK\x98\xe0\xf5\x9c\xee>Yq2R\x16\x00\x00\x00\x16\x13\x15\xac\xcbݍ\xb7\xbc\x1bw\xbd\xceT\\#;*\xf8Hy\x00\x00\x00\x18LT0D\xf5*\xe8\x0e \xe4=@wTB'\f\x00\x80;\xc1L\x05\xc3\xf4wW{\x05\x84\xea|\xf4/\xef\xfe\b\xe6\x00\x00\x00,\xa6*X\xd0\xedv{HO\xecX\xe5\x00\xde\x0ex\xea\"\xe5\x00\x00\x00`0U\xc1P0\xd0^M\"\xf9\xbc\xc7\x1b\xec\x0fx\xddՑ2\x00\x00\x000\x98\xab`\x98\x81\xea&\xbc\xbd\xe6\xc5ݱ\x16\xaf7\x925\x00\x00\x00\x83\x89\n6 З3n\xfa\xda\u007fM@\x95\xc7\xc2f\x00\x00\x00\xd0b\x9e\x82\t\x95b\xf8\xfeL\x05V\xb0A\x92\xea\"\xb7%\x01\x00\x00F\x8cy\n\x86\xaa\xe8\x14\n:\x8a\xect\a\x11\xe2\xab|\x91\xb2\x00\x00\x00\xb0\x98\xa8`]\xee\xa6\xce\xeeN\x1a\xc9\xefr\x9f\xec>S\xe9\x85\t\xad\x00\x00\xdc\x11&*\x18\n4UWԵ\x90y\x14\xe8t\xb5\xc7{Z\x88\x94\x01\x00\x00@\x83\x99\n\x06\x00\x000:@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]bK\xc1\\.\xbd$\x00\x00\xf7+&+X\xbb[z4~\xc0\xeb9\x10\xf1\t\xad\x1fs;u\x92\x84z\x8e\xe3\xcaQ9\xde\xd6\x0fϦ\xd0k\xe3\x16\xe1\x17\x176K\xeb\tc\xa7\xe5\xb8\xe3p\x98w\xef\xd0\xd9\xe8\xc0\a\xab\xc1/5\x1c\xc7\xea\xf7\x8b\x1cר\xfcq\xeeG\x8eY+[\x97|0,\xafH-k\x1b\x81\x17Gd{w\x8d\xfaً\x0e\xfb\x8f\xa2\xf28%\xed\x81\xc3\u007fX\xe3\xc3D(\xc3\xfd\x83\xb9\n\xc6W\x1c\xab\xa4\x89\xee\n_\x97\xaf\xa2;\x82y\x91\xfd\x8aN\x92\xc0\xbf\xcb\xed\xbe\x8e\xae\xbfŽ\x1b\xf6)\x89\x1d.;\xde^\xf2\xfbk9\xa3K|8\xcdi\xe1\xae\xe3;t\xa6\xd2z6\x92\xc5p.\xa5\xbdՇ_\xfaޚq\x89\xd9{\xc5o+\x97\xd3gm\x05\x87\x1a\x9f3\x96\x9e>\xff\xf2r\xa4\x87NqX\xbfa\xb8\xabF\xcdsԺ\xd2\xfa\"Y\x8d\x04\xed\x81\xc3\u007fXw\xd7\xea#\x81\xf5\x1b\xa9\f@41W\xc1\xbcM\xddT\xc1\x84*\xb2\xc6DZ\xaa\xf0_\xca=\\\x89NR\xe4\x02w\x1co[\xb9\v(,\xe5v\xf1\xb5\xe3\x0e.6\x14\xa9\xabpG\xce\x14~P\x18\xc9B\x87%b\x17\xb3~\x89v\xb7]Q\x9a\xd5yd\xeb\n\xd3y*\xd0W%\xdd\xe2\xd8G\xa2`wӨ}\xb8/)\xf4G\xb2\x1a)\xec\x81#|Xw\xd5\xea#@\xe37\xd2\t\x03D\x11S\x15\xac\xdd\xc3\a\xa8\x82uV\x90\xb3\x99\xaf\xe8\fk\xeeR\xfb].m\x17ll\x15,\x12w\xe7l\xd9\xdd\\K\x85e\xf4\xa5,$\xaf\xaa4s\xa9\xc19\xee\x102\xc2@\xc1t\x8b3f\n\xd6\xc3Es\xa0u\a\a\xbe\xabV\x1f\x01c\xe5\x17\x88\x84\x99\n\xc6Wt!Q\xc1\x9a\xf6\xd3\x1d\xfb\xc3.\xf5\xd1k۪\x93\x94`\x14\x8c/̴e\x15\x9c\xc3\u007f\xbe\xc4\xd9\xeaK\x16\xa4\xad\xa6C\xae+E\x99酮a\x17[\xe3ʴ\x05%X?\xcf\xd98\xae\xac\xa7h\xae}\x8d\xe6\x1b\xb4/\x8d\x13\x87d\x82\xc3\xf6jVf\xeb\xd6Yy<\xf1[\xe3\xcaJ/\xe81p\xc6\xda2\x87`\x8as\x98\x13YF\xde\xf7\xafβ9~\x94\x854\xa8\xb5`\xd9)^(\x85;Y\xbfXi\xb6\xba2\xc5\xe2\x14fR\ro\xa6\xbbk\x97\xa5-\xa9\x153\xf6\x14:\xf01\x88\xecc\x05ۊ\x8fl\xff\x8c\xf1\xa0)\x0e\x83\xbdDn\xbeh6\xea\xa0C<\x9a؍\x96\vi\xf0\x01\xe8\xb7\x03[!\xf5\xc0ʇE\x88\xd4\xea\x06\xce\xe4\xe20\xd945fZ]\xc9\xc6\xfaՔA\xc7\x19\x10e\xccT0o\x13\x92\x14\xacN\\(\xf2X]8s\x97\xed\x92NR\xe2\x02\xd7<00\xd0L\x14\xac\x99s\xb56\x16p\x1d\b}\xdch\xe3\x1c\xe553\xc8e\xdf3kA\xfd\xe1\xd5\\\xe8\xc5\xe6\xe2\xb66\xd78\x96\th\xa0\xb11k\xc1\x8c\xac\x92\"\xaeW\xe3\xf8\xac\xdf/\xf6DZgq%y\x9cc\xb7\xa3\x86\xfa\xcd\xda]\x9e\x95v\xc1\xc0\x19c\xcb\xece\x8a\xc3\u007f\xe0_\x90\xe7\xf7\xfb\x89\xe8\x9c\xe5\x8a\x1a\x8f\xd7;8\xed\xd8C\xad\x05K\xfd\x0fPG\xd6\ahY=\xeb\x17+\r\xb7\xac\xb1q\t)No\x16\xb7\xa6\xbccP,\x8e\xbd\xac\xb9\xcc^D\x92\xadi\xcb\xde:^No\x03`\x05\xbbR\xc4\xd5t\xb0\x1e\xd8\xe2\xb0عE\x8d\x87\x1d\xa4\xf9\xa2ڨ\xe7\xfc\x8d\\\xb9\xdfO\x15C)\xa4\x81\xad~;\xb0\x15b\x0e\xac|X\x91[\xdd\xc0\x99R\x1c&\x1b[c\xb6Օl\x1a\xbfl\x19t\x9c\x01Q\xc6D\x05\xeb\xf4\xf0\xb2\x82U\x9e\xa4{NV\x861ﵽ\xa8\x93\x94\xb9 }\r⋸\xbf\x91|C.y\x8e춧c\xa9+r\xe0\xd4\xca\x05x\xaf\xb0$\xe4bk\xe6ޥ\u007f\xd1/\xcde\x1c\xe93\r\xbf\x15 \x9d\x90\x99E\xd8\xfc\xb08\x8d\xc3>\x17\x9b\xf5e-7r\xc6ز\x87P\x8bÌ;j\x1d\xe4r\xa8\x9d\xa5U0\xb6\x16*~\a\xdai+A\x0e\u007f\x88\xdfE\x03X\x02\x16,\xc7ɾ\xdd\xcbm\\:\xd9y\x9cvK\x8fs\xcd\xf8\xad\xac5\xd8`\xb0\x91\x84α\x82\xd5؛\x893m\xe5uG\x91\x0e\xdcSs\x91\xf2F\xb9Q\x95Q$SH}[\xfdv`+\xa4\x1dEJ\x1fV\xc4Vg`\x9c\xb1\xc5a\xb2\xa9IƯ\xa6\f\x1a\xbfR\x19\f\x9c\x01Q\xc5<\x05\xe3+:\x05A\xe8\xae\x14\xf0\x95['\x0e\x1f}\xe1\xfa`/\xd9zu\x922\x17p\xaf\xa2\xa3\xa3\x86\xc6\xc1>\xab]3w\x16G\x83\xddv\"7$N\xd3'N\xb3(\v\xb9\xd8\n\xe7\x0e\xe2B\bYtr\xc22\xfb0\xb7\x14Y\xc1\x1aq6\x1e\xed|\x9e\xec\xa2øZ\x8e\x9e\xbd:\xce\x18[\xf6\x10Jq\x10s\xce_ʜ\xfbR\xfd9a\x10iaj\xa1\xd2\xcb\xf5\xe7\x15\xad\xec'\xdd\x14\x8d\xdfWɛRq\xd0@\xeb\x1arո\x16ѿ\x16Q\x15U\x87a\x05\xe5e\x92|h+\xaf\xab`jy\xa3ۨ\x8a\x821\x854\xb0\xd5m\a\xb6B\xba\n\x16\xb1\xd5\x19\x18glq\x98lj\x92\xf1\xab)\x83\x9e\x82\x198\x03\xa2\x8ay\nv\xd1-\x13@M\xe2\xac02\xac4\xe2\n=\aB\x93\nL\x1c\xacÑ\xb5\xf3\x90?O\xbc\xd8ȹDN\x9c\xb3\x9c\x1f\xa1\xe1A\xe7%R\u05cd~\xc5/\x1b\x16\x1f\x11\x91\x15\xec8\xea\xb0!I\xc1\xe8.?G\xef\xa1\xeb8cl\xd9C(\xc5A\xec9\xdfW_\xb8\b\x0f9\x91\x06\xb6\x16*\x82\xfdBڹ\xb4\v6A\xc7/-N\a\x1d\x9a\t+\vp\a\xa9\x80f)XN&\x90\r(.\n\x1c3\x16\x89\x87\xd6V\xde0\x92O\xcb\x1b\xe5FU\x14\x8c)\xa4\xbe\xad~;\xb0\x15\xd2U\xb0ȭ\xae\xc28c\x8b\xc3dS\x93\x8c_M\x19\xf4\x14\xcc\xc0\x19\x10U\xccS0!Hh\xf7\x04\x83\x02\xeat\x93\xa1\x03\xef\x0es/r+ף\x93T`\x14l\xd1r2\xee(\xd4^l\x9fq\xb5\xe4\xefРs\xd1ܳ\x14\x12\xd66\xbc\x9f\xc4(\x98]V0z'\xa1\x9e\xa3#\x1e\x1dg\x8c-{\x88a\xd7R}/\xd6\x01ҟ\xebk\xb4\xd7j\x0e\xcaւa\xc1[\x99(\xabf\x01\n\xf1K\x83\xe2\xa48\x99/Q\xb32l\xe1\x9aK\x93s]\xa4]\x98>\x98\xe3B\xef,\x1a?\x1a^yR\x1c\x16\xb5\xbcQnT\xb5\x0f\xa6\x16R\xdfV\xbf\x1dZ#\xf5\xc1\"\xb6:\x03\xe3\x8c-\x8e\xae\x821~[\x87\xf5\xc1d\xbfr\x1fL\xdf\x19\x10U\xccS0\x91\x804\x1f\x8c\f#}a\xe6\x83E肱\n\x96EN&a\x89\xf6bC˳\xf0\x10\xab\xc7\x1er\xb1\x1d\x17\x835e\xb4\x03t'\n\xe6\xc0\xd7\x15?\x97N\xbe\xd2s\xc6ز\x87`\xcf\xe3<\x9c\xf9\ny\xaf\x9c\x16\x1d\xe5ic{l-\x18֬|\x0e\x15\xae\\\x8dB\xfcf\x91\x88\xcc\"\xec\xd1A\xaa\x89\x04R\x95fj\xd0H\x06\x94\xfd\x99y\x838\xbd\x95\xe8.\x99M\xd1l\xeb\b\xf1\xa0\x16\x87E-o\x94\x1bUQ0\xa6\x90\xfa\xb6\xfa\xed\xc0VHW\xc1\"\xb6\xba\xbe3\xb68\xba\n\xc6\xf8ՔA\xe3W*\x83\x813\x84zw\x8f\xfc\xc7\v@\x04\xccU0!\xd0\xee\t\\CtN\xfeŰs\xf2K\xd4~W\x89N\x17\x8c\x9d\x93_\xce\x15\xd6\xee^\xc69\xde\xea\xb8ⷹ:\xd0Y\x97\xcd\u007f\x05]H\xcb*/K\xe7l\xef^\x10gq\xd7\xf8\xfd\xbd8\xe3N\xee\xf9\xc6Cd\x02\xa8\xd0A\xef'\xf5\x868\x1e\xfc\xc0ﷻ\xfc~\x1e]H\xaf\xe9o\xb4\x9d\xeb\u007f>\xef\x12\xa27\xff\xea\x17\xa4\xf7 }g\x1a[e/[\x1cr:\xd7\x1c\xcaK\xbbD\x14,\xad\xac\x19\x1b\xb4j\x0e\xac\xd6B\xb3{+\xb7\x1b\xbd\xc5ыF\xf1K\x8a\xb3\xa6\xa3u%)\x8e\x83\xcb,;\x8e\xfd\x92&*\xe2v6\xef\xe4\xc4{\x91\xf6E\xb5\xcd[\xb9z2'\xdf\xf5\xc1`\u007fAf\xebu\x8d\a\xb58*ly\xa3ڨ\xe2\xbd\xc8\x0e\xfa}\xa5\x14\xd2\xc0֠\x1d\x94\n\xb1\aV?\xacȭ\xae\xefL-\x0e\x93M\xe3\x81i3&\x9b\xea\x97-\x83\x9e3b\\\xc0\xfd\b\x01Q\xc2\\\x05\v\x900X\x15M\x1d\xa8\xf0\x86\xf9]\xe4\xf5\xb4\"\x9d\xa4\n\xfb\xbbH\xa1f\x81\xddQX\xbf\xc0\x96\xf7\"\xfe\xdbv\x81L\xd0\xc1\xfd\x9b\x9e\x82\xf4\xb9%\xef\xdap\xd2%\xc52\xe87\xfe\xf1<G\xfa\xcaf2\t\x94R\x10\xe2\xf8\xacd[/88\xaeq\x06\x97\xd6Hc \xf6\x12\u05ec\xcc\"r:\xea9\xd3\xda*\x87\xd0\x14\a\rlM\xb7\xe7\x91˲qey\x96-3O+`L-4\xbb\x9b\xd3\xcea\xdd\x10;0\xb2_<\xd4*/\x9c!\x16gy}٢4\x878SM\xa8Y\x92\xb6\xa4V\xec\xd7\xf6\x14f\xcdX~\x88\xfe.\x92\xe3\xce\xe2\x82qe\x1a\x0fjqT\xd8\xf2F\xb3Q\afѽ6m!\r>\x00\x83vP*\xc4\x1eX\xf9\xb0\x88A\x84V\xd7w\xa6\x16\x87ɦ\xf5\xc0\xb4\x99\x9aM\xf5˖A\xcf\x191\xaew\x84\xfb\xf5.pG\x98\xab`#\xe6U\xeec\x9d\xa4yH\xe3\x04\x00\x00\xcc%F\x14l\xa2=V\a\x14\f\x00&\x041\xa2`\x13\rP0\x00\x98\x10\x80\x82\xdd\x05b`V\xe6\xcdo=\xc4\xf2\xad7\xc3\xe4\x04\x00 \xaa\x80\x82\xdd\x0540\xdb+\xa6\xff\xa8\xd5/\xaaa\u007f\f\x9b\x1b\x00\x80\xa8\x01\n6J\x86\v\x18\x96\xb0H\x99\x00\x00\x88\x0e\xa0`\xa3\xe3M\x1d\x01{\xe8!\x18H\x02\xc0\xf8\x00\n6:\xf4\xba`\xd0\t\x03\x80\xf1\x02\x14lt\xe8\n\xd8C\x0fE\xca\x06\x00@T\x00\x05\x1b\x1d\xa0`\x00`&\xa0`\xa3\x03\x14\f\x00\xcc\x04\x14lt\x80\x82\x01\x80\x99\x80\x82\x8d\x0eP0\x000\x13P\xb0\xd1qo)\x98wf0\x92ɸsm\xa67\x92\tp\x1fc\xb2\x82\xb5\xbb\x95\xd3\xd3\x17~\xb1\xc8\x11\xe3\xb1Z\xadŨ\x18o+\xc2X]\x8c\xb7N\xc3/\xb9\xd8,\xb1+\x8c]$\"+X\xbe5\xae\xda0{\b\xbb\xacqU\x91ldƠ\x9e۰\xc3\xc848\x9dG\xc2\x1a\x1ct:\x9d{\xd1^\xbc=\x18\xc6\xea\xd3l\xe7*\xfc\xf2\n6\x9b\xffi\x18;\xb4-n[\xb8\xb7\x81\xfb\x1bs\x15\x8c\xaf8&/O\x14t\x9f\fk:bx\x8fu[\x10\x05\xb7Y=\xc3W\x1dbh\xc9M\xc0\xdbn\x9fo\x97\xb5%\x9c]\x04\"+X\xc0\x17?\x12]\xa0\xf0G\xa7\xeb\xdb\xfaN\x0f\xdb\x15\xfdz\xee\x8a\xf3D\xb0\xa0\xdch[\xbfW\xf7\x8d\xb6\xf3\x92\xc1A\xe7\xde\xcf\xd1\xe7\xef8\x0f\xdeе\x13\xb9\xfd\xf3W\xb2\xf1\xcb\xef\xdb\xda\x1a\x9c?\x0fc\x87{\x86\x8f\x96\x86}\x1f\xb8\x9f1W\xc1\xbcMݒ\x82\x05\xaa\xa3\xa5`\xa8\xddz\x00o}\xd6\xf6\xf0f\xc5\t\xe2kK\xc4+;\x1c\x91\x15\f\xa1\x84\x11+\x18B\xf3\xf4m\xa7/\x1e\xbe/\xda\xf5\xbc\x18\xbf!\xbc\x81\xc2f}\x05[\xbfEJ|\xe4<\x85\xb7mΏt\xcd\x14\xf6f\x8b\xaf\xe7#(\x18ڔ\x10\xe6\xe9\xbd\xc0\xfd\x8d\xa9\n\xd6\xee\xe1\xc5\xe7\xe4#\x9f\xdbW\x11\xc3\n\xf6\xbf\u007f\xf7_\xff\xf5\xeb\u007f\xfc_x\xfb\xbb\xa7\xc6D\xc1R\xc7A\xc1r\x93\xc3v\xe6\x18\f\x14l\xed\x16)\x11m\x05\xe3\x93s\xc3\x1b\x00\xf7/f*\x18_\xd1%\xad\xf4\x81\xfayy\xd5[]\xaa\x95\x98O5\xe2\x17'ǧ\xcc;\x83\xf7\x9ey\xd4j\xddԵtj\xe2\x9cA֘\xb9\xb2U\xdb|k\xbc{ݴ\xc4\xd9\xf4\xcb<\xb04y\xca\xc2\xdcaWv\xe5\xcc\xc4i\xebx#\xbfݓ\xad\"\x93\xd9\x0e\x81\xa8`o\x92\xb6x\xea_\xc9\xf6_e\x05\x93\xbda\x05\xcb\xcfM\x9e2\x8fF\xa1\x8e\xceN\x89O\x9a\x93B\xb3\xeeJML\xdd%z\xe9Z\x98\x14\x9f<\x87<e\x1b+X>>\xc6cAƃW:p*\xd2\x10\xe5z\x0eL\x96\xbb`m\x9bWd?\xb3y\xc5m\x9c\xbcݰ~\xfeچ\xdbt\xf7\xa7[\x9e\xc9\xce\xd9\xfc{D\x15\xecu\xa7ә\x8d\a\x89\xb7\x0f\xae\x9f\xbf\xea\x8d[\b\x9dp\x8a\xacG\x1a\x05\xbb\xb1%'{\xc5f\"e\xaf8\xb3\x0f\xbe\xb1j>u\x80~\xbf=\xe7\xe9-\xaf\x84*\x98\xe2\xec\xa3l\xa7sϧ\xdbWdo\xfe\x82\xbe\xb1)\xb1\x1f\x01\x80\x1ef*\x18Y\x1e2\xa0,\xd3\x1dN\xc1\xf8\xa3\x937\x05QpӔ\xa3<\xbe\x9es}\xd5\xf3\xe2\xf0\xe5\xd8_]\x95\xf2\xe4\xe4\x94uK\xad\x9aAF\xbb\xd5\xdb\xdf\u07ff\x9f\\٪mgգ֤\xe2\xd2\xc9\v\xb1A\xd7\xe4i\x1e\xeflk蕝\x1b\x97\xef-MJ\x15\f\xfc\x0exJE<\xecR\x85\xa2\x82=\xfc\xe6\xd0\u007f\xfc\xe3C\x0f\u007f\xeb\xd7C\xff\xf6\xb0\xa4`\x8a7\xac`\xd6Ԫ\xaa\xd4D\\\x9e\x93֥\xd5M\xee$+Q\x8c܄M\xdeM\tK\x89\x13_b궦b+\x89\xf6`\x05\v,\x8d+ma\xcb\xc3\x1f\xf3=\x99\xe1\xf3\x85\xde\xea\x88r=O[}\xe2\xfb\xbf\xfc\xfe\xf6#\xa7\x0e>\xe3$\xe2\xb1#{ϩ=\xd9\xdb\xc9\xee\xb6\xf9\xeb\xdf9\xb5\xd7ـ\xa8\x82\xfd~\xbb\xb3\x81\x84\xbdv8_?Ր\xb3\xf66\xba\xd1ֶjc[[\xdbo\x10U\xb0[\xb7n\x9d\"\nv¹\xa3\xed\xc8f'6\xfd\xe8H\xb63g\xef;\xf3\xb7`\x83O\xe7\xaf:xb\xb33T\xc1\x14g\xb7\x8e\x1cY\xb1j~\xce\x1bۿ\u007f\x95\xbeq,R\xff\x11\xb8o1Q\xc1:I\bzd\n\x86/;2\x8cZL\x06\x13|5\xe9ؤ.\xa4\xbbS\xad\xb3\xf9\xd0u\xeaۥ.K\xbb\xd66a\n\xbeN\x97&\xe1T\xc6T\xbcWH\r\xb9\xb2\xbdV\x0f\xfd\xab\xca\xc8o\xf0\xa2\x88f\u0081\x14\xf7zj\xe8\xd7\x0f}\xeb[\x0f\xfdߡ\u007f\x94\xe2`\xac\xb7\x84i\xb8\a\xd1?u&\xeev%\x11\xed\xda5\x05\xeb\xda\x01ڃ:`ݏ\xdfJ\x99\x83Eq\xa0\x9a,ڄ\x15l[\x82wxytG\x91Q\xad\xa7\xd7zQ4l\xc8!\xda\xd5\xf04\xeey\x9d\xa2\x9d)\xba\xbd\xb5b3\xee\x1c\xdd>B\x82\xf3X\xc1\x1a\xb2O\x10\xdb\x13\xf4v\xe3y\xf1\xe6$3\x8a\x14\xc1\nv\x8bd\xb8-\xbe\x93\xfd4\xee\u007fm\xcf\xc1\xa9\x8d\xab\x88\xaf\xb5!\n\xa6u\xe6\xdcx\x03ݖn\x05t[G|;\x17\xb8\xcf0O\xc1\xf8\x8aNA\x10\xba+\x05i\x91\xc8\xf0\n\xe6K\xe4\x11\x9fH{\t\xc1]s\xa6N\x96\x86T\xa9:1\xdevkiKKK)\x8d\x0f1\xb6\tD\xfeHP\x88\xb7\xba\xc9ߛB\xae\xec\xc5S\a\x061)\xb9\x06~/Ze\x86\x8f\"\x1f\xfa\xfb\xa1??\xf5硧\x86\xfe\xfc\xb0\xa4`\xac\xb7\x04:<s[\xaf\xa1\xee\xe4\xa9\xf9\xee3\x02\xe9\xc4\xe5N\xa3\xf9\xa7a\x83\xfd\xd63\x8a\xbfyś\xac\xe2\x04\x13myt\x15,\xaa\xf5\xac\x93\x15\xecjΊ\xd7\x0f\xfe\xea6\x19:\xeeXK\xf7\xacz\x85\xc8دdK\xac`?qR\x01C\xdbW\xdc\xfe\x02\x93\xb3\x83\xfc\xc1(\xd8;\xe7ϟo\xa0q\xb0\x1b\r\x9bW\xccwR?\xd9Ċ\x04\xbfn\x88\xd3,\xf6\x84(\x98\xd6Y\xf6U\xa4\xd0m\x1d\xf1$\x13\xe0>\xc3<\x05\xbb\xe8\x96\x11WY\v\xaf`\x83Iu\xa8.\x89\x88]Krʆ:_\x86\xa4`Ӈ\x9b2\xf1!֖\xc6\xd3ɕ}R\x1c.\x85F\xb8S%}Zh\xe4\xd7\xe7\x15\xf1\xb1;%\x05{过\xfech\xe8\xd7C\xbf\x93\xfe\xd4x\x13#\xf9>\xebi\xb2,\xf9\xe2i\xd6$2\xbfi\xe6<\x9a\u007f\x0e>P\xa9U\x8d\xf2\xccK\x9e<M\xee^\xb2\xe5\t\x1fɏF=\xd58ٍ\x83[V9\x9fy\aK\xd8\xc6\xcdt\xc7\xe6\xf5d\x16\xd8-\xc5ts\xce\xfcU[hpl\xad\xd4ۢvz\x91\xfc\xf39+\xf6\x9ch\xdb(*\x18\xb9\x01@\x14켳\r\xa1\xe1\x91|\xad\xb3\xf5H\xa5\xc5z\f\x01\x80\x1e\xe6)\x98\x10$\xb4{\x82A\xb1\x13\x16^\xc1P\xfeB\xb40\x9f$\xa6\xcd$\x83\x9e\x85\x92\x82-\x1cn\xc9\\٬\xadre_\xb3\xd2\xf8yh\x84{\xe9\xd4Ӕ\xa0\x91_]d\x05\xfb\x0f\xb1=\xfe]V0\xd6[\xc2:bYa\xe5\xd1I\xd2\x1b\xe3\xab\x12q\x01r\xa7\xd2\xfcSqW\xa8ɪ\xce\xf6\x9a\x97\xd4~q2\x9d\xfe\xa4-\x0fQ\xb0\x90\x15\x81\xa3\\O^\xbeez~\x0f\x16\xa7\x1bG\xb2\x1bp\x1fL\f\xe7\xaf\xd8A\xfa`\xe7\x15\xd3\xcd9\x1f}:\x9f\x04\xc4p\xb7\xe9<\x85\x8e\xf6\xa8\x82\x1d\xbc\xaaQ\xb0U\xeb\x89\xf0m\xd1*\xd8\x1fi4\r\xed\x18\xd6\a\vu&S\x1c?\xd2ۤ\xc0\xfd\x86y\n&2\xd28\x18jI\b$\xd0K0\x85\\tB\xaa\xa4`\xe1\xfb&\xac\xadre\xa3\xe9)\xd7\x10\xeaz,\xe4\xca> \xc6Z6\xd1\t\xe0z~u\x91\x15\xec͡\xa1?\xffyh\xe8\xdfd\x05c\xbd%\xa4\x900״\f|xZ4\x94\x91O\xc2Nd`TE\x86\x8c|r\x06\x19W\xe6\x13\xa1#\xb3)\xf6Ǔ\x12iʓ\x813\a\xa5`P\xf76q\xb8\x17\xedz.\x9e*~\x95\xec\xa5\xfa\x836ҡ#\x89I\x1d!;n\xe4l$j\xf6\xfa\x1bH\x9cMq*\x9b(\x9ah\x80\xf6\xd0\xe9\x15\x1b7\"\xf49\xd9\xc1(؊-\x88D\xbc\xb4\n\x86֯\xc0*\xf5\x9b\xec\x10\x05\xd38c\x15L\x986\a\x01\x80.\xe6*\x98\x10h\xf7\x04H\x00\xbb?\x10\xf0\xf8\x02\xe1~\x94'$\xcfN\xa6WX\xb1u\xf1\xaem\xa9x(\xd62\xd8B\xef\xd1]\xd4\x1a\xb2s\xd5Uۀ/>\xb7\x05\x9d\u038d\xf7\x05P{bJ\xf1\xa6)q\x8fz:Ź\xea\xa5>\x1f\xe9\xddl\xb0.\xae\xf6\xe6Z+\x91\xbe_}d\x05\xfbס\xa1\xff\xf3\xefCCO\xc9\n\xa6z#\xf7\"\xe7\xb44͜r\x91\x94=\xb1\xd8[\x97K\x87wK\xe36x7ĉ\xf7\"\x1f\x9b\xe6ޟo\xad s\xf2s[\x06\xf89ɾ\xa0\xc6\x03V\xa4Һىb\x1fl\x9e\x95^\xcfQ\xafgW\x9c8\xf5}\xafs\xfe\xde\x13'vБ\xdev\xe7\x9e\x13{\x9c\xe2\xbd\xc8\xecU\r\xa7^w\x1e$s\xf2_\xf9\xf9\xed\x1b\x9bs\xda>\xc7r\xf3\xfd\xedG\xb0-\x95\x9e\xbd\xd9\r'6ο\xaa\x99\x93\xbf\u05f9\xa5a\xefZ<&\xfd\xf9նl\x9c헯d\xb7]E\x1f\xcd\xcfٻ\xe7ig\xf6\xc1\x8f\xd0U2'\xbf\xa1\xad\x8dD\xbd\x14g_\xfc\x82\xdeؔ\u007flT\xcatR\x01@\x83\xb9\n\x16 a0\xd2\x179)F\xc4\u008d\x15J\x13\xc4\vL(}2!i\xb1gj|ƙ8\x1a\xd0\t\xf9~V\u007f/\xe8fl\xc9$\xab\xf8\xf6D\xbc\xc5\xfd\x9f\xaeyS\xa6\xae\xf3<\x8a\x93\xb9RP\x88vE\x0ed$M\xc9؏\x90\xbe_}d\x05\xfb\xfb\xff\xfa吏\xfa\xef\xdf=\xac(\x98\xe2\r\x8f\xf1\x8a\x17ON^J\xa2}\x95\x19\xc5)\xf1\xc9\x194>%\xd0\xf9`b\xb7\xa7kq\xca\xe4\xe9u\xe4w\x91Vk\xdc\xc9*\xbcݤ\xf1\x80\x06\xf2\xa7$fHq*O\x12\x8d\xd0G\xbf\x9e\x9b\x1e\xa3Ѧ\x83\x1b\xf7\xae\xc8\xce\xd9HCU\xb7\x1b\xd6*\xf3\xc1~\xb3%g\xfe\xfa\x13\xf4w\x91N\xe7/\x8f\xe0\xcdO\xf0\xdeS\x1b\x9fyz#\xed\xb4\xa1[\xaf?\x9d\xbd\xf1\xbc\xf6w\x91\xb7\x1bVe\xe7l?\xb8*{#\xf9\x01d\xf6\xaf\xe6\xe3-\xee\xdc}\xba\xf9\xe9\x15{\x0ef\xe3\xe4\x0e)\xf8\xb5\x051\xce>b\x02b\b\x1dM\\\x87\x00@\x1fs\x15,\xf6yH\x9fH\xd9&&\xeb\xe2'⤅\xaa\xf8\\͌e\x00`\x00\x05\x1b\x1d\xf7\x94\x82\xa1Ҕ\t\xf8t\x9ddx4\x05`\f(\xd8\xe8\x10\x05\x8bi\x91\x98V0\x00\x885@\xc1F\a(\x18\x00\x98\t(\xd8\xe8\x18>\x80\xfc\xeaà`\x000^\x80\x82\x8d\x8ea+\xde>\xfc7\xff\xe3aX\xf1\x16\x00\xc6\tP\xb0\xd1\xf1o\x0f\x85\xf0\xb0\x05K؛\x91\xb2\x01\x00\x10\x15@\xc1FIh'\xec\xab\x16\xcb\xdf\xfcO\xf8\r\f\x00\x8c\x0f\xa0`\xa3\xe4\x8f!\x12\xf6UK\xee_O\xe9\x04\t\x03\x80q\x01\x14lԼ\xa9Ѱ\xafZ\xeaNZ\x92;ᙢ\x000\x1e\x80\x82E\x19\xdeR=t\xcc2\xb5\v$\f\x00\xc6\x01P\xb0(C\x14l\xe8\x80e\xdaE\xf6Y\xd4\x00\x00\x8c\r\xa0`Q\x86\xb7T\xfdeh\xa8\xce2\x1d$\f\x00\xc6\x1eP\xb0(\xc3[*\xb1\x82\rUZ2\xbaA\xc2\x00`\xac1Y\xc1\xda\xdd\xe2C\xe1y_u\x85\xf7̽\xf0\b\x02\xde\xe2\xf9\x92H\xd8.\xcbl\x900\x00\x18k\xccU0\xbe\xe2\x18}\x80\x1f\xef\xf1\xb6w\x9f\xf4\xd4\xdd\x03\x12&+\xd8\xd06\xcbB\x900\x00\x18c\xccU0oS7U\xb0\xa6j\xf2\xa4\xbfkQ[\xb6\xdbDxKŗ\xa2\x84m\xb2,\x05\t\x03\x80\xb1\xc5T\x05k\xf7\xf0\xe2s\xf2\xeb\xc4'\xeb\xf9\xbca\xcdc\x02\xde\xe2\xfe\x93\xa8`C\xeb,\xf9\x01\x900\x00\x18K\xccT0\xbe\xa2KZ\xe9# >\x01\xfe\xd8D|D\xe8\x1d\xc2[v\xfd\xe9\xcb/\xc5\xd6ɵ\xac\x03\t\x03\x80\xb1\xc4L\x05\xf36\xb1k\x15!$Ti\x96b\x8cM\xb0\x82\xfd?\xb9\x136\xb4в!x\x0f\xc4\xf6\x00`\xc2b\xa2\x82uzx\xad\x82\x1d\xf3\\3\xb6\x8e\x15xK\xa9@:a\u007f9v\xf4\xe8Q\xdfc\x96b\x900\x00\x18;\xccS0\xbe\xa2S\x10\x84\xeeJA\x90v\xb4\xb8\xb5+\xba\xc6&X\xc1\x06i',\xc5\"R\xca\v\b\x00\x80\xb1\xc1<\x05\xbb\xe8\x96!됡A\x9f\xbb3R\x96X\x00+X?\xfaSŗCM\x969\x9b\xb6m+u7\x05A\xc1\x00`\xac0O\xc1\x84 \xa1\xdd\x13\xa4W8\xef\xad\fD\xca\x11\x13\xf0\x96m\xfc`\xb1e\xdb_\x86\xe2\xa7\xec\xef\xbcx\xb1;8`\xb9\xe7\x88\xd4\b\x000^\x98\xa7`\"R\x1c\xecZU\x1d\x8fE\xed\x1ex\xa0\x03Q\xb0u\x96I\u007f\xfb\xe5P\x95eW`\x00\x0f\x94\x91\xe5\xe6=\x06(\x180a0W\xc1\x84@\xbb'p\r\xa1\ue2aa\xee@ po̦ؖk\x99\xb6\xc1\xb2\xeb/\u007f\xf9\xdb'\xdb\xe9\\\nP0\x00\x18+\xccU\xb0\x00\t\x83U!\xb4_\x8a\x88\xdd\x133Z\x13-\xa9\x9e\x96i\xd6/\x87\xb6Y\xaa\xe9\b\x19\x14\f\x00\xc6\ns\x15\xec\x1e\x84\xb7X\xa6W\xb6_k\xb2x\xfe\xf2\xa5e\xe1E2\x95\x02\x14\f\x00\xc6\nP\xb0(\xc3[\xe6Uw\xf2\x02?\xcd\xfa'ޒ\xd1I\x86\x91a\x14L\xef\xad\b\x82\x17E=\x8c\xecJ\xdf\x02\x14\f\x980\x80\x82E\x19~\xd3Q,`h\xe0\xc0\x03\x93,_)\xee\xba\xd7\x14\x8c\xee\x00\x05\x03&\f\xa0`Qf\xe0Z\xb0_\x9c\x1e2}v\xe9\xb1k\x11\xe2`\xa0`\x000*@\xc1\xa2\x8d\xf4\x1b\x03\x81\xbf\xd8\xdeu\x8d\xfe\xa2\xc8\"+\x01I\xbc\xf6\xb8e\xd2w?\xc1\u007f\xbc\xfc\xc8_?\xf2\x02\xd9\xff\xe3\xaf[\x1e\xf9\xe1\x1fH\xe2q˃/S\xab\xf7\xbf3\xe9\x81\xef`#˳\x0fZ\x18\x03%\xcbMƑb\xfb\xc2#\x96\xaf\xff\xf4\xe5G,O\xfc\x8cu*\xf1\xb3Ix\xf3]\xfc\u007f҇\xea\x9b8\xcb_?\x82\x8fH|X\x1e\u007f\r'Ȏ\x17nj\xcar\xf3\xa7_yA\xc9Bg\x83\x81\x82\x01\x13\aP\xb0\xb1B\x18\x18\x18\x10\xc5L\xa3`_\xdbw\xf9\xc3\xefb)y\xfb\xc1}\x97\xf7\x11}\xfa\xe9\xdf\xfd\xf4\xf2\xfb\xdf\xfc!\xde\xf3\x95\xb7/\xbf\xffO\xd4\xea\xef\xf6]\xfe\xed?\u007f\x0f'\x9f\xf8\x905\x90\xb3P_\xb2#\xd5\xf6\xfd\xcb\xff\xf2\x00\xd9|\x93ɣ\xf4\xa2\xbe\xf6\xde͟Y>\xbc\xf9\xdeט7-\xd4\xe1\xdb7o>\xfe\xec'\u007f\xf8鷱N=\xb8\xef\xb7\xfb\x1e\xfc\xb1\xa6,x\x1f\x9b\x85\x1e;B\xd5\x01`\xdc\x00\x05\x1b{4\n\xf6\x1e~\xfdO\xdc!z\xe2Ǥ\xa7\x83\xf7\xfc\x03\xd9\xf3\xe1#7o~㵛\xb2\x15\xe1\xb7\x0fJ֊\x81\x92\x85ZɎ\x14\xdb\xf7o\xde\xfc\x84n\x1e`\xf2(\n\xf6\xcf\xcf\xde|\xd6\xf2\xf2\xcd\x1f\xfe3\xf3\xa6\x85:|\xe2\xe6\xcd\a>\x14\x8d\xbeAw|\x83-\xcb\v_\u007f\x9f-\x03(\x180\xb1\x00\x05\x1b{4\n&'&\x91\x91\xe4'$!\xfeP\a\xef\xfcDV\x8d\x9b\x1f~{\x92\xb8\x8b\x8c\x03\x15\x03%\x8bd\x15b\xab\xece\x9d*\xbc\xfd͛O|\xef\xdb7\xbf\xf1v\xe8\x11?\xc1*\xf8/\x93\xbe\xf72\x11\xb1I\xf2\x0e\xa5,?\xfc\xc6oo\xb2e\x00\x05\x03&\x16\xa0`cOx\x05\xb3H\xfd\x1fq\x8f\xf8\xe6\x13\xff\xf2\xe1\x1f\xfe\xa0\xe8\x85\xc6`\x98\x82im\xe5\xc3\xc8y\x14.O\xfa\xf0\x81\x0f'}h\xb9̼\xa9(\xd8\xcd\xf7\x9e\xfdΤg\x19\x05Sʲo\xd2\xdb\xf4U\xc9B7\x91j\f\x00\xe3\x05(\xd8\xd8C\xf4\xea?\x89L\xb0\n\xa6\f\t\xbf\xf1\x82$\x0eO\xbc\xa6\x88\xc4\x03Xg\xf6\xc9֪\x81f\x14\xa9k+o\x94<*\xff\xf0\xbd\u007f\xa0\xff\x997\x95Q$\xe1g\x0f0\xa3H\xb5,\xef}\xe55M\x16\xba\x89Tc\x00\x18/@\xc1\xc6\x1e|\xd5\u007f\xf7\xbb\x1f^\xde\xf75V\xc1\x94\xb0\xfc\xbeI/\u007fry\xdf7q\xe2A%z\xfe\xf8\xb3\x97\xdfS\xac\x15\x03m$_\xdejl卒G\xb2\xc3<ky\x96\xfeg\xdeT\"\xf9\xdf|\xfb\xf2\xe5\x17\x1e\xa7Q\xfb\xcb4\x92ϔ\xe5\xfd\a_`\xb2<\xf26(\x180\x91\x00\x05\x1b{\xb0\f|\xf2O\x93,_\u007f\x8dU\xb0\x9b/?(M\x8d\xd8\xf7\xc4\x03\x96'\xf6\xe1\xc4k_\x97g0\xbc\xf7\xb8\xe5\xc1\x17\x14k\xc5@\xc9\xc2*\x98\xc6V\xd9(y\x14\x05{\xcf\xf2\xfe\xcd\xf7i\xfc_y\x93L\xc0\xa0\xb3)\xde~\xc22\xe9\xdbd\x12\x06\xd9A\xbb[jYn\xfe\xec\x91g\xd5,\xaf=\x02\xb3)\x80\x89\x04(\xd8أ\x88Ƚ\x02(\x180a\x88-\x05s\xb9\xf4\x92\x13\x1dP0\x00\x18+LV\xb0v\xe9\x81:\x81\x03U\x15\xd5\xc7\xf8\b\xd6\x1fs;u\x92\x84fN\xc2\x11f]\x8d\xe3\x8e\xc3\xc6oF\a\xf6\x10\xbd6n\x11M\x80\x82iy\x91\xe3\x1a\x99?\xc7\xe1c\x91\b9\xf0]0z\x0f\x91q\xe1\xd38\xad'\xbc\xcd\xf8\xb5ل\xc7\\\x05\xe3+\x8e\xd1g\xb4\x06\xdd\xde\xce\xeeκ\xaa\b\x12Vd\xbf\xa2\x93$\xf4\u007f`s\xf91;\xb9\xebó\xc94\xa7\x8d\xf9٧9D\x87\xcbN_A\xc1\xb4\\\xf1\xdbʙ?\xc7\xe1c\x91\b9\xf0\x1d\xd0zV|\xbd{\x0f\f\xb23\x03.\xf9\xfd\xb5\xdc\aaMƱ\xcd&<\xe6*\x98\xb7\xa9\x9b*X\x17]\xa6\x88\x8f\xb0\xd6G\x0fW\xa2\x93\x94\xb0\xd33\xab\x91\xfb\f\x193\x0eKnh\x0eQ\x0e\n\xa6\x8f]#\x03\xe3\xf0\xb1\xc8\xd8\xefR\u007f~P(\xa7\xee\xd6\x03\x83\xeä\x8eH\n6\x9em6\xc11U\xc1\xda=\xbc\xf4\x9c|\xda\xf9\n\xba\xc3/\xf6\xe1R\xfb].m\x17\f\xc9gVO\xa8\xb0\x99\x8a\xac`\xf7\x1c\x11\xea\x1d\x91(\xc8\xc0\xddq\xb7\a^\x16M\x05[\x16\x05\x05\x03d\xccT0\xbe\xa2\x8bY\U00076ffb\xda\x1b\xf6\x9b\xa5\u05f6U')\xa3\x9cY/q\xb6\xfa\x92\x05i\xab/\x91\x1e\x19Ǖ\xa3r\x8e\x04/\xfa\xd28)\x86q\xce\xc6qe=Es\xedk\xc8\xe1j\x97\xa5-\xa9\xd5fc\xc0{k\\Y\xe9\x05=F\xd9\xf4\x0f\x81\x87\x1bE\x99\xe9\x85\xd2(\xb2qeڂ\x12\xba\x88\x89\u007fu\x96\xcd\xf1\xa3,\xcd!\x10_\x98i\xcb*8\x87\x8c\xca\xc0x\x18u\xdd\x04\x87\xedլ\xcc֭\xb3\xf2x\x03\xbf\x87\xa5\x80\xe22M\x01\xca\xe8\x01\xc81\xcbpS\x97\xa8\x85\xd4\xf1\xc0\xa2\xd6M\x83}\xab+\x936*Stփ\x9a\x8d\xa9\x10\x89u\xbe*\xd5\xd8\x00\xa5}_\"FJ \xb2\xa7Ёw\x93\xef<\xb6\xe8\nl!\xf5>!M\x93\xe8U^\xc3gE\x8e\xac\x92\x12\a\x1d\xe6\xc9\x1f\x80\x913ր\xb5\r\xaf`\xecy\xa6{F\xddW\x98\xa9`\xde&u\xcd\xee\xa0\xdb\xed\xf6\x84\x0f\x83\xb9l\x97t\x922\xf6\xb2\x81\x81B\xd2\x03\xfb\xb8\xd1\xc69\xcakf\xe0/\xba~\xff\xac\xb2\xeb\xe8z\xd9,?>\xcd\xce\xfa\xfd\xa2\xca\r46f-\x98\x91UR\xc4\xf5\x92\xce\\Ys\x99\xbdH\x93\x8d\x81\xec\xcd\xda]\x9e\x95v\xc1 \x9b\xfe!PϬ\x05\xf5\x87WsT\xc1\\\xdc\xd6\xe6\x1a\xc72,)g\xb9\xa2\xc6\xe3\xf5\x0eN+\xd4͜\xab\xb5\xb1\x80\xeb0*\x03\xe3a\xf4uk\x9dŕ\xe4q\x8eݎ\x1a\x03\xbf\xfc\a\xfe\x05y~\xbf_\x1bJ\xbe\xfe\xfcJ?\x8f\xdf[\xf9\xfcu\xdc\xd4ܢ\xc6ÎB\xa3\x92\xb1\xa8u\xd3`\xe7\x9656.\xc1\x8d\xca\x14\x9d\xf5\xa0fc*\xd4\xffA\u058bW\xe4\x1a뢶\xaf\x18\xaf\x92\x02\x91\xadi\xcb\xde:^\xce\xd5 M\xd1U\x98B\xea~B\x9a&ѫ<\xcb\xe0\xa2\xcc\xda2{Z\xfd\xea\x1a\xe6\x030r\xc6\x18hl#\xf4\xc1\xd4\xf3L\xff\x8c\xba\xaf0Q\xc1:\x89b)}\xb0`\xa0\xbd:l$\xbf\xd7\xf6\xa2NR\xc1N\xbe\xd8\n\xc4d:ַ\"\aI\xbaȩ\xf6\xbc<\xf1B\xe9\xa7-\xe3H\x1f\x04\xff;\xce\x1dGd۬\xcd\xc6\xfa\x9d\x8b\xcd\xfa\xb2\x96\x1bf\xd3=\xc4\xca\x05\xf8*\x13\x96\x90\v\xa8\x99{\x17\x91s\x12\u007fi\xd6:h\xcfh\x96\xf6|\xebo$W\xe4\x92]M\xa7\x00\x00\x00\x11\xe6IDAT\xe7hv\xbd20\x1eF_\xb7\xcc\"\xec\xef0\x9d\x8cb\xe0Ww\x94\xf3\xae؛YDm\x1d\x9f\xe1\xa3\x13[#\x0f\nl\xdd\x18\xec\x8b\x06\xb08-X.\xfd%\x15]\xf5\xa0ɦT\b\x95\x93\x8eK\x91\xf14\x1a\xb6}\xa9S:\x8c\x1f\xc8Z\x83\x8f6\xd8؇آ30G\xd3\xff\x844\xa3H\xddʫ4r\xb83W\xcb\x11qf?\x00\x16\xc5\x19c\xa0\xb5\x8d<\x8a\x94\xdą\xbc\xf7\x11\xe6)\x18_\xd1)\bBw\xa5\xa0\xb4\xfe@uS\x18\xfb\x97l\xbd:I\x05\xbb\xab\xa3c\x89\xa4`\xe4\x1c\x17cP\xad\xf6~ԟ\xe6\x97m\x94\xab\xdc.9pI\x17\xa6K\x9b\x8d\xc1Ngm\xd4r}F\xd9\xf4\x0e\xd1\xc7Փ\x972\xe2\xacp\xee \xae\xa7\x90\x85m/e\xce}\xa9\xfe\x9c\x10:\xe1\xe3\xb3\xda5sgqKhv\xbd20\x1eF_\xb7\xccF|}\xf0h\xe7\xf3\x86~u\x15\xec\x1c7\xd0\xffn\x9f`?\xa7\xb15\xf2\xa0\xc2ԍ\xc1\xfe*ي\x8d\xca(\x98\xea\x81ͦT\b]\xc2\xc200\xa3\x15\x19\xc1\xb6\xaf\xaa`͜:\x8a\x8dTH\x83O\x88U0\xddʫ\xecLG\xe4F\xd3!\xa4\xfd\x00X\x14g\x8c\x81\xd6v\xc4\nfT\xde\xfb\b\xf3\x14\xec\xa2[&\x80\xa4G\x01\x9eq\x1b\u007f\x97\\\xb1\xbbt\x92*\xe4#mnU\x92\xd2i*8\x0e\xa1C\x0e٫z\x95\xcbQ\x9e\x95\xa2\xe6\x15,\xd7fc\x10\xf3\xf8\xb9\xb3F\xd9\xf4\x0eq\x96\xa3\xc2B\x9d-\x91\x02\x1f\xe4+\xbe\xaf\xbep\x11\x1e\xc2!\r\x1d\x8e\xac\x9d\x87\xfcyK\x94\xec\xa1e`=\x8c\xban\x99\xc7Q\x87\rQ\x053\xf0\xab\xab`\x03\xb6s5\\Y\x0f7\xa0\xb15\xf2\xa0\xc0֍\x81mTF\xc1\x14\x0f\x9alJ\x85\x10ZS\x82\x8e\xa7\x87\xb9\\\x99\xf6U\x9d\xd5\xd0B\x8bD,\xa4\xee'4,\x92?\xac\xf2*5\xe4n\xf8q\xda\ac?\x00\x16\xc5\x19c\xa0\xb5\x1d\xb1\x82\x19\x95\xf7>\xc2<\x05\x13\x82\x84vO0(\b\x95>\xba\xebL\x85\xb1\x82m\xe5zt\x92*\xd2Gz\xee3\xedi\xba\xf59\xf4\x9c\x12\xf5W\xafr\xe5[p.}\x99\xebB\x06g7\xb2\xd3\xdc\xf5\x1co\x94M\xef\x10\x9fq\xb5Ԍ8+\x9a{\x96\x82\vv\x96\xf4\xe7\xfa\x1a\xed\xb5\x88e\xd1r2\x88)4V0\xc6\xc3\xe8\xebF\x14\xcc.*\x98\x91_\ua87e\x17iXԘ\xb7r\xd1!\xdaSPm\x8d<\xa8\xb9\x98\xba1\xd8\xe9-c\xb1Q\xf5\x14L\x93\x8d\x11\xd4Î\xc1p\xbf\xc5`ۗ:\xa3\x9d\xe0V\xb6\x0f\x16\xa1\x90\xfa\x9f\x10\xdb$\xfa\x95W\xe9\xe5\xd6\xf4\x9e[\xb0\x92\x9cȚ\xb3\x84Aq\xc6\x18hmG\xac`F彏0O\xc1D\xc48X\xd5\x01\xb2\r7\x8a\x8c\xd4\x05\x93?\xd2̝\xdaӴ\xc3~Ůđ\x87_\xe5\xcd4\x8a\xd1(Ɗ\xf4\x15́Oo~n\x9ea6\xddC,\xcf\xea\xc3c\t;qv\\\f\x94\x94\xe1\xef\xc9r\xee8I\xe6i\xa3xYī\xb0\xc4X\xc1\x18\x0f\xa3\xaf\x1b\xa3`F~\xf3pe\xaf\x84\xde\xf0{\xfe%\xdbq\xeeE\xea[\xb55\xf2\xa0\xc0֍\xc1\x9eE\"S\x8b\U000a4fc6)\x98&\x1b\xa3`\x83\x8e\xc3\xe9\xf2 \xb2\xb7|\xd8-N\xb6}\xd3\xf0\x89 ,'\xce\xfa3\xf3\x06\xf1\xcbV\"\xf6\x91\n\xa9\xff\t\xb1M\xa2_y\x95\xb3\x9c\x83\xe3\xf2\xe8\\\x1f\xcdY\xa2\xe7\x8c1\xd0\xda2\n\xa6SM\x82\xd4fF彏0W\xc1\x84@\xbb'p\x8d\xcchm\xea\xec\xee\f\x17\xc9/Q\xfb]%:]0yN\xbe\u007fV\xc9\x15\xbf\xcdՁκl~r\x1a\t\x99\xab3i\xc7n\xf0\x03\xbfߎmx$tлA\xbd4c\x11\xb7\xb3y'WDg[3\xd9T\xc8m\xb3\xfa\x05\xe9=\x06\xd9\xf4\x0f\x81.\xa4e\x95\x97\xa5s\xb6w\xf1hb'\xf7|\xe3!\x179C˹\xb4\xb2f\x9c\xd4Frʹ\xc2\xda\xdd\xcb8\xc7[\x1dFeP<\x8c\xben\x17\xd2k\xfa\x1bm\xe7\xfa\x9fϻd\xe8\xb7\xdc^s(/-\xe4n\xef\xee\xb4Y\xc2\x02\xfb\ue4062\xf0\xa0\xa0\xd6M\xe3\xccέ\xe9h]\x89\x1b\x95):\xebAͦ\xa9\x10>\xde\xdct\xb9\x9b^\xc0\xa5\xf5!-l\xfb\xaet\xec\u07bd\\\xfc\x00Z\xed\x8bj\x9b\xb7r\xf5#(\xa4\xfe'\xa46\x89~\xe5Y\xce\xd9[\x9b\xfdW\xc4B\xb2g\x89\x8e3\x8d\x81\x9a\xa4s\xf2k\xe4:\xebT\x939ό\xca{\x1fa\xae\x82\x05H\x18\xac\x8a$\x9a\xaa+\xeaZ\xd4xE(\xd7ӊt\x92*\xca\xef\"\xb9\x9a\x17\xf1\xc6v\x81L\x99\xa1_L5\xf6\x1ajqVz\xbf\x1e\x9d\x13\x13b\xe0A\xa8Y\x92\xb6\xa4V\xa0\xbfxc\xb3)\xd8K\\\xb32\x8b\xae \x83l\xfa\x87\xc0\xfd\xaf\x82\xf4\xb9%\xefڨ\xb3\xe3y\x8e\xf4\x95\xe4˵qey\x96-3/\xe4t\x13j\x16\xd8\x1d\x85\xf5\vlyFeP<\x8c\xben\xb8\x83\xd08\x83Kk\x14\xc37\xfa~\a\xb6\xa6\xdb\xf3B'@\x9c\x9dU\x86U\xac#\xd4֠d2j\xdd4\xce\x16\x95\x17Π\x8d\xca\x14\x9d\xf5\xa0f\xd3T\x88\x84ȕ\xfew}ڰI\x1al\xfb\xf6\xe4\xd9g\xac~U,NOa\u058c\xe5\x87FRH\xfdOHm\x12\xfdʳ|`#嵭<\x87BΒ\xe1\xce4\x06j\xd2%5\x89\xd8\xf5ԩ&s\x9e\x19\x95\xf7>\xc2\\\x05\x1b1\xafr\x1f\xeb$\xc7\x03et\x06L\x00\xfa\xed\xea\xc5z\x88\v\xed\x9cL\x00\xae\xa7\xbdx]\x10\xfa\xce\x16\xa6G\xabp\x13\xb2\x9a\x13\x88\x18Q0\xf3\x1e\xab\x03\n6\x91hT\xee\xbd\n\xef\xce\x1a\xdf\x13ad\x1c\x92F\xb9\x82#4\xfauwL\xd0jN bD\xc1\xcc\x03\x14l\xc2Pފ\xf2\xca\xe4?\xae8J\x8c\x83\x0e\xe6qV\xba\xf1y\x8e\xd3\r\xc0\xdf1\x13\xb4\x9a\x13\bP\xb0\xb0\x88\x91[`\"\xd0\xcf-{)s\xa2\x8f\xa8\x04W\x9a\xab\xb1\xb5\x11o#Y\x02\xd1\x01\x14,,4r\xdb\x1b\xc9\n\x18\x17\xca\xd2\xf2\"<\xf8o\"pxu\xa6-sMtƐ@d@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]@\xc1\x00\x00\x88]bK\xc1\xcc\xfby$\x00\x00\x13\x11\x93\x15\xac\xdd\xed\xd5I\x1a\xf11\xb7S')3ҕ\xd8k\x8d\x97\xebR\xd6\xe7\x02\x00 &0W\xc1\xf8\x8ac\x95Ó\x86\x14\xa9\xeb\xdc\x16\r[\xf2v\xc4+\xb1\xf7\xf9\x97\x1b\xfeZ[Z\x9f\v\x00\x80\xd8\xc0\\\x05\xf36uW\x0eO\x1a\xd1Õ\xe8$U\x86=JΈ\x02\xe3\xe7M\f{\xca4\x00\x00\x13\x18S\x15\xac\xdd\xc3\xcb\xebE2IC\\j\xbf\xcb5\xbc\vv\a\x80\x82\x01\xc0=\x82\x99\n\xc6Wt\xc9+\xde2ICzm[u\x92\x12\xba\xab\xd77\xe2}\xe5\xca:\xf5\xea\xb2\xeeX\xc1\xb6\xe2\x9dv\xb2ʌ\xbar\xfc\x95\xa2\xcc\xf4B\x18E\x02@,a\xa6\x82y\x9b\x945\xbb\x99\xa4!.\xdb%\x9d\xa4\x8c\xde\xea\xf5\xfd\xfeYe\xd7\xe5u\xea\x99eݱ\x82])\xe2jȃ\xbfԕ\xe3{f-\xa8?\xbc\x9a\x03\x05\x03\x80\x18\xc2D\x05\xeb\xf4\xf0\xb2l1ICzm/\xea$Y\x94U\xbb\x94\xd5둋,\x97\xf0<\x99x\xc1.\xeb\x8e\x15\xac\xc6N\x9f\xe0Ĭ\x1c\xbfrA?Ys\v\x14\f\x00b\b\xf3\x14\x8c\xaf\xe8\x14\x04\xa1\xbbR\x10ؤ1/\xa9O\x1ad\x92,\x8a\x82\x11\xc5\x12\x03Z\xad\xf6~ԟF\x16\xd0f\x97u/(/\xe3ę\x17\xea\xca\xf1}t\x89!q\x8dT\x00\x00b\x04\xf3\x14\xec\xa2[&\xc0$\r\xcd#.y\xab\xb7r*\x12\x1c\x87\xd0!\xba:\x04\xbb\xac{\x81c\xc6\"q-+u\xe5\xf8\xb3\x1c\xd19\x88\xe4\x03@La\x9e\x82\tAB\xbb'\x18\x14\x98\xa4\xa1\xf9Vu\x9dۭ:K\xde\x12t\x14\fm}\x0e=G\xa3\xfe\xec\xb2\xee\x05\x8e\v\xbd\xb3\xe8R\x8b\xea\xca\xf1\x9fq\xb5\xd4\f\x14\f\x00b\b\xf3\x14L\x84\t~\x85\x8d\x83\x8d\xa0\v\xa6\xab`\x1d\xf6+v\xbaT\a\xbb\xac;\x99M\xd1l#\xbb\x99\x95\xe3\x97g\xf5!\xd4c\x97\x14\xacww\f<\x92\x1d\x00\xee{\xccU0!\xd0\xee\t\\\vM\xeaQ\xa2\xf6\xbbJ\xf4\xba`\xfa\xab\xd7c\xb7\x99\xab3C\x96\x80\xef\xf3/w}0\xd8_\x90\xd9z\x9d]9\xfeBZVyY\xba\xb8N=Y\xec\xfdG\xc3\x0f\x02\x00\xc0\x04\xc3\\\x05\v\x90\xd8WUhR\x87\xebiE:I\x06\xfd\xd5\xeb15\xf6\x1a\xd1BYֽ\x96\u061d%s\xc5\xc8\xe2\x83\xea\xca\xf1=\x05\xe9sK\u07b5\x89\xd9\xea\x1d\xf5:G\x01\x00`ba\xae\x82\x8d\x98W\xb9\x8fu\x92\x00\x00\xdc\xe7Ĉ\x82\xc1cu\x00\x00\xd0!F\x14\f\x00\x00@\aP0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\x00\x00b\x17P0\xf3\x18\xe8\xef\xef\x1fDh\x10\xbf\fD\xb2\x05\x00@\x0fP0\xd38\x16g\xb5Z\x13y>\x11\xbf\xc4\x1d\x8dd\r\x00\x80\x0e\xa0`c\x88wf\x10\xa1k3\r\xd6\"\xaf\xb6z[Z\xda\x11joi\xf1Z\xab\xf5m\x00\x00\b\x8b\xc9\n\xd6\ue997w\xbf\x87>c\xda\x13\x8d\xc1\xd4~\xabDR\x18oMI\x06\xb2\x12\x9ek\xf9I\x89sF\xbc\xb0\xee6k1}\x89ۦ\xfbv\xb5\xb5[Nv߁\x82\xdde\xd1Gʩ\xef;Ern\x871\xca9a\xfc&\x00\x8c#\xe6*\x18_q\x8c>\x98\x95w\x9f\t`\x82\x91\xecG\x02\u007f,>ׇ\xd9`\r\xe3Λ8r\xc9`\x98\x9d\xec\xceM\xe4#YI\xec\x8a\xf3\x88\t\uf8e5z\xefGR0\xdf\xe9\xe1\xfb\xd0]\x17}\xa4\xdcj\xcb~\xa5\r\xb3\xc7\xf9\xb9\xb1щ\xf9G\x8c\xdf\x04\x80q\xc4\\\x05\xf36uK\n\xa6\\\xccQ \x81v}*\xc3)\x18\x1aqG\x8a嚵\x14\t#\x15\xb0\x8b\xf1\x1b\xe4\xe4\xa6\x04\xbd\xeaER\xb0鋇\xef#\xdcU\xd1\xef\x80\xec\xbdd{\xd0y#\x8cM\x98\xfe\x19\x00\x8c'\xa6*X\xbb\x87\x0f\x8c\x99\x82u\xad\x8bdw\xc7tY\xef`\x00\x97\x9b\xach\x1d\x9f\x9c\xabc\x10I\xc1R\r\x14l\xac\x11\x15\xec7o\x80J\x011\x80\x99\n\xc6Wt\xa1\x91)X\xb5\xd5j-F\xc5x[\x8d\xf8\xc5\xc9\xf1)\xf3\xce\xe0\xbdg\x1e\xb5Z7u-\x9d\x9a8gPc-*\x18&\xdf\x1a\xef^7-qvw\x88\x87D\xab5\x8e>\xd0Z\xebaWjb\xea.m6\x86\x81$1\xbc\xb6\x8e\x18\xc4U\xe2>\x96uZ\xa8m\xd7¤\xf8\xe49tɸ\x81\xc9J\x17\fw\xc2\x12\xfb\xd10\xf4\x14\xec\xe8\xec\x94\xf8\xa49)\xb8w*\x05\xf3R\xb5\x85T\x8b\xae9ppiRʺuI\x9a\xf1e\xf7d\xc9\xc5dm=n7\xac\x9f\xbf\xb6\x81\xcaS\xdb\xe6\x15\xd9\xcfl^\x11\"U\xa2\x82a^qf\x1f|c\xd5\xfcͿG\xe8\x88\xd3\xe9܋\xf6\xe2\xed\x11tc>}\xc1|\x94\xedt\xee\xf9t\xfb\x8a\xec\xcd_0~\x99l\x000֘\xa9`\xde&\xa4(XS\xb5\xbb\xea\xa8\xcee.\xc2\x1f\x9d\xbc)\x88\x82\x9b\xa6\x1c\xe5\xf1\xb5\x9d뫞\x17ׂP\u007fuUʓ\x93S\xd6-\xb5j\xafфM\xfd\xfd\x8bI\x0f\xac\xb3\xeaQkRq\xe9\xe4\x85Z\x0f\xe8\xa4\xcf'\xaa\x9c\xc6Cn\xc2&濾\xa5\x9al,g|U\xd6b\x9f\x0f\xebS\xc0\x17\x8f\xb3\xb7\xe4&\x84\xd8\xfa\x12S\xb75\x15[i\xd4\xeb\xb4էf=fmA\xc3\xd0Q\xb0\x93֥\xd5M\xee$+\x96\xaac\xbe'3|>_gH!\x95\xa2\xb3\a\x1e\x98\x96\xbc\xab8!\xb1b6\x1bo\x1b\U00014284\xdc\x1fّ\xbd\xe7Ԟ\xec\xed8\xf5\xcb\xefo?r\xea\xe03\xce/4\xef\xa3\xec\x9fܺ\xb5\xe5\r\x9c\xf8\xe8H\xb63g\xef;\xf3\xb7 t\xa3m\xfeO>G\x9f\xef}\xba\r\x8f-Ϸ\xb5\x89*w\xebȑ\x15\xab\xe6缱\xfd\xfbW\x19\xbfL6\x00\x18kLT\xb0N\x0f\xaf*X\xe5\x99\xee\xce\xea*㻇\xb9dH\xb5\x98\f\xc6\xf8j2:K\x15\xe5%\xd5:\x1b\xff\x15\x12\x9aJ =\x8fybr\n\xbe\xea\x97&i=\x10\x12\xe5~\x9a\xe2\xe1\x80\xf5\x00\"\xdb\xfd\xdal,\xea(\x92\xaaHq\x02\xd2\xd8\xf6\xa7\xcc\xc1\x15\x18\xa8\xa6+.y\xad\x17Ռ\xba\xa3D\x1d\x05ەD\xfb\x82Sh\xa8\x8b\x19Ej\xaa)\x17]=p\x95\x15wIwYۑ\x86\xe0E\x11m8\xf0\x94\xf3\x94\xbcm\xc8!\xda\xd5\xf0th\x1f\x8c܉\xdc,&\x9f\xc6\x1d\xa9\xed9$\xb9\x83h\xde\xf6\x1d\xb2\x8d\xdcO[\xeb\xdcx\x03ݾ\xa1\xf1\xcbf\x03\x80\xb1\xc5<\x05\xe3+:\x05A\xe8\xae\x14\xf0\xe5*\xb4\x93\xeeW\xbfG\xa7\xa7\"\xe1K\xe4\xf1\x10\x8avk\x82\xbb\xe6L\x9dL\x86W\x98T\xbd\x18yBnKK\xaa\xa4`D\xb1D\xa5a< V\xc1d\x0f\xb9\xd3\xe8˴\\m6\x16}\x05Sl\xf7\x13!\x91\xa9\xd3*\x98\xce*L:\n֝<5\xdf}F\x10\x85\x9cU0\xb6\x9a\x8a\x82)\a\xde0\x05\r\x0f\xd2]\x94g\x95h{\xa8;\xd6җU\xaf t5g\xc5\xeb\a\u007fu;4ޕ\xbd\xe3\xfc\xf9\xb5\x92\x82\x11\xc5ڛM\x92mٷЭ\xf9m\xb2\x8d\xa2`\xd9W\xc5\x04\xe3\x97\xcd\x06\x00c\x8by\nv\xd1-\x13\x90w\x1d\xad3\xb4\x1eL\xaaCuI\xa4oҒ\x9c\xb2\xa1Η!)\xd8t\x1d[\"/\xfb\x9b\x94\xa4\xa44\xaa\a\x82\xaa`\xb2\x87\x99\xa2\xe6͙\xae\xcdƢ\xaf`J\xb2\xd4\xca\f\x83[\u0601c\x8b\xf5\x18\x1a\x86^\x1c\x8cw/\x9efM\x12珱\n\xc6VSQ0\xe6\xc0A\xd2{\f\xe9\x83\xf9\xbc\"\xcch\x16\xb3QԦ\xcd\xeb\xf1\xe6\xc6\xc1-\xab\x9cϼ\xa3\x13\a;զ$%)\xfa\xe2\xe9\x13\xe8\xc43\xb2\xa9\xaa`\xeb\xa5\x04\xeb\x97\xc9\x06\x00c\x8by\n&\x04\t\xed\x9e`P@M\xa22\xf8\xc2\xdc\xea\xcb_\x88\x16\xe6\x93Ĵ\x99d4\xb5PR\xb0\x90X\x15E\x8a\xe4\x9f\tj\xa5H\xf1@P\x15L\xf6\x90;\x95\xbeL\xcdE#U\xb0M!\n\xd6defp\xf1\xca\xfd\x04\xf2v\xbc\xce\x1c\f\xbd8\x18\x89\xfe\xf3U\x89\xe4~\x82\xa8`\x15\xd4FS\xcd\xe1\n\xd6\x1d7\xa7\xfb\xccԙ#\x9af\xb1\x83\x06\xeeo\xaf\xc0ݤ\xf3{p\xf2Ƒ\xec\x06\xad\x85\xa4N\x1f\xdd\xd0J\xd1\xeb[Ж\xd7Cl\xb0\x82m\x91\x12\x8c_P0`\xfc0O\xc1D\xc48\x98\x97v\xbe\xaey\x98QX(-\t\x81\x04ګI!W\xb3\x90*)\x98ތ\x03I;\x927h\xa5H\xf1@P\x15L\xf6\xe0\xa5#\xbd**R\x11\x15,\x11\xfb\x16\xa6\x87(\x18\x9f\x9cA\xc6\u007f\xf9\xe24\x8e\xc5S\x15E\x11\xa6\xcdA\xc3\xd1Q\xb0b\x1a\x8bC\x19Th32\xf0\x88Y|CS\xcd\xe1\nvښd\xb5f(]ٰ\x9c\xa2\xb7\x11\x8f\x90x\xd5^\x1a\xb4B\x1b_\xa1oto\x93\x86\xbd\x92:\xe5\xec\xd1J\xd1/\xb2\xaff\xffB\xf62\\\xc1\x18\xbf\xa0`\xc0\xf8a\xae\x82\t\x81vO\xe0\x1a\xbez\xdc\a\xba\xbaOVx\xc3\xf4\"\x84\xe4\xd9\xc9\xf4\xedb\xeb\xe2]\xdbR\xf1P\xabe\xb0\x85ޯc\xe2M\x04yN\xbeo\xf2\xba\x80/>\xb7\x05\x9d\u038d'7\x10U\x0f\x03->_B\xae\xef(\x8f4\x1e\x96\xc6m\xf0n\x88[Jo52\xd9\x14\xc4{\x91-\xd4\xc5̤m\xdbfZ\x1f\xf5tjl}\x8fMs\xefϷVP\xf3\xae8\xe5\xce`\xa9Uoz\xbd\xae\x82%\x16{\xebr\xc5ۘ\xc5\t\xa5u\xb3\x13\xbb5\x85T\x8b\xce\x1e\xf8tB\x93\xd7\x17\x18Q\x17\f\xa1\xed\xce='\xf68I\\~\xafs\xfe\xde\x13'v8\xc5\x11\xe3<+\x95YyN~\xdb\xfc7\xae\xe2\xe4\xcfo\xff\xf2\x95\xec6\x12뺝\xb3Y\xfc\xa1\xd1ퟷQ\x9b\x1b\xe8\x8b_\xb4\xad\xda\xd8\xd6\xf6\xa9֯6\x1b\x00\x8c)\xe6*X\x80\x84\xc1H\xd7'\xd8T\xe5\U000761fd\x06K\x13DE\x10J\x9fLHZ\xec\x99\x1a\x9fq&\x8e\x06\xaaC\xfa7\xca\xef\"\xad\xa5\xf9x\x13\xdfN\x9e\xfd\x90\xcfz8)泺\x91ƃ@\xe7\x83\td\xaa\x95&\x9b\xc4\xc0\x14j\xfbh'\xf9\xa3+#q\xf2\xec\r\xd8@k۵8e\xf2t9\x98\xb7\xe91)\xf8u4Qwrm\xb5\xb5K~\xbaN\x97\xa4`\x95\x19\xc5)\xf1\xc9\x19b\xe4j \u007fJb\x06\xee4\xb2\x85T\x8b\xce\x1e\xf8X<\xd9\x17\x9f\x11\x12\b\xd3\xe7v\xc3Zi>\xd8\xc1\x8d{Wd\xe7l\x94\xa2\xf3\x9e$7y9\xe5\x94ix\x05o\xb2\u007fEf\u007f\xd1^Z\x834\xdc\xfc\xa5\xf4\xfeA\xf4\x91\x98ج\xf5\x1b\x92\r\x00\xc6\x12s\x15\xec\xdef]<ե\xaa\xf8\\\xed\x8c[\t:iUz\xba\x0e\x9d\xc3q\xb7\x04\x13\U000c30c3\xfcɅSF\xfa\x8b'\x00\xb8W\x00\x05\x1bCJS\xc8\xd3u\x92\xf5\x1fM\x81\x06ϴ\xc8O\xd7i9\xa3\xabq#\xa4N\x9c?\x86\x84\xa4\xd1\xe8 \x00\xc4\"\xa0`\xb1\xcf\xe98q\xf8\xd8\x1e\x17\xe6N\b\x00ܓ\x80\x82\xc5>Bnb~\x95\xaf*?Q\xef\xf7\xe3\x00pO\x03\nv/\xe0\x9d\x9d\x1c\x9f<\xe7\x0e\x1e\x9c\x01\x00\xf7\b\xa0`\x00\x00\xc4.\xa0`\x00\x00\xc4.CC\xff\x1f\xf8\xaa\xf0z\xf7Oɏ\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/help.html": `<!--{
+        "Title": "Static analysis features of godoc"
+}-->
+
+<style>
+  span.err { 'font-size:120%; color:darkred; background-color: yellow; }
+  img.ss { margin-left: 1in; } /* screenshot */
+  img.dotted { border: thin dotted; }
+</style>
+
+<!-- Images were grabbed from Chrome/Linux at 150% zoom, and are
+     displayed at 66% of natural size.  This allows users to zoom a
+     little before seeing pixels. -->
+
+<p>
+  When invoked with the <code>-analysis</code> flag, godoc performs
+  static analysis on the Go packages it indexes and displays the
+  results in the source and package views.  This document provides a
+  brief tour of these features.
+</p>
+
+<h2>Type analysis features</h2>
+<p>
+  <code>godoc -analysis=type</code> performs static checking similar
+  to that done by a compiler: it detects ill-formed programs, resolves
+  each identifier to the entity it denotes, computes the type of each
+  expression and the method set of each type, and determines which
+  types are assignable to each interface type.
+
+  <b>Type analysis</b> is relatively quick, requiring about 10 seconds for
+  the &gt;200 packages of the standard library, for example.
+</p>
+
+<h3>Compiler errors</h3>
+<p>
+  If any source file contains a compilation error, the source view
+  will highlight the errant location in red.  Hovering over it
+  displays the error message.
+</p>
+<img class="ss" width='811' src='error1.png'><br/>
+
+<h3>Identifier resolution</h3>
+<p>
+  In the source view, every referring identifier is annotated with
+  information about the language entity it refers to: a package,
+  constant, variable, type, function or statement label.
+
+  Hovering over the identifier reveals the entity's kind and type
+  (e.g. <code>var x int</code> or <code>func f
+  func(int) string</code>).
+</p>
+<img class="ss" width='652' src='ident-field.png'><br/>
+<br/>
+<img class="ss" width='652' src='ident-func.png'>
+<p>
+  Clicking the link takes you to the entity's definition.
+</p>
+<img class="ss" width='652' src='ident-def.png'><br/>
+
+<h3>Type information: size/alignment, method set, interfaces</h3>
+<p>
+  Clicking on the identifier that defines a named type causes a panel
+  to appear, displaying information about the named type, including
+  its size and alignment in bytes, its
+  <a href='http://golang.org/ref/spec#Method_sets'>method set</a>, and its
+  <i>implements</i> relation: the set of types T that are assignable to
+  or from this type U where at least one of T or U is an interface.
+
+  This example shows information about <code>net/rpc.methodType</code>.
+</p>
+<img class="ss" width='470' src='typeinfo-src.png'>
+<p>
+  The method set includes not only the declared methods of the type,
+  but also any methods "promoted" from anonymous fields of structs,
+  such as <code>sync.Mutex</code> in this example.
+
+  In addition, the receiver type is displayed as <code>*T</code> or
+  <code>T</code> depending on whether it requires the address or just
+  a copy of the receiver value.
+</p>
+<p>
+  The method set and <i>implements</i> relation are also available
+  via the package view.
+</p>
+<img class="ss dotted" width='716' src='typeinfo-pkg.png'>
+
+<h2>Pointer analysis features</h2>
+<p>
+  <code>godoc -analysis=pointer</code> additionally performs a precise
+  whole-program <b>pointer analysis</b>.  In other words, it
+  approximates the set of memory locations to which each
+  reference&mdash;not just vars of kind <code>*T</code>, but also
+  <code>[]T</code>, <code>func</code>, <code>map</code>,
+  <code>chan</code>, and <code>interface</code>&mdash;may refer.  This
+  information reveals the possible destinations of each dynamic call
+  (via a <code>func</code> variable or interface method), and the
+  relationship between send and receive operations on the same
+  channel.
+</p>
+<p>
+  Compared to type analysis, pointer analysis requires more time and
+  memory, and is impractical for code bases exceeding a million lines.
+</p>
+
+<h3>Call graph navigation</h3>
+<p>
+  When pointer analysis is complete, the source view annotates the
+  code with <b>callers</b> and <b>callees</b> information: callers
+  information is associated with the <code>func</code> keyword that
+  declares a function, and callees information is associated with the
+  open paren '<span style="color: dark-blue"><code>(</code></span>' of
+  a function call.
+</p>
+<p>
+  In this example, hovering over the declaration of the
+  <code>rot13</code> function (defined in strings/strings_test.go)
+  reveals that it is called in exactly one place.
+</p>
+<img class="ss" width='612' src='callers1.png'>
+<p>
+  Clicking the link navigates to the sole caller.  (If there were
+  multiple callers, a list of choices would be displayed first.)
+</p>
+<img class="ss" width='680' src='callers2.png'>
+<p>
+  Notice that hovering over this call reveals that there are 19
+  possible callees at this site, of which our <code>rot13</code>
+  function was just one: this is a dynamic call through a variable of
+  type <code>func(rune) rune</code>.
+
+  Clicking on the call brings up the list of all 19 potential callees,
+  shown truncated.  Many of them are anonymous functions.
+</p>
+<img class="ss" width='564' src='call3.png'>
+<p>
+  Pointer analysis gives a very precise approximation of the call
+  graph compared to type-based techniques.
+
+  As a case in point, the next example shows the dynamic call inside
+  the <code>testing</code> package responsible for calling all
+  user-defined functions named <code>Example<i>XYZ</i></code>.
+</p>
+<img class="ss" width='361' src='call-eg.png'>
+<p>
+  Recall that all such functions have type <code>func()</code>,
+  i.e. no arguments and no results.  A type-based approximation could
+  only conclude that this call might dispatch to any function matching
+  that type&mdash;and these are very numerous in most
+  programs&mdash;but pointer analysis can track the flow of specific
+  <code>func</code> values through the testing package.
+
+  As an indication of its precision, the result contains only
+  functions whose name starts with <code>Example</code>.
+</p>
+
+<h3>Intra-package call graph</h3>
+<p>
+  The same call graph information is presented in a very different way
+  in the package view.  For each package, an interactive tree view
+  allows exploration of the call graph as it relates to just that
+  package; all functions from other packages are elided.
+
+  The roots of the tree are the external entry points of the package:
+  not only its exported functions, but also any unexported or
+  anonymous functions that are called (dynamically) from outside the
+  package.
+</p>
+<p>
+  This example shows the entry points of the
+  <code>path/filepath</code> package, with the call graph for
+  <code>Glob</code> expanded several levels
+</p>
+<img class="ss dotted" width='501' src='ipcg-pkg.png'>
+<p>
+  Notice that the nodes for Glob and Join appear multiple times: the
+  tree is a partial unrolling of a cyclic graph; the full unrolling
+  is in general infinite.
+</p>
+<p>
+  For each function documented in the package view, another
+  interactive tree view allows exploration of the same graph starting
+  at that function.
+
+  This is a portion of the internal graph of
+  <code>net/http.ListenAndServe</code>.
+</p>
+<img class="ss dotted" width='455' src='ipcg-func.png'>
+
+<h3>Channel peers (send ↔ receive)</h3>
+<p>
+  Because concurrent Go programs use channels to pass not just values
+  but also control between different goroutines, it is natural when
+  reading Go code to want to navigate from a channel send to the
+  corresponding receive so as to understand the sequence of events.
+</p>
+<p>
+  Godoc annotates every channel operation&mdash;make, send, range,
+  receive, close&mdash;with a link to a panel displaying information
+  about other operations that might alias the same channel.
+</p>
+<p>
+  This example, from the tests of <code>net/http</code>, shows a send
+  operation on a <code>chan bool</code>.
+</p>
+<img class="ss" width='811' src='chan1.png'>
+<p>
+  Clicking on the <code>&lt;-</code> send operator reveals that this
+  channel is made at a unique location (line 332) and that there are
+  three receive operations that might read this value.
+
+  It hardly needs pointing out that some channel element types are
+  very widely used (e.g. struct{}, bool, int, interface{}) and that a
+  typical Go program might contain dozens of receive operations on a
+  value of type <code>chan bool</code>; yet the pointer analysis is
+  able to distinguish operations on channels at a much finer precision
+  than based on their type alone.
+</p>
+<p>
+  Notice also that the send occurs in a different (anonymous) function
+  from the outer one containing the <code>make</code> and the receive
+  operations.
+</p>
+<p>
+  Here's another example of send on a different <code>chan
+  bool</code>, also in package <code>net/http</code>:
+</p>
+<img class="ss" width='774' src='chan2a.png'>
+<p>
+  The analysis finds just one receive operation that might receive
+  from this channel, in the test for this feature.
+</p>
+<img class="ss" width='737' src='chan2b.png'>
+
+<h2>Known issues</h2>
+<p>
+  All analysis results pertain to exactly
+  one configuration (e.g. amd64 linux).  Files that are conditionally
+  compiled based on different platforms or build tags are not visible
+  to the analysis.
+</p>
+<p>
+  Files that <code>import "C"</code> require
+  preprocessing by the cgo tool.  The file offsets after preprocessing
+  do not align with the unpreprocessed file, so markup is misaligned.
+</p>
+<p>
+  Files are not periodically re-analyzed.
+  If the files change underneath the running server, the displayed
+  markup is misaligned.
+</p>
+<p>
+  Additional issues are listed at
+  <a href='https://go.googlesource.com/tools/+/master/godoc/analysis/README'>tools/godoc/analysis/README</a>.
+</p>
+`,
+
+	"analysis/ident-def.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03\xd2\x00\x00\x00\xf5\b\x03\x00\x00\x00\x8b\f=\xff\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE!# #$\"$%#($#&'%'(&-'\")+(4,\",.+01/>/\"241A2%685G6$8:7;<:Q9$>@=W>#AB@CEB\\B'cC$GIF\x00f\x00\x00g\x00\x00h\x00gF'\x00i\x01KLJ\x00j\x02\x02k\x03\x04l\x05mJ&\x06m\x06sJ(OQN\vo\b\x0ep\nwN&\nq\x16TUS\x10q\f\fr\x17\x0fs\x18~R%WYV\x12u\x1a,`\xae7]\xad\x15v\x1c\x86T)\x16w\x1d[]Z9a\xab\x19y\x1e^_];b\xac<c\xad\x8dZ(>e\xaf)z ac`+{\"(|*\x92]%cebAh\xb2egd+\u007f,\x9a_)Li\xafDl\xb0.\x81.ikh0\x830Ho\xb31\x841/\x858Jq\xb6mol\xa3f);\x86:Us\xb3\xabg->\x88<Wu\xb5\xaej(sur@\x8b>B\x8c@\xb3m,vxu@\x8dGC\x8dA\\z\xbbxzwI\x8dH]}\xb7K\x8fJ\xb9r*_\x80\xbaM\x91L}\u007f|\xc1s-O\x93MP\x94Oc\x84\xbeN\x95U\x81\x83\x80\xc7x+W\x95VX\x97Xm\x87\xbcY\x98Y\xd1z(Z\x99Z[\x9aZ\x87\x89\x86\\\x9b[r\x8c\xc2\xd6~-^\x9d]\\\x9dc\x8a\x8c\x89d\x9ddz\x8f\xbff\x9ff\x8f\x91\x8eh\xa1hޅ+~\x93\xc4j\xa3j\x92\x94\x91k\xa4ky\x97\xc6s\xa4lq\xa5s\x95\x97\x94\xec\x8a,\x83\x9bŘ\x9a\x96\x9a\x9b\x98u\xaaw\x86\x9e\xc8\xf1\x8e/\x9b\x9d\x9a~\xaay\x88\xa0˞\xa0\x9d\x80\xad|\xf7\x93-\xa0\xa2\x9f\xfd\x92/\x81\xb0\x85\xa2\xa4\xa1\x92\xa5\xca\xff\x952\x82\xb2\x86\xa4\xa6\xa3\x83\xb3\x87\x8b\xb2\x88\xa6\xa8\xa5\x96\xa9\u038d\xb5\x8a\xa9\xab\xa8\x8e\xb6\x8c\x9e\xad͍\xb8\x93\xac\xae\xab\x95\xb8\x95\xa1\xb1ї\xba\x96\xaf\xb1\xae\x98\xbb\x98\xa4\xb3Բ\xb4\xb0\xa5\xb5՛\xbe\x9a\xb5\xb7\xb4\xac\xb7ѣ\xbf\x9d\xa2\xc0\xa4\xb7\xb9\xb6\xa4¦\xb9\xbb\xb8\xa5Ĩ\xb1\xbd\u05fb\xbd\xba\xa8Ǫ\xb7\xbfԯƫ\xbe\xc0\xbd\xb9\xc1\xd6\xc0¾\xb2ɮ\xc1\xc3\xc0\xbb\xc3ؼ\xc4ٱ̶\xc4\xc6ó\u0378\xb9̸\xc1\xc8\u07bb\xca\xde\xc7\xc9ƻκ\xbdϻ\xca\xcc\xc8\xc7\xcbۿҾ\xc4\xcf\xdd\xcd\xcf\xcc\xcb\xcf\xdf\xc8\xd3\xc1\xc6\xd4\xc7\xcd\xd1\xe1\xd0\xd2\xcf\xc8\xd6\xca\xd2\xd2\xdd\xd2\xd4\xd1\xca\xd8\xcc\xd3\xd5\xd2\xce\xd6\xdf\xcc\xda\xcd\xd5\xd7\xd4\xd6\xd8\xd5\xcd\xdc\xcf\xd4\xdb\xd0\xd8\xd9\xe3\xd2\xdb\xe3\xd5\xdc\xd1\xd9\xdb\xd8\xd7\xde\xd3\xd5\xdf\xda\xdc\xde\xdb\xda\xdf\xe2\xd7\xe1\xdc\xe0\xde\xe2\xde\xe0\xdd\xd8\xe2\xdd\xdd\xe2\xe5\xe0\xe2\xdf\xe2\xe4\xe1\xdf\xe5\xe7\xe4\xe6\xe3\xe8\xe5\xea\xe2\xe7\xea\xe5\xe7\xe4\xe6\xe8\xe5\xe4\xe9\xec\xe7\xe9\xe6\xfe\xff\xfc\x93\x8dkM\x00\x00 \x00IDATx^\xed\x9d\u007ft\x14\xd5\xdd\xff\a%\x064*\x15\xe1y<\xb3=lbJ0@\x94\x86F\xac(\x98o崆\xf4\x89i\xfa\x8d\xf6\xa4R\u007f`A\x10\x1a͓ñ\"\x02\x15\x1e\x8c\xf5l\xea\x81ش\x91`h\xf6(\xb89r\xb2\x12\xe4Ⱥ(<\x12\xda''\x94\xd2\xf6!\xc5\b\xc8S(ȓv\xd7Գ\xde\xef\xf9\xde{\xe7\u05fd\xb3wfv\x03a\xc8\xec\xe7\xf5\xc7\xee\xec\xe43\xf7\xde\xf9̼\xf7\xde;;\x99\xb7\xf4\xff.\x00\x04\x00\xc0e\x86\xe4$[;\x9c\n\a\x00\xe0R\x03\x92\x06\x00O\x01\x92\x06\x00O\x01\x92\x06\x00O\x01\x92\x06\x00O1\x92$]_/Z\x04\x00\x80\xc1=I\xf7w4\aZv\x9dS?u\a\x82\xb6ј?\xc9\xeb\x04\x8b\x84_˄9\xed\xc9\xdbX\xf0\xb1O.u\x8a\xb1'\xc5\x12\x9e\x95\xe5\x90S\xccP\xe9$;]\x82\x17z\x17\x14\x16TE\xca\xf6!\x94h\x983\xcd7\xed\x9eF\x84\xa2\xb2\\\x95@!\x1c\x11q*\xc7\x0e\xf1n\xa6\xb8\xf3\xa8\x0eW\x9f\xd7\xe7\x14\xa5s\xb6\xbe(wA\xc2)*\x89\xc8\xf4\x9dN!\x19\x85k\x92>\x11\b\xf6\x1c\xeb\xd9\xd2<@?\x9d\v\xecjr\xd8\x00\xd5\xe6\x9e\x16,\x12ο*\xb7G\xbb\x96\xca\r\xc9\x1bYp\xa0\xce\xef\x14\xe2\x80}\t\x91^\xe5\xfdT\xd4\xd7h\x13\x96\x1aZa&\x06\xf6E\v\x16\x1dƊ\xf6=ڹ}\x11\xfd\xee\x88\xc8\vں\xda\x17\xcaQ\x14\x8fȹQ\x14\vɑ\xb8p\xe3T\x11\xeff\x8a\xe9;\x1e\x8d\xb6\xc9\xfb\x9c\xa2t\xaa\x8b\xda\xea\xf2\xce;E%ѕ\xa7}kZ$*\xc3pM҇\x02\xc7\xf0\xeb@\xa0\x87~\nv\x1cs\x92t\x9f\xbcZ\xb0\xa8\x10\x91\U0006937b\xc4?\xa3TiL霴ö\x84\u007f[\xa2-\xf9/\\\xd2Faf\n\xd7◚j\xb2XG$\xbd\xba\x80\b8>\x05\xa7'&\xd7\xd6\xe1\xfeT\x8eYm\x9b\"\xe2\xddL9}\aS\x97\xf4y\xb9\x15%\x86\xd2\\\xbdc\xb7NT&ᚤ\x11\xed\x9eO\x06\xfa\xc9[w\xd3@\xbf\x93\xa4\xeb\xfc\xa7\x04\x8b\n\x8a\xa4\xe3\x05+Q\xaa\xa4|NZb[B\xf9Ŕt\xb9\xbd\xa4K\xe8\xe0\xa4W\xee\xc4\xfd\\\x05]]QC$\x1dɏ\x8d(I\xf7\xc9\x17:\x80\xb6NT&ឤ1\xb1\xa3-A\xf2\x15{.p\b9I\xfac\xdf*\xc1\xa2\x8a\"i\xb4\xb2\x90\xbcn\xafʻg\xb5r&\xf7-*\xf4\x15-\xa0\xfao+\xcf+k\xa3+O\xd5Θ\xb2H\x1d92\xb1\x1a\xbd>Yn\xe8\xab-ɭI\xb0\x01\x03Kf\xf8J\x16\xf6\x9aK\x88֔\xf8\n\x17\x94p%\xec\x94\x15\xca\xc9\a\xff\xda\xd5\xf7\xe4\xd5\x1c\xa7\u007f\x10ԶR\xf6\xb5'\a\x1c\xc6mX\x88f\xcarA\x9c+\xcc\f\x95\xf4\xd2\"\xba\xf3]x\xbb\xaaEt\xf5\xa2*\"\xe9\x8f\xcbC\x02IkU\xf0\x15\xa7\x91(v\xad\x06\x99\xb37\xa2F\x99\x8c\xfe\xd9D\xe9\x92^)\xcbۍ)\xb8 \x0f\x83\x85\xcan\xae6\x1f\x00\xb59\x89\"ߋ3gDV\x15T\x0fp\u06ddϓ\xd5\xcb\x15\\\xa2D\x87%SpQ\xd2'\x03\x18zy,\u0601\x1c%]\xef;.XTQ%\xdd.\xe3\xe3]/\xaf\xeaj\x9d^NN\x87H~\xf9\xab\x91F<\x9e#\x1d{CW\x83\xff)\xbc\xd4WpO\xfb\xce\x1a\x99\x9e\x93L\xacN<\x14*\x99\x93?su\xad|\x9c\r\xe8\x92\xeb#\xa1\x85\xf2A\xbe\x84\xdf\xcaO\x85\"\xed\x852W\x02\x9e\xe4Ω\x8eF\xa3t\x1a\xe0\x97KC;\x8b\x16Y\xd5\xf6\xa7\x90O\x9e\xde\xf8\xeb|> q\xa0Q>\x80ޔ\xb7\xf7\U00085661\x92>^\"\xd74\x1e\x18$\x9f˖\xd1\xd5\xcbʨ\xa4[\x17(\x92\x8e\u007f\xac\x10g\xab\xe0*N#Q\xecZ\x9dX\xb4\xa0\xe1o\xe8o\r\x05\xd1\x18\x9b(\xa4KZ\xb9\xa6\xa0N\xc1Ey@\xbdѐ\xdc\x18\x8d\x9e6\x1d\x00\xbd9\x91\x02yu\xb5\\\xb8\xb1\xa8\x95\xdb\fo\x17U\x06Bl\xa2\x84\x87%SpQ\xd2\xe8d\u007fwK3\xd6tO`\xc0Q\xd2\xc7}\xcf\n\x165TIw\xe1\xc9t\x97\xfc&\"g\x12\xfe掗\xd4\xe0\xb3x0t\x1e\xa1w\xe9\x85߈܅{\xb29\xf8,O\x94\xf9i\xbc\x1e\xcbQ.\x93\xbe`\x80\v\x88\x85H\xb7R\xb6\x10q%\xb4M\xa7=I\x81\xf9\xdca\x06\xdeEg\xf1I<\x1dY\xd6柂\xcf\xdcڤ\x80\xba\x8a\xb337\x9a\v3C%\x8d\xceo\xac\xf0\xc9S\xc8V\xa5\xb5tum)\x95\xf4\xe9\xdc\xd3T\xd2\xd5j\xffU\xc5WaT\x9cN\xa2\x98\xb5,\xf5K\xf1\xcb2\xf2\xd3\"\x93(\xc4\f\xbc\xa9\xee\x1a\xed\xb2\xce\f\xbc\xf5\x03\xc04\xa7\xa8\x16o\xb9\x13\xd5%\xff|\x99\xab\xcdm\xf4DY\x1d\x96\x8c\xc0MIc\xe2-\x1d\xe4\x12Y\"\x918ڔ\xb0;\x00+}\x1f\v\x165\xf4^\xfa<Zz\xc7 .-1\xb3\x9e\x9c;\xfa\x15\xd0\xfa2\xfaVZ\x87\xce\xcb\xf4\xb7\xae\x06rr1\xb1\x1c\xe5~u\x18\xc0\x06\x9cm\xab\xb9\xa3@.C\\\t\x9f\xce(Y\xd9ޛ\x184\x15\xc0J\x9al\xdbhS\x9b\xbfN\x18\x10/+z4\xa903\x8a\xa4It\xe4G\xe4\xb4W{\xe9\xa5J/\x8d\x16\xb4RI\xf7\xedT\xe8\xe3\xab0*N#Q\xecZ\x96Hn\f\xc5\xf2\xa2dQO\x14A i\xab\xac\xb3\x92\xd6\x0e\x80\xd1\x1cT\x14\u0085\r\xa0\xb5ː\x99dI[\x1d\x96\x8c\xc05I\xc7\x15\x01\xef\x0f$\x8e\x044\xfa-\xa3O\xf9\xeb\x05\x8b:\xaa\xa4\xd7\x16\xe0\xb3Z\xed\x92p/\xd1*\xeb?\xe0T)\xf2x\xb4\x02\xf5\xca\xf4\xbc\xa3'\x17\x13\xcbQ\xaeM\\\x99\x80\x83E%k;\xa3\xd5e\x88+\x01\x9do_R*\x17\xbdj*\xc0|y̮6\xab\x80\x90~a\xc9A\xd2\a\xe9\x148Q\x857\xabR6]\xa8̥Q\xa8\xcc<\x97f\xab0*N#Q\xdc\xce3$\n;Qg!9\xa6F\xa2\b\x02I[e\x9d\x95\xb4v\x00\x8c栢w\xd1A\x1fB\xebR\x91\xb4\xd5a\xc9\bܒt\xa2i\a}ǒN\x9c$t\aN\x9e\xb4\xee\xa6W\xc9}\x82E\x1dE҃\xd3\xf1!\xad\xbd\xa3\x97r\x96\xac5:\x9f;\xe8[I\x1d:+\xd3k?tV\xc7\xc4r\x94/R\x17\x98\x80\xd2\n\"\x8eE\xf8LeK\xe8%\xb7\xbc\xfc=\x94\xdbf.\x81\x9c\\\xed\xa4\xab1Ne\x8b\xda,\x02N\x155\x94\x9c5\x17f\x90\xa0sk*颕tM\xc3\x1c<\xc4V\xa4P^\xa3H:\x96\x171I\x9a\xad¨8\x8dD\xb1k9V-D\x8b\xe8UK#Q\x04^\xd2\rvYg%\xad\x1d\x00\xa39\xa8(\x82\x0e\xfaS\x904I\x94\xd5a\xc9\bܒ4j\xee \xafd\xe0\xad`;\x97>M\a\x89\xe6E\x03E\xd2\xebș\x19Q\xe6h\rx\x1e\x1a+\xaa&C\xafU\xab\xc8В\xac\r\x91\xc1iE\t\x9e2\xf6\xe5*\xa7\xb2\x1eˡ\u007f\xdb3\x01%\xe4,K\x94\x913\x95)\xa1Q~\x97\x04T\x9b\a\x0e\xd5ո\xa5ʌ\x95\x11\x8e\xb06q\xc0`E\x03\xaa\xafN\x98\n3h#\xbd\xe5Y\xf9u\xbcX8\x93ܞ\x91 2X\x9dO\u007f\x97ΫW$\x8dꖙ$\xcdVaT\x9cN\xa2\x98\xb5\x1c\a\xfc\xa7\xfc\a\xc8\x02\x93(\xc4H:\x0f\u007f\xfb$*\xec\xb2\xceJZ;\x00LsR\x90\xb4\x9e(\xabÒ\x11\xb8&\xe9C\x81\x8e\x9ec=-\xea\xddc\x89\xfe\xee@\xff\x19\xcb\xe0\xb5FϼV\xd0I+w\x8f=\xa5\xdc=\xb6N^\x16\uab17\xb7#2\xc1+m\xebZEg\u007f\xb5\xf2\xba\xaeu2\xb9zt8ofc\xc34\xd9\xf7\xe6a.V'q\x80^9U\xe6\xebF@\xa3\xbc\xa4mc\xb9\\\xf8\xea\x01\xb6\x84F9\xbf\xa1\v\a\x98\xef\xbal\xf4\xff\xba\xb3:\xefSr\xa5\xb7\xee\x00\xea\xad\xf3EO\x89k\x13\a\xc4\xf7=;\xfd8\xea+X\xbd/\xce\x14\xc6\x12\x91\x17\x84ެ($+\v墆wq@\x1fY[\xd3\x19\xed\xac\x91;\xc9\xddc\xa1\x18\x8a\xe6\x99\u007f\xc4ҫ\xe0*N#Q\xecZ\x96Č\x9a\x19\xf4\x1b\x88Iԧ\xe4\xee\xb1\xd6h\x94\f0\xaa\xa6\xbf\xba\xb1\xc2:\xeb\xea\x15\xef\x03\t\xd3\x01ЛsxZk,\xe4\xeb\x8d-\xab\xe6\x86+\x83\xfb\xa2Q\u007f]4JO#=QV\x87%#pMҨ\u007fGK`\xebnu\x12\xd7O\xa6\xd2\xcdV\xa1\xa7\xf3j\x05\x8b\x06\xca=\xde%\xea=ޑ\xea\xc2)U]t\xb1o\xc9\xcc\xfc\x8aN\xb2\x94x\xbd,\xaf\xac\x8d\x9es}\v\xa7\x95\xac}\xd3'?\xcb\xc7j\xf4*3\xbdGM\x85%Z\xe7\xf8\xa7/m\x9f\xe3\xabfK\xd8^\xd5X\xe2+\xaaN:u⫦\xe5V\x1f\xa4\xf7x˾\xc3\xe4\xb7S\x8b\xda\xc4\x01\x11\x99\xfcB\xbbJV\xee\xd0\xd6\n\xe3\xe8,\xcf+x\x94ʪ\xa2\xbd\xa14o\xfaB\xf2M\x97h\x98S \x17\xcciL\xd0\x12B\xb8[,2Of\xb4*\xf8\x8a\xd3H\x14\xbb\x96\xa5\xd5\xdfJߙDթ\xb3f\xd2\xe7\xf6U\xe7\xe6\u05fch\x99\x87x\x01\x8d\xf4\xfd\xd9t\x00\xb4\xe6$\x8a\xf0\xfe\xe4\xcby!\xd3\x1c\xfc\xb7j\x15\xf4\xd8뉲:,\x19\x81{\x92N\x83\x17\xe5?\t\x16\x01\x00HfDH\x1a\xfe\xab\x12\x00ReDH\x1a\x00\x80T\x01I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x18I\x92\x86[\xbd\x01\xc0\x11\xf7$m\x18\xe8Ě\x94\xe7\x149\xf8BX\x1b\xe8\x10\x86\xcdF%U\xb7\x98\xa1\xe3\xd8t\xc7\x00\x95\xa1\xda\xf5\xa4it#&\xd5FR\xd2O\xeaP\xf7-\xf3pMҌ\x81ι\xc0\xfe~\xccI\x87-\xac\rt\b\x86\x8d\x8a#i\xfa\xac\xa4f\x95s\x018:\xc08\xedۅ\xda\xf5\xa4it#F\xd8H\xcb\xec\b\x92j\x9fɡ\xee[\xe6ᚤ\x19\x03\x9ds\x81\xa3N\xd1\xc8\xde@\x87\x90\xfa\x03^\xd3\xf5YI\xd1*g\xe88:\xc08\xec\xdbE\xb0\xebI\xc3\x15\xc3\nQ#\xad\xb3\x93\x9cT\xa7L\x0ey\xdf2\f\xd7$\xcd\x18\xe8\xa4&i;\x03\x9d\xf4H\xd7g%E\xab\x9c\x8b\xc0\x10\v\xbb\bv=\x17A\xd2\"\xacw(9\xa9N;?\xe4}\xcb0ܓ4\xd2\rtR\x92\xb4\xad\x81\x8ea\xa3\xc2\xf8\xc2\xe0\xc5\xd6\xfa\x99\xd3\xc8\x13|\x18\xff\x16\vC\x1a\xc3\xf6\x85s\x96\x11\xb9\xc50\xf6,|a\x9a\xf5\x8c\x85\x05\x8f\xd8\xd5\xc5\xc2\x01F\x14\xc0{\xdeh\xa4c\xd7s\xe1F7LR\x11c\xb6#l$\xbfC\xf6\x16<\xe2Lr\xf8W\xd5Ϡ\x15w\xe1\xb8\x17ս0`\xf7-\xa3qQҺ\x81ι@ǖ@s\xd8\xf4\xe0;\x13\xb6\x06:\x86\x8d\n\xe3\vC\x16K66\x96\xe4\x1df\xfd[,\fi\f\xdb\x17\xd6YF\xe8\x16\xc3سp\x85\xe9^/\x16\x16<\x16\xae.B\a\x18a\x00\xe7y\xa3\x93\x8e]υ\x1b\xdd0Ie\xcdv\x84\x8d\xe4Z\xe6`\xc1#\xce$\x87_.\x0f\x85\xcapű}%\xf5\xa7ս0`\xf7-\xa3qQҺ\x81ι@S\xf7ў\x96f\xbb+\xde\xf6\x06:\x04\xedѯ\x86/\f\xf2\x97\xe0\xd1\xfd\xf9\x12b\xe7h<\xe1V<\xc2cm_\x8c\x12\xc4n1\x9c=\x8b^\x18\xe3\xf5\"\xb6\xe0\xb1vu\x11<[^\x1c\xc0\xec\x1bK\x1av=\x17ntc$\x95\xdbcq#\x99\xa7\xf7:Y\xf0Xd\xd2\xc0_\x8aO\x90\xf8\x1cr4\x1bIg\xfe\x94\xf9\x87Lc\xdf2\x1a7%\x8d\xd4\xe7x'\xba\xc9\xc9\x15k\xdam\x13ho\xa0C\xd0\xcf(\xf2\x9coE\xbc\xfe\xff \xafm\xf2ygI\xb3\xb6/z\t\x16n1\x9c=\x8b^\x18\xe3\xf5\x82\x84\x16<֮.\xa9K\xda\xd87\x964\xecz.\xdc\xe8\xc6H*\xb7\xc7\xe2F\xea-s\xb6\xe0\xb1Ȥ\x81\xffE\xf2J\x8f\xe6q\xf90\x8a\xe7\x9b\x1f\x00\xca\xec[&㚤\r\x03\x1dmMx\xabe\xb0\x93\x81\x0eA?\xa3\f\xf1*C\xc1(yb\xbf\x93\xa4Y\xdb\x17=\xd6\xca-\x86\xb5g\xd1\vc\xbc^\x90Ђ\xc7\xda\xd5%uI3{\xc1\x90\x86]υ\x1b\xdd\x18I\xe5\xf6X\xdcH\xbde\xce\x16<\x16\x994`\x8e&\xfa\xd1Z\xf4\xee\x14\U000d78f1o\x19\x8d[\x92f\ftPG\x90.\xee\bZ\x87;\x18\xe8\x10D\x92\xa6\x97ѨE\xad\xe1\xdf\xc2\xf8\xac0\xb0\xb6/z\t\x16n1\x9c=\x8b^\x18\xe3\xf5\x82\x84\x16<֮.\xc9\x0e0\x16\x01v\x92Nͮ\xe7\u008dn\x8c\xa4r{l#iҲ\x14,xę4\xf0\xd3_.\xe9\xd1D;\v\a\x05\x16\x96\xfa\xbee4nI\x9a5\xd0\tn!\x8bg\x02\xfb-\x83\x9d\ft\b\"I\x17\xe1\xb3v\xe0\x8ej\xc4\xfa\xb7\x88\riX\xdb\x17\xa3\x04\xb1[\fgϢ\x17\xc6x\xbd0=\x0e\xe3\x16c\xed\xea\x92\xec\x00c\x11`!\xe94\xecz.\xdc\xe8\xc6H*\xb7\xc7\xe2F\xea-K\xc1\x82G\x9cI\x03\xffL\xe2\x98[J\x8e&\x1a,\xdc9-\xf9\xc1\xfb\xfa\xbea>\xdex\xa1\xb7ÍT\\\x934c\xa0s4\xb0\xed\xd0ѽ\x81\xa0\xf5\x90\xc9\xc1@\x87\xb1Q\xe1|a\xc85\xd2\xf69S\xc8\x06\x8c\u007f\v\x12\x19\xd2\x18\xb6/l\tb\xb7\x18Ξ\xc5(L\xf7z\xb1\xb4\xe0\x11\xb9\xba\x88\x1d`\x84\x01ܾ\xb1\xa4l׃.\xdc\xe8\x86M\xaaa\xb6c\xd5Hc\x87\x9c-x\x04\x994U\\s R5E9\xfc\xeb\ue612|\xba\xe8\xfb\x86Y(/H\xfa{f\xe0\x9a\xa4Y\x03\x9d\x13\x1d́`\xb7\xb5\xa2\x9d\ft\x18\x1b\x15\xce\x17ƿ\xba\xbe`F-=\xffY\xff\x16\x91!\x8da\xfb\u0095 t\x8b\xe1\xecY\x8c\xc2t\xeb\x19\v\v\x1e\xb1\xab\x8b\xd8\x01F\x18\xc0{\xde0\xa4l\xd7C\xb80\xa3\x1b.\xa9\x86َU#\x99\x1dr\xb4\xe0\x11d\x92\xa3\xb4qI\xbeZ1\xb9\x81PtEE\xdb7L\xfb\xf4vA@&\xe0\x9e\xa4\xd3`\xa8\x06:p\xbf\xd10py$5\xe6\xcfLë\x14\x18\x11\x92\x1e\xea\u007fU^\x1eg\x9fǸ<\x92\x1a\x82+\xdbV\x8c\bI\x0f\x95\xcb\xe3\xec\xf3\x18\x97AR\x1b#\xa8\xba\xc1)(c\U00070915\v5\xc0E\xe5rHjL._Yt\xde)*c\xf1\xb0\xa4\xe9\x85\x1a\xe1\x8df\xc0\x90\xb9,\x92ڐ_m\xbe\x11\x1e\xd0\xf1\xb0\xa4\x01 \x13\x01I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x00I\x03\x80\xa7\x18I\x92\x1e\xea\xad\xde\x00\x90A\xb8'i\xc3@\aӳ\xad\xa9e\xaf}\xbc\x83\x81\x0e\x00\x00\x04\xd7$\xcd\x18\xe8\xa0xG`\xf7\x91\xbd\x81C\xf6[\xd8\x1b\xe8\x00\x00@pMҌ\x81\x0e\xea \x9e\x1b'\xe9\xa25N\x06:\x00\x00 \x17%\xcd\x18\xe8\xf4+O\x1d;g\x1f\u007f\xf1\ft\x00\xc0ø'i\xa4\x1b\xe8\xec\x0e\f:\x19\xb99\x18\xe8\x00\x00\xa0⢤u\x03\x9d`\xb0gk\xa0yׅ\x18\xe8\x00\x00\xa0ࢤu\x03\x9d\x16j\xa0\xd3\xdcra\x06:\x00\x00 w%\x8d\xb4\xe7xӾz \xb0\xc7&\xd0\xd9@\a\x00\x00䢤\x19\x03\x1d\xd59'l㶑\x82\x81\x0e\x00\x00\xc8=I\xb3\x06:{\x9b\xa8\xbc;.\xcc@\a\x00\x00䞤Y\x03\x1d\xc5:\xe7\\\xc0\xfa\xf6\xb1T\ft\x00\x00@.J\x9a1\xd0A{\x03{\x8fv7m\x15ش\xaa8\x19\xe8\x00\x00\xa0⚤Y\x03\x1dt(\x18ز\xd7Zю\x06:\x00\x00\xa8\xb8'\xe94\x18\xaa\x81\x0e\x00d\x1e#B\xd2\xf0_\x95\x00\x90*#B\xd2\x00\x00\xa4\nH\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\xc5H\x924\xdc\xea\r\x00\x8e\xb8'i\xdd@g\xb0)\xa0\xd0l\xbf\x81\x9d\x81N\xef\x82\u0082\xaaH\xd9>\xf36\xb6<+\xcb!\xa7\x18\xf2\x88a\xb9\xd4)\xe6\xa2\x11\x99\xbe\xd3)D\xe7l}Q\xee\x02LJ%#T%\x93\xfd\f\xe1\xd7*\xa7P\v,\x12U\x87\x8b\xcc\x13\xfd\xf7z\xaa-\xa3\xa4\x91_-;\x96\x15'\x93\xda1\xf6\x14\xaeI\xda0Љ\x05\xf6\xf6c\xf6*\x0f\xe8\xb7\xc6\xc6@\xa7\xd7\xf7h\xe7\xf6E\xa9\x1e\xbdH\xaf\xf2~*\xeak\xb4\x8f\xa4\x1c\xa8\xf3;\x85\xa4\x88V\xb1\xf5ڮ\xbc\xd4v\x81P]\xd4V\x97w\xde)\n\xa1\xbe\xd5r$\x86bQyuj*H\xc6\"Qǣ\xd16Y\xf4-\x9aj\xcb\x14\x04\xf9\x15'Jώe\xc5ɤr\x8c-j\x1b\xa9\xb8&i\xc6@\xa7\x9b<\xd9d\xa0i\x97\xfd\x06v\x06:5\xd5\xe4\xb5.EI\xff\xdb\x12m\xc9\xefx\xb8\t\x8d\x17K\xd2FŖkS\xed\xdb\x10:/\xb7\xa2\x84\xfd\xb3\xcfUZe\xf2\xa0\x89\x04\x8e\x1f2V\x89:(RV\xea-SHί8Qlv\x84\x15\vq>\xc6V\xb5\x8dP\\\x934c\xa0Cٶ\xc5\xfa\xa9&\x14;\x03\x9d\x92\x06\xf2\xda+w\xa2T(wK\xd2\xe5\xc2sG\xbc֑>9\xd51\xfa\xa5\x96t\xea-SHίsJ.\xa6\xa4\x9dk\x1bQ\xb8'i\xa4\x1b\xe8\x10z\x02'\xeccm\rt\x96\x16\x1d&o]\xb4k\xd8^\x95w\xcfj\xa5\x93`\x165v\xca\n\xe5\xe4\x83\u007f\xed\xea{\xf2j\x8e[\xc5\xe2q[\xed\x8c)\x8bԁa[y^Y\x9b\xb2\xbaoQ\xa1\xafh\xc1)\xb4R\x96\xb7+\x93\xc1D\x91\xefř3\"\xab\n\xaa\a\xd8\xc2Vʾv\xb5\n\xb6\xe2\x81%3|%\v{M\xcd9\x9f'\x1bs\a\xad6\xa6\x04\x86\xc1Be\xb3\xd5\\l\xafO\x96\x1b\xfajKrk\xb8\xceސ\xb4Q\x18\xd7^\xa39\\\tњ\x12_\xe1\x82\x12R\x84\x91(#\x96\x90\xac\xac\xb4Z\xc6\xe5W˙8Q|v\x8c\x8a\x99F\x1a\xb0\x8d\xf4\xaf\xaa\x9f1m\xa12\xe70\x92\xaa\x1d7\xfe|\xf0\x04.JZ7\xd0!\xb4t\xd8\xc6:\x18\xe8\x1c/\x91k\x1a\x0f(\xdd|\xbd\xbc\xaa\xabuzy\x82_\xd4\x19\xd8\x17\x9dS\x1d\x8dF\xffL>\xf8\xe5\xd2\xd0\u03a2E\xa6\xcd\f\xfa\n\xeei\xdfY#\xd3S\xae\xce\xdf\xd0\xd5\xe0\u007f\x8a,F\xf2\xcb_\x8d4b\x89(35:\x19\x8c\x14ȫ\xab\xe5\u008dE\xadla\u007f\n\xf9\xe4鍿\xce_\xc4W\xdc%\xd7GB\v僦\xe6\xf4F\xa3Z\x9f\xa2\xd7Ɣ\xc0\xd2\x1b\rɍ\xd1\xe8i.6\x1e\n\x95\xccɟ\xb9\xbaV\xe6\x12dH\x9a)\x8cm\xaf\xd1\x1c\xb6\x84\xdf\xcaO\x85\"\xed\x852I\x89\x91(#\x96 \xe8,\xd3i\x19\x9b_=g\xe2Dq\xd91*f\x1bi\xc0n\xe6\x97\xcbC\xa1\xb2<\xf2\x9d\xaf7\x879n\xdc\x01\xf0\x04.JZ7\xd0\xc1\x1c\xa13k\x1b\x1c\ft\xceo\xac\xf0\xc9S\xc8wx\x97\xfc&\"G<\xc4-r0\x03\uf8b3\xf8\\\x9a\x8e\xacb\xab\xe6\xe0^#QFN\xb9w\xe5\b~\x8d\xc8]\xf8\xfc,\xa9\xc1\x1a\x19\f\x91\v@\xf4$\xa3#ǢZ\\\xc8NTW\xcf\x17柂O\xe2\xda\xe9|ű\x10\x19\x0e\x94-\xe4\xd7\x12r\x95\x93\x96\xa9\x8d+\x81A\x1f\u07b2\xb1\xa8\\\xa6\xdd.\x17\xc9\x0e\xbc\x8d\u0098\xf6\xf2\xcd\xd1Jh\x9bNt\xd2V@%\xad'\x8a\x8bu\x18x;\xb6\x8c\xc9/w\x00ĉҳ\x83\x8c\x8a\xd9F\x1a\xb0\x9b\xf9K\xf1\xde\xc7\xe7T\x98\x92\xaa\x1f7\x18x\xb38\x15\xeeL\\\xed\x9d;Z\xec\xe3R0ЉG~D\x0e\xd6\xd2;\x06\x13\x98\x99\xf5\xdc\"\a#i\xf2'z`\x85\xb1\xe7\xe5v\xf2\xd6@\x02\xea\xcb\xe8\xaa\xd2:r\xf6\x19\x97H\x19I\x87\xf0y6\x80\xd6.\xe3\v\xa3\x8f\x1dO:wζ\xd5\xdcQ \x97\x99\xd6\"\xfd\xa4ej\xe3J`Ѕ\xc3Ƣr\u007f\xb2\x05 'i\xbd0\xa6\xbd|s\xb4\x12>\x9dQ\xb2\xb2\xbd7A\xc7>F\xa2\xb8X\aI;\xb5\x8c\xcd/w\x00ĉ\x12I\x9am$\x03\xb3\x99\xffE\xf2\xda&\x9f\xe7\x93\n\x92\x16\xe2T\xb8\x1d\x8c\x81\x0e\xa6\xc9\xfa\xb1\xfc\x14\a\x03\x9d\x83\xf4rY\xa2\n\u007f-\x97\xa9s#~\x91\xc3ty\x8c\x1eXal\xaf\x1cEZ@գtգ\x15\x9aD\xcc%\x14\xbd\x8b\x0e\xfa\x10Z\xb7\x8c/Lx\xee\x1c,*Y\xdb\x19\xad\xb6\x964S\x1bW\x02\x83.\x1c6\x16\x95\v\xe6\x84m\xf2\xdf\xf1kL&\xb3Ha{\xf9\xe6\xe8%\x9co_R*\x17\xbd\x8a\xb8\u0378X\aI;\xb5\x8c\xcd/w\x00ĉ\x12I\x9am\xa4\x01\xbb\x992X\x8f\xe2\xafa\xab\xa4\x82\xa4\r\x9c\n\xb7\x815\xd0!~\x1bG\xec\xc3\x1d\ft\x8aVҷ\x869xPyG/\xe5,\xb7\xc8A\x0fa;\xe93\x8c\x03+\x8c=KU\x80\xe8\xe5\x9b\xfa;誒:2t3\xf5Ҵ\x9b)\x8a\xa0\x83~E\"laI\xe7\x0e\xa9\xb8\xb4\x82\f\f\x17\x95\xf1k\tZ/m\xd4\xe6(i6\x16\x95\x9b\xe6܄(m\xaf\xa2\x1fF\xd2F{\xf9\xe6h%\xf4\x92\xdby\xfe\x1e\xca\xe5\xbf\t\xb8X\xa7^ڡel~\xb9\x03 N\x94H\xd2l#\r\xd8\xcd\xfc\xf4B];\x1e\x90$%\xb5\xc1tX\xbc\x81[\x92f\rt\xc8TZ\xbbL&\xc6\xc9@\xa7p&\x99\xd7&\xc8Y\x13Qfc\r\x1b\xb9E\x8e\xeaj\\\x8c2\xd1\xd5\xcfTqlE\t.\xb7/\x97\x04tр\x10\x19\xdbNJ\xaa\xc9@o\x15\xb9\ue7b7\x16\xd7[a\x92\b[\x18+H\xbd\xe2\x12rz'\xca\xcaL\xcdA\xfaI\xcb\xd4\xe6(i6V\xd8\xe3\fL#\xe3\x9a\xfai\x03\xc8B\xd2\\s\xf4\x12\x1a\xe5w\xc9[u=\xb7\x19\x17\xeb iǖ1\xf9\xe5\x0e\x808Q\"I\xb3\x8d4`7\xf3\xcf$\x17>J\xab\xf9\xe6\x18\xc7\xcdt\x00F>\xaeI\x9a5\xd0A=\x01;oig\x03\x9dB\xb9\xa8\xe1\xdd\xcejz\x93\xe0:yY\xa8\xb3^\xde\xce/\xb24\xfa\u007f\x8dc?%\xd7=\xeb\x0e\xa0\xde:_\xf4\x94E\xecἙ\x8d\r\xd3dߛ\x87q7\"\xaf\xebZ'גՑ\xdcҶ\xaeUt\"X5\xfdՍ\x15$\xe0\xf0\xb4\xd6X\xc8\xd7\x1b[V}\x9c)\x8c\xabB\xaf\x18\x9f\x88K\xda6\x96˅\xaf\x1e`\xd7\x0e\xee\x8bF\xfdu\xd1(I\x89^\x1b_\x82\x8er]\xf9\x00\x9d\xb5豉\x03\xf4\xeamҥ\x86\x90\xfclW=9g\x99\xc2\xd8\xf6\x1a\xcdaKh\x94\xf3\x1b\xba\xf0^D\xb860M\xff\x94\xdc\xc4\xd5\x1a\x8d\xf2\xfd[:-c\xf3\xcb\x1e\x00Q\xa2\x98\xec0\x15\x1b\x8dda\xf3\xeb\x97k\x0eD\xaa\xa6\xf4!\xee\x10\xeaǍ\xad\xcd\x1b\xb8&i\xce@\xe7\xc8\x16\xdbPG\x03\x9d\x8a\xf6\x86Ҽ\xe9ꏏ\x91\xea\xc2)U]\xe6E\x86\xf8\xaai\xb9\xd5\a\xe9\xfd\xbf\xb2\xef0\xf9\xb9\xf3Y\xabؾ\x85\xd3J־\xe9#\x01\x89\xd7\xcb\xf2\xcaڔ+\x00}Kf\xe6Wtҥ\xea\xdc\xfc\x9a\x17e\xb9\xbeH\x96C\xf9r^H\x99\rj\x85\xf1Uh\x15\xa3D\xeb\x1c\xff\xf4\xa5\xeds|\xd5\xec\xdaߪ\xd3I\xf2U\xa1\xd7Ɨ\xa0\x11/\xa0\x91>\xfaӋ\x1e۫l\xff(2\xd3U\x9eWNv\xcd(\x8ck\xaf\xd1\x1c\xb6\x84\xedU\x8d%\xbe\xa2\xea\b\xdf\x06\xa6\xe9uj{\xb9\xee7\xbd\x961\xf9e\x0f\x80(QLv\x98\x8a\x8dF\xb2\xb0\xf9-m\\\x92?\xa3V\xb9\xd8b\x1cB\xed\xb8q\x87\xc5\x1b\xb8'\xe94\x00\x03\x1d\x00H\x95\x11!i\xf8\xafJ\x00H\x95\x11!i\x00\x00R\x05$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9e\x02$\r\x00\x9eb$I\x1an\xf5\x06\x00Gܓ\xb4n\xa0\x83\xd0\xc0\xae-\x81-\xbb\x06\x1c6\xb03\xd0ѹ\xf4\x86)\xe9x\xde0\x88Mf:\xc9\xff\f\x92'\xd8\x1a\x8e@\x89\x869\xd3|\xd3\xeei$O'\x91\xab\x12\xd4\t\xc7\xf4\xbf\x84Cm\x83\x90\xce\xd2ܲPy\xd2\u007f\xa4ړ\x86\xa5\r0̸&i\xc3@\a\x9dk\xda\xdas\xb4gK\x93\xfd\x93M\xec\ft\xd26Ź\x88\xa4\xe3y\xc3 6\x99\x19\xd8\x17-Xt\x98s\x04\x8a\xc8\vں\xda\x17\xcaQ\x14\x8fȹQ\x14\v\xc9\x11\xf3\x03#\x84m\x18\x9a/\xcc\xebrm\xe7Z9\xdd\xc7\xf8\xa7ai\x03\f3\xaeI\x9a1\xd0\t\xb7\x90\xe7\xfe\f\xb6\x84m7\xb03\xd0I\xdf\x14\xe7\"\x92\xba\xe7\r\x83\xb5\xc9L\xe1Z\xc49\x02\xad. \x02\x8eOYM\x9e\bX[\x87\xd0\xc7r\xf2v\xa26\f\xc9\x17\xa6On\xc0\xaf\xabӕ4J\xc7\xff\x02\x18V\\\x934c\xa0ӱ\x95\xae\b\xda?\x9d\xdf\xce@'驟\x97=\xd6&3TҌ#P5}\xbe&\xaa\xa8!\x92\x8e\xe4DŽ\x92\x161\xa4\a_>5\x9d|\x81\xfcI\xe6\x1fϗ\n \xe9\xcb\x04\xf7$\x8dt\x03\x9d3M\xe13\xf13\xe1\xa63v\xb1v\x06:\xe9\x99\xe2\xe8\xf67HhSC檍\xa8QV&\xe5Z\t\x16\xce2ix\xde0\x01\xbcɌ\t*i\xc6\x11\xa8Jy\xb2\xe6\xa2*\"\xe9\x8f\xcbCI\x926\xda`a\xd7\xc3y\xff\xe8\xf0N8\x1a\xd3\xd6ҷ\u05cf[l\xc6fG\xe8\xa5\xc3x\xd3 \xab\x03\x00\f'.J\xda0Љu\xe0\xa5\x0e\xfb#og\xa0\x93\x96)\x8ea\u007f#\xb6\xa9\x89E\v\x1a\xfe\x86\xfe\xd6P\x10\x8d1%X9ˤ\xe1y\xc3X\xf0\xb0&3f\xa8\xa4\x19G\xa0\xb2et\xf5\xb22*\xe9\xd6\x05ɽ\xb4\xde\x06\v\xbb\x1e\xd6\xfbǀw\xc2QQ\x1f\x96\xaf ڌ͎\xd0K\x87\xf1\xa6\xb1:\x00\xc0\xb0⢤u\x03\x9dxGKO\u007fOK\x87\x9du\xa5\x83\x81N\x1a\xa68\x8c\xfd\x8d\x85MM\xfdR\xfc\xb2\xac\xde\\\x82\xd0Y\x06\xa5\xeey\xc3\xd9\xc98\f\xbc\x19G\xa0R\xe5\xf9\x89\xb5\xa5TҧsO\x8b\x06\xde\xda\xd3p\x85v=\\\xc5:&o\x1a\x85\xc3\xca\xc5\xf4x<n\xb5\x19\x93\x1d\v/\x1d\xe3\x01\xc1V\x0eF\xc0p⦤\x91\xfa\x1c\xefp\v\xbd\x00\xd4bg0\xedd\xa0\x93\xb2)\x0ek\u007fcaS\x13ɍ\xa1X^\xd4\\\x82\xd0Y\x06\xa5\xeey\xc3\xd9\xc98I\x1a\xe9\x8e@j/\xbdT\xe9\xa5тV[I3\x15\xeb)\xe1*6\xe0\xbdi\x14\xfeN{\xe9e\xf4w2\x8b͌\xecXx\xe9\x18\x92\xb6r0\x02\x86\x13\xd7$m\x18\xe8$\x02\xfb\xb5E\xcbh\a\x03\x9d4LqX\xfb\x1b\vG\x95Da'\xea,L\x98K\x10:ˠ\xd4=o8;\x19\aI3\x8e@UJ\xf3\x17*si\x14*\xb3\x954S\xb1\x9e\x12\xaeb\x1d\x937\x8d\n\xad\xfdt\xa7\xbc.n\xb1\x19\x93\x1d\v/\x1d\xa7\x03\x00\f/nI\x9a1\xd0\xd1$\xfd\xa1\x8d\xa4\x1d\ft\xd20\xc5a\xedo\xacljV-D\x8b\xe8\x158\xde\xd5E\xe4,\x83R\xf7\xbc\xe1\xecdD\x92NЉ/\x15\x15\xe3\bT\xad|\x93\x94\xd7(\x92\x8e\xe5Eґ4I\tW\xb1\x8eɛF\xe5\xa9\"\xf2\x85\xd7I\xae4\x887c\xb2c\xe1\xa5cx\xd3X9\x18\x01É[\x92f\rtv\xa8\x03\xef\x1d\x96\xc1N\x06:\xe9\x98\xe20\xf67V65\a\xfc\xa7\xfc\xc4\a\x83/A\xe8,\x83R\xf7\xbc\xe1\xecdD\x92n#\xaeUg\xe5\xd7\x11\xe7\b\xb4:\x9ff'\xaf^\x914\xaa[\x96\xa2\xa4\xf5\x94p\x15똼iT\x94ߥ\xab\x89\xa4ś1ٱ\xf0\xd21\xbci\xf8\x03\xf0\xf1F\xb8\xbd\xecR\xe0\x9a\xa4\x19\x03\x9dXsK\xf7\xb1\xee\x96f\xebK\xdeN\x06:\xe9\x98\xe2\xb0\xf67\x1665\x89\x1953\x94\x11\x83^\x82\xd8Y&-\xcf\x1bƿ\x855\x99a\x1a&/\b\xbdYQH\x9c\\\x18G\xa0\x88\\\xd3\x19\xed\xac\x91;\xc9\xddc\xa1\x18\x8a\xe6\x99$m\xb4\xc1®\x875\x8e1\xe0L|\fZ\xe5\xfa\xaez\xe5\xee1\xe1fLv,\xbct\x18o\x1a\xee\x00,\x94\x17\x98\x8b\x02\x86\x01\xd7$\xcd\x1a\xe8\xc4\xf7l\tl\xddcm\x8b\xe5h\xa0\x93\x96)\x0ec\u007fceS\xd3\xea\xd7\xee\x9e\xd2J\x10;ˤ\xe3y\xc3\x04p&3\f\x9d\xe5y\x05\x8f\x1e&K\x8c#P\xa2aN\x81\\0\xa71\x81\xc5M~\rNT\x14\xf1_\x05F\x1b,\xecz8\xef\x1f\x1d\xceć\xa1\xb34\xaf\xa2\xab\xa4\xcbj3dd\xc7\xc2K\x87\xf5\xa6a\x0f@\xfbt\xe6\a2`\xd8pO\xd2i\x00\x06:\x00\x90*#B\xd2\xf0_\x95\x00\x90*#B\xd2\x00\x00\xa4\nH\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\xda]6_0N5\x00\x19\x06H\xda]\x9c\x04\xeb\x8cS\r@\x86\x01\x92v\x17'\xc1:\xe3T\x03\x90a\x80\xa4\xdd\xc5I\xb0\xce8\xd5\x00d\x18 iwq\x12\xac3N5\x00\x19\x06H\xda]\x9c\x04\xeb\x8cS\r\x97\x92K\xfbD\xa2K[ۈ\x01$\xed.N\x82uƩ\x86KF\u007f\xe5u\xd2\\\x84\xe6I9\xf3{\x9cb/\x1c\xb56 \t\xefK:8\xf9\xa4Sȥ\xe1\xcc\xe4`\xf2J'\xc1:\xa3\x16\xe4\xfan&&N\ft\x1c%\xffa\x17\x98\x983@W\t\xf7\xf8\xe2\xa0\xd5\x06$ឤ\x19\x03\x9d\xc4\xfe\xad\x81\xad\xf6\xdf\xec\xff\xbb\xe1;\xb3\x9f\xfe\xc26D\xcc\x1ai\x85\xbatd\xb44\xd164\x897\x8a1_\xff\xfe[_:\x05j|2\xab\xf8\x01뿮\x19\xf5\\ҺoK\x84\xeb\xff\xaf\x93pu~v\xa5t=\xb7B-[\xdfM!\x1d9C\x12י\x1f\xe4dߞ\xe2\xf8\xb6[ڦ-\x86%\xe595\xc2=\xbe80\xb5\x01<\xaeI\x9a1\xd0I\x04\x03\x1f\x1e\xd9\x1b\xd8k\x17\xfe\xe4}o\xbd0\xfb3\xbb\b1\xebG5\xe9˻+\xb3l\"\x05|\xf6\x9b\xe2\xb7?z\xff\xf9\xe2ל\x025\xbe\xfc݆;m\xfe\x1c\xbcb\xbdy\xd5+ߖ\x1e\xfc\xc9\xe37KwY(8\x99\x9f\xdcr%\xf7\x99\x16\xc3\ue988`\xf6\x96\xe4\x95;l3N\xb8\xed\xba\x97*\xb3\x1d|\x8d4\xf6Hacq\xb7\xba$\xd8\xe3\x8b\x03S\x1b\xc0㚤\x19\x03\x9d\xfd\x813tŀu\xf4g\xc5o\xa0/\xfea\xfdw+\x8e\x8c^\xcc|Z\x91\xaa\xa4ONUF\xb1\x1f\x14\xff\x11\xebtC\xf1_\xec\xc3\x19^\xb3\x934Z\x9ee\x1e+n~B\xfa)\xd6\xe5\xad\xd2\xcf\xc4\x02\x16\xf0\u007f\x92%\xcd\xef\xa6\bQW;y\x9e`%\xcb\x19i=J\xd8\x1c\x15\x0eC\xc7\xecb\xf2\x1e_\x1c\x98*\x00\x1e\xd7$\xcd\x18\xe8\xa8\xce9M6\x9d\xc6'\xc5\xefY\xffц\xca\xeb\xd832eIwK\xdd\xf4\x9dJ\x1a}~\xf7\x06\xfbp\x06{I\x0f\\WiZ\xa3J\xfa\x97W\xdd*֯\x00\x81\xa4\xf9\xddL\x95IN\x92>$\xa51\\\x17K:y\x8f/\x0e iKܓ4\xd2\rt\xb6*c\xa8\xa0\xd5\xec\xe8\x8b\xef\x14S^FhCq\xf1;\xea\x8cuC\xf1\xac\xb7^~`\xf6\xd3\xffCc>y\xe6;\xb3\xeeS\x97\r\xe2c\xb5ޫ\u007f\xfe\xb8\xab\xbf\xa5\x0e\xbc\x9b&gOxD\xd1\xc0\xa1o匾\xee\xf6~n\xa3\xf5\x13\x82=ROp\xc2K\x9a\xa4ц\xef\xe0\x97/\xdf\xfe\xf1\xdd\x0f\xbc\xfc\x99\xd61\x82\x00\x00\x0f\xfaIDAT9\r1j\xfb\xf2\xad\xc7f?\xfc\x06\x9dl\xff\xcf\xf3\u07fd\xf7\x19e\xe0\xad\xc7\xfeqVq\xf1\xa6O\x9e\xbf\u007f\xf6\xd3\xff\xa4\x1b.\xcf6=`M\x95\xf4\xe6[ǐ\xd7\ao\xbc\xea\xfao\xfc\x92*\xf5g7\x8f\xb9r\xccW\u007fN\x16\xbfw\xc3U7|\x8f\xae\xfc\xf9\u05ee\x19s\xb3:\xf0\xd6b\x91\xb1\x9b-xZ\xbe\x02\xad\xc0\xaf-l\x1d\xe7\xb2%iT3Y\xfa\x814:\xf0Ȅ\xec\xdbq\xcf\x19\x94\x14&\xd1\x10-%\xfb\xaf\x90\xa4\xe5\x87\xe6\x8fϾ}0\x9e\xa3\x04<BJ\x987n\xf4\xb8\xb9\xea\x04\x99\xc9\x19\x93I<\x81\xd6E\xd6͌\x8a\x93\xf6\x18\tkc\x16q\xc0K\x93\xb2'\xe1\xf4#~-K\x18$m\x85\x8b\x92\xd6\rtv5\xd1g`\x06\x04\xd3=\x85?|\xf4N\xf1k\x1f}\xf4W,\x9b\x8ff\xbd\xa6\xceX\xff\xfb\x9dY\xc5\xf7\xbd\xf6\x9b\xbb\x9f!\x11\xffy\xf7c\xbf\xf9\xe05<:\xe7٫\x9d[\x87\xc6N\b\x04o\x93\xa8\xa4+G=\x14\\\x9f3\x89\fE\xc3c'\xad\xe9X!\xad\xe16\xea\x9f/M\x94n\x92\xe6\x1d\xd3%\xfdV1\x1e\xf3\xbfP\xfc\xf2\xfbo\xdc\xf70\xb9D\xc7\xd4\xf6\u009d\x9b\xde\xdft\xe7\xf3x铻\x1fx\xfb\xbd\xa7\x8b\xa9\xa4\xf5\xd8\xcf\xdfy\xe7\xfe\xef\xdf\xfdݗ\x9f\xff\xfa_iٻ\xccg\xa2&\xe9\xefIX\x9d\xb7H\xb7>\xfe\xbd17\xfc\n\u007f\xfe\xc9U7|\xfb\x89\xbb$\xa2\xe4[\xae\xbc\xeb\U0007bbbc\x85\xc8\xfc\xaa\xeb\x1f|\xfc_%*i=\x16\x19\xbb9\x10\x1e\xbb\xfc$:\xb9\xfc\xea0\xdfi\xef\r\x87\xb3\xe8ճ\x9e\xe6+\xa4\x9c\x15k\xc6~\x8bxz\x87'L\r\x87\xc3\xf4\xaa\xa4\x9e\x92XK\xf3W&\x8c\x1d\xf7\xc8|\xe9(\xda\x1fn\x96V\x84\xc3D\xbbA\xa92\xdc2w\xd4\x1e\x12\xcb\xe4\xcc\xc8\xe4\xe0\x89\xf0\xe4\xab\xf5J\xe39\x93w\x1dS\x87\xfaI{,\xae\x8d\xad\x18Uf-\x0f.Ϛ\x8f\xb8\xe60\xf0\xb5\x01<.JZ7\xd0\x19h\n\x9e\x8c\xf5\a\x03-֡\xc6\xc0\xfbNr\xadJ\x19\xde\xdey/\xee'\x9f\xbf\x0f/}~\xffӸK\xfc\xe2\x1d\xf3\xf5\xb3\xa0tDY\x98:\x9e\\\x86\x9b\x94E\xd7\x05\x10\x19\xb8\xe1n+6\xee\xf68yڰ\xd9_o\xdbhi4\x1d2\xa8\x92~\x1fO\xa6\xdf+~\x1b/\xfd\x1e\x0f\x12\xd8\xda\xde/\xfe\x80\x86\xbd\x8fЏ\xbfOV>LZ\xc6\xc4\"\xf4p\xf1\x93\xff@_\xaa\xd7\x01\x8eJ\xa6\xef-M\xd2O\xe0\xc9\xf4\xe3҃x\xe9ߥ\x1f\xe2\x81\xf85\xff\x8a\x85\xfd\xcb\x1f\xbeB\xfe\xf2\xc4f\xf5\xf5\xc6k\xb1\xee\u007fu\x03\x91\xb4\x11\x8b\x98\xddD\x95d,=O0\xd6\xcdV/\x88g]\x8d\xc51?\x87.\xeb\x03o&%x\xadt\x1b>&\xf4\x9a\x98>\xf0\x1eh!\x02\xba\x89\xfc\x0e\xcc\xe4\x8c\xd9l.\xeeΙA\xfa6\xfc\xf1\x9b\xcab\xd2\x1e[֦/n\x93\xc8L\xacC\xb9\xa6\xcd\x04\xe8\x98j\x038ܔ4R\x9f\xe3\x8d\xce\x04q\u007f\xbd;hs\x94Ē~A[|\xbf\xf8\x0f\xc2Ͷ\xaa\xe7\xfa9z\x16\xa1\xe5D\xd2\xf3\xc6\xc7\a1\xe3*ɹ\xb3_\xb0љGF\x8f\x93\xc6e->\xa3K\xfa\xed\xe2\xcf\xd0\xf3\xf7\u007f\xf1O\xccw_\xe0j{A\xf9\xcd\xea\x81\r\xe8\xb3\xe2\xb7\xc8\xd2&\xd2\x1c&\x16K\xfaο\x1ae\x1fUNd\x03M\xd2\x0fJ\xafl\xbe\xf9\xda_\xfe\ns\xcd-\x9b\xb5\xb5\xb4;V~\xb3\xba\xfe\x96ͯ\xd0N{\xf3]D\xd2F,2v\x13w\xa1\xd9\x03h [\xf0@t]\xd2D\xee\xea5\x05]\xd2LJ\xf0Zゖ1\x97>\xf9\xd2\xed\xe3\xc7J7!.g\xccfG\xb7\xe9?Fc\x06rƯߡ6)i\x8f-k\xd3\x17+o\xa2o\x13\xcd\x01:|m\x00\x8fk\x926\ft\xc8[\xecL\x025\xd9xb\x89%\xad/\xbeQ\xfc\xb9p\xb3\xdd\xea\xa8O\x1d\x99\xd2Sy\x92:\x89\xc4]\xcezI\xf4\xe8\xf059\x01<\x97^\x9f\xf3\x9c.\xe9_\xdcM:[\x85\xa7\xb9\xda~\xfc4}{\xfa1\xdc'\u007fD\x96hs\x98X\xfc\xe11\xa6\xec=\x92i'5\xf1~\xe3\xaa͛oP[\xf6Uu\x1c\xaep\xe3W\xe9\xdbWo\xdc\xfcS\xe9'\xba\xa4\x8dXd\xec&\x1e\x92\xe6lE[s\x12(\t]\xd2\xe4\xdd,i&%\xf8\xc3$}#]\xd2{\xae\x1b\xb7xk\xf86\"5&g\xdcfxv\xbbG\xfb\xc3\x1eɰ\nO\xdac\xcb\xda\xf4ũJ\a\xff\xcdɦ\x00\x16\xa66\x80\xc7-I3\x06:\xf8D$K\x87\x02\xfcU*\x0e\x93\xa47\x99$\xfdA\xf1\uf15b\r(SHtF\"\x17[\x10\xbd<6\u007f\xfc^\xcaI2\xb6\xfbP\xb4U\x9c^\xf1&\xf3{E\xd2_\xdc\xf7\f\xe9y\u007fO\xf9\x8c\xab\xed\x85\xfbɕ\xb1/\xef\u007f\x01\xfd\xaf2\x91\u007fA\xe9\xa5\xf5X,\xe9g\x98\xa2W\x8c6\xfdʫ]\xf1\x1es\xf3\xe6\xcd_\xbb\xf6\xa7\x94\x9f\xf3\xbd\xf4\xb5\xf4\xedZ\xbd\x97\xa6\x97njXd\xec&桹h\xeeC(\x19KI\a\x8er)\xc1k\xbf\xa5o\xa4Kz\xe2d\xd2'~\x8bH\x9a\xc9\x19\xb7\x99\xc5\x15\xef\xe4=\xb6\xacM_\xac\x1cO\xdf\xc6W\x9a\x02X\xe0\x8a\xb7%nI\x9a5\xd0\xe9\t\xe0\xa3{\xae\xd9\xee\xde\x01Cҳ\u007f\x815\xf6\x98I\xd2\xff\xb8\xefIr\xd9\xea\xe5\x97\xcd\xdb\xcd\x1b\xaf\xf4X\x93\xc7\xe1a\xf4\xa1,r*w(\x97\x83\x97?G~a\x99J\x84\xfbP\x92\x06\x8e]}\x8c\xbe+\x92\xdeD$\xfc\x8123\xde\xf4\x1b\xae\xb6\xf7\xe9\xdaw\xc8\\\xfa\xb1\xfb\xb1\x82\xff2[\xf9\x86\xd1cyI'&~\x13\xf1\xa8⽋\xbc>Af\xd1x\xf9ۛ7\xbf2\xe6_H7}\xeb7Ȭ\x99\xac\xfd\xa1\xf48\uec2fy\x85\\##\x926bI)\xdan\xe2\x0e;\xab?Kt\xb2\x8b$=u*B'H6\x98\x94p?m\xe9\x92\x1eGt\x95\x98D$\xcd\xe4\x8c\xdb\xccB\xd2\xc9{lY\x1b3\xb5'c\xf5f\xa5r\x8b_\xda@Җ\xb8&i\xc6@\xe7P`ϱ\xfdMA\xebɑr\xc5\xfbw\xf4~\xd0\x1f\xdf\xf7\x9b\xd7\x1e+\x9e\xf5\xf6\u007f\xff\xf5\xa3Y\x1b~\xf7\xe5\x1f6\xcc\"W\xc2\xffs\xf6\x03o\xbd\xff\xb22\x9de94J\xb9\x9aݝ=n\xc5\xf2\x9cQW\x90;[\x16K\xf3Z\x82\x95\x12\xb9\xddjG\xd6ė\xb6=\xa4L\xb4\x05pw\x8fm\xfa\xfa\xf3\xef\xbc\xf7\x02\x15+S\xdb\xf3ś\xde\xdbTL\xaex\xffq\xf6w_\xdbt/i\x19\x13\xfb\xcf\xff\xfa\xe8\xfbO~\xf4\xd1'j\x81k$\xf3o\xef\xf4\xee\xb1'nQ\xee\x1e\xbbK\xfa\xda\x0f\x1f\xbf\x85^\xf8\xfa\xc9U\xd7\u007f\xef\x89[%r\xa3\xe8פ\xbb\x1e\xc7\u007f\xc1K?\xbd\xea\x9ao\xdf5F\xba\xf2\xc1\x9f1\xb1\xa4\x14m7\xb1\x84\xc6\xdd>\xce<\xee\x8e\xef\x0e\x87\xb3*\xc3\xe1s\xa8?<\xbar7\xda[9\x9a^\xc7^\x91\xb5f\xebm\xd9\xe4\xcbKO\xc9\xe0nz\x1d\x9c\u0383\x95+\u07bbIi+\xa4y/=7I\xcaY\xb3\x9b\xcb\x19\x93I2\xb9\xd1G\xd8\xc6D@\xb0\xc7\xe2\xda؊\xd1\xfcQ\x8b\x83\x8bG\xcd7\xad\xe5؛4\x9e\aT\\\x934k\xa0\xf3aK \xf8\xa1`\x02\xa8\xf2\xf9\xbdtf:\xeb/\xe4\xc3'Oξ\xfb\xe9M\xc5\xc5\x1b6\x90U\u007f\xb8\x1b\xbf\x92\x1bA\xfe\xf2\xccw\xef~\xec\xbd\xe4m\x97g)\x87\xfe\xd0ܜ\xf1\x8b\x03WH?\xc0\xcb\x1d\xb7\xe5\\=U\xf9\x11\xfcмqc'oM\xdeL\x81\xde\xe3]|\xbf\xfaE\xf1\xc1\x93߹\xf7\xc7\xef\xd3E\xa3\xb6/\xdexx\xf6\xc3o\xd0/\x9bO\x9e\xbe\xf7\xfe_\xbc=\x8b6G\x8b\xfd#3\xa9&\x17\xaf\x92n\xf2R\xee\xf1\xbeV\xf9\xd9y\xf3\x13\xff2f̍O\xd0ş\xdd|\xcdU7>N\x96~E\u007f\x97\xfe\x15]\xf9\xd51\xd7~\xe3\xc1+\xa5[\x99XZ\x8c\xb6\x9bx\xae\x9b\xc5\xff$\x87\xd93J\x99\xbc\x06\xd0\x0f\xf0\xeb\xe8\xeel\xfcJ\xf2\x10\u007f('{\xaa2%\xd5R\xb2_\t%=k\xfcj\xbax\x05\xf9\x95+\xb1fBVμ\xc0\xf8Ѹ_gs\xc6d\x12\x9d\xb8b\xde\xfe\x13\xf8 \xc6\xfb\xf7\xce\xcb\xd2\xe6P\x82=\x16\xd7\xc6,\xe2\xea\xd6ߔ}\xd3K\t\xd3Z\x0e\xad6 \t\xf7$}\x89xht\x8bSȥ\xa2yt\xa5\xf9\x8e\x89\x8b\xf6\x9fX\x97\xc1nn\x9dH/y͕\xa4\xafh\x17\xcaE{|\x91Pk\x03\x92\xf0\xbc\xa4њq'\x9cB.\rg\xae{.y\xa5\x93`\x9dQ\v\xba\x1cv\xf3\xc4~\xdc;\xf7\u007fxL\xfb,\xdc\xe3\x8b\x06\xad\rH\xc2\xfb\x92\xbe\xbcq\x12\xac3N5\x00\x19\x06H\xda]\x9c\x04\xeb\x8cS\r@\x86\x01\x92v\x17'\xc1:\xe3T\x03\x90a\x80\xa4\xdd\xc5I\xb0\xce8\xd5\x00d\x18 iwq\x12\xac3N5\x00\x19\x06H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\x1a\x00<\x05H\xda+\xc0\r\xcf\x00\x05$\xed\t\xc0N\x06\xd0\x00I{\x01\xb0\x93\x01t\\\x95tw@\xfd\x97\x9d\xfe`\xa0Ý{\xf0\x19g\x19\v\xb7\x18{S\x9c!\x13\xbc:\xf5\a\xe2i\x8d\xac\x94$)\xfb\x90 \x00\xecd\x00\x1d7%}.\xb0K\xf9\xef\xf9c\x81\xf0\xa1p@\xff\a\x9eK\t\xe3,c\xe1\x16\xe3`\x8a3T\x16KN\x06\x19\x06Z#\x8f\x86\xc3/\t\x9f\xe6\x01v2\x80\x8e\x9b\x92\x0ev\x1c\xa3\x92N4\x93\xff\xdf\xdf\xd5\xec\xca\x05\x1e\xbdRk\xb7\x18{\a\x8d!\xb2\\Z\xee\x14b`dF\xfc\x80\x1exl\x0f\xa0㢤\xbb\x9b\x06\xfa\xa9\xa4{\x02䡓\xd4\x1e\xcbE\xac\xddb\x86E\xd2+\xec\xad&\xad\x00I\x03\x0e\xb8'\xe9s\x81CH\x91t\x872\x11\xdc&x\xfc\xf4\xf0b8˰n1,\"S\x1cda\xd7#r\xcd1\x1b\xe8\x18\xacQ<>\x8e\x8eU*\x96Ʋ\xf3\x0e\xc6\xe8\x86i$A,^\xb0\x93\x01tܓ41\xb7S$\xbdUyn\xd6.\xcbg\x80\r\x1b\xba\xb3\f\xeb\x16\xc3 4ű\xb2\xeb\x11\xb9\xe6\x98\rt\f\xd6KԦ5\u07b4^!\x10g\xfe\xc8\x18ݰ\x8dDBI\x83\x9d\f\xc0⚤{\x88\xf7\xac\"\xe9&\xe5\x91v{\xec-\x92\x87\t\xedi\xb8\u0081\xb7\xd8\x14Gl\xd7c\xe5\x9a\xc3\x19\xe8\x18\x04\xd4璞8\xa2`z\xcc\x10kt\xc34R$\xe9\xb9\x12\xd8\xc9\x00\x06nI\x1aϜ\x13\x89\xc4ѦDBw\xae\f_\xfa^\x1a\xd9K\xda\xc2\x14Gl\xd7c\xe5\x9a\xc3\x19\xe8\x184)\xcf\xca=\"i\xf0O\xb6e\x8dn\x1c$\rv2\x00\x8b[\x92>\x12\xd0\xe8G\x1d\x8a\x96\x82\x97|.M\xb0\x93\xb4\x85)\x8eخ\xc7\xca5\x873\xd01\xd8u\xb5\xa2\xcdpP\xc1\xf4+\x14\xfb\b}\aI#\xb0\x93\x01\x18ܒt\xe2$\xa1;p\xf2d\x02\x8f\xc1ɯ\xc1\xe7ܹ\xe2m'i\vS\x1c\xb1]\x8f\x95k\x0eg\xa0\x932\xe9I\x1a\xaex\x03:nIZ\xa1_\xfd]\x9atQ;\xdc\xf9]\xdav.-6\xc5\xe1\xedz\x8e<\xa7\f\x99\xad\\s\xac$m\xbf\xb7 i`\x88\xb8)\xe9D\u007fw\xa0\x9fx;\x1f\r\xec8\x12&~k\x97\x18\xc3Y\x86u\x8ba\x10\x9a\xe2\x98\xecz\xe6J\xb7+\xc1\"\xd7\x1c\x93\x81\x0eCp\xac\xcd%-\xd6\xe8\x86i\xe41r\xf7\xd8\xfap8)S`'\x03\xe8\xb8)\xe9~2\x95\xa6\xbf\xb8\xf6o\v\x04]\xb8\xc7\xdbp\x96a\xddbXD\xa68\x88\xb7\xeb\t\xe4h\x96Z\x02\xd7\x1c\xde@\x87e[\x8e\xcdm٬э\xd1Hz\x8f7!\xc9\xf9\r\xecd\x00\x1d7%\r\\4\xc0N\x06\xd0\x00I{\x04\xb0\x93\x01\x14@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)\\\x95\xb4n\xa0\x83PؕG\x9a\x8c\x14\x86\xc9\xc4\a\xf0\"nJZ7\xd0A\xe8D \x13\x1e\x9e\xb5c\xafS\x84\x05\xc3d\xe2\x03x\x117%\xad\x19\xe8 \xd4ߒ\x11\x92\x9e\x9c\xf4삔\x19\x16\xc7\x0f\xc0\x8b\xb8(i\xdd@\a\x85\x03ጐ\xf4$\x9040\xec\xb8'i\xc3@\a\xc5\x06\xb4\xc7\xf3{\x82\xfdWH\xd2\xf2C\xf3\xc7g\xdf>\x88?5MΞ\xf0\xc8\x00\x1e\x93\xa8O\x19\x9aD\x9eC4\xaa\t\x1d\x19-M\xe4bY\xd7\x1c\x96\xe13\xf1\x01\xbc\x88{\x926\ft\b^\x92t\xac\xa5\xf9+\x13Ǝ{d\xbe\x84\xd5Y9\xea\xa1\xe0\xfa\x9cI\t4\xb0+<aj8L\xae\x03\xf6\x87G\xaf@hwe\x16\x17˹\xe6\x18\f\xa3\x89\x0f\xe0E\\\x934c\xa0C\xf0\x92\xa41\x93\xa4\xdb\xce\xe1\x81\b\xe9\x9b\xc9\xc3\x06\xf7H\xf4\xa9\x89\xc6\xc0\x9b}\xa6\xaf\x1ekr\xcdQ\x19F\x13\x1f\xc0\x8b\xb8%i\xd6@\x87\xe05Ig\xa9\xc3\xe7y\xe3ヘq\x95t\xadX\xd2Z\xac\xc95Ga8M|\x00/▤Y\x03\x1d\x82\xd7$=I[Pg\xd0\xf4\xf1\x9d\x16\x92\xd6bM\xcf\xe3W\x18N\x13\x1f\xc0\x8b\xb8%i\xd6@\x87\xe05Ik\x13\xe2\xf9\xe3\xf7RNҵD\xd2Ԃ\x80\x8awy\x16\x1f+\x94\xb4\x8b&>\xc0\x88\xc4-I+xw.\xad\xf5\xc7\x1dR\vy[\xfe\x1cy\x9d:\x15\xa1\x13tE\xf6b\xfc\xad69\x8b\x8f\x15JzXM|\x00\x0f⦤u\x03\x9dX\u007f\u007f`G\xbf\xc9ay\xe42\xb8\x9b^\xdbVT\xb6X\x9a\xd7\x12\xacT\x9cgWd\xad\xd9z[\xf61\xbc45\xe7\xb9\xe7&KW\x04z\x98X\xd65\x87a\x18M|\x00/⦤u\x03\x9d\xbdʬ\xfa\x9c\xd3\x06#\x84\xfd\x8a\xe5\xcd7\x95O\x1d\xb7\xe5\\=U1ˉ?\x94\x93=\x95\x0eG\x0eM\xcd\x1e{\xfbbI\xfa\x01\x13˺\xe6\xb0\f\x9f\x89\x0f\xe0Eܔ4\x00\x00\x17\x1d\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\n\x904\x00x\x8a\x8c\x96\xf4<)g>X\x02\x00\xde\"\xa3%ݿ#01g\xc0)\n\x00F\x12\xaeJZ3\xd0\x19\b\xb7\x04\x82\xfb\a\x1d\xa2\x87\x85\xb0\xb4\xdf)\x04\x00F\x12nJZ3\xd09\x17\bv\x1f\xd9۴\xd5\rM\xef\x91v;\x85\x00\xc0H\xc2MIk\x06:;Z\xc8\xf3\xc7\xce\x04\x86\xea\x18u!\x80\xa4\x01\x8fᢤu\x03\x9d\xad-\xf4\xf3\x0e\xdd\xc6\xf2\x12\x02\x92\x06<\x86{\x926\ft\xfa\x8f\xd1\x15\xbb\xb6\xd8\xc6\x0f\x0f\xddR\xd8)\x04\x00F\x12\xeeI\x9a7\xd0A(\xd1솸\xe29\x93w\x1dK8E\x01\xc0\x88\xc15I\x9b\ftp'\x1d8c\x1d=|l3\x1e\xfc\a\x00\x1e\xc0-I\x9b\rt\xd0\xee\xc0\x11\xdb\r\x86\x89\x81\x9c\xf1\xebw\xb8R3\x00\f\vnI\xdad\xa03\xb8#\xe0\xcem\\{\xa4\x0e\xa7\x10\x00\x18I\xb8%i\xde@g \xd8\xc4=\x8e\xfe\xd2\x01W\xbc\x01\x8fᖤ\x15Թ\xf4\x99\xe6-\xe7\xb0\xcac\x0e\xd1\xc3\x01H\x1a\xf0\x18nJZ3\xd09\x1ah>\xd2\xdf\u07ff\xab\xc5i\x83a`7H\x1a\xf0\x16nJZ3\xd0٦Ϊ/\xf9\xad&\xf1\xfe\xbd\xf3\xb2\\\x1a\xf1\x03\xc0\xf0ত]g\xae$}\xe5\x92\u007f\x8f\x00\xc0\xb0\x92ђ\xee\xff\xf0\x98S\b\x00\x8c02Z\xd2\x00\xe0=@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)@\xd2\x00\xe0)\xfe??\xe8B\x81\x97E\xcd\x14\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/ident-field.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03\xd2\x00\x00\x00\xde\b\x03\x00\x00\x00\xe6g\xc8\n\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x02\x05\x01\n\x03\x01\x05\b\x03\f\x0e\v\f\x10\x1c\x0e\x11\x14\x10\x12\x0f\r\x15$\x16\x17\x14\x1c\x1b\x15\x1b\x1d\x1a\x1f\x1f\x19\x13#A!# $$\x1d#$\"$%#&'%\x19(G((!'(&+)\x1e\x14+N()'++$*,)/-\"*.0-.,02/63(241685<9-5:=:;9=?=CA5AB@CEBKH<MH7HIG\x00f\x00\x00i\x01JLI\x00j\x02SN=MOL\x05m\x05PRO\fo\t4U\x98XSBTUS\x0fq\v\fr\x177Y\xa3WYV,`\xae7]\xad\x15w\x1c\\^[c^L9a\xab\x19y\x1e_`^;c\xad=d\xae)z!ac`De\xa3?f\xb0)|*Bh\xb3egdghfLi\xafDl\xb0qjSikh/\x82/Ho\xb3/\x859Jq\xb6mol;\x86:Ut\xb4Xv\xb6?\x8a>|u]tvsB\x8c@@\x8dG\\z\xbby{x]~\xb7e|\xb8K\x90J\x85}e_\x80\xba}\u007f|O\x93Nb\x83\xbdN\x95Ud\x85\xbf\x81\x83\x80W\x95Vl\x87\xbc\x90\x86hZ\x98Yo\x89\xbf\x87\x89\x86]\x9c\\\\\x9dds\x8dÕ\x8cn\x8b\x8d\x8az\x8e\xbfe\x9ef\x8d\x8f\x8c|\x90\xc1\x9b\x91s\x90\x92\x8fi\xa2i~\x93\xc4x\x95Ā\x94œ\x94\x91\x9f\x95w{\x98\xc7s\xa4lq\xa5s\x95\x97\x94\x82\x9aė\x99\x96\x83\x9cƙ\x9b\x98u\xaaw\xa6\x9b}\x87\x9f\xc9~\xaay\x9c\x9e\x9b\x89\xa1ˀ\xad|\x9f\xa1\x9e\x8f\xa2ǫ\xa1\x82\xa1\xa3\xa0\xa2\xa4\xa1\x92\xa5ʂ\xb1\x85\xa5\xa7\xa4\x8a\xb2\x87\xb4\xa7\x83\x8b\xb3\x89\x96\xa9Χ\xa9\xa6\x98\xabю\xb6\x8c\xaa\xac\xa9\x9e\xad͍\xb8\x93\xba\xad\x88\xad\xaf\xac\x95\xb9\x95\xa1\xb0Я\xb1\xae\xa3\xb2Ә\xbc\x98\xa5\xb5ճ\xb5\xb2\x9b\xbf\x9bµ\x90\xab\xb7ѵ\xb7\xb4\xa3\xbf\x9d\xa2\xc0\xa4\xad\xb9ӷ\xb9\xb6\xb9\xbb\xb8\xb0\xbc֦Ũ\xbb\xbd\xba\xb3\xbeٽ\xbf\xbc\xa8ǫ\xb7\xbfԯƫ\xbf\xc1\xbd\xce\xc0\x9b\xb9\xc1ֲɮ\xc1ÿ\xbb\xc3\xd8\xc2\xc4\xc1\xbd\xc4ڲ̷\xc4\xc6\xc3\xc0\xc8ݻ\xca\xde\xc7\xc9ƻκ\xd9ɝ\xc6\xca\xd9\xc0\xcc\xda\xc7\xcb\xdb\xca\xccɿҾ\xc9\xcd\xdd\xd7ϡ\xcd\xcf\xcc\xc4\xd0\xde\xc8\xd3\xc1\xcc\xd0\xe0\xcf\xd1\xce\xe1ѥ\xd2\xd2\xdd\xc9\xd7\xcb\xd2\xd4\xd1\xcd\xd6\xde\xcc\xda\xce\xe6֪\xcf\xd8\xe0\xd5\xd8\xd4\xd2\xda\xe2\xd8\xda\xd6\xd8\xd9\xe3\xd5\xdc\xd1\xd3\xdc\xe4\xda\xdc\xd9\xe6ݯ\xd8\xdd\xe0\xd5\xdf\xda\xdc\xde\xdb\xdc\xdd\xe7\xda\xdf\xe2\xd7\xe1\xdc\xe0\xde\xe2\xde\xe0\xdd\xf0\xe0\xb3\xdf\xe1\xde\xdc\xe2\xe4\xde\xe3\xe6\xe1\xe3\xdf\xe3\xe5\xe2\xe1\xe6\xe9\xe8\xe5\xea\xe5\xe7\xe4\xe4\xe9\xeb\xe7\xe9\xe6\xf1\xf3\xf0\xfa\xfc\xf9\xfe\xff\xfcŃ\x89%\x00\x00 \x00IDATx^\xed\x9d\x0fX\x14\u05fd\xf7/\u05fc\xf5m\xea\x9d(o\xb9o/)\x04S\xac\xb6Y\xd9摖p\xcd<f\t\xe8\x8d\x18\xb9\x8a \x1aR\xa4&J\xa3VL\x8c\x18b\x1e5ָ\xc1\x10,i@\xafJ\xb34\x06\xb4\xa4P\xe3\x1fb\xc0\x98\bj0&$/)i\xc0\x98\r\x1a\x93\x9a?\xf8\xc8B\xe0\xb4<\xef9gfg\xce\xcc\xce\xec,\b;\xec\xf2\xfb<\x0f\xbbgg\u007fs\xe6\xec\xd9\xf3\xdd\xf3g\x86\xf9\xfeK\xff\xa0A\x00\x00\x8c8\xfe\xc5H\xb8\xfa\x18e\r\x00\x80\xff\x01I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\x00\x18Zz\x8d\x02\x86\x17\x904\x00\f!\xce\xf4\x89\xdc,\xa3\xa0a%\xd8%]6\xcdi\x14b&\x1d\xd3ʌB\x02\x91Q\\\xebS\xa6\xd8+?4\n\x1aV̓tӾ\xa2\x92cb\xfa\xb4\xdd\xe15\xf6\x9b\x8ds\x13s\xfb\xbc\x86h\xf3\x18\xb7\xc6(d\xa8h]\x95\x94\x92w2\xe5K\xf5\xf6Ol\xfc\"\xadx\x81\xc7Ư\xf3\xd8V\xc4a\xa2f\x1c\xd7\bgh\t\xe5\xa6\xf8\x1a\xeb#$\xb35h\r~,\xf0\x12%\x1c\xd8\x1bC_\xeb\xfbyL\xf2\xaaw\x8c\xe2|D\xabև\x86\x06n\x9fQ\xc8pc\x96\xa4]\x95\xf6\xc3-\xc7\xed\xcd\xf4\xc5\xe5\x82C\xc5^\xa3\x1fJ\xa9\xc8O\xba\xe65D\x93\xcd㋌B\x86\x8a\x13I\xbf\xaa\xa8\xce\xe2\xf9\x0f\xd4o\xf4\x9d\xd9h\xd3\xdaA\xc41a\xb3zӕ\"n]U\xd14\xaeJ+^\xe6pz\x98ϱީ\x12\u007f\x11HfN\xe4|\x8c+\xba\xe2-\x9c\x1e\xd8\v\xc3P\xeb\xd7\xf6\xf3{O\xeeϾ\xf3\xa4Q\xa07N\xbe+%5j}h\xa8\xe5j\x8cB\x86\x1b\xb3$]Y\x80\x87fN{\x13}\xe1\xa8l\xf7*\xe9\xaf\xf8r\xd4\xd7\xe5-B\x9b\x96\xd0e\xde\x03:\xe2:\xbc\a\xf8\xccWɹ=\buexJ\x1a\xa1Ro\x92F+\xc2\xda՛Nӟ\xfa\xb8\xc9\x1a\xd1,k\xc2|\x8f\xf5\xca\xedsĄ\x90Y\x15w\xda[\xb4x`]\x86\xa5\xd6[\xf9\x13\xf8\xd71'\xc3(\xce\x1b\xd9k\xe5\xb4F\xad\x0f\t\xb5\xdca\xa3\x90\xe1\xc6$I;\xedo\x92'\xa138]\xe4rz\x95\xf4y\xfe\x88\xb7\xb7uI\x9f\xd8\xe9=\xe0\xb4Q\xe3\xf5\x99¤\xcf\xc8S9\xff\x91\xe7{\xde%\xdd91]\xbdIP\xd6fΠ\xf4\x8c\xa4\rc\xbd\x123\xa4\x92\x1e\x96Z\xa7\x92\xc6\xd5;\x88\x1fv\x89,F\xd2\x1a\xb5>$\x8c^I\x1f.\xe8\x96\xd2W\n\x9a\x91\x17I\xf7\xcc\xe5)O#\xb4\x85\xe7\xabŹ\xe9\x16\xdeV\xf1tFҪ\x8b4\xe6\xfcڹ\xb6\x94܋\xaa=]\x11Rw\xd1<'*t\xe2\f\xe5\x9a\xcd\xe6Ɏ&\xae\xc91\xf9)\x9cn\\\x95f\x9b\x9b\x9bF\xa6\xeb}\u007f\xcaN\xcax\x1a7\x9d\xf7m<\xbf\xe3|~Z\xe2\xaao\xab\xf1\xf1KQ)O\x8e\xaf\x19\x8026\xd1<\xbf(\xc7}u_EvRV\x05\x9d\xfa_\xccKM^+\f\xbc\xa5ݐ\xaa\xbc+\xc2]H\x89\xa0\xacy\xd1\xf4E\xf1\xb4\xf0\xc9K\x88H\xae̙\x18\x1a}w\x03\xdd\xe8\x9c71rN\xba,iu,\xea\\6%\"\xeep\xf4>\x94ɍ/\x96\xa7\xbfr@͌\xe8Ш\x19x7\a'\x10\x83T\x9268\xb0\x1c\xd00\x81\xe3V4ϛ\x14>\x83|\xa9\xeeZWn\x95\x90k\x9d\xa9>\xfcm\x96oJM\xce=OC\xb4\xbeMA\xd2y\xa9$\xcd\xd4dWᢤ\x9c3\xa9ul\xd3P\x04H_\xec\x11\xa1\x15\xf1\xd9b\x86\x9e\xb5\xae\xf9\x81\x94\x9f⩘\xf0\x18\xd2\\t>\x1b\"u7Z%]\xe6h\xdae/>Dk\xd5Q\x89\xbcI\x1a}\xd0X͗66\xe2^\xf0b\xa3\xadT\x9c\x9b\xb6V\xdb\xf8\x94\xd2?$璈\x93I\xd9{O\x94\xe2ѹ\x92\xe3\xd2\f\xb3*\"\xe6\xb1\xca5\xdc\x06\xc5\xdb\xcey\xdc\x14\xee6n\x0e\x1e\x81\xbdsg\xfe+'*\xe6\xf2\xdf\xe2͛\xf8mu\xe5)Y}\xa8\xa7\xba:-\xe3\x9eԧ\xf3\xee\xfc\xb4\xab1\xf9\xb9/ї\xcf%7vi\a\xf4\xb0\aϷ\xed\xa8\xdba\xcbǩ\xf3\xc9\x19\xfb\x8f\xac⩤\xa5\xdd\xd4\xe5=\xe4\xd1\nNs\x0eW\xd32\x8e.ᤏ\xcftl\x8e\x8a\xe9%\xdaK\xaf*\xb9{|-\xde\xd8\x1c1\xb9\xa8l:\x17\xa6\x1b{yR\xd4c\x8eL\x8e{\n9kB\xd7H\xd3_9\xa0\x96\x9b\xb7\xab\xd2\x1e\xc5u\xa3\xceC5\x93\xe3jjj\x9a\xc4\xcc\\\xae}T\xd2F\a\x96\x03\\%\xc5ѓ#\xa2\x97\xcc\xe3\xc8R\xaf\xbb֕[%\xe4Zg\xaa\x8f|\x9bi\xa5\xa5iI\xadH\xe7\xdbl\xe5\xeb\xba>*Ŀ\xab\x88\xad\xc9ki\xc9\xe5uX\xcd\x15l\xd3`\x03\xe4/\xb6\xebLcFNcc\xa3{\x14\xe5Y\xeb\x9a\x1fH\xf1)\xd2\xc3V8V\x84\xcd\xd3\xfdl\xddΪ\xdb#\xafg\xb84$\x98$\xe9\x12{qC{Sq\t\xd6tSQ\xa7wI\xb3\x03o\x1b\xf9N\x85\x81\xac-\x19\xff\x8e\xe7\xa7\xe0TO\xda*\xdc7\xf6T\u007f\xa5\xda\xcd\xc1\xb5\b\tW\xf4\f\x17\xf9\x1e\xd4S\xb8}\xa1\\(]\xa0\xacH!b.Oƍ\xe0U~?N\x9e#\xdd1\x1e\xaa\xf1\x0f]C}d]nS\x1e~\xc8#]\xb1f\xc0'\xccԠ\x8ev('\xf8:\x84r2\xf0O@_\x96M\xb9\x9b\xaa\xbc\xed\xdc.\xa4\xe44\xed6瑤\x83#KM\xb5\xdc\xf3\xa4\xfc\xa4\xb5\xdcFNz\xc6M\xc2\xc9ޘ0\xdd\xd8y\x91dD\xb2\x84#]J\x18Y~\xa6ce&\xe0\xa9(ҿl\x8e\xa4\xc7c\x06\xde\x02\xa7}80\x13\x80s\xe0\xa6_\x11\xe7QR\xad+\xb62H\xb5\xce֯-\xed\x1aQh\xb6\u07b7\xd9J\xbb\xd8|\xf2\x83\xc8\xd4d>i\x03h\x1b\x964\xdb4\x98\x00\xe6\x8bU\x0e\xbc5j]\xef\x03I\xc9}t\f#<j~\xb6Y\xb8꼟\xba\xf1\a&I\xdaQ@*\xa3\xb3\xa8\x16u\x164\xf5\xf6\xf6~X\xec\xed\x92\x1bmI结uZkR\x982w\xe3rpoj\xbcݱ$4\x9a\x9b\x18\xb6\x04\v\xfd\xd3Դm\x15\x1f\xf4ᦄ\xf2\xd2z\xbeŤҁt\x96\xedS1\xf8db\x17\xeaJ:\xa9\x17\xd0c\x93;\x95M\xc29\xabE\x1b\xd15\xda\xd6\xd0\x0e\x9br7UyۅF\xc4p\x9a\xdbp\xd81-\x9c\x94\xfe\xdeI\xaenL4\x99\xf9u<5cR\x04w\x1b\xee\x839;\t[\x11\xa6\x1b\x1bN\xcf\"5\xa9$\xcd\x04\xb4O\x9c\x94i\u007f\x13\t\x83OF\xd2\x1bjkk7\x10I\x1b\x1e\x98\r@1aRwU\xc6H:LщQ\x98Zg\xeb\xd7VH\x1e\xcb\xf9\xaft\xbe\xcdV\xfe\x0f\xe7^\xcdN\xfc\x04\xb15ٗT*\xbc\xa7\x944S\xd5\xcc\x17\xeb!iu\xad\xeb} )\x99~\x1b}\x9a\xa2\x0e\x90\xf8p\x9f}ʨ\xed\xa5\xab\x84\x9fȪ2\xd4bw\xa3\u007fu\x82\xb6\xa4\xa5d9ߣ\xb9\xdba\xf7\xd8j3\xe79oB\xe8\xb1(;\x9e\xd5m\x8e\"c\xd6k\x15k3\xf8\xb9{\xfbH\xc7!@G\xf4Y\xee\x99\x17\xfa6\xf9\b:2\x97\xfc\xd8k\a\x88s\xe9\x1e\xdcA?H\xdfA\xb9ٸ\xa3h$)ZHf7Uyk\xb9CH\t\x9d\xd2^\x1eO\xe4\x13#\xf6\x9b\xb8\x8b\xac\x9d\x18\xbdlW\xcdtܮ\x8e\tgJ\xe4\xe51u\xac\xd8\x05]QI\x9a\xc9\f]\xb6ϙ\xc2E=F\x8f\xa7\xb5<fx`63\x14s\xbbT\xf8\xc3\xf2\x88\x96\xd9*\xc1\xd6:S\xbf\xf4\xdbD\x8d\xfc\xbb:\xdf&\x9dK\v?\x91rM^\x14\xdaE\x97J\xd2\xec7$\u007f\xb1*I{ֺ\xde\a\x92\x92\xd3\xee\xa6O3\xa6\xa9\x02Xj\xb8Z\xcd\xed~\xc4$I\x1f/\xa2\xbdr%\x1e\xa6t81\xa7\x8b\x9c\xfa\x8aVKz\x87J\xd2'\xf8\xf75w\xeb\f\x13\xafx\xa8\xe44/\xc5pѵW\xa2\xf6s\x85dbV\x9dXA~\xe2ߥ|A\"\x98F\xb0-\x17\xe5n#\t\xed\x80\xc2D\xfa\xba\x9a\xff\x12m\x12V\xd9\xd2\xf2\xd17B/\x9doS\xee\xa6*\xef\x9aP\xf5\xd0TPV\x04)\xfd\xbcI\xc7)\xb8S\x9b2\x8d\x14u\x0eVV\a\x95*b\x96\xc7T\xb1\xbdB/}Z\x964\xedX\x99̎\x915\xac+χӌ\xa8\xa4\v>TH\xda\xf0\xc0L\x00\xf3\xa3\xc0Ժb\xab\x8c\\\xebl\xfd\xdah\xddV\xf0\xd7t\xbeMay,\x99|\xe7rM\x8a\xbd\xf4\a\xb2\xa4w\xa8\xaa\x9a\xf9bţ\xed\x17\xc7\x05\x9e\xb5\xae\xf7\x81\xa4d\xfa$\xfa4)]\x15\xc02zW\xbc;\xe8I\xac+\x05\xee\xcb\xc7|\x9dK'\xe1\xf1Y߯T\x92\xeeJ\xc9!?\xec۶\xa9\xf7\x9b3Y\x18\xcewN\x8c#M(s\x89:\xa0=R8;YJ&\xbex껑\xe8\x8dN\x92\v\xf7\x92GF\xd2o%~\x96\xf8\x16Ih\a\b\xe7\xa5\xfbr\xd2ȸ\x9a\x04T\x93,\xb3\xd3\xf0\x8c\xf0\xa3D\x9br7ey{\xa7\xcc@*\x04eM\\Ұ\x06\xcf\xdcJȖ\x15\xb8S\x8b&\x8d\xa87\x86\x8c\xfe\xa6E\xe3v\xd7\xfc\x830\xdd\xd89Q\xa4aΣ\n\f\xc7\xea\xed\xbd\x9d\xc42\x01k\x84\x19a\\&}\x8c\xc3\xdf\x00y\x8f\x91\xb4ၙ\x00e\x03w\u05fan\xb3w\u05faB\xd2s\xbbpŤ\xe5\xa8k\xa7e\x9d0\x8c\x17$\x9d\xb2\xad\xb5\x94\xadɵs\xb1l\xfb\xf2\xa9\xa4\xe5\xa6\xc1\x040_,~Ĺ\u007f)\xbc\xa7U\xebz\x1fHJ:\xe8X\xfdya\xba\f\x92Vs\xac\xe0X\xfb\xe9\xe2]\xdd\xf4E/\xe9\xa5u/?\x10V\xbc\xcfбӃ){K\xb3y\xdb\xfe\xd6\xcf\x1am\x1b\xcf\xf4\xbd\xb3\xd1FV\xc2O&.\xaa\xa8\x13\x16I\x144\x8f\x17\u05f8\xab~0\xe5)G\xa6\xfee\x8e\xa5|R\xe9\xabG6\xf1d\xae\\xg\xde+8Y\x8d\xbe}\x8b\xae\x91~\"\x84\xf4\xa5\xaeJ\x15.I\xd5\x0e\xa8Kzp\xff\x91U\xb638\x99\xc7\x17\xbeZȓ\xf5\xb4֤\xd4\xd2\x1dɤ\xbc\xccn\xaa\xf2n\xf0\x1cB\bW\x15N\x9fA&o˸{K\xcaҹb\xa2\xc29O\xad\x8b\xc1\x83\xe5\xc3\xe8tx\xf4\x9a\x15\x91\xe3'\x145\xe9\xc4:'F?\xb5kV\x18\x95\xf4\xb4\xa8u\xeb\xa6q$V\x91Y\xc4\x1aǮtauzM؆\xb2\xe9\xe1\xedʫnj\x0e,\at\x1f\xa6k\xe6\xee)\xb4X몭\x9e(\xaa\xcf\xc6gWWd$\x93\xf5hE\xed\xcc\xe2\x04\xe9\xb5Rm\xe6\xe4n\xccbk\U000b3534\x8aWr\x13i\xac\xd44\xd8\x00\xf6\x8bſ\xff\xe5G\x1eJ\x12zi\x8dZ\xd7\xfc@\x8aO1o\xfc2Dz\xf1\xf3\xbc}\xb6c\x1e\xe3y\xbfc\x96\xa4QsYѮc\x82\xa2\x91\x93L\xa5\xf5\xfa\xe9\x9ed:1\xb2ѳ\x0f\xe7s\x12\xefY\xb5\x83\xe7\xb7l!\x9b>H\u008f[\xf0\xe6\x8f֦ޓ-\xaf9K\xac\xf8\x81X\xc1\xcds\xa2#\xa6\xa9\x978e\xfe\x94S\x9afK\xc9\x11.7<\x91379\a7\xa0\xf7\x9993\xa6\\Z\x01\xd3\x0eh]\x9547\x97\xae\xec\xf4\x95g%e\x95S\xfd\x9f\xcfMN+\xdco\xa3\x85t\xef\x86\x14\xe5\xad\t\xf7\x18;\x94\xe0\t\x1d\x9e\xe46L\x8e\"\xfd\xc1\xbe\xe9Q\x91qD\xb6\xbd\x1b&\x87E\xdd[49\x14\xf7\xa9\xcdwGNZR4\x81\xcbԉE\x1d\xe9\xd1\xe1ӏQI7DžG\xccX\xc6q\x99l@qܚ\xe8Љq\xe2\xf9\xa6\xcc\xc8\xf0\xb8Z\xf6\x1ao\xbbၙ\x80\x86\xf1t\x0e*u{B\xad\xab\xb7z\xa0\xa8>\xdbӛ\x92S\xf3\xe9\xe5:\x8ao\xb3(\x8a.ȑ\v\x03p\xa7ۚ1\xf7U\xc4\xd6\xe4\x17\x9b\xd2\x12\x1f:G%-5\r6@\xf1\xc5\xf6lKN\xcc9G\x93\x1a\xb5\x8e4?\x90\xf2Sl\xbe-\xfc\xb6\xcd\x1e[Y\x9c\x13\xe648\xcd\xfd\xefJ\xd3$\xed\x1f\x96\x84\x96\x18\x85\x98\xcb\xf3\xa1\xe9\xddF1\x83\xa6S\x98\xfa\xfa\x9dAԺ\xb0<68\xba<\xc7g\x06\fc\xad\x97M\xe1\xe0\x9f+\x87\x95\r\xd1^\x96\xdḑc\xe2:\xa3\x90\xeb\xc0,I\x0f\xa2\xd6\xfd*\xe9\xe1\xadug\xc3@?\xfc\xd0\x12\xec\x92\x1e\u0558&\xe9\x81\xe3WI\a7 \xe9\xe0\xa5y\x1f\xb7\xc4\xf4\xf5W\x9f\xb8H\x17;\x8d\xa2t8_\xc7?\xfd\xd6`w\x0eB@\xd2\xc1K\x1c\xc7q\x13\x9a\x8d\xa2F\x02t\xb1\xf3\x13\xa3(\x1dr\xc8\xce獢F\x0f i\x00\b*@\xd2\x00\x10T\x80\xa4\x01 \xa8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\xb38\x92\xfd\xe5\xf0Z\xb9\x00\xa3\x13\xf3$\xed6\xd0q\x15\xd1\xdb\x14\x15i\xddK(\x88\xd9˗\x92\x8b\x18\x87\xcf\xca\x05\x18\xa5\x98%i\xd9@\xe7\xb2\xfdMr\xab\"s\xff{\xc5\x1f0\xfe-\xe4\xfec\u007f\x12\x12\xc3f\xe5\x02\x8cR̒\xb4l\xa0s\xd9n\xaeџ\xdf`\xfd[\xce\vw\xc4$\f\x97\x95\v0J1IҌ\x81Ψ\x914{\x83\xcaM)]\xee\xe4pY\xb9\x00\xa3\x14\x93$\xcd\x18\xe8\x98(i\r\xa7\x16\xd6\x14GөŇX-7\x1e\xa5\u007fK\xcf=R'\xadm\xe5\x02\x00\x83\xc5$I3\x06:\x97\xed\x958YcB\xb3\xd6rja\\]\xb4\x9dZ\x8cc5\xddx\x94\xfe-\xef\b7\xf8\x16аr\x01\x80Ac\x92\xa4\x19\x03\x9d+4Y\xf2\xbc\xdf5\xad\xe7\xbb#\xb9\xba\xe88\xb5\x18\xc5\xea\xba\xf1\xc8\x03\xef:\xd6\xe0\xd2\xd3\xca\x05\x00\x06\x8fI\x92\x96\rt\x10:M\xc4\xec*\xf2{W\xa5\xe7\xbb#\xb9\xba\xe88\xb5\x18\xc4\xea\xbb\xf1Ȓ>\xc23\xff\xef\xefi\xe5\x02\x00\x83\xc7$I\xcb\x06:nj\xfc\xdeU\xe9\xf9\xeeH\xae.:N-\x06\xb1\xfan<\xb2\xa4\xcf\xf0g\xe4<<\xad\\\x00`\xf0\x98$i\xc6@\xa7\x92\x9a\x17\xa0*\x87\xd7\x1d\x86\x01=\xdf\x1dIz:N-\x06\xb1\xde\xddx\x04\xff\x96.\xf6\xeey\x9eV.\x000xL\x924c\xa0\xe3\xa0\xddsG\x91\x96\xb9䰢\xed\xd4\xc2\xc8Tǩ\xc5(Vύ\x87\xf5oY\x9b!\xdd\xffN\xc3\xca\x05\x00\x06\x8fI\x92f\ft\xda\xed\xfb\x9a?<V\xe0\xf7NZ۩E\xe1\xea\xa2\xed\xd4b\x14\xab\xe9ƃ\x94\xfe-\x1f\xf1\u007fp\x97B\xcb\xca\x05\x00\x06\x8dY\x92f\ft\x9c\x95\xc5E\x8e\xd3F\xf1Á\x86S\x8b\xd2\x14Gө\xc5(VӍ\a)\xfc[\x10z.Q\x9cMk[\xb9\x00\xc0`1Mҁ\xc8\x10\xde\x03\xbeo\x9b\x8dv\xdd\xc3h\xe5\x02\x8cN@\xd2\x03`\b%\x8d\xfa\xcaS\xbf\x18n+\x17`4\x02\x92\x1e\x00C)i\x00\x18\x1e@Ҿ\x03N-@\x00\x00\x92\xf6\x1dpj\x01\x02\x00\x904\x00\x04\x15 i\x00\b*@\xd2\x00\x10T\x80\xa4\x01 \xa8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x04)\xbdF\x01A\nH\x1a\bF\x9c\xe9\x13\xb9YFA\xc1\tHz\xd4A\x9d{\xae\x9f\x91\xed\xfd3e\x8a\xbdҴ;Ϛ\x8by\x92v\x1b\xe8(\x93\xfe\xa52J\xfa7\xed\x8ę\xf0\x19\xa6\x8c\xd5>\xb1\xf1\x8b\x8cb\x10\xb9\xaf\x12\xe6Ό\n\x9f\xafH\xd5\xc9Wt\xee\xe9\x98\x1e\xf9\x98ƻ\x03`\x88\xbd\u007f\x1c\x91\xbe\xff˼\xfb{K\xe78.\xbcY#\xa0\x81ۧ\xb1ut`\x96\xa4e\x03\x1d6\xe9o\x1c\xe1\xd2\x1dϦO|*=\xfc\xb2\xb7\xe0\xe1\xa2\xef\xccF\x9bQ\f櫽\xfc\xfeƺ<\xfe9\xa3@7\xda\xf9\xba\x9d{\x96Lzl\xfcu\x9a\x16\r\xad\xf7\xcf2n\x99Q\x88\x84\xfb{k\xaf\xa9٬y\xcb\xe4Z\xaeFc\xeb\xe8\xc0,I\xcb\x06:l\xd2<:8\xdc<;\x8d\xa2\x86\x89R_$\x8dN\xf0\xadX\xa7[\xd8\xfb\x05\x1b\xa0\x91\xaf\xe4\xdcs\xfb:\x14~\xbd\xcd~H\xbd\u007fVp+\x8cB\xb4\xa8Ց\xb4\xdfo8;b0IҌ\x81\x0e\x934\x91f\xce\xf7aߐ3\x00I\xa3\x9e\xe4-F\x81\x12\x1a\xf9J\xce=\xb7\x15\xb5s\xd7;0\x1aR\xef\x9f5\xdc\x1a\xa3\x10-@\xd2jL\x924c\xa0\xc3$\xfd\xcb\xe5p\x8e\x1b_LR\xae(\x8e\xe2qˠ\xe2iᓗྻa\x02ǭh\x9e7)|F7\x93T\x05\x8b\xb7/j\x8f\x102\xe3\"T]\x98\x86]\x0fB\x17\xf3R\x93\xd7\n\x03dƂG3V\x904\xda2W7\xb6\xaf\";)K\x98l\xeb\xe4+;\xf7\xccX1\xeb6\xfcY&4i\x1f\xcd7#!\xd9\xfbG\xfc\xf0\n\xa4ݘ\xcc\x14\xf9*x\x8c\xa3s{\xed\xea\xcb\xe4B\xedK&\x87\xcf \xdb\xe4\uf360-\xde*\x90\xf4`0\xca\xda\x1b\x8c\x81\x0e\x93\xf43\xc7jj\u0084\x9e\xe1͚\xe7\xb9555\xea\xb9e\xfa\xf8L\xc7樘^\xe4*)\x8e\x9e\x1c\x11\xbdd\x1e\xf7!\x93TE\x8b7\x19t\x15m\x16P9fk\xd9\xf5\xa0\xf3\xc9\x19\xfb\x8f\xac\xe2\xa9\xf4d\v\x1e\xedXQ\xd2\x15|\x97^l\xbemG\xdd\x0e[\xbe~\xbe\x8csϚ\x88\xb0c\xdd3\xe2\x0e\xeb\x1c\xcd7#!\xd9\xfbG\xfc\xf0\n\xa4ݘ\xcc\x14\xf9*\xd8\xccљ\xb9v\xf55\x15O\xe0\xa2\xd6l\x88\xa0\xe7\xa5\xe4\xef\riJ\xba\xdbYu{\xa4Y\x93(\xf31IҌ\x81\x0e\x93\xf4?\xe1\ue9a15\xf0vpE\x88\xb4\x19j\x86\x11\xc3M\xbf\"N\x0f\x98$\x8b\xfbV\xc0\xce\x16\x01\xe5\x0f\x84\xb6]ON\x06\xd6g_\x16\x91\x1ec\xb6\xa3\x1d+J\x9a\x98\xefh\xc7\xd6\xf1'hX\x9d^\xbe\xacs\xcf:Ύ\xae\x84\x93\x0f}\x1dFB\xb2\xf7\x8f|\x1fd\t\xa5{\x90;3E\x92\xc5\xce\t\xfd\xbcv\xf5\xa1\xb0H\xdcCϋ\x12_\x85{\x93\xf4,\xdcǛ8\x8d2\x1b\x93$\xcd\x18\xe8\xb0^:~ǫ\xa4\xef\x9d\xe4\xea\xc6D\xd3\tcL\x98\xd4+3I\rZ87\x8aF\xaei\xd7sM\xd0\xc6\x0e\"=\xc6lG\xdb\xdaG\x94\xf4~\xfe+\x9d\xd8M\xc29\xabE\x1b\xf5\xf2e\x9c{J\xb8\xc8%h\xc3D2y\xb8\x0e#!\xaf\xde?J\xf7 \x9b\xd4+3I\x96\"\xfa\x03\xaaW}(\x8c|\vk\xc2\xc4W^%\xfd\xe1>\xfb\x14\xe8\xa5\a\x83Q\xd6\xde`\ft<\xbdt\xfc\x88WILjm\x8b\x8e\xf6bn\x97\xb7\xcbI-j\x1c\x02\xca\xf5dM\xbb\x9es\xc28\x98.c1f;\xda\xd6>\xa2\xa4\v\x93\xf5b\x1f\x14n?\x9c\x9b\xad\x97\xaf\xec\xdc\xe3\f_R\xf5\x83\x96I\xf4\xd3_\x87\x91\x90W\xef\x1f\xa5{\x90;3E\x92\xe5P\xa4\xa0M\xed\xeaCt\xa8훤15\x9c)=Ĉ\xc0$I3\x06:L\xd2\xffx\x95\xf4\xbcI\xc7)\x1d\xe4E\xcc\x1ci;\x93\xf4\x1dM\xbb\x9eo\x04m\xe4\v\xbd\xa9d\xb6\xa3m\xed#\xaex\xa7\xacՋ\xdd$XZ\xa7\xe5\xeb\xe5+;\xf7\x94\xe1>p֤\x88\xcbB\xbe\x836\x12\xf2\xea\xfd\xe3\xe9\x1e$\xc0$\a\xc0\xc0$\r+ރ\xc2(ko0\x06:L\xd2\xffx\x95\xf4>\xae\x84<\xad\xa0\x17I\x19KZc:ɠmד\x9d\x86g\xb0\x1f%\x12\xe91f;ڱ\x82\xa4\v\x89\x00\xb5c\xeb\xe8\xd6j2\x97\xd6\xce\x17I\xce=\xbb\xb8f\xf4&w/\xea\x8dn\xb9\x0e#!\xc6\xfb\xa7e\x8d\xc7\x191ŁA\xd2~\xc3$I3\x06:lү\xb8\x0e\xd7Ԅ\xa5\xd7\xd4\\q\xafx{\xb4\x82eܽ%e\xe9\\1\xea>\\39\xae\xa6\x864v&\xa9BkїAˮ\a\xb5&\xa5\x96\xeeH\xe6m\xfb[\x15f;Z\xb1\xc2\xd5c\xf9<\xed'\xb5c\xf3\xf8\xc2W\v\xf9<\xfd|%\xe7\x1eg\xf8\x9c]ѓC3ׅ:\xaf\xc3H\x88\xf1\xfe\x99\xc5\xc5!5\xd2nLf\x8a|\x158\"\xbc\x8cӜ5\xa1\xe9\x87\xd1\xf1\xf4\xd0\x1a'\xfb\xbdѫ\xc76\xd7\xd4x\xacm\x1c\x1b\xc5n\xa0fI\x9a1\xd0a\x93\xfe\xa4v\xbc0U\xb6#W$ML\xf0\xb8\x80m\xdf\xf4\xa8ȸ}\b5\b\xa1\xa4\xb13I\x15Z\xa7fY4\xecz\x10:\x9f\x9b\x9cV\xb8\xdfƓ\xebG\x18\xb3\x1d\x8dXz\x8d7\x9f&\x0ey5c\xfbʳ\x92\xb2\xca\xfb\xbc\xe4+9\xf7TN\x8e\xca쬜\x1c\xf9\x94\xce\xd1|1\x12b\xbd\u007f6\x87E!\x0fܻ1\x99)\xf3e\xd9\x17\xe5\xe5\xb2\xecL\\塧\xc3\xf1c&\xf3\xbd\xd1k\xbc\t\x1e\xc3&\xe7\x849\rNS\xae\xd87\x1f\xd3$\r\x98\x83۹\xe7z\x10\x96ǔ\xde?\xb3\xa6\xebE\x9bB\xd9\x14\x0e\xfe\xb9r\xc0\x18e\r\x8cH\x04\xe7\x9e\xeb\x82JZ\xe9\xfd\xb3nĝ\tv6\xa8\xaf\x1c\x1a%\x80\xa4\x81\x01\xe3i$\xd4\x1e\xb5Y3\x12\xf0? i`\xa0\x80\x91Ј\x06$\r\f\x140\x12\x1aр\xa4\x01 \xa8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\x00\b*@\xd2\x00\x10T\x80\xa4\x01 \xa80OҢkNw\xb1]\xa0\x18\x01\x00pݘ%i\xc95\xc7e?\xee\xc4\x1c\xb37\x18\xed\x12\xe8T\x1dG\x000\xec\x98%i\xd95\xe74\xb9ۯ\xab8\xf8\xefBq\xfb`nY\x06\x00\x03\xc4$I\xab]s\x1c\xfe\xbfO\x91\xdf\x19\xd4]\b\x01`\x80\x98$i\x95kN\x93=x\xfe]]\xe9\xb0\xe3\xb6\xe0q\x88\xb7ԉ!7\xdd\x19_\x8cZB\xb9)\x8aX\xd6\"\x86e`.4\x00`\x92\xa4U\xae9%\x95^\xa3\x03\n\x85Îd\xc1\xd3y\x88ޅ\xb0\xa6\x89\xde\x1ao\r\xfeQK\x0fS\xc4*,b\x18\x06\xe6B\x03\x00&IZ\xe9\x9a\xd3b\x1fBS\xd3\x11\x80䰣\xb4\xe0\x91\x06\xde\xec\rle7\x1e\xa5E\x8c\xc8\x00]h\x00\xc0$I+]s*K\xbcG\a\x1a\x92Î҂G[Ғ\x1b\x8f\xd2\"Fd\x80.4\x00`\x92\xa4\x95\xae9E\xa6ܖ\u007f\xf8\x90\x1cvb\xc4\x19\xb4`\xc1\xa3-iɍGy\xf3y\x91\x01\xba\xd0\x00\x80I\x92V\xb8\xe6tؽ\xd9T\x04 \x92x=-x\nH\x9fLŻ\"L\x19\xab-\xe9\xa1u\xa1\x01F\x01&IZ\xe1\x9a\xd3b\xbfl\x10\x1e`H2UX\xf0\xc4\xc5!\xe4\xa4\x1b\u0097!\xd4{\xbbO\x92\x1eZ\x17\x1a`\x14`\x92\xa4\x15\xae9Mv\xf7\xcaw0\xa0pؑ,x\x10Q놲\xe9\xe1d!pZԺuӸ\tEML,k\x11\xc320\x17\x1a\x000KҬkN\x8b\xdbw<(P:\xec\xb8-x0\xae\xcc\xc8\xf08\xba\x1e\xd8\x1c\x17\x1e1c\x19\xc7e2\xb1\xacE\x8c\x82\x01\xb9\xd0\x00\x80i\x92\x06\x00`8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\x00\b*@\xd2\x00\x10T\x80\xa4\x01 \xa8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\xc5(\x96\xf4\x1c.j^\x93Q\x10\x00\x04\x18\xa3X\xd2Ϊ\xa2)Q\x9dFQ\x00\x10X\x98'i\xd1@\a\xa1\xceC\xbb\nv\x1d2E[U\\\xd0{|\x00\xa3\r\xb3$-\x19\xe8\xa0\xcbŻ\x9aڛv\x15\x9bqg\x93Z\xee\xb0Q\b\x00\x04\x16fIZ6Щ)!7B\xe8.\xa91\xdae\x18\x00I\x03A\x87I\x92f\ft*\x85\xbb\x84\x96\x99qw~\x904\x10t\x98$i\xc6@\xa7\xa3\xb8\xaa\xc3\xd5QS\xdc\xe1-~\x98hઌB\x00 \xb00IҬ\x81\x0e\x9eV\xdb\xed\xfbL\xb9\xa3\xa0+jڡ\xf6^\xa3(\x00\b L\x924c\xa0\xe3\xaa,ir6\x95T\x9ab]\xb9\x8f㸻\x8d\x82\x00 \x800IҌ\x81N\r5\xc6r\x95\x98a0\xdd\x195isU\x90\xf9\x02\x00\xa3\x1c\x93$\xcd\x18\xe8\x14Ѕ2\xf4f\x81\xb7\xf8a\xa2\x963cQ\x0e\x00\x86\x11\x93$\xcd\x18舒>n\x8e\xa4a\xc5\x1b\b2L\x924c\xa0S%\x0e\xbc\xcdX{\x06I\x03A\x87I\x92f\ft\\ϗ\x9cn?]\xf2\xbc\x19KއA\xd2@\xb0a\x96\xa4\x19\x03\x1dW\xed\xae\xa2]\xb5\xfeW\xb4\xcby|N\x98Ҁ\n\x00\x02\x1e\xd3$m>\xb38.\xba\xcc(\b\x00\x02\x8cQ,i\xe7\xf1v\xa3\x10\x00\b8F\xb1\xa4\x01 \x18\x01I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\x00\b*@\xd2\x00\x10T\x80\xa4\x01 \xa8\x00I\x03@P\x01\x92\x06\x80\xa0\x02$\r\x00A\x85y\x92\x96\ftz\x1b\xca\nv\x8d\x1c\xbf\xb9\xd6\xdc\xe4䜓Yg\x8c\xe2\x04N\xa4\x1c\xd1\u007f\xb3\x94\xb7\x91w\xeb\x92\xf8R\xed\x80-<_\xad\xfd\x0e\xfa\xc4\xc6/\xd2ykh\t\x88B\x02\xbec\x96\xa4e\x03\x1d\xe4(:\xder\xac\xe0\x98\xd1\x1e~\xe2][\xee+չ\xfa\xadXūI\xaf\xe8\xbf\xf9E^\xd2C\xf8\xe9\xa1ļ/\x94o\x9c|Wx\xbe\xd8h\xd3\xd1\x11\xea;\xb3Ѧ\xf3\xd6\xd0\x12\x10\x85\x04|\xc7,I\xcb\x06:o\x16\x90\x9b\xf27\x17\x98\xe2s\xe7ɪ\x9c>\xdcT7\xfa*i\xd4\xe7\xed\xcd\xc2ܤk\xe8\xab\xc4\xdcB\xd5\xf6\xec\xb5\ue52eZp\xf7\xe9'\xb5\x04D!\x01\x9f1IҌ\x81\x8ec\x1f\xddR<B\xba\xe94ڲ[y/\xe3i\xdf)\xcc{\xa8\x1a\xfdiU\x9eZ-Y#I-\x01QH\xc0gL\x924c\xa0\xb3K\xf0\xb7+s\xe8\x06\x0f\x0f\xef\xdbx~\xc7\xf9\xfc\xb4\xc4U߲\x9b\xf3RZ\xf1c_]\x17y\xfcSvR\xc6\xd3]\x8a\xd8j\x9eǓ\xceR\x9e\fͯ%\xf1\xf2\b\xfd\xfcڹ\xb6\x94܋\xecnX-\x15\xb9(\xb7\x82\xaaE\xdaz\x84\x17\xc8&{\xd9\n\x9f\xceHZE\xf6B}\x15\xd9IY\x15\xb4\u05ff\x98\x97\x9a\xbcV5\xa6m\x8f\xe0\x04\"Twn\x90\x0f,\xa1\xf8lrqPWᢤ\x9c3\xa9u\x8a\xfd\x87\xb2\x90\x80\xf9\x98$i\xc6@\xe7P1\xbdCh\xd1.\xa3}\x86\x98\x9e\xea괌{R\x9fλ\xf3Sv\xf3\xa7i\xfc\xaaҷzhz\x13\xbf\xad\xae<%\xab\x8f\x8d\xedjL~\xeeK\xf4\xe5sɍ\xb8\xe1\x9fklL\x14{\xb0\x93I\xd9{O\x94\xf2\xe5\xecnX-\x17\x93\xbeI\xfc\x8c\xaaE\xda\xdau\xa61#\xa7\xb1\xb1\xf1#\xb2\x9b\x8dϨ>27\x97$\xf3m;\xeav\xd8\xf2q\xea|r\xc6\xfe#\xabx\xa5Z\\E\x9b\x05\x8a\x94\xb7ic\x0e,\xa1\xf8lrq\xae\xa5%\x97\xd7m\xe1\xf9\nE\x06CYH\xc0|L\x924c\xa0\xd3Y\xe4p\xba\x9ce\xf6\x12\xa3}\x86\x9e,\xfe\xa1k\xa8\xef\x9ar\xe3W\xa5\xbf\xb2\xf1ɤ\xef}\x95ߏ\x1f\xcf\t\xfd\xb0\x1c\xbb)\x0f?\xe4m\x12\xc3EI\xf7\xa4\xad\xea!R\xfaJ\xb1[a\x1e\xcaژ\x8d\x88Z\x94\x99\xc9cڔop\x8e)8Uǟ\xc0\x8f'x܅\xe6d\xe0\x9f\x8b\xbe,\x95Z\x9c-\x02\xca; 2\aV \x95\x979p~2\xe9i\xb7yHz\b\v\t\x98\x8eI\x92f\ftP\x87\xc3n\xb7\x1fv\x98pg\xbf,\x9b\xa2\x83\x96\xe89\xb1\x8a4ڼ\xb4\x9eo1\xa9\x9b\x94\xb1'\x13\xbbPW\xd2I\xf1\x95(\xe9:\xfe\x03\xf7\xde\xccnX-{\xf9\xbdT-\xca\xccd\xb5\x90\xd7tB\xbaI8\x1d\xb4h#\xba&hn\x87R--\x9c\x1b\x85\xe3\x0fs`\x05Ry\xe5\x03\xf7%Ѳ\xb6zJz\xc8\n\t\x98\x8fI\x92f\ft0\xae\x8e^Tl\x82'VV\xb6\xe7\xb6s\u0094\xf1\xc1\\\xd2\xd1\t\xe4*c\xbfM>\x82\x8e\xccu\xaft\x8b\x92.\xe7{\xdc\xef3\xbba\xb5|Q\xf8%U\x8b23\xe5\xca\x13U˃\xf4\x1d\x94\x9b\x8d{\xc9F\x84<W\x9ej\x1c\x025\x8a\xad́\x15H\xe5\x95\x0f|QX\xf3\xeb\xf2\x94\xf4\xd0\x15\x120\x1d\x93$\xcd\x18\xe8 \xbaP\xd6l7\xe1\x8e\xdar\xa3\x95I\xd9F\x9f\n3H\x9f\xf5.\xe5\vU\xec\xb6\\\x94\xbb\xcd\xfdB\x94\xf4\t\xfe}\xf7\x16f\xb7\xc2<aK\xa1Vf\xfbI7*\xabeS\x1a\xf9\x95\xe8K\xcbG\xdf\xf0\xe5\xbd\x1dW\\\xf9>\xa9\x859\xb0\x02\xa9\xbc\xf2\x81\xc5^\xfa\x03OIӸ\x81\x16\x92\xe6\xe2[!\x01?b\x92\xa4\x19\x03\x9d&\"\xe6+\xc5f\xf8簒nY'\x8cg禒Yi\x1fy\xeb\x840\xa7,ܫ\x8a}+\xf1\xb3ķ\xdc/DIw\xa5\xe4\x90\xder\xdb6\xc5n\x8cZ\x14\x99\xe5\xe4 \xf4%\xdd \xab\xa5\x8e\xbe\xae&#\xfe\xec\xff\xfaј1?\xfa\xb9Oja\x0e\x8c\xe4O\xc1\x94\x979\xf0ڹX\xab}\xf9\xa2\xa4ݱ\x83-d\x1a\xae\xa8\x8f\x12}*$\xe0GL\x924c\xa0\xd3l\xafm\u007f\xb3\xd8\xe1w\xb7\x8doߢk\xba\x9f\x88/gq3\xe8\xf3\\>\xa5\xb4\xee\xc8CId\xa9\xb7\xf0μW\x8el\u00adX\x19ۗ\xba*\x95\x8e\xbb{\xce46&nll$\x8bf'\x13\x17U\xd4\t+O\xd2n\xdf\xe4\xe5|\x86_\u007f\x96\x93\xf7\r\xb3\x15\x11y\x94\xe3C|\x8a>k\xb4m<\xd3\xf7\xceF[#\x8e\xcb\xe3\v_-䉾\xde\xff?\xdf).\x18\xf3\u007f\xff\xb3\xa2\x15\x19\xc3\x1cX\xfa\x14\x8a\xf2\xca\a\xfe,%\xad\xe2\x95\xdcDe\xec`\vٚ\x94Z\xba#\x99\xb7\xed\xf7\xa5\x90\x80\xff0KҌ\x81\xce\xf1\x92\"\xc7q\xa3\xf0\xa1\xe7}fڈ)\x8a\xb2\xd3\xe7_U\x14.JJɥ'oЉ\x9c\xb9\xc99u\x1e\xb1\xe56\xe1\x94\xd1;\xe2ԓJ䣵\xa9\xf7d\x1fQ\xecV\xca\xf3dai#O/\x9fvo\xc5\xf4lKN\xcc9G/\x9f\xe6m\x1f\x90\xb3\xdb[\xf0/EyVRV9\xf9\xadp\xfdpV\u007f\u007f\xe4\x8f~N\xb6\x1a\xc3\x1c\xd8\xfd)\x94\xe5\x95\x0f\xfcŦ\xb4ćΉ\x92\x16c\a[Ht>79\xadp\xbfͷB\x02~\xc34I\x03\xfatF\xce\xc1\x92\xbe\xadyxF.\xea\xe51 \xb8\x00I\x8f@\xa8\xa4#nk\x02I\x03\x03\a$\xad\x84\x1f\t\xfc\xe7\xffƒ\xfe\xe1\xff\xfa\xb7\u007f\xfb\xf9p\x88\x1a$\x1d܀\xa4\x95\x18\xa9\xcd/PIG|\xe7\x87\xdf\xfdN\xc3.\xc7\xe5n4\xa4\x9c\xaf\xe3\x9f~\xcb\xeb\xff\x8f\x01\x01\rHz\x04B\a\xde\x13;\xfa\xbbC0\xa1\x87\xdb;\x87R\xd59\xf87\xc3v\xde(\n\bX@\xd2#\x8f\xde+D\xd2w\xe3*\xfe\xde,W\xf3ؐ\x90\xef\xd9;{\x8dv\x02\x00\x01\x90\xf4\x88\xa3%.f,\x96\xf4f\\\xc5ӛ\xfa\xfbӗ\x1c\x8a\v\x99\xde\x01\x9a\x06|\x03$=\xd2pE|\xef\xf6\x1b\xb0\xa4kq\x15/\xfb\a\x96\xb6\xb3\xbf\u007fF\xf80\x9d\xd0\x02\x82\x0f\x90\xf4H\xa3!\xe4p\u007f8\x964\xc2U|\f\xff\x1d\xc6\u007fs\xc2\x1aF\xc8}\x9c\x80\x11\x0fHz\x84ѻ!\xe4\x1f\xfdd.M\xf8\xa7\xf8\a\x92\x06|\x06$=\xc2\xe8\xce\xfc^\u007f\xff\xc49\xfd\xbd\xae\u007f\xf6w\xe3?\x17\xfe\x03I\x03\xbe\x03\x92\x1ea\xb8\xe6\x85\xf5\xf7\xc7d\xfe\xf3\x1f\xfd\xc7\xff\xf1\xcf\xfe\x86\xde\xfe\xfe&\x9040\x00@\xd2#\f\u05ecHZ\xbb\x9b\x1fs\xf6oXw\xa5\u007f\xdd:\x04\x92\x06\x06\x00Hz\x84\xe1\x9a\x1e\xfdO\x0f@ҀϘ#\xe9\xeeb\xbb@1y\xe5,+\xdag\xc2=MF&\xaei\x93\xff\xe1\xc1,\x904\xe0+\xe6H\x94>:\xac\x00\x00\f\bIDAT\xdae?\xee\xc4\x1c\xb37\xe0\x17\xed\x055\xcd5\x05\xaa\x9bS\x8fZ\\\xd3&zn\x8c\x8e\x02I\x03>b\x8e\xa4\xd1iz\xefnz\v\xc1^\xfax\xa8\x18.\x8f\xa2\xb8\x96\x8d\xa9\xb9\xa2bWȽ\xa7AҀo\x98$i\x8a\x83ܧ\b5\x15Py\x17\x8c\x1c\xefJS\xe9m\n\r\xb9Ổ\xb1\x84\x1b0!?(iq\xa1\x90\x00\xc5\xe8\x13\x03C\x8b\x89\x92n\x12n\nZ)xb9̸\x9f\xe0H\xc4uzŬ\xe9230\x99\x8e\x86˽(\xe4j@\x02\x92\xf63&J\xba\xa4\x92>\xed\x12n\xe0}Ȅ[\xf3\x8fL\\Ζ&\x05\xcd-N\xf2\x9fX i\xc0\x17̓t\x8b]X\x11+\xae\xa5O\xb5\xc5ނG\x17\xdd.%\xddt\x9d\x01$\r\xf8\x82y\x92\xae\x14M\xb0D\xe7\xca*\u007f\xdb\xdc\x05\x1c i\xc0\x17̓t\x91h(M\x1d7\x10*\x83\xb9\xb4\x01D\xd2O\x8eŏ\xac\xb6C<\x12\xde\xf0)HB/Z7\x17\xcd7@\xd2~\xc64Iw\xd8E_\x88&;q\xbc\xbbb\x87\x15o\x03\x88`\xc6\xfd\xf9\xaawI\u007f~\xdfMcn\xf8\xe9\xee\xab\xdahi.\xe4\x16\xe1\xf9\x16\x8fl}\x94t\x88F\x8a}\xdb\xe8s\x01C\x8bi\x92n\xb1_\x16\x12\xbd\xd4;\xa7\n\xceK\x1b\x11\xa2%\x1a\xb5\xa4\u007f\xf1\xb3\xd7?\u007f\xfb\xc9[\xd5a^\b\xb9\x89\xfe\x00\xec\xbe\xe9\xfa%\xad\tH\xdaϘ&\xe9&\xbb\xfb>\x1d\xed\x05U-Up\xf5\x98!d\xc8-\x80\x85\xf2\xcc\u007f\x8c\x19w\x9f\xa8\xa7G\xc7\xfd\xeb\xb8߈\xc2\x1a\xf37\xb7\x94\xa4\x88\an\f\x19{\x01'.\x8c}\x9b\xeey\xf3\x98\x1b\x1fe\xdf\u007f\xfc\xc7$\xfcǏ3\xd9\nG\ty\xfc\xe61c\u007fA2\xfc\r9\xc2Uա^\xff\xe9\xd817?\xee\x8e\xc5G!\x85a\xf6\xb9Q\b\x05I\xfb\x19\xd3$\xdd\"/\x879\xf7\x15\x94\xc15ކH\xbd4~x\xf1\xdf_\xbc\xf0\xfa\x8f\xef\xa3\xe9\xdf߸\xfb\xc2\xee\x1bE\x9d\x8d{QT\xb4\x1cq\xeb\xdbW\u007f\xf28\xde\xf2\xf8Oh\xf4w\x9f\xb9\xf0\xfa/\x149܄G\xf3\u007f\xfe\xbe:[\xda\u007f_x\xfbg?\xc3B\xbfq\xf7\xe7\xbbo|Fu\xa8\x9b\x1f\xf8\xdb\xe7/\xfe\xc4\x1d\x8b\x8fB%\xcd\xec#\x84\x82\xa4\xfd\x8ci\x92\x06\x06\n+\xe9[ɜ\xfa\xedqB\x1ak\xed\xea3\xa2Ξ\x19\xfb\xd3\a\xa8\xaa\xe5\b\x9c\xa0#\xf1[\x9f$ѷ<)\x0429<\x8e\x15\xf8\xb3'\xd5\xd9\n{^\xfd\u007fc\xf1>\xf4\b\xb7\xa8\x0eu\xc3\xdb³\x1c\x1b\xc2\xec#\x85\x82\xa4\xfd\fH:``%=\xd6=\x02'i2\xcc\xfd\x9b\xa8\xb3\xab\u007f{\xf4\xae\x9bIW-G|~\xf5\xea\xe7c\u07fe\xfa\xf6\xd8\xcfI\xb4{d\xce\xe6\xf0\xfd\xd7_\xff\xbeG\xb6\xe2\x03y\xbc\x81\x1e\xe1\x06ա\xfe{\xec]\x8f\xbe-\x95\xe9sQ\xd2\xca}@\xd2\xfe\a$\x1d0\xb0\x92\x1e#\xf6\x90\n\xf1H<\xfe}e\xc4իw\xddw\xf5\xbe\xbb\xe4\x1f\x80\xab\xca\xf7\x9f\xbc\xeb\xae'=\xb2Ւ\xb4\xf2P\u007f~\xe0\xa77<\xc0Ƃ\xa4G\x02 送\x95\xf4-\xbf\x91\xb5\xa7\x18\rS\x88\xfa\xd8\b<I\xbe\xe9\xeaM/\n\xd1\xe2\xc0[\xf1\xfe\xcd7_\xf5Ȗ\x91\xa7\xf6\xc0\x9b\xf0\xfa\rz\x92\x86\x81\xb7Y\x80\xa4\x03\x06Vһ\xc7>\xfa\xb7\v\xbb\u007fLӊ5\xab[\x9f|\xfb\xf3\xd7\u007f\xf6\ve\x04\xe6\xa6\an\x12\xf7\xbc\xf1\xf7tyL\xf5\xbe*\xdbq\xbfw\x1f\x8c<\nK]\xea\xe5\xb1\x1f\xff\xfe\u0085\xdf\xdc\xccƲ\x92~f\x1c\x0e\x1d\a\x92\xf6? 送\x95\xf4\xd5ݷ\x8e\x19s\xebn!\xfd\xe8\x8d\xf2\x99\xa5\xdd?\xbda̸\xff\xbe\xa0\x8a\xb8z\xf5\xbe\u007fu\x9f\xf2z\xe6?\x84\x93X\xca\xf7U\xd9>3.$D\x96\xe7\xd5ߌ\v\x11Ob1\x87\xfa\xfd\xadc\xc6\xfe\xe4u6\x96\x954=\x89\xf5\xc0\x18\x90\xb4\xdf\x01I\a\f\x92\xf6\x02\a<\xde\aI\xfb\x1b\x90t\xc0\x10`\x92\xfeş/\xbc\xf8\xef\x0f\x80\xa4\xfd\x0eH:`\b0I?\xfa\xfd17aE\x83\xa4\xfd\rH:`\b0I\xbb\x01I\xfb\x19\x90t\xc0\x00\x92\x06|\x01$\x1d0\x84\x04(F\x9f\v\x18Z@\xd2\x00\x10T\x80\xa4W\xaf\xd6J\x02@\x80b\x8e\xa4\x95\x06:\bU\x99wK\x93\xbfZ\x9e\xd0H\xbayقI\xc0\x89\xf7~\x19\x1f\xbb\xf0\xe8\xfc7pr\xeb\xcc;\xa6\xde1s;B\xf5\x16\xcbB\x84\x0e\xe0\x88\xa3\xea\xfd\x86\x89\xa3\xf1\u007f\x91\xd2mS-\xb3\xbd\x84z\xe7a\x8b\xe5\x80Q̀\x18\xba\x8aZ\x8dìmFQ\x80.\xe6HZa\xa0\x83\x90\xd3^k\xb0\xc3\xf0\xb1\xd2zI#\xe9\xc6\xf5F}\xec\xf2\xf7\x10:;u遗\x96S\x1d\x1c\xb5\xfcr\xcf\xc1\x17\x96Z\xea\x91\xeb\xa8Ŋ\x1f\x0fX\x8e\xba\xd0\x10s\xf4\xac\xe6\xe6\x83VF\x88\xa7V[5\x83|\xe1R\xfd\xd4\xedF1\x03b\xe8*\xea\xe3\xfa\xfa\xff\xb1\xbca\x14\x05\xe8b\x8e\xa4Y\x03\x1d\xac\xe8\x12\xf3$\xddfY\xaf\x91d\x89']\xf7\xe2\xc5$\xb9\x9a\xb4\xd4\xf5\xb1\xb4\xec\xb18\xd8eY\xb9\x9a\xec\xe7CC\x1d \xf3\x97\x1bE`\xb6\x0f^\xd2\bY\x87V\xd2h(+\xea\x14H\xfa:0I\xd2\x14\xc1@\aU٫\nL\x93\xf4j\xb9g^\xed\xd9I\x13hKM\xd8J\x92\uf456\xbax\x01ݼ`1i\xa9Gq\xb3\xf5\xb9\xa5\x0e\x80\x80\x95\xf4\x90T\x14H\xfaz0QҢ\x81\x0er\xb9ܷ\xe7\xf7?mS\xd7k$\x15Ж\xba<\xfe=\x92>\x88\xdb\xe4BAm\xcb\x17\x92\x96\xda6\xff\x80\xba\xa5\x9e\x9dj\xb1lm[\x99`\xbd\x9f\xdc \xf1\xa5\x85֙\xeb\xe9\xfb\xae'f\xc7.|#\xe1 z\xc4byI\x9e\t\xcb\x01\xf5\x8b\x13\xa6\xc6\xff\x12\xcfG\xffb\x11\x98\x8f\x14|m\xb5\x90=)\x97V\xc6\xc7.\xf7\x1cx\xb7-\x8f\xc7Y\xe0_\xa6N\x9cHXJF\xef\x8fX\xa6\xeeY?Ӻ\xf8cU\xa8u\xfd\xea\xf8;\x96\xb6Ѵ\\\x06\x19\xcd\x1c\x0e\xe2\x12\xfc\x16m\xb7h\xce\xc4\aZQdn\xbd]\xccL>\x1aA\x94\xb4^E!\xf4B\xfc\x1e\x04\xe8`\xa2\xa4E\x03\x1d\x82i\x92^=\xf5c\x8d\xa4\x02\xdaR?N\xb0ܿ\xfd\x14\x1dT\xcc\xff5\xdd\xfc\xeb\xf9\xb4\xa5\xee\xfc\xa5\xba\xa5\xba\x0e\xbc\x94036a\xfdJ\xcb\xc7d\x04\xba\xfe\xe0\xce\xf8\xf9X\xdc_'\xc4\xef<\xf8\xb0ŲG\x9cNJ3a9\xe0\xace偣{\xe2-\xbdd^:sa}}}\x9b\xaa$g\xeb\xebž\xb5-v\xe6\v\u007fYlQK\xfa\xb5\xd8\xf9\xbf;\xbaݲ\x93ho\xf5k\a\x96ZN!\xf4ח\xa6Z\xe2\xb7\xef\x8cUw\xfbV\xcb\xfc\x97^\x9ao%\x02\x94\xcb\xc0\xa0\x99\x83덄\x87/\xa1K[c\xeb5\xfa\xdb\x01WT}\xecVwf\xf2\xd1\b\xa2\xa4u*\n\xb3\xdcr?\x02t0O\xd2n\x03\x1d\x82Y\x92\xfex\xea\xc3\x1aI%\xb4\xa5\xa2\xaf\x9f]0\xd5\x12K\xfa\xa6\xd9+\xe9敳iK\xbdd\xbd\xe49\x9e\x9coY܉\xfb9\xa2\x8b?\"\xd2Bqߺ2\x96\f\xeb\xd7[H\xf7B\x85I\x87\xcdL\xc0\x9ex\xd2\\\xff'V\xc8Ag\xe0-Jz\xe1L|\xc8\xde\xf9*I\xbb\x12\xeeǛ\xbb\x0f|M~WH\x99\x84\\\xac\xb1\xf8\xb7ee\xbc:\xa7\xd98\xc25s\x81\xa2\flf\xda9l'C\x87\x95\x9a'\xfb\x06^Q\xabI\xee\xbf&\x99\xb1Gc\x06ޚ\x15\x85i{\xb6\r\x01:\x98'i\xb7\x81\x0e\xc1,I?2\xb5M#\xa9$\xde}f\xcbu\xf4~\xcbA\xa9\xf3Y.t>\xe8\x97;5$m\x15;\xfc\xe5\tݽ\x98\x04\xdcj\xadt\x92\xf9W\x95\xa4\x99\x80\x8f\xe3\x13\x1e\xd9s\x16u\v9x\x95\xf4\xd74\x17\xb4U%\xe9\x83\x16y\x9d\xfc\xef{\xeeO\x88\x15\x86\xeeV\xa2\x19\x8fy\xb7\xf5\xb7\xe4q\x8f\xe5k\xb6\f,\xda9|ly\x0f\xb9b5\xcfE\r\xbc\xa2^\xb3\xba\x90\xcbZO\x92\xcc\xd14%\xadSH\xc0\x13\xf3$\xed6\xd0!\x98$\xe9K\xd6\xd5\x1aI\x15\xb4\xa5\x9e\x12V\xce\x16.\x15\xfe0K\x85)\":0_C\xd2\xeeY\xf0|qV\xbc\x1cK\x81\xce>]*I\xcb\x01X\xa8{\x96϶\xc4\xffN\xd8ѫ\xa4\xcfZ\xa8\f\xd42\xdd)\x17\xe4T|\xc2\x13\a\xea\x17ϗ\xf6\xf1\x944ͩ\x1e\xff\n\xb0e\x90\xd1\xcb\xe1\xfe'\xd0\xd1\xd8n\xa4\xc1\xc0+\xaa7\xfe\x00z\x99\x0eNأiJZ\xbb\x90\x80\x06\xa6IZ2\xd0!\x98$\xe9\xf5\xb8\xa5y&%z\xe9&\xdaR\xe3\x1f\xa1[\xb6\xceDHlw\xf3\x17\v-\xd5e=\xea)iw\xc3[\x99p\x96\xf2w\xd4+H\xe8=YҴ\x8f\x95\x03\xd0Yr\x9c\xaf_\xb2\xee\x91rx\xc1sr/\xe4\xf2w\xa1\x97V/\x8f\x1d\x95{\xe9\xd9\vH\x99\x96{\x934]\f|\xc1\xd2ɖ\x81A/\x87\xbf\xc4w{\\d7\xe8\x8aZ\xbf\x1c-\xa7\xe5`\x8f\xa6\x96\xb4\xba\xa2\x00\xef\x98&i\xc9@\x87`\x8e\xa4\x8d:\xe9=\xa43\xfc;YmB\xf1\t_\x93-Di\xe2\xe9V\xb2\x03i\xa9h\xf5\xaf\xf5%}T蛷>K\x96\x82Ik\\)H\x1a7\xfe\xde\x05Ve\xc0v\xe1Ҫ\x85tJ\xbf\x10wm\x974\x96\x95Ź\xf4\x02R\x9c6\xabJ\xa6\xae\xf8\x85\xa4\xfb\\\x8fE\x92@J\xd0;ߛ\xa4\x13ȼ{\xf6BE\x19\x18\xf4r\xe8\x8e\xff\xcb\x1d\xeaq\xf7\xa0+\xea\x94\xf5\x92\x95.\x89\xb1Gc%\xadUQ\x98\xb6\xedm\b\xd0\xc14I\xcb\x06:.\xa7\xb3\xa8\xcai\x82\xdd\xc6\x13r\xcf\xfc\x84F'M.\u007f:\xf0\xc7\x05\U00064bcc\xb7\xc4o=z`1\xb9P\xf1\xa8\xe5\xfe\x97\xeb_^ly\x99\\\x14u\xc0\x85\xea\xadʖ\xda{\x8a\xaeW\v\xf9=a\xf9\xf5\x81\x97W\x93E\x9dK\xf1\t{\x0e,\xb7RI/\x8c\xffݳ\v,S\xff\xf8\x1e\x1b\xb0\xdd\x12\xbb\xf5\xe0\x81Ֆ\xd7\xc8~ۭ;_^lU\xf6\xd2\xddo\xd4\xd7[W\xd7\xd7w\xe2\xceޚ\xb0}\xeb\x1dB\x0e\fG\xad\xb3\xf7\x1c\\oy\x81d\xb6|ϳ\xf3\xf10\xfeԥ\xfa\xa9\xabO\xa1\xb3\xab\xa7\xd6+Ϻ[-\xf7\x9f:\xba0\xb6\r\xb1e`\xd0\xcdቄX\xb5}\xd9\xe0*\x8a\x10\xbfXX\xb6\x93\x8f&\\=\xb6\xb3\xbe\x9e\xe4\xa6YQ\x98\xa5\xe4\x02S@\x1b\xd3$-\x1b\xe8\x1c\x13.\xf7\xbe\xe2-z8\xb8d]\xa9\x91d90\xdf\x1a\xbb\x94\xaaf\xc1\v[g[\xe3\x85Ӹ[g\xc6Zbɥ˯\xd1S\xaa\xbd\v\xe2\x15M\xfc\xac0\xe9\x13&\x92\xe8\xe8\xe2\xf8\u0605\aI\xea\xef\xab\x13\xac\x8b\xcfRI\xb7-\xb4\xc6.\xfe\xad\xc5\xf20\x1b\xf0\xd2\xc2\xed\tS\xe3\x17\xbeFws\xad\xbfú\xf0\x14R f,\xe4\xb0\xf4\x8e\x84'\xfe8բZ\xa5o[\x9e\x10\xbb\x80tg\xbd;gZ㗿0s\xea\u0087\xf1\x1eS\xdf#\xa7\xb4\x95\xb1\xb3\xb7/\x8f\x8d_)\xc8\\.\xa4\x8cn\x0em\x16\xcf\x01͠*\x8a\xb0Ӻ\x93>\xcbG\xa3\xd7x\xbbg͚\x15EwS/\xe0\x03\x12\xa6I\xda|~k\xf9\xabFrx\x11\x96\xc7\x02\x1a\x97\xf55\xa3\x90\xe1g\xe9b\xa3\x88\xd1\xcb(\x96\xb4\x19\xffU\x19\x04\x92>\xe0\xd9\xd7\xfa\x9dg-\xaa1\x05 3\x8a%m\x06\x81.\xe9\xed\xaf\xa1\xc5[\x8d\x82\x86\x9d\x8f\xe3w\x1a\x85\x8cb@\xd2\xfe\xa4\xed\xa8e\xbdj\x86\x1cP\xb8,\xf3\x1f\x89\xff\xda(\n0\x15\x90\xb4?YHV\x9aڌ\xa2F0[c\x17\xb7\x19\xc5\x00\xe6\x02\x92\x06\x80\xa0\x02$\r\x00A\x05H\x1a\x00\x82\n\x904\x00\x04\x15 i\x00\b*\xfe?\xb6^u\v\xa5[\x1f\x81\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/ident-func.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03\xd2\x00\x00\x00\xda\b\x03\x00\x00\x00}\xf6\x8a\x1c\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\x01\x04\x00\x02\x05\x01\n\x03\x01\x05\b\x03\t\f\b\t\x0f\x11\x0e\x10\f\x10\x12\x0f\x13\x15\x12\x15\x16\x14\x0f\x17&\x19\x18\x11\x1a\x1a\x13\x1a\x1c\x19\x1c\x1c\x16\x13\x1e7 \x1f\x19!# $$\x1d#$\"$%#'(&)(\"+)\x1e\x14+N++$*,)/-\"-.,.2402/63(241:7+685;9-:;9?<0=?=C@4AB@CEBGE8KH<MI8HIG\x00f\x00\x00i\x01JLI\x00j\x02SN=MOL\x05m\x051S\x96WRAQSP\fo\t\x0fq\vUVT\fr\x175[\xa4XZW,`\xae7]\xad\x15w\x1cb]K\\^[9a\xab\x19y\x1e;c\xad=d\xae`b_)z!?f\xb0)|*Bh\xb3egdLi\xafDl\xb0qjRikh/\x82/Ho\xb3/\x859Jq\xb6mol;\x86:Ut\xb4Xv\xb6?\x8a>|u]tvsB\x8c@@\x8dG\\z\xbby{x]~\xb7e|\xb8\x84|dK\x90J_\x80\xba}\u007f|O\x93Nb\x83\xbd\x8b\x81cN\x95Ud\x85\xbf\x81\x83\x80W\x95Vl\x87\xbc\x8f\x86hZ\x98Yo\x89\xbe\\\x9a[\x87\x89\x86\x93\x89k^\x9d]\\\x9dds\x8dË\x8d\x8a\x96\x8doz\x8e\xbfe\x9ef\x8d\x8f\x8c|\x90\xc1\x9b\x91s\x90\x92\x8fi\xa2i~\x93\xc4x\x95Ā\x94œ\x94\x91{\x98\xc7s\xa4l\xa0\x96xq\xa5s\x97\x99\x96\x83\x9bţ\x99{\x99\x9b\x98u\xaaw\xa7\x9d~\x87\x9fɜ\x9e\x9b\u007f\xabz\x89\xa1˫\xa0\x82\x9f\xa1\x9e\x8f\xa2ǡ\xa3\xa0\xa2\xa4\xa1\x92\xa5ʂ\xb1\x85\xa5\xa7\xa4\x94\xa8ͳ\xa7\x82\x8b\xb3\x89\xa7\xa9\xa6\x96\xaa϶\xa9\x84\x8e\xb6\x8c\x9d\xac̪\xac\xa9\x8d\xb8\x93\xba\xad\x88\x9f\xafέ\xaf\xac\xa1\xb1ѯ\xb1\xae\x97\xbb\x97\xc0\xb3\x8e\xa5\xb4Ԛ\xbe\x9a\xb3\xb5\xb2\xab\xb7ѵ\xb7\xb4\xa3\xbf\x9d\xa2\xc0\xa4Ÿ\x93\xb7\xb9\xb6\xae\xbaԹ\xbb\xb8\xb0\xbc֦Ũ\xbb\xbd\xba\xb2\xbdض\xbeӽ\xbf\xbc\xa8ǫ\xafƫ\xcd\xc0\x9a\xb9\xc0տ\xc1\xbe\xba\xc2ײɮ\xc2\xc4\xc1\xbc\xc4ٲ̷\xd2Š\xc4\xc6\xc3\xd5ƚ\xc0\xc8ݻ\xca\xde\xc7\xc9ƻκ\xd8ɝ\xc0\xcc\xda\xc7\xcb\xdb\xca\xccɿҾ\xc9\xcd\xdd\xd7ϡ\xcd\xcf\xcc\xc4\xd0\xde\xdfϣ\xc8\xd3\xc1\xcc\xd0\xe0\xcf\xd1\xce\xe1Ҧ\xc9\xd7\xcb\xd2\xd4\xd1\xd2\xd3\xdd\xdf֨\xcd\xd6\xde\xcc\xda\xce\xe6֪\xd6\xd8\xd5\xd0\xd9\xe1\xd8\xd9\xe3\xd5\xdc\xd1\xd3\xdc\xe4\xda\xdc\xd9\xe6ݯ\xecܰ\xd5\xdf\xda\xdc\xdc\xe7\xdc\xde\xdb\xda\xdf\xe2\xd7\xe1\xdc\xe0\xde\xe2\xde\xe0\xdd\xf0\xe0\xb3\xdf\xe1\xde\xdd\xe3\xe5\xe1\xe3\xdf\xe3\xe5\xe2\xe1\xe6\xe9\xe8\xe5\xea\xe5\xe7\xe4\xe4\xe9\xeb\xe7\xe9\xe6\xf1\xf3\xf0\xfa\xfc\xf9\xfe\xff\xfcd\x82\x05\xe8\x00\x00 \x00IDATx^\xed\x9d\x0fT\x14\xd7\xdd\xf7\x1fZ\xf3\xc6\xe6M\xda\xd7Q\xf6\xe9S\xe2K\xa9%F\xdbd\x95x\xdeJ\xa0fN\\@\x13\x90*\x82Ę*M\xa2\xb4Q⟜h0\xc4\x1c\xff\xb4.\xc1@\f\th\"I\xa4\xc1\x83A\xa4V\xadx\fA\x03\x96'\xc1D\x92\x87\xa4\xa6nj$QL#\t\x1c\x16\x02\xb7\xf5\xbc\xf7ޙ\x9d\xb93;\xb3\xb3\xc0\xee\x0e\f\xbf\xcf\xd1ݻw\u007f\xf7\xcfܹ\u07fd\u007ff\x98\xdf\u007f\\\x1b<\b\x00\x80\xe1\xc6\u007f\x18\xe9\xd6\aFy\x03\x00\x10r@\xd2\x00`)@\xd2\x00`)@\xd2\x00`)@\xd2\x00\x10`\xfa\x8c\f\x82\nH\x1a\x00\x02\x89+c\x127\xc7\xc8(\x98X^\xd2e3یL̤}f\x99\x91\xc9Hd\x14\xb7\xfaԩ\xce\xcaO\x8c\x8c\x82\x89\x89\x92n\xdeWTrB\f79\xcb}\xda~\xb3y^bN\xbfO\x13m\x9e\xe4\xd6\x19\x99\x04\x8as9I\xa9\xb9\xa7R\xbfR\xc7\u007f\xee\xe0\xefӲ\x17xr\xc2\x06\xaf\xb8\"\x0e\x135\xfb\xa4\x869Ck87\xd5_[?!\x99\xadC\xeb\xf0k\x81\x0f+\xa1`_\x04\xbeիxLr\xce\xfbFv~\xa2\xd5ꁡ\x81\xdbgd\x12dL\x93\xb4\xbb\xd2y\xb4\xf5\xa4\xb3\x85~h/8\\\xec\xd3\xfa\x91Ԋ\xbc\xa4\x0e\x9f&\x9al\x9dPdd\x12(\xea\x93~Sqp)\xcf\u007f\xa4\xfe\xa2\xff\x9d\xcd\x0e\xad\x04\"\xe5\xe1[\xd5QW\x8b\xb8\r\xd5E3\xb9j-{\x99\xa3\x196\xbfm}S-\xfe\"\x90\xcc\xdaPۓ\\\xd1U_\xe6\xb4`\x1f\x04\xa1ջ\xab\xf8\x97NUe\xddu\xca\xc8\xd0\x17\xa7\xceJA\x8dV\x0f\f\xb5\\\x8d\x91I\x901Mҕ\x05.\x84ڜ\xcd\xf4Cy\xa5˧\xa4;\xf8\n\xd4\xdf\xed\xcbB\x9bV\xdbr\xdf\x06mq\x81\x9a v$\xaf\xe9\xc5=/\xd3[\xd2\b\x95\xfa\x924Zis\xa9\xa3\x9a\xe8O\xfd\xcc)\x1a\xd6,\xebl\xfe\xdb\xfadF\x8a\x18\x102\xab\xe6\x9a|Y\x8b\x05\xeb\x12\x94V?\xc7\xd7\xe3_\xc7\xecL#;_d\xad\x97\xc3\x1a\xad\x1e\x10j\xb9\xa3F&A\xc6,I\xbb\x9c\r\xe4M\x18\f\x9a\x8aܾ%}\x81?\xee\xebk]2&u\xfa6h2\xea\xbc~S\x98t\x99\xbc\xed\xe5?\xf5\xfeη\xa4;'e\xa8\xa3\x04em\xe5\fj\xcfH\xda\xd0\xd6'\xd3\x03*頴:\x954\xaa\xe0\a\xf1\xc3.\xb1\x94\x91\xb4F\xab\a\x84\xd1+\xe9\xa3\x05=R\xf8jA\v\xf2!\xe9\xdey<%\x1f\xa1m<\u007fP\\\x9bn\xe3\x1d\x15\xf9\x99I9_P\x9b\v\xeb\xe79RŰ\x8c{\xa24\\\xb4\xa4D\x85O\x9a\xad\xfca\xde:\xa5\xbc\x99k.\x9f\xe2\xc4\xe1ƜtǼ\x9ct\xb2\\\xef\xaf\xcaJ\xca\xcc\xc7]\xe7C\a\xcf０\x97\x9e\x98\xf3\xedA\\~)*\xe5I\xf9\x9a\x06(s\vͳc/\x1e\xab\xfb+\xb2\x92\x96VХ\xff\x17\xb9i\xc9녉\xb7\x94\f\xa9\xea\xbb2\u008d\x94\bʚ\x1fM?\x14ό\x98\xb2\x8c\x88\xe4j\xca$[\xf4\x1c\xfaS\x88\\\xf3'E\xa6dȒVۢ\xce\xe5S'\xc6\x1d\x8dއ\x96p\x13\x8a\xf1\xc0).\u007fe\x83\x9aY\xd1\xe1Q\xb3q\xb2rN`:RIڠ`٠!\x9c\xe3V\xb6̟\x1c1\x9b\x9cTO\xab+c%\xe4Vg\x9a\x8f\x9c\xcd-i\xc9k.P\x13\xad\xb3)H:7\x8d\x84\x99\x96\xec.\xbc/)\xfb\x9d\xb4z\xb6k(\f\xa4\x13{\\\xe8E|\x96\x98\xa1w\xabk\x1e\x90\xf2(\x9c\xd3#\xa6\x93\xee\xa2sl\x88\xb4\xddh\x95tYy\xf3ng\xf1aڪ\xe5\x95ȗ\xa4\xd1G\x8d\a\xf9\xd2\xc6F<\n~\xd1\xe8(\x15צ\xe7\x0e:\xf8\xd4\xd2W\x92\xe9\x0f賓\xacW\xeaK\xf9\xbd\xaa\x84'\xa5\x15f\xf5\xc4\xe9OV\xae\xe36)\xbev\xcd\xe7\xa6r\xb7s)X\xe8\xefߕw\xa4\xbeb\x1e\xff-\x8e\xde\xc2\xe7\xd7W\xa4.\xedG\xbd\a\x0f\xa6gޓ\x96\x9f{\xd7\xe7ݍ\xc9/|\x85\xbez!\xb9\xb1[۠\x97-<ϱ\xb3~\xa7#\x0f\x87.$gV\x1d\xcfᩤ\xa5d\xea\xfa\x1e\xf6\xea\x05M\\\xb9\xbby9G\xb7p2&,)\xdf\x1a5\xbd\x8fh/\xa3\xbad΄Z\x1c\xd92qJQ\xd9,Φk\xdb>9\xea\xc9\xf2%\x1c\xe7D\xae\x9a\xf0u\xd2\xf2W6\xa8\xe5\xe6\xef\xaetFq=\xa8\xf3p͔\xb8\x9a\x9a\x9af13\xb7{\x1f\x95\xb4Q\xc1\xb2\x81\xbb\xa48z\xca\xc4\xe8e\xf39\xb2\xd5\xebiue\xac\x84\xdc\xeaL\U000d1cd9^Z\x9a\x9et\x0e\xe9\x9cM,\xe9\xeeO\v\xf1\xef*b[\xb2#=yo=Vs\x05\xdb5X\x03\xf9\xc4v76ff766zfQޭ\xaey@\x8a\xa3Ȱ\xad,_i\x9b\xaf{l=m\xd53\"\x872]\n\x04fI\xba\xc4Y\xdc\xe0j..\xc1\x9an.\xea\xf4-iv\xe2\xed \xe7T\x98\xc8:\x92\xf1\xefx^*\x0e\xf5\xa6\xe7\u0c71\xf7\xa0z\xff\xac\x9ck\x15\x02\xee\xe8\xd9nr\x1e\xdaU\x06\xfb¹p\xbaAY\x91J\xc4\\\x91\x8c;\xc1q\xbe\n\aϒ\xe1\x18O\xd5\xf8G\xba\x85U\xfc\x96\\\xfc\x92K\x86bM\x83\xcf\xf9\xbfH\xb9\xd6\xd3\x01\x85\xbefg\xe2\xb4\xfdK\x1d\xcad\xaa\xfa\xba\xb8\xddHI\x13\x1d6\xe7\x93`9G\xb6\x9aj\xb9\x17I\xfdIo\xb9\x9d\\\xf4\x9c9\x19\a\xfb\xa6\xdbtm\xe7G\x92\x19\xc92\x8e\f)6\xb2\xfdL\xe7ʌ\x813\x8a\x8c/[#iy\xcc\xc4[\xa0ɏ\x82\x19\x03\x9c\x037몸\x8e\x92Z]\x11\xcb \xb5:۾\x8e\xf4n\xa2\xd0,\xbd\xb3y\x8e\x0e\xb1y\xe4\a\x91i\xc9<\xd2\aP>\x964\xdb5\x18\x03\xe6\xc4*'\xde\x1a\xad\xaew@Rp\x1f\x9d\xc3\b\xaf\x9a\xc76\a7\x9d\xefK7!\xc0,I\x97\x17\x90\xc6\xe8,\xaaE\x9d\x05\xcd}}}\x9f\x14\xfb\xba\xe5F[\xd2y\x9e`\xbd֞\x14\xa6\xccӹʹ\x06\x8d\xafۗ٢\xb9I\xb6eX\xe8\x97\xd3\xd2\xf3+>\xea\xc7]\t\xe5\xa6\xf7~\x8bI\xa3\x13饎\xcfE\xe3S\x89ݨ;锞A\xafC\x1eT\xb6\b\u05ec\xee\xdbL\xb7\xf50;\x1d\xcad\xaa\xfa\xba\x84N\xc4\xd0\xc4m:Z>3\x82\xd4>e\xb2\xbb\a\x13MV~m\xceٓ'r\xb7\xe3\x9aS\xa9\xa2\x956]\xdb\bz\x15\xa9Y%i\xc6\xc05i\xf2\x12g\x03\x12&\x9f\x8c\xa47\xd5\xd6\xd6n\"\x926,\x985@\xd3m\xd2pU\xc6HZ\x8e\x95`Z\x9dm_G!y\xad\xe0;t\xce\xe69\xfe\x95\xb3dz\x12\x89\xb9ܒ\xfdI\xa5\xc2wJI3M͜X/I\xab[]\uf024`\xc6\xed\xf4m\xaa\xda@\xe2\x93}Ω\xa3v\x94\xae\x16~\"\xab\xcbP\xabӃ\xfe\x16\xa4\xb6\xa4\xa5\xe0^\xbeW3\xd9Q\xcf\xdcj+\xe7\xbdnB\xe8\xc9('^\xd5m\x8d\"s֎\x8a\xf5\x99\xfc\xbc\x97\xfa\xc9\xc0!\xb0\x86\x98,\xf5\xac\xbcз\xc9GБy\xe4\xc7^\xdb@\\K\xf7\xe2\xa1\xf9a\xfa\r\xca\xc9\xc2\x03E#\t\xd1J2\xc9T\xf5\xad\xe5\x0e#%tI\xdb>\x81\xc8g\xba8n\xe2!\xb2vR\xf4\xf2\xdd5q\xb8_\x9d\x10\xae\x94\xc8\xdbcj[q\b\xba\xaa\x924\x93\x19jw\xa6L增\xa4\xe5im\x8f\x19\x16\xccf\x86\xa6ϐ*\u007fT\x9e\xd12\xb1\x12l\xab3\xedK\xcf&j\xe4\xcf\xea\x9cM\xba\x96\x16~\"\xe5\x96\xfc\x82?B\xbe\xebVI\x9a=C\xf2\x89UIڻ\xd5\xf5\x0eH\nΜM\xdff\xcfP\x19\xb0\xd4p\xb5\x9a\xf1\xa1\xc3,I\x9f,\xa2\xa3r%\x9e\xa6\xb4\x11\x9a\x8a\xda|\\\xd8PIz\xa7Jҧ\xf8\x0f5\x93u\xda\xc4;\x1e*9\xcd[1\xdct\uf568\xfdl!Y\x98\x1dL\xac ?\xf1g)t\xde\xc7t\x82\xfc5h}>\th\x1b\x14&\xd2\xcf\a\xf9\xaf\xd0\x16a\x97-=\x0f}#\x8c\xd2y\x0ee2U}\xd7\xd9\xd4SSAY\x13I\xed\xe7O>I\xc1\xad3u&\xa9j\x8a<X2\xdbc*\xdb>a\x94n\x92%M\aV&\xb3\x13d\x0f\xeb\xea\x8b\x114#*\xe9\x82O\x14\x926,\x981`~\x14\x98VW\xc4\xcaȭζ\xaf\x83\xb6-\xd9\xd1\xd6>\x9b\xc2\xf6X29\xe7rK\x8a\xa3\xf4G\xb2\xa4w\xaa\x9a\x9a9\xb1biU\xe2\xbc\xc0\xbb\xd5\xf5\x0eH\nfL\xa6o\x933T\x06,\xa3wǻ\x9d^ĺZ\xe0\xb9}\xccߵt\x12\x9e\x9f\xf5\xffF%\xe9\xee\xd4l\xf2Þ\x9f\xafN\x972E\x98\xcewN\x8a#]h\xc92\xb5\x81+R\x98\x1a\x94\xd2\x0e\x83\xb27\x93Y1]$\x17\xbeD^\x19I\xbf\x9bx9\xf1]\x12\xd06\xe8H^O\xf6\xba\xb3\xd3=\x06\aI\x96Y\xe9\xb8[}\x9a\xe8P&Sַo\xeal\xa4BP֤e\r\xeb\xf0ʭ\x84ĬăZ4\xe9D}\xd3\xc9\xecoF4\x9e\xb7\xb6\xd8l\xba\xb6)Q\xa4cΧ\n\x8c\xc0\xea\xed\x9bAl\x19\x83u\u008a0n\t}\x8dÿ\xac\xe4;F҆\x053\x06\xca\x0e\xeeiu\xddn\xefiu\x85\xa4\xe7\xe1\xb5twz\xb6\xbauZ7\b\xd3xAҩ\xf9\xe7Jٖ\\?\x0f\xb7o\u007f\x1e\x95\xb4\xdc5\x18\x03\xe6\xc4\xe2W\x9c\xfbW\xc2wZ\xad\xaew@R\xb0\x9c\xce\xd5_\x14\x96\xcb i5'\nN\xb8\x9a\x8aw\xf7\xd0\x0f}\xae\xa6\"\x97z\xefJB\xd8\xf1~\x87Ν\x1eN}\xa94\x8bwT\x9d\xbb\xdc\xe8\xd8\xfcN\xff\xfb\x9b\x1dd'\xfcT\xe2}\x15\xf5\xc2&\x89\x82\x96\t\xe2\x1ew\xb5m\xaa\xb3|\x89\xfem\x8e\xa5|R\xe9\xf1#[x\xb2V.\xbc+\xf7\xc8_\xb6\xe03\xff\xed\xbbt\x8fT\xfcU\xefO\xcbI\xa3U\xd01\xa8Oz\xb8\xeax\x8e\x83̴s\xf9\xc2\xe3\x85<\xd9O;\x97\x94V\xba3\x99ԗI\xa6\xaa\xef&\xef)\x84pWa\xdcl\xb2x[Υ\x94\x94ep\xc5D\x85)\xce\r\xd3\xf1d\xf9(j\x8a\x88^\xb72rBxQ\xb3\x8e\xadkR\xb4s\xf7\x1c\x1b\x95\xf4̨\r\x1bfr\xc4V\x91\xd9\xc4u\xe5\xbb3\x84\xdd\xe9u\xb6Me\xb3\"\\ʻnj\n\x96\rz\x8e\xd2=s\xcf\x12ZluU\xac7\x8a\xe6s\xf0Y\a+2\x93\xc9~\xb4\xa2u\xe6p\x82\xf4\x04Ig\xe7l^ʶ\xe4\xe5\xd4\xf4\x8a#k\x12\xa9\xad\xd45X\x03\xf6\xc4\xe2\xdf\xff\xbdG\x1e\x11\xee\x1f\xd0ju\xcd\x03R\x1c\xc5\xfc\t\xcb˗O\x98\xef\xeb\xd8Nx\xcd\xe7C\x8di\x92F-eE\xbbO\b\x8aF.\xb2\x94\xd6\x1b\xa7{\x93\xe9\xc2\xc8A\xaf>\\\xc8N\xbc'g'\xcfo\xdbF\xa2>J¯\xdbp\xf4\xa7\xeb\xd3\xee\xc9:\xe2\x9dv\xa5Ml\xe0\x96\x94\xe8\x893\xd4[\x9c2U٥\xe9\x8e\xd4l\xe1v\xc3\xfa\xecy\xc9ٸ\x03}(\xac\xc8rD\x9b\xbd\xd2\x0e\x98\xb6\xc1\xb9\x9c\xa4yk\xe8\xceN\u007f\xc5R\xcfu\xe9\vk\x92\xd3\v\xab\x1c\xb4\x92\x9edHQߚ\b\xaf\xb9C\t^\xd0\xe1EnÔ(2\x1e싋\x8a\x9cId۷i\x8a-*\xa5h\x8a-\x0e\x1fϜ\xc8\xc9ˊ¹%:\xb6\xa8-#:b\xd6\t*閸\x88\x89\xb3\x96s\xdc\x12֠8n]t\xf8\xa48\xf1zӒȈ\xb8Z\xf6\x1eo\xa7a\xc1\x8cA\xc3\x04\xba\x06\x95\x86=\xa1\xd5ձ^(\x9aϑ\xbf%9-O\x90\x1b{6\x8b\xa2\xe8T\x9f\xdc\x18\xf0\nn\xe3\xccyd\xbe&\xb7dǖ\xf4\xc4G\xceRIK]\x835P\x9c\xd8\xde\xfc\xe4\xc4l\xe1\xa6P\x8dVG\x9a\a\xa4<\x8a\xad\xb7Gܾ\xd5+\x96\xa5-<\xa5\xa1\xcdԿ\xae4Oҡa\x99\xad\xc4\xc8\xc4\\^\xb4e\xf4\x18\xd9\f\x9aNa\xe9\x1br\x06\xd1\xea\xc2\xf6\xd8\xe0\xe8\xf6\x9e\x9f\x19\x10\xc4V/\x9b\xca\xc1\x1fW\x06\x95M\xd1\x03\xbf\x9f8\x84\xb4O\n֟\x04\x11̒\xf4 Z=\xa4\x92\x0en\xab\xb75\x04\xe7\xf6q?\xb1\xbc\xa4G5\xa6Iz\xe0\x84TҖ\x06$maZ\xf6q\xcb\xcc\xde\u007f\xf5\x8f/\xe8f\xa7\x91\x95\x0e\x17\xea\xf9\xfcw\a\x9b\xd8z\x80\xa4-\xccL\x8e\xe3\xc2[\x8c\xac\x86\x03t\xb3\xf3s48\xb2I\xe2\vFV\xa3\x06\x904\x00X\n\x904\x00X\n\x904\x00X\n\x904\x00X\n\x904\x00X\n\x904\x00X\n\x904\x00X\n\x904\x00X\n\x90\xb4i\x1c\xcf\xfa*\xb8\xae\\\x80Q\x89\x89\x92\xf68\xd0q\x17\xd1\xc7\x14\x15i=K\xc8¼ė\x92\x9b\x18\x83\xe7\xca\x05\x18\x9d\x98&iفN\xbb\xb3\xc1\x85\x19\xe8\x9f\xee\x8c<\x18\xff-\xe4\x91<UB h\xae\\\x80щi\x92\x96\x1d\xe8\xb4;\xbd\x1f\xb5hIX\xff-\x17\x84'b\x12\x82\xe5\xca\x05\x18\x9d\x98%iƁΨ\x914\xfb\x80\xca-\xa9\x92'\x98`\xb9r\x01F'fI\x9aq\xa0c\xa2\xa45<\xb5\xb0Nq4=\xb5\xf8a\xab\xe5\x8dG\u9fe5\xf7\x1ei\x90\xd6v\xe5\x02\x00\x83\xc4,I3\x0etڝ\x958XcB\xb7\xd6\xf2\xd4\xc2xu\xd1\xf6\xd4bl\xab\xe9\x8dG\xe9\xbf\xe5}\xe1\x01\xdf\x02\x1a\xae\\\x00`\xb0\x98%iƁ\xceU\x1a,y1\xe4\x9a\xd6\xf3\xbb#yu\xd1\xf1\xd4bd\xab\xeb\x8dG\x9ex׳\x0e.\xbd]\xb9\x00\xc0\xa01KҲ\x03\x1d\x84\x9a\x88\x98\xddE!\x1f\xaa\xf4\xfc\xeeH^]t<\xb5\x18\xd8\xea{\xe3\x91%}\x84g\xfe\xde\xdfە\v\x00\f\x1a\xb3$-;\xd0\xf1P\x13\xf2\xa1J\xcf\xef\x8e\xe4\xd5E\xc7S\x8b\x81\xad\xbe7\x1eY\xd2\xef\xf0\xef\xc8yx\xbbr\x01\x80Ac\x96\xa4\x19\a:\x95\x82\xaf\xbf\xear\x9f\t\x82\x80\x9e\xdf\x1dIz:\x9eZ\fl}{\xe3\x11\xfc\xb7t\xb3O\xcf\xf3v\xe5\x02\x00\x83\xc6,I3\x0et\xca\xe9\xf0\xdc^\xd4`\x90$\xe0h{jad\xaa\xe3\xa9\xc5\xc8V\xcf\x1b\x0f\xeb\xbfe}\xa6\xf4\xfc;\rW.\x000h̒4\xe3@\xc7\xe5\xdc\xd7\xf2ɉ\x82\x90\x0f\xd2ڞZ\x14^]\xb4=\xb5\x18\xd9jz\xe3AJ\xff-\x9f\x12\xdf\x11\x02Z\xae\\\x00`\xb0\x98&iƁN[eqQy\x93\x91}0\xd0\xf0Ԣt\x8a\xa3\xe9\xa9\xc5\xc8V\xd3\x1b\x0fR\xf8oA\xe8\x85D\xf12\x96\xb6+\x17\x00\x18$\xe6Iz$\x12\xc0g\xc0\xf7\xe7;\xe8\xd0\x1dDW.\xc0\xa8\x04$=\x10\x02(iԿ7\xad#خ\\\x80Q\bHz \x04R\xd2\x00\x10\x14@\xd2\x03\x00<\xb5\x00\xc3\x1f\x90\xf4\x00\x00O-\xc0\xf0\a$\r\x00\x96\x02$\r\x00\x96\x02$\r\x00\x96\x02$\r\x00\x96\x02$\r\x00\x96\x02$\r\x00\x96\x02$\rX\x95>#\x03k\x02\x92\x06,\x89+c\x127\xc7\xc8Ȓ\x80\xa4G\x1f\xd4s\xcf\xd0\x19\u07be\u007f\xa6NuV\x9a\xf6\xe4YS1Q\xd2\x1e\a:\xca`h\xa9\x8c\x92\xfeL\xbb}IT\xc4lS\xe6j\x9f;\xf8\xfb\x8cl\x10y\xae\x12\xe6\xae\xcc\n\xbf\xefH\xd5\xc9W\xf4\xdc\xd3>+\xf2I\x8do\a@\x80}\xff\x94G\xfa\xff'\xf3\x9e\xf3\x96\xc1q\\D\x8b\x86A\x03\xb7O#vT`\x9a\xa4e\a:l0ԔGHO<\x9b5ə\x11\xd1\xee\xcb8X\xf4\xbf\xb3\xd9ad\x83\xe9x\x89\xafj\xac\xcf\xe5_02\xf4\xa0\x9d\xaf\xc7sϲ\xc9ON\x18\xa2Ӣ\xc0\xfa\xfeY\xce-72\x91\xf0\x9c7WM\xcdV\xcdG&\xd7r5\x1a\xb1\xa3\x02\xd3$-;\xd0a\x83\xe6\xd1\xce\xe1\xee\xd9id\x15$J\xfd\x914\xaa\xe7\xcfa\x9dnc\x9f\x17l\x80F\xbe\x92\xe7\x9e\x19\x1bP\xc4P\xbb}@}\xff\xac\xe4V\x1a\x99hQ\xab#\xe9\x90?pv\xb8`\x96\xa4\x19\a:L\xd0DZ8\xff\xa7}\x01g\x00\x92F\xbd\xc9ی\f%4\xf2\x95<\xf7\xdc^\xe4\xe2\x86:1\n\xa8\xef\x9fu\xdc:#\x13-@\xd2*̒4\xe3@\x87\t\x86\x96\xf6\b\x8e\x9bPLB\xee(\x8e\xe2\xf5Ƞ\xe2\x99\x11S\x96ᱻ!\x9c\xe3V\xb6̟\x1c1\xbb\x87\t\xaa\x8c\xc5\xc7\x17\xb9&\n\x99q\x13UC\x98\x86\xbb\x1e\x84\xbe\xc8MK^/L\x90\x19\x17<\x9a\xb6\x82\xa4Ѷy\xba\xb6\xfd\x15YIK\x85ŶN\xbe\xb2\xe7\x9e\xd9+\xe7\u070e\x8f%\xbcY\xbb4\xff\x1c\tɾ\u007făW %c2S\xe4\xab\xe0I\x8e\xae\xed\xb5\x9bo\t\x17\xee\\6%b\x16\x89\x93\xcf\x1bA[\xbc\xd5 \xe9\xc1`\x94\xb7/\x18\a:L0Ĝ\xa8\xa9\xb1\t#CC͋ܺ\x9a\x1a\xf542c\u0092\xf2\xadQ\xd3\xfb\x90\xbb\xa48z\xca\xc4\xe8e\xf3\xb9O\x98\xa0\xcaZ|Ƞ\xbbh\xab\x80\xcac\xb6\x96\xbb\x1et!9\xb3\xeax\x0eO\xa5'\xbb\xe0Ѷ\x15%]\xc1w\xeb\xd9\xe69v\xd6\xeft\xe4\xe9\xe7\xcbx\xeeY7\xd1v\xa2gv\xdcQ\x9d\xd2\xfcs$$\xfb\xfe\x11\x0f^\x81\x94\x8c\xc9L\x91\xaf\x82\xad\x1c]\x99k7_sq8\x17\xb5n\xd3Dz]J>oHS\xd2=m\xd53\"\xcdZD\x99\x8eY\x92f\x1c\xe80\xc1\xd0\x13\xe1\xe9\x1aZ\x13\xefr\xae\b\x91>C\x9daL\xe7f]\x15\x97\aL\x90\xc5\xf3(\xe0\xb6V\x01\xe5擶\xbb\x9e\xecL\xac\xcf\xfe\xa5Dz\x8c\xb3\x1dm[Q\xd2\xc4\xf9\x8e\xb6m=}\xda0}\xd5Η\xf5ܳ\x81s\xa2\xab\x11䠇\xe0HH\xf6\xfd#?\aYB\xe9=ȓ\x99\"\xc8\xe2\xe4\x84q^\xbb\xf9\x90-\x12\xff\xe0Ώ\x12?E\xf8\x92\xf4\x1c<ƛ\xb8\x8c2\x19\xb3$\xcd8\xd0a}\xe9\x84\x1c\x9f\x92N\x99\xec\xee\xc1D\xd3\x05\xe3t\x9b4*3A\rZ9\x0f\x8aN\xae鮧C\xd0\xc6N\"=\xc6َ\xb6k\x1fQ\xd2U|\x87\x8e\xed\x16\xe1\x9a\xd5}\x9b\xf5\xf2e<\xf7\x94p\x91\xcbЦI=hH\x8e\x84|\xfa\xfeQz\x0frH\xa32\x13d)\xa2?\xa0z͇l\xe4,\xac\xb3\x89\x9f|J\xfa\x93}Ω0J\x0f\x06\xa3\xbc}\xc18\xd0\xf1\xf6\xa5\x13B|Jz\xbaط\xe8lo\xfa\f9^\x0ejQS.\xa0\xdcO\xd6t\xd7sV\x98\a\xd3m,\xc6َ\xb6k\x1fQ҅\xc9z\xb6\x0fS?=('K/_\xd9sO[IJj[\xebdz\xf4Cp$\xe4\xd3\xf7\x8f\xd2{\x90'3E\x90\xe5p\xa4\xa0M\xed\xe6Ct\xaaퟤ15\x9c)#\xc4p\xc0,I3\x0et\x98`\xe8\xf1)\xe9\xf9\x93OR\xe8\x14pz\x8a\x14\xcf\x04\xfdG\xd3]\xcf7\x826\xf2\x84\xd1Tr\xb6\xa3\xed\xdaG\xdc\xf1N]\xafg\xbbEpi\x9d\x9e\xa7\x97\xaf칧\f\x8f\x81s&O\xa4\xd7\xe1\x87\xe0Hȧ\xef\x1fo\xefA\x02Lp\x00\fLҰ\xe3=(\x8c\xf2\xf6\x05\xe3@\x87\t\x86\x1e\x9f\x92\xdeǕ\x90\xb7\x95\xf4&)cIk,'\x19\xb4\xdd\xf5d\xa5\xe3\x0e\xffi\"\x91\x1e\xe3lG\xdbV\x90t!\x11\xa0\xb6\xad\x10{\x90\xac\xa5\xb5\xf3E\x92\xe7\x9e\xdd\\\vj\xe0RP_t\xeb\x10\x1c\t1\xbe\u007fZ\xd7y]\x11S\x14\f\x92\x0e\x15fI\x9aq\xa0\xc3\x06C\x8a\xfbhM\x8d-\xa3\xa6\xe6\xaag\xc7۫\x17,\xe7RJ\xca2\xb8b\xd4s\xb4fJ\\M\r\xe9\xecLP\x85֦/\x83\x96\xbb\x1et.)\xadtg2\xef\xa8:\xa7p\xb6\xa3e+\xdc=\x96\xc7\xd3qR\xdb6\x97/<^\xc8\xe7\xea\xe7+y\xeei\x8bH\xd9\x1d=ŶdCx\xdb\x10\x1c\t1\xbe\u007f\xe6p3\x91\x1a)\x19\x93\x99\"_\x05\xe5\x13}\xcc\xd3\\5\xe1\x19G\xd1Ɍ\xf0\x1a\x17{\xde\xe8\xddc[kj\xbc\xf66N\x8c^o\xa0\xa6I\x9aq\xa0\xc3\x06CI\xed\x04a\xa9\xecD\xeeH\x1a\b\xf7\xba\x81m_\\T\xe4\xcc}X\xf2\x82)\xe9\xecLP\x85֥Y\x16\rw=\b]X\x93\x9c^X\xe5\xe0\xc9\xfd#\x8c\xb3\x1d\r[z\x8f7\x9f.Ny5m\xfb+\x96z\xaeK\xeb\xe4+y\uea5c\x12\xb5\xa4\xb3rJ\xa4S\xa74\u007f\x1c\t\xb1\xbe\u007f\xb6ڢ\x90\x17\x9edLf\xca|Y\xf6E\xf9\xb8-{\t9=M\x11\xf8u\ts\xde\xe8=\xde\x04\xafiS[xJC\x9b)w웎y\x92\x06\x82B_\xfbU\xdfW\x03=\x9e{\x86\x82\xb0=\xa6\xf4\xfd3'N\xcf\xda\x14ʦr\xf0Ǖ\x03\xc6(o \xf4\xb8&\x8d\x193\xc5\xe5SԂ\xe7\x9e!A%\xad\xf4\xfd\xb3a\xd8]\tnk\b\xe0\r\xe8#\b\x90\xf4\x88\x81\xf7\x83_\xfe\xd7\xff*.\x18\xf3_\xbf\xd4\xfe֨\x04\xbf\xf1v$\xe4\x8aڪi\t\x84\x1c\x90\xf4\x88A[\xa6J~\xf9\xbf\xe7\\\xbb\xf6\u007f\xff\xcf\xff\xd3\xfe֨\x04\u007f\x01GB\xc3\x19\x90\xb4\xa5\xe8\x8cL\xb9v-\xf2\xf6\x96\xe0\xde\\\v\x8e\x84\x863 iKA%=\xf1\xf6\xe6\xe0J\x1a\x18\u0380\xa4-\x85 i[ܬ&\x10\xf5h\x05$m)\x04I\x8f\x8d\xfc\xfe\r\r\xbb\xcb\xdbC\u007f\xa9\x1f0\x1f\x90\xb4\xa5\xa0\x92\x9e\xd4~\xad\xe7;aaa\xb6\xa3\xaeNP\xf5\xa8\x03$m%\xfa\xae\x12I\xcf\xc6\xe7\xe6\xfbs\xdc-c\xc3¾\xef\xec\x1c\x9d\xb7P\x8db@\xd2\x16\xa2u\xe6\xf4뱤\xb7\xe2s3\xab\xf9ڵ\x8ce\x87g\x86ŵ\x83\xa6G\x17 i\xeb\xe0\x9e\xf8\xfd\x19\xd7aI\xd7\xe2s\xb3\xfc_X\xdamxĎ\b\xf2\x05-`\xb8\x01\x92\xb6\x0e\raG\xafE`I#|nN\xe0\xffG\xf1\xff\x14[è}\xbc\xc7(\x05$m\x19\xfa6\x85\xfd\xeb\x1aYK\x13\xfe-\xfe\aI\x8f:L\x94\xb4\xe85\xa7\xa7\xd8)P\x8c\x80\xa1г\xe4\xfb\u05eeMJ\xb9\xd6\xe7\xfe\xf7\xb5\x1e\xfcߍ\xff\x13I\x87\x01\xc3\x17\xa3\x93:\bL\x93\xb4\xe45\xc7\xed<\xe9\u009c\x10\x1e\xd0oe\xaaO\xa2`\xe2\x9eo\xbbvm\xfa\x92\u007f\xff\xeb\xda\xc9\u007f\xfd\xfbZCߵk͂\xa4\xbb\x80እ$-{͡7:\xb9\x8b\xad\xff\x14\x8a\x19\x83yd\x99\xff\xb8\xe7D\xd2Ӳ\xf5I\u05f5M\x1b\xae^۰\x01\x81\xa4\x879V\x92\xb4\xdakNy\xe8\x9fS\x14r\x06\xf5\x14B\xffqϊ\xfe\xb7\x17 \xe9a\x8d\x95$\xad\xf2\x9a\xd3\xec\x1c\xa2\x13\xc5a\x84\xd2Î\xc7\x05O\xb9\xf8H\x9d\xe9\xe4\xa1;\x13\x8aQ\xab\x8d\x9b\xaa\xb0e]İ\xf8\xed\x85\xc6=sʿ\xbc\x98\x03\x92\x1e\xceXI\xd2*\xaf9%\x95>\xadG\x14\n\x0f;\x92\v\x9e\xce\xc3\xf4)\x845\xcd\xf4\xd1x\xeb\xf0\x8fZ\x86Ma\xabp\x11\xc3\xe0\xb7\x17\x1a\xf7\xccIȋ\xe8(\"\xe9gn4\xd4\xf5\xfd\xb7\x1aYx\x13F\xff\xe9\u007f\x190\xbc\xf2\xba\xf5~-3\xdf(2Q\x1d\xaeAe\x8d\xda\xef\x89\x1f|\x87\xbe\x87\xdd\xf8\x18y\xf3\xbfvV\x92\xb4\xd2kN\xab\xd3Zϔ\x91<\xec(]\xf0H\x13o\xf6\x01\xb6\xb27\x1e\xa5\x8b\x18\x11\xff\xbdи\x97\x8f\xa9\xb9\xaabwXJ\x13\xee\x8d\xe3^7\xea[\x17ǾE\xbb\x98\x91\x9d\x02}I\xbf>\xde8\xab\xb0\xb0\xb017\xdd\xf6\x94\x91\x19\xc1+\xaf\xb7\xc6^\x14\xbf\x19\\&\xe2\xe1j~\xa7Qq\xa3\xf6\xbb\xe1\xf9/\xe9\xfb\x97\xcf\xdfHޤ\xda\x19b%I+\xbd\xe6T\x96\xf8\xb6\x1eiH\x1ev\x94.x\xb4%-y\xe3Q\xba\x88\x11\xf1\xdf\vM_\xb3-\xec\xfa\x1bn\xb8\xe1{\xdf\xfb\xdeرc\xaf\xc7\\w]\x98\xad\xa4\xd5\xe7X\xea\u125fuu\xdd\xf1\xdb+aW~{\x87\x91\xa9\x8c~\xb6\xbf\xfa\x95\xeeW\x128\xf5\x95\xbf\xfe\xe1Ƿ^12\xd4*\xe8֧\xa4o\x06\x93\t9\\=4\x8eʨ\xfd¾\x14\x03_\n\x96\xb7\xfa\xf5\x1b\xd3e-I+\xbd\xe6\x14\x99\xf2X\xfe\xe0!y\xd8Q\xba\xe0і\xb4\xe4\x8dG\xf9\xf0y\x91\x01x\xa1q7\xad\x9c3+n\x96\xcc\xec\xd9K\xca\x1b\xda\xc3\xc8P\x16&vK\xa2\xef\xa7n\x1e3\xf6\x17\x1f\xe3\x0f\xcf\xde<\xe6\xa6DŽ\xbeu\xdb\x13X\x1b\x8f\xde\x12vˣX\x1c\xcf\xfeh̸\xfb\xbfԲ|t\xdcw\xc7\xd1\x14\x8f\xe1\xc0\xa3a\xaa\xfc\x1e\xfd\x81\x10\x89\x87\xb5?\x93o\u07bam옛\x9fb\x92ɦ]\x1e\x9d|y\v\x99\xa5zJ\xd4/H\xaeԃd\x16\xfc\xc4\x1dC\xca\x04\x1f\xee\xc7t(\xbd8\xf6c1\x1bO\xdd\xe8\xe5beq4\xe6\xadۮ\xbf\xee6\xb6-\xa4\xe2X\xc9\v!O픕\x16j.\xb5\x05\x8d\xf2:\x89C\xc7,I+\xbc\xe6\xb4;}\xb9\xa9\x18\x81H\xe2\xf5v\xc1S@\xc6d*ޕ6\xa5\xad\xb6\xa4\a\xe2\x85\xc6\xdd\xd6ڬ\xa0\xa5\xd5\xd5\xd9'\x8eҲ\xa4ǿ|\xf1\xbd;p\xa7{\xfe\x86g/\xbe\xf5\v\xa1\xef\x8d{K\x96\xf4\xeb?|\xfd\xe2[d=\xe8e\xf9̍/\xff\xe3\xe5\x1b\x9f\xc5\x11?x\xf5\xe2\xab7\x85)\xf3{\xd6\x13\xd9\xf5\xc6x\xfa\xcd\xcd\x0f\xfe\xfd\xca\xeb?g\x92I\xa6\x8c\x0e^\xff\xcf.\xb9D\xfd\x82\xe4J\xfd\xf4\xbfq\xaa\xb7\xc6\r)\x13r\xb8?#?6O\xfd̫Yh\x96\xca\xe2H\xd4\x0f_\xbe\xf8\x8f\xbb\xef\x96s\x97,\xf0\uf0b0\x92&|\x87N\xb9=\xb5S\xe5B^䶠Q\xde'qȘ%i\x85לVg\xbb\x81\xf9\bC\x92\xa9\xc2\x05O\\\x1cBm4\"b9\x9e'\xcf\xf0K\xd2\x03\xf3B\xd3\xe3V҃\u007f8\xbd$\xfd\x06~\xff\x9f\xb1]]?\xfe\x83\xd4\x13\xbb\xc6\\\x94'\u07b7\x10\x83\xf7\xc6iX\xfe\xf8\x19\xfc\xf2̏\xbb\xba~\xf2,\t\x84)\xf3\xa3\x91ϒrȼ\x1b\xbf_\xf7\x9e*\x99d*V\x85pqL\x97\\\xa2~Ar\xa5\xfe\xecI5\x84L\xc8\xe1\xfe\xe1\x16\xfc\xe1\x96?x\xb2\x91\xeaF\xb3T\x16\xe7\x19\x85\xffq\xa3\x9c\xbbd\xd1u\xe5\xb1\xf1]\x1e\xc6?F\x96\x00\x9eکr!/r[\xd0(\xad\x938D̒\xb4\xc2kN\xb3\xd3J\u007f-\xa4\xf0\xb0#\xb9\xe0AD\xad\x9b\xcafE\x90\x8d\xc0\x99Q\x1b6\xcc\xe4\u008b\x9a\x19[\xd6E\f\xcb\xc0\xbc\xd0h\xe0%iO`\xcc\xc7RO\xa4}\xdcc46L\x9c|zY^\xffw\xfc\xf2\xf7\xeb=\x810e~R$\x99w\x93\x88_\x8d\xbd\xfb\x89\xf7\xd8d\x92)\xf3F\xba\xbfT\xa2~Ar\xa5\xaexR\r!\x13r\xb8Wƾ\xd7\xf5\xde\xd8+\x9el\x94\xed\xa3,\x8eD\xfd\xf7\xcf\xc7*r\x97,\xf0T]\xfem\xfc\x03\x8d\xf1\xd4N\x95\xcb\x15\xb6RB\x94\xd1\xc9\x1b\x04\xa6I\x9a\xf5\x9a\xd3\xea\xf1;n\t\x94\x1ev<.x0\xee%\x91\x11qt?\xb0%.b\xe2\xac\xe5\x1c\xb7\x84\xb1e]\xc4(\x18\x90\x17\x1a\r\xc2\xf4$}=#\xe9q\xcc\x0e\xf0\x18qp\xf5\xb6\xf4S\xd2\u007f\x1e'&\xfe\xf3\x83\xb7]\xff\xa0\x81\xa4ɜY*Q\xbf U\xa54&\xde\x03Ʉ\x1e\xee\xdd\xf7w\xdd\u007f\xb7\x94\x8d\xb2}\x94ő\x97\x9f\xfc\xea\xbd//2m!Yt]\xf9-3J\xff\x96(\xd5S;\xef\\Tma-I\x03!B\xec\xa5c\xff\a\xbf\xbc\xc1\xf6ݟ0\x13o\xb2=\xe6\xe1Ǐ\x8a\x01/K퉷d\xe5\x99x\xd3\xfdnQl\u007f\xbd\x8e\x9dl2يo_\x92\xa5\xa6T\xa2~A\xaaJ\xa9\xb6\xc7\x06\x9a\t=\xdc\xd7\xc7w\x8d\u007f]\xcaF\xaa\xdbwȖ\x97\xb28\xf2r\x1d\x1e\xd8_e\xdb\xc2c\xa1\xb1\x96\xf6\xd4\xce;\x17U[\x80\xa4\x81A v\xd7;\xeex\xef\xe2\xcb\xe3پ\xfb\xea\x8d\xcfK\xdbc\xecU\x9d\x97\xaf\u007f\xe2\xe3\x8b/ߪa\xf9\xccMd\x9fI\xbd=\xe6\xb1zv\x1c\x8e\x1c\x87\x03\xe3\xdf\x10\"n}\xfe\xe2\xc5Gof\x92ɒ\x16\xd2]yO\xb8\xfe$\x95\xa8_\x90\xaaR\xf42\xd1\xe03\x11\x0ew\xfc\x83\x9e\xe1\x95=\x8cq\xcf{\xb5\x01y\xb9\xf9\xc1\x8bo\x8cg\xdaB\xb2\xe8\xf2\xa4\x95C\x9e\x8bX\u07b9\xa8\xda\x02$\r\f\x02\xb1\xbb~\xfc\x8b\xb1c~\xf4\x14\xdbw\xbb\x9e\xf9ј\x1f\x88\x17\xb1\x14\xf7^\xbc\xfa\xd3\xeb\xc6\xfc\xf4e-\xcbG\xc7}G\xbc,\xf4\x03\xf9\"\x96d\xf5\xe8M\xdf\x1d\xf7\xe0\x18a\xdeM\"\x9e\xffɘ\xb1?\xff+\x93L)ir\x97\xc8ϞR\x94\xa8_\x90\xb2R\xc2\xcd\x1c\x83\xcfD8\xdc\xfb\xbf\xeb\xb9͋=\x8cgƑկ\xa28\xf2\xf2\xc6\xcdcn\xfa-\xdb\x16Rq]\xea\xeb\xd2\xf2\xad&^\xb9\xa8\xda\x02$\r\f\x82\xb0.\u007f\x18\xcc\r\xa1Z\xe0\xd9,\x9dw\u007f9\xc6\xc8r(\xf8\u007f˥\x0e\x81:\\\x81\x9b\xa4\xbb\xc7n\"o\xfe\xd7\x0e$\r\f\x02\xff$\x1d\b~\xf1狯\xff\xf0Aa\x81\xfa\xfa\xcdF\xd6\x16≛\xc4{\xbcox\xcc\xc0R\x05H\x1a\x18\x04\xa1\x93\xf4\x13\xff9f\xfc\x83B0l\xfc\xab\xbem\x01\x02H\x1a\x18\x04\xa1\x9340P@\xd2\xc0 \x00I\x0f_@\xd2\xc0 \b\x03\x86/F'o\x10\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x8cfI\xa7pQ\U000db34c\x00`d1\x9a%\xed\xaa.\x9a\x1a\x05\xeee\x00ka\xa2\xa4E\a:\bu\x1e\xde]\xb0\xfb\xb0)ڪ\xe6,\xef\xe3\x03\x18e\x98&iɁ\x0ej/\xde\xdd\xecj\xde]lƓMj\xb9\xa3F&\x000\xa20MҲ\x03\x9d\x9a\x12\xf2 \x84\x9e\x92\x1a\xa3$A\x00$\rX\r\xb3$\xcd8Щ\x14\x9e\x12Zf\xc6\xd3\xf9AҀ\xd50KҌ\x03\x9d\xf6\xe2\xeavw{\x8d)\x13\xef\x06\xae\xda\xc8\x04\x00F\x14fI\x9au\xa0\x83\x97\xd5N\xe7>S\x9e(莚q\xd8\xd5gd\x05\x00#\a\xb3$\xcd8\xd0qW\x964\xbb\x9aK*Mq]\xb9O~\xf0\x1f\x00X\x01\xb3$\xcd8Щ\xa1\x8e\xb1\xdc%f8\x98\ue31a\xbc\xb5\xdab~\x01\x80эY\x92f\x1c\xe8\x14\b\x97\x86\x1b\n|\xd9\a\x89ZΌM9\x00\b\x1efI\x9aq\xa0#J\xfa\xa49\x92\x86\x1do\xc0Z\x98%iƁN\xb58\xf16c\xef\x19$\rX\r\xb3$\xcd8\xd0q\xbfX\xd2\xe4j*yь-\xef\xa3 i\xc0b\x98&iƁ\x8e\xbbvw\xd1\xee\xda\xd0+\xda\xed:\x99b\xb3\x96\xafz\x000O\xd2\xe63\x87\xe3\xa2ˌ\x8c\x00`d1\x9a%\xed:\tC4`9F\xb3\xa4\x01\xc0\x82\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x98(iɁN_CY\xc1\xee\xe1\xe3o\xee\\Nrr\xf6\xa9\xa5\x8dFv\x02\xf5\xa9\xc7\xf5\xbf,\xe5\x1d\xe4\xdb\xfa$\xbeT\xdb`\x1b\xcf\x1f\xd4\xfe\x06}\xee\xe0\xef\xd3\xf9*\xb0\x8c\x88J\x02~c\x9a\xa4e\a:\xa8\xbc\xe8d뉂\x13F)B\xc4Yǚ#\a\xd7\xeb\xf7b\x15Ǔ\x8e\xe8\u007fّ\x9b\xf4\b~{$1\xb7C\xf9ũ\xb3\xc2\xfb\x17\x8d\x0e\x1d\x1d\xa1\xfew6;t\xbe\n,#\xa2\x92\x80ߘ&iفNC\x01y(\u007fK\x81)~\xee\xbc\xc9\xc9\xee\xc7]u\xb3\xbf\x92F\xfd\xbe\xbe,\xccI\xea@\x1d\x899\x85\xaa\xf8\xac\xf5\x9e\x90\xaeZ\xf0\xf0\x19\"\xb5\x8c\x88J\x02\xfeb\x96\xa4\x19\a:\xe5\xfbhL\xf10\x19\xa6\xd3i\xcf>\xc7\xfb\x18|\"\x05\xd7\xcf\x00\x00\r\xafIDAT\xfd\xa70\xf7\x91\x83\xa8*'W\xad\x96\xa5\xc3I-#\xa2\x92\x80\xbf\x98%iƁ\xcen\xc1\xbf]Y\xb9\xaeqp\xf8\xd0\xc1\xf3;/\xe4\xa5'\xe6|\xcbF禞ï\xfd\xf5\xdd\xe4\xb5*+)3\xbf[a{\x90\xe7\U00062cd4'S\xf3\x8e$^\x9e\xa1_X?ϑ\x9a\xf3\x05\x9b\f\xab\xa5b=ʩ\xa0j\x91b\x8f\xf3\x02Y$\x95\xa30?3\x89\xa6B\xfd\x15YIK+\xe8\xa8\xffEnZ\xf2z՜\xd65\x91\x13\x98\xa8zr\x83\\\xb0\x84\xe2\xd8\xe4\xea\xa0\xee\xc2\xfb\x92\xb2\xdfI\xabW\xa4\x0fd%\x01\xd31KҌ\x03\x9d\xc3\xc5\xf4\t\xa1E\xbb\x8d\xd2\x04\x98ރ\a\xd33\xefI\xcbϽ\xebs6\xfa\xf3t>\xa7\xf4\xdd^\x1a\xde\xc2\xe7\xd7W\xa4.\xedgm\xbb\x1b\x93_\xf8\n}\xf5Br#\xee\xf8g\x1b\x1b\x13\xc5\x11\xecTR\xd6+\xf5\xa5\xfc^6\x19V\xcb\x17I\xdf$^\xa6j\x91b\xbb\x1b\x1b3\xb3\x1b\x1b\x1b?%\xc9\x1c|\xe6\xc1\xe3\xf3\xe8x\x98\xe7\xd8Y\xbfӑ\x87C\x17\x923\xab\x8e\xe7\xf0J\xb5\xb8\x8b\xb6\n\x14)\x1f\xd3\xc6\x14,\xa186\xb9:\x1d\xe9\xc9{\xeb\xb7\xf1|\x85\"\x83@V\x120\x1d\xb3$\xcd8\xd0\xe9,*os\xbbʜ%Fi\x02\xcfR\xfe\x91n\xd4߭\x8c\xec(\xfd\x8d\x83O&c\xefq\xbe\n\xbf\x9e\x15\xc6a\xd9vK.~\xc9\xdd\"\x9a\x8b\x92\xeeM\xcf\xe9%R\xeaP$+\xccEK7g!\xa2\x16ef\xf2\x9c6\xf5\x1b\x9cc*\x0e\xd5\xf3\xf5\x9e\xd7\xecL\\N\xffR\x95Z\xdaZ\x05\xda\x14\xb1L\xc1\n\xa4\xfa2\x05\xe7%\x93\x916\xdfK\xd2\x01\xac$`6fI\x9aq\xa0\x83\xda˝N\xe7\xd1r\x13\x9e\xec\xb7ԡ\x18\xa0%zO\xe5\x90N\x9b\x9b\xde\xfb-&m\x8b\xd2\xf6Tb7\xeaN:%~\x12%]\xcf\u007f\xe4I\xcd$\xc3jy\x85\u007f\x89\xaaE\x99\x99\xac\x16\xf2\x99.H\xb7\b\x97\x83\xeeی:\x04\xcd\xedT\xaa\xa5\x95\xf3\xa0\xf0\xf8\xc3\x14\xac@\xaa\xaf\\p\u007f\x12\xad\xeb9oI\a\xac\x92\x80\xe9\x98%iƁ\x0e\xc6\xddއ\x8aM\xf0\x89\xb54\xcb;\ueb30d|x\r\x19\xe8\x04\xd6(m\xbfM>\x82\x8e\xcc\xf3\xect\x8b\x92\xde\xcb\xf7z\xbeg\x92a\xb5t\x14~Eբ\xccL\xb9\xf3D\xd5\xf20\xfd\x06\xe5d\xe1Q\x92^\x14W\xef<Ք\v\xd4(b\x99\x82\x15H\xf5\x95\v\xfeB\xd8\xf3\xeb\xf6\x96t\xe0*\t\x98\x8dY\x92f\x1c\xe8 \xbaQ\xd6\xe24\xe1q\x9dr\xa7\x95Iͧo\x85\x99d\xcc:K\xe9P\xd9\xe6\xafA\xeb\xf3=\x1fDI\x9f\xe2?\xf4\xc40\xc9\ns\x85\x98B\xad̪\xc80*\xabeK:\xf9\x95\xe8O\xcfC\xdf\b\x9a\xcb\xf3K-L\xc1\n\xa4\xfa\xca\x05\x8b\xa3\xf4Gޒ\xa6vA\xac$\x10:̒4\xe3@\xa7ى\x17\x87W\x8b\xcd\xf0\x9f\xc3J\xbau\x830\x9f\x9d\x97F\xfas?\xf9\xaa^XS\x16\xbe\xa4\xb2}7\xf1r⻞\x0f\xa2\xa4\xbbS\xb3\xc9h\x99\x9f\xafHƨE\x91Yv6B_\xd1\bY-\x82\xc1A2\xe3\xcfJ\xc7u\xf84\xd1/\xb50\x05#\xf9(\x98\xfa2\x05\xaf\x9f\x87\xf3\xed\xcf\x13%\xed\xb1\rA%\x81\xd0a\x96\xa4\x19\a:-\xceZWCqyȽm|\xfb.\xdd\xd3\xf5\xac\x90\xe7\x88~\xa6\xe7\xf1\xa9\xa5\xf5G\x1eI\"[\xbd\x85w\xe5\x1e\xf9\xcb\x16܋\x95\xb6\xfdi9it\xde\xdd\xfbNcc\xe2\xe6F\xb2\xf7\x8dW\xd8\xf7U\xd4\v;OR\xb2or\xb3/\xe3ϗ\xb3s\xbfab\x11\x91\xc7^\\\xc4et\xb9ѱ\xf9\x9d\xfe\xf77;\x1a\xb1]._x\xbc\x90'\xfa:\x97\x94V\xba3\x99wT\x9dC\xc60\x05KG\xa1\xa8\xaf\\\xf0\xe5\xd4\xf4\x8a#k\x12\x95\xb6!\xa9$\x102L\x934\xe3@\xe7dIQ\xf9I#\xf3\xc0\xf3\xa1\xb0l\xcc\x11?\x16E9\xe9\xfbo*\n\xefKJ]C/ޠ\xfa\xecy\xc9\xd9\xf5^\xb6{\x1d\xc2%\xa3\xf7ť'\x95ȧ\xeb\xd3\xee\xc9:\xa2HV\xca\xf3dci3Oo\x9f\xf6\xc4bz\xf3\x93\x13\xb3\xcf\xd2ۧy\xc7G\xe4\xea\xf66r\xc9w\xa9\xe7\x92\xef\x855\xc9\xe9\x85U\x0e\x12k\fS\xb0\xe7(\x94\xf5\x95\v\xeeؒ\x9e\xf8\xc8YQҢmh*\t\x84\n\xf3$\r\x98\x85z{\f\xb0\x14 \xe9\xd1\aH\xdaҀ\xa4G\x1f iK\x03\x92\x1eu\\\xa8\xe7\xf3\xdf\xf5\xf9\xf7c\xc0H\x06$=\xea\xc8&\xbb]\x17\x8c\xac\x80\x91\nH\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x05H\x1a\x00,\x85I\x92\xee)v\n\x14\x93O\xae\xb2\xa2}&<\xd3\x04\x00,\x88I\x92v;O\xba0'\xe8\xb3M\\\x055-5\x05\xa0i\x00\b\x00&I\x1a5\xd1gw\xd3G\b\xf6\xd1\xd7\xc3\xc5}\x06I\x00\x000\xc6,IS\xca\xc9s\x8aPs\x01\x95w\xc1\xf0\xf1]\t\x00#\x173%M\x9f#\x88P\xa5\xe0\x13\xab܌\xe7\t\x02\x80\xd50S\xd2%\x95\xf4m\xb7\xf0\x00\xef\xc3&<\x9a\x1f\x00,\x87\x89\x92n\x15\x9f\xdc]\\K\xdfj\x8b}\x19\x03\x00\xe0\x17&J\xbaRt\x82%z\xae\xac\x0e\xb5\x9b;\x00\xb0\"&J\xbaHt(])x\xa1-\x83\xb54\x00\f\x1d\xf3$\xdd\xee\x14\xfdB4;\x89ǻ\xabN\xd8\xf1\x06\x80\xa1c\x9e\xa4[\x9d\xedB\xa0\x8f\xfaΩ\x86\xeb\xd2\x00\x10\x00̓t\xb3\xd3\xe32\xc7UP\xddZ\rw\x8f\x01@ 0Oҭ\xf2v\x98k_A\x19(\x1a\x00\x02\x81y\x92\x06\x00 \b\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\x01\xc0R\x80\xa4\xd1ڵZA\x00\x18\x99\x98$i\xa5\x03\x1d\x84\xaa\xcd{\xa4\xc9\xdf\xecOk\x04=\x1c\xb0c\x12p\xe0\x83_\xc7\xc7.:\xb6\xe0m\x1c\xdc>\xf7\xceiw\xce݁P\x9dݾ\b\xa1\xfd\xd8\xe2\x98:]\x908\x16\xff')|~\x9a\xfd^\x1f\xa6\xbeYk\xb7\xef7\xb2\x19\x10\x81k\xa8\xd5\xd8,漑\x15\xa0\x87I\x92V8\xd0A\xa8\xcdYk\x90 x\xac\x8a\xb9\xa4\x11\xf4\xe0~\xbb.v\xc5\a\b\x9d\x99\xf6Ё\xfd+\xa8\x0e\x8e\xd9\u007f\xbd\xe7\xd0k\x0f\xd9\xeb\x90\xfb\x98=\x06\xbf\xee\xb7\x1fs\xa3\x00s\xec\x8cf\xf4\xa1\x18F\x88\xa7W\xc7h\x1a\xf9å\xbai;\x8cl\x06D\xe0\x1a곺\xba=\xf6\xb7\x8d\xac\x00=L\x924\xeb@\a!W\x89y\x92>oߨ\x11d\x89'C\xf7\xe2\xc5$\xb8\x9a\xf4ԍ\xb1\xb4\xee\xb1\xd8\xd8m_\xb5\x9a\xa4\xf3\xa3\xa3\x0e\x90\x05+\x8c,0;\x06/i\x84b\x02+i\x14Ȇ:\r\x92\x1e<fI\x9a\"8\xd0A\xd5\xce\xea\x02\xd3$\xbdZ\x1e\x99W{\x0f\xd2\x04\xdaS\x13\xb6\x93\xe0\a\xf6\x03\xb8\xd3.\xa4\xd1\v\x17\x93\x9ez\fw[\xbf{\xea\x00\x18\xb1\x92\x0eHC\x81\xa4\x87\x80\x99\x92\x16\x1d\xe8 \xb7\xdb\xf3x\xfe\xd0s~\xdaF\x8d\xa0\x02\xdaSW\xc4\u007f@\u0087p\x9f\\$\xa8m\xc5\"\xd2S\xcf/د\xee\xa9g\xa6\xd9\xed\xdbϯJ\x88y\x80< q\xff\xa2\x98\xb9\x1b\xe9\xf7\xee\xa7\xef\x8d]\xf4v\xc2!\xf48\x99\x96J+a٠nq´\xf8_\xe3\xf5\xe8\x9f\xec\x02\v\x90\x82\xafc\xec\xd2\n\xf8Ҫ\xf8\xd8\x15\xde\x13\xef\xf3+\xe2q\x16\xf8\x97\xa9\x13\a\x12\x1e\"\xb3\xf7\xc7\xed\xd3\xf6l\x9c\x1b\xb3\xf83\x95i\xccƵ\xf1w>$\xacY\xe5:\xc8h\xe6p\b\xd7\xe0\xf7h\x87]s%>І\"k\xeb\x1dbfri\x04Q\xd2z\r\x85\xd0k\xf1{\x10\xa0\x8d\x99\x92\x16\x1d\xe8\x10L\x93\xf4\xdai\x9fi\x04\x15О\xfaY\x82\xfd\x81\x1d\xa7\xe9\xa4b\xc1\xefh\xf4\xef\x16О\xba\xeb\xd7\xea\x9e\xea\u07bf?anl\xc2\xc6U\xf6\xcf\xc8\ft\xe3\xa1]\xf1\v\xb0\xb8\xbfN\x88\xdfuh\xadݾG\\NJ+a\xd9\xe0\x8c}\xd5\xfec{\xe2\xed}d]:wQ]]\x9dz\x8f\xe8L]\x9d8\xb6\x9e\x8f\x9d\xfbڟ\x16\xdbՒ~3v\xc1s\xc7v\xd8w\x11\xed\xad}s\xffC\xf6\xd3\b\xfdm\xff4{\xfc\x8e]\xb1\xeaa?ƾ`\xff\xfe\x051D\x80r\x1d\x184sp\xbf\x9d\xb0\xf6\x12\xba\xb4=\xb6Nc\xbc\x1dpC\xd5\xc5n\xf7d&\x97F\x10%\xad\xd3P\x98\x15\xf6\a\x10\xa0\x8d\x89\x92\xf68\xd0!\x98%\xe9Ϧ\xad\xd5\b*\xa1=\x15}\xfd\xdc\xc2i\xf6X26ݻ\x8aF\xaf\xba\x97\xf6\xd4K1\x97\xbc\xe7\x93\v\xec\x8b;\xf18Gt\xf1GDz(N\xb7*\x96L\xeb7\xda\xc9\xf0B\x85I\xa7͌\xc1\x9ex\xd2]\xf7\xc4\n9\xe8L\xbcEI/\x9a\x8b\x8b\xec[\xa0\x92\xb4;\xe1\x01\x1cݳ\xffk\xf2\xbbB\xea$\xe4\x12\x13\x8b\u007f[Vūs\xba\x17[\xb8\xe7.Tԁ\xcdL;\x87\x1dd\xea@\x16\xc6\xde\f\xbc\xa1V\x93\xdc\u007fGڝ-\x8d\x99xk6\x14\xe6\xfcs\xb0%\xae\x87\x89\x92\xf68\xd0!\x98%\xe9ǧ\x9d\xd7\b*\x89\xf7\\\xd9r\x1f{\xc0~H\x1a|V\b\x83\x0f\xfa\xf5.\rILj\x03\xfe\x8a\x84\x9e>L\x02\x96@\f]d\xfeM%i\xc6\xe0\xb3\xf8\x84\xc7\xf7\x9cA=B\x0e>%\xfd5\xcd\x05mWI\xfa\x90]\xde'\xff\xe7\x9e\a\x12b\x85\xa9{\f\x11\xa0\u05fa;\xe6\xf7\xe4u\x8f\xfdk\xb6\x0e,\xda9|f\xff\x00\xb9c5\xafE\r\xbc\xa1ތq#wL\x1d\t2\xa5iJZ\xa7\x92\x80\x17&J\xda\xe3@\x87`\x92\xa4/Ŭ\xd5\b\xaa\xa0=\xf5\xb4\xb0s\xb6\xe8!\xe1?\xe6!a\x89\x88\xf6/А\xb4g\x15\xbc@\\\x15\xaf\xc0R8@\"\xdc*I\xcb\x06X\xa8{V\xdck\x8f\u007fNH\xe8S\xd2g\xecT\x06j\x99\xee\x92+r:>\xe1\xe9\x03u\x8b\x17Hi\xbc%Ms\xaaÿ\x02l\x1dd\xf4rx\xe0it,\xb6\ai0\xf0\x86\xea\x8b?\x80\x0e\xd0\xc9\t[\x9a\xa6\xa4\xb5+\txc\x9e\xa4%\a:\x04\x93$\xbd\xd1~^#(\xd1G\xa3hO\x8d\u007f\x9c\xc6l\x9f\x8b\x90\xd8\xef\x16,\x16z\xaa;昷\xa4=\x1doU\xc2\x19\xca?Q\x9f \xa1\x0fdI\xd31V6@gH9_\xef\x8f\xd9#\xe5\xf0\x9a\xf7\xe2^\xc8\xe5\x9f\xc2(\xad\xde\x1e;&\x8f\xd2\xf7.$uZ\xe1K\xd2\x1b\xc9\xebk\xf6N\xb6\x0e\fz9\xfc)\xbeg\xb5z\xa8\x1ctCm\\\x81Vl$\x01\xb64\xb5\xa4\xd5\r\x05\xf8\xc4<IK\x0et\b\xe6H\xfaR\xccj\x8d\xa0\xcc\x1e2\x18\xfe\x93\xec6\xa1\xf8\x84\xafI\fQ\x9ax\xb9\x95\x8cꤧ\xa2տӗ\xf41a\xed\xb7\xfd9\xb2\x15Lz\xe3*AҸ\xf3\xf7-\x8cQ\x1a\xec\x10n\xadZDg\v\x8b\xf0\xd0vIc[Y\\K/$\xd59\x1f\xa3\x92\xa9;~\x11\x19>7nD(\x81Ԡo\x81/I'\x90u\xf7\xbd\x8b\x14u`\xd0ˡ'\xfeOw\xaa\xe7݃n\xa8\xd31\x97b\xe8\x96\x18[\x1a+i\xad\x86\u009c\xdf\x01ki=̓\xb4\xec@\xc7\xedr\x15U\xbb\xda|Z\a\x85\xa7\xe5\x91\xf9i\x8dA\x9a\xdc\xfe\xb4\xff\x8f\v\xe3\xc9X\x19o\x8f\xdf~\xec\xc0br\xa3\xe21\xfb\x03\a\xea\x0e,\xc6\x13i7\xeegnT\x17\xa3\xec\xa9}\xa7\xe9~\xf5y1\xdf\xdf\xed?@o\xbc\xb8\x14\x9f\xb0\xe7\xc0\x8a\x18*\xe9E\xf1\xcf=\xb7\xd0>\xed\x8f\x1f\xb0\x06;\xec\xb1\xdb\x0f\xe1\xe0\x9b$ݎ\x98]\xb84\xe5(\xdd\xf3v]]\xcc꺺N<\xd8\xc7$\xec\xd8~\xa7\x90\x03ñ\x98{\xf7\x1c\xdah\u007f\x8dd\xb6b\xcfs\v\xf04\xfe\xf4\xa5\xbai\xabO\xa33\xab\xa7\xd5)\xaf\xba\xc7\xd8\x1f8}lQ,\xa9\xa6\\\a\x06\xdd\x1c\x9eN\x88U\xbb/\x1b\\C\x11\xe2\x17\v\xdbvri\xc2\xddc\xbb\xea\xeaHn\x9a\r\x85y\x88\xdc`\nhb\x9e\xa4e\a:'\x84۽\xaf\xfa\xb2\x0e\x06\x97bVi\x04Y\x0e,\x88\x89}\x88\xaaf\xe1k\xdb\uf349\x17.\xe3n\x9f\x1bk\x8f%\xb7.\xbfI/\xa9\xf6-\x8cWt\xf13¢OXH\xa2c\x8b\xe3c\x17\x1d\"\xa1\u007f\xaeN\x88Y|\x86J\xfa\xfc\xa2\x98\xd8ſ\xb7\xdbײ\x06\xfb\x17\xedH\x98\x16\xbf\x88*\x1a\xb97\xde\x19\xb3\xe84R f,\xe4\xf0Н\tO\xffq\x1á\xe1\xfc\x8a\x84\u0605d\xd1\u07b7knL\xfc\x8a\xd7\xe6N[\xb4\x16\xa7\x98\xf6\x01\xb9\xa4\xad\xb4\xbdwNJ\xd8\xf8U\x82\xcc\xe5J\xca\xe8\xe6p^](\x1adC\x11v\xc5\xec\xa2\xefri\xf4\x1eoϪY\xb3\xa1h2\xf5\x06>\xe0\xc1<I\x9b\xcf\xef\xed\u007f\xd3\b\x06\x17a{lD\xe3\x8ey\xd3\xc8$\xf8<\xb4\xd8\xc8b\xd42\x9a%m\xc6_UZ@\xd2\xfb\xbd\xc7ڐ\xf3\x9c]5\xa7\x00$F\xb3\xa4\xcd`\xa4KzǛh\xf1v#\xa3\xa0\xf3Y\xfc.#\x93\xd1\vH:\xa4\x9c?fߨZ!\x8f(\xdc\xf6\x05\x8f\xc7\u007fmd\x05\x98\tH:\xa4,\";M#\xf9\xfa\xcb\xf6\xd8\xc5#\xb9\xfa\xa3\x01\x904\x00X\n\x904\x00X\n\x904\x00X\x8a\xff\x0f\xb8\x98\xba\xeaw\xacpV\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/ipcg-func.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\xaa\x00\x00\x01\xb1\b\x03\x00\x00\x00\x9d\xa2d\x9d\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x02\x04\x00\a\t\x05\n\f\b\x0e\x10\r\x13\x15\x12!# '(&+-*2319:8?@>QSPVXU,`\xae7]\xadZ\\Z8^\xae8a\xaa:b\xab;b\xac^`]<c\xad=d\xae?e\xaf@f\xb0Ag\xb2Bh\xb3Ci\xb4fgeCk\xafEj\xb5Lj\xafMk\xb0Fm\xb2Ol\xb2Ho\xb4Ip\xb5Jq\xb6molKr\xb7Ms\xb8Nt\xb9Ou\xbaPv\xbbrtqWv\xb6Xw\xb7Yx\xb8[y\xb9wyv\\{\xbbV~\xbd^|\xbdX\x80\xbf`~\xbeZ\x81\xc0`\x81\xbbb\x80\xc0}\u007f|b\x83\xbd\x80\x81\u007fc\x84\xbed\x85\xbfe\x86\xc0\x82\x84\x81f\x87\xc1\x84\x86\x83h\x88\u0085\x87\x84i\x89Æ\x88\x85j\x8a\xc4k\x8bƈ\x89\x86q\x8b\xc1r\x8d\u008a\x8c\x89s\x8e\xc3t\x8f\xc4v\x90ō\x8f\x8cw\x91Ə\x91\x8ex\x92\xc8q\x94\xc9y\x93\xc9z\x94\xcas\x96ˀ\x94Ł\x95\xc6z\x97Ǔ\x95\x92\x82\x96ǃ\x97Ȗ\x98\x95\x84\x99\xca~\x9b\xca\u007f\x9c̆\x9b̀\x9d́\x9eΈ\x9d\u0382\x9fϛ\x9d\x9a\x88\xa0˄\xa1ѝ\x9f\x9c\x8a\xa2̌\xa4\u038d\xa5Ў\xa6ѣ\xa5\xa1\x8f\xa7Ґ\xa8Ӧ\xa8\xa5\x91\xaaԘ\xabє\xac֙\xacҪ\xac\xa9\x9a\xadӛ\xaeԭ\xaf\xac\x9d\xb0֘\xb4ذ\xb2\xae\x9f\xb3ر\xb3\xb0\xa0\xb4٢\xb5۳\xb5\xb2\xb4\xb6\xb3\xa3\xb7ݝ\xb9ݨ\xb8ض\xb8\xb5\xaa\xb9ٷ\xb9\xb6\xa4\xbcڬ\xbb۹\xbb\xb8\xad\xbcܮ\xbdݯ\xbeߩ\xc0߰\xbfཿ\xbc\xab\xc2\xe1\xb1\xc1\xe1\xb6\xc1\xdc\xc0¾\xad\xc4\xe3\xb7\xc2\xdd\xc1\xc3\xc0\xb8\xc3\u07b2\xc5\u07b9\xc4\xdf\xc3\xc5º\xc5\xe0\xb4\xc7\xe1\xbb\xc7\xe2\xb6\xc9\xe3\xc6\xc8ż\xc8\xe3\xb8\xcb\xe5\xbe\xca\xe5\xc9\xcb\xc8\xc0\xcb\xe6\xba\xce\xe7\xc2\xcd\xe8\xbf\xcf\xe2\xcc\xceʼ\xd0\xe9\xc3\xce\xe9\xc7\xcf\xe4\xc8\xd0\xe6\xc3\xd3\xe6\xca\xd2\xe7\xd1\xd3\xd0\xcc\xd4\xe9\xc6\xd6\xea\xd4\xd6\xd2\xce\xd6\xeb\xcf\xd7\xec\xca\xd9\xed\xd0\xd8\xed\xcb\xdb\xee\xd7\xda\xd6\xd4\xd9\xe9\xcc\xdc\xf0\xd6\xda\xea\xd7\xdb\xeb\xda\xdc\xd9\xd2\xde\xec\xdb\xde\xda\xd9\xdd\xed\xd4\xe0\xee\xdb\xdf\xef\xde\xe0\xdd\xdc\xe0\xf0\xd6\xe2\xf0\xdd\xe1\xf2\xd7\xe3\xf2\xe1\xe3\xe0\xdf\xe3\xf3\xe3\xe5\xe2\xda\xe6\xf4\xe1\xe5\xf5\xde\xe7\xef\xe5\xe7\xe4\xdc\xe8\xf6\xe6\xe8\xe5\xdd\xe9\xf7\xe6\xe7\xf1\xe0\xe9\xf1\xe1\xea\xf2\xe8\xea\xe6\xe2\xeb\xf3\xe9\xeb\xe8\xe3\xec\xf4\xea\xec\xe9\xe5\xee\xf6\xec\xec\xf7\xec\xee\xeb\xed\xed\xf8\xe7\xef\xf8\xe8\xf0\xf9\xee\xf0\xed\xe9\xf1\xfa\xef\xf1\xee\xf0\xf0\xfb\xee\xf3\xf6\xf1\xf3\xf0\xf4\xf2\xf6\xef\xf5\xf7\xf2\xf5\xf1\xf0\xf6\xf8\xf4\xf7\xf3\xf2\xf7\xf9\xf3\xf8\xfb\xf6\xf8\xf4\xf4\xf9\xfc\xf7\xf9\xf6\xf5\xfa\xfd\xf8\xfa\xf7\xf6\xfb\xfe\xf9\xfb\xf8\xfa\xfc\xf9\xfd\xfb\xff\xf7\xfd\xff\xfb\xfd\xfa\xf8\xfe\xff\xf9\xff\xff\xfc\xff\xfb\xfe\xff\xfc\x1d\xe0k\xdb\x00\x00 \x00IDATx^\xed\x9d\tp\x14\u05f9\xef}\x93\xdc\xfb\xde]t2\xaa\xbe3\x12\xd2\x13TI\"b\xb9PzFU\xc0Ř\xb5j\"\x95)!\x97\x8b\x87\x1d+U\x02\xa2\xd8O@L \x18\xa1g\f\x97\xa4,,\x16\x13H\xbc@t\xcbv\n\xd9\xd8V\x99'{\xd8\\Pl\x97\xe0`\x85\xb2͢\xc8\x06\x83\x1fKر@\bMթw\x96\x99\x9e\xd33=\xea\x99Ѩ՟\xfa\xfbE\x91z\xce|}\xba\xc7\xfa\xe9\xcc鞦\xff\x0fQ\x04\x01\xc1CV\x05\b\xe2\fPU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80`\xa1j\x1b\x828\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x84$Tm\x988X\xcb\x1d\xf3\\\xbc\x9e\x12c\n!\xa4\xdc\xd02\x8c\xb5l\x89S\xfd\xe9\xfbq\x9e\x88\xc3H\xd6\x17\xf9ȪJ\xe2g\xa5\xb5r\xf1ͪ\xe2<\xcdW0m\xe9\xe1\x1e\xd7@\xfa\x95\xc4U}\x96\b\xfcq\xbbJ\x88dT=\xbdj\xc8\"\xd3'\xe2\xf1\x8e\xd8\xc3j\xab2\x89\xae\xea\x81i$L\xd6*\x8b\x95\x90\xfe#aU\x0fg\xc8\xdf\xe6\xc2\xf8}%B\x12\xaa\xbe_BHr\xaa>%\xf6p\xc8\xe7Vu\x82\xb0\xaa\x9f\x16\x13\x85eV\xab!\xfdEªna\xbfnj\x15\u007f\\\xbf+~_\x89\x10\xab광#G\xfeѬt\x06IR\xd5\xd6AR\xb7\x97\xad\n\x05aU\xe7\xf3U|\x13ʧ\xe4\xf1\x05-\xc1\xe9\x03b;\t\xab\xfa2\xfb=\x16\xc7\xef'QbU\x8dKҪ\xbe\x1c\x1a\x19'Y\x15\nª\x0ef?\xffן\xd8\xc2\xe7\v\xf9\xcas-VC\xfa\x8b\x84U\xfd\r\xfb5\x8e\x8d\xdfO\xa2\xf4\xa5\xaa\x13\xf9.\xf2\xc1\u007f\x8fU%'\xa4\xea\x01\xee\xe7\x9fdSIz\xfe\x1c\x91>!AU\xcbC\x03\x16\x19\xd9֖\xcd~\xc8#\xf3!l\x89\xbfw\x17\xb0wж\xd6ec\x06\xf9\x8a\x17|\x1aZ\xe3\xf3U~vT]\xf4ě\xc6\xed\xf50W\xdd3\u007fL\x8e\xa6\r\x9e\xb0H\x8837\xbc\xc5M\xfcсg\x8b\xb3\xbc\x85\xe5\xe19\xad\xd9\x06\xdbv\xf1\xd9\xf4G|\x90\\\x10n2\xab\xdbU5ԛ3\xe5U\x83\xaa\xafȧ^\xad\xaa\xaa\x9a/\x17\x8d\x1b\xfc\\8\xbcl\xa8\x967\x83\xff\x97(\x93\xad{\xf8\x06w\xc5V#}B\xdaT\xdd5R\x16\x14\xca\xc9\xecG#\xc3k<\xf5\xa5\xba\xbd\xf8\xaan\xca\n\xaf\x91\xc7\xe7\x8b\x06Uׇ\x9f\xf3K\xe1L6\xd8ֶ\x80=\x18#\xd6+<\x1dj2\xa9{\xd9+\x1fV\x86T=ͧ\xa8ު\xa8\xb3bQ\x1b\x14\xaa\xf2\xfeɣ|\xce\xee\x95{\xb1\x88-N4\xa9F\xfa\x84t\xa9\xaa\r\rW\x88\xb3Y{\x06\x13\x9dy\xea\xf6⪺K($O3\xe4\xb7\x1aUݔ\xa1w6AX\x18\xbbA\xe6\\!\xe1\xee\xbdϛ^\r\xf5\x1d[\xb7E\xef*\x93ȹ\xeas\xf2a^\xc5\xca\xc8\x11c\xf4\x06\xb9\xaa\x83DۊӼ?yN\x8b\xff\rԛT#}B\x82\xaa~\xb8\x85\x9fV-\u07b2\xe5\x9d8\xaa\x12R\xb0\xe2\x9dz\xbe\x90\xc9G\x16n\xa4\xb7zS\xfd\x04\xf6\xd3\U000e1cbd\xb8\xaaV\xb3\x1fU\xbbN\xb7n\xe2\x9d.c[\xdc4\x9e-<\xb1iӁ\xb6Os\xd9Ҙ\x86?\xfe\x8a\x1f\xe1\u05f6\x99nP\x9e\xa2\xc8< \x05\xfaq\xa8\xef\x98:!\x9a6\xff\x9d-O\b\xb3xg\xadcI\x98⥲\xab\x98\r~.\x9e\xce\x1c3\xccs@\x8c\xa5\x13x\x15\xff\xa3\x18\xd4jR\x8d\xf4\t\t\xaa\xaa\x1eV\x99\xab\x9aÏe\xc49xf\xf3\x87\xfc'\u007fW\xffr\f1\x9e\x93\x8f\xab*\u007f?\x16\xf3\xdaM?\x9e\xbf^\x1c\x17\xe9\x87U˸E\xfcd\xe9\x1f\xd9\xf05\xbc\xcdl\x83\x8c\n\"\x8f\xfd\xb9J\xda\x01\xd9wL\x1d\xf7\x99\xac\xe7OU\x91\xb0X\x9f\xf25C\x14l1ݠP\xd5\xc7\xd6\xdf\xce楙\xa1\x037>\xeeW\x99\xee\x1e\xd2\x17\xa4M\xd5gE\v\x1fX\xd8o{1\xe1\xd3FΖ\xe7^1\x9c\x89\x8d\xab*\xf7\xc5W\xf1\xf2\x81\xc8\x13\xba\xaa\xfc\xc8~\x85h\xe2\xe2\xf3\x89l\xcc\x06\x99p>\xb6\xf4\x1b\xb6\xb0\x87k\xb5Dv\x11S\xf7\xac\xbec\x875\xa2\x8f\x81\xef?\x95\x13vU{\xd3l\x83Bէd\xb1\xf8\xa3Z\xcc\xfe\n\a\x87\xfe;\xc4\xee\x1e\xd2\x17\xa4MUy\u07bd\x88\x88\xc9%\x9f\xdaVEoJ\x10W\xd5M!W\x86=\xb5\xa9U>\xa1\xab\xca=*\x9b\xcb\x19\x1e\xdaP\xcc\x06\xdb\xda\xfe\x0f[\xf0\x89\xf7o\xfe\x86>Bv\x11S\xf7c\xa2\x0f\xf2\xfcC\xaa\xda\xf0N\x9c~gѣ>\xb1\xfd\xa1\xa7M6(T\r\u007f\xb2\xc0\xf7\xb4\xb8\xad\xedU\x12:\xb3\x15\xbb{H_\xd0+U\xf9$-\xac\xaa<Q3R\x1a1\x89\xfd\x98\x1f\xbd)A\xfc3\x00\xe2\x1dY\x90/Ǩ\xb0\xaa_\x12\x03\xb5m&\x1b\x94#Zn9g4\xaf\x92\xe7\xc8b\xea\xf8\xdcy\xb1\xdc\xee$\x125\xb3lm\xe0\xbb\xc2\xeac7(T}'T\xf7%?g\xf0\xa1x\x1b\xe0\xeb\x9b\xec\x1e\xd2\x17\xf4JU~\x8e&\xac\xaat\x83\x0fU!U\x9f\x8dޔ\xa0\x87\xf3\xaa\x9b&z¿oq\xf9VX\xd5V\xa3\v\xbc)f\x83rv\xacP!\x9e\x8d\xa9\x9bH\xf4\x8f\x15B\xaa\xbe\xbc\xa8jF\xf8\x84\xc1\x01>\xb0.3٠PU\u007fk\xe7\x1f\xc5\xceoe\xb5\xde?\x99\xef\x1e\xd2\x17\xa4\xa0*\x9f\xf6\x89\xdf\xff\x97\xfc$\x8d\xa9\xaa|\xc4yB4\xb4~d8\xad\xda\xf3\xe5*\a^~B\fl\xc4\xcb\xe7\x00\xfa\x04\xc0\x17\xa9\b\x11\xabj\xb5Q\x98\xd0\\ \xa6\x8e\xf7\x19\x9as\x8e&B\xd5\x12u\x87\xf8\xd8\xfb\xac\xc9\x06\x85\xaa\xfag`\xfc\xb3\x86\x91\xaf\xe8\xeb\xc5\xee\x1e\xd2\x17\xa4\xa0\xea\xe0\x90\x1dr$3U\x95\x1fV\x15\x88S\x8c\xbf&\xdeb\xf5c\xf5\xf8\xaa\xb6n\x97\x9fK\xf1uŨ͵\x12\xc3+\u007fo\x97\xc7I[B\xba\xc4l\xf0\xcb|\x12\xc5\n\xd3:~\x12u\xa4h\xd8Ç\xf0Z\xe9\xb8\x16:\x9d\xb6\x8b\x1fj-3٠QնG\x89\xfc\x04W\n\x1a\xbb{H_\x90\x82\xaa|\xe8\x11\xf6\x89\x93<\xa6\xaa\n\x89\u007f\xc5\x1e\u007f\xce\x1b\u0087Μx\xaa\xee\xe2}D\xa6\x15\x1f\x86\xba\x17\xb3\x88\x85la0\x1f%\xdf!${\xec\x01\xb3\r\x8a\x832\xfd\x13'~\xf2\xf4\xe16\xb3:qҊ[|\xba\x8c/Նv\xb5@|\xb2\xfa\xfe\b\"7\x1d\xb3A\xa1j\xe4\xe4D躘Їb\xb1\xbb\x87\xf4\x05)\xa8\xca\x15\xf2,|\u007f\x8b_\xfc\xbeLUm\x9bƟ\xf2\xd7.*\x0e\xfd\xf2u\xb8\xaa\x85\xe5:[\xf4Q\xb5X\x18s\xb8\xf5C~r>\x8fK\xc0\xaf>͙\xff\xd4\u007f\xca)d\xf1\xab\xbb^\xe1\xdb\x11g\xdfc6\xc8ŋ\x9c\xd2\xe4\xf2\x90\xed\xa6;Ƈ@\xf2D\xc3o\xe4y\xffڶ\xf0\aq\xf9c'ɹ\a?5\x1b\xb3\xc1(U?\xcf\x15\xa5\xa1Kwcw\x0f\xe9\vRP\xf5U\x12\"\x93\x8fB檪\x1f\xac\x1a\xaeʟB\f\xd4ꪾ\xefS\x9a\xf9Ǖm\xb5z\xc9\xca\xc83Y\xc2\xfb\xe8\r\x8a\x93\xa4\x91\x8b\xbeŅ+\x95\xa6;\xf6\xa1\xbe\x99a\xb2\xef\xb6\xc3\xfa\xd5\n\x9c\"!d\xf4\x06\xa3Tm\x9b\xc7\x1f\xeb\x17p\xc5\xec\x1e\xd2\x17\xa4\xa0j\xf8\xe3\xf9\xac\xfaY$\x9e\xaam\x1f\x8d\b\xff\xf6\xaa\f\x1f\x8b\xc7U\xb5\xedͼp\xa3W\x9e\xac:,\xcf\xcbs\xd3\xeb\u0082\xe5ɋ\xb0\xa37\xc8?0\"\xcaG\r\xfc\x9cTN\xab鎽\x19\xba\xfezn\x1d\t\xff\x83\x952\xa23)\xd4I\xd4\x06\xa3U\x15\xb3\x86\xc8e\xb1ѻ\x87\xf4\x05\xa9\xa8\xda\xf6ʣ\xb9\xdea\xf3\xf6\xb4\xf5\xa0j\xdb\xe7+\xa7\f\xd6|ß\n\x9f\x8d\f\x11_ն\xd6\x15S\xf2\xbcZ\xee\x98g\xc3\xce}T>X\x1b<It\xb7g~qn\xe6\xa01\x8bBW.Eo\x90\u007f\x1f\xa3l\x85\xef,?\x19o\xb6c\a\xe6\x16y\x87\x94\xbd٦\xab\xcaF\xf4\xb9c\x06k\u07bc1\xf3\xfeS\xef\xc1\xb8\xc1hU\xdb\xf8\xf5\t\xf5\x91\x87Q\xbb\x87\xf4\x05\t\xab\x8a \xfd\v\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80`\xa1*\x828\x05T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa4]ՉdIlc\xfb\xbd\xd86+V\x90\xa7\xadJBE\tU\x9a\xd3@ʭJ\x10\x87`\x87\xaa\xc1\x95\xbe\xebf\xa5=\x93\x90\x80\xa8\xaa{\xb0C\xd5\x0eBPU\xa4\xb7\xa0\xaaV%\x88C@U\xadJ\x10\x87\xd0\x1bU?~O\xe7\xff\xea\x8dR\xd5\x06Rw\xa9\xba@+\x9a\u007f\x89\xd2\x1a\x11\xfbs\x84\xb5\xb6W\x17i\xb9e;xY=Y\xb5c\xb8o\xec)\xb5\x90\xb1\xbd\xa2@\xf3\x8d^p\x81F\vx\xe2\x99aZ\xee\x8cݦE\xc6ʝe\xf9\xbe\xf1M\x87Ȥ\xc8F\f\xab4\x90\xda\xe3\xe59\xd9\xe3_\v\x8a\a\xe5\x17\xf8\xe6\x17\xa6\xf0\xb7\x84\xd8KoT}\xe4\xefu\xfeMo\f\xabZ]@\xb2s\t\x19\xddA7W\x10R^\xd1N\xe9\x8e,\xe2}\xb8\x88\x90Ŕ[T\xed%$\xabC-\xa4\xb4\x8a\x90\x82\x92<\xf6\xedr\x94\x80M>\x92]\x92OH\x93Y\x91\xa1\xb2\x81\x90\xfc\x12\x8dTHU\xe5F\f\xab0;\xb35\xff\xa3\x1eR\x19\xe4\x0f\x1e\xce#\xf9l\xf3\xc5\x1d\x14q6\xbdQ\xf5\xcc?\xe8\xaa\x1e\xd4\x1bê\x92Ql\bl\xd2\xc8\x06}\x02ОMj\xeePڒK\x1a\xb9E\x9e\xe1M\xcd\x1b\x8c\x85\xcd\xc4LJ\xdc@6Yi\x14\xf0\xebl\xb2\xa0\x83\x06k\x89\xf7\x92I\x91Zy\xd4C\xea\x83\xf4\xf2\f\"U\x95\x1b1\xac¶8\xfc$\xa5\ar\xc9F\xf1`\xd8>J?\xd0\xc8f\x8a8\x9bި\x1a\x19V#\x83jDտ\xf0GU\xa4JW\xb5\x86\x94\x89\x8a7\xc8(n\x119F\xa3\vk2\x16\x89\x8a\x1a2\xc7(\xe0\"\xe2\x0fu\xbeޤH\xad\x9cEj\xf8\x8f\x8eaRU\xb9\x11\xc3*l\x8bG\xf9\x837H\x91x\xd0\xca\x1f\x88\xcd#\x8e\xa6W\xaa\xea\xc3jdP\xd5U-\x16\x8fV\xf1Ö\x90\xaa\x85\xe4m\xd1\xd6\xe1!\xa7\x98EE\u2061\x90ޓo\xc3\xcbȓF\x01\x8bC\xab\xb6\xb7\aM\x8a\x94ʮl)'k\x13\xaaʍ\x18Vi \x13d\x9b\x97\x1c\xd77_\x8f\x87W\x8e\xa7W\xaa\xd2\u007f\x8f\x19TuU\xe5\b\xba\x9e\xcc\b\xabz\x8bM\b\xc7\v4\xd2\xccܐ㤡\x90\x95\xeeް\xb8b(!\xb3\x8d\xaajr\xec\v\x11]\xa4T\xb6\x93̠Xh\x96\xaa\xfacWi\x90\xe3.\xf7\u007f;{ +6ꕈS靪_\xfcC\xf4\xa0\xaa\xab*G\xa9\xf5\xdcD\xa9\xeay%\x05\xb8\x91YT!\n\f\x85\xc1U\xecȉd\x94L\x88R\xf5\x0e!\xed\xfa\x06b\x8b\x94\xcaC$K.|\"U\xad\x88]\xa5\x81,\x95%\xe3\xc8\x1b\xfa\xe6QU\xe7\xd3;U\xe5\xb0\xfa#\xb5%\xae\xaa\xd7\t9\x11)3U\xb5\x96dTn\xde\u007f\x8b\xd6E\xa9\x1a$\xec\xbd:Ll\x91Ry\x82d\x18FՊ\xd8U\x1a\xc8\x02Y;\x9a\r\xee\xa8*\x1cz\xa9\xaa\x18V\xd5A5\xbe\xaat\b?\xf2紜\xec2U\xf5A6;j\xe2TGO\x00\x86\x8b\xb3T\x94\xbe=m\x95I\x91R\xf9\xc0\x1b\x9a\xab\xaeTT5\xae\x12~Ͽ\xa3\xb1\xa1\x1aU\x85C/U\xe5êaP5S\xf5\x1e!\u007f\xa3\xfc(\xbbD\x8cx\xdb\xf9)'3U/\x84\x06\xcf[\x05\xfcIU\xd5\x1a9\x93\xa5e\xa4֤H\xad\xac\x90cfW\xb1\xa2\xaaq\x95\x06\xa2\xb5\xcb-\x97PT\x15\x10\xbdU\x95\r\xab\x86A\xd5LUvT\xd4x\xa7\x8b\x1e\xf7\x9297\xd9,2\x97T\x9bO\x00\xba\x06\x91\x1a&\xf3Y?\xe1k\xa9\x02\x9e\xf6\x91e\x0fh\xb0\x8ed\x9d7)R+\x0fgx\xd6\a\xe9\xcd'\x89\xa2\xaaq\x95\x06BJ\x98\xab\xdb}\xec\xfd\x1fU\x05DoU\xa5\xffn\x1cTMU-a\a5\xcd\xe2<\xbf\xb7d8\x93\xa8#\xce\\\xb5\x9e\x90\xa1\xfe\xb1\x9e\x9cE\xe4\xe1\xe8O\xab4\x92S\x92K\xb4&\xb3\"Ce=\xff\xb4\xcaG\xc6q\xf7\xc2\x1b1\xac\xd2@\x86y3K\x86\x11RKQUH\xf4Z\xd5/\x8c\x83\xaa\xa9\xaa\xc7'zs\xde`?O\xfc\xacH\xf3\x95\xac\xe2\xd7Y\x9b\xaaJ\x9b'\r\xf1\x8e^t首\xd1n\x14\x90\x1e\xaf,\xc8\x1cR\xc1/$\x88-2V6\xfb\ay'47\xf0)Cx#\x86U\xd8\x16\x8f\x94e疵\xa8\x9bGU\x9dO\xafUu(+ȼ8\xcf\xe0\xc5T@\x19h\xaa\x96\x95\x04\xc4ωd]\x9c\nT\x15(\x03M\xd5\xf9☩c1ɽ\x1c\xa7\x02U\x05\xca@S\xf5B\x11\xc9\x1cU\xec#Y\xcd\xf1*PU\xa0\f4U\xe9͕%\xb9\xbe\x115'\xe3\x16\xa0\xaa@\x19p\xaa\"\x03\x15T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 ؤ\xea\xc5o/^\xb9ml\xba}\xe5\xe2\xb5k\xdd\xe6\xe5\b\x12\x83M\xaaF\xf8x\xed\x15\x8a\x82\"\xc9c\xaf\xaa\xf7)]\xfd\xd8_\xf9\x0f\x04I\x12{U\xa5\xfc}\x1f\xc7T$\x15\xecT\xf5\xfe\xfd\xce\xfb\xf7\x0fn\xbb\xc6~t\xa3\xafH\x92ة\xaa`u\xe99\xab\x12\x041\xc1vU\xbb\xafXU \x88\x19v\xa9\xca\xde\xf0\xbf\xd8\xf6۵kּ\xbe\x8d}[\xfb\xd6{\xdfY\xad\x81 \x06\xecR\x95\x1d\xf4\xaf}\xbct\xfa\xe4ɓ\x1fa\xff\x9f\xfe8\x9b\x06\xe0y\x00$\x19lT\xf5\x85\xc9\x1f\u007f\xf6\xe7\xcf\xfe\xcc\xf8\xec\xb3_N>\x83\xaa\"Ia\xa3\xaa/\x96\xde\xd5\x1f\xae)=C;)ڊ$\x8e\x9d\xaaN\xffB\u007f\xf4\xc2\xf43=U#H\fv\xaa:UW\x95.GU\x91$\xb1Q\xd5\xe5\x8f\xdd\xd8\xf6\xa3\x1f\xfd\x1b\xfb_\xe9\xfd\xdfN\xbf\xb8wm\xe7\xc15\xca\xf5\x00G<\x84\x90\xb9\xfa\n;\xf2\x9aL;\xb2\xa0\xde\xfbk\xb3\xe6v\x8d\x14\xf3\x9fGg\xe4\xe7Lk)\xd9mV\x838\x1b\x1bU}~&\xfd\xe5\xf7\xfe\xee\xfb\u007f\xf7\xfd\xef\xfd\xf7\xcemSo\xbf\xfe\xd8\xed?\x94*\aW]\x9f\x8c-\t\x9c\xd7W\xf8 \xfb\xed\xd8^Z\x0eŶ\x19)\xd1J̚\x83\xfb\xaa4\xf6\xe3\x90V\xde\xf4F\x05\tGh#\x90\xb0Q\xd5\x17J\xbf=\xb7m\xdb{\xec\u007f\x1fӗ\xa6\x9e\xbb\xf2Y\xf7\x95/:\xd5\x1a\xbf!<2Hc\x99\xf0\xa4I\xa3\xca\x1dO\xa5\xe7\x96\xe93u\\\xd52?\xeb5X\x85\xaaB\xc4FU\x95\xb9j\xb7\xe9\\\xd5o\x99s:~\xb6EA\v9DZL\x9f\x11\xaa\x0e\xe7\xf9\xaf\xf4(Iin\x81\xf4/v\xaaZzN\xceLٷ\xff\x98z\x86ލ>Y\x15Q\xf5\xba\x8f\x10\xcfV\xb9\xbc\xb3\xacH˟1,H\x9b\x88d\x1co\r\xbe\xf6hv\xf1\xc2\x0eJ\x9f!\xda\xc6\x05\xc5YegEq\xddPZ\xc8\x13\xa9\r\xad\xdfT\x16\xe6\xce\x12\x13\x80'\v\x8e\xf1u\xb7\xdfR{8\x92I\xc8\xd2S\x95\xc3}e]\x8d\xac\xfb:ZG\xc4\x14A/@\x1c\x81\xad\xaa\xde\xd0\x1f\xae)5\xf9\b@\x19U\x0f\x05\x02\xde:\xb1t \xa3\xf2\xed\x1d\x1b\xf3I\x17\xbd\xb3;0zZ \x108\xc1\x9b\xe7yj\xb67\xe4\x8d\x0fҿl\xcd$yu\xbfΑ\x19\xd5\xfeYt6\xefEm=\x95S\xbc\xb9\xa9\x8cpUۋ<eu{\x1ePC\x0f\x1d\x8d[\x87\x8d\x1eT\xb4\xa02\xe3\xeb[;s\x96]\xa2\x97jsw\xdeR\n\x10G`\xa7\xaa3\x9f\u007f\xe9\xc5Ռ\x17W\xbf\xf4\x93GL.\xb06N\x00|R\xd5uy]\xfc{\xae0F\x9f\x00\xbcK~Ǿ\xef'|\xe4\xd5r\xcfRZ\x99Ǜ\x83\xd9\xf5\xb4>[\x94FZ\xa7\x8cb#c\xb0\x84\xabJ\xaf\xae\x98\xa0\x91\xdcƨ\x1e\xe8x\xe2\xbfI\x837\xd9\xd2<>\x1b\xae\xfcYt\x01\xd2\xffب\xea[?}\xact\xaa\xa4\xf4\xa7?\xbf\x98\xa0\xaa\xe7\v\x87\xd7l<\x1c\x94#\xa1\xae\xea\x93#\x1et1\x86\xf2\x93[\xda\x1c\x1a\x9a\x8a\xd2#dw\xc7nr\x84\xaa\xad\xd7\xc9F\xfex\xa9\x16Z\xf5ގ2\xb2\xdd\xd8\x03\x1d\xaf}\x1dz\xb6\xc5\xd7A;\xb2Z\xa26\x818\x00\xbbTe\xdc8w\xe6\x8b0\xe7\xbe5\xb9\xb6\xdaTUz}\xc3\xecb\x92\xbf\xca8\xaa\x96\x84\xe6\xad\xfc\r^\xe3\x85R\xd5\x06\xd1\xd8@\xd5\xd6CDĮ\x8b\x82\xfd\xdf\xf0\xc5\xe0\xa4rc\x0ft\xfc\xb8\xf0V\xbb\xf2\x9bhS~0j\x13\x88\x03\xb0QUK\xa4\xaa\xb7\x96]\x15\x8fB\xaa\x1eZ̼\xb9\xbeշ\x8e?\x10\xaanf#`\xe5\x88C\x02\x9e\xa4\xae\xa8:k\xdc\xfe\xfd\xfb\xc7͢j\xeb߈Xu\x0e/(\xa8\x11}.\x19e쁎\x9f\x15\xde\aZSA+D\x95\xa1\x00\xe9\u007f\xecT\xb5\xbb\xfb~\x98n\xb3\vU\xa4\xaa\x87\xc9N\xf1(\xa4j\x1d\x11q\xe9\xfe\xeap\xc5%~t\xde,O\x8d.YI\r\xaa\x16.d\xdf\x16\x14RC\xeb\xc4\"\xe6\xfeI/_\xcc/\xe4\u007f\x06An\xa6ڃz\x12l\x8f\xf7\x82w\x0f_0\x14 \xfd\x8f\x9d\xaa\xf6Lמ\xb1%\xec\xf8>\xb0\x81\xbda?\xf8$\x10\xf0V\x05v\xde\xe4\xaaf\xd7~\xd04W\x9e-\xad\xd3\xea\x9b\xfc\xd9\xfc#\xad\xc5\x19O\xbf\xcdZߠ\x17\x02Zվ\xe0\xe1*-p\xa1\xa3\x99,\xb9C\xef\xfc\x8a4\xdfSZ鱬\xa2\xba\xa5\x83=\x99\xbf;N\xf3IAms\x93\xdfwR\xed\xa1k\x8f8\xb3\xd0.w#XXV(\x0f\xfa\xf5\x02\xc4\x118Gգ\x9e\xd0\xe4\xd0w\x82\x1e\b-o\xa0\xf4\xb5iuEZ\x81_\x9e\u05ffW3\xd87m\xbfXl\xf6\x0fɝ\xd2\xccϠ\x12\xa2\xb5f\xb3\xef\xcf\xec\xc8\xe0\xe7C\x9b\b\xc9ء\xb4Rz\xaa|\xf0\xf0\xe7~\x97\xc9\x16'l^R\x9c\x9dWq\xd2\xd0\xc3\x11\xb9\xb1\xf2\xd0~\xd4k\xf5\xa1\xa5p\x01\xe2\b\x9c\xa3*\x82\xf4\b\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xf4\xb3\xaa\x18\x12\x84$J?\xab\x1a\x01C\x82\x90\x9eq\x86\xaa\x18\x12\x84X\xe2\fU)\x86\x04!V8AU\f\tB\x12\xc0\t\xaa\n0$\b\xe9\x19Ǩ\x8a!AH\xcf\xf4\xb7\xaa\x18\x12\x84$H\u007f\xab\x8a!AH\x828@U\f\tB\x12\xc1\x01\xaabH\x10\x92\bNP5\xa1\x90\xa0\xa6G/\xc5y&U\xaeN\u009bWC\xc2\t\xaa&\x12\x12\xb4\x8a\xd4Eݓ\xb7\xd7a)\xc1U\x9e\xd8\xfbQa\u038bcq\x80\xaa\x16!A\x82\x06\xcfkQ+\xa6#,e{fCt\x13\xe6\xbc8\x16\a\xa8j\x11\x12\xc4i\xd3\x16\x87\x17/\xfb\xe5]$\xd3\x12\x96\xb2L;\x1bӆ9/\x0e\xc5\x01\xaaZ\x86\x04Q:\xb7@O\x8f8F\x8e\x89\x9fi\tK\xb9S\x10{Oj\xccyq(\x0eP\xd52$\x88>\x18\xb4H.4\x8c~\xf7\x049\xb1}\xf4\xfaT\xc3R\x94\x02\xd1\xe12_L\x82\n\xe6\xbc8\x14'\xa8j\x15\x12D\x0f\xcb{\xa4\xf3_7y\x98\x94\x90Y\xe7S\rKQ\nĚ\xbb\xc9\x1e\x1a\x05\xe6\xbc8\x14G\xa8j\x11\x12D\xb7\x93\x93\xe1\xc5f\x8dh\U000969e9\x86\xa5D\n\x18gI\xcca\x13\xe6\xbc8\x14'\xa8j\x15\x12\xc4\xdetC\xb7\x94\xbe\xba@+$\x85\xde\xe7\xfe&\x1f\xa6\x14\x96\x12)\xa0\\\xd5F\x1a\x05\xe6\xbc8\x14\a\xa8j\x19\x12D\xf7\x91O\xe4ª\xfc\r\xc7\xc9_\x1a\xf2W\xf6\",%R@\xf9p\x15sr\x13s^\x1cJ\u007f\xabJ\x13\b\t\xa2\x1dZH\x18\xfa\x80\x1e#\xc7\xe9\x83`/\xc2R\x94\x02\xaeN\xccI%\xccyq(\x0eP5\x01f\x8d\xd2\x0f+\xce\xe7\xca\x13\xf4)\x87\xa5\xa8\xa7\x9a\x82\xc5\xe1\x04\x00ھ\xb2M.`\u038bCq\x82\xaaV!A\x94\x9e\xf0\xc4|P\x99ZX\x8a\xb1\x80\xd6\x13\xfd\x83\xa7\n2\x83\xff\xc0\x9c\x17\xc7\xe2\x04U\x13`\x997zN\x99ZX\x8a\xb1`\xa7\xef9\xbd\xbf\xcdy\x1b\xf8\x0f\xccyq,@T\r\xce\xd7\x1a\xadj\x92\xa6Q\x9b\xdbeU\x838\x06 \xaa\xd2`\xfd\xd0t\x1fY\\-X\x89'\xd6\x01\x01EU\xc4\xf5\xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\x0eU\x15\x93W\x90h\x1c\xaaj\x04L^A$\xceV\x15\x93W\x10\x1dg\xabJ1y\x05\t\xe3dU1y\x05Qp\xb2\xaa\x02L^A$\x8eW\x15\x93W\x10\x89SU\xc5\xe4\x15$\n\xa7\xaa\x8a\xc9+H\x14\x0eV\x15\x93W\x10\x15\a\xab\x8a\xc9+\x88\x8a\x93UM(y\x05q\vNV5\x91\xe4\x15\f\tr\r\x0eV5\x91\xe4\x15\xdbB\x82\xd2\xd0/\xd2;\x1c\xacj\x02\xc9+\xf6\x85\x04\xa5\xa5_\xa478X\xd5\x04\x92Wl\f\tJK\xbfH/p\xb0\xaa\xd6\xc9+v\x86\x04\xa5\xa5_\xa4\x178YU\xcb\xe4\x15;C\x82R\xeb\x17I\x1f\x8eV\xd5*y\xc5ΐ\xa0\xd4\xfaE҇\x93U\xb5L^\xb15$(\xd5~\x914\xe1`U\xad\x93Wl\r\t\xa2)\xf6\x8b\xa4\t\xa7\xaaJ\x13I^\xb13$(\xe5~\x914\xe1`U\xad\xb13$(\xe5~\x914\xe1dU\xad\x93Wl\f\tJ\xb9_$M8YUk\xec\v\tJ\xb1_$}\xc0Vվ\x90\xa0\x14\xfbE\xd2\apU1$\xc8=\x00W\x15C\x82\xdc\x03tU\x11׀\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10`\xaaڍ!A\xee\x03\xa6\xaa\xf7)}i&\x86\x04\xb9\v\x98\xaa2:\xa3\xc2\x02\x91\x81\x0eLU\xd9;\xff\xde\u05ef\xe1\x04\xc0U\xc0T\x15'\x00.\x04\xa6\xaa\x14'\x00\xee\x03\xa6\xaa8\x01p!0U\xc5\t\x80\v\x81\xa9*\xc5\t\x80\xfb\x80\xa9\xaa\x9c\x00tw\xd2\xee\xfb\xfc\v\x87W7\x00S\xd5\xd0\x04\x00q\x130Uet\xde\xe8y(Ő\xa0\x81\x06LU\xf95\x00o\xdd\xdf\xfbR\xe7\xde\xd5\xec\xeb\xee\xc1\xb51\x15\xb6\x85\x04U\x11B\xb2NŶ\xab\xfc\xad:\xdf7\x03o\x83\xd1K`\xaa\xca\xefi\xfd\x93\xef^\x9fy[|\xdd\xd8\xf6\x93\xe8\x02\xfbB\x82\xce\x06\x02\xeb·y\x8d\x87\xbf`\xc3\x1c\xdf\xf5\x9ek\x10+`\xaaʸ\xfb\x1d\xbd\xf6\xd7\xd0\u05cdsQO\xda\x18\x12D\xf9}\x83{V\xf5*i\xa0\xc1\xe8\xfb\xb5\"\xc9\x02SUq\x06\xe0J\xfc\xe7m\f\t\xa2֪\x9e\xea\xddF\x11\tLU\xc5\x19\x80\xaf\xba\xef\xc69YegH\x10UT\r\xae\x1f\x975v\x9d\x98\x94^\xae\x1c2t\xe1\xc2!ٍ\x0f\x86ț\xad/\x88]\x0fI\n\x98\xaaҞ?\x02\xb03$\x88*\xaa\xceіn_\xaaU\xb1\xa5\a\x0f\x17\xac\xab\xf5\xfa6\x97\xd5\xd3Á\xad\xa4.\x10\xb8\x10\xbb\x1e\x92\x140U\xb5\xb8\x06\xc0\u0590\xa0\x88\xaaͤ9\xfc\xbd\x91\x1c\xa1t\x1d9.\xdaq\x02\x90\x16`\xaajq\r\x80\xcd!AaU畈\x1f\x0f\xb3auq.[8\x19R\x14UM\v0U\xa5=O\x00\xec\f\t\xa2\x11U'\xc9\x1b\xad\x97O\xa4\xb4>\xe32\x1f_\xe5\x11\x1d\xaa\x9a\x16`\xaaj1\x01\xb03$\x88FT\x9d;\x82{\x1e\x1c>\x87ү=e_\x1f\x19=I\x9e\xf6GU\xd3\x02LU\xad.\x02\xb41$\x88FT\xdd.&\xb7[\xf9\x1c\xe3\x10\xc9'\xc4\xff\x8d|\x1eUM\v0U\xa5\x16\x17\x01\xda\x18\x12t\x9e\u007fZU\x1f\b\xf0\tm\xa5g\xf1\xbb\x8b=\x95l\xe9\x90w\xc7\xf6\xc07\xa23y\x06`\x1f~\xae\xda[`\xaaj\xf9\xaf\x00\xec\v\t\x9a\x13\x9a\xd7\xf2\xd3\a\xc1\x86\x92\xac\x12q^u\xb7\xc6۴i\xc7\xe8\xbd\\\xf1t\xe6\t\x8a\xf4\x0e\x98\xaaZM\x00\xfa;$\xe8Rv\xf5\xa5\xae\xae\xeb\a*\x06\xe3'\xffi\x03\xa6\xaa\xd4\xf2_\x01\xf4oHPS\xae\xac\f\xe6c\xccZڀ\xa9\xaa\xe5\x04\xa0\x9f9䑧\xa9\x8ey\x0e[T\"\t\x03SU\xcb\t@?\x13\x9c\xeb\xabnli\xac\xf6U':\x0e#\x96\xc0T\x95ZN\x00\xfa\x99`SY\xa1VX\xf6.\x9a\x9a>`\xaa\xea\xf4\t\x00\xd2\a\xc0T\xd5\xe9\x13\x00\xa4\x0f\x80\xa9*u\xfa\x04\x00I?0U\xc5\t\x80\v\x81\xa9*N\x00\\\bLU)N\x00\xdc\a\xaa\x8a\x00\x01\xa6\xaa8Wu!0UŹ\xaa\v\x81\xa9*\xc5\t\x80\xfb\x00\xa6\xea\xb6\xce+w;\xef\xdfg_{_\xbf\xc2\u007fܧ\xf7\xef\xde\xed\xbck\xb5\x1e\x02\x1f`\xaa\ue95d\xfc\a{\xe7\xff\x8f\xd238\x01p\x15\xc0T\xedԗ\xae\x9c\x89,#n\x00\x98\xaa\xfc\xa0\xff\xe0\x1fV\xbf\xb0|\xf9\xf3\xbf\\\xbe|\xf9\v\xbf\u007f\xeb6\x9e\ap\t\xd0Te\xef\xf9k\x1e/e̔ߧ\x9e\xc3i\x80K\x00\xa8\xea\v\x93\xf7~u\xe6\xab\xef\xe8\xc53_}\xf5\xfcd\x9c\xb1\xba\x05\x80\xaa\xbeX\xfa\x1d[x\xef\x17\xfc\xe1\x9a\xd23\xddw1\xb6\xc2\x15@Tu\xfa\x17l\xe1_\x1e\xda\xcb\x1e-\x9f~\xc6j\rd\x80\x00RU\xae\xe7\xffx\x88\v\x1b_U\x8c\xad\x18h\x00Tu\xf9\xcc\xdb\u007f\xf8\xd7\x1f\xfe\xb7\xef\xfd\xf3\xbf\xfe\xcf\xfb\xafO\xbd\xf2\xf1\x8b\x9d\a_\x8a\xa9\xb3-\xb6\"\x01\x8e\x97e\x17T\xb6\x14\xa4\xfbO\xc7m\x00T\xf5\xf9\x99ݿ\xfc\xc1\xf7\xbf\xf7\xd0\x0f~\xf0\x8f\x9doM\xbd\U00047677\xfb3\xb6\u009a\xe6\xec\t\x1b\xb7\x96\x10\x82\xf7W\xe9\x1d\x00U}\xb1\xf4ܕ\x83\a\u007f\xf8\xfd\xb5\a\xffLWO\xff\xea\xc6W\xf4\xf6\xb7QU\xf6\xc6V\xf4\xcc՜\x8a{\x94\xde\x19\x85\xaa\xf6\x12\x88\xaaN\xfd\x8c-\xfc\xf0!6K\xed^^j:W\xb57\xb6\xa2g\x16\xfb\xfe\x1f\xffQ\x8f\xaa\xf6\x12\x88\xaa\x96^d\v\xa5\xffą]=\xdd\xecd\x95\x8d\xb1\x15\xcf\x10m\xe3\x82⬲\xb3T\xed\xb7\x96u\xb3\x95neߗ\xd1Q?\x13\x85\x97\xeb\xef)\xb9\x16\xcaj\x86\x1e\x90\xf8\x80T\xf5\x9a\xfe\xf0%ӋVl\x8c\xad\xf8\xcb\xd6L\x92W\xf7\xeb\x9c\nC\xbf\x97\x9e~\x94usk\xf7\x94\xca\xcb\xf7<\xe1\xbb\vR%\xd7BY\xcd\xd0\x03\x12\x1f\x88\xaa>\xfe\x8b\xe5\xcf?\xbf\xe6\xf7\xec\xdb\xf2\xc7\x1f1\xbb\xc0\xda\xd6\xd8\n-\xf7,[-ϸ\xdak\xc5\u2e52\xd7h\xbb2\xe5Pr-\x94\xd5\xd4E$>\x00U\xdd\xf6\U000d93d5J\x1e\xfb\xf9/\xae\x98\xa8jkl\x856\x87\xf2\x1b\xaf\x1bW;\xe2\xb9\xd7\xf1\xda\xf5.\xed\b}\x90\x19\x19U\x95\\\ve5u\x11\x89\x0f4U\x19w\xaf\\\xbc\xf8\xed\xb7\xd7\xee\xb2o\xdf^\x89\xcc\x05\x14l\x8d\xad\x10\xb9\x03B4e\xb5{\x99G\xebɲ\x13\x1e6?\r\xcdU\x1f4\x1br-\x94\xd5\xd4E$>\x00U\xa5\xe2R\xc05?\xbd\xe2\x8c؊\x88h\xeaj\xc5[\xfdS\x8a\x9b\xf84`\xb1Ot\xd3H.\xa9\xb9\x16\xa8j\xd2\x00T\xb5\xbb\xb3\xf3Fg\xe7O'\xef\xed\xbcq\xbf\xd3\xfcB\x15;c+\"\xa2\xa9\xab=]\xa35\x93g\xf8\xec\xf7jN\x05;\x98\v\xfa\x87\x1br-Pդ\x01\xa8\xaa\xe4\xf6\x95\x1e.\xa9\xb6/\xb6\xe2B@\xab\xda\x17<\\\xa5\xf1dJ}5JWf\xe5\x04G\xfbV\xf0\x92\xe6\xacI\xbfk*\xcb\xe43\a=\xd7BY\xcd\xd0\x03\x12\x1f\x98\xaavR\xba\xf6\u007f\x9f\xa1\xf1\xffɊm\xb1\x15\xcf\xf0t\x8a\xd6l\xf6\xfd\x19e5J\x0f\xe5\xd6\xd2U\xd9\xfbE\xe9\xf1\xb2\xac\xfc\x8aV\xbe\xa4\xe7Z(\xab\x19{@\xe2\x02Sջ\x94\xb2\t\x00\x8d\xff\x0fU\xfb9\xb6\x02\xe9\x03`\xaaJ-&\x00\xfd\x1d[\x81\xf4\x010U\xc5\x1b\x01\xb9\x10\x98\xaa⍀\\\bLU)\xde\b\xc8}\xc0T\x15'\x00.\x04\xa6\xaa8\x01p!0U\xa58\x01p\x1f0U\xc5\t\x80\v\x81\xa9*N\x00\\\bLU)N\x00\xdc\a\xaa\x8a\x00\x01\xa6\xaa8Wu!0UŹ\xaa\v\x81\xa9*\xc5\t\x80\xfb\x00\xa6*\xc6V\xb8\x17`\xaabl\x85{\x01\xa6*\xc6V\xb8\x17`\xaabl\x85{\x81\xa6*\xc6V\xb8\x16\x80\xaabl\x85;\x01\xa8*\xc6V\xb8\x13\x88\xaabl\x85+\x01\xa9j_\xc7V`@\x85\x13\x01\xa8j\x8a\xb1\x15I\x90r@\x05҇\x00T5\xb5؊\xe4H-\xa0\x02\xe9K\x00\xaa\x9aZlE\x92\xa4\x12P\x81\xf4)\x10UM)\xb6\"IR\t\xa8@\xfa\x14\x88\xaa\xa6\x14[A\xe9\xe9Y\xf9Z\xc1\x8cohb\xe9\x111\x01\x15\x94\xee,+\xd2\xf2g\f\x13\xf7HM8\xf8\x02I\x17 UM%\xb6\x82\xb6d\x8f[\xb5\xa3\x8e\xf0{\xfd%\x92\x1e\x11\x13PA\x0fdT\xbe\xbdcc>\xe1\xb7XK<\xf8\x02I\x17\x10UM)\xb6\xa2\xa3\xa8\xec\x1e\x1bo\x1b\xaf&\x98\x1e\x11\x1bP\xb1.\x8fK\xba.7\x98l\xf0\x05\x92\x16\x00\xaa\x9aZlE39\x1c~:\xa1\xf4\x88\u0600\x8a\xf3\x85\xc3k6\x1e\x0e\xf2<\xa1\xe4\x82/\x90\xb4\x00MU\x9ajlE=\xd1'\x8e\t\xa5G\x98\x04T\\\xdf0\xbb\x98\xe4\xaf\n&\x1b|\x81\xa4\x05\x80\xaaҔb+vD\ue35ePzDl@š\xc5l\xb5\xeb[}\xeb\x92\r\xbe@\xd2\x02@US\x8b\xad\xb8U\xe0\xe7o\xdd5\xf3\x13K\x8f0\t\xa8\xa8\x13\x93[\xea\xafN6\xf8\x02I\v\x00U\x95$\x1b[A[\xbc\x0foh\xae!\x9biB\xe9\x11\xb1\x01\x15L\xd5\xec\xda\x0f\x9a\xe6\x12>\x17M<\xf8\x02I\x170UM!\xb6\x82ғ\xb3\x87\x0e\x9a(\xaeC\xb1N\x8f0\t\xa8\xa0\xafM\xab+\xd2\n\xfc-\xe2A\xc2\xc1\x17H\xba\x80\xa9j_\xc7V`@\x85\x03\x81\xa9*\xed\xdb\xd8\n\f\xa8p\"0U\xc5\x1b\x01\xb9\x10\x98\xaa⍀\\\bLU)\xde\b\xc8}\xc0T\x15'\x00.\x04\xa6\xaa8\x01p!0U\xa58\x01p\x1f0U\xc5\t\x80\v\x81\xa9*N\x00\\\bLU)N\x00\xdc\aXU\x11\xb7\x01SU6I\xfdxm\xfc\xebU\x91\x81\bLUq\xae\xeaB`\xaaJq\xae\xea>`\xaa\x8a'\xab\\\bLUq\x02\xe0B`\xaaJq\x02\xe0>`\xaa\x8a\x13\x00\x17\x02SU\x9c\x00\xb8\x10\x98\xaaR\x9c\x00\xb8\x0f\x98\xaa\xca\t@w'\xed\xbeϿpxu\x030U\rM\x00\x107\x01SUF獞\x87R\x8c\xad\x18h\xc0T\x95_\x03\xf0\xd6\xfd\xbd/u\xee];\xee\x1e\\\x1bS\xd1/\xb1\x15Gg\xe4\xe7Lk)\x89\xbd[\x06\x92\x06`\xaa\xca\xef\xb2\xfa\x93\xef^\x9fy[|\xdd\xe8\xdf؊\x96\xf0-\x83\x0ei\xe5MoT\x10y\xbb*\xbdռ\x16I\x1a\x98\xaa2\xee~G\xaf\xfd5\xf4u\xe3\\ԓ\xb6\xc6VLx2\xb4P\xe6g\x03\xe6\xac֍\x00\x00\aLIDATy\xb0J\xaa\xaa\xb7\x9a\xd7\"I\x03SUq\x06\xe0J\xfc\xe7m\x8d\xad\xd0\xef\x048|\t\xff~\x944\x19Z\xcdk\x91\xa4\x81\xa9\xaa8\x03\xf0U\xf7\xdd8'\xabl\x8c\xadh\n\xdd\xf3\x97\xdf\x0e\xf8\xc9\x02\xfeW\x11\xdc~\xcb\xd0zsv\xa1VT~\x84\x1ak1\xd7\"i`\xaaJ{\xfe\b\xc0\xc6؊;\xbb\xc5M+\x03'Xc{\x91\xa7\xacn\x0f\xbf\x8b\xab\xda\xfa.\xa9ni,\xf7\xec7\xb6b\xaeE\xd2\xc0T\xd5\xe2\x1a\x00\x9bc+\xf47\xf5\xab+&h$\xb7\x91\x1aZ;\x1ao\xb11\xb4\xa4\xc2؊\xb9\x16I\x03SU\x8bk\x00l\x8e\xadP\xe7\x9f\xf7v\x94\x89\xbba+\xad\x97ו\x8d\xc8!r\x9bz+\xe6Z$\rLUi\xcf\x13\x00\x9bc+\xc2\xfa\xed\xe7\xf3`\x1a\x94\xddGZ\v\x8a\x165\x05\xfcQ\xaab\xaeE\xd2\xc0T\xd5b\x02`sl\x05\xd7o\xf3ה\x16\x88\xc4\n\xbad\x94\xa1\xb5x\"\xff\x1b\x99\xa5\xa8\xca[1\xd7\"i`\xaaju\x11\xa0\xad\xb1\x15~?\xa5\x97xC~\xe1U\xbe\xa6L\\\xd1[\x8b\xf8\xc3\xe0X\xa9\xaaފ\xb9\x16I\x03SUjq\x11\xa0}\xb1\x15\xbc]\xabo\xf2g\xb3?\x88|RP\xdb\xdc\xe4\xf7\x9d4\xb4֑\xd9\xebV\x8cg\x13\x87}j+\xe6Z$\rLU-\xff\x15\x80m\xb1\x15\x8c{5\x83}\xd3\xf6\xb3\x85\t\x9b\x97\x14g\xe7U\x9c4\xb6\x06\xebGkyOn\x1e\xa5\xf9\xd5V̵H\x1a\x98\xaaZM\x000\xb6b\x00\x02SUj\xf9\xaf\x000\xb6b\xc0\x01SU\xcb\t\x002\xf0\x80\xa9\xaa\xe5\x04\x00\x19x\xc0T\x95ZN\x00\x90\x01\aLUq\x02\xe0B`\xaa\x8a\x13\x00\x17\x02SU\x8a\x13\x00\xf7\x01SU\x9c\x00\xb8\x10\x98\xaa\xe2\x04\xc0\x85\xc0T\x95\xe2\x04\xc0}\xa0\xaa\b\x10`\xaa\x8asU\x17\x02SU\x9c\xab\xba\x10\x98\xaaR\x9c\x00\xb8\x0f\x98\xaa\xe2\x04\xc0\x85\xc0T\x15'\x00.\x04\xa6\xaa\x14'\x00\xee\x03\xa6\xaa8\x01p!0U\xc5\t\x80\v\x81\xa9*\xc5\t\x80\xfb\x80\xa9*\xc6V\xb8\x10\x98\xaabl\x85\v\x81\xa9*\xed\xdb\xd8\n\x10\xb8.[\x03\xac\xaa\a\xdf\xeb>\xf8\xdbN\xf9\xf5_\xbf\x8fy:\xb1؊\xe6\f\xe2\xd9G?\xf1\x10\xdfu\xabRA\xbdW\u07b5\xa5\x8a\x10\x92u*ܺ#\xaf\ai\x8exXm\xe4~\u007f=\xd6&E\xdcl\x8d\xf0N\x0e4`\xaa\xca\x06\xd4_L\xbe\xb1\x96}=¾\xae\xbd\xfe\xf3\xe8\x02=\xb6\xa2眈\x8e\xb7Ɏ\a\xb4cԄ\x04\xd3$J4y멳\x81\xc0\xba\xf0\xdd\x06)\xfd ;\xfaV\xac\n]\x9f\x8c-\t\x9c\xd7\x1f\x9a֦\x18f\x11'[#\xbc\x93ɑ\xe2>\xd8\bLU\xad\x88\xc4VX\xe4D\xb4\x93[\x94\xd6\x0e\x89\xa8\xd4#w<\x95\x9e\xf0\xfd\x01\xf7GT\xa5=\x8f\xdf\xfc\x96j\x11\xccjS\r\xb30\xcd\xd6Pw2\tR\xdd\a\xfb\x18\x98\xaaFb+,r\"\xb8\xaa͙-=\xd6Dh!\x87H\xb8VU\xb5g\x8c\xaa\x9a\x91j\x98\x85i\xb6\x86\xba\x93I\x90\xea>\xd8ǀT5\x1c[aȉ\xd0c+\x9e!\x99\rՅ\x83\xcb\xf9\\\x93\xa9ڞ\xbbB\xae\xa5\x04I\xe8\x8bj-\xa5uCiamh\x1baU\xaf\xfb\b\xf1\x88ۤ7\xb2-\xd5\xd1:\"\x82\xab\x94\xce\"\xaaFj\x95\f\f\xf30\vC\x8a\x86\xdez$\x93\x90\xa5\xa7*\x87\xfb\xca\xe4-\xb5L\xb25ԝ\x8c\x04u\xa8\x99\x1d&\xaf\xcd\xf8\x1fʡ\fHUñ\x15\x86\x9c\b=\xb6\x82\aT\f[\xb1bX\xd61\xaeꥒA\xf7\xe4ZJ\x90\x84\xbe\xa8\xd62\xe9f\xd1\xd9a\xef\xf4Q\xf5P \xe0\x15w\x1e\xbe\xb53g\xd9%z\xa96w\xe7-Cgʨ\xaa\xd7*\x19\x18\xe6a\x16\x86\x14\r\xbd\xb5\xa3q\xeb\xb0у\x8a\x16Tf|-z\x89\xcd\xd6PwR\t\xeaP\x16\xcd^\x9ba\x1f\x9cʀTU\x89\xad\x88\xa4GDb+\xa86\xfc&\x1b\xe2\x8a&rU\x9f\x1eU\xb0N\x14(A\x12j\xa6D\xa4\x96\x06\xb3\xebi}vh\xb2\xa9N\x00|\xa1\x9bd\xcf\xe3\xf3\xbdʟ\x19;\x8b\x9a\x00\x84j\x95\f\x8c8a\x16\x91\x14\rcH\x06\xf1ߤ\xc1\x9b\xb2>6[C\xd9I\xe5\x15+\x8bq^\x1bN\x00\xfa\a=\xb6B\xf9\r(\xb1\x15T\x1et\xad#W\x99\xaa\xbe㛇\x88_\xbc\x12$\xa1fJDj\xe9\x11\xb2\xbbc79\"\xfb0S\xb5\x85\xbd\x1fwd\xb5\x18;3WU\xc9\xc0\x88\x13f\x11I\xd10\x86dh_G:\x8b\xcd\xd6PvRy\xc5\xcab\x9c׆\xaa\xf6\x0f\xfb\"\x1a\xe9\xbf\x01%\xb6B\xdeJ\x9d\x06\xc8!\xa6\xeaV\xdaU,R\xfc\x94 \t5S\"RK\x1bDc\xe8\x04\x91\x99\xaa]\xf9M\xb4)?h\xec\xcc\\U%\x03#N\x98E\xe4~\xefƐ\fu>i\x92\xad\x11\xd9I\xe5\x15+\x8bq^\x1b\xaa\xda?Db+\"9\x11Jl\x05\xd5\xe6\xf3\xef\x1b\xc9My\xb2\xaa\xd9\xcbOV)A\x12j\xa6D\xa4\x96\xce\x1a\xb7\u007f\xff\xfeq\xb3d\x1ff\xaaҚ\nZ!\xb2+\xd4\x1e\xa4\xaa\xb7\x96]Uk\x95\f\x8c8a\x16\x11U\x8d!\x19\xb3h\x84\xd8l\re'\x95W\xac,\xc6ym\x91}p,\x03RU%\xb6BωPb+\xa8\x96\xcf~\xc3wF\xf8C\xe7U\x83\x93x\x82\x95\x12$\xa1fJDji\xe1B\xf6mA\xa1\xec\xd8T\xd5=\xde\v^q\xa0\xa3\xf6 U=Lv\xaa\xb5J\x06F\x9c0\x8b\x88\xaa\x86\x88\vu\xf43\xc9\xd6PvRy\xc5\xcab\x9c\xd7\x16\xd9\a\xc720U\x8d\xc4VDr\"\x94\xd8\n\x8d\x8ck\xdc<:\xf7$\xedh\xe2\x9fVѷ3\xb6\xdf3\x04I(\x8b\x91\xdaf\xb2\xe4\x0e\xbd\xf3+\xd2|\x8f\x9e\xe7\x9fV\xd5\a\x02l\x10z\xf0\t;\xaa\xaf\n\xec\x14\xf3\xdd`aY\xa1\xfc#\xd1{\xe8\xda3\xb6\x84\x1d[\a6\x90\x80Z\xabf`\x98\x85Y\x18R4\x94\xceđzx&\x1e\x9b\xad\xa1\xee\xa4\xfa\x8a\x95E\xb3\xd7f\xd8\a\xa720U\x8d\xc4V(9\x11\x91\xd8\nm\xe1ܜ\xc2\xca\v|\x88\xe1\xd7\x00\xd0i$\x83\x0f\x91J\x90DdQ\xafݑ\xc1O\x986\x11\x92\xb1\x83\xce\tM\xf8\xd8\x11\xff\x01\x8f\\\x94\xd1\x16\xf5Z}h\x0f\xc2=\x1c\r=O|'\xd4ZC\x06\x86I\x98\x851E#\xdczDv\x10\x1aKM\xb25ԝT_\xb1\xbah\xf2ڌ\xfb\xe0P\x06\xa8\xaa=\xc7VD\xa6\xb2\xd6$Sk/\xbd\xcf\xd6p\xeek3c\x80\xaa\xdaslE2\xbf\xa2djm%\r\xd9\x1a\x8e}m\xa6\fTU{$\x99_Q2\xb5Ѐ\xf5\xda\\\xa8\xea7\xe2\x88ŪJ\x92L-4\xa0\xbd6\x17\xaa*\x8eX\xdaiB$S\v\rh\xafͅ\xaa\"0AU\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\x02\xaa\x8a\x00\x01UE\x80\x80\xaa\"@@U\x11 \xa0\xaa\b\x10PU\x04\b\xa8*\x02\x04T\x15\x01\xc2\xff\amu\xa3\x1c\xa2\xebff\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/ipcg-pkg.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\xf0\x00\x00\x03\xc6\b\x03\x00\x00\x00\xb2,^L\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x02\x04\x00\t\v\a\r\x0f\f\x10\x12\x0f\x13\x15\x12\x1b\x1d\x1a !\x1f!#!$%#&(&+-*/1.2416859:8<=;>@=AB@DFCFHEJKIOQNQSPTVSWYV,`\xae7]\xad8^\xae[]Z8a\xaa:b\xab;b\xac_`^<c\xad=d\xae?e\xaf@g\xb1Bh\xb3egdDi\xb4Ck\xafFk\xb6Lj\xafhjgNk\xb1Fn\xb2Ho\xb4Pm\xb2kmjIp\xb5Kr\xb6nomMs\xb8Nt\xb9Ou\xbaPv\xbbrtqXv\xb6Yx\xb8vwuZy\xb9[z\xbaxyw]{\xbbV~\xbd_}\xbeY\x80\xbf`\x81\xbbb\x80\xc0[\x82\xc1~\x80}b\x83\xbdc\x84\xbe\x81\x83\x80e\x85\xc0g\x87\u0084\x86\x83\x85\x87\x84i\x89Æ\x88\x85j\x8aŇ\x89\x86\x88\x8a\x87q\x8c\xc1\x89\x8b\x88s\x8eË\x8d\x8at\x8f\xc4v\x90ō\x8f\x8cw\x91Ǐ\x91\x8eq\x94\xc9y\x93ɑ\x93\x90z\x94ʀ\x94Ł\x95Ɠ\x95\x92{\x98ǂ\x96ǃ\x98ɖ\x98\x95\u007f\x9cˆ\x9a˘\x9a\x97\x80\x9d͈\x9d\u0382\x9fϜ\x9e\x9a\x88\xa0˄\xa1ў\xa0\x9d\x8a\xa2̋\xa3Ρ\xa3\xa0\x8d\xa5ώ\xa6я\xa7Ҥ\xa6\xa3\x90\xa8ӑ\xa9ԧ\xa9\xa5\x92\xabՔ\xac֩\xab\xa8\x98\xacѪ\xac\xa9\x9a\xadӛ\xafԭ\xaf\xab\xae\xb0\xad\x9d\xb1֘\xb4ذ\xb2\xaf\x9f\xb3ء\xb4ڲ\xb4\xb1\xb3\xb5\xb2\xa2\xb6ܣ\xb7ݝ\xb9ݵ\xb7\xb4\xa9\xb8ٶ\xb8\xb5\xa3\xbb٫\xbaڸ\xba\xb7\xac\xbbۦ\xbdܹ\xbb\xb8\xad\xbcܮ\xbdݯ\xbeߩ\xc1\u07fd\xbf\xbb\xb0\xc0\xe0\xab\xc2\xe1\xb2\xc1\xe2\xbf\xc1\xbe\xad\xc4\xe3\xb7\xc2\xdd\xc1ÿ\xb2\xc5\xde\xc2\xc4\xc1\xb9\xc4\xdf\xc3\xc5º\xc5\xe0\xb4\xc7\xe0\xbb\xc7\xe2\xb6\xc9\xe3\xbc\xc8\xe3\xc6\xc9ſ\xca\xe5\xb9\xcd\xe6\xc9\xcc\xc8\xc1\xcc\xe7\xc2\xcd\xe9\xbc\xcf\xe9\xbf\xcf\xe2\xcd\xcf\xcc\xc7\xcf\xe4\xc8\xd0\xe6\xc2\xd2\xe6\xca\xd1\xe7\xcb\xd3\xe9\xc6\xd5\xe9\xd2\xd4\xd1\xce\xd6\xeb\xc9\xd9\xed\xd5\xd8\xd4\xd0\xd8\xed\xcb\xdb\xee\xd4\xd9\xe9\xd8\xda\xd6\xcc\xdc\xf0\xd6\xda\xea\xd7\xdb\xeb\xda\xdc\xd9\xd1\xdd\xeb\xd8\xdc\xec\xd9\xdd\xed\xdc\xdf\xdb\xd4\xe0\xee\xdb\xdf\xef\xde\xe0\xdd\xdd\xe1\xf1\xe0\xe2\xdf\xd7\xe3\xf1\xd9\xe5\xf4\xdf\xe4\xf4\xe3\xe5\xe2\xde\xe6\xef\xe5\xe7\xe4\xdc\xe8\xf6\xdd\xe9\xf7\xe6\xe7\xf1\xe0\xe9\xf1\xe7\xe9\xe6\xe8\xea\xe7\xe2\xeb\xf3\xe9\xeb\xe8\xe3\xec\xf4\xeb\xed\xea\xe5\xee\xf6\xec\xed\xf7\xe7\xef\xf8\xed\xef\xeb\xe8\xf0\xf9\xee\xf0\xed\xf0\xf0\xfb\xf0\xf2\xef\xee\xf3\xf6\xf1\xf3\xf0\xf4\xf2\xf6\xf2\xf4\xf1\xef\xf5\xf7\xf0\xf6\xf8\xf4\xf6\xf3\xf2\xf7\xf9\xf3\xf8\xfb\xf6\xf8\xf4\xf7\xf9\xf6\xf5\xfa\xfd\xf8\xfa\xf7\xf6\xfb\xfe\xf9\xfb\xf8\xfa\xfc\xf9\xfd\xfb\xff\xf7\xfd\xff\xfb\xfd\xfa\xf8\xfe\xff\xf9\xff\xff\xfc\xff\xfb\xfe\xff\xfc\x9fIc\x17\x00\x00 \x00IDATx^\xed\xbd\vlT\xe7\x9d\xff\x9dn\xbb\u007f\x92\xf4\xbe\xffM[\x1e\a\x9d\xe0\x91c\xaf\x16\xd9kհuJ\x9b8\xf0&\u0080\x18\xe3\x80l(\xb7֊X\x87\xb0\x15\x97\x10\x93FXd^BH߄\x05\x8aCK\x92%\x1b\xe3\xd5\xca.V\xc1ZHF@P$\xccE\xa4)I\x1b\xc0\t!\\\x82\x13\b66c\xec\x91~z\xcfs\xce\\\xce̜\xb9ٞ\xe7\xfc\xec\xf9~\x82f\x9e9\xf3\x9ccW\xfd\xcc\xf1\xf7\x9c\x999\xdf;\b\x80,\xe2\x8ed\x13\x00\x18M@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U@x\x90U$\x12\xbe\x03\x80\xd1\x06\x84\aY\x05\x84\aY\x05\x84\aY\x05\x84\aY\x05\x84\aY\x05\x84\aY\x05\x84\aY\x05\x84\aYEj\xc2\xe7\n!\xfe\xdfx\x9b\xf8\xf3\x9f\xe2=\x93\x16%\xfa\xcf\xf8\xafd\x93\"\b\xae\x91\xfe\x9aI\x90\x1b\xfc\xefd\x93\xc0\x88d\xc8\u009f\xd98\xe1i\xfbg\xd2$}m!<H\x9b\xa1\n\xff\xa72! <\x181\fU\xf89\x02\u0083\x11\x04\x84\xb7\x01\u008f^ \xbc\rq\x84?\xfa\xefQ\xe0E1\xf2HO\xf8B!r;\xfeZ\xffP^\xee\x03\xab\xfe\xac?\xae\x15\x01^\x95\xb3\x8e\xfe\xfb\x03\xae\xf1\xc5U\x01\xf7\xfe\xaa/\xfeYG}\xb1V0\xe7L̊:g\xfe\xc3]8>\xc75\xf1\x17\u007f4\x1f\xc7j\xfb\xd7\x17\xdd\x05Zn\xc9/\xfe\xa7#\xf1\x1a\xb1k\x1e\xae-\x19\x9f_\xfej\xc73\xfa3\x9e\xa8_%f3\x9a\x10\x85\x1dG\x97M\xd4\xd7\xf8}x\xc3\xff\xfd7\xcfC\xae\xdc\xc9O\xbfo\xd9\xec\x83\"\x02\xedp\a\x18i\xa4/\xfc\xe1\u007f5\xff\xef.>\x1c%\xfc+\xae\xc0\x03\xb7\xa1\xb4a\xd9*\xf9\xb8<vŎ\x8e??\x1c\x12g\x85\xf13b\xb4}\xeb_\x83\x13~\xf5\xb7\x84kĬ\xf9jn`\xbd:\x11\x16>\xf8\xab\xc4lF\n\xff?\xf9撪\xbf\x067\xbc\xad\xcc\\2\xe9\x84e\xbb\"\x82E\x1d`đ\xb6\xf0Zq\xf0\xffow\xa4\xf0\xaf\x8e\r\x99\xf0\xa8\xbe\x1f5,\xcb3\x96=\x1f\xbbbGG\x95\b\xf3\x9frA\xb4\xb6\x87\xf3\xc3\x13j\x13\xae\x11\xbd\xe6\x1f\xb5\xe0\xb4\t\"$|\xe8W\x89ٌ>;//\xb8dAp\xc3\xc1W\xaf\x98g\xd9\xf2\xcf,\xebb\a?\"I[x}w\xe8\xf9\xe3\x169\x18\xf7玷^\x9d\xaa\x0f~\xf1\xea\xab':\xfe,\xfd|h\xdb\x1f\u007f#\xdd\xd1%3,\xd3'=T\x92s\"vŎ\xff\x95\xf7\xab\xff\xf8\xa7\x8dr\xb5_ɟ\x11\xad\xedt\xfd\xf1\xf8e\xafnyT\xbf\xcfy+\xd1\x1a\xd1k> \xd7\\\xf5\xc7\xff2\xd5\xf6D\xfe*\xb1\x9b1^\x1e\xf9O\xbf\xea1^\x91\xc1\r\x8a\xe2\x8d\u007f\xfa\xddD\xb9%K\xa8\x89\xd8\xc5\xff\xa2\x03\x8c<\xd2\x17>O\xee\xd8\xfe(\xff\x1f\x97ﰆ\x0eZ\xeb\xf5\xc1\x032\x10\xfcQߕN\xec\bX\x96\xab\xcf\xd9k\xb7\xe2\x9f~55\xcfH\x14\x1ea\x04\x8d\x18m\xdf\n\xda\xf7\xb7\x87\xf4\xc1\xb2DkD\xad\xf9?rM#\x8d\xd7ȑ'\xf2W\x89\u074c\x16\xfc\xddNH\xe3݁\r\xe6\x1d\r\xfe\x12\xd67\x92-\xbbx\xec\xe0G$\xe9\v\xff\xefƒ\xbc\x80d!\xe1˅\x11\x18t\xa4\xa0o\x05,\xfbU`\x03\xb1+\xea\xc8\xe0\xd3\xf1\xbc\xfe\xb8L\x0e\xa2\xb4\x95Ǜ\x0f\x19\xa3\xffz\xea\xf7A\xb7\xec\u05c8Zs\xb5\xfep\xb21\xfa\xf3x\x11\x16>\xf8\xab\xc4lF\n\xff\x94\xb1|\xa3>r\x9d17h\xa4\xa8\x8e\t\x91\x9b\xee\xf8\xbd\b\x81\x04?\"I_\xf8\xff0\x96H'\xe4\x91jHx)re\xadD\xe6\x80\xdf\x05,\xfb]`\x03\xb1+\xea\xbc\xff\xdf\xf5s\xfeI\xcez(\xf8\x84ŭ\xaa\x90t\x16\xec\u05c8Z\xb32\xbc\xa6<>\xf5D\xfd*1\x9b\x91\u009b'l\x0e\xcbe\x87\xcd\r\x9a\xbf\xed\xc4\xf0ok2Y\x04\x18\x87\x1d\xfc\x88$}\xe1M\xb5\xfeUD\n\xff7\x11A}\xc0\xb2\xc0\x99?\x9b\x15;~W\x1e:\xb6|X>\x8e\xd2V\xfe\xc5X\xd5\x11A\xbc5l\xd6\f\xbc5\xe0\x16aჿJ\xccf\xe4#\xd3^\xe3\u007fğ\xac/\xca\aD\x94\xf0\xbf\x0f\xae\xfa\x8b\x0e0\x12I_x\xf3ݖ\xa0\tA\xe1\xff*\"x:\xb0\xe4\xad\xc0\x06bV<Si\xcc+\xf9\x85<\xd1\x13O\xf8\u007f\xef\xb0\x10\u007f\x8d\xa85\xe5Q\xeejsh\x15\xfe\xadx\x9b\xd1BO\x1a\xf3\xf6\x9a\x1b\x8c\xfc\x9f\x19&\xb0\x8b\x1f\xf7V\a\x18\x89\f\x97\xf0Ɣ\x88w\x1e\r{\x82\u007f\xf7cV\x94Ǹ\xf9\x1bOtt\xfc\xa7>\xf8\u007f\xe4\x13Q\xda\xce\x13\xc1\xbd\xe8\xfbo\x19\xa7\xe1\xe3\xafa\x13i\x02\x81]\x1ecz\"\u007f\x95\xd8\xcdH\xe1\x8d\xf3\x93\x11\x91&\x9e\xf0\xbf\x17\x06\v:\xc0\x88d8\x847\x8e\xf8\xe4\xa1j\xbd\xf1\xd4\u007f\x9bj%\x16^\xaah\xc4\xe4\xff\xd0\a\x8fʁ\xcdAk\xa1qt\xf9[1\xfe\x81\xdaDkD\xad\xb9J\u007fXl\xacyX\x9e{\x8f\x12>v3Rx\xf3\x05\xf2\xa2>\xca\xefH,\xbc\xb9\x8b\xc7\x0e~\xa42T\xe1\xe7\x89@\xf2\x90\xe7F\xfeI\xbe\xc5\xfaG!\\\x0f\x1f\rXv4\xb0\x81\x98\x15\xf3\x83&UF\xeb\x1b\xe0-\xb9\xfao\xf4\xc1_'\x9bB\xc6_#jM\xe3\xcc\xe73\xfa\xe0}\x19\x8bB\xc2\a~\x95\xd8\xcdH\xe15\x99\xf0\xff,7TՑD\xf8W\xe4\xc6~\xd1\x01F&C\x15\xfeW\xfa}ު_\xfdw\xc7Q9g\xf2\u007f\x1e\xfe}a@\xa4\xc4\xc2˻\u007f}\xab\xe3\xf0/\xe4,\xbb\xb34\xc6\x1bO\xc2\xedyZ\xce\x14\xff\x9bh\x8d\xe85\x8d\x8f\xbc\xcc\xd9Xo~4!J\xf8\xd8\xcd\x18\x87\xb0\xe3\x97m\xab\x97\xdb1\x8em\x13\n\u007f\xe6\x01\xf3\x8d00\"\x19\xaa\xf0\x1e\x11\xb4j\xa3\b\xe1\x92>$\x16\xfe\x19c\xe2xs~\xb1|\"Z[\xebG\v\x96u$Z#z\xcd?\x05&\x89q\x05\"F\xf8\xd8\xcdH\xe1s\x83?\xe9W\xc1\r\xc7\x15^\xa6\xf8_t\x80\x11\xcaP\x85?a~\nE\x1a\xe9\tZS`\x9c\x01L,\xfc_\xa7\x9bssV\xffk`Z\xb4\xb6\x1doM\nlO\xd4\x1a\x9f͉\xbbF̚\xaf\x98\xbf\x89\xf6[\xb9\xca\xf3\x91\xbfJ\xecf\xa4\U0002f598K\x17\x19\xc7lj\x85?\xf3\x00v\xf0#\x97\xa1\n\xdf\xf1VU\xbe\xf6O\xe5\xc6\xf0\xf0\x8a\x9f\xe5\x8f\xcb{\xe8i\xf3\U000ff245\xef8\xe3yȥ\x15\xff\xea-\xe3\x03hu\x1d6\xdav\xfcu\xe3\xf4\u007f\xd2r'\xfe*\xf0\xde~\xdc5b\xd7|\xebW\xc5\xda?\xcd\xfb_#\x16\xfd\u007fQ\xbfJ\xccf\x8cӒ\u007f\xfe\xf7\x12-\u007fz\xc0\xed\xc4\xc2w\xfc\xce\xfay20\xb2HM\xf8\x11\xc5\xdf\xfe\x16\x1a\xcawZ\xff3\xc1T\x83\xf0y\xf8\x149s\xb4\x03\x8cTF\xa1\xf0\u007f\xcc)x\xa8r\x9b\x1c\xfdY此\x1f\x01H[x0\x82\x19\x85\u009f\xc8\x11\xf2\xbd\xa5?\xfd\xe9?\xe4{\x03\x0f$\x9b\x0e\u1ccaQ(\xbc\xf1\xde@\x88\xdf'\x9b\r\u1cca\xd1(\xfc\x9f\xcbC\xba\x8f\xfbM\xb2\xc9\x10>\xbb\x18\x8d\xc2wt\xbc\xfa\x8b\a\xf24-\xff\xa1e\xa9\x88\f\u1cc9\xd1)<\x00q\x80\xf0 \xab\x80\xf0 \xab\x80\xf0 \xab\x80\xf0 \xabH$<\x00\xa3\x0e\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n\b\x0f\xb2\n5\xc2_\xbe\xfcygw\xe4\xa2\xee\xce\xcb_}9`?\x1d\x80L\xa1F\xf80\a\xb7w\x124\a\x8e\xa1T\xf8>\xa2Ms?\x96w\x008\x83R\xe1I&\x19\xec߁\x83(\x14\xbe\xaf\xcf\xd7\xd7w|ϗ\xfa\xdd\x00\xac\aΠPx\x83\x97\x1e\xbb\x98l\n\x00\x99C\xb5\xf0\x03\x9d\xc9f\x00\x90A\x14\t\xafG\x98\xd3{\xfe\xb0}\xeb\xe67\x9b\xb7oݺ\xbdy\xdf\xcddk\x00\x90\t\x14\t\xdfG\xb4}\xfe\xac\x99\xd3fL\x93̜_q\x11\xe7j\x80\x13\xa8\x13~ô\x83\xa7\xdf;\xfd\x9e\xce\xe9\xd3k\xa6\x9d\x83\xf0\xc0\t\x14\n?\xbb7\xf4pk\xc59\xf2\x11\x9c\a\xcaQ(\xfc̳\xa1G\x1bf\x9eK4\x1b\x80L\xa1P\xf8\x19!\xe1i}X~\x00T\xa2N\xf8\xf5s\xbb\xf7\xfc\xf8\xc7?\xd1\xff\xab\xe8{}\xe6\xe7G\xb6\xfb\x8eoU\U0007969f\x8e\x193\xe6\xee\xe3\xc9f\x81,A\x9d\xf0\xeb\xaai\xcd\u05fe\xf6w\xfa\u007f\xdf\xf25\xcf\xe8~cn\xf7\xeeY6\x87\xae\x9d\t\xc2\xce\xee\xb7\xe3?\x17\x97\x0f\x9b\x9bW\x8e\xd9c\f\xcf\xe1M\x80\xacG\x9d\xf0\x1bf_\xbeؼgߞ}\xcd\ai\U000cc2dd\xa7\a:?\xf4E\xcf\x1bX\xfb\xcd\xfb\xec\xd67\xf9\xc1\x8f\xe3?\x97\x88}\x01\xe1\xef\xfb\xe6\xda\xcc\xffE\x01\xacQ'\xfc\v3N\a\x1f\r\xc4\xcb\xf0\a\u007f0\xe6\xfe\x0fm\x9f1\xb8\xe7_\xe2?\x97\x88\xa0\xf0g\xef\x1f\U000c30c9\xa7\x82Q\x8e:\xe17̺h&v\xfdfӌs\xd4\x1bsZ\xb2sƝ\xdf\xddn\x0e\xd7\xfd\xf0\xee\u007f\x98\xd1Mt\xe4\xce1c\xee\xa7\xef\x8d\x19\xf3\xcdޭcL\ue258pP\x9f0\xf7\xf8O\xbew\xf7}\xbeG\xc6ܹv\xda?\xdc}\x9f|\xc5t\xfe\xcbw\xee\xfa\xee\xfd\a\x03\x1b\x0e\nO\xb4\xfd\xbbwNC\xae\xc9f\x14\n?;\xfc\x9d\xa7\xcd\x156\xe9}\xf3w\xee\x9c\xfd\x959\xfc\xf9\x9d\x8fl_\xf9\xed{\xfa\xa8o\xcf\xc2;\xf7к;\xd7\x1d\xa4\xaf\x9a\x9b\xff\xe1G\xcd\xcd\xcd\xc7#&\xdcܰ\xfe{\xff\xf0\xcd\xefM\xfbɝ\xa7\x8f\xac\xbfs̷\x17>\xf9\xcd\u007f֟\xdf>\xe6\xe7\xbb7\xdc\u007f\xe7>ssa\xe1\xe9\xab\xd9w~{S\xf4O\x06كB\xe1\xab\xd7m~a\x93\xce\v\x9b6\xff\xf2\x91د\x81<2枃\x81\xe1\xf61ϒ\xd4\xf49\xf9\xe0\xa7?\xbc\xf8\xbd\xc7\xcd\xe5\xa1H\x131\xe1\x9e1\xf7\xe9;m\xb9\u07fe\xeb\x9b\xfa\xde\xfd'\xdf\xd6G\xdd\x1b\xbe\x94\xcf\xfc\xb39\xdd\"\xbc\xfe7\xe1\x9e1\xd3\bd+\xea\x84o~\xfc\xb1\x8a\x19&\x15\x8f?\xf9y\x8c\xf0\xcf\xde\xf5\xadu\x81\u13ff\xef\x93|\xf7\xa7\xf2\xc1\xcd{\xbe}\u007f`yH\xf8\x88\t\xf7\xdc\x15<8\xb8K>\x9e\u007f\x97\x1c^\\s\xdf\xf7\xbf\x19\x88?\x91¯\xfb\xd6\xddk\td+\x8a\x84\xd7\xe9\xbex6\xc4\xc5\xcb6gK\x8e\xdf7\xe6\x87\a\x8d\xd1=\x81\xb8n\xee\xa07\x8di\x0e\xcc\b\t\x1f1\xe1\x9e\x1f\x04\xb7p\xd7|\xfdf\xa1\x14~߷\xbf;\xeb\xa5\xe6{c\x85?\xf2\xc31\xf7\x87\x0e\x9eA\xf6\xa1N\xf8\x14x\xe9;wΒQ\xe4'\xdf\u007f\xdb\xc0\xf8\xae\xc8\xd9\xef\xcc\xfd\xdee\xf3yC\xf8gOGM\b\x9f\xbb\xb9k!\x05\x84\xff\xbf?\x94\a\f\xff\x12-\xbc\x9e\xe0\x83\x87\xc5 ;Q(\xfc\xc0@_\x90\x818\x1f\x1b\xeb\x9cq\xe7w^'z}\xcc\x06\xf9h\xae\x8c\xee\xbe\x1fV\xd3\xcf\xef3\xe7\xdf{/\xd1\xc7\xf29\xeb\x04[\xe1\xbf+\x97\xf5\xdd\x13%\xfc\x9b\u07fds\xd6W\x04\xb2\x19\x85§\xc4\xc1\x1fIUg\xdf\xf9\xe3\x176\xfft\xccz\xba\xd9\xfcȷ?\xa4\xf7\xbe9\xadY~\xd4r\xfe]On\xbe\xef\xee\xb3\xd6\t\xbe=ƹ\x9b\xf7\xf4eg\x9b\xef\xfc\xe9\x1ez\xfb\xa7w6\x9f\xa5\x85c\xfee\xcd\xe3\xf7\x8c\xf9ֿ\xed\xd1\x177\xaf\x1c\xf3\xeb\xe6f\xfd\x0fÿ\xfc\xe8`\xc2\x1f\x0eF?܄\x0f\xf0\xfa\xbd\xdf\xfa\xe6\x8f\xfe w\xe5c\xc6L\xa3Gƌ\xb9s\xb7\xbe\xb4\xf7\x91o\xdd\xfd\xa3}\x11\x13\xe4y\xf81\xf2\\\xbd<ͣO;r\xb7~\xfb\b\xf5\xfd\xfa\x1f\xee\xfa\xf6\x8f\x9f\xfd\xfe]\xf7\x1a\x9f\xa5\x91\f\xf2]Z0\xba`*<\x00\x99\x01\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x02\u0083\xac\x82\x8b\xf0\xbe\xa8VK\x002\x02\v\xe1\a\x88\x8e\xbc\xf1\xa5\x82\xcb\ue06c\x87\x85\xf0}D\x9b\xabQg\t\x14\xc0BxB\xa4\x01\x8apV\xf8=\xbe\xce^\x9fQgy\xf0\xcdNy\xd7G}\xbd\xbd\xbeps\x02\x00Ë\xb3\xc2\x1f!\xe3r\xaa\xb2\xa1{6Jp\x80\x02\x9c\x15>|\xf5\xe0\xces1W\x12\x06`\xf8qVxyb\xe6\xf8\xeeM\x1b\x9e[\xff\xec\xda\xf5ϭ\xdf\xf0zs7\xceՀL\xe2\xb0\xf0z\x8aٺp\xf6c\xb3fUϟ=k\xd6c\xd53Pg\t2\x8a\xf3\xc2o\x98v\xe4\xfc\xd9\xf37\xe9\xf2\xd9\xf3\xe7\x9fE\x9d%\xc8,\f\x84\xaf\x90\xad\xdc\xfbVʇ[+\xce\r\xc4^7\x1e\x80a\xc3y\xe1_\x98)\x1b\f~t\xc7A\xfd\xd1s\xa8\xb3\x04\x99\xc5y\xe1\xcd\xfe\xd6\xfb\uf437\xa8\xb3\x04\x19\xc6y\xe1\xd7\xcf\xed\xde}\u07fdw\u007f\xed\a\xf7\xfd\xbc\xef\x8d\x19\x9d\a7\xf8\x8eo\x8e\x9a\xb5e\xfco\xe5\xddr\x91\xd3d\xb3\r\x00R\xc7y\xe1\xd7U\x0f\xac\xfd\xc6\xd7\xff\xee\x8eo|\xe3;\xb2\xcerwu\xf7\x9e_F\xcd*\xd3\xca\xe4\xdd\x05\xaf\xe6\xb1\xd9\x06\x00\xa9\xe3\xbc\xf0\x1b*.v\x1e?~\xef\u05f7\x1f\u007f\x8f^\x9ay\xbe\xfb<u_\x8e\x9cԕS\x93\xd3e\x8c <\x18\"\xce\vo\xd6Y\xde+3\xfc\xc0\xfaYv\x19\xde+\x8e\x89\x03\xc6\b\u0083!\xe2\xbc\xf0\x1bf\xc9\x1d\xfa\xac\xefI\xed7ʹ;-\xe9)\xa6b\xd3tm\xc5\x13\xc5\xf9Ug\xe4\xd0[Y\xa2\x15\xcd)\xf1\x13\x00i\xc0@\xf8\x8a/C\x0fm\xeb,ɽ\x88\x16\xbb\x8d\x91&\xa645\x96\xb9N\x11\x1d\x1d\xbb\xb4e\xff\xce\"q;f6\x00\t` \xfc\xfc5\xeb\x9f]\xb7\xf5\xf5\xe7\x9e]\xb7~\xbeM\x9d%\xf9][\xe8e\x97\xb1+\xd7&\xf7\x10\xf5\x94\x96\x135\x14H\xd5\x1b\xf2\xb1\x87\ai\xe1\xbc\xf0{\x9e\xac\x9e;{vEE\xc5\xec\xd9s\x9f\\\xd9\x19+\xfcIq\xa8\xe7\x908)\x87\xda3\xf2v\x87\xb8F\x9f\x15O\\\xb1\xf3\x84\xbf?z2\x00\tqXx\x9d\xde\xce\xcb:_\xf5~\xae\xdfv\xdaU\x8em\x13\x92mrh\x1e\xb4\xea\a\xb1D\xd7w,\x9e,\x8a6b\x0f\x0f\xd2\xc2y\xe1\xc9\xf8\x90\xf0\xe6\xc7;\xe3}0xє\xf6\xf6\xf6)\x8b\xe4P[%ow\x8a\x1b\xd4^\xa7\xab~\xbd1\xb7\xc1~\x1d\x00\xecq^\xf8\x01\x9f\xaf\xdb\xe7{|\xda\x11_w\x9f\xcf\xeeccū\xf5\x9bU\xc5r\xa8\x15\xdf\"\xea\u007fP?\x82\xf5\x886\xb9\xc0\xbd\xccf\x05\x00\xe2\xe2\xbc\xf0&ݝq\xf6\xef=m\xa2\xbe\x8b\xba~#\xdanɳ4\x95\x87\xf7\x97\xe7\u007f$\x85wշ\xb6\xd4\x06\xce\xcf\x03\x90\",\x84\xf7\x11m\u007f\xf2,\xd9~\xc9o\xffX!\x9a\xa8E\x88\xb1\xfb\x89\x1e\xf4,\xce+\xae\xb9\xa4/\xde5\xddS\xa2\x15\xba\xe1;H\x0f\x16\xc2\xf7\x12鑆p\xb1\x02\x90qX\bO\t\"\r\x00\xc3\t\v\xe1q\xa9=\xa0\n\x16\xc2\xe3R{@\x15,\x84'\\j\x0f(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\b\x0f\xb2\n\x16\xc2#\xc3\x03U\xb0\x10\x1e\x19\x1e\xa8\x82\x85\xf0\x84H\x03\x14\xe1\xac\xf0(5\x03\x8aqVx\x94\x9a\x01\xc58+<J̀b\x9c\x15\x1e\xa5f@1\x0e\v\x8fR3\xa0\x16\xe7\x85G\xa9\x19P\b\x03\xe1Qj\x06\xd4\xe1\xbc\xf0(5\x03\nq^x\x94\x9a\x01\x858/|\x92R\xb3F\xe3R\xaa\x13\xe6}\x12o\x13\x00\xa4\x81\xf3\xc2')5\xebj\x15\xbf\xf1zw\x95M\xf8\"\xeeF\x00H\x19\xe7\x85OVjvI4\xea\xb7WsQ\xef\x04\x86\x01\xe7\x85OVjf\nOeKb\x9e\x01 m\x9c\x17>Y\xa9\x99)\xfc\x95\xf1\xcf\x13\xddX\\\xac\x95T\x19] \xd6R3\xff\xaer\xd7\x03\xab{b6\x0e@\f\f\x84ORjvI\xec\xec\xb9\xf1N\xd9\xcfn\x10\xb5\x8ae\a\x9a\xaar\xda)\xb2Ԭ6g\xc5\xdem\x05SQ\x06\x02\x92\xc3@\xf8$\xa5f\x97\x8c\xd34\xa5\x17\xf4aOS\x97\xbe?/\x9bG\x11\xa5f\xadb\x97>l7\x93\x0f\x00\tq^\xf8d\xa5f\x97D}{{\xdb\x13\x13\x8e\xea\xe3\xab\r\x95\x93\xf2\x84졷\x94\x9a-\x99\xd4\u007f[\xa7\xb86v\xf3\x00D\xe1\xb0\xf0\x94\xbc\xd4,pк\xa4\xd4O\xed\x85%O\xb7x\xddRxK\xa9Y\x990\x99\x17\xbb.\x00Q8/<%)5\v\b\xff\x9a\xb8J\x93\xcb\xe5\x91\xe9\")\xbc\xa5Ԭf\xd21\x83\xab\xb6\xab\x03`\xc5yᓕ\x9a\x05\x84_\x9a\xe7\xa7\x12Y\xe5\xe7\u007fX\no)5k\x13MrX\xbf1v]\x00\xa2p^x\x93\xb8\r \xe6;\xad-5\xe2Ei\xf9\xe2\x86秊\xa2\x17ߍ(5\xab\x1b[Ӣ\x0fw\xd9o\x00\x00\v,\x84OTjf~\x96F+۩G\x18\xff\x96R\xad`\xc9k\xa5\x9a;\xb2Ԭ\xcd=!\u007fz\x9b\xdd\xda\x00D\xc2Bx\x94\x9a\x01U\xb0\x10\x9ePj\x06\x14\xc1Bx\\j\x0f\xa8\x82\x85\xf0\xb8\xd4\x1eP\x05\v\xe1\t\x97\xda\x03\x8a`!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x02\u0083\xac\x82\x85\xf0\xc8\xf0@\x15,\x84G\x86\a\xaa`!<!\xd2\x00E8+<J̀b\x9c\x15\x1e\xa5f@1\xce\n\x8fR3\xa0\x18g\x85G\xa9\x19P\x8c\xc3£\xd4\f\xa8\xc5y\xe1Qj\x06\x14\xc2@x\x94\x9a\x01u8/<J̀B\x9c\x17\x1e\xa5f@!\xce\v\x9f\xa4\xd4L\xe7T\xa5\xab\xb0\xe6@\xe1\x15\xaa\x15B\xb8\xce\xd8o\t\x80Tp^\xf8$\xa5fDm\xaeGw6\x96\t\xf1\x01]\xf0z\x1b\xc4;q6\x05@\n8/|\xb2R\xb3ky\xf3n\x11u\x95\xea\u0093\xec=\x80\xf0`\b8/|\xb2R\xb3\xba\xdcK\xf2n\x8b0\xb2\f\x84\aC\xc2yᓕ\x9a\x95>a\xdc]\xddrKޅ\x84\x0f7\x99\x85\xabΖ\vm\xe7\xaa\a\\\x95\x17\b\x00{\x18\b\x9f\xb8\xd4\xecV\xce\x16\xebÐ\xf0\xe1&\xb3p\xd5\xd9_\x1alj\x02\xcfo\xf3\x16\x10\x00\xf60\x10>q\xa9\xd9'\xa2\xc5\xfa0(\xbc\xa5\xc9\xccRuFZ\xbe\xbew\xaf) \x00\xecq^\xf8$\xa5f\xfd\xe3l\xf7\xf0\xd6&\xb3p\xd5\x19iK\xf5\x1b\x8fF\x00\xd8\xe3\xb0\xf0\x94\xbc\xd4,\x90\xe1\xfb\xcd\u0083\xa0\xf0\x96&3kՙ&\v\xea!<\x88\x8b\xf3\xc2S\x92R\xb3\xba\\\xa3\xad\xacI\\\x91wA\xe1-Mf\x96\xaa3\b\x0f\x92\xe0\xbc\xf0\xc9Jͮ\xe5-\xe8\xd73\xba{\xa2\xf1((\xbc\xa5\xc9\xccRu\x06\xe1A\x12\x9c\x17\xde$A\x03H\x9b\xab|WK\xe5\xb8CD\x9f\xc9wZ\xb7x\xbd\x9f\x92\xb5\xc9,\\uvɫվ\xeb?Q\xaby/\xc5\xdb\x18\xc8rX\b\x9f\xa8Ԍ\x8c\xcf\xd2\x14\xcd{_\x1f,\r\x04\xf7%ri\xa8\xc9,\\u\xb6\\֟\xbd\xef\xd2o\x97\xc7\xd9\x14\xc8vX\b\x8fR3\xa0\n\x16\xc2\x13J̀\"X\b\x8fK\xed\x01U\xb0\x10\x1e\x97\xda\x03\xaa`!<\xe1R{@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E@x\x90U\xb0\x10\x1e\x19\x1e\xa8\x82\x85\xf0\xc8\xf0@\x15,\x84'D\x1a\xa0\bg\x85G\xa9\x19P\x8c\xb3£\xd4\f(\xc6Y\xe1Qj\x06\x14\xe3\xac\xf0(5\x03\x8aqXx\x94\x9a\x01\xb58/<J̀B\x18\b\x8fR3\xa0\x0e\xe7\x85G\xa9\x19P\x88\xf3£\xd4\f(\xc4yᓔ\x9am\x91W^\x1a[\xba\xd3o>\xdc_\xd0j\xbb!\x00R\xc2yᓔ\x9a]\xdb(^\xf3\xee]\"\xea͇\xad\xae\x88\xcb\xc5\x03\x90\x1e\xce\v\x9f\xacԬM\x9c\"\xf2/7;\xcd\xf4\x91\xddf\x00H\x11\xe7\x85OVjf\bO=y\xb8\\$\x18\x06\x9c\x17>Y\xa9\x99)<-/\"\xba\x9e+DN\xa3|tr\x9c\x10\xf5gj&\xe6Vގ\xdd(\x00qa |\xe2R\xb3\xa0\xf0;D\x17Q\xbb\xd7;^^\x01\x9ez\x9a\x1aKJ\xf3JVՌ\xfd\x94\x00H\x1d\x06\xc2'.5\v\n\xdf\x16\b\xf1\xb9\x9e\xc0\xf2\xa9\xc2}\x83\xfc7\b\x804p^\xf8$\xa5fA\xe1_\x13\u05cc\x87a\xe15\xec\xdcA\xda8,<%/5\v\b\xffT\x9e\xf90,\xfc\x94ع\x00$\xc1y\xe1)I\xa9\x99)|\u007f\xc1\x12\xf3aX\xf8E\xb6\xd3\x01H\x84\xf3\xc2'+53\x85\xaf\x13\xc7̇a\xe1\x17\xc7\xce\x05 \t\xce\vo\x12\xb7\x01\xc4x\xa7\xb5m\xa9\x90\x9e\xf7\xbf\xe3\xf5\x8e\xaf\xf5zo\xd0\xed\xc3\xde\xd2\xe9^\xef'\xf6\xeb\x00\x10\x0f\x16\xc2'*53>K#&\xee\x90\xe3\xa39f\xa9\xd9\x0e:i\x8e\xaa\xec\xd6\x00 >,\x84G\xa9\x19P\x05\v\xe1\t\xa5f@\x11,\x84ǥ\xf6\x80*X\b\x8fK\xed\x01U\xb0\x10\x9ep\xa9=\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\" <\xc8*X\b\x8f\f\x0fT\xc1Bxdx\xa0\n\x16\xc2\x13\"\rP\x84\xb3£\xd4\f(\xc6Y\xe1Qj\x06\x14\xe3\xac\xf0(5\x03\x8aqVx\x94\x9a\x01\xc58,<J̀Z\x9c\x17\x1e\xa5f@!\f\x84G\xa9\x19P\x87\xf3£\xd4\f(\xc4y\xe1Qj\x06\x14\xe2\xbc\xf0IJ\xcd\xdaƚ\x17_\x12\x05\xfdq\xb6Q\xab?\xe9:c\x8eOΙ\x907\xfd@١8S#\xe6\xda5\xa4\xbd\x12(\\\x00\xa3\x15\xe7\x85ORj\xd6sH\xab\xf5\xeaԉ+q\xb6q\xc1\xebm\x10\xef\x18\xc3cZUˮ\x05B4řj\x9dKv\ri\u05fd\xe5\x1e\x02\xa3\x18\xe7\x85OVjF\x9a\xa1\xe0.q\xd5v\v\x06\xed\x01\x89+\xdd~\"\u007fm|\xe1-s%6\riU\x10~T\xe3\xbc\xf0\xc9J\xcd\x02\u009fY\x95\xa0\xbf/(\xf1\xc4zy{R$\xaa\xb6\xb4\no\x03\x84\x1f\xdd8/|\xb2R\xb3\x80\xf0:Mz\x00\xf7\x90G\xc8\xc8rcq\xb1VRu2\xf0LP\xe2%\x85\xf2\xd2\xda\xfe\xbd]Ԫ\xcfzƘ\xdbX\xa4\xfd\xa6\xb8\xf8\xc0\x8a|wW\xc4\xdcpC\xdar\xa1\xed\\\xf5\x80\xab\xf2\x82|\xa0\v\xbfB_k\xbc\xfe\xf7\xc4[Y\xa2\x15\xcd)AQ\xe6h\x82\x81\xf0IJ\xcdH\xab\xef\xe9Y\xb2Z\x1fty\xf3\xea\xafЕ\xfa|\xaf\x14zف\xa6\xaa\x9cvsJP\xe2OJr*=\x87\xe5\xd1mϡ\x92ern\x9e\xb7\xeb@\x9eX\xe5\x16\x136\x16\xbd\x1c17ܐ\xf6\x97\xc6q\xa2\xc0\xf3ۼ\x05\xf2\x81.\xfc\x85\x9a\x9c-\xfa\x86\x8f\x8e]ڲ\u007fg\x91@O\xe0h\x82\x81\xf0IJ\xcdH\v_\x18\xbbVր\xd4<A\xb2\xc6O\xdf_\xfb\xcb\xe6\x99SB\x12_{\xfeQM\xe4\x1b\x11\xde#+q\x96\xd6\xea7\x855\xb4W\xb4\xd2\xd2e\x91s)ܮ\xa0\xe5\xeb{\xf7\x9a\x029ԅ\u007fY3N\xde4\x14H\xd5\x1b\xf2\xb1\x87\x1fM8/|\xb2R3Җ\xb5\xb7\x97\x99\xc2\x1f\xc8\xed\xa1\x1e\x97W\x0e\xaf6TN\xca\x13e\xe6\x14\xabķ\xf6W\x8a\xbd\xfa\xfd\x85\xb1\xefӭ\xbc\xfd\xfa\xa8\xb0\x91\xde\x15]\xf4tM\xccܐ\xf0K\xf5\x1b\x8f&\x87U\x9eza\x9e\xac\xfc\xacx⊝'\xfc\xf1Ά\x82\x11\x89\xc3\xc2S\xf2R3#÷\xed7\x86\xb7'\xb4PK\x91\xdc\xe5\xb6\x17\x96<\xdd\xe2uG\t\xdfn\xc4p\u007f\xb9\xf1\xf2\xa8\\Mm\xf9R\xd7\xc26j\xd7e\xaeK \xbc\xbc\x0f\b_\x987y\x81\xb9S\xbf\xbec\xf1dQ\xb4\x11{\xf8ф\xf3\xc2S\x92R\xb3\xe0A\xebIyZr\xc5<Z\xb0B>\x9a\\ޣ\xdf.\x8a\x12\xbe\xd0x\x8e\xeaK\xe5m\xeb\x84~#Ѥ)|\xc1\xa9O\xf2\xb6\x18\x13\xebtկ7\xe66\x10\x18=8/|\xb2R\xb3\xa0\xf0\x85u\xfa\xcd\xe1\xf1\x97\xc6\x1f\x96\x8fJd\x87\x9f\xff\xe1(ዊe\x99\xab\xdf,\xf8\xeb/j\xcd7\xfe0\xa4'\xbc\xfc{\xa2Ƀa\x8fh\x93\v\xdc\xcb\b\x8c\x1e\x9c\x17\xde$n\x03H\xf0\x9dVo\x9e<Q\xe3/\xae,6\"\x86G,nx~\xaa(z\xf1]\xfaL\xbe{\xba\xc5\xeb\xfdT\x17^\x14z\xdaZܹ\x1f\x19\xab\xd6Mʗ\x87\x9d\xa7\xf2_\xeei\xd4N\xf6Ը/X\xe7\x86\x1b\xd2.y\xb5\xdaw\xfd'j5\xef\xa5\xeb\xde\xf2\xdaw\xfa\xbb\xaa\n\x0f\\\xd1\u007f\x84\xab\xbe\xb5\xa5V\x1c\xb0\xff\xc5\xc0\x88\x84\x85\xf0\x89J\xcd\xdaD\x10#glь;\xf2o)\xd5\n\x96\xbcV\xaa\xb9ii\xe0\xf9%D\x8f\xee\xac\xff\x99\xab`\x9e\xe9;}$\xe4\xce\xd9_$Dc\x9ep5\t1\xcf:7ܐ\xb6\\\xbf\xd5\xdew\xe9\xb7\xcb_\xd1or\x8e6\xea\xb7\xf5\xb4k\xba\xa7D+t\xc3\xf7Q\x05\v\xe13Tj֥AV\x10\x05\v\xe1)3\xa5fM\x13\xf0\x9e\x11\x88\x82\x85\xf0\x99\xb8Ԟ\xe7\x80\xdf]\x9fl\x12\xc8:X\b\x9f\x81K\xed\xf5\x88)\xcb\v\xaf'\x9b\x05\xb2\x0e\x16\xc2S\x06.\xb5\xe7q\xb9?H6\ad\x1f,\x84\xcfD\xa4\x01\xc0\x0e\x16\xc2g \xd2\x00`\v\v\xe1)\x03\x91\x06\x00;X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\x17\xe1\x01P\x02\v\xe1\xf5\xf0\xfe\xf6\xf6\xb8\x9f\x87\a`\xf8`!<2<P\x05\v\xe1\t\x19\x1e(\x82\x85\xf08-\tT\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1\x11i\x80*X\b\x8fH\x03T\xc1BxB\xa4\x01\x8a`!\xbc\x8c4o~5\u08c1>\xf9\x0f\xbbz\x901X\b\x1f\x884\x00d\x1c\x16\u0093\x8c4ح\x03\x05\xb0\x10^\x8f4\aw\xf7\x1d\xd9\xec;\xf2\x92\xfe\xaf\xf7\xf8v\xcbs\xc9K\xcd\x00H\x1d\x16\xc2\xcb⛅7߬\xee6\xff\xa5Vjv\xe0\x18\x01\x90.,\x84\xd7\xe9\xbdI_~\x1c\xf8\xd7}1\xe2\xa98\xa5f\x8f.!\x00҅\x85\xf0\xc6\x1bO\x9d\xf1\x9e\x8dSj6u\xb1\xddd\x00\x12\xc2Bx\xe3,\xcd\xf9\x81^\xfbӒ\xa1R\xb3Sㄨ\xf2\x97\b\x91\u007f\xab5\x10\xec\xa7\xc4n\f\x80\x04\xb0\x10\x9e\x12\xbe\xf1\x14*5\xf3\x1f\xf6\xe4\x1c\xa6]cw\x9d\xa0\xaeC\xde\xd2\xe9z\xb2ǵ\x96@z\xb0\x10>\xf1gi,\xa5f\xfe\xa5\xe5WK6\x9a\x8b\x11i\xc0 `!|\xe2\xcf\xd2XJͨ\xe7ᢪ@\x96\x87\xf0`\x10\xb0\x10\x9e\x12G\x9ap\xa9\x19Q\x8b8\x14\x18Ax0\bX\b\x9f$\xd2XJ\xcd.\x14֗|a.6\x84\xdf\xf9\xa9\xfd:\x00\xd8\xc3B\xf8$\x91&\\j\xd6_^O\xcb\xdcf\xa6q\xbb\x89\xae\x88&\xfbu\x00\xb0\x87\x85\xf0\x94 \xd2XJ\xcdz\x0e-/\xb8@\x1dy+\x0e\xdd\"Y\xba\xb7\xa5\xc5\xed\xfa,\xcej\x00\xd8\xc2B\xf8D\x91\xc6Rj&\x87\xabh\x85\x10cewӭ\x15\xf9\xb9\xd3\xdb\xedV\x01 .,\x84\xc77\x9e\x80*X\bO\xf8\xc6\x13P\x04\v\xe1\xf1%n\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1\x11i\x80*X\b\x8fH\x03T\xc1BxB\xa4\x01\x8a\xe0\"<\x00J`!<J̀*X\b\x8f\f\x0fT\xc1BxB\x86\a\x8a`!<NK\x02U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fR3\xa0\n\x16£\xd4\f\xa8\x82\x85\xf0\x84R3\xa0\b\x16\xc2'*5\xf3\x06K\xcdƟ\x8c\xbb~\x98\x93s&\xe4M?Pv\x88\xa8V_\xc5u&\xfe\xcc\xe5\"\a\x97\xe9\xcbBX\b\x9f\xa8\xd4\xec֡\xc29\xf2J{\xbbD[\xdc\xf5C\x1cӪZv-\x10\xf2\x8a\x93\x17\xbc\xde\x06\xf1N\xfc\xa9\x17\xbc\xa1f\x11\x90E\xb0\x10\x9e\x12\x96\x9aM\\&o?JE\xf8Jy\xa1U\u007fm\xe0\x12\xab퉄\xb7T\xe9\x80,\x82\x85\xf0\x89K\xcdL\xe1\xfb\xb7݈7!\xcc\xc4zy{R\xb4\x18\x8f <\x88\x81\x85\xf0\x89K\xcdL\xe1uN\x8e\x13\xa2\xfeL\xcd\xc4\xdc\xca\xdb\xfa~\xfc\x95)\xae\x87\x1b\xfct\xbbH\xfbMq\xf1\x81\x15\xf9\xee.\xa2%\x85\xa7\xf4y\xfe\xbd]\xc6\xfc\xa0\xf07\x16\x17k%U\xe6!\x80\xb7\xb2D+\x9aS\"\xaf\xb8\xad=\xb5\xea\x01W\xe5\x05\x02\xd9\x04\v\xe1)\xe1\x1bO\x13k{z^.\xd7\a=M\x8d%\xa5y%\xabj\xc6~J\xb4T\xab\xdf[\xaf\xd5\x12\x1d\xc8\x13\xab\xdcb\xc2Ƣ\x97\x89>)ɩ\xf4\x1c\x0eVv\a\x85o\x15\xcb\x0e4U\xe5\xc8+\r\x1f\x1d\xbb\xb4e\xff\xce\"\xa1\xbfbH\x13\x93\x1b[\x8a\x16\xc4\xf9\xa9`t\xc2B\xf8ğ\xa5\x99(\xcf\xd1\x14\x9a\xe3\xa9\xc2}\x83\xfc7\xe4U\xb4e\xa47n\vkh\xafh\xa5\xa5\xf2\x0f\xc1\xb5\xe7\x1f\xd5D~\xe0\xf4KP\xf8\x9e&}\x8f\xef/\x9b\xa7\x0f\x1b\n\xa4\xea\r\xf9\xc6\x1e\xbe\xf0\v\xa2ڂ\xd8\x1f\bF1,\x84O\xfcY\x9a\x89U\xed\xedK\x83\xc2k\x9f\x9a\x83\xda2\xe3\xeeA}\x17_\xd8H\xef\x8a.z\xba\xc6|\xe6\xd6\xfeJ\xb1\xd7\x18\x852\xfcՆ\xcaIyB\xae\xf1Y\xf1\xc4\x15;O\xf8\x8d\xbf\x01\x9a|\x85x4\x02\xd9\x04\v\xe1)q\xa4\xd1\xc5<\xb5\xd3\x1cO\r6\x11\x97\x9b\xb5~Uz\xd4)l\xa3v]\xdb:]\xf8v#\x91\xfb\x03O\x06\x85o/,y\xba\xc5\xeb6^\"\xd7w,\x9e,\x8a6\x1a{xy\xd0\n\xe1\xb3\f\x16\xc2'\x894\xcb\xc2㩋\x02\x83\xdaI\xd2Y\xffĥ\x11\xc2\x17\xae0\x9e\xac/5\xee\x82\xc2O.\xef\xd1o\x17I\xe1\xdb\xeb\xf4ծ7\xe66\x10\x84\xcfNX\b\x9f$\xd2X\x85_\x1c\x18\xec\x15\x8d\xfam\xa3\f/\x16ዊ\xaf\xe9K\xfd\x81\x97EP\xf8\x12\xf9\xd0\xff\xb0\x14\xdec\x9e\xcdw\xcbMB\xf8l\x84\x85\xf0\x94 \xd2\xdcz\xa7p\xce!\xf34\xe3\xed\xc3F\xdf\xfc'ƃ\x9a\x9c\xbaֺ\x1c]\xf2S\xf9/\xf74j'{j\xdc\x17\xa8H\x14z\xdaZܹ\x1f\xe9i]\xbeӺ\xc5\xeb\xfdTZ\xbe\xb8\xe1\xf9\xa9\xa2\xe8\xc5w\xf5\xa1\xab\xbe\xb5\xa5V\x1c\xa0K^\xad\xf6]\xff\x89Z\xcd{)\xceO\x06\xa3\x11\x16\xc2'\x8a4\xc6giv\x19Ó9\xc2\xd2B\xbf\xad\xccU\xd6\xe0'\u007f\x91\x10\x8dy\xc2\xd5$\xc4<ztg\xfd\xcf\\\x05\xf3t\xdfii\xe0#8K\xf4\xa9[J\xb5\x82%\xaf\x95jn\xda5\xddS\xa2\x15\xba\x0f\xc8\xcf\xd2\b\xa1\xbd\xef\xd2o\x97\xdb\xfdX0Ja!<\xbe\xf1\x04T\xc1Bx\xc27\x9e\x80\"X\b\x8f/q\x03U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x04\x82U\v\x00\x00 \x00IDAT\x16\xc2\x13\"\rP\x04\x84\aY\x05\v\xe1\x91\xe1\x81*X\b\x8f\f\x0fT\xc1BxB\xa4\x01\x8apV\xf8^=\xc6\f\xf8$\a\xdf\xf8\xdc\xe7\xeb\xeb\x93;y$\x1b\x909\x9c\x15>\x80\xae\xf9\xa6\xd9\xe7\x10i@\xe6a!\xbcN\xe79_\xb2)\x00\f\x1d\x87\x85\xd7\xe3\xcb\xf1\xed\xeb֮]\xa3\xb3v\xcdڭ\xafw#рL\xe2\xb0\xf0\xf2\xfc\xcc¹\xd5sM\xaa\xab\xa7\x9dG\xb0\x01\x99\xc4y\xe17\xcc8\xfe\xe5\xe7_\xea\xe87\xebf Ƀ\x8c\xc2@\xf8\x8a\xf0\x19\xc9ͳ\xce\xc9k\b#\u0383L\xe1\xbc\xf0/\xcc\xf80\xf4h\xfd\xac\xb3\x89f\x030T\x9c\x17~\xc3̰\xe4\xcfʹ\x13\xbe\xe5\xc1\xf1e-S[\xe3\xf46\xa1\xac\t\xa4\x81\xf3¯\xaf\xee\xfd\xc3?\xfe\xe3=\xfa\u007f\xff\xec\xdb=\xa3\xf3\xed\xb5\xbdo\xaf\x8d\x98\xb3MԴ<%Ķ8\xbdM(k\x02i\xe0\xbc\xf0\xeb\xaa\xfb\xd6\xfd\xfd\xdf\xff\x1f\xfd\xbf\xef\xfb\x9agt7/\xbc\xd9\\m\x9d\xf2\xd1\xd8z\xfdv\x95\x14\x9e\xeckl <H\x19\xe7\x85\xdf0\xeb\xfcͳ\x1f\x9f\xff\xf8\xfc\xd9˴i\xe6ǾN\xf2}e\x9dR[pK\xbf\xfd@4\x18\x8f <\x18\x12\xce\v\xff\u008cӡGv\a\xad\xf9O\x1bw\xdb>1\xeeB\xc2\a;\x9et\xb4\x15O\x14\xe7W%\xe8d\x05 \x88\xf3\xc2o\x98\x19\xee\xef{if\xcci\xc9\xeb\xe25\xeb\n!\xe1C\x1dO\xb2\xaciJSc\x99\xeb\x14\x01\x90\f\x06\xc2W|\x1ez\xf8Ҭ\x987\x9e\xde7\xae\xe8\xee\xef\xe9\xb9e<\f\no\xe9x\"mr\x0fQOi9\x01\x90\f\xe7\x85ߴ\xf0\xc95+W\xfe\xfa\xd7+W\xae\\S\xfdH\xcc\xd7@\xcc=|\x8d\x10b\xbf|\x18\x14\xde\xd2\xf1D\xda3r\xb8C\\#\x00\x92\xe0\xb0\xf0\x03D\xfbV\xfer~u\xf5\xc2ǫ\xab\xab\xe7\xaf\\\xdb\x19\xf3\xe1\xb1\t2\xc3_j\x11u\xc6.>(\xbc\xa5\xe3)p\xd0\xea\x15\xc7\b\x80$8,\xbcN_o\xb7\x8eo@\xde\xf6\xf6\xc6>_[$Mo\x89:-i\xe9x\"m\x95\\\xb2S\xa4P\xd5\r\xb2\x1d\xe7\x85'c?\xff\xc2\xc2\xcf\xe3|0\xd88\x0f\xefwG\to\xe9x\"\xadX\u007fI\xf4?\xe8\xb6]\x1d\x00+\xce\v?\xd0\xd7\xd7\xed\xf3\xfd۴#\xben_\x9f\xddG%\xb7\x88'Zk\x8dwZ-\xbdM\xe1\x8e'y\x96\xa6\xf2\xf0\xfe\xf2\xfc\x8fl\xd6\x05 \x12\xe7\x857\xe9M\xf0%\xee\x96ɹ\xe5m%m\x11\xbdM\xa1\x8e'\x9d\a=\x8b\xf3\x8ak\xd0M\x06R\x80\x85\xf0>\xa2M\x8f\x9f%|*\x18d\x1c\x16\xc2뇪z\xa4!\x9b#V\x00\x86\x17\x16\xc2S\xe2H\x03\xc0\xb0\xc1Bx\\j\x0f\xa8\x82\x85\xf0\xb8\xd4\x1eP\x05\v\xe1\t\x97\xda\x03\x8a`!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84O\x10i\xb0\xe7\a\xc3\n\v\xe1)\x8e\xd8\xd8\xf3\x83ᆅ\xf0\xf1\xc4\xc6\xc1,\x18nX\b\x8fH\x03T\xc1Bx\x8a/\xf6\x91\xdd\x11\xd7\xdd\x03`h\xb0\x10>&\xd2\xec\xf1u\xf6\xfa\xfa\xfaz\xfb\xfa6T\x9c\x95w}\xd4\xd7\xdb\xeb\xc37D\xc0Pa!|L\xa49\x12\xfa\xba\x1f\xda\xfd\xc0\xb0\xc2Bx\x8a\x8e4\x90\x1cd\b\x16\xc2Ǟ\xa5\x91u\x96\xbb7mxn\xfd\xb3k\xd7?\xb7~\xc3\xebͨ\xb3\x04\xc3\x02\v\xe1c\xcf\xd2\xe8í\vg?6kV\xf5\xfcٳf=V=\xe3\"NN\x82စ\xf0\x14s\x96F^Uxڑ\xf3g\xcfߤ\xcbgϟ\u007fv\x1a\xea,\xc1\xb0\xc0B\xf8\xd8Hc\\F\xfb&\xc9K\xadʇ[+\xe4u\xe3\xe1<\x182,\x84\xb7\x8d4/̔u\x96?\xba\xe3\xa0\xfe蹙\xe7\xe2\xad\v@:\xb0\x10\x9el#\x8dQay\xff\x1d\xf2v=\xea,\xc1\xf0\xc0Bx\xdbH\xb3~n\xf7\xee\xfb\xee\xbd\xfbk?\xb8\xef\xe7}o\xcc\xe8<\xb8\xc1w|s\xc4Z\xa8\xb3\x04\xe9\xc3Bx\xdbH\xb3\xaez`\xed7\xbe\xfeww|\xe3\x1bߑu\x96\xbb\xab\xbb\xf7\xfcҺ\x12\xea,\xc1 `!<\xd9F\x9a\x8a\x8b\x9dǏ\xdf\xfb\xf5\xed\xc7ߣ\x97f\x9e\xef>Oݗ\xadSPg\t\x06\x01\v\xe1m#\x8dYgy\xaf\xcc\xf0\x03\xa8\xb3\x04\xc3\x04\v\xe1m#͆Yr\x87>\xeb{R\xfbM3cNK\xa2\xce\x12\f\x06\x16\u0093}\xa4\xf9R\x1f\x98\x9d\xad\x9b+Pg\t\x86\x05\x16\xc2ۿ\xf14\u007f\xcd\xfag\xd7m\u007f\xe3\xb9g\u05ed\x9f\x8f:K0<\xb0\x10\xde6\xd2\xecy\xb2z\xee\xec\xd9\x15\x15\x15\xb3g\xcf}reg\xcc۬\xa8\xb3\x04\x83\x80\x85\xf0d\xf7\x8d\xa7\xde\xce\xcb\x17/_n^\u007fZ\xbf\xeb\xb4\xf9\xda\x13\xea,\xc1 `!|\x82/q\xaf\x9du>\xceGhPg\t\x06\x01\v\xe1c#\r\xc9\xc3U_\xaf\xcf\xf7\xd2\xfc\xb3\xbe\xde>\x9f\x9d\xf3\xa8\xb3\x04\xe9\xc3Bx\x8a\u007f]\x9a\x83\u007f\x88-\xa3\x0f\x82:K\x906,\x84\x8f\x17i|Dkf\x1e\xc7\x17\xfe\xc0\xf0\xc1Bx\xdbH\x13X>\x1f\x17b\x02\xc3\b\v\xe1ip\x91\x06\x80\xb4a!<.\xb5\aT\xc1B\xf8\x04b\xe3R{`Xa!<\xe1\xea\xc1@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<\xc5\x17\x1b\u0083a\x85\x85\xf0\xf1\"\r2<\x18nX\b\x9f\xe8\xb34\xc8\xf0`8a!<!\xd2\x00E\xb0\x10>AtA\xa9\x19\x18VX\b\x1f\x13]Pj\x062\x04\v\xe1):\xba\xa0\xd4\fd\b\x16\xc2\xc7D\x1aH\x0e2\x04\v\xe1c\xcf\xc6\f\xa0\xd4\fd\x04\x16\u0093ݥ\xf6Pj\x062\x00\v\xe1\xed/\xb5\x87R30\xfc\xb0\x10>6\xd2\xf4\xa1\xd4\fd\x04\x16\u0093]\xa4A\xa9\x19\xc8\x00,\x84\xb7\x8f4\xc9J\xcdNΙ\x907\xfd@١\x88\x85\x91\xfdf\xfb\vZcV\x03Y\r\v\xe1m#M\xb2R\xb3cZUˮ\x05BDV\xf5E\xf6\x9b\xb5\xbaZ\x02\xa3\x03\xb8\x840\x90\xb0\x10\x9e\xec\"M\xb2R\xb3J\xb7\x9f\xc8_+b\xba)\xaduO\xfe\xe0\xe0\xd1%\xd1\xd3@V\xc2Bx\xfbH\x93\xa4\xd4lb\xbd\xbc=)\x82\xfb\xf0\x10v\xfdf4uq\xec2\x90\x85\xb0\x10\xde6\xd2$+5[R(˛\xfc{\xbbh\xb9\x18\xb7mY\xb8\xbe,(\xfc\xf5\\!r\xe4ų\xa95p\xb1\xd5)1\x1b\x01\xd9\x06\v\xe1ɶ\xe3)q\xa9\x19}R\x92S\xe99ܯ\x8f\xfe\xd28N\x94<\xef)\tԗ\x85\xf6\xf0\xed^\xefx\xa3\x04\xa4됷t\xba\xd7\xeb\xfd\x80@\xb6\xc3B\xf88\x91&a\xa9\x19ѵ\xe7\x1f\xd5D\xbe\x11ᵉ7\xf4=z\x89Y_f\x8d4\xb9\xc1\xaaVD\x1a`\xc0Bx\xfb7\x9e\x12\x97\x9a\x19\xdc\xda_iv}\xd4\xc9G\rf}\x19\x84\a\xf1a!<\xd9E\x9ad\xa5f\xed\x17\xe4\xad\xdfh1\x8b\xa8/\x83\xf0 >,\x84\xb7\xfd\xc6S\xb2R\xb3\xc2\x15\xc6]})E\u0557\xc5\x17~\xe7\xa7\x04\xb2\x1c\x16\xc2\xc7F\x9a\xd0\xf2\xf8\xa5fE\xc52\xc0\xf8\xa7.\xd2o\xb5\xa2.\xfd\xd0t\x92Y_f+\xbc[\u007f\xeeJ\xec9{\x90m\xb0\x10\x9e쾬\x9d\xacԬH\x14z\xdaZܹ\xb2\xb3L\x96\xcc\xef,\x95\xf5e\x96~\xb3\xfew\xbc\xde\xf1\xb5^\xaf\xb1\xdb\xf7h[Zܮ\xcfb7\x03\xb2\v\x16\xc2'\xb8.M\xfc\x06\x90Gw\xd6\xff\xccU0\xcf\xe8\xe8\xd3V\xd7\x06\xea\xcb,\xfdfGs\xcc\xe1\x0e9\xe3֊\xfc\xdc\xe9\xed\xb6\x1b\x02\xd9\x04\v\xe1\xe3E\x9a\x94K\xcd4\x0f\x01\x90\n,\x84\xa78ן\xe9K\xb5\xd4\f\u0083\x14a!\xfc\xa0\"\x8d\x15\b\x0fR\x84\x85\xf0\t\xceҤr\xa9\xbd\v^\xad\xf6]?\x01\x90\x1c\x16\xc2\xd3\xd0.\xb5\xb7\\?2\xd5>I6\v\x00b\"|\x82H\x83\xab\a\x83a\x85\x85\xf0C\x8c4\x00\xa4\f\v\xe1ih\x91\x06\x80\x94a!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84O\x10] <\x18VX\b\x1f/\xba Ãᆅ\xf0\x94\xe0\xb34\xc8\xf0`8a!<\"\rP\x05\v\xe1\x13\xec\xc9Qj\x06\x86\x15\x16\xc2S\xf4\x9e\xbcW\xdfۛ\xdfx\xdaP\xf1\xa1\xef\xa6,5#Dy0\f\xb0\x10>A\xa4A\xa9\x19\x18VX\b\x8f\x83S\xa0\n\x16\xc2S\xcc\xc1\xa9\xbe\xb3?\xbe}\xddڵkt֮Y\xbb\xf5u\x94\x9a\x81a\x81\x85\xf0\xb6\x97\xdaۼpn\xf5\\\x93\xea\xeai\xf1.\xd6\x01@Z\xb0\x10>6\xd2\xe8\xc3\r3\x8e\u007f\xf9\xf9\x97:\xfaͺ\x19(5\x03\xc3\x02\v\xe1\xc9\xf6\xea\xc1\x15\xe1E\x9bgɫ\a\x0f\xe0\xf8\x15\f\x15\x16\xc2\xdbF\x9a\x17f|\x18zdw}x\x00\x06\x01\v\xe1\xed#\x8d\xa5\xc8\xec9\xbbR\xb30\x91Mf\x01\x96\x8b\x1c\\Y\x0fD\xc3Bx\xb2\x8b4\xeb\xab{\xff\xf0\x8f\xffx\x8f\xfe\xdf?\xfbv\xcf\xe8|{m\xef\xdbk\xe3\xac\x1c\xd9d\x16Z\x88\x8bw\x80\x18X\bo\x1bi\xd6U\xf7\xad\xfb\xfb\xbf\xff?\xfa\u007fߗ\xa5f\xcd\vo6W\xc7߄]\xb1\x13\x84\a1\xb0\x10\xde>\xd2\xcc:\u007f\xf3\xec\xc7\xe7?>\u007f\xf62m\x9a\xf9\xb1\xaf\x93|\t>V\x03\xe1AJ\xb0\x10\x9el\x9b\xb8\x8dR3\xf3\x91\xedA\xeb՚\tūWOp\x19I=$\xbc\xff\x95)\xae\x87\x1b\x8c\xcb2i+\x9e\bW\x9d\x01 a!\xbcm\xa4\xd90\xb33\xf4𥙱\xa7%\xfb\x1f,l\xf0\x8c\xcf\xddY\xf9\xb2|\x14\x12~\xa9V\xbf\xb7^\xab\x95Cy\x11\xedƲ@\xd5\x19\x00\x12\x16\xc2\xdbG\x9a\x8a\xcf\xf5\xc1\x80\xb1\xf0\xa5Y\xb1o<5\x89\x93\xb2\xd6)\xa0sP\xf86\xd1\x16\xba\xd5&\xf7\x10\xf5\x94\x96\x13\x00AX\bOv\x91f\xd3\xc2'\u05ec\\\xf9\xeb_\xaf\\\xb9rM\xb5M\xa9Y]\xbe~\xf3Q\xb0\x978(|m\x99q\xf7\xa0\xdc\xc5k\xcf\xc8\xe1\x0e\xb3\xea\f\x00\t\v\xe1c#\x8d>ܷ\xf2\x97\xf3\xab\xab\x17>^]]=\u007f\xe5\xda\xd8k\b\xbf<\xf6\xaaܕG\xedፎ3\xa2*\xb9[\x8f\xa8:\x03@\xc2Bxۏ\a\xf7\xf5v\u007f\xd5ݽgù\xee/\xbb{{cW\xfa4\xa7\xf2ӓ\xa5偫\x06\x87\xf6\xf0\x93\xe4\x02\xffĥ\x14Uu\x06\x80\x84\x85\xf0\x14\xffK\xdckf\xc6\xfb\x9c\xfc1Q$\x84\xfbB\xe0QP\xf8\xbdB\x96\xcd7\x9a\xed\xadŷ䱭\xdbvu\x90\x9d\xb0\x10\xde\xf6\x1bO\x03}}\xbd>\xdf\xf6\xc7\xcf\xfaz}}6\xce\x1f\x1b\xbf\u007f\xaf\xf7\x82\xb1\x83\xb74\x99QMN]k]N\x8d\\\xac\x89\xca\xc3\xfb\xcb\xf3?\x8a]\x17d-,\x84\x8f\xf7\x8d'\xfd\x15p\xf0\xf5xץ9\xa4\xc9\xc62m\xfa\xa9\x88&3\xf2o+s\x95\x99\xe7\xe1\x1f\xf4,\x0eT\x9d\x01\x10\x80\x85\xf0\x14'\xd2\xf8\x88~=#N\xa9\xd9\x15ײ+\xb7o_?\xba \xff\xba\xdd\xd3\x00\xd8\xc2B\xf8x_\xe2\xd6w\xf9\xdb\x1f\x8f\xf3]\xa7\x96|\xf3p\xd5_\xd4f\xf74\x00\xb6\xb0\x10~0\x91\xe6X\x8eyB\xf2T\xce\t\xbb\xa7\x01\xb0\x85\x85\xf04\x88K\xed\xf9ks\x975\x1dhZ\x96\xbb\fuf uX\b?\xa8K\xed\xf9[+\x8b\xb5\xe2\xcaV\xf8\x0eҀ\x85\xf0\t\"\r\xae\x1e\f\x86\x15\x16\xc2\xd3 \"\r\x00\x83\x81\x85\xf0\x83\x8a4\x00\f\x02\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1\a\x11i\x10u\xc0\xa0`!|\xba\x91\x06Q\a\f\x16\x16\xc2S\x9a\x91\x06Q\a\f\x16\x16\xc2#\xd2\x00U\xb0\x10>\xe5H\x13h\xf7\xd39\xf8\xc6\xe7>\x1f\xda\xfd@\xba\xb0\x10\x9eҏ4\x9bf\xa3\x13\x04\f\x02\x16\xc2\x0f\"Ҡ\xce\x12\f\n\x16§\x1ci\xe4\x10\xed~`\b\xb0\x10\x9eR\x8e4}h\xf7\x03C\x82\x85\xf0\xa9G\x9a>\xb4\xfb\x81!\xc1B\xf8\xd4#M\x1f\xda\xfd\xc0\x90`!<\xa5\x13i\xd0\xee\a\x86\x00\v\xe1Ӌ4\xc9\xdb\xfdZ\xe4e\xc8&F\u007f\xbb{\u007fA\xab\xddd\x90U\xb0\x10>\xadH\x93B\xbb_\xd7!oޢ\x98\xe2\x8fVWK\xf4\"\x90u\xb0\x10\x9e҉4\xa9\xb5\xfb\x15\xad\x8e]\x86\vz\x00\x1e§\x17iRj\xf7\xb3\x13\x1e\x00\x1e§\x15i\x92\xb6\xfb\x19\x98\u0087+\xfd\xae\xe7\n\x91#/\x1dO˅\xb6s\xd5\x03\xae\xca\xe0\x95\xe5AV\xc1BxJ'\xd2$k\xf731\x85\xb7T\xfa\xb5{\xbd\xe3\x8d\n\x9c\xbf4\x8e\x13\x05\x9e\xdf\xe6-\x88]\t\x8c~X\b\x9f^\xa41\xda\xfdL\xec\xda\xfdL\f᭕~:\xb9\x81\xa2b-_\u07fb\xd7\x14خ\aF9,\x84O+\xd2$k\xf731\x84\xb7V\xfa\x91ExY\x00\xe5\xd1l\xd7\x03\xa3\x1c\x16\xc2Sʑf y\xbb\x9f\x89!\xbc\xb5ҏ,\xc2\xcb{\b\x9f\x9d\xb0\x10>\xf5H\xa3\xd3\xd7ۭ\xe3\x1b\x90\xb7v\xed~\xb7?\x90\a\xa9\x13\x8c=\xbc\xa5ҏ < &§\x1eiB\xcb_X\xf8y\x9c}\xfb+\xc2KtUl\xa3\xc8J?\x82\xf0\x80\x98\bO)G\x1a2\xda\xfd\xba}\xbe\u007f\x9bv\xc4\xd7m\xdb\xeew@\xcci\xd9U>\xe139\x0eW\xfa\xf5\xbf\xe3\xf5\x8e\xaf\xf5zo\xd0%\xafV\xfb\xae\xffD\xad\xe6E\xddY\x16\xc2B\xf8\xb4\"\x8dIo\xfc/q\xb7Lu\xe5W\xbdo\fÕ~Gs̢\xbf\x1d\xb4\\v\xff\xbd\xef\xd2o\x97\xc7\xdd\x04\x18\xb5\xb0\x10>\xddH\xe3#\xda\xf4\xf8Y\xfbv?\x00\x12\xc1BxJ'Ґ\xbcx\x01鑆l\x8eX\x01H\f\v\xe1\x877\xd2\x00\x10\x1f\x16§\x1bi\x12\xbc@\x00H\b\v\xe1)\xcdH\x13o9\x00\xc9`!\xfc \"\r.\xb5\a\x06\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<\r5\xd2\\\xbe\xfcyg\xd4\x06\xba;/\u007f\xf5%^\x12 \n\x16\xc2\x0fc\xa49\xb8=ޗ\xfe\x00 &\xc2\x0fW\xa4\xd17\xb0i.\x0efA\x02X\bOC\x8d4a\xba;\xb1\u007f\a\t`!\xfc\xf0D\x9a\xbe>__\xdf\xf1=_\xeaw\x03\xb0\x1e\xd8\xc3B\xf8\xe1\x8a4:/=v\xd1f)\x00\x01X\bO\xc3\x17i\x06\xc2\xd7\xe1\x03 \x16\x16\xc2\x0f=\xd2諞\xde\xf3\x87\xed[7\xbfټ}\xeb\xd6\xed\xcd\xfbnگ\x06\xb2\x1d\x16\xc2\x0f=\xd2\xe8\xabn\x9f?k\xe6\xb4\x19\xd3$3\xe7W\\Ĺ\x1a`\a\v\xe1iȑF\x1fn\x98v\xf0\xf4{\xa7\xdf\xd39}z\xcd4\xb4\xfb\x01[X\b?\xf4H#\x85\x9f\x1d\xbe\x8a\xc1֊s\xf2\"\x1ep\x1eD\xc3B\xf8a\x894\x96\xb2\xb3\xbe\r3\xcfE\xaf\x03\x80\x84\x85\xf04,\x91fFHxZo\xdf\xee\a\x00\v\xe1\x87%Ҭ\x9f۽\xe7\xc7?\xfe\x89\xfe_E\xdf\xeb3??\xb2\xddw|k\xe4\xe7jNU\xba\nk\x0e\x14^\xa1Z!\x84\xeb\f\x81,\x84\x85\xf0\xc3\x12i\xd6UӚ\xaf}\xed\xef\xf4\xff\xbe%\xdb\xfdޘ۽;\xb2\x1f\xa4\xcd\xf5\xe8\xce\xc62!>\xa0\v^o\x83x'z\xab \x1b`!<\rK\xa4\x99}\xf9b\xf3\x9e}{\xf65\x1f\xa4\xcd3.v\x9e\x1e\xe8\xfc\xd0z\xf5\xc9ky\xf3n\x11u\x95\xea\xc2\xeb\xb4C\xf8섅\xf0\xc3\x12i,\xed~\x03v\x19\xbe.\u05f8<\xf6\x16ad\x19\b\x9f\xa5\xb0\x10~X\"͆Y\x17\xcd%\xfaͦ\x19\xe7\xe4\xa5V#6X\xfa\x84qwu\xcb-y\x17\x12\u07bf\xab\xdc\xf5\xc0\xea\x1e}tcq\xb1VRu\x92\xd0l9\x9aa!<\rO\xa4\tobsE\xcc\x1bO\xb7r\xb6X\x1f\x86\x84\xaf\xcdY\xb1w[\xc1T?Q\xabXv\xa0\xa9*\xa7\x1d͖\xa3\x19\x16\xc2\x0fK\xa4\xd9P\xbdn\xf3\v\x9bt^ش\xf9\x97\xb1\xed~\x9f\x88\x16\xebà\xf0\xadb\x97\U00068468\xa7\xa9K\xdf\xe1\x97͓\x8b\xd1l9Za!\xfc\xb0D\x9a\xe6\xc7\x1f\xab\x98aR\xf1\xf8\x93\x9fGo\xad\u007f\x9c\xed\x1e~ɤ\xfe\xdb:Ų\xd9\xf2jC\xe5\xa4<aT]\xa2\xd9r\xb4\xc2Bx\x1ar\xa4\xd1\xe9\xbex6\xc4\xc5˱\u007f-\x02\x19\xbe\xdfl)\x0e\n_f6\xe1\b}\xbf\xde^X\xf2t\x8b\xd7m\n\x8f\u07b3Q\n\v\xe1\x87\x1eiR\xa0.\xf7\xaa\xbck\x12W\xe4]P\xf8\x9aI\xc7\f\xf4\xe7&\x97\xcbC\xd7E\x10~T\xc3B\xf8\xa1G\x1ac\xe9@_\x90\x81\x98M\xc9\xf3\xf0\v\xfa\xf5\x8c\xee\x9eh<\n\n\xdf&\x9a\xe4]\xfdF\xa2\x92E\xfa\xc0\xff0\x84\x1fհ\x10\x9e\x86#\xd2$\xa5\xcdU\xbe\xab\xa5r\xdc!\xa2\xcf\xe4;\xad[\xbc\xdeO\xf5\xa5uckZZj填G,nx~\xaa(z\xf1]4[\x8e^X\b\xaf$\xd2\x18\x9f\xa5)\x9a\xf7\xbe>X\x1a\b\xeeK\xe4\xd26\xf7\x84\xfc\xe92\xd8\xfb\xb7\x94j\x05K^+\xd5\xdch\xb6\x1c\xbd\xb0\x10~x\"\r\x00\xc9a!<)\x894\x000\x11^Q\xa4\x01\x80\x87\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe13\x1di\xf4\r\xbf\x8d:K a!|\xa6#\r\xfe\"\x80 ,\x84\xa7\xccG\x9a\xb4\xfe\"\x80\xd1\v\v\xe1\x15D\x9a\xb4\xfe\"\x80\xd1\v\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0*\"͛_\r\xf8h\xa0O\xfeK\xeb\x95\x02F\x17,\x84W\x14i\x00\xe0!<\xa9\x884\x89g\xb7\x94_I\xf8\xfc\x90\xb8V\x1eqmz\xe0 ,\x84W\x10i\x0e\xee\xee;\xb2\xd9w\xe4%\xfd_\xef\xf1\xed136\n\x8f?bA\x1a͖\xcbEN\x93\xfd3_,+ʝ\xa3o\xd7\xffb\xceF\xfb\x19\x83\xe4\x13MLN6\a\xd8\xc2Bx\x05\x91慅7߬\xee6\xff\xed\xf9e\xf4\x84m9\xbb\xa2\x96\xa4\xd1ly\xc1k\\k\xd8\x06wᎥ\xb9\xd7\xe5h\xef\xb8m\xf6S\x06\x87\xff\xddZ\\\xd9xp\xb0\x10\x9e2\x1fizoҗ\x1f\a\xfeu_\x8cz\xb2C\xab\v\x0e\xaf\xba\xaf\x06\x87\xa9\x17\xfd\xc5\x11\xfe\x9a\xd8F\xfe.s\\\xaf\roC\x1a.\xe5=HX\b\xaf \xd2\x1cy\xa33\xfe\xf3\xb5\x85=\xc1\xe1)q*8\x1c\xb2\xf0gDkh\xdcUXk;g\xb0@\xf8A\xc2Bx\x05\x91fs\xf5\xf9\x81\xde8\xa7%\xfb\xf3\x9e6\a\xdbJ[?\x10\x1f\xec-}\xc5x\x14\x14>\\gI\x93\x03\xd7ٞN\xad\xfa\xed3\xe4\xd1o\xf5\xfc\xae\xadx\xa28\xbf\xea\x8c\x11\xe7w\x05\x02v\xff\x04s\xea\xaa\xc0\x0f\xa9\xcf\r\xbd\xa8\x02Xk2\xc7m[\x16\xdcBhh\xa9Ԍ\xe8ѼPS\x9c\xbf\b\x91f\x90\xb0\x10\x9e2\x1fi\x12\xfdE8!\xbc\xe6\xe0B\x8dxP\x94\x89E\x9f\x19\x8f\xc2E\u007f\xc1:K\xd2j\xbd:\xe5b#\xf5\x1c*Yv\x85\xae\xd4\xe7y\xf5̢\x89)M\x8de\xaeSf\x9c\x0f\x04\xec\x13\xdeF\xe1\xf1\x86*\x15\x0e\x89\xc3Q?6\xb2&\xb3\xe4yO\x89\xbe\x05\xcb\xd0R\xa9i\xed\xd1<\x93\xf7\xc0k-\x95\x02\xc2\x0f\x0e\x16\xc2+\x894\xf1\xff\"\xec\x15\x1f\x05\x87m\x9a\xd0\xda\x02\xe3\xa0\xf0\x96:K\xcf1}T+\x8c\x03P\xcf\x14\xfdf\xa9\x11T\xb4\xc9\xfa^\xb8\xa7\xb4\x9c\"\xbbr\xac\x91\x86.\x88\xe8S\x93\x115\x99\x13o\x10]/)\x8f\x18Z*5-=\x9a\xd3K{\xe4j\x10~p\xb0\x10^I\xa4\x89\xff\x17\xa1E|b\x0e\xae\xadҊE\xf1\xf8\xa7\xbe0\x1e\x852\xbc\xa5\xceR\x8f*\x8bǚgt.\x8c}\x9fn\xe5\xed\x97C\xed\x19y\xbbC\\K(|̹KkM\xa6q\xd4\xdc`l!4\xb4Vj\x86z4\xaf\x8b\x9d\xf2\xf9z\b?8X\bO\xceF\x9aw\x83fo\x9c\xb0\xe3\x94\xf8˶\"\xf3\xa4yPxk\x9d%\xf5\xccт{\xea\xca\xd5Ԗ\xdf/G\xe6A\xabW\x1cK |\xbb8D\x91\xc4\xd4dZ\xb6`\f-\x95\x9a\xe1\xed\xb6\x9b\xf9\v\a\xad\x83\x84\x85\xf0\x0eG\x9a\x9e\xd0Y\x96~\xe3,M\xbf\xf9\x1eTPxk\x9de\xd7\xf4\xf1\xc1\xc4C\xad\x13\xfa\xcdDC\x9aqd\xbaS\xdc\b\x88Yo#\xbcG\xeb\xa2H\"j2-[\b\r-\x95\x9aa\xe1\xbf\x10\r\xf2\xf9\xa5\x10~p\xb0\x10\xde\xe1HC\x8bJCo\xb3~\x96\xffYp\x18\x14\xdeRgym\x8aK\xee_[\xddry\u007fQk\xbe\x91hH+\xbe\xa5?|P.u=\xad\xcf}4Vx\xff\xe4\xaa\xe0\xf0\x93\x8d\x1d\xd1\xdb%\xadH\u007f9tMrG\f-\x95\x9a\x96\xbf\x1c\xe5%z\xee\xf9h<\x84\x1f\x1c,\x84'g#\r\x9d\xc9\xf9m\xf4\"K\xb3e\xb8\xce\xf2z\x99\xd8(O\xd3<a\xdaV7)\xff\xb61\xd0D\xe5\xe1\xfd\xe5\xf9\xf2з\xbc`\xe3\xf3\xe5bܮS\x81\xb34\xef\x06^J[dZ1\x99'\xe6\x18\xf7\xe1\xed\x9a\xe7yv\x96\x1a[\xb0\fC\x95\x9a\xd6\x1e\xcdS\xae\x12O}~\x8e\xfc\x11 }X\b\xefp\xa4\xd1w\xa2\xe3\xa3\x03\xb6\xa5\xd92\\gyb\\`i\x891\xe7#\xb1̜\xfc\xa0gq^q\x8dq\x02\xf2\x8c;7\xaf\xf2\x19!\x96\xdf\xca7f\x8e\xfb\xc0\x98\xe1\xcd}*\xb4\xe9\xd7\nv\x18\xf7\xe1\xedꖯ\xae\rn\xc12\fUjF\xf4h\x9e\xa9ʟ\xf8Ԯq\xa8\xd4\x1c\x14,\x84w:Ґ\u007f\x85\x16\xe7\xf3_\x89\xe8\xd2\x0e$\x9b\x12\xa0I\xab\xbd\x9dp\x82\xe5\xbd\xdax\x1f\xcc\x01\xc3\x02\v\xe1\xc9\xe1H#\xf7\xb6\xc5W)]\x9a&$\xb68ĵ\u008d\x91\x9fŌ\x01«\x82\x85\xf0\x8eG\x9aA\xe09\xe0w\xd7'\x9b\x942\x10^\x15,\x84w<ҤO\x8f\x98\xb2\xbc\xf0z\xb2Y)r\xc18&\x8d\x1e\x82L\xc0Bxr<Ҥ\x8f\xc7\xe5\xfe ٜT1\x8eI?\x89\x1e\x82L\xc0B\xf8\x91\x18i\xc0Ȅ\x85\xf0#0Ҁ\x11\n\v\xe1i\x04F\x1a02a!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84\xcft\xa4\x01 \b\v\xe13\x1di\x06Pj\x06\x02\xb0\x10\x9e2\x1ciҝ\x0fF/,\x84W\x10iҝ\x0fF),\x84W\x10iҚ\x0fF/,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16«\x884(5\x03\x12\x16\u0093\x9aH\x03\x00\x0f\xe1\x95D\x9a\xc4/\x0f\x94\x9ae\t,\x84W\x10ix\x96\x9a\xed/\xb0\\}2\f:\xcb2\a\v\xe1)\xf3\x91\x86g\xa9Y\xab\xcbv\u05cfβ\xcc\xc1Bx\x05\x91\x86i\xa9Y\xbc\vr\xe0jؙ\x82\x85\xf0\n\"\xcd\b+5\x83\U00019085\xf0\x94\xf9Hð\xd4\xecz\xae\x109\xb2\xce&ngY\xa8\xd4\xec\xd48!\xaa\xfc%B\xe4\xdf\"0$X\b\xaf \xd2$\x9a\xefP\xa9\x19\xb5{\xbd㍿\r\xf1:\xcbB\xa5f\xfeÞ\x9côk\xec\xae\x13\xd1\xdb\x00i\xc2Bx%\x91&\xfe|\x87J\xcd$\xb9\x810d\xdbYf-5\xf3/-\xbfZ2\xbc\xfd\xf5\xd9\t\v\xe1IE\xa4\x89?ߩR3\xb2\bo\xd7Yf-5\xa3\x9e\x87\x8b\xaap\xcdɡ\xc3Bx\x87#\x8dC\xa5f\x92\x90\xf0v\x9de\xd6R3\xf9\xb2\xb4\xdb\x00H\x13\x16\xc2;\x1ci\x1c*5\x93\xc4\bo\xed,\xb3\x96\x9aх\xc2\xfa\x92/l\xb6\x00҃\x85\xf0\xe4l\xa4q\xa8\xd4L\x12#\xbc\xb5\xb3\xccZj\xd6_^O\xcb\xdc\xc84C\x86\x85\xf0\x0eG\x1a\x87J\xcd\xfa\xdf\xf1z\xc7\xd7z\xbd7\xe2v\x96\x85J\xcdz\x0e-/\xb8@\x1dy+\x0e\xe1\xb4\xe4\x10a!\xbcÑơR\xb3\xa39\xe6\xc6v\xc4\xef,\v\x96\x9a\xb5\x19'\xf4W\b16\xd5V)\x10\a\x16\u0093Ñ\xc6\xf9R3\xa0\n\x16\xc2;\x1di\x9c/5\x03\xaa`!\xbc\xe3\x91f\x10\fo\xa9\x19P\x05\v\xe1\xc9\xe9H\x93>\xc3Zj\x06\xd4\xc1Bx\xe7#M\xfa\fg\xa9\x19P\a\v\xe1Gb\xa4\x01#\x13\x16\xc2\xd3ȋ4`\x84\xc2B\xf8\x91\x18i\xc0Ȅ\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10>ӑ\x06\x80 ,\x84\xa7\fG\x9a\x01\x94\x9a\x81\x00,\x84\xcft\xa4I\xf7\x05\x02F/,\x84W\x10i\xd2z\x81\x80\xd1\v\v\xe1)\xf3\x91&\xdd\x17\b\x18\xa5\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\xa4 Ҡ\xd4\fHX\b\xaf(\xd2\x00\xc0Cx%\x91&\xf1n\x1d\xa5fY\x02\v\xe1)\xf3\x91\x86g\xa9YRⴞ\x81A\xc3Bx\x05\x91\x86g\xa9Y\x98\x03\xc7Ȏ8\xadg`а\x10^A\xa4aZj\x16\xe2\xd1%\xf6\xcbq\x01\xa7a\x86\x85\xf0\x94\xf9Hý\xd4l\xea\xe2\x84O\x83ႅ\xf0\n\"\r\xc3R3\xf2V\x96hEsJ\xfc\xc6\xc6$S\x88N\x8e\x13\xa2\xfeL\xcd\xc4\xdc\xca\xdb\xf1ZϮ\xd6L(^\xbdz\x82k\x10W\xc3\x04<\x84W\x10i\x12\xbd@\x1c*5;:vi\xcb\xfe\x9dE\xe26u\x1d\xf2\x96N\xd77\xfc\x81,\x94j,)\xcd+YU3\xf6\xd38\xadg\xfd\x0f\x166x\xc6\xe7\xee\xac|\x99@\xfa\xb0\x10\x9eTD\x9a\xf8/\x10\x87J\xcd\x1a\n\xe4\xb5X\x1b\xf2\x8d\x98n\x894S\x85\xfb\x06\xf9o\x98\x0fb[Ϛ\x84\xfeǦ!\x9c\xbc@Z\xb0\x10^I\xa4\x89\xff\x02q\xa8\xd4\xec\xb3\xe2\x89+v\x9e\xf0\x1b-Q\x11\xc2k\x9f\x86'Ŵ\x9eQ]>\xc9K\xd3\xe3\xec\xcd\xe0`!\xbcÑƩR\xb3\xeb;\x16O\x16E\x1bc\xf6\xf0S,sb;q^\x1e{U6$`\x0f?8X\bO\xceF\x1a\x87J\xcd\xda\xeb\xf4\x9fs\xbd1\xb7A>0\x84\xdfi\xecڧ.\xb2L\x8a\x15\xfeӜ\xcaOO\x96\x96\xe3|\xe5\xe0`!\xbcÑơR3\x8f0^;n\xa37ǭ\xaf|\xc5L=\x11g(c\x85?&\x8a\x84p'>\xab\x0f\xe2\xc2Bx\x87#\x8dC\xa5f\x1e\xe1\xaaom\xa9\x15Fo\x8eG\xdb\xd2\xe2v}F\xb7\x0f\x1b'l>\x91\xcb\xec[ώ\x8d\u07ff\xd7{\x01;\xf8A\xc2Bxr6\xd28Tj\xb6k\xba\xa7D+t\x9b=Q\xb7V\xe4\xe7No':i6\x9d\x19\u007f\x0e\xec[\xcf\x0eir\x996\x1d!~P\xb0\x10\xde\xe9H3\x92Jͮ\xb8\x96]\xb9}\xfb\xfa\xd1\x05\xf9\xe8\x1f\x19\f,\x84w:Ҍ\xa4R\xb3\x16\xf3\xbc=\xf9\x8bBG\xcf \rX\bONG\x9aA\xe0T\xa9ٱ\x1c3˜\xca9\x91d&\xb0\x83\x85\xf0\x8eG\x9a\xf4q\xac\xd4\xcc_\x9b\xbb\xac\xe9@Ӳ\xdce\xc3\xf6G#\xab`!\xbc\xf3\x91&}\x1c+5\xf3\xb7V\x16kŕ\xad\xf0}P\xb0\x10\x9eF`\xa4\x01#\x13\x16\u008f\xc0H\x03F(,\x84\x1f\x89\x91\x06\x8cLX\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1)Ñ\x06\x80 ,\x84\xcft\xa4\x19@\xa9\x19\b\xc0B\xf8LG\x1a\xfcE\x00AX\bO\x99\x8f4i\xfdE\x00\xa3\x17\x16\xc2+\x884i\xfdE\x00\xa3\x17\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1UD\x1a\x94\x9a\x01\t\v\xe1\x15E\x1a\x00x\bO*\"M:\xb3\xc1\xa8\x85\x85\xf0\n\"M\xdcR3\xef\xd8\xc0ŕƟ\x8c\xbb~\x98\x93s&\xe4M?Pv(y\xebY\xfc\xaa3\xe0$,\x84W\x10i▚\xdd:T8G^>o\x97H\xe1:/Ǵ\xaa\x96]\v\x8c֏d\xadg\xf1\xab\u0380\x93\xb0\x10\x9e2\x1fi\x12\x94\x9aM4.\x98\xf7Q*\xc2W\xba\xfdF#\x82\xb9\xefNR\x02\x05\xe19\xc2Bx\x05\x91&A\xa9\x99)|\xff\xb6\x1b\xf1&\x84\x99h\\z\xe9d\xa0\x8d\x00\u008f@X\b\xaf \xd2$(5\x9b\x18\xb8$jD\xa1\x18\xf9_\x99\xe2z\xb8\xc1O\xb7\x8b\xb4\xdf\x14\x17\x1fX\x91\xef\xee\"ZR(/\xfb\xe5\xdfk^\xeaݦ\xf5,\\T\xa6\v\xffT\xa8\x87\f\xb0\x81\x85\xf0\x94\xf9H\x93\xe0/\xc2\xc4ڞ\x9e\x97e?SD\xa1\xd8R\xad~o\xbdVKt O\xacr\x8b\t\x1b\x8b^&\xfa\xa4$\xa7\xd2s\xb8?\xb0\xa2M\xebY\xb8\xa8L^D{rcKт8?\x158\x03\v\xe1\x95D\x9a\xb8\u007f\x11&\xcas4\x85\xe68T(\xd6fDz㶰\x86\xf6\x8aVZ*\xff\x10\\{\xfeQM\xe4\aN\xbfش\x9eY\x8bʴ\xc2/\x88j\vb\u007f p\x10\x16\xc2+\x894q\xff\"L\xacjo_\x1a\x14>X(VkV:=\xa8\xef\xe2\v\x1b\xe9]\xd1EOט\xcf\xdc\xda_)\xf6\x1a#\x9b\xd63kQ\x99&_!\x81\xba'\xc0\x05\x16\u0093\xb3\x91F\x17\xf3\xd4Ns\x1c*\x14+7\x1bj\xaa\xf4\xa8S\xd8F\xed\xba\xb6u\xba\xf0\xedF\"\xf7\a\x9e\xb4k=\xb3\x14\x95Y\xfb\xcd\x00\x17X\b\xefp\xa4Y\x16\x1e\x87\n\xc5j'Ig\xfd\x13\x97F\b_\xb8\xc2x\xb2\xbeԸ\xb3i=\xb3\x16\x95Ax\x8e\xb0\x10\xde\xe1Hc\x15~q`\xb0W\xc8\xce\xf7F\x19^,\xc2\x17\x15_ӗ\xfa\x03/\v\x9b\xd63kQ\x19\x84\xe7\b\v\xe1\xc9\xc1Hs\xeb\x9d\xc29\x87\xccӌ\xd6B1\xaaɩk\xad\xcb\xd1%?\x95\xffrO\xa3v\xb2\xa7\xc6}\x81\x8aD\xa1\xa7\xadŝ\xfbQ\x9c\xd63KQ\x99\xb5\x87\f\xf0\x81\x85\xf0NF\x1a\xe3\xb34f\xb7\xb6\xb5P\x8c\xfc\xdb\xca\\e\r~\xf2\x17\tј'\\MḄGw\xd6\xff\xccU0O\xd6\xf5ٶ\x9eY\x8aʬ=d\x80\x0f,\x84w6Ҁl\x82\x85\xf0\xe4`\xa4\x01\xd9\x05\vᝌ4 \xbb`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2g:\xd2P\xfa\xf3\xc1(\x85\x85\xf0\x99\x8e4\xe9\xce\a\xa3\x17\x16\xc2S\x86#M\xba\xf3\xc1腅\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10^E\xa4A\xa9\x19\x90\xb0\x10\x9e\x14D\x9a\xb9(5\x03\xc4Dx%\x91&\xe5\x97\a\x18Ͱ\x10>ӑF\xe7\xf8\xbe\x81\xe3\u007f\xf0\x05\xfe\xbd\x9elv\xf2\xce2\vޱ\xa2\xdcO-B\x8cݟl\xaay\xad\xa7\xdad\xb3@\xe6`!<e>Ҭ\x99ֽ=\xf0\xef\xab7\x9eL\xb6B\xf2\xce2\v=\xfbE\xae\x97\xbaZ\xc4\xfe\x9edS\xe9\xf6;\x0f\x97y?K6\vd\x0e\x16\xc2+\x88\xc7O\xf3\xe3\x00\x00\x0e\xfdIDAT4\x83 I\x85S\x98.Q\xa3\xef\xb4?\x11]\xc9&J\xdc\xeed3@&a!\xbc\x82H3\b\xd2\x10~\xbf\xab\a\u008f\fX\bO\x19\x8e4\x89h\xd2C\xb5\x87<\xc2(_\r6\x99\x19\x04\x84_.rv\xd1'\x9a\x98\x1c\xd9oF\xfe]\xe5\xae\aV\xcb\x14\xd3%>\x99\xdab\n\x1f\xea7\x8b7\xd7*|h\xe9r\xa1\xedD\x01\x9a\x1aX\b\xefd\xa4\xe9\xf2\xe6\xd5_\xa1+\xf5\xf9\xde.K\x93\x99$ \xbc\xd10\xec\u007f\xb7V\x8b\xec7\xa3ڜ\x15{\xb7\x15L\xf5\x1b\xc2o\x9bc\n\x1f\xee7\x8b3\xd7*|h\xe9_\x1alj\x02\xcfo\xf3P\x80\x96yX\b\xefl\xa4\xa9]\xa2\xdf\xd4<A\x11Mfd\x894\xe1f\x03K\xbfY\xabq\x8d\xedvٛ\xa0\v\u007fu\xfcUCxK\xbf\x99\xfd\\\x8b\xf0֥Z\xbe\xbew\xafA\x01Z\xe6a!<9\x18i\xf4}qn\x0f\xf5\xb8\xbc\x14\xd1dF\xf6\u0087\xfb͖L꿭S\\k\bOs\xb6\x98\x19>\xdcof?\xd7\"\xbcu\xa9\xb6\x94\xd0\x16\xa2\x04\x16\xc2;\x19i\xf4\xb8=\xa1\x85Z\x8adܰ4\x99\x91\xbd\xf0\xe1\xf6\x9b\xb2@!\xc2<S\xf8\x96\x87\r\xe1-\xfdf\xf6s-\xc2[\x97\xa2\x1eG\x15,\x84w6\xd2Њy\xb4\xc0h+\xb34\x99Q\xb4\xf0\xf5Q\xc2\xd7L:fp\xd5\x14\xbeǵ_\no\xe97\xb3\x9f\x1b\x10\xbe\xab\xfeZ\xc4R\b\xaf\n\x16\u0093\xa3\x91\x86\x0e\x8f\xbf4\xfe\xb0\x1cX\x9a\xcc\xc8\"\xbc\xebi\xfdU\xf0h\x94\xf0m¨'\xae\xdfh\nOKk\xa4\xf0\x96~3\xfb\xb9\x01\xe1O\bo\xc4R\b\xaf\n\x16\xc2;\x1bi\xc8_\\Yl\x9e\x8a\f5\x99Y;˨\xbc`\xe3\xf3\xe5bܮS\xd6~3\xaa\x1b[\xd3\xd2R\xab\x1fx\xf6\xec\x17-]\xe4͕\u0087\xfb\xcd\xec\xe7\xde>\xfcp\x99Wg\x87.|x)\n\xd0\xd4\xc1Bx\x87#\rmѶ\x98\x83`\x93YDg\x19\x9dq\xe7\xe6U>#\xc42k\xbf\x99\xbe\xdfvOȟަ\x1f\xf4\x8e\x95\xe7\xf0\xfd\xe5\x85~K\xbf\xd9t\xfb\xb9\x81\xde4!r?\xb0,E\x01\x9a:X\bO\xceF\x1a\x90E\xb0\x10\xde\xe1H\x03\xb2\b\x16\xc2;\x1di@\xf6\xc0BxB\xa4\x01\x8a`!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16§\x1ci\x8e\x9f\xfd\xf0|g\xe4\x9cΏϞ?\x8b}=H\x11\x16\xc2S\xaa\x91\xc6\x17\x1a\x1d߇]<\x18\x04,\x84O9\xd2\x04\xe6\xe87\x1bf\x9eC\x86\a\xe9\xc3B\xf8\x94#Mx|\xf1\xbd\xf0\xde\x1e\x80\x94a!<\xa5\x1ai:\xa5\xf0\x03\x92s\xc7o\xca;\x9b\x95\x00H\x00\v\xe1Ӎ4}\x884`\x90\xb0\x10>\xe5H\x13\x8e1_\x9e\x8e\x9e\f@\n\xb0\x10\x9eR\x8d4\x92\x8bG\xf6\xed۷砼\xddw\xf08\x92<H\v\x16§\x1ci\xa4\xfb\u007fxlƴG\x1e\x996M\xdeTW_F\xb0\x01\xe9\xc0B\xf8\x94#\x8d\x91\xde+v\xbf\xbd\xef\xed\xf7\xce\x1f\xdc\xf7\xf6ۿ~\x04I\x1e\xa4\x05\v\xe1)\xe5H#\x85\x9f-cL\xe7A\xf9p{\xc59\x99\xebq\xb2\x06\xa4\n\v\xe1ӊ4\xf2\xfc\f\xd1}_;H8W\x03҆\x85\xf0iE\x9a\x17f|\xa8\x0f\xee\xbf\xe3\xa2~\xbb~\xe6\xd9\xe8u\x00H\x04\v\xe1)\x9dH\xf3\xdcc\x9dG\x1e\xff\xe5\xf7\xbf>\xed\xf1\xb5\x03\xdbg\\>\xbd\xa7\xef\xf4\x1e\xcb\xca\x1e\xa1\xb5\xe8w{]\xc2\x13\xb3\xbdh\x96\x8b\x9c\xa6ds\xc0肅\xf0iE\x9auմ\xe6\x8e;\xbe\xa6\xffw\xb7\xafyF\xf7\xeb\x15\xddoL;\x1b~Q\\\xadq\xc9\xda0wn\xcd\xd5\xc8-\x1d8F\xd1\x18%\xdb \xab`!|Z\x91\xe6\xb9\xc7>?\xfe\xec\xda\xff\xfb\xf5\xeag7\x0fl\x9fy\xf1\xdc\xc1\xbes\aoZV\xaa\x9b\xe3\xbaN\xd7r\xe7\xd4Em\xec\xd1%\x14\v\x84\xcf6X\bO\xe9D\x9a\x17f\xc87Y\uf2db\xe1\xebj\xdcM\xb4\xab\xb2&Z\xf8\xa9\x8bc\xa6B\xf8샅\xf0iE\x9a\r3?\xd6\a\xff\xfc\x8d\x83d\x9e\xa5\x89~\xaf\xb5\xae\xa6a\x01\xcd\xd9!\x85\xbf\xb1\xb8X+\xa9:\xa9/l\r\x94\xe7M1\xa6\x9cYT\xa4\x15ι\xa0\x8f\xb4\xa7V=઼@ [`!|Z\x91f\xc3\xec^}\xe03>K\x138\x0f\x1fA]\xcd\x05\xd7\x17\xe3/I\xe1[Ų\x03MU9\xedD]\x87\xbc\xa5ӽ^\xaf,\x8b\xa4\x03\xae)/\xee\xf7\bYU\xa9\x89ɍ-E\v\bd\v,\x84\xa7t\"͆Ƕ7\xefn>rz\xdf\xee\xe6\xe6'm\xdei\xad\xab\xa1\xb2e\x8f\x92\x14\xbe\xa7\xa9\x8b\xc8_6\xcfX\x1e\x8a4=%\x95\xb7\x88\xfa\x9b\xae\xe9c\xad\xf0\v\xa2\xda\x02\x02\xd9\x02\v\xe1ӊ4o̝9\xed\x11\x93i\xd5\vc?K\xa3\v\xff\xa2\xd8h\bOW\x1b*'\xe5\x892cyH\xf86q\"4Y[F\xa8|\xcf*X\b\x9fz\xa4ѹ|\xfc\xa0\xce\xdbo\xcb\xdb\xe36\xdf{҅\xbf\xfa\xd4\x15C\xf8\xf6\u0092\xa7[\xbc\xee(᷈\x9e\xd0d\xe3\xa0\x15\xc2g\x11,\x84\xa7\x94#M\n\xe8\xc2K\xa4\xf0\x93˥ڋ,\xc2\xef\xfc\x94h\xbf\b\x9f\x91\x87\xf0\xd9\x06\v\xe1S\x8f4)`\x11\xbed\x91>\xf0?l\n\xefv\x13]\x11M\xfa\x01l\xa1\xbb_\u007f\xbcb\x15A\xf8샅\xf0iE\x9a$|Q㾤\xdf]r\xd7|A\x1e\xb1\xb8\xe1\xf9\xa9\xa2\xe8\xc5wIj\xbd\xa5\xc5\xed\xfaL\x1f\x1d\x18\xff\xe0\x8e\xb6\x15b']\xf2j\xb5\xef\xfaO\xd4j\xdeKI\xb6\nF\v,\x84\xa7a\x8c4\x1e!\x9e\xd0\xef\x96\t\xe1!\xff\x96R\xad`\xc9k\xa5\x9a\xfc\xb0\xc1\xad\x15\xf9\xb9\xd3ۍ9\x1f-.\xce+o\x91\x9f\xa5\x11B{ߥ\xdf.O\xb8M0z`!\xfc\xb0F\x1a\x00\x12\xc0B\xf8\x94#\r\xec\aC\x84\x85\xf0\x94j\xa4\xe9L/\xcf\x03\x10\r\v\xe1S\x8e4i\x1e\xc0\x02\x10\r\v\xe1S\x8e4\x10\x1e\f\x11\x16\xc2S\xaa\x91\x06\u0083!\xc2B\xf8\x94#M7\x84\aC\x83\x85\xf0)G\x1a\x00\x86\b\v\xe1)\xd5H\x03\xc0\x10a!|ʑ\x06\x80!\xc2BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1\x11i\x80*X\b\x8fH\x03T\xc1BxB\xa4\x01\x8a`!<\"\rP\x05\v\xe1\x11i\x80*X\bO\x884@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x89\"͛_\r\xf8h\xa0O\xfeî\x1e\f\x19\x16\xc2S\x82H3\xf7c\x9b'\x00\x18$,\x84O\x18i\xb0[\a\xc3\b\v\xe1\x13\x1c\x9c\x1e\xdf7p\xfc\x0f\xbe\xc0\xbf\xd7-O$-\x15N\xa7\xa1\x18d\r,\x84\xa7\xf8\x91fʹ\xee\xed\x81\u007f_\xbd\xf1\xa4幤\xa5\xc2\xe94\x14\x83\xac\x81\x85\xf0\x83;ߞ\xacc5\xad\x86b\x90%\xb0\x10~p\xe7ۓ\n\x9fNC1\xc8\x12X\bO\x83:\xdf\x1e.\x15\x0e\x17\x10\x13y+K\xb4\xa29%\xfe\x88\x86b\xf2\xef*w=\xb0\xba'\xb2\xa1غ\x1a\xc8\x12X\b?\xc8H\x13*\x15\x0e\x17\x10\xd3ѱK[\xf6\xef,\x12\xb7#\x1a\x8a\xa96g\xc5\xdem\x05S\xfd\x11\rŖ\xd5@\xb6\xc0B\xf8AF\x9aP\xa9\xb0\xa5\x80\xb8\xa1\u0dbc\xcd\xf7G4\x14\xb7\x8a]\xfa\xd2v\xd1(\xd7\v7\x14[{\x8bAv\xc0Bx\x1a\\\xa4\t\x97\n\x87\v\x88?+\x9e\xb8b\xe7\t\xbf\xac\xe9\xb34\x14/\x99\xd4\u007f[\xa7\xb8VN\x0egxko1\xc8\x0eX\b?\xc8H\x13\xaa\x9c\xb4\x16\x10_߱x\xb2(\xda\xe8\x8fh(.\v$wcg\x1e\x12>\xa2\xb7\x18d\a,\x84\x1fd\xa4\t\to) n\xaf\xd3U\xbfޘ\xdb\x10Q\xd8Z3阁qF>\xd4P\x1c\xd1[\f\xb2\x03\x16\xc2\xd3\xe0\"MHxK\x01\xb1G\xb4\xc9\xe7\xdc\xcb\"\x84o\x13ƻ\xb2\xf5\x1b\x8d\xe7\x82\r\xc5\x11\xbd\xc5 ;`!\xfc`\"\x8d\xb5T\xd8R@\xec\x11\xae\xfa֖Zq \xa2\xa1\x98\xea\xc6ִ\xe8K\xe5\xa1k\xb8\xa18\xa2\xb7\x18d\a,\x84\x1fL\xa4\xb1\x96\n[\n\x88wM\xf7\x94h\x85\xee\x03\x91\r\xc5\xfa>\xde=!\u007f\xba\xb1\xf3\x0f7\x14G\xf4\x16\x83쀅\xf04\xa8H\x03@\xfa\xb0\x10~0\x91\x06\x80\xc1\xc0B\xf8\xc1D\x1a\x00\x06\x03\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1BxD\x1a\xa0\n\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"\xb8\b\x0f\x80\x12X\b\xaf\x87\xf7\xb7\xb7w\"Ã\xcc\xc3Bxdx\xa0\n\x16\xc2\x132<P\x04\v\xe1qZ\x12\xa8\x82\x85\xf0\x884@\x15,\x84'D\x1a\xa0\b\x16\xc2#\xd2\x00U\xb0\x10\x1e\x91\x06\xa8\x82\x85\xf0\x84H\x03\x14\xc1Bx4n\x03U\xb0\x10>\x10i\x00\xc88,\x84'4n\x03E\xb0\x10^\x8f4\aw\xf7\x1d\xd9\xec;\xf2\x92\xfe\xaf\xf7\xf8v\xeb\x93\xc7r\x8c\xf2\x8e\xd8\xee\xb1-\xe3\u007f+\xef\x92Vr\x03\x10\x86\x85\xf0\xfa\xce\xfd\x85\x857߬\xee6\xff\xed\xf9\xa5\xf5\xc9\xdb\xefx\x1b\xc4\x16\xef;\xfd\xd1k\x95iF\x95A\xd2Jn\x00°\x10^\xa7\xf7&}\xf9q\xe0_\xf7Ũ'\xdb\xc5;\xb1kt\xe5\xd4\xe4t\x19#\b\x0fR\x86\x85\xf0\xc6\x1bO\x9d\xf1\x9f\xb7\x15\xde+\x8e\x89\x03\xc6\b\u0083\x94a!\xbcq\x96\xe6\xfc@o\xbcӒ!\xe1\xc35\xdbD\x9eb*6M\xd7V<Q\x9c_u&z\x02\x00\xb1\xb0\x10\x9e\x92\xbc\xf1\x14\x14\xdeR\xb3M\xe4^D\x8bͮ\x1aMLij,s\x9d\x8a\x9a\x00@,,\x84O\xf6Y\x9a\xa0\xf0\x96\x9am\xf2\xbb\xb6\xd0\xcb.cW\xaeM\xee!\xea)-\x8f\x9c\x00\x80\r,\x84O\xf6Y\x9a\xa0\xf0\x96\x9am:)\x0e\xf5\x1c\x12'\xe5P{F\xde\xee\x10\xd7\"&\x00`\x03\v\xe1)\xc5Hc\xa9٦m\xc6\xd9\xf9mr\xa9yЪ\x1f\xc4FL\x00\xc0\x06\x16§\x1ai,5۴hJ{{\xfb\x14Y-L\xda*y\xbbS܈\x98\x00\x80\r,\x84O5\xd2Xj\xb6\xa9x\xb5~\xb3\xaaX>֊o\x11\xf5?莜\x00\x80\r,\x84\xa7D\x91&\xf0N\xeb\xe1~\xb2\xd4l\xf7\xb4\x89\xfa.\xea\xfa\x8dh\xbb%\xcf\xd2T\x1e\xde_\x9e\xff\x91u\x02\x00\xb6\xb0\x10>a\xa49\x11\xfe,M\xb8f{\xffX!\x9a\xa8E\x88\xb1\xfb\x89\x1e\xf4,\xce+\xae\x91=\xf3\xe1\t\x00\xd8\xc2B\xf8d\x91\x06\x80ႅ\xf0\x84o<\x01E\xb0\x10>\xd9Y\x1a\x00\x86\v\x16\xc2#\xd2\x00U\xb0\x10\x9e\x10i\x80\"X\b\x8fH\x03T\xc1BxD\x1a\xa0\n\x16\xc2\x13\"\rP\x04\v\xe1\x11i\x80*X\b\x8fH\x03T\xc1BxB\xa4\x01\x8a\x80\xf0 \xab`!<2<P\x05\v\xe1\x91\xe1\x81*X\bO\x884@\x11\xce\n\xbf\xc7\xd7\xd9\xeb\xeb\xeb\xd3\xff\x1d|\xb3S\xde\xf5Q_o\xaf\xaf7\xd9z\x00\f\x12g\x85?B>y\xa7g\x99M\xb3\xcf!Ҁ\xcc\xe3\xac\xf0\xbeШ\xf3\\x\f@\xc6pVxyb\xe6\xf8\xeeM\x1b\x9e[\xff\xec\xda\xf5ϭ\xdf\xf0zs7\xceՀL\xe2\xb0\xf0z\x8aٺp\xf6c\xb3fUϟ=k\xd6c\xd53.\"\u0600L\xe2\xbc\xf0\x1b\xa6\x1d9\u007f\xf6\xfcM\xba|\xf6\xfc\xf9g\xa7!Ƀ\x8c\xc2@\xf8\x8a\x9b\xfa`\xdfJ\xf9pkŹ\x81^\x94\x9a\x81\xcc\xe1\xbc\xf0/\xcc\xfcP\x1f\xfc莃\xfa\xa3\xe7f\x9eK\xb6\x06\x00C\xc1y\xe17\xcc<\xab\x0f\xee\xbfCޮ7\xc6\x00d\f\xe7\x85_?\xb7{\xf7}\xf7\xde\xfd\xb5\x1f\xdc\xf7\xf3\xbe7ft\x1e\xdc\xe0;\xbe9jV\x8b\xbc\x12\xd3\xc4\xe8+\xa4\xee/h%\x00\xd2\xc3y\xe1\xd7U\x0f\xac\xfd\xc6\xd7\xff\xee\x8eo|\xe3;\xbe\xe6\x19ݻ\xa3K\xcdt\xba\x0ey\xf3\x16\x9d\x8a^\xb7\xd5\xd5\x12\xbd\b\x80$8/\xfc\x86\x8a\x8b\x9dǏ\xdf\xfb\xf5\xed\xc7ߣ\x97f\x9e\xef>Oݗc'\x16\xad\x8e]\x86\x8bb\x83\xb4q^\xf8\x17f\x9c\xd6\a\xf7\xca\f?\xb0~V\xbc\fo'<\x00i\xe3\xbc\xf0\x1bf\xc9\x1d\xfa\xac\xefI\xed7͌wZ\xd2\x14\xde\xff\xca\x14\xd7\xc3\rr\xcf~=W\x88\x9cF\xb9l\xb9\xd0v\xaez\xc0Uy!v%\x00\xa2a |ŗ\xa1\x87\x9b+\xe2\xbd\xf1d\n\xbfT\xab\xdf[\xaf\xd5\xcaa\xbb\xd7;\xdeh\xfe\xf8K\xe38Q\xe0\xf9m\xde\x02\xdb\xf5\x00\x88\x80\x81\xf0\xf3\u05ec\u007fv\xdd\xd6ן{v\xdd\xfa\xf9\x8f\xc4\xfb\x1a\x88!|\x9b\xd1w`\xde\xea\xe4\x06\xfaY\xb5|}\xef^S`\xbb\x1e\x00\x118/\xfc\x9e'\xab\xe7Ξ]QQ1{\xf6\xdc'Wv&\x12\xbe\xd6蚧\ak\xcde!\xe1\x97\xea7\x1e\xcdv=\x00\"pXx\x9d\xde\xce\xcb:_\xf5~\xae\xdfv~\x15o\x96!|y\x951\xae*7\x97\x85\x84\x97\xf7\x10\x1e\xa4\x82\xf3\u0093\xf1!\xe1͏w\xc6\xf9`\xf0\xed\x0f\xe4A\xea\x04c\x0f?\xc9hh\x9d\xb8\xd4|\x06\u0083\xb4q^\xf8\x01\x9f\xaf\xdb\xe7{|\xda\x11_w\x9f\xcf&ϼ\"\xbcDW\x8d\x82ʽB\x9e\x97i\x14{\xcdg <H\x1b\xe7\x857\xe9\xee\x8c\xf7ŏ\x03bNˮ\xf2\t\x9f\xc9qMN]k]N\x8d>\xea\u007f\xc7\xeb\x1d_\xeb\xf5ޠK^\xad\xf6]\xff\x89Z\xcd{)\xce\x16\x00\b\xc1Bx\x1f\xd1\xf6'\xcfR\x9c/\xf9\xb5Lu\xe5W\xbdo\f\xfd\xdb\xca\\e\xc6y\xf8\xa3fՙ\xd8A\xcb\xf5[\xed}\x97~\xbb\xdc~}\x00°\x10\xbe\x97H\x8f4\x84\x8b\x15\x80\x8c\xc3BxJ\x14i\x00\x18FX\b\x8fK\xed\x01U\xb0\x10\x1e\x97\xda\x03\xaa`!<\xe1R{@\x11,\x84G\xa4\x01\xaa`!<\"\rP\x05\v\xe1\t\x91\x06(\x82\x85\xf0\x884@\x15,\x84G\xa4\x01\xaa`!<!\xd2\x00E@x\x90U\xb0\x10\x1e\x19\x1e\xa8\x82\x85\xf0\xc8\xf0@\x15,\x84'D\x1a\xa0\bg\x85G\xa9\x19P\xcc\xff\x0f\x19\x026\x1d6\x9ff\xc5\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/typeinfo-pkg.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x042\x00\x00\x03\xa2\b\x03\x00\x00\x00\xb5\xb6\a\xdf\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x03\x00PLTE!# #$\"$%#&(%()'*,),.,/0.231463685;<:>@=BDAGHF\x00f\x00JLI\x00j\x02\x03l\x04OQN\rp\nSUR\fr\x17VXU,`\xae7]\xad8^\xae\x16w\x1d[]Z8a\xaa:b\xab;b\xac<c\xad`a_=d\xae?e\xaf@f\xb0*{!bdaAg\xb2)}*Bh\xb3Ci\xb4egdEj\xb5higMj\xb0Fm\xb2/\x82/Ol\xb1Ho\xb4Pm\xb2Ip\xb5/\x858Jq\xb6molKr\xb7Ms\xb8Nt\xb9pro=\x87<Ou\xbaXv\xb6tvs@\x8b?Yx\xb8Zy\xb9@\x8dG]{\xbbxzwI\x8dH_}\xbdX\x80\xbf`~\xbeZ\x81\xc1|~{`\x81\xbbb\x80\xc0N\x92Mb\x83\xbdM\x95U\x80\x82\u007fd\x84\xbfW\x95Vf\x86\xc1h\x88\xc2Z\x98Y\x85\x87\x84i\x89\xc3j\x8a\xc4q\x8b\xc1^\x9d]\\\x9dc\x8a\x8c\x89s\x8e\xc3d\x9deu\x8fŎ\x90\x8dw\x91\xc7h\xa1hy\x93\xc9z\x94ʀ\x94Œ\x94\x91z\x97Ɓ\x95Ƃ\x96\xc7q\xa5r\x83\x97Ȗ\x98\x95\x84\x99\xca\u007f\x9cˆ\x9b̀\x9d͙\x9b\x98u\xaaw\x81\x9eΈ\x9d\u0383\xa0ψ\xa0\xcb\u007f\xabz\x9d\x9f\x9c\x8a\xa2̠\xa2\x9f\x8c\xa4\u0380\xb0\x84\x8d\xa5Ў\xa6ѣ\xa5\xa2\x82\xb2\x86\x8f\xa7Ҥ\xa6\xa3\x91\xa9Ԍ\xb4\x89\x98\xabє\xac֩\xab\xa8\x99\xacҚ\xadӍ\xb8\x93\x9b\xafԮ\xb0\xad\x9d\xb1֗\xba\x97\x9f\xb3ؠ\xb4٢\xb5ۛ\xbe\x9b\xb3\xb5\xb2\xa3\xb7ݣ\xbf\x9d\xa9\xb8٢\xc1\xa4\xaa\xbaڸ\xba\xb7\xa5\xbd۬\xbbۭ\xbcܦĨ\xae\xbdݯ\xbfߨǪ\xbd\xbf\xbc\xb1\xc0\xe1\xab\xc3\xe1\xb0Ǭ\xb2\xc1\xe2\xb6\xc1\xdc\xc0¿\xb7\xc2ݸ\xc3\u07b2\xc5\u07b9\xc4߳\xc7\xe0\xba\xc5\xe0\xb2ͷ\xc5\xc7Ļ\xc7\xe2\xbc\xc8\xe3\xb7\xca\xe3\xbbκ\xbe\xca\xe5\xb9\xcc\xe6\xc9\xcb\xc8\xc0\xcb\xe6\xc1\xcc\xe7\xc2\xcd\xe9\xbf\xcf\xe2\xc0ӿ\xbc\xd0\xe9\xcd\xcf\xcc\xc7\xcf\xe4\xc8\xd3\xc1\xc8\xd0\xe6\xca\xd1\xe7\xd1\xd3\xd0\xc8\xd7\xca\xcb\xd3\xe9\xc5\xd5\xe8\xce\xd5\xeb\xcc\xda\xce\xd5\xd7\xd4\xcf\xd7\xec\xd0\xd8\xed\xcb\xda\xee\xd5\xdb\xd0\xd4\xd9\xe9\xd6\xda\xea\xd9\xdb\xd8\xd7\xdb\xeb\xd2\xde\xec\xdc\xde\xda\xd9\xdd\xed\xd6\xe0\xdb\xd4\xe0\xee\xdb\xdf\xef\xde\xe0\xdd\xd5\xe1\xf0\xe0\xe2\xdf\xdd\xe1\xf2\xdf\xe3\xf3\xe3\xe5\xe1\xda\xe6\xf5\xe1\xe5\xf5\xde\xe7\xef\xe5\xe7\xe4\xe6\xe7\xf1\xe0\xe9\xf1\xe7\xe9\xe6\xe1\xea\xf2\xe2\xeb\xf3\xe3\xec\xf4\xe5\xee\xf6\xec\xec\xf7\xeb\xee\xea\xed\xed\xf8\xe7\xef\xf8\xe8\xf0\xf9\xf0\xf0\xfb\xed\xf2\xf5\xf0\xf2\xef\xee\xf3\xf6\xf4\xf2\xf6\xf2\xf4\xf1\xef\xf5\xf7\xf0\xf6\xf8\xf2\xf7\xf9\xf3\xf8\xfb\xf7\xf9\xf6\xf5\xfa\xfd\xfa\xfc\xf8\xfd\xfb\xff\xf7\xfd\xff\xf8\xfe\xff\xf9\xff\xff\xfe\xff\xfc\x8c\xab\xeb\xca\x00\x00 \x00IDATx^\xec\xbd\x0fpT\xd5\xdd\xff\u007fu\x8d\x80\x80\x80\x88r\x02\x99\x8d!\x85\x87\x80~ML%\xa0\x86\xca\x17j\x11\xed\xfc\x8c\xa8\x93<\x0fc\xa4\xa2\x8fm\x9c\xaf\xd16T\xa0\xea\x83X\x91g\x88\x98\x87>t(\x14\n\xa2և\xa1\x8c\xed<\x86\xe1\xa9y\x06\xa4)jU\bJ\xad\x04\x19\x89ЂR\xadB\x88$s~\xf7ܿ\xe7\xde=w\xef\x9eݻٽ\xbb\xef\x97#\xb9{\xf7s\xce\xf9\x9c\xb3{\xde{\xef\xb9w\xf7\xadP\x00\x00H\x18\xc5/\x00\x00\x00l \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t|$\xe3\x18\x00\x00p@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12\xc8H\xc6\a\xbf\xf7\xa8D\x8a\xdf6\xce\xf8?ђ\x8a;\x9ey\xdf/\x12\x00\x90u$.\x19\x9f\xb4\\\xb5Գ\x9a\x84\xd9\u007f\a1\x19\xd7\xe2\x17\f\x00\xc86\x12\x96\x8c\xdf\xcf$$u\xc9\xf8`\x06\xe1X\xe1\x17\x0e\x00\xc82\x12\x96\x8cz\x12\x84d,aJQRS?\xb7\x82mD\xff\xe0\x17\x0f\x00\xc8.\xfaY2&\xab\xb5,\xf8@\xdd8\xfc8ӌF\xbfx\x00@vѿ\x92\xb1\x9f\xe9\xc4\a\xfa\xf6lusF\xfcp\x00@\xb6\x91\xa0d4\x9a\xcb\x0f\xcf/P\xff\xb9Y\xdf\xf9[u\xb3X\x15\x80(!\x15\xc7\xf67M+.\x9b\xfb\xbcY`\u007fӍ\xe3\x8a+\xeb\xff\xcbٚ&\x19F\xcc\U000cd34dKD\xc1\x875-Yqm\xb4\xa2\x9e\xe9T\x9d\xbe\xf7\xad\xd1\xea\xf6[q\xa3?9\x06\x00H3Ғ\xc1tb\xf4~kg\xfd1]2~;Y\u007f\xbe\xfe\xb0\xf6ԆqF|\xeda\xbe\xb5O\xd8\x12Fq\xa3\xebb\xad+X\x13\x81\xc7\xd8\xe3\x9a\xff\"\xba(\xa9,e\x8f\xe3G\x1f\x03\x00\xa4\x1bi\xc98VE\xccK\x1d\x15D?dP%c\xc2D3\xe0^\xf6\xcc\xf3\xa3͇\xa4\xc6\xf1ٿT\xdfY1\xff\xb9\xb7\xac}\xee`&\x02\x13\xb4}\xab>\xb9V\xfdW\xbf\x16{\x83\xba\xb5&~\xf41\x00@\xbaIP2\xfe\xf0\xfc\xadꤼ\xf7\xf9\xe7\xf7k\xb3^;3\xf9ou\xe3*\xf6I\x1fe\x13\xb6l\xe9\xf3͕lC=a\xf8\xa0L\xfd\xfb\x9du\xbf}z\x82\xfa\xb7\x99o\xee\xf0\xcdք\xbf\xf1\x19\xfd\xf0!&\xf8\xb0\xf6t\xd1w\xa6\x16\uedcf-~ϔ\xe1\xb0O4\x00 \xdd$(\x19\xdc\xf2'[T\x18͎\x11\x9a\x88qɃI\xc6D\xb6g?ӌ\xdac\xc7V0E`b\xf2[5v\x9a\xa3\xbd\x0f\xe6[\x9aA*\xb4刘`M\x04Jԓ\x97\x9dj\x8dEFc\xec0\xe7\xff\xf9E\x03\x00ҍ\xbcd\x1c\xab!\xfa\x99\t;i\xd0V%\xa2\xd6S-\xeaV\xe9'Z\x84~\x9a\xf0\x1du\xeb\x0f\x8e\x06\x8f\xfd\xfe_\xad\x93\x98\xe8o\x8d\xea\x1c\xc1\x9a\b\xfc\xab\x11]\xabn?\xad\xee\x9bl4\x16?\x1a\x00\x90f\x92\x90\x8c_\xa8[\xb3\xf5S\x85\x1b\xb4\x1dL2\xfe[\xdbz\x8b\xcd߷\x8e1M\xa8kdLS\xb7~\xe1n\xf3\x93\xff^ZS\xa2iƵ\x9f\x1c\x8b\r\xd6D\xc0,\xf4<\xd1.\xc5\x1a\u007f\xfc\xa2\x01\x00i&\t\xc98<AӅ&kG\x94\x18\x97?\xf5\xf9\xfb{}y\xc1Bx[\xf8\xe1uS\xd9s\xffu,6X\xdb\xf3\xdff\x1c[c\xfdñ\xf9F=>\xd1\x00\x804\x93\x84d\x1c\xfbWm\xb2N3V\x19t\xc9\xf8\x83\xb6\xa5\xcdߝ\xaey\xcd\xdd\x00\xf6\x8b\xa5\x8d\xf5\xe6\xad\x1b\xfbK\xb4jb\x83\xb5=\u007f0\x8b\xb0[̗\x1c.1.\xb6\xfaE\x03\x00\xd2K2\x92\xc1.\x95\xdc\xfc\ab\xdd\t\xc1$C\x17\x02\xe3Ą\x89\x81\xeb&.\x1dv\xc7g\xbd\xf9\x80]6m:\x16\x1b|X\xafĀ\xad\xb6\xde\xf0\xbcU\xce'\x1a\x00\x90^\x92\x91\fv\x80Aء\x86\xf1\xedu&\x19\xffO\xdbb˟e\xfa\xca\xe4O\xb5\x1d\xff\xe5\x9c\xcc\xecd\xc6\xfc.\xda[\xac\xd8\nA\xb0K\x04\u0602\xe7͖P\xf8E\x03\x00\xd2J\u00921_?&\xd00n\xc8*1\xee\xecds?ʖ\x13>\x98\xaa\x1f\r\xb0\xaf\x9cMf\xe7\x11\xea\xf1H\xe9\xcd\xdc\xfd\x12\xecЄThG$\xbfg\a\x19d\xa7 X\x13\x01\xbb\xd0/\xf4\xc6*\xf5[\xc2\xfc\xa2\x01\x00i%a\xc9`G\x15\x13\x97\xfc+\xbb,z\xec\xadBm\x16\xcf7\x9e\xd2n\xe5*nZ\xb7\x82\xdd\x18J~k,S\xccx\xfe\xad\xe7\xd9ڥ\xe3>\xeez\xad`\xf9\xcds\xa7j\x1bs\x8f\t\x82]\"p\xb8L\v}\\\u007f\xe4\x17\r\x00H+\tKF\xb36q\x8d{9\xe7j\xdb\xe6\x9a\x02\x93\f\xfd\xa2)1\xceP\x9e#\x16\xe3\xfe\xc07\xf7\xfe\r\x84\xa3j\xbf(\xd8-\x02?d\x8fG\x9b\xe7\x1e~\xd1\x00\x80t\x92\xb0d\xbc\xaf߀\xa5\x9f\x9bh'\v\xe5\xe6\xb7G\xb4\xe5\xcf*}\x1a/\xd0OV\x9aM\t\xf9?\xbfu\xb6\xb7\xbfΞ\xf2s\r\x19p\x05\xbbE@;\x9b\x99k=\xf4\x89\x06\x00\xa4\x93\x84%\xe3\xd8\x1f\xea'G'\x1b\xdfng\x17=\xc9\x0f\xcdg\xb4\x8b\xac\x1f4M\x8dr_~\u007fkɌ\xb2\xa2\t7/\xfd\xe0\x98\x9b\xdf7~gr\xb4\xb8\xe2;?\xb4\xc5\xc4\x19\x1c#\x02\xec\xeb-\xeb\xec\x87>\xd1\x00\x804\x92\xb8d\xf0\xecd\xf3\xd4\xfa\n\xbb}_\x06\x00 \xc7IJ2>ak\x19\xf6\xd7\xcd \x19\x00\xe4\r\xf2\x92\xf1\x8b_<\xc7n\x95\xe0\xee\x03\x87d\x00\x907\xc8KF\xad\xbe\xf8Xa\xff\xdc\x16$\x03\x80\xbcA^2\xfeUS\x8cq\xdc7\xc1 \x19\x00\xe4\r\xf2\x92\xd129Z<\xad\x81\xbfE\x1b\x92\x01@\xde /\x19\x00\x80<\x06\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\xc0G2\x00\x00\x80\a\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90 e\xc9\xf8\xfcD\x17\x00 oHQ2\xbe\xf4\xab\x1f\x00\x90S\xa4&\x19P\f\x00\xf2\x8c\xd4$ïv\x00@\x8e\x91\x92d|\xeeW;\x00 \xc7HI2\xb0\xf2\t@\xbe\x91\x92d\xf8U\x0e\x00\xc85 \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\t\xd0\xe9\x17\x00@\xde\x00\xc9\xf0c\xef\x94A\xcax\xbf \x00\xf2\x05H\x86\x1fC\x87>\xbcr\xb7_\x10\x00\xf9BVH\xc6\xf6\xb1\x03\a\x8cZ}\xf1Z\xbf\xb8L\xb0]Y\xe9\x17\x02@\x1e\x11\xb0d\xac\xde\x14\xbbϗM\x91+\x9e\\<^Q\x9e\xf0\v\x94F&\x1d\x8f\xd8MJV*\x19\x00\x19\"`\xc9\x189)v\x9f/c/g\xffNI\x83dȤ\xe3\x11\v\xc9\x00\x80'`\xc9\x18.1G-\x86\xdc\xc6\xfeݮ<\xe9\x17(\x8dL:\x1e\xb1\x90\f\x00x\x82\x94\x8c\xe5\x8a\xcep}\xf3\xb6\xaey\xea\xbfOLWο\xff\xba\xc1\x03\xafxU\x8bytd\xc1\xd0Y\x1d\xcer\x93.ڮ\x15\xef\xe0\x03^:_\xad\xe1\xd5+\x87\x14\x8c\xed|B\xadf\x9e^\x998\xc0Q\xdbڱ\x83#\x03\xc7\x0ev\xa4\xc3\xc5NW\xce[\xdc\xf5ZD\x19\xaa\x05\xbf6~`d\xd0\xd8\xdd|\xac\x8bՐ\f\x008\x82\x94\x8c\x8e\xb5\xab\x87\x8eZ\xbdz\xf5\xabls\xf0u{\xbb\xf6\xde5`m\xc7\xf6\xc5\xe7+\x83\xe7\xcd\x1b\\\xc0ta\xcayӗ\xdf?p\xb8s\x92\xef\x1e|\xde\xd8yk\xf5}V\xc0_\x9eX<x腃g]\xa9\xec\xeeX;\xe06\xa32q\x00_\xd9&eʓ+\x1f\x1e\xa8t\xf2\xe9p\xb1\xbbWG\xeeRueJ\x84\x05\xaf.\x18~\xcfʻ\x94{\xf8X\x9eν\xabG\x0ep\t\x1c\x00yM\x90\x92\xd1\xc5\x1f\xdd\xdf\xc5>\xb0\xa7La\x9b\x91!\xea\xac\xeb\x18<\x92}\xf0?\xda\xc5f\xf5bg\xa9\x8ey##\xca\x00v\b\xe1\b\x18\xae\\\xce\n\xb2zX\xb5WN\xf1\x0e\xb0yp Ӟ\xfb\ah\x0f\xb8\x93\r;\x96IF\xd7]L2\xfe2\x98\x1d\xa1t>\xd1ኵ\x18\xaf\x1ex,\x8f\xdd\r@\xfe\x926\xc9حl\xef\xea\xbcP\xbb@\x19\xd1\xd6*\xeeW:\xba&\r\xe9d\f\x9e\x12S\xb0s\xe5X69\x1d\x01\xc3#\xe6\xf1\xc3ꂎ\xae?\x17\xac\xee\xf2\f\xb0\xd9}ѐ\xe9\x0f\xbfdܰ\xc9K\x86\x15kK\xc6r\xe5%\xbb\xa0H2v\xaf|p\xe8@\x1ce\x00`\x936\xc9\xe8\x1a;\xabk\xe5\x00m\xe6js\xb4k\xb5\xb2I\xfd\xa8\xd7q\xdeM\xb9I\x9f\xcc#\xaf\xe8r\x06\f\xb7V\x16:\a>ٵ\\;|\xf0\b\xe0\xe8xp\xd2Pe\xd0=\xda6/\x19V\xac-\x19\xf7+\u007f\xb1\xcby,\u007f\xb2\xb4\x01\x00&鐌\x875\tP\xa7\xb8~^\xd2\x15\x99\xc5\xfe}X=ʸr\xc8&\x8dw\x1d\x85.\x9a\xae\xfd\xb9mH\x973`\xb8\xad,\xd3\xc7w\x8dע\xbc\x02,6\xcdQ\xff\xe9X\\\xf0\xa0\x16`\xa7c\xc7j\x92q\x1b\x93\x8c\x951G\x19\x0f\xc7\x1c\xb6\xe0\x8a\t\x00<\x01KƨQ]]{\xf5\x1b,:\a.\x1f\xb8Z\xdb\x19\x19\xc4V\x11\x86\x8cbsT{\xea\xb6y\x8eB\x03\a\xeb\x8b\t\xe3]\x01\xdc\xe7\xfe\xda\xc8\xee\x886u\xbd\x02,\xee\xd2\xef\xd6\x1cu\x9d\xf6\xaf\x9d\x8e\x1d[\xa0\x8aJ\xe7H&\x19\x1d\x17\x8dbG.\xd3g\xb9by \x19\x00\xf0\x04,\x19wE\xeeY~y\x81\xfeQ=g\x88~^\xd2\x15Q\x86?\xf1\xf0\x90\x01\xaf\xb1}ʤ'\x96Oq-\u007f\x0eT.\xbak哗\x17\xbc\xca\at\xea\xd70^3b.\x1a{\x91\xbe\xe1\x15`r\x97Rp\xd7\xf2'\xa7(\x9aZ\x99\xe98bG\r\x9c7o\xa4r\xfe\xa3\xdbճ\x8e\v.~p\xf9t\xe5a>\xd6\x05$\x03\x00\x9e\x80%\xa3s\xfa\xc0\x82Q\xc6\xc9\xff\xab\xcau\xfaFd֔\x01\x17]\xa9Oƕ\x97\x0f\x1c0\xca\xf5\xad\x8d\x91\x0f\xdf6\xb4\xc0\xbcq\xc3\fx\xe9<m\xcdb\xac\x11s\u007f\xe4\x1ec\xcb#\xc0\xe4\xd1Q\xf3\x06G.\x1a\xa5\x1fߘ\xe98b_\x1dUp\xe1\xd8\xdb\x14\x85\x9d\xe8\xbc:i\xf0\x85#\x9ftĺ\xd8{\xfe\xa4\x97\xf6\xe2\xdb\xef\x00\x18\x04,\x19<\x1d\x11}\xde\x1a˟ae\xf9P\xf7r-\x00yL\x1a%㉁Ƈs\xb8%C=\xd0xi\xaf_\b\x00\xf9B\xba$c\xde\xea\xae\xcbM\xa5\b\xbbd\x00\x00,\xd2$\x19\u007fV\x86O\xbfH\xbf\aj\xf7\xea\xc8\x14\xac \x02\x90#\xa4I2\xba\xee*\xb8\xdc\xf8\xbe\xc6tEQ\"\xee\xeb\x1a\x00\x80p\x92.\xc9\x00\x00\xe4$\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x99\x96\x8c;\xef\x14m\x02\x00\xb2\x94\fK\xc6\xff\x0e\xfb\x9e`3E~y\xd9\u007f\xfa\x85X\xbc\xf7ϗ\x8d\xf8\xbf\xfa\xd7\xe7\xccbw\x0e\x1b6\xec\x92\xd7\xe3\x94\xf1\xe6\xf5\x11\xc3\xfe\xc9/&3\b3\x13t\x9e\xc35\x0e\xd9\xdb7ЯdX2n\x1f\xf1'\xc1f\xa2\xfc\xeaw\xc2\xdd?\xbf\xe4Y\xe1~\x11ߺ\xec\xa9;/yO\xdb4\x8b\xfdq˖\xa7\x86m1\x9e\xf7h\u008b\xdf\xdc9\xc2/$\xbdx\xe6+\xcaL\xd0y\x0e\xc78teA\xdf@V\x90Y\xc9x}\xd8݂̈́\xb9\xfa\xbb~\x11~\xbc7\xecߺ\xba\xb8\xdf\f6\xf8\x8d5Ud\x9bx$\xc3\xd3\xca;\xdf\xd8\xcc<:\xcf\xf1\x1b^22\xde7\x90\x15dV2\ued0f,\xee\x94?Ȑ\x9eϱ\xbc>Lx\x0e\x93\x1f\x92\xe1\xd1y\x0eH\x06\x88!\xa3\x92\xf1\xfa\x88\xbb\x05\x9b\xf6\xd3\u07fdl\xc4e\xffWS\x92\xa7\xae\xbe\xe4\xea\xa7Կ\xff2l\xc4Sw\u007f\xe3\x92o\xfd\xb1\xab\xeb?\x87\xe9\\\xad\xee\xee\xf8\xee\x98\x11c\xbe\xad\x1d\x93\xbfw\x89\xbaO;\xc8\xe6b\xbb\xba\xb6|k\x8cZ\xd7\x18G\xfd\x9d\x97\xe95\xdc\xed(\xc60\xa6\n\xdfDW׳\xd7_\xf2\x8d\xef\xa9\x1fʿ\x1b1l\xd8\x0f^\xbf}̈our{\xbb\xba\xfet\xfb\x98K\xbf\x1b{\xf0n\xa6\xee,f\xf2/\xacU}\x99\xc0\x91\xafU\xef\xff\xa8ž\xdd5fذK;Հ\u007f\xbbs̥\xdf~ݫ^q\xbe\xe2\xcc<;o\x17\xe3$\x83\xabA4\x92 \x8fȨd\xdc9⏂M\x93_]r\xf5\x8f\u007f\xf9Ȱ\x9fh\xcf\xfe\xe0\xe7?\x18q{W\xd7\xff>;b\xd8e\x8f\xfc\xe4\x12\xf5\xb3\xf4\xcf[\xb6|\xe3\xfa-[\xb6\xbc\xae>\xff\xf3aw\xfe\xea\xd9o\x0f\xfb\r+\xf6\xbb-[F<\xc26\xb8خ\xdf\r\xbb\xfd\xd9_>u\xd90\xe7\x8fx\xfen˳\xc3\x1eٲ\xe5O\x8eb\fc\xaa\xf0Mt\xdd9\xec\xee\x9f\xff\xdbeWwvu>\xfb\xec\x98o\\2\xe6\xeeۇ\xfd\x91\xdb\xdb\xf5\xfa\xa5\xdfx\xea?\xbf5\xcc-\x19V\xea\x8eb\x16\u007f\xd2ZՖ\t\xf8|\xb9\xd6~\xf3\x88گ\u007f\x1f\xf6\xecﴀ1?~d\xcc%\xff\xe3Q\xaf8_\x8f\xcc<:o\x17\xeb\xb2%\x83\xabA<\x92 \u007fȤd\xfcq\xc4?\v6M:ǰ\x8f\xe3\xceg\xdf\xeb\xea\xfa\xe5\xb0_v\xb1\u007f\u007f\xae\xfe;\xe2Ru\xc6\xdd~\x99\x16b\x1d\x85\xff\xe5ٿ\xf0\x0fͷ\xbf\x1d\xfb\xd4e\xec-\xfeԥ].\x1c\xc7\xe61\x92\xd1\xc5\xd5\xf9\xf3a\xff\xae=\xa1}\x18_=\xec[\xba[#\xb7\xf7\xfao\xa89t^횘|\xeav1\x1e\xadU\xfd\x98\xdf\xce\xd7\xd1ڝ\xdf|ȍ\xf5\xd81j\xe1\xf7\xc6|ӻ^Q\xbe\xe2\xccĝw4l\x8d\x03W\x83\xd7H\x82|!\x93\x92\xf1/#^\x17l\x9a\xfc|\x98\xb5\xf8\u007f\xa7~u\xef\x9f؍\x1b#\xd8?\xc6Y\xb5}\xe2\xfe\xdeS\xdf\x1as\xa9q@\xceI\x86\x15\xfb\xc71c\xfe\xe5\xa9\xdfu\xc5|4&.\x19\xdf\x1d\xa39;\x8e\xd1n\x1e\xb9\xda<&\xb2\xf7\xbe7\x8c\x9d%t\xfd\xc051\xf9\xd4\xedb<\xbcdX\xf9:Z\xeb\xbc\xfa\xb2o\x1b\xb1\xdau视\xbd\xe7Y\xaf _\x8f\xccĝw4l\x8e\x03_\x83\xd7H\x82|!\x83\x92\xf1\xa7\x11w\n6-~b\x1f\xfb^\xafϘo\xab\x9f\xae\xfc\f\xb3\xe7\xc7o.\x1b\xf3\xbd\xff\xd8r}\x8cdر\xef=\xf5\xdd\u007f\x1avُ\xbb\\$.\x19W\x1b\xeb\x04\xda㫯\x8e\xd9\xfb;\xbd\x88{\x89\x90O\xdd.\xc6\xc3K\x86\xb5\xe9h\xad\xebY3\x1d=\xc3-\xaa\x98z\xd5+\xc8\xd7#3q\xe7\x9d\r\x1b\xe3\xe0\xa8\xc1c$A\xbe\x90Aɸ{\xd8\xeb\x82M\x8b_qG\x19\xfab\x9b\xf6\xd1\x17#\x19O\xa9\x9f\xb0\xff\xf4Mvb\xf2]o\xc9\xf8\x1d\xfbx~\xef\xd9\x11Ou9IL2X\x13\xb7\x8f\xf9\x9d\xc6{\xd6^\x86\xbd\xd7\xf8$v/\u007f\xf2\xa9\x8b/gh\xad\xfe\xc0%\x19\x8e\xd6\xfet\xd9\x0f\xc6\xe8wO\xe8k\xc4O\r\xeb\xf0\xacW\x90\xafGf\xe2\xce;\x1av\x1de\xdc\x19o$A\xbe\x909\xc9\xf09\xc8\xe8\xfa\xcbe׳Ì\xbb\xeff\xe7(\xec\xd4\xfaY}-\x83\x93\x8c\xeb\xafW˲\xe7ư\x89\xd2y\xb5\xb7d<\xa2\x9d\xfaw]\xef^1\xf1\x95\f\xab\x89_\xea\xa7\xf7?\xd0>^\xad9\xca\xed\xfd&\x9b֯\x8fpML>u\xb1d\\\xa2\xce\xc1\xceo\xba$\x83o\xad\xf3\x9b?\xe8\xbaS\xbf\xcc2\xe22U\x1a\xff<\xe6z\xefzE\xf9\x8a3\x13w\xde\xd1Mk\x1c\xb8\x1a\xbcF\x12\xe4\v\x99\x93\x8c\xef\xd9G\x16\xdc&ǯF\xfc\xd3S?\xbf[\xfb\x80\xbb}\xd8\xf7~\xfe\xbda\xb7k\x17\x18\xee\xfcM\xd7\xef\xee\x1c\xa1\xad\xf4?2\xe2'\xff\xf1\xadK\xfe\xc8\xde\xc7\xdf}\xea\xc7W\xab\x87˿\xe9\xeaܲE\x8dٲ\xa5\xc3\x11\xfbȰK\x1e\xf9\xf9\u007f\xdc9\xecW\x8e\x16\xf4\x8b\x06\xdau\x16\xbb\x98~\xd7\xe3O\xb6l\xd1\xd6\a\xac&\xd4$\xff\xbfg\xd5\x1a\x9e\xed\xea\xfc\x8dv]\xe2u\xad\nko\xd7\xff\\2\xe6\x91\x1f\\:lĿ\xff\x8f\xa3\r+uG1\x8e\xeb/\xfb\xf1\x8f\xbfɊ9\xfaf\xb7\xb6\xe5\x9f/\xfbc\xd7\xeb\x97\u07bdE\x15\x8d\x11î~\xf6\xa9o\\\xfa\xbaw\xbd\x82|=2\x13w\x9e+ƍ\x03W\x83x$A\xfe\x901\xc9\xf8\xd3%\xb7\v6\x1d\xbc\xfe\xdd1\x97|\xf3?\xb4\xcd\u007f3nB\xf8g\xf54{\xc4\xff\xb0\xdb\bا\\\xe7ݗ\x8e\xb8\x9e\xbd\xe9;\u007f\xf2\x8d\x11\x97}\xf7\xa9o\x8c\xb8^=\xef\xd6y\xca\x11\xfb\xec\xf5\x8f\x8c\x19q\xd9\xf5\xce\xf7y\xe7\xa5Z\xa4\xb6\xf2j\x17Ӿ[a\x9d\xce[M\xa8\x1f\xc0\xd7_v\xe9\xf5?\xb7B\x8d\x15Is\xaf\x9a\xee\xb7/\x1d\xf3\xbd\u007f\x1f1\xcc\xf5\xf9k\xa6\xee,f\xf3\xfa\xf5#.\xf9\xd6\x0f\xd4$\x9d}3\xeb\xfd\xe50v\xef\xc4\xdd꿿b˟w^:\xe6\xf6?ũW\x90\xaf83\x8f\xces\xc5\xf8q\xb0k\x10\x8e$\xc8#2&\x19?\x18\xf6\xbf\x82M\x10\x17\xfb\xd4\t\x80\f\x911\xc9\xc0\xb7ޓ\x00\x92\x012N\xc6$\x03$\x01$\x03d\x1cHFx\xd0\xd7G\x01\xc8(\x90\x8c\xf0\xf0\xcf\xe6r%\x00\x99\x03\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90 Pɘ\xa4\f\x9c\xb2]\xd4\n\x00 G\bT2v\xaf~t\xe8\xc0\x0eQ3\x00\x80\xdc P\xc9PY\xad\xbc$\xd8\v\x00\xc8\x11\x82\x96\x8cM\xcaZ\xc1^\x00@\x8e\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x10\xb4dlWV\v\xf6\x02\x00r\x84\xa0%\xa3s\xe0ȵ\xbb\xe1\x8b\x03@\xae\x12\xb4dt\xadT\x14\xe5\n\xd1\x13\x00\x80\x1c h\xc9\xe8\x188\xe4\xfeկ\t\x9e\x00\x00\xe4\x02AK\xc6&e\xa5`/\x00 G\b^2p\xc5\x04\x80\x1c\x06\x92\x01\x00\x90 h\xc9X\v\xc9\x00 \x97\tT2:wo\x9a\x14\xd9-j\x06\x00\x90\x1b\x04*\x19\xe3\x15e\xf0rQ+\x00\x80\x1c!P\xc9\xd8\xfb\x12\x0e1\x00\xc8m\x02\x95\f\x00@\xae\x03\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x90\x92d\x9c\xf0\xab\x1d\x00\x90c\xa4$\x19\x9f\xfb\xd5\x0e\x00\xc81R\x92\f\x9c\x99\x00\x90o\xa4&\x19_\xfaU\x0f\x00\xc8-R\x93\fh\x06\x00yF\x8a\x92A\xe9\xe7X\x03\x05 \x8fHY2\x00\x00\xf9\x04$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 Aʒ\xb1\xf6\xca\xc1\x91\x01\x17߶\xd7/.\xe3t\x9e\xf5\x8b\xf0\xa0S1\xb8`Ȕ\xddlG\x87\xf182\xf8\xcaMVм\xe1\x05\x91\x8bƯu\x95\r\xcd\xe8\x00\x90 )J\xc6\xd9\xf1\xc6\xf49\xff~\xbf\xd0\f\xf3`\xc1\xe7~!\x1e\xa8\x92Q0@\xe5B\xd6\xcf\xd5Ԗ\f\xc6<=\xe6ш\xf1x,\xdfJxF\a\x80DIQ2\xe6(\x05\x0f\xbe\xfby\xe7K\xea\xdcX\xe9\x17\x9bQ\xce*J\n\x92ѡm|\xbd}\xa8\u0084G\x95\x8c\xbd\x9f\xabt\xbd:VQ^e\xcf\xccR\x94\xf1/u}\xb9\xf7\xae\x882\xeak\xbbdhF\a\x80\x84IM2>\x8f(ơ\xf8\x14eH\xfc\xd0\f\x13\x84d\xa8b\x11Q\x9e\xd0$\xa3S\u007f|v\x882E\xfd\xb3ZQ\x16\xeb;^R\x94G\xad\x82\xe1\x19\x1d\x00\x12&5\xc9xM\x89\x18\x1f\xaa{\xadi\x94\x9d\x04#\x19t\xa4r\x1b/\x19\xf4\x1ee\xb0Z\xf7 e\xba\x190\x9d\x13\x87\xf0\x8c\x0e\x00\t\x93\x9ad\xec\xb5g\xd3\xea\xed_\xb2?\x9d\xb3\x86D\x06\x8e\u007f\x89m>\xaa<\xfcҐ\x82\x91s\x94\xf1z\xc4u\xca]\xc2\x00\xb3\x06\xfb!\x17\xb3X\xb9\xe7\xdd\xf1\x03.\x1c\xb9\xdc3\x82vL\x1f\x1c\x190\xeaQ}u\xd3Q\xf4\xfe\x13\xb3\x06G\x86\xdcv\x82\x9d\"0v\xbb\x82\r\xd6N\xba(R0\xf4\xb6.W\x19\x13^2\x86+s\x1c\x92\xf1\x84r\xa1Z^Q\xfeb\x06t\xdc\xff\xaaU0\xd0\xd1\x01 ;HM2\xe8\x10e\xe8Z\xee䝾T\xa0D\x86\x0f\xd1W\x05\x1fU\xe6\\\xa0(\x05\xef*\x11\xed\xf3\xfd\xec\x85\xca^a\x809}\xad\x87|\xccbeRAd\xec\xa8\xf3\x94\xeb\xbc\"\xf6^\xa8\f\x18>TQƺ\xdb_\xac̺H\xb9p\xa0\xa2\f=K\x97OR\x94\xf1Wv:\x83\r\xa6+\xcaE\xc3\a\xa9\xff\x9cp\x961\xe1$c\xb7\xa2,wH\xc6]\xcaPJoc\xff\x88\brt\x00\xc8\x0eR\x94\x8c\xed\x11E\x190\xfe\xd1\xdd\xc6\xc3\xce\v\x959\xea\xc7\xe9\xf6\x01l\xb9\xefQ\xe5\xbc!\xab7=\xa9\x1e\xcck\x87\b\xab\x95\xe1\x1e\x01\x06\xe6CG\xccbE\x19\xf2g\xf5\x18\u007f\x00\xabD\x181^\xb9M\x9d\x96\xbb\a\xb0u\x03wѡ\xdb\xd5c\x80\x88\xf2\xa4ub\xc2\a\x1blR\nا\xfa\xf6\x02\xe5AW\x19\xb3S\x86d\x9c\xed\\>H\x19r\x96\x97\x8c\x13\x83\x94Y\x94^\xa1-h\b\brt\x00\xc8\x0eR\x94\f\xda1V;\xe4\x1f4\x87\x1d֫\xc7\xffWh{W\xb2\xcf\xddG\x15E\xbb\x1f\xe1\t\xfd3\xfdJ\xe5a\x8f\x00\x03\xf3\xa1#f\xb1\xb1s%[#\x10F\fV\xb4)\xf9\xf0\x95kc\x8bjS}:[i0$\x83\x0f6\x98\xa3\x9d\x11\xb0\xbf\xd3]e\f\xac\xfb2T\x86\xb0gU\xc9\xd8}B\xa5c\xe5\xc5J\xe4]\xb6\xc01\x87\x8a\tpt\x00\xc8\x0eR\x95\fuF=q\xa5z \xaf\\\xc8\xeej\x1a\xacݷ\xa0N\xd0\xf3ԙ\xf7\xa8\xb1\x12x\"r\xde\tv\xf9\xe0\xbc.\x8f\x00\x03\xf3\xa1#f\xb12J\u007f\x10Q\xde\x15G\x8cUFn7\x8f\xfe]E/\xd6\x1e<\xacL\xb2$\x83\x0f69\xab\x1f\xfb\xdfÎ\x15\x1ce\f,\xc98\u007f\xd2r-\x94\xbb/\xe3\xbc\xe5Z\xa5^\x92\x11\xe0\xe8\x00\x90\x1d\xa4.\x19\x8c\xbd\xf3\x06(\x05\x9d\xf4sE\xb9x\xa4FD٤\xbe\xe7\x8d\x15\x83I\xec\x12\xe4r\xf6\xc8#@\xc7x\xe8\x8cY\xcc.Q0.V\xcf%\x84\x11\xaf\xb2\xa3\xff+\x97\x9f\x10\x14\xd5?\xb3\x9f`+\x8c\x86dp\xc16g\xb7?9o\xd2`E\x97\f\xae\x8c\x81*\x19\xef~\xfd\xf5\x97\x9b\x86*c\xf5r\xa6d\\x\xf1,\xed8`\x8ar%\x8dG \xa3\x03@v\x90\xa2d|m~dw^\xa4̣]\xf6ǯz6\xfe\xa89\x93ֲ#\x85\xb1\xec\xfc\xdc#@\xc7x\xe8\x8cYl\xde_9\xd2.\xe0\x8c\xa0{\xa7\x14\xa8\x1b\xe7O\xff2\xa6\xa8~\xa4\xc0K\x06\x17l\xf1\xf0 \x16?|\x94.\x19\\\x19\x03s-\xe3\xc4`e\xb8V\xac\xc3u\xc9\xf4\x1e~\xf9\xf3%\xeeZn\x90\xa3\x03@v\x90\x9ad\x8c4\x8e\xa4U橓\xecs\xeer$\xb5\xdf\xf3g\a(\x9d'\xce+\xf8\x92z\x058\x1e:c\xac\xa3\x8c\xa1\xda\a\xaf \x82\xb2Äy\x17+\xcau1E\x05\x92a\a\x9bܣ(ӗ\xbf\xf6\xa5yb\xe2-\x19t\xbb\xa2\xafp\xb8%c7\xf7\xb8C9Ϻ\xca\x1a\xe8\xe8\x00\x90\x1d\xa4&\x19\xe3\xedk\x05\xf3\xd8\xe6@\xf3\xc6\xe8\xed\x1d_s\xef\xf9Y\xca\xe2'\xf4H\x8f\x00\r\xf3\xa1#f\xb1qx\xfeeD\x9d\x96\u0088?o7J\x9f\xff\xb5\xbbh\xacd\xf0\xc1:_\x17\xb0\x1b:)[{\xf4\x93\fvw\a\xbb\xb8\xe2\x96\f:\x98]71C\x06Z\x97E\x03\x1d\x1d\x00\xb2\x83\xd4$c\xb5\xf5\xe5\x89\xceA\xecb\xe1te\xb86\x15\xd7*\x91\x13\xdc{\xfeUe\xecXm\xb2y\x05h\x98\x0f\x1d1\x8b\x95\x886=\x17\xb3\x8b\x90\xa2\b\xf5h^\xbb\x1c\xf1\xaer\xdeYwQ\xa7d\x9c\xd0\x0e\xfd\xed`\x9d.\xe3\xc2\xc4\xe7\x17\xb1\xca\xe3K\xc6\xe7\ue2ec\x06O*\xfa\x95R\xed\xae\xae\a\xad݁\x8e\x0e\x00\xd9Aj\x92\xa1\x9e\x83+\xe3Wwt\xed~p\x90r\xb1:\x99ލ(\xd3\xd5\x0f\xf3W\a\xb2k\b\xdc{~H$2H\x9b\f^\x01\f\xf3\xa1#f\xb1\xa2\fW\xe7\xe7\xda\x02\xf5\xbcD\x1c1V\x19\xab\xca\xc0\xe7\x93\xd8ራ(?\xfd#\xca\xca/\xbfv\x04\xeb|=@\xbb\xdeѩ\xf6\xe4\n?ɠ+\x15\xe5\x1e\x81d\xa8\xc7\x13ʔ\xed\x9f\u007f\xbd\xf76\xc5\xf1\xb5\xb4`Fg\xf9\xc3\xdb)\x00\xd9B\x8a\x92\xf1\xb9\xf9\xf5nmb\xab\x1f\xac\x11傑C\x14\xe5\xf2\xb3\x8eIq\x8fb.Ix\x040\xac\x87|\xccbe\xc8\x05\xe7\xb3\x1b\"\xef\xf1\x8a\xf8\xcb@%r\xf1\xf0\x02ePGLQ~\xfa\x8fTs\xdc\xe4\f\xd6yXQ\x06_1\xf2\xbc\x01w\xb1\xeb\xab>\x92\xa1\x8a@\xa4C \x19g\xa7\x98\xc3p\x05\xffM\x96`Fgx\x9ck\xb8\x00\xf47)J\x06\xa5/\xcd\x1a: r\xd1\x15ˍ\x0f\u05ceYC\"\x05#\x1ff\x87\xfdܤ\xe8P\x14\xf3\x16Hq\x00u<\xe4b\xd49\xbc\xfb\x8a\x82\x81Wl\xf7\x8c\xa0\x9ds\x86D.\x18z\xd7\tAQm\x97>\xfd\xdf\x1du\xc1\x80\x95\xae`\x9dM\x97\x0f\x8c\xa8{>g\xab%~\x92\xd1\x11Q\x8fOb%\x83\xd2\xedӇ^\x10\xb9h\x92\xfb'v\x82\x18\x1dH\x06\xc8&R\x96\x8c4c\xcea\x00@V\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x90\xed\x92\x01\x00\xc8* \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t\x82\x97\x8c\x1a\xf2S\xbf\x10\xc6*\xf2}\xbf\x10\x1f\x8e\xf7\xfaE\x00\x00\x82&\xb4\x92\xd1\xf7\\\xc9i\xbf\x18\x00@ЄV2z\b\x81d\x00\xd0\xef@2\x00\x00\x12@2\x00\x00\x12\xa4$\x19\xbb_\xb3\xd8m\xed\xd4%c\x1dY\xf5\xd7\xc6\xf2\xe2\x99\xdbhߺ\x19ъ\xa6\xd3ھ\x15\x87\xea'\x96\xde\xfa\xeb>jI\xc6\xf1\xa6\xaahY\xdd.\xeaQ\xc4\x15\xd0|\xaa\xa9\"Z\xb5\xe4\x14\xa5\x8b\b\xe3 \xa5G\x1a*\xa3\x13k\xd6`)\x14\x80~!%ɸM\xb1\x98n\xed4%\xa3q2)\x8f\x12\xb2\xad\x81\x14\x97\x13R\xa3\xed\xab/\x8d\xd6\xd6\x14\x92\x86>S2v\x8d#\xc53\xab\bY\xe6Q\xc4\x15\xd0TAJ\xcb\b\xa9\ue85b\xe7\x13R?\xff8\xfd\xb0\x94\x94\xddTM\xc8\x1d}\x82\xfc\x00\x00A\x93\x92dtEL\xc58\xaf\xc3\xdaiJ\x06\xa9\xfe\x90\xf6\xce'\xc5\xc5/\xf4\xd1W\bٯ\xed\x9b\xf61\xa5\xfb\xcb\xc8FC2\x8e\x97\x92Eݔ\xee)#\xdb\xc4Eb\x02ޤ\xb45J6X'&\xf5d\x89z\x80q`\x02i\xf5J\x12\x00\x10 )I\x86}\x98q\x9d\xbdϒ\x8cC\xea\x9f\x0f\tif;oa\xb3|\x9dv&A\xe9ˤʐ\x8cE\xa4\x8e\xea{\xaa\xc5E\xdc\x01\x1f\xb1\a\x8d\xa4ђ\x8ck\xf5*\xd7ܻ\x93\x02\x00\xd2Oj\x92a\x1efp\a\x19\x96dLc\x0f\xba\t\xf9\x80\xfd\x9dOZ\xd8>\xed\\\x83\xf6\x16\xabڠIF%yE\xdb\xd3SH\x8e\n\x8b\xb8\x02n\xd4\x1e\xb4\x90zK2\xee 5o\x9e\xa3\x00\x80~\"5ɠsb\x0e2,ɨe\x0f\xce\x11r\x92\xfd\xbdO\x97\x8cEz\xc8\f\xb2S\x93\fU\x1dfܪ\x11%m\xa2\"\xee\x00\xfd\x90c\x03'\x19oF\t\x990\u007f\xf3\xdf)\x00\xa0?HQ2\xf4\xc3\f\xfe Ò\x8cz\xf6@\x9d\xff\x9f\xb1\xbf\x86d<c\x86\xbc\xacIƧ\xc4f\x9b\xa8\x880@\x95\x8c:\xfb\"\xeb\x87\vJ\xd4'\x8b\x1a\xbb)\x00 \xfd\xa4(\x19\xfaa\x06\u007f\x90\x11W2\x1e\xd3C\xaa\xd5C\x06&\x19\xa7\t9b\x17\x14\x14\x11\x068%C=\xcfi\u007fz&!\r\x14\x00\x90~R\x95\fv\x98\xe18Ȉ+\x19ڙ\a펒\xe3\xfaZ\xc6U\xecB\bc\xcf\xc7\xe7\x84ED\x01\xbcd\xf4}\xfc\x86\xb6k\r)\u008a\x06\x00\xfd@\xaa\x92\xc1\x0e3\xa68vē\x8c\xe8q\xaa=w\x93qŤ\x91ܤ\xddO\xb1\x93\x14\x9f\x12\x16\x11\x05\xe8\x92\xd1K\xc8?(=IFk\xc1\x87H!n\xe6\x02\xa0\x1fHY2:#\x8a\xe3 #\xaed\x90\x9bT\xcd\xd8Y\xa2\x9e\x97\xe8\x92q\xa8\x98<t\x86ҷ\xcbH\x93\xb8\x88(@\x97\f\x1a%ۺ\xcf\xd1;\xc8\x1dj\xf4\xe9\xf9\xc6\x01\f\x00 \xbd\xa4,\x19t\x8e\xf3 #\xaedL-.\xbai*!+\xa8y\xf7gk\x94\x14ϞF\xc8\xdc\x1eq\x11Q\x80!\x19\xb3\tQ\xa5\xe7X\x19\x89\xde8\xb3\x84\x94\x1f\xa5\x00\x80\xf4\x93\xbadt:\x0f2\xe2JF\xfd\xc1\xbaҲ\xba=l\x8f\xf1\x1d\x93#?\xaa\x8a\x96\xccn\xe9\xf5(\"\n0$\xe3PM\xf1ė\xd9wP\xa6E\x8b\xab\x97\xe2*+\x00\xfdB꒑8\xe6\x94\a\x00\x84\x16H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x82\xfe\x94\f\x00@\xe8\x81d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80dP\xfa\x842\xde/D\xe5Ae\x8a_\x88\x0f\x9dg\xfd\"L\xd0Y\xe9\x00\x00 \x00IDAT\x00\xc8z \x19\xfd&\x19\x0f\x16|\xee\x17\x02@\xd6\x03ɠt\xf7\x83\xab\xfdBh\xea\x92qVQ \x19 \xfc@2\x12\x05\x92\x01\x00\x85d$N\xe6%\xa3\xa9\xc9/\x02\x80\xb4\x13f\xc9\xd8;~Ѐ\xb1ۇo\xf7\x8b\xf3C[\xcbX\xac<\xd89}\xd0\x05\xc3W\xaa\x9b\x17G\x06\xcdb\xd3{\xb1rϻ\xe3\a\\8r9\x8b2$\xa3s\u0590\xc8\xc0\xf1/Q*.\xe2\n\xb8\xffĬ\xc1\x91!\xb7\x9d\xa0t\x8e\xc2\xd8Mi\xc7\xf4\xc1\x91\x01\xa3\x1e\x95_\n=B\x96х\xa4p\x9b_\x9c\x80\x17\b!ʹY\xfdws\x9c\xa8\xe3Q2C\xfdӨ\x86\x8d;\x1a'\x0e\xe45!\x96\x8cݑI\xabW^\xa9(+\xfd\x02\xfd0$c\xfa@ePD\xad\xee:\xe5\x82A\x8a2\x8a\xb2}\x93\n\"cG\x9d\xa7\\GM\xc9x\xa9@\x89\f\x1f\xa2(\U000e8e08+`\xd6Eʅ\x03\x15e\xe8Y\xba|\x92\xa2\x8c\xbf\xb2\x93\xee\xbdP\x190|\xa8\xa2\x8c\x8d\x93\x90\xc1\x9e\x03\x8e\x87\rŧ\xe8\xc9\xf6h\xb30\xc0\x15\xeb\xe2̋\xe4\xb9S\xf4T\vy\xf1L\x9c\xa8\xbew\x1a\xa3ꟿ\xb5\xb7\xaf'olj\x03yM\b%\xe3\xc4\xd8\x13\xda\xdf+\xb4Y7=0\xc9P\x86\xee\xa5g\xafT\"\x17,\xff\x9a\xaeV\x94״}C\xfeL\xe9k\x03\x94\xe5\x86dt^\xa8\xcc\xf9\x92\xd2\xed\x03X\xab\xa2\"1\x01\xea1\xd0ڈ\xf2\xa4ub2^\xb9\xedkU\xee\x06(k\xfdҢ5\x0f\xf0\x8f\x8e\x8e~\x8c\xfd\xe1%\x83\vp\xc6\xc6p\x88\xb4\xa9\xff\xee!\x87\xe2F\xd1\xe6\xa8\xfew\x1f$\x03x\x11B\xc9ث\xec\xd5\xfe\x0e\x99\xa7?J\xe4rG\\L\xc9`\xd5\xeeU\x94{ؾ\x91l\x96\x1b\xfb\xe8Je\x88!\x19s\x94+\xa8\xbeg\xa8\xb8\x88;\xa0\x83=\x98\xaeL\xb7$c0;9\xa1\xf4\xe1+\xfd%\xe3\xd6\xfb\xf8G\x0fE?c\u007fx\xc9\xe0\x02\x9c\xb11@2@P\x84M2\x16\x0f]ۡt\xac\x1d\xfa\x04\xa5S\x06k\xf3y\xed\x97\xec\xdf\xe5\xa3\n.\xbeK\xdd\xda}\xbezN\xd0qݐ\x82\xf1_\xafT\x14\xe5~z\xbf\xa2\x9f\xba\b\x02\xcc:\r\xc9\x18¶\xbfT\xf4)}\xa5\xf20ۧ\x9dkг\x11\xe5]]2\x06\x1b\x02u\xf6<U\fDE\\\x01\x17k\x0f\x1eV&Y\x921V\x19\xb9\xddjYc!\x89n|\xec\xc6qu\u007fc\x0f\xfa~]Sz\xe3\xe3=\x94\xee :\xb7\x18QNj\x16i\u007f\xa3K\x8dX.\x80\xdb\\H\x8a\xd65UN\xaew\xadEp\x92q\xe6\xbe\xcahU\xfdAw\xc3'\x1b*\xcb\x16h'&\x94\x93\f+\x9d\x83E\x84<s\xb4aZI\xdd9\n\xf2\x9a\xb0IF\xd7u\xcap\xf5\xbf)]\xea9\xc0\x90\xf3\xc6\xdf\xff\xaa>\xfdf\x9d7g\xed\xe2A#\xbf\xa6gW\xae\x1c2t\xc0\x90ۮS:\xbf\xdc>\xe0\x9e\x13\xf4\xc4=\x03\xb6\u007f)\x0e0\xeb4$C;\xcf\xf9ZQ\xba\xd8\xdf)\xbadܦG\\\xac\x9eF0\xc9\xf8\\Q.\x1e\xa9\x11Q6\x89\x8a\xb8\x03\xae\xb0\x1b0$\xe3Ո\xa2\f\xb8r\xf9\t\xabG\xf4\xa3\xadE\xa4\xa2\xf9g\x13\xefe\x0f~X\xb8h纊[\xfbh\xf7\x9b\xed\xd5w\xb4\xb7\xb7\x1f1\xa2\x9a\xa2\xda̦Q2ck\xeb5j,\x17\xc0m\xb2ʦ\xaej\x9e:\xeeC\xcas\x88\xec\xec\xe9\xe9ic\x92\xb1\x834\xed\xd9V_\xb8\xcf\xd9\xf0щ7\xbe\xd0ZG\xa2z\xb8%\x19V:=۶N\xad\x9eP\xf5X\xc3\xe8\xbfR\x90ׄM2(\xdd\x14Q\"\x9b\xb4\xad\xcf\xef\x1f\x15Q\x06\xb2C\x88\xb5l\xb1\x81\xbe\xa6/k\x8cT\xaeP\xe7&\x9b\x9e\xb3\u0602\xe5u\xb3\xbc\x03t\fɘĶ]\x921O\x8f\x18\xa9\x16d\x92ѥج\x14\x15\x11\x068$\x83\xee\x9dR\xa0>y\xfe\xf4/\xad\xf6i\xb4L\x95\x83\x86\n\xca\xe6\xf3\x8b\x94\xcdحl7\u007f\xb2q<\xbaЈ\xad\xf8\x87:\x93+\xa8+\xc0ތN;C\xe9\xe9\xaa\x1a\xcas\xc88\x0eQ%\xa3g[\xb7z\xf4p\xd3|-\xd6jxn\xb5z(\xd17;\xaa\x87\x9b\x92\xe1L\x87Ԟ\xa1}\xf1\xd6OA>\x106\xc9\xf8\xfc\xb6\xc8`ep\xe4.\xe3S\xfa\xecK\xe3\xd9:┡_3\x06Og\xfbFF\xcc\xe3\x87\xed\x05_ҳ\x05\xec\"\xacG\x80N\x1c\xc90\x8e2\x86\xaa\x87\f\xc6QF\x87]NPD\x18\xe0\x94\fuk\xfb\xbc\x8b\x15\xed*\x8cA\xf4!j\xac#<pC\xef9\x95k\x1b\xd9n^2\x16F\x8f\x1b\xb1M\xd4Zs\x10K\xc62\xf6\xefz\xf2\x15\xe58D~\xb6o\u07fe5\xdaZ\xc6\x17\xeb\xebn\x98Hfk\xb1fç\xc9F\xf6\xf8\x99\xa8\x1enJ\x863\x9d(\x0e0@\xf8$\xe3\xe1AO\xbe\xabt,\x1e\xf4\xa0z̠MTz\xf9$v\x14\xa0s%\xdb1r\xa4\x19\xfc\xf5\xa0\xd5t\xed v\xea\xe2\x11\xa0\x13G2\xf4K\xa1_FԳ\x18m-c\xa0y}f{\xc7\xd7\xc2\"\xa2\x00\x87d\xfcY\xbf\x8d\xe4Q\xe5|{EC[\xd2\xd4d`\xb6q4\xa0\x1d\x03p\x8ap2\xfa\xa3\x98X/\xc9\xd0\xd6Gۉ\xe3\xaa+\xb7\x96\xb1\xaf\xa2jik{\xedl+\x96Uv\x80\xb4S\x1a\xbb\xfc\xe9L\xc7y\xe0\x02\xf2\x94\xb0I\x06\xfdZ\xbbb¦\xdbEs\xb4\x1d\xf3\x86\xaa'\x1fCwkh\xc7\x1e#\xed\xbb4\xe7\\I\xafԢ\xbc\x024\xe2H\x86~<\xb2X\x19n\\1\x99\xae\f\xd7f\xfaZ%rBXD\x14`I\x86\xdaz\x97\x11\xfc\xaer\x9e}3\x97-\x03\r7\x1c\xd0\xf8\x82\xed\xd6d`\xb3\xf6Ѿ\xa4\xf0XL\xac#\xc0ތ.a\x8f7\x12\xc7\x19\x04'\x193j\xd4S\x10\xba\xc0)\x19\xff \xeb\xd9\xe3\x87\xf4z-\xc9p\xa6\xb3\x80\x02\x10>\xc9Pg\xdd@\xfd\xf0b\xd0`\xed@\x9f\t\xc0&\xfd\xb3}ރ\xe6\x0e\x83W#]\x91WنW\x80F\x1c\xc9P\x86\xab\x9a\xb1\xb6@=/\xd1%\xe3݈2]m\xf5Ձ\xca\x1cq\x11Q\x80\xf1Uو\xb2\xf2˯\xe9Xe\xac\x1a\xfd\xf9$\xfe^.[\x06ڈvs\xe7O\x9fc\xff\xd6\xd6RzJ\xdb\xf1Y\xf1C\xb1\xb1|\x00\xb7\x19\xbd\xa6\x9b\xd2\xee\x1bj\xb5\x88\xe3\xcf\xe9R\xc3IF\x15\x9b\xf9}7;%\x83\xd6T\xa9'2\x1f\x17\xeb\xf5Z\x92\xe1H\xc7\xe7:.\xc8\x13B(\x19&\x83\x94\x8b\xeeٴ\xfa\x8a\x02\xb6x0O\x99\xb2z-\xbb\xab\xeb\xebW\xb7\x0f\x1d\xbb}\xbb\xb9X1\xf8\x8a\xc1\xfa\x86W\x00#\x8ed\f\xb9\xe0|v+'\xbb\xefB\xbf\xfbsuD\xb9`\xa4\xba\xe7\xf2\xb3\xe2\"\xa2\x00C2\xd8\xc9\xd1&\xfa\x97\x81J\xe4\xe2\xe1\x05\xca k\xcd\xe3\xb3\xf6h\xe3;}\xef7F\xdb?\xa3t\xd9\xe8\xef\xbf\xd2\xdaH^fO4G״֖~\xaan=>\xfa\xa8 \x96\v\xe06\xa3\xe4\x96m\x9b\xab\xcb>\xd6\xe2\xe7\x93z\xf6\x87\xbf\xfb\xb3\x99ܷ~խ\xa4\xbc\xe5\x1d\xbe\xb2\x0f\xc7U5?3\xb9\xb0\xe8\xc5C\xf4Sv\xf7\xe7\xba\xf6vv\xc8b\xa5s\xee-\xed\xa2\xccq\n\xf2\x9d\x10Kƨ\xe5\xf3..\x184I\x9fz\x9b\xc6\x0e\x1cx\xb9z,\xb0\xfb<m\xcdb\xbc\x11\xb38\xf2\xa8\xb1\xe5\x11\xc0\x88#\x19\x93v_Q0\xf0\nm\xf9\xc1\xf8\x8eIǬ!\x91\x82\x91\x0f\xb3\xb3\n\xa1d\b\x02\f\xc9xw\xd4\x05\x03\xd4c\x9d\xce9C\"\x17\f\xbd˾ʺ\x90\x10\x12=\\\xaa\xfe\xcb.\x8a\xb4\xd5^U6\xb7M{\xa2w\xd1\xe4\x92;\xf6\xa9\x1b\u007f/i\x10\xc6Z\x01\xfcf\xf4\xf1Ɖ\x95\r\x9f\xe9\xf1/Tl\xd0\xfe\x10\xf3;&\x1biߚ\xeah\xc5\x03/TGk\x1d\x95\x1d\xad\x9f<m\xe9\x8bE\xea\xe6C\xc6\x02\x86v?\xa9\x99\xce\xc1Bm_=\x05\xf9N\x88%#\xfd\x98S>\xd3<M\x8eЄ\xe1o\x0f\x05 p \x19q\xc8\x16\xc9\xf8\x91̷\xde!\x19 \xad@2\xe2\x90-\x92!\x05$\x03\xa4\x15HF\x1cB(\x19'\xb5%M\xbf(\x00\x92\x06\x92\x11\x87\x10J\x86\xb6\xa4\x89\xeb\x1a }@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12\x04.\x19\xfb\b![\xcd\a\xa7\xa3\x84\x1c\x8a\t9ޫ\xfe\xb3\x8e\xd4\xc7<ᤙ4\xfaDhh\xb5\x01\x00\xfa\x87\xb4H\xc6|\xf3\xc1\xafI\xacd\xf4=Wr\x9a\x06&\x19Fm\x00\x80\xfe!\r\x921ztI\x8f\xf1\xa0^ \x19=\x84\x04(\x19Fm\x00\x80\xfe!\r\x92\x11\xad!\xad\xfa\xf6\x99\xe8LH\x06\x009E:$c\riз\xb7\x92fH\x06\x009EJ\x92\xb1\xfb5\x8b\xdd\xe6>U2\x8e\x93\x89\xfa\x92d=9bH\xc6\xf1\xa6\xaahY\xdd.uk\x11a\x1cd\x92\xf1YSE\xb4\xeaq}\xc6\u007f\xd8X\xa9\x06\xb4\xe9u쩛\\Z\xbb\xcf!\x19G\x1a*\xa3\x13k\xd6\xe8\xf5\xc6\xd6\x06\x00\xe8\x1fR\x92\x8c\xdb\x14\x8b\xe9\xe6>U2\xe8̈́Mg\xda]|\xd39]2v\x8d#\xc53\xab\bYF\xe9\xe6\xf9\x84\xd4\xcf?\xaeJ\xc6\xcc\nR^F\xc8\f\xb6\xf0\xf1b\x94\x94\xdeTN\xc8BV\xae\x85\x90\x8a\x99Ѣ\x1aN2>,%e7U\x13rG\x9f\xb86\x00@\xff\x90\x92dtEL\xc58\xaf\xc3\xdc\xc7$\xe39\xd2\xc46\xb7\x91U\xbad\x1c/%\x8b\xbaՃ\x872\xb2\x8d;1!SߡtG\x94l\xa6\xf4@!y\xba\x87\xf6m-&k\xd4\ad\xf4\xfa>z\xaa\x96p\x92QO\x96\xa8\a\x18\a&\xb0U\x12Qm\x00\x80\xfe!%ɰ\x0f3\xae\xb3v1\xc98J*\xd8\xd1\xc0|rT\x97\x8cE\xa4N{\xeeeR\xcdK\xc6a\xb6\xaf\x91\tC=y@\vXO&\xf7\xd2{\xc9\"\xb6}\xfa*N2\xae\xd5O>\xd6ܻS\\\x1b\x00\xa0\u007fHM2\xcc\xc3\f\xfb C\x93\f:\x93\xa8\a\x10\xdd%3\xa9.\x19\x95\xe4\x15\xed\xb9\x9eBrԖ\x8c\x19ھ5\xa4\x9e\xf6\x96\xb0x\x95\xdeR\xf2f\xdf\x04\xb2_{\xb0\x88\x93\x8c;H͛\xe7\x8cmQm\x00\x80\xfe!5ɠs\xdc\a\x19\xbad4\x93\xc7)m%ͺdt\x132\xe3V\x8d(i\xb3%\xa3V\x8bߨ\xfe\xfd\x98\x10\xe3N\x8e\x1a\xb2\xf1\x14!\xdd\xc63\xb6d\xbc\x19%d\xc2\xfc\xcd\u007fW7\x85\xb5\x01\x00\xfa\x87\x14%C?\xcc\xe0\x0e2t\xc98L\xa6R\xba\x80\x1c\xd1%\xe3Sb\xb3\xcd}\x91\x95I\xc6ARd\x94\xae%k\x8e\x10\xa2o\xb7\xf2WL>\\P\xa2\x96.j\xec\x16\xd7\x06\x00\xe8\x1fR\x94\f\xfd0\x83;\xc8\xd0%\x83V\x93\x83=\xeay\x89.\x19\xa7\x89*\x1e\x16\x02\xc9\xf8\x84?\xca\xf8\xbby\x94\xf1\xb2\xf3\xbe\x8c\xde\xf6\xa7g\x12\xd2 \xae\r\x00\xd0?\xa4*\x19\xec0\x83?\xc80$\xe3i\xb2b\x87z^b\xace\\Ům0\xf6||N$\x19\xbd\xc5\xf6ZF{_\x19yK{\xb0̖\x8c\xbe\x8f\xdf\xd0\xfe\xae!E焵\x01\x00\xfa\x87T%\x83\x1dfL\xe1\x1f\xeb\x92q\x80\xccld\a\x03\xbad4\x92\x9b\xd8\x15\x14\xba\x93\x14\x9f\xa2\xbd\x84\xfc\x83:%\x83\xd6\x1b\xf7\x8bn$\x13zh\x83\xfe\xa0\xa7ʖ\x8c\x93d\xf4g\xec\xef!R\xd8+\xac\r\x00\xd0?\xa4,\x19\x9d\x11\x85?\xc80$\x83V\x91q슈.\x19\x87\x8a\xc9Cg(}\xbbL\xbb_#J\xb6u\x9fsJ\xc6\xfe\"\xb2\xa2\x97\xd2\xd6\x12\xd2B\xe9\x91(Y\xd5G\xcf\xcc'\x8e+&w\xa8\x9aqz>\v\x16\xd5\x06\x00\xe8\x1fR\x96\f:\xc7q\x90aJ\xc6ㄝ\x97\x18\x92A[\xa3\xa4x\xf64B\xe6\xb2%\x8bل\x906\xa7d\xd0\xcdEd\xe2\xcd\x15\x844\xb1\xe3\x87mQR~s\t\xa9\xe7$\xe3X\x19\x89\xde8\xb3\x84\x94\x1f\x15\xd7\x06\x00\xe8\x1fR\x97\x8cN\xc7A\x86)\x19\xef\xe8ZaH\x06=\xf2\xa3\xaah\xc9\xec\x16\xed+\"\x87j\x8a'\xbe\xec\x92\fz\xb0\xa1\"zM}\x9b^\xc7\xfb\xf3\xcbKnm\xdb\xc6/\u007f\x1eo\x9a\x16-\xae^\xfaw*\xae\r\x00\xd0?\xa4.\x19\x00\x80<\x02\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92\x01\x00\x90\x00\x92A[kN\xf9\x85H\xf2\xd5\xdcV\xbf\x90\x14\b>\xdf~ \xbdC\x02\xfa\x91\\\x93\x8c\x85\xa4p\x9b\xc7Sǣd\x86`w\vi\xees\xee9X_>\xf1\x8e=7\xbd)\bN\x8c\xbe\x96\xc2\xe7\x84O\xac)\xfe\x99p\xbf\fz\xbe\x8d\x84\x90qG\xcd}\xbb*v\xc4+\x928\a\v\xd5z\x1b\xad\x87\x81\xd5\xeb=$ l\xe4\x8ad\xec9\xa0\xff=\xd9\x1em\xf6\b\xe9{\xa71\x1a\xbbw]\xe1\xaf]{\x0eD\xeb[_\xbe\x97\x10/\xe9I\x84\x9dE\xebD\xbbgGo\x12\xed\xf6\xc1웆\x91\xef\xdf\xda\xdbד\xb7͝;J_\x89)口^\x9dso\xdf|S\xfb\xa7\xd6Ca\xbd\x82b\x89\xe01$ l\xe4\x8ad\xd4<`nyJ\x06\xa5\xcdј]Ǣ\xcb\xcc\xcd/j\xbf\xd0\xfe\xd6ժ\x9f\xe2}\x8d)I\x06]\x11\xfd[\xec\xce\xee\u0086\xc2\xee\xd8\xdd~\xd8}s\xe4\xbbϖ\f\xea:NJ\f\xbe^\x8b\xdaZ\xfe\x91\xa8^a\xb1\x04\x10\x0e\t\b\x1d\xb9\"\x19\xb7\xdegn\xc9IFcE\x8f\xb9\xf9!\xf9P\xfb;\xed\xa7\xec߃$\xa5\x93\xef\xee\n\xfb\xf0ޢ\x9d\x1c {bw\xfba\xf7͑//\x19I\xc1\xd7k\xe1\x94\f\x11\xc2b\t \x1c\x12\x10:\xc2%\x19箉>}m\xe5\x9eEe\xb5\xecú\xef\xd75\xa57>\xaeN\xa1\x1dD\xe7\x16\x16\x13]\xfa؍\xe3\xea\xb4\x0f\xb4\xbe\r\xb7\x8c\xbby\xbd\xf6Iy\xb2\xa1\xb2lA\xec\x89I\uf125\xfaƺ\xea\x1dGȑ\x9d\xd5\x1b(}\xa0\x82IG\xdfNG\x13\a\x8b\by\xe6hô\x92\xbas\xdbԖ\x9ai3\xd1N]D\x01Z\x85+J\xac\xb9m\xd1|-\xad4\x04\xed\x93\x05\xe5ъ\xfa\x93\xceM\xab\xb2\x85\xa4h]S\xe5\xe4\xfa\xa3\xae\xbe\xd9\xf9R[2N\x97\x10R\xb8U\xdf\xf7F]U\xb4\xbc~\xaa\xe3\xe0`!\x89n\xb4\x87D8f\x1c\xb6d\b\xebu\x14\xe3\xf2\x155\x91Ȑ\x80\xd0\x11.ɠ{&\x92\xc7j\xc9U\xcf]\xb3F}\xf0\xc3\xc2E;\xd7U\xdc\xdaG\xbb\xdfl\xaf\xbe\xa3\xbd\xbd\xfd\b\v\x89\x92\x19[[\xaf\xb9\x97m>\x14}f\xe73Q\xf6\xd9vt\xe2\x8d/\xb4֑\xa8\xbb\xbe\xf7I\xbb\xbeq\xb2\x81\xccT\xff[\xa0\x9e\xc7\x1f\xaf*\xack~\xabW\xdbm5ѳm\xeb\xd4\xea\tU\x8f5\x8c\xfek\xf7\x1b\x13W\x9c\xa2\xa7V\x94\xbd\xd1-\x0e\xd0J\xbeI\xder7Fk\x17\xd0\xfb\xf4\x19\xb9\xa7\xf4\x96\x96]\xcdd\x8dsӪ죭Ed\xea\xaa\xe6\xa9\xe3>t\xf6\xcdΗrG\x19\a\xdaۋu%\xda?\xba\xe1\x95]\x1b\xcb\xc99\xbeUVYE\xf3\xcf&jC\"\x1e3\x0e\xee(CT\xaf\xa3\x98#\xdf\xd8&\x12\x19\x12\x10:B&\x19\xb4\xa2\x81\xee$;\xe8CM\xecs\xf2E\xca&\x8e\xf6Aȝ\x98T\xfcC}\xdbV\xa8[m\xa4\xcd\xfcwn\xb5\xfa\x01\xd77;\xea\xaen'\xf9\xd8\xdcl\x8b\x92h\x9b\xb6\xf5ժ\x9a()cK\x19\xce&H\xed\x19\xdawF\xdd\xfa!;\x9bo\xf8\x91w\x80\xca\xdfH\xcc\xcaa_\xe9\x1a\xba\xa6\x94\x1d\x01\xf4Tթ\x92Ի\xed+\xc7&_Yt\x9aZ\xcf\xe9\xaa\x1a\xad^\xfbL\x80\xcb\xd7qbR\xa2O\xed\xf5\x15L,֗\xb9\x96 \xa2e\xea\xc7\u007f\x03\x1b\x12\x8f1\xe3p\x9e\x98\x88굊9\xf2\xf5h\xc2gH@\xf8\b\x9ddl\xa5\xef\x90n\xba\xf4\xfb\xea\t\xc4\r\xbd\xe7T\xae\xd5ΐ9\xc9P\xd5D_\xb5\xf8\xe1Lm\xc7\xccFz\x9ald[\xcfD\xddյ\x92\xe3\xfa\xc6W\x8fE+Ie\xf1\xd2\u007f\xe8\x0f{wՑ\x9d\xee&\xa2\u007f5J\xedQ\x8f\xb0{Ʊ\xcf{\x8f\x00\xca\xe6G\xcc\xf2\xe9A\xf2fϛ\xe4 e2\xf6\x81\xb9\x93\xdb\xe4+\xd3W9\xd7\x13UI\xf8\xa9m\xe5K\x85\x92\xf1i\xe5\xb4E\x1b?\xe8\xeb\xa5N\xa2\x0fQcH<ƌC(\x19\x8ez\xadb\x8e|=\x9a\xf0\x19\x12\x10>B'\x19mt_\x94\xd2e\xaad\xcc6N\xab\xe7\xb3\xfd\xae\xe5O\xed\xcd;\xb7^\xdbQ_C\x0f\xe8\xc7\xf3\xb1˟\xef\x98Ӯ\xa5|\xc3!\xf2Ѻ\xf2\xe7ԩ\xa8\xad0\xf4\xb1\xd2\xce&j\xccR\xe7\xca[ik9\xfb\xc8\xf5\b\xa0lB\xc7\xdcױN\v]\xa7m\xf5\xd8;\xadM\xbe2}\x11\xb7\x9d\xb0\v\x9a\xdc\xd4~\x87\x93\t\x81d\xd0\xd3\x1b\xee\x9bA\xaeiq\x1feXC\xe21f\x1cB\xc9p\xd4k\x15\x8b\xc9WЄϐ\x80\xf0\x11b\xc9h\xb8ဆviT{\x1fof\x1fi\xf6\x9b\xb7\xf1\x06\xf6\x16\xef\x9b\xf6\x10\xfd\aYς\x1e\x8a\xba\xab뱮\xaf\xf4\xd2\x0f\xc9!ګ\x96\xa8X\xa4\xed\xf8i\xb5\xbb\x89\x05V\xb1E\xf3\xe9\xbdZ\x94W\x00\xcb \xe6r\xea\x82[\xf6\xed\xdbw\v\v\xdaE\xac{\x1b\xb8M\xbe\xb2\xe8\x12\xb6g#a\xc7\xf4v߸|\x85\x92q`\x99\x9a\xff\xe9\xad%\xeb\xa9\x03{H<ƌC\x97\x8c\xee\x15_i\x8fD\xf5Z\xc5\x1c\xf9z4\xe13$ |\x84X2\xda\xf4\xe3ܟjw\x15\xb2w\xfa)m\x87\xfd\xe6ݩ\x9dOoeg\x185U\xea\x14\xf8\xb88\x1aS߂j\xeb\x13\xf9\xd32\xfd\x1e\xa6\xf2J6]\xfaػ\xdd\xd1\x04\xf7\xa1\xfcV\xf1g\xc5\xdaR\x9eW\x00\xed\x9bQO\xddT>\xae\xfe\xf3X%e\xd7\x1bk\xd9A\xfe\xa2%\x8eM\xbe\xb2\xe85\xea\xf4\xea\xbeA\x9b\xbfv\xdf\x1c\xf9\n$\xa3Y[\xbd\xa1\xb5Mԁ=$\x1ecF\xe9\xf1\xe7\x8e鱺d\xbcO\xde\xd0\x1e\x89굊9\xf2\x157\xe17$ |\x84L2\x0eM^ӳ5z\xb0\xa7\xa1\xf6o\xaan\x8c\xfe\xfe+\xad\x8d\xe4e\xf6DstMkm\xe9\xa7\xf4\xb3\xf6h\xe3;}\xef7F\xdb?S?\xf0\n\x97\xedXVؠ>\xfdḪ\xe6g&\x17\x16\xbdx\xc8U\xe1\x91\u0098[\xb8\xcbIEs[km\t[h\xb4\x9a8\xf7\x96v\xa5\xc0XI諬\xabԧ\xaeG\x00]c\x1f<\x18\xf4\xb4\x91\x9fv\xd3\xee\xa7I\x9b*\x11{\x8agnh[D6S\xc7&ס(\xb9e\xdb\xe6\xea2m\xb1\xd3\xec\x1b\xc3\xcc\xf7Sv\xf7\xe7\xba\xf6v\xf5þ\xf7\xed\xf6\xf6\xe2\xc6\xf67ΰ\xa9]\xbab\x87Z\x83\xe3\xe6\x0fǐ\x88ƌ1\x9fh\xf3\xf9\xdc[7\xdfԮ\xb2A=\x93\xf3\xaa\xd7.fU&n\xc2wH@\x18\t\x97d\xf4]C\xc8\xd6\t\xa4t\x9b~\xaa\xdcV{U\xd9\xdc6\xed\x99\xdeE\x93K\xee\xd8\xc7\xee\x10 $z\xb8T\xfdw\xa1\x1a\xben\xf6\xb8\xd9\xfa}\x19G\xeb'O[\xfab\x11\xdb\xebdE\xb1\xfb\x04\xbbf\xf3Og\x94V\xcc\xd7/M\x98Mh_\xbe \xc4\xfc\x9c\\\x17]cl\x89\x03\xde(\xb1\xef\x9f0\xd85\x9a\xdd\xc8\xd1J\xc8\xe8]꣏\xef\xbbvB\x8d~\xb3\x18\xb7iw(\xfax\xe3\xc4ʆϴ\xbdf\xdf4\x8c|\x1f2V\f\x1e\xa0t\xbf\xde2\xd9@\xe9\xaf\xefh\xae\x8aV\xd4:o\x17s\f\x89h\xcc\x18/Tl`\u007f\x8c^\x10Rrij^\xae\x98Y\x99\xb8\t\xdf!\x01a$\\\x92\x91\x06\xfa\x96D\xb7\xf9\xc5H\xb3-\xda\xe8\xb85B\x1e\xefoʤ#\xdf~ \xf5!\x01\xd9A\xdeK\x06\xed[s\xed\xdf\xfdb$\xf9\xaa\u2e64\xbe\xf4\xc1\xe1}\xdb{\x1a\xf2\xed\a\x02\x18\x12\x90\x1d@2\xb2\x938ߔ\x01 \x93@2\xb2\x91\x93\xdar\xa2_\x14\x00\x19\x00\x92\x91\x8dhˉ\xf6}\x9e\x00d\x0f\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\x8c4x\x9cf\x8f\x01i\xf0}\x031d\xcf\xcb\xdd/\xe4\x9add\xaf'\xeb\vĴ?\xd9,(bb$\xe9\xb4\\5\xe0jh-2~ע\xa8\x95\xdbl\x1b\xcd\xfeN\xae?b\x96\x88훈\x98bn\xe2\f\xaa\x1fɺ\xbaƼX\xbe9d\xae\x17y\xe67\x9b+\x92\x91\xfd\x9e\xacg^$ϝ\xa2\xa7ZȋgD%\f\x8c$\x9d\x96\xab\x06\\\r-\xc4\xf8U\xae\xd1-\xdcfϛ\xd1\xc6\xf6=\xeb\xaaK>\xd2\v\xc4\xf6M\x88\xbb\x98E\x02\x83j\xe1\xe1Ԛ\x9c[\xac\xe0\xc5\xf2\xcd!\x93\xbd\xc8+\xbf\xd9\\\x91\x8c\x10x\xb2\x1e\xd2~@s\x0fq\xff\x96\xa0\v3I\x81\u007f\xa2]ú\xa8\x11P\xb2\x8e\xdb4:\xdf]Y\xa7\x85s}\xf3\xc1Q\xcc&\xa1A5\xf0rjM\xe0(GL̋\xe5\x9bC\x06{\x91O~\xb3\xb9\"\x19!\xf0d\rR2z?1\x02>\xe9\xe56\xcd\xce7\x97hoq\xaeo>8\x8a\xd9$4\xa8\x06\xc9:\xb5z\x92\xa4dd\xa6\x17\xf9\xe47\x1b.\xc9\b\xb5'+'\x19g\ueaccV\xd53\x13$\x87\x9b\xa9#IK2\xac&\\\xa2\xc3i\x8a\xb5\xa9O\x8a\x96\"\xf6\xa3\xe5f߸\xcc8\xafWʛ\xc1\xda\xc5\xec̼\x06\x95C\xe4\xd4ʏ\x83\xed\xea\xea\xe8\xe6\x17\rW]\xfb\xf8\xe3W\x95z\x1e\xc6q\xe3`w\x9eF\x17\xfdHO}!)|\xd9Z\xec\xe0*\xcbd/\xf2\xc8o6\\\x92\x11jO\xd6CdgOOO\x1b\x9b\xf0;HӞm\xf5\x85\xfb\x9c\x86\xa9\xce$-\x19\xb0\x9a\xe0k\xa0q$\xa3\xef\x96\xd9l\xdb\xec\x1b\x97\x19\xe7\xf5\xea0\x83\xb5\x8bٙy\r\xaa\x8dЩ\xd51\x0e\x96\xab+\xdf\xcdޙ\x15뛋K6י\xbf\xb8\xec\x86\x1f\a\xbb\xf3ڏ\xaeo\x9d\xad\xa6\xae-J\x18\x8b\x1d|e\x99\xecE\x1e\xf9͆L2\xc2\xec\xc9z\xc8\xf8\x10;\xc4ޑ\xaa\xda\xf4ݤ\x19\x8a\xd9n\xa6\xce$M\x19\xe0\x9a\xe0j\xa0\x1e\x92\xb1\xa2\xa7\xe7ང\xfd\x869\xdf7;3\xdb\xeb\x953\x83\xe5\x8a\xf1\x99\t\a\x95C\xec\xd4\xea\x1a\a\xd3o\xcd\xee\xe66\xe61\xb9>\xce\xf9\x197\x0e\x0e\xdb\xd7\x19\xea\xee\x9ej\xe6\xbff\xbb\xa6\xf0\x95e\xb2\x17y\xe47\x1b:\xc9\b\xaf'\xeb!\xf2\xb3}\xfb\xf6\xad\xd1\xdee_\xac\xaf\xbba\"\xd1\x0e\x06,7SW\x92\xa6\fpM\xf05xH\x06S\x94r}\x15\x86\xf3o\xb53\xb3\xbd^93X\xbe\x18\x97\x99pP9\xc4N\xad\xaeq\xb0&\x9beں\xacL\xfd\xe7c\xef\xa5\"~\x1c\x1c\xb6\xafO\xb3\xdd\x1b\x98M\xad-\x19|e\x99\xecE\x1e\xf9͆N2\xc2\xeb\xc9ʭD쫨Z\xda\xda^\xabK\x86\x99\xaf+IS\x06\xb8&\x12X\xcbhڷ\xef\x13c\xf9\x8f\xf3o\xb53\xd3\xcf\xf7\x99\xd7+g\x06\xcb\x15\xe33\x13\x0e*\x8fЩ\xd55\x0e\xd6d\xb3jX3\xfa\vv\xec\xf7!\xf5\x80\x1f\a\x0f\x9bZqe\x99\xecE\x1e\xf9͆X2\xc2\xe6\xc9\xcaM\xf8\x195l\xba.pJ\x86+IS\x06\xb8&\x12\x90\f\xb3;\xd4\xe1\xdfjgf{\xbdrf\xb0\\1>3\xe1\xa0r\x88\x9dZ]\xe3\x10;\xd9\xfeZX\xf7׃\xd5s=\xaf[\xf2\xe3\x10kS\xbb\x99\xd9\xd4j\x95=\xe3\xae,\x93\xbd\xc8#\xbf\xd9\x10KF\xd8<Y\xb9\t_\xc5ގ}7;%Õ\xa4)\x03\\\x13r\x92\xc1\xf5\x8d\xfb\xa0\xb5\xbc^93X\xae\x18\x9f\x99pP9\xc4N\xad\xceq\x10L\xb6\x03\xe4\x1aBjO\x1a\xcf\x1fo\x8e\xb9{\x8a\x1b\a\x87\xed\xeb\xb5l\xede&\xf3\x8c\x1d\xb7TM\xb2\xc6]Y\x06{\x91O~\xb3!\x93\x8c\x10{\xb2\xf2w\u007f6\x93\xfb֯\xba\x95\x94\xb7\xbc\xc3\xe7\xcb%\xc9Y\xae\xdaM8\xef\x1f}_\r0\xda07\xd9\r\x90\xdc\xfd\xd2F\xdf\x1c\x99q^\xaf\x96\x19,_\xccΌz\f\xaa\x8dЩ\x95o\xcdvu\xe5k8P\xbckg\xfbIS\xcd\xeaI\xe9i\xea\x84\u007f\xb1\x1c6\xb5uo\xed\xaa\xd1R\x9f[Ѳ\xaa\x86\xb0\x00\xbb\xb2\x8c\xf6\"\x9f\xfcf\xc3%\x19a\xf6d\xb5\xbf!\xb2\x91\xf6\xad\xa9\x8eV<\xf0Bu\xb4֑\xaf\x9d$g\xb9j7\xc1\xd7@{X\x99\x12mA\xdf\xdalS\xff\xce\xe4\x9a\xd4\xfb\xe6Ȍ\xf7z5\xcd`\xf9bvf\xd4cPm\x84N\xad|k\xb6\xab+_Û\xda2e\xf4\x0e}\x19`s)\xd9G]\xf0/\x96\xfd\x1a\xcfl\xbeo\x82\x91\xfa\xd1ڒ\tuO;+\xcbd/\xf2\xcao6\\\x92\x91\x06\xd2\xe2q\x9a%\x06\xa4\x82\xbe9\xce\\2©ҦS\xe7Ν\xde\u007f\xefd\xfd袕\xb8\x8f2$pW\xd6o8\x1aΒ\x97\xbb\x9f\xc8{\xc9H\x87\xc7i\xd6\x18\x90\xc6\xf6-\xf3\x92Ѫ\xdf\x01A\xfb\xca\xdbؿ/\x965\xc5\r\x8f\x8f\xb3\xb2~\x84o8k^\xee\xfe\x01\x92\x91_d^2\x0e\x14\xeag$\x1f\x16\xb2\xfbBN\x96/\xe9\x8d\x1f\x1f\x17ge\xfdH\xc6\x1a\xce<\x90\x8c|\"\x1b\xbc^\xfb\x1aK\x9a\xb6\xed\xd9\xd6T\xd2\x14@\"\x81V&C\xc6\x1a\xce<\x90\x8c|\"+\xbc^\xfbv\xd4UF+\xebv\x042\xd7\x02\xadL\x86\x8c5\x9cq \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\x00\x00\t \x19\xa0\x1f\xe9\xeb\xd3\xff\a\xe1\x05\x92\x01\xfa\x8b\xcf\x1a+Ƚ\x94>@\xca\x1b\xbd\u007f\xf8\x13d;\x90\x8c4\xf8\x96f¤3\xf8^\x04Mߌ\x19\x1bw\x1dW\x95\xa3\xfd\x85\x19W\xe9?\"\x98\x89\x81\x02)\x92k\x92\x91ݞ\xac\xa4\xbc\xee}A\xbcM\xb2\x16\xa6\t\xba\xafz\x93d\xc3\xffh\xba\xa6\xa4>\xc1\x86\x0f\xea?\u007f\xc5\xd8\xc3~\x9e\x9bz\f\x14\xc8nrE2\x120\xde\xcc\x02O\xd6\xf6\x17jF\xef\x11ś\b\xcd?=\x8cBy\x12t_\xf5&Ɇk+6<T\x92\xe0OU\xec'o\x98\x9b\xf6o\x10敛in\x90+\x92\x91\x90\xf1f̏K\xf7\xbf'k\xdf\xdcjA\xb4\x8d\xe8\x13\xdb\xcb(\xd4&q\xf7UO\x92j\xf8+\xb2\x8e\xf6%\xfa;\xb9\xa2\xdf*\xcd/7\xd3\xdc W$#!\xe3M\x81d\xf4\xbb'+\xef\x05\x90 \xfeF\xa1\x89\xbb\xafJ\xe1\xdb\xf0Q\"q:#\x96\x8c|r3\xcd\r\xc2%\x199\xe0\xc9\xdaPI\xf9zyoO\xdb\xfcSl\x14\xeaٚ\xc0}\x95ږ\xab\\\xbe\xee$\r\x84\xae\xa3\xbe\r\xf7^\xa5\a<Fy\x93Y\xca{\xbdr\xddd\v\x18\xef\x98\r\x1e$\xf6\xe9\x99\xc0\xcdTԚ#u\xeb\x85\xf5\xe8\x10H#ᒌ\xd0{\xb2\x1eYJV9\xeaux{Z\xe6\x9fb\xa3P\xcf\xd6\x04\ueadc\xe5*\x97\xaf;I\x13\x91\xeb\xa8\u007f\xc3\x1f\xb4o%\xcd\xed\xda\xefu\xdb&\xa8\x0e\xafW\xbb\x9b\xe7\xfe\xbe\xa7\xa6\xcc҆ޫj\xde\xfc\xd48\x15\x12\xb8\x99\x8aZs\xa4n\xbd\xb0^\x1d\x02\xe9#d\x92\x11~Oֆ>g1\x97\xb7\xa7a\x98!6\n\xf5jM\xe4\xbe\xca[\xae\xda\xf9\xba\x92\xe4\x88u\x1dM\xa0a\xebĄ3A\xe5\x1a\xe6\x8a\xcdW\xbbΝİ\x9f\x037~\x8c=v\xa0\xbcZ\xb36\xb9\x17ֻC M\x84N2B\xed\xc9\xfaΎ\x9a\x92\xe3\xceb.oOc抍B\xbdZ\x13\xb9\xaf\xf2\x96\xabv\xbe\xae$9b]G\x13h\xd8^˰MP\xb9\x86\xb9b\u007fm\xdb0c\xb2\xb5P\xda]1m\xdd.#\xe7\u0601\xf2j\xcdڴ_X\xea\xdd!\x90&B'\x19!\xf7d=]\xb8\xc1Y\xcc\xe5\xedi\xce\\\xa1Q\xa8Wk\"\xf7U~\x99\xd5\xceו$G\xac\x1fX\x02\r[\x92\xc1\x99\xa0r\r;\x8a\xd1v۰d\x9f\xeeMol\xbb\aʫ5k\xd3~a\xa9w\x87@\x9a\b\xb1d\x84ӓu\xe2\ng1\x97\xb7\xa71s\xc5F\xa1^\xad\x89\xdcWy\xcbU;_W\x92\x1c\x9e\x92\x11\xafaK28\x13T\xaeaG1\x8f+&\x82\x81\xf2j\xcdڴ_X\xea\xdd!\x90&B,\x19\xe1\xf4d\xadXrp\x15_\xcc\xe9\xedi\xce\\\xb1Q\xa8gk\x02\xf7U\xder\xd5\xce\xd7Y\x8cG$\x19\xbe\r[\x92\xc1\x99\xa0r\r;\x8ayH\x86`\xa0\xbcZ\xb36\xb9\x17ֻC M\x84L2B\xec\xc9j\xdc0][\xdfx\x13\x9f:\xe7\xedi\x9b\u007f\x8a\x8dB\xbd[\x13\xb9\xafZ\x96\xab\xd4\xce\xd7U\xccD\xec:\xea۰~\xc5D39\xe0MP\xb9\x86\xf9WH\x15G\xeb\f\xe4\x1d\xfbz\xab\xc8\xcdTԚ#u\xeb\x85\xf5\xe8\x10H#ᒌ0{\xb2\xb2\xdb#ZԸ\xea\xf2\x1d\\1\xde\xdb\xd36\xff\x14\x1b\x85z\xb6&t_\xb5,W\x19F\xbe\xeeb\x06b\xd7Q\xbf\x86{˴\xcd\"v\x15\xd6a\x82\xca5̽B\xf4\xefE\xf7\x1d\xfc\x8c]V\xfe\xec\xfd\x05Q\xd3IY\xecf*h͑\xba\xf5\xc2zt\b\xa4\x91pIF\x1aȰ'k@\xa6\xa2i\xe9Eд\xceԔ~>!S\xcd\vD\x89\x0f\x14\xc8\x16\xf2^22\xec\xc9\x1a\x94\xa9h\x1az\x91\x06N\x1dT\x8f.>;\xf0\xa9\xf9Xb\xa0@\xb6\x00\xc9\xc8,y\xec\xed\t\xc2\t$#\xb3䱷'\b'\x90\x8c\f\x93\xbfޞ \x9c@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00H\x04\xd8\xc9\x1a@2\x00\xf0\x05v\xb26\x90\x8c4\xb8\x99f\xbb\xd5h\xf0=\xceq`'ˑk\x92\x91\u007f\x9e\xac\xed\xa3\xc9\xdc>\xfa\n!\xa3\xed\xdfӌO\xaa\xfe\xad\xbe$ы\x14H\xb25\xd8\xc9&I\xaeHF\xfez\xb2\xf6\xec\"%\xed\xb4\xfb\x15\xb2+\xc6BHL\xca\xfe\xad6\x1e\x99\t{\x916\x92\x183\x06\xecd\x93$W$#\x8f=Y\xbbIC\xa3z\fE\x12\xf4F\r\xc0\xbf\xd5\xc2+\xb3\x04?\xbc\x03\"\x891\x83\x9dl\xf2\xe4\x8ad\xe4\xb1'k7\xd9\xf7\xbad\xee\x00\x00 \x00IDATUړ\xb8d\x04\xe9ߚ\xbd?\xd5\xeb\x9b\x19\xecd\x93%\\\x92\x01OVAk\xdd\xe4\xf8\xad\xaf\xe8\x92aY\xa3z\f\x14\xb5{̹\xaf&R\xccF\x94\x19\x9f\x8e\xd0\xe0\x95\xef\xa6\x10\xd8Ɇ\x86pI\x06<Y\x05\xad\xa9\x92\xb1\xae^\x97\f\xdb\x1aU<P\xd4\xee1羚H1\vaf\x8e\u038b\f^\x1d\xdd\x14\x01;\xd9\xd0\x102ɀ'klk\xaad\xfc\xbd\xf8\xef\x9adp֨^\x03e\xf7\xd8v_M\xa0\x98\x8583W\xe7c\r^]\xdd\x14\x01;\xd9p\x10:ɀ'\xab\xbb5U2h\xfd:}-öF\xf5\x1a(ۿ\x95s_\xf5/f!\xce\xcc\xd5\xf9X\x83WW7E\xc0N6\x1c\x84N2\xe0\xc9\xean\x8dI\xc6+7k\x92\xc1Y\xa3z\r\x94\xed\xdfj\x0fT\x02\xc5l\x84\x99\xb9:\x1fk\xbd\xe6\xea\xa6\b\xd8Ɇ\x83\x10K\x06<Yu\x98d\xf4\x94\xeeb\x92\xc1Y\xa3z\r\x94\xddc{\xa0\x12(f!\xce\xcc\xd5\xf9\xd8I\xec\xea\xa6\b\xd8Ɇ\x83\x10K\x06<Yu\x98dЇ\x1a\x98dp֨^\x03e\xf7\xd8\x1e\xa8D\x8a\x99\x883sv^0\x89\x9d\xdd<\xde,\xb8\xd3\nv\xb2\xe1 d\x92\x01O֘\xd6zv\x91W\xbai{\t\x93\f\xdb\x1a\xd5s\xa0\xcc\x1e\xf3\x03\x95H1\x13af|\xe7\xc5\x06\xaf\\7U\xeaI\xa9\xeb\xbeK\xd8Ɇ\x86pI\x06<Yc[\xdb3\x9a\xdd \xd2WS\xa1\xf6ӲF\x9d\xeb9Pf\x8f\xf9\x81J\xa8\x98\x8103\xbe\xf3b\x83W\xae\x9b*\x9bK\xed\xc5\x01\x1d\xd8Ɇ\x86pIF\x1aH\x8b\x9bi\xe2V\xa3\x01y\xb2ʐ\x96\x1e\xfb\xe0\xeef+\xe9\xb7\xee\x06\x02\xecdm\xf2^2\xd2\xe1f*a5\x1a\x94'\xab\fi\xe8\xb1\x1f\xcen\xf6\xbdX\xd6\x147<\v\x81\x9d\xac\t$#\xb3\xe4\x89'\xab\xb3\x9b'˗\xf4Ə\a\xd9\v$#\xb3\xe4\x89'k\x9et3/\x80dd\x98<\xf1d͓n\xe6\x03\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\x8c48\x94f\x8f_g\xf0}\xeb_\xb2g$\x81I\xaeIF\xf6z\xb2&_\uf87aҊ\x86=\x151\x93ߣC\x1c~\xee\xab\xfe5\x18$\x9b:GR\xbd\xc8_\xe7\xd3\xec%W$#\xfb=Y\x93\xae\xb7\xad\xb4f\xe3\xd6ل\x1cq?!\xee\x10\x87\xaf\xfb\xaao\r\x06ɦΑl/\xf2\xd5\xf94{\xc9\x15\xc9\b\x81'k\x92\xf5~5q~/\xa5\xddձ\x93M\xd8!\x8eD\xdcW\xe3\xd7`\x92d\xea\x1c\xc9\xf7\"O\x9dO\xb3\x97\\\x91\x8c\x10x\xb2&Y\xef\xb2\x12\xed\x97\xe3\xd6\xc8O\xb6D\xdcW\x13\x93\x8c$S\xe7H\xbe\x17y\xea|\x9a\xbd\x84K2B\xedɚ\\\xbd\xb4Z\xb7\n\xfbbM\xafW\x87x\xfbP\xdbT\xd4\xee\x9b\xc3jT\xa6\x06\x8b\xe4R\xe7\x87$\xe9^\b\x9dOA\x06\t\x97d\x84ړ5\xb9z{\v\xb9syq\x878\xefT\xceT\xd4\xee\x1b\xbfW\xaa\x06\x8b\xe4R\xe7\x02\x92\xef\x85\xd0\xf9\x14d\x90\x90IF\x98=Y\x93\xab\xf78w6 \xee\x10W\x19\xeffj\xf7\x8d\xdb+W\x83MR\xa9s\x01\xc9\xf7B8\x92 \x83\x84N2\xc2\xeb\xc9ʐ\xaf\xb7\xb7\xc8\xfe\xc0\x17w\x88\xab\x8cw3\xb5\xfb\xc6핫\xc1\x81|\xea\\@\xf2\xbd\xf0\x1aI\x90)B'\x19\xe1\xf5dM\xb2^c\x15\xa0\xb7ͫC\\,\xeffj\xf7\x8d\xdb+W\x83E\x92\xa9s\x01I\xf7B4\x92 \x93\x84X2\xc2\xe6ɚd\xbd\xcbJ4\a\x81m\xe4\x94G\x87\xb8X\x87\x9b\xa9\xd57n\xaf\\\r\x16I\xa6\xce\x05$\xdd\v\xd1H\x82L\x12b\xc9\b\x9b'k\x92\xf5~5\xf1^v\x95\xa1v\x9aW\x87\xb8X\x87\x9b\xa9\xd57n\xafd\r&I\xa6\xce\x05$\xdf\v\xc1H\x82L\x122\xc9\b\xb3'kr\xf5\xaa\x93i\xdc\xdc\x17[\xeb\x8a\xd8ѹ\xb8C\\,\xeffj\xf7\x8d\xdb+W\x83Ir\xa9;\x02\x92\xee\x85\xc8\xf9\x14d\x90pIF\x98=Y\x93\xac\x97\xb2og\x8c\xbbf\xfea\xb6\xe5\xd1!.\x96w3\xb5\xfbf\uf56c\xc1 \xb9ԝ\x01I\xf6B\xec|\n2G\xb8$#\r\xa4š4K\xfc:\xd3ҷ\xfe%KF\x12\xd8\xe4\xbdd\xa4á4k\xfc:\xd3з\xfe%kF\x12X@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\xd2\xe0[\x9aa'\xd1\xe0;\x1462\xfc\x02\xe46\xb9&\x19\xf9\xe4\xc9ꁟ\x11\xab\x1f\xbb*vx?\xf9\x02\xfb\x05\x8c\xf2\xba\xf7\xbd#\x18\xfaP7\x11\xcdW`\r!M\xae\xe7\xe36A\xb9\x1e7\xaa\xad\x8d;\x1a7V\x04\xac\\\xd3H\xaeHF>z\xb2\x8a\xf15b\xf5cGi\x1c\x13\x803/\x92\xe7\xda_\xa8\x19\xbd\xc7;\x84\x9aC\xfdii\v\xfb\xfd\xbf\xafZ&|\xeaz\xdenb\x8f\xe8'\xb7\xec\x1e\xff\xad\xbd}\xbd\xf9\xab\xc7R\xc0\xca5m\xe4\x8ad\xe4\xa7'\xab\x80D\x8cX}\x88{\x8cr\x88\xf9\x8f\xf4ͭ\x8e\x17C\x8d\xa1\xbeI\xff)\xbeͳc\x9e\xb6\x9a\xb0_7\x1bg\x8f\xf7%%\x19\xb0rM\x1b\xb9\"\x19\xf9\xe9\xc9* \x11#\xd6T\xd0$\xc3û\x80C\x1b\xea{\x9fѶ\u007fz\xafw\x1c\xff\x13\xcb&\xce\x1e')\x19\xb0rM\x17\xe1\x92\fx\xb2\x1a\x1dZH\xa2\x1b\x8dnr\x9b|\x87\x84F\xac\x9e\xc5,N\x97\x10R\xb8U\xdf\xe6\x86\xcfF\x97\x8c\x86J-\xc0J\xf2\xcc}\x95Ѫ\xfa\x83Z\x84=\xd4\xcb\xf4C\x88\a\x969F\xc7n\xc2\xf1\xba\x89{\xccI\x06\x97\xce\x1buU\xd1\xf2\xfa\xa9}T<\x92Z8\xac\\\xd3D\xb8$\x03\x9e\xacF\x87>\xdaZD*\x9a\u007f6\xf1^\xc7&\xf53b\xf5,fs\xa0\xbd\xbd\xb8\xd9\xd5\x1a\xcf!\xb2\xb3\xe7\xc8R\xb2\x8am\xdb6\xaa;HӞm\xf5\x85\xfb\xa8c\xa87\xd7\xd0w\xaaަ\xb7nt\x8e\x8eՄ\xe3u\x13\xf7\x98\x93\f;\x9d\xfd\xa3\x1b^ٵ\xb1\x9c\x9c\xa3R/\x00\b\x84\x90I\x06<Y\xcd\u007f\xa3e\xea\xf1A\x03\xeb&\xbf\xe9g\xc4\xeaU\xccA\x89.\x19|1\x9bC\xdaqA\x03\xfb\x80\xe7mT\xb7\xa92\xd7w\x13\xfb\xd9wn\xa8\xdb\xcb\xe9\xd2\xe8RZ\xae\xa9\x98ctJ̳G\xebu\x13\xf7\x98ڒ\xc1\xa5\xb3\xbe\x82\x89\xc5\xfa\xb2>\xc9\x17\x00\x04A\xe8$\x03\x9e\xac\xacCj7\x1f\xa2\xe6\xe2\f\xb7\xe9c\xc4\xeaÝ1\x9f\xf9b6\x87\xc8\xcf\xde\xd9QS\xc2Z\xe1{\xf1\xc5\xfa\xba\x1b&\x92\xd9\xd41\xd4\u007f%=w4\xcc\xed\xd6Sr\x8cN\xacd\x88{Lm\xc9\xe0\xd2\xf9\xb4rڢ\x8d\x1f\xf4\xf5R\xf9\x17\x00\xa4L\xe8$\x03\x9e\xac\xacC|7\xf9M\x1f#V\xcfb\x0e\x8c\xf9\xcc\x17\xb3\xd1\xd62N\x17n\xa0\x8e$\xf7UT-mm\xafU%\x83\x1f\xea\xbe臥\aJ?\x8cj\xeb\x0f\x8eщ\x95\fq\x8f\xa9-\x19|:\xa77\xdc7\x83\\\xd3\xd2'\xf7\x02\x80@\b\xb1d\xe4\xb3'\xab\xe7\u070fo\xc4*%\x19|1\x1b}\xf9s\xe2\n\xeaHrF\r\x13\xa8\x05\xaad8\x86\xba\xba\xa5\x92V\xae\xd1/\xc8:F\xc7)\x19\xecu\x13\xf7\x98ڒ\xc1\xa5s`\x99\xbayzk\xc9z\xb9\x17\x00\x04B\x88%#\xaf=Y=\xe7~|#V\x19\xc9\xe0\x8bQz\xfc\xb9c\xda_]2*\x96\x1c\\\xc5'Y\xc5&k\xdfͪd8\x86\xba\xae\xe6^z\xef\xdc:\xad\xa0\xe3r\xaa%\x19\xd6\xeb&\xee1\xb5%\x83K\xa7Y__\xa9m\x92{\x01@ \x84L2\xe0ɪw\x88릣\xc7>F\xac\xde\xc5Lz\xdfno/nl\u007f\xe3\f_\x8c1\xdf0J<\xa8M\xd7\xda\xfaƛ\xf8$\x9b\xc9}\xebW\xddJ\xca[\xdeq\f\xf5\x92\xd1-\xb4e\xb4z\xdc\xc4w\x93o\xc2z\xdd<z\xfc)\xbb\xfbs]{\xfb_\x1d\xe94\x93\xd2\x15;\xd4\xd8=T\xea\x05\x00\x81\x10.ɀ'\xab\xd1!\xae\x9b\x8e\x1e\xd3\xf8F\xacq\x8a\x19\xec\xd7\xf3!\x1b\xa8c\xf8(}\xa1\x82\xed\xa2\xec\xe6\x91\x165\xed\xear\xf6-\x11+ɾ5\xd5ъ\a^\xa8\x8e\xd6:\x86z縃\xf4Pi\xab\xb3\x9b|\x13\xd6\xebF\xc5=~H\x0f%\x0f8\xd2\xf9\xf5\x1d\xcdUъ\xda=\x8eb\xfe/\x00\b\x84pIF\x1aH\x8boi&\x9dD\xd3ҡ\xb0\x91\xc9\x17 \xd7\xc9{\xc9H\x87oif\x9dD\xd3С\xb0\x91\xd9\x17 ǁd\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\x00\x00$\x80d\xa4\xc1\xc24Ö\xa0\x01t\xa8\xc9m\x89\b\x92$[F2\xb8\xf7d\xaeIF\xcey\xb22\x13T\xdd\xdddsk\x91\xf1\xeb\x11E\xad\xdcf\xdbh\xf6wr\xfd\x11\xb3D\xaa\x9e\xac*GȲx#\x19\x8f\xc4L[\xe5I\xde\xe05\xa3d\xcdH\x06gS\x9b+\x92\x91\xb3\x9e\xac\xcc\x04\xf5\x14=\xd5B^<\xd3B\x8cߨ\x1a\xdd\xc2m\xf6\xbc\x19ml߳\xae\xba\xe4#\xbd@R\x9e\xac.kԆ\xe2S\xae\x91\xe4\x02\x846\xaa\x16\x89\x99\xb6ʓ\xb4\xc1k?\x93e#\xc95\x11\x94Mm\xaeHF\xeez\xb2\xea?\xb6\xb9\x87\x1c\xa2\xeb\xa2\xc6/a\x96\xac\xe36\x8d\x1ewW\xea?\xb1\x99\x9c'\xab\xd3\x1a\xf5\xe8\xe8\xc7\xd8\x1f~$\xb9\x00\x91\x8d*G\x82\xa6\xad\xd2$i\xf0\x1a4\xe6\xbbċ,\x1bI\xbe\x89\x80ljsE2rדՖ\x8c\xdeO\f\x9d\xf8\xa4\x97\xdb4{\xdc\\\xa2M\x9d\xe4<Y\x9d֨\x0fE\xb5\xdf\x03\xe5G\x92\v\x10٨r$h\xda*M\x92\x06\xafAc\xbeK\xbcȲ\x91\xe4\x9b\bȦ6\\\x92\x91\x8f\x9e\xac\xb6d08SckS\u007fC\xb6\x14\xb1_\x147;\xb4B\xadf+ݪ\xfe\xbb\xc2\xce\xc0i\xc4*\x1e>\x95\xe3E\xba}\x825\x92\\\x00\xb7\xb9\x90\x14\xadk\xaa\x9c\\\u007f\x94:\x10\x9b\xb6\xda6\xaa\x8eb\"\xb7X\xb1\xe5j\x92\x06\xaf\xee\x97%\x06G\x00\x97o\xf7\xd2\x19\xa5w\xbc}m\x9b#\xd8~\x97dp$\xad\xcc\x16\x92\u0097\xad\x15:\xd1P\xbb\xd3\tƦ6\\\x92\x91\x87\x9e\xac\x9a\tjOO\x9b\x9fd\xf4ݢ\x1d\xb1\x9b\x1d:\xf5\xfd\x1a\xb5\x9a\xee7\xe76\xf0?\xea\xe70b\x15\x0f\x9fJ\x93q\x00k\x8d$\x17\xc0m\xb2ʦ\xaej\x9e:\xce\xf9\xb1+6m\xb5mT\x1d\xc5Dn\xb1b\xcb\xd5$\r^\xdd/K\f\x8e\x00\xbb\xb5\xd37\x94\xafi[h\xfc\xa6\xb1\x85\xfd.\xc9\xdcHڙik$\xe6\n\x9dh\xa8\xdd\xe9\x04cS\x1b2\xc9\xc8?OV\xc3\x04\x95ē\x8c\x15==\a\xef%\xbbضա_\xebW\x87f\xba\xd6Bm#V\x8f\xe1cW\x96\x8c\xdf\x1c\xb7G\xd2\xe3p::M\xcd\xfat\x95\xdbN\x8d\xe16m\xe5lT\xb9bb\xb7X\xb1\xe5jr\x06\xaf\xeeX\x11V\x00W\xac\xb1\x8cy\xdb-qI\x06\xff.\xc9\xd4H\xf2\x99\xd9V4\x1eC\xed<\xf7\tƦ6t\x92\x91o\x9e\xac\xcc\x04u\u07fe}k\xe2I\x06{g\x95\xebK$V\x87\x0e\x16\xf6\xf6\xfc\xfa\xf4\xb9\xe8A\xea\xc06b\xf5\x18>\xf509jTa\x8f\xa4\xd7\x1b][i]O\xbe\xa2\x1cb\xd3V\xceF\x95+&v\x8b\x15[\xae&g\xf0\xea\x8e\x15a\x05\xd8\xc5\xfa\xc6iu~\xe4\x92\f\xfe]\x92\xa1\x91tdfK\x86\xc7P\xbb%C\xf4\x9e\x94%t\x92іo\x9e\xac\t\xace4\xed\xdb\xf7\x89q\xd9\xc0\xeaPo\xd1\xc15dő\xc2^\xea\xc0\x1e\x1d\x8f\xe1\xa3'\xa3?\x8a\x89\xf5z\xa3k\xef\xdev\xa7ɐش\x95\xb3Q\xe5\x8ay\xb8\xc5\n-W\x934xuŊ\xb0\x02\xecb\u007f\xd3\x17\xa9\xbb]\x92\xc1\xbdK25\x92\x8e\xcc\xc49pC플`ljC,\x19y\xe2ɚ\x80d\x98}\xa0|\x87fl\xad\x9d;\xa3\xd5}\xf3\x9a=:\x1e\xc3G\x97\x14\x1e\x8b\x89u\x04pC\xbd\x84=\xdeH\x1c\a\xfdb\xd3V\xceF\x95+&v\x8b\xf5\xb0\\M\xce\xe0\xd5\x15+\xc2\n\xb0\x8b\xf5\xe9u\x1ev\x9f\x98\xd8\xef\x92L\x8d\xa4#3\xad\xdeg\xa2\xd4s\xa8\xf9\xd6D\xef\xc9d\b\xb1d\xe4\x89'\xab\x9cd\xd8\x1d\xfa\xfe\xa2h\x1bY\xf8\x00ub\x8f\x8e\xc7\xf0}Vl\xd96\xf3ot;\x80\x1f\xeakԷ`\xf7\r\xb5ZD|\xd3V\xceF\x95+&v\x8b\xf5\xb0\\M\xce\xe0\xd5\x19{\xbcYp\xf7\x94\x15\xc0\x15[P\xaeN\xbe\xbe\x86\x98\xb5\f\xeb]\x92\xb1\x91\xe43\x1b\xb7Tݬa\xf5z\f5\xdfZP6\xb5!\x93\x8c\xfc\xf3d\xe5\xee\xfeTw\xbf\xbf\x9e\xac3*67\xd9ݟ\xd6\xcd\xe2\\\x87\x9e\x1b7\xb1\xaf\xbad\x15\xe5q\x8c\x8eh\xf8(}|\xf4QA,\x17\xc0mF\xc9-\xdb6W\x97\xe9\v\xae~\xa6\xad\xb6\x8d*WL\xe4\x16+\xb6\\M\xd2\xe0\xd5\xf5\xb2ԓ\xd2\xd3ԁ#\xc0n\xed\xb3\x8a\xaa\xf5\xad\xf3\x8bc%\xc3 s#\xc9g6\xb7\xa2eU\r\xd1\xde\xd5\xe2\xa1\xe6[\vʦ6\\\x92\x91\x87\x9e\xac\xf6wL6\xaa\xf2\xc0:V\xa2M\x0fk\xb3M\xfd;\x93k\xc6\xecЁ\xb2\x15\xb4\xa5t\x1f\xe5q\x1a\xb1\n\x86\x8f\xfe\xbd\xa4A\x18\xcby\xa7ڛ\xd1\xc7\x1b'V6\x186\xd0\xf1M[y\x1bU\xae\x98\xc8-Vl\xb9\x9a\xa4\xc1\xabk|7\x97\x12爸\x02\xec־h\xac*\xa9=\xe0)\x19\x99\x1bI>\xb3\xa3\xb5%\x13\xea\x9ev\xe5\xe0\x18>\xae\xb5\xa0lj\xc3%\x19i -\x16\xa6\x99\xb4\x04M\xadCO\x13\xee\x88\xc5\x0f\xc7\x19Q\xe2$Y,\x10Z\x89\xeb(#.\xee\xe5O\x19\xd2;\x92\xf2\x99\x05\xf6\x9e\xcc{\xc9H\x87\x85if-AS\xeaЏ\x9a\xfc\"8\xa4\xdf\xe8:I\x16\v\x80\xbe\x17\xcbd\xfa\x97\xc4ĴI\xefHJg\x16\xdc{\x12\x92\x01\x92F\xfa\x8d\xae\x93d\xb1\x008Y\xbe\xc4u\xd19>\xd2\x133Y\xa4\x87\xa4\xdf2\x8b\x05\x92\x01\x92䤶\xaa\xe7\x17\x15C\x92\xc52\xc1\xd16\xf2\xd8[\xfd\x90\xaa\xfc\x90\xf4Wf\" \x19 I\xb4U\xbd\xe3T\x96$\x8be\x82\xb9j\xaaE\xae\uf2a5\x03\xf9!\xe9\xaf\xccD@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x00\x00\x12@2\x82\xb00u\x11\x9c\xffez\b\xbe\xc7\xfdK\xb6\x8fon\x93k\x92\x91\x93\x9e\xac\xc19sj\xf8\x99\xb6z\fT,Iu\xc8ɡ\xbaҊ\x86=\x151\x12\x167\x87\xe0\xfcE\x81<\xb9\"\x199\xed\xc9\x1a\xa43g\x02\xa6\xad⁊%\xb9\x0e9h+\xadٸu6\x89\xfdi\t\x9f\x1c\x82\xf2\x17\x05\xf2\xe4\x8ad\xe4\xb8'k\x80Μ\x89\x98\xb6\n\x06J@\x92\x1d\xe2\xf8j\xe2\xfc^J\xbb\xabE\xbfF\x13?\x87\x80\xfcE\x81<\xb9\"\x19\xee\xdfw\x17\"x\x17\x86œ58g\xceDL[\x13\x93\x8c$;ı\xacD\xfb\xed\xba5\xf2\x92\x11\x90\xbf(\x90'\\\x92\x91\xbf\x9e\xac\x819sZ=\xa6\xf4\x93\x05\xe5ъz\xe6\xae\"\x1e(\xae2.\xd6&\xb9\x0e\xf1\x03U\xad\x1b}|\xb1\xa6W:\a\x81\xbf\xa8\xa8\t\xa7\xe5\xaaل\xafS+\xf0&\\\x92\x91\xaf\x9e\xac\x01:sZ=\xa6{Joi\xd9\xd5L\xd8H\x8a\aʮ\x8c\x8f\xb5I\xaeC\\@o!\xb7\"!\x99\x83\xc0_TԄ\xe3e\xb1\x9a\xf0uj\x05ބL2\xf2֓50gN\xab\xc7=Uu\xeal\xef\xdd\xf6\x95\xd7@q\x95q\xb1<\xc9u\xc8\x0e8Ν\xd3\xc8\xe6\x10;\xbe^\xaf\x85\xb5\xc9;\xc0\xfa;\xb5\x02\x0fB'\x19\xf9\xe8\xc9\x1a\xa43\xa7\xd5\xe36\xf2\x81\xb9O<P\\e\\\xac\x8b$:d\a\xf4\x16ه-\xb29Ď\xaf\xd7kam\xf2\x0e\xb0\xfeN\xad\xc0\x83\xd0IF~z\xb2\x06\xe7\xcci\xf5\x98[P\x15\x0f\x14W\x99x\xf15\xc9\x0eq\x01\xc6ZFo\x9b|\x0e\xb1\xe3\xeb\xf5ZX\x9b\xbc\x03\xac\xbfS+\xf0 Ē\x91W\x9e\xac\x819sZ=\xdee{g\x89\a\x8a\xabl\x97\xd0g+\xc9\x0eq\x01\xcbJ4\xfb\x84m\xe4\x94t\x0e\xb1\xe3땃\xb5\xc9;\xc0\xfa;\xb5\x02\x0fB,\x19y\xe5\xc9\x1a\x9c3\xa7\xd9\xe3\xee\x8aZvֲh\x89\xd7@q\x95q\xb1\x1cIv\x88\v\xf8j\xe2\xbd\xecZI\xed4\xe9\x1c\x04\xe3땃\xb5\xc9;\xc0:]]\x81\x04!\x93\x8c\xfc\xf3d\rܙ\xd3\xea\xf1\x9e\xe2\x99\x1b\xda\x16\x91\xcd\xd4k\xa0\xb8\xf1\xe5bm\x92\xeb\x90#\xa0m\xdc\xdc\x17[\xeb\x8aޔ\xceA\xe4/*j\xc2њՄ\xeb\xc5\x022\x84K2\xf2Г5hgN\xae\xc7\x1f\xdfw\xed\x84\x1amM\xc4c\xa0\xb8\xf1\xb5cm\x92\xeb\x903\xe0Pݸk\xe6\x1ff[R9\x88\xfdE\x05M8Z\xb3\x9ap%\td\b\x97d\xa4\x81\xd4,L=\b\xcc\xff҇\xa4<\xb3\xd2\xd2\xe3\xfe\xa5\xbf\xc6\x17\b\xc8{\xc9H\xcd\xc2TLp\xfe\x97>$%\x19\xe9\xe8q\xff\xd2o\xe3\v\x04@2\xc2Lr\x92\x01@\n@2BL&\x9d9A\xbe\x02\xc9\b1\x99t\xe6\x04\xf9\n$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$#\r\x0e\xa5Y\xe9\x19\x1a|7\x93$+G\a$L\xaeIF6{\xb2R\xfa\x8f\xa6kJ\xea\x13\xf8RH\x06\x8cX\xe3\x11l:pT\r7\xb9\"\x19!\xf0dU\xa9\xad\xd8\xf0P\xc9i\xd13N2`\xc4\x1a\x8f\xa0Ӂ\xa3j\x98\xc9\x15\xc9\b\x81'\xabzHN\xd6\xd1>\xf7\xaf\xdc\nɄ\x11\xab\x00sH\x82N\a\x8e\xaa!&W$#\x04\x9e\xac\x94\x1e%;bw\nɄ\x11\xab\x00sH\x82N\a\x8e\xaa!&\\\x92\x11fO\xd6ޫ\xf4$\x1fs\xc5r\xae\xa3i7b\xf5jت\x97\x87\x1b\x92\x80\xd3\x11:\xaa\x82\x90\x10.\xc9\b\xb5'\xeb\a\xed[Is;\xfb\xe5sG,\xe7:\x9av#V\x8f\x86\xedzy\xb8!\t8\x1d\xa1\xa3*\b\t!\x93\x8cP{\xb2\xf2'&V,WC?\x18\xb1\x8a\x1b\xe6\xeb屆$\xe0tģ\x03\xc2A\xe8$#̞\xac\xbcd\x98\xb1\\\r\xfd`\xc4*l\xd8Q\xaf\r7$\x01\xa7\xe3\xe5X\v\xc2@\xe8$#\xbc\x9e\xacN\xc90c\xb9\x1a\xfa\xc1\x88Uذ\xa3^\x1bnH\x02NG<: \x1c\x84X2\xc2\xe6\xc9\xea\x94\f3\x96\xab\xa1\x1f\x8cX\x85\r;\xea將$\xe0tģ\x03\xc2A\x88%#l\x9e\xacN\xc90c\xb9\x1a\xfa\xc1\x88U\xdc0_\xaf\x03sH\x82NG8: \x1c\x84L2\xc2\xecɪ_1y\xa7\xcfe\t\xca\xf5\"\xedF\xac\x1e\r\xf3\xf5\n\t:\x1d\x91\xa3*\b\tᒌ0{\xb2\xf6\x96i\x01EGܱ\\/\xd2m\xc4\xea\xd50W\xaf\x88\xa0\xd3\x11;\xaa\x82p\x10.\xc9H\x03iq(M\xabghR\x16i\tt3\xa9z\x93)\x96\xd6\xd1\x01\xe9&\xef%#\x1d\x0e\xa5\xe9\xf5\f\x95\x9f\xa3\f\xffn&W\xaf|\xb1\xf4\x8e\x0eH7\x90\x8c\xd0!=G\x13$\xc9z\x93,\x06\xc2\n$#l\xa4ˈ5\xc9z\x93,\x06B\v$#l\xa4ˈ5\xc9z\x93,\x06B\v$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$\x03\x00 \x01$#\rf\xa5\xd9\xee:\x1a|\x8f\x03%ۇ/\xcf\xc95ɀ'\xab?\xa9سr\xa4-I\x98\xb6f5\xb9\"\x19\xf0dM\x98\x94\xecY9Ҙ$L[\xb3\x98\\\x91\fx\xb2&J\x92\xf6\xac\x1cA:\xb5z\x00\xd3\xd6\xec%W$\x03\x9e\xac\x89\x92\xa4=+G\x90N\xad\x1e\xc0\xb45{\t\x97d\xe4\xbb'\xab\xe5q\xba\x90\x14\xadk\xaa\x9c\\\xaf}\xeb\xdc\xea\xe6B\x12\xddhuފu\xd4\xe0k\xcf*n\xc2\xc6ߩ5\x80$aښńK2\xf2ܓ\xd5\xf68\xfdhk\x11\x99\xba\xaay\xea8\xa6nV7\xd9ފ\xe6\x9fMd\x9d\xb7c\x1dM\xf8ٳz4a\xe3\xeb\xd4\x1aD\x920m\xcdbB&\x19\xf9\xed\xc9\xca{\x9cF\xa7\xa9\x85OW\xd58\xbaI\xa3e\xea\x87w\x03\xeb<\x17\xebH\xd2ǞU܄\x03\x1f\xa7\xd6 \x92\x84ik\x16\x13:\xc9\xc8cOV\x87ǩ\xbe\x88\xb9\x9e|\xc5uS\xdd\xfb\x105:\xcf\xc5:\x92\x8co\xcf\xea\xd1\x04\x87\x9fSk I´5\x8b\t\x9dd\xe4\xb1'\xab\xc3\xe3T_\xe5m'\a\xb8n\xf2\x9d\xe7b\x1dIƷg\xf5h\x82\xc3ϩ5\x90$aښńX2\xf2Γ\xd5\xe1q\x1a]\xc2Jo$g\xb8n\xf2\x9d\xe7b\x1dIƷg\xf5h\x82\xc7ǩ5\x90$aښńX2\xf2ϓ\x95\xf78\x8d^\xa3Ω\xee\x1bj\x1d\xdd\xe4:\xcf\xc5:\x92\xf4\xb1g\x157\xe1$\xbeSk I´5{\t\x99d\xe4\xb7'+\xefq\x1a%\xb7l\xdb\\]ƒ\xb4\xba\xc9w\x9e\x8f\xe5\a\xcaǞգ\t!iL\x12\xa6\xad\xd9K\xb8$#\xcf=Yy\x8f\xd3\xe8\xe3\x8d\x13+\x1b>c\x9bV7\xf9\xce;\xfcP\xb9&|\xecY=\x9a\x10\x91\xc6$aښńK2\xd2@\x02f\xa5\xf2\xf4\x83\xebh\x9c\x9b\\}H\xb8\xc7\xc97a\x92d\r\xfd0| i\xf2^2\x120+\x95\xa6?\\G\x93\x9c\x8d\x8cD{\x9cB\x13\x06\xc9\xd5\xd0\x1f\xc3\a\x92\x06\x92\x11R\x92\x9b\x8dR\xa4\xdeD\xea5\x80\xac\x03\x92\x11JNjk\x88~Q)\x91z\x13\xa9\xd7\x00\xb2\x10HF(\xd1\xd6\x10\x8f\xd3t\x92z\x13\xa9\xd7\x00\xb2\x10H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02H\x06\x00@\x02HF\x1a\x1cJ\xb3\xc7TT\xeb[\xf6\xa4\x03r\x80\\\x93\x8c\xec\xf6d\x8dK\x1a<N\xf5\xbe\xf9\xa5\x93\x86\x86A\xee\x92+\x92\x11\x0eOV!f\xea\x81x\x9c\xee\xe1\u007f\xcd\xca\xea[\xfct\x82o\x18\xe40\xb9\"\x19\xa1\xf0d\x15c\xa5\x1e\x84ǩ=\x0e\x8e\xbe\x89\xd3\t\xd2\\\x95o\x18\xe42\xb9\"\x19\xa1\xf0d\x15c\xa5\x1e\x84\xc7)\xff\x93\xc5\\\xdf\xc4\xe9\x04i\xae\xca7\fr\x99pIF\x98=Y\xd5\x0f\xf5\x86\xab\xae}\xfc\xf1\xabJ\xb7y\xa4\xee\xe1qڽtF\xe9\x1do_\xdb\xc6\xd6i^\xb6VdD&\xa8\x8eq\xb0\xfbƈM\xc7\xdf\\5نAN\x13.\xc9\b\xb5'k\xef̊\xf5\xcd\xc5%\x9b\xeb\xd6x\xa4.\xf68=}C\xf9\x9a\xb6\x85\x84l\xd0\xd7i\xcc\x15\x19\x91\t\xaac\x1c쾉\xd3\xf15WM\xbaa\x90ӄL2\xc2\xecɺ\x8d\x1cdf\x83\x87b\x8a\xd9'&\f\xb7\xc7ic\x19so[\xa2\xce\\\xde\x01\xc4\xc3\x04\x95??\xe0\xfa&\xf68\xf51WM\xbaa\x90ӄN2\xc2\xebɺ\xacL\xfd\xe7cm\x89D\x9c\xba\xd0\xe3\xb4o\x9c\xb66\xf3\x91k\xe6z\x98\xa0\xf23\x97s_\x15\xa5\xe3g\xae\x9a|\xc3 \xa7\t\x9dd\x84דu\xcd\xe8/\xd81χ1\xc5\x1c˟n\x8fӿ\xe9˰ݮ\x99\xeba\x82\xca\xcf\\\xce}U\x94\x8e\x9f\xb9j\xf2\r\x83\x9c&Ē\x116Oֿ\x16\xd6\xfd\xf5`\xf5ܾ\x98bf\xeaB\x8fӾ\x12-\xc3\xc3\xf6\xccՎ\x95<LP\xb9q\xe0\xddW\x85\x1e\xa7>\xe6\xaa\xc97\fr\x9a\x10KF\xd8<Y\x0f\x90k\b\xa9=\x19S\xccJ]\xecq\xba\xa0\\\x9d\x9d}\r\xda\xcc\x1d\xb7Tݬ\x89:k\xe0MP\xb9qp\xf4M\xecq\x1a\xdf\\5\xf9\x86A.\x132\xc9\b\xb3'\xeb\x81\xe2];\xdbO\xba\x8aQ;u\x0f\x8f\xd3\xcf*\xaaַ\xce/\xd6f\xee܊\x96U5D\xeb\x85\xd8\x04ծ\x8c:\xfa\x16\xdf\xe34\xe8\x86A.\x13.\xc9\b\xb3'+}3\xca\x02\xa2w|\xc8\x17\xa3v\xea\x1e\x1e\xa7\xf4\x8bƪ\x92\xda\x03\xda\xcc=Z[2\xa1\xeei\xadob\x13T\xab2\r\xabo\xf1=N\x83o\x18\xe40ᒌ4\x90\xb0C\xa9\f\"S\xd1S\xa5M\xa7Ν;\xbd\xff\xdeɧEE|\xd0W!%1\xfb\x96\x8a\xc7iR\r\x83\x1c&\xef%#a\x87R\t\x84\xa6\xa2\xad\xfa\xfd\v\xb4\xaf\xbc-\xe69\u007f\x92\x9b\xb9z\xdfR\xf28M\xaea\x90\xbb@2\xfa\x8b\x03\x85\xfa\x17:>,\xfc\xc0'RD\xc6fn\xc6\x1a\x06Y\n$\xa3\xbf\xe8k,iڶg[SIS\x12\x1f\xf9G\xdb\xc8co%Q.e2\xd60\xc8V \x19\xfdFߎ\xba\xcaheݎd&\xe0\\BH\xd1Q\xbf\xa84\x90\xb1\x86A\xb6\x02\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\x00\x00H\x00\xc9\xc8iOV\x0eس\x82@\xc85ɀ'\xab\a\xb0g\x05\xc1\x90+\x92\x01O\xd6\xf8\xf4\xa7=+\xc8irE2\xe0\xc9\x1a\x97~\xb5g\x059M\xaeH\x06<Y\xe3ү\xf6\xac \xa7\t\x97d\xe4\xa5'\xab\xe5|\xba\x90\x14\xadk\xaa\x9c\\\xaf}\x17\xdd\xea\xdbB\x12\xddh\xf5؊uԐ\xba=k\x009\x80\x1c!\\\x92\x91\x8f\x9e\xac\xb6\xf3\xe9G[\x8b\xc8\xd4U\xcdS\xc71I\xb3\xfa\xc6\xf6V4\xffl\"\xeb\xb1\x1d\xcbא\xba=k\x109\x80\x1c!d\x92\x91\x87\x9e\xac\xbc\xf3it\x9aZ\xfb\xe9\xaa\x1aG\xdfh\xb4L\xfdto`=\xe6b\x1dM\xa4j\xcf\x1aD\x0e G\b\x9dd\xe4\x9b'\xab\xc3\xf9T_\xc4\\O\xbe\xe2\xfa\xa6\xee}\x88\x1a=\xe6b\x1dM\xa4h\xcf\x1aH\x0e G\b\x9dd\xe4\x9b'\xab\xc3\xf9T_\xdam'\a\xb8\xbe\xf1=\xe6b\x1dM\xa4h\xcf\x1aH\x0e G\b\xb1d\xe4\x87'\xab\xc3\xf94\xba\x84\x15\xd8H\xcep}\xe3{\xcc\xc5:\x9aHў5\x90\x1c@\x8e\x10b\xc9\xc8\x13OV\xde\xf94z\x8d:ۻo\xa8u\xf4\x8d\xeb1\x17\xebh\"U{\xd6@r\x00\xb9A\xc8$#\x0f=Yy\xe7\xd3(\xb9e\xdb\xe6\xea2\x96\x99\xd57\xbe\xc7|,\xdfD\xaa\xf6\xac\x81\xe4\x00r\x83pIF>z\xb2\xf2Χ\xd1\xc7\x1b'V6|\xc66\xad\xbe\xf1=v\xb8\xa4rM\xa4j\xcf\x1aL\x0e '\b\x97d\xa4\x81\x90x\xb2\xeaĹ\xb3Շ \xecYu\x92\xcf\x01\xe4\x04y/\x19!\xf1d\xd5Ia\xba\x06`Ϫ\x93B\x0e \x17\x80d\xf4\x17\xa9y\xb2\xead\xc3t͆\x1c@\x06\x81d\xf4\x17)y\xb2j\x9c\xd4\x16\x19\xfd\xa2\xd2K6\xe4\x002\n$\xa3\xdfHœUC[d\xe4n\xe3\xcc\x04ِ\x03\xc8(\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\f\x00\x80\x04\x90\x8c\xbc\xf2d\r1\xf1\x065\xec}\v\x15\xb9&\x19!\xf6d\xd5ГL\x835jl7\x9dx\x8cN,)\x8f\x0e\xa5\x87\xeaJ+\x1a\xf6T\xc4L\xf3\xb89\xc4\x19T\xbf\xbe\t\xd9U\xb1\xc3/$U\xfa\xa1\x89\xd4\xf0\x9d-\xadE\xc6Ϸ\x16\xd9z\x9d+\x92\x11bOV\az\x92\x81X\xa3\xee\xe1\u007f}+\xb6\x9b.ģ\x13K\x00\xa3\xd3VZ\xb3q\xeblB\x8e\xb8\x9f\xf0\xc9\xc1kP}\xfb&dGi\xac7C\xc0\xa4\xdcĞx?\xa0\x96\x02\tϖ\x16\xd2\u07be\x9e\xacko\x1f\xddb=\x93+\x92\x11bOV\x17Z\x92AX\xa3\xdaC\xe2\xe8\xa6'\x82\xd1\x11\x90\xfa\xe8|5q~/\xa5\xddձ\x92ᗃxP\x13\xe9\x9b\b\x89\x03\x13\xf3\xad!\x8bD\x13B\xf8\x97P\x06\xbf|\x13\x9e-\xeb\xa2\xec\x17\xe9ߦ\xb4\xc4V\xeb\\\x91\x8c\x10{\xb2\xba\xb0%#EkT\xfe\u05cb\xb9nz\x92\x98d\xa4>:\xcbJ\xb4_\x01\\#/\x19\xe2AM\xa4o)b\xbe5\xfa\x1b\xfe%\x94\xc1/߄gK\xef'\x86d|\xd2k\xed\x0f\x97d\x84ٓ\xd5\x11`\x9b\x95\x9e\xb9\xaf2ZU\u007fP\v\xb1\x93\xf4\xb0F\xed^:\xa3\U0010edefmc'\xa1/[\xa7\xfe\"\xefTǐ\U0001eb1f,(\x8fVԳ\xdf9\x17\x8f\x0eo\xa3j\xc7ڤ>:\xd5?\xd2*\xfabM\xaft\x0e\x02\xa3[\xaeo\"3X\x8f\xccN\x97\x10Rh\x9a\xb8qC\"\xf2\x90\xe5\xde\x1a\xe9j\u0082\u007f\x83s/!\xdb|Z\xaf\xd7i\x8a\x1b7߀f\xcb>\xdd\x04\xc7\xca!\\\x92\x11fOVG\x80mV\xba\x834\xed\xd9V_\xb8\x8f:\x92\x14[\xa3\x9e\xbe\xa1|M\xdbBB6\xe8'\xa1橿\xc8;\xd51$\x9c'\xeb\x9e\xd2[Zv5\x136|\xe2\xd1\xe1lT\xb9X\x9b\x94G\xa7\xb7\x90[\x91\x90\xcc!\xd6N\x96\xeb\x9b\xd0\f\xd6+\xb3\x03\xed\xed\xc5\xc6\a,ׄ\xd0C\x96{k\xa4\xab\t\x1b\xee\rν\x84=oV5\xb1z'\xbe\xd1\xed0\xc5\xf5\xc97\x98\xd9bH\x86\x95C\xc8$#̞\xac\\\x00W\xacg\x9b\xfa\xee껉\xfd`:\x97\xa4\xd8\x1a\xb5\xb1\x8c}N-Q%\x837\x0e\xf1\xf0N\xe5\x8fj\xadn\xf6Tթ\xb3\xbdw\xdbW^\xa3\xc3gf\xc7\xf2\xa4::ǹs\x1a\xd9\x1cD\x83j\xf5\xcd\xcb\fV\x94\x19\xa3D\x9f\xcf\\\x13^\x1e\xb2\xd6[#}MXpop\xfe%lf\xc7\x04\r\xday\x99m\x8a\xeb\x9bo \xb3e\x9fi\xb5g\xe4\x10:\xc9\b\xaf'+\x17\xc0\x17\xfbb}\xdd\r\x13\xc9l\xeaHRh\x8d\xda7N{\a~\xe4\x92\f\x0f\xefT^2\xacn\xb6\x11\xeb\x87Gţ\xc3U\xc6źHitz\x8b\xec\xc3\x16\xd9\x1cD\x83j\xf5\xcd\xcb\fV\x94\x19Ø\xcf\\\x13b\x0fY\ueb51\xae&8\xb878\xff\x12\xfem\xf4a\xda;q\x17۴Mq}\xf3\rd\xb6X\x92a\xe4\x10:\xc9\b\xaf'+\x17\xc0\x15\xdbWQ\xb5\xb4\xb5\xbdv6u$)\xb4F\xfd\x9b\xfe\xf9\xdc\xed\x92\f\x0f\xefT^2\xacnr\v\xaa\xe2\xd1\xe1*\x13/\xbe\xa6>:\xc6ZFo\x9b|\x0e\xa2A\xb5\xfdf=\xcc`E\x991\x8c\xf9\xcc5!\xf6\x90\xe5\xde\x1a\xe9j\x82\x83{\x83;^º\xc7i[\x99\ue8edU\xcaLq}\xf3\rd\xb6X\x92a\xe4\x10b\xc9\b\x9b'+\x17\xc0\x15\x9bQ\xc3\xdeN\vT\xc9\xe0\x93\x14Z\xa3\xf6\xe9\xef\xc0ödh\x1f\x04\x1eީܐ\xd8\xdd\xdce[\xa5\x89G\x87\xabl\x97\xd0V-\xf5\xd1YV\xa2\x99@l#\xa7\xa4s\x10\r\xaa\xd57/3XQf\fc>sMxx\xc8\xdao\x8d\xb45a\x13+\x19\xfaK\xb8\xa3\xbc\xf7\xa1\x1fj\x11\xb6)\xaeo\xbe\x81\xcc\x16[2\xf4\x1cB,\x19a\xf3d\xe5\x02\xb8bU\xec\xdd\xd6w\xb3*\x19|\x92bk\xd4\x05\xe5\xea\v\xdeנIƸ\x85CSm\x00\x00\x11\xbeIDAT\xa5\xeafM\xd4Y\x19\xef\x9d\xca\r\x89\xdd\xcd\xee\x8aZ\xf6I\xb5h\x89\xd7\xe8p\x95q\xb1\x1c\xa9\x8f\xceW\x13\xefe\xd7Jj\xa7I\xe7 \xb6\x935\xfb\xe6e\x06+ʌa\xccg\xae\tO\x0fY\xf3\xad\x11t\x13ǛcT\xd9!\x19\xdcK\xd8[\xbec\xb2v^\u0099\xe2\xfa\xe6\x1b\xc8l\xb1%C\xcf!d\x92\x11bOVG\x00owz\xdf\xfaU\xb7\x92\xf2\x96w\xf8$\xc5֨\x9fUT\xado\x9d_\xacI\xc6܊\x96U5D\xeb\x90\xd8;\xd5\xf6z\xa5\\7\xf7\x14\xcf\xdcж\x88l\xa6^\xa3\xc3\r*\x17k\x13\xc0贍\x9b\xfbbk]ћ\xd29\x88\xedd;\t\xcd`=2\xeb}\xbb\xbd\xbd\xb8\xb1\xfd\x8d3\xce&\xfc<d\x83n\xa2\x9e\x94\xba\xac\xf3\x1cop\xc7K\xb8\xec\x862\xfd\xf2=g\x8a\xeb\x93o \xb3\xe5\xfd\xf5d\x9d9\xecZ\x0eᒌ0{\xb2:\x03\xac\xd4\xfb\xd6TG+\x1ex\xa1:Z\xcb%\xe9a\x8dJ\xbfh\xac*\xa9=\xa0I\xc6\xd1ڒ\tuOk\xdd\x14{\xa7ZC\xa2au\xf3\xe3\xfb\xae\x9dP\xa3\xad\x89x\x8c\x0e7\xa8v\xacM\x10\xa3s\xa8n\xdc5\xf3\x0f\xb3-\xa9\x1c\xbc\xecd\x8d\xbe\t\xcd`=2ۯ\xef\xd6F\x92o\xc2\xc7C6\xe8&6\x97\x12\xf3\x05\xd2q\xbd\xc1\xf9\x97\xf0cҤop\xa6\xb8\xf1\xf3\rd\xb6\xf4\xb0gK\xce\xfc\xff\xed\x9d\xcdk\x1cG\x1a\x87\xff\r\x95\xc1\x8c\x91\x05\x8bE\x10h\x1c\x82\x1d\x88\x0f\xc6\x106d/\xc29\x8cN\xc2$\x81\b\x1d,ؕ!\x98\x18\x82ذ>\fYC\xf0\xc5Ɔ\x80C \xe8\xe0\x93M\x0e\x02\x81\x18\x88\xcd\x06\a\x13\xb3X\x84\xb0\x868Ƒ\x8dM\x1c!\xa2\xa1v\xfac\xba\xde\xeayk\xaa\xab\xa7{F\xd5\xf3{ \xc90\xe9\xa9z\xab\xde\xd6o4\x1f\xea'\x1a1\xac\xc1\xaf\xc8(\x81\xa19Y\v#z\xfbӑR\x969\\\x8c\x9b\xea\xf1\xdan\x89̂ޝZ\xfc\x17G#\xd4Յ5\x8c}d\f\xcd\xc9Z\x18\xb9\"\xa3\x8ce\x0e\x97>\x9b\xea\xeb\xda\xda_M\xaf؎IX\x9b\x89\x03s\x84\x91\x11ր\xc8\xf0\x8e|\x91\x01\xf6\x1fOg\xcf\xefَ\x89hn\xb6\x1b\x17\xe3ۣ\x8a\x8cn\r\x88\f\xdfx\xb4.>\xb9[\xe2/1`\xff\xb1+\xde=W\x8f^\u008cL\x8a\x9bԀ\xc8\xf0\x8d\xd3B\x88\x83\x8flG\x81Jќj\xfc\x1c\xdd\x1a\x9d\x14\xb7[\x03\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\x03\x00\xe0\x00\"\xa3\x04\xa1\xe7\xbet\xb2\x0eN\xf1\x1b5\\`u-\x84\xaaE\x86\xd52\xd9C坬\xc1`\x91\\C\xbfX\x8e\x8e\xdd\xc9j3\x9f\xdaG\x88\x19x\u007fau\x1d%U\x89\x8c̖\xc94\xd5w\xb2\x06\x83=\x93\xcf.\x89\xaf\xfe\xe8s\xb4\xd5\xc9j5\x9fZG\x88)`\u007fau\xcdJ\tVתDFf\xcbd\x8aqp\xb2F\x17\x12\xdd\x14\xe9\x8b\x18\xa6`v\x87\x90\xc5|\xda\u007f\x84.\x83\xef/\xac\xae\x99)\xc1\xeaZ\x95\xc8\xc8l\x99L1\x0eN\xd6B\"#\x8b\xf94[d\f\xbe\xbf\xb0\xbaf\xa6\x04\xab\xab_\x91Q\x90eR1\x16NV\x1a\x19\xb6\x89M\v\x82\xd5u\x00\xe5j\xb5\xac\xae~EFA\x96I\xc5X8Y\x83\xc1vw\xd7\xc3ȰMlZ\x10\xac\xae\x03(W\xabeu\xf5,2\x8a\xb1L*\xc6\xc2ɺ\x15?\xd9le\x98ش X]\aR\xaeV\xc9\xea\xea]d\x14a\x99T\x8c\x85\x93\xb53ؽ{\xf7.\a\x91a\x9dش X]C\xf2)W\xabeu\xf5.2\x8a\xb0L*\xc6\xc2\xc9J\xde˰NlZ\x10\xac\xae!\xf9\x94\xabղ\xbaz\x1c\x19\xf9-\x93\x8a\xb1p\xb2\x92ȰNlZ\x10\xac\xae\x11\xf9\x94\xab\x95\xb2\xbaz\x1c\x19\xf9-\x93\x84qp\xb2\x92ȰNl\\\x10\xac\xae!N\xcaUB\x85\xac\xae\x9eEF!\x96I\xca\x188Y\xb5o\u007f\xda&6.\bV\xd7\x10'\xe5*C\xd1S\x8c\xc0\xea\xeaWd\x14b\x99ԩ\xbe\x93U\xfd\x8d\xc9u\xeb\xc4ҸbX]#\\\x94\xab\fEO1\x02\xab\xab_\x91Q\x02\xa5\b=\xf7\x9f\x93upJ٨\xe1\x02\xabktc0\xdf\xda\xd8GF\x19B\xcf\xfd\xe8d\x1d\x9c\x126j\xb8\xc0\xea\x1a\a&\"c\xcc\x18Ud\x80\xfd\xc7(\xac\xae\x88\f߀\x93\x15\xb8S\xa0\xd5\x15\x91\xe1\x1bp\xb2\x82\x1c\x14guEd\x00\x00\x1c@d\x00\x00\x1c@d\x00\x00\x1c@d\x00\x00\x1c@d\x00\x00\x1c@d\x00\x00\x1c@d\x00\x00\x1c@d\x80!\xd2nG\xff\x00\u007fAd\x80a\xb1\xbd\\\x17\xefK\xf9\x91\x98]N_\x83\x00\xf8\x03\"\xa3\x04\x1d\xe7(\x9c\xaců\xa2h\xda'O^\xdfx\xdcI\x8e֍\x933\xa6k\xea\x03\x96Q\x9cQ&\xaa\x16\x19\x9e;Ys;8sIE\t9'~\xb9rtr!\xe3\xc4\xd1e\x83B6Ń>\a\x96H\xcee\xf6\xa55!N\xb7\xe5M!&6l\x87R\xfa\x9c\xa91\xcbB\x88\xc3џ\x06\xe4?\xa3\x8a\xa7*\x91Q\x11'+\xeb\xe0\xcc\xe0\xd5\xcc'\x15%䜸Q\xbfvv2\xe3\x05\x1b~\x10\xdfuo\xdeK.\xd0[\x16\x86\xd2\av\x9c2\xecn\x88ɖܹ)6\x9c~u\xeas\xa6\xc6<i\xb5\xae&\x1b\x95\xf7\x8c*\x9e\xaaDFU\x9c\xac\xdc3\xb6ݫ\x99W*J\xc85\xf1\xef\xe2\x8al\xf7^\u007f\x97\x87\xe4D\xf9\x91a*=\xe3oDN\xec\x88@\x0f\xf2Xd݈.\xb6Ȑ\xdaF\xe5=\xa3\n\xa7*\x91Q\x1d'k/v\xaffIRQ\xebď\x84\xc3\xef\xf9C\x8d\fk\xe9\x05\xb2#6\xa6vK\x8f\x8c\"Ϩ\x81\xf0+2*\xe8d\x95/\x96f\u07b8pafJwp\xb2rU\x9b0U\xbf\xb7k\xf1$\xf5\xa6\x8b\x8cQ\x13\x9f\x13\xb5\xeb\xf1\xf6Y'ޛ\x89\x0e\xf8D\xea\x82W\x93>tS|ߝ\xf0\x81ؔFH\rj\\C\xe75\xb8=\xa3+f\x97I\x1b\xc0\xa2\xe9o9\xa3j'2\x1e\xff\xedf\x14\x19N\xf5\xd6>\xfeG\xa2FUg*\xb9\xa9g+\xa3\x93\xe5ڢ\x9fg\xdd\xc1\f\x9dσ_\x91QA'\xebީ\xfa\xd5\xe6\xa1\xc9/\xe7/S\a'/W\xb5\tS\xb5{\x13\x8b'\xa97]d\x97d\xe2\xc0\xd7Yo~q\xa4\xb3}\xf6\x89\xff\xdb\xfaF4[\xc1\xa5\xdc%\x11\xbc\xf2\xfa\xd0?\x9fo\xceM'\xa7\xfc\xde\xccܝ\xdfL\xaf\x11H\rd\\\xbe\xf3\x14vϴ\x15s\xcb\xd4\x1a\xc0A\xf5\xb7\xacQ5\x88\x8c+\vQd\xb8\xd4\x1b^\xe8\xfb\x9b\xbf\x86jTu\xa6қzd0:Y\xae-ڊ\x93\xc1L\x9dρg\x91Q='\xebZ\xf0\xe1\xc1U\xd1\xfd\xa2B\xec\xad\xe0\xe5\xaaVa*\xb9\x97\xbaH\xa9\xe6S+\x92\x10O,kӝ\xa7ޥzt\xacm\xe2\xe4\x85\t\x11\xbc\xf2\xfa\xd03\x9d'}\xf2\"f]\x90k\x97\xf7\xa0j \xe3\x9a:\x9f\xc0\xefYjŽ\xcbL5\x80A\x99qx\xa3j'2\x9e\x1fz\x1eF\x86K\xbd\xb2v\xb2sR\ue798\xd3\xceTrS\xea\x91\xd1{F\x99ڒ\xdc\xd4\x063u\xde\x15\xef\"\xa3jN\xd6\xd5i\x19\\.\xbe\xfb\xc6I|J\xf3rU\xab0\x95\xdcK]\xa4T\xf3\xa9\x15IH~\x96\xce\xca\xe4M\x1f\xeb\xc4꽌D\xf0jЇ\xfe\xba~\xed\xe4kɋ\xfd\x9d\xfa\x9bW6\xcc\x17\x86\"5\xa8qM\x9dO\xe0\xf7,\xb5\xe2\xdee\xa6\x1a\xc0\xa0\"\x837\xaav\"C.\\\x89\xde\xcbp\xa8W\xd6>\v\xfe}M\xfcN\xceTzS\xa6##}F\x99ڒ\xdc\xd4\x063u\xde\x15\xef\"\xa3\xd7\x11\x199-}u\xb2^\x9ex\x11\xfc\x98=\x8c\xffO\xf7\x94f\xe5\xaaVa*\xb9\x97\xbaH\xa9\xe6S+\x92\x90\xfc,%ۗa\xe2$2\x94\xe0լ\x0fm)\xe3\xc6=\xd1\xf7+\f\xaa\x062\xae\xa9\xf3\nv\xcfR+\xee]f\xaa\x01\fdKX\xa3j\x10\x197\xdf\t#é^\xa5FUg*\xbd)\xf5\xc8\xe8=\xa3LmInj\x83\x99:\xef\x8aǑQ\r'\xeb\xaf\a\xe6\u007f}p\xe2t\xf7en|J\xf3rU\xab0\x95ܫ\xb9H\x89\xe6S+\x92`\x8c\x8c~\x13'\x91\xa1\x04\xaff}h\xf6OLT\rd\\S\xe7\x13\xf8=K\xad\xb8w\x99\xa9\x060(\xfd-oT\r\"cwj#\x88\f\x97zc5\xea\x97\xe2\x0fr\xa6қRߨ\xde3\xcaԖ\xe4\xa66\x98\xa9\xf3\xaex\x1c\x19\xd5p\xb2\xde\x17G\x85h<\xed\x1e\x12\x9fҼ\\\xd5*L%\xf7j.R\xa2\xf94}\xfa\xc8E\x86u\xe2$2\x88\xe0ը\x0f\xe5#\x83\x91\x8a\x92\x1aȸ\xa6\xce'\xf0{\x96Zq\xef2\xf5\x06p\xe5(\xfd-oT\r\"C\x9e]\n\"å^Y{#x\xd3\xe7TC;S\xc9M\xa9m\x14sF\x99ڒ\xdc\xd4\x06+\xeasg\xcf\"\xa3zN\xd6\xfb\x876\xbem=\r\a#\x0eNV\xaej\x15\xa6j\xf7R\x17i\xb7\xde\xd4ú\xa8\x89\xb5\xed\xb3M\x1c}b\x12^ߞ\b^\x8d\xfa\xd0\xfb\xea\x17\xeb\xef\xd5筽RQZ\x83\x1a\xd7\xd8\xf9\x04v\xcfh\xbd\xfc2I\x03\xd8r\xa8\xfe\x965\xaa\xeen\x88\x9b;\xb25\x19D\x86K\xbd\xb2&\xe6\xefn̅jTu\xa6\x92\x9b\xbf\x05\xdf\xfe\xbc\xd2jEoAp:Y\xae-Z\x8f\x93\xc1\f\x9dσ_\x91QA'\xeb\x9dZpo\xed\xbd\x87\x9a\x83\x93\x95\xab\x1ag\xeb\xaeB\xbf\x97\xfaP\xe3z\xd3\x0f\x8bQ\x13k\xdbg\x99xo:\xbcy0\xf8\x14\x96\n^M\xfa\xd0\xe7\a?|\xb0\xddi\xc6\xde\xf6\x8f\x1fԶ\xbbs\xf7HE\xb5\x1a\x92qO\x1b;\x9f\xc0\xee\x19]1\xbfL\xd2\x00ɕC\xf5\xb7\xacQus\"\xf8\x86N{\xaeޖN\xf5\xcaS\xcd\x0f\xff\x12\xabQə\xaan\x9e\x8d\xca\x15\x1f\x05w\xf3:Y\xa6-Z\x8f\x93\xc1\f\x9dσ_\x91Q\x02\xa5\xe88\xb3;Y\x9fM\xad<\xfb\xf3\xcfW?\xbc\xffZƿ\xd4\xe0)e\x15Es\xebT\xf8\xf3sF\x88\xe3\xe4\xf3\t\a\xa9h\x19\xa4\x1b0\xe2rLd?\xa3Jg\xec#\xa3\f\x1d\xa7\x83\x93\xf5V\xf45\x02ٞ]\xef\u007f\xa0\x85\x12VQ\x02\xcf\x1et\x9eS\xb7\xef\xff\xa6\xeeq\x92\x8a\x96\x81ހ\x91\x97c\xc0\xe1\x8c*\x1dD\xc6h\xb9\u007f \xfa\x85\xf8\xe1\x01\xf55\x8aq\"\xbbT\xb4$\xf4\x06\x8c\xbc\x1c\x0f@d\x8c\x96\xf6\xf2\xe4\xca\xda\xe6\xda\xca\xe4ʾy\x16\x19/\xd0\x00W\x10\x19#\xa6}{\xfe\xf5\xda\xeb\xf3\xb7q\u008e\b4\xc0\x11D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x02u\xe9\"2\x00\x00\xfdH\xb9t\x11\x19%\xd8L\xf7\x93A\x93\xa3\xf8\x15\x83\xea\x92v\xe9V-2<w\xb2\xc6E\xde\b\xaem0;\xff\xa3\xed\xe8|8\xf8[՞\x95a3\xe5i\x8aZ\x90\xb8\xdf\x1e\x16Mۡ\xa5Qn\x032B\x9c\xacFr\xb6e\x10\x97nU\"\xa3\"Nָ\xc8?\xbe\x12\xffnݘ\x9b\xe8#\bʏ\x8b\xbfU\xedY\x196S\x9e\x17\x8b\x87\x83\v\xf54&\x17S\xd7ʴ+b\v\xa3\x90\x06\fZ\xaf\xe6d50\x02\x97nU\"\xa3*Nָȭ \xd9ۧOX\x8e̓\xa3\xbf5ٳ\x8c\xcfI\x01ݝ\xcc\xc9\xea\xc2\xe1W\xf2\xf7Ʌt\x9dVEl\x01tK/\xa2\x01\x05\xd4k7Qrm\xb1N<\x90K\xb7*\x91Q\x1d'\xab\x8a\fM,P\x18\x8e\xfeVfϬ<\xecw\x89\u007f;\xab\x8b\x8d5\xf9\xf5\xfcb:2\x8a\xba\xdem?\xba\xa5\x17р\x02\xea\xb5G\x06\x87u\xe2\x81\\\xba~E\x86\xcfNV^\xe8\xa9\xd9AU\x91\xd1\x19\xbb\xf4\xba\xa4ǒ\x11Ή\x83WVz\x84\x9e\xda`\xac>\x94\xacإ\x1c\x17\x9b)\xd9Iݒ\xfaY\xb4g\xda\b\xc4ߪX]\xbc\xfa\xbe\\\xb8։\f\xe2C\xd5z\x9cԻ\xd5\xd9\xf5\x85\xf61!\xa6\rW\xc61\x99pw>=9\xf5\xde\u007f\xdeX\xd7\x0e&\xa5\x1b\x1a\x90<L3\xb5r\x1d\xd2\xea\xe5\xe0+\xd3\x1a\x9b\xfc\xb8\x92\xed\xa3C\x8cƥ\xebWd\xf8\xecd兞\xd4\x0eJ\x8a\xdc\x12\xdf\xee\xfe\xfc\xa9\xf8\\\xab\x81\x8c\x10<\xec\xf8\xe7\xcd\xe3\xbaГ\x0e\xc6\xebCɊ]\xcaq\xb1\x99\x92\x9dTS\xec\xde9\xb6\x12\xecّ\xefv\xe8\b\xd4ߪX]|2\xf5\xf2\xd0v'2\x88\x0f\x95WĶ\xef6\x0fܕ_O|m\xba\xa6\x99\xc1\x84\xfb\xea\xad\xd9\xcb\xeb\xe7\xc2+3\x13H\xe9|\x03\xd4è\xa9\x95\xed\x90V/\a_\x99\xd6\xd8$2\xc8\xf6ic\x8cĥ\xebYd\xf8\xecd兞\xc4\x0eJ\x8a\xdc\n\x9f\a\x96\xda\xfa\x14\xd4:Z{\xb33ѫc\xbaГ\ff\x98M\xadإ\x9c\x80\xec6\xd3d'i\xbd\xcd\xe0YoiY\x1f\x81\x8ac\x15\xab\x8b\xf2\xed\x959\x19\xbe0a\xe5m\xb4\xde\xf6ٹ\x17\xc7\xfa~>řp\x97\xa7\x83'\xd3\xf3\xa9\xc8 \xa5\xf3\r\xa0\x0fS\x95\x19:d\u007f}\xc0UF\x1a+ɋ\x02\xb2}:\xc3w\xe9z\x17\x19\xfe:Yy\xa1\xa7\xb2\x83\xd2\"\xb7\xc4\x17\xdfߞ\x9b|\xac\x1fK\xad\xa3ћ\x98Wu\xa1'Q\x8d\x1afS+v)' \xab͔\xec$\xad\xf7\xc9\xc4Or\xefȆ>\x02\x15\xc7*:\x91qI\\\xea\x13\x19ڂv\xdf9\xda\xff\xe3BƄ\xdb>\x1c=7\xa7\"\x83\x94\xce6@{\x98\xaa\xccС\f\x91\xc18zIc%\x89\f\xb2}:\xc3w\xe9z\x17\x19\xeb\xbc\xe9\xd2\a'++\xf4T\xf5\xd2\"×ү\x0e\\\x93\xfa\xb1\xc4:\xca\n=\xad\xfaP\xeaou(' \xab͔\xec\xa4fI\x9d\xbf ףw\x1c\xd4\b\xfcۋ\x9d\xe6\xbe\xf8\xf4Y\x9f\xc8\xd0\x1d\xa77\x19\xfb-\x851\xe1>\x89rn'\x15\x19\xa4t\xb6\x01\xda\xc3Te\x86\x0ee\x88\f\xc6\xd1K\x1a+\xe9[\x8fj\xfbt\x86\xef\xd2\xf582|s\xb2\xf2BOU/-2z\xf7\xed\xc8E\xa9\x1dK\xad\xa3\x91\xd0\xf3\xba.\xf4\xa4\xde@~6\xb5b\x97r\x022\xdbL\xd5Nj\x96\xd4۳{g\xff\x9e\x1aa\x831\x80E\xcd\xed\xa0\"\xe3_\xb5\xf0\x0e^\x11\xfb\xb4\xfe\xcf\xe3/\x99Q\x12\x18\x13n;Z\xccO\xe9\x17&\xaat\xb6\x01\xda\xc3Te\x86\x0eQ/,\x0f\xe7\xe8%\x8d\x9542\xd4\xf6\xe9\fߥ\xebqd\xf8\xe6d兞\xa4^Rdt\xc6\xd6\xcf?\xf8\x9c\x1eK\xad\xa3\xb5\xa3\x9dH\xday\xab\xa1\x8b7\xd5`\x86\xd9Ԋ]\xca\t\xb0\xd9L\tݝ\xd4,\xa9{\xb3\xb7_\xdbH\x8d\xa0\x89c\xe5\xe3\u007f\xff\x12\xfe\x97F\x86\xf2\xa1\x1a\x14\xb1{s\x17\xe5J#n\"gTeM\xb8\x1f\xccv~\x1c\xdaK=\xefe$\xa5\xf3\r\xa0\x0fS\x95\x19:D\xbd\xb0\xd9+#\x8d\x95\xf4\xc7Um\x9f\xce\xf0]\xba\x9eE\x86\xc7NV^\xe8I\xeb%EF_\xd2m,,\xbfM\x97IG\xa8\x89w\u05fe<\xa1\v=u\x9b)3[@w\xc5.\xe5d\xb1\x992h\x96T\xb9\xfa\xd6t\xf0ޠ\xd6!*\x8e\x95g\"\xff\xdf˥F\xf0f\xfevc\xe9%\xf5\xa1\xaa\x1eS\x1f\xea\x9ds\xf5'\xf2\x97#\xe7\uf13f\xb3\xf7\x1aU\r&\xdc\xed\xfa\xb1\xab\xb7\xce\x1cꍌ.|\x03\xe8\xc3He|\x87H\xbd\x0e\x95\x91\xc6\xeaN\xd6x\xfb(\xa3q\xe9\xfa\x15\x19>;Yy\xa1\xa7VoRd\xf0ՏK\x9d1O\xcc\xde&\xc7j#\xd4.,\x1fI\v=\xe9`\xecl!\xf1\x8a\x1d\xca\xc9d3eЦ\x90\xff\x13\xe1s\xaf\xae}\xa5\xe2\xd8\x1b\xf5k\xc1\u007f\x9aB\x04\x1fF\xad\x04\xdf~!>TV\x11\x1b\xbc\x83\u007f^~,D\xf4\xd5\xee^\xa3\xaa\xc1\x84+_,\x1f\x9bl\xdc7F\x86\xa1\x01\xf4a\xb42\xb6C\xb4^\x87\xcaTc5'kw\xfb(\xa3q\xe9\xfa\x15\x19%P\x8a\xcdt\b\x06\xcd\xe4M\x18g\x8aZ\xb1\xabNv\xa76\xd0_ld\xc2ͨ\x9a~\xfb3#\xb9\x1e\x96\xb92Sc\x87\xb1}<)\x97\xee\xd8GF\x196\xd3a\x184\xf3GFQ+v\xd5ɮ͔\x1d\xa3\xaeF\xd5\\?\xfb\xb9\x1e\xe6P\x99\xa9\xb1\xe5o\x9f\x19ͥ\x8b\xc8\xf0\x94\x01\"\xa3 \x9ct\xb2\xcd\xcdv\xe3\xa2\xed\xa0Aq5\xaa\xe6\xf8\xd9\x0f\xc8\xf10\x87\xca\xd8\xc6\x0ee\xfb2\x82\xc8\xf0\x92\xa7\xe1\xdb]\xb6\xa3\xca\xc5\xc5f\xba+\xde=W\xcf\xf8\x9b\xf9\xd0x\xb4.>\xb9k\xaf=M·e\x83o\xec\xbe\xda>D\x86\x97\x84ow=\x96\xa3\xc5\xc5fڜj\x18\xff\xdabT\x9c\x0e\xde\x04\xb4\\\u0086!\xe7òah\xec~\xda>D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x01D\x06\x00\xc0\x81\xff\x03&\xf2B\xcdI\x1b+\x96\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"analysis/typeinfo-src.png": "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\xc1\x00\x00\x01\xb3\b\x03\x00\x00\x00\xf9m:\x11\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x02\xfdPLTE\x00\x01\x00\n\x03\x01\x05\a\x03\x02\r\x14\n\f\b\x10\x12\x0e\x0f\x13\x1e\x1b\x1a\x14 \x1f\x19\x1c \"\x17!;!# #$\"$%#&'%'(&+)\x1e()'\x18-T*,)/,!-/,12053'35386*6758:7<:.<>;>@=CA5&CxAB@EFDIJH\x00g\x00KLJ\x00j\x026NzNOM0R\x95\x06m\x06UP?PRO>V\x82\x0fq\vTVS\rr\x17\\WEVXU,`\xae7]\xad\x15w\x1c[]Z8`\xaa\x19y\x1e;b\xac_a^=d\xae?f\xb0*{!bdaSe\x84)}+Bh\xb3efdDi\xb4ghfLj\xafpiQEm\xb1ikh0\x820Ol\xb2Ip\xb4lnkTp\xa3Kr\xb7npm6\x869Nt\xb9zs[Wu\xb5>\x89=strZx\xb9vwt]{\xbbG\x8eHy{xX\x80\xbf^\u007f\xb9\x85}ea\u007f\xbf}\u007f|O\x93N\u007f\x81~c\x84\xbeW\x95V\x82\x84\x81m\x87\xbch\x88Ð\x86h[\x99Zj\x8ać\x88\x85q\x8b\xc1\x8a\x8c\x89`\x9dd\x96\x8cnt\x8e\xc4z\x8f\xbf\x8f\x91\x8eg\xa1hy\x93\xc9~\x93\xc4x\x95Ē\x94\x91\x81\x95Ɵ\x95w{\x98ǃ\x98ɂ\x9aė\x99\x96u\xa8v\x86\x9b̀\x9d̙\x9b\x98\xa5\x9b|\x85\x9eȂ\xa0ϙ\x9e\xa0\x9c\x9e\x9b\x89\xa1˞\xa0\x9d\xab\xa1\x82\xa0\xa2\x9f\xa1\xa3\xa0\x81\xb0\x83\x91\xa5ʕ\xa5Ď\xa6ѣ\xa5\xa2\x91\xa9Դ\xa7\x83\x95\xa9Χ\xa9\xa6\x8c\xb4\x8a\x94\xac֪\xac\xa9\x99\xadҟ\xaeλ\xae\x89\xad\xaf\xac\x9d\xb1֯\xb1\xae\x98\xbb\x97\xa3\xb3ӡ\xb5ڧ\xb6ֱ\xb5Ĵ\xb6\xb3\xa3\xbf\x9d\xac\xb7\xd2ķ\x92\xaa\xb9ڢ\xc1\xa4\xb7\xb9\xb6\xb3\xbcĭ\xbcܺ\xbc\xb9\xa6Ũ\xb1\xbd\u05fd\xbf\xbb\xb1\xc0\xe1\xb8\xc0կǫ\xcd\xc0\x9a\xc0¾\xb7\xc2ݻ\xc3ؽ\xc4ڲ̷\xc4\xc6ú\xc6\xe1\xc0\xc8\xdd\xc7\xc9żκ\xd8ɝ\xc6\xca\xda\xc0\xcb\xe6\xc9\xcc\xc8\xc2\xcd\xe8\xbf\xcf\xe2\xcd\xcf\xcc\xc4\xd0\xde\xcb\xcf\xdf\xc8\xd3\xc1\xc8\xd0\xe5\xe1ѥ\xd0\xd2\xce\xc8\xd7\xca\xcb\xd3\xe9\xd2\xd4\xd1\xd2\xd3\xdd\xce\xd6\xdf\xdfש\xce\xd6\xec\xcc\xda\xce\xe6֪\xd6\xd8\xd5\xcb\xdb\xee\xd5\xdc\xd1\xd3\xdb\xe4\xd6\xda\xea\xd9\xda\xe4\xda\xdc\xd9\xd2\xde\xec\xd9\xdd\xed\xdc\xdd\xe7\xd7\xe1\xdc\xe0\xde\xe2\xdd\xe0\xdc\xdb\xe0\xe2\xf0\xe0\xb3\xd6\xe2\xf0\xdd\xe1\xf1\xe0\xe2\xdf\xde\xe3\xe6\xe0\xe4\xf4\xe3\xe5\xe2\xe1\xe6\xe9\xde\xe7\xef\xe8\xe5\xea\xe5\xe7\xe4\xe6\xe7\xf2\xe4\xe9\xeb\xe7\xe9\xe6\xe2\xea\xf3\xeb\xee\xea\xec\xed\xf7\xe6\xef\xf7\xe8\xf0\xf9\xf0\xf0\xfb\xf0\xf2\xef\xf4\xf2\xf6\xef\xf4\xf7\xf4\xf6\xf3\xf2\xf8\xfa\xf8\xfb\xf7\xf6\xfb\xfe\xfd\xfb\xff\xf9\xff\xff\xfe\xff\xfc\x11\n֍\x00\x00 \x00IDATx^\xed\x9d\r\\T\xe7\xbd\xe7\xef\xb2\xcd&\xbb\x0f\xcc4w.s?e\x8a\xbd\xbc\xe8z-[\xb2z>\x8c#\xd6-h\x16#,6\xd7\x17\xbc\x94+\x95h\xae\xa2\xb7Jbȍ\x8e\x91\xd8\x05\nac\x12r'\x161vg\xbd)+\x91\x98b,\ti41\xb9\x96H,-\x9b\x17\x92\xb6c\x1a-&\xd4\x13\x93[\xaf\n\xfd\x9c\xcf>/g\xe6<g\xe6\x9cy\x81\xe1\f\a\xfeߴ\xe3\x993\xcfy\xce\x19\xf8\xce3\xff\xf3\xf6\xe3Ϥq#\x02@\xe2\xf9\xb3H\x9e\xea\x13\xa9k\x000\x000\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01sc\xb4\xc1\xde\xde\xc0d\x8f\xdbC\xff\xf5u\xec\xaf\xdb\xdf\xe1\xd3[\x02\x00\xc2a\xb0\xc1\x83\xee.\xff\xe4P]G#\xfd\xb7\xb1\xb5\xb7\xafw\u007f\xe3\x90\xeeB\x00\xa0\x8f\xb1\x06\xf77+\x06{\xda\xfb\xa8\xc1\xde\xe6a\xfc8\xdcܡ\xb7\x10\x00\x84\xc1P\x83\xbdno]\x97<\xddS\xef\xeb\xa7\x06\xb7\xb7\xd2\xe7\xad\xed:\v\x01@8\f5\xd8\xe7\x13\x1b\xbb\xe4ɺ\xd3b\xbf\\Ex\x87\x86\x87\xbcPE\x00\xe3\xc2P\x831~\x83=x\xc8e\x06\x8b\xbev\xb7\xdb\xdd\x06{r\xc0\xb8H\x90\xc1\xbd\xf5>\xbf\xc1\xc3\xedͽ\xfd\xbd\xcd\xed\xc3\xe1\x16\x03\x00\x1d\x12c\xb0\xaf\xaewdd\xa4\xafq\x04Ow4_\x14aO\x0e\x18/\x891\xf8\x8c\xdbO\xbfX\xd7M_\xe8\xae\v\xb7\x18\x00\xe8\x90\x18\x83\xc5ABO\xfd\xe0\xa0\b\x06\x03\x13\"A\x06S\xe4\xa3i\xb4\x8a\xb8\xd8\fGӀ\xf1`\xa8\xc1\xbe\xfe\xfezo\xff {2\xd2\xdfS\xdf?\x84g67\xf7\xf4\xf547\xc3\xc1\b`<\x18jp\x17\xab}\x99\xab\xfdd\xb2\tO\fw\xee\xafo\xed\x84C\x11\xc0\xb80\xd4`\x00\x88;`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\xa6`$R\x83\x99\v\x18<\x0eF\x86GF\xf0\xff#5\x8b\x17\xfd%ihI\xa4F3\x1608fzggf\xe6eef\x96\x1bu=hf\xa6\xbb\xbd/R\xa3\x19\x8b\xd1\x06k\xa4N\x8dt\xb7ֵ*\xb3\x8d\xe2!A8\xa2\xf3\xd2y\xa7\xb0J\x14\x8f9\x05\x86S\xd5n\u0602rs\x93l\xb9s\x936\x1a\xa3p\x0fj\x8b\xd4d&c\xb0\xc1\x1a\xa9S\xa2\xa7\xbe\xbb\xaf+\x90\x84\xa2\x857܋\xb1\xf2\xe2\xab\xec\xdf\xf7O:[t\x9a\\y\xf9\x01\x97(>)\x9c<y@8p\xf2\xe4\x82'\xf9\x17}\xb7l\x93\xa4\xdek\xd2\xe8\x97\x16E\x11q\x11˦\xeb\xb4\xedBp\x13l\x18\x8c5X+u\xaa\xbb\x8e\x88p\xba.̀6\xb7P\xff\xb5\x98\xa9\xd8\xee\x9fr\xe9\x19,\x8a-\xd8\xe0\x03NQ|UxY\x14\xf3\x0f\xf0/\xf92\x93\x92\x92\xc4¤\xa4/UGap,\x9b\xaeӶ\x13uj\xce\a(\x86\x1a\xac\x99:\xe5aߑ\xfc\rt\xc1̎A\x83\x88\xac\x8b\xd6\xe0\xcb\xe7e\x83\xcf_V\xbd\xd6_\x96\x85\r\xbeeѶ\xde(\xee+\x89e\xd3uڂ\xc1a1\xd4`\xcdԩV/\x9d\xd1\xea\xd1Yȃ\x18\xb3\xd9\xe4\x06\xb1\x1a?6\x97\xa1\x94ڕ\x0e\xfb\xa2ӴMc\x8e-C\xbdc\xf5\xe9\ngCqы\xbb\v\xaa.\xe1gW~T\x91\xbfj7\x9e:&\x97\xb6\x15\xa4\x8dk\xdf\xeeU\xf9\x9b\xde'\x93W\x0eT\xe4\xaf;p\x85L\xbe\xbf\xa3\xa8`+\xa9\"\b\xd4`\xb6X\x83\u0602\x1f\x8f<$8\xff\xd7\u007f\xc3\x06\xffǮ\xc1a\xa5_\x15\x1dy\x0e\x8b=/]\xb5\xe9\xdd)\bm<\xbd<ݖ7\\\x86\x92\x1b\xc53\x16\x94I\x1b\x9f)\xb4[\xd2\xf2\xfa\xf9\xb6Ax\xc1\xe0p\x18j\xb0\xa8\x95:\xd5\xd1H\x86\xb2\x8b\xf5\xfbu\x96\xf0ux3r\xbd^\xb2\v\xe8\xebp\xac\x19\x14\a\xabS;|\xbdM)(}[u\xba\xad\a7)I.\xf3\xd4\xdag\xab\x0eo\xbdX \xec\xae\x12\xee|r\x05)\x01v\n\xbb\x8f\x1f(ZwE\xbc\xf4\xf2\xc9UU'O\x9e|\x9b4q\t\xab\x8e\x1c[\xb1\x95L\xeet5\x1cop\xed\xc0S\xe7\vV=sl\x93\xa06\xf8\xd2\xcb\xc5\x0f\xfcZ\xfcuK\xc1\xc9Ko\x1eq\n\xff\x19\x1b\xfc\x1f\xfe\xf70\xd7/O\x17*\xd9\xdf\ueda3aզ77\xa5g\xa4:ʗ\xa3\xbe~\xaf\xa5\x1a\x8f\xac%V\xd2\xd8k\x9b]\xd3^\x8dj\xf8\xb6<Ã\u07b9vc\xf6\x18MJ\x82\f\xe6R\xa7|\xf5\x9eA_\u007f\xab\xbbY\u007f!\xe5뵚\fQ%%dҚ\x8e\xbb\x18r䐡\xae^$_\xb6\xea\x1e\x8av\x88Džc\xe2\xce\a\xc9\x10\xfa\x8cHl\xa4\xc7\x14\xb8*\xa2\xe8\xb7X\xc2\"<u\\8\xee\u007f\xacZ\x85\x87\xd4+k\xd5\x06㲂\x8c\xda;v\xd2\xc5J\xff'1\xf8\u007f\f\xab\xfb\rඓ\x8fdm*}\xc2U\x06\xb3\xd1|\xbc\xc5\xc4F+6X\xac&\x06\xfb\x1cy\x17I`\xd1PP\xdb\x00K\xf0\xb0\xac\xf7\xed\x04\x10\x12c0\x9f:%\x0ey\xdcnw\xa7\xa7U\u007f!\xe5Wۇzċ\xa94Zº\x81<֢!q٬a\x82\xa3D\xb5P\xd1\x11\xec\xd6%q\x1f\x1eXw\x94^\xfe\x14SL\x05\xe4\f\xc6rӊWܹ\x96\xceX\xf5\x80x\x81J)6\x04\x1b\xfc\xfe\x827\xc4\xcb\x05/\xd2\xc5\x1a\x9aI\x15\xf1\xd7\x17\xd4\xfd\x06\xe8s\xa4\x97\xb9\xbbEV$\xf3\x06[\xfd\au\x15\x83=\xa8[YP\xcb\xe0\xbe6w&\x8c\xc1\xe1H\x8c\xc1|\xea\x14\xc674\"6\x869d\xc4\xfdj\xf3\xca\xc56:\xc61\rp\x91\xd8%f\xc9%\xa4\xfa\xbcU\xd1q\xf1U\xa7H\r^+W\xbf\x9b\xc8\xfc\xa0=9jp\x05}E\xdcT\x81\x95=)\xfa犜\xc1\xe2\xa6}\xe2\xf1\x82\xcbl1f\xf0\xab\xea~\x15\x86܅\x99(\xad\x86N\xf3\x06\xcf\xf5O)\x06\xd7\"\xceN\x9d=9\xa8\x83Ò\x18\x83\xf9\xd4)6X\x9df.kC\u007f\xb5ut\x04\xf3؇Y\x11!Z\xcbȣ\x1b+\xb0|V\x17eP\xb5\x101\xd8%\xcac\xf0\xab\x94\vd>5\xf8\x99wE\xde\xe0\x9d\xa5\xa4\x94\xbdR\xbaS\xfc\xad@\x0f\x9d\xed\f1\xf8\xd8\xd2\xcb;\xd9X\xebڭ\x8c\xc1\\\xbf\x01\xba*ER\xf7\xda\xdc\xe4\t\xb7銠\xd4\xe0\x8d\xc4\xe0\xf6\x901\xb8.\xe4\xec\x1b\x1c\x8b\bK\x82\f\xa6\xb0:\xb8\u05cd\xcd\xf35yu\x16 \xe4\xe6b\xe7Y\x99;l\xf7\xd8Y>\x955\x8dT\x95\xb3\xf0Km\xec\xa5\r\xdbT\vq\x06\x1fg\x95j\x03=3QU%\x8a\xbf\xa63\x14\x83Y\x83#\xa4\x0e\xae(\xc6>\xbe\xed\n1\xf8\xf2\x9dǖ\xd2\"Bt\xad\xf0\xd7\xc1\xaa~\x03T\xb3sh\xb9k裲\xe9\x8a\xc16\xec\xf8\xc8\\Z\a\xa7\xe5\x92\x0fpYYP[\x1e08,\x86\x1a\xac\x99:u\xda\xdd\xd5\xd7\xdd\xe8\tW\xebU[kZ\xe7\xdb\xd8\xe0T9\x8b\x15\x11\xa2\x15\xcdn\xae˰\x9f!\xf3в\xfd\xad%\xa8\x91_\xe6ͥ\a.\x1dq\xbeyiG\xd5\xfbX\xe3\x05;\x8e\x1c\xdb\xc9|kq\x1d8V\x95\xff\xae\xf8\xeeI\xe7\x03/_y\xe3\x01\xe7I<\x1e\xef\x10\xf6\x1d\xdb'\x90c\x11o\xe6\x17\xb74,\x15\x9cϼ\x89\x9f\xbcq@8 \x9f\xc2\x13\xf7\x95\x16|J'\\\xc2\u007f!\x06\xff\xdfau\xbf\x01\xaa\x91\xadڃ7\x87~&\xfd\x9b>\xdcI\x0f5\x9c\xa1-r\xec۶堔\xfa^\\\"ܞ\xe9\xf6\x94\xa1:\xbem\x10pN.,\x86\x1a\xac\x9d:ս\xbf\xde\xc3}\x97jp\xb1\xccn˕\a\xa2\xd3h%\x9b\xb0\x96\x97\xa4:\x96\xb3ڣ-\xd7n\xcfU]=pe\x85 \x1cY,\xe4\x1f\x11\x04r\xb8\xecx՝\x05U\xc7\xe9+\x97w/uU\xbdJ\xaf\x8b\x10\x9co\xe4\xe3LJ\xc8\xf1\xe0\xb5\xf9k\xd9\xf1\xe0\U000db596\xee{\xc6I\xe6^\"\xaf\xe6\xcb5\xc2\xdb\u0083lµ\x9b\x1e\x0f>=\xac\xee7@cn\xb5Ò\x96˾T\xfc\x9bޝLK\xf5<:\xf3t\xae-5o\x03Bd\xe4=]\xe8H\xcdiU\xb5\rb0\xa5\xb0{а\v\xe1L\x87\xa1\x06\xc7\x03\x9fU\xae7؞\x9cq\\r\xb1\"BޓK9\x1d\xc5\x19\xb9\xf8К\x19\xbc\x97\n(\x98\xce\xe0f\xb9\x880\xdc\xe0#w\xb2\"\xc2x\x83\xf10\xdc\x1df?w\x86c.\x83\xab\xbd\xe2|\xbf\xb8\x11\f\x16&\x91\xbf\"u\xf0_\xf3s\xc2n\n0\x99\x98\xca`\x1f\x9a]\x96\xc6.\b\xeb\xf7ZJ\xc2\xee\xa2\xeb\xd97q\x9c\u007f\xf5\xe7\xd8\xe0\u007f\xff\xe7\u007f\xedT\xe6\x85\xdb\x12`R1\x95\xc1b\xb5-W\xben\xa0\f\xef\x16Y΄o\x1dGZ\xf2\xab\xdefS\x0f\t\xff\xc9\u007fu\xe5~\x03\xeb\b@\x0fs\x19<\x15\xa0W\xb8_\x95\xa4\xd1[\x96Dq}00ـ\xc1\xb1\xe2C(7\xf7\x96\xb4ܹI+\xc1\xe0)\x00\x18\x1c+\xc3^\x87\xdd>\xcbn\xb7\xcf\xef\x82+n\xa6\x00`p\xcc\\\xec?s\xfa̙ӧ\xfb@\xe0\xa9\x00\x18<\x0eHV\x84\x81y\x11@8\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06'\x8c͛\xb5&\x81\x181\xda`\xf9^\\_=\xbdβ\x9e\x9e\xd5\xeao\xado3͕+-\x82\xf3\x18\xfe\xe7x\xbe\xa0\x9f6\x11\x15\xff\x92}\x9f\xc6$\x10+\x06\x1b\xecO\x9d\x1arw\xf7c\xe8\xc5\xee}u\xde3\xdeЛk\xa6(\x17v\xe4W\xe1\u007f\xaa\\;\xd4\xf7\x16\x05Ҭ\xa2\xe5\x9e9\xefhLF\xcbs\xafL\xb4A,ĵ\xb38c\xac\xc1\x81ԩ!w\xc0ؑ&r\vBG\x93Y\x0eN\xed۔\u007fA\xbc\xe0ڴ/h\xbe\x92f\x15\x15o)\xe3\xee[\xe3\x18\x82\xef\xfa\xeeD\x1b\xc4B\\;\x8b3\x86\x1a\xac\xa4Nq\x06\xf7\xd2\xc44_\x9d\xf1\xe9\x95\xe3cߎ\xaa#\xe2\x8f6\xed\b6x]l\x06oV\xc6\xddͱ\x0f\xc1\x91\x9d\x8a\xd8 \x16\xe2\xdaY\x9c1\xd4`%u\x8a3\xb8\x9d\xdd\x1d\xe4\tw\xab\xe7\xe4prS\xb1\xf3\xceM\xc5W\x82B\xa5\x9e\tdQ\x89\xe7\xb7\xde\xe9,\x92\xa7\xfd\xec\xdbq`\xab\xb8\xe9\x006\x98\xe6\xb7\xcaI\xad\xf2U\x964\xcd*\x90E\xf5\xa6S\x106])\x16\x84\x02u\xf2\x9a\x18~\b\xfe\x87\xec\xecG7/\xfc\xc6w\xdf\x12\xc5W\xb2\xb3\xb3\xf7\xbcu\xcf\xc29\xab\xc9W\xd4Swͻ\xeb)\xfc\xef\xff\xc9f\xdcE\x9b\x1fZ=\xef\x9b\xf7\xb1\xf3\x83o}\xf7\x8e\xec;\xfe\xf6\x1du\x83\x17V/\xc43\x17\x8aA\xf8\xdbr\xfd\xe2\x15\x1f\u009b\x93\xfd-:\xf9\xd4}ߜ\xb7\xfa\x97zkSm\x99\xce*\f\xc1P\x83EQ1\xb8}\xbf\xbb\xa9\x83\xfc\xdc[\xd9}\x8c\x1da\x12O&\x877\x16\xec8r\xfc\x99;\x85O\x83C\xa5\x8aZ\x9e,\xa0YT/\xe6W<y\xbcEPEWb\x83\xdf\xcf\xff\xad\xeb]l0\xcdoeI\xad\xaa4\xab@\x16Օ\xd7[\x84\xd7\xc5\x1f-\xf8\xd1\x1b!+ߜ\xfdK\x8dIƿ\x1c\xca\xce^\xb8g\xcf\xc2y\xaf\x88\x17\x0f\x1dZ\xf8\xcdy\vﻇ\xb4\xd9<gϏ\xf7̹\a\x8f\x04/\xbc\xf0\xcd\xd5/\xbc\xf0\xc2[l\xf1\xfb~\xfc\xe8\x1dw\x11ß\x9bwף\xcf\xed\xc9~T\xd5\xe0\x95\xec{\x0e=\xf7\xd4\x1d\xd9AUZ\xa0-\xd7\xef;/d\xef\x11şn\x9eö\xe1\x8e=\x8f\xce\xfb\xae\xde\xda\xf8-\xd3Y\x851$\xc8`\x9f\xbb\xb1\xa7\xafw\u007f\xf3\xc5\xc0\x9c.՝\xc6Fp\xa0\x88\xdc6t\xa0\x80\xdc\xdfɇJ\x15\xe01w\aɢ\xba\\\xbc\t\x8f\x9d\x97\x8f\xa8w\xd9\xf6\xed\x10\xd7>P!\xd2*B\xb9_\x9f\xab\"\xf8,\xaa+;+.\x14\xaboƧ\xfc2{\xb3\xc6d\x809\v\xf1g\xfb7\v\xbfM\xa6\xef\xca^\xcdª\x9e\xcb~N$\x8f?\xa6s\xfd\xdf\xeb?\xc6\xc3&\xb6\x8e<^\\\xb8zX\x14\x87\x0f\xfdF\xd5\xe0\xa9;\xe8\xf0=O\xbd\x06\xae-\xdf\xef\x1cl\xb0\xb8g\x0ei1\xe7\x1b\xf8Cs\xcf\x1d\xa2\xaa3nmܖi\xaf\xc2 \x12d\xb0\xd8C\x8b\xdf\xfa\xce@v\xa5\xd7\xf01\xf8ݢ\xd2\xddϼq\x85~\xc1\xf3\xa1R\xc4c9E\"t\xec\xa4\x06?)<\x19\xc6`U\x16\xd5\xe5u+6\xa9\x83\x01)\xff\x90\xfd\x96\xc6d\x809\xb4\xaex*\x9b\xb8x\xd7\x1cy\x88\xde\xfc-\xfaϷ\xa8\xf0\x01\xa7\xbe\xbb\x90\xfcQ\x8f\x91\x85\x9b\x89^\xdc!\x83@\x83_ޱ\xf0\x1f\x9ezE\f\xba\x1a\x9fk\xcb\xf7\xcb\x1b\xbc90\xa9\xb96n˴Wa\x10\x892\x98AJ\x87v\x16l\xd7ڮ\xd5|R\xb9\xf0\xcc\xf6U\u008a'\xa9`|\xa8\x94([y@\b)_Ej\xf0\x85}\xbf\x0ec\xb0:\x8b\xeaH 3\x85\xe3\x9d9\x9b5&\x15\xa8H\xe2\vԲ\xbb\xee\x92g\xaef\x1a\xfd-\x1b\x99\xfdN\xdd%W\xa9\xf8\xf9\xa3\xd9\x17\x95.\x94\x9d\xaf\xdf<\xf5\xddoe\xdf\U00068a02k\xcb\xf7\xcb\x1b\xacLj\xae\x8d\xdb2\xedU\x18D\x82\f\x96\xb5\xf5zHf\x0f\x1d\x8e݆\x1f\x8bxu\x1fv\xf7\xc2\x11\x17-s\xb9P\xa9\x80\x95/\nZ\x87xI\b\x10F1\xb8\x813\x98\xa4Y\xa9\xb2\xa8\xde/j(\xfemH\x1f\xf7)\xe3\xee}\x1aCp`\f&?\x99\x80=\x9bٞ\xd2Be\f~\x8a|\xcf/|\x85Bˁ\xe01\x984x\x85\xf4\xf5\x9bCs\x9e\x12y\xb8\xb6|\xbf\xe1\f\x0eZ\x1b\xb7eګ0\x88\x04\x19\xec\xa1i\xc1C\xf5\xdd\xe4x0)#\xbc\xc6\x1f\x0fn\xa1\x91\xabb\xd5\x03\xe4\x91\v\x95\n\x18|\xa9\xa8\x8a\f»w\xd3\xf9}\xdb\xd8my\xbc\xc1\xf9\xf8\xe1J\x0538\x90f\xc5gQ]\xaeh\x11\x1f\xa8\n.#\"\r\xc1\xe2\x9c;H\x81\xb9p5\x99\x0e\xaaA\x0f\xb1:x5~\xed\x1d2\xe39V\x93\xee\xc1\xbe\xf9\xee \xb5\xadx\xdf}\xaa\x06{h\x99+\xaeV\xaf\x87k\xcb\xf7;\x0f?\x1f\xf9v\x88\xc1Zk\xe3\xb6L{\x15\x06a\xa8\xc1J\xeaT\x9f\xbb\xedt_W\x1d\x1d\x89\x13uN\xaeE\xc8o9vl\xa7\xc0ĕC\xa5TYT/\xbaV\x1d8\xbe\x9b届\x8bX\xe0\xceowT\x91\xd4\xc0w\xabv\u0875\xa2\xe8ɖ\n9\xa1ʟf\xc5eQ]~\xf9\xa1\xa2\xf7\xc5\xf3\x05\xbb_V\x97#\x91\x86`qN\xf6]\x87\x9e\xfa\xe67\xde\x12G~J\x8f\x03\xb06\xf7d\xdf\xf7\xe3\xfb\xb2\xef\xa1\xd3{\xe6<zh\xf5\xbc_\xd2\x1e\xee9th35\xeb\xb99\xdfz\n\xb7xJ\xd5`O\xf6\xbc=?\xc6\r\x9eS\xaf\x82k\xcb\xf5\xbb\xfa\x8eG\xf7|;;\xfb\xd0+０\xbd\xf9\xa7\xe2+\x9b\xb3_xG{m\xfc\x96\xe9\xac\xc2\x18\f5\x98K\x9d\x1alo\xaa\xf7\xf4\xb0\xd9\xfdmu\xad\t\xb8.\xe2GU-\xc5\u03a2*9\x89G\x0e\x95ReQ\x89oo/^\\q\x8c5\xa8\xb7\xd30\xca\x16A \xd5\xc6\x03\x02\xb9.\xe2|\x95k\xf1\xa6\x06\xd6֟f%*YT\xc7q7\xbb\xc5݂\xb0\xe0E~\xc5\xef̻Gc\x92g\xce}\x9b\xe7\xddq\xcf;\xec\xa8+\xe6o\xd9\xecG\xe5㶘\xe1\xfb\xbe1g\xf5O\xe9\xe4s\xab\xef\xf8\xc6j:0\x8bo}w\xe1\xbco\x1fR78\xb4z\xcf\xc2\xec;V\x87\xd8ŵU\xfa}k\xf5\x9cy\xab\xf7dgo\xdeLV\xfb\xca<\xfc\xb0Y{m\xfc\x96\xe9\xad\xc2\x10\f5x*\x13\b\x95\x9a|\xf6d\xff\x8b\xc6$\x0fۓ\x03\xa2\x01\f\x96\t\x84JM>\x91/\xab\x04\x83\xa3\a\f&\xb4\xbcx\xa5j\x82\x17K\xc6\x1508z\xc0`\xcc%\xa1\xe2\xa1\"\xf5\x99\xb7D\xc2\xf6\xa2\x80\xe8\x00\x83\tJ\xa8\xd4T\x80\xeeEi\x1d\xa2\x004\x00\x83\x01s\x03\x06\x03\xe6\x06\f\x8e+I\xe6\"\xd2\xdb1\x03`p\\I\xfa\xc8L\x80\xc1@0`\xb0\xe1\x80\xc1q\x05\f6\x1c08\xae\x80\xc1\x86\x03\x06Ǖ\xa8\f\xe6\x1b=rk\xd0\"!3\"\xa1\xd7<\x8an\xc0` \x98\xa4h\xcc\xe1[\xdc\xf6à\x17Cf\x84!)\xf0\xa0\xf9b\xe0\x90\x83N\v0x<h\xa5N\x05\xe6N-\xcaPr\xc8\xdf8\x969cA\x99\x9a/De0OH\xebX\x16\x8f`p\xb8Wً\x81\xedf\x99\x01\xa6\xc4`\x83\xb5R\xa7\x94\xb9S\x03o\x17\xfb\xb7\xdfk\xd1\xfd\x93u\x9d%V\xcd\xf9\xf2\xc0w\xeb/\xb0\x1f\xbf\xba\xe5\xe7I\u007f\u007fۿ\xbb\xed{D\x96G\xbe\x9ct\xdb\xdf\xf8\xc5\xc1\xff\xfbǿH\xba\xe5\xeb?\xff\x88\x8d\x90\xa4\xd5\xdf˯\xa9f$\xfd\x9d\\S\xe0\x8e\x92\xbe\xfc\xc3\xefݖ\xf4\x95\x9f(\x9d\xb1\xf1\xd5\xdf\x15\xd7\xcd\xf7Ȅ\xdf\xe0\x9f\xe8o\x8cb0\xcb\f0%\xc6\x1a\xac\x95:\xc5͝\x1a\xcc\r\xfc\r\xfa0\u007ft\xb1Z\xcf`:\xea}\x8d\x88\xf2\xbd\xff\xfaQҭO\xfc\xea\x89[\u007f\xf0\xd1G?\xfc\xf2\x0f\u007f\xf5\x93\xaf\xfd\x8db\xf0mO\xfc\xeag_\xff:k\xfdȭO\xfc\xe2\x89[\x1f\t\xbc\xa8\xccH\xfa\xea\xcf\xe4\xb9_\xf9ɯ\xfe\xfb\x97\xc8\xc3\u05f8\xce\xd8\x18\xec\xef*\xb0\xd4\x0f\xe8Z\x03c\xb0\xfe\xc6\xf0UD\v\x18\x1c\x05\x9a\xa9S\xdcܩ\xc1\xec\x89\x1b\xfc\xc4m\xf8\xe1\xab\xff\xfcQ\x12\xd1\xf2\x91\xaf\xe2iR\xdd\xfe\xec6\xc5\xe0\u007f&\xcfoa\xad\xff\x92\xb6\xfaK\xc5\xe0\xc0\fڌ\xce\xc5C\xef\xcf\xe9×\xb8Θ\xc1\xfe\xae\x02K}\x85N\x04\f\xd6\xdf\x1808V4S\xa7\xb8\xb9F2\x9cf\xd9\xe0px\xcbRsi`Sc\x8e-\xa3\x1cOy\x10c6\x99i-/ϰ\xe5\xb1-u϶e\xd1ی\xc4\xfe\xe5\x0e{\xa1n\x15\xc1\xb4\xfa\x8bG>\xfa\xc9W\xf04\xf9r\xff9\xb6\xeb\x16~\x97*P,\xcb\x13\xb7\xf8[\xc9\xf3\x94\x19I\xbf\xf8H\x99\x1bx\bt\xa6̥\xb3\x03+\xa3\x13\x81\xf9\xfa\x1b\x93t\x80ރ\xfa\xfe\x8e\xa2\x82\xadPEDIh\xea\x147\xd7P\xbc\xa9\xa8|>\xb2oK\xab\xc1OJ\x92\xcb<\xb5\xf6\xd9#\xa2\xafÛ\x91\xeb\xf5\xb2]K+\xcaljM[B&K\xac\x1b=\x1b\xad\xcb\xf1\xd4\xe9Ԍ\xfa\xd6<\x14\xde\xe0\u007f\xfc\xcaG\u007f\xf3\x8f\x9c4Ir5\xe0\xb7*Z\x83\xb9E\x94\x87@gQ\x1a\xac\xbb1I.r\xdf\xf5\xf9\x82U\xcf\x1c\xdb$\x80\xc1\xd1\x11\x9a:\xc5\xcd5\x96\xb4\xe5x\xc4\xf5\x88%+\xc9\xc8[\x8fgt\"z쁫\"\xc8\x1fq.\xb1\xe3\xa96\xd4\xe6\u007f̝\x85?w#Y\xe1\r\xfe\xe8\xd6\x1f\x92\xaa \xe9\x11\xfc\xf0\b\x1e\xff\xfeR\xdeQ\xf3[\xa528L\x15\xc1-\xa2<\x04:S\x1b\xacWE\xe8oL\xd2q\x128P\xb5\xea\x12ޕ[\v\x06GGh\xea\x14?\xd7PҚ\xb1\xb3>\xb1r\x99(.\x9b5Lp\x94\x90\xf9\x9c\xc1XnV\U00056c03g\x99%\xe2\x10\xa2\xb5\xc4F]\x83o\xfb\x01\x91\xe3\xef\xd8ξ\u007f\xe7\xe9\x89[\xbe\xf7\xf3_=\xf1\xb5\x80x*\x83\x1f\xa1\xad\x1e\t\xbc\xa8\xcc\xd068\xd0\x19]U\xa0\xab\xc0RA{r\xfa\x1b\x93$\xaez@\xbc\xc0\xd2\x04\x1a\xc0\xe0\xe8\bM\x9d\n\x9dk\x10imb\xa7E\xa4\x06g\xc9\xd5/-\x18\x82\xf6\xe4\xa8\xc19\x8b茼\x1c\xb1\vќ7\xfd=\xb9Gn#%\xe6/\xbeD\xbe\xaa\xc9A0v\x00뉯~)\xe9\xabO\x04tT\x19\xfc\x11i\xa5\x1aW\xfd3\xb4\r\x0etFW\xa5\x98\x1a\xe8\xe6{\xb7rG\xd3>\xd2ߘ$qS\x85\xf8\xaap\x92l9\xec\xc9EIh\xea\x147\xd7X\x88\xc1Vf\xf0\xf2Y]\x14z|\x9a\x1aL\x13X\x14\x83Kf\xd1E\xd2\x03c\xb0\xfe\x9e\x1c㑯\a\xfcI<z\x1b\x93t\xa5t\xa7\xf8[\x96.\xbb\x13\f\x8e\x8e\xd0\xd4)n\xae\xb1p\x06\xb7\xb1\nx\xc36\xf2\x98\x9b+\x8a\x83t\x86b\xb0\x87>o\xc6e\xb3\x98\xe3\xc0\xc5\xf1\xe9\xdb\xc3\x1b\xfc\xb3/\xffL[\x9aD\xa0\xbb1IGH\x1d\\Q|A\x14\xdfv\x81\xc1Q\xa0\x9d:\xa5\xcc5\x94^{\x8d\xaf\xd9\xd2\xe3[\x96\x8b\x87\xdbJ\xb4l\u007fk\t\xa2\x19\xc6\xd5֚\xd6\xf9\xb6>rN\xae\xa4S\xec*\xb1x\xfb\xf1(\x9d\\\xe9\xa9L&\xc7\"zl\x8e\xea\x8d\xf6\xe4\x94z\xad3\xe1\xb2%I_\xfa\xc1G\xda\xd2$\x00\xfd\x8dI\x12ȱ\x887\xf3\x8b[\x1a\x96\xca\xd9Y\xe6\xc3P\x83\xb5S\xa7\xb8\xb9\x062\x92\x86PS*\xb25\xb3\xea\xb7-\xd7n\xcfe\u007f\x0f\xe1b\x99ݖ\xdbI\xae\x8b@\xc8\xd2cÏexnm\x96-\xab\x96\xbe~z\x91=\xbd\xbc>\x85\xce\rfJ(\x1b5\xf2\xf1\xe0\U000db596\xee{\xc6I\xb3\xb3̇\xa1\x06O\u007fLfp\xa4\xb7c\x06\xc0ฒd.\"\xbd\x1d3\x00\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807F\x1b\xac\x91:\xe5\xf36\u05f5v\x0f\x87_nr\xa8\xb1\xd6\xe8\xbfؚ\"\xdf{\x94\xb2_\xbfQ\\\xf9\xed\x03+\\\x9b\xae\xd0?\x18*䟏\xd4:\x98cN\x81\xe1<\x12\xa9\xe9t\xc2`\x835R\xa7|\xf5\xad=}]\xf5\xad\x89P8˒\xa5\xffb\r\xf2zkQ\xad\u05cb\xc2h\x1eW\xaa\x8a\x0e\xec̿ \x8a\xef\x9f<y@x9l\xd3\x17_\r\x99\xf5\xa4@\x16;p\xf2\xe4\x82'5\x16\x98\xb6\x18k\xb0V\xeaT{3\xf9\xab\xf6C\x89\x88\xed\xf1%/Oֿ\xb0\xbe\xd6Bn\xc0\xef\x14E[\xadn\x9b\xb8rA8 ^\xb9Ħ_\x8d`p\xc5\xf6\x90Y\a\x9c\xf2b\xf9\a4\x16\x98\xb6\x18j\xb0f\xeaT+\xfb\x8e\xf6\xdf\xf4i$^\xd4\xcd\xee<\xd6\xe4\xe2\x19\xd9\xe03\x17u\xdbĕ\xf3±\xc0t$\x83ׅ\x1a|\xf9\xbc\xbc\xd8\xf9ˡ\xed\xa7/\x86\x1a\xac\x99:\xd5Ϧ:\x8c*69\xaa\x1d\xa2\x83\xdc\xccٍ+ލ\xa7\x97\xa7\xdb\xf2p)3\xb8\xdc\xee(/\xb7\xdb轟\xd4`\x96E\xb5A\xacƏ\xcde(\xa5v\xa5þ\xe84\xed\xc1\x1fV\x15\vo\xe2z\xb5\xe1\xfc\x8eRצOE\xf1ʏ*\xf2W\xed\xc6\x03\xef\xe5;Y\x11\xbb\x9b5\n\x18\x1ch\x809\xbf\xf5NgѦ\xf7\xc5cr\xc1[\x11ҷ\xbc\x18i\xd0 \xb6\xe0\xc7#\x0f\t\xce\x03\x0f\x16-\xddt>\xb8\xb3邡\x06\x8bz\xa9S\xa28Ҥ?\x18N\x1a\xf3\v\xc5\xc2\\\xfc\xaf\xaf\xb9)=#\xd5Q\xbe\x1c\xf5\x89Ùi\xb5\xd5V[]\x1e-~e\x83}\x1d\x8e5\x83\xe2`uj\x87\xaf\xb7)\x05\xa5o\xabN\xb7\x91\x9b\xfc\x02aU\xb1p\xf9ȑ\xe2U\x8b\x8bw\xefX\xf0\xae(\xee\x14v\x1f?P\xb4\x0eﾽq\xf2\x88\xd0r\xf2们Q\xc0`\xa5\x81\xf8b~œ\xc7[p\xa9q\xe9哫\xaaN\x9e<\x19\xfawH\xe5\xc5.\xbd\\\xfc\xc0\xaf\xc5_\xb7\x14\x9c\xbc\xf4\xe6\x11\xa7P\xdc\xd2R\x9c\xff\xa6\xba\xb3iC\x82\f\x0eJ\x9d\xc2Cp\xfd\x90\xde\"\x93ƈ\xadF\xac\xb11\xfdf\xa3\xf9\xf8\xe3\xe4#w\xd4w\xe3\x12\x18\xb1\x9bP\xfd\x06\xe3\xe1\x9aD\x01\x96\xd0L\x1fk:n6\xe4\xc8\t\n\xab\x8a\x85uB\xd5\x05\xf1\xca\x052X>#\x12\xef\xe8\xd1\x03\xad*\x82kp\xb9x\xd3e\xe2?\xfd\x03\xd0\x1aU\x04\xbf\x98\xd8B\xc6\xe7\x1d;ɤ\xab\x14/q\xa1\xb8\"hmӅ\x04\x19\x1c\x94:%v\xf2y\xc2Fэ:|\x1d\x88EV̶\xca\x1bPIb\xd2N#9L(`p\x1fv\xfabj;\x99\xb4n \x8f\xb5hH\x1dV\x15\v\xeb\\\xf2P\xbb\xa3\xf4\xf2\xa7\x98b\xaa\x9a\x96\xc1\\\x83\xe3\xc2\x1b\\\x0f\x11\f~\u007f\xc1\x1b\xe2\xe5\x82\x17ɤ\xab\x81<\x1e\x10.\xa8\xd76]H\x94\xc1\f9uj\xd8\xebNğ!\xa8\xa5G{ف\x86\xd9s\xe5\x995h\x90$\xa0\x04\x8f\xc1b^\xb9\xd8f\xa7G\xfcX\xaa\xb0\x17u\xa9êba\x9d\xbf\x82]+W\xb4\x9b\xc8\x13-\x83\xb9\x06\a\x04n\x0f-\x92\xc1\xe2\xa6}\xe2\xf1\x02\xba\x80\xab\x85<\x9e\x14^U\xafm\xba\x90 \x83U\xa9S>Oc\xbf\xee\x02\x93H\xe1\xec\xce\xceN9%-\x10\x96֗\x9c\xd7ם\x91#?S\f\xf6؇Y\x11!ZiP\x84\x1b\xf9\xd4aU\xb1\xb0n\xab<\xb1\xa3\xf4U\n\xad\f\xb4\xc7\xe0@\x83\x17\x05\xee\x1805\xf8\x99w\xc5 \x14\x83\x8f-\xbd\xbc\x93\x8d\xb5.\xbas\xf8\f\x1d\x83\xb9\xb5M\x17\x12d0\x9f:5Լ\x9f\x96\x14\xfa\vM\x12\x8er\xfcP\xee\xa0\xd3\x01\x83\xbbP\x1aB\xb9\xfeO\x94b\xf0\xb0\xddc\xa7E\x84hM#\x15\xf3\xacܠ\xb0\xaaX\b\x8c\xa0\xc7YM\xda@\xcfAh\x19\xcc5\xb8TTE\xc6\xd4\xddTȪ*Q\xfc\xb5\\\xd0\xf6m;\x13\xbc\x189\xb6ql)-\"D\u05caKx\xe1Ҫ\xa0\xb5M\x17\f5X3u\xaa\xaf\xae\xb9\xaf\xbf\xbf\xbf#\xe6ݡ\t\xe2\xf3\xa0\r>ѷ\x01\xb5]\x1c\ue931\xd7ԃnk\xbb\xc7\xeb\x17\xb8\xab\x16\xd5v\xc9ӕ\xb3X\x11!Z\xd1\xec\xe6\xba\f;i͇UEͧ\xaf\xd3#\t\xe7\xe9\x93}\vv\x1c9\xb6\x93\x98ŎE\xbcL\x8e\x13\xbc+\x9f\\{W\xd5@|ѵ\xea\xc0\xf1\xdd,,\xb5\xc5u\xe0XU>\x1b\x83\x17\xa1<\xb9\xeb7\xf0b\xfe\x81z_i\xc1\xa7t\xc2%T\x1cyfU\xc1\xdb\xeaΦ\r\x86\x1a\xac\x99:\xd5\xc6f\xba\x8d>\xa3\xd1N\x8e\xee\x8a\xfb\xf1c{w2-g\xa9\a\x1d\x162i\xc9%\xdb\xe6#\x91S6\xf9\xcb\xe14Z\xc9&\xac\xe5%\xa9\x8e\xe5Lr.\xac*j\xdeT\x15\xa3ǫ\xee,\xa8:\x8e\xc7\xcc\x02:\xd7ID\xdb)\u05eb\xdb\xf9\x06\x98\xb7\xb7\x17/\xae`\xe3\xf4\xe5\xddK]U\xb2\xac\xf5v\xf6\xe7\x11\xc4K\xf9x\xa1|\xb9Fx[x\x90M\xb8v\xef,(\xda\xf1\xaejm\xd3\bC\r6\x01\x83\xb65\x83\xc3\xc3C]K\xec\xc1U\x8d\xcf*\x1f\xb1\x0e\xf3\xf7a\xa6\x12\x97\\\xac\x88\x90\xf7\xe4\xa6-`\xb0\x9aV\xbb<a\x0f\xfeNh\x96\x8b\b\xb3\x18|\xe4NVD\x80\xc1\xbaD\xeaڔt%\xb3\xe3h=\xc9\xdd\xfc\xecj\xaf8\xdf/\xae\x19\fny\xf1J\x95_\\0X\x8fH]\x9b\x93\x12ۚfo\xf3\x1a\xdbJ~\xa6\x0f\xcd.Kc'\rY\xaa\xf0\x14\xe7\x92P\xf1P\x11\xab\x87\xdf?\xe9|\xe0\xe5iu\x1a9\b08\x18O\x9e\xc3\xe2\xc8\v\xaa!\xaam\xb9\xf29\x17\x9a*\x1c8z5Uiɯ\x92/\x9ax\x88\xec\x1e\x9e\x0f\xdb\xd8܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb91\xda`\x8dԩ\xfe\xb6\xa6\xba\xe6\x0e\xc3/p\xaf'WQ\xda\xf3\xba\xf4[\x94\x90k+O\a͜\xcc,*H\x9d\x1a\a\x06\x1b\xac\x91:5\xe8\xf6\xf4\xf6\xf5\xeeo2Za_=\xda\xe6\xad\xcf\t\x13y\xd2GR\xa7\x82\xaf\x81\x98\xcc,*H\x9d\x1a\a\xc6\x1a\xac\x95:u\x86N\xfa\x8c\xbf׳\a\x91K\xd3s3µ\xe9\f1x\x12\xb3\xa8 uj<\x18j\xb0f\xea\x14\xbbAn\xd0m\xf8͞\xcc\xe0Z\x14n\xf0\x0f5x\x12\xb3\xa8 uj<\x18j\xb0f\xea\x14}\xa1\xaf\xd9蛌\xfc\x06/gwz\xfa\xe3\xa3ԡR~\x83\xb9\xd4)\xed\xb9\xb1dQA\xeaT\\1\xd4`Q;uj\x90\xec\xd3\x19]\x06\x13\x83=\xbe\xdeJDo4\x0e\xc4G\xa9B\xa5\xb4R\xa7\xb4\xe7ƒE\x05\xa9Sq%A\x06\xabS\xa7\x06\xfb{\x9a\rߓ\xc3\x06\x13\x96\x93I>>J\t\x95\x12\xb5S\xa7\xe2\x90E\x05\xa9S\xf1#A\x06\a\xa7N\x89\xc3\xcd\xed\xda\vL\x1e=\xa8\xa6ӓc#W\xab\xf3\xf1QJ\xa8\x94\xa8\x9d:\x15\x87,*H\x9d\x8a\x1f\x892\x98AR\xa7\xe4\x1d\xa2n\xb7F\xebI\x85\xd6\xc1C\xc9d\xbd||\x94\x12*%j\xa7N\xc5!\x8b\nR\xa7\xe2G\x82\f\xe6R\xa7\x1a\xd9\x01\xd9\xee:\xbdE&\v\xb6'\x97J\xcc\xe3㣔P)Q;u*\x0eYT\x90:\x15?\x12d0\x97:\xd5D\x03C\x12RE\x905\xa7\x95\xf7lS\xc5G)\xa1R\xa2v\xeaT\x1c\xb2\xa8 u*~\x18j\xb0f\xea\xd4iw{o_oB\xf6\xe4\xe8\x19\x8d\xbc\x92,U|\x94\x12*\xd5'\x9f}c\a\xfe\x02\xa9S\x13͢\x82ԩ\xb8b\xa8\xc1\x9a\xa9Sb\u007f{s]kg\xdc\xcf\x0fD\xa2\x19\x97\xaa5\xd8\xe3\f\x9am\xa2\xc4G)\xa1R%rA\xcbB\x01\x03\xa9S\x13͢\x82ԩ\xb8b\xa8\xc1\xa6@/\xd0$\x90:\xa5=w\xca\xe5\xa0@\xeaTD\"umR\xf4T\f\xa4Niϝr\x06C\xeaTD\"umR4U\xe4S\xa7\xb4\xe7N-\x83!u*\x1a\"umJ\xb4C\xa5\xb8\xd4)\xed\xb9S,\x8b\nR\xa7\xa2\"RצD'TJI\x9dҞ;ղ\xa8 u*\x1a\"u\r\x00\x06\x00\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01sc\xb4\xc1\x1a\xa9S\x98\x1e\xc3\xff\xa2gt\xf4\xe4\xd9Җy\xd3Tw[pYT\x9a\xb1T\xb1\xd2\x1e\xf2\x97\xeb\x80X0\xd8`\x8d\xd4)\xf2\xac\xae#\xb6?Ml\x10m\xb6\xb9\xee\xe6,\x84T'\x94\xb9,*\xcdX\xaaX\xf1\xd84\x02ؼ]\xa1\xf3\x00M\x8c5X+u\n\xe3i\uf6ca\x06\x0f\xa5.\xb9H\xee\x1cB\xc1\x97DpI>\xa1\xa1>qana\xa4\x16\x80\x8c\xa1\x06k\xa7N\x89=\xf5\xbe\xfe\xa9hp\xa5\x8d~GԠ\xe0Ba\xf2\r\x9e\r\x06G\x8b\xa1\x06k\xa7N\xf9\xeaN\x8b\t0\xb8\fY\xdc\xe5\x19\xb6\xbc>2\x99\xdc(\x9e\xb1\xa0Lq8Ͳ\xc1\xe1\xf0\x96\xa5\xe6\xfaDq\x16\xbb\x81h\xb0\xe6\xa2\xe8+tX\x1c\x8b\xfc\u007f\xa8V\xcb\xe0\x8e<\x87Ş\x97\x1e\xbc\x16\r\x94\xb5ៃ\r\xa1\xe4&67\xb09\x1e\xf9\xee\xa6\xd9\x11:\x02\b\x86\x1a,j\xa6Ny\xda\xc5D\x18L\x82\xa2\xec\xd55\xa9K\xe8ս\xd5X\xc6\x12+\xfe\x9aHE\xe5\xf3\x91}[Z\x8dx1YI\xa7\xf4\xa0\x95\xde\xe6Eɲ\xad\x1a\x06w\xa1\x92\xfd\xedn;Һ\x8f#\bnmx9\xaf\x97]\x1b\xcfm\x8e\xafÛ\x91\xeb\xf5z\rO\xf34%\t2\x98K\x9d\xea%\x91i\t0X\x14\xadv<\xe0-\xa7\u007f̞ZTM\x9cJ[\x8eu\xf5\x88%+\xc5>\xd4\x1ah\xeak&\x1f\xb6\xac%왆\xc1nz\xb7Qm\xaa\x18\r\xca\xda\b6\xf9\xee\x0ens\xa0\x8a\x88\x9e\x04\x19\xac\xa4N\xf9\xeazGFF\xfa\x1a\xf5r\xf2&\x11+\xc9*a\"q\x067c+}b\xe52q8\x85˸\x1et\xe7\xcdJEY쉆\xc1}\x8e\xf42w\xb7\x18\xc5\x10,\xea\x1a\xacl\x0e\x18\x1c=\x892\x98\xd1\xd1*\x9eq\xfb1<@\x98\x13\x893\xb8M초\xc4`\u007f\x1d<܆EMsT\xb6zs\xf5\r\xc6uQa&J\x8b.\xd7]\xc7`n.\x18\x1c5\t2\x98K\x9d\x1a$\xf4\xd4\x0f\x86\ti\x9a$\x82\r\xde\xe87\xd8\xca\f\x96\x8fE4\xa3A13\x87|g\x14\xea\x1b\xdcU2\x10U\xbe\x00\x00\x1e\xa0IDAT)\x92Z\xc3\x16U\xfa\x9b\xb26\x82\xae\xc1u\xaa\x8ce@\x9b\x04\x19̥NQ\x12S\a+\xcaذ\x80#s\x83\f\x1eJ]\x82\xab\x82\x91\xdctQt\x10\xa3F\xb2\xf4\r\xae\xa6\x01@b\xee\x1a1\n\x94\xb5\xd1g\x1a\x06\xe7\xe6\xe2\x8fv\xb8\xfcV\xc0\x8f\xa1\x06k\xa6NaF\xfa{\xea\xfbCn\x05\x9ed\xd8\xed\xc5]%\x16/._r\xec۶堔\xfa\xde^{\x8d\xaf\xd9\xd2\xe3[\x96\xdbG\xce\xc9\xe5Է\xe6\xa5t\x10A\v\xdd\xdbf#{M'\x9fE\xc5MV#[\xb5\xa7\xb5$\xccߕ\xe1\b\xacM\x1c\xee\xf4z\xad%\xde\x0e\x9fzs\xb0\xc85\xad\xf3m0\x06G\x81\xa1\x06k\xa7Na\x99\xc8ܦpKN\x02\xf4\xf6\xe2\x1e\x92 U&\x8a\xa7sm\xa9y\x1b\x10Z\x93\x86PS*\xb25\xb3\xf0Tr]\xc4\"\xb2\x95#5\x19V\xfb\xb2\xfaY\x96\\>\x8b\x8a\x9bḽvX\xd2r\xa3\x128\xb0\xb62\xb1+\x99\xf5\xe0Vo\x8ex\xb1\xccn˝\x94s%\xd3\x0eC\r\x06\x80\xb8\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b\x13\x18\\\x88\xec\xcb\xe1\x961@\a\x13\x18\xdc\xef\xadϴ\x1b\xfe\x17?\x01\x93`\xb4\xc1\xa1\xa9SA\x01T\xdaK\xa1n\x11\x00\xb40\xd8`\x8d\xd4)u\x00\x956\x93\x94+\x02L\x03\x8c5X+uJ\x1d@\xa5\r\x18\f\xe8a\xa8\xc1\x9a\xa9S`00\x11\f5X3u*\x1a\x83{\xa2\xbb\xff\f\x98\x81\x18j\xb0\xa8\x95:\xc5\aP\xe91l\xcf\xe9\xe8K@&\n0\xf5I\x90\xc1\\\xea\x147\xa9O\x1bBhQ\xb8\x06\xc0L%A\x06+\xa9S\xaaI=|\xf6\xf4\xda\xf6\xc8\xc5\x060\x03I\x94\xc1\x8c\x8eV\xad\xc9P:Q{\x98W\x81\x99L\x82\f\xe6R\xa7\xb8I]\xe0X\x04\xa0G\x82\f\xe6R\xa7\x82\x03\xa8\xb4\x00\x83\x01=\f5X3uJ\x1d@\xa5\r\x18\f\xe8a\xa8\xc1کS\xaa\x00*\r\x86\xfb\xbb\n\xad\x86G\xb3\x02&\xc1P\x83\xc7\xc7\x12\x84\xd2\xc3\xed\xe6\x013\x1a\x13\x18\xdc\xdf\r\xc7\xd1\x00]L`0\x00\x84\x01\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807F\x1b\x1c\x9a:\x85\xe9m\xabo\xee\n\xb3\x10\x00\xe8b\xb0\xc1\x1a\xa9S\xe2p\xbb\xbb\xf3L\x97\xfbL\xb8\xe5\x00@\ac\r\xd6J\x9d\x12\xdb\xeb\xfa\x89\xda\x10\xb0\n\x8c\aC\r\xd6L\x9d\xeaw\xd3;\xe4 ^\x15\x18\x17\x86\x1a\xac\x99:\xd5Y\x17.w\x15\x00\xc2c\xa8\xc1\xa2V\xeaT\xab\xa7\xb75R\xea\x14\x00\xe8\x91 \x83\xb9\xa8\xa9f:\xd9\xd4\f#10\x1e\x12d0\x175婋\x9c:\x05\x00z$\xca`\x06\x89\x9a\xf2\xb2\xfb\x90\xbdp;20\x1e\x12d0\x175\xd5U?\xc2\xcd\x01\x80\xd8H\x90\xc1\\\xd4\xd4\x10=\x9a\xe6\x93\x0f\xb3\x01@l\x18j\xb0f\xea\x94\xd8U\xd7\xd5\xd7\xd3\xd8\n{r\xc0x0\xd4`\xed\xd4)\xf1Lk\xfd\xfe.\x10\x18\x18\x17\x86\x1a\f\x00q\a\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0x*0\x12\xa9\x01\xa0\v\x18\x9cp\xfaK\xd2ВH\x8d\x00=\xc0\xe0\x84\x93\x99\xe9n\x87\xbf76n\x8c68$uj\xb8\x91]r\xe9n\x8a\xb0\xe4$s\xbc\xe8X\xa4&\x93C\x0fj\x8b\xd4\x04\b\x83\xc1\x06\x87\xa6N\xf9\xdc]d\xaa\xcb\x1d\xe6/\x83{\xbb\xf4_\x8b\x17\xc7\xf2\x8fDj\xa2A,[\xa6Ӷ\vuh\xce\a\xa2\xc3X\x83\xb5R\xa7\xd8]ˍ\xe1~\x8ds\vü\x18/\xaeDj\xa0E,[\xa6\xd3\x16\xfe\xea\xf9\xc40\xd4`\xcd\xd4)\x8ag\u007f\xb8{4f\xc7\xe0\x89\xb1IJe:m\xc1\xe0\x89\xf1g\x1b\x00\xc0\xccL`\f\x06\x80)\x00\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xccMX\x83\xeb\x11O\u007f\xb8\xa6\x00\x90\x18\xc0`\xc0܄5x\xf4\x1aa.\xaa\xa6\xff\x8e\x86k\n\x00\x89!\x8a:8\a\xd5DjbjJJ\xf8gː\xa8\xd7P\xcdU\xbb\x9b\xfd[\x9e~{\xa6\x9b}\xbc\xdbsli\x85C\xfa\xcb,B\xa3Ѯ\xe0Z\xa5\xc3⨼\x86\xa7jr\"\xb5\x9dр\xc1]\xd6a\xfei\x94\x82I\xa3\xf3\x115\xf8j:*\xac\x9e\x8b\n\xc9\xf46\x94Q]\x92\x92\xea\xd3](z\x83G\xb3Pn\xf5|\x94uC\x92n\xa4\xd5Gj=\x93\x89\xc5\xe0F\x94\xc9&jP\x99Ԅj\x86\nSSs<l\xd6\xc5\xf2t\x8b}I\xb7v\x0f\x9aT\xa2\xe4v\x9d\x97.ZȚ\xbc)r\x01\x9e\xe2\xd5iǓ\x89*#5\xd1d4]\xbdܵh\xfc\x92$1\a1\x83+Q\xabD\xbc\xc7o\xbd\x0f\xe5b\xe1:\x91jLWA\f\x8en\x05\xfbQ9~܀\x1a\xf1c\xbd-\xaaEf(\xb1\x18|Ղ\x06\xe9D\x06\xea\xc5\x06\x17ڬy\xb9\xc9h\r\x99\xd3mC֬t\x84\xb6\xe9\xf6\x12\xa0\xa7\x8f\xfd+\xf6Zj\xf5ڜ.\xb3J\x92\x1b\xf5\xf66\xa3\xc6\xde^\xa6J\x04\xc6k\xb0\a\x85\xf9\xd6\xd7e\u007f*\xcac\x9bU\x92E\x1e\xdb\x11~/k\x10\x1d}+\xf5\xbf\xb2\x88\xc1\xd1Q\x89\u007f\xc4\xe43Q\x86\x1f\xaf٢\xf8\xb1\xceXb1X*d\x86\xf6\xa1t\t\x1b\x8c2\xf0/\xac\xcfNƠ\x8b\xa9\xa8\x12\x0f?=v\xa47\xac*\xe4\x04\x86(\xab\xae\xc1R-6\xb8\xd1\"Ig\xd0iI\xb25\xea\xb6S\xf0\xb8{\"5\xd1$k.\xfd\xa76˖\x9a\xd7%\xd1*\xe2\x8c\xff\xe8\v\xee\xf1Zu:.G\xaf\xe2\x17\x1c\xfe\xb9\x1b\xf1\x93̌\x9e\x0e\xfe\x83UM\u07b8}\xae\xd6\n$\xa9\xbf\xc4aI\xcd픸*·2Ͷh0\x13W\xb8\x85i\xbe\xe5vkNW\xd0\x1a\xdch\xbfD>\x18\xf4\a^\x92zC\xbbg F\x83;\x88\xba\xe4\xbbm\x1b5\x98\x1e^k#\xf3*\xd1\"\x89=\xc9\xd0\xee\x83#j\x83G}\xb2\xc1\xbeh\a\xaeq0\xc8\x1cو\xe6W\x97\xa7\xa2.j\xb0XO\u0600\xec\xa2t-\x13\x97\xa3˓ӱ\xc2e\x852\xa4j\xe8\x1e\x95\x14\x83\xaf\xf5W\xa3\x9cQ\xe9**'uղ\xe02\xf8\xcc\xed\xb65\xd5\xcbRH\x9d\xe17ؗ\x86\x96T\xceJ\xb5\x13\x83mi\x8bZ\xdd\xf6\xe4~\xf5\x1a\xae\xa6\xa7\xb6\x0ez\xec\x0eZ?xP\x87\x04\xe8\x10\x93\xc1\xa3\xa9D\xa8\xd14\xf2\xc5ۄr\xd9<+~\xe6@\xacT\xbd\x91\x8c\xe4\xdf\xdfh\x9ae[\xba\xa3g\x83=\x8f\xecNK\x9e\\[\xe6\xc6\x1b\xe43\xc0\xa0\xbb\xd7\xd6ꍙ\xb6E#\xb4\xfd\xfe\x1c\xdb\xdc\xfdtJ\\\xe3\xb0/'U\x04\x81\x1aLjKR\xa0\xd4\xe2\xc7\xf6J\x94\xd2T\x9en/d\xeb\xf1\xf7;n\x9a\xa9\x1c7R\xf2$b\xf3\"eO\xeeFV\n\xfe\x1e/\xa7\xef]\xb3\xb4U\f\xaeDȁ\u007f\"\xfdhIj\xfa\xf2,d\x0fR8\x0f\x91\xba\xc9K\n\x02\xbf\xc1\x85\xa8\r\xaf!\x97\xfc\x18\ni\xa1\xd0\x15R\x03\r\xcf\xc2\xef\xd6\xc1\xba\x1aD\x1b$@\x87\x98\fƿ\xd0J\xf2\xd3&ߖM\xfe\x9fj\x16꼆PV\x0e\xc5B\x861JO*ژ\x87\xecn\xba#]\x96\\\xd9ٔ\x86ǩ\x1b\xbd\xbd\x99y\xbd\xbd\xbd\xf47cEYm\x1di\xcb\xc9d\x99u[\xe76+\xf9]\xfaR3=\x1d\x8b\x90\xda\xe0\x1b\xbd\xe9\xe5W\xa5\xab5\xa9\xbd7\x86\xdaR\xd0,w\xed,\xdb \xdf\xef\xb8)\xa3\x1f\xb9\x1bɳ\x88\xb7d\xb0\xf7\x1b\xbc\x8c\xecD\x8d\xdeN\xbft\xa4\x9c\x94\xd0O\x89bpWG\x8d\xcd\xd6+\x9dFh\xd9(\xd9\xcd]\xa2n\xd8Iwv\xaf\x92ٲ\xc1ג\xe9'\xb8\x8f\x19L\xde\xe15\x94\xa7^h(ͺѳ\xd1\xca\x14\x1eMΕ\x00\x1db3\xf8\fJ\x1b\x95V\xd2\x1d\xe4&\xff^[\x0ej\x13\x91B\xa0\x10v\xac\xc1cW\x87TVN\xc60\x0f]\xb8\x8d\xb6W\xaa\b\a\xf9rN\x93ȇ\xa2\xcb\xff8?\x03\xcb2:Wm0.+\xc8Ｌ\x8c.6\v\x0f\xeb\xd7\xd2s\x83\xfa\x1d\x1fK\x10\xa9q\xb1Ȗ\xf9n\xba\x9b*\x1b\\C\xf7P\xfbQF\ra6:#\x95-\x91ieK\xaa\xea\xe0^\\>\x9dA\x16\xd2\xd7\xe8\xac\xe4k\xeauHW{=\xd59d\x80\x97\r\ue875\xb4$Y\xa8\xc1d}\xa3h\xbe\xa4ZC.):p\xb7\xecXpj\xe4\xe2l\xc6\x12\x9b\xc1R\x06\xea\x19\xb5\xa5\x90_T\x93\xfc[\x902Q\x17\x1e\x83Cw\xe8\x1dm\xf8wzC\xaa^)I+3F\t\xe9T@\xce`r\xc0\xa8\x86\xb8ZFw襬2<\x18QA\xb6\x05\x1b<\x82\x06q\x11C\x8f\xd6Y\xe9G\xa7\x19]S\xf7;>r\xd9с\xd1\xc6,\xfc\xe9\xcb\xea\xf3\x1b܁\xe6\x92\xf9\xbd\x81\x0ff\x97zON\n2X\x9a\x8b\x86\x87䃍\xcb\xe5#6~\x86\x97\x93z\xa0\x843\xb8]^4\x9d\x1aL\xb5'\x06sk\xb8*\xab\xbb\bу\xd5\x0e\xbb\x04\xe8\x10\xa3\xc15\xa8\xb2\x8b}K6\xc9\xdf{7,\xf8\x87\x1c8\x06ѣ\xecu9\xba\xa43\x16\x89\x1a<W\xfe\xcd,\xa3\xdd)\x06\x93~\xc9>\x9b4\x9f\x9e\x10\x90\ns\xf17k/]O\xb0\xc1Ғj\xa9\xcbN;g;\x80=\xb8\xbaT\xf5;>\x98@\x04ѳ\x04\xd9o0\x83\amvjN\x1fZ\xa9\xbb$3\xf8\x86\x87\xed\x01,A\xfd\xa3\xc9l\xa4\\\x8eT\x85\xf0h&\xaa\xec\xc5%\x10gp\x97\xfc\xfd\x95\xaa6\x98cH\xae\xbc\xcb\xf1\xe0\x8f\xb19$@\x87\x18\r\xbe\x88\xd2+\x99\xadM\xc8r\x91\xfcیf\x93/a:d\xe1\xafu\xab_\bj\xb0\x95\x19\xbc&\xa3\x8fB_\xa3\x06{\x88 TEjp\x19\xfb\xddg\x94\xe1_4ݟ+\v1\xb8#m\x94\x15\x11\x92\x95\x0e\x82\xadx\fV\xf5;>\xca\xe9\x80髦\xe5{!\xfeT\x10\x83\xaf\xa6\xa7\xb0Cs7,\xe9\xf4}5\xd6\x06\x17\x06\x01\x83-T\xaeQ\x87\xe5\x1a\xfeA\xd1\x02$#UU\x97\x9fa\xe7\xebz\xc9'^6Xd\xbe\xfa\x90\xae\xc1\xd7\x10\xfbV\x9a\x8fF\xe8\xabP\a\xeb\x12\xa3\xc1\xf8[\xd7\xc6\x0eN6!4\x1bk\xd8i#\xc5\xeb\x90\x15\x95\xe1\xdf\xf1i;=\x93\xc4\xe0\f\xeeb\xd2o\xa3ߝyyd\xb7\x86\xccP\f\ue925l\x1b\xea\xc4+H\xc7\x1d\xf9n\x0f1x4\xad\xc3\xceN\xf9Y\xd3ȩ\u058c<u\xbf\xe3<\x1e\xdcL\x8f\xa2\x88h6\xb6ntv\xf2U\"\xd8\xe8|\xe4?\x02\xbd\x92\x8e\x96\xbd\xc9\x1au\xa8\\E,\xa7\xffT\x93\xc1\xdaC\xf7\xe4\x1a\xc9\xde\xee\xe8Հ\xf2\xfdT\xbf\x1b\xb9\x9c\xc1x\xc4\xc6k\x1d]\xa2o0nA\xaa)/S\xb7o\x9cgkf\x04\xb1\x1a܊\x10\x1b\t\x9bЬ\xdbSf\xcfB\xecE\xaf\x15\xdd>\x17?\xc9\r\f?C\xf6\xfa\x1bm\x96\xfe\x1b+\xf3F\xe8/\xb8\xbd\xa3\x8c\xedq\xd5X\xeb;\x16\xd9DrN\xae\xec\xb4\xd4Wf\xe9\xc5#ך\xe4\xea\xce\xead\xb2\xf34hK\xaf\xddfON\xf1\x90ʺ\xaf\x195ʧ\xf0\xa4\xea\fVDHV\x94\xd3ޚI\x8fYq\xfd\x8e\xf3\x9c\xdcEvHe#\x9a\xb5ac\x16)q\xb1`5\xc8QS\xbd\x11\xd3A\xaez\xc8ٸ\xd2z\xbb\xffs\xc4!\x1b<\xec@y\x1bsP&\xf1p\x19ʪ^\x82f]%\x9f\xbc\x1c\u007f\xbb\xd1\xd9h\x91\xbbڑ\x99\x96\xc5\x1d\x0fNEK*3\xec\xc4O\x1d\x83\x87\xd3\xd0\"\xdc\x17;2\xd7\bǃ\xf5\x89\xd5\xe0kVV\xa8\x92\xb3\xca\xfd\x8bl\xf6E\xf2\xc8\xe7+O\xb7\xd8\xe6\xd6\x05\x04\x1eMC\xa8-\x15\xd9\xdaY\x95ڕg\xb7\xcfg\a\xdaF+\xed\xb6\xbc3\xf4(*\xb2\f\xda\xf0#Q\xafy\xaemn3\xeb\xa9\xd0>\xabړB\xe6\xdeHů\xda\xe4\xd1\xcc\xe7\x1f߭\x1b\xcbR\x1dk\xd81/\xa5\xdfq\x1a,e\xd1\xe1ut\xff\xdcT\xdb\\v\x85\x83X\xe6ߣ\xc2=^ݘnq,W\xef\x9a1\xfc{rbY\x9a%\xbd\x9an\xe4h}\xa6\xd5QN\x8c\xe4\f&\a\xb8\xad\x99\xb57\x96\xe1\x82 pNn\xa80նd\x88\f\xcb:\x06Kb\xb9ÒV\xc6.:Z\xa2\xaeK\x00\x9e(\fV\xe1c\xa7\xe5\xa8\xc1\xe1[ƛ\x1bV\xf9\xc3\x12\xe6T\xde8\xf0\xb0}\xa5x\xd3\x1dt|W\r\xdb\xdf\x15Qt\aQĔm\x91\x9a\xcc`b5\xb8\xc6? \x1bnp\xbb\\D\xc4\xd9\xe0\t\x1d\x8bӧ,\xec\x15\xa9v\xba\x83\xb81\xca\x03ٵ\xb6\t\xec\xaaN{b2xh\xb8\xfdv\xab|\xa5\x9f\xb1\x06\xd7\xf6H\x8b\xfcN\xc4\xd7`ɛ\xa2\u007f=︹X\x18\xf6Tw5\xca\xd8X\x9d\x1b|\x1eN\x87k\xf6h\xae͛\xb1\xc4d094\xef\xf7\xc8P\x83o\xa0\x9cJ\a\xab\x87\xd9\x0e`<Y\xbe<R\x8b\xf8\xe3\xc9I\xb5e\xd5FW\xddn\x9b\xc8Y\xf3\xe9OL\x06\xd7\xd9\xd2\x02_\x8e\x86\x1a,դ\xe6\xc9#%\xdd\x01\xbc\x18\xbe50\x83\x88\xc9`\x00\x98r\x80\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\xcd\xd46x\u007f\xf0\xfd\x0e\x9a\xb8\xc3\\\x03\x19\x1d\x17\xe1x\x95i\x01\x831n[\xe8œ\x80I\x98\xda\x06\xf7\xbb\xa3\t;\x99\xa8\xc1\xa3\b\x81\xc1\xa6ej\x1b\x1c\x1d`\xf0L\x06\f\x06\x83\xcdM\xdc\f\x8es\f\x1a\x83\xd6\xc1M\xc8=\\\x96v{\x16\xee\xbe)ӚVNlS\xa5\xb6\xc9\x06s\xd1mZ\x8b\x045\xa8\xbdZ\uec24o\xbc\xca\xceS\xd3\xf8\x16_Y\xba%5\xa7~\xc2{u\x1f\n\x98\xbda\x1a\x1c\x15\x84\x13a^\x06ba\xc2\x06OR\f\x1aC6\xb8̎Ҭ\b\xb5\xafA\xb7\xa7!z\xe3\x8d*\xb5\x8d\x19\xccG\xb7i-\x12Ԡ܁R\xed\beސZ\x97!T\xb8\xec\xa24\x98\x8a\xecs3P\x94W\x8c\x85\xe1O\xef}g\xfd\xc0\x17a\x1a\\\x1f\xa8:\x18\xe6e \x16\"\x1a|5/\xfcũQ\x87H\xc5\x16\x83Ɛ\rF\x99\x83\xd2\xe82d\xbd\xdd3*\xb5#\x12\x81\xa3Jm\xa3\x06\xab\xa2۴\x16\tn\x90\xd1+I\x1d\x16rc\xa9\\E,A\x1b\xf1\xf0ۗ\x1a\x87[z\xb6l\x89\xd0`;\x18\x1c/\"\x1a<\x88\xb4n\xb1Q\x88\xda\xe0\xf1Ġ\xf9\r&\x9b0(_ٙC\xa4S\xa5\xb6Q\x83U\xd1mZ\x8b\x047\xa0\t\x17e\xe46\t\xd9\xe0t\xd6e\xdd\xf2Ni\xa2\x80\xc1\xc6\x11\xde\xe0\xa6\xcc\xce!\xe4\xeb\xccܟ\xa0\x184\xd9`z+\xdb\rY\xdae\xa8NR\xa7\xb6Q\x83U\xd1mZ\x8b\x045`\xe9$u\xe4\x1aQ\xd9\xe0<\x94\xd3\x1b\xfc\xe1\x1a\xd8Z\xea\\\xb1\xbdtLz\r\x97\xb6\xff$\x1dď/5\b\xce\xe7\x1f[\x9b\xbf\xf5s\xda\xe2\xb3\xfbW8\x8b\xb6\u007f\xae^\x8c3x\xechE\xfew\x8e\x8e\x05\xb5\xc5\x067\xe0\xbe\\\xd7q\x83\x13U\x8b\xd7>\x86\x1b|\xe8\x14\x84\xa7?\xd9uw\xfe\xd6?I@Ԅ7X\\\x83\xb2\xf0\u007f%b\x82b\xd0d\x83ie\x8a=\xa3\xb7\x87\x94\x90:\x9aOm\xa3\x06\xab\xa3\xdb4\x16\tn\xb0HY\x81lp\xaf\x05\xa1\xd4e\xad|\xd1\xf4\xc1\x82\x87O\x9d}~\x85\xf0'il\xa0\xf4\xfb\u007f\x94\xfex\xb0`\xe0\xe6\xefO8\x85\xa2\x83\x87\v\xee'-\xce-\xae8|\xf6\xa0𬤂3\xf8a\xd7ӯ?\xed\xda\x1b\xd4\x16\x1b\xfc\xf9.\xe1\xd9\x0f\xf1\xe4^\xa1\xe1\xf5\xa3E\xebǤ\xb1\x97N\x94\xae*(}lׂp54\x10D\xa4*\xa2˂,\xf4^\xe0\x84Ġ\xc9\x06\xd3k\xe9\x83\fVRۨ\xc1\xea\xe86\x8dE4\x1b\xa8\f\x96\x06Kȝ\xd3)eʗ\xc0\xd1\"2\x1c\x1e]J\x86Ѓ\x15\xf8\xe1a\xaa\xa2k)\x1eGw\x15ᩱҭ\xf8\xb5\xb1\x97\xaeK*\x14\x83\xcf\ng\xfd\x8f|[l\xf0\xb3\xae\xd7H\x83\xd7\xe8a\x89\x0f\xd9\xc1\x89\xf5\u0096\x9b\xd2\xd8M\t\x88\x9e\xf0\x06_\xdbhIG\x0ek\xf5\xd5\x04Š\x851XIm\xf3\x8f\xc1\\t\x9b\xc6\"\x9a\r\xd4\x06㩞mY\x88;\xba\xfcE\xf1\xdd\r\xcf\xffn\x8c\xd6\x00\x9f/\xf8\x9d4V@|\x94\\\x0f㇃.\x89\xa8\xf9;I\x03\xc5\xe0\xbd\xeb\xe8?\xeb\xf6\xaa\xdbn?\xf8\xb4p\x8aN=x\xf7؟0\xa5\xf4\xa3\xb1\xde\x05\xc3o\xac\x847\u061d\xb6\u007f\b\r5\xa7\xb9\x13\x14\x83\x16\xc6`.\xb5\x8d\xd6\xc1\xaa\xe86\xadE\xb4\x1a\xa8\f\xf6\xb1 \x8cF\x94\xa2\x941\u05cf>\xb8VXq\x98*\xbc\xf51\xe9,\x1d\x8d%\x17\xd9\x0f\xa3\x06?+\x8cI\x1a(\x06\u07fb\x9d\xfe\xb3\xbdJ\xddv{Q\xc1\xda\xfb\xe9\xd3\xf5\x02\x83\xd6$\xeb\xab$ F\"T\x11\xa3\xf4X\x04\xf9\x8d&$\x06-\x8c\xc1\\j\x1b5X\x15ݦ\xb5\x88V\x83\x80\xc1WIz\x03k<\x84\x92\x03\x06\u007f\xf88\xb6\xec\xfa\x89\xfc\xa3\xe4ɩ\x15c\xac\x88\xe0\f>+|(i\xc0\f\xbe\xf9\xf4ui\xef\xdd\xc4ӱ\xbb\x1fV\xb7\xdd^\xf4\xf1g\x05\xb4x\xdeu\xf7\x87\x14Z\x87\xac\xbf_\xa33 ,\x91\xea`I\xb4\xb3\xdb\xeb\r\x8eAc\x841\x98Km\xa3\x06\xab\xa2۴\x16\xd1j _\xfcfA\xed7F\xa5<\x94\x87[_[Ɲ\xd28H\xabXi\xcb\xf7\xc9\xe3؊SK\xe9S\xce\xe0\x9b\xc5[\x88\xa1\r\x8f\xd1\xf9\x9f\x1d\xfe\x8c-\xc7\f\xfe@\x18\x90^\xa7\x05\xee\t\xe1uu[r4\xed\xac\x93\x18}Vx\x89\xb4}\xf20y\\\xff\xa0\x04\xc4HD\x83e\x8c\x8eAc\x841\x98Kmc\xe7\xe4\xf8\xe86\xadE\xb4\x1a\xc8\x06\x93\xf2\xa5K\xf2ّ%3ˆҔ\xfc\x88\x83\xc2⃯\x9d\xda+\x9c\xa3\xcf\x1e\xbf{)ٱ\xfb\xd7\x01\xe7\xde\xf7\xc6>\xd8\xeb\x1c\xf8WI:\xe7Zw\xf4l\x83\xf0<mp\xbf@k\x86?\xfd\xbf\xef\xac\x1f\xc0\x1c\xc5\x06K\xbb\x84\xc7_{\\\xd8E\xe6\a\xda^\x1f\xa8\xc2=\xdc\xdc^|\ue3f8\xd7\x05\x0f\x9e«8\x81\x17\x1bXu\xef\xc0\xc0g\x12\x10\vQ\x1alx\f\x1a#\x8c\xc1\\j\x9b|]\x04\x17ݦi\xb0F\x03\xd9\xe0\xa1\xdc\xdbS\xdb\xc8u\x13\x19\x96\xdb3\xab\xb9\xc3i'\xee=X\xea,\xde\xc2\x04\x96\xfe\xc0.v \ar\x9d\xbf[\x8c\x1f\x1b\xc8\xcc\aK\v\xaa\xd8N\x99\xf4|\x11-7>\x96K[!\xff\x13r<x}\xfez\xf9x\xb0\xbf\xedQ\xf2\xe2\a'\xf0\xc3\xd3x\xee\xd9-w.\xbd\xf7\xac|9\x85\xc0>\x04@\xd4Dip\xfc\x99X\f\x9a\xb1i\x1527]\xe7\"5\x01\f'a\x06O,\x06-!\x06\xbft'\x9c,\x9bz$\xc6\xe0\tǠ\x19o\xf0\xc1sc[\xe0b\x86)HB\f\x9ex\f\x9a\xe1\x06\x8f\t\x15\r\xc5Agހ\xa9@B\f\x9ex\f\x9a\xe1\x06K\a\x17o\xf9$R\x1b \x01$\xc6`\x00\x88\x17`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807\x86\x1b|\xaaꏑ\x9aL\"\xd7\xef=\x15\xa9IT\xd0w\x11\xaf\u0380\x8901\x83\x1b\x04v\x87\x81\x06\x9f9\x85\xb5\x1a\xb3\x0f\v\a5\xef,\xd3%\xe2*N9\xe5\xabq\x9dQ\xf84vX8\x1c23\xf6\x9c3\xf6.4;\x03\ff|\x06\x9f\x93\xef\xf8\xfa|\xc0\xa9w\xbd\xd6\xd8{{]\xa1s\x8fF\x1dy\x17\xf5*\x0e\v\xe4n\x88g\a\x06\x16D\xa5\xd3\xebΣ\xc1\xb3b\xce9\v\xbc\v\x8d\xce\x00\x83\x19\x9f\xc1U\x81\xfb\xb9\\\xfaW\x1c\x1e\f5\xf83\xe7\xe3\xfe\xc9\xeb[\xc2_\xe9\x15\xf5*\x9eu\x92Q\xf4=I\xca\x0f\x8a\x1d\xd1\xe1iWP\xc0\x8e\x14kJ\x14\xf7.\xb4:\x03\fe|\x06\xaf\x8fV\xaf \xf6\x16\aJ\x88\x8f\x85\x8fC^\xe6\x89z\x15c\x9f\xc9\x06\u007f\x16]yr\xb38\xb4`\x88\xcd`\xee]hu\x06\x18J8\x83\xff\xb4\xc2\xf9O\xa5\xc5\xe7\x1a\x96n!)2\x81|\xafSr\xddI2l$\xd7c\x81\b1.!\xec\xf3]\xc5K\xef\x0f\xad\"\xc6\n\xe4\xc1\xeb\xe8\xaa\xd7>\x11>y}\xd5\xd18\xad\x82\x1a,\x05\x85\x9b\x1d\xdd[\xbct;\xbd\"2\xd0/\xe5\xe9\xfc\x10\xd5c\xc99S\xde\x05A\xa33\xc0P\u008e\xc1\xe7\n\x84Ƕ\bw\x1e^A\xbe\x9f\x03\xf9^7\a\xe8=\xb5\x03T\x0e\x97\xb0\xf6ĩ\x154\xe6@I\b\xfb\xa4`\xed\xf3\xa7\xb6\n!\x06\x93\xdb\xcf)\x9f\xef\x12\xd6\xe1\xff\xee\xff\"N\xab\x90\r\x0e\n7+=x\xb04\xffc\xbe_ʀ\xf0\xff\xa4 b\xc99S\xde\x05A\xa33\xc0P\xc2W\x11Ż\xa4ׅS4-L\x9d\xef\xa5|\xc5\x17\xfd\x1b6\x84D\x88q\ta\xf7\xae\"{\xea\xebC\f~]\xf8\x83\u007f\xf2\xacSp\xd2\xf0\x85\xb8\xacB6X\x1dnv7\x1e֯\x97V\x05\xf5\x8b?>B\xc8A\x8b\x18r\xceT\xefB\xb33\xc0P\"\x18|BzO\xb8)=\xfe`p\xbe\x97\xa2\x17yN+^%!\xec:\x8bOx:\xc4\xe0S\x82\x1c\x86p\xfd1g\xb1P\xecz\xec\xdfⴊ\x80\xc1|\xb8\x19\xfd\xae?*\\W\xf7K\xa4\v9<\x17C\xce\x19\xf7.\b\x1a\x9d\x01\x86\x12\xc1\xe0\xb3҇xW\x9f\xe8\xa5\xce\xf7R\xeffQ\xbd\x94\x84\xb0\x0f\xd9\xd7l\xe8\x9e\xdc{~\xd1\x0e\xaf8\xfa{\xe1\xf7GW\x1c\x8e\xd3*\x02\x06\a\x87\x9b\xe1o\xf9\x0f\xd5\xfdJ\xfeeyb\xc89\xe3\xde\x05A\xa33\xc0P\"\x1b\xecbz\xa9\xf3\xbd\x88^ϓC\xa8\x8a^JBؿ\t\xf4(\xe9á{r\x81\xc3\nc\xf4X\x04\t\x85\x8c\xcb*\x14\x83\xb9p3\x9a\x04\xf5<\x1e\xdfU\xfd⮜7\xa5 b\xc89\xe3߅\xa4\xd9\x19`(Q\x1b\xac\xca\xf7\"\xbf\xf1?\xd2\x19\x8a^\\BXU)\x96\xe5\x0f\xae\x10\x83\xa5\xfbW\x05\x86\xb5/\x96~\x11\xbfU(\x06s\xe1f+\xb0[7\xef\xde\x12ԯ4\xb664\x15'\x86\x9c3I\xf5.\xb4:\x03\f%\xac\xc1\xbf_\xfa\xec\xd8\t\xe7\xc7c\xbb\xb6|\xce\xe5{IħgOmY\xfc\x85:BLI\b\xfb8\xbf\xf4\xe0\xd3K\x05\xe7\x89\xdf\au\xf8I\xc8iظ\xac⃣\xf2a\x02)\x10nF\x0eaT\xbc\xf4\xfc\xaa\xa5d\xaf\x8b\xef\x17\x17\a\xca\xd0ʈ-\xe7L\xf5.B;\x03\f&\x9c\xc1c+\x04\xe1D\x81\xb0\xf8%VB\xfa\xf3\xbd\xc8+\rK\xf3\xef\xfd0(B\x8cK\b\xfbd\xfbһ\x1f;\xe1\xa4\xc1b*\x9ev\xa9\xcbƸ\xacb\x8c\xbc\x9a/\u007f\x9b\xff\xc1\u007f\x85\x83뱽\x05Ż\xfe\x95Ns\xfd\x0e\xe4?&\x05\x11c\xce\x19\xf7.4:\x03\ff|\xe7\xe4\xc6\xcdX\x83s\x92\xf7\xdd\x03\xe1fڧ\xf2^r\xee\x9dxt\x94\xff]ĥ3`b\x18l\xb04\xf6l\xe9\xf5Hm&D \xdcL\xd3\xe0\xebŇ\x95\x03\fㇽ\x8b8u\x06L\b\xa3\r\x9e\\\xf8p\xb30\x97S\x00ӈie0\x17n\xf69\xdd\x01\x8c\xd0\x1e\x98\x06L+\x83\xb9p3\xba\x03\bq\xe83\x80\xe9e00\xf3\x00\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb91\xdc\xe0鑛\x16\v\x113\xd6\xe2\xf4#I\xc4{\x9b\x02L\xcc\xe0\x88\xa1f!L\xc5ܴs\v\x84{\xc7HFł\xb3\x1a\x8b0>\u07ba\xb8x\u05f9b\x95j{\xe5K\x8aՓ\xc1D\xccX\x8b\xfeGr\xb6(\xdc[\x9c\xa11n\xe338\xeaP\xb3`\xa6dn\xda\xd8Y!\u007f@\xbayJ8\xabk\xd2\xd9\xc5UϟX/\b*I?'+~/x2\x88\x88\x19k\xd1\xffH\xa4\xd7\x16k\x18\xec\xffAI34\xc6m|\x06G\x1dj\x16\xc4\x14\xcdM\xbb)\xecڋ7Nнi\xf3z\x01\xb9Q\xf9\xe6*!x\x98Un\xd0\xe3'9\"f\xacq\r\"\xa3\xf5\tS~P33\xc6m|\x06G\x1dj\x16\xc4\x14\xcdM\xbb)\x9c]<\x16\xce\xe0\xc7\xf3\xe9\xddJ\xcf\xc6npČ5\xae\xc1\xf8X\xcf\x19<\x13c\xdc 7M\"\x06\u007f\xb6\xfe\x145\xb8\x81$\x05\xd3\xfaZ\xb5e\xab\x1e\xa6\xed\xae?;&\xdd|\xb0\xd8Y\xba\xdd\xffͭe\xf0\xc0\xd6R\xe7\x8a\xed\xa5t%\x113\xd6\xfc\r\xf0\xf6>\x1fx\x9b\x01\x94\xcd\xc1+\xcf\x17\xe4\x18c\xae\xad\xea\a%\xcd\xc8\x187\xc8M\x93\xa8\xc1G\xb7S\x83i\xd5\xcd\xeakn\xcb\xc6\x04\xa5@yM\xd8{\xee\xa5\xed\xfe[\x945\f\xfe`\xc1ç\xce>\xbfB\xa07;E\xccX\xf37 \xdb[t\xf0p\xc1\xfd\xaaW\xb9\xcd\xc1+\x18\x18`_G\\[\xd5\x0fJ\x9a\x911n\x90\x9b&Q\x83\xaf\xbb\xae\xb3*BI\xa7P\xb6\xec3n\x89\xb1\x97n\x92\x15\a\xf2\u007fB\f>ZD\xdc=ʂ\x83\"f\xac)\r\\K\U00058eab(\xe8ues\b\xf9\aC\xdb\xf2U\xc4L\x8cq\x83\xdc4\x89\x1a,m\u007f6\xc4\xe0\xc0\x96\x8d9\xb9\x9d\xc4\xebG\xb7\xde] \xacgO4\f\xfe\xa2\xf8\xee\x86\xe7\u007f7\xc6\x06\xfc\x88\x19kJ\x03\xd7Òƾ\x83\x8e\xc1\\\xdb \x83CW1͉\x9c\xd9\xe3\x9ch\xa8\x99\xc2T\xcdM#\x06\x9f\xfaN\x88\xc1ʖ\xc9u\xf0\x18\xfeh|XT\xfa\xf8\xa9\x81-\xeb\xfd}\x85\xd6\xc1\u05cf>\xb8VX\xc1nc\x8e\x98\xb1\xa64P\xbb\xeaG\xc7`n\xae\xca\xe0\x19\x18\xe3\x16\xd9`\xd7DC\xcd\x14\xa6jn\x1a1xl\xf1Y\xc5\xe0\xa7\xfd\x06\xcb[\xf6x>]\xf6%\xe1\x8f\xd2\xda*\xb2\r\xf7\xafgKj\x18\xfc\xe1\xe3\xb8\xc1\xf5\x13\xf9t\x03#f\xac)\r\xc2\x18\x1c\xf86\xd35\xf8y\xf9π\xcc\xc0\x18\xb7\xa8\r\x1e\u007f\xa8\x19\xc7\x14\xcdM#\x06K\x0f\xef\xa2\x06\xe7\xe3\xe2c\xac*\xc8`v<xl\xcbݒTJF\xf2\xb1\xef\xacgKj\x18|\x90\x16\xebҖ\xef\xd3g\x113\xd6\x02\r\xb4\rV6\x87>\xd30X\xf9A\xe9\xadbz\x03\xb9i\xf4\x9cܩ\x9bҹ|j\xf0\xbdE\x87\x0fV\x91~U[v6\xff\xde\x13\xa7\xb6:\a\x88\xa0\x0f\x1e=\xb8\x1eW\t\xefI_\xc8'\x03\xf1G\x91\x9b<(,>\xf8\x1a^\x1b\x8b\x0e\x8a\x98\xb1&7P\xbdM\x8e\xc0\xe6Hc\xef\r\f\xb8\xf6\x0e\f\xdc\fj\xeb\xffA\x11fb\x8c\x1b\xe4\xa6\xd1\xeb\"\xf0\x186VE\xcf-|\xb2%\xbf`\xeb?\t\xc2^\xf5\x96}\xbc5\u007f\xc5\xfd$\x11{\xec\xd9U\xae\xa2\a\x9f_\xe5\xdc\"=,\xd7\xd7x\x90\xe6&O\xdc{\xb0\xd4Y\xbcEξ\x8a\x9c\xb1\xc6\x1a\xa8\xde&\x87\u007fs\x1a\xa4\x0f\xe4U\x1c\rj\xeb\xffAI34\xc6m|\xe7\xe4\xc6\xcd\xf4\xc8M\x8b\x85\x88\x19k\xf1\xfb\x91\x18\xfeަ\x04\x06\x1b<Mr\xd3b!b\xc6Z\xbc~$\txoS\x01\xa3\r\x9e\\ 7m\xe61\xad\f\x86ܴ\x19ȴ2\x18r\xd3f \xd3\xcb``\xe6\x01\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01sc\xb8\xc1q\n\t\x1b'\x93\x9b-\x161!\r\x88?\x1338b\xa8Y\bч\x84\xc9D\\\xc5\xc4s\xd3\xee\x15H\x10\xc3\t\xfcx/?;L\x16\x1a\xe5\xa8\x10\x94\x17\x151!\r\x98\x04\xc6gpԡf\xc1D\x1f\x12\x16\xf5*&\x9e\x9b\xf6I\x83p\xee\xa6ts@hЋE\xd3\xe4\xfa@\x95j\xcb\"&\xa4\x01\x93\xc1\xf8\f\x8e:\xd4,\x88)\x9a\x9bvT \xdf\v\u007f\x12B\xc4\xd3N\x92\n\xb0\x9d߲\x88\ti\xc0\xa40>\x83\xa3\x0e5\vb\x8a\xe6\xa6\xc5\xc5\xe0\x88\ti\xc0\xa4\x00\xb9i\x12opP|Y\xc0`n\xc5\xd2g\xf7\xafp\x16m'-\xb0\xc1\xe4*N\x17\xf96\x89\x98\x90\x06L\x0e\x90\x9b&\xf1\x06\aŗ\x05\fVV,\x9d[\\q\xf8\xecA\x9a\xa4\x86\r\xc6\xef\x84\xdd&\x1d1!\r\x98\x1c 7MRW\x11\xaa\xf82\u007f\xbf܊\xc7J\xb7\x925\xbfD\xc6]l\xf0\xb3\xae\xd7Xӈ\ti\xc0\xe4\x00\xb9iR\x90\xc1\x0fK\xa1iVʊ\xb1ƿ\v,\xb7\xfd\xe0\xd3\x01U#&\xa4\x01\x93C\xe4\xcc\x1e\xe7DC\xcd\x14\xa6jn\x1aќ$\xf7\x1c\x95\xf8\xb5IJ\xbfʊ\xa5g\x05\xa5\xc4\xdd^T\xb0\xf6~\xf9iĄ4`r\x88l\xb0k\xa2\xa1f\nS57m\x80FݰJV\xd3`e\xc5x\f\xfe0\xb0\xdc\xf6\xa2\x8f?+\x90\x8f\xe1ELH\x03&\x87\xa8\r\x1e\u007f\xa8\x19\xc7T\xcdM[J\xa4\u07fb\x94h\xa7i0\xb7\xe2\x9b\xc5[\xc8{h \x9f\x0fr4\xed\xacS6:bB\x1a0)@n\x1a\xe1\x84\xd0p\xf6\xfb\xe4u~m\\\x16\x1a\xb7b\xe9\x9ck\xddѳ\r\xb8\x0e\xbf>P\x85\xdb\xde\xdc^|\x8e^\xe9\x111!\r\x98\x14 7\x8d5\xa8Z\\E^\xe7\xd7\xc6e\xa1\xf1+\x96\xfe\xf0`iA\xd5)z]\x84 |p\x02?<M\xe7GLH\x03&\x83\xf1\x9d\x93\x1b7\xf1\v\t\xd3#q\xb9i\x11\x13Ҁ\xc9\xc0`\x83\xe3\x16\x12\xa6K\x02s\xd3\"&\xa4\x01\x93\x80\xd1\x06O.\x90\x9b6\xf3\x98V\x06Cn\xda\fdZ\x19\f\xb9i3\x90\xe9e00\xf3\x00\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\r\x18\f\x98\x1b0\x1807`0`n\xc0`\xc0܀\xc1\x80\xb9\x01\x83\x01s\x03\x06\x03\xe6\x06\f\x06\xcc\xcd\xff\aڧC\xea]\xae?U\x00\x00\x00\x00IEND\xaeB`\x82",
+
+	"callgraph.html": `<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Internal call graph</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Internal call graph</span></p>
+		<p>
+		  This viewer shows the portion of the internal call
+		  graph of this package that is reachable from this function.
+		  See the <a href='#pkg-callgraph'>package's call
+		  graph</a> for more information.
+		</p>
+		<ul style="margin-left: 0.5in" id="callgraph-{{.Index}}" class="treeview"></ul>
+	</div>
+</div>
+`,
+
+	"codewalk.html": `<!--
+	Copyright 2010 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.
+-->
+
+<style type='text/css'>@import "/doc/codewalk/codewalk.css";</style>
+<script type="text/javascript" src="/doc/codewalk/codewalk.js"></script>
+
+<div id="codewalk-main">
+  <div class="left" id="code-column">
+    <div id='sizer'></div>
+    <div id="code-area">
+      <div id="code-header" align="center">
+        <a id="code-popout-link" href="" target="_blank">
+          <img title="View code in new window" alt="Pop Out Code" src="/doc/codewalk/popout.png" style="display: block; float: right;"/>
+        </a>
+        <select id="code-selector">
+          {{range .File}}
+          <option value="/doc/codewalk/?fileprint=/{{urlquery .}}">{{html .}}</option>
+          {{end}}
+        </select>
+      </div>
+      <div id="code">
+        <iframe class="code-display" name="code-display" id="code-display"></iframe>
+      </div>
+    </div>
+    <div id="code-options" class="setting">
+      <span>code on <a id="set-code-left" class="selected" href="#">left</a> &bull; <a id="set-code-right" href="#">right</a></span>
+      <span>code width <span id="code-column-width">70%</span></span>
+      <span>filepaths <a id="show-filepaths" class="selected" href="#">shown</a> &bull; <a id="hide-filepaths" href="#">hidden</a></span>
+    </div>
+  </div>
+  <div class="right" id="comment-column">
+    <div id="comment-area">
+      {{range .Step}}
+      <div class="comment first last">
+        <a class="comment-link" href="/doc/codewalk/?fileprint=/{{urlquery .File}}&amp;lo={{urlquery .Lo}}&amp;hi={{urlquery .Hi}}#mark" target="code-display"></a>
+        <div class="comment-title">{{html .Title}}</div>
+        <div class="comment-text">
+	{{with .Err}}
+	ERROR LOADING FILE: {{html .}}<br/><br/>
+	{{end}}
+        {{.XML}}
+        </div>
+        <div class="comment-text file-name"><span class="path-file">{{html .}}</span></div>
+      </div>
+      {{end}}
+    </div>
+    <div id="comment-options" class="setting">
+      <a id="prev-comment" href="#"><span class="hotkey">p</span>revious step</a>
+      &bull;
+      <a id="next-comment" href="#"><span class="hotkey">n</span>ext step</a>
+    </div>
+  </div>
+</div>
+`,
+
+	"codewalkdir.html": `<!--
+	Copyright 2010 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.
+-->
+
+<table class="layout">
+{{range .}}
+<tr>
+	{{$name_html := html .Name}}
+	<td><a href="{{$name_html}}">{{$name_html}}</a></td>
+	<td width="25">&nbsp;</td>
+	<td>{{html .Title}}</td>
+</tr>
+{{end}}
+</table>
+`,
+
+	"dirlist.html": `<!--
+	Copyright 2009 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.
+-->
+
+<p>
+<table class="layout">
+<tr>
+	<th align="left">File</th>
+	<td width="25">&nbsp;</td>
+	<th align="right">Bytes</th>
+	<td width="25">&nbsp;</td>
+	<th align="left">Modified</th>
+</tr>
+<tr>
+	<td><a href="..">..</a></td>
+</tr>
+{{range .}}
+<tr>
+	{{$name_html := fileInfoName . | html}}
+	<td align="left"><a href="{{$name_html}}">{{$name_html}}</a></td>
+	<td></td>
+	<td align="right">{{html .Size}}</td>
+	<td></td>
+	<td align="left">{{fileInfoTime . | html}}</td>
+</tr>
+{{end}}
+
+</table>
+</p>
+`,
+
+	"error.html": `<!--
+	Copyright 2009 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.
+-->
+
+<p>
+<span class="alert" style="font-size:120%">{{html .}}</span>
+</p>
+`,
+
+	"example.html": `<div id="example_{{.Name}}" class="toggle">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Example{{example_suffix .Name}}</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Example{{example_suffix .Name}}</span></p>
+		{{with .Doc}}<p>{{html .}}</p>{{end}}
+		{{$output := .Output}}
+		{{with .Play}}
+			<div class="play">
+				<div class="input"><textarea class="code" spellcheck="false">{{html .}}</textarea></div>
+				<div class="output"><pre>{{html $output}}</pre></div>
+				<div class="buttons">
+					<a class="run" title="Run this code [shift-enter]">Run</a>
+					<a class="fmt" title="Format this code">Format</a>
+					{{if not $.GoogleCN}}
+					<a class="share" title="Share this code">Share</a>
+					{{end}}
+				</div>
+			</div>
+		{{else}}
+			<p>Code:</p>
+			<pre class="code">{{.Code}}</pre>
+			{{with .Output}}
+			<p>Output:</p>
+			<pre class="output">{{html .}}</pre>
+			{{end}}
+		{{end}}
+	</div>
+</div>
+`,
+
+	"godoc.html": `<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#375EAB">
+{{with .Tabtitle}}
+  <title>{{html .}} - The Go Programming Language</title>
+{{else}}
+  <title>The Go Programming Language</title>
+{{end}}
+<link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+{{if .SearchBox}}
+<link rel="search" type="application/opensearchdescription+xml" title="godoc" href="/opensearch.xml" />
+{{end}}
+<link rel="stylesheet" href="/lib/godoc/jquery.treeview.css">
+<script type="text/javascript">window.initFuncs = [];</script>
+</head>
+<body>
+
+<div id='lowframe' style="position: fixed; bottom: 0; left: 0; height: 0; width: 100%; border-top: thin solid grey; background-color: white; overflow: auto;">
+...
+</div><!-- #lowframe -->
+
+<div id="topbar"{{if .Title}} class="wide"{{end}}><div class="container">
+<div class="top-heading" id="heading-wide"><a href="/">The Go Programming Language</a></div>
+<div class="top-heading" id="heading-narrow"><a href="/">Go</a></div>
+<a href="#" id="menu-button"><span id="menu-button-arrow">&#9661;</span></a>
+<form method="GET" action="/search">
+<div id="menu">
+<a href="/doc/">Documents</a>
+<a href="/pkg/">Packages</a>
+<a href="/project/">The Project</a>
+<a href="/help/">Help</a>
+{{if not .GoogleCN}}
+<a href="/blog/">Blog</a>
+{{end}}
+{{if .Playground}}
+<a id="playgroundButton" href="http://play.golang.org/" title="Show Go Playground">Play</a>
+{{end}}
+<span class="search-box"><input type="search" id="search" name="q" placeholder="Search" aria-label="Search" required><button type="submit"><span><!-- magnifying glass: --><svg width="24" height="24" viewBox="0 0 24 24"><title>submit search</title><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/><path d="M0 0h24v24H0z" fill="none"/></svg></span></button></span>
+</div>
+</form>
+
+</div></div>
+
+{{if .Playground}}
+<div id="playground" class="play">
+	<div class="input"><textarea class="code" spellcheck="false">package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, 世界")
+}</textarea></div>
+	<div class="output"></div>
+	<div class="buttons">
+		<a class="run" title="Run this code [shift-enter]">Run</a>
+		<a class="fmt" title="Format this code">Format</a>
+		{{if not $.GoogleCN}}
+		<a class="share" title="Share this code">Share</a>
+		{{end}}
+	</div>
+</div>
+{{end}}
+
+<div id="page"{{if .Title}} class="wide"{{end}}>
+<div class="container">
+
+{{if or .Title .SrcPath}}
+  <h1>
+    {{html .Title}}
+    {{html .SrcPath | srcBreadcrumb}}
+  </h1>
+{{end}}
+
+{{with .Subtitle}}
+  <h2>{{html .}}</h2>
+{{end}}
+
+{{with .SrcPath}}
+  <h2>
+    Documentation: {{html . | srcToPkgLink}}
+  </h2>
+{{end}}
+
+{{/* The Table of Contents is automatically inserted in this <div>.
+     Do not delete this <div>. */}}
+<div id="nav"></div>
+
+{{/* Body is HTML-escaped elsewhere */}}
+{{printf "%s" .Body}}
+
+<div id="footer">
+Build version {{html .Version}}.<br>
+Except as <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
+the content of this page is licensed under the
+Creative Commons Attribution 3.0 License,
+and code is licensed under a <a href="/LICENSE">BSD license</a>.<br>
+<a href="/doc/tos.html">Terms of Service</a> |
+<a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
+</div>
+
+</div><!-- .container -->
+</div><!-- #page -->
+
+<!-- TODO(adonovan): load these from <head> using "defer" attribute? -->
+<script type="text/javascript" src="/lib/godoc/jquery.js"></script>
+<script type="text/javascript" src="/lib/godoc/jquery.treeview.js"></script>
+<script type="text/javascript" src="/lib/godoc/jquery.treeview.edit.js"></script>
+
+{{if .Playground}}
+<script type="text/javascript" src="/lib/godoc/playground.js"></script>
+{{end}}
+{{with .Version}}<script>var goVersion = {{printf "%q" .}};</script>{{end}}
+<script type="text/javascript" src="/lib/godoc/godocs.js"></script>
+
+</body>
+</html>
+
+`,
+
+	"godocs.js": `// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/* A little code to ease navigation of these documents.
+ *
+ * On window load we:
+ *  + Generate a table of contents (generateTOC)
+ *  + Bind foldable sections (bindToggles)
+ *  + Bind links to foldable sections (bindToggleLinks)
+ */
+
+(function() {
+'use strict';
+
+// Mobile-friendly topbar menu
+$(function() {
+  var menu = $('#menu');
+  var menuButton = $('#menu-button');
+  var menuButtonArrow = $('#menu-button-arrow');
+  menuButton.click(function(event) {
+    menu.toggleClass('menu-visible');
+    menuButtonArrow.toggleClass('vertical-flip');
+    event.preventDefault();
+    return false;
+  });
+});
+
+/* Generates a table of contents: looks for h2 and h3 elements and generates
+ * links. "Decorates" the element with id=="nav" with this table of contents.
+ */
+function generateTOC() {
+  if ($('#manual-nav').length > 0) {
+    return;
+  }
+
+  var nav = $('#nav');
+  if (nav.length === 0) {
+    return;
+  }
+
+  var toc_items = [];
+  $(nav).nextAll('h2, h3').each(function() {
+    var node = this;
+    if (node.id == '')
+      node.id = 'tmp_' + toc_items.length;
+    var link = $('<a/>').attr('href', '#' + node.id).text($(node).text());
+    var item;
+    if ($(node).is('h2')) {
+      item = $('<dt/>');
+    } else { // h3
+      item = $('<dd class="indent"/>');
+    }
+    item.append(link);
+    toc_items.push(item);
+  });
+  if (toc_items.length <= 1) {
+    return;
+  }
+
+  var dl1 = $('<dl/>');
+  var dl2 = $('<dl/>');
+
+  var split_index = (toc_items.length / 2) + 1;
+  if (split_index < 8) {
+    split_index = toc_items.length;
+  }
+  for (var i = 0; i < split_index; i++) {
+    dl1.append(toc_items[i]);
+  }
+  for (/* keep using i */; i < toc_items.length; i++) {
+    dl2.append(toc_items[i]);
+  }
+
+  var tocTable = $('<table class="unruled"/>').appendTo(nav);
+  var tocBody = $('<tbody/>').appendTo(tocTable);
+  var tocRow = $('<tr/>').appendTo(tocBody);
+
+  // 1st column
+  $('<td class="first"/>').appendTo(tocRow).append(dl1);
+  // 2nd column
+  $('<td/>').appendTo(tocRow).append(dl2);
+}
+
+function bindToggle(el) {
+  $('.toggleButton', el).click(function() {
+    if ($(this).closest(".toggle, .toggleVisible")[0] != el) {
+      // Only trigger the closest toggle header.
+      return;
+    }
+
+    if ($(el).is('.toggle')) {
+      $(el).addClass('toggleVisible').removeClass('toggle');
+    } else {
+      $(el).addClass('toggle').removeClass('toggleVisible');
+    }
+  });
+}
+
+function bindToggles(selector) {
+  $(selector).each(function(i, el) {
+    bindToggle(el);
+  });
+}
+
+function bindToggleLink(el, prefix) {
+  $(el).click(function() {
+    var href = $(el).attr('href');
+    var i = href.indexOf('#'+prefix);
+    if (i < 0) {
+      return;
+    }
+    var id = '#' + prefix + href.slice(i+1+prefix.length);
+    if ($(id).is('.toggle')) {
+      $(id).find('.toggleButton').first().click();
+    }
+  });
+}
+function bindToggleLinks(selector, prefix) {
+  $(selector).each(function(i, el) {
+    bindToggleLink(el, prefix);
+  });
+}
+
+function setupDropdownPlayground() {
+  if (!$('#page').is('.wide')) {
+    return; // don't show on front page
+  }
+  var button = $('#playgroundButton');
+  var div = $('#playground');
+  var setup = false;
+  button.toggle(function() {
+    button.addClass('active');
+    div.show();
+    if (setup) {
+      return;
+    }
+    setup = true;
+    playground({
+      'codeEl': $('.code', div),
+      'outputEl': $('.output', div),
+      'runEl': $('.run', div),
+      'fmtEl': $('.fmt', div),
+      'shareEl': $('.share', div),
+      'shareRedirect': '//play.golang.org/p/'
+    });
+  },
+  function() {
+    button.removeClass('active');
+    div.hide();
+  });
+  button.show();
+  $('#menu').css('min-width', '+=60');
+}
+
+function setupInlinePlayground() {
+	'use strict';
+	// Set up playground when each element is toggled.
+	$('div.play').each(function (i, el) {
+		// Set up playground for this example.
+		var setup = function() {
+			var code = $('.code', el);
+			playground({
+				'codeEl':   code,
+				'outputEl': $('.output', el),
+				'runEl':    $('.run', el),
+				'fmtEl':    $('.fmt', el),
+				'shareEl':  $('.share', el),
+				'shareRedirect': '//play.golang.org/p/'
+			});
+
+			// Make the code textarea resize to fit content.
+			var resize = function() {
+				code.height(0);
+				var h = code[0].scrollHeight;
+				code.height(h+20); // minimize bouncing.
+				code.closest('.input').height(h);
+			};
+			code.on('keydown', resize);
+			code.on('keyup', resize);
+			code.keyup(); // resize now.
+		};
+
+		// If example already visible, set up playground now.
+		if ($(el).is(':visible')) {
+			setup();
+			return;
+		}
+
+		// Otherwise, set up playground when example is expanded.
+		var built = false;
+		$(el).closest('.toggle').click(function() {
+			// Only set up once.
+			if (!built) {
+				setup();
+				built = true;
+			}
+		});
+	});
+}
+
+// fixFocus tries to put focus to div#page so that keyboard navigation works.
+function fixFocus() {
+  var page = $('div#page');
+  var topbar = $('div#topbar');
+  page.css('outline', 0); // disable outline when focused
+  page.attr('tabindex', -1); // and set tabindex so that it is focusable
+  $(window).resize(function (evt) {
+    // only focus page when the topbar is at fixed position (that is, it's in
+    // front of page, and keyboard event will go to the former by default.)
+    // by focusing page, keyboard event will go to page so that up/down arrow,
+    // space, etc. will work as expected.
+    if (topbar.css('position') == "fixed")
+      page.focus();
+  }).resize();
+}
+
+function toggleHash() {
+  var id = window.location.hash.substring(1);
+  // Open all of the toggles for a particular hash.
+  var els = $(
+    document.getElementById(id),
+    $('a[name]').filter(function() {
+      return $(this).attr('name') == id;
+    })
+  );
+
+  while (els.length) {
+    for (var i = 0; i < els.length; i++) {
+      var el = $(els[i]);
+      if (el.is('.toggle')) {
+        el.find('.toggleButton').first().click();
+      }
+    }
+    els = el.parent();
+  }
+}
+
+function personalizeInstallInstructions() {
+  var prefix = '?download=';
+  var s = window.location.search;
+  if (s.indexOf(prefix) != 0) {
+    // No 'download' query string; detect "test" instructions from User Agent.
+    if (navigator.platform.indexOf('Win') != -1) {
+      $('.testUnix').hide();
+      $('.testWindows').show();
+    } else {
+      $('.testUnix').show();
+      $('.testWindows').hide();
+    }
+    return;
+  }
+
+  var filename = s.substr(prefix.length);
+  var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+  $('.downloadFilename').text(filename);
+  $('.hideFromDownload').hide();
+  var m = filenameRE.exec(filename);
+  if (!m) {
+    // Can't interpret file name; bail.
+    return;
+  }
+
+  var os = m[3];
+  var ext = m[6];
+  if (ext != 'tar.gz') {
+    $('#tarballInstructions').hide();
+  }
+  if (os != 'darwin' || ext != 'pkg') {
+    $('#darwinPackageInstructions').hide();
+  }
+  if (os != 'windows') {
+    $('#windowsInstructions').hide();
+    $('.testUnix').show();
+    $('.testWindows').hide();
+  } else {
+    if (ext != 'msi') {
+      $('#windowsInstallerInstructions').hide();
+    }
+    if (ext != 'zip') {
+      $('#windowsZipInstructions').hide();
+    }
+    $('.testUnix').hide();
+    $('.testWindows').show();
+  }
+
+  var download = "https://dl.google.com/go/" + filename;
+
+  var message = $('<p class="downloading">'+
+    'Your download should begin shortly. '+
+    'If it does not, click <a>this link</a>.</p>');
+  message.find('a').attr('href', download);
+  message.insertAfter('#nav');
+
+  window.location = download;
+}
+
+function updateVersionTags() {
+  var v = window.goVersion;
+  if (/^go[0-9.]+$/.test(v)) {
+    $(".versionTag").empty().text(v);
+    $(".whereTag").hide();
+  }
+}
+
+function addPermalinks() {
+  function addPermalink(source, parent) {
+    var id = source.attr("id");
+    if (id == "" || id.indexOf("tmp_") === 0) {
+      // Auto-generated permalink.
+      return;
+    }
+    if (parent.find("> .permalink").length) {
+      // Already attached.
+      return;
+    }
+    parent.append(" ").append($("<a class='permalink'>&#xb6;</a>").attr("href", "#" + id));
+  }
+
+  $("#page .container").find("h2[id], h3[id]").each(function() {
+    var el = $(this);
+    addPermalink(el, el);
+  });
+
+  $("#page .container").find("dl[id]").each(function() {
+    var el = $(this);
+    // Add the anchor to the "dt" element.
+    addPermalink(el, el.find("> dt").first());
+  });
+}
+
+$(document).ready(function() {
+  generateTOC();
+  addPermalinks();
+  bindToggles(".toggle");
+  bindToggles(".toggleVisible");
+  bindToggleLinks(".exampleLink", "example_");
+  bindToggleLinks(".overviewLink", "");
+  bindToggleLinks(".examplesLink", "");
+  bindToggleLinks(".indexLink", "");
+  setupDropdownPlayground();
+  setupInlinePlayground();
+  fixFocus();
+  setupTypeInfo();
+  setupCallgraphs();
+  toggleHash();
+  personalizeInstallInstructions();
+  updateVersionTags();
+
+  // godoc.html defines window.initFuncs in the <head> tag, and root.html and
+  // codewalk.js push their on-page-ready functions to the list.
+  // We execute those functions here, to avoid loading jQuery until the page
+  // content is loaded.
+  for (var i = 0; i < window.initFuncs.length; i++) window.initFuncs[i]();
+});
+
+// -- analysis ---------------------------------------------------------
+
+// escapeHTML returns HTML for s, with metacharacters quoted.
+// It is safe for use in both elements and attributes
+// (unlike the "set innerText, read innerHTML" trick).
+function escapeHTML(s) {
+    return s.replace(/&/g, '&amp;').
+             replace(/\"/g, '&quot;').
+             replace(/\'/g, '&#39;').
+             replace(/</g, '&lt;').
+             replace(/>/g, '&gt;');
+}
+
+// makeAnchor returns HTML for an <a> element, given an anchorJSON object.
+function makeAnchor(json) {
+  var html = escapeHTML(json.Text);
+  if (json.Href != "") {
+      html = "<a href='" + escapeHTML(json.Href) + "'>" + html + "</a>";
+  }
+  return html;
+}
+
+function showLowFrame(html) {
+  var lowframe = document.getElementById('lowframe');
+  lowframe.style.height = "200px";
+  lowframe.innerHTML = "<p style='text-align: left;'>" + html + "</p>\n" +
+      "<div onclick='hideLowFrame()' style='position: absolute; top: 0; right: 0; cursor: pointer;'>✘</div>"
+};
+
+document.hideLowFrame = function() {
+  var lowframe = document.getElementById('lowframe');
+  lowframe.style.height = "0px";
+}
+
+// onClickCallers is the onclick action for the 'func' tokens of a
+// function declaration.
+document.onClickCallers = function(index) {
+  var data = document.ANALYSIS_DATA[index]
+  if (data.Callers.length == 1 && data.Callers[0].Sites.length == 1) {
+    document.location = data.Callers[0].Sites[0].Href; // jump to sole caller
+    return;
+  }
+
+  var html = "Callers of <code>" + escapeHTML(data.Callee) + "</code>:<br/>\n";
+  for (var i = 0; i < data.Callers.length; i++) {
+    var caller = data.Callers[i];
+    html += "<code>" + escapeHTML(caller.Func) + "</code>";
+    var sites = caller.Sites;
+    if (sites != null && sites.length > 0) {
+      html += " at line ";
+      for (var j = 0; j < sites.length; j++) {
+        if (j > 0) {
+          html += ", ";
+        }
+        html += "<code>" + makeAnchor(sites[j]) + "</code>";
+      }
+    }
+    html += "<br/>\n";
+  }
+  showLowFrame(html);
+};
+
+// onClickCallees is the onclick action for the '(' token of a function call.
+document.onClickCallees = function(index) {
+  var data = document.ANALYSIS_DATA[index]
+  if (data.Callees.length == 1) {
+    document.location = data.Callees[0].Href; // jump to sole callee
+    return;
+  }
+
+  var html = "Callees of this " + escapeHTML(data.Descr) + ":<br/>\n";
+  for (var i = 0; i < data.Callees.length; i++) {
+    html += "<code>" + makeAnchor(data.Callees[i]) + "</code><br/>\n";
+  }
+  showLowFrame(html);
+};
+
+// onClickTypeInfo is the onclick action for identifiers declaring a named type.
+document.onClickTypeInfo = function(index) {
+  var data = document.ANALYSIS_DATA[index];
+  var html = "Type <code>" + data.Name + "</code>: " +
+  "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<small>(size=" + data.Size + ", align=" + data.Align + ")</small><br/>\n";
+  html += implementsHTML(data);
+  html += methodsetHTML(data);
+  showLowFrame(html);
+};
+
+// implementsHTML returns HTML for the implements relation of the
+// specified TypeInfoJSON value.
+function implementsHTML(info) {
+  var html = "";
+  if (info.ImplGroups != null) {
+    for (var i = 0; i < info.ImplGroups.length; i++) {
+      var group = info.ImplGroups[i];
+      var x = "<code>" + escapeHTML(group.Descr) + "</code> ";
+      for (var j = 0; j < group.Facts.length; j++) {
+        var fact = group.Facts[j];
+        var y = "<code>" + makeAnchor(fact.Other) + "</code>";
+        if (fact.ByKind != null) {
+          html += escapeHTML(fact.ByKind) + " type " + y + " implements " + x;
+        } else {
+          html += x + " implements " + y;
+        }
+        html += "<br/>\n";
+      }
+    }
+  }
+  return html;
+}
+
+
+// methodsetHTML returns HTML for the methodset of the specified
+// TypeInfoJSON value.
+function methodsetHTML(info) {
+  var html = "";
+  if (info.Methods != null) {
+    for (var i = 0; i < info.Methods.length; i++) {
+      html += "<code>" + makeAnchor(info.Methods[i]) + "</code><br/>\n";
+    }
+  }
+  return html;
+}
+
+// onClickComm is the onclick action for channel "make" and "<-"
+// send/receive tokens.
+document.onClickComm = function(index) {
+  var ops = document.ANALYSIS_DATA[index].Ops
+  if (ops.length == 1) {
+    document.location = ops[0].Op.Href; // jump to sole element
+    return;
+  }
+
+  var html = "Operations on this channel:<br/>\n";
+  for (var i = 0; i < ops.length; i++) {
+    html += makeAnchor(ops[i].Op) + " by <code>" + escapeHTML(ops[i].Fn) + "</code><br/>\n";
+  }
+  if (ops.length == 0) {
+    html += "(none)<br/>\n";
+  }
+  showLowFrame(html);
+};
+
+$(window).load(function() {
+    // Scroll window so that first selection is visible.
+    // (This means we don't need to emit id='L%d' spans for each line.)
+    // TODO(adonovan): ideally, scroll it so that it's under the pointer,
+    // but I don't know how to get the pointer y coordinate.
+    var elts = document.getElementsByClassName("selection");
+    if (elts.length > 0) {
+	elts[0].scrollIntoView()
+    }
+});
+
+// setupTypeInfo populates the "Implements" and "Method set" toggle for
+// each type in the package doc.
+function setupTypeInfo() {
+  for (var i in document.ANALYSIS_DATA) {
+    var data = document.ANALYSIS_DATA[i];
+
+    var el = document.getElementById("implements-" + i);
+    if (el != null) {
+      // el != null => data is TypeInfoJSON.
+      if (data.ImplGroups != null) {
+        el.innerHTML = implementsHTML(data);
+        el.parentNode.parentNode.style.display = "block";
+      }
+    }
+
+    var el = document.getElementById("methodset-" + i);
+    if (el != null) {
+      // el != null => data is TypeInfoJSON.
+      if (data.Methods != null) {
+        el.innerHTML = methodsetHTML(data);
+        el.parentNode.parentNode.style.display = "block";
+      }
+    }
+  }
+}
+
+function setupCallgraphs() {
+  if (document.CALLGRAPH == null) {
+    return
+  }
+  document.getElementById("pkg-callgraph").style.display = "block";
+
+  var treeviews = document.getElementsByClassName("treeview");
+  for (var i = 0; i < treeviews.length; i++) {
+    var tree = treeviews[i];
+    if (tree.id == null || tree.id.indexOf("callgraph-") != 0) {
+      continue;
+    }
+    var id = tree.id.substring("callgraph-".length);
+    $(tree).treeview({collapsed: true, animated: "fast"});
+    document.cgAddChildren(tree, tree, [id]);
+    tree.parentNode.parentNode.style.display = "block";
+  }
+}
+
+document.cgAddChildren = function(tree, ul, indices) {
+  if (indices != null) {
+    for (var i = 0; i < indices.length; i++) {
+      var li = cgAddChild(tree, ul, document.CALLGRAPH[indices[i]]);
+      if (i == indices.length - 1) {
+        $(li).addClass("last");
+      }
+    }
+  }
+  $(tree).treeview({animated: "fast", add: ul});
+}
+
+// cgAddChild adds an <li> element for document.CALLGRAPH node cgn to
+// the parent <ul> element ul. tree is the tree's root <ul> element.
+function cgAddChild(tree, ul, cgn) {
+   var li = document.createElement("li");
+   ul.appendChild(li);
+   li.className = "closed";
+
+   var code = document.createElement("code");
+
+   if (cgn.Callees != null) {
+     $(li).addClass("expandable");
+
+     // Event handlers and innerHTML updates don't play nicely together,
+     // hence all this explicit DOM manipulation.
+     var hitarea = document.createElement("div");
+     hitarea.className = "hitarea expandable-hitarea";
+     li.appendChild(hitarea);
+
+     li.appendChild(code);
+
+     var childUL = document.createElement("ul");
+     li.appendChild(childUL);
+     childUL.setAttribute('style', "display: none;");
+
+     var onClick = function() {
+       document.cgAddChildren(tree, childUL, cgn.Callees);
+       hitarea.removeEventListener('click', onClick)
+     };
+     hitarea.addEventListener('click', onClick);
+
+   } else {
+     li.appendChild(code);
+   }
+   code.innerHTML += "&nbsp;" + makeAnchor(cgn.Func);
+   return li
+}
+
+})();
+`,
+
+	"images/minus.gif": "GIF89a\t\x00\t\x00\xf7\x00\x00\x00\x00\x00\x80\x80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\xf9\x04\x01\x00\x00\xff\x00,\x00\x00\x00\x00\t\x00\t\x00\x00\b\"\x00\x03\b\x1cH\xf0\x9f\xc1\x83\xff\x04\"<\xa8pa\xc2\x00\xff\x00H\x94\xf8\xd0aE\x87\r\x17\x12\xdc\x18  \x00;",
+
+	"images/plus.gif": "GIF89a\t\x00\t\x00\xf7\x00\x00\x00\x00\x00\x80\x80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\xf9\x04\x01\x00\x00\xff\x00,\x00\x00\x00\x00\t\x00\t\x00\x00\b&\x00\x03\b\x1cH\xf0\x9f\xc1\x83\xff\x04\x1e\x04pP\xa1A\x86\x06\x15\x02\x9881a\x80\x85\r/>̈0#A\x82\x01\x01\x00;",
+
+	"images/treeview-black-line.gif": "GIF89a\x10\x00\xf0\x06\xf7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\xf9\x04\x01\x00\x00\xff\x00,\x00\x00\x00\x00\x10\x00\xf0\x06\x00\b\xff\x00\xff\t\x1c\xf8\x0f\x00\xc1\x83\b\r\"\\X\x90\xe1B\x85\x0e\tB\x8c(p\"E\x8b\x111:\xd4\xc8\x10\x80Ǐ\x1f\x1fR\x948r G\x91%\x1b\xa6<\x990\xa5ʒ,\x0f\xc6$\xb9\xd2\xe5L\x936s\xd6\xdc\tSgO\x9e#oV\xf4\x19\x94\xe8E\xa3\x19\x91nTڑ)ʟP\x8b\x02=:5iեW\x9bf}*5*U\xafV\xc1b\x15\xab\x95,\u05ef]Ӣ]\x1bVm[\xb6c\xddƅ[Vn]\xbag\xdfꝻ\xf7n\u07fc|\x03\xfb\x15\fx\xb0\xe1\u0088[nUl\x96\xb1\xdd\xc42\x9d:\xc6;\xf9oe\u0097\x0fg\x86L\xb3q\xe4ş=w~\xbc\xb9thҧ)\xa7\xb6\xbc\x1askͯ9\xe3\x04=Zumַ]熽[\xf6PڳE\aG\xdd\xdbt\xf1\xd8Ƈ\xdbV\x8e\x9b\xb9n缡\xfb~Iܥ\xf5\xebسk\xdfν{\xf4\xdf\xc2\xc1W\xff\x17\xbf\x9c|s\xf3\xcf\xd1\u007f\xa7^\x9e\xfdy\xf7\xe9\xe1\xaf\x17*\u007f:\xfd\xfb\x92\x91\xeb?\xce_zr\xf5\xf6\xe5\xd7\x1f\x80\xff\xd5W ~\xc0\x11\xb8\x9f\u007f\v*8\xa0\x81\rB\xf8 \x82\xe1I\xc8\xe0\x84\x02^\xa8\xa1\x83\x1bZ\xc8\xe1\x87\x1e\x86H\xe1x\"f\b\xe2\x88\xed\xa1\xf8\x9e\x8a\xf1\xb18\x9f\x89%&\x18c\x85.\x06(c\x8d\a\u0088c\x84;bx\xa3\x8e@\xfe($\x8dA\x129$\x89=v\x98\xe4\x89E\"\xd9d\x8aO\xae\x18e\x8bS\xbex$\x94WJ\x99%\x95[Zi\xe4\x97Nvi#\x98X\x92\xa9\xa5\x99\\\xa2\xe9e\x98j\x8e\xc9\xe6\x9be\xc2y\xa6\x9ciҹf\x9cxΙg\x9d{ީ\xe7\x9f|\x02\xeag\xa0\x84\x0ej\xa8\x9b}\"*\xa8\xa2\x852zh\x8ebBڦ\xa4v:j)\xa5\x89b\xba\xa8\xa6\x8dr\xfa(\x8fU^\nj\xa4\xa3NZj\xa5\x9e\x8a꣩\xab\xa2zj\xa6\xafn\xff\x1ak\xa7\xb3~\xda*\xac\xb7ʚ+\xad\xbbڪd\xa8\xa9\x06[\xab\xaa\xbf\x92\xda+\xb1L\x1a[,\xab˺z\xac\xb0\xcf\x0e\vm\xb3\xb8R\xab\xab\xb5\xbcb\xebk\xb2\xccr묶\xc8\xce\xf8\xad\xb7Ւ{\xad\xb9٢\xbb\xad\xb8\xe5\xb2{\xae\xbb\xe9»\xee\x92\xf2\x86K\xef\xbd\xc0J\xabo\xb4\xfc\x82;\xad\xba\xf6\xe6\xdb/\xc0\xff\xd6[0\xbe\xca\x12\xbc\xaf\xbf\v+<\xb0\xc1\rC\xfc0\xc2\xddJ\xcc\xf0\xc4\x02_\xac\xb1\xc3\x1b[\xcc\xf1\xc7\x1e\x87L\xf1\xb8\"g\f\xf2\xc8\xed\xa2\xfc\xae\xca\xf1\xb2<\xaf\xc9%'\x1cs\xc5.\a,s\xcd\aÌs\xc4;c|\xb3\xce@\xff,4\xcdA\x13=4\xc9=w\x9c\xf4\xc9E#\xddt\xcaO\xaf\x1cu\xcbS\xbf|4\xd4WK\x9d5\xd5[[m\xf4\xd7Nwm3\xd8X\x93\xad\xb5\xd9\\\xa3\xedu\xd8j\x8f\xcd\xf6\xdbe\xc3}\xb6\xdciӽv\xdcxϝw\xdd{\xdf\xff\xad\xf7\xdf|\x03\xeew\xe0\x84\x0fn\xb8\xdb}#.\xb8\xe2\x853~x\xcebC\u07b6\xe4v;n9\xe5\x89c\xbe\xb8\xe6\x8ds\xfe8\xcfU_\x0ez\xe4\xa3O^z型\xee\xb3髣~z\xe6\xafo\x1e{\xe7\xb3\u007f\xde:\xec\xb7˞;\xed\xbbۮt\xe8\xa9\a_\xbb꿓\xde;\xf1L\x1b_<\xeb˻~\xbc\xf0\xcf\x0f\x0f}\xf3\xb8S\xaf\xbb\xf5\xbcc\xef{\xf2\xccs\xef\xbc\xf6\xc8\xcf\xfc\xbd\xf7Փ\u007f\xbd\xf9٣\xbf\xbd\xf8\xe5\xb3\u007f\xbe\xfb\xe9ÿ\xfe\xd2\xf2\x87O\xff\xfd\xc0K\xaf\u007f\xf4\xfc\x83?\xbd\xfa\xf6\xcb_\xff\x00\xf8\xbf\xfa\x15\x10\u007f\xca#\xe0\xfe\xfc\xb7@\x05\x0eЀ\r\x84\xe0\x03\x11\xd8=\t2p\x82\x02\xbc\xa0\x06\x1d\xb8A\vr\xf0\x83\x1e\f!\x05\xc7'\xc2\f\x82p\x84\xedC\xe1\xfbT\x18?\x16\xceτ%L`\f+\xe8\xc2\x00ʰ\x86\a\x84!\x0e#\xb8C\f\xdeP\x87@\xfc\xa1\x102i\x18D\"\x0e\x91\x84=\xec`\x12OXD$61\x85O\\a\x14[8\xc5\x17\x1e\x11\x8aW\x94b\x16\xa9\xb8E+\x1a\xf1\x8bN\xec\xa2\ri\b\x12\x90\x04\x04\x00;",
+
+	"images/treeview-black.gif": "GIF89a`\x00\x85\x00\xa1\x01\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff!\xf9\x04\x01\x00\x00\x02\x00,\x00\x00\x00\x00`\x00\x85\x00\x00\x02\xfe\x94\x8f\xa9\xcb\xed\x0fE\x98\xc1ш\xb3ި\xf2\x0f\x86\x9a'\x96\xa6I\x9e\xeaʶ\xee\nIJ\xfc\xd6&\xb0\xe0\xf6\xfe\xe9\x82\xef\xe3\t#\xc0Cp\x88d\xe0f\xcbY\xf2\x89(\x1a\x8eP\xa8\xf4W\xcdNs\xda,\xd3\xd9\xedR\xc3^\xb2yl~\xa2\xd3\xc85[\xe8~\xabRF9\x8f\xbe\xb5o.\x96\tW?R\x12\a\x98\x80Gx\x88\x98\b\xf8E\xa3\xa826\xe8\x88\x01)yBY)\xf8\xe3Ą\xd9\xf3\xd7\tr\t\xea\xa9\x109\x9a\xc3hzڠ\xba\xfa\xd0\xea\xca\x1a{3\x9bY\x1b\x02\xebj\x98\xbb\xba\x1b\xcb\xd7\x00\x1c\xf5k\xdb{{\x8c\x9c\xac\x8cʸ\xac\xf4\xe9<\x9c\x87\x15\x9dp\xc5{\xdaD\xc3Y}]m]7\xfdM\r>>\x95j\x9e\xae\xbe\xceގd\xb8\x0e\xff+\xac@\u007f뛎o\xae?\xce\xef\x8e\x1d+\x15@P\xa2\xc6yKwМ\xb6\x18\x9a\x1aEKh0\x1c\xb9\x88\xa5\xd4\tt\x871\xa3\xc6d\x8d\x06\xe4\xe5\xdb豗\x9f>!O\x95\xfcv\xb2ZJ\x8e,\r\xa2C\b\xed[A\x991\xbb5d\xc8\xedaM\x9d\x15a\xf6T\xf8\xb2\xa5СDG\xadtvtY\xd2J\xf6:\x8cT\xb8q`-\xa9\xb3\xa8\x06\xfc\x17\x94b9\xa8?\xb5J\x83\xca)\xa7\xb3\x996\xbb\xd24\xdb-kѵlۺ}\v7.\x82\x02\x00;",
+
+	"images/treeview-default-line.gif": "GIF89a\x10\x00\xf0\x06\xf7\x00\x00\x00\x00\x00\x80\x80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\xf9\x04\x01\x00\x00\xff\x00,\x00\x00\x00\x00\x10\x00\xf0\x06\x00\b\xff\x00\xff\t\x1cH\xb0\xa0A\x81\x01\x0e*\\x0!Ç\v\x1dB\x9cHP\"E\x8a\t3\xfe\xd3x\xb1aNj\x16?2\f)R!ɒ\x06O\xa2\xac\xb8rdˈ/M\xc6\xf48\xb3\xa0ʗ7[\xe6\\\xb9\x13eϒ?E\x06\xfd8\xb4cQ\x905m&e\xb9\x14aS\xa7O\x8fb|\xba\x91\xaaԉW!f}\xb8\xd5eT\xab`\xbf\x8am\xda\x15\xe6إee\x9eM\x9a\x96&ٰo\xd7\xd6l\x9b\x12.Z\xbbl\xf1\xce\xd5;\x93\xaeR\xb9}\xf9\xc6\xf4\xcb4\xaeỀ\a\vƹXgc\x9e\x8f}F\x06:Yhe\xa2\x97\xa9j\xde̹3\xd7\xccH\x133\x16\xed\x984dӒQSVm\x995f\xd7FAO\x85\x1d\xfap^ڳm\xefōUvo\xdeZ}\a\a\xfe\x99\xb8W݁\x8d\x9bE\xaeX\xb9Z棡\x97\x96~\x9azj뫱\xb7\xd6\xfe\x9a{l\xe7n\x11{\xff\xaf-\xbe\xfc\xed\xf1\xb9\xcd\xefF\xff\x9b\xfdp\xf7\xc5\xe1\x1fW\x9f\\\xfer\xfa\xcd\xed?\xc7\x1f\x9d\xfft\xff\xd5\x01x\x9d\x80\xd9\x11\xb8\x9d\x81\xdd!\xf8\x9d~ᝧ y\x0eF\xb8ރ\xe9IX\x1f\x85\xeda\xf8\x9e\x86\xf1q8\x9f\x85\xf9yx\x1f\x88\xfd\x91\xf8\x9f\x89\x01\xa28\xa0\x8a\x05\xb2x\xa0\x8b\t¸\xa0\x88\xfb\xc9\b\xe1\x846V\x88\xe3\x8e\x17昡\x8f\x1b\x02١\x90\x1f\xf2\x18\"\x91#\x1aY\xa2\x92'2\x99\xa2\x93+B٢\x94/R\x19\xa3\x953\"Y#\x967\xf6ȥ\x8e^\x86y\xe4\x97?\x92\x19\xa4\x99C\xa2Y\xa4\x98K\xb2٤\x9bO\xc2\x19\xa5\x9cS\xd2Y\xa5\x9dW♥\x9aI\xea\xd9\xe5\x98~\x82\t\xe8\xa0m\x12\xfa\xa6\xa1q\":\xa7\xa2u2z\xa7\xa3yB\xbag\xa0eRz\xa6\xa5ib\xba\xa6\xa4\u007f\x16\xea顟&\x1aꢣ6Z꣧F\x9aꤜ\n\xbaj\xa7\xa0\xc6\xff*\xaa\xac\xa4\xd2j\xaa\xad\xa8⪪\xae\xac\xbe\xea*\xaf\xb0\xce*l\xad\xc3\xdeZl\xae\xc7\xee\x9al\xaf\xc0\xfe\xbal\xb0\xc4Fk\xac\xb4\xc8R\xab\xac\xb5\xcc>\xeb,\xb6\xd0N\xebm\xb5\xdf^\x1bn\xb6\xdcn;n\xb7\xe0\xa6+\xae\xba\xe4\x9ek.\xbb\xe8\xae+o\xbb\xf0\xbe;o\xbc\xf4\xdeko\xbe\xfc\xe2\xeb\xef\xbe\xffVڪ\xc0\xbe\x12ܬ\xc1\xda\"\\\xae\xc2\xee2\\\xaf\xc3\xfaB\xdc/\xc0\x14K\x1c\xf0\xa5\x03c\\\xb0\xc6\as\x9c\xb0\xc7\v\x83ܰ\xc8\x0f\x93\x1c\xb1\xc9\x13[\\1\xca\x17g\x9a\xb1\xcb\x1b\xc3ܱ\xcc\x1f\xd3\x1c\xb2\xcd#\xe3\\\xb2\xce'\xf3\x9c2\xcb+\xfb\xdc\xf2\xa61\x13=\xb3\xd15#}\xb3\xd293\xbd\xb3\xd3=C\xfd\xb3\xd0AK=t\x9f/[]5\xd6Es}\xb4\xd7I\x83\xbd\xb4\xd8M\x93\xfd\xb4\xd9Q\xa3=\xb5\xd6*\xb7\r\xb4\xdbT\xc3\xcd\xf6\xdbt\xc7]\xf7\xdcv\xe7\x8d\xf7\xdej_\xff\xbd\xa5\xa6}o\xfdwց\xcb]\xf8݇\xeb\x9d8߃w\xdd\xf8\u05cf\x87\x1d\xf9ؓ\x97]\xf9ٗ\xa7\x9d\xf9ڋw\xbe\xb9\xdf\r\xf2\xf9\xb9\xe0\xa1\x03>\xba\xe1\xa7#\x9e\xba\xe2\xab3^:\xe1\xad{\xfe\xba\xe3\xb3C^\xbb\xe4\xb7S\x9e\xbb\xe5\xbbc\u07bb\xe6\xbfs\x1e\xfb\xf0\xc1\x83^\x17x\xc73\x98<\x8dœ\xbe\xbc\x96ͣ\x1e\xbd\xeaӳ^\xbd\xebϋ~\xbd\xecٛ\xbe=\xf1\xdd\xc3\xfe\xfd\xf8\xe1\xd3^\xbe\xed\xe7㞾\xee\xeb\xf3\u07be\xef\xef\x03\x1f\xbf\xf0\xe4\xff\xa5\xbc\xfd\xcc\xcfo<\xfe\xd0\xeb\xef<\xff\xda\xf3\x9f\xf4\x04H=\x02Zπ\xd8\x03\xa0\xf7\x10\xc8=\x05\x8a\x8f\x81\xe0s\xa0\xf9$\x88>\n\xaaς\xecà\xfb4\b?\x0e\xcaσ\xf4\x83`\xfd\n\x93?\x10\ue3c4\xfd3\xe1\xffP\x18@\x15\x0eЅ\x05\x84\xe1\x01e\x98@\x16.\x90\x86\r\xb4\xe1\x03q\x18A\x1dNЇ\x15\x04\xe2\x05\xa6\x85\x98A\"nЈ\x1dD\xe2\a\x95\x18B\x1e\x8ep \x84\x81\xa2pf\xc8\xc4\x13J\x11yN\x14\xa1\x16\xb3\xc8\xc5*\xae\xf0\x8a\xf7\xf3\xe2\v\xc5\x18C2R\x11\x8c%4c\rјB5損-tc\x0f\xe1xC9>\x11*a\xa4\xe3\x0e\xed\xb8E>vQ\x8f?\x04d\x10\x059DB\x16ѐGDd\x12\x15\xb9DF6я\x90t\xa4\x15\xf1\x98FI~\x91\x92m\xb4\xe4\x185YFN\x9e\x11\x93q\xf4\xe4\x1aAYGQ\xbe\x91\x94{4\xe5\x1cQ\x19HV\x0eҕ\x85\x84\xe5!e\x99HZ.\xd2)\x1a\xc9H@\x00\x00;",
+
+	"images/treeview-default.gif": "GIF89a`\x00\x85\x00\xa1\x03\x00\x00\x00\x00\x80\x80\x80\xbc\xbc\xbc\xff\xff\xff!\xf9\x04\x01\x00\x00\x03\x00,\x00\x00\x00\x00`\x00\x85\x00\x00\x02\xfe\x9c\x8f\xa9\xcb\xed\x0f\a\x98\xc0ш\xb3ި\xf2\x0f\x86\x9a'\x96\xa6I\x9e\xeaʶ\xee\x1aIJ\xfc\xd6f\xb0\xe0\xf6\xfe\xe9\xd2\xe1\xe3\t#>Rp\x88d\xe0(\x93\x01\ue64c\"\x8a@\xa9uz0^\xb7GCw;\x9c\x89\xc1\xe4\xb2\xd9yN\xab\xa5ߵ\xfb}j\xc3M\x82y\xb2\xae\x90\xdb\x13\x82\xfe\xa3\x8f\xb7\xf7\x11\b\xa2'h@x\xa8\xb8\xc8\xc8&F\xd3(\xf2e\x18\xf90Y\x19r\x89\xd9#\xc1\x84\x06\xb5\x89\xa1\x19\xaa1J*\x9asZ\xfa\x18\xa3\xeajE\xf9*\xeb\x12;k\x1bwې\x98\xfb\x97J\n\xf8\xe7w\xbb\xbbQkG̛\xac\xbc\xfc\xc6\xda\xca\xec\xe5\vM\x15\r\x8df\xa0e\xbd\xe4\te\xbcI}=\x9dU\xa5-\xcd\xec\xecm\xad\xbe\xce\xde\ueb81\xac\x1e\xff\v\xac+l;\x0fM\x9c\xfe\xfb~\xb0\xef/ :u\xa6\x96\x81\xe3\x17\xea \xc1N\x17\xba\x19\x1cWM\x1c6r\x12\x13 \xfc\xe6,\xa0\xc6b\x8d\x1c\xf5i\xcc\xc7\f$\xa6z\xf6DV2\x99\f%/\x95\x1d[\xde\x1aX.\xcfB\x991-.dR\xc1\xa1\xb2\x82;\xcd=\xa49-\xa3ˡD\x8b\x1eb9\xec\xe3\xca{\vH\x1a\x9du\xf1i\xa5\xa8R\x0f\xc1\xac\x88\xa5fV\xac\x14\xcf1l\xa23\x19O\xb1>{\x02='\xb4\xaaڵlۺ}˫\x00\x00;",
+
+	"images/treeview-gray-line.gif": "GIF89a\x10\x00\xf0\x06\xf7\x00\x00\x00\x00\x00\x80\x80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00!\xf9\x04\x01\x00\x00\xff\x00,\x00\x00\x00\x00\x10\x00\xf0\x06\x00\b\xff\x00\xff\t\x1c\xf8/\x00\xc1\x83\b\r\"\\X\x90\xe1B\x85\x0e\tB\x8c(p\"E\x8b\x111:\xd4\xc80\x80Ǐ\x1f\x1fR\x948r G\x91%\x1b\xa6<\x990\xa5ʒ,\x0f\xc6$\xb9\xd2\xe5L\x936s\xd6\xdc\tSgO\x9e#oV\xf4\x19\x94\xe8E\xa3\x19\x91nTڑ)ʟP\x8b\x02=:5iեW\x9bf}*5*U\xafV\xc1b\x15\xab\x95,\u05ef]Ӣ]\x1bVm[\xb6c\xddƅ[Vn]\xbag\xdfꝻ\xf7n\u07fc|\x03\xfb\x15\fx\xb0\xe1\u0088[nUl\x96\xb1\xdd\xc42\x9d:\xc6;\xf9oe\u0097\x0fg\x86L\xb3q\xe4ş=w~\xbc\xb9thҧ)\xa7\xb6\xbc\x1askͯ9\xe3\x04=Zumַ]熽[\xf6PڳE\aG\xdd\xdbt\xf1\xd8Ƈ\xdbV\x8e\x9b\xb9n缡\xfb~Iܥ\xf5\xebسk\xdfν{\xf4\xdf\xc2\xc1W\xff\x17\xbf\x9c|s\xf3\xcf\xd1\u007f\xa7^\x9e\xfdy\xf7\xe9\xe1\xaf\x17*\u007f:\xfd\xfb\x92\x91\xeb?\xce_zr\xf5\xf6\xe5\xd7\x1f\x80\xff\xd5W ~\xc0\x11\xb8\x9f\u007f\v*8\xa0\x81\rB\xf8 \x82\xe1I\xc8\xe0\x84\x02^\xa8\xa1\x83\x1bZ\xc8\xe1\x87\x1e\x86H\xe1x\"f\b\xe2\x88\xed\xa1\xf8\x9e\x8a\xf1\xb18\x9f\x89%&\x18c\x85.\x06(c\x8d\a\u0088c\x84;bx\xa3\x8e@\xfe($\x8dA\x129$\x89=v\x98\xe4\x89E\"\xd9d\x8aO\xae\x18e\x8bS\xbex$\x94WJ\x99%\x95[Zi\xe4\x97Nvi#\x98X\x92\xa9\xa5\x99\\\xa2\xe9e\x98j\x8e\xc9\xe6\x9be\xc2y\xa6\x9ciҹf\x9cxΙg\x9d{ީ\xe7\x9f|\x02\xeag\xa0\x84\x0ej\xa8\x9b}\"*\xa8\xa2\x852zh\x8ebBڦ\xa4v:j)\xa5\x89b\xba\xa8\xa6\x8dr\xfa(\x8fU^\nj\xa4\xa3NZj\xa5\x9e\x8a꣩\xab\xa2zj\xa6\xafn\xff\x1ak\xa7\xb3~\xda*\xac\xb7ʚ+\xad\xbbڪd\xa8\xa9\x06[\xab\xaa\xbf\x92\xda+\xb1L\x1a[,\xab˺z\xac\xb0\xcf\x0e\vm\xb3\xb8R\xab\xab\xb5\xbcb\xebk\xb2\xccr묶\xc8\xce\xf8\xad\xb7Ւ{\xad\xb9٢\xbb\xad\xb8\xe5\xb2{\xae\xbb\xe9»\xee\x92\xf2\x86K\xef\xbd\xc0J\xabo\xb4\xfc\x82;\xad\xba\xf6\xe6\xdb/\xc0\xff\xd6[0\xbe\xca\x12\xbc\xaf\xbf\v+<\xb0\xc1\rC\xfc0\xc2\xddJ\xcc\xf0\xc4\x02_\xac\xb1\xc3\x1b[\xcc\xf1\xc7\x1e\x87L\xf1\xb8\"g\f\xf2\xc8\xed\xa2\xfc\xae\xca\xf1\xb2<\xaf\xc9%'\x1cs\xc5.\a,s\xcd\aÌs\xc4;c|\xb3\xce@\xff,4\xcdA\x13=4\xc9=w\x9c\xf4\xc9E#\xddt\xcaO\xaf\x1cu\xcbS\xbf|4\xd4WK\x9d5\xd5[[m\xf4\xd7Nwm3\xd8X\x93\xad\xb5\xd9\\\xa3\xedu\xd8j\x8f\xcd\xf6\xdbe\xc3}\xb6\xdciӽv\xdcxϝw\xdd{\xdf\xff\xad\xf7\xdf|\x03\xeew\xe0\x84\x0fn\xb8\xdb}#.\xb8\xe2\x853~x\xcebC\u07b6\xe4v;n9\xe5\x89c\xbe\xb8\xe6\x8ds\xfe8\xcfU_\x0ez\xe4\xa3O^z型\xee\xb3髣~z\xe6\xafo\x1e{\xe7\xb3\u007f\xde:\xec\xb7˞;\xed\xbbۮt\xe8\xa9\a_\xbb꿓\xde;\xf1L\x1b_<\xeb˻~\xbc\xf0\xcf\x0f\x0f}\xf3\xb8S\xaf\xbb\xf5\xbcc\xef{\xf2\xccs\xef\xbc\xf6\xc8\xcf\xfc\xbd\xf7Փ\u007f\xbd\xf9٣\xbf\xbd\xf8\xe5\xb3\u007f\xbe\xfb\xe9ÿ\xfe\xd2\xf2\x87O\xff\xfd\xc0K\xaf\u007f\xf4\xfc\x83?\xbd\xfa\xf6\xcb_\xff\x00\xf8\xbf\xfa\x15\x10\u007f\xca#\xe0\xfe\xfc\xb7@\x05\x0eЀ\r\x84\xe0\x03\x11\xd8=\t2p\x82\x02\xbc\xa0\x06\x1d\xb8A\vr\xf0\x83\x1e\f!\x05\xc7'\xc2\f\x82p\x84\xedC\xe1\xfbT\x18?\x16\xceτ%L`\f+\xe8\xc2\x00ʰ\x86\a\x84!\x0e#\xb8C\f\xdeP\x87@\xfc\xa1\x102i\x18D\"\x0e\x91\x84=\xec`\x12OXD$61\x85O\\a\x14[8\xc5\x17\x1e\x11\x8aW\x94b\x16\xa9\xb8E+\x1a\xf1\x8bN\xec\xa2\ri\b\x12\x90\x04\x04\x00;",
+
+	"images/treeview-gray.gif": "GIF89a`\x00\x85\x00\xa1\x03\x00\x00\x00\x00\x80\x80\x80\xbc\xbc\xbc\xff\xff\xff!\xf9\x04\x01\x00\x00\x03\x00,\x00\x00\x00\x00`\x00\x85\x00\x00\x02\xfe\x9c\x8f\xa9\xcb\xed\x0f\x87\x98\xc2ш\xb3ި\xf2\x0f\x86\x9a'\x96\xa6I\x9e\xeaʶ\xee\x1aIJ\xfc\xd6f\xb0\xe0\xf6\xfe\xe9\x03p\xf0\xf1\x86\x11\x1f\xd0 $*\x198\x80\xd39\x98%\x97Kc\x90\x8aUX\x91\xd9.W\xeb\xedJg\xe1\xf2\xb4,F\xab\xcfj*\xbb\xad|Ç\xf2\xb9*u\xb5\xef\xf0_\xfdh\xf2p\x01\xe67RRG\x98\xc0\x87\xb8\xc8\xd8H8F\xe3\xa8rv(\x89Aiy\x82\x99i\xf8\xf3\x04$\xc5ٓ#*\xb2Y::\x88\xca\x01\x19\xb3\xda\xf9\xaa\x19+;\v[\x1bRyې{\xab\xc8[\xeb;+\xd80\x8c\xf0K\xa8\xa8q여\xeb\xfc\f\rݺ\xfcz\x1a\xadz\x14u\xcdt\x90M\xbd\xda\xf4\x19E\xb6\xdd\xe7]\x8e\x9d\x87\xaen\xbcn\xdc\xea\x1e/?O_\xef\xd5,\x8f\xffJ\x81_\xec\x1c\x9c\x8fT@U\xee\x00\xdac7oZB\x81\xf1\xb6h\x93\xe7\xf0\x1b\xaapO\xc6E*\x17q\xa1\x81ms\x10\x19\xbaSx0\xa4ȑ$%\x90\xd4W\xf0\x9a?\x05+{\x9d|Y2fL\x90\r=\xae\xb3v\xd3&:\x8aPB\xedԉ\x11\xe86\x9c;\xe1\xc9<\x8a4\xe9*\x94똢sZ\xaa\xe5\x01\xa9\xd7$\xea\xb2z\vk-\xad\xb3\xb8\x96\xa2\xf9QhU\xb1ш\x06\xfd\x04\x8a\\P\x829\xd9\xfet\x8bѨҹt\xebڽ\x8b7\xaf\x82\x02\x00;",
+
+	"implements.html": `<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Implements</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Implements</span></p>
+		<div style="margin-left: 1in" id='implements-{{.Index}}'>...</div>
+	</div>
+</div>
+`,
+
+	"jquery.js": `/*! jQuery v1.8.2 jquery.com | jquery.org/license */
+(function(a,b){function G(a){var b=F[a]={};return p.each(a.split(s),function(a,c){b[c]=!0}),b}function J(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(I,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:+d+""===d?+d:H.test(d)?p.parseJSON(d):d}catch(f){}p.data(a,c,d)}else d=b}return d}function K(a){var b;for(b in a){if(b==="data"&&p.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function ba(){return!1}function bb(){return!0}function bh(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function bi(a,b){do a=a[b];while(a&&a.nodeType!==1);return a}function bj(a,b,c){b=b||0;if(p.isFunction(b))return p.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return p.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=p.grep(a,function(a){return a.nodeType===1});if(be.test(b))return p.filter(b,d,!c);b=p.filter(b,d)}return p.grep(a,function(a,d){return p.inArray(a,b)>=0===c})}function bk(a){var b=bl.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function bC(a,b){return a.getElementsByTagName(b)[0]||a.appendChild(a.ownerDocument.createElement(b))}function bD(a,b){if(b.nodeType!==1||!p.hasData(a))return;var c,d,e,f=p._data(a),g=p._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;d<e;d++)p.event.add(b,c,h[c][d])}g.data&&(g.data=p.extend({},g.data))}function bE(a,b){var c;if(b.nodeType!==1)return;b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase(),c==="object"?(b.parentNode&&(b.outerHTML=a.outerHTML),p.support.html5Clone&&a.innerHTML&&!p.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):c==="input"&&bv.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):c==="option"?b.selected=a.defaultSelected:c==="input"||c==="textarea"?b.defaultValue=a.defaultValue:c==="script"&&b.text!==a.text&&(b.text=a.text),b.removeAttribute(p.expando)}function bF(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bG(a){bv.test(a.type)&&(a.defaultChecked=a.checked)}function bY(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=bW.length;while(e--){b=bW[e]+c;if(b in a)return b}return d}function bZ(a,b){return a=b||a,p.css(a,"display")==="none"||!p.contains(a.ownerDocument,a)}function b$(a,b){var c,d,e=[],f=0,g=a.length;for(;f<g;f++){c=a[f];if(!c.style)continue;e[f]=p._data(c,"olddisplay"),b?(!e[f]&&c.style.display==="none"&&(c.style.display=""),c.style.display===""&&bZ(c)&&(e[f]=p._data(c,"olddisplay",cc(c.nodeName)))):(d=bH(c,"display"),!e[f]&&d!=="none"&&p._data(c,"olddisplay",d))}for(f=0;f<g;f++){c=a[f];if(!c.style)continue;if(!b||c.style.display==="none"||c.style.display==="")c.style.display=b?e[f]||"":"none"}return a}function b_(a,b,c){var d=bP.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function ca(a,b,c,d){var e=c===(d?"border":"content")?4:b==="width"?1:0,f=0;for(;e<4;e+=2)c==="margin"&&(f+=p.css(a,c+bV[e],!0)),d?(c==="content"&&(f-=parseFloat(bH(a,"padding"+bV[e]))||0),c!=="margin"&&(f-=parseFloat(bH(a,"border"+bV[e]+"Width"))||0)):(f+=parseFloat(bH(a,"padding"+bV[e]))||0,c!=="padding"&&(f+=parseFloat(bH(a,"border"+bV[e]+"Width"))||0));return f}function cb(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=!0,f=p.support.boxSizing&&p.css(a,"boxSizing")==="border-box";if(d<=0||d==null){d=bH(a,b);if(d<0||d==null)d=a.style[b];if(bQ.test(d))return d;e=f&&(p.support.boxSizingReliable||d===a.style[b]),d=parseFloat(d)||0}return d+ca(a,b,c||(f?"border":"content"),e)+"px"}function cc(a){if(bS[a])return bS[a];var b=p("<"+a+">").appendTo(e.body),c=b.css("display");b.remove();if(c==="none"||c===""){bI=e.body.appendChild(bI||p.extend(e.createElement("iframe"),{frameBorder:0,width:0,height:0}));if(!bJ||!bI.createElement)bJ=(bI.contentWindow||bI.contentDocument).document,bJ.write("<!doctype html><html><body>"),bJ.close();b=bJ.body.appendChild(bJ.createElement(a)),c=bH(b,"display"),e.body.removeChild(bI)}return bS[a]=c,c}function ci(a,b,c,d){var e;if(p.isArray(b))p.each(b,function(b,e){c||ce.test(a)?d(a,e):ci(a+"["+(typeof e=="object"?b:"")+"]",e,c,d)});else if(!c&&p.type(b)==="object")for(e in b)ci(a+"["+e+"]",b[e],c,d);else d(a,b)}function cz(a){return function(b,c){typeof b!="string"&&(c=b,b="*");var d,e,f,g=b.toLowerCase().split(s),h=0,i=g.length;if(p.isFunction(c))for(;h<i;h++)d=g[h],f=/^\+/.test(d),f&&(d=d.substr(1)||"*"),e=a[d]=a[d]||[],e[f?"unshift":"push"](c)}}function cA(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h,i=a[f],j=0,k=i?i.length:0,l=a===cv;for(;j<k&&(l||!h);j++)h=i[j](c,d,e),typeof h=="string"&&(!l||g[h]?h=b:(c.dataTypes.unshift(h),h=cA(a,c,d,e,h,g)));return(l||!h)&&!g["*"]&&(h=cA(a,c,d,e,"*",g)),h}function cB(a,c){var d,e,f=p.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((f[d]?a:e||(e={}))[d]=c[d]);e&&p.extend(!0,a,e)}function cC(a,c,d){var e,f,g,h,i=a.contents,j=a.dataTypes,k=a.responseFields;for(f in k)f in d&&(c[k[f]]=d[f]);while(j[0]==="*")j.shift(),e===b&&(e=a.mimeType||c.getResponseHeader("content-type"));if(e)for(f in i)if(i[f]&&i[f].test(e)){j.unshift(f);break}if(j[0]in d)g=j[0];else{for(f in d){if(!j[0]||a.converters[f+" "+j[0]]){g=f;break}h||(h=f)}g=g||h}if(g)return g!==j[0]&&j.unshift(g),d[g]}function cD(a,b){var c,d,e,f,g=a.dataTypes.slice(),h=g[0],i={},j=0;a.dataFilter&&(b=a.dataFilter(b,a.dataType));if(g[1])for(c in a.converters)i[c.toLowerCase()]=a.converters[c];for(;e=g[++j];)if(e!=="*"){if(h!=="*"&&h!==e){c=i[h+" "+e]||i["* "+e];if(!c)for(d in i){f=d.split(" ");if(f[1]===e){c=i[h+" "+f[0]]||i["* "+f[0]];if(c){c===!0?c=i[d]:i[d]!==!0&&(e=f[0],g.splice(j--,0,e));break}}}if(c!==!0)if(c&&a["throws"])b=c(b);else try{b=c(b)}catch(k){return{state:"parsererror",error:c?k:"No conversion from "+h+" to "+e}}}h=e}return{state:"success",data:b}}function cL(){try{return new a.XMLHttpRequest}catch(b){}}function cM(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function cU(){return setTimeout(function(){cN=b},0),cN=p.now()}function cV(a,b){p.each(b,function(b,c){var d=(cT[b]||[]).concat(cT["*"]),e=0,f=d.length;for(;e<f;e++)if(d[e].call(a,b,c))return})}function cW(a,b,c){var d,e=0,f=0,g=cS.length,h=p.Deferred().always(function(){delete i.elem}),i=function(){var b=cN||cU(),c=Math.max(0,j.startTime+j.duration-b),d=1-(c/j.duration||0),e=0,f=j.tweens.length;for(;e<f;e++)j.tweens[e].run(d);return h.notifyWith(a,[j,d,c]),d<1&&f?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:p.extend({},b),opts:p.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:cN||cU(),duration:c.duration,tweens:[],createTween:function(b,c,d){var e=p.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(e),e},stop:function(b){var c=0,d=b?j.tweens.length:0;for(;c<d;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;cX(k,j.opts.specialEasing);for(;e<g;e++){d=cS[e].call(j,a,k,j.opts);if(d)return d}return cV(j,k),p.isFunction(j.opts.start)&&j.opts.start.call(a,j),p.fx.timer(p.extend(i,{anim:j,queue:j.opts.queue,elem:a})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}function cX(a,b){var c,d,e,f,g;for(c in a){d=p.camelCase(c),e=b[d],f=a[c],p.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=p.cssHooks[d];if(g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}}function cY(a,b,c){var d,e,f,g,h,i,j,k,l=this,m=a.style,n={},o=[],q=a.nodeType&&bZ(a);c.queue||(j=p._queueHooks(a,"fx"),j.unqueued==null&&(j.unqueued=0,k=j.empty.fire,j.empty.fire=function(){j.unqueued||k()}),j.unqueued++,l.always(function(){l.always(function(){j.unqueued--,p.queue(a,"fx").length||j.empty.fire()})})),a.nodeType===1&&("height"in b||"width"in b)&&(c.overflow=[m.overflow,m.overflowX,m.overflowY],p.css(a,"display")==="inline"&&p.css(a,"float")==="none"&&(!p.support.inlineBlockNeedsLayout||cc(a.nodeName)==="inline"?m.display="inline-block":m.zoom=1)),c.overflow&&(m.overflow="hidden",p.support.shrinkWrapBlocks||l.done(function(){m.overflow=c.overflow[0],m.overflowX=c.overflow[1],m.overflowY=c.overflow[2]}));for(d in b){f=b[d];if(cP.exec(f)){delete b[d];if(f===(q?"hide":"show"))continue;o.push(d)}}g=o.length;if(g){h=p._data(a,"fxshow")||p._data(a,"fxshow",{}),q?p(a).show():l.done(function(){p(a).hide()}),l.done(function(){var b;p.removeData(a,"fxshow",!0);for(b in n)p.style(a,b,n[b])});for(d=0;d<g;d++)e=o[d],i=l.createTween(e,q?h[e]:0),n[e]=h[e]||p.style(a,e),e in h||(h[e]=i.start,q&&(i.end=i.start,i.start=e==="width"||e==="height"?1:0))}}function cZ(a,b,c,d,e){return new cZ.prototype.init(a,b,c,d,e)}function c$(a,b){var c,d={height:a},e=0;b=b?1:0;for(;e<4;e+=2-b)c=bV[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function da(a){return p.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}var c,d,e=a.document,f=a.location,g=a.navigator,h=a.jQuery,i=a.$,j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf,m=Object.prototype.toString,n=Object.prototype.hasOwnProperty,o=String.prototype.trim,p=function(a,b){return new p.fn.init(a,b,c)},q=/[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,r=/\S/,s=/\s+/,t=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,u=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^[\],:{}\s]*$/,x=/(?:^|:|,)(?:\s*\[)+/g,y=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,z=/"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,A=/^-ms-/,B=/-([\da-z])/gi,C=function(a,b){return(b+"").toUpperCase()},D=function(){e.addEventListener?(e.removeEventListener("DOMContentLoaded",D,!1),p.ready()):e.readyState==="complete"&&(e.detachEvent("onreadystatechange",D),p.ready())},E={};p.fn=p.prototype={constructor:p,init:function(a,c,d){var f,g,h,i;if(!a)return this;if(a.nodeType)return this.context=this[0]=a,this.length=1,this;if(typeof a=="string"){a.charAt(0)==="<"&&a.charAt(a.length-1)===">"&&a.length>=3?f=[null,a,null]:f=u.exec(a);if(f&&(f[1]||!c)){if(f[1])return c=c instanceof p?c[0]:c,i=c&&c.nodeType?c.ownerDocument||c:e,a=p.parseHTML(f[1],i,!0),v.test(f[1])&&p.isPlainObject(c)&&this.attr.call(a,c,!0),p.merge(this,a);g=e.getElementById(f[2]);if(g&&g.parentNode){if(g.id!==f[2])return d.find(a);this.length=1,this[0]=g}return this.context=e,this.selector=a,this}return!c||c.jquery?(c||d).find(a):this.constructor(c).find(a)}return p.isFunction(a)?d.ready(a):(a.selector!==b&&(this.selector=a.selector,this.context=a.context),p.makeArray(a,this))},selector:"",jquery:"1.8.2",length:0,size:function(){return this.length},toArray:function(){return k.call(this)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=p.merge(this.constructor(),a);return d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")"),d},each:function(a,b){return p.each(this,a,b)},ready:function(a){return p.ready.promise().done(a),this},eq:function(a){return a=+a,a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(k.apply(this,arguments),"slice",k.call(arguments).join(","))},map:function(a){return this.pushStack(p.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:j,sort:[].sort,splice:[].splice},p.fn.init.prototype=p.fn,p.extend=p.fn.extend=function(){var a,c,d,e,f,g,h=arguments[0]||{},i=1,j=arguments.length,k=!1;typeof h=="boolean"&&(k=h,h=arguments[1]||{},i=2),typeof h!="object"&&!p.isFunction(h)&&(h={}),j===i&&(h=this,--i);for(;i<j;i++)if((a=arguments[i])!=null)for(c in a){d=h[c],e=a[c];if(h===e)continue;k&&e&&(p.isPlainObject(e)||(f=p.isArray(e)))?(f?(f=!1,g=d&&p.isArray(d)?d:[]):g=d&&p.isPlainObject(d)?d:{},h[c]=p.extend(k,g,e)):e!==b&&(h[c]=e)}return h},p.extend({noConflict:function(b){return a.$===p&&(a.$=i),b&&a.jQuery===p&&(a.jQuery=h),p},isReady:!1,readyWait:1,holdReady:function(a){a?p.readyWait++:p.ready(!0)},ready:function(a){if(a===!0?--p.readyWait:p.isReady)return;if(!e.body)return setTimeout(p.ready,1);p.isReady=!0;if(a!==!0&&--p.readyWait>0)return;d.resolveWith(e,[p]),p.fn.trigger&&p(e).trigger("ready").off("ready")},isFunction:function(a){return p.type(a)==="function"},isArray:Array.isArray||function(a){return p.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):E[m.call(a)]||"object"},isPlainObject:function(a){if(!a||p.type(a)!=="object"||a.nodeType||p.isWindow(a))return!1;try{if(a.constructor&&!n.call(a,"constructor")&&!n.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||n.call(a,d)},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},error:function(a){throw new Error(a)},parseHTML:function(a,b,c){var d;return!a||typeof a!="string"?null:(typeof b=="boolean"&&(c=b,b=0),b=b||e,(d=v.exec(a))?[b.createElement(d[1])]:(d=p.buildFragment([a],b,c?null:[]),p.merge([],(d.cacheable?p.clone(d.fragment):d.fragment).childNodes)))},parseJSON:function(b){if(!b||typeof b!="string")return null;b=p.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(w.test(b.replace(y,"@").replace(z,"]").replace(x,"")))return(new Function("return "+b))();p.error("Invalid JSON: "+b)},parseXML:function(c){var d,e;if(!c||typeof c!="string")return null;try{a.DOMParser?(e=new DOMParser,d=e.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(f){d=b}return(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&p.error("Invalid XML: "+c),d},noop:function(){},globalEval:function(b){b&&r.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(A,"ms-").replace(B,C)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,c,d){var e,f=0,g=a.length,h=g===b||p.isFunction(a);if(d){if(h){for(e in a)if(c.apply(a[e],d)===!1)break}else for(;f<g;)if(c.apply(a[f++],d)===!1)break}else if(h){for(e in a)if(c.call(a[e],e,a[e])===!1)break}else for(;f<g;)if(c.call(a[f],f,a[f++])===!1)break;return a},trim:o&&!o.call("` + "\xEF\xBB\xBF" + ` ")?function(a){return a==null?"":o.call(a)}:function(a){return a==null?"":(a+"").replace(t,"")},makeArray:function(a,b){var c,d=b||[];return a!=null&&(c=p.type(a),a.length==null||c==="string"||c==="function"||c==="regexp"||p.isWindow(a)?j.call(d,a):p.merge(d,a)),d},inArray:function(a,b,c){var d;if(b){if(l)return l.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=c.length,e=a.length,f=0;if(typeof d=="number")for(;f<d;f++)a[e++]=c[f];else while(c[f]!==b)a[e++]=c[f++];return a.length=e,a},grep:function(a,b,c){var d,e=[],f=0,g=a.length;c=!!c;for(;f<g;f++)d=!!b(a[f],f),c!==d&&e.push(a[f]);return e},map:function(a,c,d){var e,f,g=[],h=0,i=a.length,j=a instanceof p||i!==b&&typeof i=="number"&&(i>0&&a[0]&&a[i-1]||i===0||p.isArray(a));if(j)for(;h<i;h++)e=c(a[h],h,d),e!=null&&(g[g.length]=e);else for(f in a)e=c(a[f],f,d),e!=null&&(g[g.length]=e);return g.concat.apply([],g)},guid:1,proxy:function(a,c){var d,e,f;return typeof c=="string"&&(d=a[c],c=a,a=d),p.isFunction(a)?(e=k.call(arguments,2),f=function(){return a.apply(c,e.concat(k.call(arguments)))},f.guid=a.guid=a.guid||p.guid++,f):b},access:function(a,c,d,e,f,g,h){var i,j=d==null,k=0,l=a.length;if(d&&typeof d=="object"){for(k in d)p.access(a,c,k,d[k],1,g,e);f=1}else if(e!==b){i=h===b&&p.isFunction(e),j&&(i?(i=c,c=function(a,b,c){return i.call(p(a),c)}):(c.call(a,e),c=null));if(c)for(;k<l;k++)c(a[k],d,i?e.call(a[k],k,c(a[k],d)):e,h);f=1}return f?a:j?c.call(a):l?c(a[0],d):g},now:function(){return(new Date).getTime()}}),p.ready.promise=function(b){if(!d){d=p.Deferred();if(e.readyState==="complete")setTimeout(p.ready,1);else if(e.addEventListener)e.addEventListener("DOMContentLoaded",D,!1),a.addEventListener("load",p.ready,!1);else{e.attachEvent("onreadystatechange",D),a.attachEvent("onload",p.ready);var c=!1;try{c=a.frameElement==null&&e.documentElement}catch(f){}c&&c.doScroll&&function g(){if(!p.isReady){try{c.doScroll("left")}catch(a){return setTimeout(g,50)}p.ready()}}()}}return d.promise(b)},p.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){E["[object "+b+"]"]=b.toLowerCase()}),c=p(e);var F={};p.Callbacks=function(a){a=typeof a=="string"?F[a]||G(a):p.extend({},a);var c,d,e,f,g,h,i=[],j=!a.once&&[],k=function(b){c=a.memory&&b,d=!0,h=f||0,f=0,g=i.length,e=!0;for(;i&&h<g;h++)if(i[h].apply(b[0],b[1])===!1&&a.stopOnFalse){c=!1;break}e=!1,i&&(j?j.length&&k(j.shift()):c?i=[]:l.disable())},l={add:function(){if(i){var b=i.length;(function d(b){p.each(b,function(b,c){var e=p.type(c);e==="function"&&(!a.unique||!l.has(c))?i.push(c):c&&c.length&&e!=="string"&&d(c)})})(arguments),e?g=i.length:c&&(f=b,k(c))}return this},remove:function(){return i&&p.each(arguments,function(a,b){var c;while((c=p.inArray(b,i,c))>-1)i.splice(c,1),e&&(c<=g&&g--,c<=h&&h--)}),this},has:function(a){return p.inArray(a,i)>-1},empty:function(){return i=[],this},disable:function(){return i=j=c=b,this},disabled:function(){return!i},lock:function(){return j=b,c||l.disable(),this},locked:function(){return!j},fireWith:function(a,b){return b=b||[],b=[a,b.slice?b.slice():b],i&&(!d||j)&&(e?j.push(b):k(b)),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!d}};return l},p.extend({Deferred:function(a){var b=[["resolve","done",p.Callbacks("once memory"),"resolved"],["reject","fail",p.Callbacks("once memory"),"rejected"],["notify","progress",p.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return p.Deferred(function(c){p.each(b,function(b,d){var f=d[0],g=a[b];e[d[1]](p.isFunction(g)?function(){var a=g.apply(this,arguments);a&&p.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f+"With"](this===e?c:this,[a])}:c[f])}),a=null}).promise()},promise:function(a){return a!=null?p.extend(a,d):d}},e={};return d.pipe=d.then,p.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[a^1][2].disable,b[2][2].lock),e[f[0]]=g.fire,e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=k.call(arguments),d=c.length,e=d!==1||a&&p.isFunction(a.promise)?d:0,f=e===1?a:p.Deferred(),g=function(a,b,c){return function(d){b[a]=this,c[a]=arguments.length>1?k.call(arguments):d,c===h?f.notifyWith(b,c):--e||f.resolveWith(b,c)}},h,i,j;if(d>1){h=new Array(d),i=new Array(d),j=new Array(d);for(;b<d;b++)c[b]&&p.isFunction(c[b].promise)?c[b].promise().done(g(b,j,c)).fail(f.reject).progress(g(b,i,h)):--e}return e||f.resolveWith(j,c),f.promise()}}),p.support=function(){var b,c,d,f,g,h,i,j,k,l,m,n=e.createElement("div");n.setAttribute("className","t"),n.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",c=n.getElementsByTagName("*"),d=n.getElementsByTagName("a")[0],d.style.cssText="top:1px;float:left;opacity:.5";if(!c||!c.length)return{};f=e.createElement("select"),g=f.appendChild(e.createElement("option")),h=n.getElementsByTagName("input")[0],b={leadingWhitespace:n.firstChild.nodeType===3,tbody:!n.getElementsByTagName("tbody").length,htmlSerialize:!!n.getElementsByTagName("link").length,style:/top/.test(d.getAttribute("style")),hrefNormalized:d.getAttribute("href")==="/a",opacity:/^0.5/.test(d.style.opacity),cssFloat:!!d.style.cssFloat,checkOn:h.value==="on",optSelected:g.selected,getSetAttribute:n.className!=="t",enctype:!!e.createElement("form").enctype,html5Clone:e.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",boxModel:e.compatMode==="CSS1Compat",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,boxSizingReliable:!0,pixelPosition:!1},h.checked=!0,b.noCloneChecked=h.cloneNode(!0).checked,f.disabled=!0,b.optDisabled=!g.disabled;try{delete n.test}catch(o){b.deleteExpando=!1}!n.addEventListener&&n.attachEvent&&n.fireEvent&&(n.attachEvent("onclick",m=function(){b.noCloneEvent=!1}),n.cloneNode(!0).fireEvent("onclick"),n.detachEvent("onclick",m)),h=e.createElement("input"),h.value="t",h.setAttribute("type","radio"),b.radioValue=h.value==="t",h.setAttribute("checked","checked"),h.setAttribute("name","t"),n.appendChild(h),i=e.createDocumentFragment(),i.appendChild(n.lastChild),b.checkClone=i.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=h.checked,i.removeChild(h),i.appendChild(n);if(n.attachEvent)for(k in{submit:!0,change:!0,focusin:!0})j="on"+k,l=j in n,l||(n.setAttribute(j,"return;"),l=typeof n[j]=="function"),b[k+"Bubbles"]=l;return p(function(){var c,d,f,g,h="padding:0;margin:0;border:0;display:block;overflow:hidden;",i=e.getElementsByTagName("body")[0];if(!i)return;c=e.createElement("div"),c.style.cssText="visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px",i.insertBefore(c,i.firstChild),d=e.createElement("div"),c.appendChild(d),d.innerHTML="<table><tr><td></td><td>t</td></tr></table>",f=d.getElementsByTagName("td"),f[0].style.cssText="padding:0;margin:0;border:0;display:none",l=f[0].offsetHeight===0,f[0].style.display="",f[1].style.display="none",b.reliableHiddenOffsets=l&&f[0].offsetHeight===0,d.innerHTML="",d.style.cssText="box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;",b.boxSizing=d.offsetWidth===4,b.doesNotIncludeMarginInBodyOffset=i.offsetTop!==1,a.getComputedStyle&&(b.pixelPosition=(a.getComputedStyle(d,null)||{}).top!=="1%",b.boxSizingReliable=(a.getComputedStyle(d,null)||{width:"4px"}).width==="4px",g=e.createElement("div"),g.style.cssText=d.style.cssText=h,g.style.marginRight=g.style.width="0",d.style.width="1px",d.appendChild(g),b.reliableMarginRight=!parseFloat((a.getComputedStyle(g,null)||{}).marginRight)),typeof d.style.zoom!="undefined"&&(d.innerHTML="",d.style.cssText=h+"width:1px;padding:1px;display:inline;zoom:1",b.inlineBlockNeedsLayout=d.offsetWidth===3,d.style.display="block",d.style.overflow="visible",d.innerHTML="<div></div>",d.firstChild.style.width="5px",b.shrinkWrapBlocks=d.offsetWidth!==3,c.style.zoom=1),i.removeChild(c),c=d=f=g=null}),i.removeChild(n),c=d=f=g=h=i=n=null,b}();var H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,I=/([A-Z])/g;p.extend({cache:{},deletedIds:[],uuid:0,expando:"jQuery"+(p.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){return a=a.nodeType?p.cache[a[p.expando]]:a[p.expando],!!a&&!K(a)},data:function(a,c,d,e){if(!p.acceptData(a))return;var f,g,h=p.expando,i=typeof c=="string",j=a.nodeType,k=j?p.cache:a,l=j?a[h]:a[h]&&h;if((!l||!k[l]||!e&&!k[l].data)&&i&&d===b)return;l||(j?a[h]=l=p.deletedIds.pop()||p.guid++:l=h),k[l]||(k[l]={},j||(k[l].toJSON=p.noop));if(typeof c=="object"||typeof c=="function")e?k[l]=p.extend(k[l],c):k[l].data=p.extend(k[l].data,c);return f=k[l],e||(f.data||(f.data={}),f=f.data),d!==b&&(f[p.camelCase(c)]=d),i?(g=f[c],g==null&&(g=f[p.camelCase(c)])):g=f,g},removeData:function(a,b,c){if(!p.acceptData(a))return;var d,e,f,g=a.nodeType,h=g?p.cache:a,i=g?a[p.expando]:p.expando;if(!h[i])return;if(b){d=c?h[i]:h[i].data;if(d){p.isArray(b)||(b in d?b=[b]:(b=p.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,f=b.length;e<f;e++)delete d[b[e]];if(!(c?K:p.isEmptyObject)(d))return}}if(!c){delete h[i].data;if(!K(h[i]))return}g?p.cleanData([a],!0):p.support.deleteExpando||h!=h.window?delete h[i]:h[i]=null},_data:function(a,b,c){return p.data(a,b,c,!0)},acceptData:function(a){var b=a.nodeName&&p.noData[a.nodeName.toLowerCase()];return!b||b!==!0&&a.getAttribute("classid")===b}}),p.fn.extend({data:function(a,c){var d,e,f,g,h,i=this[0],j=0,k=null;if(a===b){if(this.length){k=p.data(i);if(i.nodeType===1&&!p._data(i,"parsedAttrs")){f=i.attributes;for(h=f.length;j<h;j++)g=f[j].name,g.indexOf("data-")||(g=p.camelCase(g.substring(5)),J(i,g,k[g]));p._data(i,"parsedAttrs",!0)}}return k}return typeof a=="object"?this.each(function(){p.data(this,a)}):(d=a.split(".",2),d[1]=d[1]?"."+d[1]:"",e=d[1]+"!",p.access(this,function(c){if(c===b)return k=this.triggerHandler("getData"+e,[d[0]]),k===b&&i&&(k=p.data(i,a),k=J(i,a,k)),k===b&&d[1]?this.data(d[0]):k;d[1]=c,this.each(function(){var b=p(this);b.triggerHandler("setData"+e,d),p.data(this,a,c),b.triggerHandler("changeData"+e,d)})},null,c,arguments.length>1,null,!1))},removeData:function(a){return this.each(function(){p.removeData(this,a)})}}),p.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=p._data(a,b),c&&(!d||p.isArray(c)?d=p._data(a,b,p.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=p.queue(a,b),d=c.length,e=c.shift(),f=p._queueHooks(a,b),g=function(){p.dequeue(a,b)};e==="inprogress"&&(e=c.shift(),d--),e&&(b==="fx"&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return p._data(a,c)||p._data(a,c,{empty:p.Callbacks("once memory").add(function(){p.removeData(a,b+"queue",!0),p.removeData(a,c,!0)})})}}),p.fn.extend({queue:function(a,c){var d=2;return typeof a!="string"&&(c=a,a="fx",d--),arguments.length<d?p.queue(this[0],a):c===b?this:this.each(function(){var b=p.queue(this,a,c);p._queueHooks(this,a),a==="fx"&&b[0]!=="inprogress"&&p.dequeue(this,a)})},dequeue:function(a){return this.each(function(){p.dequeue(this,a)})},delay:function(a,b){return a=p.fx?p.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){var d,e=1,f=p.Deferred(),g=this,h=this.length,i=function(){--e||f.resolveWith(g,[g])};typeof a!="string"&&(c=a,a=b),a=a||"fx";while(h--)d=p._data(g[h],a+"queueHooks"),d&&d.empty&&(e++,d.empty.add(i));return i(),f.promise(c)}});var L,M,N,O=/[\t\r\n]/g,P=/\r/g,Q=/^(?:button|input)$/i,R=/^(?:button|input|object|select|textarea)$/i,S=/^a(?:rea|)$/i,T=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,U=p.support.getSetAttribute;p.fn.extend({attr:function(a,b){return p.access(this,p.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){p.removeAttr(this,a)})},prop:function(a,b){return p.access(this,p.prop,a,b,arguments.length>1)},removeProp:function(a){return a=p.propFix[a]||a,this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,f,g,h;if(p.isFunction(a))return this.each(function(b){p(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(s);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{f=" "+e.className+" ";for(g=0,h=b.length;g<h;g++)f.indexOf(" "+b[g]+" ")<0&&(f+=b[g]+" ");e.className=p.trim(f)}}}return this},removeClass:function(a){var c,d,e,f,g,h,i;if(p.isFunction(a))return this.each(function(b){p(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(s);for(h=0,i=this.length;h<i;h++){e=this[h];if(e.nodeType===1&&e.className){d=(" "+e.className+" ").replace(O," ");for(f=0,g=c.length;f<g;f++)while(d.indexOf(" "+c[f]+" ")>=0)d=d.replace(" "+c[f]+" "," ");e.className=a?p.trim(d):""}}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";return p.isFunction(a)?this.each(function(c){p(this).toggleClass(a.call(this,c,this.className,b),b)}):this.each(function(){if(c==="string"){var e,f=0,g=p(this),h=b,i=a.split(s);while(e=i[f++])h=d?h:!g.hasClass(e),g[h?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&p._data(this,"__className__",this.className),this.className=this.className||a===!1?"":p._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(O," ").indexOf(b)>=0)return!0;return!1},val:function(a){var c,d,e,f=this[0];if(!arguments.length){if(f)return c=p.valHooks[f.type]||p.valHooks[f.nodeName.toLowerCase()],c&&"get"in c&&(d=c.get(f,"value"))!==b?d:(d=f.value,typeof d=="string"?d.replace(P,""):d==null?"":d);return}return e=p.isFunction(a),this.each(function(d){var f,g=p(this);if(this.nodeType!==1)return;e?f=a.call(this,d,g.val()):f=a,f==null?f="":typeof f=="number"?f+="":p.isArray(f)&&(f=p.map(f,function(a){return a==null?"":a+""})),c=p.valHooks[this.type]||p.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,f,"value")===b)this.value=f})}}),p.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,f=a.selectedIndex,g=[],h=a.options,i=a.type==="select-one";if(f<0)return null;c=i?f:0,d=i?f+1:h.length;for(;c<d;c++){e=h[c];if(e.selected&&(p.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!p.nodeName(e.parentNode,"optgroup"))){b=p(e).val();if(i)return b;g.push(b)}}return i&&!g.length&&h.length?p(h[f]).val():g},set:function(a,b){var c=p.makeArray(b);return p(a).find("option").each(function(){this.selected=p.inArray(p(this).val(),c)>=0}),c.length||(a.selectedIndex=-1),c}}},attrFn:{},attr:function(a,c,d,e){var f,g,h,i=a.nodeType;if(!a||i===3||i===8||i===2)return;if(e&&p.isFunction(p.fn[c]))return p(a)[c](d);if(typeof a.getAttribute=="undefined")return p.prop(a,c,d);h=i!==1||!p.isXMLDoc(a),h&&(c=c.toLowerCase(),g=p.attrHooks[c]||(T.test(c)?M:L));if(d!==b){if(d===null){p.removeAttr(a,c);return}return g&&"set"in g&&h&&(f=g.set(a,d,c))!==b?f:(a.setAttribute(c,d+""),d)}return g&&"get"in g&&h&&(f=g.get(a,c))!==null?f:(f=a.getAttribute(c),f===null?b:f)},removeAttr:function(a,b){var c,d,e,f,g=0;if(b&&a.nodeType===1){d=b.split(s);for(;g<d.length;g++)e=d[g],e&&(c=p.propFix[e]||e,f=T.test(e),f||p.attr(a,e,""),a.removeAttribute(U?e:c),f&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(Q.test(a.nodeName)&&a.parentNode)p.error("type property can't be changed");else if(!p.support.radioValue&&b==="radio"&&p.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}},value:{get:function(a,b){return L&&p.nodeName(a,"button")?L.get(a,b):b in a?a.value:null},set:function(a,b,c){if(L&&p.nodeName(a,"button"))return L.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,f,g,h=a.nodeType;if(!a||h===3||h===8||h===2)return;return g=h!==1||!p.isXMLDoc(a),g&&(c=p.propFix[c]||c,f=p.propHooks[c]),d!==b?f&&"set"in f&&(e=f.set(a,d,c))!==b?e:a[c]=d:f&&"get"in f&&(e=f.get(a,c))!==null?e:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):R.test(a.nodeName)||S.test(a.nodeName)&&a.href?0:b}}}}),M={get:function(a,c){var d,e=p.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;return b===!1?p.removeAttr(a,c):(d=p.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase())),c}},U||(N={name:!0,id:!0,coords:!0},L=p.valHooks.button={get:function(a,c){var d;return d=a.getAttributeNode(c),d&&(N[c]?d.value!=="":d.specified)?d.value:b},set:function(a,b,c){var d=a.getAttributeNode(c);return d||(d=e.createAttribute(c),a.setAttributeNode(d)),d.value=b+""}},p.each(["width","height"],function(a,b){p.attrHooks[b]=p.extend(p.attrHooks[b],{set:function(a,c){if(c==="")return a.setAttribute(b,"auto"),c}})}),p.attrHooks.contenteditable={get:L.get,set:function(a,b,c){b===""&&(b="false"),L.set(a,b,c)}}),p.support.hrefNormalized||p.each(["href","src","width","height"],function(a,c){p.attrHooks[c]=p.extend(p.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),p.support.style||(p.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=b+""}}),p.support.optSelected||(p.propHooks.selected=p.extend(p.propHooks.selected,{get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}})),p.support.enctype||(p.propFix.enctype="encoding"),p.support.checkOn||p.each(["radio","checkbox"],function(){p.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),p.each(["radio","checkbox"],function(){p.valHooks[this]=p.extend(p.valHooks[this],{set:function(a,b){if(p.isArray(b))return a.checked=p.inArray(p(a).val(),b)>=0}})});var V=/^(?:textarea|input|select)$/i,W=/^([^\.]*|)(?:\.(.+)|)$/,X=/(?:^|\s)hover(\.\S+|)\b/,Y=/^key/,Z=/^(?:mouse|contextmenu)|click/,$=/^(?:focusinfocus|focusoutblur)$/,_=function(a){return p.event.special.hover?a:a.replace(X,"mouseenter$1 mouseleave$1")};p.event={add:function(a,c,d,e,f){var g,h,i,j,k,l,m,n,o,q,r;if(a.nodeType===3||a.nodeType===8||!c||!d||!(g=p._data(a)))return;d.handler&&(o=d,d=o.handler,f=o.selector),d.guid||(d.guid=p.guid++),i=g.events,i||(g.events=i={}),h=g.handle,h||(g.handle=h=function(a){return typeof p!="undefined"&&(!a||p.event.triggered!==a.type)?p.event.dispatch.apply(h.elem,arguments):b},h.elem=a),c=p.trim(_(c)).split(" ");for(j=0;j<c.length;j++){k=W.exec(c[j])||[],l=k[1],m=(k[2]||"").split(".").sort(),r=p.event.special[l]||{},l=(f?r.delegateType:r.bindType)||l,r=p.event.special[l]||{},n=p.extend({type:l,origType:k[1],data:e,handler:d,guid:d.guid,selector:f,needsContext:f&&p.expr.match.needsContext.test(f),namespace:m.join(".")},o),q=i[l];if(!q){q=i[l]=[],q.delegateCount=0;if(!r.setup||r.setup.call(a,e,m,h)===!1)a.addEventListener?a.addEventListener(l,h,!1):a.attachEvent&&a.attachEvent("on"+l,h)}r.add&&(r.add.call(a,n),n.handler.guid||(n.handler.guid=d.guid)),f?q.splice(q.delegateCount++,0,n):q.push(n),p.event.global[l]=!0}a=null},global:{},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,q,r=p.hasData(a)&&p._data(a);if(!r||!(m=r.events))return;b=p.trim(_(b||"")).split(" ");for(f=0;f<b.length;f++){g=W.exec(b[f])||[],h=i=g[1],j=g[2];if(!h){for(h in m)p.event.remove(a,h+b[f],c,d,!0);continue}n=p.event.special[h]||{},h=(d?n.delegateType:n.bindType)||h,o=m[h]||[],k=o.length,j=j?new RegExp("(^|\\.)"+j.split(".").sort().join("\\.(?:.*\\.|)")+"(\\.|$)"):null;for(l=0;l<o.length;l++)q=o[l],(e||i===q.origType)&&(!c||c.guid===q.guid)&&(!j||j.test(q.namespace))&&(!d||d===q.selector||d==="**"&&q.selector)&&(o.splice(l--,1),q.selector&&o.delegateCount--,n.remove&&n.remove.call(a,q));o.length===0&&k!==o.length&&((!n.teardown||n.teardown.call(a,j,r.handle)===!1)&&p.removeEvent(a,h,r.handle),delete m[h])}p.isEmptyObject(m)&&(delete r.handle,p.removeData(a,"events",!0))},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,f,g){if(!f||f.nodeType!==3&&f.nodeType!==8){var h,i,j,k,l,m,n,o,q,r,s=c.type||c,t=[];if($.test(s+p.event.triggered))return;s.indexOf("!")>=0&&(s=s.slice(0,-1),i=!0),s.indexOf(".")>=0&&(t=s.split("."),s=t.shift(),t.sort());if((!f||p.event.customEvent[s])&&!p.event.global[s])return;c=typeof c=="object"?c[p.expando]?c:new p.Event(s,c):new p.Event(s),c.type=s,c.isTrigger=!0,c.exclusive=i,c.namespace=t.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,m=s.indexOf(":")<0?"on"+s:"";if(!f){h=p.cache;for(j in h)h[j].events&&h[j].events[s]&&p.event.trigger(c,d,h[j].handle.elem,!0);return}c.result=b,c.target||(c.target=f),d=d!=null?p.makeArray(d):[],d.unshift(c),n=p.event.special[s]||{};if(n.trigger&&n.trigger.apply(f,d)===!1)return;q=[[f,n.bindType||s]];if(!g&&!n.noBubble&&!p.isWindow(f)){r=n.delegateType||s,k=$.test(r+s)?f:f.parentNode;for(l=f;k;k=k.parentNode)q.push([k,r]),l=k;l===(f.ownerDocument||e)&&q.push([l.defaultView||l.parentWindow||a,r])}for(j=0;j<q.length&&!c.isPropagationStopped();j++)k=q[j][0],c.type=q[j][1],o=(p._data(k,"events")||{})[c.type]&&p._data(k,"handle"),o&&o.apply(k,d),o=m&&k[m],o&&p.acceptData(k)&&o.apply&&o.apply(k,d)===!1&&c.preventDefault();return c.type=s,!g&&!c.isDefaultPrevented()&&(!n._default||n._default.apply(f.ownerDocument,d)===!1)&&(s!=="click"||!p.nodeName(f,"a"))&&p.acceptData(f)&&m&&f[s]&&(s!=="focus"&&s!=="blur"||c.target.offsetWidth!==0)&&!p.isWindow(f)&&(l=f[m],l&&(f[m]=null),p.event.triggered=s,f[s](),p.event.triggered=b,l&&(f[m]=l)),c.result}return},dispatch:function(c){c=p.event.fix(c||a.event);var d,e,f,g,h,i,j,l,m,n,o=(p._data(this,"events")||{})[c.type]||[],q=o.delegateCount,r=k.call(arguments),s=!c.exclusive&&!c.namespace,t=p.event.special[c.type]||{},u=[];r[0]=c,c.delegateTarget=this;if(t.preDispatch&&t.preDispatch.call(this,c)===!1)return;if(q&&(!c.button||c.type!=="click"))for(f=c.target;f!=this;f=f.parentNode||this)if(f.disabled!==!0||c.type!=="click"){h={},j=[];for(d=0;d<q;d++)l=o[d],m=l.selector,h[m]===b&&(h[m]=l.needsContext?p(m,this).index(f)>=0:p.find(m,this,null,[f]).length),h[m]&&j.push(l);j.length&&u.push({elem:f,matches:j})}o.length>q&&u.push({elem:this,matches:o.slice(q)});for(d=0;d<u.length&&!c.isPropagationStopped();d++){i=u[d],c.currentTarget=i.elem;for(e=0;e<i.matches.length&&!c.isImmediatePropagationStopped();e++){l=i.matches[e];if(s||!c.namespace&&!l.namespace||c.namespace_re&&c.namespace_re.test(l.namespace))c.data=l.data,c.handleObj=l,g=((p.event.special[l.origType]||{}).handle||l.handler).apply(i.elem,r),g!==b&&(c.result=g,g===!1&&(c.preventDefault(),c.stopPropagation()))}}return t.postDispatch&&t.postDispatch.call(this,c),c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,c){var d,f,g,h=c.button,i=c.fromElement;return a.pageX==null&&c.clientX!=null&&(d=a.target.ownerDocument||e,f=d.documentElement,g=d.body,a.pageX=c.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=c.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?c.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0),a}},fix:function(a){if(a[p.expando])return a;var b,c,d=a,f=p.event.fixHooks[a.type]||{},g=f.props?this.props.concat(f.props):this.props;a=p.Event(d);for(b=g.length;b;)c=g[--b],a[c]=d[c];return a.target||(a.target=d.srcElement||e),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,f.filter?f.filter(a,d):a},special:{load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){p.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=p.extend(new p.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?p.event.trigger(e,null,b):p.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},p.event.handle=p.event.dispatch,p.removeEvent=e.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]=="undefined"&&(a[d]=null),a.detachEvent(d,c))},p.Event=function(a,b){if(this instanceof p.Event)a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?bb:ba):this.type=a,b&&p.extend(this,b),this.timeStamp=a&&a.timeStamp||p.now(),this[p.expando]=!0;else return new p.Event(a,b)},p.Event.prototype={preventDefault:function(){this.isDefaultPrevented=bb;var a=this.originalEvent;if(!a)return;a.preventDefault?a.preventDefault():a.returnValue=!1},stopPropagation:function(){this.isPropagationStopped=bb;var a=this.originalEvent;if(!a)return;a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()},isDefaultPrevented:ba,isPropagationStopped:ba,isImmediatePropagationStopped:ba},p.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){p.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj,g=f.selector;if(!e||e!==d&&!p.contains(d,e))a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b;return c}}}),p.support.submitBubbles||(p.event.special.submit={setup:function(){if(p.nodeName(this,"form"))return!1;p.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=p.nodeName(c,"input")||p.nodeName(c,"button")?c.form:b;d&&!p._data(d,"_submit_attached")&&(p.event.add(d,"submit._submit",function(a){a._submit_bubble=!0}),p._data(d,"_submit_attached",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&p.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){if(p.nodeName(this,"form"))return!1;p.event.remove(this,"._submit")}}),p.support.changeBubbles||(p.event.special.change={setup:function(){if(V.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")p.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),p.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),p.event.simulate("change",this,a,!0)});return!1}p.event.add(this,"beforeactivate._change",function(a){var b=a.target;V.test(b.nodeName)&&!p._data(b,"_change_attached")&&(p.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&p.event.simulate("change",this.parentNode,a,!0)}),p._data(b,"_change_attached",!0))})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){return p.event.remove(this,"._change"),!V.test(this.nodeName)}}),p.support.focusinBubbles||p.each({focus:"focusin",blur:"focusout"},function(a,b){var c=0,d=function(a){p.event.simulate(b,a.target,p.event.fix(a),!0)};p.event.special[b]={setup:function(){c++===0&&e.addEventListener(a,d,!0)},teardown:function(){--c===0&&e.removeEventListener(a,d,!0)}}}),p.fn.extend({on:function(a,c,d,e,f){var g,h;if(typeof a=="object"){typeof c!="string"&&(d=d||c,c=b);for(h in a)this.on(h,c,d,a[h],f);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=ba;else if(!e)return this;return f===1&&(g=e,e=function(a){return p().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=p.guid++)),this.each(function(){p.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,c,d){var e,f;if(a&&a.preventDefault&&a.handleObj)return e=a.handleObj,p(a.delegateTarget).off(e.namespace?e.origType+"."+e.namespace:e.origType,e.selector,e.handler),this;if(typeof a=="object"){for(f in a)this.off(f,c,a[f]);return this}if(c===!1||typeof c=="function")d=c,c=b;return d===!1&&(d=ba),this.each(function(){p.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){return p(this.context).on(a,this.selector,b,c),this},die:function(a,b){return p(this.context).off(a,this.selector||"**",b),this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length===1?this.off(a,"**"):this.off(b,a||"**",c)},trigger:function(a,b){return this.each(function(){p.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return p.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||p.guid++,d=0,e=function(c){var e=(p._data(this,"lastToggle"+a.guid)||0)%d;return p._data(this,"lastToggle"+a.guid,e+1),c.preventDefault(),b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),p.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){p.fn[b]=function(a,c){return c==null&&(c=a,a=null),arguments.length>0?this.on(b,null,a,c):this.trigger(b)},Y.test(b)&&(p.event.fixHooks[b]=p.event.keyHooks),Z.test(b)&&(p.event.fixHooks[b]=p.event.mouseHooks)}),function(a,b){function bc(a,b,c,d){c=c||[],b=b||r;var e,f,i,j,k=b.nodeType;if(!a||typeof a!="string")return c;if(k!==1&&k!==9)return[];i=g(b);if(!i&&!d)if(e=P.exec(a))if(j=e[1]){if(k===9){f=b.getElementById(j);if(!f||!f.parentNode)return c;if(f.id===j)return c.push(f),c}else if(b.ownerDocument&&(f=b.ownerDocument.getElementById(j))&&h(b,f)&&f.id===j)return c.push(f),c}else{if(e[2])return w.apply(c,x.call(b.getElementsByTagName(a),0)),c;if((j=e[3])&&_&&b.getElementsByClassName)return w.apply(c,x.call(b.getElementsByClassName(j),0)),c}return bp(a.replace(L,"$1"),b,c,d,i)}function bd(a){return function(b){var c=b.nodeName.toLowerCase();return c==="input"&&b.type===a}}function be(a){return function(b){var c=b.nodeName.toLowerCase();return(c==="input"||c==="button")&&b.type===a}}function bf(a){return z(function(b){return b=+b,z(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function bg(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}function bh(a,b){var c,d,f,g,h,i,j,k=C[o][a];if(k)return b?0:k.slice(0);h=a,i=[],j=e.preFilter;while(h){if(!c||(d=M.exec(h)))d&&(h=h.slice(d[0].length)),i.push(f=[]);c=!1;if(d=N.exec(h))f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=d[0].replace(L," ");for(g in e.filter)(d=W[g].exec(h))&&(!j[g]||(d=j[g](d,r,!0)))&&(f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=g,c.matches=d);if(!c)break}return b?h.length:h?bc.error(a):C(a,i).slice(0)}function bi(a,b,d){var e=b.dir,f=d&&b.dir==="parentNode",g=u++;return b.first?function(b,c,d){while(b=b[e])if(f||b.nodeType===1)return a(b,c,d)}:function(b,d,h){if(!h){var i,j=t+" "+g+" ",k=j+c;while(b=b[e])if(f||b.nodeType===1){if((i=b[o])===k)return b.sizset;if(typeof i=="string"&&i.indexOf(j)===0){if(b.sizset)return b}else{b[o]=k;if(a(b,d,h))return b.sizset=!0,b;b.sizset=!1}}}else while(b=b[e])if(f||b.nodeType===1)if(a(b,d,h))return b}}function bj(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function bk(a,b,c,d,e){var f,g=[],h=0,i=a.length,j=b!=null;for(;h<i;h++)if(f=a[h])if(!c||c(f,d,e))g.push(f),j&&b.push(h);return g}function bl(a,b,c,d,e,f){return d&&!d[o]&&(d=bl(d)),e&&!e[o]&&(e=bl(e,f)),z(function(f,g,h,i){if(f&&e)return;var j,k,l,m=[],n=[],o=g.length,p=f||bo(b||"*",h.nodeType?[h]:h,[],f),q=a&&(f||!b)?bk(p,m,a,h,i):p,r=c?e||(f?a:o||d)?[]:g:q;c&&c(q,r,h,i);if(d){l=bk(r,n),d(l,[],h,i),j=l.length;while(j--)if(k=l[j])r[n[j]]=!(q[n[j]]=k)}if(f){j=a&&r.length;while(j--)if(k=r[j])f[m[j]]=!(g[m[j]]=k)}else r=bk(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):w.apply(g,r)})}function bm(a){var b,c,d,f=a.length,g=e.relative[a[0].type],h=g||e.relative[" "],i=g?1:0,j=bi(function(a){return a===b},h,!0),k=bi(function(a){return y.call(b,a)>-1},h,!0),m=[function(a,c,d){return!g&&(d||c!==l)||((b=c).nodeType?j(a,c,d):k(a,c,d))}];for(;i<f;i++)if(c=e.relative[a[i].type])m=[bi(bj(m),c)];else{c=e.filter[a[i].type].apply(null,a[i].matches);if(c[o]){d=++i;for(;d<f;d++)if(e.relative[a[d].type])break;return bl(i>1&&bj(m),i>1&&a.slice(0,i-1).join("").replace(L,"$1"),c,i<d&&bm(a.slice(i,d)),d<f&&bm(a=a.slice(d)),d<f&&a.join(""))}m.push(c)}return bj(m)}function bn(a,b){var d=b.length>0,f=a.length>0,g=function(h,i,j,k,m){var n,o,p,q=[],s=0,u="0",x=h&&[],y=m!=null,z=l,A=h||f&&e.find.TAG("*",m&&i.parentNode||i),B=t+=z==null?1:Math.E;y&&(l=i!==r&&i,c=g.el);for(;(n=A[u])!=null;u++){if(f&&n){for(o=0;p=a[o];o++)if(p(n,i,j)){k.push(n);break}y&&(t=B,c=++g.el)}d&&((n=!p&&n)&&s--,h&&x.push(n))}s+=u;if(d&&u!==s){for(o=0;p=b[o];o++)p(x,q,i,j);if(h){if(s>0)while(u--)!x[u]&&!q[u]&&(q[u]=v.call(k));q=bk(q)}w.apply(k,q),y&&!h&&q.length>0&&s+b.length>1&&bc.uniqueSort(k)}return y&&(t=B,l=z),x};return g.el=0,d?z(g):g}function bo(a,b,c,d){var e=0,f=b.length;for(;e<f;e++)bc(a,b[e],c,d);return c}function bp(a,b,c,d,f){var g,h,j,k,l,m=bh(a),n=m.length;if(!d&&m.length===1){h=m[0]=m[0].slice(0);if(h.length>2&&(j=h[0]).type==="ID"&&b.nodeType===9&&!f&&e.relative[h[1].type]){b=e.find.ID(j.matches[0].replace(V,""),b,f)[0];if(!b)return c;a=a.slice(h.shift().length)}for(g=W.POS.test(a)?-1:h.length-1;g>=0;g--){j=h[g];if(e.relative[k=j.type])break;if(l=e.find[k])if(d=l(j.matches[0].replace(V,""),R.test(h[0].type)&&b.parentNode||b,f)){h.splice(g,1),a=d.length&&h.join("");if(!a)return w.apply(c,x.call(d,0)),c;break}}}return i(a,m)(d,b,f,c,R.test(a)),c}function bq(){}var c,d,e,f,g,h,i,j,k,l,m=!0,n="undefined",o=("sizcache"+Math.random()).replace(".",""),q=String,r=a.document,s=r.documentElement,t=0,u=0,v=[].pop,w=[].push,x=[].slice,y=[].indexOf||function(a){var b=0,c=this.length;for(;b<c;b++)if(this[b]===a)return b;return-1},z=function(a,b){return a[o]=b==null||b,a},A=function(){var a={},b=[];return z(function(c,d){return b.push(c)>e.cacheLength&&delete a[b.shift()],a[c]=d},a)},B=A(),C=A(),D=A(),E="[\\x20\\t\\r\\n\\f]",F="(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",G=F.replace("w","w#"),H="([*^$|!~]?=)",I="\\["+E+"*("+F+")"+E+"*(?:"+H+E+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+G+")|)|)"+E+"*\\]",J=":("+F+")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:"+I+")|[^:]|\\\\.)*|.*))\\)|)",K=":(even|odd|eq|gt|lt|nth|first|last)(?:\\("+E+"*((?:-\\d)?\\d*)"+E+"*\\)|)(?=[^-]|$)",L=new RegExp("^"+E+"+|((?:^|[^\\\\])(?:\\\\.)*)"+E+"+$","g"),M=new RegExp("^"+E+"*,"+E+"*"),N=new RegExp("^"+E+"*([\\x20\\t\\r\\n\\f>+~])"+E+"*"),O=new RegExp(J),P=/^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,Q=/^:not/,R=/[\x20\t\r\n\f]*[+~]/,S=/:not\($/,T=/h\d/i,U=/input|select|textarea|button/i,V=/\\(?!\\)/g,W={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),NAME:new RegExp("^\\[name=['\"]?("+F+")['\"]?\\]"),TAG:new RegExp("^("+F.replace("w","w*")+")"),ATTR:new RegExp("^"+I),PSEUDO:new RegExp("^"+J),POS:new RegExp(K,"i"),CHILD:new RegExp("^:(only|nth|first|last)-child(?:\\("+E+"*(even|odd|(([+-]|)(\\d*)n|)"+E+"*(?:([+-]|)"+E+"*(\\d+)|))"+E+"*\\)|)","i"),needsContext:new RegExp("^"+E+"*[>+~]|"+K,"i")},X=function(a){var b=r.createElement("div");try{return a(b)}catch(c){return!1}finally{b=null}},Y=X(function(a){return a.appendChild(r.createComment("")),!a.getElementsByTagName("*").length}),Z=X(function(a){return a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!==n&&a.firstChild.getAttribute("href")==="#"}),$=X(function(a){a.innerHTML="<select></select>";var b=typeof a.lastChild.getAttribute("multiple");return b!=="boolean"&&b!=="string"}),_=X(function(a){return a.innerHTML="<div class='hidden e'></div><div class='hidden'></div>",!a.getElementsByClassName||!a.getElementsByClassName("e").length?!1:(a.lastChild.className="e",a.getElementsByClassName("e").length===2)}),ba=X(function(a){a.id=o+0,a.innerHTML="<a name='"+o+"'></a><div name='"+o+"'></div>",s.insertBefore(a,s.firstChild);var b=r.getElementsByName&&r.getElementsByName(o).length===2+r.getElementsByName(o+0).length;return d=!r.getElementById(o),s.removeChild(a),b});try{x.call(s.childNodes,0)[0].nodeType}catch(bb){x=function(a){var b,c=[];for(;b=this[a];a++)c.push(b);return c}}bc.matches=function(a,b){return bc(a,null,null,b)},bc.matchesSelector=function(a,b){return bc(b,null,null,[a]).length>0},f=bc.getText=function(a){var b,c="",d=0,e=a.nodeType;if(e){if(e===1||e===9||e===11){if(typeof a.textContent=="string")return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=f(a)}else if(e===3||e===4)return a.nodeValue}else for(;b=a[d];d++)c+=f(b);return c},g=bc.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?b.nodeName!=="HTML":!1},h=bc.contains=s.contains?function(a,b){var c=a.nodeType===9?a.documentElement:a,d=b&&b.parentNode;return a===d||!!(d&&d.nodeType===1&&c.contains&&c.contains(d))}:s.compareDocumentPosition?function(a,b){return b&&!!(a.compareDocumentPosition(b)&16)}:function(a,b){while(b=b.parentNode)if(b===a)return!0;return!1},bc.attr=function(a,b){var c,d=g(a);return d||(b=b.toLowerCase()),(c=e.attrHandle[b])?c(a):d||$?a.getAttribute(b):(c=a.getAttributeNode(b),c?typeof a[b]=="boolean"?a[b]?b:null:c.specified?c.value:null:null)},e=bc.selectors={cacheLength:50,createPseudo:z,match:W,attrHandle:Z?{}:{href:function(a){return a.getAttribute("href",2)},type:function(a){return a.getAttribute("type")}},find:{ID:d?function(a,b,c){if(typeof b.getElementById!==n&&!c){var d=b.getElementById(a);return d&&d.parentNode?[d]:[]}}:function(a,c,d){if(typeof c.getElementById!==n&&!d){var e=c.getElementById(a);return e?e.id===a||typeof e.getAttributeNode!==n&&e.getAttributeNode("id").value===a?[e]:b:[]}},TAG:Y?function(a,b){if(typeof b.getElementsByTagName!==n)return b.getElementsByTagName(a)}:function(a,b){var c=b.getElementsByTagName(a);if(a==="*"){var d,e=[],f=0;for(;d=c[f];f++)d.nodeType===1&&e.push(d);return e}return c},NAME:ba&&function(a,b){if(typeof b.getElementsByName!==n)return b.getElementsByName(name)},CLASS:_&&function(a,b,c){if(typeof b.getElementsByClassName!==n&&!c)return b.getElementsByClassName(a)}},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(V,""),a[3]=(a[4]||a[5]||"").replace(V,""),a[2]==="~="&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),a[1]==="nth"?(a[2]||bc.error(a[0]),a[3]=+(a[3]?a[4]+(a[5]||1):2*(a[2]==="even"||a[2]==="odd")),a[4]=+(a[6]+a[7]||a[2]==="odd")):a[2]&&bc.error(a[0]),a},PSEUDO:function(a){var b,c;if(W.CHILD.test(a[0]))return null;if(a[3])a[2]=a[3];else if(b=a[4])O.test(b)&&(c=bh(b,!0))&&(c=b.indexOf(")",b.length-c)-b.length)&&(b=b.slice(0,c),a[0]=a[0].slice(0,c)),a[2]=b;return a.slice(0,3)}},filter:{ID:d?function(a){return a=a.replace(V,""),function(b){return b.getAttribute("id")===a}}:function(a){return a=a.replace(V,""),function(b){var c=typeof b.getAttributeNode!==n&&b.getAttributeNode("id");return c&&c.value===a}},TAG:function(a){return a==="*"?function(){return!0}:(a=a.replace(V,"").toLowerCase(),function(b){return b.nodeName&&b.nodeName.toLowerCase()===a})},CLASS:function(a){var b=B[o][a];return b||(b=B(a,new RegExp("(^|"+E+")"+a+"("+E+"|$)"))),function(a){return b.test(a.className||typeof a.getAttribute!==n&&a.getAttribute("class")||"")}},ATTR:function(a,b,c){return function(d,e){var f=bc.attr(d,a);return f==null?b==="!=":b?(f+="",b==="="?f===c:b==="!="?f!==c:b==="^="?c&&f.indexOf(c)===0:b==="*="?c&&f.indexOf(c)>-1:b==="$="?c&&f.substr(f.length-c.length)===c:b==="~="?(" "+f+" ").indexOf(c)>-1:b==="|="?f===c||f.substr(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d){return a==="nth"?function(a){var b,e,f=a.parentNode;if(c===1&&d===0)return!0;if(f){e=0;for(b=f.firstChild;b;b=b.nextSibling)if(b.nodeType===1){e++;if(a===b)break}}return e-=d,e===c||e%c===0&&e/c>=0}:function(b){var c=b;switch(a){case"only":case"first":while(c=c.previousSibling)if(c.nodeType===1)return!1;if(a==="first")return!0;c=b;case"last":while(c=c.nextSibling)if(c.nodeType===1)return!1;return!0}}},PSEUDO:function(a,b){var c,d=e.pseudos[a]||e.setFilters[a.toLowerCase()]||bc.error("unsupported pseudo: "+a);return d[o]?d(b):d.length>1?(c=[a,a,"",b],e.setFilters.hasOwnProperty(a.toLowerCase())?z(function(a,c){var e,f=d(a,b),g=f.length;while(g--)e=y.call(a,f[g]),a[e]=!(c[e]=f[g])}):function(a){return d(a,0,c)}):d}},pseudos:{not:z(function(a){var b=[],c=[],d=i(a.replace(L,"$1"));return d[o]?z(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)if(f=g[h])a[h]=!(b[h]=f)}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:z(function(a){return function(b){return bc(a,b).length>0}}),contains:z(function(a){return function(b){return(b.textContent||b.innerText||f(b)).indexOf(a)>-1}}),enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&!!a.checked||b==="option"&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},parent:function(a){return!e.pseudos.empty(a)},empty:function(a){var b;a=a.firstChild;while(a){if(a.nodeName>"@"||(b=a.nodeType)===3||b===4)return!1;a=a.nextSibling}return!0},header:function(a){return T.test(a.nodeName)},text:function(a){var b,c;return a.nodeName.toLowerCase()==="input"&&(b=a.type)==="text"&&((c=a.getAttribute("type"))==null||c.toLowerCase()===b)},radio:bd("radio"),checkbox:bd("checkbox"),file:bd("file"),password:bd("password"),image:bd("image"),submit:be("submit"),reset:be("reset"),button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&a.type==="button"||b==="button"},input:function(a){return U.test(a.nodeName)},focus:function(a){var b=a.ownerDocument;return a===b.activeElement&&(!b.hasFocus||b.hasFocus())&&(!!a.type||!!a.href)},active:function(a){return a===a.ownerDocument.activeElement},first:bf(function(a,b,c){return[0]}),last:bf(function(a,b,c){return[b-1]}),eq:bf(function(a,b,c){return[c<0?c+b:c]}),even:bf(function(a,b,c){for(var d=0;d<b;d+=2)a.push(d);return a}),odd:bf(function(a,b,c){for(var d=1;d<b;d+=2)a.push(d);return a}),lt:bf(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:bf(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},j=s.compareDocumentPosition?function(a,b){return a===b?(k=!0,0):(!a.compareDocumentPosition||!b.compareDocumentPosition?a.compareDocumentPosition:a.compareDocumentPosition(b)&4)?-1:1}:function(a,b){if(a===b)return k=!0,0;if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,h=b.parentNode,i=g;if(g===h)return bg(a,b);if(!g)return-1;if(!h)return 1;while(i)e.unshift(i),i=i.parentNode;i=h;while(i)f.unshift(i),i=i.parentNode;c=e.length,d=f.length;for(var j=0;j<c&&j<d;j++)if(e[j]!==f[j])return bg(e[j],f[j]);return j===c?bg(a,f[j],-1):bg(e[j],b,1)},[0,0].sort(j),m=!k,bc.uniqueSort=function(a){var b,c=1;k=m,a.sort(j);if(k)for(;b=a[c];c++)b===a[c-1]&&a.splice(c--,1);return a},bc.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},i=bc.compile=function(a,b){var c,d=[],e=[],f=D[o][a];if(!f){b||(b=bh(a)),c=b.length;while(c--)f=bm(b[c]),f[o]?d.push(f):e.push(f);f=D(a,bn(e,d))}return f},r.querySelectorAll&&function(){var a,b=bp,c=/'|\\/g,d=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,e=[":focus"],f=[":active",":focus"],h=s.matchesSelector||s.mozMatchesSelector||s.webkitMatchesSelector||s.oMatchesSelector||s.msMatchesSelector;X(function(a){a.innerHTML="<select><option selected=''></option></select>",a.querySelectorAll("[selected]").length||e.push("\\["+E+"*(?:checked|disabled|ismap|multiple|readonly|selected|value)"),a.querySelectorAll(":checked").length||e.push(":checked")}),X(function(a){a.innerHTML="<p test=''></p>",a.querySelectorAll("[test^='']").length&&e.push("[*^$]="+E+"*(?:\"\"|'')"),a.innerHTML="<input type='hidden'/>",a.querySelectorAll(":enabled").length||e.push(":enabled",":disabled")}),e=new RegExp(e.join("|")),bp=function(a,d,f,g,h){if(!g&&!h&&(!e||!e.test(a))){var i,j,k=!0,l=o,m=d,n=d.nodeType===9&&a;if(d.nodeType===1&&d.nodeName.toLowerCase()!=="object"){i=bh(a),(k=d.getAttribute("id"))?l=k.replace(c,"\\$&"):d.setAttribute("id",l),l="[id='"+l+"'] ",j=i.length;while(j--)i[j]=l+i[j].join("");m=R.test(a)&&d.parentNode||d,n=i.join(",")}if(n)try{return w.apply(f,x.call(m.querySelectorAll(n),0)),f}catch(p){}finally{k||d.removeAttribute("id")}}return b(a,d,f,g,h)},h&&(X(function(b){a=h.call(b,"div");try{h.call(b,"[test!='']:sizzle"),f.push("!=",J)}catch(c){}}),f=new RegExp(f.join("|")),bc.matchesSelector=function(b,c){c=c.replace(d,"='$1']");if(!g(b)&&!f.test(c)&&(!e||!e.test(c)))try{var i=h.call(b,c);if(i||a||b.document&&b.document.nodeType!==11)return i}catch(j){}return bc(c,null,null,[b]).length>0})}(),e.pseudos.nth=e.pseudos.eq,e.filters=bq.prototype=e.pseudos,e.setFilters=new bq,bc.attr=p.attr,p.find=bc,p.expr=bc.selectors,p.expr[":"]=p.expr.pseudos,p.unique=bc.uniqueSort,p.text=bc.getText,p.isXMLDoc=bc.isXML,p.contains=bc.contains}(a);var bc=/Until$/,bd=/^(?:parents|prev(?:Until|All))/,be=/^.[^:#\[\.,]*$/,bf=p.expr.match.needsContext,bg={children:!0,contents:!0,next:!0,prev:!0};p.fn.extend({find:function(a){var b,c,d,e,f,g,h=this;if(typeof a!="string")return p(a).filter(function(){for(b=0,c=h.length;b<c;b++)if(p.contains(h[b],this))return!0});g=this.pushStack("","find",a);for(b=0,c=this.length;b<c;b++){d=g.length,p.find(a,this[b],g);if(b>0)for(e=d;e<g.length;e++)for(f=0;f<d;f++)if(g[f]===g[e]){g.splice(e--,1);break}}return g},has:function(a){var b,c=p(a,this),d=c.length;return this.filter(function(){for(b=0;b<d;b++)if(p.contains(this,c[b]))return!0})},not:function(a){return this.pushStack(bj(this,a,!1),"not",a)},filter:function(a){return this.pushStack(bj(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?bf.test(a)?p(a,this.context).index(this[0])>=0:p.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c,d=0,e=this.length,f=[],g=bf.test(a)||typeof a!="string"?p(a,b||this.context):0;for(;d<e;d++){c=this[d];while(c&&c.ownerDocument&&c!==b&&c.nodeType!==11){if(g?g.index(c)>-1:p.find.matchesSelector(c,a)){f.push(c);break}c=c.parentNode}}return f=f.length>1?p.unique(f):f,this.pushStack(f,"closest",a)},index:function(a){return a?typeof a=="string"?p.inArray(this[0],p(a)):p.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.prevAll().length:-1},add:function(a,b){var c=typeof a=="string"?p(a,b):p.makeArray(a&&a.nodeType?[a]:a),d=p.merge(this.get(),c);return this.pushStack(bh(c[0])||bh(d[0])?d:p.unique(d))},addBack:function(a){return this.add(a==null?this.prevObject:this.prevObject.filter(a))}}),p.fn.andSelf=p.fn.addBack,p.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return p.dir(a,"parentNode")},parentsUntil:function(a,b,c){return p.dir(a,"parentNode",c)},next:function(a){return bi(a,"nextSibling")},prev:function(a){return bi(a,"previousSibling")},nextAll:function(a){return p.dir(a,"nextSibling")},prevAll:function(a){return p.dir(a,"previousSibling")},nextUntil:function(a,b,c){return p.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return p.dir(a,"previousSibling",c)},siblings:function(a){return p.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return p.sibling(a.firstChild)},contents:function(a){return p.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:p.merge([],a.childNodes)}},function(a,b){p.fn[a]=function(c,d){var e=p.map(this,b,c);return bc.test(a)||(d=c),d&&typeof d=="string"&&(e=p.filter(d,e)),e=this.length>1&&!bg[a]?p.unique(e):e,this.length>1&&bd.test(a)&&(e=e.reverse()),this.pushStack(e,a,k.call(arguments).join(","))}}),p.extend({filter:function(a,b,c){return c&&(a=":not("+a+")"),b.length===1?p.find.matchesSelector(b[0],a)?[b[0]]:[]:p.find.matches(a,b)},dir:function(a,c,d){var e=[],f=a[c];while(f&&f.nodeType!==9&&(d===b||f.nodeType!==1||!p(f).is(d)))f.nodeType===1&&e.push(f),f=f[c];return e},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var bl="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",bm=/ jQuery\d+="(?:null|\d+)"/g,bn=/^\s+/,bo=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,bp=/<([\w:]+)/,bq=/<tbody/i,br=/<|&#?\w+;/,bs=/<(?:script|style|link)/i,bt=/<(?:script|object|embed|option|style)/i,bu=new RegExp("<(?:"+bl+")[\\s/>]","i"),bv=/^(?:checkbox|radio)$/,bw=/checked\s*(?:[^=]|=\s*.checked.)/i,bx=/\/(java|ecma)script/i,by=/^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,bz={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bA=bk(e),bB=bA.appendChild(e.createElement("div"));bz.optgroup=bz.option,bz.tbody=bz.tfoot=bz.colgroup=bz.caption=bz.thead,bz.th=bz.td,p.support.htmlSerialize||(bz._default=[1,"X<div>","</div>"]),p.fn.extend({text:function(a){return p.access(this,function(a){return a===b?p.text(this):this.empty().append((this[0]&&this[0].ownerDocument||e).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(p.isFunction(a))return this.each(function(b){p(this).wrapAll(a.call(this,b))});if(this[0]){var b=p(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return p.isFunction(a)?this.each(function(b){p(this).wrapInner(a.call(this,b))}):this.each(function(){var b=p(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=p.isFunction(a);return this.each(function(c){p(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){p.nodeName(this,"body")||p(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.insertBefore(a,this.firstChild)})},before:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(a,this),"before",this.selector)}},after:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(this,a),"after",this.selector)}},remove:function(a,b){var c,d=0;for(;(c=this[d])!=null;d++)if(!a||p.filter(a,[c]).length)!b&&c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),p.cleanData([c])),c.parentNode&&c.parentNode.removeChild(c);return this},empty:function(){var a,b=0;for(;(a=this[b])!=null;b++){a.nodeType===1&&p.cleanData(a.getElementsByTagName("*"));while(a.firstChild)a.removeChild(a.firstChild)}return this},clone:function(a,b){return a=a==null?!1:a,b=b==null?a:b,this.map(function(){return p.clone(this,a,b)})},html:function(a){return p.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(bm,""):b;if(typeof a=="string"&&!bs.test(a)&&(p.support.htmlSerialize||!bu.test(a))&&(p.support.leadingWhitespace||!bn.test(a))&&!bz[(bp.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(bo,"<$1></$2>");try{for(;d<e;d++)c=this[d]||{},c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),c.innerHTML=a);c=0}catch(f){}}c&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(a){return bh(this[0])?this.length?this.pushStack(p(p.isFunction(a)?a():a),"replaceWith",a):this:p.isFunction(a)?this.each(function(b){var c=p(this),d=c.html();c.replaceWith(a.call(this,b,d))}):(typeof a!="string"&&(a=p(a).detach()),this.each(function(){var b=this.nextSibling,c=this.parentNode;p(this).remove(),b?p(b).before(a):p(c).append(a)}))},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){a=[].concat.apply([],a);var e,f,g,h,i=0,j=a[0],k=[],l=this.length;if(!p.support.checkClone&&l>1&&typeof j=="string"&&bw.test(j))return this.each(function(){p(this).domManip(a,c,d)});if(p.isFunction(j))return this.each(function(e){var f=p(this);a[0]=j.call(this,e,c?f.html():b),f.domManip(a,c,d)});if(this[0]){e=p.buildFragment(a,this,k),g=e.fragment,f=g.firstChild,g.childNodes.length===1&&(g=f);if(f){c=c&&p.nodeName(f,"tr");for(h=e.cacheable||l-1;i<l;i++)d.call(c&&p.nodeName(this[i],"table")?bC(this[i],"tbody"):this[i],i===h?g:p.clone(g,!0,!0))}g=f=null,k.length&&p.each(k,function(a,b){b.src?p.ajax?p.ajax({url:b.src,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0}):p.error("no ajax"):p.globalEval((b.text||b.textContent||b.innerHTML||"").replace(by,"")),b.parentNode&&b.parentNode.removeChild(b)})}return this}}),p.buildFragment=function(a,c,d){var f,g,h,i=a[0];return c=c||e,c=!c.nodeType&&c[0]||c,c=c.ownerDocument||c,a.length===1&&typeof i=="string"&&i.length<512&&c===e&&i.charAt(0)==="<"&&!bt.test(i)&&(p.support.checkClone||!bw.test(i))&&(p.support.html5Clone||!bu.test(i))&&(g=!0,f=p.fragments[i],h=f!==b),f||(f=c.createDocumentFragment(),p.clean(a,c,f,d),g&&(p.fragments[i]=h&&f)),{fragment:f,cacheable:g}},p.fragments={},p.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){p.fn[a]=function(c){var d,e=0,f=[],g=p(c),h=g.length,i=this.length===1&&this[0].parentNode;if((i==null||i&&i.nodeType===11&&i.childNodes.length===1)&&h===1)return g[b](this[0]),this;for(;e<h;e++)d=(e>0?this.clone(!0):this).get(),p(g[e])[b](d),f=f.concat(d);return this.pushStack(f,a,g.selector)}}),p.extend({clone:function(a,b,c){var d,e,f,g;p.support.html5Clone||p.isXMLDoc(a)||!bu.test("<"+a.nodeName+">")?g=a.cloneNode(!0):(bB.innerHTML=a.outerHTML,bB.removeChild(g=bB.firstChild));if((!p.support.noCloneEvent||!p.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!p.isXMLDoc(a)){bE(a,g),d=bF(a),e=bF(g);for(f=0;d[f];++f)e[f]&&bE(d[f],e[f])}if(b){bD(a,g);if(c){d=bF(a),e=bF(g);for(f=0;d[f];++f)bD(d[f],e[f])}}return d=e=null,g},clean:function(a,b,c,d){var f,g,h,i,j,k,l,m,n,o,q,r,s=b===e&&bA,t=[];if(!b||typeof b.createDocumentFragment=="undefined")b=e;for(f=0;(h=a[f])!=null;f++){typeof h=="number"&&(h+="");if(!h)continue;if(typeof h=="string")if(!br.test(h))h=b.createTextNode(h);else{s=s||bk(b),l=b.createElement("div"),s.appendChild(l),h=h.replace(bo,"<$1></$2>"),i=(bp.exec(h)||["",""])[1].toLowerCase(),j=bz[i]||bz._default,k=j[0],l.innerHTML=j[1]+h+j[2];while(k--)l=l.lastChild;if(!p.support.tbody){m=bq.test(h),n=i==="table"&&!m?l.firstChild&&l.firstChild.childNodes:j[1]==="<table>"&&!m?l.childNodes:[];for(g=n.length-1;g>=0;--g)p.nodeName(n[g],"tbody")&&!n[g].childNodes.length&&n[g].parentNode.removeChild(n[g])}!p.support.leadingWhitespace&&bn.test(h)&&l.insertBefore(b.createTextNode(bn.exec(h)[0]),l.firstChild),h=l.childNodes,l.parentNode.removeChild(l)}h.nodeType?t.push(h):p.merge(t,h)}l&&(h=l=s=null);if(!p.support.appendChecked)for(f=0;(h=t[f])!=null;f++)p.nodeName(h,"input")?bG(h):typeof h.getElementsByTagName!="undefined"&&p.grep(h.getElementsByTagName("input"),bG);if(c){q=function(a){if(!a.type||bx.test(a.type))return d?d.push(a.parentNode?a.parentNode.removeChild(a):a):c.appendChild(a)};for(f=0;(h=t[f])!=null;f++)if(!p.nodeName(h,"script")||!q(h))c.appendChild(h),typeof h.getElementsByTagName!="undefined"&&(r=p.grep(p.merge([],h.getElementsByTagName("script")),q),t.splice.apply(t,[f+1,0].concat(r)),f+=r.length)}return t},cleanData:function(a,b){var c,d,e,f,g=0,h=p.expando,i=p.cache,j=p.support.deleteExpando,k=p.event.special;for(;(e=a[g])!=null;g++)if(b||p.acceptData(e)){d=e[h],c=d&&i[d];if(c){if(c.events)for(f in c.events)k[f]?p.event.remove(e,f):p.removeEvent(e,f,c.handle);i[d]&&(delete i[d],j?delete e[h]:e.removeAttribute?e.removeAttribute(h):e[h]=null,p.deletedIds.push(d))}}}}),function(){var a,b;p.uaMatch=function(a){a=a.toLowerCase();var b=/(chrome)[ \/]([\w.]+)/.exec(a)||/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||a.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},a=p.uaMatch(g.userAgent),b={},a.browser&&(b[a.browser]=!0,b.version=a.version),b.chrome?b.webkit=!0:b.webkit&&(b.safari=!0),p.browser=b,p.sub=function(){function a(b,c){return new a.fn.init(b,c)}p.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function c(c,d){return d&&d instanceof p&&!(d instanceof a)&&(d=a(d)),p.fn.init.call(this,c,d,b)},a.fn.init.prototype=a.fn;var b=a(e);return a}}();var bH,bI,bJ,bK=/alpha\([^)]*\)/i,bL=/opacity=([^)]*)/,bM=/^(top|right|bottom|left)$/,bN=/^(none|table(?!-c[ea]).+)/,bO=/^margin/,bP=new RegExp("^("+q+")(.*)$","i"),bQ=new RegExp("^("+q+")(?!px)[a-z%]+$","i"),bR=new RegExp("^([-+])=("+q+")","i"),bS={},bT={position:"absolute",visibility:"hidden",display:"block"},bU={letterSpacing:0,fontWeight:400},bV=["Top","Right","Bottom","Left"],bW=["Webkit","O","Moz","ms"],bX=p.fn.toggle;p.fn.extend({css:function(a,c){return p.access(this,function(a,c,d){return d!==b?p.style(a,c,d):p.css(a,c)},a,c,arguments.length>1)},show:function(){return b$(this,!0)},hide:function(){return b$(this)},toggle:function(a,b){var c=typeof a=="boolean";return p.isFunction(a)&&p.isFunction(b)?bX.apply(this,arguments):this.each(function(){(c?a:bZ(this))?p(this).show():p(this).hide()})}}),p.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bH(a,"opacity");return c===""?"1":c}}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":p.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!a||a.nodeType===3||a.nodeType===8||!a.style)return;var f,g,h,i=p.camelCase(c),j=a.style;c=p.cssProps[i]||(p.cssProps[i]=bY(j,i)),h=p.cssHooks[c]||p.cssHooks[i];if(d===b)return h&&"get"in h&&(f=h.get(a,!1,e))!==b?f:j[c];g=typeof d,g==="string"&&(f=bR.exec(d))&&(d=(f[1]+1)*f[2]+parseFloat(p.css(a,c)),g="number");if(d==null||g==="number"&&isNaN(d))return;g==="number"&&!p.cssNumber[i]&&(d+="px");if(!h||!("set"in h)||(d=h.set(a,d,e))!==b)try{j[c]=d}catch(k){}},css:function(a,c,d,e){var f,g,h,i=p.camelCase(c);return c=p.cssProps[i]||(p.cssProps[i]=bY(a.style,i)),h=p.cssHooks[c]||p.cssHooks[i],h&&"get"in h&&(f=h.get(a,!0,e)),f===b&&(f=bH(a,c)),f==="normal"&&c in bU&&(f=bU[c]),d||e!==b?(g=parseFloat(f),d||p.isNumeric(g)?g||0:f):f},swap:function(a,b,c){var d,e,f={};for(e in b)f[e]=a.style[e],a.style[e]=b[e];d=c.call(a);for(e in b)a.style[e]=f[e];return d}}),a.getComputedStyle?bH=function(b,c){var d,e,f,g,h=a.getComputedStyle(b,null),i=b.style;return h&&(d=h[c],d===""&&!p.contains(b.ownerDocument,b)&&(d=p.style(b,c)),bQ.test(d)&&bO.test(c)&&(e=i.width,f=i.minWidth,g=i.maxWidth,i.minWidth=i.maxWidth=i.width=d,d=h.width,i.width=e,i.minWidth=f,i.maxWidth=g)),d}:e.documentElement.currentStyle&&(bH=function(a,b){var c,d,e=a.currentStyle&&a.currentStyle[b],f=a.style;return e==null&&f&&f[b]&&(e=f[b]),bQ.test(e)&&!bM.test(b)&&(c=f.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":e,e=f.pixelLeft+"px",f.left=c,d&&(a.runtimeStyle.left=d)),e===""?"auto":e}),p.each(["height","width"],function(a,b){p.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth===0&&bN.test(bH(a,"display"))?p.swap(a,bT,function(){return cb(a,b,d)}):cb(a,b,d)},set:function(a,c,d){return b_(a,c,d?ca(a,b,d,p.support.boxSizing&&p.css(a,"boxSizing")==="border-box"):0)}}}),p.support.opacity||(p.cssHooks.opacity={get:function(a,b){return bL.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=p.isNumeric(b)?"alpha(opacity="+b*100+")":"",f=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&p.trim(f.replace(bK,""))===""&&c.removeAttribute){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bK.test(f)?f.replace(bK,e):f+" "+e}}),p(function(){p.support.reliableMarginRight||(p.cssHooks.marginRight={get:function(a,b){return p.swap(a,{display:"inline-block"},function(){if(b)return bH(a,"marginRight")})}}),!p.support.pixelPosition&&p.fn.position&&p.each(["top","left"],function(a,b){p.cssHooks[b]={get:function(a,c){if(c){var d=bH(a,b);return bQ.test(d)?p(a).position()[b]+"px":d}}}})}),p.expr&&p.expr.filters&&(p.expr.filters.hidden=function(a){return a.offsetWidth===0&&a.offsetHeight===0||!p.support.reliableHiddenOffsets&&(a.style&&a.style.display||bH(a,"display"))==="none"},p.expr.filters.visible=function(a){return!p.expr.filters.hidden(a)}),p.each({margin:"",padding:"",border:"Width"},function(a,b){p.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bV[d]+b]=e[d]||e[d-2]||e[0];return f}},bO.test(a)||(p.cssHooks[a+b].set=b_)});var cd=/%20/g,ce=/\[\]$/,cf=/\r?\n/g,cg=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,ch=/^(?:select|textarea)/i;p.fn.extend({serialize:function(){return p.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?p.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ch.test(this.nodeName)||cg.test(this.type))}).map(function(a,b){var c=p(this).val();return c==null?null:p.isArray(c)?p.map(c,function(a,c){return{name:b.name,value:a.replace(cf,"\r\n")}}):{name:b.name,value:c.replace(cf,"\r\n")}}).get()}}),p.param=function(a,c){var d,e=[],f=function(a,b){b=p.isFunction(b)?b():b==null?"":b,e[e.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=p.ajaxSettings&&p.ajaxSettings.traditional);if(p.isArray(a)||a.jquery&&!p.isPlainObject(a))p.each(a,function(){f(this.name,this.value)});else for(d in a)ci(d,a[d],c,f);return e.join("&").replace(cd,"+")};var cj,ck,cl=/#.*$/,cm=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,cn=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,co=/^(?:GET|HEAD)$/,cp=/^\/\//,cq=/\?/,cr=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,cs=/([?&])_=[^&]*/,ct=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,cu=p.fn.load,cv={},cw={},cx=["*/"]+["*"];try{ck=f.href}catch(cy){ck=e.createElement("a"),ck.href="",ck=ck.href}cj=ct.exec(ck.toLowerCase())||[],p.fn.load=function(a,c,d){if(typeof a!="string"&&cu)return cu.apply(this,arguments);if(!this.length)return this;var e,f,g,h=this,i=a.indexOf(" ");return i>=0&&(e=a.slice(i,a.length),a=a.slice(0,i)),p.isFunction(c)?(d=c,c=b):c&&typeof c=="object"&&(f="POST"),p.ajax({url:a,type:f,dataType:"html",data:c,complete:function(a,b){d&&h.each(d,g||[a.responseText,b,a])}}).done(function(a){g=arguments,h.html(e?p("<div>").append(a.replace(cr,"")).find(e):a)}),this},p.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){p.fn[b]=function(a){return this.on(b,a)}}),p.each(["get","post"],function(a,c){p[c]=function(a,d,e,f){return p.isFunction(d)&&(f=f||e,e=d,d=b),p.ajax({type:c,url:a,data:d,success:e,dataType:f})}}),p.extend({getScript:function(a,c){return p.get(a,b,c,"script")},getJSON:function(a,b,c){return p.get(a,b,c,"json")},ajaxSetup:function(a,b){return b?cB(a,p.ajaxSettings):(b=a,a=p.ajaxSettings),cB(a,b),a},ajaxSettings:{url:ck,isLocal:cn.test(cj[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":cx},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":p.parseJSON,"text xml":p.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:cz(cv),ajaxTransport:cz(cw),ajax:function(a,c){function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeout(h),g=b,e=i||"",x.readyState=a>0?4:0,f&&(u=cC(l,x,f));if(a>=200&&a<300||a===304)l.ifModified&&(w=x.getResponseHeader("Last-Modified"),w&&(p.lastModified[d]=w),w=x.getResponseHeader("Etag"),w&&(p.etag[d]=w)),a===304?(y="notmodified",k=!0):(k=cD(l,u),y=k.state,s=k.data,t=k.error,k=!t);else{t=y;if(!y||a)y="error",a<0&&(a=0)}x.status=a,x.statusText=(c||y)+"",k?o.resolveWith(m,[s,y,x]):o.rejectWith(m,[x,y,t]),x.statusCode(r),r=b,j&&n.trigger("ajax"+(k?"Success":"Error"),[x,l,k?s:t]),q.fireWith(m,[x,y]),j&&(n.trigger("ajaxComplete",[x,l]),--p.active||p.event.trigger("ajaxStop"))}typeof a=="object"&&(c=a,a=b),c=c||{};var d,e,f,g,h,i,j,k,l=p.ajaxSetup({},c),m=l.context||l,n=m!==l&&(m.nodeType||m instanceof p)?p(m):p.event,o=p.Deferred(),q=p.Callbacks("once memory"),r=l.statusCode||{},t={},u={},v=0,w="canceled",x={readyState:0,setRequestHeader:function(a,b){if(!v){var c=a.toLowerCase();a=u[c]=u[c]||a,t[a]=b}return this},getAllResponseHeaders:function(){return v===2?e:null},getResponseHeader:function(a){var c;if(v===2){if(!f){f={};while(c=cm.exec(e))f[c[1].toLowerCase()]=c[2]}c=f[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){return v||(l.mimeType=a),this},abort:function(a){return a=a||w,g&&g.abort(a),y(0,a),this}};o.promise(x),x.success=x.done,x.error=x.fail,x.complete=q.add,x.statusCode=function(a){if(a){var b;if(v<2)for(b in a)r[b]=[r[b],a[b]];else b=a[x.status],x.always(b)}return this},l.url=((a||l.url)+"").replace(cl,"").replace(cp,cj[1]+"//"),l.dataTypes=p.trim(l.dataType||"*").toLowerCase().split(s),l.crossDomain==null&&(i=ct.exec(l.url.toLowerCase())||!1,l.crossDomain=i&&i.join(":")+(i[3]?"":i[1]==="http:"?80:443)!==cj.join(":")+(cj[3]?"":cj[1]==="http:"?80:443)),l.data&&l.processData&&typeof l.data!="string"&&(l.data=p.param(l.data,l.traditional)),cA(cv,l,c,x);if(v===2)return x;j=l.global,l.type=l.type.toUpperCase(),l.hasContent=!co.test(l.type),j&&p.active++===0&&p.event.trigger("ajaxStart");if(!l.hasContent){l.data&&(l.url+=(cq.test(l.url)?"&":"?")+l.data,delete l.data),d=l.url;if(l.cache===!1){var z=p.now(),A=l.url.replace(cs,"$1_="+z);l.url=A+(A===l.url?(cq.test(l.url)?"&":"?")+"_="+z:"")}}(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&x.setRequestHeader("Content-Type",l.contentType),l.ifModified&&(d=d||l.url,p.lastModified[d]&&x.setRequestHeader("If-Modified-Since",p.lastModified[d]),p.etag[d]&&x.setRequestHeader("If-None-Match",p.etag[d])),x.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+(l.dataTypes[0]!=="*"?", "+cx+"; q=0.01":""):l.accepts["*"]);for(k in l.headers)x.setRequestHeader(k,l.headers[k]);if(!l.beforeSend||l.beforeSend.call(m,x,l)!==!1&&v!==2){w="abort";for(k in{success:1,error:1,complete:1})x[k](l[k]);g=cA(cw,l,c,x);if(!g)y(-1,"No Transport");else{x.readyState=1,j&&n.trigger("ajaxSend",[x,l]),l.async&&l.timeout>0&&(h=setTimeout(function(){x.abort("timeout")},l.timeout));try{v=1,g.send(t,y)}catch(B){if(v<2)y(-1,B);else throw B}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var cE=[],cF=/\?/,cG=/(=)\?(?=&|$)|\?\?/,cH=p.now();p.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=cE.pop()||p.expando+"_"+cH++;return this[a]=!0,a}}),p.ajaxPrefilter("json jsonp",function(c,d,e){var f,g,h,i=c.data,j=c.url,k=c.jsonp!==!1,l=k&&cG.test(j),m=k&&!l&&typeof i=="string"&&!(c.contentType||"").indexOf("application/x-www-form-urlencoded")&&cG.test(i);if(c.dataTypes[0]==="jsonp"||l||m)return f=c.jsonpCallback=p.isFunction(c.jsonpCallback)?c.jsonpCallback():c.jsonpCallback,g=a[f],l?c.url=j.replace(cG,"$1"+f):m?c.data=i.replace(cG,"$1"+f):k&&(c.url+=(cF.test(j)?"&":"?")+c.jsonp+"="+f),c.converters["script json"]=function(){return h||p.error(f+" was not called"),h[0]},c.dataTypes[0]="json",a[f]=function(){h=arguments},e.always(function(){a[f]=g,c[f]&&(c.jsonpCallback=d.jsonpCallback,cE.push(f)),h&&p.isFunction(g)&&g(h[0]),h=g=b}),"script"}),p.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){return p.globalEval(a),a}}}),p.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),p.ajaxTransport("script",function(a){if(a.crossDomain){var c,d=e.head||e.getElementsByTagName("head")[0]||e.documentElement;return{send:function(f,g){c=e.createElement("script"),c.async="async",a.scriptCharset&&(c.charset=a.scriptCharset),c.src=a.url,c.onload=c.onreadystatechange=function(a,e){if(e||!c.readyState||/loaded|complete/.test(c.readyState))c.onload=c.onreadystatechange=null,d&&c.parentNode&&d.removeChild(c),c=b,e||g(200,"success")},d.insertBefore(c,d.firstChild)},abort:function(){c&&c.onload(0,1)}}}});var cI,cJ=a.ActiveXObject?function(){for(var a in cI)cI[a](0,1)}:!1,cK=0;p.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&cL()||cM()}:cL,function(a){p.extend(p.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(p.ajaxSettings.xhr()),p.support.ajax&&p.ajaxTransport(function(c){if(!c.crossDomain||p.support.cors){var d;return{send:function(e,f){var g,h,i=c.xhr();c.username?i.open(c.type,c.url,c.async,c.username,c.password):i.open(c.type,c.url,c.async);if(c.xhrFields)for(h in c.xhrFields)i[h]=c.xhrFields[h];c.mimeType&&i.overrideMimeType&&i.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(h in e)i.setRequestHeader(h,e[h])}catch(j){}i.send(c.hasContent&&c.data||null),d=function(a,e){var h,j,k,l,m;try{if(d&&(e||i.readyState===4)){d=b,g&&(i.onreadystatechange=p.noop,cJ&&delete cI[g]);if(e)i.readyState!==4&&i.abort();else{h=i.status,k=i.getAllResponseHeaders(),l={},m=i.responseXML,m&&m.documentElement&&(l.xml=m);try{l.text=i.responseText}catch(a){}try{j=i.statusText}catch(n){j=""}!h&&c.isLocal&&!c.crossDomain?h=l.text?200:404:h===1223&&(h=204)}}}catch(o){e||f(-1,o)}l&&f(h,j,l,k)},c.async?i.readyState===4?setTimeout(d,0):(g=++cK,cJ&&(cI||(cI={},p(a).unload(cJ)),cI[g]=d),i.onreadystatechange=d):d()},abort:function(){d&&d(0,1)}}}});var cN,cO,cP=/^(?:toggle|show|hide)$/,cQ=new RegExp("^(?:([-+])=|)("+q+")([a-z%]*)$","i"),cR=/queueHooks$/,cS=[cY],cT={"*":[function(a,b){var c,d,e=this.createTween(a,b),f=cQ.exec(b),g=e.cur(),h=+g||0,i=1,j=20;if(f){c=+f[2],d=f[3]||(p.cssNumber[a]?"":"px");if(d!=="px"&&h){h=p.css(e.elem,a,!0)||c||1;do i=i||".5",h=h/i,p.style(e.elem,a,h+d);while(i!==(i=e.cur()/g)&&i!==1&&--j)}e.unit=d,e.start=h,e.end=f[1]?h+(f[1]+1)*c:c}return e}]};p.Animation=p.extend(cW,{tweener:function(a,b){p.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");var c,d=0,e=a.length;for(;d<e;d++)c=a[d],cT[c]=cT[c]||[],cT[c].unshift(b)},prefilter:function(a,b){b?cS.unshift(a):cS.push(a)}}),p.Tween=cZ,cZ.prototype={constructor:cZ,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(p.cssNumber[c]?"":"px")},cur:function(){var a=cZ.propHooks[this.prop];return a&&a.get?a.get(this):cZ.propHooks._default.get(this)},run:function(a){var b,c=cZ.propHooks[this.prop];return this.options.duration?this.pos=b=p.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):cZ.propHooks._default.set(this),this}},cZ.prototype.init.prototype=cZ.prototype,cZ.propHooks={_default:{get:function(a){var b;return a.elem[a.prop]==null||!!a.elem.style&&a.elem.style[a.prop]!=null?(b=p.css(a.elem,a.prop,!1,""),!b||b==="auto"?0:b):a.elem[a.prop]},set:function(a){p.fx.step[a.prop]?p.fx.step[a.prop](a):a.elem.style&&(a.elem.style[p.cssProps[a.prop]]!=null||p.cssHooks[a.prop])?p.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},cZ.propHooks.scrollTop=cZ.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},p.each(["toggle","show","hide"],function(a,b){var c=p.fn[b];p.fn[b]=function(d,e,f){return d==null||typeof d=="boolean"||!a&&p.isFunction(d)&&p.isFunction(e)?c.apply(this,arguments):this.animate(c$(b,!0),d,e,f)}}),p.fn.extend({fadeTo:function(a,b,c,d){return this.filter(bZ).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=p.isEmptyObject(a),f=p.speed(b,c,d),g=function(){var b=cW(this,p.extend({},a),f);e&&b.stop(!0)};return e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,c,d){var e=function(a){var b=a.stop;delete a.stop,b(d)};return typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,c=a!=null&&a+"queueHooks",f=p.timers,g=p._data(this);if(c)g[c]&&g[c].stop&&e(g[c]);else for(c in g)g[c]&&g[c].stop&&cR.test(c)&&e(g[c]);for(c=f.length;c--;)f[c].elem===this&&(a==null||f[c].queue===a)&&(f[c].anim.stop(d),b=!1,f.splice(c,1));(b||!d)&&p.dequeue(this,a)})}}),p.each({slideDown:c$("show"),slideUp:c$("hide"),slideToggle:c$("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){p.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),p.speed=function(a,b,c){var d=a&&typeof a=="object"?p.extend({},a):{complete:c||!c&&b||p.isFunction(a)&&a,duration:a,easing:c&&b||b&&!p.isFunction(b)&&b};d.duration=p.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in p.fx.speeds?p.fx.speeds[d.duration]:p.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";return d.old=d.complete,d.complete=function(){p.isFunction(d.old)&&d.old.call(this),d.queue&&p.dequeue(this,d.queue)},d},p.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},p.timers=[],p.fx=cZ.prototype.init,p.fx.tick=function(){var a,b=p.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||p.fx.stop()},p.fx.timer=function(a){a()&&p.timers.push(a)&&!cO&&(cO=setInterval(p.fx.tick,p.fx.interval))},p.fx.interval=13,p.fx.stop=function(){clearInterval(cO),cO=null},p.fx.speeds={slow:600,fast:200,_default:400},p.fx.step={},p.expr&&p.expr.filters&&(p.expr.filters.animated=function(a){return p.grep(p.timers,function(b){return a===b.elem}).length});var c_=/^(?:body|html)$/i;p.fn.offset=function(a){if(arguments.length)return a===b?this:this.each(function(b){p.offset.setOffset(this,a,b)});var c,d,e,f,g,h,i,j={top:0,left:0},k=this[0],l=k&&k.ownerDocument;if(!l)return;return(d=l.body)===k?p.offset.bodyOffset(k):(c=l.documentElement,p.contains(c,k)?(typeof k.getBoundingClientRect!="undefined"&&(j=k.getBoundingClientRect()),e=da(l),f=c.clientTop||d.clientTop||0,g=c.clientLeft||d.clientLeft||0,h=e.pageYOffset||c.scrollTop,i=e.pageXOffset||c.scrollLeft,{top:j.top+h-f,left:j.left+i-g}):j)},p.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;return p.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(p.css(a,"marginTop"))||0,c+=parseFloat(p.css(a,"marginLeft"))||0),{top:b,left:c}},setOffset:function(a,b,c){var d=p.css(a,"position");d==="static"&&(a.style.position="relative");var e=p(a),f=e.offset(),g=p.css(a,"top"),h=p.css(a,"left"),i=(d==="absolute"||d==="fixed")&&p.inArray("auto",[g,h])>-1,j={},k={},l,m;i?(k=e.position(),l=k.top,m=k.left):(l=parseFloat(g)||0,m=parseFloat(h)||0),p.isFunction(b)&&(b=b.call(a,c,f)),b.top!=null&&(j.top=b.top-f.top+l),b.left!=null&&(j.left=b.left-f.left+m),"using"in b?b.using.call(a,j):e.css(j)}},p.fn.extend({position:function(){if(!this[0])return;var a=this[0],b=this.offsetParent(),c=this.offset(),d=c_.test(b[0].nodeName)?{top:0,left:0}:b.offset();return c.top-=parseFloat(p.css(a,"marginTop"))||0,c.left-=parseFloat(p.css(a,"marginLeft"))||0,d.top+=parseFloat(p.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(p.css(b[0],"borderLeftWidth"))||0,{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||e.body;while(a&&!c_.test(a.nodeName)&&p.css(a,"position")==="static")a=a.offsetParent;return a||e.body})}}),p.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);p.fn[a]=function(e){return p.access(this,function(a,e,f){var g=da(a);if(f===b)return g?c in g?g[c]:g.document.documentElement[e]:a[e];g?g.scrollTo(d?p(g).scrollLeft():f,d?f:p(g).scrollTop()):a[e]=f},a,e,arguments.length,null)}}),p.each({Height:"height",Width:"width"},function(a,c){p.each({padding:"inner"+a,content:c,"":"outer"+a},function(d,e){p.fn[e]=function(e,f){var g=arguments.length&&(d||typeof e!="boolean"),h=d||(e===!0||f===!0?"margin":"border");return p.access(this,function(c,d,e){var f;return p.isWindow(c)?c.document.documentElement["client"+a]:c.nodeType===9?(f=c.documentElement,Math.max(c.body["scroll"+a],f["scroll"+a],c.body["offset"+a],f["offset"+a],f["client"+a])):e===b?p.css(c,d,e,h):p.style(c,d,e,h)},c,g?e:b,g,null)}})}),a.jQuery=a.$=p,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return p})})(window);`,
+
+	"jquery.treeview.css": `/* https://github.com/jzaefferer/jquery-treeview/blob/master/jquery.treeview.css */
+/* License: MIT. */
+.treeview, .treeview ul {
+	padding: 0;
+	margin: 0;
+	list-style: none;
+}
+
+.treeview ul {
+	background-color: white;
+	margin-top: 4px;
+}
+
+.treeview .hitarea {
+	background: url(images/treeview-default.gif) -64px -25px no-repeat;
+	height: 16px;
+	width: 16px;
+	margin-left: -16px;
+	float: left;
+	cursor: pointer;
+}
+/* fix for IE6 */
+* html .hitarea {
+	display: inline;
+	float:none;
+}
+
+.treeview li {
+	margin: 0;
+	padding: 3px 0pt 3px 16px;
+}
+
+.treeview a.selected {
+	background-color: #eee;
+}
+
+#treecontrol { margin: 1em 0; display: none; }
+
+.treeview .hover { color: red; cursor: pointer; }
+
+.treeview li { background: url(images/treeview-default-line.gif) 0 0 no-repeat; }
+.treeview li.collapsable, .treeview li.expandable { background-position: 0 -176px; }
+
+.treeview .expandable-hitarea { background-position: -80px -3px; }
+
+.treeview li.last { background-position: 0 -1766px }
+.treeview li.lastCollapsable, .treeview li.lastExpandable { background-image: url(images/treeview-default.gif); }
+.treeview li.lastCollapsable { background-position: 0 -111px }
+.treeview li.lastExpandable { background-position: -32px -67px }
+
+.treeview div.lastCollapsable-hitarea, .treeview div.lastExpandable-hitarea { background-position: 0; }
+
+.treeview-red li { background-image: url(images/treeview-red-line.gif); }
+.treeview-red .hitarea, .treeview-red li.lastCollapsable, .treeview-red li.lastExpandable { background-image: url(images/treeview-red.gif); }
+
+.treeview-black li { background-image: url(images/treeview-black-line.gif); }
+.treeview-black .hitarea, .treeview-black li.lastCollapsable, .treeview-black li.lastExpandable { background-image: url(images/treeview-black.gif); }
+
+.treeview-gray li { background-image: url(images/treeview-gray-line.gif); }
+.treeview-gray .hitarea, .treeview-gray li.lastCollapsable, .treeview-gray li.lastExpandable { background-image: url(images/treeview-gray.gif); }
+
+.treeview-famfamfam li { background-image: url(images/treeview-famfamfam-line.gif); }
+.treeview-famfamfam .hitarea, .treeview-famfamfam li.lastCollapsable, .treeview-famfamfam li.lastExpandable { background-image: url(images/treeview-famfamfam.gif); }
+
+.treeview .placeholder {
+	background: url(images/ajax-loader.gif) 0 0 no-repeat;
+	height: 16px;
+	width: 16px;
+	display: block;
+}
+
+.filetree li { padding: 3px 0 2px 16px; }
+.filetree span.folder, .filetree span.file { padding: 1px 0 1px 16px; display: block; }
+.filetree span.folder { background: url(images/folder.gif) 0 0 no-repeat; }
+.filetree li.expandable span.folder { background: url(images/folder-closed.gif) 0 0 no-repeat; }
+.filetree span.file { background: url(images/file.gif) 0 0 no-repeat; }
+`,
+
+	"jquery.treeview.edit.js": `/* https://github.com/jzaefferer/jquery-treeview/blob/master/jquery.treeview.edit.js */
+/* License: MIT. */
+(function($) {
+	var CLASSES = $.treeview.classes;
+	var proxied = $.fn.treeview;
+	$.fn.treeview = function(settings) {
+		settings = $.extend({}, settings);
+		if (settings.add) {
+			return this.trigger("add", [settings.add]);
+		}
+		if (settings.remove) {
+			return this.trigger("remove", [settings.remove]);
+		}
+		return proxied.apply(this, arguments).bind("add", function(event, branches) {
+			$(branches).prev()
+				.removeClass(CLASSES.last)
+				.removeClass(CLASSES.lastCollapsable)
+				.removeClass(CLASSES.lastExpandable)
+			.find(">.hitarea")
+				.removeClass(CLASSES.lastCollapsableHitarea)
+				.removeClass(CLASSES.lastExpandableHitarea);
+			$(branches).find("li").andSelf().prepareBranches(settings).applyClasses(settings, $(this).data("toggler"));
+		}).bind("remove", function(event, branches) {
+			var prev = $(branches).prev();
+			var parent = $(branches).parent();
+			$(branches).remove();
+			prev.filter(":last-child").addClass(CLASSES.last)
+				.filter("." + CLASSES.expandable).replaceClass(CLASSES.last, CLASSES.lastExpandable).end()
+				.find(">.hitarea").replaceClass(CLASSES.expandableHitarea, CLASSES.lastExpandableHitarea).end()
+				.filter("." + CLASSES.collapsable).replaceClass(CLASSES.last, CLASSES.lastCollapsable).end()
+				.find(">.hitarea").replaceClass(CLASSES.collapsableHitarea, CLASSES.lastCollapsableHitarea);
+			if (parent.is(":not(:has(>))") && parent[0] != this) {
+				parent.parent().removeClass(CLASSES.collapsable).removeClass(CLASSES.expandable)
+				parent.siblings(".hitarea").andSelf().remove();
+			}
+		});
+	};
+	
+})(jQuery);
+`,
+
+	"jquery.treeview.js": `/*
+ * Treeview 1.4.1 - jQuery plugin to hide and show branches of a tree
+ * 
+ * http://bassistance.de/jquery-plugins/jquery-plugin-treeview/
+ * http://docs.jquery.com/Plugins/Treeview
+ *
+ * Copyright (c) 2007 Jörn Zaefferer
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Revision: $Id: jquery.treeview.js 5759 2008-07-01 07:50:28Z joern.zaefferer $
+ *
+ */
+
+;(function($) {
+
+	// TODO rewrite as a widget, removing all the extra plugins
+	$.extend($.fn, {
+		swapClass: function(c1, c2) {
+			var c1Elements = this.filter('.' + c1);
+			this.filter('.' + c2).removeClass(c2).addClass(c1);
+			c1Elements.removeClass(c1).addClass(c2);
+			return this;
+		},
+		replaceClass: function(c1, c2) {
+			return this.filter('.' + c1).removeClass(c1).addClass(c2).end();
+		},
+		hoverClass: function(className) {
+			className = className || "hover";
+			return this.hover(function() {
+				$(this).addClass(className);
+			}, function() {
+				$(this).removeClass(className);
+			});
+		},
+		heightToggle: function(animated, callback) {
+			animated ?
+				this.animate({ height: "toggle" }, animated, callback) :
+				this.each(function(){
+					jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
+					if(callback)
+						callback.apply(this, arguments);
+				});
+		},
+		heightHide: function(animated, callback) {
+			if (animated) {
+				this.animate({ height: "hide" }, animated, callback);
+			} else {
+				this.hide();
+				if (callback)
+					this.each(callback);				
+			}
+		},
+		prepareBranches: function(settings) {
+			if (!settings.prerendered) {
+				// mark last tree items
+				this.filter(":last-child:not(ul)").addClass(CLASSES.last);
+				// collapse whole tree, or only those marked as closed, anyway except those marked as open
+				this.filter((settings.collapsed ? "" : "." + CLASSES.closed) + ":not(." + CLASSES.open + ")").find(">ul").hide();
+			}
+			// return all items with sublists
+			return this.filter(":has(>ul)");
+		},
+		applyClasses: function(settings, toggler) {
+			// TODO use event delegation
+			this.filter(":has(>ul):not(:has(>a))").find(">span").unbind("click.treeview").bind("click.treeview", function(event) {
+				// don't handle click events on children, eg. checkboxes
+				if ( this == event.target )
+					toggler.apply($(this).next());
+			}).add( $("a", this) ).hoverClass();
+			
+			if (!settings.prerendered) {
+				// handle closed ones first
+				this.filter(":has(>ul:hidden)")
+						.addClass(CLASSES.expandable)
+						.replaceClass(CLASSES.last, CLASSES.lastExpandable);
+						
+				// handle open ones
+				this.not(":has(>ul:hidden)")
+						.addClass(CLASSES.collapsable)
+						.replaceClass(CLASSES.last, CLASSES.lastCollapsable);
+						
+	            // create hitarea if not present
+				var hitarea = this.find("div." + CLASSES.hitarea);
+				if (!hitarea.length)
+					hitarea = this.prepend("<div class=\"" + CLASSES.hitarea + "\"/>").find("div." + CLASSES.hitarea);
+				hitarea.removeClass().addClass(CLASSES.hitarea).each(function() {
+					var classes = "";
+					$.each($(this).parent().attr("class").split(" "), function() {
+						classes += this + "-hitarea ";
+					});
+					$(this).addClass( classes );
+				})
+			}
+			
+			// apply event to hitarea
+			this.find("div." + CLASSES.hitarea).click( toggler );
+		},
+		treeview: function(settings) {
+			
+			settings = $.extend({
+				cookieId: "treeview"
+			}, settings);
+			
+			if ( settings.toggle ) {
+				var callback = settings.toggle;
+				settings.toggle = function() {
+					return callback.apply($(this).parent()[0], arguments);
+				};
+			}
+		
+			// factory for treecontroller
+			function treeController(tree, control) {
+				// factory for click handlers
+				function handler(filter) {
+					return function() {
+						// reuse toggle event handler, applying the elements to toggle
+						// start searching for all hitareas
+						toggler.apply( $("div." + CLASSES.hitarea, tree).filter(function() {
+							// for plain toggle, no filter is provided, otherwise we need to check the parent element
+							return filter ? $(this).parent("." + filter).length : true;
+						}) );
+						return false;
+					};
+				}
+				// click on first element to collapse tree
+				$("a:eq(0)", control).click( handler(CLASSES.collapsable) );
+				// click on second to expand tree
+				$("a:eq(1)", control).click( handler(CLASSES.expandable) );
+				// click on third to toggle tree
+				$("a:eq(2)", control).click( handler() ); 
+			}
+		
+			// handle toggle event
+			function toggler() {
+				$(this)
+					.parent()
+					// swap classes for hitarea
+					.find(">.hitarea")
+						.swapClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+						.swapClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea )
+					.end()
+					// swap classes for parent li
+					.swapClass( CLASSES.collapsable, CLASSES.expandable )
+					.swapClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+					// find child lists
+					.find( ">ul" )
+					// toggle them
+					.heightToggle( settings.animated, settings.toggle );
+				if ( settings.unique ) {
+					$(this).parent()
+						.siblings()
+						// swap classes for hitarea
+						.find(">.hitarea")
+							.replaceClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+							.replaceClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea )
+						.end()
+						.replaceClass( CLASSES.collapsable, CLASSES.expandable )
+						.replaceClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+						.find( ">ul" )
+						.heightHide( settings.animated, settings.toggle );
+				}
+			}
+			this.data("toggler", toggler);
+			
+			function serialize() {
+				function binary(arg) {
+					return arg ? 1 : 0;
+				}
+				var data = [];
+				branches.each(function(i, e) {
+					data[i] = $(e).is(":has(>ul:visible)") ? 1 : 0;
+				});
+				$.cookie(settings.cookieId, data.join(""), settings.cookieOptions );
+			}
+			
+			function deserialize() {
+				var stored = $.cookie(settings.cookieId);
+				if ( stored ) {
+					var data = stored.split("");
+					branches.each(function(i, e) {
+						$(e).find(">ul")[ parseInt(data[i]) ? "show" : "hide" ]();
+					});
+				}
+			}
+			
+			// add treeview class to activate styles
+			this.addClass("treeview");
+			
+			// prepare branches and find all tree items with child lists
+			var branches = this.find("li").prepareBranches(settings);
+			
+			switch(settings.persist) {
+			case "cookie":
+				var toggleCallback = settings.toggle;
+				settings.toggle = function() {
+					serialize();
+					if (toggleCallback) {
+						toggleCallback.apply(this, arguments);
+					}
+				};
+				deserialize();
+				break;
+			case "location":
+				var current = this.find("a").filter(function() {
+					return this.href.toLowerCase() == location.href.toLowerCase();
+				});
+				if ( current.length ) {
+					// TODO update the open/closed classes
+					var items = current.addClass("selected").parents("ul, li").add( current.next() ).show();
+					if (settings.prerendered) {
+						// if prerendered is on, replicate the basic class swapping
+						items.filter("li")
+							.swapClass( CLASSES.collapsable, CLASSES.expandable )
+							.swapClass( CLASSES.lastCollapsable, CLASSES.lastExpandable )
+							.find(">.hitarea")
+								.swapClass( CLASSES.collapsableHitarea, CLASSES.expandableHitarea )
+								.swapClass( CLASSES.lastCollapsableHitarea, CLASSES.lastExpandableHitarea );
+					}
+				}
+				break;
+			}
+			
+			branches.applyClasses(settings, toggler);
+				
+			// if control option is set, create the treecontroller and show it
+			if ( settings.control ) {
+				treeController(this, settings.control);
+				$(settings.control).show();
+			}
+			
+			return this;
+		}
+	});
+	
+	// classes used by the plugin
+	// need to be styled via external stylesheet, see first example
+	$.treeview = {};
+	var CLASSES = ($.treeview.classes = {
+		open: "open",
+		closed: "closed",
+		expandable: "expandable",
+		expandableHitarea: "expandable-hitarea",
+		lastExpandableHitarea: "lastExpandable-hitarea",
+		collapsable: "collapsable",
+		collapsableHitarea: "collapsable-hitarea",
+		lastCollapsableHitarea: "lastCollapsable-hitarea",
+		lastCollapsable: "lastCollapsable",
+		lastExpandable: "lastExpandable",
+		last: "last",
+		hitarea: "hitarea"
+	});
+	
+})(jQuery);
+`,
+
+	"methodset.html": `<div class="toggle" style="display: none">
+	<div class="collapsed">
+		<p class="exampleHeading toggleButton">▹ <span class="text">Method set</span></p>
+	</div>
+	<div class="expanded">
+		<p class="exampleHeading toggleButton">▾ <span class="text">Method set</span></p>
+		<div style="margin-left: 1in" id='methodset-{{.Index}}'>...</div>
+	</div>
+</div>
+`,
+
+	"opensearch.xml": `<?xml version="1.0" encoding="UTF-8"?>
+<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
+  <ShortName>godoc</ShortName>
+  <Description>The Go Programming Language</Description>
+  <Tags>go golang</Tags>
+  <Contact />
+  <Url type="text/html" template="{{.BaseURL}}/search?q={searchTerms}" />
+  <Image height="15" width="16" type="image/x-icon">/favicon.ico</Image>
+  <OutputEncoding>UTF-8</OutputEncoding>
+  <InputEncoding>UTF-8</InputEncoding>
+</OpenSearchDescription>
+`,
+
+	"package.html": `<!--
+	Copyright 2009 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.
+-->
+<!--
+	Note: Static (i.e., not template-generated) href and id
+	attributes start with "pkg-" to make it impossible for
+	them to conflict with generated attributes (some of which
+	correspond to Go identifiers).
+-->
+{{with .PDoc}}
+	<script type='text/javascript'>
+	document.ANALYSIS_DATA = {{$.AnalysisData}};
+	document.CALLGRAPH = {{$.CallGraph}};
+	</script>
+
+	{{if $.IsMain}}
+		{{/* command documentation */}}
+		{{comment_html .Doc}}
+	{{else}}
+		{{/* package documentation */}}
+		<div id="short-nav">
+			<dl>
+			<dd><code>import "{{html .ImportPath}}"</code></dd>
+			</dl>
+			<dl>
+			<dd><a href="#pkg-overview" class="overviewLink">Overview</a></dd>
+			<dd><a href="#pkg-index" class="indexLink">Index</a></dd>
+			{{if $.Examples}}
+				<dd><a href="#pkg-examples" class="examplesLink">Examples</a></dd>
+			{{end}}
+			{{if $.Dirs}}
+				<dd><a href="#pkg-subdirectories">Subdirectories</a></dd>
+			{{end}}
+			</dl>
+		</div>
+		<!-- The package's Name is printed as title by the top-level template -->
+		<div id="pkg-overview" class="toggleVisible">
+			<div class="collapsed">
+				<h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
+			</div>
+			<div class="expanded">
+				<h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
+				{{comment_html .Doc}}
+			</div>
+		</div>
+		{{example_html $ ""}}
+
+		<div id="pkg-index" class="toggleVisible">
+		<div class="collapsed">
+			<h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
+		</div>
+		<div class="expanded">
+			<h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>
+
+		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
+			<div id="manual-nav">
+			<dl>
+			{{if .Consts}}
+				<dd><a href="#pkg-constants">Constants</a></dd>
+			{{end}}
+			{{if .Vars}}
+				<dd><a href="#pkg-variables">Variables</a></dd>
+			{{end}}
+			{{range .Funcs}}
+				{{$name_html := html .Name}}
+				<dd><a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+			{{end}}
+			{{range .Types}}
+				{{$tname_html := html .Name}}
+				<dd><a href="#{{$tname_html}}">type {{$tname_html}}</a></dd>
+				{{range .Funcs}}
+					{{$name_html := html .Name}}
+					<dd>&nbsp; &nbsp; <a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+				{{end}}
+				{{range .Methods}}
+					{{$name_html := html .Name}}
+					<dd>&nbsp; &nbsp; <a href="#{{$tname_html}}.{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+				{{end}}
+			{{end}}
+			{{if $.Notes}}
+				{{range $marker, $item := $.Notes}}
+				<dd><a href="#pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</a></dd>
+				{{end}}
+			{{end}}
+			</dl>
+			</div><!-- #manual-nav -->
+
+		{{if $.Examples}}
+		<div id="pkg-examples">
+			<h3>Examples</h3>
+			<dl>
+			{{range $.Examples}}
+			<dd><a class="exampleLink" href="#example_{{.Name}}">{{example_name .Name}}</a></dd>
+			{{end}}
+			</dl>
+		</div>
+		{{end}}
+
+		{{with .Filenames}}
+			<h3>Package files</h3>
+			<p>
+			<span style="font-size:90%">
+			{{range .}}
+				<a href="{{.|srcLink|html}}">{{.|filename|html}}</a>
+			{{end}}
+			</span>
+			</p>
+		{{end}}
+		</div><!-- .expanded -->
+		</div><!-- #pkg-index -->
+
+		<div id="pkg-callgraph" class="toggle" style="display: none">
+		<div class="collapsed">
+			<h2 class="toggleButton" title="Click to show Internal Call Graph section">Internal call graph ▹</h2>
+		</div> <!-- .expanded -->
+		<div class="expanded">
+			<h2 class="toggleButton" title="Click to hide Internal Call Graph section">Internal call graph ▾</h2>
+			<p>
+			  In the call graph viewer below, each node
+			  is a function belonging to this package
+			  and its children are the functions it
+			  calls&mdash;perhaps dynamically.
+			</p>
+			<p>
+			  The root nodes are the entry points of the
+			  package: functions that may be called from
+			  outside the package.
+			  There may be non-exported or anonymous
+			  functions among them if they are called
+			  dynamically from another package.
+			</p>
+			<p>
+			  Click a node to visit that function's source code.
+			  From there you can visit its callers by
+			  clicking its declaring <code>func</code>
+			  token.
+			</p>
+			<p>
+			  Functions may be omitted if they were
+			  determined to be unreachable in the
+			  particular programs or tests that were
+			  analyzed.
+			</p>
+			<!-- Zero means show all package entry points. -->
+			<ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
+		</div>
+		</div> <!-- #pkg-callgraph -->
+
+		{{with .Consts}}
+			<h2 id="pkg-constants">Constants</h2>
+			{{range .}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+		{{end}}
+		{{with .Vars}}
+			<h2 id="pkg-variables">Variables</h2>
+			{{range .}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+		{{end}}
+		{{range .Funcs}}
+			{{/* Name is a string - no need for FSet */}}
+			{{$name_html := html .Name}}
+			<h2 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+				<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
+			</h2>
+			<pre>{{node_html $ .Decl true}}</pre>
+			{{comment_html .Doc}}
+			{{example_html $ .Name}}
+			{{callgraph_html $ "" .Name}}
+
+		{{end}}
+		{{range .Types}}
+			{{$tname := .Name}}
+			{{$tname_html := html .Name}}
+			<h2 id="{{$tname_html}}">type <a href="{{posLink_url $ .Decl}}">{{$tname_html}}</a>
+				<a class="permalink" href="#{{$tname_html}}">&#xb6;</a>
+			</h2>
+			{{comment_html .Doc}}
+			<pre>{{node_html $ .Decl true}}</pre>
+
+			{{range .Consts}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+
+			{{range .Vars}}
+				{{comment_html .Doc}}
+				<pre>{{node_html $ .Decl true}}</pre>
+			{{end}}
+
+			{{example_html $ $tname}}
+			{{implements_html $ $tname}}
+			{{methodset_html $ $tname}}
+
+			{{range .Funcs}}
+				{{$name_html := html .Name}}
+				<h3 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+					<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
+				</h3>
+				<pre>{{node_html $ .Decl true}}</pre>
+				{{comment_html .Doc}}
+				{{example_html $ .Name}}
+				{{callgraph_html $ "" .Name}}
+			{{end}}
+
+			{{range .Methods}}
+				{{$name_html := html .Name}}
+				<h3 id="{{$tname_html}}.{{$name_html}}">func ({{html .Recv}}) <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+					<a class="permalink" href="#{{$tname_html}}.{{$name_html}}">&#xb6;</a>
+				</h3>
+				<pre>{{node_html $ .Decl true}}</pre>
+				{{comment_html .Doc}}
+				{{$name := printf "%s_%s" $tname .Name}}
+				{{example_html $ $name}}
+				{{callgraph_html $ .Recv .Name}}
+			{{end}}
+		{{end}}
+	{{end}}
+
+	{{with $.Notes}}
+		{{range $marker, $content := .}}
+			<h2 id="pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</h2>
+			<ul style="list-style: none; padding: 0;">
+			{{range .}}
+			<li><a href="{{posLink_url $ .}}" style="float: left;">&#x261e;</a> {{comment_html .Body}}</li>
+			{{end}}
+			</ul>
+		{{end}}
+	{{end}}
+{{end}}
+
+{{with .PAst}}
+	{{range $filename, $ast := .}}
+		<a href="{{$filename|srcLink|html}}">{{$filename|filename|html}}</a>:<pre>{{node_html $ $ast false}}</pre>
+	{{end}}
+{{end}}
+
+{{with .Dirs}}
+	{{/* DirList entries are numbers and strings - no need for FSet */}}
+	{{if $.PDoc}}
+		<h2 id="pkg-subdirectories">Subdirectories</h2>
+	{{end}}
+	{{if eq $.Dirname "/src"}}
+		<div id="manual-nav">
+			<dl>
+				<dt><a href="#stdlib">Standard library</a></dt>
+				<dt><a href="#other">Other packages</a></dt>
+				<dd><a href="#subrepo">Sub-repositories</a></dd>
+				<dd><a href="#community">Community</a></dd>
+			</dl>
+		</div>
+		<h2 id="stdlib">Standard library</h2>
+		<img alt="" class="gopher" src="/doc/gopher/pkg.png"/>
+	{{end}}
+
+
+	<div class="pkg-dir">
+		<table>
+			<tr>
+				<th class="pkg-name">Name</th>
+				<th class="pkg-synopsis">Synopsis</th>
+			</tr>
+
+			{{if not (or (eq $.Dirname "/src") (eq $.Dirname "/src/cmd") $.DirFlat)}}
+			<tr>
+				<td colspan="2"><a href="..">..</a></td>
+			</tr>
+			{{end}}
+
+			{{range .List}}
+				{{if $.DirFlat}}
+					{{if .HasPkg}}
+						<tr>
+							<td class="pkg-name">
+								<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Path}}</a>
+							</td>
+							<td class="pkg-synopsis">
+								{{html .Synopsis}}
+							</td>
+						</tr>
+					{{end}}
+				{{else}}
+					<tr>
+						<td class="pkg-name" style="padding-left: {{multiply .Depth 20}}px;">
+							<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
+						</td>
+						<td class="pkg-synopsis">
+							{{html .Synopsis}}
+						</td>
+					</tr>
+				{{end}}
+			{{end}}
+		</table>
+	</div>
+
+
+	{{if eq $.Dirname "/src"}}
+	<h2 id="other">Other packages</h2>
+
+	<h3 id="subrepo">Sub-repositories</h3>
+	<p>
+	These packages are part of the Go Project but outside the main Go tree.
+	They are developed under looser <a href="/doc/go1compat">compatibility requirements</a> than the Go core.
+	Install them with "<a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies">go get</a>".
+	</p>
+	<ul>
+		<li><a href="//godoc.org/golang.org/x/benchmarks">benchmarks</a> — benchmarks to measure Go as it is developed.</li>
+		<li><a href="//godoc.org/golang.org/x/blog">blog</a> — <a href="//blog.golang.org">blog.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/build">build</a> — <a href="//build.golang.org">build.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/crypto">crypto</a> — additional cryptography packages.</li>
+		<li><a href="//godoc.org/golang.org/x/debug">debug</a> — an experimental debugger for Go.</li>
+		<li><a href="//godoc.org/golang.org/x/image">image</a> — additional imaging packages.</li>
+		<li><a href="//godoc.org/golang.org/x/mobile">mobile</a> — experimental support for Go on mobile platforms.</li>
+		<li><a href="//godoc.org/golang.org/x/net">net</a> — additional networking packages.</li>
+		<li><a href="//godoc.org/golang.org/x/sys">sys</a> — packages for making system calls.</li>
+		<li><a href="//godoc.org/golang.org/x/text">text</a> — packages for working with text.</li>
+		<li><a href="//godoc.org/golang.org/x/tools">tools</a> — godoc, goimports, gorename, and other tools.</li>
+		<li><a href="//godoc.org/golang.org/x/tour">tour</a> — <a href="//tour.golang.org">tour.golang.org</a>'s implementation.</li>
+		<li><a href="//godoc.org/golang.org/x/exp">exp</a> — experimental and deprecated packages (handle with care; may change without warning).</li>
+	</ul>
+
+	<h3 id="community">Community</h3>
+	<p>
+	These services can help you find Open Source packages provided by the community.
+	</p>
+	<ul>
+		<li><a href="//godoc.org">GoDoc</a> - a package index and search engine.</li>
+		<li><a href="http://go-search.org">Go Search</a> - a code search engine.</li>
+		<li><a href="/wiki/Projects">Projects at the Go Wiki</a> - a curated list of Go projects.</li>
+	</ul>
+	{{end}}
+{{end}}
+`,
+
+	"package.txt": `{{$info := .}}{{$filtered := .IsFiltered}}{{/*
+
+---------------------------------------
+
+*/}}{{if $filtered}}{{range .PAst}}{{range .Decls}}{{node $info .}}
+
+{{end}}{{end}}{{else}}{{with .PAst}}{{range $filename, $ast := .}}{{$filename}}:
+{{node $ $ast}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if and $filtered (not (or .PDoc .PAst))}}No match found.
+{{end}}{{with .PDoc}}{{if $.IsMain}}COMMAND DOCUMENTATION
+
+{{comment_text .Doc "    " "\t"}}
+{{else}}{{if not $filtered}}PACKAGE DOCUMENTATION
+
+package {{.Name}}
+    import "{{.ImportPath}}"
+
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ "" "    "}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Consts}}{{if not $filtered}}CONSTANTS
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Vars}}{{if not $filtered}}VARIABLES
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Funcs}}{{if not $filtered}}FUNCTIONS
+
+{{end}}{{range .}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ .Name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Types}}{{if not $filtered}}TYPES
+
+{{end}}{{range .}}{{$tname := .Name}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{/*
+
+---------------------------------------
+
+*/}}{{if .Consts}}{{range .Consts}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Vars}}{{range .Vars}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{range $name := .Names}}{{example_text $ $name "    "}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Funcs}}{{range .Funcs}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{example_text $ .Name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Methods}}{{range .Methods}}{{node $ .Decl}}
+{{comment_text .Doc "    " "\t"}}
+{{$name := printf "%s_%s" $tname .Name}}{{example_text $ $name "    "}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if and $filtered (not (or .Consts (or .Vars (or .Funcs .Types))))}}No match found.
+{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{with $.Notes}}
+{{range $marker, $content := .}}
+{{$marker}}S
+
+{{range $content}}{{comment_text .Body "   " "\t"}}
+{{end}}{{end}}{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{if not $filtered}}{{with .Dirs}}SUBDIRECTORIES
+{{if $.DirFlat}}{{range .List}}{{if .HasPkg}}
+	{{.Path}}{{end}}{{end}}
+{{else}}{{range .List}}
+	{{repeat ` + "`" + `. ` + "`" + ` .Depth}}{{.Name}}{{end}}
+{{end}}{{end}}{{/*
+
+---------------------------------------
+
+*/}}{{end}}{{/*
+Make sure there is no newline at the end of this file.
+perl -i -pe 'chomp if eof' package.txt
+*/}}
+`,
+
+	"play.js": `// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+function initPlayground(transport) {
+	'use strict';
+
+	function text(node) {
+		var s = '';
+		for (var i = 0; i < node.childNodes.length; i++) {
+			var n = node.childNodes[i];
+			if (n.nodeType === 1) {
+				if (n.tagName === 'BUTTON') continue
+				if (n.tagName === 'SPAN' && n.className === 'number') continue;
+				if (n.tagName === 'DIV' || n.tagName == 'BR') {
+					s += "\n";
+				}
+				s += text(n);
+				continue;
+			}
+			if (n.nodeType === 3) {
+				s += n.nodeValue;
+			}
+		}
+		return s.replace('\xA0', ' '); // replace non-breaking spaces
+	}
+
+	// When presenter notes are enabled, the index passed
+	// here will identify the playground to be synced
+	function init(code, index) {
+		var output = document.createElement('div');
+		var outpre = document.createElement('pre');
+		var running;
+
+		if ($ && $(output).resizable) {
+			$(output).resizable({
+				handles: 	'n,w,nw',
+				minHeight:	27,
+				minWidth:	135,
+				maxHeight:	608,
+				maxWidth:	990
+			});
+		}
+
+		function onKill() {
+			if (running) running.Kill();
+			if (window.notesEnabled) updatePlayStorage('onKill', index);
+		}
+
+		function onRun(e) {
+			var sk = e.shiftKey || localStorage.getItem('play-shiftKey') === 'true';
+			if (running) running.Kill();
+			output.style.display = 'block';
+			outpre.innerHTML = '';
+			run1.style.display = 'none';
+			var options = {Race: sk};
+			running = transport.Run(text(code), PlaygroundOutput(outpre), options);
+			if (window.notesEnabled) updatePlayStorage('onRun', index, e);
+		}
+
+		function onClose() {
+			if (running) running.Kill();
+			output.style.display = 'none';
+			run1.style.display = 'inline-block';
+			if (window.notesEnabled) updatePlayStorage('onClose', index);
+		}
+
+		if (window.notesEnabled) {
+			playgroundHandlers.onRun.push(onRun);
+			playgroundHandlers.onClose.push(onClose);
+			playgroundHandlers.onKill.push(onKill);
+		}
+
+		var run1 = document.createElement('button');
+		run1.innerHTML = 'Run';
+		run1.className = 'run';
+		run1.addEventListener("click", onRun, false);
+		var run2 = document.createElement('button');
+		run2.className = 'run';
+		run2.innerHTML = 'Run';
+		run2.addEventListener("click", onRun, false);
+		var kill = document.createElement('button');
+		kill.className = 'kill';
+		kill.innerHTML = 'Kill';
+		kill.addEventListener("click", onKill, false);
+		var close = document.createElement('button');
+		close.className = 'close';
+		close.innerHTML = 'Close';
+		close.addEventListener("click", onClose, false);
+
+		var button = document.createElement('div');
+		button.classList.add('buttons');
+		button.appendChild(run1);
+		// Hack to simulate insertAfter
+		code.parentNode.insertBefore(button, code.nextSibling);
+
+		var buttons = document.createElement('div');
+		buttons.classList.add('buttons');
+		buttons.appendChild(run2);
+		buttons.appendChild(kill);
+		buttons.appendChild(close);
+
+		output.classList.add('output');
+		output.appendChild(buttons);
+		output.appendChild(outpre);
+		output.style.display = 'none';
+		code.parentNode.insertBefore(output, button.nextSibling);
+	}
+
+	var play = document.querySelectorAll('div.playground');
+	for (var i = 0; i < play.length; i++) {
+		init(play[i], i);
+	}
+}
+`,
+
+	"playground.js": `// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+In the absence of any formal way to specify interfaces in JavaScript,
+here's a skeleton implementation of a playground transport.
+
+        function Transport() {
+                // Set up any transport state (eg, make a websocket connection).
+                return {
+                        Run: function(body, output, options) {
+                                // Compile and run the program 'body' with 'options'.
+				// Call the 'output' callback to display program output.
+                                return {
+                                        Kill: function() {
+                                                // Kill the running program.
+                                        }
+                                };
+                        }
+                };
+        }
+
+	// The output callback is called multiple times, and each time it is
+	// passed an object of this form.
+        var write = {
+                Kind: 'string', // 'start', 'stdout', 'stderr', 'end'
+                Body: 'string'  // content of write or end status message
+        }
+
+	// The first call must be of Kind 'start' with no body.
+	// Subsequent calls may be of Kind 'stdout' or 'stderr'
+	// and must have a non-null Body string.
+	// The final call should be of Kind 'end' with an optional
+	// Body string, signifying a failure ("killed", for example).
+
+	// The output callback must be of this form.
+	// See PlaygroundOutput (below) for an implementation.
+        function outputCallback(write) {
+        }
+*/
+
+function HTTPTransport() {
+	'use strict';
+
+	// TODO(adg): support stderr
+
+	function playback(output, events) {
+		var timeout;
+		output({Kind: 'start'});
+		function next() {
+			if (!events || events.length === 0) {
+				output({Kind: 'end'});
+				return;
+			}
+			var e = events.shift();
+			if (e.Delay === 0) {
+				output({Kind: 'stdout', Body: e.Message});
+				next();
+				return;
+			}
+			timeout = setTimeout(function() {
+				output({Kind: 'stdout', Body: e.Message});
+				next();
+			}, e.Delay / 1000000);
+		}
+		next();
+		return {
+			Stop: function() {
+				clearTimeout(timeout);
+			}
+		}
+	}
+
+	function error(output, msg) {
+		output({Kind: 'start'});
+		output({Kind: 'stderr', Body: msg});
+		output({Kind: 'end'});
+	}
+
+	var seq = 0;
+	return {
+		Run: function(body, output, options) {
+			seq++;
+			var cur = seq;
+			var playing;
+			$.ajax('/compile', {
+				type: 'POST',
+				data: {'version': 2, 'body': body},
+				dataType: 'json',
+				success: function(data) {
+					if (seq != cur) return;
+					if (!data) return;
+					if (playing != null) playing.Stop();
+					if (data.Errors) {
+						error(output, data.Errors);
+						return;
+					}
+					playing = playback(output, data.Events);
+				},
+				error: function() {
+					error(output, 'Error communicating with remote server.');
+				}
+			});
+			return {
+				Kill: function() {
+					if (playing != null) playing.Stop();
+					output({Kind: 'end', Body: 'killed'});
+				}
+			};
+		}
+	};
+}
+
+function SocketTransport() {
+	'use strict';
+
+	var id = 0;
+	var outputs = {};
+	var started = {};
+	var websocket;
+	if (window.location.protocol == "http:") {
+		websocket = new WebSocket('ws://' + window.location.host + '/socket');
+	} else if (window.location.protocol == "https:") {
+		websocket = new WebSocket('wss://' + window.location.host + '/socket');
+	}
+
+	websocket.onclose = function() {
+		console.log('websocket connection closed');
+	}
+
+	websocket.onmessage = function(e) {
+		var m = JSON.parse(e.data);
+		var output = outputs[m.Id];
+		if (output === null)
+			return;
+		if (!started[m.Id]) {
+			output({Kind: 'start'});
+			started[m.Id] = true;
+		}
+		output({Kind: m.Kind, Body: m.Body});
+	}
+
+	function send(m) {
+		websocket.send(JSON.stringify(m));
+	}
+
+	return {
+		Run: function(body, output, options) {
+			var thisID = id+'';
+			id++;
+			outputs[thisID] = output;
+			send({Id: thisID, Kind: 'run', Body: body, Options: options});
+			return {
+				Kill: function() {
+					send({Id: thisID, Kind: 'kill'});
+				}
+			};
+		}
+	};
+}
+
+function PlaygroundOutput(el) {
+	'use strict';
+
+	return function(write) {
+		if (write.Kind == 'start') {
+			el.innerHTML = '';
+			return;
+		}
+
+		var cl = 'system';
+		if (write.Kind == 'stdout' || write.Kind == 'stderr')
+			cl = write.Kind;
+
+		var m = write.Body;
+		if (write.Kind == 'end') {
+			m = '\nProgram exited' + (m?(': '+m):'.');
+		}
+
+		if (m.indexOf('IMAGE:') === 0) {
+			// TODO(adg): buffer all writes before creating image
+			var url = 'data:image/png;base64,' + m.substr(6);
+			var img = document.createElement('img');
+			img.src = url;
+			el.appendChild(img);
+			return;
+		}
+
+		// ^L clears the screen.
+		var s = m.split('\x0c');
+		if (s.length > 1) {
+			el.innerHTML = '';
+			m = s.pop();
+		}
+
+		m = m.replace(/&/g, '&amp;');
+		m = m.replace(/</g, '&lt;');
+		m = m.replace(/>/g, '&gt;');
+
+		var needScroll = (el.scrollTop + el.offsetHeight) == el.scrollHeight;
+
+		var span = document.createElement('span');
+		span.className = cl;
+		span.innerHTML = m;
+		el.appendChild(span);
+
+		if (needScroll)
+			el.scrollTop = el.scrollHeight - el.offsetHeight;
+	}
+}
+
+(function() {
+  function lineHighlight(error) {
+    var regex = /prog.go:([0-9]+)/g;
+    var r = regex.exec(error);
+    while (r) {
+      $(".lines div").eq(r[1]-1).addClass("lineerror");
+      r = regex.exec(error);
+    }
+  }
+  function highlightOutput(wrappedOutput) {
+    return function(write) {
+      if (write.Body) lineHighlight(write.Body);
+      wrappedOutput(write);
+    }
+  }
+  function lineClear() {
+    $(".lineerror").removeClass("lineerror");
+  }
+
+  // opts is an object with these keys
+  //  codeEl - code editor element
+  //  outputEl - program output element
+  //  runEl - run button element
+  //  fmtEl - fmt button element (optional)
+  //  fmtImportEl - fmt "imports" checkbox element (optional)
+  //  shareEl - share button element (optional)
+  //  shareURLEl - share URL text input element (optional)
+  //  shareRedirect - base URL to redirect to on share (optional)
+  //  toysEl - toys select element (optional)
+  //  enableHistory - enable using HTML5 history API (optional)
+  //  transport - playground transport to use (default is HTTPTransport)
+  //  enableShortcuts - whether to enable shortcuts (Ctrl+S/Cmd+S to save) (default is false)
+  function playground(opts) {
+    var code = $(opts.codeEl);
+    var transport = opts['transport'] || new HTTPTransport();
+    var running;
+
+    // autoindent helpers.
+    function insertTabs(n) {
+      // find the selection start and end
+      var start = code[0].selectionStart;
+      var end   = code[0].selectionEnd;
+      // split the textarea content into two, and insert n tabs
+      var v = code[0].value;
+      var u = v.substr(0, start);
+      for (var i=0; i<n; i++) {
+        u += "\t";
+      }
+      u += v.substr(end);
+      // set revised content
+      code[0].value = u;
+      // reset caret position after inserted tabs
+      code[0].selectionStart = start+n;
+      code[0].selectionEnd = start+n;
+    }
+    function autoindent(el) {
+      var curpos = el.selectionStart;
+      var tabs = 0;
+      while (curpos > 0) {
+        curpos--;
+        if (el.value[curpos] == "\t") {
+          tabs++;
+        } else if (tabs > 0 || el.value[curpos] == "\n") {
+          break;
+        }
+      }
+      setTimeout(function() {
+        insertTabs(tabs);
+      }, 1);
+    }
+
+    // NOTE(cbro): e is a jQuery event, not a DOM event.
+    function handleSaveShortcut(e) {
+      if (e.isDefaultPrevented()) return false;
+      if (!e.metaKey && !e.ctrlKey) return false;
+      if (e.key != "S" && e.key != "s") return false;
+
+      e.preventDefault();
+
+      // Share and save
+      share(function(url) {
+        window.location.href = url + ".go?download=true";
+      });
+
+      return true;
+    }
+
+    function keyHandler(e) {
+      if (opts.enableShortcuts && handleSaveShortcut(e)) return;
+
+      if (e.keyCode == 9 && !e.ctrlKey) { // tab (but not ctrl-tab)
+        insertTabs(1);
+        e.preventDefault();
+        return false;
+      }
+      if (e.keyCode == 13) { // enter
+        if (e.shiftKey) { // +shift
+          run();
+          e.preventDefault();
+          return false;
+        } if (e.ctrlKey) { // +control
+          fmt();
+          e.preventDefault();
+        } else {
+          autoindent(e.target);
+        }
+      }
+      return true;
+    }
+    code.unbind('keydown').bind('keydown', keyHandler);
+    var outdiv = $(opts.outputEl).empty();
+    var output = $('<pre/>').appendTo(outdiv);
+
+    function body() {
+      return $(opts.codeEl).val();
+    }
+    function setBody(text) {
+      $(opts.codeEl).val(text);
+    }
+    function origin(href) {
+      return (""+href).split("/").slice(0, 3).join("/");
+    }
+
+    var pushedEmpty = (window.location.pathname == "/");
+    function inputChanged() {
+      if (pushedEmpty) {
+        return;
+      }
+      pushedEmpty = true;
+      $(opts.shareURLEl).hide();
+      window.history.pushState(null, "", "/");
+    }
+    function popState(e) {
+      if (e === null) {
+        return;
+      }
+      if (e && e.state && e.state.code) {
+        setBody(e.state.code);
+      }
+    }
+    var rewriteHistory = false;
+    if (window.history && window.history.pushState && window.addEventListener && opts.enableHistory) {
+      rewriteHistory = true;
+      code[0].addEventListener('input', inputChanged);
+      window.addEventListener('popstate', popState);
+    }
+
+    function setError(error) {
+      if (running) running.Kill();
+      lineClear();
+      lineHighlight(error);
+      output.empty().addClass("error").text(error);
+    }
+    function loading() {
+      lineClear();
+      if (running) running.Kill();
+      output.removeClass("error").text('Waiting for remote server...');
+    }
+    function run() {
+      loading();
+      running = transport.Run(body(), highlightOutput(PlaygroundOutput(output[0])));
+    }
+
+    function fmt() {
+      loading();
+      var data = {"body": body()};
+      if ($(opts.fmtImportEl).is(":checked")) {
+        data["imports"] = "true";
+      }
+      $.ajax("/fmt", {
+        data: data,
+        type: "POST",
+        dataType: "json",
+        success: function(data) {
+          if (data.Error) {
+            setError(data.Error);
+          } else {
+            setBody(data.Body);
+            setError("");
+          }
+        }
+      });
+    }
+
+    var shareURL; // jQuery element to show the shared URL.
+    var sharing = false; // true if there is a pending request.
+    var shareCallbacks = [];
+    function share(opt_callback) {
+      if (opt_callback) shareCallbacks.push(opt_callback);
+
+      if (sharing) return;
+      sharing = true;
+
+      var sharingData = body();
+      $.ajax("/share", {
+        processData: false,
+        data: sharingData,
+        type: "POST",
+        contentType: "text/plain; charset=utf-8",
+        complete: function(xhr) {
+          sharing = false;
+          if (xhr.status != 200) {
+            alert("Server error; try again.");
+            return;
+          }
+          if (opts.shareRedirect) {
+            window.location = opts.shareRedirect + xhr.responseText;
+          }
+          var path = "/p/" + xhr.responseText;
+          var url = origin(window.location) + path;
+
+          for (var i = 0; i < shareCallbacks.length; i++) {
+            shareCallbacks[i](url);
+          }
+          shareCallbacks = [];
+
+          if (shareURL) {
+            shareURL.show().val(url).focus().select();
+
+            if (rewriteHistory) {
+              var historyData = {"code": sharingData};
+              window.history.pushState(historyData, "", path);
+              pushedEmpty = false;
+            }
+          }
+        }
+      });
+    }
+
+    $(opts.runEl).click(run);
+    $(opts.fmtEl).click(fmt);
+
+    if (opts.shareEl !== null && (opts.shareURLEl !== null || opts.shareRedirect !== null)) {
+      if (opts.shareURLEl) {
+        shareURL = $(opts.shareURLEl).hide();
+      }
+      $(opts.shareEl).click(function() {
+        share();
+      });
+    }
+
+    if (opts.toysEl !== null) {
+      $(opts.toysEl).bind('change', function() {
+        var toy = $(this).val();
+        $.ajax("/doc/play/"+toy, {
+          processData: false,
+          type: "GET",
+          complete: function(xhr) {
+            if (xhr.status != 200) {
+              alert("Server error; try again.");
+              return;
+            }
+            setBody(xhr.responseText);
+          }
+        });
+      });
+    }
+  }
+
+  window.playground = playground;
+})();
+`,
+
+	"search.html": `<!--
+	Copyright 2009 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.
+-->
+{{with .Alert}}
+	<p>
+	<span class="alert" style="font-size:120%">{{html .}}</span>
+	</p>
+{{end}}
+{{with .Alt}}
+	<p>
+	<span class="alert" style="font-size:120%">Did you mean: </span>
+	{{range .Alts}}
+		<a href="search?q={{urlquery .}}" style="font-size:120%">{{html .}}</a>
+	{{end}}
+	</p>
+{{end}}
+`,
+
+	"search.txt": `QUERY
+	{{.Query}}
+
+{{with .Alert}}{{.}}
+{{end}}{{/* .Alert */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Alt}}DID YOU MEAN
+
+{{range .Alts}}	{{.}}
+{{end}}
+{{end}}{{/* .Alt */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Pak}}PACKAGE {{$.Query}}
+
+{{range .}}	{{pkgLink .Pak.Path}}
+{{end}}
+{{end}}{{/* .Pak */}}{{/*
+
+---------------------------------------
+
+*/}}{{range $key, $val := .Idents}}{{if $val}}{{$key.Name}}
+{{range $val}}    {{.Path}}.{{.Name}}
+{{end}}
+{{end}}{{end}}{{/* .Idents */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Hit}}{{with .Decls}}PACKAGE-LEVEL DECLARATIONS
+
+{{range .}}package {{.Pak.Name}}
+{{range $file := .Files}}{{range .Groups}}{{range .}}	{{srcLink $file.File.Path}}:{{infoLine .}}{{end}}
+{{end}}{{end}}{{/* .Files */}}
+{{end}}{{end}}{{/* .Decls */}}{{/*
+
+---------------------------------------
+
+*/}}{{with .Others}}LOCAL DECLARATIONS AND USES
+
+{{range .}}package {{.Pak.Name}}
+{{range $file := .Files}}{{range .Groups}}{{range .}}	{{srcLink $file.File.Path}}:{{infoLine .}}
+{{end}}{{end}}{{end}}{{/* .Files */}}
+{{end}}{{end}}{{/* .Others */}}{{end}}{{/* .Hit */}}{{/*
+
+---------------------------------------
+
+*/}}{{if .Textual}}{{if .Complete}}{{.Found}} TEXTUAL OCCURRENCES{{else}}MORE THAN {{.Found}} TEXTUAL OCCURRENCES{{end}}
+
+{{range .Textual}}{{len .Lines}}	{{srcLink .Filename}}
+{{end}}{{if not .Complete}}...	...
+{{end}}{{end}}
+`,
+
+	"searchcode.html": `<!--
+	Copyright 2009 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.
+-->
+{{$query_url := urlquery .Query}}
+{{if not .Idents}}
+	{{with .Pak}}
+		<h2 id="Packages">Package {{html $.Query}}</h2>
+		<p>
+		<table class="layout">
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<tr><td><a href="/{{$pkg_html}}">{{$pkg_html}}</a></td></tr>
+		{{end}}
+		</table>
+		</p>
+	{{end}}
+{{end}}
+{{with .Hit}}
+	{{with .Decls}}
+		<h2 id="Global">Package-level declarations</h2>
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<h3 id="Global_{{$pkg_html}}">package <a href="/{{$pkg_html}}">{{html .Pak.Name}}</a></h3>
+			{{range .Files}}
+				{{$file := .File.Path}}
+				{{range .Groups}}
+					{{range .}}
+						{{$line := infoLine .}}
+						<a href="{{queryLink $file $query_url $line | html}}">{{$file}}:{{$line}}</a>
+						{{infoSnippet_html .}}
+					{{end}}
+				{{end}}
+			{{end}}
+		{{end}}
+	{{end}}
+	{{with .Others}}
+		<h2 id="Local">Local declarations and uses</h2>
+		{{range .}}
+			{{$pkg_html := pkgLink .Pak.Path | html}}
+			<h3 id="Local_{{$pkg_html}}">package <a href="/{{$pkg_html}}">{{html .Pak.Name}}</a></h3>
+			{{range .Files}}
+				{{$file := .File.Path}}
+				<a href="{{queryLink $file $query_url 0 | html}}">{{$file}}</a>
+				<table class="layout">
+				{{range .Groups}}
+					<tr>
+					<td width="25"></td>
+					<th align="left" valign="top">{{index . 0 | infoKind_html}}</th>
+					<td align="left" width="4"></td>
+					<td>
+					{{range .}}
+						{{$line := infoLine .}}
+						<a href="{{queryLink $file $query_url $line | html}}">{{$line}}</a>
+					{{end}}
+					</td>
+					</tr>
+				{{end}}
+				</table>
+			{{end}}
+		{{end}}
+	{{end}}
+{{end}}
+`,
+
+	"searchdoc.html": `<!--
+	Copyright 2009 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.
+-->
+{{range $key, $val := .Idents}}
+	{{if $val}}
+		<h2 id="{{$key.Name}}">{{$key.Name}}</h2>
+		{{range $val}}
+			{{$pkg_html := pkgLink .Path | html}}
+			{{if eq "Packages" $key.Name}}
+				<a href="/{{$pkg_html}}">{{html .Path}}</a>
+			{{else}}
+				{{$doc_html := docLink .Path .Name| html}}
+				<a href="/{{$pkg_html}}">{{html .Package}}</a>.<a href="{{$doc_html}}">{{.Name}}</a>
+			{{end}}
+			{{if .Doc}}
+				<p>{{comment_html .Doc}}</p>
+			{{else}}
+				<p><em>No documentation available</em></p>
+			{{end}}
+		{{end}}
+	{{end}}
+{{end}}
+`,
+
+	"searchtxt.html": `<!--
+	Copyright 2009 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.
+-->
+{{$query_url := urlquery .Query}}
+{{with .Textual}}
+	{{if $.Complete}}
+		<h2 id="Textual">{{html $.Found}} textual occurrences</h2>
+	{{else}}
+		<h2 id="Textual">More than {{html $.Found}} textual occurrences</h2>
+		<p>
+		<span class="alert" style="font-size:120%">Not all files or lines containing "{{html $.Query}}" are shown.</span>
+		</p>
+	{{end}}
+	<p>
+	<table class="layout">
+	{{range .}}
+		{{$file := .Filename}}
+		<tr>
+		<td align="left" valign="top">
+		<a href="{{queryLink $file $query_url 0}}">{{$file}}</a>:
+		</td>
+		<td align="left" width="4"></td>
+		<th align="left" valign="top">{{len .Lines}}</th>
+		<td align="left" width="4"></td>
+		<td align="left">
+		{{range .Lines}}
+			<a href="{{queryLink $file $query_url .}}">{{html .}}</a>
+		{{end}}
+		{{if not $.Complete}}
+			...
+		{{end}}
+		</td>
+		</tr>
+	{{end}}
+	{{if not $.Complete}}
+		<tr><td align="left">...</td></tr>
+	{{end}}
+	</table>
+	</p>
+{{end}}
+`,
+
+	"style.css": `body {
+	margin: 0;
+	font-family: Arial, sans-serif;
+	font-size: 16px;
+	background-color: #fff;
+	line-height: 1.3em;
+}
+pre,
+code {
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+pre {
+	line-height: 1.4em;
+	overflow-x: auto;
+}
+pre .comment {
+	color: #006600;
+}
+pre .highlight,
+pre .highlight-comment,
+pre .selection-highlight,
+pre .selection-highlight-comment {
+	background: #FFFF00;
+}
+pre .selection,
+pre .selection-comment {
+	background: #FF9632;
+}
+pre .ln {
+	color: #999;
+	background: #efefef;
+}
+.ln {
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+body {
+	color: #222;
+}
+a,
+.exampleHeading .text {
+	color: #375EAB;
+	text-decoration: none;
+}
+a:hover,
+.exampleHeading .text:hover {
+	text-decoration: underline;
+}
+.article a {
+	text-decoration: underline;
+}
+.article .title a {
+	text-decoration: none;
+}
+
+.permalink {
+	display: none;
+}
+:hover > .permalink {
+	display: inline;
+}
+
+p, li {
+	max-width: 800px;
+	word-wrap: break-word;
+}
+p,
+pre,
+ul,
+ol {
+	margin: 20px;
+}
+pre {
+	background: #EFEFEF;
+	padding: 10px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+
+h1,
+h2,
+h3,
+h4,
+.rootHeading {
+	margin: 20px 0 20px;
+	padding: 0;
+	color: #375EAB;
+	font-weight: bold;
+}
+h1 {
+	font-size: 28px;
+	line-height: 1;
+}
+h1 .text-muted {
+	color:#777;
+}
+h2 {
+	font-size: 20px;
+	background: #E0EBF5;
+	padding: 8px;
+	line-height: 1.25;
+	font-weight: normal;
+}
+h2 a {
+	font-weight: bold;
+}
+h3 {
+	font-size: 20px;
+}
+h3,
+h4 {
+	margin: 20px 5px;
+}
+h4 {
+	font-size: 16px;
+}
+.rootHeading {
+	font-size: 20px;
+	margin: 0;
+}
+
+dl {
+	margin: 20px;
+}
+dd {
+	margin: 0 0 0 20px;
+}
+dl,
+dd {
+	font-size: 14px;
+}
+div#nav table td {
+	vertical-align: top;
+}
+
+
+#pkg-index h3 {
+	font-size: 16px;
+}
+.pkg-dir {
+	padding: 0 10px;
+}
+.pkg-dir table {
+	border-collapse: collapse;
+	border-spacing: 0;
+}
+.pkg-name {
+	padding-right: 10px;
+}
+.alert {
+	color: #AA0000;
+}
+
+.top-heading {
+	float: left;
+	padding: 21px 0;
+	font-size: 20px;
+	font-weight: normal;
+}
+.top-heading a {
+	color: #222;
+	text-decoration: none;
+}
+
+div#topbar {
+	background: #E0EBF5;
+	height: 64px;
+	overflow: hidden;
+}
+
+body {
+	text-align: center;
+}
+div#page {
+	width: 100%;
+}
+div#page > .container,
+div#topbar > .container {
+	text-align: left;
+	margin-left: auto;
+	margin-right: auto;
+	padding: 0 20px;
+}
+div#topbar > .container,
+div#page > .container {
+	max-width: 950px;
+}
+div#page.wide > .container,
+div#topbar.wide > .container {
+	max-width: none;
+}
+div#plusone {
+	float: right;
+	clear: right;
+	margin-top: 5px;
+}
+
+div#footer {
+	text-align: center;
+	color: #666;
+	font-size: 14px;
+	margin: 40px 0;
+}
+
+div#menu > a,
+input#search,
+div#learn .buttons a,
+div.play .buttons a,
+div#blog .read a,
+#menu-button {
+	padding: 10px;
+
+	text-decoration: none;
+	font-size: 16px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+div#playground .buttons a,
+div#menu > a,
+input#search,
+#menu-button {
+	border: 1px solid #375EAB;
+}
+div#playground .buttons a,
+div#menu > a,
+#menu-button {
+	color: white;
+	background: #375EAB;
+}
+#playgroundButton.active {
+	background: white;
+	color: #375EAB;
+}
+a#start,
+div#learn .buttons a,
+div.play .buttons a,
+div#blog .read a {
+	color: #222;
+	border: 1px solid #375EAB;
+	background: #E0EBF5;
+}
+.download {
+	width: 150px;
+}
+
+div#menu {
+	text-align: right;
+	padding: 10px;
+	white-space: nowrap;
+	max-height: 0;
+	-moz-transition: max-height .25s linear;
+	transition: max-height .25s linear;
+	width: 100%;
+}
+div#menu.menu-visible {
+	max-height: 500px;
+}
+div#menu > a,
+#menu-button {
+	margin: 10px 2px;
+	padding: 10px;
+}
+::-webkit-input-placeholder {
+	color: #7f7f7f;
+	opacity: 1;
+}
+::placeholder {
+	color: #7f7f7f;
+	opacity: 1;
+}
+#menu .search-box {
+	display: inline-flex;
+	width: 140px;
+}
+input#search {
+	background: white;
+	color: #222;
+	box-sizing: border-box;
+	-webkit-appearance: none;
+	border-top-right-radius: 0;
+	border-bottom-right-radius: 0;
+	border-right: 0;
+	margin-right: 0;
+	flex-grow: 1;
+	max-width: 100%;
+	min-width: 90px;
+}
+input#search:-moz-ui-invalid {
+	box-shadow: unset;
+}
+input#search + button {
+	display: inline;
+	font-size: 1em;
+	background-color: #375EAB;
+	color: white;
+	border: 1px solid #375EAB;
+	border-top-left-radius: 0;
+	border-top-right-radius: 5px;
+	border-bottom-left-radius: 0;
+	border-bottom-right-radius: 5px;
+	margin-left: 0;
+	cursor: pointer;
+}
+input#search + button span {
+	display: flex;
+}
+input#search + button svg {
+	fill: white
+}
+
+#menu-button {
+	display: none;
+	position: absolute;
+	right: 5px;
+	top: 0;
+	margin-right: 5px;
+}
+#menu-button-arrow {
+	display: inline-block;
+}
+.vertical-flip {
+	transform: rotate(-180deg);
+}
+
+div.left {
+	float: left;
+	clear: left;
+	margin-right: 2.5%;
+}
+div.right {
+	float: right;
+	clear: right;
+	margin-left: 2.5%;
+}
+div.left,
+div.right {
+	width: 45%;
+}
+
+div#learn,
+div#about {
+	padding-top: 20px;
+}
+div#learn h2,
+div#about {
+	margin: 0;
+}
+div#about {
+	font-size: 20px;
+	margin: 0 auto 30px;
+}
+div#gopher {
+	background: url(/doc/gopher/frontpage.png) no-repeat;
+	background-position: center top;
+	height: 155px;
+}
+a#start {
+	display: block;
+	padding: 10px;
+
+	text-align: center;
+	text-decoration: none;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+a#start .big {
+	display: block;
+	font-weight: bold;
+	font-size: 20px;
+}
+a#start .desc {
+	display: block;
+	font-size: 14px;
+	font-weight: normal;
+	margin-top: 5px;
+}
+
+div#learn .popout {
+	float: right;
+	display: block;
+	cursor: pointer;
+	font-size: 12px;
+	background: url(/doc/share.png) no-repeat;
+	background-position: right top;
+	padding: 5px 27px;
+}
+div#learn pre,
+div#learn textarea {
+	padding: 0;
+	margin: 0;
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+div#learn .input {
+	padding: 10px;
+	margin-top: 10px;
+	height: 150px;
+
+	-webkit-border-top-left-radius: 5px;
+	-webkit-border-top-right-radius: 5px;
+	-moz-border-radius-topleft: 5px;
+	-moz-border-radius-topright: 5px;
+	border-top-left-radius: 5px;
+	border-top-right-radius: 5px;
+}
+div#learn .input textarea {
+	width: 100%;
+	height: 100%;
+	border: none;
+	outline: none;
+	resize: none;
+}
+div#learn .output {
+	border-top: none !important;
+
+	padding: 10px;
+	height: 59px;
+	overflow: auto;
+
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+	-moz-border-radius-bottomright: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	border-bottom-right-radius: 5px;
+	border-bottom-left-radius: 5px;
+}
+div#learn .output pre {
+	padding: 0;
+
+	-webkit-border-radius: 0;
+	-moz-border-radius: 0;
+	border-radius: 0;
+}
+div#learn .input,
+div#learn .input textarea,
+div#learn .output,
+div#learn .output pre {
+	background: #FFFFD8;
+}
+div#learn .input,
+div#learn .output {
+	border: 1px solid #375EAB;
+}
+div#learn .buttons {
+	float: right;
+	padding: 20px 0 10px 0;
+	text-align: right;
+}
+div#learn .buttons a {
+	height: 16px;
+	margin-left: 5px;
+	padding: 10px;
+}
+div#learn .toys {
+	margin-top: 8px;
+}
+div#learn .toys select {
+	border: 1px solid #375EAB;
+	margin: 0;
+}
+div#learn .output .exit {
+	display: none;
+}
+
+div#video {
+	max-width: 100%;
+}
+div#blog,
+div#video {
+	margin-top: 40px;
+}
+div#blog > a,
+div#blog > div,
+div#blog > h2,
+div#video > a,
+div#video > div,
+div#video > h2 {
+	margin-bottom: 10px;
+}
+div#blog .title,
+div#video .title {
+	display: block;
+	font-size: 20px;
+}
+div#blog .when {
+	color: #666;
+	font-size: 14px;
+}
+div#blog .read {
+	text-align: right;
+}
+
+.toggleButton { cursor: pointer; }
+.toggle > .collapsed { display: block; }
+.toggle > .expanded { display: none; }
+.toggleVisible > .collapsed { display: none; }
+.toggleVisible > .expanded { display: block; }
+
+table.codetable { margin-left: auto; margin-right: auto; border-style: none; }
+table.codetable td { padding-right: 10px; }
+hr { border-style: none; border-top: 1px solid black; }
+
+img.gopher {
+	float: right;
+	margin-left: 10px;
+	margin-bottom: 10px;
+	z-index: -1;
+}
+h2 { clear: right; }
+
+/* example and drop-down playground */
+div.play {
+	padding: 0 20px 40px 20px;
+}
+div.play pre,
+div.play textarea,
+div.play .lines {
+	padding: 0;
+	margin: 0;
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+div.play .input {
+	padding: 10px;
+	margin-top: 10px;
+
+	-webkit-border-top-left-radius: 5px;
+	-webkit-border-top-right-radius: 5px;
+	-moz-border-radius-topleft: 5px;
+	-moz-border-radius-topright: 5px;
+	border-top-left-radius: 5px;
+	border-top-right-radius: 5px;
+
+	overflow: hidden;
+}
+div.play .input textarea {
+	width: 100%;
+	height: 100%;
+	border: none;
+	outline: none;
+	resize: none;
+
+	overflow: hidden;
+}
+div#playground .input textarea {
+	overflow: auto;
+	resize: auto;
+}
+div.play .output {
+	border-top: none !important;
+
+	padding: 10px;
+	max-height: 200px;
+	overflow: auto;
+
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+	-moz-border-radius-bottomright: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	border-bottom-right-radius: 5px;
+	border-bottom-left-radius: 5px;
+}
+div.play .output pre {
+	padding: 0;
+
+	-webkit-border-radius: 0;
+	-moz-border-radius: 0;
+	border-radius: 0;
+}
+div.play .input,
+div.play .input textarea,
+div.play .output,
+div.play .output pre {
+	background: #FFFFD8;
+}
+div.play .input,
+div.play .output {
+	border: 1px solid #375EAB;
+}
+div.play .buttons {
+	float: right;
+	padding: 20px 0 10px 0;
+	text-align: right;
+}
+div.play .buttons a {
+	height: 16px;
+	margin-left: 5px;
+	padding: 10px;
+	cursor: pointer;
+}
+.output .stderr {
+	color: #933;
+}
+.output .system {
+	color: #999;
+}
+
+/* drop-down playground */
+#playgroundButton,
+div#playground {
+	/* start hidden; revealed by javascript */
+	display: none;
+}
+div#playground {
+	position: absolute;
+	top: 63px;
+	right: 20px;
+	padding: 0 10px 10px 10px;
+	z-index: 1;
+	text-align: left;
+	background: #E0EBF5;
+
+	border: 1px solid #B0BBC5;
+	border-top: none;
+
+	-webkit-border-bottom-left-radius: 5px;
+	-webkit-border-bottom-right-radius: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	-moz-border-radius-bottomright: 5px;
+	border-bottom-left-radius: 5px;
+	border-bottom-right-radius: 5px;
+}
+div#playground .code {
+	width: 520px;
+	height: 200px;
+}
+div#playground .output {
+	height: 100px;
+}
+
+/* Inline runnable snippets (play.js/initPlayground) */
+#content .code pre, #content .playground pre, #content .output pre {
+        margin: 0;
+        padding: 0;
+        background: none;
+        border: none;
+	outline: 0px solid transparent;
+        overflow: auto;
+}
+#content .playground .number, #content .code .number {
+        color: #999;
+}
+#content .code, #content .playground, #content .output {
+	width: auto;
+        margin: 20px;
+        padding: 10px;
+        -webkit-border-radius: 5px;
+        -moz-border-radius: 5px;
+        border-radius: 5px;
+}
+#content .code, #content .playground {
+        background: #e9e9e9;
+}
+#content .output {
+        background: #202020;
+}
+#content .output .stdout, #content .output pre {
+        color: #e6e6e6;
+}
+#content .output .stderr, #content .output .error {
+        color: rgb(244, 74, 63);
+}
+#content .output .system, #content .output .exit {
+        color: rgb(255, 209, 77)
+}
+#content .buttons {
+        position: relative;
+        float: right;
+        top: -50px;
+        right: 30px;
+}
+#content .output .buttons {
+        top: -60px;
+        right: 0;
+        height: 0;
+}
+#content .buttons .kill {
+        display: none;
+        visibility: hidden;
+}
+a.error {
+	font-weight: bold;
+        color: white;
+	background-color: darkred;
+        border-bottom-left-radius: 4px;
+        border-bottom-right-radius: 4px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        padding: 2px 4px 2px 4px; /* TRBL */
+}
+
+
+#heading-narrow {
+	display: none;
+}
+
+.downloading {
+	background: #F9F9BE;
+	padding: 10px;
+	text-align: center;
+	border-radius: 5px;
+}
+
+@media (max-width: 930px) {
+	#heading-wide {
+		display: none;
+	}
+	#heading-narrow {
+		display: block;
+	}
+}
+
+
+@media (max-width: 760px) {
+	.container .left,
+	.container .right {
+		width: auto;
+		float: none;
+	}
+
+	div#about {
+		max-width: 500px;
+		text-align: center;
+	}
+}
+
+@media (min-width: 700px) and (max-width: 1000px) {
+	div#menu > a {
+		margin: 5px 0;
+		font-size: 14px;
+	}
+
+	input#search {
+		font-size: 14px;
+	}
+}
+
+@media (max-width: 700px) {
+	body {
+		font-size: 15px;
+	}
+
+	pre,
+	code {
+		font-size: 13px;
+	}
+
+	div#page > .container {
+		padding: 0 10px;
+	}
+
+	div#topbar {
+		height: auto;
+		padding: 10px;
+	}
+
+	div#topbar > .container {
+		padding: 0;
+	}
+
+	#heading-wide {
+		display: block;
+	}
+	#heading-narrow {
+		display: none;
+	}
+
+	.top-heading {
+		float: none;
+		display: inline-block;
+		padding: 12px;
+	}
+
+	div#menu {
+		padding: 0;
+		min-width: 0;
+		text-align: left;
+		float: left;
+	}
+
+	div#menu > a {
+		display: block;
+		margin-left: 0;
+		margin-right: 0;
+	}
+
+	#menu .search-box {
+		display: flex;
+		width: 100%;
+	}
+
+	#menu-button {
+		display: inline-block;
+	}
+
+	p,
+	pre,
+	ul,
+	ol {
+		margin: 10px;
+	}
+
+	.pkg-synopsis {
+		display: none;
+	}
+
+	img.gopher {
+		display: none;
+	}
+}
+
+@media (max-width: 480px) {
+	#heading-wide {
+		display: none;
+	}
+	#heading-narrow {
+		display: block;
+	}
+}
+
+@media print {
+	pre {
+		background: #FFF;
+		border: 1px solid #BBB;
+		white-space: pre-wrap;
+	}
+}
+`,
+}
diff --git a/vendor/golang.org/x/tools/godoc/static/style.css b/vendor/golang.org/x/tools/godoc/static/style.css
new file mode 100644
index 0000000..79989ee
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/static/style.css
@@ -0,0 +1,837 @@
+body {
+	margin: 0;
+	font-family: Arial, sans-serif;
+	font-size: 16px;
+	background-color: #fff;
+	line-height: 1.3em;
+}
+pre,
+code {
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+pre {
+	line-height: 1.4em;
+	overflow-x: auto;
+}
+pre .comment {
+	color: #006600;
+}
+pre .highlight,
+pre .highlight-comment,
+pre .selection-highlight,
+pre .selection-highlight-comment {
+	background: #FFFF00;
+}
+pre .selection,
+pre .selection-comment {
+	background: #FF9632;
+}
+pre .ln {
+	color: #999;
+	background: #efefef;
+}
+.ln {
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+body {
+	color: #222;
+}
+a,
+.exampleHeading .text {
+	color: #375EAB;
+	text-decoration: none;
+}
+a:hover,
+.exampleHeading .text:hover {
+	text-decoration: underline;
+}
+.article a {
+	text-decoration: underline;
+}
+.article .title a {
+	text-decoration: none;
+}
+
+.permalink {
+	display: none;
+}
+:hover > .permalink {
+	display: inline;
+}
+
+p, li {
+	max-width: 800px;
+	word-wrap: break-word;
+}
+p,
+pre,
+ul,
+ol {
+	margin: 20px;
+}
+pre {
+	background: #EFEFEF;
+	padding: 10px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+
+h1,
+h2,
+h3,
+h4,
+.rootHeading {
+	margin: 20px 0 20px;
+	padding: 0;
+	color: #375EAB;
+	font-weight: bold;
+}
+h1 {
+	font-size: 28px;
+	line-height: 1;
+}
+h1 .text-muted {
+	color:#777;
+}
+h2 {
+	font-size: 20px;
+	background: #E0EBF5;
+	padding: 8px;
+	line-height: 1.25;
+	font-weight: normal;
+}
+h2 a {
+	font-weight: bold;
+}
+h3 {
+	font-size: 20px;
+}
+h3,
+h4 {
+	margin: 20px 5px;
+}
+h4 {
+	font-size: 16px;
+}
+.rootHeading {
+	font-size: 20px;
+	margin: 0;
+}
+
+dl {
+	margin: 20px;
+}
+dd {
+	margin: 0 0 0 20px;
+}
+dl,
+dd {
+	font-size: 14px;
+}
+div#nav table td {
+	vertical-align: top;
+}
+
+
+#pkg-index h3 {
+	font-size: 16px;
+}
+.pkg-dir {
+	padding: 0 10px;
+}
+.pkg-dir table {
+	border-collapse: collapse;
+	border-spacing: 0;
+}
+.pkg-name {
+	padding-right: 10px;
+}
+.alert {
+	color: #AA0000;
+}
+
+.top-heading {
+	float: left;
+	padding: 21px 0;
+	font-size: 20px;
+	font-weight: normal;
+}
+.top-heading a {
+	color: #222;
+	text-decoration: none;
+}
+
+div#topbar {
+	background: #E0EBF5;
+	height: 64px;
+	overflow: hidden;
+}
+
+body {
+	text-align: center;
+}
+div#page {
+	width: 100%;
+}
+div#page > .container,
+div#topbar > .container {
+	text-align: left;
+	margin-left: auto;
+	margin-right: auto;
+	padding: 0 20px;
+}
+div#topbar > .container,
+div#page > .container {
+	max-width: 950px;
+}
+div#page.wide > .container,
+div#topbar.wide > .container {
+	max-width: none;
+}
+div#plusone {
+	float: right;
+	clear: right;
+	margin-top: 5px;
+}
+
+div#footer {
+	text-align: center;
+	color: #666;
+	font-size: 14px;
+	margin: 40px 0;
+}
+
+div#menu > a,
+input#search,
+div#learn .buttons a,
+div.play .buttons a,
+div#blog .read a,
+#menu-button {
+	padding: 10px;
+
+	text-decoration: none;
+	font-size: 16px;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+div#playground .buttons a,
+div#menu > a,
+input#search,
+#menu-button {
+	border: 1px solid #375EAB;
+}
+div#playground .buttons a,
+div#menu > a,
+#menu-button {
+	color: white;
+	background: #375EAB;
+}
+#playgroundButton.active {
+	background: white;
+	color: #375EAB;
+}
+a#start,
+div#learn .buttons a,
+div.play .buttons a,
+div#blog .read a {
+	color: #222;
+	border: 1px solid #375EAB;
+	background: #E0EBF5;
+}
+.download {
+	width: 150px;
+}
+
+div#menu {
+	text-align: right;
+	padding: 10px;
+	white-space: nowrap;
+	max-height: 0;
+	-moz-transition: max-height .25s linear;
+	transition: max-height .25s linear;
+	width: 100%;
+}
+div#menu.menu-visible {
+	max-height: 500px;
+}
+div#menu > a,
+#menu-button {
+	margin: 10px 2px;
+	padding: 10px;
+}
+::-webkit-input-placeholder {
+	color: #7f7f7f;
+	opacity: 1;
+}
+::placeholder {
+	color: #7f7f7f;
+	opacity: 1;
+}
+#menu .search-box {
+	display: inline-flex;
+	width: 140px;
+}
+input#search {
+	background: white;
+	color: #222;
+	box-sizing: border-box;
+	-webkit-appearance: none;
+	border-top-right-radius: 0;
+	border-bottom-right-radius: 0;
+	border-right: 0;
+	margin-right: 0;
+	flex-grow: 1;
+	max-width: 100%;
+	min-width: 90px;
+}
+input#search:-moz-ui-invalid {
+	box-shadow: unset;
+}
+input#search + button {
+	display: inline;
+	font-size: 1em;
+	background-color: #375EAB;
+	color: white;
+	border: 1px solid #375EAB;
+	border-top-left-radius: 0;
+	border-top-right-radius: 5px;
+	border-bottom-left-radius: 0;
+	border-bottom-right-radius: 5px;
+	margin-left: 0;
+	cursor: pointer;
+}
+input#search + button span {
+	display: flex;
+}
+input#search + button svg {
+	fill: white
+}
+
+#menu-button {
+	display: none;
+	position: absolute;
+	right: 5px;
+	top: 0;
+	margin-right: 5px;
+}
+#menu-button-arrow {
+	display: inline-block;
+}
+.vertical-flip {
+	transform: rotate(-180deg);
+}
+
+div.left {
+	float: left;
+	clear: left;
+	margin-right: 2.5%;
+}
+div.right {
+	float: right;
+	clear: right;
+	margin-left: 2.5%;
+}
+div.left,
+div.right {
+	width: 45%;
+}
+
+div#learn,
+div#about {
+	padding-top: 20px;
+}
+div#learn h2,
+div#about {
+	margin: 0;
+}
+div#about {
+	font-size: 20px;
+	margin: 0 auto 30px;
+}
+div#gopher {
+	background: url(/doc/gopher/frontpage.png) no-repeat;
+	background-position: center top;
+	height: 155px;
+}
+a#start {
+	display: block;
+	padding: 10px;
+
+	text-align: center;
+	text-decoration: none;
+
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	border-radius: 5px;
+}
+a#start .big {
+	display: block;
+	font-weight: bold;
+	font-size: 20px;
+}
+a#start .desc {
+	display: block;
+	font-size: 14px;
+	font-weight: normal;
+	margin-top: 5px;
+}
+
+div#learn .popout {
+	float: right;
+	display: block;
+	cursor: pointer;
+	font-size: 12px;
+	background: url(/doc/share.png) no-repeat;
+	background-position: right top;
+	padding: 5px 27px;
+}
+div#learn pre,
+div#learn textarea {
+	padding: 0;
+	margin: 0;
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+div#learn .input {
+	padding: 10px;
+	margin-top: 10px;
+	height: 150px;
+
+	-webkit-border-top-left-radius: 5px;
+	-webkit-border-top-right-radius: 5px;
+	-moz-border-radius-topleft: 5px;
+	-moz-border-radius-topright: 5px;
+	border-top-left-radius: 5px;
+	border-top-right-radius: 5px;
+}
+div#learn .input textarea {
+	width: 100%;
+	height: 100%;
+	border: none;
+	outline: none;
+	resize: none;
+}
+div#learn .output {
+	border-top: none !important;
+
+	padding: 10px;
+	height: 59px;
+	overflow: auto;
+
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+	-moz-border-radius-bottomright: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	border-bottom-right-radius: 5px;
+	border-bottom-left-radius: 5px;
+}
+div#learn .output pre {
+	padding: 0;
+
+	-webkit-border-radius: 0;
+	-moz-border-radius: 0;
+	border-radius: 0;
+}
+div#learn .input,
+div#learn .input textarea,
+div#learn .output,
+div#learn .output pre {
+	background: #FFFFD8;
+}
+div#learn .input,
+div#learn .output {
+	border: 1px solid #375EAB;
+}
+div#learn .buttons {
+	float: right;
+	padding: 20px 0 10px 0;
+	text-align: right;
+}
+div#learn .buttons a {
+	height: 16px;
+	margin-left: 5px;
+	padding: 10px;
+}
+div#learn .toys {
+	margin-top: 8px;
+}
+div#learn .toys select {
+	border: 1px solid #375EAB;
+	margin: 0;
+}
+div#learn .output .exit {
+	display: none;
+}
+
+div#video {
+	max-width: 100%;
+}
+div#blog,
+div#video {
+	margin-top: 40px;
+}
+div#blog > a,
+div#blog > div,
+div#blog > h2,
+div#video > a,
+div#video > div,
+div#video > h2 {
+	margin-bottom: 10px;
+}
+div#blog .title,
+div#video .title {
+	display: block;
+	font-size: 20px;
+}
+div#blog .when {
+	color: #666;
+	font-size: 14px;
+}
+div#blog .read {
+	text-align: right;
+}
+
+.toggleButton { cursor: pointer; }
+.toggle > .collapsed { display: block; }
+.toggle > .expanded { display: none; }
+.toggleVisible > .collapsed { display: none; }
+.toggleVisible > .expanded { display: block; }
+
+table.codetable { margin-left: auto; margin-right: auto; border-style: none; }
+table.codetable td { padding-right: 10px; }
+hr { border-style: none; border-top: 1px solid black; }
+
+img.gopher {
+	float: right;
+	margin-left: 10px;
+	margin-bottom: 10px;
+	z-index: -1;
+}
+h2 { clear: right; }
+
+/* example and drop-down playground */
+div.play {
+	padding: 0 20px 40px 20px;
+}
+div.play pre,
+div.play textarea,
+div.play .lines {
+	padding: 0;
+	margin: 0;
+	font-family: Menlo, monospace;
+	font-size: 14px;
+}
+div.play .input {
+	padding: 10px;
+	margin-top: 10px;
+
+	-webkit-border-top-left-radius: 5px;
+	-webkit-border-top-right-radius: 5px;
+	-moz-border-radius-topleft: 5px;
+	-moz-border-radius-topright: 5px;
+	border-top-left-radius: 5px;
+	border-top-right-radius: 5px;
+
+	overflow: hidden;
+}
+div.play .input textarea {
+	width: 100%;
+	height: 100%;
+	border: none;
+	outline: none;
+	resize: none;
+
+	overflow: hidden;
+}
+div#playground .input textarea {
+	overflow: auto;
+	resize: auto;
+}
+div.play .output {
+	border-top: none !important;
+
+	padding: 10px;
+	max-height: 200px;
+	overflow: auto;
+
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+	-moz-border-radius-bottomright: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	border-bottom-right-radius: 5px;
+	border-bottom-left-radius: 5px;
+}
+div.play .output pre {
+	padding: 0;
+
+	-webkit-border-radius: 0;
+	-moz-border-radius: 0;
+	border-radius: 0;
+}
+div.play .input,
+div.play .input textarea,
+div.play .output,
+div.play .output pre {
+	background: #FFFFD8;
+}
+div.play .input,
+div.play .output {
+	border: 1px solid #375EAB;
+}
+div.play .buttons {
+	float: right;
+	padding: 20px 0 10px 0;
+	text-align: right;
+}
+div.play .buttons a {
+	height: 16px;
+	margin-left: 5px;
+	padding: 10px;
+	cursor: pointer;
+}
+.output .stderr {
+	color: #933;
+}
+.output .system {
+	color: #999;
+}
+
+/* drop-down playground */
+#playgroundButton,
+div#playground {
+	/* start hidden; revealed by javascript */
+	display: none;
+}
+div#playground {
+	position: absolute;
+	top: 63px;
+	right: 20px;
+	padding: 0 10px 10px 10px;
+	z-index: 1;
+	text-align: left;
+	background: #E0EBF5;
+
+	border: 1px solid #B0BBC5;
+	border-top: none;
+
+	-webkit-border-bottom-left-radius: 5px;
+	-webkit-border-bottom-right-radius: 5px;
+	-moz-border-radius-bottomleft: 5px;
+	-moz-border-radius-bottomright: 5px;
+	border-bottom-left-radius: 5px;
+	border-bottom-right-radius: 5px;
+}
+div#playground .code {
+	width: 520px;
+	height: 200px;
+}
+div#playground .output {
+	height: 100px;
+}
+
+/* Inline runnable snippets (play.js/initPlayground) */
+#content .code pre, #content .playground pre, #content .output pre {
+        margin: 0;
+        padding: 0;
+        background: none;
+        border: none;
+	outline: 0px solid transparent;
+        overflow: auto;
+}
+#content .playground .number, #content .code .number {
+        color: #999;
+}
+#content .code, #content .playground, #content .output {
+	width: auto;
+        margin: 20px;
+        padding: 10px;
+        -webkit-border-radius: 5px;
+        -moz-border-radius: 5px;
+        border-radius: 5px;
+}
+#content .code, #content .playground {
+        background: #e9e9e9;
+}
+#content .output {
+        background: #202020;
+}
+#content .output .stdout, #content .output pre {
+        color: #e6e6e6;
+}
+#content .output .stderr, #content .output .error {
+        color: rgb(244, 74, 63);
+}
+#content .output .system, #content .output .exit {
+        color: rgb(255, 209, 77)
+}
+#content .buttons {
+        position: relative;
+        float: right;
+        top: -50px;
+        right: 30px;
+}
+#content .output .buttons {
+        top: -60px;
+        right: 0;
+        height: 0;
+}
+#content .buttons .kill {
+        display: none;
+        visibility: hidden;
+}
+a.error {
+	font-weight: bold;
+        color: white;
+	background-color: darkred;
+        border-bottom-left-radius: 4px;
+        border-bottom-right-radius: 4px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        padding: 2px 4px 2px 4px; /* TRBL */
+}
+
+
+#heading-narrow {
+	display: none;
+}
+
+.downloading {
+	background: #F9F9BE;
+	padding: 10px;
+	text-align: center;
+	border-radius: 5px;
+}
+
+@media (max-width: 930px) {
+	#heading-wide {
+		display: none;
+	}
+	#heading-narrow {
+		display: block;
+	}
+}
+
+
+@media (max-width: 760px) {
+	.container .left,
+	.container .right {
+		width: auto;
+		float: none;
+	}
+
+	div#about {
+		max-width: 500px;
+		text-align: center;
+	}
+}
+
+@media (min-width: 700px) and (max-width: 1000px) {
+	div#menu > a {
+		margin: 5px 0;
+		font-size: 14px;
+	}
+
+	input#search {
+		font-size: 14px;
+	}
+}
+
+@media (max-width: 700px) {
+	body {
+		font-size: 15px;
+	}
+
+	pre,
+	code {
+		font-size: 13px;
+	}
+
+	div#page > .container {
+		padding: 0 10px;
+	}
+
+	div#topbar {
+		height: auto;
+		padding: 10px;
+	}
+
+	div#topbar > .container {
+		padding: 0;
+	}
+
+	#heading-wide {
+		display: block;
+	}
+	#heading-narrow {
+		display: none;
+	}
+
+	.top-heading {
+		float: none;
+		display: inline-block;
+		padding: 12px;
+	}
+
+	div#menu {
+		padding: 0;
+		min-width: 0;
+		text-align: left;
+		float: left;
+	}
+
+	div#menu > a {
+		display: block;
+		margin-left: 0;
+		margin-right: 0;
+	}
+
+	#menu .search-box {
+		display: flex;
+		width: 100%;
+	}
+
+	#menu-button {
+		display: inline-block;
+	}
+
+	p,
+	pre,
+	ul,
+	ol {
+		margin: 10px;
+	}
+
+	.pkg-synopsis {
+		display: none;
+	}
+
+	img.gopher {
+		display: none;
+	}
+}
+
+@media (max-width: 480px) {
+	#heading-wide {
+		display: none;
+	}
+	#heading-narrow {
+		display: block;
+	}
+}
+
+@media print {
+	pre {
+		background: #FFF;
+		border: 1px solid #BBB;
+		white-space: pre-wrap;
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/tab.go b/vendor/golang.org/x/tools/godoc/tab.go
new file mode 100644
index 0000000..d314ac7
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/tab.go
@@ -0,0 +1,82 @@
+// 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.
+
+// TODO(bradfitz,adg): move to util
+
+package godoc
+
+import "io"
+
+var spaces = []byte("                                ") // 32 spaces seems like a good number
+
+const (
+	indenting = iota
+	collecting
+)
+
+// A tconv is an io.Writer filter for converting leading tabs into spaces.
+type tconv struct {
+	output io.Writer
+	state  int // indenting or collecting
+	indent int // valid if state == indenting
+	p      *Presentation
+}
+
+func (p *tconv) writeIndent() (err error) {
+	i := p.indent
+	for i >= len(spaces) {
+		i -= len(spaces)
+		if _, err = p.output.Write(spaces); err != nil {
+			return
+		}
+	}
+	// i < len(spaces)
+	if i > 0 {
+		_, err = p.output.Write(spaces[0:i])
+	}
+	return
+}
+
+func (p *tconv) Write(data []byte) (n int, err error) {
+	if len(data) == 0 {
+		return
+	}
+	pos := 0 // valid if p.state == collecting
+	var b byte
+	for n, b = range data {
+		switch p.state {
+		case indenting:
+			switch b {
+			case '\t':
+				p.indent += p.p.TabWidth
+			case '\n':
+				p.indent = 0
+				if _, err = p.output.Write(data[n : n+1]); err != nil {
+					return
+				}
+			case ' ':
+				p.indent++
+			default:
+				p.state = collecting
+				pos = n
+				if err = p.writeIndent(); err != nil {
+					return
+				}
+			}
+		case collecting:
+			if b == '\n' {
+				p.state = indenting
+				p.indent = 0
+				if _, err = p.output.Write(data[pos : n+1]); err != nil {
+					return
+				}
+			}
+		}
+	}
+	n = len(data)
+	if pos < n && p.state == collecting {
+		_, err = p.output.Write(data[pos:])
+	}
+	return
+}
diff --git a/vendor/golang.org/x/tools/godoc/template.go b/vendor/golang.org/x/tools/godoc/template.go
new file mode 100644
index 0000000..eda5874
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/template.go
@@ -0,0 +1,179 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Template support for writing HTML documents.
+// Documents that include Template: true in their
+// metadata are executed as input to text/template.
+//
+// This file defines functions for those templates to invoke.
+
+// The template uses the function "code" to inject program
+// source into the output by extracting code from files and
+// injecting them as HTML-escaped <pre> blocks.
+//
+// The syntax is simple: 1, 2, or 3 space-separated arguments:
+//
+// Whole file:
+//	{{code "foo.go"}}
+// One line (here the signature of main):
+//	{{code "foo.go" `/^func.main/`}}
+// Block of text, determined by start and end (here the body of main):
+//	{{code "foo.go" `/^func.main/` `/^}/`
+//
+// Patterns can be `/regular expression/`, a decimal number, or "$"
+// to signify the end of the file. In multi-line matches,
+// lines that end with the four characters
+//	OMIT
+// are omitted from the output, making it easy to provide marker
+// lines in the input that will not appear in the output but are easy
+// to identify by pattern.
+
+package godoc
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"regexp"
+	"strings"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// Functions in this file panic on error, but the panic is recovered
+// to an error by 'code'.
+
+// contents reads and returns the content of the named file
+// (from the virtual file system, so for example /doc refers to $GOROOT/doc).
+func (c *Corpus) contents(name string) string {
+	file, err := vfs.ReadFile(c.fs, name)
+	if err != nil {
+		log.Panic(err)
+	}
+	return string(file)
+}
+
+// stringFor returns a textual representation of the arg, formatted according to its nature.
+func stringFor(arg interface{}) string {
+	switch arg := arg.(type) {
+	case int:
+		return fmt.Sprintf("%d", arg)
+	case string:
+		if len(arg) > 2 && arg[0] == '/' && arg[len(arg)-1] == '/' {
+			return fmt.Sprintf("%#q", arg)
+		}
+		return fmt.Sprintf("%q", arg)
+	default:
+		log.Panicf("unrecognized argument: %v type %T", arg, arg)
+	}
+	return ""
+}
+
+func (p *Presentation) code(file string, arg ...interface{}) (s string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("%v", r)
+		}
+	}()
+
+	text := p.Corpus.contents(file)
+	var command string
+	switch len(arg) {
+	case 0:
+		// text is already whole file.
+		command = fmt.Sprintf("code %q", file)
+	case 1:
+		command = fmt.Sprintf("code %q %s", file, stringFor(arg[0]))
+		text = p.Corpus.oneLine(file, text, arg[0])
+	case 2:
+		command = fmt.Sprintf("code %q %s %s", file, stringFor(arg[0]), stringFor(arg[1]))
+		text = p.Corpus.multipleLines(file, text, arg[0], arg[1])
+	default:
+		return "", fmt.Errorf("incorrect code invocation: code %q %q", file, arg)
+	}
+	// Trim spaces from output.
+	text = strings.Trim(text, "\n")
+	// Replace tabs by spaces, which work better in HTML.
+	text = strings.Replace(text, "\t", "    ", -1)
+	var buf bytes.Buffer
+	// HTML-escape text and syntax-color comments like elsewhere.
+	FormatText(&buf, []byte(text), -1, true, "", nil)
+	// Include the command as a comment.
+	text = fmt.Sprintf("<pre><!--{{%s}}\n-->%s</pre>", command, buf.Bytes())
+	return text, nil
+}
+
+// parseArg returns the integer or string value of the argument and tells which it is.
+func parseArg(arg interface{}, file string, max int) (ival int, sval string, isInt bool) {
+	switch n := arg.(type) {
+	case int:
+		if n <= 0 || n > max {
+			log.Panicf("%q:%d is out of range", file, n)
+		}
+		return n, "", true
+	case string:
+		return 0, n, false
+	}
+	log.Panicf("unrecognized argument %v type %T", arg, arg)
+	return
+}
+
+// oneLine returns the single line generated by a two-argument code invocation.
+func (c *Corpus) oneLine(file, text string, arg interface{}) string {
+	lines := strings.SplitAfter(c.contents(file), "\n")
+	line, pattern, isInt := parseArg(arg, file, len(lines))
+	if isInt {
+		return lines[line-1]
+	}
+	return lines[match(file, 0, lines, pattern)-1]
+}
+
+// multipleLines returns the text generated by a three-argument code invocation.
+func (c *Corpus) multipleLines(file, text string, arg1, arg2 interface{}) string {
+	lines := strings.SplitAfter(c.contents(file), "\n")
+	line1, pattern1, isInt1 := parseArg(arg1, file, len(lines))
+	line2, pattern2, isInt2 := parseArg(arg2, file, len(lines))
+	if !isInt1 {
+		line1 = match(file, 0, lines, pattern1)
+	}
+	if !isInt2 {
+		line2 = match(file, line1, lines, pattern2)
+	} else if line2 < line1 {
+		log.Panicf("lines out of order for %q: %d %d", text, line1, line2)
+	}
+	for k := line1 - 1; k < line2; k++ {
+		if strings.HasSuffix(lines[k], "OMIT\n") {
+			lines[k] = ""
+		}
+	}
+	return strings.Join(lines[line1-1:line2], "")
+}
+
+// match identifies the input line that matches the pattern in a code invocation.
+// If start>0, match lines starting there rather than at the beginning.
+// The return value is 1-indexed.
+func match(file string, start int, lines []string, pattern string) int {
+	// $ matches the end of the file.
+	if pattern == "$" {
+		if len(lines) == 0 {
+			log.Panicf("%q: empty file", file)
+		}
+		return len(lines)
+	}
+	// /regexp/ matches the line that matches the regexp.
+	if len(pattern) > 2 && pattern[0] == '/' && pattern[len(pattern)-1] == '/' {
+		re, err := regexp.Compile(pattern[1 : len(pattern)-1])
+		if err != nil {
+			log.Panic(err)
+		}
+		for i := start; i < len(lines); i++ {
+			if re.MatchString(lines[i]) {
+				return i + 1
+			}
+		}
+		log.Panicf("%s: no match for %#q", file, pattern)
+	}
+	log.Panicf("unrecognized pattern: %q", pattern)
+	return 0
+}
diff --git a/vendor/golang.org/x/tools/godoc/util/throttle.go b/vendor/golang.org/x/tools/godoc/util/throttle.go
new file mode 100644
index 0000000..53d9ba6
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/util/throttle.go
@@ -0,0 +1,88 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package util
+
+import "time"
+
+// A Throttle permits throttling of a goroutine by
+// calling the Throttle method repeatedly.
+//
+type Throttle struct {
+	f  float64       // f = (1-r)/r for 0 < r < 1
+	dt time.Duration // minimum run time slice; >= 0
+	tr time.Duration // accumulated time running
+	ts time.Duration // accumulated time stopped
+	tt time.Time     // earliest throttle time (= time Throttle returned + tm)
+}
+
+// NewThrottle creates a new Throttle with a throttle value r and
+// a minimum allocated run time slice of dt:
+//
+//	r == 0: "empty" throttle; the goroutine is always sleeping
+//	r == 1: full throttle; the goroutine is never sleeping
+//
+// A value of r == 0.6 throttles a goroutine such that it runs
+// approx. 60% of the time, and sleeps approx. 40% of the time.
+// Values of r < 0 or r > 1 are clamped down to values between 0 and 1.
+// Values of dt < 0 are set to 0.
+//
+func NewThrottle(r float64, dt time.Duration) *Throttle {
+	var f float64
+	switch {
+	case r <= 0:
+		f = -1 // indicates always sleep
+	case r >= 1:
+		f = 0 // assume r == 1 (never sleep)
+	default:
+		// 0 < r < 1
+		f = (1 - r) / r
+	}
+	if dt < 0 {
+		dt = 0
+	}
+	return &Throttle{f: f, dt: dt, tt: time.Now().Add(dt)}
+}
+
+// Throttle calls time.Sleep such that over time the ratio tr/ts between
+// accumulated run (tr) and sleep times (ts) approximates the value 1/(1-r)
+// where r is the throttle value. Throttle returns immediately (w/o sleeping)
+// if less than tm ns have passed since the last call to Throttle.
+//
+func (p *Throttle) Throttle() {
+	if p.f < 0 {
+		select {} // always sleep
+	}
+
+	t0 := time.Now()
+	if t0.Before(p.tt) {
+		return // keep running (minimum time slice not exhausted yet)
+	}
+
+	// accumulate running time
+	p.tr += t0.Sub(p.tt) + p.dt
+
+	// compute sleep time
+	// Over time we want:
+	//
+	//	tr/ts = r/(1-r)
+	//
+	// Thus:
+	//
+	//	ts = tr*f with f = (1-r)/r
+	//
+	// After some incremental run time δr added to the total run time
+	// tr, the incremental sleep-time δs to get to the same ratio again
+	// after waking up from time.Sleep is:
+	if δs := time.Duration(float64(p.tr)*p.f) - p.ts; δs > 0 {
+		time.Sleep(δs)
+	}
+
+	// accumulate (actual) sleep time
+	t1 := time.Now()
+	p.ts += t1.Sub(t0)
+
+	// set earliest next throttle time
+	p.tt = t1.Add(p.dt)
+}
diff --git a/vendor/golang.org/x/tools/godoc/util/util.go b/vendor/golang.org/x/tools/godoc/util/util.go
new file mode 100644
index 0000000..feedb76
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/util/util.go
@@ -0,0 +1,89 @@
+// 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 util contains utility types and functions for godoc.
+package util // import "golang.org/x/tools/godoc/util"
+
+import (
+	pathpkg "path"
+	"sync"
+	"time"
+	"unicode/utf8"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// An RWValue wraps a value and permits mutually exclusive
+// access to it and records the time the value was last set.
+type RWValue struct {
+	mutex     sync.RWMutex
+	value     interface{}
+	timestamp time.Time // time of last set()
+}
+
+func (v *RWValue) Set(value interface{}) {
+	v.mutex.Lock()
+	v.value = value
+	v.timestamp = time.Now()
+	v.mutex.Unlock()
+}
+
+func (v *RWValue) Get() (interface{}, time.Time) {
+	v.mutex.RLock()
+	defer v.mutex.RUnlock()
+	return v.value, v.timestamp
+}
+
+// IsText reports whether a significant prefix of s looks like correct UTF-8;
+// that is, if it is likely that s is human-readable text.
+func IsText(s []byte) bool {
+	const max = 1024 // at least utf8.UTFMax
+	if len(s) > max {
+		s = s[0:max]
+	}
+	for i, c := range string(s) {
+		if i+utf8.UTFMax > len(s) {
+			// last char may be incomplete - ignore
+			break
+		}
+		if c == 0xFFFD || c < ' ' && c != '\n' && c != '\t' && c != '\f' {
+			// decoding error or control character - not a text file
+			return false
+		}
+	}
+	return true
+}
+
+// textExt[x] is true if the extension x indicates a text file, and false otherwise.
+var textExt = map[string]bool{
+	".css": false, // must be served raw
+	".js":  false, // must be served raw
+}
+
+// IsTextFile reports whether the file has a known extension indicating
+// a text file, or if a significant chunk of the specified file looks like
+// correct UTF-8; that is, if it is likely that the file contains human-
+// readable text.
+func IsTextFile(fs vfs.Opener, filename string) bool {
+	// if the extension is known, use it for decision making
+	if isText, found := textExt[pathpkg.Ext(filename)]; found {
+		return isText
+	}
+
+	// the extension is not known; read an initial chunk
+	// of the file and check if it looks like text
+	f, err := fs.Open(filename)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+
+	var buf [1024]byte
+	n, err := f.Read(buf[0:])
+	if err != nil {
+		return false
+	}
+
+	return IsText(buf[0:n])
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/emptyvfs.go b/vendor/golang.org/x/tools/godoc/vfs/emptyvfs.go
new file mode 100644
index 0000000..01b6942
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/emptyvfs.go
@@ -0,0 +1,85 @@
+// 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 vfs
+
+import (
+	"fmt"
+	"os"
+	"time"
+)
+
+// NewNameSpace returns a NameSpace pre-initialized with an empty
+// emulated directory mounted on the root mount point "/". This
+// allows directory traversal routines to work properly even if
+// a folder is not explicitly mounted at root by the user.
+func NewNameSpace() NameSpace {
+	ns := NameSpace{}
+	ns.Bind("/", &emptyVFS{}, "/", BindReplace)
+	return ns
+}
+
+// type emptyVFS emulates a FileSystem consisting of an empty directory
+type emptyVFS struct{}
+
+// Open implements Opener. Since emptyVFS is an empty directory, all
+// attempts to open a file should returns errors.
+func (e *emptyVFS) Open(path string) (ReadSeekCloser, error) {
+	if path == "/" {
+		return nil, fmt.Errorf("open: / is a directory")
+	}
+	return nil, os.ErrNotExist
+}
+
+// Stat returns os.FileInfo  for an empty directory if the path is
+// is root "/" or error. os.FileInfo is implemented by emptyVFS
+func (e *emptyVFS) Stat(path string) (os.FileInfo, error) {
+	if path == "/" {
+		return e, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (e *emptyVFS) Lstat(path string) (os.FileInfo, error) {
+	return e.Stat(path)
+}
+
+// ReadDir returns an empty os.FileInfo slice for "/", else error.
+func (e *emptyVFS) ReadDir(path string) ([]os.FileInfo, error) {
+	if path == "/" {
+		return []os.FileInfo{}, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (e *emptyVFS) String() string {
+	return "emptyVFS(/)"
+}
+
+// These functions below implement os.FileInfo for the single
+// empty emulated directory.
+
+func (e *emptyVFS) Name() string {
+	return "/"
+}
+
+func (e *emptyVFS) Size() int64 {
+	return 0
+}
+
+func (e *emptyVFS) Mode() os.FileMode {
+	return os.ModeDir | os.ModePerm
+}
+
+func (e *emptyVFS) ModTime() time.Time {
+	return time.Time{}
+}
+
+func (e *emptyVFS) IsDir() bool {
+	return true
+}
+
+func (e *emptyVFS) Sys() interface{} {
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/emptyvfs_test.go b/vendor/golang.org/x/tools/godoc/vfs/emptyvfs_test.go
new file mode 100644
index 0000000..8ea9b01
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/emptyvfs_test.go
@@ -0,0 +1,58 @@
+// 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 vfs_test
+
+import (
+	"testing"
+	"time"
+
+	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/godoc/vfs/mapfs"
+)
+
+func TestNewNameSpace(t *testing.T) {
+
+	// We will mount this filesystem under /fs1
+	mount := mapfs.New(map[string]string{"fs1file": "abcdefgh"})
+
+	// Existing process. This should give error on Stat("/")
+	t1 := vfs.NameSpace{}
+	t1.Bind("/fs1", mount, "/", vfs.BindReplace)
+
+	// using NewNameSpace. This should work fine.
+	t2 := vfs.NewNameSpace()
+	t2.Bind("/fs1", mount, "/", vfs.BindReplace)
+
+	testcases := map[string][]bool{
+		"/":            {false, true},
+		"/fs1":         {true, true},
+		"/fs1/fs1file": {true, true},
+	}
+
+	fss := []vfs.FileSystem{t1, t2}
+
+	for j, fs := range fss {
+		for k, v := range testcases {
+			_, err := fs.Stat(k)
+			result := err == nil
+			if result != v[j] {
+				t.Errorf("fs: %d, testcase: %s, want: %v, got: %v, err: %s", j, k, v[j], result, err)
+			}
+		}
+	}
+
+	fi, err := t2.Stat("/")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if fi.Name() != "/" {
+		t.Errorf("t2.Name() : want:%s got:%s", "/", fi.Name())
+	}
+
+	if !fi.ModTime().IsZero() {
+		t.Errorf("t2.Modime() : want:%v got:%v", time.Time{}, fi.ModTime())
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/gatefs/gatefs.go b/vendor/golang.org/x/tools/godoc/vfs/gatefs/gatefs.go
new file mode 100644
index 0000000..7045a5c
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/gatefs/gatefs.go
@@ -0,0 +1,89 @@
+// 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 gatefs provides an implementation of the FileSystem
+// interface that wraps another FileSystem and limits its concurrency.
+package gatefs // import "golang.org/x/tools/godoc/vfs/gatefs"
+
+import (
+	"fmt"
+	"os"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// New returns a new FileSystem that delegates to fs.
+// If gateCh is non-nil and buffered, it's used as a gate
+// to limit concurrency on calls to fs.
+func New(fs vfs.FileSystem, gateCh chan bool) vfs.FileSystem {
+	if cap(gateCh) == 0 {
+		return fs
+	}
+	return gatefs{fs, gate(gateCh)}
+}
+
+type gate chan bool
+
+func (g gate) enter() { g <- true }
+func (g gate) leave() { <-g }
+
+type gatefs struct {
+	fs vfs.FileSystem
+	gate
+}
+
+func (fs gatefs) String() string {
+	return fmt.Sprintf("gated(%s, %d)", fs.fs.String(), cap(fs.gate))
+}
+
+func (fs gatefs) Open(p string) (vfs.ReadSeekCloser, error) {
+	fs.enter()
+	defer fs.leave()
+	rsc, err := fs.fs.Open(p)
+	if err != nil {
+		return nil, err
+	}
+	return gatef{rsc, fs.gate}, nil
+}
+
+func (fs gatefs) Lstat(p string) (os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.Lstat(p)
+}
+
+func (fs gatefs) Stat(p string) (os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.Stat(p)
+}
+
+func (fs gatefs) ReadDir(p string) ([]os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.ReadDir(p)
+}
+
+type gatef struct {
+	rsc vfs.ReadSeekCloser
+	gate
+}
+
+func (f gatef) Read(p []byte) (n int, err error) {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Read(p)
+}
+
+func (f gatef) Seek(offset int64, whence int) (ret int64, err error) {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Seek(offset, whence)
+}
+
+func (f gatef) Close() error {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Close()
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/httpfs/httpfs.go b/vendor/golang.org/x/tools/godoc/vfs/httpfs/httpfs.go
new file mode 100644
index 0000000..f232f03
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/httpfs/httpfs.go
@@ -0,0 +1,94 @@
+// 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 httpfs implements http.FileSystem using a godoc vfs.FileSystem.
+package httpfs // import "golang.org/x/tools/godoc/vfs/httpfs"
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+func New(fs vfs.FileSystem) http.FileSystem {
+	return &httpFS{fs}
+}
+
+type httpFS struct {
+	fs vfs.FileSystem
+}
+
+func (h *httpFS) Open(name string) (http.File, error) {
+	fi, err := h.fs.Stat(name)
+	if err != nil {
+		return nil, err
+	}
+	if fi.IsDir() {
+		return &httpDir{h.fs, name, nil}, nil
+	}
+	f, err := h.fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return &httpFile{h.fs, f, name}, nil
+}
+
+// httpDir implements http.File for a directory in a FileSystem.
+type httpDir struct {
+	fs      vfs.FileSystem
+	name    string
+	pending []os.FileInfo
+}
+
+func (h *httpDir) Close() error               { return nil }
+func (h *httpDir) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
+func (h *httpDir) Read([]byte) (int, error) {
+	return 0, fmt.Errorf("cannot Read from directory %s", h.name)
+}
+
+func (h *httpDir) Seek(offset int64, whence int) (int64, error) {
+	if offset == 0 && whence == 0 {
+		h.pending = nil
+		return 0, nil
+	}
+	return 0, fmt.Errorf("unsupported Seek in directory %s", h.name)
+}
+
+func (h *httpDir) Readdir(count int) ([]os.FileInfo, error) {
+	if h.pending == nil {
+		d, err := h.fs.ReadDir(h.name)
+		if err != nil {
+			return nil, err
+		}
+		if d == nil {
+			d = []os.FileInfo{} // not nil
+		}
+		h.pending = d
+	}
+
+	if len(h.pending) == 0 && count > 0 {
+		return nil, io.EOF
+	}
+	if count <= 0 || count > len(h.pending) {
+		count = len(h.pending)
+	}
+	d := h.pending[:count]
+	h.pending = h.pending[count:]
+	return d, nil
+}
+
+// httpFile implements http.File for a file (not directory) in a FileSystem.
+type httpFile struct {
+	fs vfs.FileSystem
+	vfs.ReadSeekCloser
+	name string
+}
+
+func (h *httpFile) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
+func (h *httpFile) Readdir(int) ([]os.FileInfo, error) {
+	return nil, fmt.Errorf("cannot Readdir from file %s", h.name)
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs.go b/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs.go
new file mode 100644
index 0000000..660b1ca
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs.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 mapfs file provides an implementation of the FileSystem
+// interface based on the contents of a map[string]string.
+package mapfs // import "golang.org/x/tools/godoc/vfs/mapfs"
+
+import (
+	"io"
+	"os"
+	pathpkg "path"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// New returns a new FileSystem from the provided map.
+// Map keys should be forward slash-separated pathnames
+// and not contain a leading slash.
+func New(m map[string]string) vfs.FileSystem {
+	return mapFS(m)
+}
+
+// mapFS is the map based implementation of FileSystem
+type mapFS map[string]string
+
+func (fs mapFS) String() string { return "mapfs" }
+
+func (fs mapFS) Close() error { return nil }
+
+func filename(p string) string {
+	return strings.TrimPrefix(p, "/")
+}
+
+func (fs mapFS) Open(p string) (vfs.ReadSeekCloser, error) {
+	b, ok := fs[filename(p)]
+	if !ok {
+		return nil, os.ErrNotExist
+	}
+	return nopCloser{strings.NewReader(b)}, nil
+}
+
+func fileInfo(name, contents string) os.FileInfo {
+	return mapFI{name: pathpkg.Base(name), size: len(contents)}
+}
+
+func dirInfo(name string) os.FileInfo {
+	return mapFI{name: pathpkg.Base(name), dir: true}
+}
+
+func (fs mapFS) Lstat(p string) (os.FileInfo, error) {
+	b, ok := fs[filename(p)]
+	if ok {
+		return fileInfo(p, b), nil
+	}
+	ents, _ := fs.ReadDir(p)
+	if len(ents) > 0 {
+		return dirInfo(p), nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (fs mapFS) Stat(p string) (os.FileInfo, error) {
+	return fs.Lstat(p)
+}
+
+// slashdir returns path.Dir(p), but special-cases paths not beginning
+// with a slash to be in the root.
+func slashdir(p string) string {
+	d := pathpkg.Dir(p)
+	if d == "." {
+		return "/"
+	}
+	if strings.HasPrefix(p, "/") {
+		return d
+	}
+	return "/" + d
+}
+
+func (fs mapFS) ReadDir(p string) ([]os.FileInfo, error) {
+	p = pathpkg.Clean(p)
+	var ents []string
+	fim := make(map[string]os.FileInfo) // base -> fi
+	for fn, b := range fs {
+		dir := slashdir(fn)
+		isFile := true
+		var lastBase string
+		for {
+			if dir == p {
+				base := lastBase
+				if isFile {
+					base = pathpkg.Base(fn)
+				}
+				if fim[base] == nil {
+					var fi os.FileInfo
+					if isFile {
+						fi = fileInfo(fn, b)
+					} else {
+						fi = dirInfo(base)
+					}
+					ents = append(ents, base)
+					fim[base] = fi
+				}
+			}
+			if dir == "/" {
+				break
+			} else {
+				isFile = false
+				lastBase = pathpkg.Base(dir)
+				dir = pathpkg.Dir(dir)
+			}
+		}
+	}
+	if len(ents) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	sort.Strings(ents)
+	var list []os.FileInfo
+	for _, dir := range ents {
+		list = append(list, fim[dir])
+	}
+	return list, nil
+}
+
+// mapFI is the map-based implementation of FileInfo.
+type mapFI struct {
+	name string
+	size int
+	dir  bool
+}
+
+func (fi mapFI) IsDir() bool        { return fi.dir }
+func (fi mapFI) ModTime() time.Time { return time.Time{} }
+func (fi mapFI) Mode() os.FileMode {
+	if fi.IsDir() {
+		return 0755 | os.ModeDir
+	}
+	return 0444
+}
+func (fi mapFI) Name() string     { return pathpkg.Base(fi.name) }
+func (fi mapFI) Size() int64      { return int64(fi.size) }
+func (fi mapFI) Sys() interface{} { return nil }
+
+type nopCloser struct {
+	io.ReadSeeker
+}
+
+func (nc nopCloser) Close() error { return nil }
diff --git a/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs_test.go b/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs_test.go
new file mode 100644
index 0000000..6b7db29
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/mapfs/mapfs_test.go
@@ -0,0 +1,111 @@
+// 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 mapfs
+
+import (
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestOpenRoot(t *testing.T) {
+	fs := New(map[string]string{
+		"foo/bar/three.txt": "a",
+		"foo/bar.txt":       "b",
+		"top.txt":           "c",
+		"other-top.txt":     "d",
+	})
+	tests := []struct {
+		path string
+		want string
+	}{
+		{"/foo/bar/three.txt", "a"},
+		{"foo/bar/three.txt", "a"},
+		{"foo/bar.txt", "b"},
+		{"top.txt", "c"},
+		{"/top.txt", "c"},
+		{"other-top.txt", "d"},
+		{"/other-top.txt", "d"},
+	}
+	for _, tt := range tests {
+		rsc, err := fs.Open(tt.path)
+		if err != nil {
+			t.Errorf("Open(%q) = %v", tt.path, err)
+			continue
+		}
+		slurp, err := ioutil.ReadAll(rsc)
+		if err != nil {
+			t.Error(err)
+		}
+		if string(slurp) != tt.want {
+			t.Errorf("Read(%q) = %q; want %q", tt.path, tt.want, slurp)
+		}
+		rsc.Close()
+	}
+
+	_, err := fs.Open("/xxxx")
+	if !os.IsNotExist(err) {
+		t.Errorf("ReadDir /xxxx = %v; want os.IsNotExist error", err)
+	}
+}
+
+func TestReaddir(t *testing.T) {
+	fs := New(map[string]string{
+		"foo/bar/three.txt": "333",
+		"foo/bar.txt":       "22",
+		"top.txt":           "top.txt file",
+		"other-top.txt":     "other-top.txt file",
+	})
+	tests := []struct {
+		dir  string
+		want []os.FileInfo
+	}{
+		{
+			dir: "/",
+			want: []os.FileInfo{
+				mapFI{name: "foo", dir: true},
+				mapFI{name: "other-top.txt", size: len("other-top.txt file")},
+				mapFI{name: "top.txt", size: len("top.txt file")},
+			},
+		},
+		{
+			dir: "/foo",
+			want: []os.FileInfo{
+				mapFI{name: "bar", dir: true},
+				mapFI{name: "bar.txt", size: 2},
+			},
+		},
+		{
+			dir: "/foo/",
+			want: []os.FileInfo{
+				mapFI{name: "bar", dir: true},
+				mapFI{name: "bar.txt", size: 2},
+			},
+		},
+		{
+			dir: "/foo/bar",
+			want: []os.FileInfo{
+				mapFI{name: "three.txt", size: 3},
+			},
+		},
+	}
+	for _, tt := range tests {
+		fis, err := fs.ReadDir(tt.dir)
+		if err != nil {
+			t.Errorf("ReadDir(%q) = %v", tt.dir, err)
+			continue
+		}
+		if !reflect.DeepEqual(fis, tt.want) {
+			t.Errorf("ReadDir(%q) = %#v; want %#v", tt.dir, fis, tt.want)
+			continue
+		}
+	}
+
+	_, err := fs.ReadDir("/xxxx")
+	if !os.IsNotExist(err) {
+		t.Errorf("ReadDir /xxxx = %v; want os.IsNotExist error", err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/namespace.go b/vendor/golang.org/x/tools/godoc/vfs/namespace.go
new file mode 100644
index 0000000..ca1213e
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/namespace.go
@@ -0,0 +1,389 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vfs
+
+import (
+	"fmt"
+	"io"
+	"os"
+	pathpkg "path"
+	"sort"
+	"strings"
+	"time"
+)
+
+// Setting debugNS = true will enable debugging prints about
+// name space translations.
+const debugNS = false
+
+// A NameSpace is a file system made up of other file systems
+// mounted at specific locations in the name space.
+//
+// The representation is a map from mount point locations
+// to the list of file systems mounted at that location.  A traditional
+// Unix mount table would use a single file system per mount point,
+// but we want to be able to mount multiple file systems on a single
+// mount point and have the system behave as if the union of those
+// file systems were present at the mount point.
+// For example, if the OS file system has a Go installation in
+// c:\Go and additional Go path trees in  d:\Work1 and d:\Work2, then
+// this name space creates the view we want for the godoc server:
+//
+//	NameSpace{
+//		"/": {
+//			{old: "/", fs: OS(`c:\Go`), new: "/"},
+//		},
+//		"/src/pkg": {
+//			{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//			{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//			{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//		},
+//	}
+//
+// This is created by executing:
+//
+//	ns := NameSpace{}
+//	ns.Bind("/", OS(`c:\Go`), "/", BindReplace)
+//	ns.Bind("/src/pkg", OS(`d:\Work1`), "/src", BindAfter)
+//	ns.Bind("/src/pkg", OS(`d:\Work2`), "/src", BindAfter)
+//
+// A particular mount point entry is a triple (old, fs, new), meaning that to
+// operate on a path beginning with old, replace that prefix (old) with new
+// and then pass that path to the FileSystem implementation fs.
+//
+// If you do not explicitly mount a FileSystem at the root mountpoint "/" of the
+// NameSpace like above, Stat("/") will return a "not found" error which could
+// break typical directory traversal routines. In such cases, use NewNameSpace()
+// to get a NameSpace pre-initialized with an emulated empty directory at root.
+//
+// Given this name space, a ReadDir of /src/pkg/code will check each prefix
+// of the path for a mount point (first /src/pkg/code, then /src/pkg, then /src,
+// then /), stopping when it finds one.  For the above example, /src/pkg/code
+// will find the mount point at /src/pkg:
+//
+//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//
+// ReadDir will when execute these three calls and merge the results:
+//
+//	OS(`c:\Go`).ReadDir("/src/pkg/code")
+//	OS(`d:\Work1').ReadDir("/src/code")
+//	OS(`d:\Work2').ReadDir("/src/code")
+//
+// Note that the "/src/pkg" in "/src/pkg/code" has been replaced by
+// just "/src" in the final two calls.
+//
+// OS is itself an implementation of a file system: it implements
+// OS(`c:\Go`).ReadDir("/src/pkg/code") as ioutil.ReadDir(`c:\Go\src\pkg\code`).
+//
+// Because the new path is evaluated by fs (here OS(root)), another way
+// to read the mount table is to mentally combine fs+new, so that this table:
+//
+//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//
+// reads as:
+//
+//	"/src/pkg" -> c:\Go\src\pkg
+//	"/src/pkg" -> d:\Work1\src
+//	"/src/pkg" -> d:\Work2\src
+//
+// An invariant (a redundancy) of the name space representation is that
+// ns[mtpt][i].old is always equal to mtpt (in the example, ns["/src/pkg"]'s
+// mount table entries always have old == "/src/pkg").  The 'old' field is
+// useful to callers, because they receive just a []mountedFS and not any
+// other indication of which mount point was found.
+//
+type NameSpace map[string][]mountedFS
+
+// A mountedFS handles requests for path by replacing
+// a prefix 'old' with 'new' and then calling the fs methods.
+type mountedFS struct {
+	old string
+	fs  FileSystem
+	new string
+}
+
+// hasPathPrefix returns true if x == y or x == y + "/" + more
+func hasPathPrefix(x, y string) bool {
+	return x == y || strings.HasPrefix(x, y) && (strings.HasSuffix(y, "/") || strings.HasPrefix(x[len(y):], "/"))
+}
+
+// translate translates path for use in m, replacing old with new.
+//
+// mountedFS{"/src/pkg", fs, "/src"}.translate("/src/pkg/code") == "/src/code".
+func (m mountedFS) translate(path string) string {
+	path = pathpkg.Clean("/" + path)
+	if !hasPathPrefix(path, m.old) {
+		panic("translate " + path + " but old=" + m.old)
+	}
+	return pathpkg.Join(m.new, path[len(m.old):])
+}
+
+func (NameSpace) String() string {
+	return "ns"
+}
+
+// Fprint writes a text representation of the name space to w.
+func (ns NameSpace) Fprint(w io.Writer) {
+	fmt.Fprint(w, "name space {\n")
+	var all []string
+	for mtpt := range ns {
+		all = append(all, mtpt)
+	}
+	sort.Strings(all)
+	for _, mtpt := range all {
+		fmt.Fprintf(w, "\t%s:\n", mtpt)
+		for _, m := range ns[mtpt] {
+			fmt.Fprintf(w, "\t\t%s %s\n", m.fs, m.new)
+		}
+	}
+	fmt.Fprint(w, "}\n")
+}
+
+// clean returns a cleaned, rooted path for evaluation.
+// It canonicalizes the path so that we can use string operations
+// to analyze it.
+func (NameSpace) clean(path string) string {
+	return pathpkg.Clean("/" + path)
+}
+
+type BindMode int
+
+const (
+	BindReplace BindMode = iota
+	BindBefore
+	BindAfter
+)
+
+// Bind causes references to old to redirect to the path new in newfs.
+// If mode is BindReplace, old redirections are discarded.
+// If mode is BindBefore, this redirection takes priority over existing ones,
+// but earlier ones are still consulted for paths that do not exist in newfs.
+// If mode is BindAfter, this redirection happens only after existing ones
+// have been tried and failed.
+func (ns NameSpace) Bind(old string, newfs FileSystem, new string, mode BindMode) {
+	old = ns.clean(old)
+	new = ns.clean(new)
+	m := mountedFS{old, newfs, new}
+	var mtpt []mountedFS
+	switch mode {
+	case BindReplace:
+		mtpt = append(mtpt, m)
+	case BindAfter:
+		mtpt = append(mtpt, ns.resolve(old)...)
+		mtpt = append(mtpt, m)
+	case BindBefore:
+		mtpt = append(mtpt, m)
+		mtpt = append(mtpt, ns.resolve(old)...)
+	}
+
+	// Extend m.old, m.new in inherited mount point entries.
+	for i := range mtpt {
+		m := &mtpt[i]
+		if m.old != old {
+			if !hasPathPrefix(old, m.old) {
+				// This should not happen.  If it does, panic so
+				// that we can see the call trace that led to it.
+				panic(fmt.Sprintf("invalid Bind: old=%q m={%q, %s, %q}", old, m.old, m.fs.String(), m.new))
+			}
+			suffix := old[len(m.old):]
+			m.old = pathpkg.Join(m.old, suffix)
+			m.new = pathpkg.Join(m.new, suffix)
+		}
+	}
+
+	ns[old] = mtpt
+}
+
+// resolve resolves a path to the list of mountedFS to use for path.
+func (ns NameSpace) resolve(path string) []mountedFS {
+	path = ns.clean(path)
+	for {
+		if m := ns[path]; m != nil {
+			if debugNS {
+				fmt.Printf("resolve %s: %v\n", path, m)
+			}
+			return m
+		}
+		if path == "/" {
+			break
+		}
+		path = pathpkg.Dir(path)
+	}
+	return nil
+}
+
+// Open implements the FileSystem Open method.
+func (ns NameSpace) Open(path string) (ReadSeekCloser, error) {
+	var err error
+	for _, m := range ns.resolve(path) {
+		if debugNS {
+			fmt.Printf("tx %s: %v\n", path, m.translate(path))
+		}
+		tp := m.translate(path)
+		r, err1 := m.fs.Open(tp)
+		if err1 == nil {
+			return r, nil
+		}
+		// IsNotExist errors in overlay FSes can mask real errors in
+		// the underlying FS, so ignore them if there is another error.
+		if err == nil || os.IsNotExist(err) {
+			err = err1
+		}
+	}
+	if err == nil {
+		err = &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
+	}
+	return nil, err
+}
+
+// stat implements the FileSystem Stat and Lstat methods.
+func (ns NameSpace) stat(path string, f func(FileSystem, string) (os.FileInfo, error)) (os.FileInfo, error) {
+	var err error
+	for _, m := range ns.resolve(path) {
+		fi, err1 := f(m.fs, m.translate(path))
+		if err1 == nil {
+			return fi, nil
+		}
+		if err == nil {
+			err = err1
+		}
+	}
+	if err == nil {
+		err = &os.PathError{Op: "stat", Path: path, Err: os.ErrNotExist}
+	}
+	return nil, err
+}
+
+func (ns NameSpace) Stat(path string) (os.FileInfo, error) {
+	return ns.stat(path, FileSystem.Stat)
+}
+
+func (ns NameSpace) Lstat(path string) (os.FileInfo, error) {
+	return ns.stat(path, FileSystem.Lstat)
+}
+
+// dirInfo is a trivial implementation of os.FileInfo for a directory.
+type dirInfo string
+
+func (d dirInfo) Name() string       { return string(d) }
+func (d dirInfo) Size() int64        { return 0 }
+func (d dirInfo) Mode() os.FileMode  { return os.ModeDir | 0555 }
+func (d dirInfo) ModTime() time.Time { return startTime }
+func (d dirInfo) IsDir() bool        { return true }
+func (d dirInfo) Sys() interface{}   { return nil }
+
+var startTime = time.Now()
+
+// ReadDir implements the FileSystem ReadDir method.  It's where most of the magic is.
+// (The rest is in resolve.)
+//
+// Logically, ReadDir must return the union of all the directories that are named
+// by path.  In order to avoid misinterpreting Go packages, of all the directories
+// that contain Go source code, we only include the files from the first,
+// but we include subdirectories from all.
+//
+// ReadDir must also return directory entries needed to reach mount points.
+// If the name space looks like the example in the type NameSpace comment,
+// but c:\Go does not have a src/pkg subdirectory, we still want to be able
+// to find that subdirectory, because we've mounted d:\Work1 and d:\Work2
+// there.  So if we don't see "src" in the directory listing for c:\Go, we add an
+// entry for it before returning.
+//
+func (ns NameSpace) ReadDir(path string) ([]os.FileInfo, error) {
+	path = ns.clean(path)
+
+	var (
+		haveGo   = false
+		haveName = map[string]bool{}
+		all      []os.FileInfo
+		err      error
+		first    []os.FileInfo
+	)
+
+	for _, m := range ns.resolve(path) {
+		dir, err1 := m.fs.ReadDir(m.translate(path))
+		if err1 != nil {
+			if err == nil {
+				err = err1
+			}
+			continue
+		}
+
+		if dir == nil {
+			dir = []os.FileInfo{}
+		}
+
+		if first == nil {
+			first = dir
+		}
+
+		// If we don't yet have Go files in 'all' and this directory
+		// has some, add all the files from this directory.
+		// Otherwise, only add subdirectories.
+		useFiles := false
+		if !haveGo {
+			for _, d := range dir {
+				if strings.HasSuffix(d.Name(), ".go") {
+					useFiles = true
+					haveGo = true
+					break
+				}
+			}
+		}
+
+		for _, d := range dir {
+			name := d.Name()
+			if (d.IsDir() || useFiles) && !haveName[name] {
+				haveName[name] = true
+				all = append(all, d)
+			}
+		}
+	}
+
+	// We didn't find any directories containing Go files.
+	// If some directory returned successfully, use that.
+	if !haveGo {
+		for _, d := range first {
+			if !haveName[d.Name()] {
+				haveName[d.Name()] = true
+				all = append(all, d)
+			}
+		}
+	}
+
+	// Built union.  Add any missing directories needed to reach mount points.
+	for old := range ns {
+		if hasPathPrefix(old, path) && old != path {
+			// Find next element after path in old.
+			elem := old[len(path):]
+			elem = strings.TrimPrefix(elem, "/")
+			if i := strings.Index(elem, "/"); i >= 0 {
+				elem = elem[:i]
+			}
+			if !haveName[elem] {
+				haveName[elem] = true
+				all = append(all, dirInfo(elem))
+			}
+		}
+	}
+
+	if len(all) == 0 {
+		return nil, err
+	}
+
+	sort.Sort(byName(all))
+	return all, nil
+}
+
+// byName implements sort.Interface.
+type byName []os.FileInfo
+
+func (f byName) Len() int           { return len(f) }
+func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
+func (f byName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
diff --git a/vendor/golang.org/x/tools/godoc/vfs/os.go b/vendor/golang.org/x/tools/godoc/vfs/os.go
new file mode 100644
index 0000000..fa98142
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/os.go
@@ -0,0 +1,65 @@
+// 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 vfs
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	pathpkg "path"
+	"path/filepath"
+)
+
+// OS returns an implementation of FileSystem reading from the
+// tree rooted at root.  Recording a root is convenient everywhere
+// but necessary on Windows, because the slash-separated path
+// passed to Open has no way to specify a drive letter.  Using a root
+// lets code refer to OS(`c:\`), OS(`d:\`) and so on.
+func OS(root string) FileSystem {
+	return osFS(root)
+}
+
+type osFS string
+
+func (root osFS) String() string { return "os(" + string(root) + ")" }
+
+func (root osFS) resolve(path string) string {
+	// Clean the path so that it cannot possibly begin with ../.
+	// If it did, the result of filepath.Join would be outside the
+	// tree rooted at root.  We probably won't ever see a path
+	// with .. in it, but be safe anyway.
+	path = pathpkg.Clean("/" + path)
+
+	return filepath.Join(string(root), path)
+}
+
+func (root osFS) Open(path string) (ReadSeekCloser, error) {
+	f, err := os.Open(root.resolve(path))
+	if err != nil {
+		return nil, err
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	if fi.IsDir() {
+		f.Close()
+		return nil, fmt.Errorf("Open: %s is a directory", path)
+	}
+	return f, nil
+}
+
+func (root osFS) Lstat(path string) (os.FileInfo, error) {
+	return os.Lstat(root.resolve(path))
+}
+
+func (root osFS) Stat(path string) (os.FileInfo, error) {
+	return os.Stat(root.resolve(path))
+}
+
+func (root osFS) ReadDir(path string) ([]os.FileInfo, error) {
+	return ioutil.ReadDir(root.resolve(path)) // is sorted
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/vfs.go b/vendor/golang.org/x/tools/godoc/vfs/vfs.go
new file mode 100644
index 0000000..ad06b1a
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/vfs.go
@@ -0,0 +1,45 @@
+// 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 vfs defines types for abstract file system access and provides an
+// implementation accessing the file system of the underlying OS.
+package vfs // import "golang.org/x/tools/godoc/vfs"
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+)
+
+// The FileSystem interface specifies the methods godoc is using
+// to access the file system for which it serves documentation.
+type FileSystem interface {
+	Opener
+	Lstat(path string) (os.FileInfo, error)
+	Stat(path string) (os.FileInfo, error)
+	ReadDir(path string) ([]os.FileInfo, error)
+	String() string
+}
+
+// Opener is a minimal virtual filesystem that can only open regular files.
+type Opener interface {
+	Open(name string) (ReadSeekCloser, error)
+}
+
+// A ReadSeekCloser can Read, Seek, and Close.
+type ReadSeekCloser interface {
+	io.Reader
+	io.Seeker
+	io.Closer
+}
+
+// ReadFile reads the file named by path from fs and returns the contents.
+func ReadFile(fs Opener, path string) ([]byte, error) {
+	rc, err := fs.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	return ioutil.ReadAll(rc)
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs.go b/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs.go
new file mode 100644
index 0000000..e554446
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs.go
@@ -0,0 +1,264 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package zipfs file provides an implementation of the FileSystem
+// interface based on the contents of a .zip file.
+//
+// Assumptions:
+//
+// - The file paths stored in the zip file must use a slash ('/') as path
+//   separator; and they must be relative (i.e., they must not start with
+//   a '/' - this is usually the case if the file was created w/o special
+//   options).
+// - The zip file system treats the file paths found in the zip internally
+//   like absolute paths w/o a leading '/'; i.e., the paths are considered
+//   relative to the root of the file system.
+// - All path arguments to file system methods must be absolute paths.
+package zipfs // import "golang.org/x/tools/godoc/vfs/zipfs"
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+// zipFI is the zip-file based implementation of FileInfo
+type zipFI struct {
+	name string    // directory-local name
+	file *zip.File // nil for a directory
+}
+
+func (fi zipFI) Name() string {
+	return fi.name
+}
+
+func (fi zipFI) Size() int64 {
+	if f := fi.file; f != nil {
+		return int64(f.UncompressedSize)
+	}
+	return 0 // directory
+}
+
+func (fi zipFI) ModTime() time.Time {
+	if f := fi.file; f != nil {
+		return f.ModTime()
+	}
+	return time.Time{} // directory has no modified time entry
+}
+
+func (fi zipFI) Mode() os.FileMode {
+	if fi.file == nil {
+		// Unix directories typically are executable, hence 555.
+		return os.ModeDir | 0555
+	}
+	return 0444
+}
+
+func (fi zipFI) IsDir() bool {
+	return fi.file == nil
+}
+
+func (fi zipFI) Sys() interface{} {
+	return nil
+}
+
+// zipFS is the zip-file based implementation of FileSystem
+type zipFS struct {
+	*zip.ReadCloser
+	list zipList
+	name string
+}
+
+func (fs *zipFS) String() string {
+	return "zip(" + fs.name + ")"
+}
+
+func (fs *zipFS) Close() error {
+	fs.list = nil
+	return fs.ReadCloser.Close()
+}
+
+func zipPath(name string) (string, error) {
+	name = path.Clean(name)
+	if !path.IsAbs(name) {
+		return "", fmt.Errorf("stat: not an absolute path: %s", name)
+	}
+	return name[1:], nil // strip leading '/'
+}
+
+func isRoot(abspath string) bool {
+	return path.Clean(abspath) == "/"
+}
+
+func (fs *zipFS) stat(abspath string) (int, zipFI, error) {
+	if isRoot(abspath) {
+		return 0, zipFI{
+			name: "",
+			file: nil,
+		}, nil
+	}
+	zippath, err := zipPath(abspath)
+	if err != nil {
+		return 0, zipFI{}, err
+	}
+	i, exact := fs.list.lookup(zippath)
+	if i < 0 {
+		// zippath has leading '/' stripped - print it explicitly
+		return -1, zipFI{}, &os.PathError{Path: "/" + zippath, Err: os.ErrNotExist}
+	}
+	_, name := path.Split(zippath)
+	var file *zip.File
+	if exact {
+		file = fs.list[i] // exact match found - must be a file
+	}
+	return i, zipFI{name, file}, nil
+}
+
+func (fs *zipFS) Open(abspath string) (vfs.ReadSeekCloser, error) {
+	_, fi, err := fs.stat(abspath)
+	if err != nil {
+		return nil, err
+	}
+	if fi.IsDir() {
+		return nil, fmt.Errorf("Open: %s is a directory", abspath)
+	}
+	r, err := fi.file.Open()
+	if err != nil {
+		return nil, err
+	}
+	return &zipSeek{fi.file, r}, nil
+}
+
+type zipSeek struct {
+	file *zip.File
+	io.ReadCloser
+}
+
+func (f *zipSeek) Seek(offset int64, whence int) (int64, error) {
+	if whence == 0 && offset == 0 {
+		r, err := f.file.Open()
+		if err != nil {
+			return 0, err
+		}
+		f.Close()
+		f.ReadCloser = r
+		return 0, nil
+	}
+	return 0, fmt.Errorf("unsupported Seek in %s", f.file.Name)
+}
+
+func (fs *zipFS) Lstat(abspath string) (os.FileInfo, error) {
+	_, fi, err := fs.stat(abspath)
+	return fi, err
+}
+
+func (fs *zipFS) Stat(abspath string) (os.FileInfo, error) {
+	_, fi, err := fs.stat(abspath)
+	return fi, err
+}
+
+func (fs *zipFS) ReadDir(abspath string) ([]os.FileInfo, error) {
+	i, fi, err := fs.stat(abspath)
+	if err != nil {
+		return nil, err
+	}
+	if !fi.IsDir() {
+		return nil, fmt.Errorf("ReadDir: %s is not a directory", abspath)
+	}
+
+	var list []os.FileInfo
+
+	// make dirname the prefix that file names must start with to be considered
+	// in this directory. we must special case the root directory because, per
+	// the spec of this package, zip file entries MUST NOT start with /, so we
+	// should not append /, as we would in every other case.
+	var dirname string
+	if isRoot(abspath) {
+		dirname = ""
+	} else {
+		zippath, err := zipPath(abspath)
+		if err != nil {
+			return nil, err
+		}
+		dirname = zippath + "/"
+	}
+	prevname := ""
+	for _, e := range fs.list[i:] {
+		if !strings.HasPrefix(e.Name, dirname) {
+			break // not in the same directory anymore
+		}
+		name := e.Name[len(dirname):] // local name
+		file := e
+		if i := strings.IndexRune(name, '/'); i >= 0 {
+			// We infer directories from files in subdirectories.
+			// If we have x/y, return a directory entry for x.
+			name = name[0:i] // keep local directory name only
+			file = nil
+		}
+		// If we have x/y and x/z, don't return two directory entries for x.
+		// TODO(gri): It should be possible to do this more efficiently
+		// by determining the (fs.list) range of local directory entries
+		// (via two binary searches).
+		if name != prevname {
+			list = append(list, zipFI{name, file})
+			prevname = name
+		}
+	}
+
+	return list, nil
+}
+
+func New(rc *zip.ReadCloser, name string) vfs.FileSystem {
+	list := make(zipList, len(rc.File))
+	copy(list, rc.File) // sort a copy of rc.File
+	sort.Sort(list)
+	return &zipFS{rc, list, name}
+}
+
+type zipList []*zip.File
+
+// zipList implements sort.Interface
+func (z zipList) Len() int           { return len(z) }
+func (z zipList) Less(i, j int) bool { return z[i].Name < z[j].Name }
+func (z zipList) Swap(i, j int)      { z[i], z[j] = z[j], z[i] }
+
+// lookup returns the smallest index of an entry with an exact match
+// for name, or an inexact match starting with name/. If there is no
+// such entry, the result is -1, false.
+func (z zipList) lookup(name string) (index int, exact bool) {
+	// look for exact match first (name comes before name/ in z)
+	i := sort.Search(len(z), func(i int) bool {
+		return name <= z[i].Name
+	})
+	if i >= len(z) {
+		return -1, false
+	}
+	// 0 <= i < len(z)
+	if z[i].Name == name {
+		return i, true
+	}
+
+	// look for inexact match (must be in z[i:], if present)
+	z = z[i:]
+	name += "/"
+	j := sort.Search(len(z), func(i int) bool {
+		return name <= z[i].Name
+	})
+	if j >= len(z) {
+		return -1, false
+	}
+	// 0 <= j < len(z)
+	if strings.HasPrefix(z[j].Name, name) {
+		return i + j, false
+	}
+
+	return -1, false
+}
diff --git a/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs_test.go b/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs_test.go
new file mode 100644
index 0000000..19407e4
--- /dev/null
+++ b/vendor/golang.org/x/tools/godoc/vfs/zipfs/zipfs_test.go
@@ -0,0 +1,189 @@
+// 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 zipfs
+package zipfs
+
+import (
+	"archive/zip"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/godoc/vfs"
+)
+
+var (
+
+	// files to use to build zip used by zipfs in testing; maps path : contents
+	files = map[string]string{"foo": "foo", "bar/baz": "baz", "a/b/c": "c"}
+
+	// expected info for each entry in a file system described by files
+	tests = []struct {
+		Path      string
+		IsDir     bool
+		IsRegular bool
+		Name      string
+		Contents  string
+		Files     map[string]bool
+	}{
+		{"/", true, false, "", "", map[string]bool{"foo": true, "bar": true, "a": true}},
+		{"//", true, false, "", "", map[string]bool{"foo": true, "bar": true, "a": true}},
+		{"/foo", false, true, "foo", "foo", nil},
+		{"/foo/", false, true, "foo", "foo", nil},
+		{"/foo//", false, true, "foo", "foo", nil},
+		{"/bar", true, false, "bar", "", map[string]bool{"baz": true}},
+		{"/bar/", true, false, "bar", "", map[string]bool{"baz": true}},
+		{"/bar/baz", false, true, "baz", "baz", nil},
+		{"//bar//baz", false, true, "baz", "baz", nil},
+		{"/a/b", true, false, "b", "", map[string]bool{"c": true}},
+	}
+
+	// to be initialized in setup()
+	fs        vfs.FileSystem
+	statFuncs []statFunc
+)
+
+type statFunc struct {
+	Name string
+	Func func(string) (os.FileInfo, error)
+}
+
+func TestMain(t *testing.M) {
+	if err := setup(); err != nil {
+		fmt.Fprintf(os.Stderr, "Error setting up zipfs testing state: %v.\n", err)
+		os.Exit(1)
+	}
+	os.Exit(t.Run())
+}
+
+// setups state each of the tests uses
+func setup() error {
+	// create zipfs
+	b := new(bytes.Buffer)
+	zw := zip.NewWriter(b)
+	for file, contents := range files {
+		w, err := zw.Create(file)
+		if err != nil {
+			return err
+		}
+		_, err = io.WriteString(w, contents)
+		if err != nil {
+			return err
+		}
+	}
+	zw.Close()
+	zr, err := zip.NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
+	if err != nil {
+		return err
+	}
+	rc := &zip.ReadCloser{
+		Reader: *zr,
+	}
+	fs = New(rc, "foo")
+
+	// pull out different stat functions
+	statFuncs = []statFunc{
+		{"Stat", fs.Stat},
+		{"Lstat", fs.Lstat},
+	}
+
+	return nil
+}
+
+func TestZipFSReadDir(t *testing.T) {
+	for _, test := range tests {
+		if test.IsDir {
+			infos, err := fs.ReadDir(test.Path)
+			if err != nil {
+				t.Errorf("Failed to read directory %v\n", test.Path)
+				continue
+			}
+			got := make(map[string]bool)
+			for _, info := range infos {
+				got[info.Name()] = true
+			}
+			if want := test.Files; !reflect.DeepEqual(got, want) {
+				t.Errorf("ReadDir %v got %v\nwanted %v\n", test.Path, got, want)
+			}
+		}
+	}
+}
+
+func TestZipFSStatFuncs(t *testing.T) {
+	for _, test := range tests {
+		for _, statFunc := range statFuncs {
+
+			// test can stat
+			info, err := statFunc.Func(test.Path)
+			if err != nil {
+				t.Errorf("Unexpected error using %v for %v: %v\n", statFunc.Name, test.Path, err)
+				continue
+			}
+
+			// test info.Name()
+			if got, want := info.Name(), test.Name; got != want {
+				t.Errorf("Using %v for %v info.Name() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
+			}
+			// test info.IsDir()
+			if got, want := info.IsDir(), test.IsDir; got != want {
+				t.Errorf("Using %v for %v info.IsDir() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
+			}
+			// test info.Mode().IsDir()
+			if got, want := info.Mode().IsDir(), test.IsDir; got != want {
+				t.Errorf("Using %v for %v info.Mode().IsDir() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
+			}
+			// test info.Mode().IsRegular()
+			if got, want := info.Mode().IsRegular(), test.IsRegular; got != want {
+				t.Errorf("Using %v for %v info.Mode().IsRegular() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
+			}
+			// test info.Size()
+			if test.IsRegular {
+				if got, want := info.Size(), int64(len(test.Contents)); got != want {
+					t.Errorf("Using %v for %v inf.Size() got %v wanted %v", statFunc.Name, test.Path, got, want)
+				}
+			}
+		}
+	}
+}
+
+func TestZipFSNotExist(t *testing.T) {
+	_, err := fs.Open("/does-not-exist")
+	if err == nil {
+		t.Fatalf("Expected an error.\n")
+	}
+	if !os.IsNotExist(err) {
+		t.Errorf("Expected an error satisfying os.IsNotExist: %v\n", err)
+	}
+}
+
+func TestZipFSOpenSeek(t *testing.T) {
+	for _, test := range tests {
+		if test.IsRegular {
+
+			// test Open()
+			f, err := fs.Open(test.Path)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			defer f.Close()
+
+			// test Seek() multiple times
+			for i := 0; i < 3; i++ {
+				all, err := ioutil.ReadAll(f)
+				if err != nil {
+					t.Error(err)
+					return
+				}
+				if got, want := string(all), test.Contents; got != want {
+					t.Errorf("File contents for %v got %v wanted %v\n", test.Path, got, want)
+				}
+				f.Seek(0, 0)
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk.go b/vendor/golang.org/x/tools/imports/fastwalk.go
new file mode 100644
index 0000000..31e6e27
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk.go
@@ -0,0 +1,187 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// A faster implementation of filepath.Walk.
+//
+// filepath.Walk's design necessarily calls os.Lstat on each file,
+// even if the caller needs less info. And goimports only need to know
+// the type of each file. The kernel interface provides the type in
+// the Readdir call but the standard library ignored it.
+// fastwalk_unix.go contains a fork of the syscall routines.
+//
+// See golang.org/issue/16399
+
+package imports
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+// traverseLink is a sentinel error for fastWalk, similar to filepath.SkipDir.
+var traverseLink = errors.New("traverse symlink, assuming target is a directory")
+
+// fastWalk walks the file tree rooted at root, calling walkFn for
+// each file or directory in the tree, including root.
+//
+// If fastWalk returns filepath.SkipDir, the directory is skipped.
+//
+// Unlike filepath.Walk:
+//   * file stat calls must be done by the user.
+//     The only provided metadata is the file type, which does not include
+//     any permission bits.
+//   * multiple goroutines stat the filesystem concurrently. The provided
+//     walkFn must be safe for concurrent use.
+//   * fastWalk can follow symlinks if walkFn returns the traverseLink
+//     sentinel error. It is the walkFn's responsibility to prevent
+//     fastWalk from going into symlink cycles.
+func fastWalk(root string, walkFn func(path string, typ os.FileMode) error) error {
+	// TODO(bradfitz): make numWorkers configurable? We used a
+	// minimum of 4 to give the kernel more info about multiple
+	// things we want, in hopes its I/O scheduling can take
+	// advantage of that. Hopefully most are in cache. Maybe 4 is
+	// even too low of a minimum. Profile more.
+	numWorkers := 4
+	if n := runtime.NumCPU(); n > numWorkers {
+		numWorkers = n
+	}
+
+	// Make sure to wait for all workers to finish, otherwise
+	// walkFn could still be called after returning. This Wait call
+	// runs after close(e.donec) below.
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	w := &walker{
+		fn:       walkFn,
+		enqueuec: make(chan walkItem, numWorkers), // buffered for performance
+		workc:    make(chan walkItem, numWorkers), // buffered for performance
+		donec:    make(chan struct{}),
+
+		// buffered for correctness & not leaking goroutines:
+		resc: make(chan error, numWorkers),
+	}
+	defer close(w.donec)
+
+	for i := 0; i < numWorkers; i++ {
+		wg.Add(1)
+		go w.doWork(&wg)
+	}
+	todo := []walkItem{{dir: root}}
+	out := 0
+	for {
+		workc := w.workc
+		var workItem walkItem
+		if len(todo) == 0 {
+			workc = nil
+		} else {
+			workItem = todo[len(todo)-1]
+		}
+		select {
+		case workc <- workItem:
+			todo = todo[:len(todo)-1]
+			out++
+		case it := <-w.enqueuec:
+			todo = append(todo, it)
+		case err := <-w.resc:
+			out--
+			if err != nil {
+				return err
+			}
+			if out == 0 && len(todo) == 0 {
+				// It's safe to quit here, as long as the buffered
+				// enqueue channel isn't also readable, which might
+				// happen if the worker sends both another unit of
+				// work and its result before the other select was
+				// scheduled and both w.resc and w.enqueuec were
+				// readable.
+				select {
+				case it := <-w.enqueuec:
+					todo = append(todo, it)
+				default:
+					return nil
+				}
+			}
+		}
+	}
+}
+
+// doWork reads directories as instructed (via workc) and runs the
+// user's callback function.
+func (w *walker) doWork(wg *sync.WaitGroup) {
+	defer wg.Done()
+	for {
+		select {
+		case <-w.donec:
+			return
+		case it := <-w.workc:
+			select {
+			case <-w.donec:
+				return
+			case w.resc <- w.walk(it.dir, !it.callbackDone):
+			}
+		}
+	}
+}
+
+type walker struct {
+	fn func(path string, typ os.FileMode) error
+
+	donec    chan struct{} // closed on fastWalk's return
+	workc    chan walkItem // to workers
+	enqueuec chan walkItem // from workers
+	resc     chan error    // from workers
+}
+
+type walkItem struct {
+	dir          string
+	callbackDone bool // callback already called; don't do it again
+}
+
+func (w *walker) enqueue(it walkItem) {
+	select {
+	case w.enqueuec <- it:
+	case <-w.donec:
+	}
+}
+
+func (w *walker) onDirEnt(dirName, baseName string, typ os.FileMode) error {
+	joined := dirName + string(os.PathSeparator) + baseName
+	if typ == os.ModeDir {
+		w.enqueue(walkItem{dir: joined})
+		return nil
+	}
+
+	err := w.fn(joined, typ)
+	if typ == os.ModeSymlink {
+		if err == traverseLink {
+			// Set callbackDone so we don't call it twice for both the
+			// symlink-as-symlink and the symlink-as-directory later:
+			w.enqueue(walkItem{dir: joined, callbackDone: true})
+			return nil
+		}
+		if err == filepath.SkipDir {
+			// Permit SkipDir on symlinks too.
+			return nil
+		}
+	}
+	return err
+}
+
+func (w *walker) walk(root string, runUserCallback bool) error {
+	if runUserCallback {
+		err := w.fn(root, os.ModeDir)
+		if err == filepath.SkipDir {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return readDir(root, w.onDirEnt)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go b/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go
new file mode 100644
index 0000000..f1fd649
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go
@@ -0,0 +1,13 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build freebsd openbsd netbsd
+
+package imports
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Fileno)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go b/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go
new file mode 100644
index 0000000..9fc6de0
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go
@@ -0,0 +1,14 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin
+// +build !appengine
+
+package imports
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Ino)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_portable.go b/vendor/golang.org/x/tools/imports/fastwalk_portable.go
new file mode 100644
index 0000000..6c26583
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/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 imports
+
+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/vendor/golang.org/x/tools/imports/fastwalk_test.go b/vendor/golang.org/x/tools/imports/fastwalk_test.go
new file mode 100644
index 0000000..5b307d1
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_test.go
@@ -0,0 +1,171 @@
+// 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 imports
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func formatFileModes(m map[string]os.FileMode) string {
+	var keys []string
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	var buf bytes.Buffer
+	for _, k := range keys {
+		fmt.Fprintf(&buf, "%-20s: %v\n", k, m[k])
+	}
+	return buf.String()
+}
+
+func testFastWalk(t *testing.T, files map[string]string, callback func(path string, typ os.FileMode) error, want map[string]os.FileMode) {
+	testConfig{
+		gopathFiles: files,
+	}.test(t, func(t *goimportTest) {
+		got := map[string]os.FileMode{}
+		var mu sync.Mutex
+		if err := fastWalk(t.gopath, func(path string, typ os.FileMode) error {
+			mu.Lock()
+			defer mu.Unlock()
+			if !strings.HasPrefix(path, t.gopath) {
+				t.Fatalf("bogus prefix on %q, expect %q", path, t.gopath)
+			}
+			key := filepath.ToSlash(strings.TrimPrefix(path, t.gopath))
+			if old, dup := got[key]; dup {
+				t.Fatalf("callback called twice for key %q: %v -> %v", key, old, typ)
+			}
+			got[key] = typ
+			return callback(path, typ)
+		}); err != nil {
+			t.Fatalf("callback returned: %v", err)
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("walk mismatch.\n got:\n%v\nwant:\n%v", formatFileModes(got), formatFileModes(want))
+		}
+	})
+}
+
+func TestFastWalk_Basic(t *testing.T) {
+	testFastWalk(t, map[string]string{
+		"foo/foo.go":   "one",
+		"bar/bar.go":   "two",
+		"skip/skip.go": "skip",
+	},
+		func(path string, typ os.FileMode) error {
+			return nil
+		},
+		map[string]os.FileMode{
+			"":                  os.ModeDir,
+			"/src":              os.ModeDir,
+			"/src/bar":          os.ModeDir,
+			"/src/bar/bar.go":   0,
+			"/src/foo":          os.ModeDir,
+			"/src/foo/foo.go":   0,
+			"/src/skip":         os.ModeDir,
+			"/src/skip/skip.go": 0,
+		})
+}
+
+func TestFastWalk_Symlink(t *testing.T) {
+	switch runtime.GOOS {
+	case "windows", "plan9":
+		t.Skipf("skipping on %s", runtime.GOOS)
+	}
+	testFastWalk(t, map[string]string{
+		"foo/foo.go": "one",
+		"bar/bar.go": "LINK:../foo.go",
+		"symdir":     "LINK:foo",
+	},
+		func(path string, typ os.FileMode) error {
+			return nil
+		},
+		map[string]os.FileMode{
+			"":                os.ModeDir,
+			"/src":            os.ModeDir,
+			"/src/bar":        os.ModeDir,
+			"/src/bar/bar.go": os.ModeSymlink,
+			"/src/foo":        os.ModeDir,
+			"/src/foo/foo.go": 0,
+			"/src/symdir":     os.ModeSymlink,
+		})
+}
+
+func TestFastWalk_SkipDir(t *testing.T) {
+	testFastWalk(t, map[string]string{
+		"foo/foo.go":   "one",
+		"bar/bar.go":   "two",
+		"skip/skip.go": "skip",
+	},
+		func(path string, typ os.FileMode) error {
+			if typ == os.ModeDir && strings.HasSuffix(path, "skip") {
+				return filepath.SkipDir
+			}
+			return nil
+		},
+		map[string]os.FileMode{
+			"":                os.ModeDir,
+			"/src":            os.ModeDir,
+			"/src/bar":        os.ModeDir,
+			"/src/bar/bar.go": 0,
+			"/src/foo":        os.ModeDir,
+			"/src/foo/foo.go": 0,
+			"/src/skip":       os.ModeDir,
+		})
+}
+
+func TestFastWalk_TraverseSymlink(t *testing.T) {
+	switch runtime.GOOS {
+	case "windows", "plan9":
+		t.Skipf("skipping on %s", runtime.GOOS)
+	}
+
+	testFastWalk(t, map[string]string{
+		"foo/foo.go":   "one",
+		"bar/bar.go":   "two",
+		"skip/skip.go": "skip",
+		"symdir":       "LINK:foo",
+	},
+		func(path string, typ os.FileMode) error {
+			if typ == os.ModeSymlink {
+				return traverseLink
+			}
+			return nil
+		},
+		map[string]os.FileMode{
+			"":                   os.ModeDir,
+			"/src":               os.ModeDir,
+			"/src/bar":           os.ModeDir,
+			"/src/bar/bar.go":    0,
+			"/src/foo":           os.ModeDir,
+			"/src/foo/foo.go":    0,
+			"/src/skip":          os.ModeDir,
+			"/src/skip/skip.go":  0,
+			"/src/symdir":        os.ModeSymlink,
+			"/src/symdir/foo.go": 0,
+		})
+}
+
+var benchDir = flag.String("benchdir", runtime.GOROOT(), "The directory to scan for BenchmarkFastWalk")
+
+func BenchmarkFastWalk(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		err := fastWalk(*benchDir, func(path string, typ os.FileMode) error { return nil })
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_unix.go b/vendor/golang.org/x/tools/imports/fastwalk_unix.go
new file mode 100644
index 0000000..e0fc8b7
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_unix.go
@@ -0,0 +1,123 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin freebsd openbsd netbsd
+// +build !appengine
+
+package imports
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const blockSize = 8 << 10
+
+// unknownFileMode is a sentinel (and bogus) os.FileMode
+// value used to represent a syscall.DT_UNKNOWN Dirent.Type.
+const unknownFileMode os.FileMode = os.ModeNamedPipe | os.ModeSocket | os.ModeDevice
+
+func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
+	fd, err := syscall.Open(dirName, 0, 0)
+	if err != nil {
+		return &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/vendor/golang.org/x/tools/imports/fix.go b/vendor/golang.org/x/tools/imports/fix.go
index 22fde6c..d792a78 100644
--- a/vendor/golang.org/x/tools/imports/fix.go
+++ b/vendor/golang.org/x/tools/imports/fix.go
@@ -5,23 +5,56 @@
 package imports
 
 import (
+	"bufio"
+	"bytes"
 	"fmt"
 	"go/ast"
 	"go/build"
 	"go/parser"
 	"go/token"
+	"io/ioutil"
+	"log"
 	"os"
 	"path"
 	"path/filepath"
+	"sort"
 	"strings"
 	"sync"
 
 	"golang.org/x/tools/go/ast/astutil"
 )
 
+// Debug controls verbose logging.
+var Debug = false
+
+var (
+	inTests = false      // set true by fix_test.go; if false, no need to use testMu
+	testMu  sync.RWMutex // guards globals reset by tests; used only if inTests
+)
+
+// LocalPrefix 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) {
+				return 3, true
+			}
+		}
+		return
+	},
 	func(importPath string) (num int, ok bool) {
 		if strings.HasPrefix(importPath, "appengine") {
 			return 2, true
@@ -45,7 +78,120 @@ func importGroup(importPath string) int {
 	return 0
 }
 
-func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
+// 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")
@@ -54,6 +200,18 @@ func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
 	// 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 {
@@ -64,10 +222,14 @@ func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
 		case *ast.ImportSpec:
 			if v.Name != nil {
 				decls[v.Name.Name] = v
-			} else {
-				local := importPathToName(strings.Trim(v.Path.Value, `\"`))
-				decls[local] = 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 {
@@ -81,7 +243,11 @@ func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
 			if refs[pkgName] == nil {
 				refs[pkgName] = make(map[string]bool)
 			}
-			if decls[pkgName] == nil {
+			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
 			}
 		}
@@ -89,20 +255,65 @@ func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
 	})
 	ast.Walk(visitor, f)
 
+	// Nil out any unused ImportSpecs, to be removed in following passes
+	unusedImport := map[string]string{}
+	for pkg, is := range decls {
+		if refs[pkg] == nil && pkg != "_" && pkg != "." {
+			name := ""
+			if is.Name != nil {
+				name = is.Name.Name
+			}
+			unusedImport[strings.Trim(is.Path.Value, `"`)] = name
+		}
+	}
+	for ipath, name := range unusedImport {
+		if ipath == "C" {
+			// Don't remove cgo stuff.
+			continue
+		}
+		astutil.DeleteNamedImport(fset, f, name, ipath)
+	}
+
+	for pkgName, symbols := range refs {
+		if len(symbols) == 0 {
+			// skip over packages already imported
+			delete(refs, pkgName)
+		}
+	}
+
+	// Fast path, all references already imported.
+	if len(refs) == 0 {
+		return nil, nil
+	}
+
+	// Can assume this will be necessary in all cases now.
+	if !loadedPackageInfo {
+		packageInfo, _ = dirPackageInfo(f.Name.Name, srcDir, filename)
+	}
+
 	// Search for imports matching potential package references.
 	searches := 0
 	type result struct {
-		ipath string
-		name  string
+		ipath string // import path (if err == nil)
+		name  string // optional name to rename import as
 		err   error
 	}
 	results := make(chan result)
 	for pkgName, symbols := range refs {
-		if len(symbols) == 0 {
-			continue // skip over packages already imported
-		}
 		go func(pkgName string, symbols map[string]bool) {
-			ipath, rename, err := findImport(pkgName, symbols)
+			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(pkgName, symbols, filename)
 			r := result{ipath: ipath, err: err}
 			if rename {
 				r.name = pkgName
@@ -126,190 +337,491 @@ func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
 		}
 	}
 
-	// Nil out any unused ImportSpecs, to be removed in following passes
-	unusedImport := map[string]bool{}
-	for pkg, is := range decls {
-		if refs[pkg] == nil && pkg != "_" && pkg != "." {
-			unusedImport[strings.Trim(is.Path.Value, `"`)] = true
-		}
-	}
-	for ipath := range unusedImport {
-		if ipath == "C" {
-			// Don't remove cgo stuff.
-			continue
-		}
-		astutil.DeleteImport(fset, f, ipath)
-	}
-
 	return added, nil
 }
 
 // importPathToName returns the package name for the given import path.
-var importPathToName = importPathToNameGoPath
+var importPathToName func(importPath, srcDir string) (packageName string) = importPathToNameGoPath
 
 // importPathToNameBasic assumes the package name is the base of import path.
-func importPathToNameBasic(importPath string) (packageName string) {
+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 string) (packageName string) {
-	if buildPkg, err := build.Import(importPath, "", 0); err == nil {
-		return buildPkg.Name
-	} else {
-		return importPathToNameBasic(importPath)
+func importPathToNameGoPath(importPath, srcDir string) (packageName string) {
+	// Fast path for standard library without going to disk.
+	if pkg, ok := stdImportPackage[importPath]; ok {
+		return pkg
+	}
+
+	pkgName, err := importPathToNameGoPathParse(importPath, srcDir)
+	if Debug {
+		log.Printf("importPathToNameGoPathParse(%q, srcDir=%q) = %q, %v", importPath, srcDir, pkgName, err)
+	}
+	if err == nil {
+		return pkgName
+	}
+	return importPathToNameBasic(importPath, srcDir)
+}
+
+// importPathToNameGoPathParse is a faster version of build.Import if
+// the only thing desired is the package name. It uses build.FindOnly
+// to find the directory and then only parses one file in the package,
+// trusting that the files in the directory are consistent.
+func importPathToNameGoPathParse(importPath, srcDir string) (packageName string, err error) {
+	buildPkg, err := build.Import(importPath, srcDir, build.FindOnly)
+	if err != nil {
+		return "", err
+	}
+	d, err := os.Open(buildPkg.Dir)
+	if err != nil {
+		return "", err
+	}
+	names, err := d.Readdirnames(-1)
+	d.Close()
+	if err != nil {
+		return "", err
+	}
+	sort.Strings(names) // to have predictable behavior
+	var lastErr error
+	var nfile int
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".go") {
+			continue
+		}
+		if strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		nfile++
+		fullFile := filepath.Join(buildPkg.Dir, name)
+
+		fset := token.NewFileSet()
+		f, err := parser.ParseFile(fset, fullFile, nil, parser.PackageClauseOnly)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		pkgName := f.Name.Name
+		if pkgName == "documentation" {
+			// Special case from go/build.ImportDir, not
+			// handled by ctx.MatchFile.
+			continue
+		}
+		if pkgName == "main" {
+			// Also skip package main, assuming it's a +build ignore generator or example.
+			// Since you can't import a package main anyway, there's no harm here.
+			continue
+		}
+		return pkgName, nil
+	}
+	if lastErr != nil {
+		return "", lastErr
+	}
+	return "", fmt.Errorf("no importable package found in %d Go files", nfile)
+}
+
+var stdImportPackage = map[string]string{} // "net/http" => "http"
+
+func init() {
+	// Nothing in the standard library has a package name not
+	// matching its import base name.
+	for _, pkg := range stdlib {
+		if _, ok := stdImportPackage[pkg]; !ok {
+			stdImportPackage[pkg] = path.Base(pkg)
+		}
 	}
 }
 
+// Directory-scanning state.
+var (
+	// scanGoRootOnce guards calling scanGoRoot (for $GOROOT)
+	scanGoRootOnce sync.Once
+	// scanGoPathOnce guards calling scanGoPath (for $GOPATH)
+	scanGoPathOnce sync.Once
+
+	// populateIgnoreOnce guards calling populateIgnore
+	populateIgnoreOnce sync.Once
+	ignoredDirs        []os.FileInfo
+
+	dirScanMu sync.RWMutex
+	dirScan   map[string]*pkg // abs dir path => *pkg
+)
+
 type pkg struct {
-	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"
+	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")
+	distance        int    // relative distance to target
 }
 
-var pkgIndexOnce sync.Once
+// byDistanceOrImportPathShortLength sorts by relative distance breaking ties
+// on the short import path length and then the import string itself.
+type byDistanceOrImportPathShortLength []*pkg
 
-var pkgIndex struct {
-	sync.Mutex
-	m map[string][]pkg // shortname => []pkg, e.g "http" => "net/http"
+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].importPathShort, s[j].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
 }
 
-// gate is a semaphore for limiting concurrency.
-type gate chan struct{}
-
-func (g gate) enter() { g <- struct{}{} }
-func (g gate) leave() { <-g }
-
-// fsgate protects the OS & filesystem from too much concurrency.
-// Too much disk I/O -> too many threads -> swapping and bad scheduling.
-var fsgate = make(gate, 8)
-
-func loadPkgIndex() {
-	pkgIndex.Lock()
-	pkgIndex.m = make(map[string][]pkg)
-	pkgIndex.Unlock()
-
-	var wg sync.WaitGroup
-	for _, path := range build.Default.SrcDirs() {
-		fsgate.enter()
-		f, err := os.Open(path)
-		if err != nil {
-			fsgate.leave()
-			fmt.Fprint(os.Stderr, err)
+// guarded by populateIgnoreOnce; populates ignoredDirs.
+func populateIgnore() {
+	for _, srcDir := range build.Default.SrcDirs() {
+		if srcDir == filepath.Join(build.Default.GOROOT, "src") {
 			continue
 		}
-		children, err := f.Readdir(-1)
-		f.Close()
-		fsgate.leave()
+		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 {
-			fmt.Fprint(os.Stderr, err)
-			continue
-		}
-		for _, child := range children {
-			if child.IsDir() {
-				wg.Add(1)
-				go func(path, name string) {
-					defer wg.Done()
-					loadPkg(&wg, path, name)
-				}(path, child.Name())
-			}
+			log.Print(err)
+		} else {
+			log.Printf("Read %s", file)
 		}
 	}
-	wg.Wait()
-}
-
-func loadPkg(wg *sync.WaitGroup, root, pkgrelpath string) {
-	importpath := filepath.ToSlash(pkgrelpath)
-	dir := filepath.Join(root, importpath)
-
-	fsgate.enter()
-	defer fsgate.leave()
-	pkgDir, err := os.Open(dir)
 	if err != nil {
 		return
 	}
-	children, err := pkgDir.Readdir(-1)
-	pkgDir.Close()
-	if err != nil {
-		return
-	}
-	// hasGo tracks whether a directory actually appears to be a
-	// Go source code directory. If $GOPATH == $HOME, and
-	// $HOME/src has lots of other large non-Go projects in it,
-	// then the calls to importPathToName below can be expensive.
-	hasGo := false
-	for _, child := range children {
-		// Avoid .foo, _foo, and testdata directory trees.
-		name := child.Name()
-		if name == "" || name[0] == '.' || name[0] == '_' || name == "testdata" {
+	bs := bufio.NewScanner(bytes.NewReader(slurp))
+	for bs.Scan() {
+		line := strings.TrimSpace(bs.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
 			continue
 		}
-		if strings.HasSuffix(name, ".go") {
-			hasGo = true
-		}
-		if child.IsDir() {
-			wg.Add(1)
-			go func(root, name string) {
-				defer wg.Done()
-				loadPkg(wg, root, name)
-			}(root, filepath.Join(importpath, name))
+		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)
 		}
 	}
-	if hasGo {
-		shortName := importPathToName(importpath)
-		pkgIndex.Lock()
-		pkgIndex.m[shortName] = append(pkgIndex.m[shortName], pkg{
-			importpath: importpath,
-			dir:        dir,
-		})
-		pkgIndex.Unlock()
+}
+
+func skipDir(fi os.FileInfo) bool {
+	for _, ignoredDir := range ignoredDirs {
+		if os.SameFile(fi, ignoredDir) {
+			return true
+		}
+	}
+	return false
+}
+
+// shouldTraverse reports whether the symlink fi should, found in dir,
+// should be followed.  It makes sure symlinks were never visited
+// before to avoid symlink loops.
+func shouldTraverse(dir string, fi os.FileInfo) bool {
+	path := filepath.Join(dir, fi.Name())
+	target, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			fmt.Fprintln(os.Stderr, err)
+		}
+		return false
+	}
+	ts, err := os.Stat(target)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return false
+	}
+	if !ts.IsDir() {
+		return false
+	}
+	if skipDir(ts) {
+		return false
+	}
+	// Check for symlink loops by statting each directory component
+	// and seeing if any are the same file as ts.
+	for {
+		parent := filepath.Dir(path)
+		if parent == path {
+			// Made it to the root without seeing a cycle.
+			// Use this symlink.
+			return true
+		}
+		parentInfo, err := os.Stat(parent)
+		if err != nil {
+			return false
+		}
+		if os.SameFile(ts, parentInfo) {
+			// Cycle. Don't traverse.
+			return false
+		}
+		path = parent
 	}
 
 }
 
-// loadExports returns a list exports for a package.
-var loadExports = loadExportsGoPath
+var testHookScanDir = func(dir string) {}
 
-func loadExportsGoPath(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
+var scanGoRootDone = make(chan struct{}) // closed when scanGoRoot is done
+
+func scanGoRoot() {
+	go func() {
+		scanGoDirs(true)
+		close(scanGoRootDone)
+	}()
+}
+
+func scanGoPath() { scanGoDirs(false) }
+
+func scanGoDirs(goRoot bool) {
+	if Debug {
+		which := "$GOROOT"
+		if !goRoot {
+			which = "$GOPATH"
 		}
-		fmt.Fprintf(os.Stderr, "could not import %q: %v\n", dir, err)
-		return nil
+		log.Printf("scanning " + which)
+		defer log.Printf("scanned " + which)
 	}
-	fset := token.NewFileSet()
-	for _, files := range [...][]string{buildPkg.GoFiles, buildPkg.CgoFiles} {
-		for _, file := range files {
-			f, err := parser.ParseFile(fset, filepath.Join(dir, file), nil, 0)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "could not parse %q: %v\n", file, err)
-				continue
+	dirScanMu.Lock()
+	if dirScan == nil {
+		dirScan = make(map[string]*pkg)
+	}
+	dirScanMu.Unlock()
+
+	for _, srcDir := range build.Default.SrcDirs() {
+		isGoroot := srcDir == filepath.Join(build.Default.GOROOT, "src")
+		if isGoroot != goRoot {
+			continue
+		}
+		testHookScanDir(srcDir)
+		walkFn := func(path string, typ os.FileMode) error {
+			dir := filepath.Dir(path)
+			if typ.IsRegular() {
+				if dir == srcDir {
+					// Doesn't make sense to have regular files
+					// directly in your $GOPATH/src or $GOROOT/src.
+					return nil
+				}
+				if !strings.HasSuffix(path, ".go") {
+					return nil
+				}
+				dirScanMu.Lock()
+				if _, dup := dirScan[dir]; !dup {
+					importpath := filepath.ToSlash(dir[len(srcDir)+len("/"):])
+					dirScan[dir] = &pkg{
+						importPath:      importpath,
+						importPathShort: vendorlessImportPath(importpath),
+						dir:             dir,
+					}
+				}
+				dirScanMu.Unlock()
+				return nil
 			}
-			for name := range f.Scope.Objects {
-				if ast.IsExported(name) {
-					exports[name] = true
+			if typ == os.ModeDir {
+				base := filepath.Base(path)
+				if base == "" || base[0] == '.' || base[0] == '_' ||
+					base == "testdata" || base == "node_modules" {
+					return filepath.SkipDir
+				}
+				fi, err := os.Lstat(path)
+				if err == nil && skipDir(fi) {
+					if Debug {
+						log.Printf("skipping directory %q under %s", fi.Name(), dir)
+					}
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			if typ == os.ModeSymlink {
+				base := filepath.Base(path)
+				if strings.HasPrefix(base, ".#") {
+					// Emacs noise.
+					return nil
+				}
+				fi, err := os.Lstat(path)
+				if err != nil {
+					// Just ignore it.
+					return nil
+				}
+				if shouldTraverse(dir, fi) {
+					return traverseLink
 				}
 			}
+			return nil
 		}
+		if err := fastWalk(srcDir, walkFn); err != nil {
+			log.Printf("goimports: scanning directory %v: %v", srcDir, err)
+		}
+	}
+}
+
+// vendorlessImportPath returns the devendorized version of the provided import path.
+// e.g. "foo/bar/vendor/a/b" => "a/b"
+func vendorlessImportPath(ipath string) string {
+	// Devendorize for use in import statement.
+	if i := strings.LastIndex(ipath, "/vendor/"); i >= 0 {
+		return ipath[i+len("/vendor/"):]
+	}
+	if strings.HasPrefix(ipath, "vendor/") {
+		return ipath[len("vendor/"):]
+	}
+	return ipath
+}
+
+// loadExports returns the set of exported symbols in the package at dir.
+// It returns nil on error or if the package name in dir does not match expectPackage.
+var loadExports func(expectPackage, dir string) map[string]bool = loadExportsGoPath
+
+func loadExportsGoPath(expectPackage, dir string) map[string]bool {
+	if Debug {
+		log.Printf("loading exports in dir %s (seeking package %s)", dir, expectPackage)
+	}
+	exports := make(map[string]bool)
+
+	ctx := build.Default
+
+	// ReadDir is like ioutil.ReadDir, but only returns *.go files
+	// and filters out _test.go files since they're not relevant
+	// and only slow things down.
+	ctx.ReadDir = func(dir string) (notTests []os.FileInfo, err error) {
+		all, err := ioutil.ReadDir(dir)
+		if err != nil {
+			return nil, err
+		}
+		notTests = all[:0]
+		for _, fi := range all {
+			name := fi.Name()
+			if strings.HasSuffix(name, ".go") && !strings.HasSuffix(name, "_test.go") {
+				notTests = append(notTests, fi)
+			}
+		}
+		return notTests, nil
+	}
+
+	files, err := ctx.ReadDir(dir)
+	if err != nil {
+		log.Print(err)
+		return nil
+	}
+
+	fset := token.NewFileSet()
+
+	for _, fi := range files {
+		match, err := ctx.MatchFile(dir, fi.Name())
+		if err != nil || !match {
+			continue
+		}
+		fullFile := filepath.Join(dir, fi.Name())
+		f, err := parser.ParseFile(fset, fullFile, nil, 0)
+		if err != nil {
+			if Debug {
+				log.Printf("Parsing %s: %v", fullFile, err)
+			}
+			return nil
+		}
+		pkgName := f.Name.Name
+		if pkgName == "documentation" {
+			// Special case from go/build.ImportDir, not
+			// handled by ctx.MatchFile.
+			continue
+		}
+		if pkgName != expectPackage {
+			if Debug {
+				log.Printf("scan of dir %v is not expected package %v (actually %v)", dir, expectPackage, pkgName)
+			}
+			return nil
+		}
+		for name := range f.Scope.Objects {
+			if ast.IsExported(name) {
+				exports[name] = true
+			}
+		}
+	}
+
+	if Debug {
+		exportList := make([]string, 0, len(exports))
+		for k := range exports {
+			exportList = append(exportList, k)
+		}
+		sort.Strings(exportList)
+		log.Printf("loaded exports in dir %v (package %v): %v", dir, expectPackage, strings.Join(exportList, ", "))
 	}
 	return exports
 }
 
 // findImport searches for a package with the given symbols.
-// If no package is found, findImport returns "".
-// Declared as a variable rather than a function so goimports can be easily
-// extended by adding a file with an init function.
-var findImport = findImportGoPath
+// If no package is found, findImport returns ("", false, nil)
+//
+// This is declared as a variable rather than a function so goimports
+// can be easily extended by adding a file with an init function.
+//
+// The rename value tells goimports whether to use the package name as
+// a local qualifier in an import. For example, if findImports("pkg",
+// "X") returns ("foo/bar", rename=true), then goimports adds the
+// import line:
+// 	import pkg "foo/bar"
+// to satisfy uses of pkg.X in the file.
+var findImport func(pkgName string, symbols map[string]bool, filename string) (foundPkg string, rename bool, err error) = findImportGoPath
+
+// findImportGoPath is the normal implementation of findImport.
+// (Some companies have their own internally.)
+func findImportGoPath(pkgName string, symbols map[string]bool, filename string) (foundPkg string, rename bool, err error) {
+	if inTests {
+		testMu.RLock()
+		defer testMu.RUnlock()
+	}
+
+	pkgDir, err := filepath.Abs(filename)
+	if err != nil {
+		return "", false, err
+	}
+	pkgDir = filepath.Dir(pkgDir)
 
-func findImportGoPath(pkgName string, symbols map[string]bool) (string, bool, error) {
 	// Fast path for the standard library.
 	// In the common case we hopefully never have to scan the GOPATH, which can
 	// be slow with moving disks.
-	if pkg, rename, ok := findImportStdlib(pkgName, symbols); ok {
-		return pkg, rename, nil
+	if 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
@@ -317,52 +829,226 @@ func findImportGoPath(pkgName string, symbols map[string]bool) (string, bool, er
 	// 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.
 
-	pkgIndexOnce.Do(loadPkgIndex)
+	// Read all the $GOPATH/src/.goimportsignore files before scanning directories.
+	populateIgnoreOnce.Do(populateIgnore)
+
+	// Start scanning the $GOROOT asynchronously, then run the
+	// GOPATH scan synchronously if needed, and then wait for the
+	// $GOROOT to finish.
+	//
+	// TODO(bradfitz): run each $GOPATH entry async. But nobody
+	// really has more than one anyway, so low priority.
+	scanGoRootOnce.Do(scanGoRoot) // async
+	if !fileInDir(filename, build.Default.GOROOT) {
+		scanGoPathOnce.Do(scanGoPath) // blocking
+	}
+	<-scanGoRootDone
+
+	// Find candidate packages, looking only at their directory names first.
+	var candidates []*pkg
+	for _, pkg := range dirScan {
+		if pkgIsCandidate(filename, pkgName, pkg) {
+			pkg.distance = distance(pkgDir, pkg.dir)
+			candidates = append(candidates, pkg)
+		}
+	}
+
+	// Sort the candidates by their import package length,
+	// assuming that shorter package names are better than long
+	// ones.  Note that this sorts by the de-vendored name, so
+	// there's no "penalty" for vendoring.
+	sort.Sort(byDistanceOrImportPathShortLength(candidates))
+	if Debug {
+		for i, pkg := range candidates {
+			log.Printf("%s candidate %d/%d: %v in %v", pkgName, i+1, len(candidates), pkg.importPathShort, pkg.dir)
+		}
+	}
 
 	// Collect exports for packages with matching names.
-	var wg sync.WaitGroup
-	var pkgsMu sync.Mutex // guards pkgs
-	// full importpath => exported symbol => True
-	// e.g. "net/http" => "Client" => True
-	pkgs := make(map[string]map[string]bool)
-	pkgIndex.Lock()
-	for _, pkg := range pkgIndex.m[pkgName] {
-		wg.Add(1)
-		go func(importpath, dir string) {
-			defer wg.Done()
-			exports := loadExports(dir)
-			if exports != nil {
-				pkgsMu.Lock()
-				pkgs[importpath] = exports
-				pkgsMu.Unlock()
-			}
-		}(pkg.importpath, pkg.dir)
-	}
-	pkgIndex.Unlock()
-	wg.Wait()
 
-	// Filter out packages missing required exported symbols.
-	for symbol := range symbols {
-		for importpath, exports := range pkgs {
-			if !exports[symbol] {
-				delete(pkgs, importpath)
+	done := make(chan struct{}) // closed when we find the answer
+	defer close(done)
+
+	rescv := make([]chan *pkg, len(candidates))
+	for i := range candidates {
+		rescv[i] = make(chan *pkg)
+	}
+	const maxConcurrentPackageImport = 4
+	loadExportsSem := make(chan struct{}, maxConcurrentPackageImport)
+
+	go func() {
+		for i, pkg := range candidates {
+			select {
+			case loadExportsSem <- struct{}{}:
+				select {
+				case <-done:
+					return
+				default:
+				}
+			case <-done:
+				return
+			}
+			pkg := pkg
+			resc := rescv[i]
+			go func() {
+				if inTests {
+					testMu.RLock()
+					defer testMu.RUnlock()
+				}
+				defer func() { <-loadExportsSem }()
+				exports := loadExports(pkgName, pkg.dir)
+
+				// If it doesn't have the right
+				// symbols, send nil to mean no match.
+				for symbol := range symbols {
+					if !exports[symbol] {
+						pkg = nil
+						break
+					}
+				}
+				select {
+				case resc <- pkg:
+				case <-done:
+				}
+			}()
+		}
+	}()
+	for _, resc := range rescv {
+		pkg := <-resc
+		if pkg == nil {
+			continue
+		}
+		// If the package name in the source doesn't match the import path's base,
+		// return true so the rewriter adds a name (import foo "github.com/bar/go-foo")
+		needsRename := path.Base(pkg.importPath) != pkgName
+		return pkg.importPathShort, needsRename, nil
+	}
+	return "", false, nil
+}
+
+// pkgIsCandidate reports whether pkg is a candidate for satisfying the
+// finding which package pkgIdent in the file named by filename is trying
+// to refer to.
+//
+// This check is purely lexical and is meant to be as fast as possible
+// because it's run over all $GOPATH directories to filter out poor
+// candidates in order to limit the CPU and I/O later parsing the
+// exports in candidate packages.
+//
+// filename is the file being formatted.
+// pkgIdent is the package being searched for, like "client" (if
+// searching for "client.New")
+func pkgIsCandidate(filename, pkgIdent string, pkg *pkg) bool {
+	// Check "internal" and "vendor" visibility:
+	if !canUse(filename, pkg.dir) {
+		return false
+	}
+
+	// Speed optimization to minimize disk I/O:
+	// the last two components on disk must contain the
+	// package name somewhere.
+	//
+	// This permits mismatch naming like directory
+	// "go-foo" being package "foo", or "pkg.v3" being "pkg",
+	// or directory "google.golang.org/api/cloudbilling/v1"
+	// being package "cloudbilling", but doesn't
+	// permit a directory "foo" to be package
+	// "bar", which is strongly discouraged
+	// anyway. There's no reason goimports needs
+	// to be slow just to accomodate that.
+	lastTwo := lastTwoComponents(pkg.importPathShort)
+	if strings.Contains(lastTwo, pkgIdent) {
+		return true
+	}
+	if hasHyphenOrUpperASCII(lastTwo) && !hasHyphenOrUpperASCII(pkgIdent) {
+		lastTwo = lowerASCIIAndRemoveHyphen(lastTwo)
+		if strings.Contains(lastTwo, pkgIdent) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func hasHyphenOrUpperASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if b == '-' || ('A' <= b && b <= 'Z') {
+			return true
+		}
+	}
+	return false
+}
+
+func lowerASCIIAndRemoveHyphen(s string) (ret string) {
+	buf := make([]byte, 0, len(s))
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		switch {
+		case b == '-':
+			continue
+		case 'A' <= b && b <= 'Z':
+			buf = append(buf, b+('a'-'A'))
+		default:
+			buf = append(buf, b)
+		}
+	}
+	return string(buf)
+}
+
+// canUse reports whether the package in dir is usable from filename,
+// respecting the Go "internal" and "vendor" visibility rules.
+func canUse(filename, dir string) bool {
+	// Fast path check, before any allocations. If it doesn't contain vendor
+	// or internal, it's not tricky:
+	// Note that this can false-negative on directories like "notinternal",
+	// but we check it correctly below. This is just a fast path.
+	if !strings.Contains(dir, "vendor") && !strings.Contains(dir, "internal") {
+		return true
+	}
+
+	dirSlash := filepath.ToSlash(dir)
+	if !strings.Contains(dirSlash, "/vendor/") && !strings.Contains(dirSlash, "/internal/") && !strings.HasSuffix(dirSlash, "/internal") {
+		return true
+	}
+	// Vendor or internal directory only visible from children of parent.
+	// That means the path from the current directory to the target directory
+	// can contain ../vendor or ../internal but not ../foo/vendor or ../foo/internal
+	// or bar/vendor or bar/internal.
+	// After stripping all the leading ../, the only okay place to see vendor or internal
+	// is at the very beginning of the path.
+	absfile, err := filepath.Abs(filename)
+	if err != nil {
+		return false
+	}
+	absdir, err := filepath.Abs(dir)
+	if err != nil {
+		return false
+	}
+	rel, err := filepath.Rel(absfile, absdir)
+	if err != nil {
+		return false
+	}
+	relSlash := filepath.ToSlash(rel)
+	if i := strings.LastIndex(relSlash, "../"); i >= 0 {
+		relSlash = relSlash[i+len("../"):]
+	}
+	return !strings.Contains(relSlash, "/vendor/") && !strings.Contains(relSlash, "/internal/") && !strings.HasSuffix(relSlash, "/internal")
+}
+
+// lastTwoComponents returns at most the last two path components
+// of v, using either / or \ as the path separator.
+func lastTwoComponents(v string) string {
+	nslash := 0
+	for i := len(v) - 1; i >= 0; i-- {
+		if v[i] == '/' || v[i] == '\\' {
+			nslash++
+			if nslash == 2 {
+				return v[i:]
 			}
 		}
 	}
-	if len(pkgs) == 0 {
-		return "", false, nil
-	}
-
-	// If there are multiple candidate packages, the shortest one wins.
-	// This is a heuristic to prefer the standard library (e.g. "bytes")
-	// over e.g. "github.com/foo/bar/bytes".
-	shortest := ""
-	for importPath := range pkgs {
-		if shortest == "" || len(importPath) < len(shortest) {
-			shortest = importPath
-		}
-	}
-	return shortest, false, nil
+	return v
 }
 
 type visitFn func(node ast.Node) ast.Visitor
@@ -371,17 +1057,36 @@ func (fn visitFn) Visit(node ast.Node) ast.Visitor {
 	return fn(node)
 }
 
-func findImportStdlib(shortPkg string, symbols map[string]bool) (importPath string, rename, ok bool) {
+func findImportStdlib(shortPkg string, symbols map[string]bool) (importPath string, ok bool) {
 	for symbol := range symbols {
-		path := stdlib[shortPkg+"."+symbol]
+		key := shortPkg + "." + symbol
+		path := stdlib[key]
 		if path == "" {
-			return "", false, false
+			if key == "rand.Read" {
+				continue
+			}
+			return "", false
 		}
 		if importPath != "" && importPath != path {
 			// Ambiguous. Symbols pointed to different things.
-			return "", false, false
+			return "", false
 		}
 		importPath = path
 	}
-	return importPath, false, importPath != ""
+	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/vendor/golang.org/x/tools/imports/fix_test.go b/vendor/golang.org/x/tools/imports/fix_test.go
new file mode 100644
index 0000000..b8d51a3
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fix_test.go
@@ -0,0 +1,2097 @@
+// 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 (
+	"bytes"
+	"flag"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+)
+
+var only = flag.String("only", "", "If non-empty, the fix test to run")
+
+var tests = []struct {
+	name       string
+	formatOnly bool
+	in, out    string
+}{
+	// Adding an import to an existing parenthesized import
+	{
+		name: "factored_imports_add",
+		in: `package foo
+import (
+  "fmt"
+)
+func bar() {
+var b bytes.Buffer
+fmt.Println(b.String())
+}
+`,
+		out: `package foo
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func bar() {
+	var b bytes.Buffer
+	fmt.Println(b.String())
+}
+`,
+	},
+
+	// Adding an import to an existing parenthesized import,
+	// verifying it goes into the first section.
+	{
+		name: "factored_imports_add_first_sec",
+		in: `package foo
+import (
+  "fmt"
+
+  "appengine"
+)
+func bar() {
+var b bytes.Buffer
+_ = appengine.IsDevServer
+fmt.Println(b.String())
+}
+`,
+		out: `package foo
+
+import (
+	"bytes"
+	"fmt"
+
+	"appengine"
+)
+
+func bar() {
+	var b bytes.Buffer
+	_ = appengine.IsDevServer
+	fmt.Println(b.String())
+}
+`,
+	},
+
+	// Adding an import to an existing parenthesized import,
+	// verifying it goes into the first section. (test 2)
+	{
+		name: "factored_imports_add_first_sec_2",
+		in: `package foo
+import (
+  "fmt"
+
+  "appengine"
+)
+func bar() {
+_ = math.NaN
+_ = fmt.Sprintf
+_ = appengine.IsDevServer
+}
+`,
+		out: `package foo
+
+import (
+	"fmt"
+	"math"
+
+	"appengine"
+)
+
+func bar() {
+	_ = math.NaN
+	_ = fmt.Sprintf
+	_ = appengine.IsDevServer
+}
+`,
+	},
+
+	// Adding a new import line, without parens
+	{
+		name: "add_import_section",
+		in: `package foo
+func bar() {
+var b bytes.Buffer
+}
+`,
+		out: `package foo
+
+import "bytes"
+
+func bar() {
+	var b bytes.Buffer
+}
+`,
+	},
+
+	// Adding two new imports, which should make a parenthesized import decl.
+	{
+		name: "add_import_paren_section",
+		in: `package foo
+func bar() {
+_, _ := bytes.Buffer, zip.NewReader
+}
+`,
+		out: `package foo
+
+import (
+	"archive/zip"
+	"bytes"
+)
+
+func bar() {
+	_, _ := bytes.Buffer, zip.NewReader
+}
+`,
+	},
+
+	// Make sure we don't add things twice
+	{
+		name: "no_double_add",
+		in: `package foo
+func bar() {
+_, _ := bytes.Buffer, bytes.NewReader
+}
+`,
+		out: `package foo
+
+import "bytes"
+
+func bar() {
+	_, _ := bytes.Buffer, bytes.NewReader
+}
+`,
+	},
+
+	// Remove unused imports, 1 of a factored block
+	{
+		name: "remove_unused_1_of_2",
+		in: `package foo
+import (
+"bytes"
+"fmt"
+)
+
+func bar() {
+_, _ := bytes.Buffer, bytes.NewReader
+}
+`,
+		out: `package foo
+
+import (
+	"bytes"
+)
+
+func bar() {
+	_, _ := bytes.Buffer, bytes.NewReader
+}
+`,
+	},
+
+	// Remove unused imports, 2 of 2
+	{
+		name: "remove_unused_2_of_2",
+		in: `package foo
+import (
+"bytes"
+"fmt"
+)
+
+func bar() {
+}
+`,
+		out: `package foo
+
+func bar() {
+}
+`,
+	},
+
+	// Remove unused imports, 1 of 1
+	{
+		name: "remove_unused_1_of_1",
+		in: `package foo
+
+import "fmt"
+
+func bar() {
+}
+`,
+		out: `package foo
+
+func bar() {
+}
+`,
+	},
+
+	// Don't remove empty imports.
+	{
+		name: "dont_remove_empty_imports",
+		in: `package foo
+import (
+_ "image/png"
+_ "image/jpeg"
+)
+`,
+		out: `package foo
+
+import (
+	_ "image/jpeg"
+	_ "image/png"
+)
+`,
+	},
+
+	// Don't remove dot imports.
+	{
+		name: "dont_remove_dot_imports",
+		in: `package foo
+import (
+. "foo"
+. "bar"
+)
+`,
+		out: `package foo
+
+import (
+	. "bar"
+	. "foo"
+)
+`,
+	},
+
+	// Skip refs the parser can resolve.
+	{
+		name: "skip_resolved_refs",
+		in: `package foo
+
+func f() {
+	type t struct{ Println func(string) }
+	fmt := t{Println: func(string) {}}
+	fmt.Println("foo")
+}
+`,
+		out: `package foo
+
+func f() {
+	type t struct{ Println func(string) }
+	fmt := t{Println: func(string) {}}
+	fmt.Println("foo")
+}
+`,
+	},
+
+	// Do not add a package we already have a resolution for.
+	{
+		name: "skip_template",
+		in: `package foo
+
+import "html/template"
+
+func f() { t = template.New("sometemplate") }
+`,
+		out: `package foo
+
+import "html/template"
+
+func f() { t = template.New("sometemplate") }
+`,
+	},
+
+	// Don't touch cgo
+	{
+		name: "cgo",
+		in: `package foo
+
+/*
+#include <foo.h>
+*/
+import "C"
+`,
+		out: `package foo
+
+/*
+#include <foo.h>
+*/
+import "C"
+`,
+	},
+
+	// Put some things in their own section
+	{
+		name: "make_sections",
+		in: `package foo
+
+import (
+"os"
+)
+
+func foo () {
+_, _ = os.Args, fmt.Println
+_, _ = appengine.FooSomething, user.Current
+}
+`,
+		out: `package foo
+
+import (
+	"fmt"
+	"os"
+
+	"appengine"
+	"appengine/user"
+)
+
+func foo() {
+	_, _ = os.Args, fmt.Println
+	_, _ = appengine.FooSomething, user.Current
+}
+`,
+	},
+
+	// Delete existing empty import block
+	{
+		name: "delete_empty_import_block",
+		in: `package foo
+
+import ()
+`,
+		out: `package foo
+`,
+	},
+
+	// Use existing empty import block
+	{
+		name: "use_empty_import_block",
+		in: `package foo
+
+import ()
+
+func f() {
+	_ = fmt.Println
+}
+`,
+		out: `package foo
+
+import "fmt"
+
+func f() {
+	_ = fmt.Println
+}
+`,
+	},
+
+	// Blank line before adding new section.
+	{
+		name: "blank_line_before_new_group",
+		in: `package foo
+
+import (
+	"fmt"
+	"net"
+)
+
+func f() {
+	_ = net.Dial
+	_ = fmt.Printf
+	_ = snappy.Foo
+}
+`,
+		out: `package foo
+
+import (
+	"fmt"
+	"net"
+
+	"code.google.com/p/snappy-go/snappy"
+)
+
+func f() {
+	_ = net.Dial
+	_ = fmt.Printf
+	_ = snappy.Foo
+}
+`,
+	},
+
+	// Blank line between standard library and third-party stuff.
+	{
+		name: "blank_line_separating_std_and_third_party",
+		in: `package foo
+
+import (
+	"code.google.com/p/snappy-go/snappy"
+	"fmt"
+	"net"
+)
+
+func f() {
+	_ = net.Dial
+	_ = fmt.Printf
+	_ = snappy.Foo
+}
+`,
+		out: `package foo
+
+import (
+	"fmt"
+	"net"
+
+	"code.google.com/p/snappy-go/snappy"
+)
+
+func f() {
+	_ = net.Dial
+	_ = fmt.Printf
+	_ = snappy.Foo
+}
+`,
+	},
+
+	// golang.org/issue/6884
+	{
+		name: "issue 6884",
+		in: `package main
+
+// A comment
+func main() {
+	fmt.Println("Hello, world")
+}
+`,
+		out: `package main
+
+import "fmt"
+
+// A comment
+func main() {
+	fmt.Println("Hello, world")
+}
+`,
+	},
+
+	// golang.org/issue/7132
+	{
+		name: "issue 7132",
+		in: `package main
+
+import (
+"fmt"
+
+"gu"
+"github.com/foo/bar"
+)
+
+var (
+a = bar.a
+b = gu.a
+c = fmt.Printf
+)
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	"gu"
+
+	"github.com/foo/bar"
+)
+
+var (
+	a = bar.a
+	b = gu.a
+	c = fmt.Printf
+)
+`,
+	},
+
+	{
+		name: "renamed package",
+		in: `package main
+
+var _ = str.HasPrefix
+`,
+		out: `package main
+
+import str "strings"
+
+var _ = str.HasPrefix
+`,
+	},
+
+	{
+		name: "fragment with main",
+		in:   `func main(){fmt.Println("Hello, world")}`,
+		out: `package main
+
+import "fmt"
+
+func main() { fmt.Println("Hello, world") }
+`,
+	},
+
+	{
+		name: "fragment without main",
+		in:   `func notmain(){fmt.Println("Hello, world")}`,
+		out: `import "fmt"
+
+func notmain() { fmt.Println("Hello, world") }`,
+	},
+
+	// Remove first import within in a 2nd/3rd/4th/etc. section.
+	// golang.org/issue/7679
+	{
+		name: "issue 7679",
+		in: `package main
+
+import (
+	"fmt"
+
+	"github.com/foo/bar"
+	"github.com/foo/qux"
+)
+
+func main() {
+	var _ = fmt.Println
+	//var _ = bar.A
+	var _ = qux.B
+}
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	"github.com/foo/qux"
+)
+
+func main() {
+	var _ = fmt.Println
+	//var _ = bar.A
+	var _ = qux.B
+}
+`,
+	},
+
+	// Blank line can be added before all types of import declarations.
+	// golang.org/issue/7866
+	{
+		name: "issue 7866",
+		in: `package main
+
+import (
+	"fmt"
+	renamed_bar "github.com/foo/bar"
+
+	. "github.com/foo/baz"
+	"io"
+
+	_ "github.com/foo/qux"
+	"strings"
+)
+
+func main() {
+	_, _, _, _, _ = fmt.Errorf, io.Copy, strings.Contains, renamed_bar.A, B
+}
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	renamed_bar "github.com/foo/bar"
+
+	"io"
+
+	. "github.com/foo/baz"
+
+	"strings"
+
+	_ "github.com/foo/qux"
+)
+
+func main() {
+	_, _, _, _, _ = fmt.Errorf, io.Copy, strings.Contains, renamed_bar.A, B
+}
+`,
+	},
+
+	// Non-idempotent comment formatting
+	// golang.org/issue/8035
+	{
+		name: "issue 8035",
+		in: `package main
+
+import (
+	"fmt"                     // A
+	"go/ast"                  // B
+	_ "launchpad.net/gocheck" // C
+)
+
+func main() { _, _ = fmt.Print, ast.Walk }
+`,
+		out: `package main
+
+import (
+	"fmt"    // A
+	"go/ast" // B
+
+	_ "launchpad.net/gocheck" // C
+)
+
+func main() { _, _ = fmt.Print, ast.Walk }
+`,
+	},
+
+	// Failure to delete all duplicate imports
+	// golang.org/issue/8459
+	{
+		name: "issue 8459",
+		in: `package main
+
+import (
+	"fmt"
+	"log"
+	"log"
+	"math"
+)
+
+func main() { fmt.Println("pi:", math.Pi) }
+`,
+		out: `package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() { fmt.Println("pi:", math.Pi) }
+`,
+	},
+
+	// Too aggressive prefix matching
+	// golang.org/issue/9961
+	{
+		name: "issue 9961",
+		in: `package p
+
+import (
+	"zip"
+
+	"rsc.io/p"
+)
+
+var (
+	_ = fmt.Print
+	_ = zip.Store
+	_ p.P
+	_ = regexp.Compile
+)
+`,
+		out: `package p
+
+import (
+	"fmt"
+	"regexp"
+	"zip"
+
+	"rsc.io/p"
+)
+
+var (
+	_ = fmt.Print
+	_ = zip.Store
+	_ p.P
+	_ = regexp.Compile
+)
+`,
+	},
+
+	// Unused named import is mistaken for unnamed import
+	// golang.org/issue/8149
+	{
+		name: "issue 8149",
+		in: `package main
+
+import foo "fmt"
+
+func main() { fmt.Println() }
+`,
+		out: `package main
+
+import "fmt"
+
+func main() { fmt.Println() }
+`,
+	},
+
+	// Unused named import is mistaken for unnamed import
+	// golang.org/issue/8149
+	{
+		name: "issue 8149",
+		in: `package main
+
+import (
+	"fmt"
+	x "fmt"
+)
+
+func main() { fmt.Println() }
+`,
+		out: `package main
+
+import (
+	"fmt"
+)
+
+func main() { fmt.Println() }
+`,
+	},
+
+	// FormatOnly
+	{
+		name:       "format only",
+		formatOnly: true,
+		in: `package main
+
+import (
+"fmt"
+"golang.org/x/foo"
+)
+
+func main() {}
+`,
+		out: `package main
+
+import (
+	"fmt"
+
+	"golang.org/x/foo"
+)
+
+func main() {}
+`,
+	},
+
+	{
+		name: "do not make grouped imports non-grouped",
+		in: `package p
+
+import (
+	"bytes"
+	"fmt"
+)
+
+var _ = fmt.Sprintf
+`,
+		out: `package p
+
+import (
+	"fmt"
+)
+
+var _ = fmt.Sprintf
+`,
+	},
+
+	{
+		name: "issue #19190 1",
+		in: `package main
+
+import (
+	"time"
+)
+
+func main() {
+	_ = snappy.Encode
+	_ = p.P
+	_ = time.Parse
+}
+`,
+		out: `package main
+
+import (
+	"time"
+
+	"code.google.com/p/snappy-go/snappy"
+	"rsc.io/p"
+)
+
+func main() {
+	_ = snappy.Encode
+	_ = p.P
+	_ = time.Parse
+}
+`,
+	},
+
+	{
+		name: "issue #19190 2",
+		in: `package main
+
+import (
+	"time"
+
+	"code.google.com/p/snappy-go/snappy"
+)
+
+func main() {
+	_ = snappy.Encode
+	_ = p.P
+	_ = time.Parse
+}
+`,
+		out: `package main
+
+import (
+	"time"
+
+	"code.google.com/p/snappy-go/snappy"
+	"rsc.io/p"
+)
+
+func main() {
+	_ = snappy.Encode
+	_ = p.P
+	_ = time.Parse
+}
+`,
+	},
+
+	{
+		name: "issue #12097",
+		in: `// a
+// b
+// c
+
+func main() {
+    _ = fmt.Println
+}`,
+		out: `package main
+
+import "fmt"
+
+// a
+// b
+// c
+
+func main() {
+	_ = fmt.Println
+}
+`,
+	},
+}
+
+func TestFixImports(t *testing.T) {
+	simplePkgs := map[string]string{
+		"appengine": "appengine",
+		"bytes":     "bytes",
+		"fmt":       "fmt",
+		"math":      "math",
+		"os":        "os",
+		"p":         "rsc.io/p",
+		"regexp":    "regexp",
+		"snappy":    "code.google.com/p/snappy-go/snappy",
+		"str":       "strings",
+		"user":      "appengine/user",
+		"zip":       "archive/zip",
+	}
+	old := findImport
+	defer func() {
+		findImport = old
+	}()
+	findImport = func(pkgName string, symbols map[string]bool, filename string) (string, bool, error) {
+		return simplePkgs[pkgName], pkgName == "str", nil
+	}
+
+	options := &Options{
+		TabWidth:  8,
+		TabIndent: true,
+		Comments:  true,
+		Fragment:  true,
+	}
+
+	for _, tt := range tests {
+		options.FormatOnly = tt.formatOnly
+		if *only != "" && tt.name != *only {
+			continue
+		}
+		buf, err := Process(tt.name+".go", []byte(tt.in), options)
+		if err != nil {
+			t.Errorf("error on %q: %v", tt.name, err)
+			continue
+		}
+		if got := string(buf); got != tt.out {
+			t.Errorf("results diff on %q\nGOT:\n%s\nWANT:\n%s\n", tt.name, got, tt.out)
+		}
+	}
+}
+
+// Test support for packages in GOPATH that are actually symlinks.
+// Also test that a symlink loop does not block the process.
+func TestImportSymlinks(t *testing.T) {
+	switch runtime.GOOS {
+	case "windows", "plan9":
+		t.Skipf("skipping test on %q as there are no symlinks", runtime.GOOS)
+	}
+
+	newGoPath, err := ioutil.TempDir("", "symlinktest")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(newGoPath)
+
+	// Create:
+	//    $GOPATH/target/
+	//    $GOPATH/target/f.go  // package mypkg\nvar Foo = 123\n
+	//    $GOPATH/src/x/
+	//    $GOPATH/src/x/mypkg => $GOPATH/target   // symlink
+	//    $GOPATH/src/x/apkg  => $GOPATH/src/x    // symlink loop
+	// Test:
+	//    $GOPATH/src/myotherpkg/toformat.go referencing mypkg.Foo
+
+	targetPath := newGoPath + "/target"
+	if err := os.MkdirAll(targetPath, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := ioutil.WriteFile(targetPath+"/f.go", []byte("package mypkg\nvar Foo = 123\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+
+	symlinkPath := newGoPath + "/src/x/mypkg"
+	if err := os.MkdirAll(filepath.Dir(symlinkPath), 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(targetPath, symlinkPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// Add a symlink loop.
+	if err := os.Symlink(newGoPath+"/src/x", newGoPath+"/src/x/apkg"); err != nil {
+		t.Fatal(err)
+	}
+
+	withEmptyGoPath(func() {
+		build.Default.GOPATH = newGoPath
+
+		input := `package p
+
+var (
+	_ = fmt.Print
+	_ = mypkg.Foo
+)
+`
+		output := `package p
+
+import (
+	"fmt"
+	"x/mypkg"
+)
+
+var (
+	_ = fmt.Print
+	_ = mypkg.Foo
+)
+`
+		buf, err := Process(newGoPath+"/src/myotherpkg/toformat.go", []byte(input), &Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := string(buf); got != output {
+			t.Fatalf("results differ\nGOT:\n%s\nWANT:\n%s\n", got, output)
+		}
+	})
+
+	// Add a .goimportsignore and ensure it is respected.
+	if err := ioutil.WriteFile(newGoPath+"/src/.goimportsignore", []byte("x/mypkg\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+
+	withEmptyGoPath(func() {
+		build.Default.GOPATH = newGoPath
+
+		input := `package p
+
+var (
+	_ = fmt.Print
+	_ = mypkg.Foo
+)
+`
+		output := `package p
+
+import "fmt"
+
+var (
+	_ = fmt.Print
+	_ = mypkg.Foo
+)
+`
+		buf, err := Process(newGoPath+"/src/myotherpkg/toformat.go", []byte(input), &Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := string(buf); got != output {
+			t.Fatalf("ignored results differ\nGOT:\n%s\nWANT:\n%s\n", got, output)
+		}
+	})
+
+}
+
+// Test for correctly identifying the name of a vendored package when it
+// differs from its directory name. In this test, the import line
+// "mypkg.com/mypkg.v1" would be removed if goimports wasn't able to detect
+// that the package name is "mypkg".
+func TestFixImportsVendorPackage(t *testing.T) {
+	// Skip this test on go versions with no vendor support.
+	if _, err := os.Stat(filepath.Join(runtime.GOROOT(), "src/vendor")); err != nil {
+		t.Skip(err)
+	}
+	testConfig{
+		gopathFiles: map[string]string{
+			"mypkg.com/outpkg/vendor/mypkg.com/mypkg.v1/f.go": "package mypkg\nvar Foo = 123\n",
+		},
+	}.test(t, func(t *goimportTest) {
+		input := `package p
+
+import (
+	"fmt"
+
+	"mypkg.com/mypkg.v1"
+)
+
+var (
+	_ = fmt.Print
+	_ = mypkg.Foo
+)
+`
+		buf, err := Process(filepath.Join(t.gopath, "src/mypkg.com/outpkg/toformat.go"), []byte(input), &Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := string(buf); got != input {
+			t.Fatalf("results differ\nGOT:\n%s\nWANT:\n%s\n", got, input)
+		}
+	})
+}
+
+func TestFindImportGoPath(t *testing.T) {
+	goroot, err := ioutil.TempDir("", "goimports-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(goroot)
+
+	origStdlib := stdlib
+	defer func() {
+		stdlib = origStdlib
+	}()
+	stdlib = nil
+
+	withEmptyGoPath(func() {
+		// Test against imaginary bits/bytes package in std lib
+		bytesDir := filepath.Join(goroot, "src", "pkg", "bits", "bytes")
+		for _, tag := range build.Default.ReleaseTags {
+			// Go 1.4 rearranged the GOROOT tree to remove the "pkg" path component.
+			if tag == "go1.4" {
+				bytesDir = filepath.Join(goroot, "src", "bits", "bytes")
+			}
+		}
+		if err := os.MkdirAll(bytesDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		bytesSrcPath := filepath.Join(bytesDir, "bytes.go")
+		bytesPkgPath := "bits/bytes"
+		bytesSrc := []byte(`package bytes
+
+type Buffer2 struct {}
+`)
+		if err := ioutil.WriteFile(bytesSrcPath, bytesSrc, 0775); err != nil {
+			t.Fatal(err)
+		}
+		build.Default.GOROOT = goroot
+
+		got, rename, err := findImportGoPath("bytes", map[string]bool{"Buffer2": true}, "x.go")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != bytesPkgPath || rename {
+			t.Errorf(`findImportGoPath("bytes", Buffer2 ...)=%q, %t, want "%s", false`, got, rename, bytesPkgPath)
+		}
+
+		got, rename, err = findImportGoPath("bytes", map[string]bool{"Missing": true}, "x.go")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != "" || rename {
+			t.Errorf(`findImportGoPath("bytes", Missing ...)=%q, %t, want "", false`, got, rename)
+		}
+	})
+}
+
+func init() {
+	inTests = true
+}
+
+func withEmptyGoPath(fn func()) {
+	testMu.Lock()
+
+	dirScanMu.Lock()
+	populateIgnoreOnce = sync.Once{}
+	scanGoRootOnce = sync.Once{}
+	scanGoPathOnce = sync.Once{}
+	dirScan = nil
+	ignoredDirs = nil
+	scanGoRootDone = make(chan struct{})
+	dirScanMu.Unlock()
+
+	oldGOPATH := build.Default.GOPATH
+	oldGOROOT := build.Default.GOROOT
+	build.Default.GOPATH = ""
+	testHookScanDir = func(string) {}
+	testMu.Unlock()
+
+	defer func() {
+		testMu.Lock()
+		testHookScanDir = func(string) {}
+		build.Default.GOPATH = oldGOPATH
+		build.Default.GOROOT = oldGOROOT
+		testMu.Unlock()
+	}()
+
+	fn()
+}
+
+func TestFindImportInternal(t *testing.T) {
+	withEmptyGoPath(func() {
+		// Check for src/internal/race, not just src/internal,
+		// so that we can run this test also against go1.5
+		// (which doesn't contain that file).
+		_, err := os.Stat(filepath.Join(runtime.GOROOT(), "src/internal/race"))
+		if err != nil {
+			t.Skip(err)
+		}
+
+		got, rename, err := findImportGoPath("race", map[string]bool{"Acquire": true}, filepath.Join(runtime.GOROOT(), "src/math/x.go"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != "internal/race" || rename {
+			t.Errorf(`findImportGoPath("race", Acquire ...) = %q, %t; want "internal/race", false`, got, rename)
+		}
+
+		// should not be able to use internal from outside that tree
+		got, rename, err = findImportGoPath("race", map[string]bool{"Acquire": true}, filepath.Join(runtime.GOROOT(), "x.go"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != "" || rename {
+			t.Errorf(`findImportGoPath("race", Acquire ...)=%q, %t, want "", false`, got, rename)
+		}
+	})
+}
+
+// rand.Read should prefer crypto/rand.Read, not math/rand.Read.
+func TestFindImportRandRead(t *testing.T) {
+	withEmptyGoPath(func() {
+		file := filepath.Join(runtime.GOROOT(), "src/foo/x.go") // dummy
+		tests := []struct {
+			syms []string
+			want string
+		}{
+			{
+				syms: []string{"Read"},
+				want: "crypto/rand",
+			},
+			{
+				syms: []string{"Read", "NewZipf"},
+				want: "math/rand",
+			},
+			{
+				syms: []string{"NewZipf"},
+				want: "math/rand",
+			},
+			{
+				syms: []string{"Read", "Prime"},
+				want: "crypto/rand",
+			},
+		}
+		for _, tt := range tests {
+			m := map[string]bool{}
+			for _, sym := range tt.syms {
+				m[sym] = true
+			}
+			got, _, err := findImportGoPath("rand", m, file)
+			if err != nil {
+				t.Errorf("for %q: %v", tt.syms, err)
+				continue
+			}
+			if got != tt.want {
+				t.Errorf("for %q, findImportGoPath = %q; want %q", tt.syms, got, tt.want)
+			}
+		}
+	})
+}
+
+func TestFindImportVendor(t *testing.T) {
+	testConfig{
+		gorootFiles: map[string]string{
+			"vendor/golang.org/x/net/http2/hpack/huffman.go": "package hpack\nfunc HuffmanDecode() { }\n",
+		},
+	}.test(t, func(t *goimportTest) {
+		got, rename, err := findImportGoPath("hpack", map[string]bool{"HuffmanDecode": true}, filepath.Join(t.goroot, "src/math/x.go"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		want := "golang.org/x/net/http2/hpack"
+		if got != want || rename {
+			t.Errorf(`findImportGoPath("hpack", HuffmanDecode ...) = %q, %t; want %q, false`, got, rename, want)
+		}
+	})
+}
+
+func TestProcessVendor(t *testing.T) {
+	withEmptyGoPath(func() {
+		_, err := os.Stat(filepath.Join(runtime.GOROOT(), "src/vendor"))
+		if err != nil {
+			t.Skip(err)
+		}
+
+		target := filepath.Join(runtime.GOROOT(), "src/math/x.go")
+		out, err := Process(target, []byte("package http\nimport \"bytes\"\nfunc f() { strings.NewReader(); hpack.HuffmanDecode() }\n"), nil)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		want := "golang_org/x/net/http2/hpack"
+		if _, err := os.Stat(filepath.Join(runtime.GOROOT(), "src/vendor", want)); os.IsNotExist(err) {
+			want = "golang.org/x/net/http2/hpack"
+		}
+
+		if !bytes.Contains(out, []byte(want)) {
+			t.Fatalf("Process(%q) did not add expected hpack import %q; got:\n%s", target, want, out)
+		}
+	})
+}
+
+func TestFindImportStdlib(t *testing.T) {
+	tests := []struct {
+		pkg     string
+		symbols []string
+		want    string
+	}{
+		{"http", []string{"Get"}, "net/http"},
+		{"http", []string{"Get", "Post"}, "net/http"},
+		{"http", []string{"Get", "Foo"}, ""},
+		{"bytes", []string{"Buffer"}, "bytes"},
+		{"ioutil", []string{"Discard"}, "io/ioutil"},
+	}
+	for _, tt := range tests {
+		got, ok := findImportStdlib(tt.pkg, strSet(tt.symbols))
+		if (got != "") != ok {
+			t.Error("findImportStdlib return value inconsistent")
+		}
+		if got != tt.want {
+			t.Errorf("findImportStdlib(%q, %q) = %q, want %q", tt.pkg, tt.symbols, got, tt.want)
+		}
+	}
+}
+
+type testConfig struct {
+	// goroot and gopath optionally specifies the path on disk
+	// to use for the GOROOT and GOPATH. If empty, a temp directory
+	// is made if needed.
+	goroot, gopath string
+
+	// gorootFiles optionally specifies the complete contents of GOROOT to use,
+	// If nil, the normal current $GOROOT is used.
+	gorootFiles map[string]string // paths relative to $GOROOT/src to contents
+
+	// gopathFiles is like gorootFiles, but for $GOPATH.
+	// If nil, there is no GOPATH, though.
+	gopathFiles map[string]string // paths relative to $GOPATH/src to contents
+}
+
+func mustTempDir(t *testing.T, prefix string) string {
+	dir, err := ioutil.TempDir("", prefix)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return dir
+}
+
+func mapToDir(destDir string, files map[string]string) error {
+	for path, contents := range files {
+		file := filepath.Join(destDir, "src", path)
+		if err := os.MkdirAll(filepath.Dir(file), 0755); err != nil {
+			return err
+		}
+		var err error
+		if strings.HasPrefix(contents, "LINK:") {
+			err = os.Symlink(strings.TrimPrefix(contents, "LINK:"), file)
+		} else {
+			err = ioutil.WriteFile(file, []byte(contents), 0644)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c testConfig) test(t *testing.T, fn func(*goimportTest)) {
+	goroot := c.goroot
+	gopath := c.gopath
+
+	if c.gorootFiles != nil && goroot == "" {
+		goroot = mustTempDir(t, "goroot-")
+		defer os.RemoveAll(goroot)
+	}
+	if err := mapToDir(goroot, c.gorootFiles); err != nil {
+		t.Fatal(err)
+	}
+
+	if c.gopathFiles != nil && gopath == "" {
+		gopath = mustTempDir(t, "gopath-")
+		defer os.RemoveAll(gopath)
+	}
+	if err := mapToDir(gopath, c.gopathFiles); err != nil {
+		t.Fatal(err)
+	}
+
+	withEmptyGoPath(func() {
+		if goroot != "" {
+			build.Default.GOROOT = goroot
+		}
+		build.Default.GOPATH = gopath
+
+		it := &goimportTest{
+			T:      t,
+			goroot: build.Default.GOROOT,
+			gopath: gopath,
+			ctx:    &build.Default,
+		}
+		fn(it)
+	})
+}
+
+type goimportTest struct {
+	*testing.T
+	ctx    *build.Context
+	goroot string
+	gopath string
+}
+
+// Tests that added imports are renamed when the import path's base doesn't
+// match its package name. For example, we want to generate:
+//
+//     import cloudbilling "google.golang.org/api/cloudbilling/v1"
+func TestRenameWhenPackageNameMismatch(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"foo/bar/v1/x.go": "package bar \n const X = 1",
+		},
+	}.test(t, func(t *goimportTest) {
+		buf, err := Process(t.gopath+"/src/test/t.go", []byte("package main \n const Y = bar.X"), &Options{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		const want = `package main
+
+import bar "foo/bar/v1"
+
+const Y = bar.X
+`
+		if string(buf) != want {
+			t.Errorf("Got:\n%s\nWant:\n%s", buf, want)
+		}
+	})
+}
+
+// Tests that the LocalPrefix option causes imports
+// to be added into a later group (num=3).
+func TestLocalPrefix(t *testing.T) {
+	tests := []struct {
+		config      testConfig
+		localPrefix string
+		src         string
+		want        string
+	}{
+		{
+			config: testConfig{
+				gopathFiles: map[string]string{
+					"foo/bar/bar.go": "package bar \n const X = 1",
+				},
+			},
+			localPrefix: "foo/",
+			src:         "package main \n const Y = bar.X \n const _ = runtime.GOOS",
+			want: `package main
+
+import (
+	"runtime"
+
+	"foo/bar"
+)
+
+const Y = bar.X
+const _ = runtime.GOOS
+`,
+		},
+		{
+			config: testConfig{
+				gopathFiles: map[string]string{
+					"example.org/pkg/pkg.go":          "package pkg \n const A = 1",
+					"foo/bar/bar.go":                  "package bar \n const B = 1",
+					"code.org/r/p/expproj/expproj.go": "package expproj \n const C = 1",
+				},
+			},
+			localPrefix: "example.org/pkg,foo/,code.org",
+			src:         "package main \n const X = pkg.A \n const Y = bar.B \n const Z = expproj.C \n const _ = runtime.GOOS",
+			want: `package main
+
+import (
+	"runtime"
+
+	"code.org/r/p/expproj"
+	"example.org/pkg"
+	"foo/bar"
+)
+
+const X = pkg.A
+const Y = bar.B
+const Z = expproj.C
+const _ = runtime.GOOS
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		tt.config.test(t, func(t *goimportTest) {
+			defer func(s string) { LocalPrefix = s }(LocalPrefix)
+			LocalPrefix = tt.localPrefix
+			buf, err := Process(t.gopath+"/src/test/t.go", []byte(tt.src), &Options{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(buf) != tt.want {
+				t.Errorf("Got:\n%s\nWant:\n%s", buf, tt.want)
+			}
+		})
+	}
+}
+
+// Tests that running goimport on files in GOROOT (for people hacking
+// on Go itself) don't cause the GOPATH to be scanned (which might be
+// much bigger).
+func TestOptimizationWhenInGoroot(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"foo/foo.go": "package foo\nconst X = 1\n",
+		},
+	}.test(t, func(t *goimportTest) {
+		testHookScanDir = func(dir string) {
+			if dir != filepath.Join(build.Default.GOROOT, "src") {
+				t.Errorf("unexpected dir scan of %s", dir)
+			}
+		}
+		const in = "package foo\n\nconst Y = bar.X\n"
+		buf, err := Process(t.goroot+"/src/foo/foo.go", []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != in {
+			t.Errorf("got:\n%q\nwant unchanged:\n%q\n", in, buf)
+		}
+	})
+}
+
+// Tests that "package documentation" files are ignored.
+func TestIgnoreDocumentationPackage(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"foo/foo.go": "package foo\nconst X = 1\n",
+			"foo/doc.go": "package documentation \n // just to confuse things\n",
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package x\n\nconst Y = foo.X\n"
+		const want = "package x\n\nimport \"foo\"\n\nconst Y = foo.X\n"
+		buf, err := Process(t.gopath+"/src/x/x.go", []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != want {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", in, want)
+		}
+	})
+}
+
+// Tests importPathToNameGoPathParse and in particular that it stops
+// after finding the first non-documentation package name, not
+// reporting an error on inconsistent package names (since it should
+// never make it that far).
+func TestImportPathToNameGoPathParse(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"example.net/pkg/doc.go": "package documentation\n", // ignored
+			"example.net/pkg/gen.go": "package main\n",          // also ignored
+			"example.net/pkg/pkg.go": "package the_pkg_name_to_find\n  and this syntax error is ignored because of parser.PackageClauseOnly",
+			"example.net/pkg/z.go":   "package inconsistent\n", // inconsistent but ignored
+		},
+	}.test(t, func(t *goimportTest) {
+		got, err := importPathToNameGoPathParse("example.net/pkg", filepath.Join(t.gopath, "src", "other.net"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		const want = "the_pkg_name_to_find"
+		if got != want {
+			t.Errorf("importPathToNameGoPathParse(..) = %q; want %q", got, want)
+		}
+	})
+}
+
+func TestIgnoreConfiguration(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			".goimportsignore":                                     "# comment line\n\n example.net", // tests comment, blank line, whitespace trimming
+			"example.net/pkg/pkg.go":                               "package pkg\nconst X = 1",
+			"otherwise-longer-so-worse.example.net/foo/pkg/pkg.go": "package pkg\nconst X = 1",
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package x\n\nconst _ = pkg.X\n"
+		const want = "package x\n\nimport \"otherwise-longer-so-worse.example.net/foo/pkg\"\n\nconst _ = pkg.X\n"
+		buf, err := Process(t.gopath+"/src/x/x.go", []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != want {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", buf, want)
+		}
+	})
+}
+
+// Skip "node_modules" directory.
+func TestSkipNodeModules(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"example.net/node_modules/pkg/a.go":         "package pkg\nconst X = 1",
+			"otherwise-longer.net/not_modules/pkg/a.go": "package pkg\nconst X = 1",
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package x\n\nconst _ = pkg.X\n"
+		const want = "package x\n\nimport \"otherwise-longer.net/not_modules/pkg\"\n\nconst _ = pkg.X\n"
+		buf, err := Process(t.gopath+"/src/x/x.go", []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != want {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", buf, want)
+		}
+	})
+}
+
+// golang.org/issue/16458 -- if GOROOT is a prefix of GOPATH, GOPATH is ignored.
+func TestGoRootPrefixOfGoPath(t *testing.T) {
+	dir := mustTempDir(t, "importstest")
+	defer os.RemoveAll(dir)
+	testConfig{
+		goroot: filepath.Join(dir, "go"),
+		gopath: filepath.Join(dir, "gopath"),
+		gopathFiles: map[string]string{
+			"example.com/foo/pkg.go": "package foo\nconst X = 1",
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package x\n\nconst _ = foo.X\n"
+		const want = "package x\n\nimport \"example.com/foo\"\n\nconst _ = foo.X\n"
+		buf, err := Process(t.gopath+"/src/x/x.go", []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != want {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", buf, want)
+		}
+	})
+
+}
+
+const testGlobalImportsUsesGlobal = `package globalimporttest
+
+func doSomething() {
+	t := time.Now()
+}
+`
+
+const testGlobalImportsGlobalDecl = `package globalimporttest
+
+type Time struct{}
+
+func (t Time) Now() Time {
+	return Time{}
+}
+
+var time Time
+`
+
+// Tests that package global variables with the same name and function name as
+// a function in a separate package do not result in an import which masks
+// the global variable
+func TestGlobalImports(t *testing.T) {
+	const pkg = "globalimporttest"
+	const usesGlobalFile = pkg + "/uses_global.go"
+	testConfig{
+		gopathFiles: map[string]string{
+			usesGlobalFile:     testGlobalImportsUsesGlobal,
+			pkg + "/global.go": testGlobalImportsGlobalDecl,
+		},
+	}.test(t, func(t *goimportTest) {
+		buf, err := Process(
+			t.gopath+"/src/"+usesGlobalFile, []byte(testGlobalImportsUsesGlobal), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != testGlobalImportsUsesGlobal {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", buf, testGlobalImportsUsesGlobal)
+		}
+	})
+}
+
+// Tests that sibling files - other files in the same package - can provide an
+// import that may not be the default one otherwise.
+func TestSiblingImports(t *testing.T) {
+
+	// provide is the sibling file that provides the desired import.
+	const provide = `package siblingimporttest
+
+import "local/log"
+import "my/bytes"
+
+func LogSomething() {
+	log.Print("Something")
+	bytes.SomeFunc()
+}
+`
+
+	// need is the file being tested that needs the import.
+	const need = `package siblingimporttest
+
+var _ = bytes.Buffer{}
+
+func LogSomethingElse() {
+	log.Print("Something else")
+}
+`
+
+	// want is the expected result file
+	const want = `package siblingimporttest
+
+import (
+	"bytes"
+	"local/log"
+)
+
+var _ = bytes.Buffer{}
+
+func LogSomethingElse() {
+	log.Print("Something else")
+}
+`
+
+	const pkg = "siblingimporttest"
+	const siblingFile = pkg + "/needs_import.go"
+	testConfig{
+		gopathFiles: map[string]string{
+			siblingFile:                 need,
+			pkg + "/provides_import.go": provide,
+		},
+	}.test(t, func(t *goimportTest) {
+		buf, err := Process(
+			t.gopath+"/src/"+siblingFile, []byte(need), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(buf) != want {
+			t.Errorf("wrong output.\ngot:\n%q\nwant:\n%q\n", buf, want)
+		}
+	})
+}
+
+func strSet(ss []string) map[string]bool {
+	m := make(map[string]bool)
+	for _, s := range ss {
+		m[s] = true
+	}
+	return m
+}
+
+func TestPkgIsCandidate(t *testing.T) {
+	tests := [...]struct {
+		filename string
+		pkgIdent string
+		pkg      *pkg
+		want     bool
+	}{
+		// normal match
+		0: {
+			filename: "/gopath/src/my/pkg/pkg.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/client",
+				importPath:      "client",
+				importPathShort: "client",
+			},
+			want: true,
+		},
+		// not a match
+		1: {
+			filename: "/gopath/src/my/pkg/pkg.go",
+			pkgIdent: "zzz",
+			pkg: &pkg{
+				dir:             "/gopath/src/client",
+				importPath:      "client",
+				importPathShort: "client",
+			},
+			want: false,
+		},
+		// would be a match, but "client" appears too deep.
+		2: {
+			filename: "/gopath/src/my/pkg/pkg.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/client/foo/foo/foo",
+				importPath:      "client/foo/foo",
+				importPathShort: "client/foo/foo",
+			},
+			want: false,
+		},
+		// not an exact match, but substring is good enough.
+		3: {
+			filename: "/gopath/src/my/pkg/pkg.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/go-client",
+				importPath:      "foo/go-client",
+				importPathShort: "foo/go-client",
+			},
+			want: true,
+		},
+		// "internal" package, and not visible
+		4: {
+			filename: "/gopath/src/my/pkg/pkg.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/internal/client",
+				importPath:      "foo/internal/client",
+				importPathShort: "foo/internal/client",
+			},
+			want: false,
+		},
+		// "internal" package but visible
+		5: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/internal/client",
+				importPath:      "foo/internal/client",
+				importPathShort: "foo/internal/client",
+			},
+			want: true,
+		},
+		// "vendor" package not visible
+		6: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/other/vendor/client",
+				importPath:      "other/vendor/client",
+				importPathShort: "client",
+			},
+			want: false,
+		},
+		// "vendor" package, visible
+		7: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "client",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/vendor/client",
+				importPath:      "other/foo/client",
+				importPathShort: "client",
+			},
+			want: true,
+		},
+		// Ignore hyphens.
+		8: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "socketio",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/socket-io",
+				importPath:      "foo/socket-io",
+				importPathShort: "foo/socket-io",
+			},
+			want: true,
+		},
+		// Ignore case.
+		9: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "fooprod",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/FooPROD",
+				importPath:      "foo/FooPROD",
+				importPathShort: "foo/FooPROD",
+			},
+			want: true,
+		},
+		// Ignoring both hyphens and case together.
+		10: {
+			filename: "/gopath/src/foo/bar.go",
+			pkgIdent: "fooprod",
+			pkg: &pkg{
+				dir:             "/gopath/src/foo/Foo-PROD",
+				importPath:      "foo/Foo-PROD",
+				importPathShort: "foo/Foo-PROD",
+			},
+			want: true,
+		},
+	}
+	for i, tt := range tests {
+		got := pkgIsCandidate(tt.filename, tt.pkgIdent, tt.pkg)
+		if got != tt.want {
+			t.Errorf("test %d. pkgIsCandidate(%q, %q, %+v) = %v; want %v",
+				i, tt.filename, tt.pkgIdent, *tt.pkg, got, tt.want)
+		}
+	}
+}
+
+func TestShouldTraverse(t *testing.T) {
+	switch runtime.GOOS {
+	case "windows", "plan9":
+		t.Skipf("skipping symlink-requiring test on %s", runtime.GOOS)
+	}
+
+	dir, err := ioutil.TempDir("", "goimports-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dir)
+
+	// Note: mapToDir prepends "src" to each element, since
+	// mapToDir was made for creating GOPATHs.
+	if err := mapToDir(dir, map[string]string{
+		"foo/foo2/file.txt":        "",
+		"foo/foo2/link-to-src":     "LINK:" + dir + "/src",
+		"foo/foo2/link-to-src-foo": "LINK:" + dir + "/src/foo",
+		"foo/foo2/link-to-dot":     "LINK:.",
+		"bar/bar2/file.txt":        "",
+		"bar/bar2/link-to-src-foo": "LINK:" + dir + "/src/foo",
+
+		"a/b/c": "LINK:" + dir + "/src/a/d",
+		"a/d/e": "LINK:" + dir + "/src/a/b",
+	}); err != nil {
+		t.Fatal(err)
+	}
+	tests := []struct {
+		dir  string
+		file string
+		want bool
+	}{
+		{
+			dir:  dir + "/src/foo/foo2",
+			file: "link-to-src-foo",
+			want: false, // loop
+		},
+		{
+			dir:  dir + "/src/foo/foo2",
+			file: "link-to-src",
+			want: false, // loop
+		},
+		{
+			dir:  dir + "/src/foo/foo2",
+			file: "link-to-dot",
+			want: false, // loop
+		},
+		{
+			dir:  dir + "/src/bar/bar2",
+			file: "link-to-src-foo",
+			want: true, // not a loop
+		},
+		{
+			dir:  dir + "/src/a/b/c",
+			file: "e",
+			want: false, // loop: "e" is the same as "b".
+		},
+	}
+	for i, tt := range tests {
+		fi, err := os.Stat(filepath.Join(tt.dir, tt.file))
+		if err != nil {
+			t.Errorf("%d. Stat = %v", i, err)
+			continue
+		}
+		got := shouldTraverse(tt.dir, fi)
+		if got != tt.want {
+			t.Errorf("%d. shouldTraverse(%q, %q) = %v; want %v", i, tt.dir, tt.file, got, tt.want)
+		}
+	}
+}
+
+// Issue 20941: this used to panic on Windows.
+func TestProcessStdin(t *testing.T) {
+	got, err := Process("<standard input>", []byte("package main\nfunc main() {\n\tfmt.Println(123)\n}\n"), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(got), `"fmt"`) {
+		t.Errorf("expected fmt import; got: %s", got)
+	}
+}
+
+// Tests LocalPackagePromotion when there is a local package that matches, it
+// should be the closest match.
+// https://golang.org/issues/17557
+func TestLocalPackagePromotion(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"config.net/config/config.go":         "package config\n type SystemConfig struct {}", // Will match but should not be first choice
+			"mycompany.net/config/config.go":      "package config\n type SystemConfig struct {}", // Will match but should not be first choice
+			"mycompany.net/tool/config/config.go": "package config\n type SystemConfig struct {}", // Local package should be promoted over shorter package
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package main\n var c = &config.SystemConfig{}"
+		const want = `package main
+
+import "mycompany.net/tool/config"
+
+var c = &config.SystemConfig{}
+`
+		got, err := Process(filepath.Join(t.gopath, "src", "mycompany.net/tool/main.go"), []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(got) != want {
+			t.Errorf("Process = %q; want %q", got, want)
+		}
+	})
+}
+
+// Tests FindImportInLocalGoFiles looks 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.  If an import is found that satisfies the need, it should be used over the
+// standard library.
+// https://golang.org/issues/17557
+func TestFindImportInLocalGoFiles(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{
+			"bytes.net/bytes/bytes.go":  "package bytes\n type Buffer struct {}",                               // Should be selected over standard library
+			"mycompany.net/tool/io.go":  "package main\n import \"bytes.net/bytes\"\n var _ = &bytes.Buffer{}", // Contains package import that will cause stdlib to be ignored
+			"mycompany.net/tool/err.go": "package main\n import \"bogus.net/bytes\"\n var _ = &bytes.Buffer{}", // Contains import which is not resolved, so it is ignored
+		},
+	}.test(t, func(t *goimportTest) {
+		const in = "package main\n var _ = &bytes.Buffer{}"
+		const want = `package main
+
+import "bytes.net/bytes"
+
+var _ = &bytes.Buffer{}
+`
+		got, err := Process(filepath.Join(t.gopath, "src", "mycompany.net/tool/main.go"), []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(got) != want {
+			t.Errorf("Process = got %q; want %q", got, want)
+		}
+	})
+}
+
+func TestImportNoGoFiles(t *testing.T) {
+	testConfig{
+		gopathFiles: map[string]string{},
+	}.test(t, func(t *goimportTest) {
+		const in = "package main\n var _ = &bytes.Buffer{}"
+		const want = `package main
+
+import "bytes"
+
+var _ = &bytes.Buffer{}
+`
+		got, err := Process(filepath.Join(t.gopath, "src", "mycompany.net/tool/main.go"), []byte(in), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(got) != want {
+			t.Errorf("Process = got %q; want %q", got, want)
+		}
+	})
+}
+
+// A happy path test for Process
+func TestProcess(t *testing.T) {
+	in := `package testimports
+
+	var s = fmt.Sprintf("%s", "value")
+`
+	out, err := Process("foo", []byte(in), nil)
+
+	if err != nil {
+		t.Errorf("Process returned error.\n got:\n%v\nwant:\nnil", err)
+	}
+
+	want := `package testimports
+
+import "fmt"
+
+var s = fmt.Sprintf("%s", "value")
+`
+	if got := string(out); got != want {
+		t.Errorf("Process returned unexpected result.\ngot:\n%v\nwant:\n%v", got, want)
+	}
+}
+
+// Ensures a token as large as 500000 bytes can be handled
+// https://golang.org/issues/18201
+func TestProcessLargeToken(t *testing.T) {
+	largeString := strings.Repeat("x", 500000)
+
+	in := `package testimports
+
+import (
+	"fmt"
+	"mydomain.mystuff/mypkg"
+)
+
+const s = fmt.Sprintf("%s", "` + largeString + `")
+const x = mypkg.Sprintf("%s", "my package")
+
+// end
+`
+
+	out, err := Process("foo", []byte(in), nil)
+
+	if err != nil {
+		t.Errorf("Process returned error.\n got:\n%v\nwant:\nnil", err)
+	}
+
+	want := `package testimports
+
+import (
+	"fmt"
+
+	"mydomain.mystuff/mypkg"
+)
+
+const s = fmt.Sprintf("%s", "` + largeString + `")
+const x = mypkg.Sprintf("%s", "my package")
+
+// end
+`
+
+	if got := string(out); got != want {
+		t.Errorf("Process returned unexpected result.\ngot:\n%v\nwant:\n%v", got, want)
+	}
+}
diff --git a/vendor/golang.org/x/tools/imports/imports.go b/vendor/golang.org/x/tools/imports/imports.go
index e30946b..0623248 100644
--- a/vendor/golang.org/x/tools/imports/imports.go
+++ b/vendor/golang.org/x/tools/imports/imports.go
@@ -2,6 +2,8 @@
 // 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"
@@ -31,10 +33,16 @@ type Options struct {
 	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}
@@ -46,14 +54,15 @@ func Process(filename string, src []byte, opt *Options) ([]byte, error) {
 		return nil, err
 	}
 
-	_, err = fixImports(fileSet, file)
-	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
@@ -88,7 +97,10 @@ func Process(filename string, src []byte, opt *Options) ([]byte, error) {
 		out = adjust(src, out)
 	}
 	if len(spacesBefore) > 0 {
-		out = addImportSpaces(bytes.NewReader(out), spacesBefore)
+		out, err = addImportSpaces(bytes.NewReader(out), spacesBefore)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	out, err = format.Source(out)
@@ -123,11 +135,18 @@ func parse(fset *token.FileSet, filename string, src []byte, opt *Options) (*ast
 
 	// If this is a declaration list, make it a source file
 	// by inserting a package clause.
-	// Insert using a ;, not a newline, so that the line numbers
-	// in psrc match the ones in src.
-	psrc := append([]byte("package main;"), src...)
+	// 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) {
@@ -136,8 +155,7 @@ func parse(fset *token.FileSet, filename string, src []byte, opt *Options) (*ast
 
 		adjust := func(orig, src []byte) []byte {
 			// Remove the package clause.
-			// Gofmt has turned the ; into a \n.
-			src = src[len("package main\n"):]
+			src = src[len(prefix):]
 			return matchSpace(orig, src)
 		}
 		return file, adjust, nil
@@ -246,13 +264,18 @@ func matchSpace(orig []byte, src []byte) []byte {
 
 var impLine = regexp.MustCompile(`^\s+(?:[\w\.]+\s+)?"(.+)"`)
 
-func addImportSpaces(r io.Reader, breaks []string) []byte {
+func addImportSpaces(r io.Reader, breaks []string) ([]byte, error) {
 	var out bytes.Buffer
-	sc := bufio.NewScanner(r)
+	in := bufio.NewReader(r)
 	inImports := false
 	done := false
-	for sc.Scan() {
-		s := sc.Text()
+	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
@@ -266,14 +289,14 @@ func addImportSpaces(r io.Reader, breaks []string) []byte {
 		}
 		if inImports && len(breaks) > 0 {
 			if m := impLine.FindStringSubmatch(s); m != nil {
-				if m[1] == string(breaks[0]) {
+				if m[1] == breaks[0] {
 					out.WriteByte('\n')
 					breaks = breaks[1:]
 				}
 			}
 		}
 
-		fmt.Fprintln(&out, s)
+		fmt.Fprint(&out, s)
 	}
-	return out.Bytes()
+	return out.Bytes(), nil
 }
diff --git a/vendor/golang.org/x/tools/imports/mkindex.go b/vendor/golang.org/x/tools/imports/mkindex.go
new file mode 100644
index 0000000..755e239
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/mkindex.go
@@ -0,0 +1,173 @@
+// +build ignore
+
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Command mkindex creates the file "pkgindex.go" containing an index of the Go
+// standard library. The file is intended to be built as part of the imports
+// package, so that the package may be used in environments where a GOROOT is
+// not available (such as App Engine).
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+var (
+	pkgIndex = make(map[string][]pkg)
+	exports  = make(map[string]map[string]bool)
+)
+
+func main() {
+	// Don't use GOPATH.
+	ctx := build.Default
+	ctx.GOPATH = ""
+
+	// Populate pkgIndex global from GOROOT.
+	for _, path := range ctx.SrcDirs() {
+		f, err := os.Open(path)
+		if err != nil {
+			log.Print(err)
+			continue
+		}
+		children, err := f.Readdir(-1)
+		f.Close()
+		if err != nil {
+			log.Print(err)
+			continue
+		}
+		for _, child := range children {
+			if child.IsDir() {
+				loadPkg(path, child.Name())
+			}
+		}
+	}
+	// Populate exports global.
+	for _, ps := range pkgIndex {
+		for _, p := range ps {
+			e := loadExports(p.dir)
+			if e != nil {
+				exports[p.dir] = e
+			}
+		}
+	}
+
+	// Construct source file.
+	var buf bytes.Buffer
+	fmt.Fprint(&buf, pkgIndexHead)
+	fmt.Fprintf(&buf, "var pkgIndexMaster = %#v\n", pkgIndex)
+	fmt.Fprintf(&buf, "var exportsMaster = %#v\n", exports)
+	src := buf.Bytes()
+
+	// Replace main.pkg type name with pkg.
+	src = bytes.Replace(src, []byte("main.pkg"), []byte("pkg"), -1)
+	// Replace actual GOROOT with "/go".
+	src = bytes.Replace(src, []byte(ctx.GOROOT), []byte("/go"), -1)
+	// Add some line wrapping.
+	src = bytes.Replace(src, []byte("}, "), []byte("},\n"), -1)
+	src = bytes.Replace(src, []byte("true, "), []byte("true,\n"), -1)
+
+	var err error
+	src, err = format.Source(src)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Write out source file.
+	err = ioutil.WriteFile("pkgindex.go", src, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+const pkgIndexHead = `package imports
+
+func init() {
+	pkgIndexOnce.Do(func() {
+		pkgIndex.m = pkgIndexMaster
+	})
+	loadExports = func(dir string) map[string]bool {
+		return exportsMaster[dir]
+	}
+}
+`
+
+type pkg struct {
+	importpath string // full pkg import path, e.g. "net/http"
+	dir        string // absolute file path to pkg directory e.g. "/usr/lib/go/src/fmt"
+}
+
+var fset = token.NewFileSet()
+
+func loadPkg(root, importpath string) {
+	shortName := path.Base(importpath)
+	if shortName == "testdata" {
+		return
+	}
+
+	dir := filepath.Join(root, importpath)
+	pkgIndex[shortName] = append(pkgIndex[shortName], pkg{
+		importpath: importpath,
+		dir:        dir,
+	})
+
+	pkgDir, err := os.Open(dir)
+	if err != nil {
+		return
+	}
+	children, err := pkgDir.Readdir(-1)
+	pkgDir.Close()
+	if err != nil {
+		return
+	}
+	for _, child := range children {
+		name := child.Name()
+		if name == "" {
+			continue
+		}
+		if c := name[0]; c == '.' || ('0' <= c && c <= '9') {
+			continue
+		}
+		if child.IsDir() {
+			loadPkg(root, filepath.Join(importpath, name))
+		}
+	}
+}
+
+func loadExports(dir string) map[string]bool {
+	exports := make(map[string]bool)
+	buildPkg, err := build.ImportDir(dir, 0)
+	if err != nil {
+		if strings.Contains(err.Error(), "no buildable Go source files in") {
+			return nil
+		}
+		log.Printf("could not import %q: %v", dir, err)
+		return nil
+	}
+	for _, file := range buildPkg.GoFiles {
+		f, err := parser.ParseFile(fset, filepath.Join(dir, file), nil, 0)
+		if err != nil {
+			log.Printf("could not parse %q: %v", file, err)
+			continue
+		}
+		for name := range f.Scope.Objects {
+			if ast.IsExported(name) {
+				exports[name] = true
+			}
+		}
+	}
+	return exports
+}
diff --git a/vendor/golang.org/x/tools/imports/mkstdlib.go b/vendor/golang.org/x/tools/imports/mkstdlib.go
new file mode 100644
index 0000000..02e4727
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/imports/sortimports.go b/vendor/golang.org/x/tools/imports/sortimports.go
index 68b3dc4..653afc5 100644
--- a/vendor/golang.org/x/tools/imports/sortimports.go
+++ b/vendor/golang.org/x/tools/imports/sortimports.go
@@ -1,5 +1,3 @@
-// +build go1.2
-
 // 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.
diff --git a/vendor/golang.org/x/tools/imports/sortimports_compat.go b/vendor/golang.org/x/tools/imports/sortimports_compat.go
deleted file mode 100644
index 295f237..0000000
--- a/vendor/golang.org/x/tools/imports/sortimports_compat.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// +build !go1.2
-
-// 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 "go/ast"
-
-// Go 1.1 users don't get fancy package grouping.
-// But this is still gofmt-compliant:
-
-var sortImports = ast.SortImports
diff --git a/vendor/golang.org/x/tools/imports/zstdlib.go b/vendor/golang.org/x/tools/imports/zstdlib.go
index 6cdc033..c590a4b 100644
--- a/vendor/golang.org/x/tools/imports/zstdlib.go
+++ b/vendor/golang.org/x/tools/imports/zstdlib.go
@@ -1,2365 +1,3330 @@
-// AUTO-GENERATED BY mkstdlib.go
+// 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.Enumerated":                         "encoding/asn1",
-	"asn1.Flag":                               "encoding/asn1",
-	"asn1.Marshal":                            "encoding/asn1",
-	"asn1.ObjectIdentifier":                   "encoding/asn1",
-	"asn1.RawContent":                         "encoding/asn1",
-	"asn1.RawValue":                           "encoding/asn1",
-	"asn1.StructuralError":                    "encoding/asn1",
-	"asn1.SyntaxError":                        "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",
-	"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.StdEncoding":                      "encoding/base32",
-	"base64.CorruptInputError":                "encoding/base64",
-	"base64.Encoding":                         "encoding/base64",
-	"base64.NewDecoder":                       "encoding/base64",
-	"base64.NewEncoder":                       "encoding/base64",
-	"base64.NewEncoding":                      "encoding/base64",
-	"base64.StdEncoding":                      "encoding/base64",
-	"base64.URLEncoding":                      "encoding/base64",
-	"big.Int":                                 "math/big",
-	"big.MaxBase":                             "math/big",
-	"big.NewInt":                              "math/big",
-	"big.NewRat":                              "math/big",
-	"big.Rat":                                 "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",
-	"bufio.ErrAdvanceTooFar":                  "bufio",
-	"bufio.ErrBufferFull":                     "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.Import":                            "go/build",
-	"build.ImportDir":                         "go/build",
-	"build.ImportMode":                        "go/build",
-	"build.IsLocalImport":                     "go/build",
-	"build.NoGoError":                         "go/build",
-	"build.Package":                           "go/build",
-	"build.ToolDir":                           "go/build",
-	"bytes.Buffer":                            "bytes",
-	"bytes.Compare":                           "bytes",
-	"bytes.Contains":                          "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.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.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.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.Opaque":                            "image/color",
-	"color.Palette":                           "image/color",
-	"color.RGBA":                              "image/color",
-	"color.RGBA64":                            "image/color",
-	"color.RGBA64Model":                       "image/color",
-	"color.RGBAModel":                         "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",
-	"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.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.SHA512":                           "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.Stack":                             "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.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.DefaultParameterConverter":        "database/sql/driver",
-	"driver.Driver":                           "database/sql/driver",
-	"driver.ErrBadConn":                       "database/sql/driver",
-	"driver.ErrSkip":                          "database/sql/driver",
-	"driver.Execer":                           "database/sql/driver",
-	"driver.Int32":                            "database/sql/driver",
-	"driver.IsScanValue":                      "database/sql/driver",
-	"driver.IsValue":                          "database/sql/driver",
-	"driver.NotNull":                          "database/sql/driver",
-	"driver.Null":                             "database/sql/driver",
-	"driver.Queryer":                          "database/sql/driver",
-	"driver.Result":                           "database/sql/driver",
-	"driver.ResultNoRows":                     "database/sql/driver",
-	"driver.Rows":                             "database/sql/driver",
-	"driver.RowsAffected":                     "database/sql/driver",
-	"driver.Stmt":                             "database/sql/driver",
-	"driver.String":                           "database/sql/driver",
-	"driver.Tx":                               "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.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.Field":                             "debug/dwarf",
-	"dwarf.FloatType":                         "debug/dwarf",
-	"dwarf.FuncType":                          "debug/dwarf",
-	"dwarf.IntType":                           "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.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.TagSetType":                        "debug/dwarf",
-	"dwarf.TagStringType":                     "debug/dwarf",
-	"dwarf.TagStructType":                     "debug/dwarf",
-	"dwarf.TagSubprogram":                     "debug/dwarf",
-	"dwarf.TagSubrangeType":                   "debug/dwarf",
-	"dwarf.TagSubroutineType":                 "debug/dwarf",
-	"dwarf.TagTemplateTypeParameter":          "debug/dwarf",
-	"dwarf.TagTemplateValueParameter":         "debug/dwarf",
-	"dwarf.TagThrownType":                     "debug/dwarf",
-	"dwarf.TagTryDwarfBlock":                  "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.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.Class":                               "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_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.File":                                "debug/elf",
-	"elf.FileHeader":                          "debug/elf",
-	"elf.FormatError":                         "debug/elf",
-	"elf.Header32":                            "debug/elf",
-	"elf.Header64":                            "debug/elf",
-	"elf.ImportedSymbol":                      "debug/elf",
-	"elf.Machine":                             "debug/elf",
-	"elf.NT_FPREGSET":                         "debug/elf",
-	"elf.NT_PRPSINFO":                         "debug/elf",
-	"elf.NT_PRSTATUS":                         "debug/elf",
-	"elf.NType":                               "debug/elf",
-	"elf.NewFile":                             "debug/elf",
-	"elf.OSABI":                               "debug/elf",
-	"elf.Open":                                "debug/elf",
-	"elf.PF_MASKOS":                           "debug/elf",
-	"elf.PF_MASKPROC":                         "debug/elf",
-	"elf.PF_R":                                "debug/elf",
-	"elf.PF_W":                                "debug/elf",
-	"elf.PF_X":                                "debug/elf",
-	"elf.PT_DYNAMIC":                          "debug/elf",
-	"elf.PT_HIOS":                             "debug/elf",
-	"elf.PT_HIPROC":                           "debug/elf",
-	"elf.PT_INTERP":                           "debug/elf",
-	"elf.PT_LOAD":                             "debug/elf",
-	"elf.PT_LOOS":                             "debug/elf",
-	"elf.PT_LOPROC":                           "debug/elf",
-	"elf.PT_NOTE":                             "debug/elf",
-	"elf.PT_NULL":                             "debug/elf",
-	"elf.PT_PHDR":                             "debug/elf",
-	"elf.PT_SHLIB":                            "debug/elf",
-	"elf.PT_TLS":                              "debug/elf",
-	"elf.Prog":                                "debug/elf",
-	"elf.Prog32":                              "debug/elf",
-	"elf.Prog64":                              "debug/elf",
-	"elf.ProgFlag":                            "debug/elf",
-	"elf.ProgHeader":                          "debug/elf",
-	"elf.ProgType":                            "debug/elf",
-	"elf.R_386":                               "debug/elf",
-	"elf.R_386_32":                            "debug/elf",
-	"elf.R_386_COPY":                          "debug/elf",
-	"elf.R_386_GLOB_DAT":                      "debug/elf",
-	"elf.R_386_GOT32":                         "debug/elf",
-	"elf.R_386_GOTOFF":                        "debug/elf",
-	"elf.R_386_GOTPC":                         "debug/elf",
-	"elf.R_386_JMP_SLOT":                      "debug/elf",
-	"elf.R_386_NONE":                          "debug/elf",
-	"elf.R_386_PC32":                          "debug/elf",
-	"elf.R_386_PLT32":                         "debug/elf",
-	"elf.R_386_RELATIVE":                      "debug/elf",
-	"elf.R_386_TLS_DTPMOD32":                  "debug/elf",
-	"elf.R_386_TLS_DTPOFF32":                  "debug/elf",
-	"elf.R_386_TLS_GD":                        "debug/elf",
-	"elf.R_386_TLS_GD_32":                     "debug/elf",
-	"elf.R_386_TLS_GD_CALL":                   "debug/elf",
-	"elf.R_386_TLS_GD_POP":                    "debug/elf",
-	"elf.R_386_TLS_GD_PUSH":                   "debug/elf",
-	"elf.R_386_TLS_GOTIE":                     "debug/elf",
-	"elf.R_386_TLS_IE":                        "debug/elf",
-	"elf.R_386_TLS_IE_32":                     "debug/elf",
-	"elf.R_386_TLS_LDM":                       "debug/elf",
-	"elf.R_386_TLS_LDM_32":                    "debug/elf",
-	"elf.R_386_TLS_LDM_CALL":                  "debug/elf",
-	"elf.R_386_TLS_LDM_POP":                   "debug/elf",
-	"elf.R_386_TLS_LDM_PUSH":                  "debug/elf",
-	"elf.R_386_TLS_LDO_32":                    "debug/elf",
-	"elf.R_386_TLS_LE":                        "debug/elf",
-	"elf.R_386_TLS_LE_32":                     "debug/elf",
-	"elf.R_386_TLS_TPOFF":                     "debug/elf",
-	"elf.R_386_TLS_TPOFF32":                   "debug/elf",
-	"elf.R_ALPHA":                             "debug/elf",
-	"elf.R_ALPHA_BRADDR":                      "debug/elf",
-	"elf.R_ALPHA_COPY":                        "debug/elf",
-	"elf.R_ALPHA_GLOB_DAT":                    "debug/elf",
-	"elf.R_ALPHA_GPDISP":                      "debug/elf",
-	"elf.R_ALPHA_GPREL32":                     "debug/elf",
-	"elf.R_ALPHA_GPRELHIGH":                   "debug/elf",
-	"elf.R_ALPHA_GPRELLOW":                    "debug/elf",
-	"elf.R_ALPHA_GPVALUE":                     "debug/elf",
-	"elf.R_ALPHA_HINT":                        "debug/elf",
-	"elf.R_ALPHA_IMMED_BR_HI32":               "debug/elf",
-	"elf.R_ALPHA_IMMED_GP_16":                 "debug/elf",
-	"elf.R_ALPHA_IMMED_GP_HI32":               "debug/elf",
-	"elf.R_ALPHA_IMMED_LO32":                  "debug/elf",
-	"elf.R_ALPHA_IMMED_SCN_HI32":              "debug/elf",
-	"elf.R_ALPHA_JMP_SLOT":                    "debug/elf",
-	"elf.R_ALPHA_LITERAL":                     "debug/elf",
-	"elf.R_ALPHA_LITUSE":                      "debug/elf",
-	"elf.R_ALPHA_NONE":                        "debug/elf",
-	"elf.R_ALPHA_OP_PRSHIFT":                  "debug/elf",
-	"elf.R_ALPHA_OP_PSUB":                     "debug/elf",
-	"elf.R_ALPHA_OP_PUSH":                     "debug/elf",
-	"elf.R_ALPHA_OP_STORE":                    "debug/elf",
-	"elf.R_ALPHA_REFLONG":                     "debug/elf",
-	"elf.R_ALPHA_REFQUAD":                     "debug/elf",
-	"elf.R_ALPHA_RELATIVE":                    "debug/elf",
-	"elf.R_ALPHA_SREL16":                      "debug/elf",
-	"elf.R_ALPHA_SREL32":                      "debug/elf",
-	"elf.R_ALPHA_SREL64":                      "debug/elf",
-	"elf.R_ARM":                               "debug/elf",
-	"elf.R_ARM_ABS12":                         "debug/elf",
-	"elf.R_ARM_ABS16":                         "debug/elf",
-	"elf.R_ARM_ABS32":                         "debug/elf",
-	"elf.R_ARM_ABS8":                          "debug/elf",
-	"elf.R_ARM_AMP_VCALL9":                    "debug/elf",
-	"elf.R_ARM_COPY":                          "debug/elf",
-	"elf.R_ARM_GLOB_DAT":                      "debug/elf",
-	"elf.R_ARM_GNU_VTENTRY":                   "debug/elf",
-	"elf.R_ARM_GNU_VTINHERIT":                 "debug/elf",
-	"elf.R_ARM_GOT32":                         "debug/elf",
-	"elf.R_ARM_GOTOFF":                        "debug/elf",
-	"elf.R_ARM_GOTPC":                         "debug/elf",
-	"elf.R_ARM_JUMP_SLOT":                     "debug/elf",
-	"elf.R_ARM_NONE":                          "debug/elf",
-	"elf.R_ARM_PC13":                          "debug/elf",
-	"elf.R_ARM_PC24":                          "debug/elf",
-	"elf.R_ARM_PLT32":                         "debug/elf",
-	"elf.R_ARM_RABS32":                        "debug/elf",
-	"elf.R_ARM_RBASE":                         "debug/elf",
-	"elf.R_ARM_REL32":                         "debug/elf",
-	"elf.R_ARM_RELATIVE":                      "debug/elf",
-	"elf.R_ARM_RPC24":                         "debug/elf",
-	"elf.R_ARM_RREL32":                        "debug/elf",
-	"elf.R_ARM_RSBREL32":                      "debug/elf",
-	"elf.R_ARM_SBREL32":                       "debug/elf",
-	"elf.R_ARM_SWI24":                         "debug/elf",
-	"elf.R_ARM_THM_ABS5":                      "debug/elf",
-	"elf.R_ARM_THM_PC22":                      "debug/elf",
-	"elf.R_ARM_THM_PC8":                       "debug/elf",
-	"elf.R_ARM_THM_RPC22":                     "debug/elf",
-	"elf.R_ARM_THM_SWI8":                      "debug/elf",
-	"elf.R_ARM_THM_XPC22":                     "debug/elf",
-	"elf.R_ARM_XPC25":                         "debug/elf",
-	"elf.R_INFO":                              "debug/elf",
-	"elf.R_INFO32":                            "debug/elf",
-	"elf.R_PPC":                               "debug/elf",
-	"elf.R_PPC_ADDR14":                        "debug/elf",
-	"elf.R_PPC_ADDR14_BRNTAKEN":               "debug/elf",
-	"elf.R_PPC_ADDR14_BRTAKEN":                "debug/elf",
-	"elf.R_PPC_ADDR16":                        "debug/elf",
-	"elf.R_PPC_ADDR16_HA":                     "debug/elf",
-	"elf.R_PPC_ADDR16_HI":                     "debug/elf",
-	"elf.R_PPC_ADDR16_LO":                     "debug/elf",
-	"elf.R_PPC_ADDR24":                        "debug/elf",
-	"elf.R_PPC_ADDR32":                        "debug/elf",
-	"elf.R_PPC_COPY":                          "debug/elf",
-	"elf.R_PPC_DTPMOD32":                      "debug/elf",
-	"elf.R_PPC_DTPREL16":                      "debug/elf",
-	"elf.R_PPC_DTPREL16_HA":                   "debug/elf",
-	"elf.R_PPC_DTPREL16_HI":                   "debug/elf",
-	"elf.R_PPC_DTPREL16_LO":                   "debug/elf",
-	"elf.R_PPC_DTPREL32":                      "debug/elf",
-	"elf.R_PPC_EMB_BIT_FLD":                   "debug/elf",
-	"elf.R_PPC_EMB_MRKREF":                    "debug/elf",
-	"elf.R_PPC_EMB_NADDR16":                   "debug/elf",
-	"elf.R_PPC_EMB_NADDR16_HA":                "debug/elf",
-	"elf.R_PPC_EMB_NADDR16_HI":                "debug/elf",
-	"elf.R_PPC_EMB_NADDR16_LO":                "debug/elf",
-	"elf.R_PPC_EMB_NADDR32":                   "debug/elf",
-	"elf.R_PPC_EMB_RELSDA":                    "debug/elf",
-	"elf.R_PPC_EMB_RELSEC16":                  "debug/elf",
-	"elf.R_PPC_EMB_RELST_HA":                  "debug/elf",
-	"elf.R_PPC_EMB_RELST_HI":                  "debug/elf",
-	"elf.R_PPC_EMB_RELST_LO":                  "debug/elf",
-	"elf.R_PPC_EMB_SDA21":                     "debug/elf",
-	"elf.R_PPC_EMB_SDA2I16":                   "debug/elf",
-	"elf.R_PPC_EMB_SDA2REL":                   "debug/elf",
-	"elf.R_PPC_EMB_SDAI16":                    "debug/elf",
-	"elf.R_PPC_GLOB_DAT":                      "debug/elf",
-	"elf.R_PPC_GOT16":                         "debug/elf",
-	"elf.R_PPC_GOT16_HA":                      "debug/elf",
-	"elf.R_PPC_GOT16_HI":                      "debug/elf",
-	"elf.R_PPC_GOT16_LO":                      "debug/elf",
-	"elf.R_PPC_GOT_TLSGD16":                   "debug/elf",
-	"elf.R_PPC_GOT_TLSGD16_HA":                "debug/elf",
-	"elf.R_PPC_GOT_TLSGD16_HI":                "debug/elf",
-	"elf.R_PPC_GOT_TLSGD16_LO":                "debug/elf",
-	"elf.R_PPC_GOT_TLSLD16":                   "debug/elf",
-	"elf.R_PPC_GOT_TLSLD16_HA":                "debug/elf",
-	"elf.R_PPC_GOT_TLSLD16_HI":                "debug/elf",
-	"elf.R_PPC_GOT_TLSLD16_LO":                "debug/elf",
-	"elf.R_PPC_GOT_TPREL16":                   "debug/elf",
-	"elf.R_PPC_GOT_TPREL16_HA":                "debug/elf",
-	"elf.R_PPC_GOT_TPREL16_HI":                "debug/elf",
-	"elf.R_PPC_GOT_TPREL16_LO":                "debug/elf",
-	"elf.R_PPC_JMP_SLOT":                      "debug/elf",
-	"elf.R_PPC_LOCAL24PC":                     "debug/elf",
-	"elf.R_PPC_NONE":                          "debug/elf",
-	"elf.R_PPC_PLT16_HA":                      "debug/elf",
-	"elf.R_PPC_PLT16_HI":                      "debug/elf",
-	"elf.R_PPC_PLT16_LO":                      "debug/elf",
-	"elf.R_PPC_PLT32":                         "debug/elf",
-	"elf.R_PPC_PLTREL24":                      "debug/elf",
-	"elf.R_PPC_PLTREL32":                      "debug/elf",
-	"elf.R_PPC_REL14":                         "debug/elf",
-	"elf.R_PPC_REL14_BRNTAKEN":                "debug/elf",
-	"elf.R_PPC_REL14_BRTAKEN":                 "debug/elf",
-	"elf.R_PPC_REL24":                         "debug/elf",
-	"elf.R_PPC_REL32":                         "debug/elf",
-	"elf.R_PPC_RELATIVE":                      "debug/elf",
-	"elf.R_PPC_SDAREL16":                      "debug/elf",
-	"elf.R_PPC_SECTOFF":                       "debug/elf",
-	"elf.R_PPC_SECTOFF_HA":                    "debug/elf",
-	"elf.R_PPC_SECTOFF_HI":                    "debug/elf",
-	"elf.R_PPC_SECTOFF_LO":                    "debug/elf",
-	"elf.R_PPC_TLS":                           "debug/elf",
-	"elf.R_PPC_TPREL16":                       "debug/elf",
-	"elf.R_PPC_TPREL16_HA":                    "debug/elf",
-	"elf.R_PPC_TPREL16_HI":                    "debug/elf",
-	"elf.R_PPC_TPREL16_LO":                    "debug/elf",
-	"elf.R_PPC_TPREL32":                       "debug/elf",
-	"elf.R_PPC_UADDR16":                       "debug/elf",
-	"elf.R_PPC_UADDR32":                       "debug/elf",
-	"elf.R_SPARC":                             "debug/elf",
-	"elf.R_SPARC_10":                          "debug/elf",
-	"elf.R_SPARC_11":                          "debug/elf",
-	"elf.R_SPARC_13":                          "debug/elf",
-	"elf.R_SPARC_16":                          "debug/elf",
-	"elf.R_SPARC_22":                          "debug/elf",
-	"elf.R_SPARC_32":                          "debug/elf",
-	"elf.R_SPARC_5":                           "debug/elf",
-	"elf.R_SPARC_6":                           "debug/elf",
-	"elf.R_SPARC_64":                          "debug/elf",
-	"elf.R_SPARC_7":                           "debug/elf",
-	"elf.R_SPARC_8":                           "debug/elf",
-	"elf.R_SPARC_COPY":                        "debug/elf",
-	"elf.R_SPARC_DISP16":                      "debug/elf",
-	"elf.R_SPARC_DISP32":                      "debug/elf",
-	"elf.R_SPARC_DISP64":                      "debug/elf",
-	"elf.R_SPARC_DISP8":                       "debug/elf",
-	"elf.R_SPARC_GLOB_DAT":                    "debug/elf",
-	"elf.R_SPARC_GLOB_JMP":                    "debug/elf",
-	"elf.R_SPARC_GOT10":                       "debug/elf",
-	"elf.R_SPARC_GOT13":                       "debug/elf",
-	"elf.R_SPARC_GOT22":                       "debug/elf",
-	"elf.R_SPARC_H44":                         "debug/elf",
-	"elf.R_SPARC_HH22":                        "debug/elf",
-	"elf.R_SPARC_HI22":                        "debug/elf",
-	"elf.R_SPARC_HIPLT22":                     "debug/elf",
-	"elf.R_SPARC_HIX22":                       "debug/elf",
-	"elf.R_SPARC_HM10":                        "debug/elf",
-	"elf.R_SPARC_JMP_SLOT":                    "debug/elf",
-	"elf.R_SPARC_L44":                         "debug/elf",
-	"elf.R_SPARC_LM22":                        "debug/elf",
-	"elf.R_SPARC_LO10":                        "debug/elf",
-	"elf.R_SPARC_LOPLT10":                     "debug/elf",
-	"elf.R_SPARC_LOX10":                       "debug/elf",
-	"elf.R_SPARC_M44":                         "debug/elf",
-	"elf.R_SPARC_NONE":                        "debug/elf",
-	"elf.R_SPARC_OLO10":                       "debug/elf",
-	"elf.R_SPARC_PC10":                        "debug/elf",
-	"elf.R_SPARC_PC22":                        "debug/elf",
-	"elf.R_SPARC_PCPLT10":                     "debug/elf",
-	"elf.R_SPARC_PCPLT22":                     "debug/elf",
-	"elf.R_SPARC_PCPLT32":                     "debug/elf",
-	"elf.R_SPARC_PC_HH22":                     "debug/elf",
-	"elf.R_SPARC_PC_HM10":                     "debug/elf",
-	"elf.R_SPARC_PC_LM22":                     "debug/elf",
-	"elf.R_SPARC_PLT32":                       "debug/elf",
-	"elf.R_SPARC_PLT64":                       "debug/elf",
-	"elf.R_SPARC_REGISTER":                    "debug/elf",
-	"elf.R_SPARC_RELATIVE":                    "debug/elf",
-	"elf.R_SPARC_UA16":                        "debug/elf",
-	"elf.R_SPARC_UA32":                        "debug/elf",
-	"elf.R_SPARC_UA64":                        "debug/elf",
-	"elf.R_SPARC_WDISP16":                     "debug/elf",
-	"elf.R_SPARC_WDISP19":                     "debug/elf",
-	"elf.R_SPARC_WDISP22":                     "debug/elf",
-	"elf.R_SPARC_WDISP30":                     "debug/elf",
-	"elf.R_SPARC_WPLT30":                      "debug/elf",
-	"elf.R_SYM32":                             "debug/elf",
-	"elf.R_SYM64":                             "debug/elf",
-	"elf.R_TYPE32":                            "debug/elf",
-	"elf.R_TYPE64":                            "debug/elf",
-	"elf.R_X86_64":                            "debug/elf",
-	"elf.R_X86_64_16":                         "debug/elf",
-	"elf.R_X86_64_32":                         "debug/elf",
-	"elf.R_X86_64_32S":                        "debug/elf",
-	"elf.R_X86_64_64":                         "debug/elf",
-	"elf.R_X86_64_8":                          "debug/elf",
-	"elf.R_X86_64_COPY":                       "debug/elf",
-	"elf.R_X86_64_DTPMOD64":                   "debug/elf",
-	"elf.R_X86_64_DTPOFF32":                   "debug/elf",
-	"elf.R_X86_64_DTPOFF64":                   "debug/elf",
-	"elf.R_X86_64_GLOB_DAT":                   "debug/elf",
-	"elf.R_X86_64_GOT32":                      "debug/elf",
-	"elf.R_X86_64_GOTPCREL":                   "debug/elf",
-	"elf.R_X86_64_GOTTPOFF":                   "debug/elf",
-	"elf.R_X86_64_JMP_SLOT":                   "debug/elf",
-	"elf.R_X86_64_NONE":                       "debug/elf",
-	"elf.R_X86_64_PC16":                       "debug/elf",
-	"elf.R_X86_64_PC32":                       "debug/elf",
-	"elf.R_X86_64_PC8":                        "debug/elf",
-	"elf.R_X86_64_PLT32":                      "debug/elf",
-	"elf.R_X86_64_RELATIVE":                   "debug/elf",
-	"elf.R_X86_64_TLSGD":                      "debug/elf",
-	"elf.R_X86_64_TLSLD":                      "debug/elf",
-	"elf.R_X86_64_TPOFF32":                    "debug/elf",
-	"elf.R_X86_64_TPOFF64":                    "debug/elf",
-	"elf.Rel32":                               "debug/elf",
-	"elf.Rel64":                               "debug/elf",
-	"elf.Rela32":                              "debug/elf",
-	"elf.Rela64":                              "debug/elf",
-	"elf.SHF_ALLOC":                           "debug/elf",
-	"elf.SHF_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.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.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.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.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.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.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.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.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.NewReader":                          "compress/gzip",
-	"gzip.NewWriter":                          "compress/gzip",
-	"gzip.NewWriterLevel":                     "compress/gzip",
-	"gzip.NoCompression":                      "compress/gzip",
-	"gzip.Reader":                             "compress/gzip",
-	"gzip.Writer":                             "compress/gzip",
-	"hash.Hash":                               "hash",
-	"hash.Hash32":                             "hash",
-	"hash.Hash64":                             "hash",
-	"heap.Fix":                                "container/heap",
-	"heap.Init":                               "container/heap",
-	"heap.Interface":                          "container/heap",
-	"heap.Pop":                                "container/heap",
-	"heap.Push":                               "container/heap",
-	"heap.Remove":                             "container/heap",
-	"hex.Decode":                              "encoding/hex",
-	"hex.DecodeString":                        "encoding/hex",
-	"hex.DecodedLen":                          "encoding/hex",
-	"hex.Dump":                                "encoding/hex",
-	"hex.Dumper":                              "encoding/hex",
-	"hex.Encode":                              "encoding/hex",
-	"hex.EncodeToString":                      "encoding/hex",
-	"hex.EncodedLen":                          "encoding/hex",
-	"hex.ErrLength":                           "encoding/hex",
-	"hex.InvalidByteError":                    "encoding/hex",
-	"hmac.Equal":                              "crypto/hmac",
-	"hmac.New":                                "crypto/hmac",
-	"html.EscapeString":                       "html",
-	"html.UnescapeString":                     "html",
-	"http.CanonicalHeaderKey":                 "net/http",
-	"http.Client":                             "net/http",
-	"http.CloseNotifier":                      "net/http",
-	"http.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.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.ErrShortBody":                       "net/http",
-	"http.ErrUnexpectedTrailer":               "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.MaxBytesReader":                     "net/http",
-	"http.NewFileTransport":                   "net/http",
-	"http.NewRequest":                         "net/http",
-	"http.NewServeMux":                        "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.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.Server":                             "net/http",
-	"http.SetCookie":                          "net/http",
-	"http.StatusAccepted":                     "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.StatusForbidden":                    "net/http",
-	"http.StatusFound":                        "net/http",
-	"http.StatusGatewayTimeout":               "net/http",
-	"http.StatusGone":                         "net/http",
-	"http.StatusHTTPVersionNotSupported":      "net/http",
-	"http.StatusInternalServerError":          "net/http",
-	"http.StatusLengthRequired":               "net/http",
-	"http.StatusMethodNotAllowed":             "net/http",
-	"http.StatusMovedPermanently":             "net/http",
-	"http.StatusMultipleChoices":              "net/http",
-	"http.StatusNoContent":                    "net/http",
-	"http.StatusNonAuthoritativeInfo":         "net/http",
-	"http.StatusNotAcceptable":                "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.StatusPreconditionFailed":           "net/http",
-	"http.StatusProxyAuthRequired":            "net/http",
-	"http.StatusRequestEntityTooLarge":        "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.StatusUnauthorized":                 "net/http",
-	"http.StatusUnsupportedMediaType":         "net/http",
-	"http.StatusUseProxy":                     "net/http",
-	"http.StripPrefix":                        "net/http",
-	"http.TimeFormat":                         "net/http",
-	"http.TimeoutHandler":                     "net/http",
-	"http.Transport":                          "net/http",
-	"httptest.DefaultRemoteAddr":              "net/http/httptest",
-	"httptest.NewRecorder":                    "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",
-	"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.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.NewAlpha":                          "image",
-	"image.NewAlpha16":                        "image",
-	"image.NewGray":                           "image",
-	"image.NewGray16":                         "image",
-	"image.NewNRGBA":                          "image",
-	"image.NewNRGBA64":                        "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.YCbCrSubsampleRatio420":            "image",
-	"image.YCbCrSubsampleRatio422":            "image",
-	"image.YCbCrSubsampleRatio440":            "image",
-	"image.YCbCrSubsampleRatio444":            "image",
-	"image.ZP":                                "image",
-	"image.ZR":                                "image",
-	"io.ByteReader":                           "io",
-	"io.ByteScanner":                          "io",
-	"io.ByteWriter":                           "io",
-	"io.Closer":                               "io",
-	"io.Copy":                                 "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.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.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.Unmarshal":                          "encoding/json",
-	"json.UnmarshalFieldError":                "encoding/json",
-	"json.UnmarshalTypeError":                 "encoding/json",
-	"json.Unmarshaler":                        "encoding/json",
-	"json.UnsupportedTypeError":               "encoding/json",
-	"json.UnsupportedValueError":              "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.Ldate":                               "log",
-	"log.Llongfile":                           "log",
-	"log.Lmicroseconds":                       "log",
-	"log.Logger":                              "log",
-	"log.Lshortfile":                          "log",
-	"log.LstdFlags":                           "log",
-	"log.Ltime":                               "log",
-	"log.New":                                 "log",
-	"log.Panic":                               "log",
-	"log.Panicf":                              "log",
-	"log.Panicln":                             "log",
-	"log.Prefix":                              "log",
-	"log.Print":                               "log",
-	"log.Printf":                              "log",
-	"log.Println":                             "log",
-	"log.SetFlags":                            "log",
-	"log.SetOutput":                           "log",
-	"log.SetPrefix":                           "log",
-	"lzw.LSB":                                 "compress/lzw",
-	"lzw.MSB":                                 "compress/lzw",
-	"lzw.NewReader":                           "compress/lzw",
-	"lzw.NewWriter":                           "compress/lzw",
-	"lzw.Order":                               "compress/lzw",
-	"macho.Cpu":                               "debug/macho",
-	"macho.Cpu386":                            "debug/macho",
-	"macho.CpuAmd64":                          "debug/macho",
-	"macho.Dylib":                             "debug/macho",
-	"macho.DylibCmd":                          "debug/macho",
-	"macho.Dysymtab":                          "debug/macho",
-	"macho.DysymtabCmd":                       "debug/macho",
-	"macho.File":                              "debug/macho",
-	"macho.FileHeader":                        "debug/macho",
-	"macho.FormatError":                       "debug/macho",
-	"macho.Load":                              "debug/macho",
-	"macho.LoadBytes":                         "debug/macho",
-	"macho.LoadCmd":                           "debug/macho",
-	"macho.LoadCmdDylib":                      "debug/macho",
-	"macho.LoadCmdDylinker":                   "debug/macho",
-	"macho.LoadCmdDysymtab":                   "debug/macho",
-	"macho.LoadCmdSegment":                    "debug/macho",
-	"macho.LoadCmdSegment64":                  "debug/macho",
-	"macho.LoadCmdSymtab":                     "debug/macho",
-	"macho.LoadCmdThread":                     "debug/macho",
-	"macho.LoadCmdUnixThread":                 "debug/macho",
-	"macho.Magic32":                           "debug/macho",
-	"macho.Magic64":                           "debug/macho",
-	"macho.NewFile":                           "debug/macho",
-	"macho.Nlist32":                           "debug/macho",
-	"macho.Nlist64":                           "debug/macho",
-	"macho.Open":                              "debug/macho",
-	"macho.Regs386":                           "debug/macho",
-	"macho.RegsAMD64":                         "debug/macho",
-	"macho.Section":                           "debug/macho",
-	"macho.Section32":                         "debug/macho",
-	"macho.Section64":                         "debug/macho",
-	"macho.SectionHeader":                     "debug/macho",
-	"macho.Segment":                           "debug/macho",
-	"macho.Segment32":                         "debug/macho",
-	"macho.Segment64":                         "debug/macho",
-	"macho.SegmentHeader":                     "debug/macho",
-	"macho.Symbol":                            "debug/macho",
-	"macho.Symtab":                            "debug/macho",
-	"macho.SymtabCmd":                         "debug/macho",
-	"macho.Thread":                            "debug/macho",
-	"macho.Type":                              "debug/macho",
-	"macho.TypeExec":                          "debug/macho",
-	"macho.TypeObj":                           "debug/macho",
-	"mail.Address":                            "net/mail",
-	"mail.ErrHeaderNotPresent":                "net/mail",
-	"mail.Header":                             "net/mail",
-	"mail.Message":                            "net/mail",
-	"mail.ParseAddress":                       "net/mail",
-	"mail.ParseAddressList":                   "net/mail",
-	"mail.ReadMessage":                        "net/mail",
-	"math.Abs":                                "math",
-	"math.Acos":                               "math",
-	"math.Acosh":                              "math",
-	"math.Asin":                               "math",
-	"math.Asinh":                              "math",
-	"math.Atan":                               "math",
-	"math.Atan2":                              "math",
-	"math.Atanh":                              "math",
-	"math.Cbrt":                               "math",
-	"math.Ceil":                               "math",
-	"math.Copysign":                           "math",
-	"math.Cos":                                "math",
-	"math.Cosh":                               "math",
-	"math.Dim":                                "math",
-	"math.E":                                  "math",
-	"math.Erf":                                "math",
-	"math.Erfc":                               "math",
-	"math.Exp":                                "math",
-	"math.Exp2":                               "math",
-	"math.Expm1":                              "math",
-	"math.Float32bits":                        "math",
-	"math.Float32frombits":                    "math",
-	"math.Float64bits":                        "math",
-	"math.Float64frombits":                    "math",
-	"math.Floor":                              "math",
-	"math.Frexp":                              "math",
-	"math.Gamma":                              "math",
-	"math.Hypot":                              "math",
-	"math.Ilogb":                              "math",
-	"math.Inf":                                "math",
-	"math.IsInf":                              "math",
-	"math.IsNaN":                              "math",
-	"math.J0":                                 "math",
-	"math.J1":                                 "math",
-	"math.Jn":                                 "math",
-	"math.Ldexp":                              "math",
-	"math.Lgamma":                             "math",
-	"math.Ln10":                               "math",
-	"math.Ln2":                                "math",
-	"math.Log":                                "math",
-	"math.Log10":                              "math",
-	"math.Log10E":                             "math",
-	"math.Log1p":                              "math",
-	"math.Log2":                               "math",
-	"math.Log2E":                              "math",
-	"math.Logb":                               "math",
-	"math.Max":                                "math",
-	"math.MaxFloat32":                         "math",
-	"math.MaxFloat64":                         "math",
-	"math.MaxInt16":                           "math",
-	"math.MaxInt32":                           "math",
-	"math.MaxInt64":                           "math",
-	"math.MaxInt8":                            "math",
-	"math.MaxUint16":                          "math",
-	"math.MaxUint32":                          "math",
-	"math.MaxUint64":                          "math",
-	"math.MaxUint8":                           "math",
-	"math.Min":                                "math",
-	"math.MinInt16":                           "math",
-	"math.MinInt32":                           "math",
-	"math.MinInt64":                           "math",
-	"math.MinInt8":                            "math",
-	"math.Mod":                                "math",
-	"math.Modf":                               "math",
-	"math.NaN":                                "math",
-	"math.Nextafter":                          "math",
-	"math.Phi":                                "math",
-	"math.Pi":                                 "math",
-	"math.Pow":                                "math",
-	"math.Pow10":                              "math",
-	"math.Remainder":                          "math",
-	"math.Signbit":                            "math",
-	"math.Sin":                                "math",
-	"math.Sincos":                             "math",
-	"math.Sinh":                               "math",
-	"math.SmallestNonzeroFloat32":             "math",
-	"math.SmallestNonzeroFloat64":             "math",
-	"math.Sqrt":                               "math",
-	"math.Sqrt2":                              "math",
-	"math.SqrtE":                              "math",
-	"math.SqrtPhi":                            "math",
-	"math.SqrtPi":                             "math",
-	"math.Tan":                                "math",
-	"math.Tanh":                               "math",
-	"math.Trunc":                              "math",
-	"math.Y0":                                 "math",
-	"math.Y1":                                 "math",
-	"math.Yn":                                 "math",
-	"md5.BlockSize":                           "crypto/md5",
-	"md5.New":                                 "crypto/md5",
-	"md5.Size":                                "crypto/md5",
-	"md5.Sum":                                 "crypto/md5",
-	"mime.AddExtensionType":                   "mime",
-	"mime.FormatMediaType":                    "mime",
-	"mime.ParseMediaType":                     "mime",
-	"mime.TypeByExtension":                    "mime",
-	"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.CIDRMask":                            "net",
-	"net.Conn":                                "net",
-	"net.DNSConfigError":                      "net",
-	"net.DNSError":                            "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.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.ErrExist":                             "os",
-	"os.ErrInvalid":                           "os",
-	"os.ErrNotExist":                          "os",
-	"os.ErrPermission":                        "os",
-	"os.Exit":                                 "os",
-	"os.Expand":                               "os",
-	"os.ExpandEnv":                            "os",
-	"os.File":                                 "os",
-	"os.FileInfo":                             "os",
-	"os.FileMode":                             "os",
-	"os.FindProcess":                          "os",
-	"os.Getegid":                              "os",
-	"os.Getenv":                               "os",
-	"os.Geteuid":                              "os",
-	"os.Getgid":                               "os",
-	"os.Getgroups":                            "os",
-	"os.Getpagesize":                          "os",
-	"os.Getpid":                               "os",
-	"os.Getppid":                              "os",
-	"os.Getuid":                               "os",
-	"os.Getwd":                                "os",
-	"os.Hostname":                             "os",
-	"os.Interrupt":                            "os",
-	"os.IsExist":                              "os",
-	"os.IsNotExist":                           "os",
-	"os.IsPathSeparator":                      "os",
-	"os.IsPermission":                         "os",
-	"os.Kill":                                 "os",
-	"os.Lchown":                               "os",
-	"os.Link":                                 "os",
-	"os.LinkError":                            "os",
-	"os.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",
-	"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.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.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.Section":                              "debug/pe",
-	"pe.SectionHeader":                        "debug/pe",
-	"pe.SectionHeader32":                      "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.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",
-	"png.Decode":                              "image/png",
-	"png.DecodeConfig":                        "image/png",
-	"png.Encode":                              "image/png",
-	"png.FormatError":                         "image/png",
-	"png.UnsupportedError":                    "image/png",
-	"pprof.Cmdline":                           "net/http/pprof",
-	"pprof.Handler":                           "net/http/pprof",
-	"pprof.Index":                             "net/http/pprof",
-	"pprof.Lookup":                            "runtime/pprof",
-	"pprof.NewProfile":                        "runtime/pprof",
+	"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.StartCPUProfile":  "runtime/pprof",
-	"pprof.StopCPUProfile":   "runtime/pprof",
-	"pprof.Symbol":           "net/http/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",
-	"rand.ExpFloat64":        "math/rand",
-	"rand.Float32":           "math/rand",
-	"rand.Float64":           "math/rand",
+	"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":                     "crypto/rand",
-	"rand.Reader":                   "crypto/rand",
-	"rand.Seed":                     "math/rand",
-	"rand.Source":                   "math/rand",
-	"rand.Uint32":                   "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.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.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.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.StructTag":             "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.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.Compiler":              "runtime",
-	"runtime.Error":                 "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.LockOSThread":          "runtime",
-	"runtime.MemProfile":            "runtime",
-	"runtime.MemProfileRate":        "runtime",
-	"runtime.MemProfileRecord":      "runtime",
-	"runtime.MemStats":              "runtime",
-	"runtime.NumCPU":                "runtime",
-	"runtime.NumCgoCall":            "runtime",
-	"runtime.NumGoroutine":          "runtime",
-	"runtime.ReadMemStats":          "runtime",
-	"runtime.SetBlockProfileRate":   "runtime",
-	"runtime.SetCPUProfileRate":     "runtime",
-	"runtime.SetFinalizer":          "runtime",
-	"runtime.Stack":                 "runtime",
-	"runtime.StackRecord":           "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",
+	"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",
@@ -2384,11 +3349,19 @@ var stdlib = map[string]string{
 	"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",
@@ -2411,19 +3384,40 @@ var stdlib = map[string]string{
 	"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",
@@ -2432,13 +3426,16 @@ var stdlib = map[string]string{
 	"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",
@@ -2449,6 +3446,7 @@ var stdlib = map[string]string{
 	"strconv.FormatInt":                                    "strconv",
 	"strconv.FormatUint":                                   "strconv",
 	"strconv.IntSize":                                      "strconv",
+	"strconv.IsGraphic":                                    "strconv",
 	"strconv.IsPrint":                                      "strconv",
 	"strconv.Itoa":                                         "strconv",
 	"strconv.NumError":                                     "strconv",
@@ -2459,9 +3457,13 @@ var stdlib = map[string]string{
 	"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",
@@ -2479,6 +3481,7 @@ var stdlib = map[string]string{
 	"strings.Join":                                         "strings",
 	"strings.LastIndex":                                    "strings",
 	"strings.LastIndexAny":                                 "strings",
+	"strings.LastIndexByte":                                "strings",
 	"strings.LastIndexFunc":                                "strings",
 	"strings.Map":                                          "strings",
 	"strings.NewReader":                                    "strings",
@@ -2517,9 +3520,11 @@ var stdlib = map[string]string{
 	"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",
@@ -2628,6 +3633,8 @@ var stdlib = map[string]string{
 	"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",
@@ -3005,6 +4012,7 @@ var stdlib = map[string]string{
 	"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",
@@ -3017,6 +4025,7 @@ var stdlib = map[string]string{
 	"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",
@@ -3091,6 +4100,7 @@ var stdlib = map[string]string{
 	"syscall.Cmsghdr":                                      "syscall",
 	"syscall.CommandLineToArgv":                            "syscall",
 	"syscall.ComputerName":                                 "syscall",
+	"syscall.Conn":                                         "syscall",
 	"syscall.Connect":                                      "syscall",
 	"syscall.ConnectEx":                                    "syscall",
 	"syscall.ConvertSidToStringSid":                        "syscall",
@@ -3100,9 +4110,13 @@ var stdlib = map[string]string{
 	"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",
@@ -3281,6 +4295,7 @@ var stdlib = map[string]string{
 	"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",
@@ -3356,9 +4371,15 @@ var stdlib = map[string]string{
 	"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",
@@ -3553,6 +4574,7 @@ var stdlib = map[string]string{
 	"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",
@@ -3560,10 +4582,13 @@ var stdlib = map[string]string{
 	"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",
@@ -3868,6 +4893,7 @@ var stdlib = map[string]string{
 	"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",
@@ -3910,11 +4936,13 @@ var stdlib = map[string]string{
 	"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",
@@ -3947,6 +4975,7 @@ var stdlib = map[string]string{
 	"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",
@@ -4041,6 +5070,7 @@ var stdlib = map[string]string{
 	"syscall.Fchmodat":                                     "syscall",
 	"syscall.Fchown":                                       "syscall",
 	"syscall.Fchownat":                                     "syscall",
+	"syscall.FcntlFlock":                                   "syscall",
 	"syscall.FdSet":                                        "syscall",
 	"syscall.Fdatasync":                                    "syscall",
 	"syscall.FileNotifyInformation":                        "syscall",
@@ -4066,6 +5096,7 @@ var stdlib = map[string]string{
 	"syscall.Fstore_t":                                     "syscall",
 	"syscall.Fsync":                                        "syscall",
 	"syscall.Ftruncate":                                    "syscall",
+	"syscall.FullPath":                                     "syscall",
 	"syscall.Futimes":                                      "syscall",
 	"syscall.Futimesat":                                    "syscall",
 	"syscall.GENERIC_ALL":                                  "syscall",
@@ -4532,7 +5563,9 @@ var stdlib = map[string]string{
 	"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",
@@ -4556,6 +5589,8 @@ var stdlib = map[string]string{
 	"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",
@@ -4729,6 +5764,7 @@ var stdlib = map[string]string{
 	"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",
@@ -4762,6 +5798,7 @@ var stdlib = map[string]string{
 	"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",
@@ -4954,6 +5991,7 @@ var stdlib = map[string]string{
 	"syscall.Listxattr":                                    "syscall",
 	"syscall.LoadCancelIoEx":                               "syscall",
 	"syscall.LoadConnectEx":                                "syscall",
+	"syscall.LoadCreateSymbolicLink":                       "syscall",
 	"syscall.LoadDLL":                                      "syscall",
 	"syscall.LoadGetAddrInfo":                              "syscall",
 	"syscall.LoadLibrary":                                  "syscall",
@@ -4987,10 +6025,20 @@ var stdlib = map[string]string{
 	"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",
@@ -4998,9 +6046,16 @@ var stdlib = map[string]string{
 	"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",
@@ -5017,7 +6072,10 @@ var stdlib = map[string]string{
 	"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",
@@ -5250,6 +6308,7 @@ var stdlib = map[string]string{
 	"syscall.NetlinkRouteAttr":                             "syscall",
 	"syscall.NetlinkRouteRequest":                          "syscall",
 	"syscall.NewCallback":                                  "syscall",
+	"syscall.NewCallbackCDecl":                             "syscall",
 	"syscall.NewLazyDLL":                                   "syscall",
 	"syscall.NlAttr":                                       "syscall",
 	"syscall.NlMsgerr":                                     "syscall",
@@ -5533,6 +6592,9 @@ var stdlib = map[string]string{
 	"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",
@@ -5651,6 +6713,7 @@ var stdlib = map[string]string{
 	"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",
@@ -5848,6 +6911,7 @@ var stdlib = map[string]string{
 	"syscall.RUSAGE_SELF":                                  "syscall",
 	"syscall.RUSAGE_THREAD":                                "syscall",
 	"syscall.Radvisory_t":                                  "syscall",
+	"syscall.RawConn":                                      "syscall",
 	"syscall.RawSockaddr":                                  "syscall",
 	"syscall.RawSockaddrAny":                               "syscall",
 	"syscall.RawSockaddrDatalink":                          "syscall",
@@ -6026,6 +7090,7 @@ var stdlib = map[string]string{
 	"syscall.SIOCGIFGENERIC":                               "syscall",
 	"syscall.SIOCGIFGMEMB":                                 "syscall",
 	"syscall.SIOCGIFGROUP":                                 "syscall",
+	"syscall.SIOCGIFHARDMTU":                               "syscall",
 	"syscall.SIOCGIFHWADDR":                                "syscall",
 	"syscall.SIOCGIFINDEX":                                 "syscall",
 	"syscall.SIOCGIFKPI":                                   "syscall",
@@ -6054,15 +7119,18 @@ var stdlib = map[string]string{
 	"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",
@@ -6122,14 +7190,19 @@ var stdlib = map[string]string{
 	"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",
@@ -6233,6 +7306,7 @@ var stdlib = map[string]string{
 	"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",
@@ -6261,6 +7335,7 @@ var stdlib = map[string]string{
 	"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",
@@ -6306,6 +7381,7 @@ var stdlib = map[string]string{
 	"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",
@@ -6325,6 +7401,7 @@ var stdlib = map[string]string{
 	"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",
@@ -6342,6 +7419,7 @@ var stdlib = map[string]string{
 	"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",
@@ -6698,6 +7776,7 @@ var stdlib = map[string]string{
 	"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",
@@ -7118,6 +8197,7 @@ var stdlib = map[string]string{
 	"syscall.Select":                                       "syscall",
 	"syscall.Sendfile":                                     "syscall",
 	"syscall.Sendmsg":                                      "syscall",
+	"syscall.SendmsgN":                                     "syscall",
 	"syscall.Sendto":                                       "syscall",
 	"syscall.Servent":                                      "syscall",
 	"syscall.SetBpf":                                       "syscall",
@@ -7264,6 +8344,7 @@ var stdlib = map[string]string{
 	"syscall.Sync":                                         "syscall",
 	"syscall.SyncFileRange":                                "syscall",
 	"syscall.SysProcAttr":                                  "syscall",
+	"syscall.SysProcIDMap":                                 "syscall",
 	"syscall.Syscall":                                      "syscall",
 	"syscall.Syscall12":                                    "syscall",
 	"syscall.Syscall15":                                    "syscall",
@@ -7280,6 +8361,7 @@ var stdlib = map[string]string{
 	"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",
@@ -7314,6 +8396,7 @@ var stdlib = map[string]string{
 	"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",
@@ -7323,6 +8406,13 @@ var stdlib = map[string]string{
 	"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",
@@ -7540,6 +8630,7 @@ var stdlib = map[string]string{
 	"syscall.Unlinkat":                                     "syscall",
 	"syscall.UnmapViewOfFile":                              "syscall",
 	"syscall.Unmount":                                      "syscall",
+	"syscall.Unsetenv":                                     "syscall",
 	"syscall.Unshare":                                      "syscall",
 	"syscall.UserInfo10":                                   "syscall",
 	"syscall.Ustat":                                        "syscall",
@@ -7597,6 +8688,8 @@ var stdlib = map[string]string{
 	"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",
@@ -7689,6 +8782,11 @@ var stdlib = map[string]string{
 	"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",
@@ -7700,6 +8798,7 @@ var stdlib = map[string]string{
 	"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",
@@ -7716,16 +8815,19 @@ var stdlib = map[string]string{
 	"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
@@ -7736,639 +8838,897 @@ var stdlib = map[string]string{
 	"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.InternalBenchmark":                   "testing",
-	"testing.InternalExample":                     "testing",
-	"testing.InternalTest":                        "testing",
-	"testing.Main":                                "testing",
-	"testing.RegisterCover":                       "testing",
-	"testing.RunBenchmarks":                       "testing",
-	"testing.RunExamples":                         "testing",
-	"testing.RunTests":                            "testing",
-	"testing.Short":                               "testing",
-	"testing.T":                                   "testing",
-	"testing.Verbose":                             "testing",
-	"textproto.CanonicalMIMEHeaderKey":            "net/textproto",
-	"textproto.Conn":                              "net/textproto",
-	"textproto.Dial":                              "net/textproto",
-	"textproto.Error":                             "net/textproto",
-	"textproto.MIMEHeader":                        "net/textproto",
-	"textproto.NewConn":                           "net/textproto",
-	"textproto.NewReader":                         "net/textproto",
-	"textproto.NewWriter":                         "net/textproto",
-	"textproto.Pipeline":                          "net/textproto",
-	"textproto.ProtocolError":                     "net/textproto",
-	"textproto.Reader":                            "net/textproto",
-	"textproto.TrimBytes":                         "net/textproto",
-	"textproto.TrimString":                        "net/textproto",
-	"textproto.Writer":                            "net/textproto",
-	"time.ANSIC":                                  "time",
-	"time.After":                                  "time",
-	"time.AfterFunc":                              "time",
-	"time.April":                                  "time",
-	"time.August":                                 "time",
-	"time.Date":                                   "time",
-	"time.December":                               "time",
-	"time.Duration":                               "time",
-	"time.February":                               "time",
-	"time.FixedZone":                              "time",
-	"time.Friday":                                 "time",
-	"time.Hour":                                   "time",
-	"time.January":                                "time",
-	"time.July":                                   "time",
-	"time.June":                                   "time",
-	"time.Kitchen":                                "time",
-	"time.LoadLocation":                           "time",
-	"time.Local":                                  "time",
-	"time.Location":                               "time",
-	"time.March":                                  "time",
-	"time.May":                                    "time",
-	"time.Microsecond":                            "time",
-	"time.Millisecond":                            "time",
-	"time.Minute":                                 "time",
-	"time.Monday":                                 "time",
-	"time.Month":                                  "time",
-	"time.Nanosecond":                             "time",
-	"time.NewTicker":                              "time",
-	"time.NewTimer":                               "time",
-	"time.November":                               "time",
-	"time.Now":                                    "time",
-	"time.October":                                "time",
-	"time.Parse":                                  "time",
-	"time.ParseDuration":                          "time",
-	"time.ParseError":                             "time",
-	"time.ParseInLocation":                        "time",
-	"time.RFC1123":                                "time",
-	"time.RFC1123Z":                               "time",
-	"time.RFC3339":                                "time",
-	"time.RFC3339Nano":                            "time",
-	"time.RFC822":                                 "time",
-	"time.RFC822Z":                                "time",
-	"time.RFC850":                                 "time",
-	"time.RubyDate":                               "time",
-	"time.Saturday":                               "time",
-	"time.Second":                                 "time",
-	"time.September":                              "time",
-	"time.Since":                                  "time",
-	"time.Sleep":                                  "time",
-	"time.Stamp":                                  "time",
-	"time.StampMicro":                             "time",
-	"time.StampMilli":                             "time",
-	"time.StampNano":                              "time",
-	"time.Sunday":                                 "time",
-	"time.Thursday":                               "time",
-	"time.Tick":                                   "time",
-	"time.Ticker":                                 "time",
-	"time.Time":                                   "time",
-	"time.Timer":                                  "time",
-	"time.Tuesday":                                "time",
-	"time.UTC":                                    "time",
-	"time.Unix":                                   "time",
-	"time.UnixDate":                               "time",
-	"time.Wednesday":                              "time",
-	"time.Weekday":                                "time",
-	"tls.Certificate":                             "crypto/tls",
-	"tls.Client":                                  "crypto/tls",
-	"tls.ClientAuthType":                          "crypto/tls",
-	"tls.Config":                                  "crypto/tls",
-	"tls.Conn":                                    "crypto/tls",
-	"tls.ConnectionState":                         "crypto/tls",
-	"tls.Dial":                                    "crypto/tls",
-	"tls.Listen":                                  "crypto/tls",
-	"tls.LoadX509KeyPair":                         "crypto/tls",
-	"tls.NewListener":                             "crypto/tls",
-	"tls.NoClientCert":                            "crypto/tls",
-	"tls.RequestClientCert":                       "crypto/tls",
-	"tls.RequireAndVerifyClientCert":              "crypto/tls",
-	"tls.RequireAnyClientCert":                    "crypto/tls",
-	"tls.Server":                                  "crypto/tls",
-	"tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA":    "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_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_GCM_SHA256":   "crypto/tls",
-	"tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA":      "crypto/tls",
-	"tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA":          "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_256_CBC_SHA":            "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.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",
-	"unicode.ASCII_Hex_Digit":                     "unicode",
-	"unicode.Arabic":                              "unicode",
-	"unicode.Armenian":                            "unicode",
-	"unicode.Avestan":                             "unicode",
-	"unicode.AzeriCase":                           "unicode",
-	"unicode.Balinese":                            "unicode",
-	"unicode.Bamum":                               "unicode",
-	"unicode.Batak":                               "unicode",
-	"unicode.Bengali":                             "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.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.Egyptian_Hieroglyphs":                "unicode",
-	"unicode.Ethiopic":                            "unicode",
-	"unicode.Extender":                            "unicode",
-	"unicode.FoldCategory":                        "unicode",
-	"unicode.FoldScript":                          "unicode",
-	"unicode.Georgian":                            "unicode",
-	"unicode.Glagolitic":                          "unicode",
-	"unicode.Gothic":                              "unicode",
-	"unicode.GraphicRanges":                       "unicode",
-	"unicode.Greek":                               "unicode",
-	"unicode.Gujarati":                            "unicode",
-	"unicode.Gurmukhi":                            "unicode",
-	"unicode.Han":                                 "unicode",
-	"unicode.Hangul":                              "unicode",
-	"unicode.Hanunoo":                             "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.L":                                   "unicode",
-	"unicode.Lao":                                 "unicode",
-	"unicode.Latin":                               "unicode",
-	"unicode.Lepcha":                              "unicode",
-	"unicode.Letter":                              "unicode",
-	"unicode.Limbu":                               "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.Malayalam":                           "unicode",
-	"unicode.Mandaic":                             "unicode",
-	"unicode.Mark":                                "unicode",
-	"unicode.MaxASCII":                            "unicode",
-	"unicode.MaxCase":                             "unicode",
-	"unicode.MaxLatin1":                           "unicode",
-	"unicode.MaxRune":                             "unicode",
-	"unicode.Mc":                                  "unicode",
-	"unicode.Me":                                  "unicode",
-	"unicode.Meetei_Mayek":                        "unicode",
-	"unicode.Meroitic_Cursive":                    "unicode",
-	"unicode.Meroitic_Hieroglyphs":                "unicode",
-	"unicode.Miao":                                "unicode",
-	"unicode.Mn":                                  "unicode",
-	"unicode.Mongolian":                           "unicode",
-	"unicode.Myanmar":                             "unicode",
-	"unicode.N":                                   "unicode",
-	"unicode.Nd":                                  "unicode",
-	"unicode.New_Tai_Lue":                         "unicode",
-	"unicode.Nko":                                 "unicode",
-	"unicode.Nl":                                  "unicode",
-	"unicode.No":                                  "unicode",
-	"unicode.Noncharacter_Code_Point":             "unicode",
-	"unicode.Number":                              "unicode",
-	"unicode.Ogham":                               "unicode",
-	"unicode.Ol_Chiki":                            "unicode",
-	"unicode.Old_Italic":                          "unicode",
-	"unicode.Old_Persian":                         "unicode",
-	"unicode.Old_South_Arabian":                   "unicode",
-	"unicode.Old_Turkic":                          "unicode",
-	"unicode.Oriya":                               "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.Pattern_Syntax":                      "unicode",
-	"unicode.Pattern_White_Space":                 "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.PrintRanges":                         "unicode",
-	"unicode.Properties":                          "unicode",
-	"unicode.Ps":                                  "unicode",
-	"unicode.Punct":                               "unicode",
-	"unicode.Quotation_Mark":                      "unicode",
-	"unicode.Radical":                             "unicode",
-	"unicode.Range16":                             "unicode",
-	"unicode.Range32":                             "unicode",
-	"unicode.RangeTable":                          "unicode",
-	"unicode.Rejang":                              "unicode",
-	"unicode.ReplacementChar":                     "unicode",
-	"unicode.Runic":                               "unicode",
-	"unicode.S":                                   "unicode",
-	"unicode.STerm":                               "unicode",
-	"unicode.Samaritan":                           "unicode",
-	"unicode.Saurashtra":                          "unicode",
-	"unicode.Sc":                                  "unicode",
-	"unicode.Scripts":                             "unicode",
-	"unicode.Sharada":                             "unicode",
-	"unicode.Shavian":                             "unicode",
-	"unicode.SimpleFold":                          "unicode",
-	"unicode.Sinhala":                             "unicode",
-	"unicode.Sk":                                  "unicode",
-	"unicode.Sm":                                  "unicode",
-	"unicode.So":                                  "unicode",
-	"unicode.Soft_Dotted":                         "unicode",
-	"unicode.Sora_Sompeng":                        "unicode",
-	"unicode.Space":                               "unicode",
-	"unicode.SpecialCase":                         "unicode",
-	"unicode.Sundanese":                           "unicode",
-	"unicode.Syloti_Nagri":                        "unicode",
-	"unicode.Symbol":                              "unicode",
-	"unicode.Syriac":                              "unicode",
-	"unicode.Tagalog":                             "unicode",
-	"unicode.Tagbanwa":                            "unicode",
-	"unicode.Tai_Le":                              "unicode",
-	"unicode.Tai_Tham":                            "unicode",
-	"unicode.Tai_Viet":                            "unicode",
-	"unicode.Takri":                               "unicode",
-	"unicode.Tamil":                               "unicode",
-	"unicode.Telugu":                              "unicode",
-	"unicode.Terminal_Punctuation":                "unicode",
-	"unicode.Thaana":                              "unicode",
-	"unicode.Thai":                                "unicode",
-	"unicode.Tibetan":                             "unicode",
-	"unicode.Tifinagh":                            "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.White_Space":                         "unicode",
-	"unicode.Yi":                                  "unicode",
-	"unicode.Z":                                   "unicode",
-	"unicode.Zl":                                  "unicode",
-	"unicode.Zp":                                  "unicode",
-	"unicode.Zs":                                  "unicode",
-	"url.Error":                                   "net/url",
-	"url.EscapeError":                             "net/url",
-	"url.Parse":                                   "net/url",
-	"url.ParseQuery":                              "net/url",
-	"url.ParseRequestURI":                         "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.Lookup":                                 "os/user",
-	"user.LookupId":                               "os/user",
-	"user.UnknownUserError":                       "os/user",
-	"user.UnknownUserIdError":                     "os/user",
-	"user.User":                                   "os/user",
-	"utf16.Decode":                                "unicode/utf16",
-	"utf16.DecodeRune":                            "unicode/utf16",
-	"utf16.Encode":                                "unicode/utf16",
-	"utf16.EncodeRune":                            "unicode/utf16",
-	"utf16.IsSurrogate":                           "unicode/utf16",
-	"utf8.DecodeLastRune":                         "unicode/utf8",
-	"utf8.DecodeLastRuneInString":                 "unicode/utf8",
-	"utf8.DecodeRune":                             "unicode/utf8",
-	"utf8.DecodeRuneInString":                     "unicode/utf8",
-	"utf8.EncodeRune":                             "unicode/utf8",
-	"utf8.FullRune":                               "unicode/utf8",
-	"utf8.FullRuneInString":                       "unicode/utf8",
-	"utf8.MaxRune":                                "unicode/utf8",
-	"utf8.RuneCount":                              "unicode/utf8",
-	"utf8.RuneCountInString":                      "unicode/utf8",
-	"utf8.RuneError":                              "unicode/utf8",
-	"utf8.RuneLen":                                "unicode/utf8",
-	"utf8.RuneSelf":                               "unicode/utf8",
-	"utf8.RuneStart":                              "unicode/utf8",
-	"utf8.UTFMax":                                 "unicode/utf8",
-	"utf8.Valid":                                  "unicode/utf8",
-	"utf8.ValidRune":                              "unicode/utf8",
-	"utf8.ValidString":                            "unicode/utf8",
-	"x509.CANotAuthorizedForThisName":             "crypto/x509",
-	"x509.CertPool":                               "crypto/x509",
-	"x509.Certificate":                            "crypto/x509",
-	"x509.CertificateInvalidError":                "crypto/x509",
-	"x509.ConstraintViolationError":               "crypto/x509",
-	"x509.CreateCertificate":                      "crypto/x509",
-	"x509.DSA":                                    "crypto/x509",
-	"x509.DSAWithSHA1":                            "crypto/x509",
-	"x509.DSAWithSHA256":                          "crypto/x509",
-	"x509.DecryptPEMBlock":                        "crypto/x509",
-	"x509.ECDSA":                                  "crypto/x509",
-	"x509.ECDSAWithSHA1":                          "crypto/x509",
-	"x509.ECDSAWithSHA256":                        "crypto/x509",
-	"x509.ECDSAWithSHA384":                        "crypto/x509",
-	"x509.ECDSAWithSHA512":                        "crypto/x509",
-	"x509.EncryptPEMBlock":                        "crypto/x509",
-	"x509.ErrUnsupportedAlgorithm":                "crypto/x509",
-	"x509.Expired":                                "crypto/x509",
-	"x509.ExtKeyUsage":                            "crypto/x509",
-	"x509.ExtKeyUsageAny":                         "crypto/x509",
-	"x509.ExtKeyUsageClientAuth":                  "crypto/x509",
-	"x509.ExtKeyUsageCodeSigning":                 "crypto/x509",
-	"x509.ExtKeyUsageEmailProtection":             "crypto/x509",
-	"x509.ExtKeyUsageIPSECEndSystem":              "crypto/x509",
-	"x509.ExtKeyUsageIPSECTunnel":                 "crypto/x509",
-	"x509.ExtKeyUsageIPSECUser":                   "crypto/x509",
-	"x509.ExtKeyUsageMicrosoftServerGatedCrypto":  "crypto/x509",
-	"x509.ExtKeyUsageNetscapeServerGatedCrypto":   "crypto/x509",
-	"x509.ExtKeyUsageOCSPSigning":                 "crypto/x509",
-	"x509.ExtKeyUsageServerAuth":                  "crypto/x509",
-	"x509.ExtKeyUsageTimeStamping":                "crypto/x509",
-	"x509.HostnameError":                          "crypto/x509",
-	"x509.IncompatibleUsage":                      "crypto/x509",
-	"x509.IncorrectPasswordError":                 "crypto/x509",
-	"x509.InvalidReason":                          "crypto/x509",
-	"x509.IsEncryptedPEMBlock":                    "crypto/x509",
-	"x509.KeyUsage":                               "crypto/x509",
-	"x509.KeyUsageCRLSign":                        "crypto/x509",
-	"x509.KeyUsageCertSign":                       "crypto/x509",
-	"x509.KeyUsageContentCommitment":              "crypto/x509",
-	"x509.KeyUsageDataEncipherment":               "crypto/x509",
-	"x509.KeyUsageDecipherOnly":                   "crypto/x509",
-	"x509.KeyUsageDigitalSignature":               "crypto/x509",
-	"x509.KeyUsageEncipherOnly":                   "crypto/x509",
-	"x509.KeyUsageKeyAgreement":                   "crypto/x509",
-	"x509.KeyUsageKeyEncipherment":                "crypto/x509",
-	"x509.MD2WithRSA":                             "crypto/x509",
-	"x509.MD5WithRSA":                             "crypto/x509",
-	"x509.MarshalECPrivateKey":                    "crypto/x509",
-	"x509.MarshalPKCS1PrivateKey":                 "crypto/x509",
-	"x509.MarshalPKIXPublicKey":                   "crypto/x509",
-	"x509.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.ParseCertificates":                      "crypto/x509",
-	"x509.ParseDERCRL":                            "crypto/x509",
-	"x509.ParseECPrivateKey":                      "crypto/x509",
-	"x509.ParsePKCS1PrivateKey":                   "crypto/x509",
-	"x509.ParsePKCS8PrivateKey":                   "crypto/x509",
-	"x509.ParsePKIXPublicKey":                     "crypto/x509",
-	"x509.PublicKeyAlgorithm":                     "crypto/x509",
-	"x509.RSA":                                    "crypto/x509",
-	"x509.SHA1WithRSA":                            "crypto/x509",
-	"x509.SHA256WithRSA":                          "crypto/x509",
-	"x509.SHA384WithRSA":                          "crypto/x509",
-	"x509.SHA512WithRSA":                          "crypto/x509",
-	"x509.SignatureAlgorithm":                     "crypto/x509",
-	"x509.SystemRootsError":                       "crypto/x509",
-	"x509.TooManyIntermediates":                   "crypto/x509",
-	"x509.UnhandledCriticalExtension":             "crypto/x509",
-	"x509.UnknownAuthorityError":                  "crypto/x509",
-	"x509.UnknownPublicKeyAlgorithm":              "crypto/x509",
-	"x509.UnknownSignatureAlgorithm":              "crypto/x509",
-	"x509.VerifyOptions":                          "crypto/x509",
-	"xml.Attr":                                    "encoding/xml",
-	"xml.CharData":                                "encoding/xml",
-	"xml.Comment":                                 "encoding/xml",
-	"xml.CopyToken":                               "encoding/xml",
-	"xml.Decoder":                                 "encoding/xml",
-	"xml.Directive":                               "encoding/xml",
-	"xml.Encoder":                                 "encoding/xml",
-	"xml.EndElement":                              "encoding/xml",
-	"xml.Escape":                                  "encoding/xml",
-	"xml.EscapeText":                              "encoding/xml",
-	"xml.HTMLAutoClose":                           "encoding/xml",
-	"xml.HTMLEntity":                              "encoding/xml",
-	"xml.Header":                                  "encoding/xml",
-	"xml.Marshal":                                 "encoding/xml",
-	"xml.MarshalIndent":                           "encoding/xml",
-	"xml.Marshaler":                               "encoding/xml",
-	"xml.MarshalerAttr":                           "encoding/xml",
-	"xml.Name":                                    "encoding/xml",
-	"xml.NewDecoder":                              "encoding/xml",
-	"xml.NewEncoder":                              "encoding/xml",
-	"xml.ProcInst":                                "encoding/xml",
-	"xml.StartElement":                            "encoding/xml",
-	"xml.SyntaxError":                             "encoding/xml",
-	"xml.TagPathError":                            "encoding/xml",
-	"xml.Token":                                   "encoding/xml",
-	"xml.Unmarshal":                               "encoding/xml",
-	"xml.UnmarshalError":                          "encoding/xml",
-	"xml.Unmarshaler":                             "encoding/xml",
-	"xml.UnmarshalerAttr":                         "encoding/xml",
-	"xml.UnsupportedTypeError":                    "encoding/xml",
-	"zip.Compressor":                              "archive/zip",
-	"zip.Decompressor":                            "archive/zip",
-	"zip.Deflate":                                 "archive/zip",
-	"zip.ErrAlgorithm":                            "archive/zip",
-	"zip.ErrChecksum":                             "archive/zip",
-	"zip.ErrFormat":                               "archive/zip",
-	"zip.File":                                    "archive/zip",
-	"zip.FileHeader":                              "archive/zip",
-	"zip.FileInfoHeader":                          "archive/zip",
-	"zip.NewReader":                               "archive/zip",
-	"zip.NewWriter":                               "archive/zip",
-	"zip.OpenReader":                              "archive/zip",
-	"zip.ReadCloser":                              "archive/zip",
-	"zip.Reader":                                  "archive/zip",
-	"zip.RegisterCompressor":                      "archive/zip",
-	"zip.RegisterDecompressor":                    "archive/zip",
-	"zip.Store":                                   "archive/zip",
-	"zip.Writer":                                  "archive/zip",
-	"zlib.BestCompression":                        "compress/zlib",
-	"zlib.BestSpeed":                              "compress/zlib",
-	"zlib.DefaultCompression":                     "compress/zlib",
-	"zlib.ErrChecksum":                            "compress/zlib",
-	"zlib.ErrDictionary":                          "compress/zlib",
-	"zlib.ErrHeader":                              "compress/zlib",
-	"zlib.NewReader":                              "compress/zlib",
-	"zlib.NewReaderDict":                          "compress/zlib",
-	"zlib.NewWriter":                              "compress/zlib",
-	"zlib.NewWriterLevel":                         "compress/zlib",
-	"zlib.NewWriterLevelDict":                     "compress/zlib",
-	"zlib.NoCompression":                          "compress/zlib",
-	"zlib.Writer":                                 "compress/zlib",
+	"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/vendor/golang.org/x/tools/oracle/TODO b/vendor/golang.org/x/tools/oracle/TODO
deleted file mode 100644
index 8fbf5e8..0000000
--- a/vendor/golang.org/x/tools/oracle/TODO
+++ /dev/null
@@ -1,83 +0,0 @@
-
-
-ORACLE TODO
-===========
-
-General
-=======
-
-Save unsaved editor buffers into an archive and provide that to the
-tools, which should act as if they were saved.
-
-Include complete pos/end information Serial output.
-  But beware that sometimes a single token (e.g. +) is more helpful
-  than the pos/end of the containing expression (e.g. x \n + \n y).
-
-Specific queries
-================
-
-callers, callees
-
-  Use a type-based (e.g. RTA) callgraph when a callers/callees query is
-  outside the analysis scope.
-
-implements
-
-   Make it require that the selection is a type, and show only the
-   implements relation as it applies to that type.
-
-definition, referrers
-
-  definition: Make it work with qualified identifiers (SelectorExpr) too.
-
-  references: Make it work on things that are implicit idents, like
-  import specs, perhaps?
-
-what
-
-  Report def/ref info if available.
-  Editors could use it to highlight all idents of the same local var.
-
-  More tests.
-
-pointsto
-
-  When invoked on a function Ident, we get an error.
-
-  When invoked on a named return parameter, we get an error.
-
-describe
-
-  When invoked on a var, we want to see the type and its methods.
-
-  Split "show type" and "describe syntax" into separate commands?
-
-peers
-
-  Permit querying from a makechan, for...range, or reflective op.
-
-  Report aliasing reflect.{Send,Recv,Close} and close() operations.
-
-New queries
-
-"updaters": show all statements that may update the selected lvalue
-  (local, global, field, etc).
-
-"creators": show all places where an object of type T is created
-  (&T{}, var t T, new(T), new(struct{array [3]T}), etc.
-  (Useful for datatypes whose zero value is not safe)
-
-
-Editor-specific
-===============
-
-Add support for "what" to .el; clean up.
-
-Emacs: use JSON to get the raw information from the oracle.  Don't
- open an editor buffer for simpler queries, just jump to the result
- and/or display it in the modeline.
-
-Emacs: go-root-and-paths depends on the current buffer, so be sure to
-   call it from within the source file, not the *go-oracle* buffer:
-   the user may have switched workspaces and the oracle should run in
-   the new one.
diff --git a/vendor/golang.org/x/tools/oracle/callers.go b/vendor/golang.org/x/tools/oracle/callers.go
deleted file mode 100644
index 159a403..0000000
--- a/vendor/golang.org/x/tools/oracle/callers.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// 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 oracle
-
-import (
-	"fmt"
-	"go/token"
-
-	"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"
-	"golang.org/x/tools/oracle/serial"
-)
-
-// 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 := lconf.Load()
-	if err != nil {
-		return err
-	}
-	q.Fset = lprog.Fset
-
-	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.BuildAll()
-
-	target := ssa.EnclosingFunction(pkg, qpos.path)
-	if target == nil {
-		return fmt.Errorf("no SSA function built for this location (dead code?)")
-	}
-
-	// TODO(adonovan): opt: if function is never address-taken, skip
-	// the pointer analysis.  Just look for direct calls.  This can
-	// be done in a single pass over the SSA.
-
-	// Run the pointer analysis, recording each
-	// call found to originate from target.
-	ptaConfig.BuildCallGraph = true
-	cg := ptrAnalysis(ptaConfig).CallGraph
-	cg.DeleteSyntheticNodes()
-	edges := cg.CreateNode(target).In
-	// TODO(adonovan): sort + dedup calls to ensure test determinism.
-
-	q.result = &callersResult{
-		target:    target,
-		callgraph: cg,
-		edges:     edges,
-	}
-	return nil
-}
-
-type callersResult struct {
-	target    *ssa.Function
-	callgraph *callgraph.Graph
-	edges     []*callgraph.Edge
-}
-
-func (r *callersResult) display(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) toSerial(res *serial.Result, fset *token.FileSet) {
-	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(),
-		})
-	}
-	res.Callers = callers
-}
diff --git a/vendor/golang.org/x/tools/oracle/definition.go b/vendor/golang.org/x/tools/oracle/definition.go
deleted file mode 100644
index a0340c6..0000000
--- a/vendor/golang.org/x/tools/oracle/definition.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// 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 oracle
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-
-	"golang.org/x/tools/go/loader"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
-)
-
-// definition reports the location of the definition of an identifier.
-//
-// TODO(adonovan): opt: for intra-file references, the parser's
-// resolution might be enough; we should start with that.
-//
-func definition(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
-	}
-	q.Fset = lprog.Fset
-
-	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)",
-		// and the package declaration,
-		// but I think that's all.
-		return fmt.Errorf("no object for identifier")
-	}
-
-	q.result = &definitionResult{qpos, obj}
-	return nil
-}
-
-type definitionResult struct {
-	qpos *queryPos
-	obj  types.Object // object it denotes
-}
-
-func (r *definitionResult) display(printf printfFunc) {
-	printf(r.obj, "defined here as %s", r.qpos.objectString(r.obj))
-}
-
-func (r *definitionResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	definition := &serial.Definition{
-		Desc: r.obj.String(),
-	}
-	if pos := r.obj.Pos(); pos != token.NoPos { // Package objects have no Pos()
-		definition.ObjPos = fset.Position(pos).String()
-	}
-	res.Definition = definition
-}
diff --git a/vendor/golang.org/x/tools/oracle/referrers.go b/vendor/golang.org/x/tools/oracle/referrers.go
deleted file mode 100644
index 7383d1f..0000000
--- a/vendor/golang.org/x/tools/oracle/referrers.go
+++ /dev/null
@@ -1,225 +0,0 @@
-// 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 oracle
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/token"
-	"io/ioutil"
-	"sort"
-
-	"golang.org/x/tools/go/loader"
-	"golang.org/x/tools/go/types"
-	"golang.org/x/tools/oracle/serial"
-	"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 analysis scope.
-func referrers(q *Query) error {
-	lconf := loader.Config{Build: q.Build}
-	allowErrors(&lconf)
-
-	if err := importQueryPackage(q.Pos, &lconf); err != nil {
-		return err
-	}
-
-	var id *ast.Ident
-	var obj types.Object
-	var lprog *loader.Program
-	var pass2 bool
-	var qpos *queryPos
-	for {
-		// Load/parse/type-check the program.
-		var err error
-		lprog, err = lconf.Load()
-		if err != nil {
-			return err
-		}
-		q.Fset = lprog.Fset
-
-		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?
-				pkg := qpos.info.Pkg
-				obj = types.NewPkgName(id.Pos(), pkg, pkg.Name(), pkg)
-			} else {
-				return fmt.Errorf("no object for identifier: %T", qpos.path[1])
-			}
-		}
-
-		if pass2 {
-			break
-		}
-
-		// If the identifier is exported, we must load all packages that
-		// depend transitively upon the package that defines it.
-		// Treat PkgNames as exported, even though they're lowercase.
-		if _, isPkg := obj.(*types.PkgName); !(isPkg || obj.Exported()) {
-			break // not exported
-		}
-
-		// Scan the workspace and build the import graph.
-		// Ignore broken packages.
-		_, rev, _ := importgraph.Build(q.Build)
-
-		// Re-load the larger program.
-		// Create a new file set so that ...
-		// External test packages are never imported,
-		// so they will never appear in the graph.
-		// (We must reset the Config here, not just reset the Fset field.)
-		lconf = loader.Config{
-			Fset:  token.NewFileSet(),
-			Build: q.Build,
-		}
-		allowErrors(&lconf)
-		for path := range rev.Search(obj.Pkg().Path()) {
-			lconf.ImportWithTests(path)
-		}
-		pass2 = true
-	}
-
-	// Iterate over all go/types' Uses facts for the entire program.
-	var refs []*ast.Ident
-	for _, info := range lprog.AllPackages {
-		for id2, obj2 := range info.Uses {
-			if sameObj(obj, obj2) {
-				refs = append(refs, id2)
-			}
-		}
-	}
-	sort.Sort(byNamePos{q.Fset, refs})
-
-	q.result = &referrersResult{
-		qpos:  qpos,
-		query: id,
-		obj:   obj,
-		refs:  refs,
-	}
-	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
-}
-
-// -------- 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)
-}
-
-type referrersResult struct {
-	qpos  *queryPos
-	query *ast.Ident   // identifier of query
-	obj   types.Object // object it denotes
-	refs  []*ast.Ident // set of all other references to it
-}
-
-func (r *referrersResult) display(printf printfFunc) {
-	printf(r.obj, "%d references to %s", len(r.refs), r.qpos.objectString(r.obj))
-
-	// Show referring lines, like grep.
-	type fileinfo struct {
-		refs     []*ast.Ident
-		linenums []int       // line number of refs[i]
-		data     chan []byte // file contents
-	}
-	var fileinfos []*fileinfo
-	fileinfosByName := make(map[string]*fileinfo)
-
-	// First pass: start the file reads concurrently.
-	for _, ref := range r.refs {
-		posn := r.qpos.fset.Position(ref.Pos())
-		fi := fileinfosByName[posn.Filename]
-		if fi == nil {
-			fi = &fileinfo{data: make(chan []byte)}
-			fileinfosByName[posn.Filename] = fi
-			fileinfos = append(fileinfos, fi)
-
-			// First request for this file:
-			// start asynchronous read.
-			go func() {
-				content, err := ioutil.ReadFile(posn.Filename)
-				if err != nil {
-					content = []byte(fmt.Sprintf("error: %v", err))
-				}
-				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 {
-		content := <-fi.data // wait for I/O completion
-		lines := bytes.Split(content, []byte("\n"))
-		for i, ref := range fi.refs {
-			printf(ref, "%s", lines[fi.linenums[i]-1])
-		}
-	}
-}
-
-// TODO(adonovan): encode extent, not just Pos info, in Serial form.
-
-func (r *referrersResult) toSerial(res *serial.Result, fset *token.FileSet) {
-	referrers := &serial.Referrers{
-		Pos:  fset.Position(r.query.Pos()).String(),
-		Desc: r.obj.String(),
-	}
-	if pos := r.obj.Pos(); pos != token.NoPos { // Package objects have no Pos()
-		referrers.ObjPos = fset.Position(pos).String()
-	}
-	for _, ref := range r.refs {
-		referrers.Refs = append(referrers.Refs, fset.Position(ref.NamePos).String())
-	}
-	res.Referrers = referrers
-}
diff --git a/vendor/golang.org/x/tools/playground/appengine.go b/vendor/golang.org/x/tools/playground/appengine.go
new file mode 100644
index 0000000..94c5d52
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/appengine.go
@@ -0,0 +1,26 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package playground
+
+import (
+	"net/http"
+
+	"appengine"
+	"appengine/urlfetch"
+)
+
+func init() {
+	onAppengine = !appengine.IsDevAppServer()
+}
+
+func client(r *http.Request) *http.Client {
+	return urlfetch.Client(appengine.NewContext(r))
+}
+
+func report(r *http.Request, err error) {
+	appengine.NewContext(r).Errorf("%v", err)
+}
diff --git a/vendor/golang.org/x/tools/playground/appenginevm.go b/vendor/golang.org/x/tools/playground/appenginevm.go
new file mode 100644
index 0000000..aa3a212
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/appenginevm.go
@@ -0,0 +1,11 @@
+// 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 appenginevm
+
+package playground
+
+func init() {
+	onAppengine = true
+}
diff --git a/vendor/golang.org/x/tools/playground/common.go b/vendor/golang.org/x/tools/playground/common.go
new file mode 100644
index 0000000..186537a
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/common.go
@@ -0,0 +1,63 @@
+// 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 playground registers HTTP handlers at "/compile" and "/share" that
+// proxy requests to the golang.org playground service.
+// This package may be used unaltered on App Engine.
+package playground // import "golang.org/x/tools/playground"
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+const baseURL = "https://golang.org"
+
+func init() {
+	http.HandleFunc("/compile", bounce)
+	http.HandleFunc("/share", bounce)
+}
+
+func bounce(w http.ResponseWriter, r *http.Request) {
+	b := new(bytes.Buffer)
+	if err := passThru(b, r); err != nil {
+		http.Error(w, "Server error.", http.StatusInternalServerError)
+		report(r, err)
+		return
+	}
+	io.Copy(w, b)
+}
+
+func passThru(w io.Writer, req *http.Request) error {
+	if req.URL.Path == "/share" && !allowShare(req) {
+		return errors.New("Forbidden")
+	}
+	defer req.Body.Close()
+	url := baseURL + req.URL.Path
+	r, err := client(req).Post(url, req.Header.Get("Content-type"), req.Body)
+	if err != nil {
+		return fmt.Errorf("making POST request: %v", err)
+	}
+	defer r.Body.Close()
+	if _, err := io.Copy(w, r.Body); err != nil {
+		return fmt.Errorf("copying response Body: %v", err)
+	}
+	return nil
+}
+
+var onAppengine = false // will be overriden by appengine.go and appenginevm.go
+
+func allowShare(r *http.Request) bool {
+	if !onAppengine {
+		return true
+	}
+	switch r.Header.Get("X-AppEngine-Country") {
+	case "", "ZZ", "CN":
+		return false
+	}
+	return true
+}
diff --git a/vendor/golang.org/x/tools/playground/local.go b/vendor/golang.org/x/tools/playground/local.go
new file mode 100644
index 0000000..b114b87
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/local.go
@@ -0,0 +1,20 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package playground
+
+import (
+	"log"
+	"net/http"
+)
+
+func client(r *http.Request) *http.Client {
+	return http.DefaultClient
+}
+
+func report(r *http.Request, err error) {
+	log.Println(err)
+}
diff --git a/vendor/golang.org/x/tools/playground/socket/socket.go b/vendor/golang.org/x/tools/playground/socket/socket.go
new file mode 100644
index 0000000..0c275bf
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/socket/socket.go
@@ -0,0 +1,524 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+// Package socket implements an WebSocket-based playground backend.
+// Clients connect to a websocket handler and send run/kill commands, and
+// the server sends the output and exit status of the running processes.
+// Multiple clients running multiple processes may be served concurrently.
+// The wire format is JSON and is described by the Message type.
+//
+// This will not run on App Engine as WebSockets are not supported there.
+package socket // import "golang.org/x/tools/playground/socket"
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"golang.org/x/net/websocket"
+)
+
+// RunScripts specifies whether the socket handler should execute shell scripts
+// (snippets that start with a shebang).
+var RunScripts = true
+
+// Environ provides an environment when a binary, such as the go tool, is
+// invoked.
+var Environ func() []string = os.Environ
+
+const (
+	// The maximum number of messages to send per session (avoid flooding).
+	msgLimit = 1000
+
+	// Batch messages sent in this interval and send as a single message.
+	msgDelay = 10 * time.Millisecond
+)
+
+// Message is the wire format for the websocket connection to the browser.
+// It is used for both sending output messages and receiving commands, as
+// distinguished by the Kind field.
+type Message struct {
+	Id      string // client-provided unique id for the process
+	Kind    string // in: "run", "kill" out: "stdout", "stderr", "end"
+	Body    string
+	Options *Options `json:",omitempty"`
+}
+
+// Options specify additional message options.
+type Options struct {
+	Race bool // use -race flag when building code (for "run" only)
+}
+
+// NewHandler returns a websocket server which checks the origin of requests.
+func NewHandler(origin *url.URL) websocket.Server {
+	return websocket.Server{
+		Config:    websocket.Config{Origin: origin},
+		Handshake: handshake,
+		Handler:   websocket.Handler(socketHandler),
+	}
+}
+
+// handshake checks the origin of a request during the websocket handshake.
+func handshake(c *websocket.Config, req *http.Request) error {
+	o, err := websocket.Origin(c, req)
+	if err != nil {
+		log.Println("bad websocket origin:", err)
+		return websocket.ErrBadWebSocketOrigin
+	}
+	_, port, err := net.SplitHostPort(c.Origin.Host)
+	if err != nil {
+		log.Println("bad websocket origin:", err)
+		return websocket.ErrBadWebSocketOrigin
+	}
+	ok := c.Origin.Scheme == o.Scheme && (c.Origin.Host == o.Host || c.Origin.Host == net.JoinHostPort(o.Host, port))
+	if !ok {
+		log.Println("bad websocket origin:", o)
+		return websocket.ErrBadWebSocketOrigin
+	}
+	log.Println("accepting connection from:", req.RemoteAddr)
+	return nil
+}
+
+// socketHandler handles the websocket connection for a given present session.
+// It handles transcoding Messages to and from JSON format, and starting
+// and killing processes.
+func socketHandler(c *websocket.Conn) {
+	in, out := make(chan *Message), make(chan *Message)
+	errc := make(chan error, 1)
+
+	// Decode messages from client and send to the in channel.
+	go func() {
+		dec := json.NewDecoder(c)
+		for {
+			var m Message
+			if err := dec.Decode(&m); err != nil {
+				errc <- err
+				return
+			}
+			in <- &m
+		}
+	}()
+
+	// Receive messages from the out channel and encode to the client.
+	go func() {
+		enc := json.NewEncoder(c)
+		for m := range out {
+			if err := enc.Encode(m); err != nil {
+				errc <- err
+				return
+			}
+		}
+	}()
+	defer close(out)
+
+	// Start and kill processes and handle errors.
+	proc := make(map[string]*process)
+	for {
+		select {
+		case m := <-in:
+			switch m.Kind {
+			case "run":
+				log.Println("running snippet from:", c.Request().RemoteAddr)
+				proc[m.Id].Kill()
+				proc[m.Id] = startProcess(m.Id, m.Body, out, m.Options)
+			case "kill":
+				proc[m.Id].Kill()
+			}
+		case err := <-errc:
+			if err != io.EOF {
+				// A encode or decode has failed; bail.
+				log.Println(err)
+			}
+			// Shut down any running processes.
+			for _, p := range proc {
+				p.Kill()
+			}
+			return
+		}
+	}
+}
+
+// process represents a running process.
+type process struct {
+	out  chan<- *Message
+	done chan struct{} // closed when wait completes
+	run  *exec.Cmd
+	bin  string
+}
+
+// startProcess builds and runs the given program, sending its output
+// and end event as Messages on the provided channel.
+func startProcess(id, body string, dest chan<- *Message, opt *Options) *process {
+	var (
+		done = make(chan struct{})
+		out  = make(chan *Message)
+		p    = &process{out: out, done: done}
+	)
+	go func() {
+		defer close(done)
+		for m := range buffer(limiter(out, p), time.After) {
+			m.Id = id
+			dest <- m
+		}
+	}()
+	var err error
+	if path, args := shebang(body); path != "" {
+		if RunScripts {
+			err = p.startProcess(path, args, body)
+		} else {
+			err = errors.New("script execution is not allowed")
+		}
+	} else {
+		err = p.start(body, opt)
+	}
+	if err != nil {
+		p.end(err)
+		return nil
+	}
+	go func() {
+		p.end(p.run.Wait())
+	}()
+	return p
+}
+
+// end sends an "end" message to the client, containing the process id and the
+// given error value. It also removes the binary, if present.
+func (p *process) end(err error) {
+	if p.bin != "" {
+		defer os.Remove(p.bin)
+	}
+	m := &Message{Kind: "end"}
+	if err != nil {
+		m.Body = err.Error()
+	}
+	p.out <- m
+	close(p.out)
+}
+
+// A killer provides a mechanism to terminate a process.
+// The Kill method returns only once the process has exited.
+type killer interface {
+	Kill()
+}
+
+// limiter returns a channel that wraps the given channel.
+// It receives Messages from the given channel and sends them to the returned
+// channel until it passes msgLimit messages, at which point it will kill the
+// process and pass only the "end" message.
+// When the given channel is closed, or when the "end" message is received,
+// it closes the returned channel.
+func limiter(in <-chan *Message, p killer) <-chan *Message {
+	out := make(chan *Message)
+	go func() {
+		defer close(out)
+		n := 0
+		for m := range in {
+			switch {
+			case n < msgLimit || m.Kind == "end":
+				out <- m
+				if m.Kind == "end" {
+					return
+				}
+			case n == msgLimit:
+				// Kill in a goroutine as Kill will not return
+				// until the process' output has been
+				// processed, and we're doing that in this loop.
+				go p.Kill()
+			default:
+				continue // don't increment
+			}
+			n++
+		}
+	}()
+	return out
+}
+
+// buffer returns a channel that wraps the given channel. It receives messages
+// from the given channel and sends them to the returned channel.
+// Message bodies are gathered over the period msgDelay and coalesced into a
+// single Message before they are passed on. Messages of the same kind are
+// coalesced; when a message of a different kind is received, any buffered
+// messages are flushed. When the given channel is closed, buffer flushes the
+// remaining buffered messages and closes the returned channel.
+// The timeAfter func should be time.After. It exists for testing.
+func buffer(in <-chan *Message, timeAfter func(time.Duration) <-chan time.Time) <-chan *Message {
+	out := make(chan *Message)
+	go func() {
+		defer close(out)
+		var (
+			tc    <-chan time.Time
+			buf   []byte
+			kind  string
+			flush = func() {
+				if len(buf) == 0 {
+					return
+				}
+				out <- &Message{Kind: kind, Body: safeString(buf)}
+				buf = buf[:0] // recycle buffer
+				kind = ""
+			}
+		)
+		for {
+			select {
+			case m, ok := <-in:
+				if !ok {
+					flush()
+					return
+				}
+				if m.Kind == "end" {
+					flush()
+					out <- m
+					return
+				}
+				if kind != m.Kind {
+					flush()
+					kind = m.Kind
+					if tc == nil {
+						tc = timeAfter(msgDelay)
+					}
+				}
+				buf = append(buf, m.Body...)
+			case <-tc:
+				flush()
+				tc = nil
+			}
+		}
+	}()
+	return out
+}
+
+// Kill stops the process if it is running and waits for it to exit.
+func (p *process) Kill() {
+	if p == nil || p.run == nil {
+		return
+	}
+	p.run.Process.Kill()
+	<-p.done // block until process exits
+}
+
+// shebang looks for a shebang ('#!') at the beginning of the passed string.
+// If found, it returns the path and args after the shebang.
+// args includes the command as args[0].
+func shebang(body string) (path string, args []string) {
+	body = strings.TrimSpace(body)
+	if !strings.HasPrefix(body, "#!") {
+		return "", nil
+	}
+	if i := strings.Index(body, "\n"); i >= 0 {
+		body = body[:i]
+	}
+	fs := strings.Fields(body[2:])
+	return fs[0], fs
+}
+
+// startProcess starts a given program given its path and passing the given body
+// to the command standard input.
+func (p *process) startProcess(path string, args []string, body string) error {
+	cmd := &exec.Cmd{
+		Path:   path,
+		Args:   args,
+		Stdin:  strings.NewReader(body),
+		Stdout: &messageWriter{kind: "stdout", out: p.out},
+		Stderr: &messageWriter{kind: "stderr", out: p.out},
+	}
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	p.run = cmd
+	return nil
+}
+
+// start builds and starts the given program, sending its output to p.out,
+// and stores the running *exec.Cmd in the run field.
+func (p *process) start(body string, opt *Options) error {
+	// We "go build" and then exec the binary so that the
+	// resultant *exec.Cmd is a handle to the user's program
+	// (rather than the go tool process).
+	// This makes Kill work.
+
+	bin := filepath.Join(tmpdir, "compile"+strconv.Itoa(<-uniq))
+	src := bin + ".go"
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+
+	// write body to x.go
+	defer os.Remove(src)
+	err := ioutil.WriteFile(src, []byte(body), 0666)
+	if err != nil {
+		return err
+	}
+
+	// build x.go, creating x
+	p.bin = bin // to be removed by p.end
+	dir, file := filepath.Split(src)
+	args := []string{"go", "build", "-tags", "OMIT"}
+	if opt != nil && opt.Race {
+		p.out <- &Message{
+			Kind: "stderr",
+			Body: "Running with race detector.\n",
+		}
+		args = append(args, "-race")
+	}
+	args = append(args, "-o", bin, file)
+	cmd := p.cmd(dir, args...)
+	cmd.Stdout = cmd.Stderr // send compiler output to stderr
+	if err := cmd.Run(); err != nil {
+		return err
+	}
+
+	// run x
+	if isNacl() {
+		cmd, err = p.naclCmd(bin)
+		if err != nil {
+			return err
+		}
+	} else {
+		cmd = p.cmd("", bin)
+	}
+	if opt != nil && opt.Race {
+		cmd.Env = append(cmd.Env, "GOMAXPROCS=2")
+	}
+	if err := cmd.Start(); err != nil {
+		// If we failed to exec, that might be because they built
+		// a non-main package instead of an executable.
+		// Check and report that.
+		if name, err := packageName(body); err == nil && name != "main" {
+			return errors.New(`executable programs must use "package main"`)
+		}
+		return err
+	}
+	p.run = cmd
+	return nil
+}
+
+// cmd builds an *exec.Cmd that writes its standard output and error to the
+// process' output channel.
+func (p *process) cmd(dir string, args ...string) *exec.Cmd {
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Dir = dir
+	cmd.Env = Environ()
+	cmd.Stdout = &messageWriter{kind: "stdout", out: p.out}
+	cmd.Stderr = &messageWriter{kind: "stderr", out: p.out}
+	return cmd
+}
+
+func isNacl() bool {
+	for _, v := range append(Environ(), os.Environ()...) {
+		if v == "GOOS=nacl" {
+			return true
+		}
+	}
+	return false
+}
+
+// naclCmd returns an *exec.Cmd that executes bin under native client.
+func (p *process) naclCmd(bin string) (*exec.Cmd, error) {
+	pwd, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+	var args []string
+	env := []string{
+		"NACLENV_GOOS=" + runtime.GOOS,
+		"NACLENV_GOROOT=/go",
+		"NACLENV_NACLPWD=" + strings.Replace(pwd, runtime.GOROOT(), "/go", 1),
+	}
+	switch runtime.GOARCH {
+	case "amd64":
+		env = append(env, "NACLENV_GOARCH=amd64p32")
+		args = []string{"sel_ldr_x86_64"}
+	case "386":
+		env = append(env, "NACLENV_GOARCH=386")
+		args = []string{"sel_ldr_x86_32"}
+	case "arm":
+		env = append(env, "NACLENV_GOARCH=arm")
+		selLdr, err := exec.LookPath("sel_ldr_arm")
+		if err != nil {
+			return nil, err
+		}
+		args = []string{"nacl_helper_bootstrap_arm", selLdr, "--reserved_at_zero=0xXXXXXXXXXXXXXXXX"}
+	default:
+		return nil, errors.New("native client does not support GOARCH=" + runtime.GOARCH)
+	}
+
+	cmd := p.cmd("", append(args, "-l", "/dev/null", "-S", "-e", bin)...)
+	cmd.Env = append(cmd.Env, env...)
+
+	return cmd, nil
+}
+
+func packageName(body string) (string, error) {
+	f, err := parser.ParseFile(token.NewFileSet(), "prog.go",
+		strings.NewReader(body), parser.PackageClauseOnly)
+	if err != nil {
+		return "", err
+	}
+	return f.Name.String(), nil
+}
+
+// messageWriter is an io.Writer that converts all writes to Message sends on
+// the out channel with the specified id and kind.
+type messageWriter struct {
+	kind string
+	out  chan<- *Message
+}
+
+func (w *messageWriter) Write(b []byte) (n int, err error) {
+	w.out <- &Message{Kind: w.kind, Body: safeString(b)}
+	return len(b), nil
+}
+
+// safeString returns b as a valid UTF-8 string.
+func safeString(b []byte) string {
+	if utf8.Valid(b) {
+		return string(b)
+	}
+	var buf bytes.Buffer
+	for len(b) > 0 {
+		r, size := utf8.DecodeRune(b)
+		b = b[size:]
+		buf.WriteRune(r)
+	}
+	return buf.String()
+}
+
+var tmpdir string
+
+func init() {
+	// find real path to temporary directory
+	var err error
+	tmpdir, err = filepath.EvalSymlinks(os.TempDir())
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+var uniq = make(chan int) // a source of numbers for naming temporary files
+
+func init() {
+	go func() {
+		for i := 0; ; i++ {
+			uniq <- i
+		}
+	}()
+}
diff --git a/vendor/golang.org/x/tools/playground/socket/socket_test.go b/vendor/golang.org/x/tools/playground/socket/socket_test.go
new file mode 100644
index 0000000..0ceb250
--- /dev/null
+++ b/vendor/golang.org/x/tools/playground/socket/socket_test.go
@@ -0,0 +1,77 @@
+// 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 socket
+
+import (
+	"testing"
+	"time"
+)
+
+func TestBuffer(t *testing.T) {
+	afterChan := make(chan time.Time)
+	ch := make(chan *Message)
+	go func() {
+		ch <- &Message{Kind: "err", Body: "a"}
+		ch <- &Message{Kind: "err", Body: "b"}
+		ch <- &Message{Kind: "out", Body: "1"}
+		ch <- &Message{Kind: "out", Body: "2"}
+		afterChan <- time.Time{} // value itself doesn't matter
+		ch <- &Message{Kind: "out", Body: "3"}
+		ch <- &Message{Kind: "out", Body: "4"}
+		close(ch)
+	}()
+
+	var ms []*Message
+	timeAfter := func(d time.Duration) <-chan time.Time {
+		return afterChan
+	}
+	for m := range buffer(ch, timeAfter) {
+		ms = append(ms, m)
+	}
+	if len(ms) != 3 {
+		t.Fatalf("got %v messages, want 3", len(ms))
+	}
+	if g, w := ms[0].Body, "ab"; g != w {
+		t.Errorf("message 0 body = %q, want %q", g, w)
+	}
+	if g, w := ms[1].Body, "12"; g != w {
+		t.Errorf("message 1 body = %q, want %q", g, w)
+	}
+	if g, w := ms[2].Body, "34"; g != w {
+		t.Errorf("message 2 body = %q, want %q", g, w)
+	}
+}
+
+type killRecorder chan struct{}
+
+func (k killRecorder) Kill() { close(k) }
+
+func TestLimiter(t *testing.T) {
+	ch := make(chan *Message)
+	go func() {
+		var m Message
+		for i := 0; i < msgLimit+10; i++ {
+			ch <- &m
+		}
+		ch <- &Message{Kind: "end"}
+	}()
+
+	kr := make(killRecorder)
+	n := 0
+	for m := range limiter(ch, kr) {
+		n++
+		if n > msgLimit && m.Kind != "end" {
+			t.Errorf("received non-end message after limit")
+		}
+	}
+	if n != msgLimit+1 {
+		t.Errorf("received %v messages, want %v", n, msgLimit+1)
+	}
+	select {
+	case <-kr:
+	case <-time.After(100 * time.Millisecond):
+		t.Errorf("process wasn't killed after reaching limit")
+	}
+}
diff --git a/vendor/golang.org/x/tools/present/code.go b/vendor/golang.org/x/tools/present/code.go
index 5a29951..b47a72a 100644
--- a/vendor/golang.org/x/tools/present/code.go
+++ b/vendor/golang.org/x/tools/present/code.go
@@ -15,14 +15,19 @@ import (
 	"strings"
 )
 
-// Is the playground available?
+// PlayEnabled specifies whether runnable playground snippets should be
+// displayed in the present user interface.
 var PlayEnabled = false
 
-// TOOD(adg): replace the PlayEnabled flag with something less spaghetti-like.
+// TODO(adg): replace the PlayEnabled flag with something less spaghetti-like.
 // Instead this will probably be determined by a template execution Context
 // value that contains various global metadata required when rendering
 // templates.
 
+// NotesEnabled specifies whether presenter notes should be displayed in the
+// present user interface.
+var NotesEnabled = false
+
 func init() {
 	Register("code", parseCode)
 	Register("play", parseCode)
@@ -31,6 +36,7 @@ func init() {
 type Code struct {
 	Text     template.HTML
 	Play     bool   // runnable code
+	Edit     bool   // editable code
 	FileName string // file name
 	Ext      string // file extension
 	Raw      []byte // content of the file
@@ -56,6 +62,9 @@ func parseCode(ctx *Context, sourceFile string, sourceLine int, cmd string) (Ele
 	// Pull off the HL, if any, from the end of the input line.
 	highlight := ""
 	if hl := highlightRE.FindStringSubmatchIndex(cmd); len(hl) == 4 {
+		if hl[2] < 0 || hl[3] < 0 {
+			return nil, fmt.Errorf("%s:%d invalid highlight syntax", sourceFile, sourceLine)
+		}
 		highlight = cmd[hl[2]:hl[3]]
 		cmd = cmd[:hl[2]-2]
 	}
@@ -84,6 +93,11 @@ func parseCode(ctx *Context, sourceFile string, sourceLine int, cmd string) (Ele
 	if err != nil {
 		return nil, fmt.Errorf("%s:%d: %v", sourceFile, sourceLine, err)
 	}
+	if lo > hi {
+		// The search in addrToByteRange can wrap around so we might
+		// end up with the range ending before its starting point
+		hi, lo = lo, hi
+	}
 
 	// Acme pattern matches can stop mid-line,
 	// so run to end of line in both directions if not at line start/end.
@@ -117,6 +131,7 @@ func parseCode(ctx *Context, sourceFile string, sourceLine int, cmd string) (Ele
 	return Code{
 		Text:     template.HTML(buf.String()),
 		Play:     play,
+		Edit:     data.Edit,
 		FileName: filepath.Base(filename),
 		Ext:      filepath.Ext(filename),
 		Raw:      rawCode(lines),
@@ -250,44 +265,3 @@ func parseArgs(name string, line int, args []string) (res []interface{}, err err
 	}
 	return
 }
-
-// parseArg returns the integer or string value of the argument and tells which it is.
-func parseArg(arg interface{}, max int) (ival int, sval string, isInt bool, err error) {
-	switch n := arg.(type) {
-	case int:
-		if n <= 0 || n > max {
-			return 0, "", false, fmt.Errorf("%d is out of range", n)
-		}
-		return n, "", true, nil
-	case string:
-		return 0, n, false, nil
-	}
-	return 0, "", false, fmt.Errorf("unrecognized argument %v type %T", arg, arg)
-}
-
-// match identifies the input line that matches the pattern in a code invocation.
-// If start>0, match lines starting there rather than at the beginning.
-// The return value is 1-indexed.
-func match(file string, start int, lines []string, pattern string) (int, error) {
-	// $ matches the end of the file.
-	if pattern == "$" {
-		if len(lines) == 0 {
-			return 0, fmt.Errorf("%q: empty file", file)
-		}
-		return len(lines), nil
-	}
-	// /regexp/ matches the line that matches the regexp.
-	if len(pattern) > 2 && pattern[0] == '/' && pattern[len(pattern)-1] == '/' {
-		re, err := regexp.Compile(pattern[1 : len(pattern)-1])
-		if err != nil {
-			return 0, err
-		}
-		for i := start; i < len(lines); i++ {
-			if re.MatchString(lines[i]) {
-				return i + 1, nil
-			}
-		}
-		return 0, fmt.Errorf("%s: no match for %#q", file, pattern)
-	}
-	return 0, fmt.Errorf("unrecognized pattern: %q", pattern)
-}
diff --git a/vendor/golang.org/x/tools/present/code_test.go b/vendor/golang.org/x/tools/present/code_test.go
new file mode 100644
index 0000000..b01a4e3
--- /dev/null
+++ b/vendor/golang.org/x/tools/present/code_test.go
@@ -0,0 +1,225 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package present
+
+import (
+	"fmt"
+	"html/template"
+	"strings"
+	"testing"
+)
+
+func TestParseCode(t *testing.T) {
+	// Enable play but revert the change at the end.
+	defer func(play bool) { PlayEnabled = play }(PlayEnabled)
+	PlayEnabled = true
+
+	helloTest := []byte(`
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello, test")
+}
+`)
+	helloTestHTML := template.HTML(`
+<pre><span num="2">package main</span>
+<span num="3"></span>
+<span num="4">import &#34;fmt&#34;</span>
+<span num="5"></span>
+<span num="6">func main() {</span>
+<span num="7">    fmt.Println(&#34;hello, test&#34;)</span>
+<span num="8">}</span>
+</pre>
+`)
+	helloTestHL := []byte(`
+package main
+
+import "fmt" // HLimport
+
+func main() { // HLfunc
+	fmt.Println("hello, test") // HL
+}
+`)
+	highlight := func(h template.HTML, s string) template.HTML {
+		return template.HTML(strings.Replace(string(h), s, "<b>"+s+"</b>", -1))
+	}
+	read := func(b []byte, err error) func(string) ([]byte, error) {
+		return func(string) ([]byte, error) { return b, err }
+	}
+
+	tests := []struct {
+		name       string
+		readFile   func(string) ([]byte, error)
+		sourceFile string
+		cmd        string
+		err        string
+		Code
+	}{
+		{
+			name:       "all code, no play",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Raw:      helloTest,
+				Text:     helloTestHTML,
+			},
+		},
+		{
+			name:       "all code, play",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".play main.go",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Play:     true,
+				Raw:      helloTest,
+				Text:     helloTestHTML,
+			},
+		},
+		{
+			name:       "all code, highlighted",
+			readFile:   read(helloTestHL, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Raw:      helloTestHL,
+				Text:     highlight(helloTestHTML, "fmt.Println(&#34;hello, test&#34;)"),
+			},
+		},
+		{
+			name:       "highlight only func",
+			readFile:   read(helloTestHL, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go HLfunc",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Play:     false,
+				Raw:      []byte("package main\n\nimport \"fmt\" // HLimport\n\nfunc main() { // HLfunc\n\tfmt.Println(\"hello, test\") // HL\n}"),
+				Text:     highlight(helloTestHTML, "func main() {"),
+			},
+		},
+		{
+			name:       "bad highlight syntax",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go HL",
+			err:        "invalid highlight syntax",
+		},
+		{
+			name:       "error reading file",
+			readFile:   read(nil, fmt.Errorf("nope")),
+			sourceFile: "main.go",
+			cmd:        ".code main.go",
+			err:        "main.go:0: nope",
+		},
+		{
+			name:       "from func main to the end",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go /func main/,",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Play:     false,
+				Raw:      []byte("func main() {\n\tfmt.Println(\"hello, test\")\n}"),
+				Text:     "<pre><span num=\"6\">func main() {</span>\n<span num=\"7\">    fmt.Println(&#34;hello, test&#34;)</span>\n<span num=\"8\">}</span>\n</pre>",
+			},
+		},
+		{
+			name:       "just func main",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go /func main/",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Play:     false,
+				Raw:      []byte("func main() {"),
+				Text:     "<pre><span num=\"6\">func main() {</span>\n</pre>",
+			},
+		},
+		{
+			name:       "bad address",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code main.go /function main/",
+			err:        "main.go:0: no match for function main",
+		},
+		{
+			name:       "all code with  numbers",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code -numbers main.go",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Raw:      helloTest,
+				// Replacing the first "<pre>"
+				Text: "<pre class=\"numbers\">" + helloTestHTML[6:],
+			},
+		},
+		{
+			name:       "all code editable",
+			readFile:   read(helloTest, nil),
+			sourceFile: "main.go",
+			cmd:        ".code -edit main.go",
+			Code: Code{
+				Ext:      ".go",
+				FileName: "main.go",
+				Raw:      helloTest,
+				Text:     "<pre contenteditable=\"true\" spellcheck=\"false\">" + helloTestHTML[6:],
+			},
+		},
+	}
+
+	trimHTML := func(t template.HTML) string { return strings.TrimSpace(string(t)) }
+	trimBytes := func(b []byte) string { return strings.TrimSpace(string(b)) }
+
+	for _, tt := range tests {
+		ctx := &Context{tt.readFile}
+		e, err := parseCode(ctx, tt.sourceFile, 0, tt.cmd)
+		if err != nil {
+			if tt.err == "" {
+				t.Errorf("%s: unexpected error %v", tt.name, err)
+			} else if !strings.Contains(err.Error(), tt.err) {
+				t.Errorf("%s: expected error %s; got %v", tt.name, tt.err, err)
+			}
+			continue
+		}
+		if tt.err != "" {
+			t.Errorf("%s: expected error %s; but got none", tt.name, tt.err)
+			continue
+		}
+		c, ok := e.(Code)
+		if !ok {
+			t.Errorf("%s: expected a Code value; got %T", tt.name, e)
+			continue
+		}
+		if c.FileName != tt.FileName {
+			t.Errorf("%s: expected FileName %s; got %s", tt.name, tt.FileName, c.FileName)
+		}
+		if c.Ext != tt.Ext {
+			t.Errorf("%s: expected Ext %s; got %s", tt.name, tt.Ext, c.Ext)
+		}
+		if c.Play != tt.Play {
+			t.Errorf("%s: expected Play %v; got %v", tt.name, tt.Play, c.Play)
+		}
+		if got, wants := trimBytes(c.Raw), trimBytes(tt.Raw); got != wants {
+			t.Errorf("%s: expected Raw \n%q\n; got \n%q\n", tt.name, wants, got)
+		}
+		if got, wants := trimHTML(c.Text), trimHTML(tt.Text); got != wants {
+			t.Errorf("%s: expected Text \n%q\n; got \n%q\n", tt.name, wants, got)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/present/doc.go b/vendor/golang.org/x/tools/present/doc.go
index 584e0c1..45039b6 100644
--- a/vendor/golang.org/x/tools/present/doc.go
+++ b/vendor/golang.org/x/tools/present/doc.go
@@ -58,10 +58,11 @@ After that come slides/sections, each after a blank line:
 	.code x.go /^func main/,/^}/
 	.play y.go
 	.image image.jpg
+	.background image.jpg
 	.iframe http://foo
 	.link http://foo label
 	.html file.html
-	.caption _Gopher_ by [[http://www.reneefrench.com][Renée French]]
+	.caption _Gopher_ by [[https://www.instagram.com/reneefrench/][Renée French]]
 
 	Again, more text
 
@@ -76,14 +77,18 @@ Fonts:
 Within the input for plain text or lists, text bracketed by font
 markers will be presented in italic, bold, or program font.
 Marker characters are _ (italic), * (bold) and ` (program font).
-Unmatched markers appear as plain text.
-Within marked text, a single marker character becomes a space
-and a doubled single marker quotes the marker character.
+An opening marker must be preceded by a space or punctuation
+character or else be at start of a line; similarly, a closing
+marker must be followed by a space or punctuation character or
+else be at the end of a line. Unmatched markers appear as plain text.
+There must be no spaces between markers. Within marked text,
+a single marker character becomes a space and a doubled single
+marker quotes the marker character.
 
 	_italic_
 	*bold*
 	`program`
-	_this_is_all_italic_
+	Markup—_especially_italic_text_—can easily be overused.
 	_Why_use_scoped__ptr_? Use plain ***ptr* instead.
 
 Inline links:
@@ -112,7 +117,7 @@ a file name followed by an optional address that specifies what
 section of the file to display. The address syntax is similar in
 its simplest form to that of ed, but comes from sam and is more
 general. See
-	http://plan9.bell-labs.com/sys/doc/sam/sam.html Table II
+	https://plan9.io/sys/doc/sam/sam.html Table II
 for full details. The displayed block is always rounded out to a
 full line at both ends.
 
@@ -177,6 +182,28 @@ preserves the aspect ratio of the image when scaling.
 
 	.image images/janet.jpg _ 300
 
+video:
+
+The template uses the function "video" to inject video files.
+
+The syntax is simple: 2 or 4 space-separated arguments.
+The first argument is always the file name.
+The second argument is always the file content-type.
+If there are more arguments, they are the height and width;
+both must be present, or substituted with an underscore.
+Replacing a dimension argument with the underscore parameter
+preserves the aspect ratio of the video when scaling.
+
+	.video videos/evangeline.mp4 video/mp4 400 600
+
+	.video videos/mabel.ogg video/ogg 500 _
+
+background:
+
+The template uses the function "background" to set the background image for
+a slide.  The only argument is the file name of the image.
+
+	.background images/susan.jpg
 
 caption:
 
@@ -201,5 +228,35 @@ It is your responsibilty to make sure the included HTML is valid and safe.
 
 	.html file.html
 
+Presenter notes:
+
+Presenter notes may be enabled by appending the "-notes" flag when you run
+your "present" binary.
+
+This will allow you to open a second window by pressing 'N' from your browser
+displaying your slides. The second window is completely synced with your main
+window, except that presenter notes are only visible on the second window.
+
+Lines that begin with ": " are treated as presenter notes.
+
+	* Title of slide
+
+	Some Text
+
+	: Presenter notes (first paragraph)
+	: Presenter notes (subsequent paragraph(s))
+
+Notes may appear anywhere within the slide text. For example:
+
+	* Title of slide
+
+	: Presenter notes (first paragraph)
+
+	Some Text
+
+	: Presenter notes (subsequent paragraph(s))
+
+This has the same result as the example above.
+
 */
 package present // import "golang.org/x/tools/present"
diff --git a/vendor/golang.org/x/tools/present/iframe.go b/vendor/golang.org/x/tools/present/iframe.go
index 2f3c5e5..46649f0 100644
--- a/vendor/golang.org/x/tools/present/iframe.go
+++ b/vendor/golang.org/x/tools/present/iframe.go
@@ -39,7 +39,7 @@ func parseIframe(ctx *Context, fileName string, lineno int, text string) (Elem,
 			i.Width = v
 		}
 	default:
-		return nil, fmt.Errorf("incorrect image invocation: %q", text)
+		return nil, fmt.Errorf("incorrect iframe invocation: %q", text)
 	}
 	return i, nil
 }
diff --git a/vendor/golang.org/x/tools/present/link.go b/vendor/golang.org/x/tools/present/link.go
index 6b0968f..2aead35 100644
--- a/vendor/golang.org/x/tools/present/link.go
+++ b/vendor/golang.org/x/tools/present/link.go
@@ -24,6 +24,9 @@ func (l Link) TemplateName() string { return "link" }
 
 func parseLink(ctx *Context, fileName string, lineno int, text string) (Elem, error) {
 	args := strings.Fields(text)
+	if len(args) < 2 {
+		return nil, fmt.Errorf("link element must have at least 2 arguments")
+	}
 	url, err := url.Parse(args[1])
 	if err != nil {
 		return nil, err
@@ -49,7 +52,7 @@ func renderLink(href, text string) string {
 	// Open links in new window only when their url is absolute.
 	target := "_blank"
 	if u, err := url.Parse(href); err != nil {
-		log.Println("rendernLink parsing url:", err)
+		log.Println("renderLink parsing url:", err)
 	} else if !u.IsAbs() || u.Scheme == "javascript" {
 		target = "_self"
 	}
diff --git a/vendor/golang.org/x/tools/present/link_test.go b/vendor/golang.org/x/tools/present/link_test.go
new file mode 100644
index 0000000..334e72b
--- /dev/null
+++ b/vendor/golang.org/x/tools/present/link_test.go
@@ -0,0 +1,40 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package present
+
+import "testing"
+
+func TestInlineParsing(t *testing.T) {
+	var tests = []struct {
+		in     string
+		link   string
+		text   string
+		length int
+	}{
+		{"[[http://golang.org]]", "http://golang.org", "golang.org", 21},
+		{"[[http://golang.org][]]", "http://golang.org", "http://golang.org", 23},
+		{"[[http://golang.org]] this is ignored", "http://golang.org", "golang.org", 21},
+		{"[[http://golang.org][link]]", "http://golang.org", "link", 27},
+		{"[[http://golang.org][two words]]", "http://golang.org", "two words", 32},
+		{"[[http://golang.org][*link*]]", "http://golang.org", "<b>link</b>", 29},
+		{"[[http://bad[url]]", "", "", 0},
+		{"[[http://golang.org][a [[link]] ]]", "http://golang.org", "a [[link", 31},
+		{"[[http:// *spaces* .com]]", "", "", 0},
+		{"[[http://bad`char.com]]", "", "", 0},
+		{" [[http://google.com]]", "", "", 0},
+		{"[[mailto:gopher@golang.org][Gopher]]", "mailto:gopher@golang.org", "Gopher", 36},
+		{"[[mailto:gopher@golang.org]]", "mailto:gopher@golang.org", "gopher@golang.org", 28},
+	}
+
+	for i, test := range tests {
+		link, length := parseInlineLink(test.in)
+		if length == 0 && test.length == 0 {
+			continue
+		}
+		if a := renderLink(test.link, test.text); length != test.length || link != a {
+			t.Errorf("#%d: parseInlineLink(%q):\ngot\t%q, %d\nwant\t%q, %d", i, test.in, link, length, a, test.length)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/present/parse.go b/vendor/golang.org/x/tools/present/parse.go
index 449d5ed..d7289db 100644
--- a/vendor/golang.org/x/tools/present/parse.go
+++ b/vendor/golang.org/x/tools/present/parse.go
@@ -35,9 +35,10 @@ func Template() *template.Template {
 func (d *Doc) Render(w io.Writer, t *template.Template) error {
 	data := struct {
 		*Doc
-		Template    *template.Template
-		PlayEnabled bool
-	}{d, t, PlayEnabled}
+		Template     *template.Template
+		PlayEnabled  bool
+		NotesEnabled bool
+	}{d, t, PlayEnabled, NotesEnabled}
 	return t.ExecuteTemplate(w, "root", data)
 }
 
@@ -65,12 +66,13 @@ func Register(name string, parser ParseFunc) {
 
 // Doc represents an entire document.
 type Doc struct {
-	Title    string
-	Subtitle string
-	Time     time.Time
-	Authors  []Author
-	Sections []Section
-	Tags     []string
+	Title      string
+	Subtitle   string
+	Time       time.Time
+	Authors    []Author
+	TitleNotes []string
+	Sections   []Section
+	Tags       []string
 }
 
 // Author represents the person who wrote and/or is presenting the document.
@@ -94,11 +96,32 @@ func (p *Author) TextElem() (elems []Elem) {
 // Section represents a section of a document (such as a presentation slide)
 // comprising a title and a list of elements.
 type Section struct {
-	Number []int
-	Title  string
-	Elem   []Elem
+	Number  []int
+	Title   string
+	Elem    []Elem
+	Notes   []string
+	Classes []string
+	Styles  []string
 }
 
+// HTMLAttributes for the section
+func (s Section) HTMLAttributes() template.HTMLAttr {
+	if len(s.Classes) == 0 && len(s.Styles) == 0 {
+		return ""
+	}
+
+	var class string
+	if len(s.Classes) > 0 {
+		class = fmt.Sprintf(`class=%q`, strings.Join(s.Classes, " "))
+	}
+	var style string
+	if len(s.Styles) > 0 {
+		style = fmt.Sprintf(`style=%q`, strings.Join(s.Styles, " "))
+	}
+	return template.HTMLAttr(strings.Join([]string{class, style}, " "))
+}
+
+// Sections contained within the section.
 func (s Section) Sections() (sections []Section) {
 	for _, e := range s.Elem {
 		if section, ok := e.(Section); ok {
@@ -248,6 +271,17 @@ func (ctx *Context) Parse(r io.Reader, name string, mode ParseMode) (*Doc, error
 	if err != nil {
 		return nil, err
 	}
+
+	for i := lines.line; i < len(lines.text); i++ {
+		if strings.HasPrefix(lines.text[i], "*") {
+			break
+		}
+
+		if isSpeakerNote(lines.text[i]) {
+			doc.TitleNotes = append(doc.TitleNotes, lines.text[i][2:])
+		}
+	}
+
 	err = parseHeader(doc, lines)
 	if err != nil {
 		return nil, err
@@ -255,12 +289,13 @@ func (ctx *Context) Parse(r io.Reader, name string, mode ParseMode) (*Doc, error
 	if mode&TitlesOnly != 0 {
 		return doc, nil
 	}
+
 	// Authors
 	if doc.Authors, err = parseAuthors(lines); err != nil {
 		return nil, err
 	}
 	// Sections
-	if doc.Sections, err = parseSections(ctx, name, lines, []int{}, doc); err != nil {
+	if doc.Sections, err = parseSections(ctx, name, lines, []int{}); err != nil {
 		return nil, err
 	}
 	return doc, nil
@@ -284,7 +319,7 @@ func lesserHeading(text, prefix string) bool {
 
 // parseSections parses Sections from lines for the section level indicated by
 // number (a nil number indicates the top level).
-func parseSections(ctx *Context, name string, lines *Lines, number []int, doc *Doc) ([]Section, error) {
+func parseSections(ctx *Context, name string, lines *Lines, number []int) ([]Section, error) {
 	var sections []Section
 	for i := 1; ; i++ {
 		// Next non-empty line is title.
@@ -338,9 +373,11 @@ func parseSections(ctx *Context, name string, lines *Lines, number []int, doc *D
 				}
 				lines.back()
 				e = List{Bullet: b}
+			case isSpeakerNote(text):
+				section.Notes = append(section.Notes, text[2:])
 			case strings.HasPrefix(text, prefix+"* "):
 				lines.back()
-				subsecs, err := parseSections(ctx, name, lines, section.Number, doc)
+				subsecs, err := parseSections(ctx, name, lines, section.Number)
 				if err != nil {
 					return nil, err
 				}
@@ -349,6 +386,11 @@ func parseSections(ctx *Context, name string, lines *Lines, number []int, doc *D
 				}
 			case strings.HasPrefix(text, "."):
 				args := strings.Fields(text)
+				if args[0] == ".background" {
+					section.Classes = append(section.Classes, "background")
+					section.Styles = append(section.Styles, "background-image: url('"+args[1]+"')")
+					break
+				}
 				parser := parsers[args[0]]
 				if parser == nil {
 					return nil, fmt.Errorf("%s:%d: unknown command %q\n", name, lines.line, text)
@@ -362,6 +404,7 @@ func parseSections(ctx *Context, name string, lines *Lines, number []int, doc *D
 				var l []string
 				for ok && strings.TrimSpace(text) != "" {
 					if text[0] == '.' { // Command breaks text block.
+						lines.back()
 						break
 					}
 					if strings.HasPrefix(text, `\.`) { // Backslash escapes initial period.
@@ -402,6 +445,9 @@ func parseHeader(doc *Doc, lines *Lines) error {
 		if text == "" {
 			break
 		}
+		if isSpeakerNote(text) {
+			continue
+		}
 		const tagPrefix = "Tags:"
 		if strings.HasPrefix(text, tagPrefix) {
 			tags := strings.Split(text[len(tagPrefix):], ",")
@@ -442,6 +488,10 @@ func parseAuthors(lines *Lines) (authors []Author, err error) {
 			break
 		}
 
+		if isSpeakerNote(text) {
+			continue
+		}
+
 		// If we encounter a blank we're done with this author.
 		if a != nil && len(text) == 0 {
 			authors = append(authors, *a)
@@ -503,3 +553,7 @@ func parseTime(text string) (t time.Time, ok bool) {
 	}
 	return time.Time{}, false
 }
+
+func isSpeakerNote(s string) bool {
+	return strings.HasPrefix(s, ": ")
+}
diff --git a/vendor/golang.org/x/tools/present/style.go b/vendor/golang.org/x/tools/present/style.go
index 1cd240d..e2c228e 100644
--- a/vendor/golang.org/x/tools/present/style.go
+++ b/vendor/golang.org/x/tools/present/style.go
@@ -38,7 +38,7 @@ func Style(s string) template.HTML {
 
 // font returns s with font indicators turned into HTML font tags.
 func font(s string) string {
-	if strings.IndexAny(s, "[`_*") == -1 {
+	if !strings.ContainsAny(s, "[`_*") {
 		return s
 	}
 	words := split(s)
@@ -52,16 +52,16 @@ Word:
 			words[w] = link
 			continue Word
 		}
-		const punctuation = `.,;:()!?—–'"`
 		const marker = "_*`"
 		// Initial punctuation is OK but must be peeled off.
 		first := strings.IndexAny(word, marker)
 		if first == -1 {
 			continue Word
 		}
-		// Is the marker prefixed only by punctuation?
-		for _, r := range word[:first] {
-			if !strings.ContainsRune(punctuation, r) {
+		// Opening marker must be at the beginning of the token or else preceded by punctuation.
+		if first != 0 {
+			r, _ := utf8.DecodeLastRuneInString(word[:first])
+			if !unicode.IsPunct(r) {
 				continue Word
 			}
 		}
@@ -81,17 +81,18 @@ Word:
 			open += "<code>"
 			close = "</code>"
 		}
-		// Terminal punctuation is OK but must be peeled off.
+		// Closing marker must be at the end of the token or else followed by punctuation.
 		last := strings.LastIndex(word, word[:1])
 		if last == 0 {
 			continue Word
 		}
-		head, tail := word[:last+1], word[last+1:]
-		for _, r := range tail {
-			if !strings.ContainsRune(punctuation, r) {
+		if last+1 != len(word) {
+			r, _ := utf8.DecodeRuneInString(word[last+1:])
+			if !unicode.IsPunct(r) {
 				continue Word
 			}
 		}
+		head, tail := word[:last+1], word[last+1:]
 		b.Reset()
 		b.WriteString(open)
 		var wid int
diff --git a/vendor/golang.org/x/tools/present/style_test.go b/vendor/golang.org/x/tools/present/style_test.go
new file mode 100644
index 0000000..cef5a62
--- /dev/null
+++ b/vendor/golang.org/x/tools/present/style_test.go
@@ -0,0 +1,124 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package present
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestSplit(t *testing.T) {
+	var tests = []struct {
+		in  string
+		out []string
+	}{
+		{"", []string{}},
+		{" ", []string{" "}},
+		{"abc", []string{"abc"}},
+		{"abc def", []string{"abc", " ", "def"}},
+		{"abc def ", []string{"abc", " ", "def", " "}},
+		{"hey [[http://golang.org][Gophers]] around",
+			[]string{"hey", " ", "[[http://golang.org][Gophers]]", " ", "around"}},
+		{"A [[http://golang.org/doc][two words]] link",
+			[]string{"A", " ", "[[http://golang.org/doc][two words]]", " ", "link"}},
+		{"Visit [[http://golang.org/doc]] now",
+			[]string{"Visit", " ", "[[http://golang.org/doc]]", " ", "now"}},
+		{"not [[http://golang.org/doc][a [[link]] ]] around",
+			[]string{"not", " ", "[[http://golang.org/doc][a [[link]]", " ", "]]", " ", "around"}},
+		{"[[http://golang.org][foo bar]]",
+			[]string{"[[http://golang.org][foo bar]]"}},
+		{"ends with [[http://golang.org][link]]",
+			[]string{"ends", " ", "with", " ", "[[http://golang.org][link]]"}},
+		{"my talk ([[http://talks.golang.org/][slides here]])",
+			[]string{"my", " ", "talk", " ", "(", "[[http://talks.golang.org/][slides here]]", ")"}},
+	}
+	for _, test := range tests {
+		out := split(test.in)
+		if !reflect.DeepEqual(out, test.out) {
+			t.Errorf("split(%q):\ngot\t%q\nwant\t%q", test.in, out, test.out)
+		}
+	}
+}
+
+func TestFont(t *testing.T) {
+	var tests = []struct {
+		in  string
+		out string
+	}{
+		{"", ""},
+		{" ", " "},
+		{"\tx", "\tx"},
+		{"_a_", "<i>a</i>"},
+		{"*a*", "<b>a</b>"},
+		{"`a`", "<code>a</code>"},
+		{"_a_b_", "<i>a b</i>"},
+		{"_a__b_", "<i>a_b</i>"},
+		{"_a___b_", "<i>a_ b</i>"},
+		{"*a**b*?", "<b>a*b</b>?"},
+		{"_a_<>_b_.", "<i>a <> b</i>."},
+		{"(_a_)", "(<i>a</i>)"},
+		{"((_a_), _b_, _c_).", "((<i>a</i>), <i>b</i>, <i>c</i>)."},
+		{"(_a)", "(_a)"},
+		{"(_a)", "(_a)"},
+		{"_Why_use_scoped__ptr_? Use plain ***ptr* instead.", "<i>Why use scoped_ptr</i>? Use plain <b>*ptr</b> instead."},
+		{"_hey_ [[http://golang.org][*Gophers*]] *around*",
+			`<i>hey</i> <a href="http://golang.org" target="_blank"><b>Gophers</b></a> <b>around</b>`},
+		{"_hey_ [[http://golang.org][so _many_ *Gophers*]] *around*",
+			`<i>hey</i> <a href="http://golang.org" target="_blank">so <i>many</i> <b>Gophers</b></a> <b>around</b>`},
+		{"Visit [[http://golang.org]] now",
+			`Visit <a href="http://golang.org" target="_blank">golang.org</a> now`},
+		{"my talk ([[http://talks.golang.org/][slides here]])",
+			`my talk (<a href="http://talks.golang.org/" target="_blank">slides here</a>)`},
+		{"Markup—_especially_italic_text_—can easily be overused.",
+			`Markup—<i>especially italic text</i>—can easily be overused.`},
+		{"`go`get`'s codebase", // ascii U+0027 ' before s
+			`<code>go get</code>'s codebase`},
+		{"`go`get`’s codebase", // unicode right single quote U+2019 ’ before s
+			`<code>go get</code>’s codebase`},
+		{"a_variable_name",
+			`a_variable_name`},
+	}
+	for _, test := range tests {
+		out := font(test.in)
+		if out != test.out {
+			t.Errorf("font(%q):\ngot\t%q\nwant\t%q", test.in, out, test.out)
+		}
+	}
+}
+
+func TestStyle(t *testing.T) {
+	var tests = []struct {
+		in  string
+		out string
+	}{
+		{"", ""},
+		{" ", " "},
+		{"\tx", "\tx"},
+		{"_a_", "<i>a</i>"},
+		{"*a*", "<b>a</b>"},
+		{"`a`", "<code>a</code>"},
+		{"_a_b_", "<i>a b</i>"},
+		{"_a__b_", "<i>a_b</i>"},
+		{"_a___b_", "<i>a_ b</i>"},
+		{"*a**b*?", "<b>a*b</b>?"},
+		{"_a_<>_b_.", "<i>a &lt;&gt; b</i>."},
+		{"(_a_<>_b_)", "(<i>a &lt;&gt; b</i>)"},
+		{"((_a_), _b_, _c_).", "((<i>a</i>), <i>b</i>, <i>c</i>)."},
+		{"(_a)", "(_a)"},
+	}
+	for _, test := range tests {
+		out := string(Style(test.in))
+		if out != test.out {
+			t.Errorf("style(%q):\ngot\t%q\nwant\t%q", test.in, out, test.out)
+		}
+	}
+}
+
+func ExampleStyle() {
+	const s = "*Gophers* are _clearly_ > *cats*!"
+	fmt.Println(Style(s))
+	// Output: <b>Gophers</b> are <i>clearly</i> &gt; <b>cats</b>!
+}
diff --git a/vendor/golang.org/x/tools/present/video.go b/vendor/golang.org/x/tools/present/video.go
new file mode 100644
index 0000000..913822e
--- /dev/null
+++ b/vendor/golang.org/x/tools/present/video.go
@@ -0,0 +1,51 @@
+// 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 present
+
+import (
+	"fmt"
+	"strings"
+)
+
+func init() {
+	Register("video", parseVideo)
+}
+
+type Video struct {
+	URL        string
+	SourceType string
+	Width      int
+	Height     int
+}
+
+func (v Video) TemplateName() string { return "video" }
+
+func parseVideo(ctx *Context, fileName string, lineno int, text string) (Elem, error) {
+	args := strings.Fields(text)
+	vid := Video{URL: args[1], SourceType: args[2]}
+	a, err := parseArgs(fileName, lineno, args[3:])
+	if err != nil {
+		return nil, err
+	}
+	switch len(a) {
+	case 0:
+		// no size parameters
+	case 2:
+		// If a parameter is empty (underscore) or invalid
+		// leave the field set to zero. The "video" action
+		// template will then omit that vid tag attribute and
+		// the browser will calculate the value to preserve
+		// the aspect ratio.
+		if v, ok := a[0].(int); ok {
+			vid.Height = v
+		}
+		if v, ok := a[1].(int); ok {
+			vid.Width = v
+		}
+	default:
+		return nil, fmt.Errorf("incorrect video invocation: %q", text)
+	}
+	return vid, nil
+}
diff --git a/vendor/golang.org/x/tools/refactor/README b/vendor/golang.org/x/tools/refactor/README
new file mode 100644
index 0000000..a315784
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/README
@@ -0,0 +1 @@
+golang.org/x/tools/refactor: libraries for refactoring tools.
diff --git a/vendor/golang.org/x/tools/refactor/eg/eg.go b/vendor/golang.org/x/tools/refactor/eg/eg.go
new file mode 100644
index 0000000..bf0ee29
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/eg.go
@@ -0,0 +1,343 @@
+// 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 eg implements the example-based refactoring tool whose
+// command-line is defined in golang.org/x/tools/cmd/eg.
+package eg // import "golang.org/x/tools/refactor/eg"
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/printer"
+	"go/token"
+	"go/types"
+	"os"
+)
+
+const Help = `
+This tool implements example-based refactoring of expressions.
+
+The transformation is specified as a Go file defining two functions,
+'before' and 'after', of identical types.  Each function body consists
+of a single statement: either a return statement with a single
+(possibly multi-valued) expression, or an expression statement.  The
+'before' expression specifies a pattern and the 'after' expression its
+replacement.
+
+	package P
+ 	import ( "errors"; "fmt" )
+ 	func before(s string) error { return fmt.Errorf("%s", s) }
+ 	func after(s string)  error { return errors.New(s) }
+
+The expression statement form is useful when the expression has no
+result, for example:
+
+ 	func before(msg string) { log.Fatalf("%s", msg) }
+ 	func after(msg string)  { log.Fatal(msg) }
+
+The parameters of both functions are wildcards that may match any
+expression assignable to that type.  If the pattern contains multiple
+occurrences of the same parameter, each must match the same expression
+in the input for the pattern to match.  If the replacement contains
+multiple occurrences of the same parameter, the expression will be
+duplicated, possibly changing the side-effects.
+
+The tool analyses all Go code in the packages specified by the
+arguments, replacing all occurrences of the pattern with the
+substitution.
+
+So, the transform above would change this input:
+	err := fmt.Errorf("%s", "error: " + msg)
+to this output:
+	err := errors.New("error: " + msg)
+
+Identifiers, including qualified identifiers (p.X) are considered to
+match only if they denote the same object.  This allows correct
+matching even in the presence of dot imports, named imports and
+locally shadowed package names in the input program.
+
+Matching of type syntax is semantic, not syntactic: type syntax in the
+pattern matches type syntax in the input if the types are identical.
+Thus, func(x int) matches func(y int).
+
+This tool was inspired by other example-based refactoring tools,
+'gofmt -r' for Go and Refaster for Java.
+
+
+LIMITATIONS
+===========
+
+EXPRESSIVENESS
+
+Only refactorings that replace one expression with another, regardless
+of the expression's context, may be expressed.  Refactoring arbitrary
+statements (or sequences of statements) is a less well-defined problem
+and is less amenable to this approach.
+
+A pattern that contains a function literal (and hence statements)
+never matches.
+
+There is no way to generalize over related types, e.g. to express that
+a wildcard may have any integer type, for example.
+
+It is not possible to replace an expression by one of a different
+type, even in contexts where this is legal, such as x in fmt.Print(x).
+
+The struct literals T{x} and T{K: x} cannot both be matched by a single
+template.
+
+
+SAFETY
+
+Verifying that a transformation does not introduce type errors is very
+complex in the general case.  An innocuous-looking replacement of one
+constant by another (e.g. 1 to 2) may cause type errors relating to
+array types and indices, for example.  The tool performs only very
+superficial checks of type preservation.
+
+
+IMPORTS
+
+Although the matching algorithm is fully aware of scoping rules, the
+replacement algorithm is not, so the replacement code may contain
+incorrect identifier syntax for imported objects if there are dot
+imports, named imports or locally shadowed package names in the input
+program.
+
+Imports are added as needed, but they are not removed as needed.
+Run 'goimports' on the modified file for now.
+
+Dot imports are forbidden in the template.
+
+
+TIPS
+====
+
+Sometimes a little creativity is required to implement the desired
+migration.  This section lists a few tips and tricks.
+
+To remove the final parameter from a function, temporarily change the
+function signature so that the final parameter is variadic, as this
+allows legal calls both with and without the argument.  Then use eg to
+remove the final argument from all callers, and remove the variadic
+parameter by hand.  The reverse process can be used to add a final
+parameter.
+
+To add or remove parameters other than the final one, you must do it in
+stages: (1) declare a variant function f' with a different name and the
+desired parameters; (2) use eg to transform calls to f into calls to f',
+changing the arguments as needed; (3) change the declaration of f to
+match f'; (4) use eg to rename f' to f in all calls; (5) delete f'.
+`
+
+// TODO(adonovan): expand upon the above documentation as an HTML page.
+
+// A Transformer represents a single example-based transformation.
+type Transformer struct {
+	fset           *token.FileSet
+	verbose        bool
+	info           *types.Info // combined type info for template/input/output ASTs
+	seenInfos      map[*types.Info]bool
+	wildcards      map[*types.Var]bool                // set of parameters in func before()
+	env            map[string]ast.Expr                // maps parameter name to wildcard binding
+	importedObjs   map[types.Object]*ast.SelectorExpr // objects imported by after().
+	before, after  ast.Expr
+	allowWildcards bool
+
+	// Working state of Transform():
+	nsubsts    int            // number of substitutions made
+	currentPkg *types.Package // package of current call
+}
+
+// NewTransformer returns a transformer based on the specified template,
+// a single-file package containing "before" and "after" functions as
+// described in the package documentation.
+// tmplInfo is the type information for tmplFile.
+//
+func NewTransformer(fset *token.FileSet, tmplPkg *types.Package, tmplFile *ast.File, tmplInfo *types.Info, verbose bool) (*Transformer, error) {
+	// Check the template.
+	beforeSig := funcSig(tmplPkg, "before")
+	if beforeSig == nil {
+		return nil, fmt.Errorf("no 'before' func found in template")
+	}
+	afterSig := funcSig(tmplPkg, "after")
+	if afterSig == nil {
+		return nil, fmt.Errorf("no 'after' func found in template")
+	}
+
+	// TODO(adonovan): should we also check the names of the params match?
+	if !types.Identical(afterSig, beforeSig) {
+		return nil, fmt.Errorf("before %s and after %s functions have different signatures",
+			beforeSig, afterSig)
+	}
+
+	for _, imp := range tmplFile.Imports {
+		if imp.Name != nil && imp.Name.Name == "." {
+			// Dot imports are currently forbidden.  We
+			// make the simplifying assumption that all
+			// imports are regular, without local renames.
+			return nil, fmt.Errorf("dot-import (of %s) in template", imp.Path.Value)
+		}
+	}
+	var beforeDecl, afterDecl *ast.FuncDecl
+	for _, decl := range tmplFile.Decls {
+		if decl, ok := decl.(*ast.FuncDecl); ok {
+			switch decl.Name.Name {
+			case "before":
+				beforeDecl = decl
+			case "after":
+				afterDecl = decl
+			}
+		}
+	}
+
+	before, err := soleExpr(beforeDecl)
+	if err != nil {
+		return nil, fmt.Errorf("before: %s", err)
+	}
+	after, err := soleExpr(afterDecl)
+	if err != nil {
+		return nil, fmt.Errorf("after: %s", err)
+	}
+
+	wildcards := make(map[*types.Var]bool)
+	for i := 0; i < beforeSig.Params().Len(); i++ {
+		wildcards[beforeSig.Params().At(i)] = true
+	}
+
+	// checkExprTypes returns an error if Tb (type of before()) is not
+	// safe to replace with Ta (type of after()).
+	//
+	// Only superficial checks are performed, and they may result in both
+	// false positives and negatives.
+	//
+	// Ideally, we would only require that the replacement be assignable
+	// to the context of a specific pattern occurrence, but the type
+	// checker doesn't record that information and it's complex to deduce.
+	// A Go type cannot capture all the constraints of a given expression
+	// context, which may include the size, constness, signedness,
+	// namedness or constructor of its type, and even the specific value
+	// of the replacement.  (Consider the rule that array literal keys
+	// must be unique.)  So we cannot hope to prove the safety of a
+	// transformation in general.
+	Tb := tmplInfo.TypeOf(before)
+	Ta := tmplInfo.TypeOf(after)
+	if types.AssignableTo(Tb, Ta) {
+		// safe: replacement is assignable to pattern.
+	} else if tuple, ok := Tb.(*types.Tuple); ok && tuple.Len() == 0 {
+		// safe: pattern has void type (must appear in an ExprStmt).
+	} else {
+		return nil, fmt.Errorf("%s is not a safe replacement for %s", Ta, Tb)
+	}
+
+	tr := &Transformer{
+		fset:           fset,
+		verbose:        verbose,
+		wildcards:      wildcards,
+		allowWildcards: true,
+		seenInfos:      make(map[*types.Info]bool),
+		importedObjs:   make(map[types.Object]*ast.SelectorExpr),
+		before:         before,
+		after:          after,
+	}
+
+	// Combine type info from the template and input packages, and
+	// type info for the synthesized ASTs too.  This saves us
+	// having to book-keep where each ast.Node originated as we
+	// construct the resulting hybrid AST.
+	tr.info = &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+	}
+	mergeTypeInfo(tr.info, tmplInfo)
+
+	// Compute set of imported objects required by after().
+	// TODO(adonovan): reject dot-imports in pattern
+	ast.Inspect(after, func(n ast.Node) bool {
+		if n, ok := n.(*ast.SelectorExpr); ok {
+			if _, ok := tr.info.Selections[n]; !ok {
+				// qualified ident
+				obj := tr.info.Uses[n.Sel]
+				tr.importedObjs[obj] = n
+				return false // prune
+			}
+		}
+		return true // recur
+	})
+
+	return tr, nil
+}
+
+// WriteAST is a convenience function that writes AST f to the specified file.
+func WriteAST(fset *token.FileSet, filename string, f *ast.File) (err error) {
+	fh, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err2 := fh.Close(); err != nil {
+			err = err2 // prefer earlier error
+		}
+	}()
+	return format.Node(fh, fset, f)
+}
+
+// -- utilities --------------------------------------------------------
+
+// funcSig returns the signature of the specified package-level function.
+func funcSig(pkg *types.Package, name string) *types.Signature {
+	if f, ok := pkg.Scope().Lookup(name).(*types.Func); ok {
+		return f.Type().(*types.Signature)
+	}
+	return nil
+}
+
+// soleExpr returns the sole expression in the before/after template function.
+func soleExpr(fn *ast.FuncDecl) (ast.Expr, error) {
+	if fn.Body == nil {
+		return nil, fmt.Errorf("no body")
+	}
+	if len(fn.Body.List) != 1 {
+		return nil, fmt.Errorf("must contain a single statement")
+	}
+	switch stmt := fn.Body.List[0].(type) {
+	case *ast.ReturnStmt:
+		if len(stmt.Results) != 1 {
+			return nil, fmt.Errorf("return statement must have a single operand")
+		}
+		return stmt.Results[0], nil
+
+	case *ast.ExprStmt:
+		return stmt.X, nil
+	}
+
+	return nil, fmt.Errorf("must contain a single return or expression statement")
+}
+
+// mergeTypeInfo adds type info from src to dst.
+func mergeTypeInfo(dst, src *types.Info) {
+	for k, v := range src.Types {
+		dst.Types[k] = v
+	}
+	for k, v := range src.Defs {
+		dst.Defs[k] = v
+	}
+	for k, v := range src.Uses {
+		dst.Uses[k] = v
+	}
+	for k, v := range src.Selections {
+		dst.Selections[k] = v
+	}
+}
+
+// (debugging only)
+func astString(fset *token.FileSet, n ast.Node) string {
+	var buf bytes.Buffer
+	printer.Fprint(&buf, fset, n)
+	return buf.String()
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/eg_test.go b/vendor/golang.org/x/tools/refactor/eg/eg_test.go
new file mode 100644
index 0000000..896bc9b
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/eg_test.go
@@ -0,0 +1,160 @@
+// 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.
+
+// No testdata on Android.
+
+// +build !android
+
+package eg_test
+
+import (
+	"bytes"
+	"flag"
+	exact "go/constant"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/refactor/eg"
+)
+
+// TODO(adonovan): more tests:
+// - of command-line tool
+// - of all parts of syntax
+// - of applying a template to a package it imports:
+//   the replacement syntax should use unqualified names for its objects.
+
+var (
+	updateFlag  = flag.Bool("update", false, "update the golden files")
+	verboseFlag = flag.Bool("verbose", false, "show matcher information")
+)
+
+func Test(t *testing.T) {
+	switch runtime.GOOS {
+	case "windows":
+		t.Skipf("skipping test on %q (no /usr/bin/diff)", runtime.GOOS)
+	}
+
+	conf := loader.Config{
+		Fset:       token.NewFileSet(),
+		ParserMode: parser.ParseComments,
+	}
+
+	// Each entry is a single-file package.
+	// (Multi-file packages aren't interesting for this test.)
+	// Order matters: each non-template package is processed using
+	// the preceding template package.
+	for _, filename := range []string{
+		"testdata/A.template",
+		"testdata/A1.go",
+		"testdata/A2.go",
+
+		"testdata/B.template",
+		"testdata/B1.go",
+
+		"testdata/C.template",
+		"testdata/C1.go",
+
+		"testdata/D.template",
+		"testdata/D1.go",
+
+		"testdata/E.template",
+		"testdata/E1.go",
+
+		"testdata/F.template",
+		"testdata/F1.go",
+
+		"testdata/G.template",
+		"testdata/G1.go",
+
+		"testdata/H.template",
+		"testdata/H1.go",
+
+		"testdata/bad_type.template",
+		"testdata/no_before.template",
+		"testdata/no_after_return.template",
+		"testdata/type_mismatch.template",
+		"testdata/expr_type_mismatch.template",
+	} {
+		pkgname := strings.TrimSuffix(filepath.Base(filename), ".go")
+		conf.CreateFromFilenames(pkgname, filename)
+	}
+	iprog, err := conf.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var xform *eg.Transformer
+	for _, info := range iprog.Created {
+		file := info.Files[0]
+		filename := iprog.Fset.File(file.Pos()).Name() // foo.go
+
+		if strings.HasSuffix(filename, "template") {
+			// a new template
+			shouldFail, _ := info.Pkg.Scope().Lookup("shouldFail").(*types.Const)
+			xform, err = eg.NewTransformer(iprog.Fset, info.Pkg, file, &info.Info, *verboseFlag)
+			if err != nil {
+				if shouldFail == nil {
+					t.Errorf("NewTransformer(%s): %s", filename, err)
+				} else if want := exact.StringVal(shouldFail.Val()); !strings.Contains(err.Error(), want) {
+					t.Errorf("NewTransformer(%s): got error %q, want error %q", filename, err, want)
+				}
+			} else if shouldFail != nil {
+				t.Errorf("NewTransformer(%s) succeeded unexpectedly; want error %q",
+					filename, shouldFail.Val())
+			}
+			continue
+		}
+
+		if xform == nil {
+			t.Errorf("%s: no previous template", filename)
+			continue
+		}
+
+		// apply previous template to this package
+		n := xform.Transform(&info.Info, info.Pkg, file)
+		if n == 0 {
+			t.Errorf("%s: no matches", filename)
+			continue
+		}
+
+		got := filename + "t"       // foo.got
+		golden := filename + "lden" // foo.golden
+
+		// Write actual output to foo.got.
+		if err := eg.WriteAST(iprog.Fset, got, file); err != nil {
+			t.Error(err)
+		}
+		defer os.Remove(got)
+
+		// Compare foo.got with foo.golden.
+		var cmd *exec.Cmd
+		switch runtime.GOOS {
+		case "plan9":
+			cmd = exec.Command("/bin/diff", "-c", golden, got)
+		default:
+			cmd = exec.Command("/usr/bin/diff", "-u", golden, got)
+		}
+		buf := new(bytes.Buffer)
+		cmd.Stdout = buf
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			t.Errorf("eg tests for %s failed: %s.\n%s\n", filename, err, buf)
+
+			if *updateFlag {
+				t.Logf("Updating %s...", golden)
+				if err := exec.Command("/bin/cp", got, golden).Run(); err != nil {
+					t.Errorf("Update failed: %s", err)
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/match.go b/vendor/golang.org/x/tools/refactor/eg/match.go
new file mode 100644
index 0000000..4346620
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/match.go
@@ -0,0 +1,249 @@
+// 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 eg
+
+import (
+	"fmt"
+	"go/ast"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+	"reflect"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// matchExpr reports whether pattern x matches y.
+//
+// If tr.allowWildcards, Idents in x that refer to parameters are
+// treated as wildcards, and match any y that is assignable to the
+// parameter type; matchExpr records this correspondence in tr.env.
+// Otherwise, matchExpr simply reports whether the two trees are
+// equivalent.
+//
+// A wildcard appearing more than once in the pattern must
+// consistently match the same tree.
+//
+func (tr *Transformer) matchExpr(x, y ast.Expr) bool {
+	if x == nil && y == nil {
+		return true
+	}
+	if x == nil || y == nil {
+		return false
+	}
+	x = unparen(x)
+	y = unparen(y)
+
+	// Is x a wildcard?  (a reference to a 'before' parameter)
+	if xobj, ok := tr.wildcardObj(x); ok {
+		return tr.matchWildcard(xobj, y)
+	}
+
+	// Object identifiers (including pkg-qualified ones)
+	// are handled semantically, not syntactically.
+	xobj := isRef(x, tr.info)
+	yobj := isRef(y, tr.info)
+	if xobj != nil {
+		return xobj == yobj
+	}
+	if yobj != nil {
+		return false
+	}
+
+	// TODO(adonovan): audit: we cannot assume these ast.Exprs
+	// contain non-nil pointers.  e.g. ImportSpec.Name may be a
+	// nil *ast.Ident.
+
+	if reflect.TypeOf(x) != reflect.TypeOf(y) {
+		return false
+	}
+	switch x := x.(type) {
+	case *ast.Ident:
+		log.Fatalf("unexpected Ident: %s", astString(tr.fset, x))
+
+	case *ast.BasicLit:
+		y := y.(*ast.BasicLit)
+		xval := exact.MakeFromLiteral(x.Value, x.Kind, 0)
+		yval := exact.MakeFromLiteral(y.Value, y.Kind, 0)
+		return exact.Compare(xval, token.EQL, yval)
+
+	case *ast.FuncLit:
+		// func literals (and thus statement syntax) never match.
+		return false
+
+	case *ast.CompositeLit:
+		y := y.(*ast.CompositeLit)
+		return (x.Type == nil) == (y.Type == nil) &&
+			(x.Type == nil || tr.matchType(x.Type, y.Type)) &&
+			tr.matchExprs(x.Elts, y.Elts)
+
+	case *ast.SelectorExpr:
+		y := y.(*ast.SelectorExpr)
+		return tr.matchSelectorExpr(x, y) &&
+			tr.info.Selections[x].Obj() == tr.info.Selections[y].Obj()
+
+	case *ast.IndexExpr:
+		y := y.(*ast.IndexExpr)
+		return tr.matchExpr(x.X, y.X) &&
+			tr.matchExpr(x.Index, y.Index)
+
+	case *ast.SliceExpr:
+		y := y.(*ast.SliceExpr)
+		return tr.matchExpr(x.X, y.X) &&
+			tr.matchExpr(x.Low, y.Low) &&
+			tr.matchExpr(x.High, y.High) &&
+			tr.matchExpr(x.Max, y.Max) &&
+			x.Slice3 == y.Slice3
+
+	case *ast.TypeAssertExpr:
+		y := y.(*ast.TypeAssertExpr)
+		return tr.matchExpr(x.X, y.X) &&
+			tr.matchType(x.Type, y.Type)
+
+	case *ast.CallExpr:
+		y := y.(*ast.CallExpr)
+		match := tr.matchExpr // function call
+		if tr.info.Types[x.Fun].IsType() {
+			match = tr.matchType // type conversion
+		}
+		return x.Ellipsis.IsValid() == y.Ellipsis.IsValid() &&
+			match(x.Fun, y.Fun) &&
+			tr.matchExprs(x.Args, y.Args)
+
+	case *ast.StarExpr:
+		y := y.(*ast.StarExpr)
+		return tr.matchExpr(x.X, y.X)
+
+	case *ast.UnaryExpr:
+		y := y.(*ast.UnaryExpr)
+		return x.Op == y.Op &&
+			tr.matchExpr(x.X, y.X)
+
+	case *ast.BinaryExpr:
+		y := y.(*ast.BinaryExpr)
+		return x.Op == y.Op &&
+			tr.matchExpr(x.X, y.X) &&
+			tr.matchExpr(x.Y, y.Y)
+
+	case *ast.KeyValueExpr:
+		y := y.(*ast.KeyValueExpr)
+		return tr.matchExpr(x.Key, y.Key) &&
+			tr.matchExpr(x.Value, y.Value)
+	}
+
+	panic(fmt.Sprintf("unhandled AST node type: %T", x))
+}
+
+func (tr *Transformer) matchExprs(xx, yy []ast.Expr) bool {
+	if len(xx) != len(yy) {
+		return false
+	}
+	for i := range xx {
+		if !tr.matchExpr(xx[i], yy[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// matchType reports whether the two type ASTs denote identical types.
+func (tr *Transformer) matchType(x, y ast.Expr) bool {
+	tx := tr.info.Types[x].Type
+	ty := tr.info.Types[y].Type
+	return types.Identical(tx, ty)
+}
+
+func (tr *Transformer) wildcardObj(x ast.Expr) (*types.Var, bool) {
+	if x, ok := x.(*ast.Ident); ok && x != nil && tr.allowWildcards {
+		if xobj, ok := tr.info.Uses[x].(*types.Var); ok && tr.wildcards[xobj] {
+			return xobj, true
+		}
+	}
+	return nil, false
+}
+
+func (tr *Transformer) matchSelectorExpr(x, y *ast.SelectorExpr) bool {
+	if xobj, ok := tr.wildcardObj(x.X); ok {
+		field := x.Sel.Name
+		yt := tr.info.TypeOf(y.X)
+		o, _, _ := types.LookupFieldOrMethod(yt, true, tr.currentPkg, field)
+		if o != nil {
+			tr.env[xobj.Name()] = y.X // record binding
+			return true
+		}
+	}
+	return tr.matchExpr(x.X, y.X)
+}
+
+func (tr *Transformer) matchWildcard(xobj *types.Var, y ast.Expr) bool {
+	name := xobj.Name()
+
+	if tr.verbose {
+		fmt.Fprintf(os.Stderr, "%s: wildcard %s -> %s?: ",
+			tr.fset.Position(y.Pos()), name, astString(tr.fset, y))
+	}
+
+	// Check that y is assignable to the declared type of the param.
+	yt := tr.info.TypeOf(y)
+	if yt == nil {
+		// y has no type.
+		// Perhaps it is an *ast.Ellipsis in [...]T{}, or
+		// an *ast.KeyValueExpr in T{k: v}.
+		// Clearly these pseudo-expressions cannot match a
+		// wildcard, but it would nice if we had a way to ignore
+		// the difference between T{v} and T{k:v} for structs.
+		return false
+	}
+	if !types.AssignableTo(yt, xobj.Type()) {
+		if tr.verbose {
+			fmt.Fprintf(os.Stderr, "%s not assignable to %s\n", yt, xobj.Type())
+		}
+		return false
+	}
+
+	// A wildcard matches any expression.
+	// If it appears multiple times in the pattern, it must match
+	// the same expression each time.
+	if old, ok := tr.env[name]; ok {
+		// found existing binding
+		tr.allowWildcards = false
+		r := tr.matchExpr(old, y)
+		if tr.verbose {
+			fmt.Fprintf(os.Stderr, "%t secondary match, primary was %s\n",
+				r, astString(tr.fset, old))
+		}
+		tr.allowWildcards = true
+		return r
+	}
+
+	if tr.verbose {
+		fmt.Fprintf(os.Stderr, "primary match\n")
+	}
+
+	tr.env[name] = y // record binding
+	return true
+}
+
+// -- utilities --------------------------------------------------------
+
+func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
+
+// isRef returns the object referred to by this (possibly qualified)
+// identifier, or nil if the node is not a referring identifier.
+func isRef(n ast.Node, info *types.Info) types.Object {
+	switch n := n.(type) {
+	case *ast.Ident:
+		return info.Uses[n]
+
+	case *ast.SelectorExpr:
+		if _, ok := info.Selections[n]; !ok {
+			// qualified ident
+			return info.Uses[n.Sel]
+		}
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/rewrite.go b/vendor/golang.org/x/tools/refactor/eg/rewrite.go
new file mode 100644
index 0000000..dd28aa5
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/rewrite.go
@@ -0,0 +1,343 @@
+// 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 eg
+
+// This file defines the AST rewriting pass.
+// Most of it was plundered directly from
+// $GOROOT/src/cmd/gofmt/rewrite.go (after convergent evolution).
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"os"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// Transform applies the transformation to the specified parsed file,
+// whose type information is supplied in info, and returns the number
+// of replacements that were made.
+//
+// It mutates the AST in place (the identity of the root node is
+// unchanged), and may add nodes for which no type information is
+// available in info.
+//
+// Derived from rewriteFile in $GOROOT/src/cmd/gofmt/rewrite.go.
+//
+func (tr *Transformer) Transform(info *types.Info, pkg *types.Package, file *ast.File) int {
+	if !tr.seenInfos[info] {
+		tr.seenInfos[info] = true
+		mergeTypeInfo(tr.info, info)
+	}
+	tr.currentPkg = pkg
+	tr.nsubsts = 0
+
+	if tr.verbose {
+		fmt.Fprintf(os.Stderr, "before: %s\n", astString(tr.fset, tr.before))
+		fmt.Fprintf(os.Stderr, "after: %s\n", astString(tr.fset, tr.after))
+	}
+
+	var f func(rv reflect.Value) reflect.Value
+	f = func(rv reflect.Value) reflect.Value {
+		// don't bother if val is invalid to start with
+		if !rv.IsValid() {
+			return reflect.Value{}
+		}
+
+		rv = apply(f, rv)
+
+		e := rvToExpr(rv)
+		if e != nil {
+			savedEnv := tr.env
+			tr.env = make(map[string]ast.Expr) // inefficient!  Use a slice of k/v pairs
+
+			if tr.matchExpr(tr.before, e) {
+				if tr.verbose {
+					fmt.Fprintf(os.Stderr, "%s matches %s",
+						astString(tr.fset, tr.before), astString(tr.fset, e))
+					if len(tr.env) > 0 {
+						fmt.Fprintf(os.Stderr, " with:")
+						for name, ast := range tr.env {
+							fmt.Fprintf(os.Stderr, " %s->%s",
+								name, astString(tr.fset, ast))
+						}
+					}
+					fmt.Fprintf(os.Stderr, "\n")
+				}
+				tr.nsubsts++
+
+				// Clone the replacement tree, performing parameter substitution.
+				// We update all positions to n.Pos() to aid comment placement.
+				rv = tr.subst(tr.env, reflect.ValueOf(tr.after),
+					reflect.ValueOf(e.Pos()))
+			}
+			tr.env = savedEnv
+		}
+
+		return rv
+	}
+	file2 := apply(f, reflect.ValueOf(file)).Interface().(*ast.File)
+
+	// By construction, the root node is unchanged.
+	if file != file2 {
+		panic("BUG")
+	}
+
+	// Add any necessary imports.
+	// TODO(adonovan): remove no-longer needed imports too.
+	if tr.nsubsts > 0 {
+		pkgs := make(map[string]*types.Package)
+		for obj := range tr.importedObjs {
+			pkgs[obj.Pkg().Path()] = obj.Pkg()
+		}
+
+		for _, imp := range file.Imports {
+			path, _ := strconv.Unquote(imp.Path.Value)
+			delete(pkgs, path)
+		}
+		delete(pkgs, pkg.Path()) // don't import self
+
+		// NB: AddImport may completely replace the AST!
+		// It thus renders info and tr.info no longer relevant to file.
+		var paths []string
+		for path := range pkgs {
+			paths = append(paths, path)
+		}
+		sort.Strings(paths)
+		for _, path := range paths {
+			astutil.AddImport(tr.fset, file, path)
+		}
+	}
+
+	tr.currentPkg = nil
+
+	return tr.nsubsts
+}
+
+// setValue is a wrapper for x.SetValue(y); it protects
+// the caller from panics if x cannot be changed to y.
+func setValue(x, y reflect.Value) {
+	// don't bother if y is invalid to start with
+	if !y.IsValid() {
+		return
+	}
+	defer func() {
+		if x := recover(); x != nil {
+			if s, ok := x.(string); ok &&
+				(strings.Contains(s, "type mismatch") || strings.Contains(s, "not assignable")) {
+				// x cannot be set to y - ignore this rewrite
+				return
+			}
+			panic(x)
+		}
+	}()
+	x.Set(y)
+}
+
+// Values/types for special cases.
+var (
+	objectPtrNil = reflect.ValueOf((*ast.Object)(nil))
+	scopePtrNil  = reflect.ValueOf((*ast.Scope)(nil))
+
+	identType        = reflect.TypeOf((*ast.Ident)(nil))
+	selectorExprType = reflect.TypeOf((*ast.SelectorExpr)(nil))
+	objectPtrType    = reflect.TypeOf((*ast.Object)(nil))
+	positionType     = reflect.TypeOf(token.NoPos)
+	scopePtrType     = reflect.TypeOf((*ast.Scope)(nil))
+)
+
+// apply replaces each AST field x in val with f(x), returning val.
+// To avoid extra conversions, f operates on the reflect.Value form.
+func apply(f func(reflect.Value) reflect.Value, val reflect.Value) reflect.Value {
+	if !val.IsValid() {
+		return reflect.Value{}
+	}
+
+	// *ast.Objects introduce cycles and are likely incorrect after
+	// rewrite; don't follow them but replace with nil instead
+	if val.Type() == objectPtrType {
+		return objectPtrNil
+	}
+
+	// similarly for scopes: they are likely incorrect after a rewrite;
+	// replace them with nil
+	if val.Type() == scopePtrType {
+		return scopePtrNil
+	}
+
+	switch v := reflect.Indirect(val); v.Kind() {
+	case reflect.Slice:
+		for i := 0; i < v.Len(); i++ {
+			e := v.Index(i)
+			setValue(e, f(e))
+		}
+	case reflect.Struct:
+		for i := 0; i < v.NumField(); i++ {
+			e := v.Field(i)
+			setValue(e, f(e))
+		}
+	case reflect.Interface:
+		e := v.Elem()
+		setValue(v, f(e))
+	}
+	return val
+}
+
+// subst returns a copy of (replacement) pattern with values from env
+// substituted in place of wildcards and pos used as the position of
+// tokens from the pattern.  if env == nil, subst returns a copy of
+// pattern and doesn't change the line number information.
+func (tr *Transformer) subst(env map[string]ast.Expr, pattern, pos reflect.Value) reflect.Value {
+	if !pattern.IsValid() {
+		return reflect.Value{}
+	}
+
+	// *ast.Objects introduce cycles and are likely incorrect after
+	// rewrite; don't follow them but replace with nil instead
+	if pattern.Type() == objectPtrType {
+		return objectPtrNil
+	}
+
+	// similarly for scopes: they are likely incorrect after a rewrite;
+	// replace them with nil
+	if pattern.Type() == scopePtrType {
+		return scopePtrNil
+	}
+
+	// Wildcard gets replaced with map value.
+	if env != nil && pattern.Type() == identType {
+		id := pattern.Interface().(*ast.Ident)
+		if old, ok := env[id.Name]; ok {
+			return tr.subst(nil, reflect.ValueOf(old), reflect.Value{})
+		}
+	}
+
+	// Emit qualified identifiers in the pattern by appropriate
+	// (possibly qualified) identifier in the input.
+	//
+	// The template cannot contain dot imports, so all identifiers
+	// for imported objects are explicitly qualified.
+	//
+	// We assume (unsoundly) that there are no dot or named
+	// imports in the input code, nor are any imported package
+	// names shadowed, so the usual normal qualified identifier
+	// syntax may be used.
+	// TODO(adonovan): fix: avoid this assumption.
+	//
+	// A refactoring may be applied to a package referenced by the
+	// template.  Objects belonging to the current package are
+	// denoted by unqualified identifiers.
+	//
+	if tr.importedObjs != nil && pattern.Type() == selectorExprType {
+		obj := isRef(pattern.Interface().(*ast.SelectorExpr), tr.info)
+		if obj != nil {
+			if sel, ok := tr.importedObjs[obj]; ok {
+				var id ast.Expr
+				if obj.Pkg() == tr.currentPkg {
+					id = sel.Sel // unqualified
+				} else {
+					id = sel // pkg-qualified
+				}
+
+				// Return a clone of id.
+				saved := tr.importedObjs
+				tr.importedObjs = nil // break cycle
+				r := tr.subst(nil, reflect.ValueOf(id), pos)
+				tr.importedObjs = saved
+				return r
+			}
+		}
+	}
+
+	if pos.IsValid() && pattern.Type() == positionType {
+		// use new position only if old position was valid in the first place
+		if old := pattern.Interface().(token.Pos); !old.IsValid() {
+			return pattern
+		}
+		return pos
+	}
+
+	// Otherwise copy.
+	switch p := pattern; p.Kind() {
+	case reflect.Slice:
+		v := reflect.MakeSlice(p.Type(), p.Len(), p.Len())
+		for i := 0; i < p.Len(); i++ {
+			v.Index(i).Set(tr.subst(env, p.Index(i), pos))
+		}
+		return v
+
+	case reflect.Struct:
+		v := reflect.New(p.Type()).Elem()
+		for i := 0; i < p.NumField(); i++ {
+			v.Field(i).Set(tr.subst(env, p.Field(i), pos))
+		}
+		return v
+
+	case reflect.Ptr:
+		v := reflect.New(p.Type()).Elem()
+		if elem := p.Elem(); elem.IsValid() {
+			v.Set(tr.subst(env, elem, pos).Addr())
+		}
+
+		// Duplicate type information for duplicated ast.Expr.
+		// All ast.Node implementations are *structs,
+		// so this case catches them all.
+		if e := rvToExpr(v); e != nil {
+			updateTypeInfo(tr.info, e, p.Interface().(ast.Expr))
+		}
+		return v
+
+	case reflect.Interface:
+		v := reflect.New(p.Type()).Elem()
+		if elem := p.Elem(); elem.IsValid() {
+			v.Set(tr.subst(env, elem, pos))
+		}
+		return v
+	}
+
+	return pattern
+}
+
+// -- utilities -------------------------------------------------------
+
+func rvToExpr(rv reflect.Value) ast.Expr {
+	if rv.CanInterface() {
+		if e, ok := rv.Interface().(ast.Expr); ok {
+			return e
+		}
+	}
+	return nil
+}
+
+// updateTypeInfo duplicates type information for the existing AST old
+// so that it also applies to duplicated AST new.
+func updateTypeInfo(info *types.Info, new, old ast.Expr) {
+	switch new := new.(type) {
+	case *ast.Ident:
+		orig := old.(*ast.Ident)
+		if obj, ok := info.Defs[orig]; ok {
+			info.Defs[new] = obj
+		}
+		if obj, ok := info.Uses[orig]; ok {
+			info.Uses[new] = obj
+		}
+
+	case *ast.SelectorExpr:
+		orig := old.(*ast.SelectorExpr)
+		if sel, ok := info.Selections[orig]; ok {
+			info.Selections[new] = sel
+		}
+	}
+
+	if tv, ok := info.Types[old]; ok {
+		info.Types[new] = tv
+	}
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/A.template b/vendor/golang.org/x/tools/refactor/eg/testdata/A.template
new file mode 100644
index 0000000..f611961
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/A.template
@@ -0,0 +1,13 @@
+// +build ignore
+
+package template
+
+// Basic test of type-aware expression refactoring.
+
+import (
+	"errors"
+	"fmt"
+)
+
+func before(s string) error { return fmt.Errorf("%s", s) }
+func after(s string) error  { return errors.New(s) }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/A1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/A1.go
new file mode 100644
index 0000000..9e65eb3
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/A1.go
@@ -0,0 +1,51 @@
+// +build ignore
+
+package A1
+
+import (
+	. "fmt"
+	myfmt "fmt"
+	"os"
+	"strings"
+)
+
+func example(n int) {
+	x := "foo" + strings.Repeat("\t", n)
+	// Match, despite named import.
+	myfmt.Errorf("%s", x)
+
+	// Match, despite dot import.
+	Errorf("%s", x)
+
+	// Match: multiple matches in same function are possible.
+	myfmt.Errorf("%s", x)
+
+	// No match: wildcarded operand has the wrong type.
+	myfmt.Errorf("%s", 3)
+
+	// No match: function operand doesn't match.
+	myfmt.Printf("%s", x)
+
+	// No match again, dot import.
+	Printf("%s", x)
+
+	// Match.
+	myfmt.Fprint(os.Stderr, myfmt.Errorf("%s", x+"foo"))
+
+	// No match: though this literally matches the template,
+	// fmt doesn't resolve to a package here.
+	var fmt struct{ Errorf func(string, string) }
+	fmt.Errorf("%s", x)
+
+	// Recursive matching:
+
+	// Match: both matches are well-typed, so both succeed.
+	myfmt.Errorf("%s", myfmt.Errorf("%s", x+"foo").Error())
+
+	// Outer match succeeds, inner doesn't: 3 has wrong type.
+	myfmt.Errorf("%s", myfmt.Errorf("%s", 3).Error())
+
+	// Inner match succeeds, outer doesn't: the inner replacement
+	// has the wrong type (error not string).
+	myfmt.Errorf("%s", myfmt.Errorf("%s", x+"foo"))
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/A1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/A1.golden
new file mode 100644
index 0000000..7eb2934
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/A1.golden
@@ -0,0 +1,52 @@
+// +build ignore
+
+package A1
+
+import (
+	"errors"
+	. "fmt"
+	myfmt "fmt"
+	"os"
+	"strings"
+)
+
+func example(n int) {
+	x := "foo" + strings.Repeat("\t", n)
+	// Match, despite named import.
+	errors.New(x)
+
+	// Match, despite dot import.
+	errors.New(x)
+
+	// Match: multiple matches in same function are possible.
+	errors.New(x)
+
+	// No match: wildcarded operand has the wrong type.
+	myfmt.Errorf("%s", 3)
+
+	// No match: function operand doesn't match.
+	myfmt.Printf("%s", x)
+
+	// No match again, dot import.
+	Printf("%s", x)
+
+	// Match.
+	myfmt.Fprint(os.Stderr, errors.New(x+"foo"))
+
+	// No match: though this literally matches the template,
+	// fmt doesn't resolve to a package here.
+	var fmt struct{ Errorf func(string, string) }
+	fmt.Errorf("%s", x)
+
+	// Recursive matching:
+
+	// Match: both matches are well-typed, so both succeed.
+	errors.New(errors.New(x + "foo").Error())
+
+	// Outer match succeeds, inner doesn't: 3 has wrong type.
+	errors.New(myfmt.Errorf("%s", 3).Error())
+
+	// Inner match succeeds, outer doesn't: the inner replacement
+	// has the wrong type (error not string).
+	myfmt.Errorf("%s", errors.New(x+"foo"))
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/A2.go b/vendor/golang.org/x/tools/refactor/eg/testdata/A2.go
new file mode 100644
index 0000000..3ae29ad
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/A2.go
@@ -0,0 +1,12 @@
+// +build ignore
+
+package A2
+
+// This refactoring causes addition of "errors" import.
+// TODO(adonovan): fix: it should also remove "fmt".
+
+import myfmt "fmt"
+
+func example(n int) {
+	myfmt.Errorf("%s", "")
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/A2.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/A2.golden
new file mode 100644
index 0000000..b6e3a6d
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/A2.golden
@@ -0,0 +1,15 @@
+// +build ignore
+
+package A2
+
+// This refactoring causes addition of "errors" import.
+// TODO(adonovan): fix: it should also remove "fmt".
+
+import (
+	"errors"
+	myfmt "fmt"
+)
+
+func example(n int) {
+	errors.New("")
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/B.template b/vendor/golang.org/x/tools/refactor/eg/testdata/B.template
new file mode 100644
index 0000000..c16627b
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/B.template
@@ -0,0 +1,9 @@
+package template
+
+// Basic test of expression refactoring.
+// (Types are not important in this case; it could be done with gofmt -r.)
+
+import "time"
+
+func before(t time.Time) time.Duration { return time.Now().Sub(t) }
+func after(t time.Time) time.Duration  { return time.Since(t) }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/B1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/B1.go
new file mode 100644
index 0000000..8b52546
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/B1.go
@@ -0,0 +1,17 @@
+// +build ignore
+
+package B1
+
+import "time"
+
+var startup = time.Now()
+
+func example() time.Duration {
+	before := time.Now()
+	time.Sleep(1)
+	return time.Now().Sub(before)
+}
+
+func msSinceStartup() int64 {
+	return int64(time.Now().Sub(startup) / time.Millisecond)
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/B1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/B1.golden
new file mode 100644
index 0000000..4d4da21
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/B1.golden
@@ -0,0 +1,17 @@
+// +build ignore
+
+package B1
+
+import "time"
+
+var startup = time.Now()
+
+func example() time.Duration {
+	before := time.Now()
+	time.Sleep(1)
+	return time.Since(before)
+}
+
+func msSinceStartup() int64 {
+	return int64(time.Since(startup) / time.Millisecond)
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/C.template b/vendor/golang.org/x/tools/refactor/eg/testdata/C.template
new file mode 100644
index 0000000..f6f94d4
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/C.template
@@ -0,0 +1,10 @@
+package template
+
+// Test of repeated use of wildcard in pattern.
+
+// NB: multiple patterns would be required to handle variants such as
+// s[:len(s)], s[x:len(s)], etc, since a wildcard can't match nothing at all.
+// TODO(adonovan): support multiple templates in a single pass.
+
+func before(s string) string { return s[:len(s)] }
+func after(s string) string  { return s }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/C1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/C1.go
new file mode 100644
index 0000000..523b388
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/C1.go
@@ -0,0 +1,22 @@
+// +build ignore
+
+package C1
+
+import "strings"
+
+func example() {
+	x := "foo"
+	println(x[:len(x)])
+
+	// Match, but the transformation is not sound w.r.t. possible side effects.
+	println(strings.Repeat("*", 3)[:len(strings.Repeat("*", 3))])
+
+	// No match, since second use of wildcard doesn't match first.
+	println(strings.Repeat("*", 3)[:len(strings.Repeat("*", 2))])
+
+	// Recursive match demonstrating bottom-up rewrite:
+	// only after the inner replacement occurs does the outer syntax match.
+	println((x[:len(x)])[:len(x[:len(x)])])
+	// -> (x[:len(x)])
+	// -> x
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/C1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/C1.golden
new file mode 100644
index 0000000..ae7759d
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/C1.golden
@@ -0,0 +1,22 @@
+// +build ignore
+
+package C1
+
+import "strings"
+
+func example() {
+	x := "foo"
+	println(x)
+
+	// Match, but the transformation is not sound w.r.t. possible side effects.
+	println(strings.Repeat("*", 3))
+
+	// No match, since second use of wildcard doesn't match first.
+	println(strings.Repeat("*", 3)[:len(strings.Repeat("*", 2))])
+
+	// Recursive match demonstrating bottom-up rewrite:
+	// only after the inner replacement occurs does the outer syntax match.
+	println(x)
+	// -> (x[:len(x)])
+	// -> x
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/D.template b/vendor/golang.org/x/tools/refactor/eg/testdata/D.template
new file mode 100644
index 0000000..6d3b6fe
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/D.template
@@ -0,0 +1,8 @@
+package template
+
+import "fmt"
+
+// Test of semantic (not syntactic) matching of basic literals.
+
+func before() (int, error) { return fmt.Println(123, "a") }
+func after() (int, error)  { return fmt.Println(456, "!") }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/D1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/D1.go
new file mode 100644
index 0000000..ae0a806
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/D1.go
@@ -0,0 +1,12 @@
+// +build ignore
+
+package D1
+
+import "fmt"
+
+func example() {
+	fmt.Println(123, "a")         // match
+	fmt.Println(0x7b, `a`)        // match
+	fmt.Println(0173, "\x61")     // match
+	fmt.Println(100+20+3, "a"+"") // no match: constant expressions, but not basic literals
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/D1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/D1.golden
new file mode 100644
index 0000000..2932652
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/D1.golden
@@ -0,0 +1,12 @@
+// +build ignore
+
+package D1
+
+import "fmt"
+
+func example() {
+	fmt.Println(456, "!")         // match
+	fmt.Println(456, "!")         // match
+	fmt.Println(456, "!")         // match
+	fmt.Println(100+20+3, "a"+"") // no match: constant expressions, but not basic literals
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/E.template b/vendor/golang.org/x/tools/refactor/eg/testdata/E.template
new file mode 100644
index 0000000..4bbbd11
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/E.template
@@ -0,0 +1,12 @@
+package template
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+// Replace call to void function by call to non-void function.
+
+func before(x interface{}) { log.Fatal(x) }
+func after(x interface{})  { fmt.Fprintf(os.Stderr, "warning: %v", x) }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/E1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/E1.go
new file mode 100644
index 0000000..3ea1793
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/E1.go
@@ -0,0 +1,9 @@
+// +build ignore
+
+package E1
+
+import "log"
+
+func example() {
+	log.Fatal("oops") // match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/E1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/E1.golden
new file mode 100644
index 0000000..796364f
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/E1.golden
@@ -0,0 +1,13 @@
+// +build ignore
+
+package E1
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+func example() {
+	fmt.Fprintf(os.Stderr, "warning: %v", "oops") // match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/F.template b/vendor/golang.org/x/tools/refactor/eg/testdata/F.template
new file mode 100644
index 0000000..21e1bd2
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/F.template
@@ -0,0 +1,8 @@
+package templates
+
+// Test 
+
+import "sync"
+
+func before(s sync.RWMutex) { s.Lock() }
+func after(s sync.RWMutex) { s.RLock() }
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/F1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/F1.go
new file mode 100644
index 0000000..2258abd
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/F1.go
@@ -0,0 +1,48 @@
+// +build ignore
+
+package F1
+
+import "sync"
+
+func example(n int) {
+	var x struct {
+		mutex sync.RWMutex
+	}
+
+	var y struct {
+		sync.RWMutex
+	}
+
+	type l struct {
+		sync.RWMutex
+	}
+
+	var z struct {
+		l
+	}
+
+	var a struct {
+		*l
+	}
+
+	var b struct{ Lock func() }
+
+	// Match
+	x.mutex.Lock()
+
+	// Match
+	y.Lock()
+
+	// Match indirect
+	z.Lock()
+
+	// Should be no match however currently matches due to:
+	// https://golang.org/issue/8584
+	// Will start failing when this is fixed then just change golden to
+	// No match pointer indirect
+	// a.Lock()
+	a.Lock()
+
+	// No match
+	b.Lock()
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/F1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/F1.golden
new file mode 100644
index 0000000..5ffda69
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/F1.golden
@@ -0,0 +1,48 @@
+// +build ignore
+
+package F1
+
+import "sync"
+
+func example(n int) {
+	var x struct {
+		mutex sync.RWMutex
+	}
+
+	var y struct {
+		sync.RWMutex
+	}
+
+	type l struct {
+		sync.RWMutex
+	}
+
+	var z struct {
+		l
+	}
+
+	var a struct {
+		*l
+	}
+
+	var b struct{ Lock func() }
+
+	// Match
+	x.mutex.RLock()
+
+	// Match
+	y.RLock()
+
+	// Match indirect
+	z.RLock()
+
+	// Should be no match however currently matches due to:
+	// https://golang.org/issue/8584
+	// Will start failing when this is fixed then just change golden to
+	// No match pointer indirect
+	// a.Lock()
+	a.RLock()
+
+	// No match
+	b.Lock()
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/G.template b/vendor/golang.org/x/tools/refactor/eg/testdata/G.template
new file mode 100644
index 0000000..69d84fe
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/G.template
@@ -0,0 +1,10 @@
+package templates
+
+import (
+	"go/ast" // defines many unencapsulated structs
+	"go/token"
+)
+
+func before(from, to token.Pos) ast.BadExpr { return ast.BadExpr{From: from, To: to} }
+func after(from, to token.Pos) ast.BadExpr  { return ast.BadExpr{from, to} }
+     
\ No newline at end of file
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/G1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/G1.go
new file mode 100644
index 0000000..07aaff9
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/G1.go
@@ -0,0 +1,12 @@
+// +build ignore
+
+package G1
+
+import "go/ast"
+
+func example() {
+	_ = ast.BadExpr{From: 123, To: 456} // match
+	_ = ast.BadExpr{123, 456}           // no match
+	_ = ast.BadExpr{From: 123}          // no match
+	_ = ast.BadExpr{To: 456}            // no match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/G1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/G1.golden
new file mode 100644
index 0000000..c93c53f
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/G1.golden
@@ -0,0 +1,12 @@
+// +build ignore
+
+package G1
+
+import "go/ast"
+
+func example() {
+	_ = ast.BadExpr{123, 456}  // match
+	_ = ast.BadExpr{123, 456}  // no match
+	_ = ast.BadExpr{From: 123} // no match
+	_ = ast.BadExpr{To: 456}   // no match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/H.template b/vendor/golang.org/x/tools/refactor/eg/testdata/H.template
new file mode 100644
index 0000000..fa6f802
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/H.template
@@ -0,0 +1,9 @@
+package templates
+
+import (
+	"go/ast" // defines many unencapsulated structs
+	"go/token"
+)
+
+func before(from, to token.Pos) ast.BadExpr { return ast.BadExpr{from, to} }
+func after(from, to token.Pos) ast.BadExpr  { return ast.BadExpr{From: from, To: to} }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/H1.go b/vendor/golang.org/x/tools/refactor/eg/testdata/H1.go
new file mode 100644
index 0000000..ef4291c
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/H1.go
@@ -0,0 +1,12 @@
+// +build ignore
+
+package H1
+
+import "go/ast"
+
+func example() {
+	_ = ast.BadExpr{From: 123, To: 456} // no match
+	_ = ast.BadExpr{123, 456}           // match
+	_ = ast.BadExpr{From: 123}          // no match
+	_ = ast.BadExpr{To: 456}            // no match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/H1.golden b/vendor/golang.org/x/tools/refactor/eg/testdata/H1.golden
new file mode 100644
index 0000000..a1e5961
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/H1.golden
@@ -0,0 +1,12 @@
+// +build ignore
+
+package H1
+
+import "go/ast"
+
+func example() {
+	_ = ast.BadExpr{From: 123, To: 456} // no match
+	_ = ast.BadExpr{From: 123, To: 456} // match
+	_ = ast.BadExpr{From: 123}          // no match
+	_ = ast.BadExpr{To: 456}            // no match
+}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/bad_type.template b/vendor/golang.org/x/tools/refactor/eg/testdata/bad_type.template
new file mode 100644
index 0000000..6d53d7e
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/bad_type.template
@@ -0,0 +1,8 @@
+package template
+
+// Test in which replacement has a different type.
+
+const shouldFail = "int is not a safe replacement for string"
+
+func before() interface{} { return "three" }
+func after() interface{}  { return 3 }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/expr_type_mismatch.template b/vendor/golang.org/x/tools/refactor/eg/testdata/expr_type_mismatch.template
new file mode 100644
index 0000000..2c5c3f0
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/expr_type_mismatch.template
@@ -0,0 +1,15 @@
+package template
+
+import (
+	"crypto/x509"
+	"fmt"
+)
+
+// This test demonstrates a false negative: according to the language
+// rules this replacement should be ok, but types.Assignable doesn't work
+// in the expected way (elementwise assignability) for tuples.
+// Perhaps that's even a type-checker bug?
+const shouldFail = "(n int, err error) is not a safe replacement for (key interface{}, err error)"
+
+func before() (interface{}, error) { return x509.ParsePKCS8PrivateKey(nil) }
+func after() (interface{}, error)  { return fmt.Print() }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/no_after_return.template b/vendor/golang.org/x/tools/refactor/eg/testdata/no_after_return.template
new file mode 100644
index 0000000..536b01e
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/no_after_return.template
@@ -0,0 +1,6 @@
+package template
+
+const shouldFail = "after: must contain a single statement"
+
+func before() int { return 0 }
+func after() int  { println(); return 0 }
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/no_before.template b/vendor/golang.org/x/tools/refactor/eg/testdata/no_before.template
new file mode 100644
index 0000000..9205e66
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/no_before.template
@@ -0,0 +1,5 @@
+package template
+
+const shouldFail = "no 'before' func found in template"
+
+func Before() {}
diff --git a/vendor/golang.org/x/tools/refactor/eg/testdata/type_mismatch.template b/vendor/golang.org/x/tools/refactor/eg/testdata/type_mismatch.template
new file mode 100644
index 0000000..787c9a7
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/eg/testdata/type_mismatch.template
@@ -0,0 +1,6 @@
+package template
+
+const shouldFail = "different signatures"
+
+func before() int   { return 0 }
+func after() string { return "" }
diff --git a/vendor/golang.org/x/tools/refactor/importgraph/graph.go b/vendor/golang.org/x/tools/refactor/importgraph/graph.go
index 8ad8014..d2d8f09 100644
--- a/vendor/golang.org/x/tools/refactor/importgraph/graph.go
+++ b/vendor/golang.org/x/tools/refactor/importgraph/graph.go
@@ -20,6 +20,8 @@ import (
 // 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) {
@@ -53,9 +55,10 @@ func (g Graph) Search(roots ...string) map[string]bool {
 
 // 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 import paths to errors for 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
@@ -67,39 +70,75 @@ func Build(ctxt *build.Context) (forward, reverse Graph, errors map[string]error
 
 	ch := make(chan interface{})
 
-	var wg sync.WaitGroup
-	buildutil.ForEachPackage(ctxt, func(path string, err error) {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+	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
 			}
 
-			bp, err := ctxt.Import(path, "", 0)
-			if err != nil {
-				if _, ok := err.(*build.NoGoError); ok {
-					// empty directory is not an error
-				} else {
-					ch <- pathError{path, err}
+			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.
 				}
-				// Even in error cases, Import usually returns a package.
-			}
-			if bp != nil {
-				for _, imp := range bp.Imports {
-					ch <- importEdge{path, imp}
+
+				// 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
 				}
-				for _, imp := range bp.TestImports {
-					ch <- importEdge{path, imp}
+
+				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)}
+					}
 				}
-				for _, imp := range bp.XTestImports {
-					ch <- importEdge{path, imp}
-				}
-			}
-		}()
-	})
-	go func() {
+
+			}()
+		})
 		wg.Wait()
 		close(ch)
 	}()
diff --git a/vendor/golang.org/x/tools/refactor/importgraph/graph_test.go b/vendor/golang.org/x/tools/refactor/importgraph/graph_test.go
new file mode 100644
index 0000000..52dd769
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/importgraph/graph_test.go
@@ -0,0 +1,99 @@
+// 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.
+
+// Incomplete std lib sources on Android.
+
+// +build !android
+
+package importgraph_test
+
+import (
+	"go/build"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/refactor/importgraph"
+
+	_ "crypto/hmac" // just for test, below
+)
+
+const this = "golang.org/x/tools/refactor/importgraph"
+
+func TestBuild(t *testing.T) {
+	forward, reverse, errors := importgraph.Build(&build.Default)
+
+	// Test direct edges.
+	// We throw in crypto/hmac to prove that external test files
+	// (such as this one) are inspected.
+	for _, p := range []string{"go/build", "testing", "crypto/hmac"} {
+		if !forward[this][p] {
+			t.Errorf("forward[importgraph][%s] not found", p)
+		}
+		if !reverse[p][this] {
+			t.Errorf("reverse[%s][importgraph] not found", p)
+		}
+	}
+
+	// Test non-existent direct edges
+	for _, p := range []string{"errors", "reflect"} {
+		if forward[this][p] {
+			t.Errorf("unexpected: forward[importgraph][%s] found", p)
+		}
+		if reverse[p][this] {
+			t.Errorf("unexpected: reverse[%s][importgraph] found", p)
+		}
+	}
+
+	// Test Search is reflexive.
+	if !forward.Search(this)[this] {
+		t.Errorf("irreflexive: forward.Search(importgraph)[importgraph] not found")
+	}
+	if !reverse.Search(this)[this] {
+		t.Errorf("irrefexive: reverse.Search(importgraph)[importgraph] not found")
+	}
+
+	// Test Search is transitive.  (There is no direct edge to these packages.)
+	for _, p := range []string{"errors", "reflect", "unsafe"} {
+		if !forward.Search(this)[p] {
+			t.Errorf("intransitive: forward.Search(importgraph)[%s] not found", p)
+		}
+		if !reverse.Search(p)[this] {
+			t.Errorf("intransitive: reverse.Search(%s)[importgraph] not found", p)
+		}
+	}
+
+	// Test strongly-connected components.  Because A's external
+	// test package can depend on B, and vice versa, most of the
+	// standard libraries are mutually dependent when their external
+	// tests are considered.
+	//
+	// For any nodes x, y in the same SCC, y appears in the results
+	// of both forward and reverse searches starting from x
+	if !forward.Search("fmt")["io"] ||
+		!forward.Search("io")["fmt"] ||
+		!reverse.Search("fmt")["io"] ||
+		!reverse.Search("io")["fmt"] {
+		t.Errorf("fmt and io are not mutually reachable despite being in the same SCC")
+	}
+
+	// debugging
+	if false {
+		for path, err := range errors {
+			t.Logf("%s: %s", path, err)
+		}
+		printSorted := func(direction string, g importgraph.Graph, start string) {
+			t.Log(direction)
+			var pkgs []string
+			for pkg := range g.Search(start) {
+				pkgs = append(pkgs, pkg)
+			}
+			sort.Strings(pkgs)
+			for _, pkg := range pkgs {
+				t.Logf("\t%s", pkg)
+			}
+		}
+		printSorted("forward", forward, this)
+		printSorted("reverse", reverse, this)
+	}
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/check.go b/vendor/golang.org/x/tools/refactor/rename/check.go
new file mode 100644
index 0000000..838fc7b
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/check.go
@@ -0,0 +1,858 @@
+// 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 rename
+
+// This file defines the safety checks for each kind of renaming.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/refactor/satisfy"
+)
+
+// errorf reports an error (e.g. conflict) and prevents file modification.
+func (r *renamer) errorf(pos token.Pos, format string, args ...interface{}) {
+	r.hadConflicts = true
+	reportError(r.iprog.Fset.Position(pos), fmt.Sprintf(format, args...))
+}
+
+// check performs safety checks of the renaming of the 'from' object to r.to.
+func (r *renamer) check(from types.Object) {
+	if r.objsToUpdate[from] {
+		return
+	}
+	r.objsToUpdate[from] = true
+
+	// NB: order of conditions is important.
+	if from_, ok := from.(*types.PkgName); ok {
+		r.checkInFileBlock(from_)
+	} else if from_, ok := from.(*types.Label); ok {
+		r.checkLabel(from_)
+	} else if isPackageLevel(from) {
+		r.checkInPackageBlock(from)
+	} else if v, ok := from.(*types.Var); ok && v.IsField() {
+		r.checkStructField(v)
+	} else if f, ok := from.(*types.Func); ok && recv(f) != nil {
+		r.checkMethod(f)
+	} else if isLocal(from) {
+		r.checkInLocalScope(from)
+	} else {
+		r.errorf(from.Pos(), "unexpected %s object %q (please report a bug)\n",
+			objectKind(from), from)
+	}
+}
+
+// checkInFileBlock performs safety checks for renames of objects in the file block,
+// i.e. imported package names.
+func (r *renamer) checkInFileBlock(from *types.PkgName) {
+	// Check import name is not "init".
+	if r.to == "init" {
+		r.errorf(from.Pos(), "%q is not a valid imported package name", r.to)
+	}
+
+	// Check for conflicts between file and package block.
+	if prev := from.Pkg().Scope().Lookup(r.to); prev != nil {
+		r.errorf(from.Pos(), "renaming this %s %q to %q would conflict",
+			objectKind(from), from.Name(), r.to)
+		r.errorf(prev.Pos(), "\twith this package member %s",
+			objectKind(prev))
+		return // since checkInPackageBlock would report redundant errors
+	}
+
+	// Check for conflicts in lexical scope.
+	r.checkInLexicalScope(from, r.packages[from.Pkg()])
+
+	// Finally, modify ImportSpec syntax to add or remove the Name as needed.
+	info, path, _ := r.iprog.PathEnclosingInterval(from.Pos(), from.Pos())
+	if from.Imported().Name() == r.to {
+		// ImportSpec.Name not needed
+		path[1].(*ast.ImportSpec).Name = nil
+	} else {
+		// ImportSpec.Name needed
+		if spec := path[1].(*ast.ImportSpec); spec.Name == nil {
+			spec.Name = &ast.Ident{NamePos: spec.Path.Pos(), Name: r.to}
+			info.Defs[spec.Name] = from
+		}
+	}
+}
+
+// checkInPackageBlock performs safety checks for renames of
+// func/var/const/type objects in the package block.
+func (r *renamer) checkInPackageBlock(from types.Object) {
+	// Check that there are no references to the name from another
+	// package if the renaming would make it unexported.
+	if ast.IsExported(from.Name()) && !ast.IsExported(r.to) {
+		for pkg, info := range r.packages {
+			if pkg == from.Pkg() {
+				continue
+			}
+			if id := someUse(info, from); id != nil &&
+				!r.checkExport(id, pkg, from) {
+				break
+			}
+		}
+	}
+
+	info := r.packages[from.Pkg()]
+
+	// Check that in the package block, "init" is a function, and never referenced.
+	if r.to == "init" {
+		kind := objectKind(from)
+		if kind == "func" {
+			// Reject if intra-package references to it exist.
+			for id, obj := range info.Uses {
+				if obj == from {
+					r.errorf(from.Pos(),
+						"renaming this func %q to %q would make it a package initializer",
+						from.Name(), r.to)
+					r.errorf(id.Pos(), "\tbut references to it exist")
+					break
+				}
+			}
+		} else {
+			r.errorf(from.Pos(), "you cannot have a %s at package level named %q",
+				kind, r.to)
+		}
+	}
+
+	// Check for conflicts between package block and all file blocks.
+	for _, f := range info.Files {
+		fileScope := info.Info.Scopes[f]
+		b, prev := fileScope.LookupParent(r.to, token.NoPos)
+		if b == fileScope {
+			r.errorf(from.Pos(), "renaming this %s %q to %q would conflict",
+				objectKind(from), from.Name(), r.to)
+			r.errorf(prev.Pos(), "\twith this %s",
+				objectKind(prev))
+			return // since checkInPackageBlock would report redundant errors
+		}
+	}
+
+	// Check for conflicts in lexical scope.
+	if from.Exported() {
+		for _, info := range r.packages {
+			r.checkInLexicalScope(from, info)
+		}
+	} else {
+		r.checkInLexicalScope(from, info)
+	}
+}
+
+func (r *renamer) checkInLocalScope(from types.Object) {
+	info := r.packages[from.Pkg()]
+
+	// Is this object an implicit local var for a type switch?
+	// Each case has its own var, whose position is the decl of y,
+	// but Ident in that decl does not appear in the Uses map.
+	//
+	//   switch y := x.(type) {	 // Defs[Ident(y)] is undefined
+	//   case int:    print(y)       // Implicits[CaseClause(int)]    = Var(y_int)
+	//   case string: print(y)       // Implicits[CaseClause(string)] = Var(y_string)
+	//   }
+	//
+	var isCaseVar bool
+	for syntax, obj := range info.Implicits {
+		if _, ok := syntax.(*ast.CaseClause); ok && obj.Pos() == from.Pos() {
+			isCaseVar = true
+			r.check(obj)
+		}
+	}
+
+	r.checkInLexicalScope(from, info)
+
+	// Finally, if this was a type switch, change the variable y.
+	if isCaseVar {
+		_, path, _ := r.iprog.PathEnclosingInterval(from.Pos(), from.Pos())
+		path[0].(*ast.Ident).Name = r.to // path is [Ident AssignStmt TypeSwitchStmt...]
+	}
+}
+
+// checkInLexicalScope performs safety checks that a renaming does not
+// change the lexical reference structure of the specified package.
+//
+// For objects in lexical scope, there are three kinds of conflicts:
+// same-, sub-, and super-block conflicts.  We will illustrate all three
+// using this example:
+//
+//	var x int
+//	var z int
+//
+//	func f(y int) {
+//		print(x)
+//		print(y)
+//	}
+//
+// Renaming x to z encounters a SAME-BLOCK CONFLICT, because an object
+// with the new name already exists, defined in the same lexical block
+// as the old object.
+//
+// Renaming x to y encounters a SUB-BLOCK CONFLICT, because there exists
+// a reference to x from within (what would become) a hole in its scope.
+// The definition of y in an (inner) sub-block would cast a shadow in
+// the scope of the renamed variable.
+//
+// Renaming y to x encounters a SUPER-BLOCK CONFLICT.  This is the
+// converse situation: there is an existing definition of the new name
+// (x) in an (enclosing) super-block, and the renaming would create a
+// hole in its scope, within which there exist references to it.  The
+// new name casts a shadow in scope of the existing definition of x in
+// the super-block.
+//
+// Removing the old name (and all references to it) is always safe, and
+// requires no checks.
+//
+func (r *renamer) checkInLexicalScope(from types.Object, info *loader.PackageInfo) {
+	b := from.Parent() // the block defining the 'from' object
+	if b != nil {
+		toBlock, to := b.LookupParent(r.to, from.Parent().End())
+		if toBlock == b {
+			// same-block conflict
+			r.errorf(from.Pos(), "renaming this %s %q to %q",
+				objectKind(from), from.Name(), r.to)
+			r.errorf(to.Pos(), "\tconflicts with %s in same block",
+				objectKind(to))
+			return
+		} else if toBlock != nil {
+			// Check for super-block conflict.
+			// The name r.to is defined in a superblock.
+			// Is that name referenced from within this block?
+			forEachLexicalRef(info, to, func(id *ast.Ident, block *types.Scope) bool {
+				_, obj := lexicalLookup(block, from.Name(), id.Pos())
+				if obj == from {
+					// super-block conflict
+					r.errorf(from.Pos(), "renaming this %s %q to %q",
+						objectKind(from), from.Name(), r.to)
+					r.errorf(id.Pos(), "\twould shadow this reference")
+					r.errorf(to.Pos(), "\tto the %s declared here",
+						objectKind(to))
+					return false // stop
+				}
+				return true
+			})
+		}
+	}
+
+	// Check for sub-block conflict.
+	// Is there an intervening definition of r.to between
+	// the block defining 'from' and some reference to it?
+	forEachLexicalRef(info, from, func(id *ast.Ident, block *types.Scope) bool {
+		// Find the block that defines the found reference.
+		// It may be an ancestor.
+		fromBlock, _ := lexicalLookup(block, from.Name(), id.Pos())
+
+		// See what r.to would resolve to in the same scope.
+		toBlock, to := lexicalLookup(block, r.to, id.Pos())
+		if to != nil {
+			// sub-block conflict
+			if deeper(toBlock, fromBlock) {
+				r.errorf(from.Pos(), "renaming this %s %q to %q",
+					objectKind(from), from.Name(), r.to)
+				r.errorf(id.Pos(), "\twould cause this reference to become shadowed")
+				r.errorf(to.Pos(), "\tby this intervening %s definition",
+					objectKind(to))
+				return false // stop
+			}
+		}
+		return true
+	})
+
+	// Renaming a type that is used as an embedded field
+	// requires renaming the field too. e.g.
+	// 	type T int // if we rename this to U..
+	// 	var s struct {T}
+	// 	print(s.T) // ...this must change too
+	if _, ok := from.(*types.TypeName); ok {
+		for id, obj := range info.Uses {
+			if obj == from {
+				if field := info.Defs[id]; field != nil {
+					r.check(field)
+				}
+			}
+		}
+	}
+}
+
+// lexicalLookup is like (*types.Scope).LookupParent but respects the
+// environment visible at pos.  It assumes the relative position
+// information is correct with each file.
+func lexicalLookup(block *types.Scope, name string, pos token.Pos) (*types.Scope, types.Object) {
+	for b := block; b != nil; b = b.Parent() {
+		obj := b.Lookup(name)
+		// The scope of a package-level object is the entire package,
+		// so ignore pos in that case.
+		// No analogous clause is needed for file-level objects
+		// since no reference can appear before an import decl.
+		if obj != nil && (b == obj.Pkg().Scope() || obj.Pos() < pos) {
+			return b, obj
+		}
+	}
+	return nil, nil
+}
+
+// deeper reports whether block x is lexically deeper than y.
+func deeper(x, y *types.Scope) bool {
+	if x == y || x == nil {
+		return false
+	} else if y == nil {
+		return true
+	} else {
+		return deeper(x.Parent(), y.Parent())
+	}
+}
+
+// forEachLexicalRef calls fn(id, block) for each identifier id in package
+// info that is a reference to obj in lexical scope.  block is the
+// lexical block enclosing the reference.  If fn returns false the
+// iteration is terminated and findLexicalRefs returns false.
+func forEachLexicalRef(info *loader.PackageInfo, obj types.Object, fn func(id *ast.Ident, block *types.Scope) bool) bool {
+	ok := true
+	var stack []ast.Node
+
+	var visit func(n ast.Node) bool
+	visit = func(n ast.Node) bool {
+		if n == nil {
+			stack = stack[:len(stack)-1] // pop
+			return false
+		}
+		if !ok {
+			return false // bail out
+		}
+
+		stack = append(stack, n) // push
+		switch n := n.(type) {
+		case *ast.Ident:
+			if info.Uses[n] == obj {
+				block := enclosingBlock(&info.Info, stack)
+				if !fn(n, block) {
+					ok = false
+				}
+			}
+			return visit(nil) // pop stack
+
+		case *ast.SelectorExpr:
+			// don't visit n.Sel
+			ast.Inspect(n.X, visit)
+			return visit(nil) // pop stack, don't descend
+
+		case *ast.CompositeLit:
+			// Handle recursion ourselves for struct literals
+			// so we don't visit field identifiers.
+			tv := info.Types[n]
+			if _, ok := deref(tv.Type).Underlying().(*types.Struct); ok {
+				if n.Type != nil {
+					ast.Inspect(n.Type, visit)
+				}
+				for _, elt := range n.Elts {
+					if kv, ok := elt.(*ast.KeyValueExpr); ok {
+						ast.Inspect(kv.Value, visit)
+					} else {
+						ast.Inspect(elt, visit)
+					}
+				}
+				return visit(nil) // pop stack, don't descend
+			}
+		}
+		return true
+	}
+
+	for _, f := range info.Files {
+		ast.Inspect(f, visit)
+		if len(stack) != 0 {
+			panic(stack)
+		}
+		if !ok {
+			break
+		}
+	}
+	return ok
+}
+
+// enclosingBlock returns the innermost block enclosing the specified
+// AST node, specified in the form of a path from the root of the file,
+// [file...n].
+func enclosingBlock(info *types.Info, stack []ast.Node) *types.Scope {
+	for i := range stack {
+		n := stack[len(stack)-1-i]
+		// For some reason, go/types always associates a
+		// function's scope with its FuncType.
+		// TODO(adonovan): feature or a bug?
+		switch f := n.(type) {
+		case *ast.FuncDecl:
+			n = f.Type
+		case *ast.FuncLit:
+			n = f.Type
+		}
+		if b := info.Scopes[n]; b != nil {
+			return b
+		}
+	}
+	panic("no Scope for *ast.File")
+}
+
+func (r *renamer) checkLabel(label *types.Label) {
+	// Check there are no identical labels in the function's label block.
+	// (Label blocks don't nest, so this is easy.)
+	if prev := label.Parent().Lookup(r.to); prev != nil {
+		r.errorf(label.Pos(), "renaming this label %q to %q", label.Name(), prev.Name())
+		r.errorf(prev.Pos(), "\twould conflict with this one")
+	}
+}
+
+// checkStructField checks that the field renaming will not cause
+// conflicts at its declaration, or ambiguity or changes to any selection.
+func (r *renamer) checkStructField(from *types.Var) {
+	// Check that the struct declaration is free of field conflicts,
+	// and field/method conflicts.
+
+	// go/types offers no easy way to get from a field (or interface
+	// method) to its declaring struct (or interface), so we must
+	// ascend the AST.
+	info, path, _ := r.iprog.PathEnclosingInterval(from.Pos(), from.Pos())
+	// path matches this pattern:
+	// [Ident SelectorExpr? StarExpr? Field FieldList StructType ParenExpr* ... File]
+
+	// Ascend to FieldList.
+	var i int
+	for {
+		if _, ok := path[i].(*ast.FieldList); ok {
+			break
+		}
+		i++
+	}
+	i++
+	tStruct := path[i].(*ast.StructType)
+	i++
+	// Ascend past parens (unlikely).
+	for {
+		_, ok := path[i].(*ast.ParenExpr)
+		if !ok {
+			break
+		}
+		i++
+	}
+	if spec, ok := path[i].(*ast.TypeSpec); ok {
+		// This struct is also a named type.
+		// We must check for direct (non-promoted) field/field
+		// and method/field conflicts.
+		named := info.Defs[spec.Name].Type()
+		prev, indices, _ := types.LookupFieldOrMethod(named, true, info.Pkg, r.to)
+		if len(indices) == 1 {
+			r.errorf(from.Pos(), "renaming this field %q to %q",
+				from.Name(), r.to)
+			r.errorf(prev.Pos(), "\twould conflict with this %s",
+				objectKind(prev))
+			return // skip checkSelections to avoid redundant errors
+		}
+	} else {
+		// This struct is not a named type.
+		// We need only check for direct (non-promoted) field/field conflicts.
+		T := info.Types[tStruct].Type.Underlying().(*types.Struct)
+		for i := 0; i < T.NumFields(); i++ {
+			if prev := T.Field(i); prev.Name() == r.to {
+				r.errorf(from.Pos(), "renaming this field %q to %q",
+					from.Name(), r.to)
+				r.errorf(prev.Pos(), "\twould conflict with this field")
+				return // skip checkSelections to avoid redundant errors
+			}
+		}
+	}
+
+	// Renaming an anonymous field requires renaming the type too. e.g.
+	// 	print(s.T)       // if we rename T to U,
+	// 	type T int       // this and
+	// 	var s struct {T} // this must change too.
+	if from.Anonymous() {
+		if named, ok := from.Type().(*types.Named); ok {
+			r.check(named.Obj())
+		} else if named, ok := deref(from.Type()).(*types.Named); ok {
+			r.check(named.Obj())
+		}
+	}
+
+	// Check integrity of existing (field and method) selections.
+	r.checkSelections(from)
+}
+
+// checkSelection checks that all uses and selections that resolve to
+// the specified object would continue to do so after the renaming.
+func (r *renamer) checkSelections(from types.Object) {
+	for pkg, info := range r.packages {
+		if id := someUse(info, from); id != nil {
+			if !r.checkExport(id, pkg, from) {
+				return
+			}
+		}
+
+		for syntax, sel := range info.Selections {
+			// There may be extant selections of only the old
+			// name or only the new name, so we must check both.
+			// (If neither, the renaming is sound.)
+			//
+			// In both cases, we wish to compare the lengths
+			// of the implicit field path (Selection.Index)
+			// to see if the renaming would change it.
+			//
+			// If a selection that resolves to 'from', when renamed,
+			// would yield a path of the same or shorter length,
+			// this indicates ambiguity or a changed referent,
+			// analogous to same- or sub-block lexical conflict.
+			//
+			// If a selection using the name 'to' would
+			// yield a path of the same or shorter length,
+			// this indicates ambiguity or shadowing,
+			// analogous to same- or super-block lexical conflict.
+
+			// TODO(adonovan): fix: derive from Types[syntax.X].Mode
+			// TODO(adonovan): test with pointer, value, addressable value.
+			isAddressable := true
+
+			if sel.Obj() == from {
+				if obj, indices, _ := types.LookupFieldOrMethod(sel.Recv(), isAddressable, from.Pkg(), r.to); obj != nil {
+					// Renaming this existing selection of
+					// 'from' may block access to an existing
+					// type member named 'to'.
+					delta := len(indices) - len(sel.Index())
+					if delta > 0 {
+						continue // no ambiguity
+					}
+					r.selectionConflict(from, delta, syntax, obj)
+					return
+				}
+
+			} else if sel.Obj().Name() == r.to {
+				if obj, indices, _ := types.LookupFieldOrMethod(sel.Recv(), isAddressable, from.Pkg(), from.Name()); obj == from {
+					// Renaming 'from' may cause this existing
+					// selection of the name 'to' to change
+					// its meaning.
+					delta := len(indices) - len(sel.Index())
+					if delta > 0 {
+						continue //  no ambiguity
+					}
+					r.selectionConflict(from, -delta, syntax, sel.Obj())
+					return
+				}
+			}
+		}
+	}
+}
+
+func (r *renamer) selectionConflict(from types.Object, delta int, syntax *ast.SelectorExpr, obj types.Object) {
+	r.errorf(from.Pos(), "renaming this %s %q to %q",
+		objectKind(from), from.Name(), r.to)
+
+	switch {
+	case delta < 0:
+		// analogous to sub-block conflict
+		r.errorf(syntax.Sel.Pos(),
+			"\twould change the referent of this selection")
+		r.errorf(obj.Pos(), "\tof this %s", objectKind(obj))
+	case delta == 0:
+		// analogous to same-block conflict
+		r.errorf(syntax.Sel.Pos(),
+			"\twould make this reference ambiguous")
+		r.errorf(obj.Pos(), "\twith this %s", objectKind(obj))
+	case delta > 0:
+		// analogous to super-block conflict
+		r.errorf(syntax.Sel.Pos(),
+			"\twould shadow this selection")
+		r.errorf(obj.Pos(), "\tof the %s declared here",
+			objectKind(obj))
+	}
+}
+
+// checkMethod performs safety checks for renaming a method.
+// There are three hazards:
+// - declaration conflicts
+// - selection ambiguity/changes
+// - entailed renamings of assignable concrete/interface types.
+//   We reject renamings initiated at concrete methods if it would
+//   change the assignability relation.  For renamings of abstract
+//   methods, we rename all methods transitively coupled to it via
+//   assignability.
+func (r *renamer) checkMethod(from *types.Func) {
+	// e.g. error.Error
+	if from.Pkg() == nil {
+		r.errorf(from.Pos(), "you cannot rename built-in method %s", from)
+		return
+	}
+
+	// ASSIGNABILITY: We reject renamings of concrete methods that
+	// would break a 'satisfy' constraint; but renamings of abstract
+	// methods are allowed to proceed, and we rename affected
+	// concrete and abstract methods as necessary.  It is the
+	// initial method that determines the policy.
+
+	// Check for conflict at point of declaration.
+	// Check to ensure preservation of assignability requirements.
+	R := recv(from).Type()
+	if isInterface(R) {
+		// Abstract method
+
+		// declaration
+		prev, _, _ := types.LookupFieldOrMethod(R, false, from.Pkg(), r.to)
+		if prev != nil {
+			r.errorf(from.Pos(), "renaming this interface method %q to %q",
+				from.Name(), r.to)
+			r.errorf(prev.Pos(), "\twould conflict with this method")
+			return
+		}
+
+		// Check all interfaces that embed this one for
+		// declaration conflicts too.
+		for _, info := range r.packages {
+			// Start with named interface types (better errors)
+			for _, obj := range info.Defs {
+				if obj, ok := obj.(*types.TypeName); ok && isInterface(obj.Type()) {
+					f, _, _ := types.LookupFieldOrMethod(
+						obj.Type(), false, from.Pkg(), from.Name())
+					if f == nil {
+						continue
+					}
+					t, _, _ := types.LookupFieldOrMethod(
+						obj.Type(), false, from.Pkg(), r.to)
+					if t == nil {
+						continue
+					}
+					r.errorf(from.Pos(), "renaming this interface method %q to %q",
+						from.Name(), r.to)
+					r.errorf(t.Pos(), "\twould conflict with this method")
+					r.errorf(obj.Pos(), "\tin named interface type %q", obj.Name())
+				}
+			}
+
+			// Now look at all literal interface types (includes named ones again).
+			for e, tv := range info.Types {
+				if e, ok := e.(*ast.InterfaceType); ok {
+					_ = e
+					_ = tv.Type.(*types.Interface)
+					// TODO(adonovan): implement same check as above.
+				}
+			}
+		}
+
+		// assignability
+		//
+		// Find the set of concrete or abstract methods directly
+		// coupled to abstract method 'from' by some
+		// satisfy.Constraint, and rename them too.
+		for key := range r.satisfy() {
+			// key = (lhs, rhs) where lhs is always an interface.
+
+			lsel := r.msets.MethodSet(key.LHS).Lookup(from.Pkg(), from.Name())
+			if lsel == nil {
+				continue
+			}
+			rmethods := r.msets.MethodSet(key.RHS)
+			rsel := rmethods.Lookup(from.Pkg(), from.Name())
+			if rsel == nil {
+				continue
+			}
+
+			// If both sides have a method of this name,
+			// and one of them is m, the other must be coupled.
+			var coupled *types.Func
+			switch from {
+			case lsel.Obj():
+				coupled = rsel.Obj().(*types.Func)
+			case rsel.Obj():
+				coupled = lsel.Obj().(*types.Func)
+			default:
+				continue
+			}
+
+			// We must treat concrete-to-interface
+			// constraints like an implicit selection C.f of
+			// each interface method I.f, and check that the
+			// renaming leaves the selection unchanged and
+			// unambiguous.
+			//
+			// Fun fact: the implicit selection of C.f
+			// 	type I interface{f()}
+			// 	type C struct{I}
+			// 	func (C) g()
+			//      var _ I = C{} // here
+			// yields abstract method I.f.  This can make error
+			// messages less than obvious.
+			//
+			if !isInterface(key.RHS) {
+				// The logic below was derived from checkSelections.
+
+				rtosel := rmethods.Lookup(from.Pkg(), r.to)
+				if rtosel != nil {
+					rto := rtosel.Obj().(*types.Func)
+					delta := len(rsel.Index()) - len(rtosel.Index())
+					if delta < 0 {
+						continue // no ambiguity
+					}
+
+					// TODO(adonovan): record the constraint's position.
+					keyPos := token.NoPos
+
+					r.errorf(from.Pos(), "renaming this method %q to %q",
+						from.Name(), r.to)
+					if delta == 0 {
+						// analogous to same-block conflict
+						r.errorf(keyPos, "\twould make the %s method of %s invoked via interface %s ambiguous",
+							r.to, key.RHS, key.LHS)
+						r.errorf(rto.Pos(), "\twith (%s).%s",
+							recv(rto).Type(), r.to)
+					} else {
+						// analogous to super-block conflict
+						r.errorf(keyPos, "\twould change the %s method of %s invoked via interface %s",
+							r.to, key.RHS, key.LHS)
+						r.errorf(coupled.Pos(), "\tfrom (%s).%s",
+							recv(coupled).Type(), r.to)
+						r.errorf(rto.Pos(), "\tto (%s).%s",
+							recv(rto).Type(), r.to)
+					}
+					return // one error is enough
+				}
+			}
+
+			if !r.changeMethods {
+				// This should be unreachable.
+				r.errorf(from.Pos(), "internal error: during renaming of abstract method %s", from)
+				r.errorf(coupled.Pos(), "\tchangedMethods=false, coupled method=%s", coupled)
+				r.errorf(from.Pos(), "\tPlease file a bug report")
+				return
+			}
+
+			// Rename the coupled method to preserve assignability.
+			r.check(coupled)
+		}
+	} else {
+		// Concrete method
+
+		// declaration
+		prev, indices, _ := types.LookupFieldOrMethod(R, true, from.Pkg(), r.to)
+		if prev != nil && len(indices) == 1 {
+			r.errorf(from.Pos(), "renaming this method %q to %q",
+				from.Name(), r.to)
+			r.errorf(prev.Pos(), "\twould conflict with this %s",
+				objectKind(prev))
+			return
+		}
+
+		// assignability
+		//
+		// Find the set of abstract methods coupled to concrete
+		// method 'from' by some satisfy.Constraint, and rename
+		// them too.
+		//
+		// Coupling may be indirect, e.g. I.f <-> C.f via type D.
+		//
+		// 	type I interface {f()}
+		//	type C int
+		//	type (C) f()
+		//	type D struct{C}
+		//	var _ I = D{}
+		//
+		for key := range r.satisfy() {
+			// key = (lhs, rhs) where lhs is always an interface.
+			if isInterface(key.RHS) {
+				continue
+			}
+			rsel := r.msets.MethodSet(key.RHS).Lookup(from.Pkg(), from.Name())
+			if rsel == nil || rsel.Obj() != from {
+				continue // rhs does not have the method
+			}
+			lsel := r.msets.MethodSet(key.LHS).Lookup(from.Pkg(), from.Name())
+			if lsel == nil {
+				continue
+			}
+			imeth := lsel.Obj().(*types.Func)
+
+			// imeth is the abstract method (e.g. I.f)
+			// and key.RHS is the concrete coupling type (e.g. D).
+			if !r.changeMethods {
+				r.errorf(from.Pos(), "renaming this method %q to %q",
+					from.Name(), r.to)
+				var pos token.Pos
+				var iface string
+
+				I := recv(imeth).Type()
+				if named, ok := I.(*types.Named); ok {
+					pos = named.Obj().Pos()
+					iface = "interface " + named.Obj().Name()
+				} else {
+					pos = from.Pos()
+					iface = I.String()
+				}
+				r.errorf(pos, "\twould make %s no longer assignable to %s",
+					key.RHS, iface)
+				r.errorf(imeth.Pos(), "\t(rename %s.%s if you intend to change both types)",
+					I, from.Name())
+				return // one error is enough
+			}
+
+			// Rename the coupled interface method to preserve assignability.
+			r.check(imeth)
+		}
+	}
+
+	// Check integrity of existing (field and method) selections.
+	// We skip this if there were errors above, to avoid redundant errors.
+	r.checkSelections(from)
+}
+
+func (r *renamer) checkExport(id *ast.Ident, pkg *types.Package, from types.Object) bool {
+	// Reject cross-package references if r.to is unexported.
+	// (Such references may be qualified identifiers or field/method
+	// selections.)
+	if !ast.IsExported(r.to) && pkg != from.Pkg() {
+		r.errorf(from.Pos(),
+			"renaming this %s %q to %q would make it unexported",
+			objectKind(from), from.Name(), r.to)
+		r.errorf(id.Pos(), "\tbreaking references from packages such as %q",
+			pkg.Path())
+		return false
+	}
+	return true
+}
+
+// satisfy returns the set of interface satisfaction constraints.
+func (r *renamer) satisfy() map[satisfy.Constraint]bool {
+	if r.satisfyConstraints == nil {
+		// Compute on demand: it's expensive.
+		var f satisfy.Finder
+		for _, info := range r.packages {
+			f.Find(&info.Info, info.Files)
+		}
+		r.satisfyConstraints = f.Result
+	}
+	return r.satisfyConstraints
+}
+
+// -- helpers ----------------------------------------------------------
+
+// recv returns the method's receiver.
+func recv(meth *types.Func) *types.Var {
+	return meth.Type().(*types.Signature).Recv()
+}
+
+// someUse returns an arbitrary use of obj within info.
+func someUse(info *loader.PackageInfo, obj types.Object) *ast.Ident {
+	for id, o := range info.Uses {
+		if o == obj {
+			return id
+		}
+	}
+	return nil
+}
+
+// -- Plundered from golang.org/x/tools/go/ssa -----------------
+
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
+
+func deref(typ types.Type) types.Type {
+	if p, _ := typ.(*types.Pointer); p != nil {
+		return p.Elem()
+	}
+	return typ
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/mvpkg.go b/vendor/golang.org/x/tools/refactor/rename/mvpkg.go
new file mode 100644
index 0000000..638d0cf
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/mvpkg.go
@@ -0,0 +1,375 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// licence that can be found in the LICENSE file.
+
+// This file contains the implementation of the 'gomvpkg' command
+// whose main function is in golang.org/x/tools/cmd/gomvpkg.
+
+package rename
+
+// TODO(matloob):
+// - think about what happens if the package is moving across version control systems.
+// - think about windows, which uses "\" as its directory separator.
+// - dot imports are not supported. Make sure it's clearly documented.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/token"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"text/template"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/refactor/importgraph"
+)
+
+// Move, given a package path and a destination package path, will try
+// to move the given package to the new path. The Move function will
+// first check for any conflicts preventing the move, such as a
+// package already existing at the destination package path. If the
+// move can proceed, it builds an import graph to find all imports of
+// the packages whose paths need to be renamed. This includes uses of
+// the subpackages of the package to be moved as those packages will
+// also need to be moved. It then renames all imports to point to the
+// new paths, and then moves the packages to their new paths.
+func Move(ctxt *build.Context, from, to, moveTmpl string) error {
+	srcDir, err := srcDir(ctxt, from)
+	if err != nil {
+		return err
+	}
+
+	// This should be the only place in the program that constructs
+	// file paths.
+	// TODO(matloob): test on Microsoft Windows.
+	fromDir := buildutil.JoinPath(ctxt, srcDir, filepath.FromSlash(from))
+	toDir := buildutil.JoinPath(ctxt, srcDir, filepath.FromSlash(to))
+	toParent := filepath.Dir(toDir)
+	if !buildutil.IsDir(ctxt, toParent) {
+		return fmt.Errorf("parent directory does not exist for path %s", toDir)
+	}
+
+	// Build the import graph and figure out which packages to update.
+	_, rev, errors := importgraph.Build(ctxt)
+	if len(errors) > 0 {
+		// With a large GOPATH tree, errors are inevitable.
+		// Report them but proceed.
+		fmt.Fprintf(os.Stderr, "While scanning Go workspace:\n")
+		for path, err := range errors {
+			fmt.Fprintf(os.Stderr, "Package %q: %s.\n", path, err)
+		}
+	}
+
+	// Determine the affected packages---the set of packages whose import
+	// statements need updating.
+	affectedPackages := map[string]bool{from: true}
+	destinations := make(map[string]string) // maps old import path to new import path
+	for pkg := range subpackages(ctxt, srcDir, from) {
+		for r := range rev[pkg] {
+			affectedPackages[r] = true
+		}
+		// Ensure directories have a trailing separator.
+		dest := strings.Replace(pkg,
+			filepath.Join(from, ""),
+			filepath.Join(to, ""),
+			1)
+		destinations[pkg] = filepath.ToSlash(dest)
+	}
+
+	// Load all the affected packages.
+	iprog, err := loadProgram(ctxt, affectedPackages)
+	if err != nil {
+		return err
+	}
+
+	// Prepare the move command, if one was supplied.
+	var cmd string
+	if moveTmpl != "" {
+		if cmd, err = moveCmd(moveTmpl, fromDir, toDir); err != nil {
+			return err
+		}
+	}
+
+	m := mover{
+		ctxt:             ctxt,
+		rev:              rev,
+		iprog:            iprog,
+		from:             from,
+		to:               to,
+		fromDir:          fromDir,
+		toDir:            toDir,
+		affectedPackages: affectedPackages,
+		destinations:     destinations,
+		cmd:              cmd,
+	}
+
+	if err := m.checkValid(); err != nil {
+		return err
+	}
+
+	m.move()
+
+	return nil
+}
+
+// srcDir returns the absolute path of the srcdir containing pkg.
+func srcDir(ctxt *build.Context, pkg string) (string, error) {
+	for _, srcDir := range ctxt.SrcDirs() {
+		path := buildutil.JoinPath(ctxt, srcDir, pkg)
+		if buildutil.IsDir(ctxt, path) {
+			return srcDir, nil
+		}
+	}
+	return "", fmt.Errorf("src dir not found for package: %s", pkg)
+}
+
+// subpackages returns the set of packages in the given srcDir whose
+// import paths start with dir.
+func subpackages(ctxt *build.Context, srcDir string, dir string) map[string]bool {
+	subs := map[string]bool{dir: true}
+
+	// Find all packages under srcDir whose import paths start with dir.
+	buildutil.ForEachPackage(ctxt, func(pkg string, err error) {
+		if err != nil {
+			log.Fatalf("unexpected error in ForEachPackage: %v", err)
+		}
+
+		// Only process the package or a sub-package
+		if !(strings.HasPrefix(pkg, dir) &&
+			(len(pkg) == len(dir) || pkg[len(dir)] == '/')) {
+			return
+		}
+
+		p, err := ctxt.Import(pkg, "", build.FindOnly)
+		if err != nil {
+			log.Fatalf("unexpected: package %s can not be located by build context: %s", pkg, err)
+		}
+		if p.SrcRoot == "" {
+			log.Fatalf("unexpected: could not determine srcDir for package %s: %s", pkg, err)
+		}
+		if p.SrcRoot != srcDir {
+			return
+		}
+
+		subs[pkg] = true
+	})
+
+	return subs
+}
+
+type mover struct {
+	// iprog contains all packages whose contents need to be updated
+	// with new package names or import paths.
+	iprog *loader.Program
+	ctxt  *build.Context
+	// rev is the reverse import graph.
+	rev importgraph.Graph
+	// from and to are the source and destination import
+	// paths. fromDir and toDir are the source and destination
+	// absolute paths that package source files will be moved between.
+	from, to, fromDir, toDir string
+	// affectedPackages is the set of all packages whose contents need
+	// to be updated to reflect new package names or import paths.
+	affectedPackages map[string]bool
+	// destinations maps each subpackage to be moved to its
+	// destination path.
+	destinations map[string]string
+	// cmd, if not empty, will be executed to move fromDir to toDir.
+	cmd string
+}
+
+func (m *mover) checkValid() error {
+	const prefix = "invalid move destination"
+
+	match, err := regexp.MatchString("^[_\\pL][_\\pL\\p{Nd}]*$", path.Base(m.to))
+	if err != nil {
+		panic("regexp.MatchString failed")
+	}
+	if !match {
+		return fmt.Errorf("%s: %s; gomvpkg does not support move destinations "+
+			"whose base names are not valid go identifiers", prefix, m.to)
+	}
+
+	if buildutil.FileExists(m.ctxt, m.toDir) {
+		return fmt.Errorf("%s: %s conflicts with file %s", prefix, m.to, m.toDir)
+	}
+	if buildutil.IsDir(m.ctxt, m.toDir) {
+		return fmt.Errorf("%s: %s conflicts with directory %s", prefix, m.to, m.toDir)
+	}
+
+	for _, toSubPkg := range m.destinations {
+		if _, err := m.ctxt.Import(toSubPkg, "", build.FindOnly); err == nil {
+			return fmt.Errorf("%s: %s; package or subpackage %s already exists",
+				prefix, m.to, toSubPkg)
+		}
+	}
+
+	return nil
+}
+
+// moveCmd produces the version control move command used to move fromDir to toDir by
+// executing the given template.
+func moveCmd(moveTmpl, fromDir, toDir string) (string, error) {
+	tmpl, err := template.New("movecmd").Parse(moveTmpl)
+	if err != nil {
+		return "", err
+	}
+
+	var buf bytes.Buffer
+	err = tmpl.Execute(&buf, struct {
+		Src string
+		Dst string
+	}{fromDir, toDir})
+	return buf.String(), err
+}
+
+func (m *mover) move() error {
+	filesToUpdate := make(map[*ast.File]bool)
+
+	// Change the moved package's "package" declaration to its new base name.
+	pkg, ok := m.iprog.Imported[m.from]
+	if !ok {
+		log.Fatalf("unexpected: package %s is not in import map", m.from)
+	}
+	newName := filepath.Base(m.to)
+	for _, f := range pkg.Files {
+		// Update all import comments.
+		for _, cg := range f.Comments {
+			c := cg.List[0]
+			if c.Slash >= f.Name.End() &&
+				sameLine(m.iprog.Fset, c.Slash, f.Name.End()) &&
+				(f.Decls == nil || c.Slash < f.Decls[0].Pos()) {
+				if strings.HasPrefix(c.Text, `// import "`) {
+					c.Text = `// import "` + m.to + `"`
+					break
+				}
+				if strings.HasPrefix(c.Text, `/* import "`) {
+					c.Text = `/* import "` + m.to + `" */`
+					break
+				}
+			}
+		}
+		f.Name.Name = newName // change package decl
+		filesToUpdate[f] = true
+	}
+
+	// Look through the external test packages (m.iprog.Created contains the external test packages).
+	for _, info := range m.iprog.Created {
+		// Change the "package" declaration of the external test package.
+		if info.Pkg.Path() == m.from+"_test" {
+			for _, f := range info.Files {
+				f.Name.Name = newName + "_test" // change package decl
+				filesToUpdate[f] = true
+			}
+		}
+
+		// Mark all the loaded external test packages, which import the "from" package,
+		// as affected packages and update the imports.
+		for _, imp := range info.Pkg.Imports() {
+			if imp.Path() == m.from {
+				m.affectedPackages[info.Pkg.Path()] = true
+				m.iprog.Imported[info.Pkg.Path()] = info
+				if err := importName(m.iprog, info, m.from, path.Base(m.from), newName); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// Update imports of that package to use the new import name.
+	// None of the subpackages will change their name---only the from package
+	// itself will.
+	for p := range m.rev[m.from] {
+		if err := importName(m.iprog, m.iprog.Imported[p], m.from, path.Base(m.from), newName); err != nil {
+			return err
+		}
+	}
+
+	// Update import paths for all imports by affected packages.
+	for ap := range m.affectedPackages {
+		info, ok := m.iprog.Imported[ap]
+		if !ok {
+			log.Fatalf("unexpected: package %s is not in import map", ap)
+		}
+		for _, f := range info.Files {
+			for _, imp := range f.Imports {
+				importPath, _ := strconv.Unquote(imp.Path.Value)
+				if newPath, ok := m.destinations[importPath]; ok {
+					imp.Path.Value = strconv.Quote(newPath)
+
+					oldName := path.Base(importPath)
+					if imp.Name != nil {
+						oldName = imp.Name.Name
+					}
+
+					newName := path.Base(newPath)
+					if imp.Name == nil && oldName != newName {
+						imp.Name = ast.NewIdent(oldName)
+					} else if imp.Name == nil || imp.Name.Name == newName {
+						imp.Name = nil
+					}
+					filesToUpdate[f] = true
+				}
+			}
+		}
+	}
+
+	for f := range filesToUpdate {
+		var buf bytes.Buffer
+		if err := format.Node(&buf, m.iprog.Fset, f); err != nil {
+			log.Printf("failed to pretty-print syntax tree: %v", err)
+			continue
+		}
+		tokenFile := m.iprog.Fset.File(f.Pos())
+		writeFile(tokenFile.Name(), buf.Bytes())
+	}
+
+	// Move the directories.
+	// If either the fromDir or toDir are contained under version control it is
+	// the user's responsibility to provide a custom move command that updates
+	// version control to reflect the move.
+	// TODO(matloob): If the parent directory of toDir does not exist, create it.
+	//      For now, it's required that it does exist.
+
+	if m.cmd != "" {
+		// TODO(matloob): Verify that the windows and plan9 cases are correct.
+		var cmd *exec.Cmd
+		switch runtime.GOOS {
+		case "windows":
+			cmd = exec.Command("cmd", "/c", m.cmd)
+		case "plan9":
+			cmd = exec.Command("rc", "-c", m.cmd)
+		default:
+			cmd = exec.Command("sh", "-c", m.cmd)
+		}
+		cmd.Stderr = os.Stderr
+		cmd.Stdout = os.Stdout
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("version control system's move command failed: %v", err)
+		}
+
+		return nil
+	}
+
+	return moveDirectory(m.fromDir, m.toDir)
+}
+
+// sameLine reports whether two positions in the same file are on the same line.
+func sameLine(fset *token.FileSet, x, y token.Pos) bool {
+	return fset.Position(x).Line == fset.Position(y).Line
+}
+
+var moveDirectory = func(from, to string) error {
+	return os.Rename(from, to)
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/mvpkg_test.go b/vendor/golang.org/x/tools/refactor/rename/mvpkg_test.go
new file mode 100644
index 0000000..38e8a90
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/mvpkg_test.go
@@ -0,0 +1,463 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// licence that can be found in the LICENSE file.
+
+package rename
+
+import (
+	"fmt"
+	"go/build"
+	"go/token"
+	"io/ioutil"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestErrors(t *testing.T) {
+	tests := []struct {
+		ctxt     *build.Context
+		from, to string
+		want     string // regexp to match error, or "OK"
+	}{
+		// Simple example.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"bar": {`package bar`},
+				"main": {`package main
+
+import "foo"
+
+var _ foo.T
+`},
+			}),
+			from: "foo", to: "bar",
+			want: `invalid move destination: bar conflicts with directory .go.src.bar`,
+		},
+		// Subpackage already exists.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo":     {`package foo; type T int`},
+				"foo/sub": {`package sub`},
+				"bar/sub": {`package sub`},
+				"main": {`package main
+
+import "foo"
+
+var _ foo.T
+`},
+			}),
+			from: "foo", to: "bar",
+			want: "invalid move destination: bar; package or subpackage bar/sub already exists",
+		},
+		// Invalid base name.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+var _ foo.T
+`},
+			}),
+			from: "foo", to: "bar-v2.0",
+			want: "invalid move destination: bar-v2.0; gomvpkg does not " +
+				"support move destinations whose base names are not valid " +
+				"go identifiers",
+		},
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {``},
+				"bar": {`package bar`},
+			}),
+			from: "foo", to: "bar",
+			want: `no initial packages were loaded`,
+		},
+	}
+
+	for _, test := range tests {
+		ctxt := test.ctxt
+
+		got := make(map[string]string)
+		writeFile = func(filename string, content []byte) error {
+			got[filename] = string(content)
+			return nil
+		}
+		moveDirectory = func(from, to string) error {
+			for path, contents := range got {
+				if strings.HasPrefix(path, from) {
+					newPath := strings.Replace(path, from, to, 1)
+					delete(got, path)
+					got[newPath] = contents
+				}
+			}
+			return nil
+		}
+
+		err := Move(ctxt, test.from, test.to, "")
+		prefix := fmt.Sprintf("-from %q -to %q", test.from, test.to)
+		if err == nil {
+			t.Errorf("%s: nil error. Expected error: %s", prefix, test.want)
+			continue
+		}
+		matched, err2 := regexp.MatchString(test.want, err.Error())
+		if err2 != nil {
+			t.Errorf("regexp.MatchString failed %s", err2)
+			continue
+		}
+		if !matched {
+			t.Errorf("%s: conflict does not match expectation:\n"+
+				"Error: %q\n"+
+				"Pattern: %q",
+				prefix, err.Error(), test.want)
+		}
+	}
+}
+
+func TestMoves(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("broken on Windows; see golang.org/issue/16384")
+	}
+	tests := []struct {
+		ctxt         *build.Context
+		from, to     string
+		want         map[string]string
+		wantWarnings []string
+	}{
+		// Simple example.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+var _ foo.T
+`},
+			}),
+			from: "foo", to: "bar",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+import "bar"
+
+var _ bar.T
+`,
+				"/go/src/bar/0.go": `package bar
+
+type T int
+`,
+			},
+		},
+
+		// Example with subpackage.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo":     {`package foo; type T int`},
+				"foo/sub": {`package sub; type T int`},
+				"main": {`package main
+
+import "foo"
+import "foo/sub"
+
+var _ foo.T
+var _ sub.T
+`},
+			}),
+			from: "foo", to: "bar",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+import "bar"
+import "bar/sub"
+
+var _ bar.T
+var _ sub.T
+`,
+				"/go/src/bar/0.go": `package bar
+
+type T int
+`,
+				"/go/src/bar/sub/0.go": `package sub; type T int`,
+			},
+		},
+
+		// References into subpackages
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo":   {`package foo; import "foo/a"; var _ a.T`},
+				"foo/a": {`package a; type T int`},
+				"foo/b": {`package b; import "foo/a"; var _ a.T`},
+			}),
+			from: "foo", to: "bar",
+			want: map[string]string{
+				"/go/src/bar/0.go": `package bar
+
+import "bar/a"
+
+var _ a.T
+`,
+				"/go/src/bar/a/0.go": `package a; type T int`,
+				"/go/src/bar/b/0.go": `package b
+
+import "bar/a"
+
+var _ a.T
+`,
+			},
+		},
+
+		// References into subpackages where directories have overlapped names
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo":    {},
+				"foo/a":  {`package a`},
+				"foo/aa": {`package bar`},
+				"foo/c":  {`package c; import _ "foo/bar";`},
+			}),
+			from: "foo/a", to: "foo/spam",
+			want: map[string]string{
+				"/go/src/foo/spam/0.go": `package spam
+`,
+				"/go/src/foo/aa/0.go": `package bar`,
+				"/go/src/foo/c/0.go":  `package c; import _ "foo/bar";`,
+			},
+		},
+
+		// External test packages
+		{
+			ctxt: buildutil.FakeContext(map[string]map[string]string{
+				"foo": {
+					"0.go":      `package foo; type T int`,
+					"0_test.go": `package foo_test; import "foo"; var _ foo.T`,
+				},
+				"baz": {
+					"0_test.go": `package baz_test; import "foo"; var _ foo.T`,
+				},
+			}),
+			from: "foo", to: "bar",
+			want: map[string]string{
+				"/go/src/bar/0.go": `package bar
+
+type T int
+`,
+				"/go/src/bar/0_test.go": `package bar_test
+
+import "bar"
+
+var _ bar.T
+`,
+				"/go/src/baz/0_test.go": `package baz_test
+
+import "bar"
+
+var _ bar.T
+`,
+			},
+		},
+		// package import comments
+		{
+			ctxt: fakeContext(map[string][]string{"foo": {`package foo // import "baz"`}}),
+			from: "foo", to: "bar",
+			want: map[string]string{"/go/src/bar/0.go": `package bar // import "bar"
+`},
+		},
+		{
+			ctxt: fakeContext(map[string][]string{"foo": {`package foo /* import "baz" */`}}),
+			from: "foo", to: "bar",
+			want: map[string]string{"/go/src/bar/0.go": `package bar /* import "bar" */
+`},
+		},
+		{
+			ctxt: fakeContext(map[string][]string{"foo": {`package foo       // import "baz"`}}),
+			from: "foo", to: "bar",
+			want: map[string]string{"/go/src/bar/0.go": `package bar // import "bar"
+`},
+		},
+		{
+			ctxt: fakeContext(map[string][]string{"foo": {`package foo
+// import " this is not an import comment`}}),
+			from: "foo", to: "bar",
+			want: map[string]string{"/go/src/bar/0.go": `package bar
+
+// import " this is not an import comment
+`},
+		},
+		{
+			ctxt: fakeContext(map[string][]string{"foo": {`package foo
+/* import " this is not an import comment */`}}),
+			from: "foo", to: "bar",
+			want: map[string]string{"/go/src/bar/0.go": `package bar
+
+/* import " this is not an import comment */
+`},
+		},
+		// Import name conflict generates a warning, not an error.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"x": {},
+				"a": {`package a; type A int`},
+				"b": {`package b; type B int`},
+				"conflict": {`package conflict
+
+import "a"
+import "b"
+var _ a.A
+var _ b.B
+`},
+				"ok": {`package ok
+import "b"
+var _ b.B
+`},
+			}),
+			from: "b", to: "x/a",
+			want: map[string]string{
+				"/go/src/a/0.go": `package a; type A int`,
+				"/go/src/ok/0.go": `package ok
+
+import "x/a"
+
+var _ a.B
+`,
+				"/go/src/conflict/0.go": `package conflict
+
+import "a"
+import "x/a"
+
+var _ a.A
+var _ b.B
+`,
+				"/go/src/x/a/0.go": `package a
+
+type B int
+`,
+			},
+			wantWarnings: []string{
+				`/go/src/conflict/0.go:4:8: renaming this imported package name "b" to "a"`,
+				`/go/src/conflict/0.go:3:8: 	conflicts with imported package name in same block`,
+				`/go/src/conflict/0.go:3:8: skipping update of this file`,
+			},
+		},
+		// Rename with same base name.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"x": {},
+				"y": {},
+				"x/foo": {`package foo
+
+type T int
+`},
+				"main": {`package main; import "x/foo"; var _ foo.T`},
+			}),
+			from: "x/foo", to: "y/foo",
+			want: map[string]string{
+				"/go/src/y/foo/0.go": `package foo
+
+type T int
+`,
+				"/go/src/main/0.go": `package main
+
+import "y/foo"
+
+var _ foo.T
+`,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		ctxt := test.ctxt
+
+		got := make(map[string]string)
+		// Populate got with starting file set. rewriteFile and moveDirectory
+		// will mutate got to produce resulting file set.
+		buildutil.ForEachPackage(ctxt, func(importPath string, err error) {
+			if err != nil {
+				return
+			}
+			path := filepath.Join("/go/src", importPath, "0.go")
+			if !buildutil.FileExists(ctxt, path) {
+				return
+			}
+			f, err := ctxt.OpenFile(path)
+			if err != nil {
+				t.Errorf("unexpected error opening file: %s", err)
+				return
+			}
+			bytes, err := ioutil.ReadAll(f)
+			f.Close()
+			if err != nil {
+				t.Errorf("unexpected error reading file: %s", err)
+				return
+			}
+			got[path] = string(bytes)
+		})
+		var warnings []string
+		reportError = func(posn token.Position, message string) {
+			warning := fmt.Sprintf("%s:%d:%d: %s",
+				filepath.ToSlash(posn.Filename), // for MS Windows
+				posn.Line,
+				posn.Column,
+				message)
+			warnings = append(warnings, warning)
+
+		}
+		writeFile = func(filename string, content []byte) error {
+			got[filename] = string(content)
+			return nil
+		}
+		moveDirectory = func(from, to string) error {
+			for path, contents := range got {
+				if !(strings.HasPrefix(path, from) &&
+					(len(path) == len(from) || path[len(from)] == filepath.Separator)) {
+					continue
+				}
+				newPath := strings.Replace(path, from, to, 1)
+				delete(got, path)
+				got[newPath] = contents
+			}
+			return nil
+		}
+
+		err := Move(ctxt, test.from, test.to, "")
+		prefix := fmt.Sprintf("-from %q -to %q", test.from, test.to)
+		if err != nil {
+			t.Errorf("%s: unexpected error: %s", prefix, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(warnings, test.wantWarnings) {
+			t.Errorf("%s: unexpected warnings:\n%s\nwant:\n%s",
+				prefix,
+				strings.Join(warnings, "\n"),
+				strings.Join(test.wantWarnings, "\n"))
+		}
+
+		for file, wantContent := range test.want {
+			k := filepath.FromSlash(file)
+			gotContent, ok := got[k]
+			delete(got, k)
+			if !ok {
+				// TODO(matloob): some testcases might have files that won't be
+				// rewritten
+				t.Errorf("%s: file %s not rewritten", prefix, file)
+				continue
+			}
+			if gotContent != wantContent {
+				t.Errorf("%s: rewritten file %s does not match expectation; got <<<%s>>>\n"+
+					"want <<<%s>>>", prefix, file, gotContent, wantContent)
+			}
+		}
+		// got should now be empty
+		for file := range got {
+			t.Errorf("%s: unexpected rewrite of file %s", prefix, file)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/rename.go b/vendor/golang.org/x/tools/refactor/rename/rename.go
new file mode 100644
index 0000000..b026e78
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/rename.go
@@ -0,0 +1,603 @@
+// 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 rename contains the implementation of the 'gorename' command
+// whose main function is in golang.org/x/tools/cmd/gorename.
+// See the Usage constant for the command documentation.
+package rename // import "golang.org/x/tools/refactor/rename"
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/types/typeutil"
+	"golang.org/x/tools/refactor/importgraph"
+	"golang.org/x/tools/refactor/satisfy"
+)
+
+const Usage = `gorename: precise type-safe renaming of identifiers in Go source code.
+
+Usage:
+
+ gorename (-from <spec> | -offset <file>:#<byte-offset>) -to <name> [-force]
+
+You must specify the object (named entity) to rename using the -offset
+or -from flag.  Exactly one must be specified.
+
+Flags:
+
+-offset    specifies the filename and byte offset of an identifier to rename.
+           This form is intended for use by text editors.
+
+-from      specifies the object to rename using a query notation;
+           This form is intended for interactive use at the command line.
+           A legal -from query has one of the following forms:
+
+  "encoding/json".Decoder.Decode        method of package-level named type
+  (*"encoding/json".Decoder).Decode     ditto, alternative syntax
+  "encoding/json".Decoder.buf           field of package-level named struct type
+  "encoding/json".HTMLEscape            package member (const, func, var, type)
+  "encoding/json".Decoder.Decode::x     local object x within a method
+  "encoding/json".HTMLEscape::x         local object x within a function
+  "encoding/json"::x                    object x anywhere within a package
+  json.go::x                            object x within file json.go
+
+           Double-quotes must be escaped when writing a shell command.
+           Quotes may be omitted for single-segment import paths such as "fmt".
+
+           For methods, the parens and '*' on the receiver type are both
+           optional.
+
+           It is an error if one of the ::x queries matches multiple
+           objects.
+
+-to        the new name.
+
+-force     causes the renaming to proceed even if conflicts were reported.
+           The resulting program may be ill-formed, or experience a change
+           in behaviour.
+
+           WARNING: this flag may even cause the renaming tool to crash.
+           (In due course this bug will be fixed by moving certain
+           analyses into the type-checker.)
+
+-d         display diffs instead of rewriting files
+
+-v         enables verbose logging.
+
+gorename automatically computes the set of packages that might be
+affected.  For a local renaming, this is just the package specified by
+-from or -offset, but for a potentially exported name, gorename scans
+the workspace ($GOROOT and $GOPATH).
+
+gorename rejects renamings of concrete methods that would change the
+assignability relation between types and interfaces.  If the interface
+change was intentional, initiate the renaming at the interface method.
+
+gorename rejects any renaming that would create a conflict at the point
+of declaration, or a reference conflict (ambiguity or shadowing), or
+anything else that could cause the resulting program not to compile.
+
+
+Examples:
+
+$ gorename -offset file.go:#123 -to foo
+
+  Rename the object whose identifier is at byte offset 123 within file file.go.
+
+$ gorename -from '"bytes".Buffer.Len' -to Size
+
+  Rename the "Len" method of the *bytes.Buffer type to "Size".
+
+---- TODO ----
+
+Correctness:
+- handle dot imports correctly
+- document limitations (reflection, 'implements' algorithm).
+- sketch a proof of exhaustiveness.
+
+Features:
+- support running on packages specified as *.go files on the command line
+- support running on programs containing errors (loader.Config.AllowErrors)
+- allow users to specify a scope other than "global" (to avoid being
+  stuck by neglected packages in $GOPATH that don't build).
+- support renaming the package clause (no object)
+- support renaming an import path (no ident or object)
+  (requires filesystem + SCM updates).
+- detect and reject edits to autogenerated files (cgo, protobufs)
+  and optionally $GOROOT packages.
+- report all conflicts, or at least all qualitatively distinct ones.
+  Sometimes we stop to avoid redundancy, but
+  it may give a disproportionate sense of safety in -force mode.
+- support renaming all instances of a pattern, e.g.
+  all receiver vars of a given type,
+  all local variables of a given type,
+  all PkgNames for a given package.
+- emit JSON output for other editors and tools.
+`
+
+var (
+	// Force enables patching of the source files even if conflicts were reported.
+	// The resulting program may be ill-formed.
+	// It may even cause gorename to crash.  TODO(adonovan): fix that.
+	Force bool
+
+	// Diff causes the tool to display diffs instead of rewriting files.
+	Diff bool
+
+	// DiffCmd specifies the diff command used by the -d feature.
+	// (The command must accept a -u flag and two filename arguments.)
+	DiffCmd = "diff"
+
+	// ConflictError is returned by Main when it aborts the renaming due to conflicts.
+	// (It is distinguished because the interesting errors are the conflicts themselves.)
+	ConflictError = errors.New("renaming aborted due to conflicts")
+
+	// Verbose enables extra logging.
+	Verbose bool
+)
+
+var stdout io.Writer = os.Stdout
+
+type renamer struct {
+	iprog              *loader.Program
+	objsToUpdate       map[types.Object]bool
+	hadConflicts       bool
+	from, to           string
+	satisfyConstraints map[satisfy.Constraint]bool
+	packages           map[*types.Package]*loader.PackageInfo // subset of iprog.AllPackages to inspect
+	msets              typeutil.MethodSetCache
+	changeMethods      bool
+}
+
+var reportError = func(posn token.Position, message string) {
+	fmt.Fprintf(os.Stderr, "%s: %s\n", posn, message)
+}
+
+// importName renames imports of fromPath within the package specified by info.
+// If fromName is not empty, importName renames only imports as fromName.
+// If the renaming would lead to a conflict, the file is left unchanged.
+func importName(iprog *loader.Program, info *loader.PackageInfo, fromPath, fromName, to string) error {
+	if fromName == to {
+		return nil // no-op (e.g. rename x/foo to y/foo)
+	}
+	for _, f := range info.Files {
+		var from types.Object
+		for _, imp := range f.Imports {
+			importPath, _ := strconv.Unquote(imp.Path.Value)
+			importName := path.Base(importPath)
+			if imp.Name != nil {
+				importName = imp.Name.Name
+			}
+			if importPath == fromPath && (fromName == "" || importName == fromName) {
+				from = info.Implicits[imp]
+				break
+			}
+		}
+		if from == nil {
+			continue
+		}
+		r := renamer{
+			iprog:        iprog,
+			objsToUpdate: make(map[types.Object]bool),
+			to:           to,
+			packages:     map[*types.Package]*loader.PackageInfo{info.Pkg: info},
+		}
+		r.check(from)
+		if r.hadConflicts {
+			reportError(iprog.Fset.Position(f.Imports[0].Pos()),
+				"skipping update of this file")
+			continue // ignore errors; leave the existing name
+		}
+		if err := r.update(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func Main(ctxt *build.Context, offsetFlag, fromFlag, to string) error {
+	// -- Parse the -from or -offset specifier ----------------------------
+
+	if (offsetFlag == "") == (fromFlag == "") {
+		return fmt.Errorf("exactly one of the -from and -offset flags must be specified")
+	}
+
+	if !isValidIdentifier(to) {
+		return fmt.Errorf("-to %q: not a valid identifier", to)
+	}
+
+	if Diff {
+		defer func(saved func(string, []byte) error) { writeFile = saved }(writeFile)
+		writeFile = diff
+	}
+
+	var spec *spec
+	var err error
+	if fromFlag != "" {
+		spec, err = parseFromFlag(ctxt, fromFlag)
+	} else {
+		spec, err = parseOffsetFlag(ctxt, offsetFlag)
+	}
+	if err != nil {
+		return err
+	}
+
+	if spec.fromName == to {
+		return fmt.Errorf("the old and new names are the same: %s", to)
+	}
+
+	// -- Load the program consisting of the initial package  -------------
+
+	iprog, err := loadProgram(ctxt, map[string]bool{spec.pkg: true})
+	if err != nil {
+		return err
+	}
+
+	fromObjects, err := findFromObjects(iprog, spec)
+	if err != nil {
+		return err
+	}
+
+	// -- Load a larger program, for global renamings ---------------------
+
+	if requiresGlobalRename(fromObjects, to) {
+		// For a local refactoring, we needn't load more
+		// packages, but if the renaming affects the package's
+		// API, we we must load all packages that depend on the
+		// package defining the object, plus their tests.
+
+		if Verbose {
+			log.Print("Potentially global renaming; scanning workspace...")
+		}
+
+		// Scan the workspace and build the import graph.
+		_, rev, errors := importgraph.Build(ctxt)
+		if len(errors) > 0 {
+			// With a large GOPATH tree, errors are inevitable.
+			// Report them but proceed.
+			fmt.Fprintf(os.Stderr, "While scanning Go workspace:\n")
+			for path, err := range errors {
+				fmt.Fprintf(os.Stderr, "Package %q: %s.\n", path, err)
+			}
+		}
+
+		// Enumerate the set of potentially affected packages.
+		affectedPackages := make(map[string]bool)
+		for _, obj := range fromObjects {
+			// External test packages are never imported,
+			// so they will never appear in the graph.
+			for path := range rev.Search(obj.Pkg().Path()) {
+				affectedPackages[path] = true
+			}
+		}
+
+		// TODO(adonovan): allow the user to specify the scope,
+		// or -ignore patterns?  Computing the scope when we
+		// don't (yet) support inputs containing errors can make
+		// the tool rather brittle.
+
+		// Re-load the larger program.
+		iprog, err = loadProgram(ctxt, affectedPackages)
+		if err != nil {
+			return err
+		}
+
+		fromObjects, err = findFromObjects(iprog, spec)
+		if err != nil {
+			return err
+		}
+	}
+
+	// -- Do the renaming -------------------------------------------------
+
+	r := renamer{
+		iprog:        iprog,
+		objsToUpdate: make(map[types.Object]bool),
+		from:         spec.fromName,
+		to:           to,
+		packages:     make(map[*types.Package]*loader.PackageInfo),
+	}
+
+	// A renaming initiated at an interface method indicates the
+	// intention to rename abstract and concrete methods as needed
+	// to preserve assignability.
+	for _, obj := range fromObjects {
+		if obj, ok := obj.(*types.Func); ok {
+			recv := obj.Type().(*types.Signature).Recv()
+			if recv != nil && isInterface(recv.Type().Underlying()) {
+				r.changeMethods = true
+				break
+			}
+		}
+	}
+
+	// Only the initially imported packages (iprog.Imported) and
+	// their external tests (iprog.Created) should be inspected or
+	// modified, as only they have type-checked functions bodies.
+	// The rest are just dependencies, needed only for package-level
+	// type information.
+	for _, info := range iprog.Imported {
+		r.packages[info.Pkg] = info
+	}
+	for _, info := range iprog.Created { // (tests)
+		r.packages[info.Pkg] = info
+	}
+
+	for _, from := range fromObjects {
+		r.check(from)
+	}
+	if r.hadConflicts && !Force {
+		return ConflictError
+	}
+	return r.update()
+}
+
+// loadProgram loads the specified set of packages (plus their tests)
+// and all their dependencies, from source, through the specified build
+// context.  Only packages in pkgs will have their functions bodies typechecked.
+func loadProgram(ctxt *build.Context, pkgs map[string]bool) (*loader.Program, error) {
+	conf := loader.Config{
+		Build:      ctxt,
+		ParserMode: parser.ParseComments,
+
+		// TODO(adonovan): enable this.  Requires making a lot of code more robust!
+		AllowErrors: false,
+	}
+	// Optimization: don't type-check the bodies of functions in our
+	// dependencies, since we only need exported package members.
+	conf.TypeCheckFuncBodies = func(p string) bool {
+		return pkgs[p] || pkgs[strings.TrimSuffix(p, "_test")]
+	}
+
+	if Verbose {
+		var list []string
+		for pkg := range pkgs {
+			list = append(list, pkg)
+		}
+		sort.Strings(list)
+		for _, pkg := range list {
+			log.Printf("Loading package: %s", pkg)
+		}
+	}
+
+	for pkg := range pkgs {
+		conf.ImportWithTests(pkg)
+	}
+
+	// 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".
+	conf.AllowErrors = true
+	prog, err := conf.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())
+		}
+	}
+	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, nil
+}
+
+func containsHardErrors(errors []error) bool {
+	for _, err := range errors {
+		if err, ok := err.(types.Error); ok && err.Soft {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
+// requiresGlobalRename reports whether this renaming could potentially
+// affect other packages in the Go workspace.
+func requiresGlobalRename(fromObjects []types.Object, to string) bool {
+	var tfm bool
+	for _, from := range fromObjects {
+		if from.Exported() {
+			return true
+		}
+		switch objectKind(from) {
+		case "type", "field", "method":
+			tfm = true
+		}
+	}
+	if ast.IsExported(to) && tfm {
+		// A global renaming may be necessary even if we're
+		// exporting a previous unexported name, since if it's
+		// the name of a type, field or method, this could
+		// change selections in other packages.
+		// (We include "type" in this list because a type
+		// used as an embedded struct field entails a field
+		// renaming.)
+		return true
+	}
+	return false
+}
+
+// update updates the input files.
+func (r *renamer) update() error {
+	// We use token.File, not filename, since a file may appear to
+	// belong to multiple packages and be parsed more than once.
+	// token.File captures this distinction; filename does not.
+
+	var nidents int
+	var filesToUpdate = make(map[*token.File]bool)
+	docRegexp := regexp.MustCompile(`\b` + r.from + `\b`)
+	for _, info := range r.packages {
+		// Mutate the ASTs and note the filenames.
+		for id, obj := range info.Defs {
+			if r.objsToUpdate[obj] {
+				nidents++
+				id.Name = r.to
+				filesToUpdate[r.iprog.Fset.File(id.Pos())] = true
+				// Perform the rename in doc comments too.
+				if doc := r.docComment(id); doc != nil {
+					for _, comment := range doc.List {
+						comment.Text = docRegexp.ReplaceAllString(comment.Text, r.to)
+					}
+				}
+			}
+		}
+
+		for id, obj := range info.Uses {
+			if r.objsToUpdate[obj] {
+				nidents++
+				id.Name = r.to
+				filesToUpdate[r.iprog.Fset.File(id.Pos())] = true
+			}
+		}
+	}
+
+	// Renaming not supported if cgo files are affected.
+	var generatedFileNames []string
+	for _, info := range r.packages {
+		for _, f := range info.Files {
+			tokenFile := r.iprog.Fset.File(f.Pos())
+			if filesToUpdate[tokenFile] && generated(f, tokenFile) {
+				generatedFileNames = append(generatedFileNames, tokenFile.Name())
+			}
+		}
+	}
+	if len(generatedFileNames) > 0 {
+		return fmt.Errorf("refusing to modify generated file%s containing DO NOT EDIT marker: %v", plural(len(generatedFileNames)), generatedFileNames)
+	}
+
+	// Write affected files.
+	var nerrs, npkgs int
+	for _, info := range r.packages {
+		first := true
+		for _, f := range info.Files {
+			tokenFile := r.iprog.Fset.File(f.Pos())
+			if filesToUpdate[tokenFile] {
+				if first {
+					npkgs++
+					first = false
+					if Verbose {
+						log.Printf("Updating package %s", info.Pkg.Path())
+					}
+				}
+
+				filename := tokenFile.Name()
+				var buf bytes.Buffer
+				if err := format.Node(&buf, r.iprog.Fset, f); err != nil {
+					log.Printf("failed to pretty-print syntax tree: %v", err)
+					nerrs++
+					continue
+				}
+				if err := writeFile(filename, buf.Bytes()); err != nil {
+					log.Print(err)
+					nerrs++
+				}
+			}
+		}
+	}
+	if !Diff {
+		fmt.Printf("Renamed %d occurrence%s in %d file%s in %d package%s.\n",
+			nidents, plural(nidents),
+			len(filesToUpdate), plural(len(filesToUpdate)),
+			npkgs, plural(npkgs))
+	}
+	if nerrs > 0 {
+		return fmt.Errorf("failed to rewrite %d file%s", nerrs, plural(nerrs))
+	}
+	return nil
+}
+
+// docComment returns the doc for an identifier.
+func (r *renamer) docComment(id *ast.Ident) *ast.CommentGroup {
+	_, nodes, _ := r.iprog.PathEnclosingInterval(id.Pos(), id.End())
+	for _, node := range nodes {
+		switch decl := node.(type) {
+		case *ast.FuncDecl:
+			return decl.Doc
+		case *ast.Field:
+			return decl.Doc
+		case *ast.GenDecl:
+			return decl.Doc
+		// For {Type,Value}Spec, if the doc on the spec is absent,
+		// search for the enclosing GenDecl
+		case *ast.TypeSpec:
+			if decl.Doc != nil {
+				return decl.Doc
+			}
+		case *ast.ValueSpec:
+			if decl.Doc != nil {
+				return decl.Doc
+			}
+		case *ast.Ident:
+		default:
+			return nil
+		}
+	}
+	return nil
+}
+
+func plural(n int) string {
+	if n != 1 {
+		return "s"
+	}
+	return ""
+}
+
+// writeFile is a seam for testing and for the -d flag.
+var writeFile = reallyWriteFile
+
+func reallyWriteFile(filename string, content []byte) error {
+	return ioutil.WriteFile(filename, content, 0644)
+}
+
+func diff(filename string, content []byte) error {
+	renamed := fmt.Sprintf("%s.%d.renamed", filename, os.Getpid())
+	if err := ioutil.WriteFile(renamed, content, 0644); err != nil {
+		return err
+	}
+	defer os.Remove(renamed)
+
+	diff, err := exec.Command(DiffCmd, "-u", filename, renamed).CombinedOutput()
+	if len(diff) > 0 {
+		// diff exits with a non-zero status when the files don't match.
+		// Ignore that failure as long as we get output.
+		stdout.Write(diff)
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("computing diff: %v", err)
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/rename_test.go b/vendor/golang.org/x/tools/refactor/rename/rename_test.go
new file mode 100644
index 0000000..87134a4
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/rename_test.go
@@ -0,0 +1,1334 @@
+// 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 rename
+
+import (
+	"bytes"
+	"fmt"
+	"go/build"
+	"go/token"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+// TODO(adonovan): test reported source positions, somehow.
+
+func TestConflicts(t *testing.T) {
+	defer func(savedWriteFile func(string, []byte) error, savedReportError func(token.Position, string)) {
+		writeFile = savedWriteFile
+		reportError = savedReportError
+	}(writeFile, reportError)
+	writeFile = func(string, []byte) error { return nil }
+
+	var ctxt *build.Context
+	for _, test := range []struct {
+		ctxt             *build.Context // nil => use previous
+		offset, from, to string         // values of the -offset/-from and -to flags
+		want             string         // regexp to match conflict errors, or "OK"
+	}{
+		// init() checks
+		{
+			ctxt: fakeContext(map[string][]string{
+				"fmt": {`package fmt; type Stringer interface { String() }`},
+				"main": {`
+package main
+
+import foo "fmt"
+
+var v foo.Stringer
+
+func f() { v.String(); f() }
+`,
+					`package main; var w int`},
+			}),
+			from: "main.v", to: "init",
+			want: `you cannot have a var at package level named "init"`,
+		},
+		{
+			from: "main.f", to: "init",
+			want: `renaming this func "f" to "init" would make it a package initializer.*` +
+				`but references to it exist`,
+		},
+		{
+			from: "/go/src/main/0.go::foo", to: "init",
+			want: `"init" is not a valid imported package name`,
+		},
+
+		// Export checks
+		{
+			from: "fmt.Stringer", to: "stringer",
+			want: `renaming this type "Stringer" to "stringer" would make it unexported.*` +
+				`breaking references from packages such as "main"`,
+		},
+		{
+			from: "(fmt.Stringer).String", to: "string",
+			want: `renaming this method "String" to "string" would make it unexported.*` +
+				`breaking references from packages such as "main"`,
+		},
+
+		// Lexical scope checks
+		{
+			// file/package conflict, same file
+			from: "main.v", to: "foo",
+			want: `renaming this var "v" to "foo" would conflict.*` +
+				`with this imported package name`,
+		},
+		{
+			// file/package conflict, same file
+			from: "main::foo", to: "v",
+			want: `renaming this imported package name "foo" to "v" would conflict.*` +
+				`with this package member var`,
+		},
+		{
+			// file/package conflict, different files
+			from: "main.w", to: "foo",
+			want: `renaming this var "w" to "foo" would conflict.*` +
+				`with this imported package name`,
+		},
+		{
+			// file/package conflict, different files
+			from: "main::foo", to: "w",
+			want: `renaming this imported package name "foo" to "w" would conflict.*` +
+				`with this package member var`,
+		},
+		{
+			ctxt: main(`
+package main
+
+var x, z int
+
+func f(y int) {
+	print(x)
+	print(y)
+}
+
+func g(w int) {
+	print(x)
+	x := 1
+	print(x)
+}`),
+			from: "main.x", to: "y",
+			want: `renaming this var "x" to "y".*` +
+				`would cause this reference to become shadowed.*` +
+				`by this intervening var definition`,
+		},
+		{
+			from: "main.g::x", to: "w",
+			want: `renaming this var "x" to "w".*` +
+				`conflicts with var in same block`,
+		},
+		{
+			from: "main.f::y", to: "x",
+			want: `renaming this var "y" to "x".*` +
+				`would shadow this reference.*` +
+				`to the var declared here`,
+		},
+		{
+			from: "main.g::w", to: "x",
+			want: `renaming this var "w" to "x".*` +
+				`conflicts with var in same block`,
+		},
+		{
+			from: "main.z", to: "y", want: "OK",
+		},
+
+		// Label checks
+		{
+			ctxt: main(`
+package main
+
+func f() {
+foo:
+	goto foo
+bar:
+	goto bar
+	func(x int) {
+	wiz:
+		goto wiz
+	}(0)
+}
+`),
+			from: "main.f::foo", to: "bar",
+			want: `renaming this label "foo" to "bar".*` +
+				`would conflict with this one`,
+		},
+		{
+			from: "main.f::foo", to: "wiz", want: "OK",
+		},
+		{
+			from: "main.f::wiz", to: "x", want: "OK",
+		},
+		{
+			from: "main.f::x", to: "wiz", want: "OK",
+		},
+		{
+			from: "main.f::wiz", to: "foo", want: "OK",
+		},
+
+		// Struct fields
+		{
+			ctxt: main(`
+package main
+
+type U struct { u int }
+type V struct { v int }
+
+func (V) x() {}
+
+type W (struct {
+	U
+	V
+	w int
+})
+
+func f() {
+	var w W
+	print(w.u) // NB: there is no selection of w.v
+	var _ struct { yy, zz int }
+}
+`),
+			// field/field conflict in named struct declaration
+			from: "(main.W).U", to: "w",
+			want: `renaming this field "U" to "w".*` +
+				`would conflict with this field`,
+		},
+		{
+			// rename type used as embedded field
+			// => rename field
+			// => field/field conflict
+			// This is an entailed renaming;
+			// it would be nice if we checked source positions.
+			from: "main.U", to: "w",
+			want: `renaming this field "U" to "w".*` +
+				`would conflict with this field`,
+		},
+		{
+			// field/field conflict in unnamed struct declaration
+			from: "main.f::zz", to: "yy",
+			want: `renaming this field "zz" to "yy".*` +
+				`would conflict with this field`,
+		},
+
+		// Now we test both directions of (u,v) (u,w) (v,w) (u,x) (v,x).
+		// Too bad we don't test position info...
+		{
+			// field/field ambiguity at same promotion level ('from' selection)
+			from: "(main.U).u", to: "v",
+			want: `renaming this field "u" to "v".*` +
+				`would make this reference ambiguous.*` +
+				`with this field`,
+		},
+		{
+			// field/field ambiguity at same promotion level ('to' selection)
+			from: "(main.V).v", to: "u",
+			want: `renaming this field "v" to "u".*` +
+				`would make this reference ambiguous.*` +
+				`with this field`,
+		},
+		{
+			// field/method conflict at different promotion level ('from' selection)
+			from: "(main.U).u", to: "w",
+			want: `renaming this field "u" to "w".*` +
+				`would change the referent of this selection.*` +
+				`of this field`,
+		},
+		{
+			// field/field shadowing at different promotion levels ('to' selection)
+			from: "(main.W).w", to: "u",
+			want: `renaming this field "w" to "u".*` +
+				`would shadow this selection.*` +
+				`of the field declared here`,
+		},
+		{
+			from: "(main.V).v", to: "w",
+			want: "OK", // since no selections are made ambiguous
+		},
+		{
+			from: "(main.W).w", to: "v",
+			want: "OK", // since no selections are made ambiguous
+		},
+		{
+			// field/method ambiguity at same promotion level ('from' selection)
+			from: "(main.U).u", to: "x",
+			want: `renaming this field "u" to "x".*` +
+				`would make this reference ambiguous.*` +
+				`with this method`,
+		},
+		{
+			// field/field ambiguity at same promotion level ('to' selection)
+			from: "(main.V).x", to: "u",
+			want: `renaming this method "x" to "u".*` +
+				`would make this reference ambiguous.*` +
+				`with this field`,
+		},
+		{
+			// field/method conflict at named struct declaration
+			from: "(main.V).v", to: "x",
+			want: `renaming this field "v" to "x".*` +
+				`would conflict with this method`,
+		},
+		{
+			// field/method conflict at named struct declaration
+			from: "(main.V).x", to: "v",
+			want: `renaming this method "x" to "v".*` +
+				`would conflict with this field`,
+		},
+
+		// Methods
+		{
+			ctxt: main(`
+package main
+type C int
+func (C) f()
+func (C) g()
+type D int
+func (*D) f()
+func (*D) g()
+type I interface { f(); g() }
+type J interface { I; h() }
+var _ I = new(D)
+var _ interface {f()} = C(0)
+`),
+			from: "(main.I).f", to: "g",
+			want: `renaming this interface method "f" to "g".*` +
+				`would conflict with this method`,
+		},
+		{
+			from: `("main".I).f`, to: "h", // NB: exercises quoted import paths too
+			want: `renaming this interface method "f" to "h".*` +
+				`would conflict with this method.*` +
+				`in named interface type "J"`,
+		},
+		{
+			// type J interface { h; h() } is not a conflict, amusingly.
+			from: "main.I", to: "h",
+			want: `OK`,
+		},
+		{
+			from: "(main.J).h", to: "f",
+			want: `renaming this interface method "h" to "f".*` +
+				`would conflict with this method`,
+		},
+		{
+			from: "(main.C).f", to: "e",
+			want: `renaming this method "f" to "e".*` +
+				`would make main.C no longer assignable to interface{f..}.*` +
+				`(rename interface{f..}.f if you intend to change both types)`,
+		},
+		{
+			from: "(main.D).g", to: "e",
+			want: `renaming this method "g" to "e".*` +
+				`would make \*main.D no longer assignable to interface I.*` +
+				`(rename main.I.g if you intend to change both types)`,
+		},
+		{
+			from: "(main.I).f", to: "e",
+			want: `OK`,
+		},
+		// Indirect C/I method coupling via another concrete type D.
+		{
+			ctxt: main(`
+package main
+type I interface { f() }
+type C int
+func (C) f()
+type D struct{C}
+var _ I = D{}
+`),
+			from: "(main.C).f", to: "F",
+			want: `renaming this method "f" to "F".*` +
+				`would make main.D no longer assignable to interface I.*` +
+				`(rename main.I.f if you intend to change both types)`,
+		},
+		// Renaming causes promoted method to become shadowed; C no longer satisfies I.
+		{
+			ctxt: main(`
+package main
+type I interface { f() }
+type C struct { I }
+func (C) g() int
+var _ I = C{}
+`),
+			from: "main.I.f", to: "g",
+			want: `renaming this method "f" to "g".*` +
+				`would change the g method of main.C invoked via interface main.I.*` +
+				`from \(main.I\).g.*` +
+				`to \(main.C\).g`,
+		},
+		// Renaming causes promoted method to become ambiguous; C no longer satisfies I.
+		{
+			ctxt: main(`
+package main
+type I interface{f()}
+type C int
+func (C) f()
+type D int
+func (D) g()
+type E struct{C;D}
+var _ I = E{}
+`),
+			from: "main.I.f", to: "g",
+			want: `renaming this method "f" to "g".*` +
+				`would make the g method of main.E invoked via interface main.I ambiguous.*` +
+				`with \(main.D\).g`,
+		},
+	} {
+		var conflicts []string
+		reportError = func(posn token.Position, message string) {
+			conflicts = append(conflicts, message)
+		}
+		if test.ctxt != nil {
+			ctxt = test.ctxt
+		}
+		err := Main(ctxt, test.offset, test.from, test.to)
+		var prefix string
+		if test.offset == "" {
+			prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
+		} else {
+			prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
+		}
+		if err == ConflictError {
+			got := strings.Join(conflicts, "\n")
+			if false {
+				t.Logf("%s: %s", prefix, got)
+			}
+			pattern := "(?s:" + test.want + ")" // enable multi-line matching
+			if !regexp.MustCompile(pattern).MatchString(got) {
+				t.Errorf("%s: conflict does not match pattern:\n"+
+					"Conflict:\t%s\n"+
+					"Pattern: %s",
+					prefix, got, test.want)
+			}
+		} else if err != nil {
+			t.Errorf("%s: unexpected error: %s", prefix, err)
+		} else if test.want != "OK" {
+			t.Errorf("%s: unexpected success, want conflicts matching:\n%s",
+				prefix, test.want)
+		}
+	}
+}
+
+func TestInvalidIdentifiers(t *testing.T) {
+	ctxt := fakeContext(map[string][]string{
+		"main": {`
+package main
+
+func f() { }
+`}})
+
+	for _, test := range []struct {
+		from, to string // values of the -offset/-from and -to flags
+		want     string // expected error message
+	}{
+		{
+			from: "main.f", to: "_",
+			want: `-to "_": not a valid identifier`,
+		},
+		{
+			from: "main.f", to: "123",
+			want: `-to "123": not a valid identifier`,
+		},
+		{
+			from: "main.f", to: "for",
+			want: `-to "for": not a valid identifier`,
+		},
+		{
+			from: "switch", to: "v",
+			want: `-from "switch": invalid expression`,
+		},
+	} {
+		err := Main(ctxt, "", test.from, test.to)
+		prefix := fmt.Sprintf("-from %q -to %q", test.from, test.to)
+		if err == nil {
+			t.Errorf("%s: expected error %q", prefix, test.want)
+		} else if err.Error() != test.want {
+			t.Errorf("%s: unexpected error\nwant: %s\n got: %s", prefix, test.want, err.Error())
+		}
+	}
+}
+
+func TestRewrites(t *testing.T) {
+	defer func(savedWriteFile func(string, []byte) error) {
+		writeFile = savedWriteFile
+	}(writeFile)
+
+	var ctxt *build.Context
+	for _, test := range []struct {
+		ctxt             *build.Context    // nil => use previous
+		offset, from, to string            // values of the -from/-offset and -to flags
+		want             map[string]string // contents of updated files
+	}{
+		// Elimination of renaming import.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import foo2 "foo"
+
+var _ foo2.T
+`},
+			}),
+			from: "main::foo2", to: "foo",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+import "foo"
+
+var _ foo.T
+`,
+			},
+		},
+		// Introduction of renaming import.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+var _ foo.T
+`},
+			}),
+			offset: "/go/src/main/0.go:#36", to: "foo2", // the "foo" in foo.T
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+import foo2 "foo"
+
+var _ foo2.T
+`,
+			},
+		},
+		// Renaming of package-level member.
+		{
+			from: "foo.T", to: "U",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+import "foo"
+
+var _ foo.U
+`,
+				"/go/src/foo/0.go": `package foo
+
+type U int
+`,
+			},
+		},
+		// Rename package-level func plus doc
+		{
+			ctxt: main(`package main
+
+// Foo is a no-op.
+// Calling Foo does nothing.
+func Foo() {
+}
+`),
+			from: "main.Foo", to: "FooBar",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+// FooBar is a no-op.
+// Calling FooBar does nothing.
+func FooBar() {
+}
+`,
+			},
+		},
+		// Rename method plus doc
+		{
+			ctxt: main(`package main
+
+type Foo struct{}
+
+// Bar does nothing.
+func (Foo) Bar() {
+}
+`),
+			from: "main.Foo.Bar", to: "Baz",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type Foo struct{}
+
+// Baz does nothing.
+func (Foo) Baz() {
+}
+`,
+			},
+		},
+		// Rename type spec plus doc
+		{
+			ctxt: main(`package main
+
+type (
+	// Test but not Testing.
+	Test struct{}
+)
+`),
+			from: "main.Test", to: "Type",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type (
+	// Type but not Testing.
+	Type struct{}
+)
+`,
+			},
+		},
+		// Rename type in gen decl plus doc
+		{
+			ctxt: main(`package main
+
+// T is a test type.
+type T struct{}
+`),
+			from: "main.T", to: "Type",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+// Type is a test type.
+type Type struct{}
+`,
+			},
+		},
+		// Rename value spec with doc
+		{
+			ctxt: main(`package main
+
+const (
+	// C is the speed of light.
+	C = 2.998e8
+)
+`),
+			from: "main.C", to: "Lightspeed",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+const (
+	// Lightspeed is the speed of light.
+	Lightspeed = 2.998e8
+)
+`,
+			},
+		},
+		// Rename value inside gen decl with doc
+		{
+			ctxt: main(`package main
+
+var out *string
+`),
+			from: "main.out", to: "discard",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+var discard *string
+`,
+			},
+		},
+		// Rename field plus doc
+		{
+			ctxt: main(`package main
+
+type Struct struct {
+	// Field is a struct field.
+	Field string
+}
+`),
+			from: "main.Struct.Field", to: "Foo",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type Struct struct {
+	// Foo is a struct field.
+	Foo string
+}
+`,
+			},
+		},
+		// Label renamings.
+		{
+			ctxt: main(`package main
+func f() {
+loop:
+	loop := 0
+	go func() {
+	loop:
+		goto loop
+	}()
+	loop++
+	goto loop
+}
+`),
+			offset: "/go/src/main/0.go:#25", to: "loop2", // def of outer label "loop"
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func f() {
+loop2:
+	loop := 0
+	go func() {
+	loop:
+		goto loop
+	}()
+	loop++
+	goto loop2
+}
+`,
+			},
+		},
+		{
+			offset: "/go/src/main/0.go:#70", to: "loop2", // ref to inner label "loop"
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func f() {
+loop:
+	loop := 0
+	go func() {
+	loop2:
+		goto loop2
+	}()
+	loop++
+	goto loop
+}
+`,
+			},
+		},
+		// Renaming of type used as embedded field.
+		{
+			ctxt: main(`package main
+
+type T int
+type U struct { T }
+
+var _ = U{}.T
+`),
+			from: "main.T", to: "T2",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type T2 int
+type U struct{ T2 }
+
+var _ = U{}.T2
+`,
+			},
+		},
+		// Renaming of embedded field.
+		{
+			ctxt: main(`package main
+
+type T int
+type U struct { T }
+
+var _ = U{}.T
+`),
+			offset: "/go/src/main/0.go:#58", to: "T2", // T in "U{}.T"
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type T2 int
+type U struct{ T2 }
+
+var _ = U{}.T2
+`,
+			},
+		},
+		// Renaming of pointer embedded field.
+		{
+			ctxt: main(`package main
+
+type T int
+type U struct { *T }
+
+var _ = U{}.T
+`),
+			offset: "/go/src/main/0.go:#59", to: "T2", // T in "U{}.T"
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type T2 int
+type U struct{ *T2 }
+
+var _ = U{}.T2
+`,
+			},
+		},
+
+		// Lexical scope tests.
+		{
+			ctxt: main(`package main
+
+var y int
+
+func f() {
+	print(y)
+	y := ""
+	print(y)
+}
+`),
+			from: "main.y", to: "x",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+var x int
+
+func f() {
+	print(x)
+	y := ""
+	print(y)
+}
+`,
+			},
+		},
+		{
+			from: "main.f::y", to: "x",
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+var y int
+
+func f() {
+	print(y)
+	x := ""
+	print(x)
+}
+`,
+			},
+		},
+		// Renaming of typeswitch vars (a corner case).
+		{
+			ctxt: main(`package main
+
+func f(z interface{}) {
+	switch y := z.(type) {
+	case int:
+		print(y)
+	default:
+		print(y)
+	}
+}
+`),
+			offset: "/go/src/main/0.go:#46", to: "x", // def of y
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func f(z interface{}) {
+	switch x := z.(type) {
+	case int:
+		print(x)
+	default:
+		print(x)
+	}
+}
+`},
+		},
+		{
+			offset: "/go/src/main/0.go:#81", to: "x", // ref of y in case int
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func f(z interface{}) {
+	switch x := z.(type) {
+	case int:
+		print(x)
+	default:
+		print(x)
+	}
+}
+`},
+		},
+		{
+			offset: "/go/src/main/0.go:#102", to: "x", // ref of y in default case
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func f(z interface{}) {
+	switch x := z.(type) {
+	case int:
+		print(x)
+	default:
+		print(x)
+	}
+}
+`},
+		},
+
+		// Renaming of embedded field that is a qualified reference.
+		// (Regression test for bug 8924.)
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+type _ struct{ *foo.T }
+`},
+			}),
+			offset: "/go/src/main/0.go:#48", to: "U", // the "T" in *foo.T
+			want: map[string]string{
+				"/go/src/foo/0.go": `package foo
+
+type U int
+`,
+				"/go/src/main/0.go": `package main
+
+import "foo"
+
+type _ struct{ *foo.U }
+`,
+			},
+		},
+
+		// Renaming of embedded field that is a qualified reference with the '-from' flag.
+		// (Regression test for bug 12038.)
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+type V struct{ *foo.T }
+`},
+			}),
+			from: "(main.V).T", to: "U", // the "T" in *foo.T
+			want: map[string]string{
+				"/go/src/foo/0.go": `package foo
+
+type U int
+`,
+				"/go/src/main/0.go": `package main
+
+import "foo"
+
+type V struct{ *foo.U }
+`,
+			},
+		},
+		{
+			ctxt: fakeContext(map[string][]string{
+				"foo": {`package foo; type T int`},
+				"main": {`package main
+
+import "foo"
+
+type V struct{ foo.T }
+`},
+			}),
+			from: "(main.V).T", to: "U", // the "T" in *foo.T
+			want: map[string]string{
+				"/go/src/foo/0.go": `package foo
+
+type U int
+`,
+				"/go/src/main/0.go": `package main
+
+import "foo"
+
+type V struct{ foo.U }
+`,
+			},
+		},
+
+		// Interface method renaming.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`
+package main
+type I interface {
+	f()
+}
+type J interface { f(); g() }
+type A int
+func (A) f()
+type B int
+func (B) f()
+func (B) g()
+type C int
+func (C) f()
+func (C) g()
+var _, _ I = A(0), B(0)
+var _, _ J = B(0), C(0)
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	F()
+}
+type J interface {
+	F()
+	g()
+}
+type A int
+
+func (A) F()
+
+type B int
+
+func (B) F()
+func (B) g()
+
+type C int
+
+func (C) F()
+func (C) g()
+
+var _, _ I = A(0), B(0)
+var _, _ J = B(0), C(0)
+`,
+			},
+		},
+		{
+			offset: "/go/src/main/0.go:#59", to: "F", // abstract method J.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	F()
+}
+type J interface {
+	F()
+	g()
+}
+type A int
+
+func (A) F()
+
+type B int
+
+func (B) F()
+func (B) g()
+
+type C int
+
+func (C) F()
+func (C) g()
+
+var _, _ I = A(0), B(0)
+var _, _ J = B(0), C(0)
+`,
+			},
+		},
+		{
+			offset: "/go/src/main/0.go:#64", to: "G", // abstract method J.g
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	f()
+}
+type J interface {
+	f()
+	G()
+}
+type A int
+
+func (A) f()
+
+type B int
+
+func (B) f()
+func (B) G()
+
+type C int
+
+func (C) f()
+func (C) G()
+
+var _, _ I = A(0), B(0)
+var _, _ J = B(0), C(0)
+`,
+			},
+		},
+		// Indirect coupling of I.f to C.f from D->I assignment and anonymous field of D.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`
+package main
+type I interface {
+	f()
+}
+type C int
+func (C) f()
+type D struct{C}
+var _ I = D{}
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	F()
+}
+type C int
+
+func (C) F()
+
+type D struct{ C }
+
+var _ I = D{}
+`,
+			},
+		},
+		// Interface embedded in struct.  No conflict if C need not satisfy I.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`
+package main
+type I interface {
+	f()
+}
+type C struct{I}
+func (C) g() int
+var _ int = C{}.g()
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#34", to: "g", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	g()
+}
+type C struct{ I }
+
+func (C) g() int
+
+var _ int = C{}.g()
+`,
+			},
+		},
+		// A type assertion causes method coupling iff signatures match.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`package main
+type I interface{
+	f()
+}
+type J interface{
+	f()
+}
+var _ = I(nil).(J)
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	g()
+}
+type J interface {
+	g()
+}
+
+var _ = I(nil).(J)
+`,
+			},
+		},
+		// Impossible type assertion: no method coupling.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`package main
+type I interface{
+	f()
+}
+type J interface{
+	f()int
+}
+var _ = I(nil).(J)
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	g()
+}
+type J interface {
+	f() int
+}
+
+var _ = I(nil).(J)
+`,
+			},
+		},
+		// Impossible type assertion: no method coupling C.f<->J.f.
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`package main
+type I interface{
+	f()
+}
+type C int
+func (C) f()
+type J interface{
+	f()int
+}
+var _ = I(C(0)).(J)
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+type I interface {
+	g()
+}
+type C int
+
+func (C) g()
+
+type J interface {
+	f() int
+}
+
+var _ = I(C(0)).(J)
+`,
+			},
+		},
+		// Progress after "soft" type errors (Go issue 14596).
+		{
+			ctxt: fakeContext(map[string][]string{
+				"main": {`package main
+
+func main() {
+	var unused, x int
+	print(x)
+}
+`,
+				},
+			}),
+			offset: "/go/src/main/0.go:#54", to: "y", // var x
+			want: map[string]string{
+				"/go/src/main/0.go": `package main
+
+func main() {
+	var unused, y int
+	print(y)
+}
+`,
+			},
+		},
+	} {
+		if test.ctxt != nil {
+			ctxt = test.ctxt
+		}
+
+		got := make(map[string]string)
+		writeFile = func(filename string, content []byte) error {
+			got[filepath.ToSlash(filename)] = string(content)
+			return nil
+		}
+
+		err := Main(ctxt, test.offset, test.from, test.to)
+		var prefix string
+		if test.offset == "" {
+			prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
+		} else {
+			prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
+		}
+		if err != nil {
+			t.Errorf("%s: unexpected error: %s", prefix, err)
+			continue
+		}
+
+		for file, wantContent := range test.want {
+			gotContent, ok := got[file]
+			delete(got, file)
+			if !ok {
+				t.Errorf("%s: file %s not rewritten", prefix, file)
+				continue
+			}
+			if gotContent != wantContent {
+				t.Errorf("%s: rewritten file %s does not match expectation; got <<<%s>>>\n"+
+					"want <<<%s>>>", prefix, file, gotContent, wantContent)
+			}
+		}
+		// got should now be empty
+		for file := range got {
+			t.Errorf("%s: unexpected rewrite of file %s", prefix, file)
+		}
+	}
+}
+
+func TestDiff(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skipf("diff tool non-existent for windows on builders")
+	}
+	if runtime.GOOS == "plan9" {
+		t.Skipf("plan9 diff tool doesn't support -u flag")
+	}
+
+	defer func() {
+		Diff = false
+		stdout = os.Stdout
+	}()
+	Diff = true
+	stdout = new(bytes.Buffer)
+
+	if err := Main(&build.Default, "", `"golang.org/x/tools/refactor/rename".justHereForTestingDiff`, "Foo"); err != nil {
+		t.Fatal(err)
+	}
+
+	// NB: there are tabs in the string literal!
+	if !strings.Contains(stdout.(fmt.Stringer).String(), `
+-func justHereForTestingDiff() {
+-	justHereForTestingDiff()
++func Foo() {
++	Foo()
+ }
+`) {
+		t.Errorf("unexpected diff:\n<<%s>>", stdout)
+	}
+}
+
+func justHereForTestingDiff() {
+	justHereForTestingDiff()
+}
+
+// ---------------------------------------------------------------------
+
+// Simplifying wrapper around buildutil.FakeContext for packages whose
+// filenames are sequentially numbered (%d.go).  pkgs maps a package
+// import path to its list of file contents.
+func fakeContext(pkgs map[string][]string) *build.Context {
+	pkgs2 := make(map[string]map[string]string)
+	for path, files := range pkgs {
+		filemap := make(map[string]string)
+		for i, contents := range files {
+			filemap[fmt.Sprintf("%d.go", i)] = contents
+		}
+		pkgs2[path] = filemap
+	}
+	return buildutil.FakeContext(pkgs2)
+}
+
+// helper for single-file main packages with no imports.
+func main(content string) *build.Context {
+	return fakeContext(map[string][]string{"main": {content}})
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/spec.go b/vendor/golang.org/x/tools/refactor/rename/spec.go
new file mode 100644
index 0000000..0c4526d
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/spec.go
@@ -0,0 +1,593 @@
+// 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 rename
+
+// This file contains logic related to specifying a renaming: parsing of
+// the flags as a form of query, and finding the object(s) it denotes.
+// See Usage for flag details.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+)
+
+// A spec specifies an entity to rename.
+//
+// It is populated from an -offset flag or -from query;
+// see Usage for the allowed -from query forms.
+//
+type spec struct {
+	// pkg is the package containing the position
+	// specified by the -from or -offset flag.
+	// If filename == "", our search for the 'from' entity
+	// is restricted to this package.
+	pkg string
+
+	// The original name of the entity being renamed.
+	// If the query had a ::from component, this is that;
+	// otherwise it's the last segment, e.g.
+	//   (encoding/json.Decoder).from
+	//   encoding/json.from
+	fromName string
+
+	// -- The remaining fields are private to this file.  All are optional. --
+
+	// The query's ::x suffix, if any.
+	searchFor string
+
+	// e.g. "Decoder" in "(encoding/json.Decoder).fieldOrMethod"
+	//                or "encoding/json.Decoder
+	pkgMember string
+
+	// e.g. fieldOrMethod in "(encoding/json.Decoder).fieldOrMethod"
+	typeMember string
+
+	// Restricts the query to this file.
+	// Implied by -from="file.go::x" and -offset flags.
+	filename string
+
+	// Byte offset of the 'from' identifier within the file named 'filename'.
+	// -offset mode only.
+	offset int
+}
+
+// parseFromFlag interprets the "-from" flag value as a renaming specification.
+// See Usage in rename.go for valid formats.
+func parseFromFlag(ctxt *build.Context, fromFlag string) (*spec, error) {
+	var spec spec
+	var main string // sans "::x" suffix
+	switch parts := strings.Split(fromFlag, "::"); len(parts) {
+	case 1:
+		main = parts[0]
+	case 2:
+		main = parts[0]
+		spec.searchFor = parts[1]
+		if parts[1] == "" {
+			// error
+		}
+	default:
+		return nil, fmt.Errorf("-from %q: invalid identifier specification (see -help for formats)", fromFlag)
+	}
+
+	if strings.HasSuffix(main, ".go") {
+		// main is "filename.go"
+		if spec.searchFor == "" {
+			return nil, fmt.Errorf("-from: filename %q must have a ::name suffix", main)
+		}
+		spec.filename = main
+		if !buildutil.FileExists(ctxt, spec.filename) {
+			return nil, fmt.Errorf("no such file: %s", spec.filename)
+		}
+
+		bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
+		if err != nil {
+			return nil, err
+		}
+		spec.pkg = bp.ImportPath
+
+	} else {
+		// main is one of:
+		//  "importpath"
+		//  "importpath".member
+		//  (*"importpath".type).fieldormethod           (parens and star optional)
+		if err := parseObjectSpec(&spec, main); err != nil {
+			return nil, err
+		}
+	}
+
+	if spec.searchFor != "" {
+		spec.fromName = spec.searchFor
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+
+	// Sanitize the package.
+	bp, err := ctxt.Import(spec.pkg, cwd, build.FindOnly)
+	if err != nil {
+		return nil, fmt.Errorf("can't find package %q", spec.pkg)
+	}
+	spec.pkg = bp.ImportPath
+
+	if !isValidIdentifier(spec.fromName) {
+		return nil, fmt.Errorf("-from: invalid identifier %q", spec.fromName)
+	}
+
+	if Verbose {
+		log.Printf("-from spec: %+v", spec)
+	}
+
+	return &spec, nil
+}
+
+// parseObjectSpec parses main as one of the non-filename forms of
+// object specification.
+func parseObjectSpec(spec *spec, main string) error {
+	// Parse main as a Go expression, albeit a strange one.
+	e, _ := parser.ParseExpr(main)
+
+	if pkg := parseImportPath(e); pkg != "" {
+		// e.g. bytes or "encoding/json": a package
+		spec.pkg = pkg
+		if spec.searchFor == "" {
+			return fmt.Errorf("-from %q: package import path %q must have a ::name suffix",
+				main, main)
+		}
+		return nil
+	}
+
+	if e, ok := e.(*ast.SelectorExpr); ok {
+		x := unparen(e.X)
+
+		// Strip off star constructor, if any.
+		if star, ok := x.(*ast.StarExpr); ok {
+			x = star.X
+		}
+
+		if pkg := parseImportPath(x); pkg != "" {
+			// package member e.g. "encoding/json".HTMLEscape
+			spec.pkg = pkg              // e.g. "encoding/json"
+			spec.pkgMember = e.Sel.Name // e.g. "HTMLEscape"
+			spec.fromName = e.Sel.Name
+			return nil
+		}
+
+		if x, ok := x.(*ast.SelectorExpr); ok {
+			// field/method of type e.g. ("encoding/json".Decoder).Decode
+			y := unparen(x.X)
+			if pkg := parseImportPath(y); pkg != "" {
+				spec.pkg = pkg               // e.g. "encoding/json"
+				spec.pkgMember = x.Sel.Name  // e.g. "Decoder"
+				spec.typeMember = e.Sel.Name // e.g. "Decode"
+				spec.fromName = e.Sel.Name
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("-from %q: invalid expression", main)
+}
+
+// parseImportPath returns the import path of the package denoted by e.
+// Any import path may be represented as a string literal;
+// single-segment import paths (e.g. "bytes") may also be represented as
+// ast.Ident.  parseImportPath returns "" for all other expressions.
+func parseImportPath(e ast.Expr) string {
+	switch e := e.(type) {
+	case *ast.Ident:
+		return e.Name // e.g. bytes
+
+	case *ast.BasicLit:
+		if e.Kind == token.STRING {
+			pkgname, _ := strconv.Unquote(e.Value)
+			return pkgname // e.g. "encoding/json"
+		}
+	}
+	return ""
+}
+
+// parseOffsetFlag interprets the "-offset" flag value as a renaming specification.
+func parseOffsetFlag(ctxt *build.Context, offsetFlag string) (*spec, error) {
+	var spec spec
+	// Validate -offset, e.g. file.go:#123
+	parts := strings.Split(offsetFlag, ":#")
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("-offset %q: invalid offset specification", offsetFlag)
+	}
+
+	spec.filename = parts[0]
+	if !buildutil.FileExists(ctxt, spec.filename) {
+		return nil, fmt.Errorf("no such file: %s", spec.filename)
+	}
+
+	bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
+	if err != nil {
+		return nil, err
+	}
+	spec.pkg = bp.ImportPath
+
+	for _, r := range parts[1] {
+		if !isDigit(r) {
+			return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
+		}
+	}
+	spec.offset, err = strconv.Atoi(parts[1])
+	if err != nil {
+		return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
+	}
+
+	// Parse the file and check there's an identifier at that offset.
+	fset := token.NewFileSet()
+	f, err := buildutil.ParseFile(fset, ctxt, nil, wd, spec.filename, parser.ParseComments)
+	if err != nil {
+		return nil, fmt.Errorf("-offset %q: cannot parse file: %s", offsetFlag, err)
+	}
+
+	id := identAtOffset(fset, f, spec.offset)
+	if id == nil {
+		return nil, fmt.Errorf("-offset %q: no identifier at this position", offsetFlag)
+	}
+
+	spec.fromName = id.Name
+
+	return &spec, nil
+}
+
+var wd = func() string {
+	wd, err := os.Getwd()
+	if err != nil {
+		panic("cannot get working directory: " + err.Error())
+	}
+	return wd
+}()
+
+// For source trees built with 'go build', the -from or -offset
+// spec identifies exactly one initial 'from' object to rename ,
+// but certain proprietary build systems allow a single file to
+// appear in multiple packages (e.g. the test package contains a
+// copy of its library), so there may be multiple objects for
+// the same source entity.
+
+func findFromObjects(iprog *loader.Program, spec *spec) ([]types.Object, error) {
+	if spec.filename != "" {
+		return findFromObjectsInFile(iprog, spec)
+	}
+
+	// Search for objects defined in specified package.
+
+	// TODO(adonovan): the iprog.ImportMap has an entry {"main": ...}
+	// for main packages, even though that's not an import path.
+	// Seems like a bug.
+	//
+	// pkg := iprog.ImportMap[spec.pkg]
+	// if pkg == nil {
+	// 	return fmt.Errorf("cannot find package %s", spec.pkg) // can't happen?
+	// }
+	// info := iprog.AllPackages[pkg]
+
+	// Workaround: lookup by value.
+	var info *loader.PackageInfo
+	var pkg *types.Package
+	for pkg, info = range iprog.AllPackages {
+		if pkg.Path() == spec.pkg {
+			break
+		}
+	}
+	if info == nil {
+		return nil, fmt.Errorf("package %q was not loaded", spec.pkg)
+	}
+
+	objects, err := findObjects(info, spec)
+	if err != nil {
+		return nil, err
+	}
+	if len(objects) > 1 {
+		// ambiguous "*" scope query
+		return nil, ambiguityError(iprog.Fset, objects)
+	}
+	return objects, nil
+}
+
+func findFromObjectsInFile(iprog *loader.Program, spec *spec) ([]types.Object, error) {
+	var fromObjects []types.Object
+	for _, info := range iprog.AllPackages {
+		// restrict to specified filename
+		// NB: under certain proprietary build systems, a given
+		// filename may appear in multiple packages.
+		for _, f := range info.Files {
+			thisFile := iprog.Fset.File(f.Pos())
+			if !sameFile(thisFile.Name(), spec.filename) {
+				continue
+			}
+			// This package contains the query file.
+
+			if spec.offset != 0 {
+				// We cannot refactor generated files since position information is invalidated.
+				if generated(f, thisFile) {
+					return nil, fmt.Errorf("cannot rename identifiers in generated file containing DO NOT EDIT marker: %s", thisFile.Name())
+				}
+
+				// Search for a specific ident by file/offset.
+				id := identAtOffset(iprog.Fset, f, spec.offset)
+				if id == nil {
+					// can't happen?
+					return nil, fmt.Errorf("identifier not found")
+				}
+				obj := info.Uses[id]
+				if obj == nil {
+					obj = info.Defs[id]
+					if obj == nil {
+						// Ident without Object.
+
+						// Package clause?
+						pos := thisFile.Pos(spec.offset)
+						_, path, _ := iprog.PathEnclosingInterval(pos, pos)
+						if len(path) == 2 { // [Ident File]
+							// TODO(adonovan): support this case.
+							return nil, fmt.Errorf("cannot rename %q: renaming package clauses is not yet supported",
+								path[1].(*ast.File).Name.Name)
+						}
+
+						// Implicit y in "switch y := x.(type) {"?
+						if obj := typeSwitchVar(&info.Info, path); obj != nil {
+							return []types.Object{obj}, nil
+						}
+
+						// Probably a type error.
+						return nil, fmt.Errorf("cannot find object for %q", id.Name)
+					}
+				}
+				if obj.Pkg() == nil {
+					return nil, fmt.Errorf("cannot rename predeclared identifiers (%s)", obj)
+
+				}
+
+				fromObjects = append(fromObjects, obj)
+			} else {
+				// do a package-wide query
+				objects, err := findObjects(info, spec)
+				if err != nil {
+					return nil, err
+				}
+
+				// filter results: only objects defined in thisFile
+				var filtered []types.Object
+				for _, obj := range objects {
+					if iprog.Fset.File(obj.Pos()) == thisFile {
+						filtered = append(filtered, obj)
+					}
+				}
+				if len(filtered) == 0 {
+					return nil, fmt.Errorf("no object %q declared in file %s",
+						spec.fromName, spec.filename)
+				} else if len(filtered) > 1 {
+					return nil, ambiguityError(iprog.Fset, filtered)
+				}
+				fromObjects = append(fromObjects, filtered[0])
+			}
+			break
+		}
+	}
+	if len(fromObjects) == 0 {
+		// can't happen?
+		return nil, fmt.Errorf("file %s was not part of the loaded program", spec.filename)
+	}
+	return fromObjects, nil
+}
+
+func typeSwitchVar(info *types.Info, path []ast.Node) types.Object {
+	if len(path) > 3 {
+		// [Ident AssignStmt TypeSwitchStmt...]
+		if sw, ok := path[2].(*ast.TypeSwitchStmt); ok {
+			// choose the first case.
+			if len(sw.Body.List) > 0 {
+				obj := info.Implicits[sw.Body.List[0].(*ast.CaseClause)]
+				if obj != nil {
+					return obj
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// On success, findObjects returns the list of objects named
+// spec.fromName matching the spec.  On success, the result has exactly
+// one element unless spec.searchFor!="", in which case it has at least one
+// element.
+//
+func findObjects(info *loader.PackageInfo, spec *spec) ([]types.Object, error) {
+	if spec.pkgMember == "" {
+		if spec.searchFor == "" {
+			panic(spec)
+		}
+		objects := searchDefs(&info.Info, spec.searchFor)
+		if objects == nil {
+			return nil, fmt.Errorf("no object %q declared in package %q",
+				spec.searchFor, info.Pkg.Path())
+		}
+		return objects, nil
+	}
+
+	pkgMember := info.Pkg.Scope().Lookup(spec.pkgMember)
+	if pkgMember == nil {
+		return nil, fmt.Errorf("package %q has no member %q",
+			info.Pkg.Path(), spec.pkgMember)
+	}
+
+	var searchFunc *types.Func
+	if spec.typeMember == "" {
+		// package member
+		if spec.searchFor == "" {
+			return []types.Object{pkgMember}, nil
+		}
+
+		// Search within pkgMember, which must be a function.
+		searchFunc, _ = pkgMember.(*types.Func)
+		if searchFunc == nil {
+			return nil, fmt.Errorf("cannot search for %q within %s %q",
+				spec.searchFor, objectKind(pkgMember), pkgMember)
+		}
+	} else {
+		// field/method of type
+		// e.g. (encoding/json.Decoder).Decode
+		// or ::x within it.
+
+		tName, _ := pkgMember.(*types.TypeName)
+		if tName == nil {
+			return nil, fmt.Errorf("%s.%s is a %s, not a type",
+				info.Pkg.Path(), pkgMember.Name(), objectKind(pkgMember))
+		}
+
+		// search within named type.
+		obj, _, _ := types.LookupFieldOrMethod(tName.Type(), true, info.Pkg, spec.typeMember)
+		if obj == nil {
+			return nil, fmt.Errorf("cannot find field or method %q of %s %s.%s",
+				spec.typeMember, typeKind(tName.Type()), info.Pkg.Path(), tName.Name())
+		}
+
+		if spec.searchFor == "" {
+			// If it is an embedded field, return the type of the field.
+			if v, ok := obj.(*types.Var); ok && v.Anonymous() {
+				switch t := v.Type().(type) {
+				case *types.Pointer:
+					return []types.Object{t.Elem().(*types.Named).Obj()}, nil
+				case *types.Named:
+					return []types.Object{t.Obj()}, nil
+				}
+			}
+			return []types.Object{obj}, nil
+		}
+
+		searchFunc, _ = obj.(*types.Func)
+		if searchFunc == nil {
+			return nil, fmt.Errorf("cannot search for local name %q within %s (%s.%s).%s; need a function",
+				spec.searchFor, objectKind(obj), info.Pkg.Path(), tName.Name(),
+				obj.Name())
+		}
+		if isInterface(tName.Type()) {
+			return nil, fmt.Errorf("cannot search for local name %q within abstract method (%s.%s).%s",
+				spec.searchFor, info.Pkg.Path(), tName.Name(), searchFunc.Name())
+		}
+	}
+
+	// -- search within function or method --
+
+	decl := funcDecl(info, searchFunc)
+	if decl == nil {
+		return nil, fmt.Errorf("cannot find syntax for %s", searchFunc) // can't happen?
+	}
+
+	var objects []types.Object
+	for _, obj := range searchDefs(&info.Info, spec.searchFor) {
+		// We use positions, not scopes, to determine whether
+		// the obj is within searchFunc.  This is clumsy, but the
+		// alternative, using the types.Scope tree, doesn't
+		// account for non-lexical objects like fields and
+		// interface methods.
+		if decl.Pos() <= obj.Pos() && obj.Pos() < decl.End() && obj != searchFunc {
+			objects = append(objects, obj)
+		}
+	}
+	if objects == nil {
+		return nil, fmt.Errorf("no local definition of %q within %s",
+			spec.searchFor, searchFunc)
+	}
+	return objects, nil
+}
+
+func funcDecl(info *loader.PackageInfo, fn *types.Func) *ast.FuncDecl {
+	for _, f := range info.Files {
+		for _, d := range f.Decls {
+			if d, ok := d.(*ast.FuncDecl); ok && info.Defs[d.Name] == fn {
+				return d
+			}
+		}
+	}
+	return nil
+}
+
+func searchDefs(info *types.Info, name string) []types.Object {
+	var objects []types.Object
+	for id, obj := range info.Defs {
+		if obj == nil {
+			// e.g. blank ident.
+			// TODO(adonovan): but also implicit y in
+			//    switch y := x.(type)
+			// Needs some thought.
+			continue
+		}
+		if id.Name == name {
+			objects = append(objects, obj)
+		}
+	}
+	return objects
+}
+
+func identAtOffset(fset *token.FileSet, f *ast.File, offset int) *ast.Ident {
+	var found *ast.Ident
+	ast.Inspect(f, func(n ast.Node) bool {
+		if id, ok := n.(*ast.Ident); ok {
+			idpos := fset.Position(id.Pos()).Offset
+			if idpos <= offset && offset < idpos+len(id.Name) {
+				found = id
+			}
+		}
+		return found == nil // keep traversing only until found
+	})
+	return found
+}
+
+// ambiguityError returns an error describing an ambiguous "*" scope query.
+func ambiguityError(fset *token.FileSet, objects []types.Object) error {
+	var buf bytes.Buffer
+	for i, obj := range objects {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		posn := fset.Position(obj.Pos())
+		fmt.Fprintf(&buf, "%s at %s:%d:%d",
+			objectKind(obj), filepath.Base(posn.Filename), posn.Line, posn.Column)
+	}
+	return fmt.Errorf("ambiguous specifier %s matches %s",
+		objects[0].Name(), buf.String())
+}
+
+// Matches cgo generated comment as well as the proposed standard:
+//	https://golang.org/s/generatedcode
+var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`)
+
+// generated reports whether ast.File is a generated file.
+func generated(f *ast.File, tokenFile *token.File) bool {
+
+	// Iterate over the comments in the file
+	for _, commentGroup := range f.Comments {
+		for _, comment := range commentGroup.List {
+			if matched := generatedRx.MatchString(comment.Text); matched {
+				// Check if comment is at the beginning of the line in source
+				if pos := tokenFile.Position(comment.Slash); pos.Column == 1 {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
diff --git a/vendor/golang.org/x/tools/refactor/rename/util.go b/vendor/golang.org/x/tools/refactor/rename/util.go
new file mode 100644
index 0000000..e8f8d74
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/rename/util.go
@@ -0,0 +1,105 @@
+// 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 rename
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+func objectKind(obj types.Object) string {
+	switch obj := obj.(type) {
+	case *types.PkgName:
+		return "imported package name"
+	case *types.TypeName:
+		return "type"
+	case *types.Var:
+		if obj.IsField() {
+			return "field"
+		}
+	case *types.Func:
+		if obj.Type().(*types.Signature).Recv() != nil {
+			return "method"
+		}
+	}
+	// label, func, var, const
+	return strings.ToLower(strings.TrimPrefix(reflect.TypeOf(obj).String(), "*types."))
+}
+
+func typeKind(T types.Type) string {
+	return strings.ToLower(strings.TrimPrefix(reflect.TypeOf(T.Underlying()).String(), "*types."))
+}
+
+// NB: for renamings, blank is not considered valid.
+func isValidIdentifier(id string) bool {
+	if id == "" || id == "_" {
+		return false
+	}
+	for i, r := range id {
+		if !isLetter(r) && (i == 0 || !isDigit(r)) {
+			return false
+		}
+	}
+	return token.Lookup(id) == token.IDENT
+}
+
+// isLocal reports whether obj is local to some function.
+// Precondition: not a struct field or interface method.
+func isLocal(obj types.Object) bool {
+	// [... 5=stmt 4=func 3=file 2=pkg 1=universe]
+	var depth int
+	for scope := obj.Parent(); scope != nil; scope = scope.Parent() {
+		depth++
+	}
+	return depth >= 4
+}
+
+func isPackageLevel(obj types.Object) bool {
+	return obj.Pkg().Scope().Lookup(obj.Name()) == obj
+}
+
+// -- Plundered from go/scanner: ---------------------------------------
+
+func isLetter(ch rune) bool {
+	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 0x80 && unicode.IsLetter(ch)
+}
+
+func isDigit(ch rune) bool {
+	return '0' <= ch && ch <= '9' || ch >= 0x80 && unicode.IsDigit(ch)
+}
+
+// -- Plundered from golang.org/x/tools/cmd/guru -----------------
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+//
+func sameFile(x, y string) bool {
+	if runtime.GOOS == "windows" {
+		x = filepath.ToSlash(x)
+		y = filepath.ToSlash(y)
+	}
+	if x == 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
+}
+
+func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
diff --git a/vendor/golang.org/x/tools/refactor/satisfy/find.go b/vendor/golang.org/x/tools/refactor/satisfy/find.go
new file mode 100644
index 0000000..9b365b9
--- /dev/null
+++ b/vendor/golang.org/x/tools/refactor/satisfy/find.go
@@ -0,0 +1,705 @@
+// 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 satisfy inspects the type-checked ASTs of Go packages and
+// reports the set of discovered type constraints of the form (lhs, rhs
+// Type) where lhs is a non-trivial interface, rhs satisfies this
+// interface, and this fact is necessary for the package to be
+// well-typed.
+//
+// THIS PACKAGE IS EXPERIMENTAL AND MAY CHANGE AT ANY TIME.
+//
+// It is provided only for the gorename tool.  Ideally this
+// functionality will become part of the type-checker in due course,
+// since it is computing it anyway, and it is robust for ill-typed
+// inputs, which this package is not.
+//
+package satisfy // import "golang.org/x/tools/refactor/satisfy"
+
+// NOTES:
+//
+// We don't care about numeric conversions, so we don't descend into
+// types or constant expressions.  This is unsound because
+// constant expressions can contain arbitrary statements, e.g.
+//   const x = len([1]func(){func() {
+//     ...
+//   }})
+//
+// TODO(adonovan): make this robust against ill-typed input.
+// Or move it into the type-checker.
+//
+// Assignability conversions are possible in the following places:
+// - in assignments y = x, y := x, var y = x.
+// - from call argument types to formal parameter types
+// - in append and delete calls
+// - from return operands to result parameter types
+// - in composite literal T{k:v}, from k and v to T's field/element/key type
+// - in map[key] from key to the map's key type
+// - in comparisons x==y and switch x { case y: }.
+// - in explicit conversions T(x)
+// - in sends ch <- x, from x to the channel element type
+// - in type assertions x.(T) and switch x.(type) { case T: }
+//
+// The results of this pass provide information equivalent to the
+// ssa.MakeInterface and ssa.ChangeInterface instructions.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// A Constraint records the fact that the RHS type does and must
+// satisify the LHS type, which is an interface.
+// The names are suggestive of an assignment statement LHS = RHS.
+type Constraint struct {
+	LHS, RHS types.Type
+}
+
+// A Finder inspects the type-checked ASTs of Go packages and
+// accumulates the set of type constraints (x, y) such that x is
+// assignable to y, y is an interface, and both x and y have methods.
+//
+// In other words, it returns the subset of the "implements" relation
+// that is checked during compilation of a package.  Refactoring tools
+// will need to preserve at least this part of the relation to ensure
+// continued compilation.
+//
+type Finder struct {
+	Result    map[Constraint]bool
+	msetcache typeutil.MethodSetCache
+
+	// per-Find state
+	info *types.Info
+	sig  *types.Signature
+}
+
+// Find inspects a single package, populating Result with its pairs of
+// constrained types.
+//
+// The result is non-canonical and thus may contain duplicates (but this
+// tends to preserves names of interface types better).
+//
+// The package must be free of type errors, and
+// info.{Defs,Uses,Selections,Types} must have been populated by the
+// type-checker.
+//
+func (f *Finder) Find(info *types.Info, files []*ast.File) {
+	if f.Result == nil {
+		f.Result = make(map[Constraint]bool)
+	}
+
+	f.info = info
+	for _, file := range files {
+		for _, d := range file.Decls {
+			switch d := d.(type) {
+			case *ast.GenDecl:
+				if d.Tok == token.VAR { // ignore consts
+					for _, spec := range d.Specs {
+						f.valueSpec(spec.(*ast.ValueSpec))
+					}
+				}
+
+			case *ast.FuncDecl:
+				if d.Body != nil {
+					f.sig = f.info.Defs[d.Name].Type().(*types.Signature)
+					f.stmt(d.Body)
+					f.sig = nil
+				}
+			}
+		}
+	}
+	f.info = nil
+}
+
+var (
+	tInvalid     = types.Typ[types.Invalid]
+	tUntypedBool = types.Typ[types.UntypedBool]
+	tUntypedNil  = types.Typ[types.UntypedNil]
+)
+
+// exprN visits an expression in a multi-value context.
+func (f *Finder) exprN(e ast.Expr) types.Type {
+	typ := f.info.Types[e].Type.(*types.Tuple)
+	switch e := e.(type) {
+	case *ast.ParenExpr:
+		return f.exprN(e.X)
+
+	case *ast.CallExpr:
+		// x, err := f(args)
+		sig := f.expr(e.Fun).Underlying().(*types.Signature)
+		f.call(sig, e.Args)
+
+	case *ast.IndexExpr:
+		// y, ok := x[i]
+		x := f.expr(e.X)
+		f.assign(f.expr(e.Index), x.Underlying().(*types.Map).Key())
+
+	case *ast.TypeAssertExpr:
+		// y, ok := x.(T)
+		f.typeAssert(f.expr(e.X), typ.At(0).Type())
+
+	case *ast.UnaryExpr: // must be receive <-
+		// y, ok := <-x
+		f.expr(e.X)
+
+	default:
+		panic(e)
+	}
+	return typ
+}
+
+func (f *Finder) call(sig *types.Signature, args []ast.Expr) {
+	if len(args) == 0 {
+		return
+	}
+
+	// Ellipsis call?  e.g. f(x, y, z...)
+	if _, ok := args[len(args)-1].(*ast.Ellipsis); ok {
+		for i, arg := range args {
+			// The final arg is a slice, and so is the final param.
+			f.assign(sig.Params().At(i).Type(), f.expr(arg))
+		}
+		return
+	}
+
+	var argtypes []types.Type
+
+	// Gather the effective actual parameter types.
+	if tuple, ok := f.info.Types[args[0]].Type.(*types.Tuple); ok {
+		// f(g()) call where g has multiple results?
+		f.expr(args[0])
+		// unpack the tuple
+		for i := 0; i < tuple.Len(); i++ {
+			argtypes = append(argtypes, tuple.At(i).Type())
+		}
+	} else {
+		for _, arg := range args {
+			argtypes = append(argtypes, f.expr(arg))
+		}
+	}
+
+	// Assign the actuals to the formals.
+	if !sig.Variadic() {
+		for i, argtype := range argtypes {
+			f.assign(sig.Params().At(i).Type(), argtype)
+		}
+	} else {
+		// The first n-1 parameters are assigned normally.
+		nnormals := sig.Params().Len() - 1
+		for i, argtype := range argtypes[:nnormals] {
+			f.assign(sig.Params().At(i).Type(), argtype)
+		}
+		// Remaining args are assigned to elements of varargs slice.
+		tElem := sig.Params().At(nnormals).Type().(*types.Slice).Elem()
+		for i := nnormals; i < len(argtypes); i++ {
+			f.assign(tElem, argtypes[i])
+		}
+	}
+}
+
+func (f *Finder) builtin(obj *types.Builtin, sig *types.Signature, args []ast.Expr, T types.Type) types.Type {
+	switch obj.Name() {
+	case "make", "new":
+		// skip the type operand
+		for _, arg := range args[1:] {
+			f.expr(arg)
+		}
+
+	case "append":
+		s := f.expr(args[0])
+		if _, ok := args[len(args)-1].(*ast.Ellipsis); ok && len(args) == 2 {
+			// append(x, y...)   including append([]byte, "foo"...)
+			f.expr(args[1])
+		} else {
+			// append(x, y, z)
+			tElem := s.Underlying().(*types.Slice).Elem()
+			for _, arg := range args[1:] {
+				f.assign(tElem, f.expr(arg))
+			}
+		}
+
+	case "delete":
+		m := f.expr(args[0])
+		k := f.expr(args[1])
+		f.assign(m.Underlying().(*types.Map).Key(), k)
+
+	default:
+		// ordinary call
+		f.call(sig, args)
+	}
+
+	return T
+}
+
+func (f *Finder) extract(tuple types.Type, i int) types.Type {
+	if tuple, ok := tuple.(*types.Tuple); ok && i < tuple.Len() {
+		return tuple.At(i).Type()
+	}
+	return tInvalid
+}
+
+func (f *Finder) valueSpec(spec *ast.ValueSpec) {
+	var T types.Type
+	if spec.Type != nil {
+		T = f.info.Types[spec.Type].Type
+	}
+	switch len(spec.Values) {
+	case len(spec.Names): // e.g. var x, y = f(), g()
+		for _, value := range spec.Values {
+			v := f.expr(value)
+			if T != nil {
+				f.assign(T, v)
+			}
+		}
+
+	case 1: // e.g. var x, y = f()
+		tuple := f.exprN(spec.Values[0])
+		for i := range spec.Names {
+			if T != nil {
+				f.assign(T, f.extract(tuple, i))
+			}
+		}
+	}
+}
+
+// assign records pairs of distinct types that are related by
+// assignability, where the left-hand side is an interface and both
+// sides have methods.
+//
+// It should be called for all assignability checks, type assertions,
+// explicit conversions and comparisons between two types, unless the
+// types are uninteresting (e.g. lhs is a concrete type, or the empty
+// interface; rhs has no methods).
+//
+func (f *Finder) assign(lhs, rhs types.Type) {
+	if types.Identical(lhs, rhs) {
+		return
+	}
+	if !isInterface(lhs) {
+		return
+	}
+
+	if f.msetcache.MethodSet(lhs).Len() == 0 {
+		return
+	}
+	if f.msetcache.MethodSet(rhs).Len() == 0 {
+		return
+	}
+	// record the pair
+	f.Result[Constraint{lhs, rhs}] = true
+}
+
+// typeAssert must be called for each type assertion x.(T) where x has
+// interface type I.
+func (f *Finder) typeAssert(I, T types.Type) {
+	// Type assertions are slightly subtle, because they are allowed
+	// to be "impossible", e.g.
+	//
+	// 	var x interface{f()}
+	//	_ = x.(interface{f()int}) // legal
+	//
+	// (In hindsight, the language spec should probably not have
+	// allowed this, but it's too late to fix now.)
+	//
+	// This means that a type assert from I to T isn't exactly a
+	// constraint that T is assignable to I, but for a refactoring
+	// tool it is a conditional constraint that, if T is assignable
+	// to I before a refactoring, it should remain so after.
+
+	if types.AssignableTo(T, I) {
+		f.assign(I, T)
+	}
+}
+
+// compare must be called for each comparison x==y.
+func (f *Finder) compare(x, y types.Type) {
+	if types.AssignableTo(x, y) {
+		f.assign(y, x)
+	} else if types.AssignableTo(y, x) {
+		f.assign(x, y)
+	}
+}
+
+// expr visits a true expression (not a type or defining ident)
+// and returns its type.
+func (f *Finder) expr(e ast.Expr) types.Type {
+	tv := f.info.Types[e]
+	if tv.Value != nil {
+		return tv.Type // prune the descent for constants
+	}
+
+	// tv.Type may be nil for an ast.Ident.
+
+	switch e := e.(type) {
+	case *ast.BadExpr, *ast.BasicLit:
+		// no-op
+
+	case *ast.Ident:
+		// (referring idents only)
+		if obj, ok := f.info.Uses[e]; ok {
+			return obj.Type()
+		}
+		if e.Name == "_" { // e.g. "for _ = range x"
+			return tInvalid
+		}
+		panic("undefined ident: " + e.Name)
+
+	case *ast.Ellipsis:
+		if e.Elt != nil {
+			f.expr(e.Elt)
+		}
+
+	case *ast.FuncLit:
+		saved := f.sig
+		f.sig = tv.Type.(*types.Signature)
+		f.stmt(e.Body)
+		f.sig = saved
+
+	case *ast.CompositeLit:
+		switch T := deref(tv.Type).Underlying().(type) {
+		case *types.Struct:
+			for i, elem := range e.Elts {
+				if kv, ok := elem.(*ast.KeyValueExpr); ok {
+					f.assign(f.info.Uses[kv.Key.(*ast.Ident)].Type(), f.expr(kv.Value))
+				} else {
+					f.assign(T.Field(i).Type(), f.expr(elem))
+				}
+			}
+
+		case *types.Map:
+			for _, elem := range e.Elts {
+				elem := elem.(*ast.KeyValueExpr)
+				f.assign(T.Key(), f.expr(elem.Key))
+				f.assign(T.Elem(), f.expr(elem.Value))
+			}
+
+		case *types.Array, *types.Slice:
+			tElem := T.(interface {
+				Elem() types.Type
+			}).Elem()
+			for _, elem := range e.Elts {
+				if kv, ok := elem.(*ast.KeyValueExpr); ok {
+					// ignore the key
+					f.assign(tElem, f.expr(kv.Value))
+				} else {
+					f.assign(tElem, f.expr(elem))
+				}
+			}
+
+		default:
+			panic("unexpected composite literal type: " + tv.Type.String())
+		}
+
+	case *ast.ParenExpr:
+		f.expr(e.X)
+
+	case *ast.SelectorExpr:
+		if _, ok := f.info.Selections[e]; ok {
+			f.expr(e.X) // selection
+		} else {
+			return f.info.Uses[e.Sel].Type() // qualified identifier
+		}
+
+	case *ast.IndexExpr:
+		x := f.expr(e.X)
+		i := f.expr(e.Index)
+		if ux, ok := x.Underlying().(*types.Map); ok {
+			f.assign(ux.Key(), i)
+		}
+
+	case *ast.SliceExpr:
+		f.expr(e.X)
+		if e.Low != nil {
+			f.expr(e.Low)
+		}
+		if e.High != nil {
+			f.expr(e.High)
+		}
+		if e.Max != nil {
+			f.expr(e.Max)
+		}
+
+	case *ast.TypeAssertExpr:
+		x := f.expr(e.X)
+		f.typeAssert(x, f.info.Types[e.Type].Type)
+
+	case *ast.CallExpr:
+		if tvFun := f.info.Types[e.Fun]; tvFun.IsType() {
+			// conversion
+			arg0 := f.expr(e.Args[0])
+			f.assign(tvFun.Type, arg0)
+		} else {
+			// function call
+			if id, ok := unparen(e.Fun).(*ast.Ident); ok {
+				if obj, ok := f.info.Uses[id].(*types.Builtin); ok {
+					sig := f.info.Types[id].Type.(*types.Signature)
+					return f.builtin(obj, sig, e.Args, tv.Type)
+				}
+			}
+			// ordinary call
+			f.call(f.expr(e.Fun).Underlying().(*types.Signature), e.Args)
+		}
+
+	case *ast.StarExpr:
+		f.expr(e.X)
+
+	case *ast.UnaryExpr:
+		f.expr(e.X)
+
+	case *ast.BinaryExpr:
+		x := f.expr(e.X)
+		y := f.expr(e.Y)
+		if e.Op == token.EQL || e.Op == token.NEQ {
+			f.compare(x, y)
+		}
+
+	case *ast.KeyValueExpr:
+		f.expr(e.Key)
+		f.expr(e.Value)
+
+	case *ast.ArrayType,
+		*ast.StructType,
+		*ast.FuncType,
+		*ast.InterfaceType,
+		*ast.MapType,
+		*ast.ChanType:
+		panic(e)
+	}
+
+	if tv.Type == nil {
+		panic(fmt.Sprintf("no type for %T", e))
+	}
+
+	return tv.Type
+}
+
+func (f *Finder) stmt(s ast.Stmt) {
+	switch s := s.(type) {
+	case *ast.BadStmt,
+		*ast.EmptyStmt,
+		*ast.BranchStmt:
+		// no-op
+
+	case *ast.DeclStmt:
+		d := s.Decl.(*ast.GenDecl)
+		if d.Tok == token.VAR { // ignore consts
+			for _, spec := range d.Specs {
+				f.valueSpec(spec.(*ast.ValueSpec))
+			}
+		}
+
+	case *ast.LabeledStmt:
+		f.stmt(s.Stmt)
+
+	case *ast.ExprStmt:
+		f.expr(s.X)
+
+	case *ast.SendStmt:
+		ch := f.expr(s.Chan)
+		val := f.expr(s.Value)
+		f.assign(ch.Underlying().(*types.Chan).Elem(), val)
+
+	case *ast.IncDecStmt:
+		f.expr(s.X)
+
+	case *ast.AssignStmt:
+		switch s.Tok {
+		case token.ASSIGN, token.DEFINE:
+			// y := x   or   y = x
+			var rhsTuple types.Type
+			if len(s.Lhs) != len(s.Rhs) {
+				rhsTuple = f.exprN(s.Rhs[0])
+			}
+			for i := range s.Lhs {
+				var lhs, rhs types.Type
+				if rhsTuple == nil {
+					rhs = f.expr(s.Rhs[i]) // 1:1 assignment
+				} else {
+					rhs = f.extract(rhsTuple, i) // n:1 assignment
+				}
+
+				if id, ok := s.Lhs[i].(*ast.Ident); ok {
+					if id.Name != "_" {
+						if obj, ok := f.info.Defs[id]; ok {
+							lhs = obj.Type() // definition
+						}
+					}
+				}
+				if lhs == nil {
+					lhs = f.expr(s.Lhs[i]) // assignment
+				}
+				f.assign(lhs, rhs)
+			}
+
+		default:
+			// y op= x
+			f.expr(s.Lhs[0])
+			f.expr(s.Rhs[0])
+		}
+
+	case *ast.GoStmt:
+		f.expr(s.Call)
+
+	case *ast.DeferStmt:
+		f.expr(s.Call)
+
+	case *ast.ReturnStmt:
+		formals := f.sig.Results()
+		switch len(s.Results) {
+		case formals.Len(): // 1:1
+			for i, result := range s.Results {
+				f.assign(formals.At(i).Type(), f.expr(result))
+			}
+
+		case 1: // n:1
+			tuple := f.exprN(s.Results[0])
+			for i := 0; i < formals.Len(); i++ {
+				f.assign(formals.At(i).Type(), f.extract(tuple, i))
+			}
+		}
+
+	case *ast.SelectStmt:
+		f.stmt(s.Body)
+
+	case *ast.BlockStmt:
+		for _, s := range s.List {
+			f.stmt(s)
+		}
+
+	case *ast.IfStmt:
+		if s.Init != nil {
+			f.stmt(s.Init)
+		}
+		f.expr(s.Cond)
+		f.stmt(s.Body)
+		if s.Else != nil {
+			f.stmt(s.Else)
+		}
+
+	case *ast.SwitchStmt:
+		if s.Init != nil {
+			f.stmt(s.Init)
+		}
+		var tag types.Type = tUntypedBool
+		if s.Tag != nil {
+			tag = f.expr(s.Tag)
+		}
+		for _, cc := range s.Body.List {
+			cc := cc.(*ast.CaseClause)
+			for _, cond := range cc.List {
+				f.compare(tag, f.info.Types[cond].Type)
+			}
+			for _, s := range cc.Body {
+				f.stmt(s)
+			}
+		}
+
+	case *ast.TypeSwitchStmt:
+		if s.Init != nil {
+			f.stmt(s.Init)
+		}
+		var I types.Type
+		switch ass := s.Assign.(type) {
+		case *ast.ExprStmt: // x.(type)
+			I = f.expr(unparen(ass.X).(*ast.TypeAssertExpr).X)
+		case *ast.AssignStmt: // y := x.(type)
+			I = f.expr(unparen(ass.Rhs[0]).(*ast.TypeAssertExpr).X)
+		}
+		for _, cc := range s.Body.List {
+			cc := cc.(*ast.CaseClause)
+			for _, cond := range cc.List {
+				tCase := f.info.Types[cond].Type
+				if tCase != tUntypedNil {
+					f.typeAssert(I, tCase)
+				}
+			}
+			for _, s := range cc.Body {
+				f.stmt(s)
+			}
+		}
+
+	case *ast.CommClause:
+		if s.Comm != nil {
+			f.stmt(s.Comm)
+		}
+		for _, s := range s.Body {
+			f.stmt(s)
+		}
+
+	case *ast.ForStmt:
+		if s.Init != nil {
+			f.stmt(s.Init)
+		}
+		if s.Cond != nil {
+			f.expr(s.Cond)
+		}
+		if s.Post != nil {
+			f.stmt(s.Post)
+		}
+		f.stmt(s.Body)
+
+	case *ast.RangeStmt:
+		x := f.expr(s.X)
+		// No conversions are involved when Tok==DEFINE.
+		if s.Tok == token.ASSIGN {
+			if s.Key != nil {
+				k := f.expr(s.Key)
+				var xelem types.Type
+				// keys of array, *array, slice, string aren't interesting
+				switch ux := x.Underlying().(type) {
+				case *types.Chan:
+					xelem = ux.Elem()
+				case *types.Map:
+					xelem = ux.Key()
+				}
+				if xelem != nil {
+					f.assign(xelem, k)
+				}
+			}
+			if s.Value != nil {
+				val := f.expr(s.Value)
+				var xelem types.Type
+				// values of strings aren't interesting
+				switch ux := x.Underlying().(type) {
+				case *types.Array:
+					xelem = ux.Elem()
+				case *types.Chan:
+					xelem = ux.Elem()
+				case *types.Map:
+					xelem = ux.Elem()
+				case *types.Pointer: // *array
+					xelem = deref(ux).(*types.Array).Elem()
+				case *types.Slice:
+					xelem = ux.Elem()
+				}
+				if xelem != nil {
+					f.assign(xelem, val)
+				}
+			}
+		}
+		f.stmt(s.Body)
+
+	default:
+		panic(s)
+	}
+}
+
+// -- Plundered from golang.org/x/tools/go/ssa -----------------
+
+// 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
+}
+
+func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
+
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
diff --git a/vendor/golang.org/x/tools/third_party/moduleloader/LICENSE b/vendor/golang.org/x/tools/third_party/moduleloader/LICENSE
new file mode 100644
index 0000000..1723a22
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/third_party/moduleloader/moduleloader.js b/vendor/golang.org/x/tools/third_party/moduleloader/moduleloader.js
new file mode 100644
index 0000000..c9bc6ce
--- /dev/null
+++ b/vendor/golang.org/x/tools/third_party/moduleloader/moduleloader.js
@@ -0,0 +1,7 @@
+/*
+ *  es6-module-loader v0.17.11
+ *  https://github.com/ModuleLoader/es6-module-loader
+ *  Copyright (c) 2016 Guy Bedford, Luke Hoban, Addy Osmani; Licensed MIT
+ */
+
+!function(a){function b(a,c){if("string"!=typeof a)throw new TypeError("URL must be a string");var d=String(a).replace(/^\s+|\s+$/g,"").match(/^([^:\/?#]+:)?(?:\/\/(?:([^:@\/?#]*)(?::([^:@\/?#]*))?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);if(!d)throw new RangeError("Invalid URL format");var e=d[1]||"",f=d[2]||"",g=d[3]||"",h=d[4]||"",i=d[5]||"",j=d[6]||"",k=d[7]||"",l=d[8]||"",m=d[9]||"";if(void 0!==c){var n=c instanceof b?c:new b(c),o=!e&&!h&&!f;!o||k||l||(l=n.search),o&&"/"!==k[0]&&(k=k?(!n.host&&!n.username||n.pathname?"":"/")+n.pathname.slice(0,n.pathname.lastIndexOf("/")+1)+k:n.pathname);var p=[];k.replace(/^(\.\.?(\/|$))+/,"").replace(/\/(\.(\/|$))+/g,"/").replace(/\/\.\.$/,"/../").replace(/\/?[^\/]*/g,function(a){"/.."===a?p.pop():p.push(a)}),k=p.join("").replace(/^\//,"/"===k[0]?"/":""),o&&(j=n.port,i=n.hostname,h=n.host,g=n.password,f=n.username),e||(e=n.protocol)}"file:"==e&&(k=k.replace(/\\/g,"/")),this.origin=h?e+(""!==e||""!==h?"//":"")+h:"",this.href=e+(e&&h||"file:"==e?"//":"")+(""!==f?f+(""!==g?":"+g:"")+"@":"")+h+k+l+m,this.protocol=e,this.username=f,this.password=g,this.host=h,this.hostname=i,this.port=j,this.pathname=k,this.search=l,this.hash=m}a.URLPolyfill=b}("undefined"!=typeof self?self:global),function(a){function b(a,b){return a instanceof Error?(a.message=b+"\n	"+a.message,Error.call(a,a.message)):a=b+"\n	"+a,a}function c(a,c,d){try{new Function(a).call(d)}catch(e){throw b(e,"Evaluating "+c)}}function d(){}function e(b){this._loader={loaderObj:this,loads:[],modules:{},importPromises:{},moduleRecords:{}},k(this,"global",{get:function(){return a}})}function f(){e.call(this),this.paths={}}function g(a,b){var c,d="",e=0;for(var f in a){var g=f.split("*");if(g.length>2)throw new TypeError("Only one wildcard in a path is permitted");if(1==g.length){if(b==f)return a[f];if(b.substr(0,f.length-1)==f.substr(0,f.length-1)&&(b.length<f.length||b[f.length-1]==f[f.length-1])&&"/"==a[f][a[f].length-1])return a[f].substr(0,a[f].length-1)+(b.length>f.length?"/"+b.substr(f.length):"")}else{var h=g[0].length;h>=e&&b.substr(0,g[0].length)==g[0]&&b.substr(b.length-g[1].length)==g[1]&&(e=h,d=f,c=b.substr(g[0].length,b.length-g[1].length-g[0].length))}}var i=a[d];return"string"==typeof c&&(i=i.replace("*",c)),i}function h(){}var i=("undefined"==typeof window&&"undefined"!=typeof self&&"undefined"!=typeof importScripts,"undefined"!=typeof window&&"undefined"!=typeof document),j="undefined"!=typeof process&&"undefined"!=typeof process.platform&&!!process.platform.match(/^win/);a.console||(a.console={assert:function(){}});var k,l=Array.prototype.indexOf||function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]===a)return b;return-1};!function(){try{Object.defineProperty({},"a",{})&&(k=Object.defineProperty)}catch(a){k=function(a,b,c){try{a[b]=c.value||c.get.call(a)}catch(d){}}}}();var m;if("undefined"!=typeof document&&document.getElementsByTagName){if(m=document.baseURI,!m){var n=document.getElementsByTagName("base");m=n[0]&&n[0].href||window.location.href}m=m.split("#")[0].split("?")[0],m=m.substr(0,m.lastIndexOf("/")+1)}else if("undefined"!=typeof process&&process.cwd)m="file://"+(j?"/":"")+process.cwd()+"/",j&&(m=m.replace(/\\/g,"/"));else{if("undefined"==typeof location)throw new TypeError("No environment baseURI");m=a.location.href}var o=a.URLPolyfill||a.URL;k(d.prototype,"toString",{value:function(){return"Module"}}),function(){function f(a){return{status:"loading",name:a,linkSets:[],dependencies:[],metadata:{}}}function g(a,b,c){return new Promise(n({step:c.address?"fetch":"locate",loader:a,moduleName:b,moduleMetadata:c&&c.metadata||{},moduleSource:c.source,moduleAddress:c.address}))}function h(a,b,c,d){return new Promise(function(e,f){e(a.loaderObj.normalize(b,c,d))}).then(function(b){var c;if(a.modules[b])return c=f(b),c.status="linked",c.module=a.modules[b],c;for(var d=0,e=a.loads.length;e>d;d++)if(c=a.loads[d],c.name==b)return c;return c=f(b),a.loads.push(c),i(a,c),c})}function i(a,b){j(a,b,Promise.resolve().then(function(){return a.loaderObj.locate({name:b.name,metadata:b.metadata})}))}function j(a,b,c){m(a,b,c.then(function(c){return"loading"==b.status?(b.address=c,a.loaderObj.fetch({name:b.name,metadata:b.metadata,address:c})):void 0}))}function m(b,d,e){e.then(function(e){return"loading"==d.status?Promise.resolve(b.loaderObj.translate({name:d.name,metadata:d.metadata,address:d.address,source:e})).then(function(a){return d.source=a,b.loaderObj.instantiate({name:d.name,metadata:d.metadata,address:d.address,source:a})}).then(function(e){if(void 0===e)return d.address=d.address||"<Anonymous Module "+ ++F+">",d.isDeclarative=!0,q.call(b.loaderObj,d).then(function(b){var e=a.System,f=e.register;e.register=function(a,b,c){"string"!=typeof a&&(c=b,b=a),d.declare=c,d.depsList=b},c(b,d.address,{}),e.register=f});if("object"!=typeof e)throw TypeError("Invalid instantiate return value");d.depsList=e.deps||[],d.execute=e.execute,d.isDeclarative=!1}).then(function(){d.dependencies=[];for(var a=d.depsList,c=[],e=0,f=a.length;f>e;e++)(function(a,e){c.push(h(b,a,d.name,d.address).then(function(b){if(d.dependencies[e]={key:a,value:b.name},"linked"!=b.status)for(var c=d.linkSets.concat([]),f=0,g=c.length;g>f;f++)p(c[f],b)}))})(a[e],e);return Promise.all(c)}).then(function(){d.status="loaded";for(var a=d.linkSets.concat([]),b=0,c=a.length;c>b;b++)s(a[b],d)}):void 0})["catch"](function(a){d.status="failed",d.exception=a;for(var b=d.linkSets.concat([]),c=0,e=b.length;e>c;c++)t(b[c],d,a)})}function n(a){return function(b,c){var d=a.loader,e=a.moduleName,g=a.step;if(d.modules[e])throw new TypeError('"'+e+'" already exists in the module table');for(var h,k=0,l=d.loads.length;l>k;k++)if(d.loads[k].name==e&&(h=d.loads[k],"translate"!=g||h.source||(h.address=a.moduleAddress,m(d,h,Promise.resolve(a.moduleSource))),h.linkSets.length&&h.linkSets[0].loads[0].name==h.name))return h.linkSets[0].done.then(function(){b(h)});var n=h||f(e);n.metadata=a.moduleMetadata;var p=o(d,n);d.loads.push(n),b(p.done),"locate"==g?i(d,n):"fetch"==g?j(d,n,Promise.resolve(a.moduleAddress)):(n.address=a.moduleAddress,m(d,n,Promise.resolve(a.moduleSource)))}}function o(a,b){var c={loader:a,loads:[],startingLoad:b,loadingCount:0};return c.done=new Promise(function(a,b){c.resolve=a,c.reject=b}),p(c,b),c}function p(a,b){if("failed"!=b.status){for(var c=0,d=a.loads.length;d>c;c++)if(a.loads[c]==b)return;a.loads.push(b),b.linkSets.push(a),"loaded"!=b.status&&a.loadingCount++;for(var e=a.loader,c=0,d=b.dependencies.length;d>c;c++)if(b.dependencies[c]){var f=b.dependencies[c].value;if(!e.modules[f])for(var g=0,h=e.loads.length;h>g;g++)if(e.loads[g].name==f){p(a,e.loads[g]);break}}}}function r(a){var b=!1;try{y(a,function(c,d){t(a,c,d),b=!0})}catch(c){t(a,null,c),b=!0}return b}function s(a,b){if(a.loadingCount--,!(a.loadingCount>0)){var c=a.startingLoad;if(a.loader.loaderObj.execute===!1){for(var d=[].concat(a.loads),e=0,f=d.length;f>e;e++){var b=d[e];b.module=b.isDeclarative?{name:b.name,module:G({}),evaluated:!0}:{module:G({})},b.status="linked",u(a.loader,b)}return a.resolve(c)}var g=r(a);g||a.resolve(c)}}function t(a,c,d){var e=a.loader;a:if(c)if(a.loads[0].name==c.name)d=b(d,"Error loading "+c.name);else{for(var f=0;f<a.loads.length;f++)for(var g=a.loads[f],h=0;h<g.dependencies.length;h++){var i=g.dependencies[h];if(i.value==c.name){d=b(d,"Error loading "+c.name+' as "'+i.key+'" from '+g.name);break a}}d=b(d,"Error loading "+c.name+" from "+a.loads[0].name)}else d=b(d,"Error linking "+a.loads[0].name);for(var j=a.loads.concat([]),f=0,k=j.length;k>f;f++){var c=j[f];e.loaderObj.failed=e.loaderObj.failed||[],-1==l.call(e.loaderObj.failed,c)&&e.loaderObj.failed.push(c);var m=l.call(c.linkSets,a);if(c.linkSets.splice(m,1),0==c.linkSets.length){var n=l.call(a.loader.loads,c);-1!=n&&a.loader.loads.splice(n,1)}}a.reject(d)}function u(a,b){if(a.loaderObj.trace){a.loaderObj.loads||(a.loaderObj.loads={});var c={};b.dependencies.forEach(function(a){c[a.key]=a.value}),a.loaderObj.loads[b.name]={name:b.name,deps:b.dependencies.map(function(a){return a.key}),depMap:c,address:b.address,metadata:b.metadata,source:b.source,kind:b.isDeclarative?"declarative":"dynamic"}}b.name&&(a.modules[b.name]=b.module);var d=l.call(a.loads,b);-1!=d&&a.loads.splice(d,1);for(var e=0,f=b.linkSets.length;f>e;e++)d=l.call(b.linkSets[e].loads,b),-1!=d&&b.linkSets[e].loads.splice(d,1);b.linkSets.splice(0,b.linkSets.length)}function v(a,b,c){try{var e=b.execute()}catch(f){return void c(b,f)}return e&&e instanceof d?e:void c(b,new TypeError("Execution must define a Module instance"))}function w(a,b,c){var d=a._loader.importPromises;return d[b]=c.then(function(a){return d[b]=void 0,a},function(a){throw d[b]=void 0,a})}function x(a,b,c){if(c[a.groupIndex]=c[a.groupIndex]||[],-1==l.call(c[a.groupIndex],a)){c[a.groupIndex].push(a);for(var d=0,e=b.length;e>d;d++)for(var f=b[d],g=0;g<a.dependencies.length;g++)if(f.name==a.dependencies[g].value){var h=a.groupIndex+(f.isDeclarative!=a.isDeclarative);if(void 0===f.groupIndex||f.groupIndex<h){if(void 0!==f.groupIndex&&(c[f.groupIndex].splice(l.call(c[f.groupIndex],f),1),0==c[f.groupIndex].length))throw new TypeError("Mixed dependency cycle detected");f.groupIndex=h}x(f,b,c)}}}function y(a,b){var c=a.loader;if(a.loads.length){var d=[],e=a.loads[0];e.groupIndex=0,x(e,a.loads,d);for(var f=e.isDeclarative==d.length%2,g=d.length-1;g>=0;g--){for(var h=d[g],i=0;i<h.length;i++){var j=h[i];if(f)A(j,a.loads,c);else{var k=v(a,j,b);if(!k)return;j.module={name:j.name,module:k},j.status="linked"}u(c,j)}f=!f}}}function z(a,b){var c=b.moduleRecords;return c[a]||(c[a]={name:a,dependencies:[],module:new d,importers:[]})}function A(b,c,d){if(!b.module){var e=b.module=z(b.name,d),f=b.module.module,g=b.declare.call(a,function(a,b){if(e.locked=!0,"object"==typeof a)for(var c in a)f[c]=a[c];else f[a]=b;for(var d=0,g=e.importers.length;g>d;d++){var h=e.importers[d];if(!h.locked)for(var i=0;i<h.dependencies.length;++i)h.dependencies[i]===e&&h.setters[i](f)}return e.locked=!1,b},{id:b.name});e.setters=g.setters,e.execute=g.execute;for(var h=0,i=b.dependencies.length;i>h;h++){var j=b.dependencies[h].value,k=d.modules[j];if(!k)for(var l=0;l<c.length;l++)c[l].name==j&&(c[l].module?k=z(j,d):(A(c[l],c,d),k=c[l].module));k.importers?(e.dependencies.push(k),k.importers.push(e)):e.dependencies.push(null),e.setters[h]&&e.setters[h](k.module)}b.status="linked"}}function B(b){try{b.execute.call(a)}catch(c){return c}}function C(a,b){return D(b.module,[],a),b.module.module}function D(a,b,c){var d=E(a,b,c);if(d)throw d}function E(a,c,d){if(!a.evaluated&&a.dependencies){c.push(a);for(var e,f=a.dependencies,g=0,h=f.length;h>g;g++){var i=f[g];if(i&&-1==l.call(c,i)&&(e=E(i,c,d)))return e=b(e,"Error evaluating "+i.name)}if(a.failed)return new Error("Module failed execution.");if(!a.evaluated)return a.evaluated=!0,e=B(a),e?a.failed=!0:Object.preventExtensions&&Object.preventExtensions(a.module),a.execute=void 0,e}}var F=0;e.prototype={constructor:e,define:function(a,b,c){if(this._loader.importPromises[a])throw new TypeError("Module is already loading.");return w(this,a,new Promise(n({step:"translate",loader:this._loader,moduleName:a,moduleMetadata:c&&c.metadata||{},moduleSource:b,moduleAddress:c&&c.address})))},"delete":function(a){var b=this._loader;return delete b.importPromises[a],delete b.moduleRecords[a],b.modules[a]?delete b.modules[a]:!1},get:function(a){return this._loader.modules[a]?(D(this._loader.modules[a],[],this),this._loader.modules[a].module):void 0},has:function(a){return!!this._loader.modules[a]},"import":function(a,b,c){"object"==typeof b&&(b=b.name);var d=this;return Promise.resolve(d.normalize(a,b)).then(function(a){var b=d._loader;return b.modules[a]?(D(b.modules[a],[],b._loader),b.modules[a].module):b.importPromises[a]||w(d,a,g(b,a,{}).then(function(c){return delete b.importPromises[a],C(b,c)}))})},load:function(a){var b=this._loader;return b.modules[a]?Promise.resolve():b.importPromises[a]||w(this,a,new Promise(n({step:"locate",loader:b,moduleName:a,moduleMetadata:{},moduleSource:void 0,moduleAddress:void 0})).then(function(){delete b.importPromises[a]}))},module:function(a,b){var c=f();c.address=b&&b.address;var d=o(this._loader,c),e=Promise.resolve(a),g=this._loader,h=d.done.then(function(){return C(g,c)});return m(g,c,e),h},newModule:function(a){if("object"!=typeof a)throw new TypeError("Expected object");var b=new d,c=[];if(Object.getOwnPropertyNames&&null!=a)c=Object.getOwnPropertyNames(a);else for(var e in a)c.push(e);for(var f=0;f<c.length;f++)(function(c){k(b,c,{configurable:!1,enumerable:!0,get:function(){return a[c]},set:function(){throw new Error("Module exports cannot be changed externally.")}})})(c[f]);return Object.freeze&&Object.freeze(b),b},set:function(a,b){if(!(b instanceof d))throw new TypeError("Loader.set("+a+", module) must be a module");this._loader.modules[a]={module:b}},normalize:function(a,b,c){return a},locate:function(a){return a.name},fetch:function(a){},translate:function(a){return a.source},instantiate:function(a){}};var G=e.prototype.newModule}();var p,q=function(){function b(b){var d=this;return Promise.resolve(a["typescript"==d.transpiler?"ts":d.transpiler]||(d.pluginLoader||d)["import"](d.transpiler)).then(function(a){a.__useDefault&&(a=a["default"]);var e;return e=a.Compiler?c:a.createLanguageService?g:f,"(function(__moduleName){"+e.call(d,b,a)+'\n})("'+b.name+'");\n//# sourceURL='+b.address+"!transpiled"})}function c(a,b){var c=this.traceurOptions||{};c.modules="instantiate",c.script=!1,void 0===c.sourceMaps&&(c.sourceMaps="inline"),c.filename=a.address,c.inputSourceMap=a.metadata.sourceMap,c.moduleName=!1;var e=new b.Compiler(c);return d(a.source,e,c.filename)}function d(a,b,c){try{return b.compile(a,c)}catch(d){if(d.length)throw d[0];throw d}}function f(a,b){var c=this.babelOptions||{};return c.modules="system",void 0===c.sourceMap&&(c.sourceMap="inline"),c.inputSourceMap=a.metadata.sourceMap,c.filename=a.address,c.code=!0,c.ast=!1,b.transform(a.source,c).code}function g(a,b){var c=this.typescriptOptions||{};return c.target=c.target||b.ScriptTarget.ES5,void 0===c.sourceMap&&(c.sourceMap=!0),c.sourceMap&&c.inlineSourceMap!==!1&&(c.inlineSourceMap=!0),c.module=b.ModuleKind.System,b.transpile(a.source,c,a.address)}return e.prototype.transpiler="traceur",b}();h.prototype=e.prototype,f.prototype=new h;var r=/^([^\/]+:\/\/|\/)/;f.prototype.normalize=function(a,b,c){return a=a.match(r)||"."==a[0]?new o(a,b||m).href:new o(g(this.paths,a)||a,m).href},f.prototype.locate=function(a){return a.name},f.prototype.instantiate=function(b){var d=this;return Promise.resolve(d.normalize(d.transpiler)).then(function(e){return b.address===e?{deps:[],execute:function(){var e=a.System,f=a.Reflect.Loader;return c("(function(require,exports,module){"+b.source+"})();",b.address,a),a.System=e,a.Reflect.Loader=f,d.newModule({"default":a[d.transpiler],__useDefault:!0})}}:void 0})};var s;if("undefined"!=typeof XMLHttpRequest)s=function(a,b,c,d){function e(){c(g.responseText)}function f(){d(new Error("XHR error"+(g.status?" ("+g.status+(g.statusText?" "+g.statusText:"")+")":"")+" loading "+a))}var g=new XMLHttpRequest,h=!0,i=!1;if(!("withCredentials"in g)){var j=/^(\w+:)?\/\/([^\/]+)/.exec(a);j&&(h=j[2]===window.location.host,j[1]&&(h&=j[1]===window.location.protocol))}h||"undefined"==typeof XDomainRequest||(g=new XDomainRequest,g.onload=e,g.onerror=f,g.ontimeout=f,g.onprogress=function(){},g.timeout=0,i=!0),g.onreadystatechange=function(){4===g.readyState&&(0==g.status?g.responseText?e():(g.addEventListener("error",f),g.addEventListener("load",e)):200===g.status?e():f())},g.open("GET",a,!0),g.setRequestHeader&&(g.setRequestHeader("Accept","application/x-es-module, */*"),b&&("string"==typeof b&&g.setRequestHeader("Authorization",b),g.withCredentials=!0)),i?setTimeout(function(){g.send()},0):g.send(null)};else if("undefined"!=typeof require&&"undefined"!=typeof process){var t;s=function(a,b,c,d){if("file:///"!=a.substr(0,8))throw new Error('Unable to fetch "'+a+'". Only file URLs of the form file:/// allowed running in Node.');return t=t||require("fs"),a=j?a.replace(/\//g,"\\").substr(8):a.substr(7),t.readFile(a,function(a,b){if(a)return d(a);var e=b+"";"\ufeff"===e[0]&&(e=e.substr(1)),c(e)})}}else{if("undefined"==typeof self||"undefined"==typeof self.fetch)throw new TypeError("No environment fetch API available.");s=function(a,b,c,d){var e={headers:{Accept:"application/x-es-module, */*"}};b&&("string"==typeof b&&(e.headers.Authorization=b),e.credentials="include"),fetch(a,e).then(function(a){if(a.ok)return a.text();throw new Error("Fetch error: "+a.status+" "+a.statusText)}).then(c,d)}}f.prototype.fetch=function(a){return new Promise(function(b,c){s(a.address,void 0,b,c)})},function(){function a(){document.removeEventListener("DOMContentLoaded",a,!1),window.removeEventListener("load",a,!1),b()}function b(){for(var a=document.getElementsByTagName("script"),b=0;b<a.length;b++){var c=a[b];if("module"==c.type){var d=c.innerHTML.substr(1);p.module(d)["catch"](function(a){setTimeout(function(){throw a})})}}}if(i&&"undefined"!=typeof document.getElementsByTagName){var c=document.getElementsByTagName("script");c=c[c.length-1],"complete"===document.readyState?setTimeout(b):document.addEventListener&&(document.addEventListener("DOMContentLoaded",a,!1),window.addEventListener("load",a,!1))}}(),"object"==typeof exports&&(module.exports=e),a.Reflect=a.Reflect||{},a.Reflect.Loader=a.Reflect.Loader||e,a.Reflect.global=a.Reflect.global||a,a.LoaderPolyfill=e,p||(p=new f,p.constructor=f),"object"==typeof exports&&(module.exports=p),a.System=p}("undefined"!=typeof self?self:global);
diff --git a/vendor/golang.org/x/tools/third_party/typescript/LICENSE b/vendor/golang.org/x/tools/third_party/typescript/LICENSE
new file mode 100644
index 0000000..e7259f8
--- /dev/null
+++ b/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/vendor/golang.org/x/tools/third_party/typescript/typescript.js b/vendor/golang.org/x/tools/third_party/typescript/typescript.js
new file mode 100644
index 0000000..3b28d8f
--- /dev/null
+++ b/vendor/golang.org/x/tools/third_party/typescript/typescript.js
@@ -0,0 +1,60312 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var ts;
+(function (ts) {
+    // token > SyntaxKind.Identifer => token is a keyword
+    // Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync
+    (function (SyntaxKind) {
+        SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown";
+        SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken";
+        SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia";
+        SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia";
+        SyntaxKind[SyntaxKind["NewLineTrivia"] = 4] = "NewLineTrivia";
+        SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 5] = "WhitespaceTrivia";
+        // We detect and preserve #! on the first line
+        SyntaxKind[SyntaxKind["ShebangTrivia"] = 6] = "ShebangTrivia";
+        // We detect and provide better error recovery when we encounter a git merge marker.  This
+        // allows us to edit files with git-conflict markers in them in a much more pleasant manner.
+        SyntaxKind[SyntaxKind["ConflictMarkerTrivia"] = 7] = "ConflictMarkerTrivia";
+        // Literals
+        SyntaxKind[SyntaxKind["NumericLiteral"] = 8] = "NumericLiteral";
+        SyntaxKind[SyntaxKind["StringLiteral"] = 9] = "StringLiteral";
+        SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 10] = "RegularExpressionLiteral";
+        SyntaxKind[SyntaxKind["NoSubstitutionTemplateLiteral"] = 11] = "NoSubstitutionTemplateLiteral";
+        // Pseudo-literals
+        SyntaxKind[SyntaxKind["TemplateHead"] = 12] = "TemplateHead";
+        SyntaxKind[SyntaxKind["TemplateMiddle"] = 13] = "TemplateMiddle";
+        SyntaxKind[SyntaxKind["TemplateTail"] = 14] = "TemplateTail";
+        // Punctuation
+        SyntaxKind[SyntaxKind["OpenBraceToken"] = 15] = "OpenBraceToken";
+        SyntaxKind[SyntaxKind["CloseBraceToken"] = 16] = "CloseBraceToken";
+        SyntaxKind[SyntaxKind["OpenParenToken"] = 17] = "OpenParenToken";
+        SyntaxKind[SyntaxKind["CloseParenToken"] = 18] = "CloseParenToken";
+        SyntaxKind[SyntaxKind["OpenBracketToken"] = 19] = "OpenBracketToken";
+        SyntaxKind[SyntaxKind["CloseBracketToken"] = 20] = "CloseBracketToken";
+        SyntaxKind[SyntaxKind["DotToken"] = 21] = "DotToken";
+        SyntaxKind[SyntaxKind["DotDotDotToken"] = 22] = "DotDotDotToken";
+        SyntaxKind[SyntaxKind["SemicolonToken"] = 23] = "SemicolonToken";
+        SyntaxKind[SyntaxKind["CommaToken"] = 24] = "CommaToken";
+        SyntaxKind[SyntaxKind["LessThanToken"] = 25] = "LessThanToken";
+        SyntaxKind[SyntaxKind["LessThanSlashToken"] = 26] = "LessThanSlashToken";
+        SyntaxKind[SyntaxKind["GreaterThanToken"] = 27] = "GreaterThanToken";
+        SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 28] = "LessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 29] = "GreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 30] = "EqualsEqualsToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 31] = "ExclamationEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 32] = "EqualsEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 33] = "ExclamationEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 34] = "EqualsGreaterThanToken";
+        SyntaxKind[SyntaxKind["PlusToken"] = 35] = "PlusToken";
+        SyntaxKind[SyntaxKind["MinusToken"] = 36] = "MinusToken";
+        SyntaxKind[SyntaxKind["AsteriskToken"] = 37] = "AsteriskToken";
+        SyntaxKind[SyntaxKind["AsteriskAsteriskToken"] = 38] = "AsteriskAsteriskToken";
+        SyntaxKind[SyntaxKind["SlashToken"] = 39] = "SlashToken";
+        SyntaxKind[SyntaxKind["PercentToken"] = 40] = "PercentToken";
+        SyntaxKind[SyntaxKind["PlusPlusToken"] = 41] = "PlusPlusToken";
+        SyntaxKind[SyntaxKind["MinusMinusToken"] = 42] = "MinusMinusToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 43] = "LessThanLessThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 44] = "GreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 45] = "GreaterThanGreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["AmpersandToken"] = 46] = "AmpersandToken";
+        SyntaxKind[SyntaxKind["BarToken"] = 47] = "BarToken";
+        SyntaxKind[SyntaxKind["CaretToken"] = 48] = "CaretToken";
+        SyntaxKind[SyntaxKind["ExclamationToken"] = 49] = "ExclamationToken";
+        SyntaxKind[SyntaxKind["TildeToken"] = 50] = "TildeToken";
+        SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 51] = "AmpersandAmpersandToken";
+        SyntaxKind[SyntaxKind["BarBarToken"] = 52] = "BarBarToken";
+        SyntaxKind[SyntaxKind["QuestionToken"] = 53] = "QuestionToken";
+        SyntaxKind[SyntaxKind["ColonToken"] = 54] = "ColonToken";
+        SyntaxKind[SyntaxKind["AtToken"] = 55] = "AtToken";
+        // Assignments
+        SyntaxKind[SyntaxKind["EqualsToken"] = 56] = "EqualsToken";
+        SyntaxKind[SyntaxKind["PlusEqualsToken"] = 57] = "PlusEqualsToken";
+        SyntaxKind[SyntaxKind["MinusEqualsToken"] = 58] = "MinusEqualsToken";
+        SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 59] = "AsteriskEqualsToken";
+        SyntaxKind[SyntaxKind["AsteriskAsteriskEqualsToken"] = 60] = "AsteriskAsteriskEqualsToken";
+        SyntaxKind[SyntaxKind["SlashEqualsToken"] = 61] = "SlashEqualsToken";
+        SyntaxKind[SyntaxKind["PercentEqualsToken"] = 62] = "PercentEqualsToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 63] = "LessThanLessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 64] = "GreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 65] = "GreaterThanGreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 66] = "AmpersandEqualsToken";
+        SyntaxKind[SyntaxKind["BarEqualsToken"] = 67] = "BarEqualsToken";
+        SyntaxKind[SyntaxKind["CaretEqualsToken"] = 68] = "CaretEqualsToken";
+        // Identifiers
+        SyntaxKind[SyntaxKind["Identifier"] = 69] = "Identifier";
+        // Reserved words
+        SyntaxKind[SyntaxKind["BreakKeyword"] = 70] = "BreakKeyword";
+        SyntaxKind[SyntaxKind["CaseKeyword"] = 71] = "CaseKeyword";
+        SyntaxKind[SyntaxKind["CatchKeyword"] = 72] = "CatchKeyword";
+        SyntaxKind[SyntaxKind["ClassKeyword"] = 73] = "ClassKeyword";
+        SyntaxKind[SyntaxKind["ConstKeyword"] = 74] = "ConstKeyword";
+        SyntaxKind[SyntaxKind["ContinueKeyword"] = 75] = "ContinueKeyword";
+        SyntaxKind[SyntaxKind["DebuggerKeyword"] = 76] = "DebuggerKeyword";
+        SyntaxKind[SyntaxKind["DefaultKeyword"] = 77] = "DefaultKeyword";
+        SyntaxKind[SyntaxKind["DeleteKeyword"] = 78] = "DeleteKeyword";
+        SyntaxKind[SyntaxKind["DoKeyword"] = 79] = "DoKeyword";
+        SyntaxKind[SyntaxKind["ElseKeyword"] = 80] = "ElseKeyword";
+        SyntaxKind[SyntaxKind["EnumKeyword"] = 81] = "EnumKeyword";
+        SyntaxKind[SyntaxKind["ExportKeyword"] = 82] = "ExportKeyword";
+        SyntaxKind[SyntaxKind["ExtendsKeyword"] = 83] = "ExtendsKeyword";
+        SyntaxKind[SyntaxKind["FalseKeyword"] = 84] = "FalseKeyword";
+        SyntaxKind[SyntaxKind["FinallyKeyword"] = 85] = "FinallyKeyword";
+        SyntaxKind[SyntaxKind["ForKeyword"] = 86] = "ForKeyword";
+        SyntaxKind[SyntaxKind["FunctionKeyword"] = 87] = "FunctionKeyword";
+        SyntaxKind[SyntaxKind["IfKeyword"] = 88] = "IfKeyword";
+        SyntaxKind[SyntaxKind["ImportKeyword"] = 89] = "ImportKeyword";
+        SyntaxKind[SyntaxKind["InKeyword"] = 90] = "InKeyword";
+        SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 91] = "InstanceOfKeyword";
+        SyntaxKind[SyntaxKind["NewKeyword"] = 92] = "NewKeyword";
+        SyntaxKind[SyntaxKind["NullKeyword"] = 93] = "NullKeyword";
+        SyntaxKind[SyntaxKind["ReturnKeyword"] = 94] = "ReturnKeyword";
+        SyntaxKind[SyntaxKind["SuperKeyword"] = 95] = "SuperKeyword";
+        SyntaxKind[SyntaxKind["SwitchKeyword"] = 96] = "SwitchKeyword";
+        SyntaxKind[SyntaxKind["ThisKeyword"] = 97] = "ThisKeyword";
+        SyntaxKind[SyntaxKind["ThrowKeyword"] = 98] = "ThrowKeyword";
+        SyntaxKind[SyntaxKind["TrueKeyword"] = 99] = "TrueKeyword";
+        SyntaxKind[SyntaxKind["TryKeyword"] = 100] = "TryKeyword";
+        SyntaxKind[SyntaxKind["TypeOfKeyword"] = 101] = "TypeOfKeyword";
+        SyntaxKind[SyntaxKind["VarKeyword"] = 102] = "VarKeyword";
+        SyntaxKind[SyntaxKind["VoidKeyword"] = 103] = "VoidKeyword";
+        SyntaxKind[SyntaxKind["WhileKeyword"] = 104] = "WhileKeyword";
+        SyntaxKind[SyntaxKind["WithKeyword"] = 105] = "WithKeyword";
+        // Strict mode reserved words
+        SyntaxKind[SyntaxKind["ImplementsKeyword"] = 106] = "ImplementsKeyword";
+        SyntaxKind[SyntaxKind["InterfaceKeyword"] = 107] = "InterfaceKeyword";
+        SyntaxKind[SyntaxKind["LetKeyword"] = 108] = "LetKeyword";
+        SyntaxKind[SyntaxKind["PackageKeyword"] = 109] = "PackageKeyword";
+        SyntaxKind[SyntaxKind["PrivateKeyword"] = 110] = "PrivateKeyword";
+        SyntaxKind[SyntaxKind["ProtectedKeyword"] = 111] = "ProtectedKeyword";
+        SyntaxKind[SyntaxKind["PublicKeyword"] = 112] = "PublicKeyword";
+        SyntaxKind[SyntaxKind["StaticKeyword"] = 113] = "StaticKeyword";
+        SyntaxKind[SyntaxKind["YieldKeyword"] = 114] = "YieldKeyword";
+        // Contextual keywords
+        SyntaxKind[SyntaxKind["AbstractKeyword"] = 115] = "AbstractKeyword";
+        SyntaxKind[SyntaxKind["AsKeyword"] = 116] = "AsKeyword";
+        SyntaxKind[SyntaxKind["AnyKeyword"] = 117] = "AnyKeyword";
+        SyntaxKind[SyntaxKind["AsyncKeyword"] = 118] = "AsyncKeyword";
+        SyntaxKind[SyntaxKind["AwaitKeyword"] = 119] = "AwaitKeyword";
+        SyntaxKind[SyntaxKind["BooleanKeyword"] = 120] = "BooleanKeyword";
+        SyntaxKind[SyntaxKind["ConstructorKeyword"] = 121] = "ConstructorKeyword";
+        SyntaxKind[SyntaxKind["DeclareKeyword"] = 122] = "DeclareKeyword";
+        SyntaxKind[SyntaxKind["GetKeyword"] = 123] = "GetKeyword";
+        SyntaxKind[SyntaxKind["IsKeyword"] = 124] = "IsKeyword";
+        SyntaxKind[SyntaxKind["ModuleKeyword"] = 125] = "ModuleKeyword";
+        SyntaxKind[SyntaxKind["NamespaceKeyword"] = 126] = "NamespaceKeyword";
+        SyntaxKind[SyntaxKind["NeverKeyword"] = 127] = "NeverKeyword";
+        SyntaxKind[SyntaxKind["ReadonlyKeyword"] = 128] = "ReadonlyKeyword";
+        SyntaxKind[SyntaxKind["RequireKeyword"] = 129] = "RequireKeyword";
+        SyntaxKind[SyntaxKind["NumberKeyword"] = 130] = "NumberKeyword";
+        SyntaxKind[SyntaxKind["SetKeyword"] = 131] = "SetKeyword";
+        SyntaxKind[SyntaxKind["StringKeyword"] = 132] = "StringKeyword";
+        SyntaxKind[SyntaxKind["SymbolKeyword"] = 133] = "SymbolKeyword";
+        SyntaxKind[SyntaxKind["TypeKeyword"] = 134] = "TypeKeyword";
+        SyntaxKind[SyntaxKind["UndefinedKeyword"] = 135] = "UndefinedKeyword";
+        SyntaxKind[SyntaxKind["FromKeyword"] = 136] = "FromKeyword";
+        SyntaxKind[SyntaxKind["GlobalKeyword"] = 137] = "GlobalKeyword";
+        SyntaxKind[SyntaxKind["OfKeyword"] = 138] = "OfKeyword";
+        // Parse tree nodes
+        // Names
+        SyntaxKind[SyntaxKind["QualifiedName"] = 139] = "QualifiedName";
+        SyntaxKind[SyntaxKind["ComputedPropertyName"] = 140] = "ComputedPropertyName";
+        // Signature elements
+        SyntaxKind[SyntaxKind["TypeParameter"] = 141] = "TypeParameter";
+        SyntaxKind[SyntaxKind["Parameter"] = 142] = "Parameter";
+        SyntaxKind[SyntaxKind["Decorator"] = 143] = "Decorator";
+        // TypeMember
+        SyntaxKind[SyntaxKind["PropertySignature"] = 144] = "PropertySignature";
+        SyntaxKind[SyntaxKind["PropertyDeclaration"] = 145] = "PropertyDeclaration";
+        SyntaxKind[SyntaxKind["MethodSignature"] = 146] = "MethodSignature";
+        SyntaxKind[SyntaxKind["MethodDeclaration"] = 147] = "MethodDeclaration";
+        SyntaxKind[SyntaxKind["Constructor"] = 148] = "Constructor";
+        SyntaxKind[SyntaxKind["GetAccessor"] = 149] = "GetAccessor";
+        SyntaxKind[SyntaxKind["SetAccessor"] = 150] = "SetAccessor";
+        SyntaxKind[SyntaxKind["CallSignature"] = 151] = "CallSignature";
+        SyntaxKind[SyntaxKind["ConstructSignature"] = 152] = "ConstructSignature";
+        SyntaxKind[SyntaxKind["IndexSignature"] = 153] = "IndexSignature";
+        // Type
+        SyntaxKind[SyntaxKind["TypePredicate"] = 154] = "TypePredicate";
+        SyntaxKind[SyntaxKind["TypeReference"] = 155] = "TypeReference";
+        SyntaxKind[SyntaxKind["FunctionType"] = 156] = "FunctionType";
+        SyntaxKind[SyntaxKind["ConstructorType"] = 157] = "ConstructorType";
+        SyntaxKind[SyntaxKind["TypeQuery"] = 158] = "TypeQuery";
+        SyntaxKind[SyntaxKind["TypeLiteral"] = 159] = "TypeLiteral";
+        SyntaxKind[SyntaxKind["ArrayType"] = 160] = "ArrayType";
+        SyntaxKind[SyntaxKind["TupleType"] = 161] = "TupleType";
+        SyntaxKind[SyntaxKind["UnionType"] = 162] = "UnionType";
+        SyntaxKind[SyntaxKind["IntersectionType"] = 163] = "IntersectionType";
+        SyntaxKind[SyntaxKind["ParenthesizedType"] = 164] = "ParenthesizedType";
+        SyntaxKind[SyntaxKind["ThisType"] = 165] = "ThisType";
+        SyntaxKind[SyntaxKind["StringLiteralType"] = 166] = "StringLiteralType";
+        // Binding patterns
+        SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 167] = "ObjectBindingPattern";
+        SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 168] = "ArrayBindingPattern";
+        SyntaxKind[SyntaxKind["BindingElement"] = 169] = "BindingElement";
+        // Expression
+        SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 170] = "ArrayLiteralExpression";
+        SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 171] = "ObjectLiteralExpression";
+        SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 172] = "PropertyAccessExpression";
+        SyntaxKind[SyntaxKind["ElementAccessExpression"] = 173] = "ElementAccessExpression";
+        SyntaxKind[SyntaxKind["CallExpression"] = 174] = "CallExpression";
+        SyntaxKind[SyntaxKind["NewExpression"] = 175] = "NewExpression";
+        SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 176] = "TaggedTemplateExpression";
+        SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 177] = "TypeAssertionExpression";
+        SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 178] = "ParenthesizedExpression";
+        SyntaxKind[SyntaxKind["FunctionExpression"] = 179] = "FunctionExpression";
+        SyntaxKind[SyntaxKind["ArrowFunction"] = 180] = "ArrowFunction";
+        SyntaxKind[SyntaxKind["DeleteExpression"] = 181] = "DeleteExpression";
+        SyntaxKind[SyntaxKind["TypeOfExpression"] = 182] = "TypeOfExpression";
+        SyntaxKind[SyntaxKind["VoidExpression"] = 183] = "VoidExpression";
+        SyntaxKind[SyntaxKind["AwaitExpression"] = 184] = "AwaitExpression";
+        SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 185] = "PrefixUnaryExpression";
+        SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 186] = "PostfixUnaryExpression";
+        SyntaxKind[SyntaxKind["BinaryExpression"] = 187] = "BinaryExpression";
+        SyntaxKind[SyntaxKind["ConditionalExpression"] = 188] = "ConditionalExpression";
+        SyntaxKind[SyntaxKind["TemplateExpression"] = 189] = "TemplateExpression";
+        SyntaxKind[SyntaxKind["YieldExpression"] = 190] = "YieldExpression";
+        SyntaxKind[SyntaxKind["SpreadElementExpression"] = 191] = "SpreadElementExpression";
+        SyntaxKind[SyntaxKind["ClassExpression"] = 192] = "ClassExpression";
+        SyntaxKind[SyntaxKind["OmittedExpression"] = 193] = "OmittedExpression";
+        SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 194] = "ExpressionWithTypeArguments";
+        SyntaxKind[SyntaxKind["AsExpression"] = 195] = "AsExpression";
+        SyntaxKind[SyntaxKind["NonNullExpression"] = 196] = "NonNullExpression";
+        // Misc
+        SyntaxKind[SyntaxKind["TemplateSpan"] = 197] = "TemplateSpan";
+        SyntaxKind[SyntaxKind["SemicolonClassElement"] = 198] = "SemicolonClassElement";
+        // Element
+        SyntaxKind[SyntaxKind["Block"] = 199] = "Block";
+        SyntaxKind[SyntaxKind["VariableStatement"] = 200] = "VariableStatement";
+        SyntaxKind[SyntaxKind["EmptyStatement"] = 201] = "EmptyStatement";
+        SyntaxKind[SyntaxKind["ExpressionStatement"] = 202] = "ExpressionStatement";
+        SyntaxKind[SyntaxKind["IfStatement"] = 203] = "IfStatement";
+        SyntaxKind[SyntaxKind["DoStatement"] = 204] = "DoStatement";
+        SyntaxKind[SyntaxKind["WhileStatement"] = 205] = "WhileStatement";
+        SyntaxKind[SyntaxKind["ForStatement"] = 206] = "ForStatement";
+        SyntaxKind[SyntaxKind["ForInStatement"] = 207] = "ForInStatement";
+        SyntaxKind[SyntaxKind["ForOfStatement"] = 208] = "ForOfStatement";
+        SyntaxKind[SyntaxKind["ContinueStatement"] = 209] = "ContinueStatement";
+        SyntaxKind[SyntaxKind["BreakStatement"] = 210] = "BreakStatement";
+        SyntaxKind[SyntaxKind["ReturnStatement"] = 211] = "ReturnStatement";
+        SyntaxKind[SyntaxKind["WithStatement"] = 212] = "WithStatement";
+        SyntaxKind[SyntaxKind["SwitchStatement"] = 213] = "SwitchStatement";
+        SyntaxKind[SyntaxKind["LabeledStatement"] = 214] = "LabeledStatement";
+        SyntaxKind[SyntaxKind["ThrowStatement"] = 215] = "ThrowStatement";
+        SyntaxKind[SyntaxKind["TryStatement"] = 216] = "TryStatement";
+        SyntaxKind[SyntaxKind["DebuggerStatement"] = 217] = "DebuggerStatement";
+        SyntaxKind[SyntaxKind["VariableDeclaration"] = 218] = "VariableDeclaration";
+        SyntaxKind[SyntaxKind["VariableDeclarationList"] = 219] = "VariableDeclarationList";
+        SyntaxKind[SyntaxKind["FunctionDeclaration"] = 220] = "FunctionDeclaration";
+        SyntaxKind[SyntaxKind["ClassDeclaration"] = 221] = "ClassDeclaration";
+        SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 222] = "InterfaceDeclaration";
+        SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 223] = "TypeAliasDeclaration";
+        SyntaxKind[SyntaxKind["EnumDeclaration"] = 224] = "EnumDeclaration";
+        SyntaxKind[SyntaxKind["ModuleDeclaration"] = 225] = "ModuleDeclaration";
+        SyntaxKind[SyntaxKind["ModuleBlock"] = 226] = "ModuleBlock";
+        SyntaxKind[SyntaxKind["CaseBlock"] = 227] = "CaseBlock";
+        SyntaxKind[SyntaxKind["NamespaceExportDeclaration"] = 228] = "NamespaceExportDeclaration";
+        SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 229] = "ImportEqualsDeclaration";
+        SyntaxKind[SyntaxKind["ImportDeclaration"] = 230] = "ImportDeclaration";
+        SyntaxKind[SyntaxKind["ImportClause"] = 231] = "ImportClause";
+        SyntaxKind[SyntaxKind["NamespaceImport"] = 232] = "NamespaceImport";
+        SyntaxKind[SyntaxKind["NamedImports"] = 233] = "NamedImports";
+        SyntaxKind[SyntaxKind["ImportSpecifier"] = 234] = "ImportSpecifier";
+        SyntaxKind[SyntaxKind["ExportAssignment"] = 235] = "ExportAssignment";
+        SyntaxKind[SyntaxKind["ExportDeclaration"] = 236] = "ExportDeclaration";
+        SyntaxKind[SyntaxKind["NamedExports"] = 237] = "NamedExports";
+        SyntaxKind[SyntaxKind["ExportSpecifier"] = 238] = "ExportSpecifier";
+        SyntaxKind[SyntaxKind["MissingDeclaration"] = 239] = "MissingDeclaration";
+        // Module references
+        SyntaxKind[SyntaxKind["ExternalModuleReference"] = 240] = "ExternalModuleReference";
+        // JSX
+        SyntaxKind[SyntaxKind["JsxElement"] = 241] = "JsxElement";
+        SyntaxKind[SyntaxKind["JsxSelfClosingElement"] = 242] = "JsxSelfClosingElement";
+        SyntaxKind[SyntaxKind["JsxOpeningElement"] = 243] = "JsxOpeningElement";
+        SyntaxKind[SyntaxKind["JsxText"] = 244] = "JsxText";
+        SyntaxKind[SyntaxKind["JsxClosingElement"] = 245] = "JsxClosingElement";
+        SyntaxKind[SyntaxKind["JsxAttribute"] = 246] = "JsxAttribute";
+        SyntaxKind[SyntaxKind["JsxSpreadAttribute"] = 247] = "JsxSpreadAttribute";
+        SyntaxKind[SyntaxKind["JsxExpression"] = 248] = "JsxExpression";
+        // Clauses
+        SyntaxKind[SyntaxKind["CaseClause"] = 249] = "CaseClause";
+        SyntaxKind[SyntaxKind["DefaultClause"] = 250] = "DefaultClause";
+        SyntaxKind[SyntaxKind["HeritageClause"] = 251] = "HeritageClause";
+        SyntaxKind[SyntaxKind["CatchClause"] = 252] = "CatchClause";
+        // Property assignments
+        SyntaxKind[SyntaxKind["PropertyAssignment"] = 253] = "PropertyAssignment";
+        SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 254] = "ShorthandPropertyAssignment";
+        // Enum
+        SyntaxKind[SyntaxKind["EnumMember"] = 255] = "EnumMember";
+        // Top-level nodes
+        SyntaxKind[SyntaxKind["SourceFile"] = 256] = "SourceFile";
+        // JSDoc nodes
+        SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 257] = "JSDocTypeExpression";
+        // The * type
+        SyntaxKind[SyntaxKind["JSDocAllType"] = 258] = "JSDocAllType";
+        // The ? type
+        SyntaxKind[SyntaxKind["JSDocUnknownType"] = 259] = "JSDocUnknownType";
+        SyntaxKind[SyntaxKind["JSDocArrayType"] = 260] = "JSDocArrayType";
+        SyntaxKind[SyntaxKind["JSDocUnionType"] = 261] = "JSDocUnionType";
+        SyntaxKind[SyntaxKind["JSDocTupleType"] = 262] = "JSDocTupleType";
+        SyntaxKind[SyntaxKind["JSDocNullableType"] = 263] = "JSDocNullableType";
+        SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 264] = "JSDocNonNullableType";
+        SyntaxKind[SyntaxKind["JSDocRecordType"] = 265] = "JSDocRecordType";
+        SyntaxKind[SyntaxKind["JSDocRecordMember"] = 266] = "JSDocRecordMember";
+        SyntaxKind[SyntaxKind["JSDocTypeReference"] = 267] = "JSDocTypeReference";
+        SyntaxKind[SyntaxKind["JSDocOptionalType"] = 268] = "JSDocOptionalType";
+        SyntaxKind[SyntaxKind["JSDocFunctionType"] = 269] = "JSDocFunctionType";
+        SyntaxKind[SyntaxKind["JSDocVariadicType"] = 270] = "JSDocVariadicType";
+        SyntaxKind[SyntaxKind["JSDocConstructorType"] = 271] = "JSDocConstructorType";
+        SyntaxKind[SyntaxKind["JSDocThisType"] = 272] = "JSDocThisType";
+        SyntaxKind[SyntaxKind["JSDocComment"] = 273] = "JSDocComment";
+        SyntaxKind[SyntaxKind["JSDocTag"] = 274] = "JSDocTag";
+        SyntaxKind[SyntaxKind["JSDocParameterTag"] = 275] = "JSDocParameterTag";
+        SyntaxKind[SyntaxKind["JSDocReturnTag"] = 276] = "JSDocReturnTag";
+        SyntaxKind[SyntaxKind["JSDocTypeTag"] = 277] = "JSDocTypeTag";
+        SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 278] = "JSDocTemplateTag";
+        SyntaxKind[SyntaxKind["JSDocTypedefTag"] = 279] = "JSDocTypedefTag";
+        SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 280] = "JSDocPropertyTag";
+        SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 281] = "JSDocTypeLiteral";
+        // Synthesized list
+        SyntaxKind[SyntaxKind["SyntaxList"] = 282] = "SyntaxList";
+        // Enum value count
+        SyntaxKind[SyntaxKind["Count"] = 283] = "Count";
+        // Markers
+        SyntaxKind[SyntaxKind["FirstAssignment"] = 56] = "FirstAssignment";
+        SyntaxKind[SyntaxKind["LastAssignment"] = 68] = "LastAssignment";
+        SyntaxKind[SyntaxKind["FirstReservedWord"] = 70] = "FirstReservedWord";
+        SyntaxKind[SyntaxKind["LastReservedWord"] = 105] = "LastReservedWord";
+        SyntaxKind[SyntaxKind["FirstKeyword"] = 70] = "FirstKeyword";
+        SyntaxKind[SyntaxKind["LastKeyword"] = 138] = "LastKeyword";
+        SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 106] = "FirstFutureReservedWord";
+        SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 114] = "LastFutureReservedWord";
+        SyntaxKind[SyntaxKind["FirstTypeNode"] = 154] = "FirstTypeNode";
+        SyntaxKind[SyntaxKind["LastTypeNode"] = 166] = "LastTypeNode";
+        SyntaxKind[SyntaxKind["FirstPunctuation"] = 15] = "FirstPunctuation";
+        SyntaxKind[SyntaxKind["LastPunctuation"] = 68] = "LastPunctuation";
+        SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken";
+        SyntaxKind[SyntaxKind["LastToken"] = 138] = "LastToken";
+        SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken";
+        SyntaxKind[SyntaxKind["LastTriviaToken"] = 7] = "LastTriviaToken";
+        SyntaxKind[SyntaxKind["FirstLiteralToken"] = 8] = "FirstLiteralToken";
+        SyntaxKind[SyntaxKind["LastLiteralToken"] = 11] = "LastLiteralToken";
+        SyntaxKind[SyntaxKind["FirstTemplateToken"] = 11] = "FirstTemplateToken";
+        SyntaxKind[SyntaxKind["LastTemplateToken"] = 14] = "LastTemplateToken";
+        SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 25] = "FirstBinaryOperator";
+        SyntaxKind[SyntaxKind["LastBinaryOperator"] = 68] = "LastBinaryOperator";
+        SyntaxKind[SyntaxKind["FirstNode"] = 139] = "FirstNode";
+        SyntaxKind[SyntaxKind["FirstJSDocNode"] = 257] = "FirstJSDocNode";
+        SyntaxKind[SyntaxKind["LastJSDocNode"] = 281] = "LastJSDocNode";
+        SyntaxKind[SyntaxKind["FirstJSDocTagNode"] = 273] = "FirstJSDocTagNode";
+        SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 281] = "LastJSDocTagNode";
+    })(ts.SyntaxKind || (ts.SyntaxKind = {}));
+    var SyntaxKind = ts.SyntaxKind;
+    (function (NodeFlags) {
+        NodeFlags[NodeFlags["None"] = 0] = "None";
+        NodeFlags[NodeFlags["Export"] = 1] = "Export";
+        NodeFlags[NodeFlags["Ambient"] = 2] = "Ambient";
+        NodeFlags[NodeFlags["Public"] = 4] = "Public";
+        NodeFlags[NodeFlags["Private"] = 8] = "Private";
+        NodeFlags[NodeFlags["Protected"] = 16] = "Protected";
+        NodeFlags[NodeFlags["Static"] = 32] = "Static";
+        NodeFlags[NodeFlags["Readonly"] = 64] = "Readonly";
+        NodeFlags[NodeFlags["Abstract"] = 128] = "Abstract";
+        NodeFlags[NodeFlags["Async"] = 256] = "Async";
+        NodeFlags[NodeFlags["Default"] = 512] = "Default";
+        NodeFlags[NodeFlags["Let"] = 1024] = "Let";
+        NodeFlags[NodeFlags["Const"] = 2048] = "Const";
+        NodeFlags[NodeFlags["Namespace"] = 4096] = "Namespace";
+        NodeFlags[NodeFlags["ExportContext"] = 8192] = "ExportContext";
+        NodeFlags[NodeFlags["ContainsThis"] = 16384] = "ContainsThis";
+        NodeFlags[NodeFlags["HasImplicitReturn"] = 32768] = "HasImplicitReturn";
+        NodeFlags[NodeFlags["HasExplicitReturn"] = 65536] = "HasExplicitReturn";
+        NodeFlags[NodeFlags["GlobalAugmentation"] = 131072] = "GlobalAugmentation";
+        NodeFlags[NodeFlags["HasClassExtends"] = 262144] = "HasClassExtends";
+        NodeFlags[NodeFlags["HasDecorators"] = 524288] = "HasDecorators";
+        NodeFlags[NodeFlags["HasParamDecorators"] = 1048576] = "HasParamDecorators";
+        NodeFlags[NodeFlags["HasAsyncFunctions"] = 2097152] = "HasAsyncFunctions";
+        NodeFlags[NodeFlags["DisallowInContext"] = 4194304] = "DisallowInContext";
+        NodeFlags[NodeFlags["YieldContext"] = 8388608] = "YieldContext";
+        NodeFlags[NodeFlags["DecoratorContext"] = 16777216] = "DecoratorContext";
+        NodeFlags[NodeFlags["AwaitContext"] = 33554432] = "AwaitContext";
+        NodeFlags[NodeFlags["ThisNodeHasError"] = 67108864] = "ThisNodeHasError";
+        NodeFlags[NodeFlags["JavaScriptFile"] = 134217728] = "JavaScriptFile";
+        NodeFlags[NodeFlags["ThisNodeOrAnySubNodesHasError"] = 268435456] = "ThisNodeOrAnySubNodesHasError";
+        NodeFlags[NodeFlags["HasAggregatedChildData"] = 536870912] = "HasAggregatedChildData";
+        NodeFlags[NodeFlags["HasJsxSpreadAttribute"] = 1073741824] = "HasJsxSpreadAttribute";
+        NodeFlags[NodeFlags["Modifier"] = 1023] = "Modifier";
+        NodeFlags[NodeFlags["AccessibilityModifier"] = 28] = "AccessibilityModifier";
+        // Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.
+        NodeFlags[NodeFlags["ParameterPropertyModifier"] = 92] = "ParameterPropertyModifier";
+        NodeFlags[NodeFlags["BlockScoped"] = 3072] = "BlockScoped";
+        NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 98304] = "ReachabilityCheckFlags";
+        NodeFlags[NodeFlags["EmitHelperFlags"] = 3932160] = "EmitHelperFlags";
+        NodeFlags[NodeFlags["ReachabilityAndEmitFlags"] = 4030464] = "ReachabilityAndEmitFlags";
+        // Parsing context flags
+        NodeFlags[NodeFlags["ContextFlags"] = 197132288] = "ContextFlags";
+        // Exclude these flags when parsing a Type
+        NodeFlags[NodeFlags["TypeExcludesFlags"] = 41943040] = "TypeExcludesFlags";
+    })(ts.NodeFlags || (ts.NodeFlags = {}));
+    var NodeFlags = ts.NodeFlags;
+    (function (JsxFlags) {
+        JsxFlags[JsxFlags["None"] = 0] = "None";
+        /** An element from a named property of the JSX.IntrinsicElements interface */
+        JsxFlags[JsxFlags["IntrinsicNamedElement"] = 1] = "IntrinsicNamedElement";
+        /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
+        JsxFlags[JsxFlags["IntrinsicIndexedElement"] = 2] = "IntrinsicIndexedElement";
+        JsxFlags[JsxFlags["IntrinsicElement"] = 3] = "IntrinsicElement";
+    })(ts.JsxFlags || (ts.JsxFlags = {}));
+    var JsxFlags = ts.JsxFlags;
+    /* @internal */
+    (function (RelationComparisonResult) {
+        RelationComparisonResult[RelationComparisonResult["Succeeded"] = 1] = "Succeeded";
+        RelationComparisonResult[RelationComparisonResult["Failed"] = 2] = "Failed";
+        RelationComparisonResult[RelationComparisonResult["FailedAndReported"] = 3] = "FailedAndReported";
+    })(ts.RelationComparisonResult || (ts.RelationComparisonResult = {}));
+    var RelationComparisonResult = ts.RelationComparisonResult;
+    (function (FlowFlags) {
+        FlowFlags[FlowFlags["Unreachable"] = 1] = "Unreachable";
+        FlowFlags[FlowFlags["Start"] = 2] = "Start";
+        FlowFlags[FlowFlags["BranchLabel"] = 4] = "BranchLabel";
+        FlowFlags[FlowFlags["LoopLabel"] = 8] = "LoopLabel";
+        FlowFlags[FlowFlags["Assignment"] = 16] = "Assignment";
+        FlowFlags[FlowFlags["TrueCondition"] = 32] = "TrueCondition";
+        FlowFlags[FlowFlags["FalseCondition"] = 64] = "FalseCondition";
+        FlowFlags[FlowFlags["SwitchClause"] = 128] = "SwitchClause";
+        FlowFlags[FlowFlags["Referenced"] = 256] = "Referenced";
+        FlowFlags[FlowFlags["Shared"] = 512] = "Shared";
+        FlowFlags[FlowFlags["Label"] = 12] = "Label";
+        FlowFlags[FlowFlags["Condition"] = 96] = "Condition";
+    })(ts.FlowFlags || (ts.FlowFlags = {}));
+    var FlowFlags = ts.FlowFlags;
+    var OperationCanceledException = (function () {
+        function OperationCanceledException() {
+        }
+        return OperationCanceledException;
+    }());
+    ts.OperationCanceledException = OperationCanceledException;
+    /** Return code used by getEmitOutput function to indicate status of the function */
+    (function (ExitStatus) {
+        // Compiler ran successfully.  Either this was a simple do-nothing compilation (for example,
+        // when -version or -help was provided, or this was a normal compilation, no diagnostics
+        // were produced, and all outputs were generated successfully.
+        ExitStatus[ExitStatus["Success"] = 0] = "Success";
+        // Diagnostics were produced and because of them no code was generated.
+        ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped";
+        // Diagnostics were produced and outputs were generated in spite of them.
+        ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated";
+    })(ts.ExitStatus || (ts.ExitStatus = {}));
+    var ExitStatus = ts.ExitStatus;
+    (function (TypeFormatFlags) {
+        TypeFormatFlags[TypeFormatFlags["None"] = 0] = "None";
+        TypeFormatFlags[TypeFormatFlags["WriteArrayAsGenericType"] = 1] = "WriteArrayAsGenericType";
+        TypeFormatFlags[TypeFormatFlags["UseTypeOfFunction"] = 2] = "UseTypeOfFunction";
+        TypeFormatFlags[TypeFormatFlags["NoTruncation"] = 4] = "NoTruncation";
+        TypeFormatFlags[TypeFormatFlags["WriteArrowStyleSignature"] = 8] = "WriteArrowStyleSignature";
+        TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 16] = "WriteOwnNameForAnyLike";
+        TypeFormatFlags[TypeFormatFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
+        TypeFormatFlags[TypeFormatFlags["InElementType"] = 64] = "InElementType";
+        TypeFormatFlags[TypeFormatFlags["UseFullyQualifiedType"] = 128] = "UseFullyQualifiedType";
+        TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 256] = "InFirstTypeArgument";
+    })(ts.TypeFormatFlags || (ts.TypeFormatFlags = {}));
+    var TypeFormatFlags = ts.TypeFormatFlags;
+    (function (SymbolFormatFlags) {
+        SymbolFormatFlags[SymbolFormatFlags["None"] = 0] = "None";
+        // Write symbols's type argument if it is instantiated symbol
+        // eg. class C<T> { p: T }   <-- Show p as C<T>.p here
+        //     var a: C<number>;
+        //     var p = a.p;  <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
+        SymbolFormatFlags[SymbolFormatFlags["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments";
+        // Use only external alias information to get the symbol name in the given context
+        // eg.  module m { export class c { } } import x = m.c;
+        // When this flag is specified m.c will be used to refer to the class instead of alias symbol x
+        SymbolFormatFlags[SymbolFormatFlags["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing";
+    })(ts.SymbolFormatFlags || (ts.SymbolFormatFlags = {}));
+    var SymbolFormatFlags = ts.SymbolFormatFlags;
+    /* @internal */
+    (function (SymbolAccessibility) {
+        SymbolAccessibility[SymbolAccessibility["Accessible"] = 0] = "Accessible";
+        SymbolAccessibility[SymbolAccessibility["NotAccessible"] = 1] = "NotAccessible";
+        SymbolAccessibility[SymbolAccessibility["CannotBeNamed"] = 2] = "CannotBeNamed";
+    })(ts.SymbolAccessibility || (ts.SymbolAccessibility = {}));
+    var SymbolAccessibility = ts.SymbolAccessibility;
+    (function (TypePredicateKind) {
+        TypePredicateKind[TypePredicateKind["This"] = 0] = "This";
+        TypePredicateKind[TypePredicateKind["Identifier"] = 1] = "Identifier";
+    })(ts.TypePredicateKind || (ts.TypePredicateKind = {}));
+    var TypePredicateKind = ts.TypePredicateKind;
+    /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator
+      * metadata */
+    /* @internal */
+    (function (TypeReferenceSerializationKind) {
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["Unknown"] = 0] = "Unknown";
+        // should be emitted using a safe fallback.
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue";
+        // function that can be reached at runtime (e.g. a `class`
+        // declaration or a `var` declaration for the static side
+        // of a type, such as the global `Promise` type in lib.d.ts).
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["VoidType"] = 2] = "VoidType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["NumberLikeType"] = 3] = "NumberLikeType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 4] = "StringLikeType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 5] = "BooleanType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 6] = "ArrayLikeType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 7] = "ESSymbolType";
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 8] = "TypeWithCallSignature";
+        // with call signatures.
+        TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 9] = "ObjectType";
+    })(ts.TypeReferenceSerializationKind || (ts.TypeReferenceSerializationKind = {}));
+    var TypeReferenceSerializationKind = ts.TypeReferenceSerializationKind;
+    (function (SymbolFlags) {
+        SymbolFlags[SymbolFlags["None"] = 0] = "None";
+        SymbolFlags[SymbolFlags["FunctionScopedVariable"] = 1] = "FunctionScopedVariable";
+        SymbolFlags[SymbolFlags["BlockScopedVariable"] = 2] = "BlockScopedVariable";
+        SymbolFlags[SymbolFlags["Property"] = 4] = "Property";
+        SymbolFlags[SymbolFlags["EnumMember"] = 8] = "EnumMember";
+        SymbolFlags[SymbolFlags["Function"] = 16] = "Function";
+        SymbolFlags[SymbolFlags["Class"] = 32] = "Class";
+        SymbolFlags[SymbolFlags["Interface"] = 64] = "Interface";
+        SymbolFlags[SymbolFlags["ConstEnum"] = 128] = "ConstEnum";
+        SymbolFlags[SymbolFlags["RegularEnum"] = 256] = "RegularEnum";
+        SymbolFlags[SymbolFlags["ValueModule"] = 512] = "ValueModule";
+        SymbolFlags[SymbolFlags["NamespaceModule"] = 1024] = "NamespaceModule";
+        SymbolFlags[SymbolFlags["TypeLiteral"] = 2048] = "TypeLiteral";
+        SymbolFlags[SymbolFlags["ObjectLiteral"] = 4096] = "ObjectLiteral";
+        SymbolFlags[SymbolFlags["Method"] = 8192] = "Method";
+        SymbolFlags[SymbolFlags["Constructor"] = 16384] = "Constructor";
+        SymbolFlags[SymbolFlags["GetAccessor"] = 32768] = "GetAccessor";
+        SymbolFlags[SymbolFlags["SetAccessor"] = 65536] = "SetAccessor";
+        SymbolFlags[SymbolFlags["Signature"] = 131072] = "Signature";
+        SymbolFlags[SymbolFlags["TypeParameter"] = 262144] = "TypeParameter";
+        SymbolFlags[SymbolFlags["TypeAlias"] = 524288] = "TypeAlias";
+        SymbolFlags[SymbolFlags["ExportValue"] = 1048576] = "ExportValue";
+        SymbolFlags[SymbolFlags["ExportType"] = 2097152] = "ExportType";
+        SymbolFlags[SymbolFlags["ExportNamespace"] = 4194304] = "ExportNamespace";
+        SymbolFlags[SymbolFlags["Alias"] = 8388608] = "Alias";
+        SymbolFlags[SymbolFlags["Instantiated"] = 16777216] = "Instantiated";
+        SymbolFlags[SymbolFlags["Merged"] = 33554432] = "Merged";
+        SymbolFlags[SymbolFlags["Transient"] = 67108864] = "Transient";
+        SymbolFlags[SymbolFlags["Prototype"] = 134217728] = "Prototype";
+        SymbolFlags[SymbolFlags["SyntheticProperty"] = 268435456] = "SyntheticProperty";
+        SymbolFlags[SymbolFlags["Optional"] = 536870912] = "Optional";
+        SymbolFlags[SymbolFlags["ExportStar"] = 1073741824] = "ExportStar";
+        SymbolFlags[SymbolFlags["Enum"] = 384] = "Enum";
+        SymbolFlags[SymbolFlags["Variable"] = 3] = "Variable";
+        SymbolFlags[SymbolFlags["Value"] = 107455] = "Value";
+        SymbolFlags[SymbolFlags["Type"] = 793056] = "Type";
+        SymbolFlags[SymbolFlags["Namespace"] = 1536] = "Namespace";
+        SymbolFlags[SymbolFlags["Module"] = 1536] = "Module";
+        SymbolFlags[SymbolFlags["Accessor"] = 98304] = "Accessor";
+        // Variables can be redeclared, but can not redeclare a block-scoped declaration with the
+        // same name, or any other value that is not a variable, e.g. ValueModule or Class
+        SymbolFlags[SymbolFlags["FunctionScopedVariableExcludes"] = 107454] = "FunctionScopedVariableExcludes";
+        // Block-scoped declarations are not allowed to be re-declared
+        // they can not merge with anything in the value space
+        SymbolFlags[SymbolFlags["BlockScopedVariableExcludes"] = 107455] = "BlockScopedVariableExcludes";
+        SymbolFlags[SymbolFlags["ParameterExcludes"] = 107455] = "ParameterExcludes";
+        SymbolFlags[SymbolFlags["PropertyExcludes"] = 0] = "PropertyExcludes";
+        SymbolFlags[SymbolFlags["EnumMemberExcludes"] = 107455] = "EnumMemberExcludes";
+        SymbolFlags[SymbolFlags["FunctionExcludes"] = 106927] = "FunctionExcludes";
+        SymbolFlags[SymbolFlags["ClassExcludes"] = 899519] = "ClassExcludes";
+        SymbolFlags[SymbolFlags["InterfaceExcludes"] = 792960] = "InterfaceExcludes";
+        SymbolFlags[SymbolFlags["RegularEnumExcludes"] = 899327] = "RegularEnumExcludes";
+        SymbolFlags[SymbolFlags["ConstEnumExcludes"] = 899967] = "ConstEnumExcludes";
+        SymbolFlags[SymbolFlags["ValueModuleExcludes"] = 106639] = "ValueModuleExcludes";
+        SymbolFlags[SymbolFlags["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes";
+        SymbolFlags[SymbolFlags["MethodExcludes"] = 99263] = "MethodExcludes";
+        SymbolFlags[SymbolFlags["GetAccessorExcludes"] = 41919] = "GetAccessorExcludes";
+        SymbolFlags[SymbolFlags["SetAccessorExcludes"] = 74687] = "SetAccessorExcludes";
+        SymbolFlags[SymbolFlags["TypeParameterExcludes"] = 530912] = "TypeParameterExcludes";
+        SymbolFlags[SymbolFlags["TypeAliasExcludes"] = 793056] = "TypeAliasExcludes";
+        SymbolFlags[SymbolFlags["AliasExcludes"] = 8388608] = "AliasExcludes";
+        SymbolFlags[SymbolFlags["ModuleMember"] = 8914931] = "ModuleMember";
+        SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal";
+        SymbolFlags[SymbolFlags["HasExports"] = 1952] = "HasExports";
+        SymbolFlags[SymbolFlags["HasMembers"] = 6240] = "HasMembers";
+        SymbolFlags[SymbolFlags["BlockScoped"] = 418] = "BlockScoped";
+        SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor";
+        SymbolFlags[SymbolFlags["Export"] = 7340032] = "Export";
+        SymbolFlags[SymbolFlags["ClassMember"] = 106500] = "ClassMember";
+        /* @internal */
+        // The set of things we consider semantically classifiable.  Used to speed up the LS during
+        // classification.
+        SymbolFlags[SymbolFlags["Classifiable"] = 788448] = "Classifiable";
+    })(ts.SymbolFlags || (ts.SymbolFlags = {}));
+    var SymbolFlags = ts.SymbolFlags;
+    /* @internal */
+    (function (NodeCheckFlags) {
+        NodeCheckFlags[NodeCheckFlags["TypeChecked"] = 1] = "TypeChecked";
+        NodeCheckFlags[NodeCheckFlags["LexicalThis"] = 2] = "LexicalThis";
+        NodeCheckFlags[NodeCheckFlags["CaptureThis"] = 4] = "CaptureThis";
+        NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance";
+        NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic";
+        NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
+        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuper"] = 2048] = "AsyncMethodWithSuper";
+        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuperBinding"] = 4096] = "AsyncMethodWithSuperBinding";
+        NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
+        NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
+        NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
+        NodeCheckFlags[NodeCheckFlags["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding";
+        NodeCheckFlags[NodeCheckFlags["CapturedBlockScopedBinding"] = 131072] = "CapturedBlockScopedBinding";
+        NodeCheckFlags[NodeCheckFlags["BlockScopedBindingInLoop"] = 262144] = "BlockScopedBindingInLoop";
+        NodeCheckFlags[NodeCheckFlags["ClassWithBodyScopedClassBinding"] = 524288] = "ClassWithBodyScopedClassBinding";
+        NodeCheckFlags[NodeCheckFlags["BodyScopedClassBinding"] = 1048576] = "BodyScopedClassBinding";
+        NodeCheckFlags[NodeCheckFlags["NeedsLoopOutParameter"] = 2097152] = "NeedsLoopOutParameter";
+    })(ts.NodeCheckFlags || (ts.NodeCheckFlags = {}));
+    var NodeCheckFlags = ts.NodeCheckFlags;
+    (function (TypeFlags) {
+        TypeFlags[TypeFlags["Any"] = 1] = "Any";
+        TypeFlags[TypeFlags["String"] = 2] = "String";
+        TypeFlags[TypeFlags["Number"] = 4] = "Number";
+        TypeFlags[TypeFlags["Boolean"] = 8] = "Boolean";
+        TypeFlags[TypeFlags["Void"] = 16] = "Void";
+        TypeFlags[TypeFlags["Undefined"] = 32] = "Undefined";
+        TypeFlags[TypeFlags["Null"] = 64] = "Null";
+        TypeFlags[TypeFlags["Enum"] = 128] = "Enum";
+        TypeFlags[TypeFlags["StringLiteral"] = 256] = "StringLiteral";
+        TypeFlags[TypeFlags["TypeParameter"] = 512] = "TypeParameter";
+        TypeFlags[TypeFlags["Class"] = 1024] = "Class";
+        TypeFlags[TypeFlags["Interface"] = 2048] = "Interface";
+        TypeFlags[TypeFlags["Reference"] = 4096] = "Reference";
+        TypeFlags[TypeFlags["Tuple"] = 8192] = "Tuple";
+        TypeFlags[TypeFlags["Union"] = 16384] = "Union";
+        TypeFlags[TypeFlags["Intersection"] = 32768] = "Intersection";
+        TypeFlags[TypeFlags["Anonymous"] = 65536] = "Anonymous";
+        TypeFlags[TypeFlags["Instantiated"] = 131072] = "Instantiated";
+        /* @internal */
+        TypeFlags[TypeFlags["FromSignature"] = 262144] = "FromSignature";
+        TypeFlags[TypeFlags["ObjectLiteral"] = 524288] = "ObjectLiteral";
+        /* @internal */
+        TypeFlags[TypeFlags["FreshObjectLiteral"] = 1048576] = "FreshObjectLiteral";
+        /* @internal */
+        TypeFlags[TypeFlags["ContainsWideningType"] = 2097152] = "ContainsWideningType";
+        /* @internal */
+        TypeFlags[TypeFlags["ContainsObjectLiteral"] = 4194304] = "ContainsObjectLiteral";
+        /* @internal */
+        TypeFlags[TypeFlags["ContainsAnyFunctionType"] = 8388608] = "ContainsAnyFunctionType";
+        TypeFlags[TypeFlags["ESSymbol"] = 16777216] = "ESSymbol";
+        TypeFlags[TypeFlags["ThisType"] = 33554432] = "ThisType";
+        TypeFlags[TypeFlags["ObjectLiteralPatternWithComputedProperties"] = 67108864] = "ObjectLiteralPatternWithComputedProperties";
+        TypeFlags[TypeFlags["Never"] = 134217728] = "Never";
+        /* @internal */
+        TypeFlags[TypeFlags["Nullable"] = 96] = "Nullable";
+        /* @internal */
+        TypeFlags[TypeFlags["Falsy"] = 112] = "Falsy";
+        /* @internal */
+        TypeFlags[TypeFlags["Intrinsic"] = 150995071] = "Intrinsic";
+        /* @internal */
+        TypeFlags[TypeFlags["Primitive"] = 16777726] = "Primitive";
+        TypeFlags[TypeFlags["StringLike"] = 258] = "StringLike";
+        TypeFlags[TypeFlags["NumberLike"] = 132] = "NumberLike";
+        TypeFlags[TypeFlags["ObjectType"] = 80896] = "ObjectType";
+        TypeFlags[TypeFlags["UnionOrIntersection"] = 49152] = "UnionOrIntersection";
+        TypeFlags[TypeFlags["StructuredType"] = 130048] = "StructuredType";
+        // 'Narrowable' types are types where narrowing actually narrows.
+        // This *should* be every type other than null, undefined, void, and never
+        TypeFlags[TypeFlags["Narrowable"] = 16908175] = "Narrowable";
+        /* @internal */
+        TypeFlags[TypeFlags["RequiresWidening"] = 6291456] = "RequiresWidening";
+        /* @internal */
+        TypeFlags[TypeFlags["PropagatingFlags"] = 14680064] = "PropagatingFlags";
+    })(ts.TypeFlags || (ts.TypeFlags = {}));
+    var TypeFlags = ts.TypeFlags;
+    (function (SignatureKind) {
+        SignatureKind[SignatureKind["Call"] = 0] = "Call";
+        SignatureKind[SignatureKind["Construct"] = 1] = "Construct";
+    })(ts.SignatureKind || (ts.SignatureKind = {}));
+    var SignatureKind = ts.SignatureKind;
+    (function (IndexKind) {
+        IndexKind[IndexKind["String"] = 0] = "String";
+        IndexKind[IndexKind["Number"] = 1] = "Number";
+    })(ts.IndexKind || (ts.IndexKind = {}));
+    var IndexKind = ts.IndexKind;
+    /* @internal */
+    (function (SpecialPropertyAssignmentKind) {
+        SpecialPropertyAssignmentKind[SpecialPropertyAssignmentKind["None"] = 0] = "None";
+        /// exports.name = expr
+        SpecialPropertyAssignmentKind[SpecialPropertyAssignmentKind["ExportsProperty"] = 1] = "ExportsProperty";
+        /// module.exports = expr
+        SpecialPropertyAssignmentKind[SpecialPropertyAssignmentKind["ModuleExports"] = 2] = "ModuleExports";
+        /// className.prototype.name = expr
+        SpecialPropertyAssignmentKind[SpecialPropertyAssignmentKind["PrototypeProperty"] = 3] = "PrototypeProperty";
+        /// this.name = expr
+        SpecialPropertyAssignmentKind[SpecialPropertyAssignmentKind["ThisProperty"] = 4] = "ThisProperty";
+    })(ts.SpecialPropertyAssignmentKind || (ts.SpecialPropertyAssignmentKind = {}));
+    var SpecialPropertyAssignmentKind = ts.SpecialPropertyAssignmentKind;
+    (function (DiagnosticCategory) {
+        DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning";
+        DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";
+        DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message";
+    })(ts.DiagnosticCategory || (ts.DiagnosticCategory = {}));
+    var DiagnosticCategory = ts.DiagnosticCategory;
+    (function (ModuleResolutionKind) {
+        ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";
+        ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";
+    })(ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));
+    var ModuleResolutionKind = ts.ModuleResolutionKind;
+    (function (ModuleKind) {
+        ModuleKind[ModuleKind["None"] = 0] = "None";
+        ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS";
+        ModuleKind[ModuleKind["AMD"] = 2] = "AMD";
+        ModuleKind[ModuleKind["UMD"] = 3] = "UMD";
+        ModuleKind[ModuleKind["System"] = 4] = "System";
+        ModuleKind[ModuleKind["ES6"] = 5] = "ES6";
+        ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";
+    })(ts.ModuleKind || (ts.ModuleKind = {}));
+    var ModuleKind = ts.ModuleKind;
+    (function (JsxEmit) {
+        JsxEmit[JsxEmit["None"] = 0] = "None";
+        JsxEmit[JsxEmit["Preserve"] = 1] = "Preserve";
+        JsxEmit[JsxEmit["React"] = 2] = "React";
+    })(ts.JsxEmit || (ts.JsxEmit = {}));
+    var JsxEmit = ts.JsxEmit;
+    (function (NewLineKind) {
+        NewLineKind[NewLineKind["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed";
+        NewLineKind[NewLineKind["LineFeed"] = 1] = "LineFeed";
+    })(ts.NewLineKind || (ts.NewLineKind = {}));
+    var NewLineKind = ts.NewLineKind;
+    (function (ScriptKind) {
+        ScriptKind[ScriptKind["Unknown"] = 0] = "Unknown";
+        ScriptKind[ScriptKind["JS"] = 1] = "JS";
+        ScriptKind[ScriptKind["JSX"] = 2] = "JSX";
+        ScriptKind[ScriptKind["TS"] = 3] = "TS";
+        ScriptKind[ScriptKind["TSX"] = 4] = "TSX";
+    })(ts.ScriptKind || (ts.ScriptKind = {}));
+    var ScriptKind = ts.ScriptKind;
+    (function (ScriptTarget) {
+        ScriptTarget[ScriptTarget["ES3"] = 0] = "ES3";
+        ScriptTarget[ScriptTarget["ES5"] = 1] = "ES5";
+        ScriptTarget[ScriptTarget["ES6"] = 2] = "ES6";
+        ScriptTarget[ScriptTarget["ES2015"] = 2] = "ES2015";
+        ScriptTarget[ScriptTarget["Latest"] = 2] = "Latest";
+    })(ts.ScriptTarget || (ts.ScriptTarget = {}));
+    var ScriptTarget = ts.ScriptTarget;
+    (function (LanguageVariant) {
+        LanguageVariant[LanguageVariant["Standard"] = 0] = "Standard";
+        LanguageVariant[LanguageVariant["JSX"] = 1] = "JSX";
+    })(ts.LanguageVariant || (ts.LanguageVariant = {}));
+    var LanguageVariant = ts.LanguageVariant;
+    /* @internal */
+    (function (DiagnosticStyle) {
+        DiagnosticStyle[DiagnosticStyle["Simple"] = 0] = "Simple";
+        DiagnosticStyle[DiagnosticStyle["Pretty"] = 1] = "Pretty";
+    })(ts.DiagnosticStyle || (ts.DiagnosticStyle = {}));
+    var DiagnosticStyle = ts.DiagnosticStyle;
+    (function (WatchDirectoryFlags) {
+        WatchDirectoryFlags[WatchDirectoryFlags["None"] = 0] = "None";
+        WatchDirectoryFlags[WatchDirectoryFlags["Recursive"] = 1] = "Recursive";
+    })(ts.WatchDirectoryFlags || (ts.WatchDirectoryFlags = {}));
+    var WatchDirectoryFlags = ts.WatchDirectoryFlags;
+    /* @internal */
+    (function (CharacterCodes) {
+        CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
+        CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
+        CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+        CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+        CharacterCodes[CharacterCodes["lineSeparator"] = 8232] = "lineSeparator";
+        CharacterCodes[CharacterCodes["paragraphSeparator"] = 8233] = "paragraphSeparator";
+        CharacterCodes[CharacterCodes["nextLine"] = 133] = "nextLine";
+        // Unicode 3.0 space characters
+        CharacterCodes[CharacterCodes["space"] = 32] = "space";
+        CharacterCodes[CharacterCodes["nonBreakingSpace"] = 160] = "nonBreakingSpace";
+        CharacterCodes[CharacterCodes["enQuad"] = 8192] = "enQuad";
+        CharacterCodes[CharacterCodes["emQuad"] = 8193] = "emQuad";
+        CharacterCodes[CharacterCodes["enSpace"] = 8194] = "enSpace";
+        CharacterCodes[CharacterCodes["emSpace"] = 8195] = "emSpace";
+        CharacterCodes[CharacterCodes["threePerEmSpace"] = 8196] = "threePerEmSpace";
+        CharacterCodes[CharacterCodes["fourPerEmSpace"] = 8197] = "fourPerEmSpace";
+        CharacterCodes[CharacterCodes["sixPerEmSpace"] = 8198] = "sixPerEmSpace";
+        CharacterCodes[CharacterCodes["figureSpace"] = 8199] = "figureSpace";
+        CharacterCodes[CharacterCodes["punctuationSpace"] = 8200] = "punctuationSpace";
+        CharacterCodes[CharacterCodes["thinSpace"] = 8201] = "thinSpace";
+        CharacterCodes[CharacterCodes["hairSpace"] = 8202] = "hairSpace";
+        CharacterCodes[CharacterCodes["zeroWidthSpace"] = 8203] = "zeroWidthSpace";
+        CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace";
+        CharacterCodes[CharacterCodes["ideographicSpace"] = 12288] = "ideographicSpace";
+        CharacterCodes[CharacterCodes["mathematicalSpace"] = 8287] = "mathematicalSpace";
+        CharacterCodes[CharacterCodes["ogham"] = 5760] = "ogham";
+        CharacterCodes[CharacterCodes["_"] = 95] = "_";
+        CharacterCodes[CharacterCodes["$"] = 36] = "$";
+        CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+        CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+        CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+        CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+        CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+        CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+        CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+        CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+        CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+        CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+        CharacterCodes[CharacterCodes["a"] = 97] = "a";
+        CharacterCodes[CharacterCodes["b"] = 98] = "b";
+        CharacterCodes[CharacterCodes["c"] = 99] = "c";
+        CharacterCodes[CharacterCodes["d"] = 100] = "d";
+        CharacterCodes[CharacterCodes["e"] = 101] = "e";
+        CharacterCodes[CharacterCodes["f"] = 102] = "f";
+        CharacterCodes[CharacterCodes["g"] = 103] = "g";
+        CharacterCodes[CharacterCodes["h"] = 104] = "h";
+        CharacterCodes[CharacterCodes["i"] = 105] = "i";
+        CharacterCodes[CharacterCodes["j"] = 106] = "j";
+        CharacterCodes[CharacterCodes["k"] = 107] = "k";
+        CharacterCodes[CharacterCodes["l"] = 108] = "l";
+        CharacterCodes[CharacterCodes["m"] = 109] = "m";
+        CharacterCodes[CharacterCodes["n"] = 110] = "n";
+        CharacterCodes[CharacterCodes["o"] = 111] = "o";
+        CharacterCodes[CharacterCodes["p"] = 112] = "p";
+        CharacterCodes[CharacterCodes["q"] = 113] = "q";
+        CharacterCodes[CharacterCodes["r"] = 114] = "r";
+        CharacterCodes[CharacterCodes["s"] = 115] = "s";
+        CharacterCodes[CharacterCodes["t"] = 116] = "t";
+        CharacterCodes[CharacterCodes["u"] = 117] = "u";
+        CharacterCodes[CharacterCodes["v"] = 118] = "v";
+        CharacterCodes[CharacterCodes["w"] = 119] = "w";
+        CharacterCodes[CharacterCodes["x"] = 120] = "x";
+        CharacterCodes[CharacterCodes["y"] = 121] = "y";
+        CharacterCodes[CharacterCodes["z"] = 122] = "z";
+        CharacterCodes[CharacterCodes["A"] = 65] = "A";
+        CharacterCodes[CharacterCodes["B"] = 66] = "B";
+        CharacterCodes[CharacterCodes["C"] = 67] = "C";
+        CharacterCodes[CharacterCodes["D"] = 68] = "D";
+        CharacterCodes[CharacterCodes["E"] = 69] = "E";
+        CharacterCodes[CharacterCodes["F"] = 70] = "F";
+        CharacterCodes[CharacterCodes["G"] = 71] = "G";
+        CharacterCodes[CharacterCodes["H"] = 72] = "H";
+        CharacterCodes[CharacterCodes["I"] = 73] = "I";
+        CharacterCodes[CharacterCodes["J"] = 74] = "J";
+        CharacterCodes[CharacterCodes["K"] = 75] = "K";
+        CharacterCodes[CharacterCodes["L"] = 76] = "L";
+        CharacterCodes[CharacterCodes["M"] = 77] = "M";
+        CharacterCodes[CharacterCodes["N"] = 78] = "N";
+        CharacterCodes[CharacterCodes["O"] = 79] = "O";
+        CharacterCodes[CharacterCodes["P"] = 80] = "P";
+        CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+        CharacterCodes[CharacterCodes["R"] = 82] = "R";
+        CharacterCodes[CharacterCodes["S"] = 83] = "S";
+        CharacterCodes[CharacterCodes["T"] = 84] = "T";
+        CharacterCodes[CharacterCodes["U"] = 85] = "U";
+        CharacterCodes[CharacterCodes["V"] = 86] = "V";
+        CharacterCodes[CharacterCodes["W"] = 87] = "W";
+        CharacterCodes[CharacterCodes["X"] = 88] = "X";
+        CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+        CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+        CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand";
+        CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+        CharacterCodes[CharacterCodes["at"] = 64] = "at";
+        CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+        CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick";
+        CharacterCodes[CharacterCodes["bar"] = 124] = "bar";
+        CharacterCodes[CharacterCodes["caret"] = 94] = "caret";
+        CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+        CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+        CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen";
+        CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+        CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+        CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+        CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+        CharacterCodes[CharacterCodes["equals"] = 61] = "equals";
+        CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation";
+        CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan";
+        CharacterCodes[CharacterCodes["hash"] = 35] = "hash";
+        CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan";
+        CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+        CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+        CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+        CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen";
+        CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
+        CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+        CharacterCodes[CharacterCodes["question"] = 63] = "question";
+        CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon";
+        CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
+        CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+        CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde";
+        CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace";
+        CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+        CharacterCodes[CharacterCodes["byteOrderMark"] = 65279] = "byteOrderMark";
+        CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+        CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab";
+    })(ts.CharacterCodes || (ts.CharacterCodes = {}));
+    var CharacterCodes = ts.CharacterCodes;
+})(ts || (ts = {}));
+/// <reference path="types.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    /**
+     * Ternary values are defined such that
+     * x & y is False if either x or y is False.
+     * x & y is Maybe if either x or y is Maybe, but neither x or y is False.
+     * x & y is True if both x and y are True.
+     * x | y is False if both x and y are False.
+     * x | y is Maybe if either x or y is Maybe, but neither x or y is True.
+     * x | y is True if either x or y is True.
+     */
+    (function (Ternary) {
+        Ternary[Ternary["False"] = 0] = "False";
+        Ternary[Ternary["Maybe"] = 1] = "Maybe";
+        Ternary[Ternary["True"] = -1] = "True";
+    })(ts.Ternary || (ts.Ternary = {}));
+    var Ternary = ts.Ternary;
+    function createFileMap(keyMapper) {
+        var files = {};
+        return {
+            get: get,
+            set: set,
+            contains: contains,
+            remove: remove,
+            forEachValue: forEachValueInMap,
+            clear: clear
+        };
+        function forEachValueInMap(f) {
+            for (var key in files) {
+                f(key, files[key]);
+            }
+        }
+        // path should already be well-formed so it does not need to be normalized
+        function get(path) {
+            return files[toKey(path)];
+        }
+        function set(path, value) {
+            files[toKey(path)] = value;
+        }
+        function contains(path) {
+            return hasProperty(files, toKey(path));
+        }
+        function remove(path) {
+            var key = toKey(path);
+            delete files[key];
+        }
+        function clear() {
+            files = {};
+        }
+        function toKey(path) {
+            return keyMapper ? keyMapper(path) : path;
+        }
+    }
+    ts.createFileMap = createFileMap;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
+    (function (Comparison) {
+        Comparison[Comparison["LessThan"] = -1] = "LessThan";
+        Comparison[Comparison["EqualTo"] = 0] = "EqualTo";
+        Comparison[Comparison["GreaterThan"] = 1] = "GreaterThan";
+    })(ts.Comparison || (ts.Comparison = {}));
+    var Comparison = ts.Comparison;
+    /**
+     * Iterates through 'array' by index and performs the callback on each element of array until the callback
+     * returns a truthy value, then returns that value.
+     * If no such value is found, the callback is applied to each element of array and undefined is returned.
+     */
+    function forEach(array, callback) {
+        if (array) {
+            for (var i = 0, len = array.length; i < len; i++) {
+                var result = callback(array[i], i);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    ts.forEach = forEach;
+    function contains(array, value, areEqual) {
+        if (array) {
+            for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+                var v = array_1[_i];
+                if (areEqual ? areEqual(v, value) : v === value) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    ts.contains = contains;
+    function indexOf(array, value) {
+        if (array) {
+            for (var i = 0, len = array.length; i < len; i++) {
+                if (array[i] === value) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    ts.indexOf = indexOf;
+    function indexOfAnyCharCode(text, charCodes, start) {
+        for (var i = start || 0, len = text.length; i < len; i++) {
+            if (contains(charCodes, text.charCodeAt(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    ts.indexOfAnyCharCode = indexOfAnyCharCode;
+    function countWhere(array, predicate) {
+        var count = 0;
+        if (array) {
+            for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+                var v = array_2[_i];
+                if (predicate(v)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    ts.countWhere = countWhere;
+    function filter(array, f) {
+        var result;
+        if (array) {
+            result = [];
+            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
+                var item = array_3[_i];
+                if (f(item)) {
+                    result.push(item);
+                }
+            }
+        }
+        return result;
+    }
+    ts.filter = filter;
+    function filterMutate(array, f) {
+        var outIndex = 0;
+        for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
+            var item = array_4[_i];
+            if (f(item)) {
+                array[outIndex] = item;
+                outIndex++;
+            }
+        }
+        array.length = outIndex;
+    }
+    ts.filterMutate = filterMutate;
+    function map(array, f) {
+        var result;
+        if (array) {
+            result = [];
+            for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
+                var v = array_5[_i];
+                result.push(f(v));
+            }
+        }
+        return result;
+    }
+    ts.map = map;
+    function concatenate(array1, array2) {
+        if (!array2 || !array2.length)
+            return array1;
+        if (!array1 || !array1.length)
+            return array2;
+        return array1.concat(array2);
+    }
+    ts.concatenate = concatenate;
+    function deduplicate(array, areEqual) {
+        var result;
+        if (array) {
+            result = [];
+            for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
+                var item = array_6[_i];
+                if (!contains(result, item, areEqual)) {
+                    result.push(item);
+                }
+            }
+        }
+        return result;
+    }
+    ts.deduplicate = deduplicate;
+    function sum(array, prop) {
+        var result = 0;
+        for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
+            var v = array_7[_i];
+            result += v[prop];
+        }
+        return result;
+    }
+    ts.sum = sum;
+    function addRange(to, from) {
+        if (to && from) {
+            for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {
+                var v = from_1[_i];
+                to.push(v);
+            }
+        }
+    }
+    ts.addRange = addRange;
+    function rangeEquals(array1, array2, pos, end) {
+        while (pos < end) {
+            if (array1[pos] !== array2[pos]) {
+                return false;
+            }
+            pos++;
+        }
+        return true;
+    }
+    ts.rangeEquals = rangeEquals;
+    /**
+     * Returns the last element of an array if non-empty, undefined otherwise.
+     */
+    function lastOrUndefined(array) {
+        if (array.length === 0) {
+            return undefined;
+        }
+        return array[array.length - 1];
+    }
+    ts.lastOrUndefined = lastOrUndefined;
+    /**
+     * Performs a binary search, finding the index at which 'value' occurs in 'array'.
+     * If no such index is found, returns the 2's-complement of first index at which
+     * number[index] exceeds number.
+     * @param array A sorted array whose first element must be no larger than number
+     * @param number The value to be searched for in the array.
+     */
+    function binarySearch(array, value) {
+        var low = 0;
+        var high = array.length - 1;
+        while (low <= high) {
+            var middle = low + ((high - low) >> 1);
+            var midValue = array[middle];
+            if (midValue === value) {
+                return middle;
+            }
+            else if (midValue > value) {
+                high = middle - 1;
+            }
+            else {
+                low = middle + 1;
+            }
+        }
+        return ~low;
+    }
+    ts.binarySearch = binarySearch;
+    function reduceLeft(array, f, initial) {
+        if (array) {
+            var count = array.length;
+            if (count > 0) {
+                var pos = 0;
+                var result = void 0;
+                if (arguments.length <= 2) {
+                    result = array[pos];
+                    pos++;
+                }
+                else {
+                    result = initial;
+                }
+                while (pos < count) {
+                    result = f(result, array[pos]);
+                    pos++;
+                }
+                return result;
+            }
+        }
+        return initial;
+    }
+    ts.reduceLeft = reduceLeft;
+    function reduceRight(array, f, initial) {
+        if (array) {
+            var pos = array.length - 1;
+            if (pos >= 0) {
+                var result = void 0;
+                if (arguments.length <= 2) {
+                    result = array[pos];
+                    pos--;
+                }
+                else {
+                    result = initial;
+                }
+                while (pos >= 0) {
+                    result = f(result, array[pos]);
+                    pos--;
+                }
+                return result;
+            }
+        }
+        return initial;
+    }
+    ts.reduceRight = reduceRight;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    function hasProperty(map, key) {
+        return hasOwnProperty.call(map, key);
+    }
+    ts.hasProperty = hasProperty;
+    function getKeys(map) {
+        var keys = [];
+        for (var key in map) {
+            keys.push(key);
+        }
+        return keys;
+    }
+    ts.getKeys = getKeys;
+    function getProperty(map, key) {
+        return hasOwnProperty.call(map, key) ? map[key] : undefined;
+    }
+    ts.getProperty = getProperty;
+    function isEmpty(map) {
+        for (var id in map) {
+            if (hasProperty(map, id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ts.isEmpty = isEmpty;
+    function clone(object) {
+        var result = {};
+        for (var id in object) {
+            result[id] = object[id];
+        }
+        return result;
+    }
+    ts.clone = clone;
+    function extend(first, second) {
+        var result = {};
+        for (var id in first) {
+            result[id] = first[id];
+        }
+        for (var id in second) {
+            if (!hasProperty(result, id)) {
+                result[id] = second[id];
+            }
+        }
+        return result;
+    }
+    ts.extend = extend;
+    function forEachValue(map, callback) {
+        var result;
+        for (var id in map) {
+            if (result = callback(map[id]))
+                break;
+        }
+        return result;
+    }
+    ts.forEachValue = forEachValue;
+    function forEachKey(map, callback) {
+        var result;
+        for (var id in map) {
+            if (result = callback(id))
+                break;
+        }
+        return result;
+    }
+    ts.forEachKey = forEachKey;
+    function lookUp(map, key) {
+        return hasProperty(map, key) ? map[key] : undefined;
+    }
+    ts.lookUp = lookUp;
+    function copyMap(source, target) {
+        for (var p in source) {
+            target[p] = source[p];
+        }
+    }
+    ts.copyMap = copyMap;
+    /**
+     * Creates a map from the elements of an array.
+     *
+     * @param array the array of input elements.
+     * @param makeKey a function that produces a key for a given element.
+     *
+     * This function makes no effort to avoid collisions; if any two elements produce
+     * the same key with the given 'makeKey' function, then the element with the higher
+     * index in the array will be the one associated with the produced key.
+     */
+    function arrayToMap(array, makeKey) {
+        var result = {};
+        forEach(array, function (value) {
+            result[makeKey(value)] = value;
+        });
+        return result;
+    }
+    ts.arrayToMap = arrayToMap;
+    /**
+     * Reduce the properties of a map.
+     *
+     * @param map The map to reduce
+     * @param callback An aggregation function that is called for each entry in the map
+     * @param initial The initial value for the reduction.
+     */
+    function reduceProperties(map, callback, initial) {
+        var result = initial;
+        if (map) {
+            for (var key in map) {
+                if (hasProperty(map, key)) {
+                    result = callback(result, map[key], String(key));
+                }
+            }
+        }
+        return result;
+    }
+    ts.reduceProperties = reduceProperties;
+    /**
+     * Tests whether a value is an array.
+     */
+    function isArray(value) {
+        return Array.isArray ? Array.isArray(value) : value instanceof Array;
+    }
+    ts.isArray = isArray;
+    function memoize(callback) {
+        var value;
+        return function () {
+            if (callback) {
+                value = callback();
+                callback = undefined;
+            }
+            return value;
+        };
+    }
+    ts.memoize = memoize;
+    function formatStringFromArgs(text, args, baseIndex) {
+        baseIndex = baseIndex || 0;
+        return text.replace(/{(\d+)}/g, function (match, index) { return args[+index + baseIndex]; });
+    }
+    ts.localizedDiagnosticMessages = undefined;
+    function getLocaleSpecificMessage(message) {
+        return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message.key]
+            ? ts.localizedDiagnosticMessages[message.key]
+            : message.message;
+    }
+    ts.getLocaleSpecificMessage = getLocaleSpecificMessage;
+    function createFileDiagnostic(file, start, length, message) {
+        var end = start + length;
+        Debug.assert(start >= 0, "start must be non-negative, is " + start);
+        Debug.assert(length >= 0, "length must be non-negative, is " + length);
+        if (file) {
+            Debug.assert(start <= file.text.length, "start must be within the bounds of the file. " + start + " > " + file.text.length);
+            Debug.assert(end <= file.text.length, "end must be the bounds of the file. " + end + " > " + file.text.length);
+        }
+        var text = getLocaleSpecificMessage(message);
+        if (arguments.length > 4) {
+            text = formatStringFromArgs(text, arguments, 4);
+        }
+        return {
+            file: file,
+            start: start,
+            length: length,
+            messageText: text,
+            category: message.category,
+            code: message.code
+        };
+    }
+    ts.createFileDiagnostic = createFileDiagnostic;
+    /* internal */
+    function formatMessage(dummy, message) {
+        var text = getLocaleSpecificMessage(message);
+        if (arguments.length > 2) {
+            text = formatStringFromArgs(text, arguments, 2);
+        }
+        return text;
+    }
+    ts.formatMessage = formatMessage;
+    function createCompilerDiagnostic(message) {
+        var text = getLocaleSpecificMessage(message);
+        if (arguments.length > 1) {
+            text = formatStringFromArgs(text, arguments, 1);
+        }
+        return {
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: text,
+            category: message.category,
+            code: message.code
+        };
+    }
+    ts.createCompilerDiagnostic = createCompilerDiagnostic;
+    function chainDiagnosticMessages(details, message) {
+        var text = getLocaleSpecificMessage(message);
+        if (arguments.length > 2) {
+            text = formatStringFromArgs(text, arguments, 2);
+        }
+        return {
+            messageText: text,
+            category: message.category,
+            code: message.code,
+            next: details
+        };
+    }
+    ts.chainDiagnosticMessages = chainDiagnosticMessages;
+    function concatenateDiagnosticMessageChains(headChain, tailChain) {
+        var lastChain = headChain;
+        while (lastChain.next) {
+            lastChain = lastChain.next;
+        }
+        lastChain.next = tailChain;
+        return headChain;
+    }
+    ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains;
+    function compareValues(a, b) {
+        if (a === b)
+            return 0 /* EqualTo */;
+        if (a === undefined)
+            return -1 /* LessThan */;
+        if (b === undefined)
+            return 1 /* GreaterThan */;
+        return a < b ? -1 /* LessThan */ : 1 /* GreaterThan */;
+    }
+    ts.compareValues = compareValues;
+    function compareStrings(a, b, ignoreCase) {
+        if (a === b)
+            return 0 /* EqualTo */;
+        if (a === undefined)
+            return -1 /* LessThan */;
+        if (b === undefined)
+            return 1 /* GreaterThan */;
+        if (ignoreCase) {
+            if (String.prototype.localeCompare) {
+                var result = a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });
+                return result < 0 ? -1 /* LessThan */ : result > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
+            }
+            a = a.toUpperCase();
+            b = b.toUpperCase();
+            if (a === b)
+                return 0 /* EqualTo */;
+        }
+        return a < b ? -1 /* LessThan */ : 1 /* GreaterThan */;
+    }
+    ts.compareStrings = compareStrings;
+    function compareStringsCaseInsensitive(a, b) {
+        return compareStrings(a, b, /*ignoreCase*/ true);
+    }
+    ts.compareStringsCaseInsensitive = compareStringsCaseInsensitive;
+    function getDiagnosticFileName(diagnostic) {
+        return diagnostic.file ? diagnostic.file.fileName : undefined;
+    }
+    function compareDiagnostics(d1, d2) {
+        return compareValues(getDiagnosticFileName(d1), getDiagnosticFileName(d2)) ||
+            compareValues(d1.start, d2.start) ||
+            compareValues(d1.length, d2.length) ||
+            compareValues(d1.code, d2.code) ||
+            compareMessageText(d1.messageText, d2.messageText) ||
+            0 /* EqualTo */;
+    }
+    ts.compareDiagnostics = compareDiagnostics;
+    function compareMessageText(text1, text2) {
+        while (text1 && text2) {
+            // We still have both chains.
+            var string1 = typeof text1 === "string" ? text1 : text1.messageText;
+            var string2 = typeof text2 === "string" ? text2 : text2.messageText;
+            var res = compareValues(string1, string2);
+            if (res) {
+                return res;
+            }
+            text1 = typeof text1 === "string" ? undefined : text1.next;
+            text2 = typeof text2 === "string" ? undefined : text2.next;
+        }
+        if (!text1 && !text2) {
+            // if the chains are done, then these messages are the same.
+            return 0 /* EqualTo */;
+        }
+        // We still have one chain remaining.  The shorter chain should come first.
+        return text1 ? 1 /* GreaterThan */ : -1 /* LessThan */;
+    }
+    function sortAndDeduplicateDiagnostics(diagnostics) {
+        return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics));
+    }
+    ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics;
+    function deduplicateSortedDiagnostics(diagnostics) {
+        if (diagnostics.length < 2) {
+            return diagnostics;
+        }
+        var newDiagnostics = [diagnostics[0]];
+        var previousDiagnostic = diagnostics[0];
+        for (var i = 1; i < diagnostics.length; i++) {
+            var currentDiagnostic = diagnostics[i];
+            var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0 /* EqualTo */;
+            if (!isDupe) {
+                newDiagnostics.push(currentDiagnostic);
+                previousDiagnostic = currentDiagnostic;
+            }
+        }
+        return newDiagnostics;
+    }
+    ts.deduplicateSortedDiagnostics = deduplicateSortedDiagnostics;
+    function normalizeSlashes(path) {
+        return path.replace(/\\/g, "/");
+    }
+    ts.normalizeSlashes = normalizeSlashes;
+    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files")
+    function getRootLength(path) {
+        if (path.charCodeAt(0) === 47 /* slash */) {
+            if (path.charCodeAt(1) !== 47 /* slash */)
+                return 1;
+            var p1 = path.indexOf("/", 2);
+            if (p1 < 0)
+                return 2;
+            var p2 = path.indexOf("/", p1 + 1);
+            if (p2 < 0)
+                return p1 + 1;
+            return p2 + 1;
+        }
+        if (path.charCodeAt(1) === 58 /* colon */) {
+            if (path.charCodeAt(2) === 47 /* slash */)
+                return 3;
+            return 2;
+        }
+        // Per RFC 1738 'file' URI schema has the shape file://<host>/<path>
+        // if <host> is omitted then it is assumed that host value is 'localhost',
+        // however slash after the omitted <host> is not removed.
+        // file:///folder1/file1 - this is a correct URI
+        // file://folder2/file2 - this is an incorrect URI
+        if (path.lastIndexOf("file:///", 0) === 0) {
+            return "file:///".length;
+        }
+        var idx = path.indexOf("://");
+        if (idx !== -1) {
+            return idx + "://".length;
+        }
+        return 0;
+    }
+    ts.getRootLength = getRootLength;
+    ts.directorySeparator = "/";
+    function getNormalizedParts(normalizedSlashedPath, rootLength) {
+        var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);
+        var normalized = [];
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
+            if (part !== ".") {
+                if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
+                    normalized.pop();
+                }
+                else {
+                    // A part may be an empty string (which is 'falsy') if the path had consecutive slashes,
+                    // e.g. "path//file.ts".  Drop these before re-joining the parts.
+                    if (part) {
+                        normalized.push(part);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+    function normalizePath(path) {
+        path = normalizeSlashes(path);
+        var rootLength = getRootLength(path);
+        var normalized = getNormalizedParts(path, rootLength);
+        return path.substr(0, rootLength) + normalized.join(ts.directorySeparator);
+    }
+    ts.normalizePath = normalizePath;
+    function getDirectoryPath(path) {
+        return path.substr(0, Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator)));
+    }
+    ts.getDirectoryPath = getDirectoryPath;
+    function isUrl(path) {
+        return path && !isRootedDiskPath(path) && path.indexOf("://") !== -1;
+    }
+    ts.isUrl = isUrl;
+    function isRootedDiskPath(path) {
+        return getRootLength(path) !== 0;
+    }
+    ts.isRootedDiskPath = isRootedDiskPath;
+    function normalizedPathComponents(path, rootLength) {
+        var normalizedParts = getNormalizedParts(path, rootLength);
+        return [path.substr(0, rootLength)].concat(normalizedParts);
+    }
+    function getNormalizedPathComponents(path, currentDirectory) {
+        path = normalizeSlashes(path);
+        var rootLength = getRootLength(path);
+        if (rootLength === 0) {
+            // If the path is not rooted it is relative to current directory
+            path = combinePaths(normalizeSlashes(currentDirectory), path);
+            rootLength = getRootLength(path);
+        }
+        return normalizedPathComponents(path, rootLength);
+    }
+    ts.getNormalizedPathComponents = getNormalizedPathComponents;
+    function getNormalizedAbsolutePath(fileName, currentDirectory) {
+        return getNormalizedPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
+    }
+    ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath;
+    function getNormalizedPathFromPathComponents(pathComponents) {
+        if (pathComponents && pathComponents.length) {
+            return pathComponents[0] + pathComponents.slice(1).join(ts.directorySeparator);
+        }
+    }
+    ts.getNormalizedPathFromPathComponents = getNormalizedPathFromPathComponents;
+    function getNormalizedPathComponentsOfUrl(url) {
+        // Get root length of http://www.website.com/folder1/folder2/
+        // In this example the root is:  http://www.website.com/
+        // normalized path components should be ["http://www.website.com/", "folder1", "folder2"]
+        var urlLength = url.length;
+        // Initial root length is http:// part
+        var rootLength = url.indexOf("://") + "://".length;
+        while (rootLength < urlLength) {
+            // Consume all immediate slashes in the protocol
+            // eg.initial rootlength is just file:// but it needs to consume another "/" in file:///
+            if (url.charCodeAt(rootLength) === 47 /* slash */) {
+                rootLength++;
+            }
+            else {
+                // non slash character means we continue proceeding to next component of root search
+                break;
+            }
+        }
+        // there are no parts after http:// just return current string as the pathComponent
+        if (rootLength === urlLength) {
+            return [url];
+        }
+        // Find the index of "/" after website.com so the root can be http://www.website.com/ (from existing http://)
+        var indexOfNextSlash = url.indexOf(ts.directorySeparator, rootLength);
+        if (indexOfNextSlash !== -1) {
+            // Found the "/" after the website.com so the root is length of http://www.website.com/
+            // and get components after the root normally like any other folder components
+            rootLength = indexOfNextSlash + 1;
+            return normalizedPathComponents(url, rootLength);
+        }
+        else {
+            // Can't find the host assume the rest of the string as component
+            // but make sure we append "/"  to it as root is not joined using "/"
+            // eg. if url passed in was http://website.com we want to use root as [http://website.com/]
+            // so that other path manipulations will be correct and it can be merged with relative paths correctly
+            return [url + ts.directorySeparator];
+        }
+    }
+    function getNormalizedPathOrUrlComponents(pathOrUrl, currentDirectory) {
+        if (isUrl(pathOrUrl)) {
+            return getNormalizedPathComponentsOfUrl(pathOrUrl);
+        }
+        else {
+            return getNormalizedPathComponents(pathOrUrl, currentDirectory);
+        }
+    }
+    function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
+        var pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
+        var directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
+        if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") {
+            // If the directory path given was of type test/cases/ then we really need components of directory to be only till its name
+            // that is  ["test", "cases", ""] needs to be actually ["test", "cases"]
+            directoryComponents.length--;
+        }
+        // Find the component that differs
+        var joinStartIndex;
+        for (joinStartIndex = 0; joinStartIndex < pathComponents.length && joinStartIndex < directoryComponents.length; joinStartIndex++) {
+            if (getCanonicalFileName(directoryComponents[joinStartIndex]) !== getCanonicalFileName(pathComponents[joinStartIndex])) {
+                break;
+            }
+        }
+        // Get the relative path
+        if (joinStartIndex) {
+            var relativePath = "";
+            var relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length);
+            for (; joinStartIndex < directoryComponents.length; joinStartIndex++) {
+                if (directoryComponents[joinStartIndex] !== "") {
+                    relativePath = relativePath + ".." + ts.directorySeparator;
+                }
+            }
+            return relativePath + relativePathComponents.join(ts.directorySeparator);
+        }
+        // Cant find the relative path, get the absolute path
+        var absolutePath = getNormalizedPathFromPathComponents(pathComponents);
+        if (isAbsolutePathAnUrl && isRootedDiskPath(absolutePath)) {
+            absolutePath = "file:///" + absolutePath;
+        }
+        return absolutePath;
+    }
+    ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl;
+    function getBaseFileName(path) {
+        if (path === undefined) {
+            return undefined;
+        }
+        var i = path.lastIndexOf(ts.directorySeparator);
+        return i < 0 ? path : path.substring(i + 1);
+    }
+    ts.getBaseFileName = getBaseFileName;
+    function combinePaths(path1, path2) {
+        if (!(path1 && path1.length))
+            return path2;
+        if (!(path2 && path2.length))
+            return path1;
+        if (getRootLength(path2) !== 0)
+            return path2;
+        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
+            return path1 + path2;
+        return path1 + ts.directorySeparator + path2;
+    }
+    ts.combinePaths = combinePaths;
+    /**
+     * Removes a trailing directory separator from a path.
+     * @param path The path.
+     */
+    function removeTrailingDirectorySeparator(path) {
+        if (path.charAt(path.length - 1) === ts.directorySeparator) {
+            return path.substr(0, path.length - 1);
+        }
+        return path;
+    }
+    ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
+    /**
+     * Adds a trailing directory separator to a path, if it does not already have one.
+     * @param path The path.
+     */
+    function ensureTrailingDirectorySeparator(path) {
+        if (path.charAt(path.length - 1) !== ts.directorySeparator) {
+            return path + ts.directorySeparator;
+        }
+        return path;
+    }
+    ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
+    function comparePaths(a, b, currentDirectory, ignoreCase) {
+        if (a === b)
+            return 0 /* EqualTo */;
+        if (a === undefined)
+            return -1 /* LessThan */;
+        if (b === undefined)
+            return 1 /* GreaterThan */;
+        a = removeTrailingDirectorySeparator(a);
+        b = removeTrailingDirectorySeparator(b);
+        var aComponents = getNormalizedPathComponents(a, currentDirectory);
+        var bComponents = getNormalizedPathComponents(b, currentDirectory);
+        var sharedLength = Math.min(aComponents.length, bComponents.length);
+        for (var i = 0; i < sharedLength; i++) {
+            var result = compareStrings(aComponents[i], bComponents[i], ignoreCase);
+            if (result !== 0 /* EqualTo */) {
+                return result;
+            }
+        }
+        return compareValues(aComponents.length, bComponents.length);
+    }
+    ts.comparePaths = comparePaths;
+    function containsPath(parent, child, currentDirectory, ignoreCase) {
+        if (parent === undefined || child === undefined)
+            return false;
+        if (parent === child)
+            return true;
+        parent = removeTrailingDirectorySeparator(parent);
+        child = removeTrailingDirectorySeparator(child);
+        if (parent === child)
+            return true;
+        var parentComponents = getNormalizedPathComponents(parent, currentDirectory);
+        var childComponents = getNormalizedPathComponents(child, currentDirectory);
+        if (childComponents.length < parentComponents.length) {
+            return false;
+        }
+        for (var i = 0; i < parentComponents.length; i++) {
+            var result = compareStrings(parentComponents[i], childComponents[i], ignoreCase);
+            if (result !== 0 /* EqualTo */) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ts.containsPath = containsPath;
+    function fileExtensionIs(path, extension) {
+        var pathLen = path.length;
+        var extLen = extension.length;
+        return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension;
+    }
+    ts.fileExtensionIs = fileExtensionIs;
+    function fileExtensionIsAny(path, extensions) {
+        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
+            var extension = extensions_1[_i];
+            if (fileExtensionIs(path, extension)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ts.fileExtensionIsAny = fileExtensionIsAny;
+    // Reserved characters, forces escaping of any non-word (or digit), non-whitespace character.
+    // It may be inefficient (we could just match (/[-[\]{}()*+?.,\\^$|#\s]/g), but this is future
+    // proof.
+    var reservedCharacterPattern = /[^\w\s\/]/g;
+    var wildcardCharCodes = [42 /* asterisk */, 63 /* question */];
+    function getRegularExpressionForWildcard(specs, basePath, usage) {
+        if (specs === undefined || specs.length === 0) {
+            return undefined;
+        }
+        var pattern = "";
+        var hasWrittenSubpattern = false;
+        spec: for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {
+            var spec = specs_1[_i];
+            if (!spec) {
+                continue;
+            }
+            var subpattern = "";
+            var hasRecursiveDirectoryWildcard = false;
+            var hasWrittenComponent = false;
+            var components = getNormalizedPathComponents(spec, basePath);
+            if (usage !== "exclude" && components[components.length - 1] === "**") {
+                continue spec;
+            }
+            // getNormalizedPathComponents includes the separator for the root component.
+            // We need to remove to create our regex correctly.
+            components[0] = removeTrailingDirectorySeparator(components[0]);
+            var optionalCount = 0;
+            for (var _a = 0, components_1 = components; _a < components_1.length; _a++) {
+                var component = components_1[_a];
+                if (component === "**") {
+                    if (hasRecursiveDirectoryWildcard) {
+                        continue spec;
+                    }
+                    subpattern += "(/.+?)?";
+                    hasRecursiveDirectoryWildcard = true;
+                    hasWrittenComponent = true;
+                }
+                else {
+                    if (usage === "directories") {
+                        subpattern += "(";
+                        optionalCount++;
+                    }
+                    if (hasWrittenComponent) {
+                        subpattern += ts.directorySeparator;
+                    }
+                    subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter);
+                    hasWrittenComponent = true;
+                }
+            }
+            while (optionalCount > 0) {
+                subpattern += ")?";
+                optionalCount--;
+            }
+            if (hasWrittenSubpattern) {
+                pattern += "|";
+            }
+            pattern += "(" + subpattern + ")";
+            hasWrittenSubpattern = true;
+        }
+        if (!pattern) {
+            return undefined;
+        }
+        return "^(" + pattern + (usage === "exclude" ? ")($|/)" : ")$");
+    }
+    ts.getRegularExpressionForWildcard = getRegularExpressionForWildcard;
+    function replaceWildcardCharacter(match) {
+        return match === "*" ? "[^/]*" : match === "?" ? "[^/]" : "\\" + match;
+    }
+    function getFileMatcherPatterns(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory) {
+        path = normalizePath(path);
+        currentDirectory = normalizePath(currentDirectory);
+        var absolutePath = combinePaths(currentDirectory, path);
+        return {
+            includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
+            includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
+            excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
+            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+        };
+    }
+    ts.getFileMatcherPatterns = getFileMatcherPatterns;
+    function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, getFileSystemEntries) {
+        path = normalizePath(path);
+        currentDirectory = normalizePath(currentDirectory);
+        var patterns = getFileMatcherPatterns(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
+        var regexFlag = useCaseSensitiveFileNames ? "" : "i";
+        var includeFileRegex = patterns.includeFilePattern && new RegExp(patterns.includeFilePattern, regexFlag);
+        var includeDirectoryRegex = patterns.includeDirectoryPattern && new RegExp(patterns.includeDirectoryPattern, regexFlag);
+        var excludeRegex = patterns.excludePattern && new RegExp(patterns.excludePattern, regexFlag);
+        var result = [];
+        for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
+            var basePath = _a[_i];
+            visitDirectory(basePath, combinePaths(currentDirectory, basePath));
+        }
+        return result;
+        function visitDirectory(path, absolutePath) {
+            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+                var current = files_1[_i];
+                var name_1 = combinePaths(path, current);
+                var absoluteName = combinePaths(absolutePath, current);
+                if ((!extensions || fileExtensionIsAny(name_1, extensions)) &&
+                    (!includeFileRegex || includeFileRegex.test(absoluteName)) &&
+                    (!excludeRegex || !excludeRegex.test(absoluteName))) {
+                    result.push(name_1);
+                }
+            }
+            for (var _b = 0, directories_1 = directories; _b < directories_1.length; _b++) {
+                var current = directories_1[_b];
+                var name_2 = combinePaths(path, current);
+                var absoluteName = combinePaths(absolutePath, current);
+                if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
+                    (!excludeRegex || !excludeRegex.test(absoluteName))) {
+                    visitDirectory(name_2, absoluteName);
+                }
+            }
+        }
+    }
+    ts.matchFiles = matchFiles;
+    /**
+     * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     */
+    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+        // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
+        var basePaths = [path];
+        if (includes) {
+            // Storage for literal base paths amongst the include patterns.
+            var includeBasePaths = [];
+            for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) {
+                var include = includes_1[_i];
+                // We also need to check the relative paths by converting them to absolute and normalizing
+                // in case they escape the base path (e.g "..\somedirectory")
+                var absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
+                var wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
+                var includeBasePath = wildcardOffset < 0
+                    ? removeTrailingDirectorySeparator(getDirectoryPath(absolute))
+                    : absolute.substring(0, absolute.lastIndexOf(ts.directorySeparator, wildcardOffset));
+                // Append the literal and canonical candidate base paths.
+                includeBasePaths.push(includeBasePath);
+            }
+            // Sort the offsets array using either the literal or canonical path representations.
+            includeBasePaths.sort(useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
+            // Iterate over each include base path and include unique base paths that are not a
+            // subpath of an existing base path
+            include: for (var i = 0; i < includeBasePaths.length; i++) {
+                var includeBasePath = includeBasePaths[i];
+                for (var j = 0; j < basePaths.length; j++) {
+                    if (containsPath(basePaths[j], includeBasePath, path, !useCaseSensitiveFileNames)) {
+                        continue include;
+                    }
+                }
+                basePaths.push(includeBasePath);
+            }
+        }
+        return basePaths;
+    }
+    function ensureScriptKind(fileName, scriptKind) {
+        // Using scriptKind as a condition handles both:
+        // - 'scriptKind' is unspecified and thus it is `undefined`
+        // - 'scriptKind' is set and it is `Unknown` (0)
+        // If the 'scriptKind' is 'undefined' or 'Unknown' then we attempt
+        // to get the ScriptKind from the file name. If it cannot be resolved
+        // from the file name then the default 'TS' script kind is returned.
+        return (scriptKind || getScriptKindFromFileName(fileName)) || 3 /* TS */;
+    }
+    ts.ensureScriptKind = ensureScriptKind;
+    function getScriptKindFromFileName(fileName) {
+        var ext = fileName.substr(fileName.lastIndexOf("."));
+        switch (ext.toLowerCase()) {
+            case ".js":
+                return 1 /* JS */;
+            case ".jsx":
+                return 2 /* JSX */;
+            case ".ts":
+                return 3 /* TS */;
+            case ".tsx":
+                return 4 /* TSX */;
+            default:
+                return 0 /* Unknown */;
+        }
+    }
+    ts.getScriptKindFromFileName = getScriptKindFromFileName;
+    /**
+     *  List of supported extensions in order of file resolution precedence.
+     */
+    ts.supportedTypeScriptExtensions = [".ts", ".tsx", ".d.ts"];
+    ts.supportedJavascriptExtensions = [".js", ".jsx"];
+    var allSupportedExtensions = ts.supportedTypeScriptExtensions.concat(ts.supportedJavascriptExtensions);
+    function getSupportedExtensions(options) {
+        return options && options.allowJs ? allSupportedExtensions : ts.supportedTypeScriptExtensions;
+    }
+    ts.getSupportedExtensions = getSupportedExtensions;
+    function isSupportedSourceFileName(fileName, compilerOptions) {
+        if (!fileName) {
+            return false;
+        }
+        for (var _i = 0, _a = getSupportedExtensions(compilerOptions); _i < _a.length; _i++) {
+            var extension = _a[_i];
+            if (fileExtensionIs(fileName, extension)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ts.isSupportedSourceFileName = isSupportedSourceFileName;
+    /**
+     * Extension boundaries by priority. Lower numbers indicate higher priorities, and are
+     * aligned to the offset of the highest priority extension in the
+     * allSupportedExtensions array.
+     */
+    (function (ExtensionPriority) {
+        ExtensionPriority[ExtensionPriority["TypeScriptFiles"] = 0] = "TypeScriptFiles";
+        ExtensionPriority[ExtensionPriority["DeclarationAndJavaScriptFiles"] = 2] = "DeclarationAndJavaScriptFiles";
+        ExtensionPriority[ExtensionPriority["Limit"] = 5] = "Limit";
+        ExtensionPriority[ExtensionPriority["Highest"] = 0] = "Highest";
+        ExtensionPriority[ExtensionPriority["Lowest"] = 2] = "Lowest";
+    })(ts.ExtensionPriority || (ts.ExtensionPriority = {}));
+    var ExtensionPriority = ts.ExtensionPriority;
+    function getExtensionPriority(path, supportedExtensions) {
+        for (var i = supportedExtensions.length - 1; i >= 0; i--) {
+            if (fileExtensionIs(path, supportedExtensions[i])) {
+                return adjustExtensionPriority(i);
+            }
+        }
+        // If its not in the list of supported extensions, this is likely a
+        // TypeScript file with a non-ts extension
+        return 0 /* Highest */;
+    }
+    ts.getExtensionPriority = getExtensionPriority;
+    /**
+     * Adjusts an extension priority to be the highest priority within the same range.
+     */
+    function adjustExtensionPriority(extensionPriority) {
+        if (extensionPriority < 2 /* DeclarationAndJavaScriptFiles */) {
+            return 0 /* TypeScriptFiles */;
+        }
+        else if (extensionPriority < 5 /* Limit */) {
+            return 2 /* DeclarationAndJavaScriptFiles */;
+        }
+        else {
+            return 5 /* Limit */;
+        }
+    }
+    ts.adjustExtensionPriority = adjustExtensionPriority;
+    /**
+     * Gets the next lowest extension priority for a given priority.
+     */
+    function getNextLowestExtensionPriority(extensionPriority) {
+        if (extensionPriority < 2 /* DeclarationAndJavaScriptFiles */) {
+            return 2 /* DeclarationAndJavaScriptFiles */;
+        }
+        else {
+            return 5 /* Limit */;
+        }
+    }
+    ts.getNextLowestExtensionPriority = getNextLowestExtensionPriority;
+    var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
+    function removeFileExtension(path) {
+        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
+            var ext = extensionsToRemove_1[_i];
+            var extensionless = tryRemoveExtension(path, ext);
+            if (extensionless !== undefined) {
+                return extensionless;
+            }
+        }
+        return path;
+    }
+    ts.removeFileExtension = removeFileExtension;
+    function tryRemoveExtension(path, extension) {
+        return fileExtensionIs(path, extension) ? path.substring(0, path.length - extension.length) : undefined;
+    }
+    ts.tryRemoveExtension = tryRemoveExtension;
+    function isJsxOrTsxExtension(ext) {
+        return ext === ".jsx" || ext === ".tsx";
+    }
+    ts.isJsxOrTsxExtension = isJsxOrTsxExtension;
+    function changeExtension(path, newExtension) {
+        return (removeFileExtension(path) + newExtension);
+    }
+    ts.changeExtension = changeExtension;
+    function Symbol(flags, name) {
+        this.flags = flags;
+        this.name = name;
+        this.declarations = undefined;
+    }
+    function Type(checker, flags) {
+        this.flags = flags;
+    }
+    function Signature(checker) {
+    }
+    function Node(kind, pos, end) {
+        this.kind = kind;
+        this.pos = pos;
+        this.end = end;
+        this.flags = 0 /* None */;
+        this.parent = undefined;
+    }
+    ts.objectAllocator = {
+        getNodeConstructor: function () { return Node; },
+        getSourceFileConstructor: function () { return Node; },
+        getSymbolConstructor: function () { return Symbol; },
+        getTypeConstructor: function () { return Type; },
+        getSignatureConstructor: function () { return Signature; }
+    };
+    (function (AssertionLevel) {
+        AssertionLevel[AssertionLevel["None"] = 0] = "None";
+        AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal";
+        AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive";
+        AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive";
+    })(ts.AssertionLevel || (ts.AssertionLevel = {}));
+    var AssertionLevel = ts.AssertionLevel;
+    var Debug;
+    (function (Debug) {
+        var currentAssertionLevel = 0 /* None */;
+        function shouldAssert(level) {
+            return currentAssertionLevel >= level;
+        }
+        Debug.shouldAssert = shouldAssert;
+        function assert(expression, message, verboseDebugInfo) {
+            if (!expression) {
+                var verboseDebugString = "";
+                if (verboseDebugInfo) {
+                    verboseDebugString = "\r\nVerbose Debug Information: " + verboseDebugInfo();
+                }
+                debugger;
+                throw new Error("Debug Failure. False expression: " + (message || "") + verboseDebugString);
+            }
+        }
+        Debug.assert = assert;
+        function fail(message) {
+            Debug.assert(/*expression*/ false, message);
+        }
+        Debug.fail = fail;
+    })(Debug = ts.Debug || (ts.Debug = {}));
+    function copyListRemovingItem(item, list) {
+        var copiedList = [];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var e = list_1[_i];
+            if (e !== item) {
+                copiedList.push(e);
+            }
+        }
+        return copiedList;
+    }
+    ts.copyListRemovingItem = copyListRemovingItem;
+    function createGetCanonicalFileName(useCaseSensitivefileNames) {
+        return useCaseSensitivefileNames
+            ? (function (fileName) { return fileName; })
+            : (function (fileName) { return fileName.toLowerCase(); });
+    }
+    ts.createGetCanonicalFileName = createGetCanonicalFileName;
+})(ts || (ts = {}));
+/// <reference path="core.ts"/>
+var ts;
+(function (ts) {
+    ts.sys = (function () {
+        function getWScriptSystem() {
+            var fso = new ActiveXObject("Scripting.FileSystemObject");
+            var shell = new ActiveXObject("WScript.Shell");
+            var fileStream = new ActiveXObject("ADODB.Stream");
+            fileStream.Type = 2 /*text*/;
+            var binaryStream = new ActiveXObject("ADODB.Stream");
+            binaryStream.Type = 1 /*binary*/;
+            var args = [];
+            for (var i = 0; i < WScript.Arguments.length; i++) {
+                args[i] = WScript.Arguments.Item(i);
+            }
+            function readFile(fileName, encoding) {
+                if (!fso.FileExists(fileName)) {
+                    return undefined;
+                }
+                fileStream.Open();
+                try {
+                    if (encoding) {
+                        fileStream.Charset = encoding;
+                        fileStream.LoadFromFile(fileName);
+                    }
+                    else {
+                        // Load file and read the first two bytes into a string with no interpretation
+                        fileStream.Charset = "x-ansi";
+                        fileStream.LoadFromFile(fileName);
+                        var bom = fileStream.ReadText(2) || "";
+                        // Position must be at 0 before encoding can be changed
+                        fileStream.Position = 0;
+                        // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8
+                        fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8";
+                    }
+                    // ReadText method always strips byte order mark from resulting string
+                    return fileStream.ReadText();
+                }
+                catch (e) {
+                    throw e;
+                }
+                finally {
+                    fileStream.Close();
+                }
+            }
+            function writeFile(fileName, data, writeByteOrderMark) {
+                fileStream.Open();
+                binaryStream.Open();
+                try {
+                    // Write characters in UTF-8 encoding
+                    fileStream.Charset = "utf-8";
+                    fileStream.WriteText(data);
+                    // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM).
+                    // If not, start from position 0, as the BOM will be added automatically when charset==utf8.
+                    if (writeByteOrderMark) {
+                        fileStream.Position = 0;
+                    }
+                    else {
+                        fileStream.Position = 3;
+                    }
+                    fileStream.CopyTo(binaryStream);
+                    binaryStream.SaveToFile(fileName, 2 /*overwrite*/);
+                }
+                finally {
+                    binaryStream.Close();
+                    fileStream.Close();
+                }
+            }
+            function getNames(collection) {
+                var result = [];
+                for (var e = new Enumerator(collection); !e.atEnd(); e.moveNext()) {
+                    result.push(e.item().Name);
+                }
+                return result.sort();
+            }
+            function getDirectories(path) {
+                var folder = fso.GetFolder(path);
+                return getNames(folder.subfolders);
+            }
+            function getAccessibleFileSystemEntries(path) {
+                try {
+                    var folder = fso.GetFolder(path || ".");
+                    var files = getNames(folder.files);
+                    var directories = getNames(folder.subfolders);
+                    return { files: files, directories: directories };
+                }
+                catch (e) {
+                    return { files: [], directories: [] };
+                }
+            }
+            function readDirectory(path, extensions, excludes, includes) {
+                return ts.matchFiles(path, extensions, excludes, includes, /*useCaseSensitiveFileNames*/ false, shell.CurrentDirectory, getAccessibleFileSystemEntries);
+            }
+            return {
+                args: args,
+                newLine: "\r\n",
+                useCaseSensitiveFileNames: false,
+                write: function (s) {
+                    WScript.StdOut.Write(s);
+                },
+                readFile: readFile,
+                writeFile: writeFile,
+                resolvePath: function (path) {
+                    return fso.GetAbsolutePathName(path);
+                },
+                fileExists: function (path) {
+                    return fso.FileExists(path);
+                },
+                directoryExists: function (path) {
+                    return fso.FolderExists(path);
+                },
+                createDirectory: function (directoryName) {
+                    if (!this.directoryExists(directoryName)) {
+                        fso.CreateFolder(directoryName);
+                    }
+                },
+                getExecutingFilePath: function () {
+                    return WScript.ScriptFullName;
+                },
+                getCurrentDirectory: function () {
+                    return shell.CurrentDirectory;
+                },
+                getDirectories: getDirectories,
+                readDirectory: readDirectory,
+                exit: function (exitCode) {
+                    try {
+                        WScript.Quit(exitCode);
+                    }
+                    catch (e) {
+                    }
+                }
+            };
+        }
+        function getNodeSystem() {
+            var _fs = require("fs");
+            var _path = require("path");
+            var _os = require("os");
+            var _crypto = require("crypto");
+            var useNonPollingWatchers = process.env["TSC_NONPOLLING_WATCHER"];
+            function createWatchedFileSet() {
+                var dirWatchers = {};
+                // One file can have multiple watchers
+                var fileWatcherCallbacks = {};
+                return { addFile: addFile, removeFile: removeFile };
+                function reduceDirWatcherRefCountForFile(fileName) {
+                    var dirName = ts.getDirectoryPath(fileName);
+                    if (ts.hasProperty(dirWatchers, dirName)) {
+                        var watcher = dirWatchers[dirName];
+                        watcher.referenceCount -= 1;
+                        if (watcher.referenceCount <= 0) {
+                            watcher.close();
+                            delete dirWatchers[dirName];
+                        }
+                    }
+                }
+                function addDirWatcher(dirPath) {
+                    if (ts.hasProperty(dirWatchers, dirPath)) {
+                        var watcher_1 = dirWatchers[dirPath];
+                        watcher_1.referenceCount += 1;
+                        return;
+                    }
+                    var watcher = _fs.watch(dirPath, { persistent: true }, function (eventName, relativeFileName) { return fileEventHandler(eventName, relativeFileName, dirPath); });
+                    watcher.referenceCount = 1;
+                    dirWatchers[dirPath] = watcher;
+                    return;
+                }
+                function addFileWatcherCallback(filePath, callback) {
+                    if (ts.hasProperty(fileWatcherCallbacks, filePath)) {
+                        fileWatcherCallbacks[filePath].push(callback);
+                    }
+                    else {
+                        fileWatcherCallbacks[filePath] = [callback];
+                    }
+                }
+                function addFile(fileName, callback) {
+                    addFileWatcherCallback(fileName, callback);
+                    addDirWatcher(ts.getDirectoryPath(fileName));
+                    return { fileName: fileName, callback: callback };
+                }
+                function removeFile(watchedFile) {
+                    removeFileWatcherCallback(watchedFile.fileName, watchedFile.callback);
+                    reduceDirWatcherRefCountForFile(watchedFile.fileName);
+                }
+                function removeFileWatcherCallback(filePath, callback) {
+                    if (ts.hasProperty(fileWatcherCallbacks, filePath)) {
+                        var newCallbacks = ts.copyListRemovingItem(callback, fileWatcherCallbacks[filePath]);
+                        if (newCallbacks.length === 0) {
+                            delete fileWatcherCallbacks[filePath];
+                        }
+                        else {
+                            fileWatcherCallbacks[filePath] = newCallbacks;
+                        }
+                    }
+                }
+                function fileEventHandler(eventName, relativeFileName, baseDirPath) {
+                    // When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined"
+                    var fileName = typeof relativeFileName !== "string"
+                        ? undefined
+                        : ts.getNormalizedAbsolutePath(relativeFileName, baseDirPath);
+                    // Some applications save a working file via rename operations
+                    if ((eventName === "change" || eventName === "rename") && ts.hasProperty(fileWatcherCallbacks, fileName)) {
+                        for (var _i = 0, _a = fileWatcherCallbacks[fileName]; _i < _a.length; _i++) {
+                            var fileCallback = _a[_i];
+                            fileCallback(fileName);
+                        }
+                    }
+                }
+            }
+            var watchedFileSet = createWatchedFileSet();
+            function isNode4OrLater() {
+                return parseInt(process.version.charAt(1)) >= 4;
+            }
+            var platform = _os.platform();
+            // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
+            var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
+            function readFile(fileName, encoding) {
+                if (!fileExists(fileName)) {
+                    return undefined;
+                }
+                var buffer = _fs.readFileSync(fileName);
+                var len = buffer.length;
+                if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
+                    // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
+                    // flip all byte pairs and treat as little endian.
+                    len &= ~1;
+                    for (var i = 0; i < len; i += 2) {
+                        var temp = buffer[i];
+                        buffer[i] = buffer[i + 1];
+                        buffer[i + 1] = temp;
+                    }
+                    return buffer.toString("utf16le", 2);
+                }
+                if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) {
+                    // Little endian UTF-16 byte order mark detected
+                    return buffer.toString("utf16le", 2);
+                }
+                if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
+                    // UTF-8 byte order mark detected
+                    return buffer.toString("utf8", 3);
+                }
+                // Default is UTF-8 with no byte order mark
+                return buffer.toString("utf8");
+            }
+            function writeFile(fileName, data, writeByteOrderMark) {
+                // If a BOM is required, emit one
+                if (writeByteOrderMark) {
+                    data = "\uFEFF" + data;
+                }
+                var fd;
+                try {
+                    fd = _fs.openSync(fileName, "w");
+                    _fs.writeSync(fd, data, undefined, "utf8");
+                }
+                finally {
+                    if (fd !== undefined) {
+                        _fs.closeSync(fd);
+                    }
+                }
+            }
+            function getAccessibleFileSystemEntries(path) {
+                try {
+                    var entries = _fs.readdirSync(path || ".").sort();
+                    var files = [];
+                    var directories = [];
+                    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+                        var entry = entries_1[_i];
+                        // This is necessary because on some file system node fails to exclude
+                        // "." and "..". See https://github.com/nodejs/node/issues/4002
+                        if (entry === "." || entry === "..") {
+                            continue;
+                        }
+                        var name_3 = ts.combinePaths(path, entry);
+                        var stat = void 0;
+                        try {
+                            stat = _fs.statSync(name_3);
+                        }
+                        catch (e) {
+                            continue;
+                        }
+                        if (stat.isFile()) {
+                            files.push(entry);
+                        }
+                        else if (stat.isDirectory()) {
+                            directories.push(entry);
+                        }
+                    }
+                    return { files: files, directories: directories };
+                }
+                catch (e) {
+                    return { files: [], directories: [] };
+                }
+            }
+            function readDirectory(path, extensions, excludes, includes) {
+                return ts.matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), getAccessibleFileSystemEntries);
+            }
+            var FileSystemEntryKind;
+            (function (FileSystemEntryKind) {
+                FileSystemEntryKind[FileSystemEntryKind["File"] = 0] = "File";
+                FileSystemEntryKind[FileSystemEntryKind["Directory"] = 1] = "Directory";
+            })(FileSystemEntryKind || (FileSystemEntryKind = {}));
+            function fileSystemEntryExists(path, entryKind) {
+                try {
+                    var stat = _fs.statSync(path);
+                    switch (entryKind) {
+                        case 0 /* File */: return stat.isFile();
+                        case 1 /* Directory */: return stat.isDirectory();
+                    }
+                }
+                catch (e) {
+                    return false;
+                }
+            }
+            function fileExists(path) {
+                return fileSystemEntryExists(path, 0 /* File */);
+            }
+            function directoryExists(path) {
+                return fileSystemEntryExists(path, 1 /* Directory */);
+            }
+            function getDirectories(path) {
+                return ts.filter(_fs.readdirSync(path), function (p) { return fileSystemEntryExists(ts.combinePaths(path, p), 1 /* Directory */); });
+            }
+            return {
+                args: process.argv.slice(2),
+                newLine: _os.EOL,
+                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+                write: function (s) {
+                    process.stdout.write(s);
+                },
+                readFile: readFile,
+                writeFile: writeFile,
+                watchFile: function (fileName, callback) {
+                    if (useNonPollingWatchers) {
+                        var watchedFile_1 = watchedFileSet.addFile(fileName, callback);
+                        return {
+                            close: function () { return watchedFileSet.removeFile(watchedFile_1); }
+                        };
+                    }
+                    else {
+                        _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
+                        return {
+                            close: function () { return _fs.unwatchFile(fileName, fileChanged); }
+                        };
+                    }
+                    function fileChanged(curr, prev) {
+                        if (+curr.mtime <= +prev.mtime) {
+                            return;
+                        }
+                        callback(fileName);
+                    }
+                },
+                watchDirectory: function (directoryName, callback, recursive) {
+                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
+                    // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                    var options;
+                    if (isNode4OrLater() && (process.platform === "win32" || process.platform === "darwin")) {
+                        options = { persistent: true, recursive: !!recursive };
+                    }
+                    else {
+                        options = { persistent: true };
+                    }
+                    return _fs.watch(directoryName, options, function (eventName, relativeFileName) {
+                        // In watchDirectory we only care about adding and removing files (when event name is
+                        // "rename"); changes made within files are handled by corresponding fileWatchers (when
+                        // event name is "change")
+                        if (eventName === "rename") {
+                            // When deleting a file, the passed baseFileName is null
+                            callback(!relativeFileName ? relativeFileName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName)));
+                        }
+                        ;
+                    });
+                },
+                resolvePath: function (path) {
+                    return _path.resolve(path);
+                },
+                fileExists: fileExists,
+                directoryExists: directoryExists,
+                createDirectory: function (directoryName) {
+                    if (!this.directoryExists(directoryName)) {
+                        _fs.mkdirSync(directoryName);
+                    }
+                },
+                getExecutingFilePath: function () {
+                    return __filename;
+                },
+                getCurrentDirectory: function () {
+                    return process.cwd();
+                },
+                getDirectories: getDirectories,
+                readDirectory: readDirectory,
+                getModifiedTime: function (path) {
+                    try {
+                        return _fs.statSync(path).mtime;
+                    }
+                    catch (e) {
+                        return undefined;
+                    }
+                },
+                createHash: function (data) {
+                    var hash = _crypto.createHash("md5");
+                    hash.update(data);
+                    return hash.digest("hex");
+                },
+                getMemoryUsage: function () {
+                    if (global.gc) {
+                        global.gc();
+                    }
+                    return process.memoryUsage().heapUsed;
+                },
+                getFileSize: function (path) {
+                    try {
+                        var stat = _fs.statSync(path);
+                        if (stat.isFile()) {
+                            return stat.size;
+                        }
+                    }
+                    catch (e) { }
+                    return 0;
+                },
+                exit: function (exitCode) {
+                    process.exit(exitCode);
+                },
+                realpath: function (path) {
+                    return _fs.realpathSync(path);
+                }
+            };
+        }
+        function getChakraSystem() {
+            var realpath = ChakraHost.realpath && (function (path) { return ChakraHost.realpath(path); });
+            return {
+                newLine: ChakraHost.newLine || "\r\n",
+                args: ChakraHost.args,
+                useCaseSensitiveFileNames: !!ChakraHost.useCaseSensitiveFileNames,
+                write: ChakraHost.echo,
+                readFile: function (path, encoding) {
+                    // encoding is automatically handled by the implementation in ChakraHost
+                    return ChakraHost.readFile(path);
+                },
+                writeFile: function (path, data, writeByteOrderMark) {
+                    // If a BOM is required, emit one
+                    if (writeByteOrderMark) {
+                        data = "\uFEFF" + data;
+                    }
+                    ChakraHost.writeFile(path, data);
+                },
+                resolvePath: ChakraHost.resolvePath,
+                fileExists: ChakraHost.fileExists,
+                directoryExists: ChakraHost.directoryExists,
+                createDirectory: ChakraHost.createDirectory,
+                getExecutingFilePath: function () { return ChakraHost.executingFile; },
+                getCurrentDirectory: function () { return ChakraHost.currentDirectory; },
+                getDirectories: ChakraHost.getDirectories,
+                readDirectory: function (path, extensions, excludes, includes) {
+                    var pattern = ts.getFileMatcherPatterns(path, extensions, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory);
+                    return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern);
+                },
+                exit: ChakraHost.quit,
+                realpath: realpath
+            };
+        }
+        if (typeof ChakraHost !== "undefined") {
+            return getChakraSystem();
+        }
+        else if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
+            return getWScriptSystem();
+        }
+        else if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof require !== "undefined") {
+            // process and process.nextTick checks if current environment is node-like
+            // process.browser check excludes webpack and browserify
+            return getNodeSystem();
+        }
+        else {
+            return undefined; // Unsupported host
+        }
+    })();
+})(ts || (ts = {}));
+// <auto-generated />
+/// <reference path="types.ts" />
+/* @internal */
+var ts;
+(function (ts) {
+    ts.Diagnostics = {
+        Unterminated_string_literal: { code: 1002, category: ts.DiagnosticCategory.Error, key: "Unterminated_string_literal_1002", message: "Unterminated string literal." },
+        Identifier_expected: { code: 1003, category: ts.DiagnosticCategory.Error, key: "Identifier_expected_1003", message: "Identifier expected." },
+        _0_expected: { code: 1005, category: ts.DiagnosticCategory.Error, key: "_0_expected_1005", message: "'{0}' expected." },
+        A_file_cannot_have_a_reference_to_itself: { code: 1006, category: ts.DiagnosticCategory.Error, key: "A_file_cannot_have_a_reference_to_itself_1006", message: "A file cannot have a reference to itself." },
+        Trailing_comma_not_allowed: { code: 1009, category: ts.DiagnosticCategory.Error, key: "Trailing_comma_not_allowed_1009", message: "Trailing comma not allowed." },
+        Asterisk_Slash_expected: { code: 1010, category: ts.DiagnosticCategory.Error, key: "Asterisk_Slash_expected_1010", message: "'*/' expected." },
+        Unexpected_token: { code: 1012, category: ts.DiagnosticCategory.Error, key: "Unexpected_token_1012", message: "Unexpected token." },
+        A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: ts.DiagnosticCategory.Error, key: "A_rest_parameter_must_be_last_in_a_parameter_list_1014", message: "A rest parameter must be last in a parameter list." },
+        Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: ts.DiagnosticCategory.Error, key: "Parameter_cannot_have_question_mark_and_initializer_1015", message: "Parameter cannot have question mark and initializer." },
+        A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: ts.DiagnosticCategory.Error, key: "A_required_parameter_cannot_follow_an_optional_parameter_1016", message: "A required parameter cannot follow an optional parameter." },
+        An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: ts.DiagnosticCategory.Error, key: "An_index_signature_cannot_have_a_rest_parameter_1017", message: "An index signature cannot have a rest parameter." },
+        An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: ts.DiagnosticCategory.Error, key: "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", message: "An index signature parameter cannot have an accessibility modifier." },
+        An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: ts.DiagnosticCategory.Error, key: "An_index_signature_parameter_cannot_have_a_question_mark_1019", message: "An index signature parameter cannot have a question mark." },
+        An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: ts.DiagnosticCategory.Error, key: "An_index_signature_parameter_cannot_have_an_initializer_1020", message: "An index signature parameter cannot have an initializer." },
+        An_index_signature_must_have_a_type_annotation: { code: 1021, category: ts.DiagnosticCategory.Error, key: "An_index_signature_must_have_a_type_annotation_1021", message: "An index signature must have a type annotation." },
+        An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: ts.DiagnosticCategory.Error, key: "An_index_signature_parameter_must_have_a_type_annotation_1022", message: "An index signature parameter must have a type annotation." },
+        An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: ts.DiagnosticCategory.Error, key: "An_index_signature_parameter_type_must_be_string_or_number_1023", message: "An index signature parameter type must be 'string' or 'number'." },
+        readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: { code: 1024, category: ts.DiagnosticCategory.Error, key: "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", message: "'readonly' modifier can only appear on a property declaration or index signature." },
+        Accessibility_modifier_already_seen: { code: 1028, category: ts.DiagnosticCategory.Error, key: "Accessibility_modifier_already_seen_1028", message: "Accessibility modifier already seen." },
+        _0_modifier_must_precede_1_modifier: { code: 1029, category: ts.DiagnosticCategory.Error, key: "_0_modifier_must_precede_1_modifier_1029", message: "'{0}' modifier must precede '{1}' modifier." },
+        _0_modifier_already_seen: { code: 1030, category: ts.DiagnosticCategory.Error, key: "_0_modifier_already_seen_1030", message: "'{0}' modifier already seen." },
+        _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_class_element_1031", message: "'{0}' modifier cannot appear on a class element." },
+        super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: ts.DiagnosticCategory.Error, key: "super_must_be_followed_by_an_argument_list_or_member_access_1034", message: "'super' must be followed by an argument list or member access." },
+        Only_ambient_modules_can_use_quoted_names: { code: 1035, category: ts.DiagnosticCategory.Error, key: "Only_ambient_modules_can_use_quoted_names_1035", message: "Only ambient modules can use quoted names." },
+        Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: ts.DiagnosticCategory.Error, key: "Statements_are_not_allowed_in_ambient_contexts_1036", message: "Statements are not allowed in ambient contexts." },
+        A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: ts.DiagnosticCategory.Error, key: "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", message: "A 'declare' modifier cannot be used in an already ambient context." },
+        Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: ts.DiagnosticCategory.Error, key: "Initializers_are_not_allowed_in_ambient_contexts_1039", message: "Initializers are not allowed in ambient contexts." },
+        _0_modifier_cannot_be_used_in_an_ambient_context: { code: 1040, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_be_used_in_an_ambient_context_1040", message: "'{0}' modifier cannot be used in an ambient context." },
+        _0_modifier_cannot_be_used_with_a_class_declaration: { code: 1041, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_be_used_with_a_class_declaration_1041", message: "'{0}' modifier cannot be used with a class declaration." },
+        _0_modifier_cannot_be_used_here: { code: 1042, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_be_used_here_1042", message: "'{0}' modifier cannot be used here." },
+        _0_modifier_cannot_appear_on_a_data_property: { code: 1043, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_data_property_1043", message: "'{0}' modifier cannot appear on a data property." },
+        _0_modifier_cannot_appear_on_a_module_or_namespace_element: { code: 1044, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", message: "'{0}' modifier cannot appear on a module or namespace element." },
+        A_0_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: ts.DiagnosticCategory.Error, key: "A_0_modifier_cannot_be_used_with_an_interface_declaration_1045", message: "A '{0}' modifier cannot be used with an interface declaration." },
+        A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: ts.DiagnosticCategory.Error, key: "A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file_1046", message: "A 'declare' modifier is required for a top level declaration in a .d.ts file." },
+        A_rest_parameter_cannot_be_optional: { code: 1047, category: ts.DiagnosticCategory.Error, key: "A_rest_parameter_cannot_be_optional_1047", message: "A rest parameter cannot be optional." },
+        A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: ts.DiagnosticCategory.Error, key: "A_rest_parameter_cannot_have_an_initializer_1048", message: "A rest parameter cannot have an initializer." },
+        A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: ts.DiagnosticCategory.Error, key: "A_set_accessor_must_have_exactly_one_parameter_1049", message: "A 'set' accessor must have exactly one parameter." },
+        A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: ts.DiagnosticCategory.Error, key: "A_set_accessor_cannot_have_an_optional_parameter_1051", message: "A 'set' accessor cannot have an optional parameter." },
+        A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: ts.DiagnosticCategory.Error, key: "A_set_accessor_parameter_cannot_have_an_initializer_1052", message: "A 'set' accessor parameter cannot have an initializer." },
+        A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: ts.DiagnosticCategory.Error, key: "A_set_accessor_cannot_have_rest_parameter_1053", message: "A 'set' accessor cannot have rest parameter." },
+        A_get_accessor_cannot_have_parameters: { code: 1054, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_cannot_have_parameters_1054", message: "A 'get' accessor cannot have parameters." },
+        Type_0_is_not_a_valid_async_function_return_type: { code: 1055, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_a_valid_async_function_return_type_1055", message: "Type '{0}' is not a valid async function return type." },
+        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: ts.DiagnosticCategory.Error, key: "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", message: "Accessors are only available when targeting ECMAScript 5 and higher." },
+        An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: ts.DiagnosticCategory.Error, key: "An_async_function_or_method_must_have_a_valid_awaitable_return_type_1057", message: "An async function or method must have a valid awaitable return type." },
+        Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: ts.DiagnosticCategory.Error, key: "Operand_for_await_does_not_have_a_valid_callable_then_member_1058", message: "Operand for 'await' does not have a valid callable 'then' member." },
+        Return_expression_in_async_function_does_not_have_a_valid_callable_then_member: { code: 1059, category: ts.DiagnosticCategory.Error, key: "Return_expression_in_async_function_does_not_have_a_valid_callable_then_member_1059", message: "Return expression in async function does not have a valid callable 'then' member." },
+        Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member: { code: 1060, category: ts.DiagnosticCategory.Error, key: "Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member_1060", message: "Expression body for async arrow function does not have a valid callable 'then' member." },
+        Enum_member_must_have_initializer: { code: 1061, category: ts.DiagnosticCategory.Error, key: "Enum_member_must_have_initializer_1061", message: "Enum member must have initializer." },
+        _0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: { code: 1062, category: ts.DiagnosticCategory.Error, key: "_0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", message: "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method." },
+        An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: ts.DiagnosticCategory.Error, key: "An_export_assignment_cannot_be_used_in_a_namespace_1063", message: "An export assignment cannot be used in a namespace." },
+        The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: { code: 1064, category: ts.DiagnosticCategory.Error, key: "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1064", message: "The return type of an async function or method must be the global Promise<T> type." },
+        In_ambient_enum_declarations_member_initializer_must_be_constant_expression: { code: 1066, category: ts.DiagnosticCategory.Error, key: "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", message: "In ambient enum declarations member initializer must be constant expression." },
+        Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: ts.DiagnosticCategory.Error, key: "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", message: "Unexpected token. A constructor, method, accessor, or property was expected." },
+        _0_modifier_cannot_appear_on_a_type_member: { code: 1070, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_type_member_1070", message: "'{0}' modifier cannot appear on a type member." },
+        _0_modifier_cannot_appear_on_an_index_signature: { code: 1071, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_an_index_signature_1071", message: "'{0}' modifier cannot appear on an index signature." },
+        A_0_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: ts.DiagnosticCategory.Error, key: "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", message: "A '{0}' modifier cannot be used with an import declaration." },
+        Invalid_reference_directive_syntax: { code: 1084, category: ts.DiagnosticCategory.Error, key: "Invalid_reference_directive_syntax_1084", message: "Invalid 'reference' directive syntax." },
+        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: ts.DiagnosticCategory.Error, key: "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_1085", message: "Octal literals are not available when targeting ECMAScript 5 and higher." },
+        An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: ts.DiagnosticCategory.Error, key: "An_accessor_cannot_be_declared_in_an_ambient_context_1086", message: "An accessor cannot be declared in an ambient context." },
+        _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", message: "'{0}' modifier cannot appear on a constructor declaration." },
+        _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_appear_on_a_parameter_1090", message: "'{0}' modifier cannot appear on a parameter." },
+        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: ts.DiagnosticCategory.Error, key: "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", message: "Only a single variable declaration is allowed in a 'for...in' statement." },
+        Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: ts.DiagnosticCategory.Error, key: "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", message: "Type parameters cannot appear on a constructor declaration." },
+        Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: ts.DiagnosticCategory.Error, key: "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", message: "Type annotation cannot appear on a constructor declaration." },
+        An_accessor_cannot_have_type_parameters: { code: 1094, category: ts.DiagnosticCategory.Error, key: "An_accessor_cannot_have_type_parameters_1094", message: "An accessor cannot have type parameters." },
+        A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: ts.DiagnosticCategory.Error, key: "A_set_accessor_cannot_have_a_return_type_annotation_1095", message: "A 'set' accessor cannot have a return type annotation." },
+        An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: ts.DiagnosticCategory.Error, key: "An_index_signature_must_have_exactly_one_parameter_1096", message: "An index signature must have exactly one parameter." },
+        _0_list_cannot_be_empty: { code: 1097, category: ts.DiagnosticCategory.Error, key: "_0_list_cannot_be_empty_1097", message: "'{0}' list cannot be empty." },
+        Type_parameter_list_cannot_be_empty: { code: 1098, category: ts.DiagnosticCategory.Error, key: "Type_parameter_list_cannot_be_empty_1098", message: "Type parameter list cannot be empty." },
+        Type_argument_list_cannot_be_empty: { code: 1099, category: ts.DiagnosticCategory.Error, key: "Type_argument_list_cannot_be_empty_1099", message: "Type argument list cannot be empty." },
+        Invalid_use_of_0_in_strict_mode: { code: 1100, category: ts.DiagnosticCategory.Error, key: "Invalid_use_of_0_in_strict_mode_1100", message: "Invalid use of '{0}' in strict mode." },
+        with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: ts.DiagnosticCategory.Error, key: "with_statements_are_not_allowed_in_strict_mode_1101", message: "'with' statements are not allowed in strict mode." },
+        delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: ts.DiagnosticCategory.Error, key: "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", message: "'delete' cannot be called on an identifier in strict mode." },
+        A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: ts.DiagnosticCategory.Error, key: "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", message: "A 'continue' statement can only be used within an enclosing iteration statement." },
+        A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: ts.DiagnosticCategory.Error, key: "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", message: "A 'break' statement can only be used within an enclosing iteration or switch statement." },
+        Jump_target_cannot_cross_function_boundary: { code: 1107, category: ts.DiagnosticCategory.Error, key: "Jump_target_cannot_cross_function_boundary_1107", message: "Jump target cannot cross function boundary." },
+        A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: ts.DiagnosticCategory.Error, key: "A_return_statement_can_only_be_used_within_a_function_body_1108", message: "A 'return' statement can only be used within a function body." },
+        Expression_expected: { code: 1109, category: ts.DiagnosticCategory.Error, key: "Expression_expected_1109", message: "Expression expected." },
+        Type_expected: { code: 1110, category: ts.DiagnosticCategory.Error, key: "Type_expected_1110", message: "Type expected." },
+        A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: ts.DiagnosticCategory.Error, key: "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", message: "A 'default' clause cannot appear more than once in a 'switch' statement." },
+        Duplicate_label_0: { code: 1114, category: ts.DiagnosticCategory.Error, key: "Duplicate_label_0_1114", message: "Duplicate label '{0}'" },
+        A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: ts.DiagnosticCategory.Error, key: "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", message: "A 'continue' statement can only jump to a label of an enclosing iteration statement." },
+        A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: ts.DiagnosticCategory.Error, key: "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", message: "A 'break' statement can only jump to a label of an enclosing statement." },
+        An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: ts.DiagnosticCategory.Error, key: "An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode_1117", message: "An object literal cannot have multiple properties with the same name in strict mode." },
+        An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: ts.DiagnosticCategory.Error, key: "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", message: "An object literal cannot have multiple get/set accessors with the same name." },
+        An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: ts.DiagnosticCategory.Error, key: "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", message: "An object literal cannot have property and accessor with the same name." },
+        An_export_assignment_cannot_have_modifiers: { code: 1120, category: ts.DiagnosticCategory.Error, key: "An_export_assignment_cannot_have_modifiers_1120", message: "An export assignment cannot have modifiers." },
+        Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: ts.DiagnosticCategory.Error, key: "Octal_literals_are_not_allowed_in_strict_mode_1121", message: "Octal literals are not allowed in strict mode." },
+        A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: ts.DiagnosticCategory.Error, key: "A_tuple_type_element_list_cannot_be_empty_1122", message: "A tuple type element list cannot be empty." },
+        Variable_declaration_list_cannot_be_empty: { code: 1123, category: ts.DiagnosticCategory.Error, key: "Variable_declaration_list_cannot_be_empty_1123", message: "Variable declaration list cannot be empty." },
+        Digit_expected: { code: 1124, category: ts.DiagnosticCategory.Error, key: "Digit_expected_1124", message: "Digit expected." },
+        Hexadecimal_digit_expected: { code: 1125, category: ts.DiagnosticCategory.Error, key: "Hexadecimal_digit_expected_1125", message: "Hexadecimal digit expected." },
+        Unexpected_end_of_text: { code: 1126, category: ts.DiagnosticCategory.Error, key: "Unexpected_end_of_text_1126", message: "Unexpected end of text." },
+        Invalid_character: { code: 1127, category: ts.DiagnosticCategory.Error, key: "Invalid_character_1127", message: "Invalid character." },
+        Declaration_or_statement_expected: { code: 1128, category: ts.DiagnosticCategory.Error, key: "Declaration_or_statement_expected_1128", message: "Declaration or statement expected." },
+        Statement_expected: { code: 1129, category: ts.DiagnosticCategory.Error, key: "Statement_expected_1129", message: "Statement expected." },
+        case_or_default_expected: { code: 1130, category: ts.DiagnosticCategory.Error, key: "case_or_default_expected_1130", message: "'case' or 'default' expected." },
+        Property_or_signature_expected: { code: 1131, category: ts.DiagnosticCategory.Error, key: "Property_or_signature_expected_1131", message: "Property or signature expected." },
+        Enum_member_expected: { code: 1132, category: ts.DiagnosticCategory.Error, key: "Enum_member_expected_1132", message: "Enum member expected." },
+        Variable_declaration_expected: { code: 1134, category: ts.DiagnosticCategory.Error, key: "Variable_declaration_expected_1134", message: "Variable declaration expected." },
+        Argument_expression_expected: { code: 1135, category: ts.DiagnosticCategory.Error, key: "Argument_expression_expected_1135", message: "Argument expression expected." },
+        Property_assignment_expected: { code: 1136, category: ts.DiagnosticCategory.Error, key: "Property_assignment_expected_1136", message: "Property assignment expected." },
+        Expression_or_comma_expected: { code: 1137, category: ts.DiagnosticCategory.Error, key: "Expression_or_comma_expected_1137", message: "Expression or comma expected." },
+        Parameter_declaration_expected: { code: 1138, category: ts.DiagnosticCategory.Error, key: "Parameter_declaration_expected_1138", message: "Parameter declaration expected." },
+        Type_parameter_declaration_expected: { code: 1139, category: ts.DiagnosticCategory.Error, key: "Type_parameter_declaration_expected_1139", message: "Type parameter declaration expected." },
+        Type_argument_expected: { code: 1140, category: ts.DiagnosticCategory.Error, key: "Type_argument_expected_1140", message: "Type argument expected." },
+        String_literal_expected: { code: 1141, category: ts.DiagnosticCategory.Error, key: "String_literal_expected_1141", message: "String literal expected." },
+        Line_break_not_permitted_here: { code: 1142, category: ts.DiagnosticCategory.Error, key: "Line_break_not_permitted_here_1142", message: "Line break not permitted here." },
+        or_expected: { code: 1144, category: ts.DiagnosticCategory.Error, key: "or_expected_1144", message: "'{' or ';' expected." },
+        Declaration_expected: { code: 1146, category: ts.DiagnosticCategory.Error, key: "Declaration_expected_1146", message: "Declaration expected." },
+        Import_declarations_in_a_namespace_cannot_reference_a_module: { code: 1147, category: ts.DiagnosticCategory.Error, key: "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", message: "Import declarations in a namespace cannot reference a module." },
+        Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: { code: 1148, category: ts.DiagnosticCategory.Error, key: "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", message: "Cannot use imports, exports, or module augmentations when '--module' is 'none'." },
+        File_name_0_differs_from_already_included_file_name_1_only_in_casing: { code: 1149, category: ts.DiagnosticCategory.Error, key: "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", message: "File name '{0}' differs from already included file name '{1}' only in casing" },
+        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: ts.DiagnosticCategory.Error, key: "new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead_1150", message: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead." },
+        const_declarations_must_be_initialized: { code: 1155, category: ts.DiagnosticCategory.Error, key: "const_declarations_must_be_initialized_1155", message: "'const' declarations must be initialized" },
+        const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: ts.DiagnosticCategory.Error, key: "const_declarations_can_only_be_declared_inside_a_block_1156", message: "'const' declarations can only be declared inside a block." },
+        let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: ts.DiagnosticCategory.Error, key: "let_declarations_can_only_be_declared_inside_a_block_1157", message: "'let' declarations can only be declared inside a block." },
+        Unterminated_template_literal: { code: 1160, category: ts.DiagnosticCategory.Error, key: "Unterminated_template_literal_1160", message: "Unterminated template literal." },
+        Unterminated_regular_expression_literal: { code: 1161, category: ts.DiagnosticCategory.Error, key: "Unterminated_regular_expression_literal_1161", message: "Unterminated regular expression literal." },
+        An_object_member_cannot_be_declared_optional: { code: 1162, category: ts.DiagnosticCategory.Error, key: "An_object_member_cannot_be_declared_optional_1162", message: "An object member cannot be declared optional." },
+        A_yield_expression_is_only_allowed_in_a_generator_body: { code: 1163, category: ts.DiagnosticCategory.Error, key: "A_yield_expression_is_only_allowed_in_a_generator_body_1163", message: "A 'yield' expression is only allowed in a generator body." },
+        Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: ts.DiagnosticCategory.Error, key: "Computed_property_names_are_not_allowed_in_enums_1164", message: "Computed property names are not allowed in enums." },
+        A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol_1165", message: "A computed property name in an ambient context must directly refer to a built-in symbol." },
+        A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol_1166", message: "A computed property name in a class property declaration must directly refer to a built-in symbol." },
+        A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol: { code: 1168, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol_1168", message: "A computed property name in a method overload must directly refer to a built-in symbol." },
+        A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol: { code: 1169, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol_1169", message: "A computed property name in an interface must directly refer to a built-in symbol." },
+        A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol: { code: 1170, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol_1170", message: "A computed property name in a type literal must directly refer to a built-in symbol." },
+        A_comma_expression_is_not_allowed_in_a_computed_property_name: { code: 1171, category: ts.DiagnosticCategory.Error, key: "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", message: "A comma expression is not allowed in a computed property name." },
+        extends_clause_already_seen: { code: 1172, category: ts.DiagnosticCategory.Error, key: "extends_clause_already_seen_1172", message: "'extends' clause already seen." },
+        extends_clause_must_precede_implements_clause: { code: 1173, category: ts.DiagnosticCategory.Error, key: "extends_clause_must_precede_implements_clause_1173", message: "'extends' clause must precede 'implements' clause." },
+        Classes_can_only_extend_a_single_class: { code: 1174, category: ts.DiagnosticCategory.Error, key: "Classes_can_only_extend_a_single_class_1174", message: "Classes can only extend a single class." },
+        implements_clause_already_seen: { code: 1175, category: ts.DiagnosticCategory.Error, key: "implements_clause_already_seen_1175", message: "'implements' clause already seen." },
+        Interface_declaration_cannot_have_implements_clause: { code: 1176, category: ts.DiagnosticCategory.Error, key: "Interface_declaration_cannot_have_implements_clause_1176", message: "Interface declaration cannot have 'implements' clause." },
+        Binary_digit_expected: { code: 1177, category: ts.DiagnosticCategory.Error, key: "Binary_digit_expected_1177", message: "Binary digit expected." },
+        Octal_digit_expected: { code: 1178, category: ts.DiagnosticCategory.Error, key: "Octal_digit_expected_1178", message: "Octal digit expected." },
+        Unexpected_token_expected: { code: 1179, category: ts.DiagnosticCategory.Error, key: "Unexpected_token_expected_1179", message: "Unexpected token. '{' expected." },
+        Property_destructuring_pattern_expected: { code: 1180, category: ts.DiagnosticCategory.Error, key: "Property_destructuring_pattern_expected_1180", message: "Property destructuring pattern expected." },
+        Array_element_destructuring_pattern_expected: { code: 1181, category: ts.DiagnosticCategory.Error, key: "Array_element_destructuring_pattern_expected_1181", message: "Array element destructuring pattern expected." },
+        A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: ts.DiagnosticCategory.Error, key: "A_destructuring_declaration_must_have_an_initializer_1182", message: "A destructuring declaration must have an initializer." },
+        An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1183, category: ts.DiagnosticCategory.Error, key: "An_implementation_cannot_be_declared_in_ambient_contexts_1183", message: "An implementation cannot be declared in ambient contexts." },
+        Modifiers_cannot_appear_here: { code: 1184, category: ts.DiagnosticCategory.Error, key: "Modifiers_cannot_appear_here_1184", message: "Modifiers cannot appear here." },
+        Merge_conflict_marker_encountered: { code: 1185, category: ts.DiagnosticCategory.Error, key: "Merge_conflict_marker_encountered_1185", message: "Merge conflict marker encountered." },
+        A_rest_element_cannot_have_an_initializer: { code: 1186, category: ts.DiagnosticCategory.Error, key: "A_rest_element_cannot_have_an_initializer_1186", message: "A rest element cannot have an initializer." },
+        A_parameter_property_may_not_be_declared_using_a_binding_pattern: { code: 1187, category: ts.DiagnosticCategory.Error, key: "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", message: "A parameter property may not be declared using a binding pattern." },
+        Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: ts.DiagnosticCategory.Error, key: "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", message: "Only a single variable declaration is allowed in a 'for...of' statement." },
+        The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: ts.DiagnosticCategory.Error, key: "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", message: "The variable declaration of a 'for...in' statement cannot have an initializer." },
+        The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: ts.DiagnosticCategory.Error, key: "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", message: "The variable declaration of a 'for...of' statement cannot have an initializer." },
+        An_import_declaration_cannot_have_modifiers: { code: 1191, category: ts.DiagnosticCategory.Error, key: "An_import_declaration_cannot_have_modifiers_1191", message: "An import declaration cannot have modifiers." },
+        Module_0_has_no_default_export: { code: 1192, category: ts.DiagnosticCategory.Error, key: "Module_0_has_no_default_export_1192", message: "Module '{0}' has no default export." },
+        An_export_declaration_cannot_have_modifiers: { code: 1193, category: ts.DiagnosticCategory.Error, key: "An_export_declaration_cannot_have_modifiers_1193", message: "An export declaration cannot have modifiers." },
+        Export_declarations_are_not_permitted_in_a_namespace: { code: 1194, category: ts.DiagnosticCategory.Error, key: "Export_declarations_are_not_permitted_in_a_namespace_1194", message: "Export declarations are not permitted in a namespace." },
+        Catch_clause_variable_name_must_be_an_identifier: { code: 1195, category: ts.DiagnosticCategory.Error, key: "Catch_clause_variable_name_must_be_an_identifier_1195", message: "Catch clause variable name must be an identifier." },
+        Catch_clause_variable_cannot_have_a_type_annotation: { code: 1196, category: ts.DiagnosticCategory.Error, key: "Catch_clause_variable_cannot_have_a_type_annotation_1196", message: "Catch clause variable cannot have a type annotation." },
+        Catch_clause_variable_cannot_have_an_initializer: { code: 1197, category: ts.DiagnosticCategory.Error, key: "Catch_clause_variable_cannot_have_an_initializer_1197", message: "Catch clause variable cannot have an initializer." },
+        An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: { code: 1198, category: ts.DiagnosticCategory.Error, key: "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", message: "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive." },
+        Unterminated_Unicode_escape_sequence: { code: 1199, category: ts.DiagnosticCategory.Error, key: "Unterminated_Unicode_escape_sequence_1199", message: "Unterminated Unicode escape sequence." },
+        Line_terminator_not_permitted_before_arrow: { code: 1200, category: ts.DiagnosticCategory.Error, key: "Line_terminator_not_permitted_before_arrow_1200", message: "Line terminator not permitted before arrow." },
+        Import_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: { code: 1202, category: ts.DiagnosticCategory.Error, key: "Import_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_import_Asteri_1202", message: "Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead." },
+        Export_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_export_default_or_another_module_format_instead: { code: 1203, category: ts.DiagnosticCategory.Error, key: "Export_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_export_defaul_1203", message: "Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead." },
+        Decorators_are_not_valid_here: { code: 1206, category: ts.DiagnosticCategory.Error, key: "Decorators_are_not_valid_here_1206", message: "Decorators are not valid here." },
+        Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: ts.DiagnosticCategory.Error, key: "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", message: "Decorators cannot be applied to multiple get/set accessors of the same name." },
+        Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided: { code: 1208, category: ts.DiagnosticCategory.Error, key: "Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided_1208", message: "Cannot compile namespaces when the '--isolatedModules' flag is provided." },
+        Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided: { code: 1209, category: ts.DiagnosticCategory.Error, key: "Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided_1209", message: "Ambient const enums are not allowed when the '--isolatedModules' flag is provided." },
+        Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: { code: 1210, category: ts.DiagnosticCategory.Error, key: "Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode_1210", message: "Invalid use of '{0}'. Class definitions are automatically in strict mode." },
+        A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: ts.DiagnosticCategory.Error, key: "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", message: "A class declaration without the 'default' modifier must have a name" },
+        Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: ts.DiagnosticCategory.Error, key: "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", message: "Identifier expected. '{0}' is a reserved word in strict mode" },
+        Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: ts.DiagnosticCategory.Error, key: "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", message: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." },
+        Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: ts.DiagnosticCategory.Error, key: "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", message: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." },
+        Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", message: "Invalid use of '{0}'. Modules are automatically in strict mode." },
+        Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: ts.DiagnosticCategory.Error, key: "Export_assignment_is_not_supported_when_module_flag_is_system_1218", message: "Export assignment is not supported when '--module' flag is 'system'." },
+        Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning: { code: 1219, category: ts.DiagnosticCategory.Error, key: "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", message: "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning." },
+        Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher: { code: 1220, category: ts.DiagnosticCategory.Error, key: "Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher_1220", message: "Generators are only available when targeting ECMAScript 2015 or higher." },
+        Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: ts.DiagnosticCategory.Error, key: "Generators_are_not_allowed_in_an_ambient_context_1221", message: "Generators are not allowed in an ambient context." },
+        An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: ts.DiagnosticCategory.Error, key: "An_overload_signature_cannot_be_declared_as_a_generator_1222", message: "An overload signature cannot be declared as a generator." },
+        _0_tag_already_specified: { code: 1223, category: ts.DiagnosticCategory.Error, key: "_0_tag_already_specified_1223", message: "'{0}' tag already specified." },
+        Signature_0_must_have_a_type_predicate: { code: 1224, category: ts.DiagnosticCategory.Error, key: "Signature_0_must_have_a_type_predicate_1224", message: "Signature '{0}' must have a type predicate." },
+        Cannot_find_parameter_0: { code: 1225, category: ts.DiagnosticCategory.Error, key: "Cannot_find_parameter_0_1225", message: "Cannot find parameter '{0}'." },
+        Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: ts.DiagnosticCategory.Error, key: "Type_predicate_0_is_not_assignable_to_1_1226", message: "Type predicate '{0}' is not assignable to '{1}'." },
+        Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: ts.DiagnosticCategory.Error, key: "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", message: "Parameter '{0}' is not in the same position as parameter '{1}'." },
+        A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: ts.DiagnosticCategory.Error, key: "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", message: "A type predicate is only allowed in return type position for functions and methods." },
+        A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: ts.DiagnosticCategory.Error, key: "A_type_predicate_cannot_reference_a_rest_parameter_1229", message: "A type predicate cannot reference a rest parameter." },
+        A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: ts.DiagnosticCategory.Error, key: "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", message: "A type predicate cannot reference element '{0}' in a binding pattern." },
+        An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: ts.DiagnosticCategory.Error, key: "An_export_assignment_can_only_be_used_in_a_module_1231", message: "An export assignment can only be used in a module." },
+        An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: ts.DiagnosticCategory.Error, key: "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", message: "An import declaration can only be used in a namespace or module." },
+        An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An_export_declaration_can_only_be_used_in_a_module_1233", message: "An export declaration can only be used in a module." },
+        An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", message: "An ambient module declaration is only allowed at the top level in a file." },
+        A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", message: "A namespace declaration is only allowed in a namespace or module." },
+        The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: ts.DiagnosticCategory.Error, key: "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", message: "The return type of a property decorator function must be either 'void' or 'any'." },
+        The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: ts.DiagnosticCategory.Error, key: "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", message: "The return type of a parameter decorator function must be either 'void' or 'any'." },
+        Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: ts.DiagnosticCategory.Error, key: "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", message: "Unable to resolve signature of class decorator when called as an expression." },
+        Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: ts.DiagnosticCategory.Error, key: "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", message: "Unable to resolve signature of parameter decorator when called as an expression." },
+        Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: ts.DiagnosticCategory.Error, key: "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", message: "Unable to resolve signature of property decorator when called as an expression." },
+        Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: ts.DiagnosticCategory.Error, key: "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", message: "Unable to resolve signature of method decorator when called as an expression." },
+        abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: { code: 1242, category: ts.DiagnosticCategory.Error, key: "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", message: "'abstract' modifier can only appear on a class, method, or property declaration." },
+        _0_modifier_cannot_be_used_with_1_modifier: { code: 1243, category: ts.DiagnosticCategory.Error, key: "_0_modifier_cannot_be_used_with_1_modifier_1243", message: "'{0}' modifier cannot be used with '{1}' modifier." },
+        Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1244, category: ts.DiagnosticCategory.Error, key: "Abstract_methods_can_only_appear_within_an_abstract_class_1244", message: "Abstract methods can only appear within an abstract class." },
+        Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: { code: 1245, category: ts.DiagnosticCategory.Error, key: "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", message: "Method '{0}' cannot have an implementation because it is marked abstract." },
+        An_interface_property_cannot_have_an_initializer: { code: 1246, category: ts.DiagnosticCategory.Error, key: "An_interface_property_cannot_have_an_initializer_1246", message: "An interface property cannot have an initializer." },
+        A_type_literal_property_cannot_have_an_initializer: { code: 1247, category: ts.DiagnosticCategory.Error, key: "A_type_literal_property_cannot_have_an_initializer_1247", message: "A type literal property cannot have an initializer." },
+        A_class_member_cannot_have_the_0_keyword: { code: 1248, category: ts.DiagnosticCategory.Error, key: "A_class_member_cannot_have_the_0_keyword_1248", message: "A class member cannot have the '{0}' keyword." },
+        A_decorator_can_only_decorate_a_method_implementation_not_an_overload: { code: 1249, category: ts.DiagnosticCategory.Error, key: "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", message: "A decorator can only decorate a method implementation, not an overload." },
+        Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: { code: 1250, category: ts.DiagnosticCategory.Error, key: "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", message: "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'." },
+        Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: { code: 1251, category: ts.DiagnosticCategory.Error, key: "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", message: "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode." },
+        Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: { code: 1252, category: ts.DiagnosticCategory.Error, key: "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", message: "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode." },
+        _0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag: { code: 1253, category: ts.DiagnosticCategory.Error, key: "_0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag_1253", message: "'{0}' tag cannot be used independently as a top level JSDoc tag." },
+        with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: ts.DiagnosticCategory.Error, key: "with_statements_are_not_allowed_in_an_async_function_block_1300", message: "'with' statements are not allowed in an async function block." },
+        await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: ts.DiagnosticCategory.Error, key: "await_expression_is_only_allowed_within_an_async_function_1308", message: "'await' expression is only allowed within an async function." },
+        Async_functions_are_only_available_when_targeting_ECMAScript_2015_or_higher: { code: 1311, category: ts.DiagnosticCategory.Error, key: "Async_functions_are_only_available_when_targeting_ECMAScript_2015_or_higher_1311", message: "Async functions are only available when targeting ECMAScript 2015 or higher." },
+        can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: { code: 1312, category: ts.DiagnosticCategory.Error, key: "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", message: "'=' can only be used in an object literal property inside a destructuring assignment." },
+        The_body_of_an_if_statement_cannot_be_the_empty_statement: { code: 1313, category: ts.DiagnosticCategory.Error, key: "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", message: "The body of an 'if' statement cannot be the empty statement." },
+        Global_module_exports_may_only_appear_in_module_files: { code: 1314, category: ts.DiagnosticCategory.Error, key: "Global_module_exports_may_only_appear_in_module_files_1314", message: "Global module exports may only appear in module files." },
+        Global_module_exports_may_only_appear_in_declaration_files: { code: 1315, category: ts.DiagnosticCategory.Error, key: "Global_module_exports_may_only_appear_in_declaration_files_1315", message: "Global module exports may only appear in declaration files." },
+        Global_module_exports_may_only_appear_at_top_level: { code: 1316, category: ts.DiagnosticCategory.Error, key: "Global_module_exports_may_only_appear_at_top_level_1316", message: "Global module exports may only appear at top level." },
+        A_parameter_property_cannot_be_declared_using_a_rest_parameter: { code: 1317, category: ts.DiagnosticCategory.Error, key: "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", message: "A parameter property cannot be declared using a rest parameter." },
+        Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_2300", message: "Duplicate identifier '{0}'." },
+        Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.DiagnosticCategory.Error, key: "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", message: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
+        Static_members_cannot_reference_class_type_parameters: { code: 2302, category: ts.DiagnosticCategory.Error, key: "Static_members_cannot_reference_class_type_parameters_2302", message: "Static members cannot reference class type parameters." },
+        Circular_definition_of_import_alias_0: { code: 2303, category: ts.DiagnosticCategory.Error, key: "Circular_definition_of_import_alias_0_2303", message: "Circular definition of import alias '{0}'." },
+        Cannot_find_name_0: { code: 2304, category: ts.DiagnosticCategory.Error, key: "Cannot_find_name_0_2304", message: "Cannot find name '{0}'." },
+        Module_0_has_no_exported_member_1: { code: 2305, category: ts.DiagnosticCategory.Error, key: "Module_0_has_no_exported_member_1_2305", message: "Module '{0}' has no exported member '{1}'." },
+        File_0_is_not_a_module: { code: 2306, category: ts.DiagnosticCategory.Error, key: "File_0_is_not_a_module_2306", message: "File '{0}' is not a module." },
+        Cannot_find_module_0: { code: 2307, category: ts.DiagnosticCategory.Error, key: "Cannot_find_module_0_2307", message: "Cannot find module '{0}'." },
+        Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: { code: 2308, category: ts.DiagnosticCategory.Error, key: "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", message: "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity." },
+        An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: { code: 2309, category: ts.DiagnosticCategory.Error, key: "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", message: "An export assignment cannot be used in a module with other exported elements." },
+        Type_0_recursively_references_itself_as_a_base_type: { code: 2310, category: ts.DiagnosticCategory.Error, key: "Type_0_recursively_references_itself_as_a_base_type_2310", message: "Type '{0}' recursively references itself as a base type." },
+        A_class_may_only_extend_another_class: { code: 2311, category: ts.DiagnosticCategory.Error, key: "A_class_may_only_extend_another_class_2311", message: "A class may only extend another class." },
+        An_interface_may_only_extend_a_class_or_another_interface: { code: 2312, category: ts.DiagnosticCategory.Error, key: "An_interface_may_only_extend_a_class_or_another_interface_2312", message: "An interface may only extend a class or another interface." },
+        Type_parameter_0_has_a_circular_constraint: { code: 2313, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_has_a_circular_constraint_2313", message: "Type parameter '{0}' has a circular constraint." },
+        Generic_type_0_requires_1_type_argument_s: { code: 2314, category: ts.DiagnosticCategory.Error, key: "Generic_type_0_requires_1_type_argument_s_2314", message: "Generic type '{0}' requires {1} type argument(s)." },
+        Type_0_is_not_generic: { code: 2315, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_generic_2315", message: "Type '{0}' is not generic." },
+        Global_type_0_must_be_a_class_or_interface_type: { code: 2316, category: ts.DiagnosticCategory.Error, key: "Global_type_0_must_be_a_class_or_interface_type_2316", message: "Global type '{0}' must be a class or interface type." },
+        Global_type_0_must_have_1_type_parameter_s: { code: 2317, category: ts.DiagnosticCategory.Error, key: "Global_type_0_must_have_1_type_parameter_s_2317", message: "Global type '{0}' must have {1} type parameter(s)." },
+        Cannot_find_global_type_0: { code: 2318, category: ts.DiagnosticCategory.Error, key: "Cannot_find_global_type_0_2318", message: "Cannot find global type '{0}'." },
+        Named_property_0_of_types_1_and_2_are_not_identical: { code: 2319, category: ts.DiagnosticCategory.Error, key: "Named_property_0_of_types_1_and_2_are_not_identical_2319", message: "Named property '{0}' of types '{1}' and '{2}' are not identical." },
+        Interface_0_cannot_simultaneously_extend_types_1_and_2: { code: 2320, category: ts.DiagnosticCategory.Error, key: "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", message: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'." },
+        Excessive_stack_depth_comparing_types_0_and_1: { code: 2321, category: ts.DiagnosticCategory.Error, key: "Excessive_stack_depth_comparing_types_0_and_1_2321", message: "Excessive stack depth comparing types '{0}' and '{1}'." },
+        Type_0_is_not_assignable_to_type_1: { code: 2322, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_assignable_to_type_1_2322", message: "Type '{0}' is not assignable to type '{1}'." },
+        Cannot_redeclare_exported_variable_0: { code: 2323, category: ts.DiagnosticCategory.Error, key: "Cannot_redeclare_exported_variable_0_2323", message: "Cannot redeclare exported variable '{0}'." },
+        Property_0_is_missing_in_type_1: { code: 2324, category: ts.DiagnosticCategory.Error, key: "Property_0_is_missing_in_type_1_2324", message: "Property '{0}' is missing in type '{1}'." },
+        Property_0_is_private_in_type_1_but_not_in_type_2: { code: 2325, category: ts.DiagnosticCategory.Error, key: "Property_0_is_private_in_type_1_but_not_in_type_2_2325", message: "Property '{0}' is private in type '{1}' but not in type '{2}'." },
+        Types_of_property_0_are_incompatible: { code: 2326, category: ts.DiagnosticCategory.Error, key: "Types_of_property_0_are_incompatible_2326", message: "Types of property '{0}' are incompatible." },
+        Property_0_is_optional_in_type_1_but_required_in_type_2: { code: 2327, category: ts.DiagnosticCategory.Error, key: "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", message: "Property '{0}' is optional in type '{1}' but required in type '{2}'." },
+        Types_of_parameters_0_and_1_are_incompatible: { code: 2328, category: ts.DiagnosticCategory.Error, key: "Types_of_parameters_0_and_1_are_incompatible_2328", message: "Types of parameters '{0}' and '{1}' are incompatible." },
+        Index_signature_is_missing_in_type_0: { code: 2329, category: ts.DiagnosticCategory.Error, key: "Index_signature_is_missing_in_type_0_2329", message: "Index signature is missing in type '{0}'." },
+        Index_signatures_are_incompatible: { code: 2330, category: ts.DiagnosticCategory.Error, key: "Index_signatures_are_incompatible_2330", message: "Index signatures are incompatible." },
+        this_cannot_be_referenced_in_a_module_or_namespace_body: { code: 2331, category: ts.DiagnosticCategory.Error, key: "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", message: "'this' cannot be referenced in a module or namespace body." },
+        this_cannot_be_referenced_in_current_location: { code: 2332, category: ts.DiagnosticCategory.Error, key: "this_cannot_be_referenced_in_current_location_2332", message: "'this' cannot be referenced in current location." },
+        this_cannot_be_referenced_in_constructor_arguments: { code: 2333, category: ts.DiagnosticCategory.Error, key: "this_cannot_be_referenced_in_constructor_arguments_2333", message: "'this' cannot be referenced in constructor arguments." },
+        this_cannot_be_referenced_in_a_static_property_initializer: { code: 2334, category: ts.DiagnosticCategory.Error, key: "this_cannot_be_referenced_in_a_static_property_initializer_2334", message: "'this' cannot be referenced in a static property initializer." },
+        super_can_only_be_referenced_in_a_derived_class: { code: 2335, category: ts.DiagnosticCategory.Error, key: "super_can_only_be_referenced_in_a_derived_class_2335", message: "'super' can only be referenced in a derived class." },
+        super_cannot_be_referenced_in_constructor_arguments: { code: 2336, category: ts.DiagnosticCategory.Error, key: "super_cannot_be_referenced_in_constructor_arguments_2336", message: "'super' cannot be referenced in constructor arguments." },
+        Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: ts.DiagnosticCategory.Error, key: "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", message: "Super calls are not permitted outside constructors or in nested functions inside constructors." },
+        super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: { code: 2338, category: ts.DiagnosticCategory.Error, key: "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", message: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class." },
+        Property_0_does_not_exist_on_type_1: { code: 2339, category: ts.DiagnosticCategory.Error, key: "Property_0_does_not_exist_on_type_1_2339", message: "Property '{0}' does not exist on type '{1}'." },
+        Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: ts.DiagnosticCategory.Error, key: "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", message: "Only public and protected methods of the base class are accessible via the 'super' keyword." },
+        Property_0_is_private_and_only_accessible_within_class_1: { code: 2341, category: ts.DiagnosticCategory.Error, key: "Property_0_is_private_and_only_accessible_within_class_1_2341", message: "Property '{0}' is private and only accessible within class '{1}'." },
+        An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: { code: 2342, category: ts.DiagnosticCategory.Error, key: "An_index_expression_argument_must_be_of_type_string_number_symbol_or_any_2342", message: "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'." },
+        Type_0_does_not_satisfy_the_constraint_1: { code: 2344, category: ts.DiagnosticCategory.Error, key: "Type_0_does_not_satisfy_the_constraint_1_2344", message: "Type '{0}' does not satisfy the constraint '{1}'." },
+        Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: { code: 2345, category: ts.DiagnosticCategory.Error, key: "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", message: "Argument of type '{0}' is not assignable to parameter of type '{1}'." },
+        Supplied_parameters_do_not_match_any_signature_of_call_target: { code: 2346, category: ts.DiagnosticCategory.Error, key: "Supplied_parameters_do_not_match_any_signature_of_call_target_2346", message: "Supplied parameters do not match any signature of call target." },
+        Untyped_function_calls_may_not_accept_type_arguments: { code: 2347, category: ts.DiagnosticCategory.Error, key: "Untyped_function_calls_may_not_accept_type_arguments_2347", message: "Untyped function calls may not accept type arguments." },
+        Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: { code: 2348, category: ts.DiagnosticCategory.Error, key: "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", message: "Value of type '{0}' is not callable. Did you mean to include 'new'?" },
+        Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: { code: 2349, category: ts.DiagnosticCategory.Error, key: "Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_2349", message: "Cannot invoke an expression whose type lacks a call signature." },
+        Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: ts.DiagnosticCategory.Error, key: "Only_a_void_function_can_be_called_with_the_new_keyword_2350", message: "Only a void function can be called with the 'new' keyword." },
+        Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: { code: 2351, category: ts.DiagnosticCategory.Error, key: "Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature_2351", message: "Cannot use 'new' with an expression whose type lacks a call or construct signature." },
+        Type_0_cannot_be_converted_to_type_1: { code: 2352, category: ts.DiagnosticCategory.Error, key: "Type_0_cannot_be_converted_to_type_1_2352", message: "Type '{0}' cannot be converted to type '{1}'." },
+        Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: ts.DiagnosticCategory.Error, key: "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", message: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
+        No_best_common_type_exists_among_return_expressions: { code: 2354, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_return_expressions_2354", message: "No best common type exists among return expressions." },
+        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value." },
+        An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: ts.DiagnosticCategory.Error, key: "An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type_2356", message: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
+        The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer_2357", message: "The operand of an increment or decrement operator must be a variable, property or indexer." },
+        The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", message: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
+        The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: { code: 2359, category: ts.DiagnosticCategory.Error, key: "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", message: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type." },
+        The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: { code: 2360, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", message: "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'." },
+        The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2361, category: ts.DiagnosticCategory.Error, key: "The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter_2361", message: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter" },
+        The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2362, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type_2362", message: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
+        The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: ts.DiagnosticCategory.Error, key: "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type_2363", message: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
+        Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: ts.DiagnosticCategory.Error, key: "Invalid_left_hand_side_of_assignment_expression_2364", message: "Invalid left-hand side of assignment expression." },
+        Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: ts.DiagnosticCategory.Error, key: "Operator_0_cannot_be_applied_to_types_1_and_2_2365", message: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." },
+        Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: { code: 2366, category: ts.DiagnosticCategory.Error, key: "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", message: "Function lacks ending return statement and return type does not include 'undefined'." },
+        Type_parameter_name_cannot_be_0: { code: 2368, category: ts.DiagnosticCategory.Error, key: "Type_parameter_name_cannot_be_0_2368", message: "Type parameter name cannot be '{0}'" },
+        A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: ts.DiagnosticCategory.Error, key: "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", message: "A parameter property is only allowed in a constructor implementation." },
+        A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: ts.DiagnosticCategory.Error, key: "A_rest_parameter_must_be_of_an_array_type_2370", message: "A rest parameter must be of an array type." },
+        A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: { code: 2371, category: ts.DiagnosticCategory.Error, key: "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", message: "A parameter initializer is only allowed in a function or constructor implementation." },
+        Parameter_0_cannot_be_referenced_in_its_initializer: { code: 2372, category: ts.DiagnosticCategory.Error, key: "Parameter_0_cannot_be_referenced_in_its_initializer_2372", message: "Parameter '{0}' cannot be referenced in its initializer." },
+        Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: { code: 2373, category: ts.DiagnosticCategory.Error, key: "Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it_2373", message: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it." },
+        Duplicate_string_index_signature: { code: 2374, category: ts.DiagnosticCategory.Error, key: "Duplicate_string_index_signature_2374", message: "Duplicate string index signature." },
+        Duplicate_number_index_signature: { code: 2375, category: ts.DiagnosticCategory.Error, key: "Duplicate_number_index_signature_2375", message: "Duplicate number index signature." },
+        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: ts.DiagnosticCategory.Error, key: "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", message: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
+        Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: ts.DiagnosticCategory.Error, key: "Constructors_for_derived_classes_must_contain_a_super_call_2377", message: "Constructors for derived classes must contain a 'super' call." },
+        A_get_accessor_must_return_a_value: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_2378", message: "A 'get' accessor must return a value." },
+        Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: ts.DiagnosticCategory.Error, key: "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", message: "Getter and setter accessors do not agree in visibility." },
+        get_and_set_accessor_must_have_the_same_type: { code: 2380, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_type_2380", message: "'get' and 'set' accessor must have the same type." },
+        A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: ts.DiagnosticCategory.Error, key: "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", message: "A signature with an implementation cannot use a string literal type." },
+        Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: { code: 2382, category: ts.DiagnosticCategory.Error, key: "Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature_2382", message: "Specialized overload signature is not assignable to any non-specialized signature." },
+        Overload_signatures_must_all_be_exported_or_non_exported: { code: 2383, category: ts.DiagnosticCategory.Error, key: "Overload_signatures_must_all_be_exported_or_non_exported_2383", message: "Overload signatures must all be exported or non-exported." },
+        Overload_signatures_must_all_be_ambient_or_non_ambient: { code: 2384, category: ts.DiagnosticCategory.Error, key: "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", message: "Overload signatures must all be ambient or non-ambient." },
+        Overload_signatures_must_all_be_public_private_or_protected: { code: 2385, category: ts.DiagnosticCategory.Error, key: "Overload_signatures_must_all_be_public_private_or_protected_2385", message: "Overload signatures must all be public, private or protected." },
+        Overload_signatures_must_all_be_optional_or_required: { code: 2386, category: ts.DiagnosticCategory.Error, key: "Overload_signatures_must_all_be_optional_or_required_2386", message: "Overload signatures must all be optional or required." },
+        Function_overload_must_be_static: { code: 2387, category: ts.DiagnosticCategory.Error, key: "Function_overload_must_be_static_2387", message: "Function overload must be static." },
+        Function_overload_must_not_be_static: { code: 2388, category: ts.DiagnosticCategory.Error, key: "Function_overload_must_not_be_static_2388", message: "Function overload must not be static." },
+        Function_implementation_name_must_be_0: { code: 2389, category: ts.DiagnosticCategory.Error, key: "Function_implementation_name_must_be_0_2389", message: "Function implementation name must be '{0}'." },
+        Constructor_implementation_is_missing: { code: 2390, category: ts.DiagnosticCategory.Error, key: "Constructor_implementation_is_missing_2390", message: "Constructor implementation is missing." },
+        Function_implementation_is_missing_or_not_immediately_following_the_declaration: { code: 2391, category: ts.DiagnosticCategory.Error, key: "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", message: "Function implementation is missing or not immediately following the declaration." },
+        Multiple_constructor_implementations_are_not_allowed: { code: 2392, category: ts.DiagnosticCategory.Error, key: "Multiple_constructor_implementations_are_not_allowed_2392", message: "Multiple constructor implementations are not allowed." },
+        Duplicate_function_implementation: { code: 2393, category: ts.DiagnosticCategory.Error, key: "Duplicate_function_implementation_2393", message: "Duplicate function implementation." },
+        Overload_signature_is_not_compatible_with_function_implementation: { code: 2394, category: ts.DiagnosticCategory.Error, key: "Overload_signature_is_not_compatible_with_function_implementation_2394", message: "Overload signature is not compatible with function implementation." },
+        Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: { code: 2395, category: ts.DiagnosticCategory.Error, key: "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", message: "Individual declarations in merged declaration '{0}' must be all exported or all local." },
+        Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: { code: 2396, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", message: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters." },
+        Declaration_name_conflicts_with_built_in_global_identifier_0: { code: 2397, category: ts.DiagnosticCategory.Error, key: "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", message: "Declaration name conflicts with built-in global identifier '{0}'." },
+        Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: { code: 2399, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", message: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference." },
+        Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: { code: 2400, category: ts.DiagnosticCategory.Error, key: "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", message: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference." },
+        Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: { code: 2401, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference_2401", message: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference." },
+        Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: { code: 2402, category: ts.DiagnosticCategory.Error, key: "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", message: "Expression resolves to '_super' that compiler uses to capture base class reference." },
+        Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: { code: 2403, category: ts.DiagnosticCategory.Error, key: "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", message: "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'." },
+        The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: { code: 2404, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", message: "The left-hand side of a 'for...in' statement cannot use a type annotation." },
+        The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: { code: 2405, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", message: "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'." },
+        Invalid_left_hand_side_in_for_in_statement: { code: 2406, category: ts.DiagnosticCategory.Error, key: "Invalid_left_hand_side_in_for_in_statement_2406", message: "Invalid left-hand side in 'for...in' statement." },
+        The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2407, category: ts.DiagnosticCategory.Error, key: "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_2407", message: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter." },
+        Setters_cannot_return_a_value: { code: 2408, category: ts.DiagnosticCategory.Error, key: "Setters_cannot_return_a_value_2408", message: "Setters cannot return a value." },
+        Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: { code: 2409, category: ts.DiagnosticCategory.Error, key: "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", message: "Return type of constructor signature must be assignable to the instance type of the class" },
+        All_symbols_within_a_with_block_will_be_resolved_to_any: { code: 2410, category: ts.DiagnosticCategory.Error, key: "All_symbols_within_a_with_block_will_be_resolved_to_any_2410", message: "All symbols within a 'with' block will be resolved to 'any'." },
+        Property_0_of_type_1_is_not_assignable_to_string_index_type_2: { code: 2411, category: ts.DiagnosticCategory.Error, key: "Property_0_of_type_1_is_not_assignable_to_string_index_type_2_2411", message: "Property '{0}' of type '{1}' is not assignable to string index type '{2}'." },
+        Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: { code: 2412, category: ts.DiagnosticCategory.Error, key: "Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2_2412", message: "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'." },
+        Numeric_index_type_0_is_not_assignable_to_string_index_type_1: { code: 2413, category: ts.DiagnosticCategory.Error, key: "Numeric_index_type_0_is_not_assignable_to_string_index_type_1_2413", message: "Numeric index type '{0}' is not assignable to string index type '{1}'." },
+        Class_name_cannot_be_0: { code: 2414, category: ts.DiagnosticCategory.Error, key: "Class_name_cannot_be_0_2414", message: "Class name cannot be '{0}'" },
+        Class_0_incorrectly_extends_base_class_1: { code: 2415, category: ts.DiagnosticCategory.Error, key: "Class_0_incorrectly_extends_base_class_1_2415", message: "Class '{0}' incorrectly extends base class '{1}'." },
+        Class_static_side_0_incorrectly_extends_base_class_static_side_1: { code: 2417, category: ts.DiagnosticCategory.Error, key: "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", message: "Class static side '{0}' incorrectly extends base class static side '{1}'." },
+        Class_0_incorrectly_implements_interface_1: { code: 2420, category: ts.DiagnosticCategory.Error, key: "Class_0_incorrectly_implements_interface_1_2420", message: "Class '{0}' incorrectly implements interface '{1}'." },
+        A_class_may_only_implement_another_class_or_interface: { code: 2422, category: ts.DiagnosticCategory.Error, key: "A_class_may_only_implement_another_class_or_interface_2422", message: "A class may only implement another class or interface." },
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: { code: 2423, category: ts.DiagnosticCategory.Error, key: "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", message: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor." },
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: { code: 2424, category: ts.DiagnosticCategory.Error, key: "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_proper_2424", message: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." },
+        Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2425, category: ts.DiagnosticCategory.Error, key: "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", message: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function." },
+        Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2426, category: ts.DiagnosticCategory.Error, key: "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", message: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function." },
+        Interface_name_cannot_be_0: { code: 2427, category: ts.DiagnosticCategory.Error, key: "Interface_name_cannot_be_0_2427", message: "Interface name cannot be '{0}'" },
+        All_declarations_of_0_must_have_identical_type_parameters: { code: 2428, category: ts.DiagnosticCategory.Error, key: "All_declarations_of_0_must_have_identical_type_parameters_2428", message: "All declarations of '{0}' must have identical type parameters." },
+        Interface_0_incorrectly_extends_interface_1: { code: 2430, category: ts.DiagnosticCategory.Error, key: "Interface_0_incorrectly_extends_interface_1_2430", message: "Interface '{0}' incorrectly extends interface '{1}'." },
+        Enum_name_cannot_be_0: { code: 2431, category: ts.DiagnosticCategory.Error, key: "Enum_name_cannot_be_0_2431", message: "Enum name cannot be '{0}'" },
+        In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: { code: 2432, category: ts.DiagnosticCategory.Error, key: "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", message: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." },
+        A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: { code: 2433, category: ts.DiagnosticCategory.Error, key: "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", message: "A namespace declaration cannot be in a different file from a class or function with which it is merged" },
+        A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: { code: 2434, category: ts.DiagnosticCategory.Error, key: "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", message: "A namespace declaration cannot be located prior to a class or function with which it is merged" },
+        Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: { code: 2435, category: ts.DiagnosticCategory.Error, key: "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", message: "Ambient modules cannot be nested in other modules or namespaces." },
+        Ambient_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: ts.DiagnosticCategory.Error, key: "Ambient_module_declaration_cannot_specify_relative_module_name_2436", message: "Ambient module declaration cannot specify relative module name." },
+        Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: ts.DiagnosticCategory.Error, key: "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", message: "Module '{0}' is hidden by a local declaration with the same name" },
+        Import_name_cannot_be_0: { code: 2438, category: ts.DiagnosticCategory.Error, key: "Import_name_cannot_be_0_2438", message: "Import name cannot be '{0}'" },
+        Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: { code: 2439, category: ts.DiagnosticCategory.Error, key: "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", message: "Import or export declaration in an ambient module declaration cannot reference module through relative module name." },
+        Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: ts.DiagnosticCategory.Error, key: "Import_declaration_conflicts_with_local_declaration_of_0_2440", message: "Import declaration conflicts with local declaration of '{0}'" },
+        Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: { code: 2441, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", message: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module." },
+        Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: ts.DiagnosticCategory.Error, key: "Types_have_separate_declarations_of_a_private_property_0_2442", message: "Types have separate declarations of a private property '{0}'." },
+        Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: { code: 2443, category: ts.DiagnosticCategory.Error, key: "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", message: "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'." },
+        Property_0_is_protected_in_type_1_but_public_in_type_2: { code: 2444, category: ts.DiagnosticCategory.Error, key: "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", message: "Property '{0}' is protected in type '{1}' but public in type '{2}'." },
+        Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: { code: 2445, category: ts.DiagnosticCategory.Error, key: "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", message: "Property '{0}' is protected and only accessible within class '{1}' and its subclasses." },
+        Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: { code: 2446, category: ts.DiagnosticCategory.Error, key: "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_2446", message: "Property '{0}' is protected and only accessible through an instance of class '{1}'." },
+        The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: { code: 2447, category: ts.DiagnosticCategory.Error, key: "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", message: "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead." },
+        Block_scoped_variable_0_used_before_its_declaration: { code: 2448, category: ts.DiagnosticCategory.Error, key: "Block_scoped_variable_0_used_before_its_declaration_2448", message: "Block-scoped variable '{0}' used before its declaration." },
+        The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant_or_a_read_only_property: { code: 2449, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant_or_a_read_only_property_2449", message: "The operand of an increment or decrement operator cannot be a constant or a read-only property." },
+        Left_hand_side_of_assignment_expression_cannot_be_a_constant_or_a_read_only_property: { code: 2450, category: ts.DiagnosticCategory.Error, key: "Left_hand_side_of_assignment_expression_cannot_be_a_constant_or_a_read_only_property_2450", message: "Left-hand side of assignment expression cannot be a constant or a read-only property." },
+        Cannot_redeclare_block_scoped_variable_0: { code: 2451, category: ts.DiagnosticCategory.Error, key: "Cannot_redeclare_block_scoped_variable_0_2451", message: "Cannot redeclare block-scoped variable '{0}'." },
+        An_enum_member_cannot_have_a_numeric_name: { code: 2452, category: ts.DiagnosticCategory.Error, key: "An_enum_member_cannot_have_a_numeric_name_2452", message: "An enum member cannot have a numeric name." },
+        The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: { code: 2453, category: ts.DiagnosticCategory.Error, key: "The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_typ_2453", message: "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly." },
+        Variable_0_is_used_before_being_assigned: { code: 2454, category: ts.DiagnosticCategory.Error, key: "Variable_0_is_used_before_being_assigned_2454", message: "Variable '{0}' is used before being assigned." },
+        Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: { code: 2455, category: ts.DiagnosticCategory.Error, key: "Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0_2455", message: "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'." },
+        Type_alias_0_circularly_references_itself: { code: 2456, category: ts.DiagnosticCategory.Error, key: "Type_alias_0_circularly_references_itself_2456", message: "Type alias '{0}' circularly references itself." },
+        Type_alias_name_cannot_be_0: { code: 2457, category: ts.DiagnosticCategory.Error, key: "Type_alias_name_cannot_be_0_2457", message: "Type alias name cannot be '{0}'" },
+        An_AMD_module_cannot_have_multiple_name_assignments: { code: 2458, category: ts.DiagnosticCategory.Error, key: "An_AMD_module_cannot_have_multiple_name_assignments_2458", message: "An AMD module cannot have multiple name assignments." },
+        Type_0_has_no_property_1_and_no_string_index_signature: { code: 2459, category: ts.DiagnosticCategory.Error, key: "Type_0_has_no_property_1_and_no_string_index_signature_2459", message: "Type '{0}' has no property '{1}' and no string index signature." },
+        Type_0_has_no_property_1: { code: 2460, category: ts.DiagnosticCategory.Error, key: "Type_0_has_no_property_1_2460", message: "Type '{0}' has no property '{1}'." },
+        Type_0_is_not_an_array_type: { code: 2461, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_an_array_type_2461", message: "Type '{0}' is not an array type." },
+        A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: ts.DiagnosticCategory.Error, key: "A_rest_element_must_be_last_in_an_array_destructuring_pattern_2462", message: "A rest element must be last in an array destructuring pattern" },
+        A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: ts.DiagnosticCategory.Error, key: "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", message: "A binding pattern parameter cannot be optional in an implementation signature." },
+        A_computed_property_name_must_be_of_type_string_number_symbol_or_any: { code: 2464, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", message: "A computed property name must be of type 'string', 'number', 'symbol', or 'any'." },
+        this_cannot_be_referenced_in_a_computed_property_name: { code: 2465, category: ts.DiagnosticCategory.Error, key: "this_cannot_be_referenced_in_a_computed_property_name_2465", message: "'this' cannot be referenced in a computed property name." },
+        super_cannot_be_referenced_in_a_computed_property_name: { code: 2466, category: ts.DiagnosticCategory.Error, key: "super_cannot_be_referenced_in_a_computed_property_name_2466", message: "'super' cannot be referenced in a computed property name." },
+        A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: { code: 2467, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", message: "A computed property name cannot reference a type parameter from its containing type." },
+        Cannot_find_global_value_0: { code: 2468, category: ts.DiagnosticCategory.Error, key: "Cannot_find_global_value_0_2468", message: "Cannot find global value '{0}'." },
+        The_0_operator_cannot_be_applied_to_type_symbol: { code: 2469, category: ts.DiagnosticCategory.Error, key: "The_0_operator_cannot_be_applied_to_type_symbol_2469", message: "The '{0}' operator cannot be applied to type 'symbol'." },
+        Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: { code: 2470, category: ts.DiagnosticCategory.Error, key: "Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object_2470", message: "'Symbol' reference does not refer to the global Symbol constructor object." },
+        A_computed_property_name_of_the_form_0_must_be_of_type_symbol: { code: 2471, category: ts.DiagnosticCategory.Error, key: "A_computed_property_name_of_the_form_0_must_be_of_type_symbol_2471", message: "A computed property name of the form '{0}' must be of type 'symbol'." },
+        Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: { code: 2472, category: ts.DiagnosticCategory.Error, key: "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", message: "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher." },
+        Enum_declarations_must_all_be_const_or_non_const: { code: 2473, category: ts.DiagnosticCategory.Error, key: "Enum_declarations_must_all_be_const_or_non_const_2473", message: "Enum declarations must all be const or non-const." },
+        In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 2474, category: ts.DiagnosticCategory.Error, key: "In_const_enum_declarations_member_initializer_must_be_constant_expression_2474", message: "In 'const' enum declarations member initializer must be constant expression." },
+        const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 2475, category: ts.DiagnosticCategory.Error, key: "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", message: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." },
+        A_const_enum_member_can_only_be_accessed_using_a_string_literal: { code: 2476, category: ts.DiagnosticCategory.Error, key: "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", message: "A const enum member can only be accessed using a string literal." },
+        const_enum_member_initializer_was_evaluated_to_a_non_finite_value: { code: 2477, category: ts.DiagnosticCategory.Error, key: "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", message: "'const' enum member initializer was evaluated to a non-finite value." },
+        const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: { code: 2478, category: ts.DiagnosticCategory.Error, key: "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", message: "'const' enum member initializer was evaluated to disallowed value 'NaN'." },
+        Property_0_does_not_exist_on_const_enum_1: { code: 2479, category: ts.DiagnosticCategory.Error, key: "Property_0_does_not_exist_on_const_enum_1_2479", message: "Property '{0}' does not exist on 'const' enum '{1}'." },
+        let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: { code: 2480, category: ts.DiagnosticCategory.Error, key: "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", message: "'let' is not allowed to be used as a name in 'let' or 'const' declarations." },
+        Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: ts.DiagnosticCategory.Error, key: "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", message: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." },
+        The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", message: "The left-hand side of a 'for...of' statement cannot use a type annotation." },
+        Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: ts.DiagnosticCategory.Error, key: "Export_declaration_conflicts_with_exported_declaration_of_0_2484", message: "Export declaration conflicts with exported declaration of '{0}'" },
+        The_left_hand_side_of_a_for_of_statement_cannot_be_a_constant_or_a_read_only_property: { code: 2485, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_of_statement_cannot_be_a_constant_or_a_read_only_property_2485", message: "The left-hand side of a 'for...of' statement cannot be a constant or a read-only property." },
+        The_left_hand_side_of_a_for_in_statement_cannot_be_a_constant_or_a_read_only_property: { code: 2486, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_in_statement_cannot_be_a_constant_or_a_read_only_property_2486", message: "The left-hand side of a 'for...in' statement cannot be a constant or a read-only property." },
+        Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: ts.DiagnosticCategory.Error, key: "Invalid_left_hand_side_in_for_of_statement_2487", message: "Invalid left-hand side in 'for...of' statement." },
+        Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: ts.DiagnosticCategory.Error, key: "Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", message: "Type must have a '[Symbol.iterator]()' method that returns an iterator." },
+        An_iterator_must_have_a_next_method: { code: 2489, category: ts.DiagnosticCategory.Error, key: "An_iterator_must_have_a_next_method_2489", message: "An iterator must have a 'next()' method." },
+        The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: ts.DiagnosticCategory.Error, key: "The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property_2490", message: "The type returned by the 'next()' method of an iterator must have a 'value' property." },
+        The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", message: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." },
+        Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: ts.DiagnosticCategory.Error, key: "Cannot_redeclare_identifier_0_in_catch_clause_2492", message: "Cannot redeclare identifier '{0}' in catch clause" },
+        Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2: { code: 2493, category: ts.DiagnosticCategory.Error, key: "Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2_2493", message: "Tuple type '{0}' with length '{1}' cannot be assigned to tuple with length '{2}'." },
+        Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: { code: 2494, category: ts.DiagnosticCategory.Error, key: "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", message: "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher." },
+        Type_0_is_not_an_array_type_or_a_string_type: { code: 2495, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_an_array_type_or_a_string_type_2495", message: "Type '{0}' is not an array type or a string type." },
+        The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: { code: 2496, category: ts.DiagnosticCategory.Error, key: "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", message: "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression." },
+        Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: ts.DiagnosticCategory.Error, key: "Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct_2497", message: "Module '{0}' resolves to a non-module entity and cannot be imported using this construct." },
+        Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: ts.DiagnosticCategory.Error, key: "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", message: "Module '{0}' uses 'export =' and cannot be used with 'export *'." },
+        An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: ts.DiagnosticCategory.Error, key: "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", message: "An interface can only extend an identifier/qualified-name with optional type arguments." },
+        A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: ts.DiagnosticCategory.Error, key: "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", message: "A class can only implement an identifier/qualified-name with optional type arguments." },
+        A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: ts.DiagnosticCategory.Error, key: "A_rest_element_cannot_contain_a_binding_pattern_2501", message: "A rest element cannot contain a binding pattern." },
+        _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: ts.DiagnosticCategory.Error, key: "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", message: "'{0}' is referenced directly or indirectly in its own type annotation." },
+        Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot_find_namespace_0_2503", message: "Cannot find namespace '{0}'." },
+        No_best_common_type_exists_among_yield_expressions: { code: 2504, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_yield_expressions_2504", message: "No best common type exists among yield expressions." },
+        A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: ts.DiagnosticCategory.Error, key: "A_generator_cannot_have_a_void_type_annotation_2505", message: "A generator cannot have a 'void' type annotation." },
+        _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: ts.DiagnosticCategory.Error, key: "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", message: "'{0}' is referenced directly or indirectly in its own base expression." },
+        Type_0_is_not_a_constructor_function_type: { code: 2507, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_a_constructor_function_type_2507", message: "Type '{0}' is not a constructor function type." },
+        No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: ts.DiagnosticCategory.Error, key: "No_base_constructor_has_the_specified_number_of_type_arguments_2508", message: "No base constructor has the specified number of type arguments." },
+        Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: ts.DiagnosticCategory.Error, key: "Base_constructor_return_type_0_is_not_a_class_or_interface_type_2509", message: "Base constructor return type '{0}' is not a class or interface type." },
+        Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: ts.DiagnosticCategory.Error, key: "Base_constructors_must_all_have_the_same_return_type_2510", message: "Base constructors must all have the same return type." },
+        Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: ts.DiagnosticCategory.Error, key: "Cannot_create_an_instance_of_the_abstract_class_0_2511", message: "Cannot create an instance of the abstract class '{0}'." },
+        Overload_signatures_must_all_be_abstract_or_non_abstract: { code: 2512, category: ts.DiagnosticCategory.Error, key: "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", message: "Overload signatures must all be abstract or non-abstract." },
+        Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: { code: 2513, category: ts.DiagnosticCategory.Error, key: "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", message: "Abstract method '{0}' in class '{1}' cannot be accessed via super expression." },
+        Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: ts.DiagnosticCategory.Error, key: "Classes_containing_abstract_methods_must_be_marked_abstract_2514", message: "Classes containing abstract methods must be marked abstract." },
+        Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: ts.DiagnosticCategory.Error, key: "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", message: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." },
+        All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: ts.DiagnosticCategory.Error, key: "All_declarations_of_an_abstract_method_must_be_consecutive_2516", message: "All declarations of an abstract method must be consecutive." },
+        Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: { code: 2517, category: ts.DiagnosticCategory.Error, key: "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", message: "Cannot assign an abstract constructor type to a non-abstract constructor type." },
+        A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: { code: 2518, category: ts.DiagnosticCategory.Error, key: "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", message: "A 'this'-based type guard is not compatible with a parameter-based type guard." },
+        Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", message: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." },
+        Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: ts.DiagnosticCategory.Error, key: "Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions_2521", message: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." },
+        The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: ts.DiagnosticCategory.Error, key: "The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_2522", message: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." },
+        yield_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2523, category: ts.DiagnosticCategory.Error, key: "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", message: "'yield' expressions cannot be used in a parameter initializer." },
+        await_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2524, category: ts.DiagnosticCategory.Error, key: "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", message: "'await' expressions cannot be used in a parameter initializer." },
+        Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: { code: 2525, category: ts.DiagnosticCategory.Error, key: "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", message: "Initializer provides no value for this binding element and the binding element has no default value." },
+        A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: { code: 2526, category: ts.DiagnosticCategory.Error, key: "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", message: "A 'this' type is available only in a non-static member of a class or interface." },
+        The_inferred_type_of_0_references_an_inaccessible_this_type_A_type_annotation_is_necessary: { code: 2527, category: ts.DiagnosticCategory.Error, key: "The_inferred_type_of_0_references_an_inaccessible_this_type_A_type_annotation_is_necessary_2527", message: "The inferred type of '{0}' references an inaccessible 'this' type. A type annotation is necessary." },
+        A_module_cannot_have_multiple_default_exports: { code: 2528, category: ts.DiagnosticCategory.Error, key: "A_module_cannot_have_multiple_default_exports_2528", message: "A module cannot have multiple default exports." },
+        Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: { code: 2529, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", message: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions." },
+        Property_0_is_incompatible_with_index_signature: { code: 2530, category: ts.DiagnosticCategory.Error, key: "Property_0_is_incompatible_with_index_signature_2530", message: "Property '{0}' is incompatible with index signature." },
+        Object_is_possibly_null: { code: 2531, category: ts.DiagnosticCategory.Error, key: "Object_is_possibly_null_2531", message: "Object is possibly 'null'." },
+        Object_is_possibly_undefined: { code: 2532, category: ts.DiagnosticCategory.Error, key: "Object_is_possibly_undefined_2532", message: "Object is possibly 'undefined'." },
+        Object_is_possibly_null_or_undefined: { code: 2533, category: ts.DiagnosticCategory.Error, key: "Object_is_possibly_null_or_undefined_2533", message: "Object is possibly 'null' or 'undefined'." },
+        A_function_returning_never_cannot_have_a_reachable_end_point: { code: 2534, category: ts.DiagnosticCategory.Error, key: "A_function_returning_never_cannot_have_a_reachable_end_point_2534", message: "A function returning 'never' cannot have a reachable end point." },
+        JSX_element_attributes_type_0_may_not_be_a_union_type: { code: 2600, category: ts.DiagnosticCategory.Error, key: "JSX_element_attributes_type_0_may_not_be_a_union_type_2600", message: "JSX element attributes type '{0}' may not be a union type." },
+        The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: ts.DiagnosticCategory.Error, key: "The_return_type_of_a_JSX_element_constructor_must_return_an_object_type_2601", message: "The return type of a JSX element constructor must return an object type." },
+        JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: { code: 2602, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", message: "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist." },
+        Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: ts.DiagnosticCategory.Error, key: "Property_0_in_type_1_is_not_assignable_to_type_2_2603", message: "Property '{0}' in type '{1}' is not assignable to type '{2}'" },
+        JSX_element_type_0_does_not_have_any_construct_or_call_signatures: { code: 2604, category: ts.DiagnosticCategory.Error, key: "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", message: "JSX element type '{0}' does not have any construct or call signatures." },
+        JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: ts.DiagnosticCategory.Error, key: "JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements_2605", message: "JSX element type '{0}' is not a constructor function for JSX elements." },
+        Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: { code: 2606, category: ts.DiagnosticCategory.Error, key: "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", message: "Property '{0}' of JSX spread attribute is not assignable to target property." },
+        JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: ts.DiagnosticCategory.Error, key: "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", message: "JSX element class does not support attributes because it does not have a '{0}' property" },
+        The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: ts.DiagnosticCategory.Error, key: "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", message: "The global type 'JSX.{0}' may not have more than one property" },
+        Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: ts.DiagnosticCategory.Error, key: "Cannot_emit_namespaced_JSX_elements_in_React_2650", message: "Cannot emit namespaced JSX elements in React" },
+        A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: { code: 2651, category: ts.DiagnosticCategory.Error, key: "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", message: "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums." },
+        Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: { code: 2652, category: ts.DiagnosticCategory.Error, key: "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", message: "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead." },
+        Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: { code: 2653, category: ts.DiagnosticCategory.Error, key: "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", message: "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'." },
+        Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: { code: 2654, category: ts.DiagnosticCategory.Error, key: "Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_pack_2654", message: "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition." },
+        Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: { code: 2656, category: ts.DiagnosticCategory.Error, key: "Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_2656", message: "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition." },
+        JSX_expressions_must_have_one_parent_element: { code: 2657, category: ts.DiagnosticCategory.Error, key: "JSX_expressions_must_have_one_parent_element_2657", message: "JSX expressions must have one parent element" },
+        Type_0_provides_no_match_for_the_signature_1: { code: 2658, category: ts.DiagnosticCategory.Error, key: "Type_0_provides_no_match_for_the_signature_1_2658", message: "Type '{0}' provides no match for the signature '{1}'" },
+        super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: { code: 2659, category: ts.DiagnosticCategory.Error, key: "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", message: "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher." },
+        super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: { code: 2660, category: ts.DiagnosticCategory.Error, key: "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", message: "'super' can only be referenced in members of derived classes or object literal expressions." },
+        Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: { code: 2661, category: ts.DiagnosticCategory.Error, key: "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", message: "Cannot export '{0}'. Only local declarations can be exported from a module." },
+        Cannot_find_name_0_Did_you_mean_the_static_member_1_0: { code: 2662, category: ts.DiagnosticCategory.Error, key: "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", message: "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?" },
+        Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: { code: 2663, category: ts.DiagnosticCategory.Error, key: "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", message: "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?" },
+        Invalid_module_name_in_augmentation_module_0_cannot_be_found: { code: 2664, category: ts.DiagnosticCategory.Error, key: "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", message: "Invalid module name in augmentation, module '{0}' cannot be found." },
+        Exports_and_export_assignments_are_not_permitted_in_module_augmentations: { code: 2666, category: ts.DiagnosticCategory.Error, key: "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", message: "Exports and export assignments are not permitted in module augmentations." },
+        Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: { code: 2667, category: ts.DiagnosticCategory.Error, key: "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", message: "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module." },
+        export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: { code: 2668, category: ts.DiagnosticCategory.Error, key: "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", message: "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible." },
+        Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: { code: 2669, category: ts.DiagnosticCategory.Error, key: "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", message: "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations." },
+        Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: { code: 2670, category: ts.DiagnosticCategory.Error, key: "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", message: "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context." },
+        Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: { code: 2671, category: ts.DiagnosticCategory.Error, key: "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", message: "Cannot augment module '{0}' because it resolves to a non-module entity." },
+        Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: { code: 2672, category: ts.DiagnosticCategory.Error, key: "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", message: "Cannot assign a '{0}' constructor type to a '{1}' constructor type." },
+        Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: { code: 2673, category: ts.DiagnosticCategory.Error, key: "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", message: "Constructor of class '{0}' is private and only accessible within the class declaration." },
+        Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: { code: 2674, category: ts.DiagnosticCategory.Error, key: "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", message: "Constructor of class '{0}' is protected and only accessible within the class declaration." },
+        Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: { code: 2675, category: ts.DiagnosticCategory.Error, key: "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", message: "Cannot extend a class '{0}'. Class constructor is marked as private." },
+        Accessors_must_both_be_abstract_or_non_abstract: { code: 2676, category: ts.DiagnosticCategory.Error, key: "Accessors_must_both_be_abstract_or_non_abstract_2676", message: "Accessors must both be abstract or non-abstract." },
+        A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: { code: 2677, category: ts.DiagnosticCategory.Error, key: "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", message: "A type predicate's type must be assignable to its parameter's type." },
+        Type_0_is_not_comparable_to_type_1: { code: 2678, category: ts.DiagnosticCategory.Error, key: "Type_0_is_not_comparable_to_type_1_2678", message: "Type '{0}' is not comparable to type '{1}'." },
+        A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: { code: 2679, category: ts.DiagnosticCategory.Error, key: "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", message: "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'." },
+        A_this_parameter_must_be_the_first_parameter: { code: 2680, category: ts.DiagnosticCategory.Error, key: "A_this_parameter_must_be_the_first_parameter_2680", message: "A 'this' parameter must be the first parameter." },
+        A_constructor_cannot_have_a_this_parameter: { code: 2681, category: ts.DiagnosticCategory.Error, key: "A_constructor_cannot_have_a_this_parameter_2681", message: "A constructor cannot have a 'this' parameter." },
+        get_and_set_accessor_must_have_the_same_this_type: { code: 2682, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_this_type_2682", message: "'get' and 'set' accessor must have the same 'this' type." },
+        this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: { code: 2683, category: ts.DiagnosticCategory.Error, key: "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", message: "'this' implicitly has type 'any' because it does not have a type annotation." },
+        The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: { code: 2684, category: ts.DiagnosticCategory.Error, key: "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", message: "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'." },
+        The_this_types_of_each_signature_are_incompatible: { code: 2685, category: ts.DiagnosticCategory.Error, key: "The_this_types_of_each_signature_are_incompatible_2685", message: "The 'this' types of each signature are incompatible." },
+        Identifier_0_must_be_imported_from_a_module: { code: 2686, category: ts.DiagnosticCategory.Error, key: "Identifier_0_must_be_imported_from_a_module_2686", message: "Identifier '{0}' must be imported from a module" },
+        All_declarations_of_0_must_have_identical_modifiers: { code: 2687, category: ts.DiagnosticCategory.Error, key: "All_declarations_of_0_must_have_identical_modifiers_2687", message: "All declarations of '{0}' must have identical modifiers." },
+        Cannot_find_type_definition_file_for_0: { code: 2688, category: ts.DiagnosticCategory.Error, key: "Cannot_find_type_definition_file_for_0_2688", message: "Cannot find type definition file for '{0}'." },
+        Cannot_extend_an_interface_0_Did_you_mean_implements: { code: 2689, category: ts.DiagnosticCategory.Error, key: "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", message: "Cannot extend an interface '{0}'. Did you mean 'implements'?" },
+        Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import_declaration_0_is_using_private_name_1_4000", message: "Import declaration '{0}' is using private name '{1}'." },
+        Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", message: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
+        Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", message: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
+        Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4006, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", message: "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
+        Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4008, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", message: "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
+        Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4010, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", message: "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
+        Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4012, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", message: "Type parameter '{0}' of public method from exported class has or is using private name '{1}'." },
+        Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4014, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", message: "Type parameter '{0}' of method from exported interface has or is using private name '{1}'." },
+        Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4016, category: ts.DiagnosticCategory.Error, key: "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", message: "Type parameter '{0}' of exported function has or is using private name '{1}'." },
+        Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4019, category: ts.DiagnosticCategory.Error, key: "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", message: "Implements clause of exported class '{0}' has or is using private name '{1}'." },
+        Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4020, category: ts.DiagnosticCategory.Error, key: "Extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", message: "Extends clause of exported class '{0}' has or is using private name '{1}'." },
+        Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 4022, category: ts.DiagnosticCategory.Error, key: "Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", message: "Extends clause of exported interface '{0}' has or is using private name '{1}'." },
+        Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4023, category: ts.DiagnosticCategory.Error, key: "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", message: "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named." },
+        Exported_variable_0_has_or_is_using_name_1_from_private_module_2: { code: 4024, category: ts.DiagnosticCategory.Error, key: "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", message: "Exported variable '{0}' has or is using name '{1}' from private module '{2}'." },
+        Exported_variable_0_has_or_is_using_private_name_1: { code: 4025, category: ts.DiagnosticCategory.Error, key: "Exported_variable_0_has_or_is_using_private_name_1_4025", message: "Exported variable '{0}' has or is using private name '{1}'." },
+        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4026, category: ts.DiagnosticCategory.Error, key: "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", message: "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
+        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4027, category: ts.DiagnosticCategory.Error, key: "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", message: "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
+        Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4028, category: ts.DiagnosticCategory.Error, key: "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", message: "Public static property '{0}' of exported class has or is using private name '{1}'." },
+        Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4029, category: ts.DiagnosticCategory.Error, key: "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", message: "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
+        Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4030, category: ts.DiagnosticCategory.Error, key: "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", message: "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
+        Public_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4031, category: ts.DiagnosticCategory.Error, key: "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", message: "Public property '{0}' of exported class has or is using private name '{1}'." },
+        Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4032, category: ts.DiagnosticCategory.Error, key: "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", message: "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'." },
+        Property_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4033, category: ts.DiagnosticCategory.Error, key: "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", message: "Property '{0}' of exported interface has or is using private name '{1}'." },
+        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4034, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_4034", message: "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4035, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1_4035", message: "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'." },
+        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4036, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_4036", message: "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4037, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1_4037", message: "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'." },
+        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4038, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_externa_4038", message: "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
+        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4039, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_4039", message: "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4040, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0_4040", message: "Return type of public static property getter from exported class has or is using private name '{0}'." },
+        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4041, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_modul_4041", message: "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
+        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4042, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_4042", message: "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4043, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0_4043", message: "Return type of public property getter from exported class has or is using private name '{0}'." },
+        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4044, category: ts.DiagnosticCategory.Error, key: "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", message: "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4045, category: ts.DiagnosticCategory.Error, key: "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", message: "Return type of constructor signature from exported interface has or is using private name '{0}'." },
+        Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4046, category: ts.DiagnosticCategory.Error, key: "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", message: "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4047, category: ts.DiagnosticCategory.Error, key: "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", message: "Return type of call signature from exported interface has or is using private name '{0}'." },
+        Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4048, category: ts.DiagnosticCategory.Error, key: "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", message: "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4049, category: ts.DiagnosticCategory.Error, key: "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", message: "Return type of index signature from exported interface has or is using private name '{0}'." },
+        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4050, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", message: "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
+        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4051, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", message: "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: { code: 4052, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", message: "Return type of public static method from exported class has or is using private name '{0}'." },
+        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4053, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", message: "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
+        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4054, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", message: "Return type of public method from exported class has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: { code: 4055, category: ts.DiagnosticCategory.Error, key: "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", message: "Return type of public method from exported class has or is using private name '{0}'." },
+        Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4056, category: ts.DiagnosticCategory.Error, key: "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", message: "Return type of method from exported interface has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: { code: 4057, category: ts.DiagnosticCategory.Error, key: "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", message: "Return type of method from exported interface has or is using private name '{0}'." },
+        Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4058, category: ts.DiagnosticCategory.Error, key: "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", message: "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named." },
+        Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: { code: 4059, category: ts.DiagnosticCategory.Error, key: "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", message: "Return type of exported function has or is using name '{0}' from private module '{1}'." },
+        Return_type_of_exported_function_has_or_is_using_private_name_0: { code: 4060, category: ts.DiagnosticCategory.Error, key: "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", message: "Return type of exported function has or is using private name '{0}'." },
+        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4061, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", message: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named." },
+        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4062, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", message: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: { code: 4063, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", message: "Parameter '{0}' of constructor from exported class has or is using private name '{1}'." },
+        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4064, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", message: "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4065, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", message: "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
+        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4066, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", message: "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4067, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", message: "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
+        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4068, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", message: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
+        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4069, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", message: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4070, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", message: "Parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
+        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4071, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", message: "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
+        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4072, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", message: "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4073, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", message: "Parameter '{0}' of public method from exported class has or is using private name '{1}'." },
+        Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4074, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", message: "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4075, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", message: "Parameter '{0}' of method from exported interface has or is using private name '{1}'." },
+        Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", message: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." },
+        Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", message: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." },
+        Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: ts.DiagnosticCategory.Error, key: "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", message: "Parameter '{0}' of exported function has or is using private name '{1}'." },
+        Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: ts.DiagnosticCategory.Error, key: "Exported_type_alias_0_has_or_is_using_private_name_1_4081", message: "Exported type alias '{0}' has or is using private name '{1}'." },
+        Default_export_of_the_module_has_or_is_using_private_name_0: { code: 4082, category: ts.DiagnosticCategory.Error, key: "Default_export_of_the_module_has_or_is_using_private_name_0_4082", message: "Default export of the module has or is using private name '{0}'." },
+        Conflicting_library_definitions_for_0_found_at_1_and_2_Copy_the_correct_file_to_the_typings_folder_to_resolve_this_conflict: { code: 4090, category: ts.DiagnosticCategory.Message, key: "Conflicting_library_definitions_for_0_found_at_1_and_2_Copy_the_correct_file_to_the_typings_folder_t_4090", message: "Conflicting library definitions for '{0}' found at '{1}' and '{2}'. Copy the correct file to the 'typings' folder to resolve this conflict." },
+        The_current_host_does_not_support_the_0_option: { code: 5001, category: ts.DiagnosticCategory.Error, key: "The_current_host_does_not_support_the_0_option_5001", message: "The current host does not support the '{0}' option." },
+        Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: ts.DiagnosticCategory.Error, key: "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", message: "Cannot find the common subdirectory path for the input files." },
+        File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: { code: 5010, category: ts.DiagnosticCategory.Error, key: "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", message: "File specification cannot end in a recursive directory wildcard ('**'): '{0}'." },
+        File_specification_cannot_contain_multiple_recursive_directory_wildcards_Asterisk_Asterisk_Colon_0: { code: 5011, category: ts.DiagnosticCategory.Error, key: "File_specification_cannot_contain_multiple_recursive_directory_wildcards_Asterisk_Asterisk_Colon_0_5011", message: "File specification cannot contain multiple recursive directory wildcards ('**'): '{0}'." },
+        Cannot_read_file_0_Colon_1: { code: 5012, category: ts.DiagnosticCategory.Error, key: "Cannot_read_file_0_Colon_1_5012", message: "Cannot read file '{0}': {1}" },
+        Unsupported_file_encoding: { code: 5013, category: ts.DiagnosticCategory.Error, key: "Unsupported_file_encoding_5013", message: "Unsupported file encoding." },
+        Failed_to_parse_file_0_Colon_1: { code: 5014, category: ts.DiagnosticCategory.Error, key: "Failed_to_parse_file_0_Colon_1_5014", message: "Failed to parse file '{0}': {1}." },
+        Unknown_compiler_option_0: { code: 5023, category: ts.DiagnosticCategory.Error, key: "Unknown_compiler_option_0_5023", message: "Unknown compiler option '{0}'." },
+        Compiler_option_0_requires_a_value_of_type_1: { code: 5024, category: ts.DiagnosticCategory.Error, key: "Compiler_option_0_requires_a_value_of_type_1_5024", message: "Compiler option '{0}' requires a value of type {1}." },
+        Could_not_write_file_0_Colon_1: { code: 5033, category: ts.DiagnosticCategory.Error, key: "Could_not_write_file_0_Colon_1_5033", message: "Could not write file '{0}': {1}" },
+        Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: ts.DiagnosticCategory.Error, key: "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", message: "Option 'project' cannot be mixed with source files on a command line." },
+        Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: { code: 5047, category: ts.DiagnosticCategory.Error, key: "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", message: "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher." },
+        Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: { code: 5051, category: ts.DiagnosticCategory.Error, key: "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", message: "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided." },
+        Option_0_cannot_be_specified_without_specifying_option_1: { code: 5052, category: ts.DiagnosticCategory.Error, key: "Option_0_cannot_be_specified_without_specifying_option_1_5052", message: "Option '{0}' cannot be specified without specifying option '{1}'." },
+        Option_0_cannot_be_specified_with_option_1: { code: 5053, category: ts.DiagnosticCategory.Error, key: "Option_0_cannot_be_specified_with_option_1_5053", message: "Option '{0}' cannot be specified with option '{1}'." },
+        A_tsconfig_json_file_is_already_defined_at_Colon_0: { code: 5054, category: ts.DiagnosticCategory.Error, key: "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", message: "A 'tsconfig.json' file is already defined at: '{0}'." },
+        Cannot_write_file_0_because_it_would_overwrite_input_file: { code: 5055, category: ts.DiagnosticCategory.Error, key: "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", message: "Cannot write file '{0}' because it would overwrite input file." },
+        Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: { code: 5056, category: ts.DiagnosticCategory.Error, key: "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", message: "Cannot write file '{0}' because it would be overwritten by multiple input files." },
+        Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: { code: 5057, category: ts.DiagnosticCategory.Error, key: "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", message: "Cannot find a tsconfig.json file at the specified directory: '{0}'" },
+        The_specified_path_does_not_exist_Colon_0: { code: 5058, category: ts.DiagnosticCategory.Error, key: "The_specified_path_does_not_exist_Colon_0_5058", message: "The specified path does not exist: '{0}'" },
+        Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: { code: 5059, category: ts.DiagnosticCategory.Error, key: "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", message: "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier." },
+        Option_paths_cannot_be_used_without_specifying_baseUrl_option: { code: 5060, category: ts.DiagnosticCategory.Error, key: "Option_paths_cannot_be_used_without_specifying_baseUrl_option_5060", message: "Option 'paths' cannot be used without specifying '--baseUrl' option." },
+        Pattern_0_can_have_at_most_one_Asterisk_character: { code: 5061, category: ts.DiagnosticCategory.Error, key: "Pattern_0_can_have_at_most_one_Asterisk_character_5061", message: "Pattern '{0}' can have at most one '*' character" },
+        Substitution_0_in_pattern_1_in_can_have_at_most_one_Asterisk_character: { code: 5062, category: ts.DiagnosticCategory.Error, key: "Substitution_0_in_pattern_1_in_can_have_at_most_one_Asterisk_character_5062", message: "Substitution '{0}' in pattern '{1}' in can have at most one '*' character" },
+        Substitutions_for_pattern_0_should_be_an_array: { code: 5063, category: ts.DiagnosticCategory.Error, key: "Substitutions_for_pattern_0_should_be_an_array_5063", message: "Substitutions for pattern '{0}' should be an array." },
+        Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: { code: 5064, category: ts.DiagnosticCategory.Error, key: "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", message: "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'." },
+        File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: { code: 5065, category: ts.DiagnosticCategory.Error, key: "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", message: "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'." },
+        Concatenate_and_emit_output_to_single_file: { code: 6001, category: ts.DiagnosticCategory.Message, key: "Concatenate_and_emit_output_to_single_file_6001", message: "Concatenate and emit output to single file." },
+        Generates_corresponding_d_ts_file: { code: 6002, category: ts.DiagnosticCategory.Message, key: "Generates_corresponding_d_ts_file_6002", message: "Generates corresponding '.d.ts' file." },
+        Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: ts.DiagnosticCategory.Message, key: "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6003", message: "Specify the location where debugger should locate map files instead of generated locations." },
+        Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: { code: 6004, category: ts.DiagnosticCategory.Message, key: "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", message: "Specify the location where debugger should locate TypeScript files instead of source locations." },
+        Watch_input_files: { code: 6005, category: ts.DiagnosticCategory.Message, key: "Watch_input_files_6005", message: "Watch input files." },
+        Redirect_output_structure_to_the_directory: { code: 6006, category: ts.DiagnosticCategory.Message, key: "Redirect_output_structure_to_the_directory_6006", message: "Redirect output structure to the directory." },
+        Do_not_erase_const_enum_declarations_in_generated_code: { code: 6007, category: ts.DiagnosticCategory.Message, key: "Do_not_erase_const_enum_declarations_in_generated_code_6007", message: "Do not erase const enum declarations in generated code." },
+        Do_not_emit_outputs_if_any_errors_were_reported: { code: 6008, category: ts.DiagnosticCategory.Message, key: "Do_not_emit_outputs_if_any_errors_were_reported_6008", message: "Do not emit outputs if any errors were reported." },
+        Do_not_emit_comments_to_output: { code: 6009, category: ts.DiagnosticCategory.Message, key: "Do_not_emit_comments_to_output_6009", message: "Do not emit comments to output." },
+        Do_not_emit_outputs: { code: 6010, category: ts.DiagnosticCategory.Message, key: "Do_not_emit_outputs_6010", message: "Do not emit outputs." },
+        Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: { code: 6011, category: ts.DiagnosticCategory.Message, key: "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", message: "Allow default imports from modules with no default export. This does not affect code emit, just typechecking." },
+        Skip_type_checking_of_declaration_files: { code: 6012, category: ts.DiagnosticCategory.Message, key: "Skip_type_checking_of_declaration_files_6012", message: "Skip type checking of declaration files." },
+        Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015: { code: 6015, category: ts.DiagnosticCategory.Message, key: "Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015_6015", message: "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES2015'" },
+        Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015: { code: 6016, category: ts.DiagnosticCategory.Message, key: "Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015_6016", message: "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'" },
+        Print_this_message: { code: 6017, category: ts.DiagnosticCategory.Message, key: "Print_this_message_6017", message: "Print this message." },
+        Print_the_compiler_s_version: { code: 6019, category: ts.DiagnosticCategory.Message, key: "Print_the_compiler_s_version_6019", message: "Print the compiler's version." },
+        Compile_the_project_in_the_given_directory: { code: 6020, category: ts.DiagnosticCategory.Message, key: "Compile_the_project_in_the_given_directory_6020", message: "Compile the project in the given directory." },
+        Syntax_Colon_0: { code: 6023, category: ts.DiagnosticCategory.Message, key: "Syntax_Colon_0_6023", message: "Syntax: {0}" },
+        options: { code: 6024, category: ts.DiagnosticCategory.Message, key: "options_6024", message: "options" },
+        file: { code: 6025, category: ts.DiagnosticCategory.Message, key: "file_6025", message: "file" },
+        Examples_Colon_0: { code: 6026, category: ts.DiagnosticCategory.Message, key: "Examples_Colon_0_6026", message: "Examples: {0}" },
+        Options_Colon: { code: 6027, category: ts.DiagnosticCategory.Message, key: "Options_Colon_6027", message: "Options:" },
+        Version_0: { code: 6029, category: ts.DiagnosticCategory.Message, key: "Version_0_6029", message: "Version {0}" },
+        Insert_command_line_options_and_files_from_a_file: { code: 6030, category: ts.DiagnosticCategory.Message, key: "Insert_command_line_options_and_files_from_a_file_6030", message: "Insert command line options and files from a file." },
+        File_change_detected_Starting_incremental_compilation: { code: 6032, category: ts.DiagnosticCategory.Message, key: "File_change_detected_Starting_incremental_compilation_6032", message: "File change detected. Starting incremental compilation..." },
+        KIND: { code: 6034, category: ts.DiagnosticCategory.Message, key: "KIND_6034", message: "KIND" },
+        FILE: { code: 6035, category: ts.DiagnosticCategory.Message, key: "FILE_6035", message: "FILE" },
+        VERSION: { code: 6036, category: ts.DiagnosticCategory.Message, key: "VERSION_6036", message: "VERSION" },
+        LOCATION: { code: 6037, category: ts.DiagnosticCategory.Message, key: "LOCATION_6037", message: "LOCATION" },
+        DIRECTORY: { code: 6038, category: ts.DiagnosticCategory.Message, key: "DIRECTORY_6038", message: "DIRECTORY" },
+        Compilation_complete_Watching_for_file_changes: { code: 6042, category: ts.DiagnosticCategory.Message, key: "Compilation_complete_Watching_for_file_changes_6042", message: "Compilation complete. Watching for file changes." },
+        Generates_corresponding_map_file: { code: 6043, category: ts.DiagnosticCategory.Message, key: "Generates_corresponding_map_file_6043", message: "Generates corresponding '.map' file." },
+        Compiler_option_0_expects_an_argument: { code: 6044, category: ts.DiagnosticCategory.Error, key: "Compiler_option_0_expects_an_argument_6044", message: "Compiler option '{0}' expects an argument." },
+        Unterminated_quoted_string_in_response_file_0: { code: 6045, category: ts.DiagnosticCategory.Error, key: "Unterminated_quoted_string_in_response_file_0_6045", message: "Unterminated quoted string in response file '{0}'." },
+        Argument_for_0_option_must_be_Colon_1: { code: 6046, category: ts.DiagnosticCategory.Error, key: "Argument_for_0_option_must_be_Colon_1_6046", message: "Argument for '{0}' option must be: {1}" },
+        Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: { code: 6048, category: ts.DiagnosticCategory.Error, key: "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", message: "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'." },
+        Unsupported_locale_0: { code: 6049, category: ts.DiagnosticCategory.Error, key: "Unsupported_locale_0_6049", message: "Unsupported locale '{0}'." },
+        Unable_to_open_file_0: { code: 6050, category: ts.DiagnosticCategory.Error, key: "Unable_to_open_file_0_6050", message: "Unable to open file '{0}'." },
+        Corrupted_locale_file_0: { code: 6051, category: ts.DiagnosticCategory.Error, key: "Corrupted_locale_file_0_6051", message: "Corrupted locale file {0}." },
+        Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: ts.DiagnosticCategory.Message, key: "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", message: "Raise error on expressions and declarations with an implied 'any' type." },
+        File_0_not_found: { code: 6053, category: ts.DiagnosticCategory.Error, key: "File_0_not_found_6053", message: "File '{0}' not found." },
+        File_0_has_unsupported_extension_The_only_supported_extensions_are_1: { code: 6054, category: ts.DiagnosticCategory.Error, key: "File_0_has_unsupported_extension_The_only_supported_extensions_are_1_6054", message: "File '{0}' has unsupported extension. The only supported extensions are {1}." },
+        Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: ts.DiagnosticCategory.Message, key: "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", message: "Suppress noImplicitAny errors for indexing objects lacking index signatures." },
+        Do_not_emit_declarations_for_code_that_has_an_internal_annotation: { code: 6056, category: ts.DiagnosticCategory.Message, key: "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", message: "Do not emit declarations for code that has an '@internal' annotation." },
+        Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: { code: 6058, category: ts.DiagnosticCategory.Message, key: "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", message: "Specify the root directory of input files. Use to control the output directory structure with --outDir." },
+        File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: { code: 6059, category: ts.DiagnosticCategory.Error, key: "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", message: "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files." },
+        Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: ts.DiagnosticCategory.Message, key: "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", message: "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." },
+        NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE_6061", message: "NEWLINE" },
+        Option_0_can_only_be_specified_in_tsconfig_json_file: { code: 6064, category: ts.DiagnosticCategory.Error, key: "Option_0_can_only_be_specified_in_tsconfig_json_file_6064", message: "Option '{0}' can only be specified in 'tsconfig.json' file." },
+        Enables_experimental_support_for_ES7_decorators: { code: 6065, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_decorators_6065", message: "Enables experimental support for ES7 decorators." },
+        Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", message: "Enables experimental support for emitting type metadata for decorators." },
+        Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_async_functions_6068", message: "Enables experimental support for ES7 async functions." },
+        Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: { code: 6069, category: ts.DiagnosticCategory.Message, key: "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", message: "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)." },
+        Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: ts.DiagnosticCategory.Message, key: "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", message: "Initializes a TypeScript project and creates a tsconfig.json file." },
+        Successfully_created_a_tsconfig_json_file: { code: 6071, category: ts.DiagnosticCategory.Message, key: "Successfully_created_a_tsconfig_json_file_6071", message: "Successfully created a tsconfig.json file." },
+        Suppress_excess_property_checks_for_object_literals: { code: 6072, category: ts.DiagnosticCategory.Message, key: "Suppress_excess_property_checks_for_object_literals_6072", message: "Suppress excess property checks for object literals." },
+        Stylize_errors_and_messages_using_color_and_context_experimental: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Stylize_errors_and_messages_using_color_and_context_experimental_6073", message: "Stylize errors and messages using color and context. (experimental)" },
+        Do_not_report_errors_on_unused_labels: { code: 6074, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unused_labels_6074", message: "Do not report errors on unused labels." },
+        Report_error_when_not_all_code_paths_in_function_return_a_value: { code: 6075, category: ts.DiagnosticCategory.Message, key: "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", message: "Report error when not all code paths in function return a value." },
+        Report_errors_for_fallthrough_cases_in_switch_statement: { code: 6076, category: ts.DiagnosticCategory.Message, key: "Report_errors_for_fallthrough_cases_in_switch_statement_6076", message: "Report errors for fallthrough cases in switch statement." },
+        Do_not_report_errors_on_unreachable_code: { code: 6077, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unreachable_code_6077", message: "Do not report errors on unreachable code." },
+        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6078, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6078", message: "Disallow inconsistently-cased references to the same file." },
+        Specify_library_files_to_be_included_in_the_compilation_Colon: { code: 6079, category: ts.DiagnosticCategory.Message, key: "Specify_library_files_to_be_included_in_the_compilation_Colon_6079", message: "Specify library files to be included in the compilation: " },
+        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
+        Only_amd_and_system_modules_are_supported_alongside_0: { code: 6082, category: ts.DiagnosticCategory.Error, key: "Only_amd_and_system_modules_are_supported_alongside_0_6082", message: "Only 'amd' and 'system' modules are supported alongside --{0}." },
+        Base_directory_to_resolve_non_absolute_module_names: { code: 6083, category: ts.DiagnosticCategory.Message, key: "Base_directory_to_resolve_non_absolute_module_names_6083", message: "Base directory to resolve non-absolute module names." },
+        Specify_the_object_invoked_for_createElement_and_spread_when_targeting_react_JSX_emit: { code: 6084, category: ts.DiagnosticCategory.Message, key: "Specify_the_object_invoked_for_createElement_and_spread_when_targeting_react_JSX_emit_6084", message: "Specify the object invoked for createElement and __spread when targeting 'react' JSX emit" },
+        Enable_tracing_of_the_name_resolution_process: { code: 6085, category: ts.DiagnosticCategory.Message, key: "Enable_tracing_of_the_name_resolution_process_6085", message: "Enable tracing of the name resolution process." },
+        Resolving_module_0_from_1: { code: 6086, category: ts.DiagnosticCategory.Message, key: "Resolving_module_0_from_1_6086", message: "======== Resolving module '{0}' from '{1}'. ========" },
+        Explicitly_specified_module_resolution_kind_Colon_0: { code: 6087, category: ts.DiagnosticCategory.Message, key: "Explicitly_specified_module_resolution_kind_Colon_0_6087", message: "Explicitly specified module resolution kind: '{0}'." },
+        Module_resolution_kind_is_not_specified_using_0: { code: 6088, category: ts.DiagnosticCategory.Message, key: "Module_resolution_kind_is_not_specified_using_0_6088", message: "Module resolution kind is not specified, using '{0}'." },
+        Module_name_0_was_successfully_resolved_to_1: { code: 6089, category: ts.DiagnosticCategory.Message, key: "Module_name_0_was_successfully_resolved_to_1_6089", message: "======== Module name '{0}' was successfully resolved to '{1}'. ========" },
+        Module_name_0_was_not_resolved: { code: 6090, category: ts.DiagnosticCategory.Message, key: "Module_name_0_was_not_resolved_6090", message: "======== Module name '{0}' was not resolved. ========" },
+        paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: { code: 6091, category: ts.DiagnosticCategory.Message, key: "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", message: "'paths' option is specified, looking for a pattern to match module name '{0}'." },
+        Module_name_0_matched_pattern_1: { code: 6092, category: ts.DiagnosticCategory.Message, key: "Module_name_0_matched_pattern_1_6092", message: "Module name '{0}', matched pattern '{1}'." },
+        Trying_substitution_0_candidate_module_location_Colon_1: { code: 6093, category: ts.DiagnosticCategory.Message, key: "Trying_substitution_0_candidate_module_location_Colon_1_6093", message: "Trying substitution '{0}', candidate module location: '{1}'." },
+        Resolving_module_name_0_relative_to_base_url_1_2: { code: 6094, category: ts.DiagnosticCategory.Message, key: "Resolving_module_name_0_relative_to_base_url_1_2_6094", message: "Resolving module name '{0}' relative to base url '{1}' - '{2}'." },
+        Loading_module_as_file_Slash_folder_candidate_module_location_0: { code: 6095, category: ts.DiagnosticCategory.Message, key: "Loading_module_as_file_Slash_folder_candidate_module_location_0_6095", message: "Loading module as file / folder, candidate module location '{0}'." },
+        File_0_does_not_exist: { code: 6096, category: ts.DiagnosticCategory.Message, key: "File_0_does_not_exist_6096", message: "File '{0}' does not exist." },
+        File_0_exist_use_it_as_a_name_resolution_result: { code: 6097, category: ts.DiagnosticCategory.Message, key: "File_0_exist_use_it_as_a_name_resolution_result_6097", message: "File '{0}' exist - use it as a name resolution result." },
+        Loading_module_0_from_node_modules_folder: { code: 6098, category: ts.DiagnosticCategory.Message, key: "Loading_module_0_from_node_modules_folder_6098", message: "Loading module '{0}' from 'node_modules' folder." },
+        Found_package_json_at_0: { code: 6099, category: ts.DiagnosticCategory.Message, key: "Found_package_json_at_0_6099", message: "Found 'package.json' at '{0}'." },
+        package_json_does_not_have_types_field: { code: 6100, category: ts.DiagnosticCategory.Message, key: "package_json_does_not_have_types_field_6100", message: "'package.json' does not have 'types' field." },
+        package_json_has_0_field_1_that_references_2: { code: 6101, category: ts.DiagnosticCategory.Message, key: "package_json_has_0_field_1_that_references_2_6101", message: "'package.json' has '{0}' field '{1}' that references '{2}'." },
+        Allow_javascript_files_to_be_compiled: { code: 6102, category: ts.DiagnosticCategory.Message, key: "Allow_javascript_files_to_be_compiled_6102", message: "Allow javascript files to be compiled." },
+        Option_0_should_have_array_of_strings_as_a_value: { code: 6103, category: ts.DiagnosticCategory.Error, key: "Option_0_should_have_array_of_strings_as_a_value_6103", message: "Option '{0}' should have array of strings as a value." },
+        Checking_if_0_is_the_longest_matching_prefix_for_1_2: { code: 6104, category: ts.DiagnosticCategory.Message, key: "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", message: "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'." },
+        Expected_type_of_0_field_in_package_json_to_be_string_got_1: { code: 6105, category: ts.DiagnosticCategory.Message, key: "Expected_type_of_0_field_in_package_json_to_be_string_got_1_6105", message: "Expected type of '{0}' field in 'package.json' to be 'string', got '{1}'." },
+        baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: { code: 6106, category: ts.DiagnosticCategory.Message, key: "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", message: "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'" },
+        rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: { code: 6107, category: ts.DiagnosticCategory.Message, key: "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", message: "'rootDirs' option is set, using it to resolve relative module name '{0}'" },
+        Longest_matching_prefix_for_0_is_1: { code: 6108, category: ts.DiagnosticCategory.Message, key: "Longest_matching_prefix_for_0_is_1_6108", message: "Longest matching prefix for '{0}' is '{1}'" },
+        Loading_0_from_the_root_dir_1_candidate_location_2: { code: 6109, category: ts.DiagnosticCategory.Message, key: "Loading_0_from_the_root_dir_1_candidate_location_2_6109", message: "Loading '{0}' from the root dir '{1}', candidate location '{2}'" },
+        Trying_other_entries_in_rootDirs: { code: 6110, category: ts.DiagnosticCategory.Message, key: "Trying_other_entries_in_rootDirs_6110", message: "Trying other entries in 'rootDirs'" },
+        Module_resolution_using_rootDirs_has_failed: { code: 6111, category: ts.DiagnosticCategory.Message, key: "Module_resolution_using_rootDirs_has_failed_6111", message: "Module resolution using 'rootDirs' has failed" },
+        Do_not_emit_use_strict_directives_in_module_output: { code: 6112, category: ts.DiagnosticCategory.Message, key: "Do_not_emit_use_strict_directives_in_module_output_6112", message: "Do not emit 'use strict' directives in module output." },
+        Enable_strict_null_checks: { code: 6113, category: ts.DiagnosticCategory.Message, key: "Enable_strict_null_checks_6113", message: "Enable strict null checks." },
+        Unknown_option_excludes_Did_you_mean_exclude: { code: 6114, category: ts.DiagnosticCategory.Error, key: "Unknown_option_excludes_Did_you_mean_exclude_6114", message: "Unknown option 'excludes'. Did you mean 'exclude'?" },
+        Raise_error_on_this_expressions_with_an_implied_any_type: { code: 6115, category: ts.DiagnosticCategory.Message, key: "Raise_error_on_this_expressions_with_an_implied_any_type_6115", message: "Raise error on 'this' expressions with an implied 'any' type." },
+        Resolving_type_reference_directive_0_containing_file_1_root_directory_2: { code: 6116, category: ts.DiagnosticCategory.Message, key: "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", message: "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========" },
+        Resolving_using_primary_search_paths: { code: 6117, category: ts.DiagnosticCategory.Message, key: "Resolving_using_primary_search_paths_6117", message: "Resolving using primary search paths..." },
+        Resolving_from_node_modules_folder: { code: 6118, category: ts.DiagnosticCategory.Message, key: "Resolving_from_node_modules_folder_6118", message: "Resolving from node_modules folder..." },
+        Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: { code: 6119, category: ts.DiagnosticCategory.Message, key: "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", message: "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========" },
+        Type_reference_directive_0_was_not_resolved: { code: 6120, category: ts.DiagnosticCategory.Message, key: "Type_reference_directive_0_was_not_resolved_6120", message: "======== Type reference directive '{0}' was not resolved. ========" },
+        Resolving_with_primary_search_path_0: { code: 6121, category: ts.DiagnosticCategory.Message, key: "Resolving_with_primary_search_path_0_6121", message: "Resolving with primary search path '{0}'" },
+        Root_directory_cannot_be_determined_skipping_primary_search_paths: { code: 6122, category: ts.DiagnosticCategory.Message, key: "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", message: "Root directory cannot be determined, skipping primary search paths." },
+        Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: { code: 6123, category: ts.DiagnosticCategory.Message, key: "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", message: "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========" },
+        Type_declaration_files_to_be_included_in_compilation: { code: 6124, category: ts.DiagnosticCategory.Message, key: "Type_declaration_files_to_be_included_in_compilation_6124", message: "Type declaration files to be included in compilation." },
+        Looking_up_in_node_modules_folder_initial_location_0: { code: 6125, category: ts.DiagnosticCategory.Message, key: "Looking_up_in_node_modules_folder_initial_location_0_6125", message: "Looking up in 'node_modules' folder, initial location '{0}'" },
+        Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: { code: 6126, category: ts.DiagnosticCategory.Message, key: "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", message: "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder." },
+        Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: { code: 6127, category: ts.DiagnosticCategory.Message, key: "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", message: "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========" },
+        Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: { code: 6128, category: ts.DiagnosticCategory.Message, key: "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", message: "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========" },
+        The_config_file_0_found_doesn_t_contain_any_source_files: { code: 6129, category: ts.DiagnosticCategory.Error, key: "The_config_file_0_found_doesn_t_contain_any_source_files_6129", message: "The config file '{0}' found doesn't contain any source files." },
+        Resolving_real_path_for_0_result_1: { code: 6130, category: ts.DiagnosticCategory.Message, key: "Resolving_real_path_for_0_result_1_6130", message: "Resolving real path for '{0}', result '{1}'" },
+        Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: { code: 6131, category: ts.DiagnosticCategory.Error, key: "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", message: "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'." },
+        File_name_0_has_a_1_extension_stripping_it: { code: 6132, category: ts.DiagnosticCategory.Message, key: "File_name_0_has_a_1_extension_stripping_it_6132", message: "File name '{0}' has a '{1}' extension - stripping it" },
+        _0_is_declared_but_never_used: { code: 6133, category: ts.DiagnosticCategory.Error, key: "_0_is_declared_but_never_used_6133", message: "'{0}' is declared but never used." },
+        Report_Errors_on_Unused_Locals: { code: 6134, category: ts.DiagnosticCategory.Message, key: "Report_Errors_on_Unused_Locals_6134", message: "Report Errors on Unused Locals." },
+        Report_Errors_on_Unused_Parameters: { code: 6135, category: ts.DiagnosticCategory.Message, key: "Report_Errors_on_Unused_Parameters_6135", message: "Report Errors on Unused Parameters." },
+        The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: { code: 6136, category: ts.DiagnosticCategory.Message, key: "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", message: "The maximum dependency depth to search under node_modules and load JavaScript files" },
+        No_types_specified_in_package_json_but_allowJs_is_set_so_returning_main_value_of_0: { code: 6137, category: ts.DiagnosticCategory.Message, key: "No_types_specified_in_package_json_but_allowJs_is_set_so_returning_main_value_of_0_6137", message: "No types specified in 'package.json' but 'allowJs' is set, so returning 'main' value of '{0}'" },
+        Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable_0_implicitly_has_an_1_type_7005", message: "Variable '{0}' implicitly has an '{1}' type." },
+        Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter_0_implicitly_has_an_1_type_7006", message: "Parameter '{0}' implicitly has an '{1}' type." },
+        Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member_0_implicitly_has_an_1_type_7008", message: "Member '{0}' implicitly has an '{1}' type." },
+        new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: { code: 7009, category: ts.DiagnosticCategory.Error, key: "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", message: "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type." },
+        _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: { code: 7010, category: ts.DiagnosticCategory.Error, key: "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", message: "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type." },
+        Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: { code: 7011, category: ts.DiagnosticCategory.Error, key: "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", message: "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type." },
+        Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7013, category: ts.DiagnosticCategory.Error, key: "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", message: "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type." },
+        Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: { code: 7015, category: ts.DiagnosticCategory.Error, key: "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", message: "Element implicitly has an 'any' type because index expression is not of type 'number'." },
+        Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation: { code: 7016, category: ts.DiagnosticCategory.Error, key: "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation_7016", message: "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation." },
+        Index_signature_of_object_type_implicitly_has_an_any_type: { code: 7017, category: ts.DiagnosticCategory.Error, key: "Index_signature_of_object_type_implicitly_has_an_any_type_7017", message: "Index signature of object type implicitly has an 'any' type." },
+        Object_literal_s_property_0_implicitly_has_an_1_type: { code: 7018, category: ts.DiagnosticCategory.Error, key: "Object_literal_s_property_0_implicitly_has_an_1_type_7018", message: "Object literal's property '{0}' implicitly has an '{1}' type." },
+        Rest_parameter_0_implicitly_has_an_any_type: { code: 7019, category: ts.DiagnosticCategory.Error, key: "Rest_parameter_0_implicitly_has_an_any_type_7019", message: "Rest parameter '{0}' implicitly has an 'any[]' type." },
+        Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7020, category: ts.DiagnosticCategory.Error, key: "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", message: "Call signature, which lacks return-type annotation, implicitly has an 'any' return type." },
+        _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: ts.DiagnosticCategory.Error, key: "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", message: "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer." },
+        _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7023, category: ts.DiagnosticCategory.Error, key: "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", message: "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
+        Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", message: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
+        Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: ts.DiagnosticCategory.Error, key: "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", message: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
+        JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", message: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
+        Unreachable_code_detected: { code: 7027, category: ts.DiagnosticCategory.Error, key: "Unreachable_code_detected_7027", message: "Unreachable code detected." },
+        Unused_label: { code: 7028, category: ts.DiagnosticCategory.Error, key: "Unused_label_7028", message: "Unused label." },
+        Fallthrough_case_in_switch: { code: 7029, category: ts.DiagnosticCategory.Error, key: "Fallthrough_case_in_switch_7029", message: "Fallthrough case in switch." },
+        Not_all_code_paths_return_a_value: { code: 7030, category: ts.DiagnosticCategory.Error, key: "Not_all_code_paths_return_a_value_7030", message: "Not all code paths return a value." },
+        Binding_element_0_implicitly_has_an_1_type: { code: 7031, category: ts.DiagnosticCategory.Error, key: "Binding_element_0_implicitly_has_an_1_type_7031", message: "Binding element '{0}' implicitly has an '{1}' type." },
+        You_cannot_rename_this_element: { code: 8000, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_this_element_8000", message: "You cannot rename this element." },
+        You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", message: "You cannot rename elements that are defined in the standard TypeScript library." },
+        import_can_only_be_used_in_a_ts_file: { code: 8002, category: ts.DiagnosticCategory.Error, key: "import_can_only_be_used_in_a_ts_file_8002", message: "'import ... =' can only be used in a .ts file." },
+        export_can_only_be_used_in_a_ts_file: { code: 8003, category: ts.DiagnosticCategory.Error, key: "export_can_only_be_used_in_a_ts_file_8003", message: "'export=' can only be used in a .ts file." },
+        type_parameter_declarations_can_only_be_used_in_a_ts_file: { code: 8004, category: ts.DiagnosticCategory.Error, key: "type_parameter_declarations_can_only_be_used_in_a_ts_file_8004", message: "'type parameter declarations' can only be used in a .ts file." },
+        implements_clauses_can_only_be_used_in_a_ts_file: { code: 8005, category: ts.DiagnosticCategory.Error, key: "implements_clauses_can_only_be_used_in_a_ts_file_8005", message: "'implements clauses' can only be used in a .ts file." },
+        interface_declarations_can_only_be_used_in_a_ts_file: { code: 8006, category: ts.DiagnosticCategory.Error, key: "interface_declarations_can_only_be_used_in_a_ts_file_8006", message: "'interface declarations' can only be used in a .ts file." },
+        module_declarations_can_only_be_used_in_a_ts_file: { code: 8007, category: ts.DiagnosticCategory.Error, key: "module_declarations_can_only_be_used_in_a_ts_file_8007", message: "'module declarations' can only be used in a .ts file." },
+        type_aliases_can_only_be_used_in_a_ts_file: { code: 8008, category: ts.DiagnosticCategory.Error, key: "type_aliases_can_only_be_used_in_a_ts_file_8008", message: "'type aliases' can only be used in a .ts file." },
+        _0_can_only_be_used_in_a_ts_file: { code: 8009, category: ts.DiagnosticCategory.Error, key: "_0_can_only_be_used_in_a_ts_file_8009", message: "'{0}' can only be used in a .ts file." },
+        types_can_only_be_used_in_a_ts_file: { code: 8010, category: ts.DiagnosticCategory.Error, key: "types_can_only_be_used_in_a_ts_file_8010", message: "'types' can only be used in a .ts file." },
+        type_arguments_can_only_be_used_in_a_ts_file: { code: 8011, category: ts.DiagnosticCategory.Error, key: "type_arguments_can_only_be_used_in_a_ts_file_8011", message: "'type arguments' can only be used in a .ts file." },
+        parameter_modifiers_can_only_be_used_in_a_ts_file: { code: 8012, category: ts.DiagnosticCategory.Error, key: "parameter_modifiers_can_only_be_used_in_a_ts_file_8012", message: "'parameter modifiers' can only be used in a .ts file." },
+        enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: ts.DiagnosticCategory.Error, key: "enum_declarations_can_only_be_used_in_a_ts_file_8015", message: "'enum declarations' can only be used in a .ts file." },
+        type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: ts.DiagnosticCategory.Error, key: "type_assertion_expressions_can_only_be_used_in_a_ts_file_8016", message: "'type assertion expressions' can only be used in a .ts file." },
+        Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: ts.DiagnosticCategory.Error, key: "Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_clas_9002", message: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
+        class_expressions_are_not_currently_supported: { code: 9003, category: ts.DiagnosticCategory.Error, key: "class_expressions_are_not_currently_supported_9003", message: "'class' expressions are not currently supported." },
+        JSX_attributes_must_only_be_assigned_a_non_empty_expression: { code: 17000, category: ts.DiagnosticCategory.Error, key: "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", message: "JSX attributes must only be assigned a non-empty 'expression'." },
+        JSX_elements_cannot_have_multiple_attributes_with_the_same_name: { code: 17001, category: ts.DiagnosticCategory.Error, key: "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", message: "JSX elements cannot have multiple attributes with the same name." },
+        Expected_corresponding_JSX_closing_tag_for_0: { code: 17002, category: ts.DiagnosticCategory.Error, key: "Expected_corresponding_JSX_closing_tag_for_0_17002", message: "Expected corresponding JSX closing tag for '{0}'." },
+        JSX_attribute_expected: { code: 17003, category: ts.DiagnosticCategory.Error, key: "JSX_attribute_expected_17003", message: "JSX attribute expected." },
+        Cannot_use_JSX_unless_the_jsx_flag_is_provided: { code: 17004, category: ts.DiagnosticCategory.Error, key: "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", message: "Cannot use JSX unless the '--jsx' flag is provided." },
+        A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: { code: 17005, category: ts.DiagnosticCategory.Error, key: "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", message: "A constructor cannot contain a 'super' call when its class extends 'null'" },
+        An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: { code: 17006, category: ts.DiagnosticCategory.Error, key: "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", message: "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses." },
+        A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: { code: 17007, category: ts.DiagnosticCategory.Error, key: "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", message: "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses." },
+        JSX_element_0_has_no_corresponding_closing_tag: { code: 17008, category: ts.DiagnosticCategory.Error, key: "JSX_element_0_has_no_corresponding_closing_tag_17008", message: "JSX element '{0}' has no corresponding closing tag." },
+        super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: { code: 17009, category: ts.DiagnosticCategory.Error, key: "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", message: "'super' must be called before accessing 'this' in the constructor of a derived class." },
+        Unknown_typing_option_0: { code: 17010, category: ts.DiagnosticCategory.Error, key: "Unknown_typing_option_0_17010", message: "Unknown typing option '{0}'." }
+    };
+})(ts || (ts = {}));
+/// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
+var ts;
+(function (ts) {
+    /* @internal */
+    function tokenIsIdentifierOrKeyword(token) {
+        return token >= 69 /* Identifier */;
+    }
+    ts.tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword;
+    var textToToken = {
+        "abstract": 115 /* AbstractKeyword */,
+        "any": 117 /* AnyKeyword */,
+        "as": 116 /* AsKeyword */,
+        "boolean": 120 /* BooleanKeyword */,
+        "break": 70 /* BreakKeyword */,
+        "case": 71 /* CaseKeyword */,
+        "catch": 72 /* CatchKeyword */,
+        "class": 73 /* ClassKeyword */,
+        "continue": 75 /* ContinueKeyword */,
+        "const": 74 /* ConstKeyword */,
+        "constructor": 121 /* ConstructorKeyword */,
+        "debugger": 76 /* DebuggerKeyword */,
+        "declare": 122 /* DeclareKeyword */,
+        "default": 77 /* DefaultKeyword */,
+        "delete": 78 /* DeleteKeyword */,
+        "do": 79 /* DoKeyword */,
+        "else": 80 /* ElseKeyword */,
+        "enum": 81 /* EnumKeyword */,
+        "export": 82 /* ExportKeyword */,
+        "extends": 83 /* ExtendsKeyword */,
+        "false": 84 /* FalseKeyword */,
+        "finally": 85 /* FinallyKeyword */,
+        "for": 86 /* ForKeyword */,
+        "from": 136 /* FromKeyword */,
+        "function": 87 /* FunctionKeyword */,
+        "get": 123 /* GetKeyword */,
+        "if": 88 /* IfKeyword */,
+        "implements": 106 /* ImplementsKeyword */,
+        "import": 89 /* ImportKeyword */,
+        "in": 90 /* InKeyword */,
+        "instanceof": 91 /* InstanceOfKeyword */,
+        "interface": 107 /* InterfaceKeyword */,
+        "is": 124 /* IsKeyword */,
+        "let": 108 /* LetKeyword */,
+        "module": 125 /* ModuleKeyword */,
+        "namespace": 126 /* NamespaceKeyword */,
+        "never": 127 /* NeverKeyword */,
+        "new": 92 /* NewKeyword */,
+        "null": 93 /* NullKeyword */,
+        "number": 130 /* NumberKeyword */,
+        "package": 109 /* PackageKeyword */,
+        "private": 110 /* PrivateKeyword */,
+        "protected": 111 /* ProtectedKeyword */,
+        "public": 112 /* PublicKeyword */,
+        "readonly": 128 /* ReadonlyKeyword */,
+        "require": 129 /* RequireKeyword */,
+        "global": 137 /* GlobalKeyword */,
+        "return": 94 /* ReturnKeyword */,
+        "set": 131 /* SetKeyword */,
+        "static": 113 /* StaticKeyword */,
+        "string": 132 /* StringKeyword */,
+        "super": 95 /* SuperKeyword */,
+        "switch": 96 /* SwitchKeyword */,
+        "symbol": 133 /* SymbolKeyword */,
+        "this": 97 /* ThisKeyword */,
+        "throw": 98 /* ThrowKeyword */,
+        "true": 99 /* TrueKeyword */,
+        "try": 100 /* TryKeyword */,
+        "type": 134 /* TypeKeyword */,
+        "typeof": 101 /* TypeOfKeyword */,
+        "undefined": 135 /* UndefinedKeyword */,
+        "var": 102 /* VarKeyword */,
+        "void": 103 /* VoidKeyword */,
+        "while": 104 /* WhileKeyword */,
+        "with": 105 /* WithKeyword */,
+        "yield": 114 /* YieldKeyword */,
+        "async": 118 /* AsyncKeyword */,
+        "await": 119 /* AwaitKeyword */,
+        "of": 138 /* OfKeyword */,
+        "{": 15 /* OpenBraceToken */,
+        "}": 16 /* CloseBraceToken */,
+        "(": 17 /* OpenParenToken */,
+        ")": 18 /* CloseParenToken */,
+        "[": 19 /* OpenBracketToken */,
+        "]": 20 /* CloseBracketToken */,
+        ".": 21 /* DotToken */,
+        "...": 22 /* DotDotDotToken */,
+        ";": 23 /* SemicolonToken */,
+        ",": 24 /* CommaToken */,
+        "<": 25 /* LessThanToken */,
+        ">": 27 /* GreaterThanToken */,
+        "<=": 28 /* LessThanEqualsToken */,
+        ">=": 29 /* GreaterThanEqualsToken */,
+        "==": 30 /* EqualsEqualsToken */,
+        "!=": 31 /* ExclamationEqualsToken */,
+        "===": 32 /* EqualsEqualsEqualsToken */,
+        "!==": 33 /* ExclamationEqualsEqualsToken */,
+        "=>": 34 /* EqualsGreaterThanToken */,
+        "+": 35 /* PlusToken */,
+        "-": 36 /* MinusToken */,
+        "**": 38 /* AsteriskAsteriskToken */,
+        "*": 37 /* AsteriskToken */,
+        "/": 39 /* SlashToken */,
+        "%": 40 /* PercentToken */,
+        "++": 41 /* PlusPlusToken */,
+        "--": 42 /* MinusMinusToken */,
+        "<<": 43 /* LessThanLessThanToken */,
+        "</": 26 /* LessThanSlashToken */,
+        ">>": 44 /* GreaterThanGreaterThanToken */,
+        ">>>": 45 /* GreaterThanGreaterThanGreaterThanToken */,
+        "&": 46 /* AmpersandToken */,
+        "|": 47 /* BarToken */,
+        "^": 48 /* CaretToken */,
+        "!": 49 /* ExclamationToken */,
+        "~": 50 /* TildeToken */,
+        "&&": 51 /* AmpersandAmpersandToken */,
+        "||": 52 /* BarBarToken */,
+        "?": 53 /* QuestionToken */,
+        ":": 54 /* ColonToken */,
+        "=": 56 /* EqualsToken */,
+        "+=": 57 /* PlusEqualsToken */,
+        "-=": 58 /* MinusEqualsToken */,
+        "*=": 59 /* AsteriskEqualsToken */,
+        "**=": 60 /* AsteriskAsteriskEqualsToken */,
+        "/=": 61 /* SlashEqualsToken */,
+        "%=": 62 /* PercentEqualsToken */,
+        "<<=": 63 /* LessThanLessThanEqualsToken */,
+        ">>=": 64 /* GreaterThanGreaterThanEqualsToken */,
+        ">>>=": 65 /* GreaterThanGreaterThanGreaterThanEqualsToken */,
+        "&=": 66 /* AmpersandEqualsToken */,
+        "|=": 67 /* BarEqualsToken */,
+        "^=": 68 /* CaretEqualsToken */,
+        "@": 55 /* AtToken */
+    };
+    /*
+        As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers
+        IdentifierStart ::
+            Can contain Unicode 3.0.0  categories:
+            Uppercase letter (Lu),
+            Lowercase letter (Ll),
+            Titlecase letter (Lt),
+            Modifier letter (Lm),
+            Other letter (Lo), or
+            Letter number (Nl).
+        IdentifierPart :: =
+            Can contain IdentifierStart + Unicode 3.0.0  categories:
+            Non-spacing mark (Mn),
+            Combining spacing mark (Mc),
+            Decimal number (Nd), or
+            Connector punctuation (Pc).
+
+        Codepoint ranges for ES3 Identifiers are extracted from the Unicode 3.0.0 specification at:
+        http://www.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.txt
+    */
+    var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
+    var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
+    /*
+        As per ECMAScript Language Specification 5th Edition, Section 7.6: ISyntaxToken Names and Identifiers
+        IdentifierStart ::
+            Can contain Unicode 6.2  categories:
+            Uppercase letter (Lu),
+            Lowercase letter (Ll),
+            Titlecase letter (Lt),
+            Modifier letter (Lm),
+            Other letter (Lo), or
+            Letter number (Nl).
+        IdentifierPart ::
+            Can contain IdentifierStart + Unicode 6.2  categories:
+            Non-spacing mark (Mn),
+            Combining spacing mark (Mc),
+            Decimal number (Nd),
+            Connector punctuation (Pc),
+            <ZWNJ>, or
+            <ZWJ>.
+
+        Codepoint ranges for ES5 Identifiers are extracted from the Unicode 6.2 specification at:
+        http://www.unicode.org/Public/6.2.0/ucd/UnicodeData.txt
+    */
+    var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
+    var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
+    function lookupInUnicodeMap(code, map) {
+        // Bail out quickly if it couldn't possibly be in the map.
+        if (code < map[0]) {
+            return false;
+        }
+        // Perform binary search in one of the Unicode range maps
+        var lo = 0;
+        var hi = map.length;
+        var mid;
+        while (lo + 1 < hi) {
+            mid = lo + (hi - lo) / 2;
+            // mid has to be even to catch a range's beginning
+            mid -= mid % 2;
+            if (map[mid] <= code && code <= map[mid + 1]) {
+                return true;
+            }
+            if (code < map[mid]) {
+                hi = mid;
+            }
+            else {
+                lo = mid + 2;
+            }
+        }
+        return false;
+    }
+    /* @internal */ function isUnicodeIdentifierStart(code, languageVersion) {
+        return languageVersion >= 1 /* ES5 */ ?
+            lookupInUnicodeMap(code, unicodeES5IdentifierStart) :
+            lookupInUnicodeMap(code, unicodeES3IdentifierStart);
+    }
+    ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart;
+    function isUnicodeIdentifierPart(code, languageVersion) {
+        return languageVersion >= 1 /* ES5 */ ?
+            lookupInUnicodeMap(code, unicodeES5IdentifierPart) :
+            lookupInUnicodeMap(code, unicodeES3IdentifierPart);
+    }
+    function makeReverseMap(source) {
+        var result = [];
+        for (var name_4 in source) {
+            if (source.hasOwnProperty(name_4)) {
+                result[source[name_4]] = name_4;
+            }
+        }
+        return result;
+    }
+    var tokenStrings = makeReverseMap(textToToken);
+    function tokenToString(t) {
+        return tokenStrings[t];
+    }
+    ts.tokenToString = tokenToString;
+    /* @internal */
+    function stringToToken(s) {
+        return textToToken[s];
+    }
+    ts.stringToToken = stringToToken;
+    /* @internal */
+    function computeLineStarts(text) {
+        var result = new Array();
+        var pos = 0;
+        var lineStart = 0;
+        while (pos < text.length) {
+            var ch = text.charCodeAt(pos);
+            pos++;
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                    if (text.charCodeAt(pos) === 10 /* lineFeed */) {
+                        pos++;
+                    }
+                case 10 /* lineFeed */:
+                    result.push(lineStart);
+                    lineStart = pos;
+                    break;
+                default:
+                    if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
+                        result.push(lineStart);
+                        lineStart = pos;
+                    }
+                    break;
+            }
+        }
+        result.push(lineStart);
+        return result;
+    }
+    ts.computeLineStarts = computeLineStarts;
+    function getPositionOfLineAndCharacter(sourceFile, line, character) {
+        return computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character);
+    }
+    ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter;
+    /* @internal */
+    function computePositionOfLineAndCharacter(lineStarts, line, character) {
+        ts.Debug.assert(line >= 0 && line < lineStarts.length);
+        return lineStarts[line] + character;
+    }
+    ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter;
+    /* @internal */
+    function getLineStarts(sourceFile) {
+        return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text));
+    }
+    ts.getLineStarts = getLineStarts;
+    /* @internal */
+    /**
+     * We assume the first line starts at position 0 and 'position' is non-negative.
+     */
+    function computeLineAndCharacterOfPosition(lineStarts, position) {
+        var lineNumber = ts.binarySearch(lineStarts, position);
+        if (lineNumber < 0) {
+            // If the actual position was not found,
+            // the binary search returns the 2's-complement of the next line start
+            // e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20
+            // then the search will return -2.
+            //
+            // We want the index of the previous line start, so we subtract 1.
+            // Review 2's-complement if this is confusing.
+            lineNumber = ~lineNumber - 1;
+            ts.Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file");
+        }
+        return {
+            line: lineNumber,
+            character: position - lineStarts[lineNumber]
+        };
+    }
+    ts.computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition;
+    function getLineAndCharacterOfPosition(sourceFile, position) {
+        return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
+    }
+    ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    function isWhiteSpace(ch) {
+        return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
+    }
+    ts.isWhiteSpace = isWhiteSpace;
+    /** Does not include line breaks. For that, see isWhiteSpaceLike. */
+    function isWhiteSpaceSingleLine(ch) {
+        // Note: nextLine is in the Zs space, and should be considered to be a whitespace.
+        // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
+        return ch === 32 /* space */ ||
+            ch === 9 /* tab */ ||
+            ch === 11 /* verticalTab */ ||
+            ch === 12 /* formFeed */ ||
+            ch === 160 /* nonBreakingSpace */ ||
+            ch === 133 /* nextLine */ ||
+            ch === 5760 /* ogham */ ||
+            ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
+            ch === 8239 /* narrowNoBreakSpace */ ||
+            ch === 8287 /* mathematicalSpace */ ||
+            ch === 12288 /* ideographicSpace */ ||
+            ch === 65279 /* byteOrderMark */;
+    }
+    ts.isWhiteSpaceSingleLine = isWhiteSpaceSingleLine;
+    function isLineBreak(ch) {
+        // ES5 7.3:
+        // The ECMAScript line terminator characters are listed in Table 3.
+        //     Table 3: Line Terminator Characters
+        //     Code Unit Value     Name                    Formal Name
+        //     \u000A              Line Feed               <LF>
+        //     \u000D              Carriage Return         <CR>
+        //     \u2028              Line separator          <LS>
+        //     \u2029              Paragraph separator     <PS>
+        // Only the characters in Table 3 are treated as line terminators. Other new line or line
+        // breaking characters are treated as white space but not as line terminators.
+        return ch === 10 /* lineFeed */ ||
+            ch === 13 /* carriageReturn */ ||
+            ch === 8232 /* lineSeparator */ ||
+            ch === 8233 /* paragraphSeparator */;
+    }
+    ts.isLineBreak = isLineBreak;
+    function isDigit(ch) {
+        return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
+    }
+    /* @internal */
+    function isOctalDigit(ch) {
+        return ch >= 48 /* _0 */ && ch <= 55 /* _7 */;
+    }
+    ts.isOctalDigit = isOctalDigit;
+    function couldStartTrivia(text, pos) {
+        // Keep in sync with skipTrivia
+        var ch = text.charCodeAt(pos);
+        switch (ch) {
+            case 13 /* carriageReturn */:
+            case 10 /* lineFeed */:
+            case 9 /* tab */:
+            case 11 /* verticalTab */:
+            case 12 /* formFeed */:
+            case 32 /* space */:
+            case 47 /* slash */:
+            // starts of normal trivia
+            case 60 /* lessThan */:
+            case 61 /* equals */:
+            case 62 /* greaterThan */:
+                // Starts of conflict marker trivia
+                return true;
+            case 35 /* hash */:
+                // Only if its the beginning can we have #! trivia
+                return pos === 0;
+            default:
+                return ch > 127 /* maxAsciiCharacter */;
+        }
+    }
+    ts.couldStartTrivia = couldStartTrivia;
+    /* @internal */
+    function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments) {
+        if (stopAtComments === void 0) { stopAtComments = false; }
+        // Using ! with a greater than test is a fast way of testing the following conditions:
+        //  pos === undefined || pos === null || isNaN(pos) || pos < 0;
+        if (!(pos >= 0)) {
+            return pos;
+        }
+        // Keep in sync with couldStartTrivia
+        while (true) {
+            var ch = text.charCodeAt(pos);
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                    if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
+                        pos++;
+                    }
+                case 10 /* lineFeed */:
+                    pos++;
+                    if (stopAfterLineBreak) {
+                        return pos;
+                    }
+                    continue;
+                case 9 /* tab */:
+                case 11 /* verticalTab */:
+                case 12 /* formFeed */:
+                case 32 /* space */:
+                    pos++;
+                    continue;
+                case 47 /* slash */:
+                    if (stopAtComments) {
+                        break;
+                    }
+                    if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+                        pos += 2;
+                        while (pos < text.length) {
+                            if (isLineBreak(text.charCodeAt(pos))) {
+                                break;
+                            }
+                            pos++;
+                        }
+                        continue;
+                    }
+                    if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+                        pos += 2;
+                        while (pos < text.length) {
+                            if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+                                pos += 2;
+                                break;
+                            }
+                            pos++;
+                        }
+                        continue;
+                    }
+                    break;
+                case 60 /* lessThan */:
+                case 61 /* equals */:
+                case 62 /* greaterThan */:
+                    if (isConflictMarkerTrivia(text, pos)) {
+                        pos = scanConflictMarkerTrivia(text, pos);
+                        continue;
+                    }
+                    break;
+                case 35 /* hash */:
+                    if (pos === 0 && isShebangTrivia(text, pos)) {
+                        pos = scanShebangTrivia(text, pos);
+                        continue;
+                    }
+                    break;
+                default:
+                    if (ch > 127 /* maxAsciiCharacter */ && (isWhiteSpace(ch))) {
+                        pos++;
+                        continue;
+                    }
+                    break;
+            }
+            return pos;
+        }
+    }
+    ts.skipTrivia = skipTrivia;
+    // All conflict markers consist of the same character repeated seven times.  If it is
+    // a <<<<<<< or >>>>>>> marker then it is also followed by a space.
+    var mergeConflictMarkerLength = "<<<<<<<".length;
+    function isConflictMarkerTrivia(text, pos) {
+        ts.Debug.assert(pos >= 0);
+        // Conflict markers must be at the start of a line.
+        if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) {
+            var ch = text.charCodeAt(pos);
+            if ((pos + mergeConflictMarkerLength) < text.length) {
+                for (var i = 0, n = mergeConflictMarkerLength; i < n; i++) {
+                    if (text.charCodeAt(pos + i) !== ch) {
+                        return false;
+                    }
+                }
+                return ch === 61 /* equals */ ||
+                    text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* space */;
+            }
+        }
+        return false;
+    }
+    function scanConflictMarkerTrivia(text, pos, error) {
+        if (error) {
+            error(ts.Diagnostics.Merge_conflict_marker_encountered, mergeConflictMarkerLength);
+        }
+        var ch = text.charCodeAt(pos);
+        var len = text.length;
+        if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) {
+            while (pos < len && !isLineBreak(text.charCodeAt(pos))) {
+                pos++;
+            }
+        }
+        else {
+            ts.Debug.assert(ch === 61 /* equals */);
+            // Consume everything from the start of the mid-conflict marker to the start of the next
+            // end-conflict marker.
+            while (pos < len) {
+                var ch_1 = text.charCodeAt(pos);
+                if (ch_1 === 62 /* greaterThan */ && isConflictMarkerTrivia(text, pos)) {
+                    break;
+                }
+                pos++;
+            }
+        }
+        return pos;
+    }
+    var shebangTriviaRegex = /^#!.*/;
+    function isShebangTrivia(text, pos) {
+        // Shebangs check must only be done at the start of the file
+        ts.Debug.assert(pos === 0);
+        return shebangTriviaRegex.test(text);
+    }
+    function scanShebangTrivia(text, pos) {
+        var shebang = shebangTriviaRegex.exec(text)[0];
+        pos = pos + shebang.length;
+        return pos;
+    }
+    /**
+     * Extract comments from text prefixing the token closest following `pos`.
+     * The return value is an array containing a TextRange for each comment.
+     * Single-line comment ranges include the beginning '//' characters but not the ending line break.
+     * Multi - line comment ranges include the beginning '/* and ending '<asterisk>/' characters.
+     * The return value is undefined if no comments were found.
+     * @param trailing
+     * If false, whitespace is skipped until the first line break and comments between that location
+     * and the next token are returned.
+     * If true, comments occurring between the given position and the next line break are returned.
+     */
+    function getCommentRanges(text, pos, trailing) {
+        var result;
+        var collecting = trailing || pos === 0;
+        while (pos < text.length) {
+            var ch = text.charCodeAt(pos);
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                    if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
+                        pos++;
+                    }
+                case 10 /* lineFeed */:
+                    pos++;
+                    if (trailing) {
+                        return result;
+                    }
+                    collecting = true;
+                    if (result && result.length) {
+                        ts.lastOrUndefined(result).hasTrailingNewLine = true;
+                    }
+                    continue;
+                case 9 /* tab */:
+                case 11 /* verticalTab */:
+                case 12 /* formFeed */:
+                case 32 /* space */:
+                    pos++;
+                    continue;
+                case 47 /* slash */:
+                    var nextChar = text.charCodeAt(pos + 1);
+                    var hasTrailingNewLine = false;
+                    if (nextChar === 47 /* slash */ || nextChar === 42 /* asterisk */) {
+                        var kind = nextChar === 47 /* slash */ ? 2 /* SingleLineCommentTrivia */ : 3 /* MultiLineCommentTrivia */;
+                        var startPos = pos;
+                        pos += 2;
+                        if (nextChar === 47 /* slash */) {
+                            while (pos < text.length) {
+                                if (isLineBreak(text.charCodeAt(pos))) {
+                                    hasTrailingNewLine = true;
+                                    break;
+                                }
+                                pos++;
+                            }
+                        }
+                        else {
+                            while (pos < text.length) {
+                                if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+                                    pos += 2;
+                                    break;
+                                }
+                                pos++;
+                            }
+                        }
+                        if (collecting) {
+                            if (!result) {
+                                result = [];
+                            }
+                            result.push({ pos: startPos, end: pos, hasTrailingNewLine: hasTrailingNewLine, kind: kind });
+                        }
+                        continue;
+                    }
+                    break;
+                default:
+                    if (ch > 127 /* maxAsciiCharacter */ && (isWhiteSpace(ch))) {
+                        if (result && result.length && isLineBreak(ch)) {
+                            ts.lastOrUndefined(result).hasTrailingNewLine = true;
+                        }
+                        pos++;
+                        continue;
+                    }
+                    break;
+            }
+            return result;
+        }
+        return result;
+    }
+    function getLeadingCommentRanges(text, pos) {
+        return getCommentRanges(text, pos, /*trailing*/ false);
+    }
+    ts.getLeadingCommentRanges = getLeadingCommentRanges;
+    function getTrailingCommentRanges(text, pos) {
+        return getCommentRanges(text, pos, /*trailing*/ true);
+    }
+    ts.getTrailingCommentRanges = getTrailingCommentRanges;
+    /** Optionally, get the shebang */
+    function getShebang(text) {
+        return shebangTriviaRegex.test(text)
+            ? shebangTriviaRegex.exec(text)[0]
+            : undefined;
+    }
+    ts.getShebang = getShebang;
+    function isIdentifierStart(ch, languageVersion) {
+        return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ ||
+            ch === 36 /* $ */ || ch === 95 /* _ */ ||
+            ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
+    }
+    ts.isIdentifierStart = isIdentifierStart;
+    function isIdentifierPart(ch, languageVersion) {
+        return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ ||
+            ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ ||
+            ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
+    }
+    ts.isIdentifierPart = isIdentifierPart;
+    /* @internal */
+    function isIdentifier(name, languageVersion) {
+        if (!isIdentifierStart(name.charCodeAt(0), languageVersion)) {
+            return false;
+        }
+        for (var i = 1, n = name.length; i < n; i++) {
+            if (!isIdentifierPart(name.charCodeAt(i), languageVersion)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ts.isIdentifier = isIdentifier;
+    // Creates a scanner over a (possibly unspecified) range of a piece of text.
+    function createScanner(languageVersion, skipTrivia, languageVariant, text, onError, start, length) {
+        if (languageVariant === void 0) { languageVariant = 0 /* Standard */; }
+        // Current position (end position of text of current token)
+        var pos;
+        // end of text
+        var end;
+        // Start position of whitespace before current token
+        var startPos;
+        // Start position of text of current token
+        var tokenPos;
+        var token;
+        var tokenValue;
+        var precedingLineBreak;
+        var hasExtendedUnicodeEscape;
+        var tokenIsUnterminated;
+        setText(text, start, length);
+        return {
+            getStartPos: function () { return startPos; },
+            getTextPos: function () { return pos; },
+            getToken: function () { return token; },
+            getTokenPos: function () { return tokenPos; },
+            getTokenText: function () { return text.substring(tokenPos, pos); },
+            getTokenValue: function () { return tokenValue; },
+            hasExtendedUnicodeEscape: function () { return hasExtendedUnicodeEscape; },
+            hasPrecedingLineBreak: function () { return precedingLineBreak; },
+            isIdentifier: function () { return token === 69 /* Identifier */ || token > 105 /* LastReservedWord */; },
+            isReservedWord: function () { return token >= 70 /* FirstReservedWord */ && token <= 105 /* LastReservedWord */; },
+            isUnterminated: function () { return tokenIsUnterminated; },
+            reScanGreaterToken: reScanGreaterToken,
+            reScanSlashToken: reScanSlashToken,
+            reScanTemplateToken: reScanTemplateToken,
+            scanJsxIdentifier: scanJsxIdentifier,
+            reScanJsxToken: reScanJsxToken,
+            scanJsxToken: scanJsxToken,
+            scanJSDocToken: scanJSDocToken,
+            scan: scan,
+            getText: getText,
+            setText: setText,
+            setScriptTarget: setScriptTarget,
+            setLanguageVariant: setLanguageVariant,
+            setOnError: setOnError,
+            setTextPos: setTextPos,
+            tryScan: tryScan,
+            lookAhead: lookAhead,
+            scanRange: scanRange
+        };
+        function error(message, length) {
+            if (onError) {
+                onError(message, length || 0);
+            }
+        }
+        function scanNumber() {
+            var start = pos;
+            while (isDigit(text.charCodeAt(pos)))
+                pos++;
+            if (text.charCodeAt(pos) === 46 /* dot */) {
+                pos++;
+                while (isDigit(text.charCodeAt(pos)))
+                    pos++;
+            }
+            var end = pos;
+            if (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */) {
+                pos++;
+                if (text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */)
+                    pos++;
+                if (isDigit(text.charCodeAt(pos))) {
+                    pos++;
+                    while (isDigit(text.charCodeAt(pos)))
+                        pos++;
+                    end = pos;
+                }
+                else {
+                    error(ts.Diagnostics.Digit_expected);
+                }
+            }
+            return "" + +(text.substring(start, end));
+        }
+        function scanOctalDigits() {
+            var start = pos;
+            while (isOctalDigit(text.charCodeAt(pos))) {
+                pos++;
+            }
+            return +(text.substring(start, pos));
+        }
+        /**
+         * Scans the given number of hexadecimal digits in the text,
+         * returning -1 if the given number is unavailable.
+         */
+        function scanExactNumberOfHexDigits(count) {
+            return scanHexDigits(/*minCount*/ count, /*scanAsManyAsPossible*/ false);
+        }
+        /**
+         * Scans as many hexadecimal digits as are available in the text,
+         * returning -1 if the given number of digits was unavailable.
+         */
+        function scanMinimumNumberOfHexDigits(count) {
+            return scanHexDigits(/*minCount*/ count, /*scanAsManyAsPossible*/ true);
+        }
+        function scanHexDigits(minCount, scanAsManyAsPossible) {
+            var digits = 0;
+            var value = 0;
+            while (digits < minCount || scanAsManyAsPossible) {
+                var ch = text.charCodeAt(pos);
+                if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
+                    value = value * 16 + ch - 48 /* _0 */;
+                }
+                else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
+                    value = value * 16 + ch - 65 /* A */ + 10;
+                }
+                else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
+                    value = value * 16 + ch - 97 /* a */ + 10;
+                }
+                else {
+                    break;
+                }
+                pos++;
+                digits++;
+            }
+            if (digits < minCount) {
+                value = -1;
+            }
+            return value;
+        }
+        function scanString() {
+            var quote = text.charCodeAt(pos);
+            pos++;
+            var result = "";
+            var start = pos;
+            while (true) {
+                if (pos >= end) {
+                    result += text.substring(start, pos);
+                    tokenIsUnterminated = true;
+                    error(ts.Diagnostics.Unterminated_string_literal);
+                    break;
+                }
+                var ch = text.charCodeAt(pos);
+                if (ch === quote) {
+                    result += text.substring(start, pos);
+                    pos++;
+                    break;
+                }
+                if (ch === 92 /* backslash */) {
+                    result += text.substring(start, pos);
+                    result += scanEscapeSequence();
+                    start = pos;
+                    continue;
+                }
+                if (isLineBreak(ch)) {
+                    result += text.substring(start, pos);
+                    tokenIsUnterminated = true;
+                    error(ts.Diagnostics.Unterminated_string_literal);
+                    break;
+                }
+                pos++;
+            }
+            return result;
+        }
+        /**
+         * Sets the current 'tokenValue' and returns a NoSubstitutionTemplateLiteral or
+         * a literal component of a TemplateExpression.
+         */
+        function scanTemplateAndSetTokenValue() {
+            var startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
+            pos++;
+            var start = pos;
+            var contents = "";
+            var resultingToken;
+            while (true) {
+                if (pos >= end) {
+                    contents += text.substring(start, pos);
+                    tokenIsUnterminated = true;
+                    error(ts.Diagnostics.Unterminated_template_literal);
+                    resultingToken = startedWithBacktick ? 11 /* NoSubstitutionTemplateLiteral */ : 14 /* TemplateTail */;
+                    break;
+                }
+                var currChar = text.charCodeAt(pos);
+                // '`'
+                if (currChar === 96 /* backtick */) {
+                    contents += text.substring(start, pos);
+                    pos++;
+                    resultingToken = startedWithBacktick ? 11 /* NoSubstitutionTemplateLiteral */ : 14 /* TemplateTail */;
+                    break;
+                }
+                // '${'
+                if (currChar === 36 /* $ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* openBrace */) {
+                    contents += text.substring(start, pos);
+                    pos += 2;
+                    resultingToken = startedWithBacktick ? 12 /* TemplateHead */ : 13 /* TemplateMiddle */;
+                    break;
+                }
+                // Escape character
+                if (currChar === 92 /* backslash */) {
+                    contents += text.substring(start, pos);
+                    contents += scanEscapeSequence();
+                    start = pos;
+                    continue;
+                }
+                // Speculated ECMAScript 6 Spec 11.8.6.1:
+                // <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for Template Values
+                if (currChar === 13 /* carriageReturn */) {
+                    contents += text.substring(start, pos);
+                    pos++;
+                    if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
+                        pos++;
+                    }
+                    contents += "\n";
+                    start = pos;
+                    continue;
+                }
+                pos++;
+            }
+            ts.Debug.assert(resultingToken !== undefined);
+            tokenValue = contents;
+            return resultingToken;
+        }
+        function scanEscapeSequence() {
+            pos++;
+            if (pos >= end) {
+                error(ts.Diagnostics.Unexpected_end_of_text);
+                return "";
+            }
+            var ch = text.charCodeAt(pos);
+            pos++;
+            switch (ch) {
+                case 48 /* _0 */:
+                    return "\0";
+                case 98 /* b */:
+                    return "\b";
+                case 116 /* t */:
+                    return "\t";
+                case 110 /* n */:
+                    return "\n";
+                case 118 /* v */:
+                    return "\v";
+                case 102 /* f */:
+                    return "\f";
+                case 114 /* r */:
+                    return "\r";
+                case 39 /* singleQuote */:
+                    return "\'";
+                case 34 /* doubleQuote */:
+                    return "\"";
+                case 117 /* u */:
+                    // '\u{DDDDDDDD}'
+                    if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
+                        hasExtendedUnicodeEscape = true;
+                        pos++;
+                        return scanExtendedUnicodeEscape();
+                    }
+                    // '\uDDDD'
+                    return scanHexadecimalEscape(/*numDigits*/ 4);
+                case 120 /* x */:
+                    // '\xDD'
+                    return scanHexadecimalEscape(/*numDigits*/ 2);
+                // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence),
+                // the line terminator is interpreted to be "the empty code unit sequence".
+                case 13 /* carriageReturn */:
+                    if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
+                        pos++;
+                    }
+                // fall through
+                case 10 /* lineFeed */:
+                case 8232 /* lineSeparator */:
+                case 8233 /* paragraphSeparator */:
+                    return "";
+                default:
+                    return String.fromCharCode(ch);
+            }
+        }
+        function scanHexadecimalEscape(numDigits) {
+            var escapedValue = scanExactNumberOfHexDigits(numDigits);
+            if (escapedValue >= 0) {
+                return String.fromCharCode(escapedValue);
+            }
+            else {
+                error(ts.Diagnostics.Hexadecimal_digit_expected);
+                return "";
+            }
+        }
+        function scanExtendedUnicodeEscape() {
+            var escapedValue = scanMinimumNumberOfHexDigits(1);
+            var isInvalidExtendedEscape = false;
+            // Validate the value of the digit
+            if (escapedValue < 0) {
+                error(ts.Diagnostics.Hexadecimal_digit_expected);
+                isInvalidExtendedEscape = true;
+            }
+            else if (escapedValue > 0x10FFFF) {
+                error(ts.Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
+                isInvalidExtendedEscape = true;
+            }
+            if (pos >= end) {
+                error(ts.Diagnostics.Unexpected_end_of_text);
+                isInvalidExtendedEscape = true;
+            }
+            else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
+                // Only swallow the following character up if it's a '}'.
+                pos++;
+            }
+            else {
+                error(ts.Diagnostics.Unterminated_Unicode_escape_sequence);
+                isInvalidExtendedEscape = true;
+            }
+            if (isInvalidExtendedEscape) {
+                return "";
+            }
+            return utf16EncodeAsString(escapedValue);
+        }
+        // Derived from the 10.1.1 UTF16Encoding of the ES6 Spec.
+        function utf16EncodeAsString(codePoint) {
+            ts.Debug.assert(0x0 <= codePoint && codePoint <= 0x10FFFF);
+            if (codePoint <= 65535) {
+                return String.fromCharCode(codePoint);
+            }
+            var codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800;
+            var codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00;
+            return String.fromCharCode(codeUnit1, codeUnit2);
+        }
+        // Current character is known to be a backslash. Check for Unicode escape of the form '\uXXXX'
+        // and return code point value if valid Unicode escape is found. Otherwise return -1.
+        function peekUnicodeEscape() {
+            if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* u */) {
+                var start_1 = pos;
+                pos += 2;
+                var value = scanExactNumberOfHexDigits(4);
+                pos = start_1;
+                return value;
+            }
+            return -1;
+        }
+        function scanIdentifierParts() {
+            var result = "";
+            var start = pos;
+            while (pos < end) {
+                var ch = text.charCodeAt(pos);
+                if (isIdentifierPart(ch, languageVersion)) {
+                    pos++;
+                }
+                else if (ch === 92 /* backslash */) {
+                    ch = peekUnicodeEscape();
+                    if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) {
+                        break;
+                    }
+                    result += text.substring(start, pos);
+                    result += String.fromCharCode(ch);
+                    // Valid Unicode escape is always six characters
+                    pos += 6;
+                    start = pos;
+                }
+                else {
+                    break;
+                }
+            }
+            result += text.substring(start, pos);
+            return result;
+        }
+        function getIdentifierToken() {
+            // Reserved words are between 2 and 11 characters long and start with a lowercase letter
+            var len = tokenValue.length;
+            if (len >= 2 && len <= 11) {
+                var ch = tokenValue.charCodeAt(0);
+                if (ch >= 97 /* a */ && ch <= 122 /* z */ && hasOwnProperty.call(textToToken, tokenValue)) {
+                    return token = textToToken[tokenValue];
+                }
+            }
+            return token = 69 /* Identifier */;
+        }
+        function scanBinaryOrOctalDigits(base) {
+            ts.Debug.assert(base !== 2 || base !== 8, "Expected either base 2 or base 8");
+            var value = 0;
+            // For counting number of digits; Valid binaryIntegerLiteral must have at least one binary digit following B or b.
+            // Similarly valid octalIntegerLiteral must have at least one octal digit following o or O.
+            var numberOfDigits = 0;
+            while (true) {
+                var ch = text.charCodeAt(pos);
+                var valueOfCh = ch - 48 /* _0 */;
+                if (!isDigit(ch) || valueOfCh >= base) {
+                    break;
+                }
+                value = value * base + valueOfCh;
+                pos++;
+                numberOfDigits++;
+            }
+            // Invalid binaryIntegerLiteral or octalIntegerLiteral
+            if (numberOfDigits === 0) {
+                return -1;
+            }
+            return value;
+        }
+        function scan() {
+            startPos = pos;
+            hasExtendedUnicodeEscape = false;
+            precedingLineBreak = false;
+            tokenIsUnterminated = false;
+            while (true) {
+                tokenPos = pos;
+                if (pos >= end) {
+                    return token = 1 /* EndOfFileToken */;
+                }
+                var ch = text.charCodeAt(pos);
+                // Special handling for shebang
+                if (ch === 35 /* hash */ && pos === 0 && isShebangTrivia(text, pos)) {
+                    pos = scanShebangTrivia(text, pos);
+                    if (skipTrivia) {
+                        continue;
+                    }
+                    else {
+                        return token = 6 /* ShebangTrivia */;
+                    }
+                }
+                switch (ch) {
+                    case 10 /* lineFeed */:
+                    case 13 /* carriageReturn */:
+                        precedingLineBreak = true;
+                        if (skipTrivia) {
+                            pos++;
+                            continue;
+                        }
+                        else {
+                            if (ch === 13 /* carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
+                                // consume both CR and LF
+                                pos += 2;
+                            }
+                            else {
+                                pos++;
+                            }
+                            return token = 4 /* NewLineTrivia */;
+                        }
+                    case 9 /* tab */:
+                    case 11 /* verticalTab */:
+                    case 12 /* formFeed */:
+                    case 32 /* space */:
+                        if (skipTrivia) {
+                            pos++;
+                            continue;
+                        }
+                        else {
+                            while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
+                                pos++;
+                            }
+                            return token = 5 /* WhitespaceTrivia */;
+                        }
+                    case 33 /* exclamation */:
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+                                return pos += 3, token = 33 /* ExclamationEqualsEqualsToken */;
+                            }
+                            return pos += 2, token = 31 /* ExclamationEqualsToken */;
+                        }
+                        pos++;
+                        return token = 49 /* ExclamationToken */;
+                    case 34 /* doubleQuote */:
+                    case 39 /* singleQuote */:
+                        tokenValue = scanString();
+                        return token = 9 /* StringLiteral */;
+                    case 96 /* backtick */:
+                        return token = scanTemplateAndSetTokenValue();
+                    case 37 /* percent */:
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 62 /* PercentEqualsToken */;
+                        }
+                        pos++;
+                        return token = 40 /* PercentToken */;
+                    case 38 /* ampersand */:
+                        if (text.charCodeAt(pos + 1) === 38 /* ampersand */) {
+                            return pos += 2, token = 51 /* AmpersandAmpersandToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 66 /* AmpersandEqualsToken */;
+                        }
+                        pos++;
+                        return token = 46 /* AmpersandToken */;
+                    case 40 /* openParen */:
+                        pos++;
+                        return token = 17 /* OpenParenToken */;
+                    case 41 /* closeParen */:
+                        pos++;
+                        return token = 18 /* CloseParenToken */;
+                    case 42 /* asterisk */:
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 59 /* AsteriskEqualsToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+                            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+                                return pos += 3, token = 60 /* AsteriskAsteriskEqualsToken */;
+                            }
+                            return pos += 2, token = 38 /* AsteriskAsteriskToken */;
+                        }
+                        pos++;
+                        return token = 37 /* AsteriskToken */;
+                    case 43 /* plus */:
+                        if (text.charCodeAt(pos + 1) === 43 /* plus */) {
+                            return pos += 2, token = 41 /* PlusPlusToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 57 /* PlusEqualsToken */;
+                        }
+                        pos++;
+                        return token = 35 /* PlusToken */;
+                    case 44 /* comma */:
+                        pos++;
+                        return token = 24 /* CommaToken */;
+                    case 45 /* minus */:
+                        if (text.charCodeAt(pos + 1) === 45 /* minus */) {
+                            return pos += 2, token = 42 /* MinusMinusToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 58 /* MinusEqualsToken */;
+                        }
+                        pos++;
+                        return token = 36 /* MinusToken */;
+                    case 46 /* dot */:
+                        if (isDigit(text.charCodeAt(pos + 1))) {
+                            tokenValue = scanNumber();
+                            return token = 8 /* NumericLiteral */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 46 /* dot */ && text.charCodeAt(pos + 2) === 46 /* dot */) {
+                            return pos += 3, token = 22 /* DotDotDotToken */;
+                        }
+                        pos++;
+                        return token = 21 /* DotToken */;
+                    case 47 /* slash */:
+                        // Single-line comment
+                        if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+                            pos += 2;
+                            while (pos < end) {
+                                if (isLineBreak(text.charCodeAt(pos))) {
+                                    break;
+                                }
+                                pos++;
+                            }
+                            if (skipTrivia) {
+                                continue;
+                            }
+                            else {
+                                return token = 2 /* SingleLineCommentTrivia */;
+                            }
+                        }
+                        // Multi-line comment
+                        if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+                            pos += 2;
+                            var commentClosed = false;
+                            while (pos < end) {
+                                var ch_2 = text.charCodeAt(pos);
+                                if (ch_2 === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+                                    pos += 2;
+                                    commentClosed = true;
+                                    break;
+                                }
+                                if (isLineBreak(ch_2)) {
+                                    precedingLineBreak = true;
+                                }
+                                pos++;
+                            }
+                            if (!commentClosed) {
+                                error(ts.Diagnostics.Asterisk_Slash_expected);
+                            }
+                            if (skipTrivia) {
+                                continue;
+                            }
+                            else {
+                                tokenIsUnterminated = !commentClosed;
+                                return token = 3 /* MultiLineCommentTrivia */;
+                            }
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 61 /* SlashEqualsToken */;
+                        }
+                        pos++;
+                        return token = 39 /* SlashToken */;
+                    case 48 /* _0 */:
+                        if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* X */ || text.charCodeAt(pos + 1) === 120 /* x */)) {
+                            pos += 2;
+                            var value = scanMinimumNumberOfHexDigits(1);
+                            if (value < 0) {
+                                error(ts.Diagnostics.Hexadecimal_digit_expected);
+                                value = 0;
+                            }
+                            tokenValue = "" + value;
+                            return token = 8 /* NumericLiteral */;
+                        }
+                        else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* B */ || text.charCodeAt(pos + 1) === 98 /* b */)) {
+                            pos += 2;
+                            var value = scanBinaryOrOctalDigits(/* base */ 2);
+                            if (value < 0) {
+                                error(ts.Diagnostics.Binary_digit_expected);
+                                value = 0;
+                            }
+                            tokenValue = "" + value;
+                            return token = 8 /* NumericLiteral */;
+                        }
+                        else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* O */ || text.charCodeAt(pos + 1) === 111 /* o */)) {
+                            pos += 2;
+                            var value = scanBinaryOrOctalDigits(/* base */ 8);
+                            if (value < 0) {
+                                error(ts.Diagnostics.Octal_digit_expected);
+                                value = 0;
+                            }
+                            tokenValue = "" + value;
+                            return token = 8 /* NumericLiteral */;
+                        }
+                        // Try to parse as an octal
+                        if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) {
+                            tokenValue = "" + scanOctalDigits();
+                            return token = 8 /* NumericLiteral */;
+                        }
+                    // This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero
+                    // can only be followed by an octal digit, a dot, or the end of the number literal. However, we are being
+                    // permissive and allowing decimal digits of the form 08* and 09* (which many browsers also do).
+                    case 49 /* _1 */:
+                    case 50 /* _2 */:
+                    case 51 /* _3 */:
+                    case 52 /* _4 */:
+                    case 53 /* _5 */:
+                    case 54 /* _6 */:
+                    case 55 /* _7 */:
+                    case 56 /* _8 */:
+                    case 57 /* _9 */:
+                        tokenValue = scanNumber();
+                        return token = 8 /* NumericLiteral */;
+                    case 58 /* colon */:
+                        pos++;
+                        return token = 54 /* ColonToken */;
+                    case 59 /* semicolon */:
+                        pos++;
+                        return token = 23 /* SemicolonToken */;
+                    case 60 /* lessThan */:
+                        if (isConflictMarkerTrivia(text, pos)) {
+                            pos = scanConflictMarkerTrivia(text, pos, error);
+                            if (skipTrivia) {
+                                continue;
+                            }
+                            else {
+                                return token = 7 /* ConflictMarkerTrivia */;
+                            }
+                        }
+                        if (text.charCodeAt(pos + 1) === 60 /* lessThan */) {
+                            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+                                return pos += 3, token = 63 /* LessThanLessThanEqualsToken */;
+                            }
+                            return pos += 2, token = 43 /* LessThanLessThanToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 28 /* LessThanEqualsToken */;
+                        }
+                        if (languageVariant === 1 /* JSX */ &&
+                            text.charCodeAt(pos + 1) === 47 /* slash */ &&
+                            text.charCodeAt(pos + 2) !== 42 /* asterisk */) {
+                            return pos += 2, token = 26 /* LessThanSlashToken */;
+                        }
+                        pos++;
+                        return token = 25 /* LessThanToken */;
+                    case 61 /* equals */:
+                        if (isConflictMarkerTrivia(text, pos)) {
+                            pos = scanConflictMarkerTrivia(text, pos, error);
+                            if (skipTrivia) {
+                                continue;
+                            }
+                            else {
+                                return token = 7 /* ConflictMarkerTrivia */;
+                            }
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+                                return pos += 3, token = 32 /* EqualsEqualsEqualsToken */;
+                            }
+                            return pos += 2, token = 30 /* EqualsEqualsToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
+                            return pos += 2, token = 34 /* EqualsGreaterThanToken */;
+                        }
+                        pos++;
+                        return token = 56 /* EqualsToken */;
+                    case 62 /* greaterThan */:
+                        if (isConflictMarkerTrivia(text, pos)) {
+                            pos = scanConflictMarkerTrivia(text, pos, error);
+                            if (skipTrivia) {
+                                continue;
+                            }
+                            else {
+                                return token = 7 /* ConflictMarkerTrivia */;
+                            }
+                        }
+                        pos++;
+                        return token = 27 /* GreaterThanToken */;
+                    case 63 /* question */:
+                        pos++;
+                        return token = 53 /* QuestionToken */;
+                    case 91 /* openBracket */:
+                        pos++;
+                        return token = 19 /* OpenBracketToken */;
+                    case 93 /* closeBracket */:
+                        pos++;
+                        return token = 20 /* CloseBracketToken */;
+                    case 94 /* caret */:
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 68 /* CaretEqualsToken */;
+                        }
+                        pos++;
+                        return token = 48 /* CaretToken */;
+                    case 123 /* openBrace */:
+                        pos++;
+                        return token = 15 /* OpenBraceToken */;
+                    case 124 /* bar */:
+                        if (text.charCodeAt(pos + 1) === 124 /* bar */) {
+                            return pos += 2, token = 52 /* BarBarToken */;
+                        }
+                        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                            return pos += 2, token = 67 /* BarEqualsToken */;
+                        }
+                        pos++;
+                        return token = 47 /* BarToken */;
+                    case 125 /* closeBrace */:
+                        pos++;
+                        return token = 16 /* CloseBraceToken */;
+                    case 126 /* tilde */:
+                        pos++;
+                        return token = 50 /* TildeToken */;
+                    case 64 /* at */:
+                        pos++;
+                        return token = 55 /* AtToken */;
+                    case 92 /* backslash */:
+                        var cookedChar = peekUnicodeEscape();
+                        if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
+                            pos += 6;
+                            tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();
+                            return token = getIdentifierToken();
+                        }
+                        error(ts.Diagnostics.Invalid_character);
+                        pos++;
+                        return token = 0 /* Unknown */;
+                    default:
+                        if (isIdentifierStart(ch, languageVersion)) {
+                            pos++;
+                            while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion))
+                                pos++;
+                            tokenValue = text.substring(tokenPos, pos);
+                            if (ch === 92 /* backslash */) {
+                                tokenValue += scanIdentifierParts();
+                            }
+                            return token = getIdentifierToken();
+                        }
+                        else if (isWhiteSpaceSingleLine(ch)) {
+                            pos++;
+                            continue;
+                        }
+                        else if (isLineBreak(ch)) {
+                            precedingLineBreak = true;
+                            pos++;
+                            continue;
+                        }
+                        error(ts.Diagnostics.Invalid_character);
+                        pos++;
+                        return token = 0 /* Unknown */;
+                }
+            }
+        }
+        function reScanGreaterToken() {
+            if (token === 27 /* GreaterThanToken */) {
+                if (text.charCodeAt(pos) === 62 /* greaterThan */) {
+                    if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
+                        if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+                            return pos += 3, token = 65 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
+                        }
+                        return pos += 2, token = 45 /* GreaterThanGreaterThanGreaterThanToken */;
+                    }
+                    if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+                        return pos += 2, token = 64 /* GreaterThanGreaterThanEqualsToken */;
+                    }
+                    pos++;
+                    return token = 44 /* GreaterThanGreaterThanToken */;
+                }
+                if (text.charCodeAt(pos) === 61 /* equals */) {
+                    pos++;
+                    return token = 29 /* GreaterThanEqualsToken */;
+                }
+            }
+            return token;
+        }
+        function reScanSlashToken() {
+            if (token === 39 /* SlashToken */ || token === 61 /* SlashEqualsToken */) {
+                var p = tokenPos + 1;
+                var inEscape = false;
+                var inCharacterClass = false;
+                while (true) {
+                    // If we reach the end of a file, or hit a newline, then this is an unterminated
+                    // regex.  Report error and return what we have so far.
+                    if (p >= end) {
+                        tokenIsUnterminated = true;
+                        error(ts.Diagnostics.Unterminated_regular_expression_literal);
+                        break;
+                    }
+                    var ch = text.charCodeAt(p);
+                    if (isLineBreak(ch)) {
+                        tokenIsUnterminated = true;
+                        error(ts.Diagnostics.Unterminated_regular_expression_literal);
+                        break;
+                    }
+                    if (inEscape) {
+                        // Parsing an escape character;
+                        // reset the flag and just advance to the next char.
+                        inEscape = false;
+                    }
+                    else if (ch === 47 /* slash */ && !inCharacterClass) {
+                        // A slash within a character class is permissible,
+                        // but in general it signals the end of the regexp literal.
+                        p++;
+                        break;
+                    }
+                    else if (ch === 91 /* openBracket */) {
+                        inCharacterClass = true;
+                    }
+                    else if (ch === 92 /* backslash */) {
+                        inEscape = true;
+                    }
+                    else if (ch === 93 /* closeBracket */) {
+                        inCharacterClass = false;
+                    }
+                    p++;
+                }
+                while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) {
+                    p++;
+                }
+                pos = p;
+                tokenValue = text.substring(tokenPos, pos);
+                token = 10 /* RegularExpressionLiteral */;
+            }
+            return token;
+        }
+        /**
+         * Unconditionally back up and scan a template expression portion.
+         */
+        function reScanTemplateToken() {
+            ts.Debug.assert(token === 16 /* CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'");
+            pos = tokenPos;
+            return token = scanTemplateAndSetTokenValue();
+        }
+        function reScanJsxToken() {
+            pos = tokenPos = startPos;
+            return token = scanJsxToken();
+        }
+        function scanJsxToken() {
+            startPos = tokenPos = pos;
+            if (pos >= end) {
+                return token = 1 /* EndOfFileToken */;
+            }
+            var char = text.charCodeAt(pos);
+            if (char === 60 /* lessThan */) {
+                if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+                    pos += 2;
+                    return token = 26 /* LessThanSlashToken */;
+                }
+                pos++;
+                return token = 25 /* LessThanToken */;
+            }
+            if (char === 123 /* openBrace */) {
+                pos++;
+                return token = 15 /* OpenBraceToken */;
+            }
+            while (pos < end) {
+                pos++;
+                char = text.charCodeAt(pos);
+                if ((char === 123 /* openBrace */) || (char === 60 /* lessThan */)) {
+                    break;
+                }
+            }
+            return token = 244 /* JsxText */;
+        }
+        // Scans a JSX identifier; these differ from normal identifiers in that
+        // they allow dashes
+        function scanJsxIdentifier() {
+            if (tokenIsIdentifierOrKeyword(token)) {
+                var firstCharPosition = pos;
+                while (pos < end) {
+                    var ch = text.charCodeAt(pos);
+                    if (ch === 45 /* minus */ || ((firstCharPosition === pos) ? isIdentifierStart(ch, languageVersion) : isIdentifierPart(ch, languageVersion))) {
+                        pos++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                tokenValue += text.substr(firstCharPosition, pos - firstCharPosition);
+            }
+            return token;
+        }
+        function scanJSDocToken() {
+            if (pos >= end) {
+                return token = 1 /* EndOfFileToken */;
+            }
+            startPos = pos;
+            // Eat leading whitespace
+            var ch = text.charCodeAt(pos);
+            while (pos < end) {
+                ch = text.charCodeAt(pos);
+                if (isWhiteSpaceSingleLine(ch)) {
+                    pos++;
+                }
+                else {
+                    break;
+                }
+            }
+            tokenPos = pos;
+            switch (ch) {
+                case 64 /* at */:
+                    return pos += 1, token = 55 /* AtToken */;
+                case 10 /* lineFeed */:
+                case 13 /* carriageReturn */:
+                    return pos += 1, token = 4 /* NewLineTrivia */;
+                case 42 /* asterisk */:
+                    return pos += 1, token = 37 /* AsteriskToken */;
+                case 123 /* openBrace */:
+                    return pos += 1, token = 15 /* OpenBraceToken */;
+                case 125 /* closeBrace */:
+                    return pos += 1, token = 16 /* CloseBraceToken */;
+                case 91 /* openBracket */:
+                    return pos += 1, token = 19 /* OpenBracketToken */;
+                case 93 /* closeBracket */:
+                    return pos += 1, token = 20 /* CloseBracketToken */;
+                case 61 /* equals */:
+                    return pos += 1, token = 56 /* EqualsToken */;
+                case 44 /* comma */:
+                    return pos += 1, token = 24 /* CommaToken */;
+            }
+            if (isIdentifierStart(ch, 2 /* Latest */)) {
+                pos++;
+                while (isIdentifierPart(text.charCodeAt(pos), 2 /* Latest */) && pos < end) {
+                    pos++;
+                }
+                return token = 69 /* Identifier */;
+            }
+            else {
+                return pos += 1, token = 0 /* Unknown */;
+            }
+        }
+        function speculationHelper(callback, isLookahead) {
+            var savePos = pos;
+            var saveStartPos = startPos;
+            var saveTokenPos = tokenPos;
+            var saveToken = token;
+            var saveTokenValue = tokenValue;
+            var savePrecedingLineBreak = precedingLineBreak;
+            var result = callback();
+            // If our callback returned something 'falsy' or we're just looking ahead,
+            // then unconditionally restore us to where we were.
+            if (!result || isLookahead) {
+                pos = savePos;
+                startPos = saveStartPos;
+                tokenPos = saveTokenPos;
+                token = saveToken;
+                tokenValue = saveTokenValue;
+                precedingLineBreak = savePrecedingLineBreak;
+            }
+            return result;
+        }
+        function scanRange(start, length, callback) {
+            var saveEnd = end;
+            var savePos = pos;
+            var saveStartPos = startPos;
+            var saveTokenPos = tokenPos;
+            var saveToken = token;
+            var savePrecedingLineBreak = precedingLineBreak;
+            var saveTokenValue = tokenValue;
+            var saveHasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
+            var saveTokenIsUnterminated = tokenIsUnterminated;
+            setText(text, start, length);
+            var result = callback();
+            end = saveEnd;
+            pos = savePos;
+            startPos = saveStartPos;
+            tokenPos = saveTokenPos;
+            token = saveToken;
+            precedingLineBreak = savePrecedingLineBreak;
+            tokenValue = saveTokenValue;
+            hasExtendedUnicodeEscape = saveHasExtendedUnicodeEscape;
+            tokenIsUnterminated = saveTokenIsUnterminated;
+            return result;
+        }
+        function lookAhead(callback) {
+            return speculationHelper(callback, /*isLookahead*/ true);
+        }
+        function tryScan(callback) {
+            return speculationHelper(callback, /*isLookahead*/ false);
+        }
+        function getText() {
+            return text;
+        }
+        function setText(newText, start, length) {
+            text = newText || "";
+            end = length === undefined ? text.length : start + length;
+            setTextPos(start || 0);
+        }
+        function setOnError(errorCallback) {
+            onError = errorCallback;
+        }
+        function setScriptTarget(scriptTarget) {
+            languageVersion = scriptTarget;
+        }
+        function setLanguageVariant(variant) {
+            languageVariant = variant;
+        }
+        function setTextPos(textPos) {
+            ts.Debug.assert(textPos >= 0);
+            pos = textPos;
+            startPos = textPos;
+            tokenPos = textPos;
+            token = 0 /* Unknown */;
+            precedingLineBreak = false;
+            tokenValue = undefined;
+            hasExtendedUnicodeEscape = false;
+            tokenIsUnterminated = false;
+        }
+    }
+    ts.createScanner = createScanner;
+})(ts || (ts = {}));
+/// <reference path="sys.ts" />
+/* @internal */
+var ts;
+(function (ts) {
+    function getDeclarationOfKind(symbol, kind) {
+        var declarations = symbol.declarations;
+        if (declarations) {
+            for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) {
+                var declaration = declarations_1[_i];
+                if (declaration.kind === kind) {
+                    return declaration;
+                }
+            }
+        }
+        return undefined;
+    }
+    ts.getDeclarationOfKind = getDeclarationOfKind;
+    // Pool writers to avoid needing to allocate them for every symbol we write.
+    var stringWriters = [];
+    function getSingleLineStringWriter() {
+        if (stringWriters.length === 0) {
+            var str_1 = "";
+            var writeText = function (text) { return str_1 += text; };
+            return {
+                string: function () { return str_1; },
+                writeKeyword: writeText,
+                writeOperator: writeText,
+                writePunctuation: writeText,
+                writeSpace: writeText,
+                writeStringLiteral: writeText,
+                writeParameter: writeText,
+                writeSymbol: writeText,
+                // Completely ignore indentation for string writers.  And map newlines to
+                // a single space.
+                writeLine: function () { return str_1 += " "; },
+                increaseIndent: function () { },
+                decreaseIndent: function () { },
+                clear: function () { return str_1 = ""; },
+                trackSymbol: function () { },
+                reportInaccessibleThisError: function () { }
+            };
+        }
+        return stringWriters.pop();
+    }
+    ts.getSingleLineStringWriter = getSingleLineStringWriter;
+    function releaseStringWriter(writer) {
+        writer.clear();
+        stringWriters.push(writer);
+    }
+    ts.releaseStringWriter = releaseStringWriter;
+    function getFullWidth(node) {
+        return node.end - node.pos;
+    }
+    ts.getFullWidth = getFullWidth;
+    function mapIsEqualTo(map1, map2) {
+        if (!map1 || !map2) {
+            return map1 === map2;
+        }
+        return containsAll(map1, map2) && containsAll(map2, map1);
+    }
+    ts.mapIsEqualTo = mapIsEqualTo;
+    function containsAll(map, other) {
+        for (var key in map) {
+            if (!ts.hasProperty(map, key)) {
+                continue;
+            }
+            if (!ts.hasProperty(other, key) || map[key] !== other[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function arrayIsEqualTo(array1, array2, equaler) {
+        if (!array1 || !array2) {
+            return array1 === array2;
+        }
+        if (array1.length !== array2.length) {
+            return false;
+        }
+        for (var i = 0; i < array1.length; i++) {
+            var equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];
+            if (!equals) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ts.arrayIsEqualTo = arrayIsEqualTo;
+    function hasResolvedModule(sourceFile, moduleNameText) {
+        return sourceFile.resolvedModules && ts.hasProperty(sourceFile.resolvedModules, moduleNameText);
+    }
+    ts.hasResolvedModule = hasResolvedModule;
+    function getResolvedModule(sourceFile, moduleNameText) {
+        return hasResolvedModule(sourceFile, moduleNameText) ? sourceFile.resolvedModules[moduleNameText] : undefined;
+    }
+    ts.getResolvedModule = getResolvedModule;
+    function setResolvedModule(sourceFile, moduleNameText, resolvedModule) {
+        if (!sourceFile.resolvedModules) {
+            sourceFile.resolvedModules = {};
+        }
+        sourceFile.resolvedModules[moduleNameText] = resolvedModule;
+    }
+    ts.setResolvedModule = setResolvedModule;
+    function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) {
+        if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
+            sourceFile.resolvedTypeReferenceDirectiveNames = {};
+        }
+        sourceFile.resolvedTypeReferenceDirectiveNames[typeReferenceDirectiveName] = resolvedTypeReferenceDirective;
+    }
+    ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective;
+    /* @internal */
+    function moduleResolutionIsEqualTo(oldResolution, newResolution) {
+        return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport;
+    }
+    ts.moduleResolutionIsEqualTo = moduleResolutionIsEqualTo;
+    /* @internal */
+    function typeDirectiveIsEqualTo(oldResolution, newResolution) {
+        return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary;
+    }
+    ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo;
+    /* @internal */
+    function hasChangesInResolutions(names, newResolutions, oldResolutions, comparer) {
+        if (names.length !== newResolutions.length) {
+            return false;
+        }
+        for (var i = 0; i < names.length; i++) {
+            var newResolution = newResolutions[i];
+            var oldResolution = oldResolutions && ts.hasProperty(oldResolutions, names[i]) ? oldResolutions[names[i]] : undefined;
+            var changed = oldResolution
+                ? !newResolution || !comparer(oldResolution, newResolution)
+                : newResolution;
+            if (changed) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ts.hasChangesInResolutions = hasChangesInResolutions;
+    // Returns true if this node contains a parse error anywhere underneath it.
+    function containsParseError(node) {
+        aggregateChildData(node);
+        return (node.flags & 268435456 /* ThisNodeOrAnySubNodesHasError */) !== 0;
+    }
+    ts.containsParseError = containsParseError;
+    function aggregateChildData(node) {
+        if (!(node.flags & 536870912 /* HasAggregatedChildData */)) {
+            // A node is considered to contain a parse error if:
+            //  a) the parser explicitly marked that it had an error
+            //  b) any of it's children reported that it had an error.
+            var thisNodeOrAnySubNodesHasError = ((node.flags & 67108864 /* ThisNodeHasError */) !== 0) ||
+                ts.forEachChild(node, containsParseError);
+            // If so, mark ourselves accordingly.
+            if (thisNodeOrAnySubNodesHasError) {
+                node.flags |= 268435456 /* ThisNodeOrAnySubNodesHasError */;
+            }
+            // Also mark that we've propagated the child information to this node.  This way we can
+            // always consult the bit directly on this node without needing to check its children
+            // again.
+            node.flags |= 536870912 /* HasAggregatedChildData */;
+        }
+    }
+    function getSourceFileOfNode(node) {
+        while (node && node.kind !== 256 /* SourceFile */) {
+            node = node.parent;
+        }
+        return node;
+    }
+    ts.getSourceFileOfNode = getSourceFileOfNode;
+    function isStatementWithLocals(node) {
+        switch (node.kind) {
+            case 199 /* Block */:
+            case 227 /* CaseBlock */:
+            case 206 /* ForStatement */:
+            case 207 /* ForInStatement */:
+            case 208 /* ForOfStatement */:
+                return true;
+        }
+        return false;
+    }
+    ts.isStatementWithLocals = isStatementWithLocals;
+    function getStartPositionOfLine(line, sourceFile) {
+        ts.Debug.assert(line >= 0);
+        return ts.getLineStarts(sourceFile)[line];
+    }
+    ts.getStartPositionOfLine = getStartPositionOfLine;
+    // This is a useful function for debugging purposes.
+    function nodePosToString(node) {
+        var file = getSourceFileOfNode(node);
+        var loc = ts.getLineAndCharacterOfPosition(file, node.pos);
+        return file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + ")";
+    }
+    ts.nodePosToString = nodePosToString;
+    function getStartPosOfNode(node) {
+        return node.pos;
+    }
+    ts.getStartPosOfNode = getStartPosOfNode;
+    function getEndLinePosition(line, sourceFile) {
+        ts.Debug.assert(line >= 0);
+        var lineStarts = ts.getLineStarts(sourceFile);
+        var lineIndex = line;
+        var sourceText = sourceFile.text;
+        if (lineIndex + 1 === lineStarts.length) {
+            // last line - return EOF
+            return sourceText.length - 1;
+        }
+        else {
+            // current line start
+            var start = lineStarts[lineIndex];
+            // take the start position of the next line - 1 = it should be some line break
+            var pos = lineStarts[lineIndex + 1] - 1;
+            ts.Debug.assert(ts.isLineBreak(sourceText.charCodeAt(pos)));
+            // walk backwards skipping line breaks, stop the the beginning of current line.
+            // i.e:
+            // <some text>
+            // $ <- end of line for this position should match the start position
+            while (start <= pos && ts.isLineBreak(sourceText.charCodeAt(pos))) {
+                pos--;
+            }
+            return pos;
+        }
+    }
+    ts.getEndLinePosition = getEndLinePosition;
+    // Returns true if this node is missing from the actual source code. A 'missing' node is different
+    // from 'undefined/defined'. When a node is undefined (which can happen for optional nodes
+    // in the tree), it is definitely missing. However, a node may be defined, but still be
+    // missing.  This happens whenever the parser knows it needs to parse something, but can't
+    // get anything in the source code that it expects at that location. For example:
+    //
+    //          let a: ;
+    //
+    // Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source
+    // code). So the parser will attempt to parse out a type, and will create an actual node.
+    // However, this node will be 'missing' in the sense that no actual source-code/tokens are
+    // contained within it.
+    function nodeIsMissing(node) {
+        if (!node) {
+            return true;
+        }
+        return node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* EndOfFileToken */;
+    }
+    ts.nodeIsMissing = nodeIsMissing;
+    function nodeIsPresent(node) {
+        return !nodeIsMissing(node);
+    }
+    ts.nodeIsPresent = nodeIsPresent;
+    function getTokenPosOfNode(node, sourceFile, includeJsDocComment) {
+        // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*
+        // want to skip trivia because this will launch us forward to the next token.
+        if (nodeIsMissing(node)) {
+            return node.pos;
+        }
+        if (isJSDocNode(node)) {
+            return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
+        }
+        if (includeJsDocComment && node.jsDocComments && node.jsDocComments.length > 0) {
+            return getTokenPosOfNode(node.jsDocComments[0]);
+        }
+        // For a syntax list, it is possible that one of its children has JSDocComment nodes, while
+        // the syntax list itself considers them as normal trivia. Therefore if we simply skip
+        // trivia for the list, we may have skipped the JSDocComment as well. So we should process its
+        // first child to determine the actual position of its first token.
+        if (node.kind === 282 /* SyntaxList */ && node._children.length > 0) {
+            return getTokenPosOfNode(node._children[0], sourceFile, includeJsDocComment);
+        }
+        return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
+    }
+    ts.getTokenPosOfNode = getTokenPosOfNode;
+    function isJSDocNode(node) {
+        return node.kind >= 257 /* FirstJSDocNode */ && node.kind <= 281 /* LastJSDocNode */;
+    }
+    ts.isJSDocNode = isJSDocNode;
+    function getNonDecoratorTokenPosOfNode(node, sourceFile) {
+        if (nodeIsMissing(node) || !node.decorators) {
+            return getTokenPosOfNode(node, sourceFile);
+        }
+        return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end);
+    }
+    ts.getNonDecoratorTokenPosOfNode = getNonDecoratorTokenPosOfNode;
+    function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia) {
+        if (includeTrivia === void 0) { includeTrivia = false; }
+        if (nodeIsMissing(node)) {
+            return "";
+        }
+        var text = sourceFile.text;
+        return text.substring(includeTrivia ? node.pos : ts.skipTrivia(text, node.pos), node.end);
+    }
+    ts.getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile;
+    function getTextOfNodeFromSourceText(sourceText, node) {
+        if (nodeIsMissing(node)) {
+            return "";
+        }
+        return sourceText.substring(ts.skipTrivia(sourceText, node.pos), node.end);
+    }
+    ts.getTextOfNodeFromSourceText = getTextOfNodeFromSourceText;
+    function getTextOfNode(node, includeTrivia) {
+        if (includeTrivia === void 0) { includeTrivia = false; }
+        return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);
+    }
+    ts.getTextOfNode = getTextOfNode;
+    // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__'
+    function escapeIdentifier(identifier) {
+        return identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ ? "_" + identifier : identifier;
+    }
+    ts.escapeIdentifier = escapeIdentifier;
+    // Remove extra underscore from escaped identifier
+    function unescapeIdentifier(identifier) {
+        return identifier.length >= 3 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ && identifier.charCodeAt(2) === 95 /* _ */ ? identifier.substr(1) : identifier;
+    }
+    ts.unescapeIdentifier = unescapeIdentifier;
+    // Make an identifier from an external module name by extracting the string after the last "/" and replacing
+    // all non-alphanumeric characters with underscores
+    function makeIdentifierFromModuleName(moduleName) {
+        return ts.getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");
+    }
+    ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName;
+    function isBlockOrCatchScoped(declaration) {
+        return (getCombinedNodeFlags(declaration) & 3072 /* BlockScoped */) !== 0 ||
+            isCatchClauseVariableDeclaration(declaration);
+    }
+    ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
+    function isAmbientModule(node) {
+        return node && node.kind === 225 /* ModuleDeclaration */ &&
+            (node.name.kind === 9 /* StringLiteral */ || isGlobalScopeAugmentation(node));
+    }
+    ts.isAmbientModule = isAmbientModule;
+    function isShorthandAmbientModule(node) {
+        // The only kind of module that can be missing a body is a shorthand ambient module.
+        return node.kind === 225 /* ModuleDeclaration */ && (!node.body);
+    }
+    ts.isShorthandAmbientModule = isShorthandAmbientModule;
+    function isBlockScopedContainerTopLevel(node) {
+        return node.kind === 256 /* SourceFile */ ||
+            node.kind === 225 /* ModuleDeclaration */ ||
+            isFunctionLike(node) ||
+            isFunctionBlock(node);
+    }
+    ts.isBlockScopedContainerTopLevel = isBlockScopedContainerTopLevel;
+    function isGlobalScopeAugmentation(module) {
+        return !!(module.flags & 131072 /* GlobalAugmentation */);
+    }
+    ts.isGlobalScopeAugmentation = isGlobalScopeAugmentation;
+    function isExternalModuleAugmentation(node) {
+        // external module augmentation is a ambient module declaration that is either:
+        // - defined in the top level scope and source file is an external module
+        // - defined inside ambient module declaration located in the top level scope and source file not an external module
+        if (!node || !isAmbientModule(node)) {
+            return false;
+        }
+        switch (node.parent.kind) {
+            case 256 /* SourceFile */:
+                return ts.isExternalModule(node.parent);
+            case 226 /* ModuleBlock */:
+                return isAmbientModule(node.parent.parent) && !ts.isExternalModule(node.parent.parent.parent);
+        }
+        return false;
+    }
+    ts.isExternalModuleAugmentation = isExternalModuleAugmentation;
+    // Gets the nearest enclosing block scope container that has the provided node
+    // as a descendant, that is not the provided node.
+    function getEnclosingBlockScopeContainer(node) {
+        var current = node.parent;
+        while (current) {
+            if (isFunctionLike(current)) {
+                return current;
+            }
+            switch (current.kind) {
+                case 256 /* SourceFile */:
+                case 227 /* CaseBlock */:
+                case 252 /* CatchClause */:
+                case 225 /* ModuleDeclaration */:
+                case 206 /* ForStatement */:
+                case 207 /* ForInStatement */:
+                case 208 /* ForOfStatement */:
+                    return current;
+                case 199 /* Block */:
+                    // function block is not considered block-scope container
+                    // see comment in binder.ts: bind(...), case for SyntaxKind.Block
+                    if (!isFunctionLike(current.parent)) {
+                        return current;
+                    }
+            }
+            current = current.parent;
+        }
+    }
+    ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer;
+    function isCatchClauseVariableDeclaration(declaration) {
+        return declaration &&
+            declaration.kind === 218 /* VariableDeclaration */ &&
+            declaration.parent &&
+            declaration.parent.kind === 252 /* CatchClause */;
+    }
+    ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration;
+    // Return display name of an identifier
+    // Computed property names will just be emitted as "[<expr>]", where <expr> is the source
+    // text of the expression in the computed property.
+    function declarationNameToString(name) {
+        return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
+    }
+    ts.declarationNameToString = declarationNameToString;
+    function createDiagnosticForNode(node, message, arg0, arg1, arg2) {
+        var sourceFile = getSourceFileOfNode(node);
+        var span = getErrorSpanForNode(sourceFile, node);
+        return ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2);
+    }
+    ts.createDiagnosticForNode = createDiagnosticForNode;
+    function createDiagnosticForNodeFromMessageChain(node, messageChain) {
+        var sourceFile = getSourceFileOfNode(node);
+        var span = getErrorSpanForNode(sourceFile, node);
+        return {
+            file: sourceFile,
+            start: span.start,
+            length: span.length,
+            code: messageChain.code,
+            category: messageChain.category,
+            messageText: messageChain.next ? messageChain : messageChain.messageText
+        };
+    }
+    ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain;
+    function getSpanOfTokenAtPosition(sourceFile, pos) {
+        var scanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos);
+        scanner.scan();
+        var start = scanner.getTokenPos();
+        return ts.createTextSpanFromBounds(start, scanner.getTextPos());
+    }
+    ts.getSpanOfTokenAtPosition = getSpanOfTokenAtPosition;
+    function getErrorSpanForArrowFunction(sourceFile, node) {
+        var pos = ts.skipTrivia(sourceFile.text, node.pos);
+        if (node.body && node.body.kind === 199 /* Block */) {
+            var startLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.pos).line;
+            var endLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.end).line;
+            if (startLine < endLine) {
+                // The arrow function spans multiple lines,
+                // make the error span be the first line, inclusive.
+                return ts.createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1);
+            }
+        }
+        return ts.createTextSpanFromBounds(pos, node.end);
+    }
+    function getErrorSpanForNode(sourceFile, node) {
+        var errorNode = node;
+        switch (node.kind) {
+            case 256 /* SourceFile */:
+                var pos_1 = ts.skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
+                if (pos_1 === sourceFile.text.length) {
+                    // file is empty - return span for the beginning of the file
+                    return ts.createTextSpan(0, 0);
+                }
+                return getSpanOfTokenAtPosition(sourceFile, pos_1);
+            // This list is a work in progress. Add missing node kinds to improve their error
+            // spans.
+            case 218 /* VariableDeclaration */:
+            case 169 /* BindingElement */:
+            case 221 /* ClassDeclaration */:
+            case 192 /* ClassExpression */:
+            case 222 /* InterfaceDeclaration */:
+            case 225 /* ModuleDeclaration */:
+            case 224 /* EnumDeclaration */:
+            case 255 /* EnumMember */:
+            case 220 /* FunctionDeclaration */:
+            case 179 /* FunctionExpression */:
+            case 147 /* MethodDeclaration */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 223 /* TypeAliasDeclaration */:
+                errorNode = node.name;
+                break;
+            case 180 /* ArrowFunction */:
+                return getErrorSpanForArrowFunction(sourceFile, node);
+        }
+        if (errorNode === undefined) {
+            // If we don't have a better node, then just set the error on the first token of
+            // construct.
+            return getSpanOfTokenAtPosition(sourceFile, node.pos);
+        }
+        var pos = nodeIsMissing(errorNode)
+            ? errorNode.pos
+            : ts.skipTrivia(sourceFile.text, errorNode.pos);
+        return ts.createTextSpanFromBounds(pos, errorNode.end);
+    }
+    ts.getErrorSpanForNode = getErrorSpanForNode;
+    function isExternalOrCommonJsModule(file) {
+        return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined;
+    }
+    ts.isExternalOrCommonJsModule = isExternalOrCommonJsModule;
+    function isDeclarationFile(file) {
+        return file.isDeclarationFile;
+    }
+    ts.isDeclarationFile = isDeclarationFile;
+    function isConstEnumDeclaration(node) {
+        return node.kind === 224 /* EnumDeclaration */ && isConst(node);
+    }
+    ts.isConstEnumDeclaration = isConstEnumDeclaration;
+    function walkUpBindingElementsAndPatterns(node) {
+        while (node && (node.kind === 169 /* BindingElement */ || isBindingPattern(node))) {
+            node = node.parent;
+        }
+        return node;
+    }
+    // Returns the node flags for this node and all relevant parent nodes.  This is done so that
+    // nodes like variable declarations and binding elements can returned a view of their flags
+    // that includes the modifiers from their container.  i.e. flags like export/declare aren't
+    // stored on the variable declaration directly, but on the containing variable statement
+    // (if it has one).  Similarly, flags for let/const are store on the variable declaration
+    // list.  By calling this function, all those flags are combined so that the client can treat
+    // the node as if it actually had those flags.
+    function getCombinedNodeFlags(node) {
+        node = walkUpBindingElementsAndPatterns(node);
+        var flags = node.flags;
+        if (node.kind === 218 /* VariableDeclaration */) {
+            node = node.parent;
+        }
+        if (node && node.kind === 219 /* VariableDeclarationList */) {
+            flags |= node.flags;
+            node = node.parent;
+        }
+        if (node && node.kind === 200 /* VariableStatement */) {
+            flags |= node.flags;
+        }
+        return flags;
+    }
+    ts.getCombinedNodeFlags = getCombinedNodeFlags;
+    function isConst(node) {
+        return !!(getCombinedNodeFlags(node) & 2048 /* Const */);
+    }
+    ts.isConst = isConst;
+    function isLet(node) {
+        return !!(getCombinedNodeFlags(node) & 1024 /* Let */);
+    }
+    ts.isLet = isLet;
+    function isSuperCallExpression(n) {
+        return n.kind === 174 /* CallExpression */ && n.expression.kind === 95 /* SuperKeyword */;
+    }
+    ts.isSuperCallExpression = isSuperCallExpression;
+    function isPrologueDirective(node) {
+        return node.kind === 202 /* ExpressionStatement */ && node.expression.kind === 9 /* StringLiteral */;
+    }
+    ts.isPrologueDirective = isPrologueDirective;
+    function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
+        return ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos);
+    }
+    ts.getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode;
+    function getLeadingCommentRangesOfNodeFromText(node, text) {
+        return ts.getLeadingCommentRanges(text, node.pos);
+    }
+    ts.getLeadingCommentRangesOfNodeFromText = getLeadingCommentRangesOfNodeFromText;
+    function getJsDocComments(node, sourceFileOfNode) {
+        return getJsDocCommentsFromText(node, sourceFileOfNode.text);
+    }
+    ts.getJsDocComments = getJsDocComments;
+    function getJsDocCommentsFromText(node, text) {
+        var commentRanges = (node.kind === 142 /* Parameter */ ||
+            node.kind === 141 /* TypeParameter */ ||
+            node.kind === 179 /* FunctionExpression */ ||
+            node.kind === 180 /* ArrowFunction */) ?
+            ts.concatenate(ts.getTrailingCommentRanges(text, node.pos), ts.getLeadingCommentRanges(text, node.pos)) :
+            getLeadingCommentRangesOfNodeFromText(node, text);
+        return ts.filter(commentRanges, isJsDocComment);
+        function isJsDocComment(comment) {
+            // True if the comment starts with '/**' but not if it is '/**/'
+            return text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
+                text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ &&
+                text.charCodeAt(comment.pos + 3) !== 47 /* slash */;
+        }
+    }
+    ts.getJsDocCommentsFromText = getJsDocCommentsFromText;
+    ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;
+    ts.fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)('|")(.+?)\2.*?\/>/;
+    ts.fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;
+    function isTypeNode(node) {
+        if (154 /* FirstTypeNode */ <= node.kind && node.kind <= 166 /* LastTypeNode */) {
+            return true;
+        }
+        switch (node.kind) {
+            case 117 /* AnyKeyword */:
+            case 130 /* NumberKeyword */:
+            case 132 /* StringKeyword */:
+            case 120 /* BooleanKeyword */:
+            case 133 /* SymbolKeyword */:
+            case 135 /* UndefinedKeyword */:
+            case 127 /* NeverKeyword */:
+                return true;
+            case 103 /* VoidKeyword */:
+                return node.parent.kind !== 183 /* VoidExpression */;
+            case 194 /* ExpressionWithTypeArguments */:
+                return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+            // Identifiers and qualified names may be type nodes, depending on their context. Climb
+            // above them to find the lowest container
+            case 69 /* Identifier */:
+                // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
+                if (node.parent.kind === 139 /* QualifiedName */ && node.parent.right === node) {
+                    node = node.parent;
+                }
+                else if (node.parent.kind === 172 /* PropertyAccessExpression */ && node.parent.name === node) {
+                    node = node.parent;
+                }
+                // At this point, node is either a qualified name or an identifier
+                ts.Debug.assert(node.kind === 69 /* Identifier */ || node.kind === 139 /* QualifiedName */ || node.kind === 172 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'.");
+            case 139 /* QualifiedName */:
+            case 172 /* PropertyAccessExpression */:
+            case 97 /* ThisKeyword */:
+                var parent_1 = node.parent;
+                if (parent_1.kind === 158 /* TypeQuery */) {
+                    return false;
+                }
+                // Do not recursively call isTypeNode on the parent. In the example:
+                //
+                //     let a: A.B.C;
+                //
+                // Calling isTypeNode would consider the qualified name A.B a type node. Only C or
+                // A.B.C is a type node.
+                if (154 /* FirstTypeNode */ <= parent_1.kind && parent_1.kind <= 166 /* LastTypeNode */) {
+                    return true;
+                }
+                switch (parent_1.kind) {
+                    case 194 /* ExpressionWithTypeArguments */:
+                        return !isExpressionWithTypeArgumentsInClassExtendsClause(parent_1);
+                    case 141 /* TypeParameter */:
+                        return node === parent_1.constraint;
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                    case 142 /* Parameter */:
+                    case 218 /* VariableDeclaration */:
+                        return node === parent_1.type;
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 148 /* Constructor */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        return node === parent_1.type;
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 153 /* IndexSignature */:
+                        return node === parent_1.type;
+                    case 177 /* TypeAssertionExpression */:
+                        return node === parent_1.type;
+                    case 174 /* CallExpression */:
+                    case 175 /* NewExpression */:
+                        return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0;
+                    case 176 /* TaggedTemplateExpression */:
+                        // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments.
+                        return false;
+                }
+        }
+        return false;
+    }
+    ts.isTypeNode = isTypeNode;
+    // Warning: This has the same semantics as the forEach family of functions,
+    //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
+    function forEachReturnStatement(body, visitor) {
+        return traverse(body);
+        function traverse(node) {
+            switch (node.kind) {
+                case 211 /* ReturnStatement */:
+                    return visitor(node);
+                case 227 /* CaseBlock */:
+                case 199 /* Block */:
+                case 203 /* IfStatement */:
+                case 204 /* DoStatement */:
+                case 205 /* WhileStatement */:
+                case 206 /* ForStatement */:
+                case 207 /* ForInStatement */:
+                case 208 /* ForOfStatement */:
+                case 212 /* WithStatement */:
+                case 213 /* SwitchStatement */:
+                case 249 /* CaseClause */:
+                case 250 /* DefaultClause */:
+                case 214 /* LabeledStatement */:
+                case 216 /* TryStatement */:
+                case 252 /* CatchClause */:
+                    return ts.forEachChild(node, traverse);
+            }
+        }
+    }
+    ts.forEachReturnStatement = forEachReturnStatement;
+    function forEachYieldExpression(body, visitor) {
+        return traverse(body);
+        function traverse(node) {
+            switch (node.kind) {
+                case 190 /* YieldExpression */:
+                    visitor(node);
+                    var operand = node.expression;
+                    if (operand) {
+                        traverse(operand);
+                    }
+                case 224 /* EnumDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 225 /* ModuleDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                case 221 /* ClassDeclaration */:
+                case 192 /* ClassExpression */:
+                    // These are not allowed inside a generator now, but eventually they may be allowed
+                    // as local types. Regardless, any yield statements contained within them should be
+                    // skipped in this traversal.
+                    return;
+                default:
+                    if (isFunctionLike(node)) {
+                        var name_5 = node.name;
+                        if (name_5 && name_5.kind === 140 /* ComputedPropertyName */) {
+                            // Note that we will not include methods/accessors of a class because they would require
+                            // first descending into the class. This is by design.
+                            traverse(name_5.expression);
+                            return;
+                        }
+                    }
+                    else if (!isTypeNode(node)) {
+                        // This is the general case, which should include mostly expressions and statements.
+                        // Also includes NodeArrays.
+                        ts.forEachChild(node, traverse);
+                    }
+            }
+        }
+    }
+    ts.forEachYieldExpression = forEachYieldExpression;
+    function isVariableLike(node) {
+        if (node) {
+            switch (node.kind) {
+                case 169 /* BindingElement */:
+                case 255 /* EnumMember */:
+                case 142 /* Parameter */:
+                case 253 /* PropertyAssignment */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 254 /* ShorthandPropertyAssignment */:
+                case 218 /* VariableDeclaration */:
+                    return true;
+            }
+        }
+        return false;
+    }
+    ts.isVariableLike = isVariableLike;
+    function isAccessor(node) {
+        return node && (node.kind === 149 /* GetAccessor */ || node.kind === 150 /* SetAccessor */);
+    }
+    ts.isAccessor = isAccessor;
+    function isClassLike(node) {
+        return node && (node.kind === 221 /* ClassDeclaration */ || node.kind === 192 /* ClassExpression */);
+    }
+    ts.isClassLike = isClassLike;
+    function isFunctionLike(node) {
+        return node && isFunctionLikeKind(node.kind);
+    }
+    ts.isFunctionLike = isFunctionLike;
+    function isFunctionLikeKind(kind) {
+        switch (kind) {
+            case 148 /* Constructor */:
+            case 179 /* FunctionExpression */:
+            case 220 /* FunctionDeclaration */:
+            case 180 /* ArrowFunction */:
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 151 /* CallSignature */:
+            case 152 /* ConstructSignature */:
+            case 153 /* IndexSignature */:
+            case 156 /* FunctionType */:
+            case 157 /* ConstructorType */:
+                return true;
+        }
+        return false;
+    }
+    ts.isFunctionLikeKind = isFunctionLikeKind;
+    function introducesArgumentsExoticObject(node) {
+        switch (node.kind) {
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 148 /* Constructor */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 220 /* FunctionDeclaration */:
+            case 179 /* FunctionExpression */:
+                return true;
+        }
+        return false;
+    }
+    ts.introducesArgumentsExoticObject = introducesArgumentsExoticObject;
+    function isIterationStatement(node, lookInLabeledStatements) {
+        switch (node.kind) {
+            case 206 /* ForStatement */:
+            case 207 /* ForInStatement */:
+            case 208 /* ForOfStatement */:
+            case 204 /* DoStatement */:
+            case 205 /* WhileStatement */:
+                return true;
+            case 214 /* LabeledStatement */:
+                return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements);
+        }
+        return false;
+    }
+    ts.isIterationStatement = isIterationStatement;
+    function isFunctionBlock(node) {
+        return node && node.kind === 199 /* Block */ && isFunctionLike(node.parent);
+    }
+    ts.isFunctionBlock = isFunctionBlock;
+    function isObjectLiteralMethod(node) {
+        return node && node.kind === 147 /* MethodDeclaration */ && node.parent.kind === 171 /* ObjectLiteralExpression */;
+    }
+    ts.isObjectLiteralMethod = isObjectLiteralMethod;
+    function isIdentifierTypePredicate(predicate) {
+        return predicate && predicate.kind === 1 /* Identifier */;
+    }
+    ts.isIdentifierTypePredicate = isIdentifierTypePredicate;
+    function isThisTypePredicate(predicate) {
+        return predicate && predicate.kind === 0 /* This */;
+    }
+    ts.isThisTypePredicate = isThisTypePredicate;
+    function getContainingFunction(node) {
+        while (true) {
+            node = node.parent;
+            if (!node || isFunctionLike(node)) {
+                return node;
+            }
+        }
+    }
+    ts.getContainingFunction = getContainingFunction;
+    function getContainingClass(node) {
+        while (true) {
+            node = node.parent;
+            if (!node || isClassLike(node)) {
+                return node;
+            }
+        }
+    }
+    ts.getContainingClass = getContainingClass;
+    function getThisContainer(node, includeArrowFunctions) {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case 140 /* ComputedPropertyName */:
+                    // If the grandparent node is an object literal (as opposed to a class),
+                    // then the computed property is not a 'this' container.
+                    // A computed property name in a class needs to be a this container
+                    // so that we can error on it.
+                    if (isClassLike(node.parent.parent)) {
+                        return node;
+                    }
+                    // If this is a computed property, then the parent should not
+                    // make it a this container. The parent might be a property
+                    // in an object literal, like a method or accessor. But in order for
+                    // such a parent to be a this container, the reference must be in
+                    // the *body* of the container.
+                    node = node.parent;
+                    break;
+                case 143 /* Decorator */:
+                    // Decorators are always applied outside of the body of a class or method.
+                    if (node.parent.kind === 142 /* Parameter */ && isClassElement(node.parent.parent)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
+                case 180 /* ArrowFunction */:
+                    if (!includeArrowFunctions) {
+                        continue;
+                    }
+                // Fall through
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 225 /* ModuleDeclaration */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 148 /* Constructor */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                case 153 /* IndexSignature */:
+                case 224 /* EnumDeclaration */:
+                case 256 /* SourceFile */:
+                    return node;
+            }
+        }
+    }
+    ts.getThisContainer = getThisContainer;
+    /**
+      * Given an super call\property node returns a closest node where either
+      * - super call\property is legal in the node and not legal in the parent node the node.
+      *   i.e. super call is legal in constructor but not legal in the class body.
+      * - node is arrow function (so caller might need to call getSuperContainer in case it needs to climb higher)
+      * - super call\property is definitely illegal in the node (but might be legal in some subnode)
+      *   i.e. super property access is illegal in function declaration but can be legal in the statement list
+      */
+    function getSuperContainer(node, stopOnFunctions) {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return node;
+            }
+            switch (node.kind) {
+                case 140 /* ComputedPropertyName */:
+                    node = node.parent;
+                    break;
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    if (!stopOnFunctions) {
+                        continue;
+                    }
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 148 /* Constructor */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                    return node;
+                case 143 /* Decorator */:
+                    // Decorators are always applied outside of the body of a class or method.
+                    if (node.parent.kind === 142 /* Parameter */ && isClassElement(node.parent.parent)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
+            }
+        }
+    }
+    ts.getSuperContainer = getSuperContainer;
+    function getImmediatelyInvokedFunctionExpression(func) {
+        if (func.kind === 179 /* FunctionExpression */ || func.kind === 180 /* ArrowFunction */) {
+            var prev = func;
+            var parent_2 = func.parent;
+            while (parent_2.kind === 178 /* ParenthesizedExpression */) {
+                prev = parent_2;
+                parent_2 = parent_2.parent;
+            }
+            if (parent_2.kind === 174 /* CallExpression */ && parent_2.expression === prev) {
+                return parent_2;
+            }
+        }
+    }
+    ts.getImmediatelyInvokedFunctionExpression = getImmediatelyInvokedFunctionExpression;
+    /**
+     * Determines whether a node is a property or element access expression for super.
+     */
+    function isSuperPropertyOrElementAccess(node) {
+        return (node.kind === 172 /* PropertyAccessExpression */
+            || node.kind === 173 /* ElementAccessExpression */)
+            && node.expression.kind === 95 /* SuperKeyword */;
+    }
+    ts.isSuperPropertyOrElementAccess = isSuperPropertyOrElementAccess;
+    function getEntityNameFromTypeNode(node) {
+        if (node) {
+            switch (node.kind) {
+                case 155 /* TypeReference */:
+                    return node.typeName;
+                case 194 /* ExpressionWithTypeArguments */:
+                    return node.expression;
+                case 69 /* Identifier */:
+                case 139 /* QualifiedName */:
+                    return node;
+            }
+        }
+        return undefined;
+    }
+    ts.getEntityNameFromTypeNode = getEntityNameFromTypeNode;
+    function getInvokedExpression(node) {
+        if (node.kind === 176 /* TaggedTemplateExpression */) {
+            return node.tag;
+        }
+        // Will either be a CallExpression, NewExpression, or Decorator.
+        return node.expression;
+    }
+    ts.getInvokedExpression = getInvokedExpression;
+    function nodeCanBeDecorated(node) {
+        switch (node.kind) {
+            case 221 /* ClassDeclaration */:
+                // classes are valid targets
+                return true;
+            case 145 /* PropertyDeclaration */:
+                // property declarations are valid if their parent is a class declaration.
+                return node.parent.kind === 221 /* ClassDeclaration */;
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 147 /* MethodDeclaration */:
+                // if this method has a body and its parent is a class declaration, this is a valid target.
+                return node.body !== undefined
+                    && node.parent.kind === 221 /* ClassDeclaration */;
+            case 142 /* Parameter */:
+                // if the parameter's parent has a body and its grandparent is a class declaration, this is a valid target;
+                return node.parent.body !== undefined
+                    && (node.parent.kind === 148 /* Constructor */
+                        || node.parent.kind === 147 /* MethodDeclaration */
+                        || node.parent.kind === 150 /* SetAccessor */)
+                    && node.parent.parent.kind === 221 /* ClassDeclaration */;
+        }
+        return false;
+    }
+    ts.nodeCanBeDecorated = nodeCanBeDecorated;
+    function nodeIsDecorated(node) {
+        return node.decorators !== undefined
+            && nodeCanBeDecorated(node);
+    }
+    ts.nodeIsDecorated = nodeIsDecorated;
+    function isPropertyAccessExpression(node) {
+        return node.kind === 172 /* PropertyAccessExpression */;
+    }
+    ts.isPropertyAccessExpression = isPropertyAccessExpression;
+    function isElementAccessExpression(node) {
+        return node.kind === 173 /* ElementAccessExpression */;
+    }
+    ts.isElementAccessExpression = isElementAccessExpression;
+    function isJSXTagName(node) {
+        var parent = node.parent;
+        if (parent.kind === 243 /* JsxOpeningElement */ ||
+            parent.kind === 242 /* JsxSelfClosingElement */ ||
+            parent.kind === 245 /* JsxClosingElement */) {
+            return parent.tagName === node;
+        }
+        return false;
+    }
+    ts.isJSXTagName = isJSXTagName;
+    function isExpression(node) {
+        switch (node.kind) {
+            case 97 /* ThisKeyword */:
+            case 95 /* SuperKeyword */:
+            case 93 /* NullKeyword */:
+            case 99 /* TrueKeyword */:
+            case 84 /* FalseKeyword */:
+            case 10 /* RegularExpressionLiteral */:
+            case 170 /* ArrayLiteralExpression */:
+            case 171 /* ObjectLiteralExpression */:
+            case 172 /* PropertyAccessExpression */:
+            case 173 /* ElementAccessExpression */:
+            case 174 /* CallExpression */:
+            case 175 /* NewExpression */:
+            case 176 /* TaggedTemplateExpression */:
+            case 195 /* AsExpression */:
+            case 177 /* TypeAssertionExpression */:
+            case 196 /* NonNullExpression */:
+            case 178 /* ParenthesizedExpression */:
+            case 179 /* FunctionExpression */:
+            case 192 /* ClassExpression */:
+            case 180 /* ArrowFunction */:
+            case 183 /* VoidExpression */:
+            case 181 /* DeleteExpression */:
+            case 182 /* TypeOfExpression */:
+            case 185 /* PrefixUnaryExpression */:
+            case 186 /* PostfixUnaryExpression */:
+            case 187 /* BinaryExpression */:
+            case 188 /* ConditionalExpression */:
+            case 191 /* SpreadElementExpression */:
+            case 189 /* TemplateExpression */:
+            case 11 /* NoSubstitutionTemplateLiteral */:
+            case 193 /* OmittedExpression */:
+            case 241 /* JsxElement */:
+            case 242 /* JsxSelfClosingElement */:
+            case 190 /* YieldExpression */:
+            case 184 /* AwaitExpression */:
+                return true;
+            case 139 /* QualifiedName */:
+                while (node.parent.kind === 139 /* QualifiedName */) {
+                    node = node.parent;
+                }
+                return node.parent.kind === 158 /* TypeQuery */ || isJSXTagName(node);
+            case 69 /* Identifier */:
+                if (node.parent.kind === 158 /* TypeQuery */ || isJSXTagName(node)) {
+                    return true;
+                }
+            // fall through
+            case 8 /* NumericLiteral */:
+            case 9 /* StringLiteral */:
+            case 97 /* ThisKeyword */:
+                var parent_3 = node.parent;
+                switch (parent_3.kind) {
+                    case 218 /* VariableDeclaration */:
+                    case 142 /* Parameter */:
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                    case 255 /* EnumMember */:
+                    case 253 /* PropertyAssignment */:
+                    case 169 /* BindingElement */:
+                        return parent_3.initializer === node;
+                    case 202 /* ExpressionStatement */:
+                    case 203 /* IfStatement */:
+                    case 204 /* DoStatement */:
+                    case 205 /* WhileStatement */:
+                    case 211 /* ReturnStatement */:
+                    case 212 /* WithStatement */:
+                    case 213 /* SwitchStatement */:
+                    case 249 /* CaseClause */:
+                    case 215 /* ThrowStatement */:
+                    case 213 /* SwitchStatement */:
+                        return parent_3.expression === node;
+                    case 206 /* ForStatement */:
+                        var forStatement = parent_3;
+                        return (forStatement.initializer === node && forStatement.initializer.kind !== 219 /* VariableDeclarationList */) ||
+                            forStatement.condition === node ||
+                            forStatement.incrementor === node;
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                        var forInStatement = parent_3;
+                        return (forInStatement.initializer === node && forInStatement.initializer.kind !== 219 /* VariableDeclarationList */) ||
+                            forInStatement.expression === node;
+                    case 177 /* TypeAssertionExpression */:
+                    case 195 /* AsExpression */:
+                        return node === parent_3.expression;
+                    case 197 /* TemplateSpan */:
+                        return node === parent_3.expression;
+                    case 140 /* ComputedPropertyName */:
+                        return node === parent_3.expression;
+                    case 143 /* Decorator */:
+                    case 248 /* JsxExpression */:
+                    case 247 /* JsxSpreadAttribute */:
+                        return true;
+                    case 194 /* ExpressionWithTypeArguments */:
+                        return parent_3.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent_3);
+                    default:
+                        if (isExpression(parent_3)) {
+                            return true;
+                        }
+                }
+        }
+        return false;
+    }
+    ts.isExpression = isExpression;
+    function isExternalModuleNameRelative(moduleName) {
+        // TypeScript 1.0 spec (April 2014): 11.2.1
+        // An external module name is "relative" if the first term is "." or "..".
+        return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\";
+    }
+    ts.isExternalModuleNameRelative = isExternalModuleNameRelative;
+    function isInstantiatedModule(node, preserveConstEnums) {
+        var moduleState = ts.getModuleInstanceState(node);
+        return moduleState === 1 /* Instantiated */ ||
+            (preserveConstEnums && moduleState === 2 /* ConstEnumOnly */);
+    }
+    ts.isInstantiatedModule = isInstantiatedModule;
+    function isExternalModuleImportEqualsDeclaration(node) {
+        return node.kind === 229 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 240 /* ExternalModuleReference */;
+    }
+    ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration;
+    function getExternalModuleImportEqualsDeclarationExpression(node) {
+        ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node));
+        return node.moduleReference.expression;
+    }
+    ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression;
+    function isInternalModuleImportEqualsDeclaration(node) {
+        return node.kind === 229 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 240 /* ExternalModuleReference */;
+    }
+    ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration;
+    function isSourceFileJavaScript(file) {
+        return isInJavaScriptFile(file);
+    }
+    ts.isSourceFileJavaScript = isSourceFileJavaScript;
+    function isInJavaScriptFile(node) {
+        return node && !!(node.flags & 134217728 /* JavaScriptFile */);
+    }
+    ts.isInJavaScriptFile = isInJavaScriptFile;
+    /**
+     * Returns true if the node is a CallExpression to the identifier 'require' with
+     * exactly one argument.
+     * This function does not test if the node is in a JavaScript file or not.
+    */
+    function isRequireCall(expression, checkArgumentIsStringLiteral) {
+        // of the form 'require("name")'
+        var isRequire = expression.kind === 174 /* CallExpression */ &&
+            expression.expression.kind === 69 /* Identifier */ &&
+            expression.expression.text === "require" &&
+            expression.arguments.length === 1;
+        return isRequire && (!checkArgumentIsStringLiteral || expression.arguments[0].kind === 9 /* StringLiteral */);
+    }
+    ts.isRequireCall = isRequireCall;
+    function isSingleOrDoubleQuote(charCode) {
+        return charCode === 39 /* singleQuote */ || charCode === 34 /* doubleQuote */;
+    }
+    ts.isSingleOrDoubleQuote = isSingleOrDoubleQuote;
+    /**
+     * Returns true if the node is a variable declaration whose initializer is a function expression.
+     * This function does not test if the node is in a JavaScript file or not.
+     */
+    function isDeclarationOfFunctionExpression(s) {
+        if (s.valueDeclaration && s.valueDeclaration.kind === 218 /* VariableDeclaration */) {
+            var declaration = s.valueDeclaration;
+            return declaration.initializer && declaration.initializer.kind === 179 /* FunctionExpression */;
+        }
+        return false;
+    }
+    ts.isDeclarationOfFunctionExpression = isDeclarationOfFunctionExpression;
+    /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property
+    /// assignments we treat as special in the binder
+    function getSpecialPropertyAssignmentKind(expression) {
+        if (!isInJavaScriptFile(expression)) {
+            return 0 /* None */;
+        }
+        if (expression.kind !== 187 /* BinaryExpression */) {
+            return 0 /* None */;
+        }
+        var expr = expression;
+        if (expr.operatorToken.kind !== 56 /* EqualsToken */ || expr.left.kind !== 172 /* PropertyAccessExpression */) {
+            return 0 /* None */;
+        }
+        var lhs = expr.left;
+        if (lhs.expression.kind === 69 /* Identifier */) {
+            var lhsId = lhs.expression;
+            if (lhsId.text === "exports") {
+                // exports.name = expr
+                return 1 /* ExportsProperty */;
+            }
+            else if (lhsId.text === "module" && lhs.name.text === "exports") {
+                // module.exports = expr
+                return 2 /* ModuleExports */;
+            }
+        }
+        else if (lhs.expression.kind === 97 /* ThisKeyword */) {
+            return 4 /* ThisProperty */;
+        }
+        else if (lhs.expression.kind === 172 /* PropertyAccessExpression */) {
+            // chained dot, e.g. x.y.z = expr; this var is the 'x.y' part
+            var innerPropertyAccess = lhs.expression;
+            if (innerPropertyAccess.expression.kind === 69 /* Identifier */) {
+                // module.exports.name = expr
+                var innerPropertyAccessIdentifier = innerPropertyAccess.expression;
+                if (innerPropertyAccessIdentifier.text === "module" && innerPropertyAccess.name.text === "exports") {
+                    return 1 /* ExportsProperty */;
+                }
+                if (innerPropertyAccess.name.text === "prototype") {
+                    return 3 /* PrototypeProperty */;
+                }
+            }
+        }
+        return 0 /* None */;
+    }
+    ts.getSpecialPropertyAssignmentKind = getSpecialPropertyAssignmentKind;
+    function getExternalModuleName(node) {
+        if (node.kind === 230 /* ImportDeclaration */) {
+            return node.moduleSpecifier;
+        }
+        if (node.kind === 229 /* ImportEqualsDeclaration */) {
+            var reference = node.moduleReference;
+            if (reference.kind === 240 /* ExternalModuleReference */) {
+                return reference.expression;
+            }
+        }
+        if (node.kind === 236 /* ExportDeclaration */) {
+            return node.moduleSpecifier;
+        }
+        if (node.kind === 225 /* ModuleDeclaration */ && node.name.kind === 9 /* StringLiteral */) {
+            return node.name;
+        }
+    }
+    ts.getExternalModuleName = getExternalModuleName;
+    function hasQuestionToken(node) {
+        if (node) {
+            switch (node.kind) {
+                case 142 /* Parameter */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 254 /* ShorthandPropertyAssignment */:
+                case 253 /* PropertyAssignment */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    return node.questionToken !== undefined;
+            }
+        }
+        return false;
+    }
+    ts.hasQuestionToken = hasQuestionToken;
+    function isJSDocConstructSignature(node) {
+        return node.kind === 269 /* JSDocFunctionType */ &&
+            node.parameters.length > 0 &&
+            node.parameters[0].type.kind === 271 /* JSDocConstructorType */;
+    }
+    ts.isJSDocConstructSignature = isJSDocConstructSignature;
+    function getJSDocTag(node, kind, checkParentVariableStatement) {
+        if (!node) {
+            return undefined;
+        }
+        var jsDocComments = getJSDocComments(node, checkParentVariableStatement);
+        if (!jsDocComments) {
+            return undefined;
+        }
+        for (var _i = 0, jsDocComments_1 = jsDocComments; _i < jsDocComments_1.length; _i++) {
+            var jsDocComment = jsDocComments_1[_i];
+            for (var _a = 0, _b = jsDocComment.tags; _a < _b.length; _a++) {
+                var tag = _b[_a];
+                if (tag.kind === kind) {
+                    return tag;
+                }
+            }
+        }
+    }
+    function getJSDocComments(node, checkParentVariableStatement) {
+        if (node.jsDocComments) {
+            return node.jsDocComments;
+        }
+        // Try to recognize this pattern when node is initializer of variable declaration and JSDoc comments are on containing variable statement.
+        // /**
+        //   * @param {number} name
+        //   * @returns {number}
+        //   */
+        // var x = function(name) { return name.length; }
+        if (checkParentVariableStatement) {
+            var isInitializerOfVariableDeclarationInStatement = node.parent.kind === 218 /* VariableDeclaration */ &&
+                node.parent.initializer === node &&
+                node.parent.parent.parent.kind === 200 /* VariableStatement */;
+            var variableStatementNode = isInitializerOfVariableDeclarationInStatement ? node.parent.parent.parent : undefined;
+            if (variableStatementNode) {
+                return variableStatementNode.jsDocComments;
+            }
+            // Also recognize when the node is the RHS of an assignment expression
+            var parent_4 = node.parent;
+            var isSourceOfAssignmentExpressionStatement = parent_4 && parent_4.parent &&
+                parent_4.kind === 187 /* BinaryExpression */ &&
+                parent_4.operatorToken.kind === 56 /* EqualsToken */ &&
+                parent_4.parent.kind === 202 /* ExpressionStatement */;
+            if (isSourceOfAssignmentExpressionStatement) {
+                return parent_4.parent.jsDocComments;
+            }
+            var isPropertyAssignmentExpression = parent_4 && parent_4.kind === 253 /* PropertyAssignment */;
+            if (isPropertyAssignmentExpression) {
+                return parent_4.jsDocComments;
+            }
+        }
+        return undefined;
+    }
+    function getJSDocTypeTag(node) {
+        return getJSDocTag(node, 277 /* JSDocTypeTag */, /*checkParentVariableStatement*/ false);
+    }
+    ts.getJSDocTypeTag = getJSDocTypeTag;
+    function getJSDocReturnTag(node) {
+        return getJSDocTag(node, 276 /* JSDocReturnTag */, /*checkParentVariableStatement*/ true);
+    }
+    ts.getJSDocReturnTag = getJSDocReturnTag;
+    function getJSDocTemplateTag(node) {
+        return getJSDocTag(node, 278 /* JSDocTemplateTag */, /*checkParentVariableStatement*/ false);
+    }
+    ts.getJSDocTemplateTag = getJSDocTemplateTag;
+    function getCorrespondingJSDocParameterTag(parameter) {
+        if (parameter.name && parameter.name.kind === 69 /* Identifier */) {
+            // If it's a parameter, see if the parent has a jsdoc comment with an @param
+            // annotation.
+            var parameterName = parameter.name.text;
+            var jsDocComments = getJSDocComments(parameter.parent, /*checkParentVariableStatement*/ true);
+            if (jsDocComments) {
+                for (var _i = 0, jsDocComments_2 = jsDocComments; _i < jsDocComments_2.length; _i++) {
+                    var jsDocComment = jsDocComments_2[_i];
+                    for (var _a = 0, _b = jsDocComment.tags; _a < _b.length; _a++) {
+                        var tag = _b[_a];
+                        if (tag.kind === 275 /* JSDocParameterTag */) {
+                            var parameterTag = tag;
+                            var name_6 = parameterTag.preParameterName || parameterTag.postParameterName;
+                            if (name_6.text === parameterName) {
+                                return parameterTag;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    ts.getCorrespondingJSDocParameterTag = getCorrespondingJSDocParameterTag;
+    function hasRestParameter(s) {
+        return isRestParameter(ts.lastOrUndefined(s.parameters));
+    }
+    ts.hasRestParameter = hasRestParameter;
+    function hasDeclaredRestParameter(s) {
+        return isDeclaredRestParam(ts.lastOrUndefined(s.parameters));
+    }
+    ts.hasDeclaredRestParameter = hasDeclaredRestParameter;
+    function isRestParameter(node) {
+        if (node && (node.flags & 134217728 /* JavaScriptFile */)) {
+            if (node.type && node.type.kind === 270 /* JSDocVariadicType */) {
+                return true;
+            }
+            var paramTag = getCorrespondingJSDocParameterTag(node);
+            if (paramTag && paramTag.typeExpression) {
+                return paramTag.typeExpression.type.kind === 270 /* JSDocVariadicType */;
+            }
+        }
+        return isDeclaredRestParam(node);
+    }
+    ts.isRestParameter = isRestParameter;
+    function isDeclaredRestParam(node) {
+        return node && node.dotDotDotToken !== undefined;
+    }
+    ts.isDeclaredRestParam = isDeclaredRestParam;
+    function isLiteralKind(kind) {
+        return 8 /* FirstLiteralToken */ <= kind && kind <= 11 /* LastLiteralToken */;
+    }
+    ts.isLiteralKind = isLiteralKind;
+    function isTextualLiteralKind(kind) {
+        return kind === 9 /* StringLiteral */ || kind === 11 /* NoSubstitutionTemplateLiteral */;
+    }
+    ts.isTextualLiteralKind = isTextualLiteralKind;
+    function isTemplateLiteralKind(kind) {
+        return 11 /* FirstTemplateToken */ <= kind && kind <= 14 /* LastTemplateToken */;
+    }
+    ts.isTemplateLiteralKind = isTemplateLiteralKind;
+    function isBindingPattern(node) {
+        return !!node && (node.kind === 168 /* ArrayBindingPattern */ || node.kind === 167 /* ObjectBindingPattern */);
+    }
+    ts.isBindingPattern = isBindingPattern;
+    // A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property
+    // assignment in an object literal that is an assignment target, or if it is parented by an array literal that is
+    // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'.
+    function isAssignmentTarget(node) {
+        while (node.parent.kind === 178 /* ParenthesizedExpression */) {
+            node = node.parent;
+        }
+        while (true) {
+            var parent_5 = node.parent;
+            if (parent_5.kind === 170 /* ArrayLiteralExpression */ || parent_5.kind === 191 /* SpreadElementExpression */) {
+                node = parent_5;
+                continue;
+            }
+            if (parent_5.kind === 253 /* PropertyAssignment */ || parent_5.kind === 254 /* ShorthandPropertyAssignment */) {
+                node = parent_5.parent;
+                continue;
+            }
+            return parent_5.kind === 187 /* BinaryExpression */ &&
+                parent_5.operatorToken.kind === 56 /* EqualsToken */ &&
+                parent_5.left === node ||
+                (parent_5.kind === 207 /* ForInStatement */ || parent_5.kind === 208 /* ForOfStatement */) &&
+                    parent_5.initializer === node;
+        }
+    }
+    ts.isAssignmentTarget = isAssignmentTarget;
+    function isNodeDescendentOf(node, ancestor) {
+        while (node) {
+            if (node === ancestor)
+                return true;
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isNodeDescendentOf = isNodeDescendentOf;
+    function isInAmbientContext(node) {
+        while (node) {
+            if (node.flags & 2 /* Ambient */ || (node.kind === 256 /* SourceFile */ && node.isDeclarationFile)) {
+                return true;
+            }
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isInAmbientContext = isInAmbientContext;
+    function isDeclaration(node) {
+        switch (node.kind) {
+            case 180 /* ArrowFunction */:
+            case 169 /* BindingElement */:
+            case 221 /* ClassDeclaration */:
+            case 192 /* ClassExpression */:
+            case 148 /* Constructor */:
+            case 224 /* EnumDeclaration */:
+            case 255 /* EnumMember */:
+            case 238 /* ExportSpecifier */:
+            case 220 /* FunctionDeclaration */:
+            case 179 /* FunctionExpression */:
+            case 149 /* GetAccessor */:
+            case 231 /* ImportClause */:
+            case 229 /* ImportEqualsDeclaration */:
+            case 234 /* ImportSpecifier */:
+            case 222 /* InterfaceDeclaration */:
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 225 /* ModuleDeclaration */:
+            case 232 /* NamespaceImport */:
+            case 142 /* Parameter */:
+            case 253 /* PropertyAssignment */:
+            case 145 /* PropertyDeclaration */:
+            case 144 /* PropertySignature */:
+            case 150 /* SetAccessor */:
+            case 254 /* ShorthandPropertyAssignment */:
+            case 223 /* TypeAliasDeclaration */:
+            case 141 /* TypeParameter */:
+            case 218 /* VariableDeclaration */:
+            case 279 /* JSDocTypedefTag */:
+                return true;
+        }
+        return false;
+    }
+    ts.isDeclaration = isDeclaration;
+    function isStatement(n) {
+        switch (n.kind) {
+            case 210 /* BreakStatement */:
+            case 209 /* ContinueStatement */:
+            case 217 /* DebuggerStatement */:
+            case 204 /* DoStatement */:
+            case 202 /* ExpressionStatement */:
+            case 201 /* EmptyStatement */:
+            case 207 /* ForInStatement */:
+            case 208 /* ForOfStatement */:
+            case 206 /* ForStatement */:
+            case 203 /* IfStatement */:
+            case 214 /* LabeledStatement */:
+            case 211 /* ReturnStatement */:
+            case 213 /* SwitchStatement */:
+            case 215 /* ThrowStatement */:
+            case 216 /* TryStatement */:
+            case 200 /* VariableStatement */:
+            case 205 /* WhileStatement */:
+            case 212 /* WithStatement */:
+            case 235 /* ExportAssignment */:
+                return true;
+            default:
+                return false;
+        }
+    }
+    ts.isStatement = isStatement;
+    function isClassElement(n) {
+        switch (n.kind) {
+            case 148 /* Constructor */:
+            case 145 /* PropertyDeclaration */:
+            case 147 /* MethodDeclaration */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 146 /* MethodSignature */:
+            case 153 /* IndexSignature */:
+                return true;
+            default:
+                return false;
+        }
+    }
+    ts.isClassElement = isClassElement;
+    // True if the given identifier, string literal, or number literal is the name of a declaration node
+    function isDeclarationName(name) {
+        if (name.kind !== 69 /* Identifier */ && name.kind !== 9 /* StringLiteral */ && name.kind !== 8 /* NumericLiteral */) {
+            return false;
+        }
+        var parent = name.parent;
+        if (parent.kind === 234 /* ImportSpecifier */ || parent.kind === 238 /* ExportSpecifier */) {
+            if (parent.propertyName) {
+                return true;
+            }
+        }
+        if (isDeclaration(parent)) {
+            return parent.name === name;
+        }
+        return false;
+    }
+    ts.isDeclarationName = isDeclarationName;
+    function isLiteralComputedPropertyDeclarationName(node) {
+        return (node.kind === 9 /* StringLiteral */ || node.kind === 8 /* NumericLiteral */) &&
+            node.parent.kind === 140 /* ComputedPropertyName */ &&
+            isDeclaration(node.parent.parent);
+    }
+    ts.isLiteralComputedPropertyDeclarationName = isLiteralComputedPropertyDeclarationName;
+    // Return true if the given identifier is classified as an IdentifierName
+    function isIdentifierName(node) {
+        var parent = node.parent;
+        switch (parent.kind) {
+            case 145 /* PropertyDeclaration */:
+            case 144 /* PropertySignature */:
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 255 /* EnumMember */:
+            case 253 /* PropertyAssignment */:
+            case 172 /* PropertyAccessExpression */:
+                // Name in member declaration or property name in property access
+                return parent.name === node;
+            case 139 /* QualifiedName */:
+                // Name on right hand side of dot in a type query
+                if (parent.right === node) {
+                    while (parent.kind === 139 /* QualifiedName */) {
+                        parent = parent.parent;
+                    }
+                    return parent.kind === 158 /* TypeQuery */;
+                }
+                return false;
+            case 169 /* BindingElement */:
+            case 234 /* ImportSpecifier */:
+                // Property name in binding element or import specifier
+                return parent.propertyName === node;
+            case 238 /* ExportSpecifier */:
+                // Any name in an export specifier
+                return true;
+        }
+        return false;
+    }
+    ts.isIdentifierName = isIdentifierName;
+    // An alias symbol is created by one of the following declarations:
+    // import <symbol> = ...
+    // import <symbol> from ...
+    // import * as <symbol> from ...
+    // import { x as <symbol> } from ...
+    // export { x as <symbol> } from ...
+    // export = ...
+    // export default ...
+    function isAliasSymbolDeclaration(node) {
+        return node.kind === 229 /* ImportEqualsDeclaration */ ||
+            node.kind === 228 /* NamespaceExportDeclaration */ ||
+            node.kind === 231 /* ImportClause */ && !!node.name ||
+            node.kind === 232 /* NamespaceImport */ ||
+            node.kind === 234 /* ImportSpecifier */ ||
+            node.kind === 238 /* ExportSpecifier */ ||
+            node.kind === 235 /* ExportAssignment */ && node.expression.kind === 69 /* Identifier */;
+    }
+    ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
+    function getClassExtendsHeritageClauseElement(node) {
+        var heritageClause = getHeritageClause(node.heritageClauses, 83 /* ExtendsKeyword */);
+        return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
+    }
+    ts.getClassExtendsHeritageClauseElement = getClassExtendsHeritageClauseElement;
+    function getClassImplementsHeritageClauseElements(node) {
+        var heritageClause = getHeritageClause(node.heritageClauses, 106 /* ImplementsKeyword */);
+        return heritageClause ? heritageClause.types : undefined;
+    }
+    ts.getClassImplementsHeritageClauseElements = getClassImplementsHeritageClauseElements;
+    function getInterfaceBaseTypeNodes(node) {
+        var heritageClause = getHeritageClause(node.heritageClauses, 83 /* ExtendsKeyword */);
+        return heritageClause ? heritageClause.types : undefined;
+    }
+    ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
+    function getHeritageClause(clauses, kind) {
+        if (clauses) {
+            for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) {
+                var clause = clauses_1[_i];
+                if (clause.token === kind) {
+                    return clause;
+                }
+            }
+        }
+        return undefined;
+    }
+    ts.getHeritageClause = getHeritageClause;
+    function tryResolveScriptReference(host, sourceFile, reference) {
+        if (!host.getCompilerOptions().noResolve) {
+            var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName);
+            return host.getSourceFile(referenceFileName);
+        }
+    }
+    ts.tryResolveScriptReference = tryResolveScriptReference;
+    function getAncestor(node, kind) {
+        while (node) {
+            if (node.kind === kind) {
+                return node;
+            }
+            node = node.parent;
+        }
+        return undefined;
+    }
+    ts.getAncestor = getAncestor;
+    function getFileReferenceFromReferencePath(comment, commentRange) {
+        var simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
+        var isNoDefaultLibRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/gim;
+        if (simpleReferenceRegEx.test(comment)) {
+            if (isNoDefaultLibRegEx.test(comment)) {
+                return {
+                    isNoDefaultLib: true
+                };
+            }
+            else {
+                var refMatchResult = ts.fullTripleSlashReferencePathRegEx.exec(comment);
+                var refLibResult = !refMatchResult && ts.fullTripleSlashReferenceTypeReferenceDirectiveRegEx.exec(comment);
+                if (refMatchResult || refLibResult) {
+                    var start = commentRange.pos;
+                    var end = commentRange.end;
+                    return {
+                        fileReference: {
+                            pos: start,
+                            end: end,
+                            fileName: (refMatchResult || refLibResult)[3]
+                        },
+                        isNoDefaultLib: false,
+                        isTypeReferenceDirective: !!refLibResult
+                    };
+                }
+                return {
+                    diagnosticMessage: ts.Diagnostics.Invalid_reference_directive_syntax,
+                    isNoDefaultLib: false
+                };
+            }
+        }
+        return undefined;
+    }
+    ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath;
+    function isKeyword(token) {
+        return 70 /* FirstKeyword */ <= token && token <= 138 /* LastKeyword */;
+    }
+    ts.isKeyword = isKeyword;
+    function isTrivia(token) {
+        return 2 /* FirstTriviaToken */ <= token && token <= 7 /* LastTriviaToken */;
+    }
+    ts.isTrivia = isTrivia;
+    function isAsyncFunctionLike(node) {
+        return isFunctionLike(node) && (node.flags & 256 /* Async */) !== 0 && !isAccessor(node);
+    }
+    ts.isAsyncFunctionLike = isAsyncFunctionLike;
+    function isStringOrNumericLiteral(kind) {
+        return kind === 9 /* StringLiteral */ || kind === 8 /* NumericLiteral */;
+    }
+    ts.isStringOrNumericLiteral = isStringOrNumericLiteral;
+    /**
+     * A declaration has a dynamic name if both of the following are true:
+     *   1. The declaration has a computed property name
+     *   2. The computed name is *not* expressed as Symbol.<name>, where name
+     *      is a property of the Symbol constructor that denotes a built in
+     *      Symbol.
+     */
+    function hasDynamicName(declaration) {
+        return declaration.name && isDynamicName(declaration.name);
+    }
+    ts.hasDynamicName = hasDynamicName;
+    function isDynamicName(name) {
+        return name.kind === 140 /* ComputedPropertyName */ &&
+            !isStringOrNumericLiteral(name.expression.kind) &&
+            !isWellKnownSymbolSyntactically(name.expression);
+    }
+    ts.isDynamicName = isDynamicName;
+    /**
+     * Checks if the expression is of the form:
+     *    Symbol.name
+     * where Symbol is literally the word "Symbol", and name is any identifierName
+     */
+    function isWellKnownSymbolSyntactically(node) {
+        return isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression);
+    }
+    ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically;
+    function getPropertyNameForPropertyNameNode(name) {
+        if (name.kind === 69 /* Identifier */ || name.kind === 9 /* StringLiteral */ || name.kind === 8 /* NumericLiteral */ || name.kind === 142 /* Parameter */) {
+            return name.text;
+        }
+        if (name.kind === 140 /* ComputedPropertyName */) {
+            var nameExpression = name.expression;
+            if (isWellKnownSymbolSyntactically(nameExpression)) {
+                var rightHandSideName = nameExpression.name.text;
+                return getPropertyNameForKnownSymbolName(rightHandSideName);
+            }
+            else if (nameExpression.kind === 9 /* StringLiteral */ || nameExpression.kind === 8 /* NumericLiteral */) {
+                return nameExpression.text;
+            }
+        }
+        return undefined;
+    }
+    ts.getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode;
+    function getPropertyNameForKnownSymbolName(symbolName) {
+        return "__@" + symbolName;
+    }
+    ts.getPropertyNameForKnownSymbolName = getPropertyNameForKnownSymbolName;
+    /**
+     * Includes the word "Symbol" with unicode escapes
+     */
+    function isESSymbolIdentifier(node) {
+        return node.kind === 69 /* Identifier */ && node.text === "Symbol";
+    }
+    ts.isESSymbolIdentifier = isESSymbolIdentifier;
+    function isModifierKind(token) {
+        switch (token) {
+            case 115 /* AbstractKeyword */:
+            case 118 /* AsyncKeyword */:
+            case 74 /* ConstKeyword */:
+            case 122 /* DeclareKeyword */:
+            case 77 /* DefaultKeyword */:
+            case 82 /* ExportKeyword */:
+            case 112 /* PublicKeyword */:
+            case 110 /* PrivateKeyword */:
+            case 111 /* ProtectedKeyword */:
+            case 128 /* ReadonlyKeyword */:
+            case 113 /* StaticKeyword */:
+                return true;
+        }
+        return false;
+    }
+    ts.isModifierKind = isModifierKind;
+    function isParameterDeclaration(node) {
+        var root = getRootDeclaration(node);
+        return root.kind === 142 /* Parameter */;
+    }
+    ts.isParameterDeclaration = isParameterDeclaration;
+    function getRootDeclaration(node) {
+        while (node.kind === 169 /* BindingElement */) {
+            node = node.parent.parent;
+        }
+        return node;
+    }
+    ts.getRootDeclaration = getRootDeclaration;
+    function nodeStartsNewLexicalEnvironment(n) {
+        return isFunctionLike(n) || n.kind === 225 /* ModuleDeclaration */ || n.kind === 256 /* SourceFile */;
+    }
+    ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment;
+    /**
+     * Creates a shallow, memberwise clone of a node. The "kind", "pos", "end", "flags", and "parent"
+     * properties are excluded by default, and can be provided via the "location", "flags", and
+     * "parent" parameters.
+     * @param node The node to clone.
+     * @param location An optional TextRange to use to supply the new position.
+     * @param flags The NodeFlags to use for the cloned node.
+     * @param parent The parent for the new node.
+     */
+    function cloneNode(node, location, flags, parent) {
+        // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
+        // the original node. We also need to exclude specific properties and only include own-
+        // properties (to skip members already defined on the shared prototype).
+        var clone = location !== undefined
+            ? ts.createNode(node.kind, location.pos, location.end)
+            : createSynthesizedNode(node.kind);
+        for (var key in node) {
+            if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
+                continue;
+            }
+            clone[key] = node[key];
+        }
+        if (flags !== undefined) {
+            clone.flags = flags;
+        }
+        if (parent !== undefined) {
+            clone.parent = parent;
+        }
+        return clone;
+    }
+    ts.cloneNode = cloneNode;
+    /**
+     * Creates a deep clone of an EntityName, with new parent pointers.
+     * @param node The EntityName to clone.
+     * @param parent The parent for the cloned node.
+     */
+    function cloneEntityName(node, parent) {
+        var clone = cloneNode(node, node, node.flags, parent);
+        if (isQualifiedName(clone)) {
+            var left = clone.left, right = clone.right;
+            clone.left = cloneEntityName(left, clone);
+            clone.right = cloneNode(right, right, right.flags, parent);
+        }
+        return clone;
+    }
+    ts.cloneEntityName = cloneEntityName;
+    function isQualifiedName(node) {
+        return node.kind === 139 /* QualifiedName */;
+    }
+    ts.isQualifiedName = isQualifiedName;
+    function nodeIsSynthesized(node) {
+        return node.pos === -1;
+    }
+    ts.nodeIsSynthesized = nodeIsSynthesized;
+    function createSynthesizedNode(kind, startsOnNewLine) {
+        var node = ts.createNode(kind, /* pos */ -1, /* end */ -1);
+        node.startsOnNewLine = startsOnNewLine;
+        return node;
+    }
+    ts.createSynthesizedNode = createSynthesizedNode;
+    function createSynthesizedNodeArray() {
+        var array = [];
+        array.pos = -1;
+        array.end = -1;
+        return array;
+    }
+    ts.createSynthesizedNodeArray = createSynthesizedNodeArray;
+    function createDiagnosticCollection() {
+        var nonFileDiagnostics = [];
+        var fileDiagnostics = {};
+        var diagnosticsModified = false;
+        var modificationCount = 0;
+        return {
+            add: add,
+            getGlobalDiagnostics: getGlobalDiagnostics,
+            getDiagnostics: getDiagnostics,
+            getModificationCount: getModificationCount,
+            reattachFileDiagnostics: reattachFileDiagnostics
+        };
+        function getModificationCount() {
+            return modificationCount;
+        }
+        function reattachFileDiagnostics(newFile) {
+            if (!ts.hasProperty(fileDiagnostics, newFile.fileName)) {
+                return;
+            }
+            for (var _i = 0, _a = fileDiagnostics[newFile.fileName]; _i < _a.length; _i++) {
+                var diagnostic = _a[_i];
+                diagnostic.file = newFile;
+            }
+        }
+        function add(diagnostic) {
+            var diagnostics;
+            if (diagnostic.file) {
+                diagnostics = fileDiagnostics[diagnostic.file.fileName];
+                if (!diagnostics) {
+                    diagnostics = [];
+                    fileDiagnostics[diagnostic.file.fileName] = diagnostics;
+                }
+            }
+            else {
+                diagnostics = nonFileDiagnostics;
+            }
+            diagnostics.push(diagnostic);
+            diagnosticsModified = true;
+            modificationCount++;
+        }
+        function getGlobalDiagnostics() {
+            sortAndDeduplicate();
+            return nonFileDiagnostics;
+        }
+        function getDiagnostics(fileName) {
+            sortAndDeduplicate();
+            if (fileName) {
+                return fileDiagnostics[fileName] || [];
+            }
+            var allDiagnostics = [];
+            function pushDiagnostic(d) {
+                allDiagnostics.push(d);
+            }
+            ts.forEach(nonFileDiagnostics, pushDiagnostic);
+            for (var key in fileDiagnostics) {
+                if (ts.hasProperty(fileDiagnostics, key)) {
+                    ts.forEach(fileDiagnostics[key], pushDiagnostic);
+                }
+            }
+            return ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+        }
+        function sortAndDeduplicate() {
+            if (!diagnosticsModified) {
+                return;
+            }
+            diagnosticsModified = false;
+            nonFileDiagnostics = ts.sortAndDeduplicateDiagnostics(nonFileDiagnostics);
+            for (var key in fileDiagnostics) {
+                if (ts.hasProperty(fileDiagnostics, key)) {
+                    fileDiagnostics[key] = ts.sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
+                }
+            }
+        }
+    }
+    ts.createDiagnosticCollection = createDiagnosticCollection;
+    // This consists of the first 19 unprintable ASCII characters, canonical escapes, lineSeparator,
+    // paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in
+    // the language service. These characters should be escaped when printing, and if any characters are added,
+    // the map below must be updated. Note that this regexp *does not* include the 'delete' character.
+    // There is no reason for this other than that JSON.stringify does not handle it either.
+    var escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+    var escapedCharsMap = {
+        "\0": "\\0",
+        "\t": "\\t",
+        "\v": "\\v",
+        "\f": "\\f",
+        "\b": "\\b",
+        "\r": "\\r",
+        "\n": "\\n",
+        "\\": "\\\\",
+        "\"": "\\\"",
+        "\u2028": "\\u2028",
+        "\u2029": "\\u2029",
+        "\u0085": "\\u0085" // nextLine
+    };
+    /**
+     * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2),
+     * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine)
+     * Note that this doesn't actually wrap the input in double quotes.
+     */
+    function escapeString(s) {
+        s = escapedCharsRegExp.test(s) ? s.replace(escapedCharsRegExp, getReplacement) : s;
+        return s;
+        function getReplacement(c) {
+            return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
+        }
+    }
+    ts.escapeString = escapeString;
+    function isIntrinsicJsxName(name) {
+        var ch = name.substr(0, 1);
+        return ch.toLowerCase() === ch;
+    }
+    ts.isIntrinsicJsxName = isIntrinsicJsxName;
+    function get16BitUnicodeEscapeSequence(charCode) {
+        var hexCharCode = charCode.toString(16).toUpperCase();
+        var paddedHexCode = ("0000" + hexCharCode).slice(-4);
+        return "\\u" + paddedHexCode;
+    }
+    var nonAsciiCharacters = /[^\u0000-\u007F]/g;
+    function escapeNonAsciiCharacters(s) {
+        // Replace non-ASCII characters with '\uNNNN' escapes if any exist.
+        // Otherwise just return the original string.
+        return nonAsciiCharacters.test(s) ?
+            s.replace(nonAsciiCharacters, function (c) { return get16BitUnicodeEscapeSequence(c.charCodeAt(0)); }) :
+            s;
+    }
+    ts.escapeNonAsciiCharacters = escapeNonAsciiCharacters;
+    var indentStrings = ["", "    "];
+    function getIndentString(level) {
+        if (indentStrings[level] === undefined) {
+            indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
+        }
+        return indentStrings[level];
+    }
+    ts.getIndentString = getIndentString;
+    function getIndentSize() {
+        return indentStrings[1].length;
+    }
+    ts.getIndentSize = getIndentSize;
+    function createTextWriter(newLine) {
+        var output;
+        var indent;
+        var lineStart;
+        var lineCount;
+        var linePos;
+        function write(s) {
+            if (s && s.length) {
+                if (lineStart) {
+                    output += getIndentString(indent);
+                    lineStart = false;
+                }
+                output += s;
+            }
+        }
+        function reset() {
+            output = "";
+            indent = 0;
+            lineStart = true;
+            lineCount = 0;
+            linePos = 0;
+        }
+        function rawWrite(s) {
+            if (s !== undefined) {
+                if (lineStart) {
+                    lineStart = false;
+                }
+                output += s;
+            }
+        }
+        function writeLiteral(s) {
+            if (s && s.length) {
+                write(s);
+                var lineStartsOfS = ts.computeLineStarts(s);
+                if (lineStartsOfS.length > 1) {
+                    lineCount = lineCount + lineStartsOfS.length - 1;
+                    linePos = output.length - s.length + ts.lastOrUndefined(lineStartsOfS);
+                }
+            }
+        }
+        function writeLine() {
+            if (!lineStart) {
+                output += newLine;
+                lineCount++;
+                linePos = output.length;
+                lineStart = true;
+            }
+        }
+        function writeTextOfNode(text, node) {
+            write(getTextOfNodeFromSourceText(text, node));
+        }
+        reset();
+        return {
+            write: write,
+            rawWrite: rawWrite,
+            writeTextOfNode: writeTextOfNode,
+            writeLiteral: writeLiteral,
+            writeLine: writeLine,
+            increaseIndent: function () { indent++; },
+            decreaseIndent: function () { indent--; },
+            getIndent: function () { return indent; },
+            getTextPos: function () { return output.length; },
+            getLine: function () { return lineCount + 1; },
+            getColumn: function () { return lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1; },
+            getText: function () { return output; },
+            reset: reset
+        };
+    }
+    ts.createTextWriter = createTextWriter;
+    /**
+     * Resolves a local path to a path which is absolute to the base of the emit
+     */
+    function getExternalModuleNameFromPath(host, fileName) {
+        var getCanonicalFileName = function (f) { return host.getCanonicalFileName(f); };
+        var dir = ts.toPath(host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName);
+        var filePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
+        var relativePath = ts.getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
+        return ts.removeFileExtension(relativePath);
+    }
+    ts.getExternalModuleNameFromPath = getExternalModuleNameFromPath;
+    function getOwnEmitOutputFilePath(sourceFile, host, extension) {
+        var compilerOptions = host.getCompilerOptions();
+        var emitOutputFilePathWithoutExtension;
+        if (compilerOptions.outDir) {
+            emitOutputFilePathWithoutExtension = ts.removeFileExtension(getSourceFilePathInNewDir(sourceFile, host, compilerOptions.outDir));
+        }
+        else {
+            emitOutputFilePathWithoutExtension = ts.removeFileExtension(sourceFile.fileName);
+        }
+        return emitOutputFilePathWithoutExtension + extension;
+    }
+    ts.getOwnEmitOutputFilePath = getOwnEmitOutputFilePath;
+    function getDeclarationEmitOutputFilePath(sourceFile, host) {
+        var options = host.getCompilerOptions();
+        var outputDir = options.declarationDir || options.outDir; // Prefer declaration folder if specified
+        if (options.declaration) {
+            var path = outputDir
+                ? getSourceFilePathInNewDir(sourceFile, host, outputDir)
+                : sourceFile.fileName;
+            return ts.removeFileExtension(path) + ".d.ts";
+        }
+    }
+    ts.getDeclarationEmitOutputFilePath = getDeclarationEmitOutputFilePath;
+    function getEmitScriptTarget(compilerOptions) {
+        return compilerOptions.target || 0 /* ES3 */;
+    }
+    ts.getEmitScriptTarget = getEmitScriptTarget;
+    function getEmitModuleKind(compilerOptions) {
+        return typeof compilerOptions.module === "number" ?
+            compilerOptions.module :
+            getEmitScriptTarget(compilerOptions) === 2 /* ES6 */ ? ts.ModuleKind.ES6 : ts.ModuleKind.CommonJS;
+    }
+    ts.getEmitModuleKind = getEmitModuleKind;
+    function forEachExpectedEmitFile(host, action, targetSourceFile) {
+        var options = host.getCompilerOptions();
+        // Emit on each source file
+        if (options.outFile || options.out) {
+            onBundledEmit(host);
+        }
+        else {
+            var sourceFiles = targetSourceFile === undefined ? host.getSourceFiles() : [targetSourceFile];
+            for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
+                var sourceFile = sourceFiles_1[_i];
+                // Don't emit if source file is a declaration file, or was located under node_modules
+                if (!isDeclarationFile(sourceFile) && !host.isSourceFileFromExternalLibrary(sourceFile)) {
+                    onSingleFileEmit(host, sourceFile);
+                }
+            }
+        }
+        function onSingleFileEmit(host, sourceFile) {
+            // JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.
+            // So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.
+            // For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve
+            var extension = ".js";
+            if (options.jsx === 1 /* Preserve */) {
+                if (isSourceFileJavaScript(sourceFile)) {
+                    if (ts.fileExtensionIs(sourceFile.fileName, ".jsx")) {
+                        extension = ".jsx";
+                    }
+                }
+                else if (sourceFile.languageVariant === 1 /* JSX */) {
+                    // TypeScript source file preserving JSX syntax
+                    extension = ".jsx";
+                }
+            }
+            var jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, extension);
+            var emitFileNames = {
+                jsFilePath: jsFilePath,
+                sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
+                declarationFilePath: !isSourceFileJavaScript(sourceFile) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined
+            };
+            action(emitFileNames, [sourceFile], /*isBundledEmit*/ false);
+        }
+        function onBundledEmit(host) {
+            // Can emit only sources that are not declaration file and are either non module code or module with
+            // --module or --target es6 specified. Files included by searching under node_modules are also not emitted.
+            var bundledSources = ts.filter(host.getSourceFiles(), function (sourceFile) { return !isDeclarationFile(sourceFile) &&
+                !host.isSourceFileFromExternalLibrary(sourceFile) &&
+                (!ts.isExternalModule(sourceFile) ||
+                    !!getEmitModuleKind(options)); });
+            if (bundledSources.length) {
+                var jsFilePath = options.outFile || options.out;
+                var emitFileNames = {
+                    jsFilePath: jsFilePath,
+                    sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
+                    declarationFilePath: options.declaration ? ts.removeFileExtension(jsFilePath) + ".d.ts" : undefined
+                };
+                action(emitFileNames, bundledSources, /*isBundledEmit*/ true);
+            }
+        }
+        function getSourceMapFilePath(jsFilePath, options) {
+            return options.sourceMap ? jsFilePath + ".map" : undefined;
+        }
+    }
+    ts.forEachExpectedEmitFile = forEachExpectedEmitFile;
+    function getSourceFilePathInNewDir(sourceFile, host, newDirPath) {
+        var sourceFilePath = ts.getNormalizedAbsolutePath(sourceFile.fileName, host.getCurrentDirectory());
+        var commonSourceDirectory = host.getCommonSourceDirectory();
+        var isSourceFileInCommonSourceDirectory = host.getCanonicalFileName(sourceFilePath).indexOf(host.getCanonicalFileName(commonSourceDirectory)) === 0;
+        sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath;
+        return ts.combinePaths(newDirPath, sourceFilePath);
+    }
+    ts.getSourceFilePathInNewDir = getSourceFilePathInNewDir;
+    function writeFile(host, diagnostics, fileName, data, writeByteOrderMark, sourceFiles) {
+        host.writeFile(fileName, data, writeByteOrderMark, function (hostErrorMessage) {
+            diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
+        }, sourceFiles);
+    }
+    ts.writeFile = writeFile;
+    function getLineOfLocalPosition(currentSourceFile, pos) {
+        return ts.getLineAndCharacterOfPosition(currentSourceFile, pos).line;
+    }
+    ts.getLineOfLocalPosition = getLineOfLocalPosition;
+    function getLineOfLocalPositionFromLineMap(lineMap, pos) {
+        return ts.computeLineAndCharacterOfPosition(lineMap, pos).line;
+    }
+    ts.getLineOfLocalPositionFromLineMap = getLineOfLocalPositionFromLineMap;
+    function getFirstConstructorWithBody(node) {
+        return ts.forEach(node.members, function (member) {
+            if (member.kind === 148 /* Constructor */ && nodeIsPresent(member.body)) {
+                return member;
+            }
+        });
+    }
+    ts.getFirstConstructorWithBody = getFirstConstructorWithBody;
+    function getSetAccessorTypeAnnotationNode(accessor) {
+        if (accessor && accessor.parameters.length > 0) {
+            var hasThis = accessor.parameters.length === 2 &&
+                accessor.parameters[0].name.kind === 69 /* Identifier */ &&
+                accessor.parameters[0].name.originalKeywordKind === 97 /* ThisKeyword */;
+            return accessor.parameters[hasThis ? 1 : 0].type;
+        }
+    }
+    ts.getSetAccessorTypeAnnotationNode = getSetAccessorTypeAnnotationNode;
+    function getAllAccessorDeclarations(declarations, accessor) {
+        var firstAccessor;
+        var secondAccessor;
+        var getAccessor;
+        var setAccessor;
+        if (hasDynamicName(accessor)) {
+            firstAccessor = accessor;
+            if (accessor.kind === 149 /* GetAccessor */) {
+                getAccessor = accessor;
+            }
+            else if (accessor.kind === 150 /* SetAccessor */) {
+                setAccessor = accessor;
+            }
+            else {
+                ts.Debug.fail("Accessor has wrong kind");
+            }
+        }
+        else {
+            ts.forEach(declarations, function (member) {
+                if ((member.kind === 149 /* GetAccessor */ || member.kind === 150 /* SetAccessor */)
+                    && (member.flags & 32 /* Static */) === (accessor.flags & 32 /* Static */)) {
+                    var memberName = getPropertyNameForPropertyNameNode(member.name);
+                    var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
+                    if (memberName === accessorName) {
+                        if (!firstAccessor) {
+                            firstAccessor = member;
+                        }
+                        else if (!secondAccessor) {
+                            secondAccessor = member;
+                        }
+                        if (member.kind === 149 /* GetAccessor */ && !getAccessor) {
+                            getAccessor = member;
+                        }
+                        if (member.kind === 150 /* SetAccessor */ && !setAccessor) {
+                            setAccessor = member;
+                        }
+                    }
+                }
+            });
+        }
+        return {
+            firstAccessor: firstAccessor,
+            secondAccessor: secondAccessor,
+            getAccessor: getAccessor,
+            setAccessor: setAccessor
+        };
+    }
+    ts.getAllAccessorDeclarations = getAllAccessorDeclarations;
+    function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) {
+        // If the leading comments start on different line than the start of node, write new line
+        if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos &&
+            getLineOfLocalPositionFromLineMap(lineMap, node.pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) {
+            writer.writeLine();
+        }
+    }
+    ts.emitNewLineBeforeLeadingComments = emitNewLineBeforeLeadingComments;
+    function emitComments(text, lineMap, writer, comments, trailingSeparator, newLine, writeComment) {
+        var emitLeadingSpace = !trailingSeparator;
+        ts.forEach(comments, function (comment) {
+            if (emitLeadingSpace) {
+                writer.write(" ");
+                emitLeadingSpace = false;
+            }
+            writeComment(text, lineMap, writer, comment, newLine);
+            if (comment.hasTrailingNewLine) {
+                writer.writeLine();
+            }
+            else if (trailingSeparator) {
+                writer.write(" ");
+            }
+            else {
+                // Emit leading space to separate comment during next comment emit
+                emitLeadingSpace = true;
+            }
+        });
+    }
+    ts.emitComments = emitComments;
+    /**
+     * Detached comment is a comment at the top of file or function body that is separated from
+     * the next statement by space.
+     */
+    function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) {
+        var leadingComments;
+        var currentDetachedCommentInfo;
+        if (removeComments) {
+            // removeComments is true, only reserve pinned comment at the top of file
+            // For example:
+            //      /*! Pinned Comment */
+            //
+            //      var x = 10;
+            if (node.pos === 0) {
+                leadingComments = ts.filter(ts.getLeadingCommentRanges(text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            // removeComments is false, just get detached as normal and bypass the process to filter comment
+            leadingComments = ts.getLeadingCommentRanges(text, node.pos);
+        }
+        if (leadingComments) {
+            var detachedComments = [];
+            var lastComment = void 0;
+            for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
+                var comment = leadingComments_1[_i];
+                if (lastComment) {
+                    var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end);
+                    var commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos);
+                    if (commentLine >= lastCommentLine + 2) {
+                        // There was a blank line between the last comment and this comment.  This
+                        // comment is not part of the copyright comments.  Return what we have so
+                        // far.
+                        break;
+                    }
+                }
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+            if (detachedComments.length) {
+                // All comments look like they could have been part of the copyright header.  Make
+                // sure there is at least one blank line between it and the node.  If not, it's not
+                // a copyright header.
+                var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, ts.lastOrUndefined(detachedComments).end);
+                var nodeLine = getLineOfLocalPositionFromLineMap(lineMap, ts.skipTrivia(text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    // Valid detachedComments
+                    emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments);
+                    emitComments(text, lineMap, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+        return currentDetachedCommentInfo;
+        function isPinnedComment(comment) {
+            return text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
+                text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
+        }
+    }
+    ts.emitDetachedComments = emitDetachedComments;
+    function writeCommentRange(text, lineMap, writer, comment, newLine) {
+        if (text.charCodeAt(comment.pos + 1) === 42 /* asterisk */) {
+            var firstCommentLineAndCharacter = ts.computeLineAndCharacterOfPosition(lineMap, comment.pos);
+            var lineCount = lineMap.length;
+            var firstCommentLineIndent = void 0;
+            for (var pos = comment.pos, currentLine = firstCommentLineAndCharacter.line; pos < comment.end; currentLine++) {
+                var nextLineStart = (currentLine + 1) === lineCount
+                    ? text.length + 1
+                    : lineMap[currentLine + 1];
+                if (pos !== comment.pos) {
+                    // If we are not emitting first line, we need to write the spaces to adjust the alignment
+                    if (firstCommentLineIndent === undefined) {
+                        firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], comment.pos);
+                    }
+                    // These are number of spaces writer is going to write at current indent
+                    var currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
+                    // Number of spaces we want to be writing
+                    // eg: Assume writer indent
+                    // module m {
+                    //         /* starts at character 9 this is line 1
+                    //    * starts at character pos 4 line                        --1  = 8 - 8 + 3
+                    //   More left indented comment */                            --2  = 8 - 8 + 2
+                    //     class c { }
+                    // }
+                    // module m {
+                    //     /* this is line 1 -- Assume current writer indent 8
+                    //      * line                                                --3 = 8 - 4 + 5
+                    //            More right indented comment */                  --4 = 8 - 4 + 11
+                    //     class c { }
+                    // }
+                    var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart);
+                    if (spacesToEmit > 0) {
+                        var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();
+                        var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
+                        // Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces
+                        writer.rawWrite(indentSizeSpaceString);
+                        // Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces)
+                        while (numberOfSingleSpacesToEmit) {
+                            writer.rawWrite(" ");
+                            numberOfSingleSpacesToEmit--;
+                        }
+                    }
+                    else {
+                        // No spaces to emit write empty string
+                        writer.rawWrite("");
+                    }
+                }
+                // Write the comment line text
+                writeTrimmedCurrentLine(text, comment, writer, newLine, pos, nextLineStart);
+                pos = nextLineStart;
+            }
+        }
+        else {
+            // Single line comment of style //....
+            writer.write(text.substring(comment.pos, comment.end));
+        }
+    }
+    ts.writeCommentRange = writeCommentRange;
+    function writeTrimmedCurrentLine(text, comment, writer, newLine, pos, nextLineStart) {
+        var end = Math.min(comment.end, nextLineStart - 1);
+        var currentLineText = text.substring(pos, end).replace(/^\s+|\s+$/g, "");
+        if (currentLineText) {
+            // trimmed forward and ending spaces text
+            writer.write(currentLineText);
+            if (end !== comment.end) {
+                writer.writeLine();
+            }
+        }
+        else {
+            // Empty string - make sure we write empty line
+            writer.writeLiteral(newLine);
+        }
+    }
+    function calculateIndent(text, pos, end) {
+        var currentLineIndent = 0;
+        for (; pos < end && ts.isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) {
+            if (text.charCodeAt(pos) === 9 /* tab */) {
+                // Tabs = TabSize = indent size and go to next tabStop
+                currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize());
+            }
+            else {
+                // Single space
+                currentLineIndent++;
+            }
+        }
+        return currentLineIndent;
+    }
+    function modifierToFlag(token) {
+        switch (token) {
+            case 113 /* StaticKeyword */: return 32 /* Static */;
+            case 112 /* PublicKeyword */: return 4 /* Public */;
+            case 111 /* ProtectedKeyword */: return 16 /* Protected */;
+            case 110 /* PrivateKeyword */: return 8 /* Private */;
+            case 115 /* AbstractKeyword */: return 128 /* Abstract */;
+            case 82 /* ExportKeyword */: return 1 /* Export */;
+            case 122 /* DeclareKeyword */: return 2 /* Ambient */;
+            case 74 /* ConstKeyword */: return 2048 /* Const */;
+            case 77 /* DefaultKeyword */: return 512 /* Default */;
+            case 118 /* AsyncKeyword */: return 256 /* Async */;
+            case 128 /* ReadonlyKeyword */: return 64 /* Readonly */;
+        }
+        return 0;
+    }
+    ts.modifierToFlag = modifierToFlag;
+    function isLeftHandSideExpression(expr) {
+        if (expr) {
+            switch (expr.kind) {
+                case 172 /* PropertyAccessExpression */:
+                case 173 /* ElementAccessExpression */:
+                case 175 /* NewExpression */:
+                case 174 /* CallExpression */:
+                case 196 /* NonNullExpression */:
+                case 241 /* JsxElement */:
+                case 242 /* JsxSelfClosingElement */:
+                case 176 /* TaggedTemplateExpression */:
+                case 170 /* ArrayLiteralExpression */:
+                case 178 /* ParenthesizedExpression */:
+                case 171 /* ObjectLiteralExpression */:
+                case 192 /* ClassExpression */:
+                case 179 /* FunctionExpression */:
+                case 69 /* Identifier */:
+                case 10 /* RegularExpressionLiteral */:
+                case 8 /* NumericLiteral */:
+                case 9 /* StringLiteral */:
+                case 11 /* NoSubstitutionTemplateLiteral */:
+                case 189 /* TemplateExpression */:
+                case 84 /* FalseKeyword */:
+                case 93 /* NullKeyword */:
+                case 97 /* ThisKeyword */:
+                case 99 /* TrueKeyword */:
+                case 95 /* SuperKeyword */:
+                    return true;
+            }
+        }
+        return false;
+    }
+    ts.isLeftHandSideExpression = isLeftHandSideExpression;
+    function isAssignmentOperator(token) {
+        return token >= 56 /* FirstAssignment */ && token <= 68 /* LastAssignment */;
+    }
+    ts.isAssignmentOperator = isAssignmentOperator;
+    function isExpressionWithTypeArgumentsInClassExtendsClause(node) {
+        return node.kind === 194 /* ExpressionWithTypeArguments */ &&
+            node.parent.token === 83 /* ExtendsKeyword */ &&
+            isClassLike(node.parent.parent);
+    }
+    ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause;
+    // Returns false if this heritage clause element's expression contains something unsupported
+    // (i.e. not a name or dotted name).
+    function isSupportedExpressionWithTypeArguments(node) {
+        return isSupportedExpressionWithTypeArgumentsRest(node.expression);
+    }
+    ts.isSupportedExpressionWithTypeArguments = isSupportedExpressionWithTypeArguments;
+    function isSupportedExpressionWithTypeArgumentsRest(node) {
+        if (node.kind === 69 /* Identifier */) {
+            return true;
+        }
+        else if (isPropertyAccessExpression(node)) {
+            return isSupportedExpressionWithTypeArgumentsRest(node.expression);
+        }
+        else {
+            return false;
+        }
+    }
+    function isRightSideOfQualifiedNameOrPropertyAccess(node) {
+        return (node.parent.kind === 139 /* QualifiedName */ && node.parent.right === node) ||
+            (node.parent.kind === 172 /* PropertyAccessExpression */ && node.parent.name === node);
+    }
+    ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess;
+    function isEmptyObjectLiteralOrArrayLiteral(expression) {
+        var kind = expression.kind;
+        if (kind === 171 /* ObjectLiteralExpression */) {
+            return expression.properties.length === 0;
+        }
+        if (kind === 170 /* ArrayLiteralExpression */) {
+            return expression.elements.length === 0;
+        }
+        return false;
+    }
+    ts.isEmptyObjectLiteralOrArrayLiteral = isEmptyObjectLiteralOrArrayLiteral;
+    function getLocalSymbolForExportDefault(symbol) {
+        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 512 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined;
+    }
+    ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
+    function hasJavaScriptFileExtension(fileName) {
+        return ts.forEach(ts.supportedJavascriptExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); });
+    }
+    ts.hasJavaScriptFileExtension = hasJavaScriptFileExtension;
+    function hasTypeScriptFileExtension(fileName) {
+        return ts.forEach(ts.supportedTypeScriptExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); });
+    }
+    ts.hasTypeScriptFileExtension = hasTypeScriptFileExtension;
+    /**
+     * Replace each instance of non-ascii characters by one, two, three, or four escape sequences
+     * representing the UTF-8 encoding of the character, and return the expanded char code list.
+     */
+    function getExpandedCharCodes(input) {
+        var output = [];
+        var length = input.length;
+        for (var i = 0; i < length; i++) {
+            var charCode = input.charCodeAt(i);
+            // handel utf8
+            if (charCode < 0x80) {
+                output.push(charCode);
+            }
+            else if (charCode < 0x800) {
+                output.push((charCode >> 6) | 192);
+                output.push((charCode & 63) | 128);
+            }
+            else if (charCode < 0x10000) {
+                output.push((charCode >> 12) | 224);
+                output.push(((charCode >> 6) & 63) | 128);
+                output.push((charCode & 63) | 128);
+            }
+            else if (charCode < 0x20000) {
+                output.push((charCode >> 18) | 240);
+                output.push(((charCode >> 12) & 63) | 128);
+                output.push(((charCode >> 6) & 63) | 128);
+                output.push((charCode & 63) | 128);
+            }
+            else {
+                ts.Debug.assert(false, "Unexpected code point");
+            }
+        }
+        return output;
+    }
+    /**
+     * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph
+     * as the fallback implementation does not check for circular references by default.
+     */
+    ts.stringify = typeof JSON !== "undefined" && JSON.stringify
+        ? JSON.stringify
+        : stringifyFallback;
+    /**
+     * Serialize an object graph into a JSON string.
+     */
+    function stringifyFallback(value) {
+        // JSON.stringify returns `undefined` here, instead of the string "undefined".
+        return value === undefined ? undefined : stringifyValue(value);
+    }
+    function stringifyValue(value) {
+        return typeof value === "string" ? "\"" + escapeString(value) + "\""
+            : typeof value === "number" ? isFinite(value) ? String(value) : "null"
+                : typeof value === "boolean" ? value ? "true" : "false"
+                    : typeof value === "object" && value ? ts.isArray(value) ? cycleCheck(stringifyArray, value) : cycleCheck(stringifyObject, value)
+                        : "null";
+    }
+    function cycleCheck(cb, value) {
+        ts.Debug.assert(!value.hasOwnProperty("__cycle"), "Converting circular structure to JSON");
+        value.__cycle = true;
+        var result = cb(value);
+        delete value.__cycle;
+        return result;
+    }
+    function stringifyArray(value) {
+        return "[" + ts.reduceLeft(value, stringifyElement, "") + "]";
+    }
+    function stringifyElement(memo, value) {
+        return (memo ? memo + "," : memo) + stringifyValue(value);
+    }
+    function stringifyObject(value) {
+        return "{" + ts.reduceProperties(value, stringifyProperty, "") + "}";
+    }
+    function stringifyProperty(memo, value, key) {
+        return value === undefined || typeof value === "function" || key === "__cycle" ? memo
+            : (memo ? memo + "," : memo) + ("\"" + escapeString(key) + "\":" + stringifyValue(value));
+    }
+    var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    /**
+     * Converts a string to a base-64 encoded ASCII string.
+     */
+    function convertToBase64(input) {
+        var result = "";
+        var charCodes = getExpandedCharCodes(input);
+        var i = 0;
+        var length = charCodes.length;
+        var byte1, byte2, byte3, byte4;
+        while (i < length) {
+            // Convert every 6-bits in the input 3 character points
+            // into a base64 digit
+            byte1 = charCodes[i] >> 2;
+            byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4;
+            byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6;
+            byte4 = charCodes[i + 2] & 63;
+            // We are out of characters in the input, set the extra
+            // digits to 64 (padding character).
+            if (i + 1 >= length) {
+                byte3 = byte4 = 64;
+            }
+            else if (i + 2 >= length) {
+                byte4 = 64;
+            }
+            // Write to the output
+            result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4);
+            i += 3;
+        }
+        return result;
+    }
+    ts.convertToBase64 = convertToBase64;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !ts.isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : ts.getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, /* isAbsolutePathAnUrl */ false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
+    var carriageReturnLineFeed = "\r\n";
+    var lineFeed = "\n";
+    function getNewLineCharacter(options) {
+        if (options.newLine === 0 /* CarriageReturnLineFeed */) {
+            return carriageReturnLineFeed;
+        }
+        else if (options.newLine === 1 /* LineFeed */) {
+            return lineFeed;
+        }
+        else if (ts.sys) {
+            return ts.sys.newLine;
+        }
+        return carriageReturnLineFeed;
+    }
+    ts.getNewLineCharacter = getNewLineCharacter;
+    function isWatchSet(options) {
+        // Firefox has Object.prototype.watch
+        return options.watch && options.hasOwnProperty("watch");
+    }
+    ts.isWatchSet = isWatchSet;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+    function getDefaultLibFileName(options) {
+        return options.target === 2 /* ES6 */ ? "lib.es6.d.ts" : "lib.d.ts";
+    }
+    ts.getDefaultLibFileName = getDefaultLibFileName;
+    function textSpanEnd(span) {
+        return span.start + span.length;
+    }
+    ts.textSpanEnd = textSpanEnd;
+    function textSpanIsEmpty(span) {
+        return span.length === 0;
+    }
+    ts.textSpanIsEmpty = textSpanIsEmpty;
+    function textSpanContainsPosition(span, position) {
+        return position >= span.start && position < textSpanEnd(span);
+    }
+    ts.textSpanContainsPosition = textSpanContainsPosition;
+    // Returns true if 'span' contains 'other'.
+    function textSpanContainsTextSpan(span, other) {
+        return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span);
+    }
+    ts.textSpanContainsTextSpan = textSpanContainsTextSpan;
+    function textSpanOverlapsWith(span, other) {
+        var overlapStart = Math.max(span.start, other.start);
+        var overlapEnd = Math.min(textSpanEnd(span), textSpanEnd(other));
+        return overlapStart < overlapEnd;
+    }
+    ts.textSpanOverlapsWith = textSpanOverlapsWith;
+    function textSpanOverlap(span1, span2) {
+        var overlapStart = Math.max(span1.start, span2.start);
+        var overlapEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
+        if (overlapStart < overlapEnd) {
+            return createTextSpanFromBounds(overlapStart, overlapEnd);
+        }
+        return undefined;
+    }
+    ts.textSpanOverlap = textSpanOverlap;
+    function textSpanIntersectsWithTextSpan(span, other) {
+        return other.start <= textSpanEnd(span) && textSpanEnd(other) >= span.start;
+    }
+    ts.textSpanIntersectsWithTextSpan = textSpanIntersectsWithTextSpan;
+    function textSpanIntersectsWith(span, start, length) {
+        var end = start + length;
+        return start <= textSpanEnd(span) && end >= span.start;
+    }
+    ts.textSpanIntersectsWith = textSpanIntersectsWith;
+    function decodedTextSpanIntersectsWith(start1, length1, start2, length2) {
+        var end1 = start1 + length1;
+        var end2 = start2 + length2;
+        return start2 <= end1 && end2 >= start1;
+    }
+    ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith;
+    function textSpanIntersectsWithPosition(span, position) {
+        return position <= textSpanEnd(span) && position >= span.start;
+    }
+    ts.textSpanIntersectsWithPosition = textSpanIntersectsWithPosition;
+    function textSpanIntersection(span1, span2) {
+        var intersectStart = Math.max(span1.start, span2.start);
+        var intersectEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
+        if (intersectStart <= intersectEnd) {
+            return createTextSpanFromBounds(intersectStart, intersectEnd);
+        }
+        return undefined;
+    }
+    ts.textSpanIntersection = textSpanIntersection;
+    function createTextSpan(start, length) {
+        if (start < 0) {
+            throw new Error("start < 0");
+        }
+        if (length < 0) {
+            throw new Error("length < 0");
+        }
+        return { start: start, length: length };
+    }
+    ts.createTextSpan = createTextSpan;
+    function createTextSpanFromBounds(start, end) {
+        return createTextSpan(start, end - start);
+    }
+    ts.createTextSpanFromBounds = createTextSpanFromBounds;
+    function textChangeRangeNewSpan(range) {
+        return createTextSpan(range.span.start, range.newLength);
+    }
+    ts.textChangeRangeNewSpan = textChangeRangeNewSpan;
+    function textChangeRangeIsUnchanged(range) {
+        return textSpanIsEmpty(range.span) && range.newLength === 0;
+    }
+    ts.textChangeRangeIsUnchanged = textChangeRangeIsUnchanged;
+    function createTextChangeRange(span, newLength) {
+        if (newLength < 0) {
+            throw new Error("newLength < 0");
+        }
+        return { span: span, newLength: newLength };
+    }
+    ts.createTextChangeRange = createTextChangeRange;
+    ts.unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
+    /**
+     * Called to merge all the changes that occurred across several versions of a script snapshot
+     * into a single change.  i.e. if a user keeps making successive edits to a script we will
+     * have a text change from V1 to V2, V2 to V3, ..., Vn.
+     *
+     * This function will then merge those changes into a single change range valid between V1 and
+     * Vn.
+     */
+    function collapseTextChangeRangesAcrossMultipleVersions(changes) {
+        if (changes.length === 0) {
+            return ts.unchangedTextChangeRange;
+        }
+        if (changes.length === 1) {
+            return changes[0];
+        }
+        // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }
+        // as it makes things much easier to reason about.
+        var change0 = changes[0];
+        var oldStartN = change0.span.start;
+        var oldEndN = textSpanEnd(change0.span);
+        var newEndN = oldStartN + change0.newLength;
+        for (var i = 1; i < changes.length; i++) {
+            var nextChange = changes[i];
+            // Consider the following case:
+            // i.e. two edits.  The first represents the text change range { { 10, 50 }, 30 }.  i.e. The span starting
+            // at 10, with length 50 is reduced to length 30.  The second represents the text change range { { 30, 30 }, 40 }.
+            // i.e. the span starting at 30 with length 30 is increased to length 40.
+            //
+            //      0         10        20        30        40        50        60        70        80        90        100
+            //      -------------------------------------------------------------------------------------------------------
+            //                |                                                 /
+            //                |                                            /----
+            //  T1            |                                       /----
+            //                |                                  /----
+            //                |                             /----
+            //      -------------------------------------------------------------------------------------------------------
+            //                                     |                            \
+            //                                     |                               \
+            //   T2                                |                                 \
+            //                                     |                                   \
+            //                                     |                                      \
+            //      -------------------------------------------------------------------------------------------------------
+            //
+            // Merging these turns out to not be too difficult.  First, determining the new start of the change is trivial
+            // it's just the min of the old and new starts.  i.e.:
+            //
+            //      0         10        20        30        40        50        60        70        80        90        100
+            //      ------------------------------------------------------------*------------------------------------------
+            //                |                                                 /
+            //                |                                            /----
+            //  T1            |                                       /----
+            //                |                                  /----
+            //                |                             /----
+            //      ----------------------------------------$-------------------$------------------------------------------
+            //                .                    |                            \
+            //                .                    |                               \
+            //   T2           .                    |                                 \
+            //                .                    |                                   \
+            //                .                    |                                      \
+            //      ----------------------------------------------------------------------*--------------------------------
+            //
+            // (Note the dots represent the newly inferred start.
+            // Determining the new and old end is also pretty simple.  Basically it boils down to paying attention to the
+            // absolute positions at the asterisks, and the relative change between the dollar signs. Basically, we see
+            // which if the two $'s precedes the other, and we move that one forward until they line up.  in this case that
+            // means:
+            //
+            //      0         10        20        30        40        50        60        70        80        90        100
+            //      --------------------------------------------------------------------------------*----------------------
+            //                |                                                                     /
+            //                |                                                                /----
+            //  T1            |                                                           /----
+            //                |                                                      /----
+            //                |                                                 /----
+            //      ------------------------------------------------------------$------------------------------------------
+            //                .                    |                            \
+            //                .                    |                               \
+            //   T2           .                    |                                 \
+            //                .                    |                                   \
+            //                .                    |                                      \
+            //      ----------------------------------------------------------------------*--------------------------------
+            //
+            // In other words (in this case), we're recognizing that the second edit happened after where the first edit
+            // ended with a delta of 20 characters (60 - 40).  Thus, if we go back in time to where the first edit started
+            // that's the same as if we started at char 80 instead of 60.
+            //
+            // As it so happens, the same logic applies if the second edit precedes the first edit.  In that case rather
+            // than pushing the first edit forward to match the second, we'll push the second edit forward to match the
+            // first.
+            //
+            // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange
+            // semantics: { { start: 10, length: 70 }, newLength: 60 }
+            //
+            // The math then works out as follows.
+            // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the
+            // final result like so:
+            //
+            // {
+            //      oldStart3: Min(oldStart1, oldStart2),
+            //      oldEnd3  : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)),
+            //      newEnd3  : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))
+            // }
+            var oldStart1 = oldStartN;
+            var oldEnd1 = oldEndN;
+            var newEnd1 = newEndN;
+            var oldStart2 = nextChange.span.start;
+            var oldEnd2 = textSpanEnd(nextChange.span);
+            var newEnd2 = oldStart2 + nextChange.newLength;
+            oldStartN = Math.min(oldStart1, oldStart2);
+            oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
+            newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
+        }
+        return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength:*/ newEndN - oldStartN);
+    }
+    ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions;
+    function getTypeParameterOwner(d) {
+        if (d && d.kind === 141 /* TypeParameter */) {
+            for (var current = d; current; current = current.parent) {
+                if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 222 /* InterfaceDeclaration */) {
+                    return current;
+                }
+            }
+        }
+    }
+    ts.getTypeParameterOwner = getTypeParameterOwner;
+    function isParameterPropertyDeclaration(node) {
+        return node.flags & 92 /* ParameterPropertyModifier */ && node.parent.kind === 148 /* Constructor */ && ts.isClassLike(node.parent.parent);
+    }
+    ts.isParameterPropertyDeclaration = isParameterPropertyDeclaration;
+    function startsWith(str, prefix) {
+        return str.lastIndexOf(prefix, 0) === 0;
+    }
+    ts.startsWith = startsWith;
+    function endsWith(str, suffix) {
+        var expectedPos = str.length - suffix.length;
+        return str.indexOf(suffix, expectedPos) === expectedPos;
+    }
+    ts.endsWith = endsWith;
+})(ts || (ts = {}));
+/// <reference path="utilities.ts"/>
+/// <reference path="scanner.ts"/>
+var ts;
+(function (ts) {
+    /* @internal */ ts.parseTime = 0;
+    var NodeConstructor;
+    var SourceFileConstructor;
+    function createNode(kind, pos, end) {
+        if (kind === 256 /* SourceFile */) {
+            return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, pos, end);
+        }
+        else {
+            return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, pos, end);
+        }
+    }
+    ts.createNode = createNode;
+    function visitNode(cbNode, node) {
+        if (node) {
+            return cbNode(node);
+        }
+    }
+    function visitNodeArray(cbNodes, nodes) {
+        if (nodes) {
+            return cbNodes(nodes);
+        }
+    }
+    function visitEachNode(cbNode, nodes) {
+        if (nodes) {
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
+                var result = cbNode(node);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+    }
+    // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
+    // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
+    // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
+    // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
+    function forEachChild(node, cbNode, cbNodeArray) {
+        if (!node) {
+            return;
+        }
+        // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray
+        // callback parameters, but that causes a closure allocation for each invocation with noticeable effects
+        // on performance.
+        var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode;
+        var cbNodes = cbNodeArray || cbNode;
+        switch (node.kind) {
+            case 139 /* QualifiedName */:
+                return visitNode(cbNode, node.left) ||
+                    visitNode(cbNode, node.right);
+            case 141 /* TypeParameter */:
+                return visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.constraint) ||
+                    visitNode(cbNode, node.expression);
+            case 254 /* ShorthandPropertyAssignment */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.questionToken) ||
+                    visitNode(cbNode, node.equalsToken) ||
+                    visitNode(cbNode, node.objectAssignmentInitializer);
+            case 142 /* Parameter */:
+            case 145 /* PropertyDeclaration */:
+            case 144 /* PropertySignature */:
+            case 253 /* PropertyAssignment */:
+            case 218 /* VariableDeclaration */:
+            case 169 /* BindingElement */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.propertyName) ||
+                    visitNode(cbNode, node.dotDotDotToken) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.questionToken) ||
+                    visitNode(cbNode, node.type) ||
+                    visitNode(cbNode, node.initializer);
+            case 156 /* FunctionType */:
+            case 157 /* ConstructorType */:
+            case 151 /* CallSignature */:
+            case 152 /* ConstructSignature */:
+            case 153 /* IndexSignature */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNodes(cbNodes, node.typeParameters) ||
+                    visitNodes(cbNodes, node.parameters) ||
+                    visitNode(cbNode, node.type);
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 148 /* Constructor */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 179 /* FunctionExpression */:
+            case 220 /* FunctionDeclaration */:
+            case 180 /* ArrowFunction */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.asteriskToken) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.questionToken) ||
+                    visitNodes(cbNodes, node.typeParameters) ||
+                    visitNodes(cbNodes, node.parameters) ||
+                    visitNode(cbNode, node.type) ||
+                    visitNode(cbNode, node.equalsGreaterThanToken) ||
+                    visitNode(cbNode, node.body);
+            case 155 /* TypeReference */:
+                return visitNode(cbNode, node.typeName) ||
+                    visitNodes(cbNodes, node.typeArguments);
+            case 154 /* TypePredicate */:
+                return visitNode(cbNode, node.parameterName) ||
+                    visitNode(cbNode, node.type);
+            case 158 /* TypeQuery */:
+                return visitNode(cbNode, node.exprName);
+            case 159 /* TypeLiteral */:
+                return visitNodes(cbNodes, node.members);
+            case 160 /* ArrayType */:
+                return visitNode(cbNode, node.elementType);
+            case 161 /* TupleType */:
+                return visitNodes(cbNodes, node.elementTypes);
+            case 162 /* UnionType */:
+            case 163 /* IntersectionType */:
+                return visitNodes(cbNodes, node.types);
+            case 164 /* ParenthesizedType */:
+                return visitNode(cbNode, node.type);
+            case 167 /* ObjectBindingPattern */:
+            case 168 /* ArrayBindingPattern */:
+                return visitNodes(cbNodes, node.elements);
+            case 170 /* ArrayLiteralExpression */:
+                return visitNodes(cbNodes, node.elements);
+            case 171 /* ObjectLiteralExpression */:
+                return visitNodes(cbNodes, node.properties);
+            case 172 /* PropertyAccessExpression */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.name);
+            case 173 /* ElementAccessExpression */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.argumentExpression);
+            case 174 /* CallExpression */:
+            case 175 /* NewExpression */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNodes(cbNodes, node.typeArguments) ||
+                    visitNodes(cbNodes, node.arguments);
+            case 176 /* TaggedTemplateExpression */:
+                return visitNode(cbNode, node.tag) ||
+                    visitNode(cbNode, node.template);
+            case 177 /* TypeAssertionExpression */:
+                return visitNode(cbNode, node.type) ||
+                    visitNode(cbNode, node.expression);
+            case 178 /* ParenthesizedExpression */:
+                return visitNode(cbNode, node.expression);
+            case 181 /* DeleteExpression */:
+                return visitNode(cbNode, node.expression);
+            case 182 /* TypeOfExpression */:
+                return visitNode(cbNode, node.expression);
+            case 183 /* VoidExpression */:
+                return visitNode(cbNode, node.expression);
+            case 185 /* PrefixUnaryExpression */:
+                return visitNode(cbNode, node.operand);
+            case 190 /* YieldExpression */:
+                return visitNode(cbNode, node.asteriskToken) ||
+                    visitNode(cbNode, node.expression);
+            case 184 /* AwaitExpression */:
+                return visitNode(cbNode, node.expression);
+            case 186 /* PostfixUnaryExpression */:
+                return visitNode(cbNode, node.operand);
+            case 187 /* BinaryExpression */:
+                return visitNode(cbNode, node.left) ||
+                    visitNode(cbNode, node.operatorToken) ||
+                    visitNode(cbNode, node.right);
+            case 195 /* AsExpression */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.type);
+            case 196 /* NonNullExpression */:
+                return visitNode(cbNode, node.expression);
+            case 188 /* ConditionalExpression */:
+                return visitNode(cbNode, node.condition) ||
+                    visitNode(cbNode, node.questionToken) ||
+                    visitNode(cbNode, node.whenTrue) ||
+                    visitNode(cbNode, node.colonToken) ||
+                    visitNode(cbNode, node.whenFalse);
+            case 191 /* SpreadElementExpression */:
+                return visitNode(cbNode, node.expression);
+            case 199 /* Block */:
+            case 226 /* ModuleBlock */:
+                return visitNodes(cbNodes, node.statements);
+            case 256 /* SourceFile */:
+                return visitNodes(cbNodes, node.statements) ||
+                    visitNode(cbNode, node.endOfFileToken);
+            case 200 /* VariableStatement */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.declarationList);
+            case 219 /* VariableDeclarationList */:
+                return visitNodes(cbNodes, node.declarations);
+            case 202 /* ExpressionStatement */:
+                return visitNode(cbNode, node.expression);
+            case 203 /* IfStatement */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.thenStatement) ||
+                    visitNode(cbNode, node.elseStatement);
+            case 204 /* DoStatement */:
+                return visitNode(cbNode, node.statement) ||
+                    visitNode(cbNode, node.expression);
+            case 205 /* WhileStatement */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.statement);
+            case 206 /* ForStatement */:
+                return visitNode(cbNode, node.initializer) ||
+                    visitNode(cbNode, node.condition) ||
+                    visitNode(cbNode, node.incrementor) ||
+                    visitNode(cbNode, node.statement);
+            case 207 /* ForInStatement */:
+                return visitNode(cbNode, node.initializer) ||
+                    visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.statement);
+            case 208 /* ForOfStatement */:
+                return visitNode(cbNode, node.initializer) ||
+                    visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.statement);
+            case 209 /* ContinueStatement */:
+            case 210 /* BreakStatement */:
+                return visitNode(cbNode, node.label);
+            case 211 /* ReturnStatement */:
+                return visitNode(cbNode, node.expression);
+            case 212 /* WithStatement */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.statement);
+            case 213 /* SwitchStatement */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNode(cbNode, node.caseBlock);
+            case 227 /* CaseBlock */:
+                return visitNodes(cbNodes, node.clauses);
+            case 249 /* CaseClause */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNodes(cbNodes, node.statements);
+            case 250 /* DefaultClause */:
+                return visitNodes(cbNodes, node.statements);
+            case 214 /* LabeledStatement */:
+                return visitNode(cbNode, node.label) ||
+                    visitNode(cbNode, node.statement);
+            case 215 /* ThrowStatement */:
+                return visitNode(cbNode, node.expression);
+            case 216 /* TryStatement */:
+                return visitNode(cbNode, node.tryBlock) ||
+                    visitNode(cbNode, node.catchClause) ||
+                    visitNode(cbNode, node.finallyBlock);
+            case 252 /* CatchClause */:
+                return visitNode(cbNode, node.variableDeclaration) ||
+                    visitNode(cbNode, node.block);
+            case 143 /* Decorator */:
+                return visitNode(cbNode, node.expression);
+            case 221 /* ClassDeclaration */:
+            case 192 /* ClassExpression */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNodes(cbNodes, node.typeParameters) ||
+                    visitNodes(cbNodes, node.heritageClauses) ||
+                    visitNodes(cbNodes, node.members);
+            case 222 /* InterfaceDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNodes(cbNodes, node.typeParameters) ||
+                    visitNodes(cbNodes, node.heritageClauses) ||
+                    visitNodes(cbNodes, node.members);
+            case 223 /* TypeAliasDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNodes(cbNodes, node.typeParameters) ||
+                    visitNode(cbNode, node.type);
+            case 224 /* EnumDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNodes(cbNodes, node.members);
+            case 255 /* EnumMember */:
+                return visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.initializer);
+            case 225 /* ModuleDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.body);
+            case 229 /* ImportEqualsDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.moduleReference);
+            case 230 /* ImportDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.importClause) ||
+                    visitNode(cbNode, node.moduleSpecifier);
+            case 231 /* ImportClause */:
+                return visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.namedBindings);
+            case 228 /* NamespaceExportDeclaration */:
+                return visitNode(cbNode, node.name);
+            case 232 /* NamespaceImport */:
+                return visitNode(cbNode, node.name);
+            case 233 /* NamedImports */:
+            case 237 /* NamedExports */:
+                return visitNodes(cbNodes, node.elements);
+            case 236 /* ExportDeclaration */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.exportClause) ||
+                    visitNode(cbNode, node.moduleSpecifier);
+            case 234 /* ImportSpecifier */:
+            case 238 /* ExportSpecifier */:
+                return visitNode(cbNode, node.propertyName) ||
+                    visitNode(cbNode, node.name);
+            case 235 /* ExportAssignment */:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, node.expression);
+            case 189 /* TemplateExpression */:
+                return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans);
+            case 197 /* TemplateSpan */:
+                return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal);
+            case 140 /* ComputedPropertyName */:
+                return visitNode(cbNode, node.expression);
+            case 251 /* HeritageClause */:
+                return visitNodes(cbNodes, node.types);
+            case 194 /* ExpressionWithTypeArguments */:
+                return visitNode(cbNode, node.expression) ||
+                    visitNodes(cbNodes, node.typeArguments);
+            case 240 /* ExternalModuleReference */:
+                return visitNode(cbNode, node.expression);
+            case 239 /* MissingDeclaration */:
+                return visitNodes(cbNodes, node.decorators);
+            case 241 /* JsxElement */:
+                return visitNode(cbNode, node.openingElement) ||
+                    visitNodes(cbNodes, node.children) ||
+                    visitNode(cbNode, node.closingElement);
+            case 242 /* JsxSelfClosingElement */:
+            case 243 /* JsxOpeningElement */:
+                return visitNode(cbNode, node.tagName) ||
+                    visitNodes(cbNodes, node.attributes);
+            case 246 /* JsxAttribute */:
+                return visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.initializer);
+            case 247 /* JsxSpreadAttribute */:
+                return visitNode(cbNode, node.expression);
+            case 248 /* JsxExpression */:
+                return visitNode(cbNode, node.expression);
+            case 245 /* JsxClosingElement */:
+                return visitNode(cbNode, node.tagName);
+            case 257 /* JSDocTypeExpression */:
+                return visitNode(cbNode, node.type);
+            case 261 /* JSDocUnionType */:
+                return visitNodes(cbNodes, node.types);
+            case 262 /* JSDocTupleType */:
+                return visitNodes(cbNodes, node.types);
+            case 260 /* JSDocArrayType */:
+                return visitNode(cbNode, node.elementType);
+            case 264 /* JSDocNonNullableType */:
+                return visitNode(cbNode, node.type);
+            case 263 /* JSDocNullableType */:
+                return visitNode(cbNode, node.type);
+            case 265 /* JSDocRecordType */:
+                return visitNodes(cbNodes, node.members);
+            case 267 /* JSDocTypeReference */:
+                return visitNode(cbNode, node.name) ||
+                    visitNodes(cbNodes, node.typeArguments);
+            case 268 /* JSDocOptionalType */:
+                return visitNode(cbNode, node.type);
+            case 269 /* JSDocFunctionType */:
+                return visitNodes(cbNodes, node.parameters) ||
+                    visitNode(cbNode, node.type);
+            case 270 /* JSDocVariadicType */:
+                return visitNode(cbNode, node.type);
+            case 271 /* JSDocConstructorType */:
+                return visitNode(cbNode, node.type);
+            case 272 /* JSDocThisType */:
+                return visitNode(cbNode, node.type);
+            case 266 /* JSDocRecordMember */:
+                return visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.type);
+            case 273 /* JSDocComment */:
+                return visitNodes(cbNodes, node.tags);
+            case 275 /* JSDocParameterTag */:
+                return visitNode(cbNode, node.preParameterName) ||
+                    visitNode(cbNode, node.typeExpression) ||
+                    visitNode(cbNode, node.postParameterName);
+            case 276 /* JSDocReturnTag */:
+                return visitNode(cbNode, node.typeExpression);
+            case 277 /* JSDocTypeTag */:
+                return visitNode(cbNode, node.typeExpression);
+            case 278 /* JSDocTemplateTag */:
+                return visitNodes(cbNodes, node.typeParameters);
+            case 279 /* JSDocTypedefTag */:
+                return visitNode(cbNode, node.typeExpression) ||
+                    visitNode(cbNode, node.name) ||
+                    visitNode(cbNode, node.jsDocTypeLiteral);
+            case 281 /* JSDocTypeLiteral */:
+                return visitNodes(cbNodes, node.jsDocPropertyTags);
+            case 280 /* JSDocPropertyTag */:
+                return visitNode(cbNode, node.typeExpression) ||
+                    visitNode(cbNode, node.name);
+        }
+    }
+    ts.forEachChild = forEachChild;
+    function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
+        if (setParentNodes === void 0) { setParentNodes = false; }
+        var start = new Date().getTime();
+        var result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);
+        ts.parseTime += new Date().getTime() - start;
+        return result;
+    }
+    ts.createSourceFile = createSourceFile;
+    function isExternalModule(file) {
+        return file.externalModuleIndicator !== undefined;
+    }
+    ts.isExternalModule = isExternalModule;
+    // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter
+    // indicates what changed between the 'text' that this SourceFile has and the 'newText'.
+    // The SourceFile will be created with the compiler attempting to reuse as many nodes from
+    // this file as possible.
+    //
+    // Note: this function mutates nodes from this SourceFile. That means any existing nodes
+    // from this SourceFile that are being held onto may change as a result (including
+    // becoming detached from any SourceFile).  It is recommended that this SourceFile not
+    // be used once 'update' is called on it.
+    function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
+        return IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
+    }
+    ts.updateSourceFile = updateSourceFile;
+    /* @internal */
+    function parseIsolatedJSDocComment(content, start, length) {
+        var result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length);
+        if (result && result.jsDocComment) {
+            // because the jsDocComment was parsed out of the source file, it might
+            // not be covered by the fixupParentReferences.
+            Parser.fixupParentReferences(result.jsDocComment);
+        }
+        return result;
+    }
+    ts.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
+    /* @internal */
+    // Exposed only for testing.
+    function parseJSDocTypeExpressionForTests(content, start, length) {
+        return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length);
+    }
+    ts.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
+    // Implement the parser as a singleton module.  We do this for perf reasons because creating
+    // parser instances can actually be expensive enough to impact us on projects with many source
+    // files.
+    var Parser;
+    (function (Parser) {
+        // Share a single scanner across all calls to parse a source file.  This helps speed things
+        // up by avoiding the cost of creating/compiling scanners over and over again.
+        var scanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ true);
+        var disallowInAndDecoratorContext = 4194304 /* DisallowInContext */ | 16777216 /* DecoratorContext */;
+        // capture constructors in 'initializeState' to avoid null checks
+        var NodeConstructor;
+        var SourceFileConstructor;
+        var sourceFile;
+        var parseDiagnostics;
+        var syntaxCursor;
+        var token;
+        var sourceText;
+        var nodeCount;
+        var identifiers;
+        var identifierCount;
+        var parsingContext;
+        // Flags that dictate what parsing context we're in.  For example:
+        // Whether or not we are in strict parsing mode.  All that changes in strict parsing mode is
+        // that some tokens that would be considered identifiers may be considered keywords.
+        //
+        // When adding more parser context flags, consider which is the more common case that the
+        // flag will be in.  This should be the 'false' state for that flag.  The reason for this is
+        // that we don't store data in our nodes unless the value is in the *non-default* state.  So,
+        // for example, more often than code 'allows-in' (or doesn't 'disallow-in').  We opt for
+        // 'disallow-in' set to 'false'.  Otherwise, if we had 'allowsIn' set to 'true', then almost
+        // all nodes would need extra state on them to store this info.
+        //
+        // Note:  'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6
+        // grammar specification.
+        //
+        // An important thing about these context concepts.  By default they are effectively inherited
+        // while parsing through every grammar production.  i.e. if you don't change them, then when
+        // you parse a sub-production, it will have the same context values as the parent production.
+        // This is great most of the time.  After all, consider all the 'expression' grammar productions
+        // and how nearly all of them pass along the 'in' and 'yield' context values:
+        //
+        // EqualityExpression[In, Yield] :
+        //      RelationalExpression[?In, ?Yield]
+        //      EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]
+        //      EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]
+        //      EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield]
+        //      EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield]
+        //
+        // Where you have to be careful is then understanding what the points are in the grammar
+        // where the values are *not* passed along.  For example:
+        //
+        // SingleNameBinding[Yield,GeneratorParameter]
+        //      [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt
+        //      [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt
+        //
+        // Here this is saying that if the GeneratorParameter context flag is set, that we should
+        // explicitly set the 'yield' context flag to false before calling into the BindingIdentifier
+        // and we should explicitly unset the 'yield' context flag before calling into the Initializer.
+        // production.  Conversely, if the GeneratorParameter context flag is not set, then we
+        // should leave the 'yield' context flag alone.
+        //
+        // Getting this all correct is tricky and requires careful reading of the grammar to
+        // understand when these values should be changed versus when they should be inherited.
+        //
+        // Note: it should not be necessary to save/restore these flags during speculative/lookahead
+        // parsing.  These context flags are naturally stored and restored through normal recursive
+        // descent parsing and unwinding.
+        var contextFlags;
+        // Whether or not we've had a parse error since creating the last AST node.  If we have
+        // encountered an error, it will be stored on the next AST node we create.  Parse errors
+        // can be broken down into three categories:
+        //
+        // 1) An error that occurred during scanning.  For example, an unterminated literal, or a
+        //    character that was completely not understood.
+        //
+        // 2) A token was expected, but was not present.  This type of error is commonly produced
+        //    by the 'parseExpected' function.
+        //
+        // 3) A token was present that no parsing function was able to consume.  This type of error
+        //    only occurs in the 'abortParsingListOrMoveToNextToken' function when the parser
+        //    decides to skip the token.
+        //
+        // In all of these cases, we want to mark the next node as having had an error before it.
+        // With this mark, we can know in incremental settings if this node can be reused, or if
+        // we have to reparse it.  If we don't keep this information around, we may just reuse the
+        // node.  in that event we would then not produce the same errors as we did before, causing
+        // significant confusion problems.
+        //
+        // Note: it is necessary that this value be saved/restored during speculative/lookahead
+        // parsing.  During lookahead parsing, we will often create a node.  That node will have
+        // this value attached, and then this value will be set back to 'false'.  If we decide to
+        // rewind, we must get back to the same value we had prior to the lookahead.
+        //
+        // Note: any errors at the end of the file that do not precede a regular node, should get
+        // attached to the EOF token.
+        var parseErrorBeforeNextFinishedNode = false;
+        function parseSourceFile(fileName, _sourceText, languageVersion, _syntaxCursor, setParentNodes, scriptKind) {
+            scriptKind = ts.ensureScriptKind(fileName, scriptKind);
+            initializeState(fileName, _sourceText, languageVersion, _syntaxCursor, scriptKind);
+            var result = parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind);
+            clearState();
+            return result;
+        }
+        Parser.parseSourceFile = parseSourceFile;
+        function getLanguageVariant(scriptKind) {
+            // .tsx and .jsx files are treated as jsx language variant.
+            return scriptKind === 4 /* TSX */ || scriptKind === 2 /* JSX */ || scriptKind === 1 /* JS */ ? 1 /* JSX */ : 0 /* Standard */;
+        }
+        function initializeState(fileName, _sourceText, languageVersion, _syntaxCursor, scriptKind) {
+            NodeConstructor = ts.objectAllocator.getNodeConstructor();
+            SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor();
+            sourceText = _sourceText;
+            syntaxCursor = _syntaxCursor;
+            parseDiagnostics = [];
+            parsingContext = 0;
+            identifiers = {};
+            identifierCount = 0;
+            nodeCount = 0;
+            contextFlags = scriptKind === 1 /* JS */ || scriptKind === 2 /* JSX */ ? 134217728 /* JavaScriptFile */ : 0 /* None */;
+            parseErrorBeforeNextFinishedNode = false;
+            // Initialize and prime the scanner before parsing the source elements.
+            scanner.setText(sourceText);
+            scanner.setOnError(scanError);
+            scanner.setScriptTarget(languageVersion);
+            scanner.setLanguageVariant(getLanguageVariant(scriptKind));
+        }
+        function clearState() {
+            // Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily.
+            scanner.setText("");
+            scanner.setOnError(undefined);
+            // Clear any data.  We don't want to accidentally hold onto it for too long.
+            parseDiagnostics = undefined;
+            sourceFile = undefined;
+            identifiers = undefined;
+            syntaxCursor = undefined;
+            sourceText = undefined;
+        }
+        function parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind) {
+            sourceFile = createSourceFile(fileName, languageVersion, scriptKind);
+            sourceFile.flags = contextFlags;
+            // Prime the scanner.
+            token = nextToken();
+            processReferenceComments(sourceFile);
+            sourceFile.statements = parseList(0 /* SourceElements */, parseStatement);
+            ts.Debug.assert(token === 1 /* EndOfFileToken */);
+            sourceFile.endOfFileToken = parseTokenNode();
+            setExternalModuleIndicator(sourceFile);
+            sourceFile.nodeCount = nodeCount;
+            sourceFile.identifierCount = identifierCount;
+            sourceFile.identifiers = identifiers;
+            sourceFile.parseDiagnostics = parseDiagnostics;
+            if (setParentNodes) {
+                fixupParentReferences(sourceFile);
+            }
+            return sourceFile;
+        }
+        function addJSDocComment(node) {
+            if (contextFlags & 134217728 /* JavaScriptFile */) {
+                var comments = ts.getLeadingCommentRangesOfNode(node, sourceFile);
+                if (comments) {
+                    for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                        var comment = comments_1[_i];
+                        var jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
+                        if (!jsDocComment) {
+                            continue;
+                        }
+                        if (!node.jsDocComments) {
+                            node.jsDocComments = [];
+                        }
+                        node.jsDocComments.push(jsDocComment);
+                    }
+                }
+            }
+            return node;
+        }
+        function fixupParentReferences(rootNode) {
+            // normally parent references are set during binding. However, for clients that only need
+            // a syntax tree, and no semantic features, then the binding process is an unnecessary
+            // overhead.  This functions allows us to set all the parents, without all the expense of
+            // binding.
+            var parent = rootNode;
+            forEachChild(rootNode, visitNode);
+            return;
+            function visitNode(n) {
+                // walk down setting parents that differ from the parent we think it should be.  This
+                // allows us to quickly bail out of setting parents for subtrees during incremental
+                // parsing
+                if (n.parent !== parent) {
+                    n.parent = parent;
+                    var saveParent = parent;
+                    parent = n;
+                    forEachChild(n, visitNode);
+                    if (n.jsDocComments) {
+                        for (var _i = 0, _a = n.jsDocComments; _i < _a.length; _i++) {
+                            var jsDocComment = _a[_i];
+                            jsDocComment.parent = n;
+                            parent = jsDocComment;
+                            forEachChild(jsDocComment, visitNode);
+                        }
+                    }
+                    parent = saveParent;
+                }
+            }
+        }
+        Parser.fixupParentReferences = fixupParentReferences;
+        function createSourceFile(fileName, languageVersion, scriptKind) {
+            // code from createNode is inlined here so createNode won't have to deal with special case of creating source files
+            // this is quite rare comparing to other nodes and createNode should be as fast as possible
+            var sourceFile = new SourceFileConstructor(256 /* SourceFile */, /*pos*/ 0, /* end */ sourceText.length);
+            nodeCount++;
+            sourceFile.text = sourceText;
+            sourceFile.bindDiagnostics = [];
+            sourceFile.languageVersion = languageVersion;
+            sourceFile.fileName = ts.normalizePath(fileName);
+            sourceFile.languageVariant = getLanguageVariant(scriptKind);
+            sourceFile.isDeclarationFile = ts.fileExtensionIs(sourceFile.fileName, ".d.ts");
+            sourceFile.scriptKind = scriptKind;
+            return sourceFile;
+        }
+        function setContextFlag(val, flag) {
+            if (val) {
+                contextFlags |= flag;
+            }
+            else {
+                contextFlags &= ~flag;
+            }
+        }
+        function setDisallowInContext(val) {
+            setContextFlag(val, 4194304 /* DisallowInContext */);
+        }
+        function setYieldContext(val) {
+            setContextFlag(val, 8388608 /* YieldContext */);
+        }
+        function setDecoratorContext(val) {
+            setContextFlag(val, 16777216 /* DecoratorContext */);
+        }
+        function setAwaitContext(val) {
+            setContextFlag(val, 33554432 /* AwaitContext */);
+        }
+        function doOutsideOfContext(context, func) {
+            // contextFlagsToClear will contain only the context flags that are
+            // currently set that we need to temporarily clear
+            // We don't just blindly reset to the previous flags to ensure
+            // that we do not mutate cached flags for the incremental
+            // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
+            // HasAggregatedChildData).
+            var contextFlagsToClear = context & contextFlags;
+            if (contextFlagsToClear) {
+                // clear the requested context flags
+                setContextFlag(/*val*/ false, contextFlagsToClear);
+                var result = func();
+                // restore the context flags we just cleared
+                setContextFlag(/*val*/ true, contextFlagsToClear);
+                return result;
+            }
+            // no need to do anything special as we are not in any of the requested contexts
+            return func();
+        }
+        function doInsideOfContext(context, func) {
+            // contextFlagsToSet will contain only the context flags that
+            // are not currently set that we need to temporarily enable.
+            // We don't just blindly reset to the previous flags to ensure
+            // that we do not mutate cached flags for the incremental
+            // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
+            // HasAggregatedChildData).
+            var contextFlagsToSet = context & ~contextFlags;
+            if (contextFlagsToSet) {
+                // set the requested context flags
+                setContextFlag(/*val*/ true, contextFlagsToSet);
+                var result = func();
+                // reset the context flags we just set
+                setContextFlag(/*val*/ false, contextFlagsToSet);
+                return result;
+            }
+            // no need to do anything special as we are already in all of the requested contexts
+            return func();
+        }
+        function allowInAnd(func) {
+            return doOutsideOfContext(4194304 /* DisallowInContext */, func);
+        }
+        function disallowInAnd(func) {
+            return doInsideOfContext(4194304 /* DisallowInContext */, func);
+        }
+        function doInYieldContext(func) {
+            return doInsideOfContext(8388608 /* YieldContext */, func);
+        }
+        function doInDecoratorContext(func) {
+            return doInsideOfContext(16777216 /* DecoratorContext */, func);
+        }
+        function doInAwaitContext(func) {
+            return doInsideOfContext(33554432 /* AwaitContext */, func);
+        }
+        function doOutsideOfAwaitContext(func) {
+            return doOutsideOfContext(33554432 /* AwaitContext */, func);
+        }
+        function doInYieldAndAwaitContext(func) {
+            return doInsideOfContext(8388608 /* YieldContext */ | 33554432 /* AwaitContext */, func);
+        }
+        function inContext(flags) {
+            return (contextFlags & flags) !== 0;
+        }
+        function inYieldContext() {
+            return inContext(8388608 /* YieldContext */);
+        }
+        function inDisallowInContext() {
+            return inContext(4194304 /* DisallowInContext */);
+        }
+        function inDecoratorContext() {
+            return inContext(16777216 /* DecoratorContext */);
+        }
+        function inAwaitContext() {
+            return inContext(33554432 /* AwaitContext */);
+        }
+        function parseErrorAtCurrentToken(message, arg0) {
+            var start = scanner.getTokenPos();
+            var length = scanner.getTextPos() - start;
+            parseErrorAtPosition(start, length, message, arg0);
+        }
+        function parseErrorAtPosition(start, length, message, arg0) {
+            // Don't report another error if it would just be at the same position as the last error.
+            var lastError = ts.lastOrUndefined(parseDiagnostics);
+            if (!lastError || start !== lastError.start) {
+                parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, start, length, message, arg0));
+            }
+            // Mark that we've encountered an error.  We'll set an appropriate bit on the next
+            // node we finish so that it can't be reused incrementally.
+            parseErrorBeforeNextFinishedNode = true;
+        }
+        function scanError(message, length) {
+            var pos = scanner.getTextPos();
+            parseErrorAtPosition(pos, length || 0, message);
+        }
+        function getNodePos() {
+            return scanner.getStartPos();
+        }
+        function getNodeEnd() {
+            return scanner.getStartPos();
+        }
+        function nextToken() {
+            return token = scanner.scan();
+        }
+        function reScanGreaterToken() {
+            return token = scanner.reScanGreaterToken();
+        }
+        function reScanSlashToken() {
+            return token = scanner.reScanSlashToken();
+        }
+        function reScanTemplateToken() {
+            return token = scanner.reScanTemplateToken();
+        }
+        function scanJsxIdentifier() {
+            return token = scanner.scanJsxIdentifier();
+        }
+        function scanJsxText() {
+            return token = scanner.scanJsxToken();
+        }
+        function speculationHelper(callback, isLookAhead) {
+            // Keep track of the state we'll need to rollback to if lookahead fails (or if the
+            // caller asked us to always reset our state).
+            var saveToken = token;
+            var saveParseDiagnosticsLength = parseDiagnostics.length;
+            var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+            // Note: it is not actually necessary to save/restore the context flags here.  That's
+            // because the saving/restoring of these flags happens naturally through the recursive
+            // descent nature of our parser.  However, we still store this here just so we can
+            // assert that that invariant holds.
+            var saveContextFlags = contextFlags;
+            // If we're only looking ahead, then tell the scanner to only lookahead as well.
+            // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the
+            // same.
+            var result = isLookAhead
+                ? scanner.lookAhead(callback)
+                : scanner.tryScan(callback);
+            ts.Debug.assert(saveContextFlags === contextFlags);
+            // If our callback returned something 'falsy' or we're just looking ahead,
+            // then unconditionally restore us to where we were.
+            if (!result || isLookAhead) {
+                token = saveToken;
+                parseDiagnostics.length = saveParseDiagnosticsLength;
+                parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
+            }
+            return result;
+        }
+        /** Invokes the provided callback then unconditionally restores the parser to the state it
+         * was in immediately prior to invoking the callback.  The result of invoking the callback
+         * is returned from this function.
+         */
+        function lookAhead(callback) {
+            return speculationHelper(callback, /*isLookAhead*/ true);
+        }
+        /** Invokes the provided callback.  If the callback returns something falsy, then it restores
+         * the parser to the state it was in immediately prior to invoking the callback.  If the
+         * callback returns something truthy, then the parser state is not rolled back.  The result
+         * of invoking the callback is returned from this function.
+         */
+        function tryParse(callback) {
+            return speculationHelper(callback, /*isLookAhead*/ false);
+        }
+        // Ignore strict mode flag because we will report an error in type checker instead.
+        function isIdentifier() {
+            if (token === 69 /* Identifier */) {
+                return true;
+            }
+            // If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is
+            // considered a keyword and is not an identifier.
+            if (token === 114 /* YieldKeyword */ && inYieldContext()) {
+                return false;
+            }
+            // If we have a 'await' keyword, and we're in the [Await] context, then 'await' is
+            // considered a keyword and is not an identifier.
+            if (token === 119 /* AwaitKeyword */ && inAwaitContext()) {
+                return false;
+            }
+            return token > 105 /* LastReservedWord */;
+        }
+        function parseExpected(kind, diagnosticMessage, shouldAdvance) {
+            if (shouldAdvance === void 0) { shouldAdvance = true; }
+            if (token === kind) {
+                if (shouldAdvance) {
+                    nextToken();
+                }
+                return true;
+            }
+            // Report specific message if provided with one.  Otherwise, report generic fallback message.
+            if (diagnosticMessage) {
+                parseErrorAtCurrentToken(diagnosticMessage);
+            }
+            else {
+                parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
+            }
+            return false;
+        }
+        function parseOptional(t) {
+            if (token === t) {
+                nextToken();
+                return true;
+            }
+            return false;
+        }
+        function parseOptionalToken(t) {
+            if (token === t) {
+                return parseTokenNode();
+            }
+            return undefined;
+        }
+        function parseExpectedToken(t, reportAtCurrentPosition, diagnosticMessage, arg0) {
+            return parseOptionalToken(t) ||
+                createMissingNode(t, reportAtCurrentPosition, diagnosticMessage, arg0);
+        }
+        function parseTokenNode() {
+            var node = createNode(token);
+            nextToken();
+            return finishNode(node);
+        }
+        function canParseSemicolon() {
+            // If there's a real semicolon, then we can always parse it out.
+            if (token === 23 /* SemicolonToken */) {
+                return true;
+            }
+            // We can parse out an optional semicolon in ASI cases in the following cases.
+            return token === 16 /* CloseBraceToken */ || token === 1 /* EndOfFileToken */ || scanner.hasPrecedingLineBreak();
+        }
+        function parseSemicolon() {
+            if (canParseSemicolon()) {
+                if (token === 23 /* SemicolonToken */) {
+                    // consume the semicolon if it was explicitly provided.
+                    nextToken();
+                }
+                return true;
+            }
+            else {
+                return parseExpected(23 /* SemicolonToken */);
+            }
+        }
+        // note: this function creates only node
+        function createNode(kind, pos) {
+            nodeCount++;
+            if (!(pos >= 0)) {
+                pos = scanner.getStartPos();
+            }
+            return new NodeConstructor(kind, pos, pos);
+        }
+        function finishNode(node, end) {
+            node.end = end === undefined ? scanner.getStartPos() : end;
+            if (contextFlags) {
+                node.flags |= contextFlags;
+            }
+            // Keep track on the node if we encountered an error while parsing it.  If we did, then
+            // we cannot reuse the node incrementally.  Once we've marked this node, clear out the
+            // flag so that we don't mark any subsequent nodes.
+            if (parseErrorBeforeNextFinishedNode) {
+                parseErrorBeforeNextFinishedNode = false;
+                node.flags |= 67108864 /* ThisNodeHasError */;
+            }
+            return node;
+        }
+        function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
+            if (reportAtCurrentPosition) {
+                parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0);
+            }
+            else {
+                parseErrorAtCurrentToken(diagnosticMessage, arg0);
+            }
+            var result = createNode(kind, scanner.getStartPos());
+            result.text = "";
+            return finishNode(result);
+        }
+        function internIdentifier(text) {
+            text = ts.escapeIdentifier(text);
+            return ts.hasProperty(identifiers, text) ? identifiers[text] : (identifiers[text] = text);
+        }
+        // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
+        // with magic property names like '__proto__'. The 'identifiers' object is used to share a single string instance for
+        // each identifier in order to reduce memory consumption.
+        function createIdentifier(isIdentifier, diagnosticMessage) {
+            identifierCount++;
+            if (isIdentifier) {
+                var node = createNode(69 /* Identifier */);
+                // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker
+                if (token !== 69 /* Identifier */) {
+                    node.originalKeywordKind = token;
+                }
+                node.text = internIdentifier(scanner.getTokenValue());
+                nextToken();
+                return finishNode(node);
+            }
+            return createMissingNode(69 /* Identifier */, /*reportAtCurrentPosition*/ false, diagnosticMessage || ts.Diagnostics.Identifier_expected);
+        }
+        function parseIdentifier(diagnosticMessage) {
+            return createIdentifier(isIdentifier(), diagnosticMessage);
+        }
+        function parseIdentifierName() {
+            return createIdentifier(ts.tokenIsIdentifierOrKeyword(token));
+        }
+        function isLiteralPropertyName() {
+            return ts.tokenIsIdentifierOrKeyword(token) ||
+                token === 9 /* StringLiteral */ ||
+                token === 8 /* NumericLiteral */;
+        }
+        function parsePropertyNameWorker(allowComputedPropertyNames) {
+            if (token === 9 /* StringLiteral */ || token === 8 /* NumericLiteral */) {
+                return parseLiteralNode(/*internName*/ true);
+            }
+            if (allowComputedPropertyNames && token === 19 /* OpenBracketToken */) {
+                return parseComputedPropertyName();
+            }
+            return parseIdentifierName();
+        }
+        function parsePropertyName() {
+            return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true);
+        }
+        function parseSimplePropertyName() {
+            return parsePropertyNameWorker(/*allowComputedPropertyNames*/ false);
+        }
+        function isSimplePropertyName() {
+            return token === 9 /* StringLiteral */ || token === 8 /* NumericLiteral */ || ts.tokenIsIdentifierOrKeyword(token);
+        }
+        function parseComputedPropertyName() {
+            // PropertyName [Yield]:
+            //      LiteralPropertyName
+            //      ComputedPropertyName[?Yield]
+            var node = createNode(140 /* ComputedPropertyName */);
+            parseExpected(19 /* OpenBracketToken */);
+            // We parse any expression (including a comma expression). But the grammar
+            // says that only an assignment expression is allowed, so the grammar checker
+            // will error if it sees a comma expression.
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(20 /* CloseBracketToken */);
+            return finishNode(node);
+        }
+        function parseContextualModifier(t) {
+            return token === t && tryParse(nextTokenCanFollowModifier);
+        }
+        function nextTokenIsOnSameLineAndCanFollowModifier() {
+            nextToken();
+            if (scanner.hasPrecedingLineBreak()) {
+                return false;
+            }
+            return canFollowModifier();
+        }
+        function nextTokenCanFollowModifier() {
+            if (token === 74 /* ConstKeyword */) {
+                // 'const' is only a modifier if followed by 'enum'.
+                return nextToken() === 81 /* EnumKeyword */;
+            }
+            if (token === 82 /* ExportKeyword */) {
+                nextToken();
+                if (token === 77 /* DefaultKeyword */) {
+                    return lookAhead(nextTokenIsClassOrFunctionOrAsync);
+                }
+                return token !== 37 /* AsteriskToken */ && token !== 116 /* AsKeyword */ && token !== 15 /* OpenBraceToken */ && canFollowModifier();
+            }
+            if (token === 77 /* DefaultKeyword */) {
+                return nextTokenIsClassOrFunctionOrAsync();
+            }
+            if (token === 113 /* StaticKeyword */) {
+                nextToken();
+                return canFollowModifier();
+            }
+            return nextTokenIsOnSameLineAndCanFollowModifier();
+        }
+        function parseAnyContextualModifier() {
+            return ts.isModifierKind(token) && tryParse(nextTokenCanFollowModifier);
+        }
+        function canFollowModifier() {
+            return token === 19 /* OpenBracketToken */
+                || token === 15 /* OpenBraceToken */
+                || token === 37 /* AsteriskToken */
+                || token === 22 /* DotDotDotToken */
+                || isLiteralPropertyName();
+        }
+        function nextTokenIsClassOrFunctionOrAsync() {
+            nextToken();
+            return token === 73 /* ClassKeyword */ || token === 87 /* FunctionKeyword */ ||
+                (token === 118 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine));
+        }
+        // True if positioned at the start of a list element
+        function isListElement(parsingContext, inErrorRecovery) {
+            var node = currentNode(parsingContext);
+            if (node) {
+                return true;
+            }
+            switch (parsingContext) {
+                case 0 /* SourceElements */:
+                case 1 /* BlockStatements */:
+                case 3 /* SwitchClauseStatements */:
+                    // If we're in error recovery, then we don't want to treat ';' as an empty statement.
+                    // The problem is that ';' can show up in far too many contexts, and if we see one
+                    // and assume it's a statement, then we may bail out inappropriately from whatever
+                    // we're parsing.  For example, if we have a semicolon in the middle of a class, then
+                    // we really don't want to assume the class is over and we're on a statement in the
+                    // outer module.  We just want to consume and move on.
+                    return !(token === 23 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
+                case 2 /* SwitchClauses */:
+                    return token === 71 /* CaseKeyword */ || token === 77 /* DefaultKeyword */;
+                case 4 /* TypeMembers */:
+                    return lookAhead(isTypeMemberStart);
+                case 5 /* ClassMembers */:
+                    // We allow semicolons as class elements (as specified by ES6) as long as we're
+                    // not in error recovery.  If we're in error recovery, we don't want an errant
+                    // semicolon to be treated as a class member (since they're almost always used
+                    // for statements.
+                    return lookAhead(isClassMemberStart) || (token === 23 /* SemicolonToken */ && !inErrorRecovery);
+                case 6 /* EnumMembers */:
+                    // Include open bracket computed properties. This technically also lets in indexers,
+                    // which would be a candidate for improved error reporting.
+                    return token === 19 /* OpenBracketToken */ || isLiteralPropertyName();
+                case 12 /* ObjectLiteralMembers */:
+                    return token === 19 /* OpenBracketToken */ || token === 37 /* AsteriskToken */ || isLiteralPropertyName();
+                case 9 /* ObjectBindingElements */:
+                    return token === 19 /* OpenBracketToken */ || isLiteralPropertyName();
+                case 7 /* HeritageClauseElement */:
+                    // If we see { } then only consume it as an expression if it is followed by , or {
+                    // That way we won't consume the body of a class in its heritage clause.
+                    if (token === 15 /* OpenBraceToken */) {
+                        return lookAhead(isValidHeritageClauseObjectLiteral);
+                    }
+                    if (!inErrorRecovery) {
+                        return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
+                    }
+                    else {
+                        // If we're in error recovery we tighten up what we're willing to match.
+                        // That way we don't treat something like "this" as a valid heritage clause
+                        // element during recovery.
+                        return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
+                    }
+                case 8 /* VariableDeclarations */:
+                    return isIdentifierOrPattern();
+                case 10 /* ArrayBindingElements */:
+                    return token === 24 /* CommaToken */ || token === 22 /* DotDotDotToken */ || isIdentifierOrPattern();
+                case 17 /* TypeParameters */:
+                    return isIdentifier();
+                case 11 /* ArgumentExpressions */:
+                case 15 /* ArrayLiteralMembers */:
+                    return token === 24 /* CommaToken */ || token === 22 /* DotDotDotToken */ || isStartOfExpression();
+                case 16 /* Parameters */:
+                    return isStartOfParameter();
+                case 18 /* TypeArguments */:
+                case 19 /* TupleElementTypes */:
+                    return token === 24 /* CommaToken */ || isStartOfType();
+                case 20 /* HeritageClauses */:
+                    return isHeritageClause();
+                case 21 /* ImportOrExportSpecifiers */:
+                    return ts.tokenIsIdentifierOrKeyword(token);
+                case 13 /* JsxAttributes */:
+                    return ts.tokenIsIdentifierOrKeyword(token) || token === 15 /* OpenBraceToken */;
+                case 14 /* JsxChildren */:
+                    return true;
+                case 22 /* JSDocFunctionParameters */:
+                case 23 /* JSDocTypeArguments */:
+                case 25 /* JSDocTupleTypes */:
+                    return JSDocParser.isJSDocType();
+                case 24 /* JSDocRecordMembers */:
+                    return isSimplePropertyName();
+            }
+            ts.Debug.fail("Non-exhaustive case in 'isListElement'.");
+        }
+        function isValidHeritageClauseObjectLiteral() {
+            ts.Debug.assert(token === 15 /* OpenBraceToken */);
+            if (nextToken() === 16 /* CloseBraceToken */) {
+                // if we see  "extends {}" then only treat the {} as what we're extending (and not
+                // the class body) if we have:
+                //
+                //      extends {} {
+                //      extends {},
+                //      extends {} extends
+                //      extends {} implements
+                var next = nextToken();
+                return next === 24 /* CommaToken */ || next === 15 /* OpenBraceToken */ || next === 83 /* ExtendsKeyword */ || next === 106 /* ImplementsKeyword */;
+            }
+            return true;
+        }
+        function nextTokenIsIdentifier() {
+            nextToken();
+            return isIdentifier();
+        }
+        function nextTokenIsIdentifierOrKeyword() {
+            nextToken();
+            return ts.tokenIsIdentifierOrKeyword(token);
+        }
+        function isHeritageClauseExtendsOrImplementsKeyword() {
+            if (token === 106 /* ImplementsKeyword */ ||
+                token === 83 /* ExtendsKeyword */) {
+                return lookAhead(nextTokenIsStartOfExpression);
+            }
+            return false;
+        }
+        function nextTokenIsStartOfExpression() {
+            nextToken();
+            return isStartOfExpression();
+        }
+        // True if positioned at a list terminator
+        function isListTerminator(kind) {
+            if (token === 1 /* EndOfFileToken */) {
+                // Being at the end of the file ends all lists.
+                return true;
+            }
+            switch (kind) {
+                case 1 /* BlockStatements */:
+                case 2 /* SwitchClauses */:
+                case 4 /* TypeMembers */:
+                case 5 /* ClassMembers */:
+                case 6 /* EnumMembers */:
+                case 12 /* ObjectLiteralMembers */:
+                case 9 /* ObjectBindingElements */:
+                case 21 /* ImportOrExportSpecifiers */:
+                    return token === 16 /* CloseBraceToken */;
+                case 3 /* SwitchClauseStatements */:
+                    return token === 16 /* CloseBraceToken */ || token === 71 /* CaseKeyword */ || token === 77 /* DefaultKeyword */;
+                case 7 /* HeritageClauseElement */:
+                    return token === 15 /* OpenBraceToken */ || token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */;
+                case 8 /* VariableDeclarations */:
+                    return isVariableDeclaratorListTerminator();
+                case 17 /* TypeParameters */:
+                    // Tokens other than '>' are here for better error recovery
+                    return token === 27 /* GreaterThanToken */ || token === 17 /* OpenParenToken */ || token === 15 /* OpenBraceToken */ || token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */;
+                case 11 /* ArgumentExpressions */:
+                    // Tokens other than ')' are here for better error recovery
+                    return token === 18 /* CloseParenToken */ || token === 23 /* SemicolonToken */;
+                case 15 /* ArrayLiteralMembers */:
+                case 19 /* TupleElementTypes */:
+                case 10 /* ArrayBindingElements */:
+                    return token === 20 /* CloseBracketToken */;
+                case 16 /* Parameters */:
+                    // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery
+                    return token === 18 /* CloseParenToken */ || token === 20 /* CloseBracketToken */ /*|| token === SyntaxKind.OpenBraceToken*/;
+                case 18 /* TypeArguments */:
+                    // Tokens other than '>' are here for better error recovery
+                    return token === 27 /* GreaterThanToken */ || token === 17 /* OpenParenToken */;
+                case 20 /* HeritageClauses */:
+                    return token === 15 /* OpenBraceToken */ || token === 16 /* CloseBraceToken */;
+                case 13 /* JsxAttributes */:
+                    return token === 27 /* GreaterThanToken */ || token === 39 /* SlashToken */;
+                case 14 /* JsxChildren */:
+                    return token === 25 /* LessThanToken */ && lookAhead(nextTokenIsSlash);
+                case 22 /* JSDocFunctionParameters */:
+                    return token === 18 /* CloseParenToken */ || token === 54 /* ColonToken */ || token === 16 /* CloseBraceToken */;
+                case 23 /* JSDocTypeArguments */:
+                    return token === 27 /* GreaterThanToken */ || token === 16 /* CloseBraceToken */;
+                case 25 /* JSDocTupleTypes */:
+                    return token === 20 /* CloseBracketToken */ || token === 16 /* CloseBraceToken */;
+                case 24 /* JSDocRecordMembers */:
+                    return token === 16 /* CloseBraceToken */;
+            }
+        }
+        function isVariableDeclaratorListTerminator() {
+            // If we can consume a semicolon (either explicitly, or with ASI), then consider us done
+            // with parsing the list of  variable declarators.
+            if (canParseSemicolon()) {
+                return true;
+            }
+            // in the case where we're parsing the variable declarator of a 'for-in' statement, we
+            // are done if we see an 'in' keyword in front of us. Same with for-of
+            if (isInOrOfKeyword(token)) {
+                return true;
+            }
+            // ERROR RECOVERY TWEAK:
+            // For better error recovery, if we see an '=>' then we just stop immediately.  We've got an
+            // arrow function here and it's going to be very unlikely that we'll resynchronize and get
+            // another variable declaration.
+            if (token === 34 /* EqualsGreaterThanToken */) {
+                return true;
+            }
+            // Keep trying to parse out variable declarators.
+            return false;
+        }
+        // True if positioned at element or terminator of the current list or any enclosing list
+        function isInSomeParsingContext() {
+            for (var kind = 0; kind < 26 /* Count */; kind++) {
+                if (parsingContext & (1 << kind)) {
+                    if (isListElement(kind, /*inErrorRecovery*/ true) || isListTerminator(kind)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        // Parses a list of elements
+        function parseList(kind, parseElement) {
+            var saveParsingContext = parsingContext;
+            parsingContext |= 1 << kind;
+            var result = [];
+            result.pos = getNodePos();
+            while (!isListTerminator(kind)) {
+                if (isListElement(kind, /*inErrorRecovery*/ false)) {
+                    var element = parseListElement(kind, parseElement);
+                    result.push(element);
+                    continue;
+                }
+                if (abortParsingListOrMoveToNextToken(kind)) {
+                    break;
+                }
+            }
+            result.end = getNodeEnd();
+            parsingContext = saveParsingContext;
+            return result;
+        }
+        function parseListElement(parsingContext, parseElement) {
+            var node = currentNode(parsingContext);
+            if (node) {
+                return consumeNode(node);
+            }
+            return parseElement();
+        }
+        function currentNode(parsingContext) {
+            // If there is an outstanding parse error that we've encountered, but not attached to
+            // some node, then we cannot get a node from the old source tree.  This is because we
+            // want to mark the next node we encounter as being unusable.
+            //
+            // Note: This may be too conservative.  Perhaps we could reuse the node and set the bit
+            // on it (or its leftmost child) as having the error.  For now though, being conservative
+            // is nice and likely won't ever affect perf.
+            if (parseErrorBeforeNextFinishedNode) {
+                return undefined;
+            }
+            if (!syntaxCursor) {
+                // if we don't have a cursor, we could never return a node from the old tree.
+                return undefined;
+            }
+            var node = syntaxCursor.currentNode(scanner.getStartPos());
+            // Can't reuse a missing node.
+            if (ts.nodeIsMissing(node)) {
+                return undefined;
+            }
+            // Can't reuse a node that intersected the change range.
+            if (node.intersectsChange) {
+                return undefined;
+            }
+            // Can't reuse a node that contains a parse error.  This is necessary so that we
+            // produce the same set of errors again.
+            if (ts.containsParseError(node)) {
+                return undefined;
+            }
+            // We can only reuse a node if it was parsed under the same strict mode that we're
+            // currently in.  i.e. if we originally parsed a node in non-strict mode, but then
+            // the user added 'using strict' at the top of the file, then we can't use that node
+            // again as the presence of strict mode may cause us to parse the tokens in the file
+            // differently.
+            //
+            // Note: we *can* reuse tokens when the strict mode changes.  That's because tokens
+            // are unaffected by strict mode.  It's just the parser will decide what to do with it
+            // differently depending on what mode it is in.
+            //
+            // This also applies to all our other context flags as well.
+            var nodeContextFlags = node.flags & 197132288 /* ContextFlags */;
+            if (nodeContextFlags !== contextFlags) {
+                return undefined;
+            }
+            // Ok, we have a node that looks like it could be reused.  Now verify that it is valid
+            // in the current list parsing context that we're currently at.
+            if (!canReuseNode(node, parsingContext)) {
+                return undefined;
+            }
+            return node;
+        }
+        function consumeNode(node) {
+            // Move the scanner so it is after the node we just consumed.
+            scanner.setTextPos(node.end);
+            nextToken();
+            return node;
+        }
+        function canReuseNode(node, parsingContext) {
+            switch (parsingContext) {
+                case 5 /* ClassMembers */:
+                    return isReusableClassMember(node);
+                case 2 /* SwitchClauses */:
+                    return isReusableSwitchClause(node);
+                case 0 /* SourceElements */:
+                case 1 /* BlockStatements */:
+                case 3 /* SwitchClauseStatements */:
+                    return isReusableStatement(node);
+                case 6 /* EnumMembers */:
+                    return isReusableEnumMember(node);
+                case 4 /* TypeMembers */:
+                    return isReusableTypeMember(node);
+                case 8 /* VariableDeclarations */:
+                    return isReusableVariableDeclaration(node);
+                case 16 /* Parameters */:
+                    return isReusableParameter(node);
+                // Any other lists we do not care about reusing nodes in.  But feel free to add if
+                // you can do so safely.  Danger areas involve nodes that may involve speculative
+                // parsing.  If speculative parsing is involved with the node, then the range the
+                // parser reached while looking ahead might be in the edited range (see the example
+                // in canReuseVariableDeclaratorNode for a good case of this).
+                case 20 /* HeritageClauses */:
+                // This would probably be safe to reuse.  There is no speculative parsing with
+                // heritage clauses.
+                case 17 /* TypeParameters */:
+                // This would probably be safe to reuse.  There is no speculative parsing with
+                // type parameters.  Note that that's because type *parameters* only occur in
+                // unambiguous *type* contexts.  While type *arguments* occur in very ambiguous
+                // *expression* contexts.
+                case 19 /* TupleElementTypes */:
+                // This would probably be safe to reuse.  There is no speculative parsing with
+                // tuple types.
+                // Technically, type argument list types are probably safe to reuse.  While
+                // speculative parsing is involved with them (since type argument lists are only
+                // produced from speculative parsing a < as a type argument list), we only have
+                // the types because speculative parsing succeeded.  Thus, the lookahead never
+                // went past the end of the list and rewound.
+                case 18 /* TypeArguments */:
+                // Note: these are almost certainly not safe to ever reuse.  Expressions commonly
+                // need a large amount of lookahead, and we should not reuse them as they may
+                // have actually intersected the edit.
+                case 11 /* ArgumentExpressions */:
+                // This is not safe to reuse for the same reason as the 'AssignmentExpression'
+                // cases.  i.e. a property assignment may end with an expression, and thus might
+                // have lookahead far beyond it's old node.
+                case 12 /* ObjectLiteralMembers */:
+                // This is probably not safe to reuse.  There can be speculative parsing with
+                // type names in a heritage clause.  There can be generic names in the type
+                // name list, and there can be left hand side expressions (which can have type
+                // arguments.)
+                case 7 /* HeritageClauseElement */:
+                // Perhaps safe to reuse, but it's unlikely we'd see more than a dozen attributes
+                // on any given element. Same for children.
+                case 13 /* JsxAttributes */:
+                case 14 /* JsxChildren */:
+            }
+            return false;
+        }
+        function isReusableClassMember(node) {
+            if (node) {
+                switch (node.kind) {
+                    case 148 /* Constructor */:
+                    case 153 /* IndexSignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 145 /* PropertyDeclaration */:
+                    case 198 /* SemicolonClassElement */:
+                        return true;
+                    case 147 /* MethodDeclaration */:
+                        // Method declarations are not necessarily reusable.  An object-literal
+                        // may have a method calls "constructor(...)" and we must reparse that
+                        // into an actual .ConstructorDeclaration.
+                        var methodDeclaration = node;
+                        var nameIsConstructor = methodDeclaration.name.kind === 69 /* Identifier */ &&
+                            methodDeclaration.name.originalKeywordKind === 121 /* ConstructorKeyword */;
+                        return !nameIsConstructor;
+                }
+            }
+            return false;
+        }
+        function isReusableSwitchClause(node) {
+            if (node) {
+                switch (node.kind) {
+                    case 249 /* CaseClause */:
+                    case 250 /* DefaultClause */:
+                        return true;
+                }
+            }
+            return false;
+        }
+        function isReusableStatement(node) {
+            if (node) {
+                switch (node.kind) {
+                    case 220 /* FunctionDeclaration */:
+                    case 200 /* VariableStatement */:
+                    case 199 /* Block */:
+                    case 203 /* IfStatement */:
+                    case 202 /* ExpressionStatement */:
+                    case 215 /* ThrowStatement */:
+                    case 211 /* ReturnStatement */:
+                    case 213 /* SwitchStatement */:
+                    case 210 /* BreakStatement */:
+                    case 209 /* ContinueStatement */:
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                    case 206 /* ForStatement */:
+                    case 205 /* WhileStatement */:
+                    case 212 /* WithStatement */:
+                    case 201 /* EmptyStatement */:
+                    case 216 /* TryStatement */:
+                    case 214 /* LabeledStatement */:
+                    case 204 /* DoStatement */:
+                    case 217 /* DebuggerStatement */:
+                    case 230 /* ImportDeclaration */:
+                    case 229 /* ImportEqualsDeclaration */:
+                    case 236 /* ExportDeclaration */:
+                    case 235 /* ExportAssignment */:
+                    case 225 /* ModuleDeclaration */:
+                    case 221 /* ClassDeclaration */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                        return true;
+                }
+            }
+            return false;
+        }
+        function isReusableEnumMember(node) {
+            return node.kind === 255 /* EnumMember */;
+        }
+        function isReusableTypeMember(node) {
+            if (node) {
+                switch (node.kind) {
+                    case 152 /* ConstructSignature */:
+                    case 146 /* MethodSignature */:
+                    case 153 /* IndexSignature */:
+                    case 144 /* PropertySignature */:
+                    case 151 /* CallSignature */:
+                        return true;
+                }
+            }
+            return false;
+        }
+        function isReusableVariableDeclaration(node) {
+            if (node.kind !== 218 /* VariableDeclaration */) {
+                return false;
+            }
+            // Very subtle incremental parsing bug.  Consider the following code:
+            //
+            //      let v = new List < A, B
+            //
+            // This is actually legal code.  It's a list of variable declarators "v = new List<A"
+            // on one side and "B" on the other. If you then change that to:
+            //
+            //      let v = new List < A, B >()
+            //
+            // then we have a problem.  "v = new List<A" doesn't intersect the change range, so we
+            // start reparsing at "B" and we completely fail to handle this properly.
+            //
+            // In order to prevent this, we do not allow a variable declarator to be reused if it
+            // has an initializer.
+            var variableDeclarator = node;
+            return variableDeclarator.initializer === undefined;
+        }
+        function isReusableParameter(node) {
+            if (node.kind !== 142 /* Parameter */) {
+                return false;
+            }
+            // See the comment in isReusableVariableDeclaration for why we do this.
+            var parameter = node;
+            return parameter.initializer === undefined;
+        }
+        // Returns true if we should abort parsing.
+        function abortParsingListOrMoveToNextToken(kind) {
+            parseErrorAtCurrentToken(parsingContextErrors(kind));
+            if (isInSomeParsingContext()) {
+                return true;
+            }
+            nextToken();
+            return false;
+        }
+        function parsingContextErrors(context) {
+            switch (context) {
+                case 0 /* SourceElements */: return ts.Diagnostics.Declaration_or_statement_expected;
+                case 1 /* BlockStatements */: return ts.Diagnostics.Declaration_or_statement_expected;
+                case 2 /* SwitchClauses */: return ts.Diagnostics.case_or_default_expected;
+                case 3 /* SwitchClauseStatements */: return ts.Diagnostics.Statement_expected;
+                case 4 /* TypeMembers */: return ts.Diagnostics.Property_or_signature_expected;
+                case 5 /* ClassMembers */: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected;
+                case 6 /* EnumMembers */: return ts.Diagnostics.Enum_member_expected;
+                case 7 /* HeritageClauseElement */: return ts.Diagnostics.Expression_expected;
+                case 8 /* VariableDeclarations */: return ts.Diagnostics.Variable_declaration_expected;
+                case 9 /* ObjectBindingElements */: return ts.Diagnostics.Property_destructuring_pattern_expected;
+                case 10 /* ArrayBindingElements */: return ts.Diagnostics.Array_element_destructuring_pattern_expected;
+                case 11 /* ArgumentExpressions */: return ts.Diagnostics.Argument_expression_expected;
+                case 12 /* ObjectLiteralMembers */: return ts.Diagnostics.Property_assignment_expected;
+                case 15 /* ArrayLiteralMembers */: return ts.Diagnostics.Expression_or_comma_expected;
+                case 16 /* Parameters */: return ts.Diagnostics.Parameter_declaration_expected;
+                case 17 /* TypeParameters */: return ts.Diagnostics.Type_parameter_declaration_expected;
+                case 18 /* TypeArguments */: return ts.Diagnostics.Type_argument_expected;
+                case 19 /* TupleElementTypes */: return ts.Diagnostics.Type_expected;
+                case 20 /* HeritageClauses */: return ts.Diagnostics.Unexpected_token_expected;
+                case 21 /* ImportOrExportSpecifiers */: return ts.Diagnostics.Identifier_expected;
+                case 13 /* JsxAttributes */: return ts.Diagnostics.Identifier_expected;
+                case 14 /* JsxChildren */: return ts.Diagnostics.Identifier_expected;
+                case 22 /* JSDocFunctionParameters */: return ts.Diagnostics.Parameter_declaration_expected;
+                case 23 /* JSDocTypeArguments */: return ts.Diagnostics.Type_argument_expected;
+                case 25 /* JSDocTupleTypes */: return ts.Diagnostics.Type_expected;
+                case 24 /* JSDocRecordMembers */: return ts.Diagnostics.Property_assignment_expected;
+            }
+        }
+        ;
+        // Parses a comma-delimited list of elements
+        function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
+            var saveParsingContext = parsingContext;
+            parsingContext |= 1 << kind;
+            var result = [];
+            result.pos = getNodePos();
+            var commaStart = -1; // Meaning the previous token was not a comma
+            while (true) {
+                if (isListElement(kind, /*inErrorRecovery*/ false)) {
+                    result.push(parseListElement(kind, parseElement));
+                    commaStart = scanner.getTokenPos();
+                    if (parseOptional(24 /* CommaToken */)) {
+                        continue;
+                    }
+                    commaStart = -1; // Back to the state where the last token was not a comma
+                    if (isListTerminator(kind)) {
+                        break;
+                    }
+                    // We didn't get a comma, and the list wasn't terminated, explicitly parse
+                    // out a comma so we give a good error message.
+                    parseExpected(24 /* CommaToken */);
+                    // If the token was a semicolon, and the caller allows that, then skip it and
+                    // continue.  This ensures we get back on track and don't result in tons of
+                    // parse errors.  For example, this can happen when people do things like use
+                    // a semicolon to delimit object literal members.   Note: we'll have already
+                    // reported an error when we called parseExpected above.
+                    if (considerSemicolonAsDelimiter && token === 23 /* SemicolonToken */ && !scanner.hasPrecedingLineBreak()) {
+                        nextToken();
+                    }
+                    continue;
+                }
+                if (isListTerminator(kind)) {
+                    break;
+                }
+                if (abortParsingListOrMoveToNextToken(kind)) {
+                    break;
+                }
+            }
+            // Recording the trailing comma is deliberately done after the previous
+            // loop, and not just if we see a list terminator. This is because the list
+            // may have ended incorrectly, but it is still important to know if there
+            // was a trailing comma.
+            // Check if the last token was a comma.
+            if (commaStart >= 0) {
+                // Always preserve a trailing comma by marking it on the NodeArray
+                result.hasTrailingComma = true;
+            }
+            result.end = getNodeEnd();
+            parsingContext = saveParsingContext;
+            return result;
+        }
+        function createMissingList() {
+            var pos = getNodePos();
+            var result = [];
+            result.pos = pos;
+            result.end = pos;
+            return result;
+        }
+        function parseBracketedList(kind, parseElement, open, close) {
+            if (parseExpected(open)) {
+                var result = parseDelimitedList(kind, parseElement);
+                parseExpected(close);
+                return result;
+            }
+            return createMissingList();
+        }
+        // The allowReservedWords parameter controls whether reserved words are permitted after the first dot
+        function parseEntityName(allowReservedWords, diagnosticMessage) {
+            var entity = parseIdentifier(diagnosticMessage);
+            while (parseOptional(21 /* DotToken */)) {
+                var node = createNode(139 /* QualifiedName */, entity.pos); // !!!
+                node.left = entity;
+                node.right = parseRightSideOfDot(allowReservedWords);
+                entity = finishNode(node);
+            }
+            return entity;
+        }
+        function parseRightSideOfDot(allowIdentifierNames) {
+            // Technically a keyword is valid here as all identifiers and keywords are identifier names.
+            // However, often we'll encounter this in error situations when the identifier or keyword
+            // is actually starting another valid construct.
+            //
+            // So, we check for the following specific case:
+            //
+            //      name.
+            //      identifierOrKeyword identifierNameOrKeyword
+            //
+            // Note: the newlines are important here.  For example, if that above code
+            // were rewritten into:
+            //
+            //      name.identifierOrKeyword
+            //      identifierNameOrKeyword
+            //
+            // Then we would consider it valid.  That's because ASI would take effect and
+            // the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword".
+            // In the first case though, ASI will not take effect because there is not a
+            // line terminator after the identifier or keyword.
+            if (scanner.hasPrecedingLineBreak() && ts.tokenIsIdentifierOrKeyword(token)) {
+                var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+                if (matchesPattern) {
+                    // Report that we need an identifier.  However, report it right after the dot,
+                    // and not on the next token.  This is because the next token might actually
+                    // be an identifier and the error would be quite confusing.
+                    return createMissingNode(69 /* Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Identifier_expected);
+                }
+            }
+            return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
+        }
+        function parseTemplateExpression() {
+            var template = createNode(189 /* TemplateExpression */);
+            template.head = parseTemplateLiteralFragment();
+            ts.Debug.assert(template.head.kind === 12 /* TemplateHead */, "Template head has wrong token kind");
+            var templateSpans = [];
+            templateSpans.pos = getNodePos();
+            do {
+                templateSpans.push(parseTemplateSpan());
+            } while (ts.lastOrUndefined(templateSpans).literal.kind === 13 /* TemplateMiddle */);
+            templateSpans.end = getNodeEnd();
+            template.templateSpans = templateSpans;
+            return finishNode(template);
+        }
+        function parseTemplateSpan() {
+            var span = createNode(197 /* TemplateSpan */);
+            span.expression = allowInAnd(parseExpression);
+            var literal;
+            if (token === 16 /* CloseBraceToken */) {
+                reScanTemplateToken();
+                literal = parseTemplateLiteralFragment();
+            }
+            else {
+                literal = parseExpectedToken(14 /* TemplateTail */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(16 /* CloseBraceToken */));
+            }
+            span.literal = literal;
+            return finishNode(span);
+        }
+        function parseStringLiteralTypeNode() {
+            return parseLiteralLikeNode(166 /* StringLiteralType */, /*internName*/ true);
+        }
+        function parseLiteralNode(internName) {
+            return parseLiteralLikeNode(token, internName);
+        }
+        function parseTemplateLiteralFragment() {
+            return parseLiteralLikeNode(token, /*internName*/ false);
+        }
+        function parseLiteralLikeNode(kind, internName) {
+            var node = createNode(kind);
+            var text = scanner.getTokenValue();
+            node.text = internName ? internIdentifier(text) : text;
+            if (scanner.hasExtendedUnicodeEscape()) {
+                node.hasExtendedUnicodeEscape = true;
+            }
+            if (scanner.isUnterminated()) {
+                node.isUnterminated = true;
+            }
+            var tokenPos = scanner.getTokenPos();
+            nextToken();
+            finishNode(node);
+            // Octal literals are not allowed in strict mode or ES5
+            // Note that theoretically the following condition would hold true literals like 009,
+            // which is not octal.But because of how the scanner separates the tokens, we would
+            // never get a token like this. Instead, we would get 00 and 9 as two separate tokens.
+            // We also do not need to check for negatives because any prefix operator would be part of a
+            // parent unary expression.
+            if (node.kind === 8 /* NumericLiteral */
+                && sourceText.charCodeAt(tokenPos) === 48 /* _0 */
+                && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
+                node.isOctalLiteral = true;
+            }
+            return node;
+        }
+        // TYPES
+        function parseTypeReference() {
+            var typeName = parseEntityName(/*allowReservedWords*/ false, ts.Diagnostics.Type_expected);
+            var node = createNode(155 /* TypeReference */, typeName.pos);
+            node.typeName = typeName;
+            if (!scanner.hasPrecedingLineBreak() && token === 25 /* LessThanToken */) {
+                node.typeArguments = parseBracketedList(18 /* TypeArguments */, parseType, 25 /* LessThanToken */, 27 /* GreaterThanToken */);
+            }
+            return finishNode(node);
+        }
+        function parseThisTypePredicate(lhs) {
+            nextToken();
+            var node = createNode(154 /* TypePredicate */, lhs.pos);
+            node.parameterName = lhs;
+            node.type = parseType();
+            return finishNode(node);
+        }
+        function parseThisTypeNode() {
+            var node = createNode(165 /* ThisType */);
+            nextToken();
+            return finishNode(node);
+        }
+        function parseTypeQuery() {
+            var node = createNode(158 /* TypeQuery */);
+            parseExpected(101 /* TypeOfKeyword */);
+            node.exprName = parseEntityName(/*allowReservedWords*/ true);
+            return finishNode(node);
+        }
+        function parseTypeParameter() {
+            var node = createNode(141 /* TypeParameter */);
+            node.name = parseIdentifier();
+            if (parseOptional(83 /* ExtendsKeyword */)) {
+                // It's not uncommon for people to write improper constraints to a generic.  If the
+                // user writes a constraint that is an expression and not an actual type, then parse
+                // it out as an expression (so we can recover well), but report that a type is needed
+                // instead.
+                if (isStartOfType() || !isStartOfExpression()) {
+                    node.constraint = parseType();
+                }
+                else {
+                    // It was not a type, and it looked like an expression.  Parse out an expression
+                    // here so we recover well.  Note: it is important that we call parseUnaryExpression
+                    // and not parseExpression here.  If the user has:
+                    //
+                    //      <T extends "">
+                    //
+                    // We do *not* want to consume the  >  as we're consuming the expression for "".
+                    node.expression = parseUnaryExpressionOrHigher();
+                }
+            }
+            return finishNode(node);
+        }
+        function parseTypeParameters() {
+            if (token === 25 /* LessThanToken */) {
+                return parseBracketedList(17 /* TypeParameters */, parseTypeParameter, 25 /* LessThanToken */, 27 /* GreaterThanToken */);
+            }
+        }
+        function parseParameterType() {
+            if (parseOptional(54 /* ColonToken */)) {
+                return parseType();
+            }
+            return undefined;
+        }
+        function isStartOfParameter() {
+            return token === 22 /* DotDotDotToken */ || isIdentifierOrPattern() || ts.isModifierKind(token) || token === 55 /* AtToken */ || token === 97 /* ThisKeyword */;
+        }
+        function setModifiers(node, modifiers) {
+            if (modifiers) {
+                node.flags |= modifiers.flags;
+                node.modifiers = modifiers;
+            }
+        }
+        function parseParameter() {
+            var node = createNode(142 /* Parameter */);
+            if (token === 97 /* ThisKeyword */) {
+                node.name = createIdentifier(/*isIdentifier*/ true, undefined);
+                node.type = parseParameterType();
+                return finishNode(node);
+            }
+            node.decorators = parseDecorators();
+            setModifiers(node, parseModifiers());
+            node.dotDotDotToken = parseOptionalToken(22 /* DotDotDotToken */);
+            // FormalParameter [Yield,Await]:
+            //      BindingElement[?Yield,?Await]
+            node.name = parseIdentifierOrPattern();
+            if (ts.getFullWidth(node.name) === 0 && node.flags === 0 && ts.isModifierKind(token)) {
+                // in cases like
+                // 'use strict'
+                // function foo(static)
+                // isParameter('static') === true, because of isModifier('static')
+                // however 'static' is not a legal identifier in a strict mode.
+                // so result of this function will be ParameterDeclaration (flags = 0, name = missing, type = undefined, initializer = undefined)
+                // and current token will not change => parsing of the enclosing parameter list will last till the end of time (or OOM)
+                // to avoid this we'll advance cursor to the next token.
+                nextToken();
+            }
+            node.questionToken = parseOptionalToken(53 /* QuestionToken */);
+            node.type = parseParameterType();
+            node.initializer = parseBindingElementInitializer(/*inParameter*/ true);
+            // Do not check for initializers in an ambient context for parameters. This is not
+            // a grammar error because the grammar allows arbitrary call signatures in
+            // an ambient context.
+            // It is actually not necessary for this to be an error at all. The reason is that
+            // function/constructor implementations are syntactically disallowed in ambient
+            // contexts. In addition, parameter initializers are semantically disallowed in
+            // overload signatures. So parameter initializers are transitively disallowed in
+            // ambient contexts.
+            return addJSDocComment(finishNode(node));
+        }
+        function parseBindingElementInitializer(inParameter) {
+            return inParameter ? parseParameterInitializer() : parseNonParameterInitializer();
+        }
+        function parseParameterInitializer() {
+            return parseInitializer(/*inParameter*/ true);
+        }
+        function fillSignature(returnToken, yieldContext, awaitContext, requireCompleteParameterList, signature) {
+            var returnTokenRequired = returnToken === 34 /* EqualsGreaterThanToken */;
+            signature.typeParameters = parseTypeParameters();
+            signature.parameters = parseParameterList(yieldContext, awaitContext, requireCompleteParameterList);
+            if (returnTokenRequired) {
+                parseExpected(returnToken);
+                signature.type = parseTypeOrTypePredicate();
+            }
+            else if (parseOptional(returnToken)) {
+                signature.type = parseTypeOrTypePredicate();
+            }
+        }
+        function parseParameterList(yieldContext, awaitContext, requireCompleteParameterList) {
+            // FormalParameters [Yield,Await]: (modified)
+            //      [empty]
+            //      FormalParameterList[?Yield,Await]
+            //
+            // FormalParameter[Yield,Await]: (modified)
+            //      BindingElement[?Yield,Await]
+            //
+            // BindingElement [Yield,Await]: (modified)
+            //      SingleNameBinding[?Yield,?Await]
+            //      BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
+            //
+            // SingleNameBinding [Yield,Await]:
+            //      BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
+            if (parseExpected(17 /* OpenParenToken */)) {
+                var savedYieldContext = inYieldContext();
+                var savedAwaitContext = inAwaitContext();
+                setYieldContext(yieldContext);
+                setAwaitContext(awaitContext);
+                var result = parseDelimitedList(16 /* Parameters */, parseParameter);
+                setYieldContext(savedYieldContext);
+                setAwaitContext(savedAwaitContext);
+                if (!parseExpected(18 /* CloseParenToken */) && requireCompleteParameterList) {
+                    // Caller insisted that we had to end with a )   We didn't.  So just return
+                    // undefined here.
+                    return undefined;
+                }
+                return result;
+            }
+            // We didn't even have an open paren.  If the caller requires a complete parameter list,
+            // we definitely can't provide that.  However, if they're ok with an incomplete one,
+            // then just return an empty set of parameters.
+            return requireCompleteParameterList ? undefined : createMissingList();
+        }
+        function parseTypeMemberSemicolon() {
+            // We allow type members to be separated by commas or (possibly ASI) semicolons.
+            // First check if it was a comma.  If so, we're done with the member.
+            if (parseOptional(24 /* CommaToken */)) {
+                return;
+            }
+            // Didn't have a comma.  We must have a (possible ASI) semicolon.
+            parseSemicolon();
+        }
+        function parseSignatureMember(kind) {
+            var node = createNode(kind);
+            if (kind === 152 /* ConstructSignature */) {
+                parseExpected(92 /* NewKeyword */);
+            }
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
+            parseTypeMemberSemicolon();
+            return finishNode(node);
+        }
+        function isIndexSignature() {
+            if (token !== 19 /* OpenBracketToken */) {
+                return false;
+            }
+            return lookAhead(isUnambiguouslyIndexSignature);
+        }
+        function isUnambiguouslyIndexSignature() {
+            // The only allowed sequence is:
+            //
+            //   [id:
+            //
+            // However, for error recovery, we also check the following cases:
+            //
+            //   [...
+            //   [id,
+            //   [id?,
+            //   [id?:
+            //   [id?]
+            //   [public id
+            //   [private id
+            //   [protected id
+            //   []
+            //
+            nextToken();
+            if (token === 22 /* DotDotDotToken */ || token === 20 /* CloseBracketToken */) {
+                return true;
+            }
+            if (ts.isModifierKind(token)) {
+                nextToken();
+                if (isIdentifier()) {
+                    return true;
+                }
+            }
+            else if (!isIdentifier()) {
+                return false;
+            }
+            else {
+                // Skip the identifier
+                nextToken();
+            }
+            // A colon signifies a well formed indexer
+            // A comma should be a badly formed indexer because comma expressions are not allowed
+            // in computed properties.
+            if (token === 54 /* ColonToken */ || token === 24 /* CommaToken */) {
+                return true;
+            }
+            // Question mark could be an indexer with an optional property,
+            // or it could be a conditional expression in a computed property.
+            if (token !== 53 /* QuestionToken */) {
+                return false;
+            }
+            // If any of the following tokens are after the question mark, it cannot
+            // be a conditional expression, so treat it as an indexer.
+            nextToken();
+            return token === 54 /* ColonToken */ || token === 24 /* CommaToken */ || token === 20 /* CloseBracketToken */;
+        }
+        function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(153 /* IndexSignature */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            node.parameters = parseBracketedList(16 /* Parameters */, parseParameter, 19 /* OpenBracketToken */, 20 /* CloseBracketToken */);
+            node.type = parseTypeAnnotation();
+            parseTypeMemberSemicolon();
+            return finishNode(node);
+        }
+        function parsePropertyOrMethodSignature(fullStart, modifiers) {
+            var name = parsePropertyName();
+            var questionToken = parseOptionalToken(53 /* QuestionToken */);
+            if (token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
+                var method = createNode(146 /* MethodSignature */, fullStart);
+                setModifiers(method, modifiers);
+                method.name = name;
+                method.questionToken = questionToken;
+                // Method signatures don't exist in expression contexts.  So they have neither
+                // [Yield] nor [Await]
+                fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, method);
+                parseTypeMemberSemicolon();
+                return finishNode(method);
+            }
+            else {
+                var property = createNode(144 /* PropertySignature */, fullStart);
+                setModifiers(property, modifiers);
+                property.name = name;
+                property.questionToken = questionToken;
+                property.type = parseTypeAnnotation();
+                if (token === 56 /* EqualsToken */) {
+                    // Although type literal properties cannot not have initializers, we attempt
+                    // to parse an initializer so we can report in the checker that an interface
+                    // property or type literal property cannot have an initializer.
+                    property.initializer = parseNonParameterInitializer();
+                }
+                parseTypeMemberSemicolon();
+                return finishNode(property);
+            }
+        }
+        function isTypeMemberStart() {
+            var idToken;
+            // Return true if we have the start of a signature member
+            if (token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
+                return true;
+            }
+            // Eat up all modifiers, but hold on to the last one in case it is actually an identifier
+            while (ts.isModifierKind(token)) {
+                idToken = token;
+                nextToken();
+            }
+            // Index signatures and computed property names are type members
+            if (token === 19 /* OpenBracketToken */) {
+                return true;
+            }
+            // Try to get the first property-like token following all modifiers
+            if (isLiteralPropertyName()) {
+                idToken = token;
+                nextToken();
+            }
+            // If we were able to get any potential identifier, check that it is
+            // the start of a member declaration
+            if (idToken) {
+                return token === 17 /* OpenParenToken */ ||
+                    token === 25 /* LessThanToken */ ||
+                    token === 53 /* QuestionToken */ ||
+                    token === 54 /* ColonToken */ ||
+                    canParseSemicolon();
+            }
+            return false;
+        }
+        function parseTypeMember() {
+            if (token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
+                return parseSignatureMember(151 /* CallSignature */);
+            }
+            if (token === 92 /* NewKeyword */ && lookAhead(isStartOfConstructSignature)) {
+                return parseSignatureMember(152 /* ConstructSignature */);
+            }
+            var fullStart = getNodePos();
+            var modifiers = parseModifiers();
+            if (isIndexSignature()) {
+                return parseIndexSignatureDeclaration(fullStart, /*decorators*/ undefined, modifiers);
+            }
+            return parsePropertyOrMethodSignature(fullStart, modifiers);
+        }
+        function isStartOfConstructSignature() {
+            nextToken();
+            return token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */;
+        }
+        function parseTypeLiteral() {
+            var node = createNode(159 /* TypeLiteral */);
+            node.members = parseObjectTypeMembers();
+            return finishNode(node);
+        }
+        function parseObjectTypeMembers() {
+            var members;
+            if (parseExpected(15 /* OpenBraceToken */)) {
+                members = parseList(4 /* TypeMembers */, parseTypeMember);
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                members = createMissingList();
+            }
+            return members;
+        }
+        function parseTupleType() {
+            var node = createNode(161 /* TupleType */);
+            node.elementTypes = parseBracketedList(19 /* TupleElementTypes */, parseType, 19 /* OpenBracketToken */, 20 /* CloseBracketToken */);
+            return finishNode(node);
+        }
+        function parseParenthesizedType() {
+            var node = createNode(164 /* ParenthesizedType */);
+            parseExpected(17 /* OpenParenToken */);
+            node.type = parseType();
+            parseExpected(18 /* CloseParenToken */);
+            return finishNode(node);
+        }
+        function parseFunctionOrConstructorType(kind) {
+            var node = createNode(kind);
+            if (kind === 157 /* ConstructorType */) {
+                parseExpected(92 /* NewKeyword */);
+            }
+            fillSignature(34 /* EqualsGreaterThanToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
+            return finishNode(node);
+        }
+        function parseKeywordAndNoDot() {
+            var node = parseTokenNode();
+            return token === 21 /* DotToken */ ? undefined : node;
+        }
+        function parseNonArrayType() {
+            switch (token) {
+                case 117 /* AnyKeyword */:
+                case 132 /* StringKeyword */:
+                case 130 /* NumberKeyword */:
+                case 120 /* BooleanKeyword */:
+                case 133 /* SymbolKeyword */:
+                case 135 /* UndefinedKeyword */:
+                case 127 /* NeverKeyword */:
+                    // If these are followed by a dot, then parse these out as a dotted type reference instead.
+                    var node = tryParse(parseKeywordAndNoDot);
+                    return node || parseTypeReference();
+                case 9 /* StringLiteral */:
+                    return parseStringLiteralTypeNode();
+                case 103 /* VoidKeyword */:
+                case 93 /* NullKeyword */:
+                    return parseTokenNode();
+                case 97 /* ThisKeyword */: {
+                    var thisKeyword = parseThisTypeNode();
+                    if (token === 124 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) {
+                        return parseThisTypePredicate(thisKeyword);
+                    }
+                    else {
+                        return thisKeyword;
+                    }
+                }
+                case 101 /* TypeOfKeyword */:
+                    return parseTypeQuery();
+                case 15 /* OpenBraceToken */:
+                    return parseTypeLiteral();
+                case 19 /* OpenBracketToken */:
+                    return parseTupleType();
+                case 17 /* OpenParenToken */:
+                    return parseParenthesizedType();
+                default:
+                    return parseTypeReference();
+            }
+        }
+        function isStartOfType() {
+            switch (token) {
+                case 117 /* AnyKeyword */:
+                case 132 /* StringKeyword */:
+                case 130 /* NumberKeyword */:
+                case 120 /* BooleanKeyword */:
+                case 133 /* SymbolKeyword */:
+                case 103 /* VoidKeyword */:
+                case 135 /* UndefinedKeyword */:
+                case 93 /* NullKeyword */:
+                case 97 /* ThisKeyword */:
+                case 101 /* TypeOfKeyword */:
+                case 127 /* NeverKeyword */:
+                case 15 /* OpenBraceToken */:
+                case 19 /* OpenBracketToken */:
+                case 25 /* LessThanToken */:
+                case 92 /* NewKeyword */:
+                case 9 /* StringLiteral */:
+                    return true;
+                case 17 /* OpenParenToken */:
+                    // Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier,
+                    // or something that starts a type. We don't want to consider things like '(1)' a type.
+                    return lookAhead(isStartOfParenthesizedOrFunctionType);
+                default:
+                    return isIdentifier();
+            }
+        }
+        function isStartOfParenthesizedOrFunctionType() {
+            nextToken();
+            return token === 18 /* CloseParenToken */ || isStartOfParameter() || isStartOfType();
+        }
+        function parseArrayTypeOrHigher() {
+            var type = parseNonArrayType();
+            while (!scanner.hasPrecedingLineBreak() && parseOptional(19 /* OpenBracketToken */)) {
+                parseExpected(20 /* CloseBracketToken */);
+                var node = createNode(160 /* ArrayType */, type.pos);
+                node.elementType = type;
+                type = finishNode(node);
+            }
+            return type;
+        }
+        function parseUnionOrIntersectionType(kind, parseConstituentType, operator) {
+            var type = parseConstituentType();
+            if (token === operator) {
+                var types = [type];
+                types.pos = type.pos;
+                while (parseOptional(operator)) {
+                    types.push(parseConstituentType());
+                }
+                types.end = getNodeEnd();
+                var node = createNode(kind, type.pos);
+                node.types = types;
+                type = finishNode(node);
+            }
+            return type;
+        }
+        function parseIntersectionTypeOrHigher() {
+            return parseUnionOrIntersectionType(163 /* IntersectionType */, parseArrayTypeOrHigher, 46 /* AmpersandToken */);
+        }
+        function parseUnionTypeOrHigher() {
+            return parseUnionOrIntersectionType(162 /* UnionType */, parseIntersectionTypeOrHigher, 47 /* BarToken */);
+        }
+        function isStartOfFunctionType() {
+            if (token === 25 /* LessThanToken */) {
+                return true;
+            }
+            return token === 17 /* OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType);
+        }
+        function skipParameterStart() {
+            if (ts.isModifierKind(token)) {
+                // Skip modifiers
+                parseModifiers();
+            }
+            if (isIdentifier() || token === 97 /* ThisKeyword */) {
+                nextToken();
+                return true;
+            }
+            if (token === 19 /* OpenBracketToken */ || token === 15 /* OpenBraceToken */) {
+                // Return true if we can parse an array or object binding pattern with no errors
+                var previousErrorCount = parseDiagnostics.length;
+                parseIdentifierOrPattern();
+                return previousErrorCount === parseDiagnostics.length;
+            }
+            return false;
+        }
+        function isUnambiguouslyStartOfFunctionType() {
+            nextToken();
+            if (token === 18 /* CloseParenToken */ || token === 22 /* DotDotDotToken */) {
+                // ( )
+                // ( ...
+                return true;
+            }
+            if (skipParameterStart()) {
+                // We successfully skipped modifiers (if any) and an identifier or binding pattern,
+                // now see if we have something that indicates a parameter declaration
+                if (token === 54 /* ColonToken */ || token === 24 /* CommaToken */ ||
+                    token === 53 /* QuestionToken */ || token === 56 /* EqualsToken */) {
+                    // ( xxx :
+                    // ( xxx ,
+                    // ( xxx ?
+                    // ( xxx =
+                    return true;
+                }
+                if (token === 18 /* CloseParenToken */) {
+                    nextToken();
+                    if (token === 34 /* EqualsGreaterThanToken */) {
+                        // ( xxx ) =>
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function parseTypeOrTypePredicate() {
+            var typePredicateVariable = isIdentifier() && tryParse(parseTypePredicatePrefix);
+            var type = parseType();
+            if (typePredicateVariable) {
+                var node = createNode(154 /* TypePredicate */, typePredicateVariable.pos);
+                node.parameterName = typePredicateVariable;
+                node.type = type;
+                return finishNode(node);
+            }
+            else {
+                return type;
+            }
+        }
+        function parseTypePredicatePrefix() {
+            var id = parseIdentifier();
+            if (token === 124 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) {
+                nextToken();
+                return id;
+            }
+        }
+        function parseType() {
+            // The rules about 'yield' only apply to actual code/expression contexts.  They don't
+            // apply to 'type' contexts.  So we disable these parameters here before moving on.
+            return doOutsideOfContext(41943040 /* TypeExcludesFlags */, parseTypeWorker);
+        }
+        function parseTypeWorker() {
+            if (isStartOfFunctionType()) {
+                return parseFunctionOrConstructorType(156 /* FunctionType */);
+            }
+            if (token === 92 /* NewKeyword */) {
+                return parseFunctionOrConstructorType(157 /* ConstructorType */);
+            }
+            return parseUnionTypeOrHigher();
+        }
+        function parseTypeAnnotation() {
+            return parseOptional(54 /* ColonToken */) ? parseType() : undefined;
+        }
+        // EXPRESSIONS
+        function isStartOfLeftHandSideExpression() {
+            switch (token) {
+                case 97 /* ThisKeyword */:
+                case 95 /* SuperKeyword */:
+                case 93 /* NullKeyword */:
+                case 99 /* TrueKeyword */:
+                case 84 /* FalseKeyword */:
+                case 8 /* NumericLiteral */:
+                case 9 /* StringLiteral */:
+                case 11 /* NoSubstitutionTemplateLiteral */:
+                case 12 /* TemplateHead */:
+                case 17 /* OpenParenToken */:
+                case 19 /* OpenBracketToken */:
+                case 15 /* OpenBraceToken */:
+                case 87 /* FunctionKeyword */:
+                case 73 /* ClassKeyword */:
+                case 92 /* NewKeyword */:
+                case 39 /* SlashToken */:
+                case 61 /* SlashEqualsToken */:
+                case 69 /* Identifier */:
+                    return true;
+                default:
+                    return isIdentifier();
+            }
+        }
+        function isStartOfExpression() {
+            if (isStartOfLeftHandSideExpression()) {
+                return true;
+            }
+            switch (token) {
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 50 /* TildeToken */:
+                case 49 /* ExclamationToken */:
+                case 78 /* DeleteKeyword */:
+                case 101 /* TypeOfKeyword */:
+                case 103 /* VoidKeyword */:
+                case 41 /* PlusPlusToken */:
+                case 42 /* MinusMinusToken */:
+                case 25 /* LessThanToken */:
+                case 119 /* AwaitKeyword */:
+                case 114 /* YieldKeyword */:
+                    // Yield/await always starts an expression.  Either it is an identifier (in which case
+                    // it is definitely an expression).  Or it's a keyword (either because we're in
+                    // a generator or async function, or in strict mode (or both)) and it started a yield or await expression.
+                    return true;
+                default:
+                    // Error tolerance.  If we see the start of some binary operator, we consider
+                    // that the start of an expression.  That way we'll parse out a missing identifier,
+                    // give a good message about an identifier being missing, and then consume the
+                    // rest of the binary expression.
+                    if (isBinaryOperator()) {
+                        return true;
+                    }
+                    return isIdentifier();
+            }
+        }
+        function isStartOfExpressionStatement() {
+            // As per the grammar, none of '{' or 'function' or 'class' can start an expression statement.
+            return token !== 15 /* OpenBraceToken */ &&
+                token !== 87 /* FunctionKeyword */ &&
+                token !== 73 /* ClassKeyword */ &&
+                token !== 55 /* AtToken */ &&
+                isStartOfExpression();
+        }
+        function parseExpression() {
+            // Expression[in]:
+            //      AssignmentExpression[in]
+            //      Expression[in] , AssignmentExpression[in]
+            // clear the decorator context when parsing Expression, as it should be unambiguous when parsing a decorator
+            var saveDecoratorContext = inDecoratorContext();
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ false);
+            }
+            var expr = parseAssignmentExpressionOrHigher();
+            var operatorToken;
+            while ((operatorToken = parseOptionalToken(24 /* CommaToken */))) {
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher());
+            }
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ true);
+            }
+            return expr;
+        }
+        function parseInitializer(inParameter) {
+            if (token !== 56 /* EqualsToken */) {
+                // It's not uncommon during typing for the user to miss writing the '=' token.  Check if
+                // there is no newline after the last token and if we're on an expression.  If so, parse
+                // this as an equals-value clause with a missing equals.
+                // NOTE: There are two places where we allow equals-value clauses.  The first is in a
+                // variable declarator.  The second is with a parameter.  For variable declarators
+                // it's more likely that a { would be a allowed (as an object literal).  While this
+                // is also allowed for parameters, the risk is that we consume the { as an object
+                // literal when it really will be for the block following the parameter.
+                if (scanner.hasPrecedingLineBreak() || (inParameter && token === 15 /* OpenBraceToken */) || !isStartOfExpression()) {
+                    // preceding line break, open brace in a parameter (likely a function body) or current token is not an expression -
+                    // do not try to parse initializer
+                    return undefined;
+                }
+            }
+            // Initializer[In, Yield] :
+            //     = AssignmentExpression[?In, ?Yield]
+            parseExpected(56 /* EqualsToken */);
+            return parseAssignmentExpressionOrHigher();
+        }
+        function parseAssignmentExpressionOrHigher() {
+            //  AssignmentExpression[in,yield]:
+            //      1) ConditionalExpression[?in,?yield]
+            //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
+            //      3) LeftHandSideExpression AssignmentOperator AssignmentExpression[?in,?yield]
+            //      4) ArrowFunctionExpression[?in,?yield]
+            //      5) AsyncArrowFunctionExpression[in,yield,await]
+            //      6) [+Yield] YieldExpression[?In]
+            //
+            // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
+            // (i.e. they're both BinaryExpressions with an assignment operator in it).
+            // First, do the simple check if we have a YieldExpression (production '5').
+            if (isYieldExpression()) {
+                return parseYieldExpression();
+            }
+            // Then, check if we have an arrow function (production '4' and '5') that starts with a parenthesized
+            // parameter list or is an async arrow function.
+            // AsyncArrowFunctionExpression:
+            //      1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator here]=>AsyncConciseBody[?In]
+            //      2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator here]=>AsyncConciseBody[?In]
+            // Production (1) of AsyncArrowFunctionExpression is parsed in "tryParseAsyncSimpleArrowFunctionExpression".
+            // And production (2) is parsed in "tryParseParenthesizedArrowFunctionExpression".
+            //
+            // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
+            // not a  LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
+            // with AssignmentExpression if we see one.
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+            if (arrowExpression) {
+                return arrowExpression;
+            }
+            // Now try to see if we're in production '1', '2' or '3'.  A conditional expression can
+            // start with a LogicalOrExpression, while the assignment productions can only start with
+            // LeftHandSideExpressions.
+            //
+            // So, first, we try to just parse out a BinaryExpression.  If we get something that is a
+            // LeftHandSide or higher, then we can try to parse out the assignment expression part.
+            // Otherwise, we try to parse out the conditional expression bit.  We want to allow any
+            // binary expression here, so we pass in the 'lowest' precedence here so that it matches
+            // and consumes anything.
+            var expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
+            // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
+            // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
+            // identifier and the current token is an arrow.
+            if (expr.kind === 69 /* Identifier */ && token === 34 /* EqualsGreaterThanToken */) {
+                return parseSimpleArrowFunctionExpression(expr);
+            }
+            // Now see if we might be in cases '2' or '3'.
+            // If the expression was a LHS expression, and we have an assignment operator, then
+            // we're in '2' or '3'. Consume the assignment and return.
+            //
+            // Note: we call reScanGreaterToken so that we get an appropriately merged token
+            // for cases like > > =  becoming >>=
+            if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher());
+            }
+            // It wasn't an assignment or a lambda.  This is a conditional expression:
+            return parseConditionalExpressionRest(expr);
+        }
+        function isYieldExpression() {
+            if (token === 114 /* YieldKeyword */) {
+                // If we have a 'yield' keyword, and this is a context where yield expressions are
+                // allowed, then definitely parse out a yield expression.
+                if (inYieldContext()) {
+                    return true;
+                }
+                // We're in a context where 'yield expr' is not allowed.  However, if we can
+                // definitely tell that the user was trying to parse a 'yield expr' and not
+                // just a normal expr that start with a 'yield' identifier, then parse out
+                // a 'yield expr'.  We can then report an error later that they are only
+                // allowed in generator expressions.
+                //
+                // for example, if we see 'yield(foo)', then we'll have to treat that as an
+                // invocation expression of something called 'yield'.  However, if we have
+                // 'yield foo' then that is not legal as a normal expression, so we can
+                // definitely recognize this as a yield expression.
+                //
+                // for now we just check if the next token is an identifier.  More heuristics
+                // can be added here later as necessary.  We just need to make sure that we
+                // don't accidentally consume something legal.
+                return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine);
+            }
+            return false;
+        }
+        function nextTokenIsIdentifierOnSameLine() {
+            nextToken();
+            return !scanner.hasPrecedingLineBreak() && isIdentifier();
+        }
+        function parseYieldExpression() {
+            var node = createNode(190 /* YieldExpression */);
+            // YieldExpression[In] :
+            //      yield
+            //      yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield]
+            //      yield [no LineTerminator here] * [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield]
+            nextToken();
+            if (!scanner.hasPrecedingLineBreak() &&
+                (token === 37 /* AsteriskToken */ || isStartOfExpression())) {
+                node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
+                node.expression = parseAssignmentExpressionOrHigher();
+                return finishNode(node);
+            }
+            else {
+                // if the next token is not on the same line as yield.  or we don't have an '*' or
+                // the start of an expression, then this is just a simple "yield" expression.
+                return finishNode(node);
+            }
+        }
+        function parseSimpleArrowFunctionExpression(identifier, asyncModifier) {
+            ts.Debug.assert(token === 34 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
+            var node;
+            if (asyncModifier) {
+                node = createNode(180 /* ArrowFunction */, asyncModifier.pos);
+                setModifiers(node, asyncModifier);
+            }
+            else {
+                node = createNode(180 /* ArrowFunction */, identifier.pos);
+            }
+            var parameter = createNode(142 /* Parameter */, identifier.pos);
+            parameter.name = identifier;
+            finishNode(parameter);
+            node.parameters = [parameter];
+            node.parameters.pos = parameter.pos;
+            node.parameters.end = parameter.end;
+            node.equalsGreaterThanToken = parseExpectedToken(34 /* EqualsGreaterThanToken */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, "=>");
+            node.body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
+            return finishNode(node);
+        }
+        function tryParseParenthesizedArrowFunctionExpression() {
+            var triState = isParenthesizedArrowFunctionExpression();
+            if (triState === 0 /* False */) {
+                // It's definitely not a parenthesized arrow function expression.
+                return undefined;
+            }
+            // If we definitely have an arrow function, then we can just parse one, not requiring a
+            // following => or { token. Otherwise, we *might* have an arrow function.  Try to parse
+            // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
+            // expression instead.
+            var arrowFunction = triState === 1 /* True */
+                ? parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity*/ true)
+                : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead);
+            if (!arrowFunction) {
+                // Didn't appear to actually be a parenthesized arrow function.  Just bail out.
+                return undefined;
+            }
+            var isAsync = !!(arrowFunction.flags & 256 /* Async */);
+            // If we have an arrow, then try to parse the body. Even if not, try to parse if we
+            // have an opening brace, just in case we're in an error state.
+            var lastToken = token;
+            arrowFunction.equalsGreaterThanToken = parseExpectedToken(34 /* EqualsGreaterThanToken */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, "=>");
+            arrowFunction.body = (lastToken === 34 /* EqualsGreaterThanToken */ || lastToken === 15 /* OpenBraceToken */)
+                ? parseArrowFunctionExpressionBody(isAsync)
+                : parseIdentifier();
+            return finishNode(arrowFunction);
+        }
+        //  True        -> We definitely expect a parenthesized arrow function here.
+        //  False       -> There *cannot* be a parenthesized arrow function here.
+        //  Unknown     -> There *might* be a parenthesized arrow function here.
+        //                 Speculatively look ahead to be sure, and rollback if not.
+        function isParenthesizedArrowFunctionExpression() {
+            if (token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */ || token === 118 /* AsyncKeyword */) {
+                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+            }
+            if (token === 34 /* EqualsGreaterThanToken */) {
+                // ERROR RECOVERY TWEAK:
+                // If we see a standalone => try to parse it as an arrow function expression as that's
+                // likely what the user intended to write.
+                return 1 /* True */;
+            }
+            // Definitely not a parenthesized arrow function.
+            return 0 /* False */;
+        }
+        function isParenthesizedArrowFunctionExpressionWorker() {
+            if (token === 118 /* AsyncKeyword */) {
+                nextToken();
+                if (scanner.hasPrecedingLineBreak()) {
+                    return 0 /* False */;
+                }
+                if (token !== 17 /* OpenParenToken */ && token !== 25 /* LessThanToken */) {
+                    return 0 /* False */;
+                }
+            }
+            var first = token;
+            var second = nextToken();
+            if (first === 17 /* OpenParenToken */) {
+                if (second === 18 /* CloseParenToken */) {
+                    // Simple cases: "() =>", "(): ", and  "() {".
+                    // This is an arrow function with no parameters.
+                    // The last one is not actually an arrow function,
+                    // but this is probably what the user intended.
+                    var third = nextToken();
+                    switch (third) {
+                        case 34 /* EqualsGreaterThanToken */:
+                        case 54 /* ColonToken */:
+                        case 15 /* OpenBraceToken */:
+                            return 1 /* True */;
+                        default:
+                            return 0 /* False */;
+                    }
+                }
+                // If encounter "([" or "({", this could be the start of a binding pattern.
+                // Examples:
+                //      ([ x ]) => { }
+                //      ({ x }) => { }
+                //      ([ x ])
+                //      ({ x })
+                if (second === 19 /* OpenBracketToken */ || second === 15 /* OpenBraceToken */) {
+                    return 2 /* Unknown */;
+                }
+                // Simple case: "(..."
+                // This is an arrow function with a rest parameter.
+                if (second === 22 /* DotDotDotToken */) {
+                    return 1 /* True */;
+                }
+                // If we had "(" followed by something that's not an identifier,
+                // then this definitely doesn't look like a lambda.
+                // Note: we could be a little more lenient and allow
+                // "(public" or "(private". These would not ever actually be allowed,
+                // but we could provide a good error message instead of bailing out.
+                if (!isIdentifier()) {
+                    return 0 /* False */;
+                }
+                // If we have something like "(a:", then we must have a
+                // type-annotated parameter in an arrow function expression.
+                if (nextToken() === 54 /* ColonToken */) {
+                    return 1 /* True */;
+                }
+                // This *could* be a parenthesized arrow function.
+                // Return Unknown to let the caller know.
+                return 2 /* Unknown */;
+            }
+            else {
+                ts.Debug.assert(first === 25 /* LessThanToken */);
+                // If we have "<" not followed by an identifier,
+                // then this definitely is not an arrow function.
+                if (!isIdentifier()) {
+                    return 0 /* False */;
+                }
+                // JSX overrides
+                if (sourceFile.languageVariant === 1 /* JSX */) {
+                    var isArrowFunctionInJsx = lookAhead(function () {
+                        var third = nextToken();
+                        if (third === 83 /* ExtendsKeyword */) {
+                            var fourth = nextToken();
+                            switch (fourth) {
+                                case 56 /* EqualsToken */:
+                                case 27 /* GreaterThanToken */:
+                                    return false;
+                                default:
+                                    return true;
+                            }
+                        }
+                        else if (third === 24 /* CommaToken */) {
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (isArrowFunctionInJsx) {
+                        return 1 /* True */;
+                    }
+                    return 0 /* False */;
+                }
+                // This *could* be a parenthesized arrow function.
+                return 2 /* Unknown */;
+            }
+        }
+        function parsePossibleParenthesizedArrowFunctionExpressionHead() {
+            return parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity*/ false);
+        }
+        function tryParseAsyncSimpleArrowFunctionExpression() {
+            // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
+            if (token === 118 /* AsyncKeyword */) {
+                var isUnParenthesizedAsyncArrowFunction = lookAhead(isUnParenthesizedAsyncArrowFunctionWorker);
+                if (isUnParenthesizedAsyncArrowFunction === 1 /* True */) {
+                    var asyncModifier = parseModifiersForArrowFunction();
+                    var expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
+                    return parseSimpleArrowFunctionExpression(expr, asyncModifier);
+                }
+            }
+            return undefined;
+        }
+        function isUnParenthesizedAsyncArrowFunctionWorker() {
+            // AsyncArrowFunctionExpression:
+            //      1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator here]=>AsyncConciseBody[?In]
+            //      2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator here]=>AsyncConciseBody[?In]
+            if (token === 118 /* AsyncKeyword */) {
+                nextToken();
+                // If the "async" is followed by "=>" token then it is not a begining of an async arrow-function
+                // but instead a simple arrow-function which will be parsed inside "parseAssignmentExpressionOrHigher"
+                if (scanner.hasPrecedingLineBreak() || token === 34 /* EqualsGreaterThanToken */) {
+                    return 0 /* False */;
+                }
+                // Check for un-parenthesized AsyncArrowFunction
+                var expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
+                if (!scanner.hasPrecedingLineBreak() && expr.kind === 69 /* Identifier */ && token === 34 /* EqualsGreaterThanToken */) {
+                    return 1 /* True */;
+                }
+            }
+            return 0 /* False */;
+        }
+        function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
+            var node = createNode(180 /* ArrowFunction */);
+            setModifiers(node, parseModifiersForArrowFunction());
+            var isAsync = !!(node.flags & 256 /* Async */);
+            // Arrow functions are never generators.
+            //
+            // If we're speculatively parsing a signature for a parenthesized arrow function, then
+            // we have to have a complete parameter list.  Otherwise we might see something like
+            // a => (b => c)
+            // And think that "(b =>" was actually a parenthesized arrow function with a missing
+            // close paren.
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ !allowAmbiguity, node);
+            // If we couldn't get parameters, we definitely could not parse out an arrow function.
+            if (!node.parameters) {
+                return undefined;
+            }
+            // Parsing a signature isn't enough.
+            // Parenthesized arrow signatures often look like other valid expressions.
+            // For instance:
+            //  - "(x = 10)" is an assignment expression parsed as a signature with a default parameter value.
+            //  - "(x,y)" is a comma expression parsed as a signature with two parameters.
+            //  - "a ? (b): c" will have "(b):" parsed as a signature with a return type annotation.
+            //
+            // So we need just a bit of lookahead to ensure that it can only be a signature.
+            if (!allowAmbiguity && token !== 34 /* EqualsGreaterThanToken */ && token !== 15 /* OpenBraceToken */) {
+                // Returning undefined here will cause our caller to rewind to where we started from.
+                return undefined;
+            }
+            return node;
+        }
+        function parseArrowFunctionExpressionBody(isAsync) {
+            if (token === 15 /* OpenBraceToken */) {
+                return parseFunctionBlock(/*allowYield*/ false, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false);
+            }
+            if (token !== 23 /* SemicolonToken */ &&
+                token !== 87 /* FunctionKeyword */ &&
+                token !== 73 /* ClassKeyword */ &&
+                isStartOfStatement() &&
+                !isStartOfExpressionStatement()) {
+                // Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations)
+                //
+                // Here we try to recover from a potential error situation in the case where the
+                // user meant to supply a block. For example, if the user wrote:
+                //
+                //  a =>
+                //      let v = 0;
+                //  }
+                //
+                // they may be missing an open brace.  Check to see if that's the case so we can
+                // try to recover better.  If we don't do this, then the next close curly we see may end
+                // up preemptively closing the containing construct.
+                //
+                // Note: even when 'ignoreMissingOpenBrace' is passed as true, parseBody will still error.
+                return parseFunctionBlock(/*allowYield*/ false, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ true);
+            }
+            return isAsync
+                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+        }
+        function parseConditionalExpressionRest(leftOperand) {
+            // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
+            var questionToken = parseOptionalToken(53 /* QuestionToken */);
+            if (!questionToken) {
+                return leftOperand;
+            }
+            // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
+            // we do not that for the 'whenFalse' part.
+            var node = createNode(188 /* ConditionalExpression */, leftOperand.pos);
+            node.condition = leftOperand;
+            node.questionToken = questionToken;
+            node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher);
+            node.colonToken = parseExpectedToken(54 /* ColonToken */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(54 /* ColonToken */));
+            node.whenFalse = parseAssignmentExpressionOrHigher();
+            return finishNode(node);
+        }
+        function parseBinaryExpressionOrHigher(precedence) {
+            var leftOperand = parseUnaryExpressionOrHigher();
+            return parseBinaryExpressionRest(precedence, leftOperand);
+        }
+        function isInOrOfKeyword(t) {
+            return t === 90 /* InKeyword */ || t === 138 /* OfKeyword */;
+        }
+        function parseBinaryExpressionRest(precedence, leftOperand) {
+            while (true) {
+                // We either have a binary operator here, or we're finished.  We call
+                // reScanGreaterToken so that we merge token sequences like > and = into >=
+                reScanGreaterToken();
+                var newPrecedence = getBinaryOperatorPrecedence();
+                // Check the precedence to see if we should "take" this operator
+                // - For left associative operator (all operator but **), consume the operator,
+                //   recursively call the function below, and parse binaryExpression as a rightOperand
+                //   of the caller if the new precedence of the operator is greater then or equal to the current precedence.
+                //   For example:
+                //      a - b - c;
+                //            ^token; leftOperand = b. Return b to the caller as a rightOperand
+                //      a * b - c
+                //            ^token; leftOperand = b. Return b to the caller as a rightOperand
+                //      a - b * c;
+                //            ^token; leftOperand = b. Return b * c to the caller as a rightOperand
+                // - For right associative operator (**), consume the operator, recursively call the function
+                //   and parse binaryExpression as a rightOperand of the caller if the new precedence of
+                //   the operator is strictly grater than the current precedence
+                //   For example:
+                //      a ** b ** c;
+                //             ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand
+                //      a - b ** c;
+                //            ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand
+                //      a ** b - c
+                //             ^token; leftOperand = b. Return b to the caller as a rightOperand
+                var consumeCurrentOperator = token === 38 /* AsteriskAsteriskToken */ ?
+                    newPrecedence >= precedence :
+                    newPrecedence > precedence;
+                if (!consumeCurrentOperator) {
+                    break;
+                }
+                if (token === 90 /* InKeyword */ && inDisallowInContext()) {
+                    break;
+                }
+                if (token === 116 /* AsKeyword */) {
+                    // Make sure we *do* perform ASI for constructs like this:
+                    //    var x = foo
+                    //    as (Bar)
+                    // This should be parsed as an initialized variable, followed
+                    // by a function call to 'as' with the argument 'Bar'
+                    if (scanner.hasPrecedingLineBreak()) {
+                        break;
+                    }
+                    else {
+                        nextToken();
+                        leftOperand = makeAsExpression(leftOperand, parseType());
+                    }
+                }
+                else {
+                    leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence));
+                }
+            }
+            return leftOperand;
+        }
+        function isBinaryOperator() {
+            if (inDisallowInContext() && token === 90 /* InKeyword */) {
+                return false;
+            }
+            return getBinaryOperatorPrecedence() > 0;
+        }
+        function getBinaryOperatorPrecedence() {
+            switch (token) {
+                case 52 /* BarBarToken */:
+                    return 1;
+                case 51 /* AmpersandAmpersandToken */:
+                    return 2;
+                case 47 /* BarToken */:
+                    return 3;
+                case 48 /* CaretToken */:
+                    return 4;
+                case 46 /* AmpersandToken */:
+                    return 5;
+                case 30 /* EqualsEqualsToken */:
+                case 31 /* ExclamationEqualsToken */:
+                case 32 /* EqualsEqualsEqualsToken */:
+                case 33 /* ExclamationEqualsEqualsToken */:
+                    return 6;
+                case 25 /* LessThanToken */:
+                case 27 /* GreaterThanToken */:
+                case 28 /* LessThanEqualsToken */:
+                case 29 /* GreaterThanEqualsToken */:
+                case 91 /* InstanceOfKeyword */:
+                case 90 /* InKeyword */:
+                case 116 /* AsKeyword */:
+                    return 7;
+                case 43 /* LessThanLessThanToken */:
+                case 44 /* GreaterThanGreaterThanToken */:
+                case 45 /* GreaterThanGreaterThanGreaterThanToken */:
+                    return 8;
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                    return 9;
+                case 37 /* AsteriskToken */:
+                case 39 /* SlashToken */:
+                case 40 /* PercentToken */:
+                    return 10;
+                case 38 /* AsteriskAsteriskToken */:
+                    return 11;
+            }
+            // -1 is lower than all other precedences.  Returning it will cause binary expression
+            // parsing to stop.
+            return -1;
+        }
+        function makeBinaryExpression(left, operatorToken, right) {
+            var node = createNode(187 /* BinaryExpression */, left.pos);
+            node.left = left;
+            node.operatorToken = operatorToken;
+            node.right = right;
+            return finishNode(node);
+        }
+        function makeAsExpression(left, right) {
+            var node = createNode(195 /* AsExpression */, left.pos);
+            node.expression = left;
+            node.type = right;
+            return finishNode(node);
+        }
+        function parsePrefixUnaryExpression() {
+            var node = createNode(185 /* PrefixUnaryExpression */);
+            node.operator = token;
+            nextToken();
+            node.operand = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        function parseDeleteExpression() {
+            var node = createNode(181 /* DeleteExpression */);
+            nextToken();
+            node.expression = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        function parseTypeOfExpression() {
+            var node = createNode(182 /* TypeOfExpression */);
+            nextToken();
+            node.expression = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        function parseVoidExpression() {
+            var node = createNode(183 /* VoidExpression */);
+            nextToken();
+            node.expression = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        function isAwaitExpression() {
+            if (token === 119 /* AwaitKeyword */) {
+                if (inAwaitContext()) {
+                    return true;
+                }
+                // here we are using similar heuristics as 'isYieldExpression'
+                return lookAhead(nextTokenIsIdentifierOnSameLine);
+            }
+            return false;
+        }
+        function parseAwaitExpression() {
+            var node = createNode(184 /* AwaitExpression */);
+            nextToken();
+            node.expression = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        /**
+         * Parse ES7 unary expression and await expression
+         *
+         * ES7 UnaryExpression:
+         *      1) SimpleUnaryExpression[?yield]
+         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
+         */
+        function parseUnaryExpressionOrHigher() {
+            if (isAwaitExpression()) {
+                return parseAwaitExpression();
+            }
+            if (isIncrementExpression()) {
+                var incrementExpression = parseIncrementExpression();
+                return token === 38 /* AsteriskAsteriskToken */ ?
+                    parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
+                    incrementExpression;
+            }
+            var unaryOperator = token;
+            var simpleUnaryExpression = parseSimpleUnaryExpression();
+            if (token === 38 /* AsteriskAsteriskToken */) {
+                var start = ts.skipTrivia(sourceText, simpleUnaryExpression.pos);
+                if (simpleUnaryExpression.kind === 177 /* TypeAssertionExpression */) {
+                    parseErrorAtPosition(start, simpleUnaryExpression.end - start, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
+                }
+                else {
+                    parseErrorAtPosition(start, simpleUnaryExpression.end - start, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator));
+                }
+            }
+            return simpleUnaryExpression;
+        }
+        /**
+         * Parse ES7 simple-unary expression or higher:
+         *
+         * ES7 SimpleUnaryExpression:
+         *      1) IncrementExpression[?yield]
+         *      2) delete UnaryExpression[?yield]
+         *      3) void UnaryExpression[?yield]
+         *      4) typeof UnaryExpression[?yield]
+         *      5) + UnaryExpression[?yield]
+         *      6) - UnaryExpression[?yield]
+         *      7) ~ UnaryExpression[?yield]
+         *      8) ! UnaryExpression[?yield]
+         */
+        function parseSimpleUnaryExpression() {
+            switch (token) {
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 50 /* TildeToken */:
+                case 49 /* ExclamationToken */:
+                    return parsePrefixUnaryExpression();
+                case 78 /* DeleteKeyword */:
+                    return parseDeleteExpression();
+                case 101 /* TypeOfKeyword */:
+                    return parseTypeOfExpression();
+                case 103 /* VoidKeyword */:
+                    return parseVoidExpression();
+                case 25 /* LessThanToken */:
+                    // This is modified UnaryExpression grammar in TypeScript
+                    //  UnaryExpression (modified):
+                    //      < type > UnaryExpression
+                    return parseTypeAssertion();
+                default:
+                    return parseIncrementExpression();
+            }
+        }
+        /**
+         * Check if the current token can possibly be an ES7 increment expression.
+         *
+         * ES7 IncrementExpression:
+         *      LeftHandSideExpression[?Yield]
+         *      LeftHandSideExpression[?Yield][no LineTerminator here]++
+         *      LeftHandSideExpression[?Yield][no LineTerminator here]--
+         *      ++LeftHandSideExpression[?Yield]
+         *      --LeftHandSideExpression[?Yield]
+         */
+        function isIncrementExpression() {
+            // This function is called inside parseUnaryExpression to decide
+            // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
+            switch (token) {
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 50 /* TildeToken */:
+                case 49 /* ExclamationToken */:
+                case 78 /* DeleteKeyword */:
+                case 101 /* TypeOfKeyword */:
+                case 103 /* VoidKeyword */:
+                    return false;
+                case 25 /* LessThanToken */:
+                    // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
+                    if (sourceFile.languageVariant !== 1 /* JSX */) {
+                        return false;
+                    }
+                // We are in JSX context and the token is part of JSXElement.
+                // Fall through
+                default:
+                    return true;
+            }
+        }
+        /**
+         * Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
+         *
+         * ES7 IncrementExpression[yield]:
+         *      1) LeftHandSideExpression[?yield]
+         *      2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
+         *      3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
+         *      4) ++LeftHandSideExpression[?yield]
+         *      5) --LeftHandSideExpression[?yield]
+         * In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
+         */
+        function parseIncrementExpression() {
+            if (token === 41 /* PlusPlusToken */ || token === 42 /* MinusMinusToken */) {
+                var node = createNode(185 /* PrefixUnaryExpression */);
+                node.operator = token;
+                nextToken();
+                node.operand = parseLeftHandSideExpressionOrHigher();
+                return finishNode(node);
+            }
+            else if (sourceFile.languageVariant === 1 /* JSX */ && token === 25 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeyword)) {
+                // JSXElement is part of primaryExpression
+                return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true);
+            }
+            var expression = parseLeftHandSideExpressionOrHigher();
+            ts.Debug.assert(ts.isLeftHandSideExpression(expression));
+            if ((token === 41 /* PlusPlusToken */ || token === 42 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) {
+                var node = createNode(186 /* PostfixUnaryExpression */, expression.pos);
+                node.operand = expression;
+                node.operator = token;
+                nextToken();
+                return finishNode(node);
+            }
+            return expression;
+        }
+        function parseLeftHandSideExpressionOrHigher() {
+            // Original Ecma:
+            // LeftHandSideExpression: See 11.2
+            //      NewExpression
+            //      CallExpression
+            //
+            // Our simplification:
+            //
+            // LeftHandSideExpression: See 11.2
+            //      MemberExpression
+            //      CallExpression
+            //
+            // See comment in parseMemberExpressionOrHigher on how we replaced NewExpression with
+            // MemberExpression to make our lives easier.
+            //
+            // to best understand the below code, it's important to see how CallExpression expands
+            // out into its own productions:
+            //
+            // CallExpression:
+            //      MemberExpression Arguments
+            //      CallExpression Arguments
+            //      CallExpression[Expression]
+            //      CallExpression.IdentifierName
+            //      super   (   ArgumentListopt   )
+            //      super.IdentifierName
+            //
+            // Because of the recursion in these calls, we need to bottom out first.  There are two
+            // bottom out states we can run into.  Either we see 'super' which must start either of
+            // the last two CallExpression productions.  Or we have a MemberExpression which either
+            // completes the LeftHandSideExpression, or starts the beginning of the first four
+            // CallExpression productions.
+            var expression = token === 95 /* SuperKeyword */
+                ? parseSuperExpression()
+                : parseMemberExpressionOrHigher();
+            // Now, we *may* be complete.  However, we might have consumed the start of a
+            // CallExpression.  As such, we need to consume the rest of it here to be complete.
+            return parseCallExpressionRest(expression);
+        }
+        function parseMemberExpressionOrHigher() {
+            // Note: to make our lives simpler, we decompose the the NewExpression productions and
+            // place ObjectCreationExpression and FunctionExpression into PrimaryExpression.
+            // like so:
+            //
+            //   PrimaryExpression : See 11.1
+            //      this
+            //      Identifier
+            //      Literal
+            //      ArrayLiteral
+            //      ObjectLiteral
+            //      (Expression)
+            //      FunctionExpression
+            //      new MemberExpression Arguments?
+            //
+            //   MemberExpression : See 11.2
+            //      PrimaryExpression
+            //      MemberExpression[Expression]
+            //      MemberExpression.IdentifierName
+            //
+            //   CallExpression : See 11.2
+            //      MemberExpression
+            //      CallExpression Arguments
+            //      CallExpression[Expression]
+            //      CallExpression.IdentifierName
+            //
+            // Technically this is ambiguous.  i.e. CallExpression defines:
+            //
+            //   CallExpression:
+            //      CallExpression Arguments
+            //
+            // If you see: "new Foo()"
+            //
+            // Then that could be treated as a single ObjectCreationExpression, or it could be
+            // treated as the invocation of "new Foo".  We disambiguate that in code (to match
+            // the original grammar) by making sure that if we see an ObjectCreationExpression
+            // we always consume arguments if they are there. So we treat "new Foo()" as an
+            // object creation only, and not at all as an invocation)  Another way to think
+            // about this is that for every "new" that we see, we will consume an argument list if
+            // it is there as part of the *associated* object creation node.  Any additional
+            // argument lists we see, will become invocation expressions.
+            //
+            // Because there are no other places in the grammar now that refer to FunctionExpression
+            // or ObjectCreationExpression, it is safe to push down into the PrimaryExpression
+            // production.
+            //
+            // Because CallExpression and MemberExpression are left recursive, we need to bottom out
+            // of the recursion immediately.  So we parse out a primary expression to start with.
+            var expression = parsePrimaryExpression();
+            return parseMemberExpressionRest(expression);
+        }
+        function parseSuperExpression() {
+            var expression = parseTokenNode();
+            if (token === 17 /* OpenParenToken */ || token === 21 /* DotToken */ || token === 19 /* OpenBracketToken */) {
+                return expression;
+            }
+            // If we have seen "super" it must be followed by '(' or '.'.
+            // If it wasn't then just try to parse out a '.' and report an error.
+            var node = createNode(172 /* PropertyAccessExpression */, expression.pos);
+            node.expression = expression;
+            parseExpectedToken(21 /* DotToken */, /*reportAtCurrentPosition*/ false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
+            node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+            return finishNode(node);
+        }
+        function tagNamesAreEquivalent(lhs, rhs) {
+            if (lhs.kind !== rhs.kind) {
+                return false;
+            }
+            if (lhs.kind === 69 /* Identifier */) {
+                return lhs.text === rhs.text;
+            }
+            if (lhs.kind === 97 /* ThisKeyword */) {
+                return true;
+            }
+            // If we are at this statement then we must have PropertyAccessExpression and because tag name in Jsx element can only
+            // take forms of JsxTagNameExpression which includes an identifier, "this" expression, or another propertyAccessExpression
+            // it is safe to case the expression property as such. See parseJsxElementName for how we parse tag name in Jsx element
+            return lhs.name.text === rhs.name.text &&
+                tagNamesAreEquivalent(lhs.expression, rhs.expression);
+        }
+        function parseJsxElementOrSelfClosingElement(inExpressionContext) {
+            var opening = parseJsxOpeningOrSelfClosingElement(inExpressionContext);
+            var result;
+            if (opening.kind === 243 /* JsxOpeningElement */) {
+                var node = createNode(241 /* JsxElement */, opening.pos);
+                node.openingElement = opening;
+                node.children = parseJsxChildren(node.openingElement.tagName);
+                node.closingElement = parseJsxClosingElement(inExpressionContext);
+                if (!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) {
+                    parseErrorAtPosition(node.closingElement.pos, node.closingElement.end - node.closingElement.pos, ts.Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, ts.getTextOfNodeFromSourceText(sourceText, node.openingElement.tagName));
+                }
+                result = finishNode(node);
+            }
+            else {
+                ts.Debug.assert(opening.kind === 242 /* JsxSelfClosingElement */);
+                // Nothing else to do for self-closing elements
+                result = opening;
+            }
+            // If the user writes the invalid code '<div></div><div></div>' in an expression context (i.e. not wrapped in
+            // an enclosing tag), we'll naively try to parse   ^ this as a 'less than' operator and the remainder of the tag
+            // as garbage, which will cause the formatter to badly mangle the JSX. Perform a speculative parse of a JSX
+            // element if we see a < token so that we can wrap it in a synthetic binary expression so the formatter
+            // does less damage and we can report a better error.
+            // Since JSX elements are invalid < operands anyway, this lookahead parse will only occur in error scenarios
+            // of one sort or another.
+            if (inExpressionContext && token === 25 /* LessThanToken */) {
+                var invalidElement = tryParse(function () { return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true); });
+                if (invalidElement) {
+                    parseErrorAtCurrentToken(ts.Diagnostics.JSX_expressions_must_have_one_parent_element);
+                    var badNode = createNode(187 /* BinaryExpression */, result.pos);
+                    badNode.end = invalidElement.end;
+                    badNode.left = result;
+                    badNode.right = invalidElement;
+                    badNode.operatorToken = createMissingNode(24 /* CommaToken */, /*reportAtCurrentPosition*/ false, /*diagnosticMessage*/ undefined);
+                    badNode.operatorToken.pos = badNode.operatorToken.end = badNode.right.pos;
+                    return badNode;
+                }
+            }
+            return result;
+        }
+        function parseJsxText() {
+            var node = createNode(244 /* JsxText */, scanner.getStartPos());
+            token = scanner.scanJsxToken();
+            return finishNode(node);
+        }
+        function parseJsxChild() {
+            switch (token) {
+                case 244 /* JsxText */:
+                    return parseJsxText();
+                case 15 /* OpenBraceToken */:
+                    return parseJsxExpression(/*inExpressionContext*/ false);
+                case 25 /* LessThanToken */:
+                    return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ false);
+            }
+            ts.Debug.fail("Unknown JSX child kind " + token);
+        }
+        function parseJsxChildren(openingTagName) {
+            var result = [];
+            result.pos = scanner.getStartPos();
+            var saveParsingContext = parsingContext;
+            parsingContext |= 1 << 14 /* JsxChildren */;
+            while (true) {
+                token = scanner.reScanJsxToken();
+                if (token === 26 /* LessThanSlashToken */) {
+                    // Closing tag
+                    break;
+                }
+                else if (token === 1 /* EndOfFileToken */) {
+                    // If we hit EOF, issue the error at the tag that lacks the closing element
+                    // rather than at the end of the file (which is useless)
+                    parseErrorAtPosition(openingTagName.pos, openingTagName.end - openingTagName.pos, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, openingTagName));
+                    break;
+                }
+                result.push(parseJsxChild());
+            }
+            result.end = scanner.getTokenPos();
+            parsingContext = saveParsingContext;
+            return result;
+        }
+        function parseJsxOpeningOrSelfClosingElement(inExpressionContext) {
+            var fullStart = scanner.getStartPos();
+            parseExpected(25 /* LessThanToken */);
+            var tagName = parseJsxElementName();
+            var attributes = parseList(13 /* JsxAttributes */, parseJsxAttribute);
+            var node;
+            if (token === 27 /* GreaterThanToken */) {
+                // Closing tag, so scan the immediately-following text with the JSX scanning instead
+                // of regular scanning to avoid treating illegal characters (e.g. '#') as immediate
+                // scanning errors
+                node = createNode(243 /* JsxOpeningElement */, fullStart);
+                scanJsxText();
+            }
+            else {
+                parseExpected(39 /* SlashToken */);
+                if (inExpressionContext) {
+                    parseExpected(27 /* GreaterThanToken */);
+                }
+                else {
+                    parseExpected(27 /* GreaterThanToken */, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
+                    scanJsxText();
+                }
+                node = createNode(242 /* JsxSelfClosingElement */, fullStart);
+            }
+            node.tagName = tagName;
+            node.attributes = attributes;
+            return finishNode(node);
+        }
+        function parseJsxElementName() {
+            scanJsxIdentifier();
+            // JsxElement can have name in the form of
+            //      propertyAccessExpression
+            //      primaryExpression in the form of an identifier and "this" keyword
+            // We can't just simply use parseLeftHandSideExpressionOrHigher because then we will start consider class,function etc as a keyword
+            // We only want to consider "this" as a primaryExpression
+            var expression = token === 97 /* ThisKeyword */ ?
+                parseTokenNode() : parseIdentifierName();
+            while (parseOptional(21 /* DotToken */)) {
+                var propertyAccess = createNode(172 /* PropertyAccessExpression */, expression.pos);
+                propertyAccess.expression = expression;
+                propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+                expression = finishNode(propertyAccess);
+            }
+            return expression;
+        }
+        function parseJsxExpression(inExpressionContext) {
+            var node = createNode(248 /* JsxExpression */);
+            parseExpected(15 /* OpenBraceToken */);
+            if (token !== 16 /* CloseBraceToken */) {
+                node.expression = parseAssignmentExpressionOrHigher();
+            }
+            if (inExpressionContext) {
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                parseExpected(16 /* CloseBraceToken */, /*message*/ undefined, /*shouldAdvance*/ false);
+                scanJsxText();
+            }
+            return finishNode(node);
+        }
+        function parseJsxAttribute() {
+            if (token === 15 /* OpenBraceToken */) {
+                return parseJsxSpreadAttribute();
+            }
+            scanJsxIdentifier();
+            var node = createNode(246 /* JsxAttribute */);
+            node.name = parseIdentifierName();
+            if (parseOptional(56 /* EqualsToken */)) {
+                switch (token) {
+                    case 9 /* StringLiteral */:
+                        node.initializer = parseLiteralNode();
+                        break;
+                    default:
+                        node.initializer = parseJsxExpression(/*inExpressionContext*/ true);
+                        break;
+                }
+            }
+            return finishNode(node);
+        }
+        function parseJsxSpreadAttribute() {
+            var node = createNode(247 /* JsxSpreadAttribute */);
+            parseExpected(15 /* OpenBraceToken */);
+            parseExpected(22 /* DotDotDotToken */);
+            node.expression = parseExpression();
+            parseExpected(16 /* CloseBraceToken */);
+            return finishNode(node);
+        }
+        function parseJsxClosingElement(inExpressionContext) {
+            var node = createNode(245 /* JsxClosingElement */);
+            parseExpected(26 /* LessThanSlashToken */);
+            node.tagName = parseJsxElementName();
+            if (inExpressionContext) {
+                parseExpected(27 /* GreaterThanToken */);
+            }
+            else {
+                parseExpected(27 /* GreaterThanToken */, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
+                scanJsxText();
+            }
+            return finishNode(node);
+        }
+        function parseTypeAssertion() {
+            var node = createNode(177 /* TypeAssertionExpression */);
+            parseExpected(25 /* LessThanToken */);
+            node.type = parseType();
+            parseExpected(27 /* GreaterThanToken */);
+            node.expression = parseSimpleUnaryExpression();
+            return finishNode(node);
+        }
+        function parseMemberExpressionRest(expression) {
+            while (true) {
+                var dotToken = parseOptionalToken(21 /* DotToken */);
+                if (dotToken) {
+                    var propertyAccess = createNode(172 /* PropertyAccessExpression */, expression.pos);
+                    propertyAccess.expression = expression;
+                    propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+                    expression = finishNode(propertyAccess);
+                    continue;
+                }
+                if (token === 49 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
+                    nextToken();
+                    var nonNullExpression = createNode(196 /* NonNullExpression */, expression.pos);
+                    nonNullExpression.expression = expression;
+                    expression = finishNode(nonNullExpression);
+                    continue;
+                }
+                // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName
+                if (!inDecoratorContext() && parseOptional(19 /* OpenBracketToken */)) {
+                    var indexedAccess = createNode(173 /* ElementAccessExpression */, expression.pos);
+                    indexedAccess.expression = expression;
+                    // It's not uncommon for a user to write: "new Type[]".
+                    // Check for that common pattern and report a better error message.
+                    if (token !== 20 /* CloseBracketToken */) {
+                        indexedAccess.argumentExpression = allowInAnd(parseExpression);
+                        if (indexedAccess.argumentExpression.kind === 9 /* StringLiteral */ || indexedAccess.argumentExpression.kind === 8 /* NumericLiteral */) {
+                            var literal = indexedAccess.argumentExpression;
+                            literal.text = internIdentifier(literal.text);
+                        }
+                    }
+                    parseExpected(20 /* CloseBracketToken */);
+                    expression = finishNode(indexedAccess);
+                    continue;
+                }
+                if (token === 11 /* NoSubstitutionTemplateLiteral */ || token === 12 /* TemplateHead */) {
+                    var tagExpression = createNode(176 /* TaggedTemplateExpression */, expression.pos);
+                    tagExpression.tag = expression;
+                    tagExpression.template = token === 11 /* NoSubstitutionTemplateLiteral */
+                        ? parseLiteralNode()
+                        : parseTemplateExpression();
+                    expression = finishNode(tagExpression);
+                    continue;
+                }
+                return expression;
+            }
+        }
+        function parseCallExpressionRest(expression) {
+            while (true) {
+                expression = parseMemberExpressionRest(expression);
+                if (token === 25 /* LessThanToken */) {
+                    // See if this is the start of a generic invocation.  If so, consume it and
+                    // keep checking for postfix expressions.  Otherwise, it's just a '<' that's
+                    // part of an arithmetic expression.  Break out so we consume it higher in the
+                    // stack.
+                    var typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    if (!typeArguments) {
+                        return expression;
+                    }
+                    var callExpr = createNode(174 /* CallExpression */, expression.pos);
+                    callExpr.expression = expression;
+                    callExpr.typeArguments = typeArguments;
+                    callExpr.arguments = parseArgumentList();
+                    expression = finishNode(callExpr);
+                    continue;
+                }
+                else if (token === 17 /* OpenParenToken */) {
+                    var callExpr = createNode(174 /* CallExpression */, expression.pos);
+                    callExpr.expression = expression;
+                    callExpr.arguments = parseArgumentList();
+                    expression = finishNode(callExpr);
+                    continue;
+                }
+                return expression;
+            }
+        }
+        function parseArgumentList() {
+            parseExpected(17 /* OpenParenToken */);
+            var result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression);
+            parseExpected(18 /* CloseParenToken */);
+            return result;
+        }
+        function parseTypeArgumentsInExpression() {
+            if (!parseOptional(25 /* LessThanToken */)) {
+                return undefined;
+            }
+            var typeArguments = parseDelimitedList(18 /* TypeArguments */, parseType);
+            if (!parseExpected(27 /* GreaterThanToken */)) {
+                // If it doesn't have the closing >  then it's definitely not an type argument list.
+                return undefined;
+            }
+            // If we have a '<', then only parse this as a argument list if the type arguments
+            // are complete and we have an open paren.  if we don't, rewind and return nothing.
+            return typeArguments && canFollowTypeArgumentsInExpression()
+                ? typeArguments
+                : undefined;
+        }
+        function canFollowTypeArgumentsInExpression() {
+            switch (token) {
+                case 17 /* OpenParenToken */: // foo<x>(
+                // this case are the only case where this token can legally follow a type argument
+                // list.  So we definitely want to treat this as a type arg list.
+                case 21 /* DotToken */: // foo<x>.
+                case 18 /* CloseParenToken */: // foo<x>)
+                case 20 /* CloseBracketToken */: // foo<x>]
+                case 54 /* ColonToken */: // foo<x>:
+                case 23 /* SemicolonToken */: // foo<x>;
+                case 53 /* QuestionToken */: // foo<x>?
+                case 30 /* EqualsEqualsToken */: // foo<x> ==
+                case 32 /* EqualsEqualsEqualsToken */: // foo<x> ===
+                case 31 /* ExclamationEqualsToken */: // foo<x> !=
+                case 33 /* ExclamationEqualsEqualsToken */: // foo<x> !==
+                case 51 /* AmpersandAmpersandToken */: // foo<x> &&
+                case 52 /* BarBarToken */: // foo<x> ||
+                case 48 /* CaretToken */: // foo<x> ^
+                case 46 /* AmpersandToken */: // foo<x> &
+                case 47 /* BarToken */: // foo<x> |
+                case 16 /* CloseBraceToken */: // foo<x> }
+                case 1 /* EndOfFileToken */:
+                    // these cases can't legally follow a type arg list.  However, they're not legal
+                    // expressions either.  The user is probably in the middle of a generic type. So
+                    // treat it as such.
+                    return true;
+                case 24 /* CommaToken */: // foo<x>,
+                case 15 /* OpenBraceToken */: // foo<x> {
+                // We don't want to treat these as type arguments.  Otherwise we'll parse this
+                // as an invocation expression.  Instead, we want to parse out the expression
+                // in isolation from the type arguments.
+                default:
+                    // Anything else treat as an expression.
+                    return false;
+            }
+        }
+        function parsePrimaryExpression() {
+            switch (token) {
+                case 8 /* NumericLiteral */:
+                case 9 /* StringLiteral */:
+                case 11 /* NoSubstitutionTemplateLiteral */:
+                    return parseLiteralNode();
+                case 97 /* ThisKeyword */:
+                case 95 /* SuperKeyword */:
+                case 93 /* NullKeyword */:
+                case 99 /* TrueKeyword */:
+                case 84 /* FalseKeyword */:
+                    return parseTokenNode();
+                case 17 /* OpenParenToken */:
+                    return parseParenthesizedExpression();
+                case 19 /* OpenBracketToken */:
+                    return parseArrayLiteralExpression();
+                case 15 /* OpenBraceToken */:
+                    return parseObjectLiteralExpression();
+                case 118 /* AsyncKeyword */:
+                    // Async arrow functions are parsed earlier in parseAssignmentExpressionOrHigher.
+                    // If we encounter `async [no LineTerminator here] function` then this is an async
+                    // function; otherwise, its an identifier.
+                    if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
+                        break;
+                    }
+                    return parseFunctionExpression();
+                case 73 /* ClassKeyword */:
+                    return parseClassExpression();
+                case 87 /* FunctionKeyword */:
+                    return parseFunctionExpression();
+                case 92 /* NewKeyword */:
+                    return parseNewExpression();
+                case 39 /* SlashToken */:
+                case 61 /* SlashEqualsToken */:
+                    if (reScanSlashToken() === 10 /* RegularExpressionLiteral */) {
+                        return parseLiteralNode();
+                    }
+                    break;
+                case 12 /* TemplateHead */:
+                    return parseTemplateExpression();
+            }
+            return parseIdentifier(ts.Diagnostics.Expression_expected);
+        }
+        function parseParenthesizedExpression() {
+            var node = createNode(178 /* ParenthesizedExpression */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            return finishNode(node);
+        }
+        function parseSpreadElement() {
+            var node = createNode(191 /* SpreadElementExpression */);
+            parseExpected(22 /* DotDotDotToken */);
+            node.expression = parseAssignmentExpressionOrHigher();
+            return finishNode(node);
+        }
+        function parseArgumentOrArrayLiteralElement() {
+            return token === 22 /* DotDotDotToken */ ? parseSpreadElement() :
+                token === 24 /* CommaToken */ ? createNode(193 /* OmittedExpression */) :
+                    parseAssignmentExpressionOrHigher();
+        }
+        function parseArgumentExpression() {
+            return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
+        }
+        function parseArrayLiteralExpression() {
+            var node = createNode(170 /* ArrayLiteralExpression */);
+            parseExpected(19 /* OpenBracketToken */);
+            if (scanner.hasPrecedingLineBreak()) {
+                node.multiLine = true;
+            }
+            node.elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
+            parseExpected(20 /* CloseBracketToken */);
+            return finishNode(node);
+        }
+        function tryParseAccessorDeclaration(fullStart, decorators, modifiers) {
+            if (parseContextualModifier(123 /* GetKeyword */)) {
+                return addJSDocComment(parseAccessorDeclaration(149 /* GetAccessor */, fullStart, decorators, modifiers));
+            }
+            else if (parseContextualModifier(131 /* SetKeyword */)) {
+                return parseAccessorDeclaration(150 /* SetAccessor */, fullStart, decorators, modifiers);
+            }
+            return undefined;
+        }
+        function parseObjectLiteralElement() {
+            var fullStart = scanner.getStartPos();
+            var decorators = parseDecorators();
+            var modifiers = parseModifiers();
+            var accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
+            if (accessor) {
+                return accessor;
+            }
+            var asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
+            var tokenIsIdentifier = isIdentifier();
+            var propertyName = parsePropertyName();
+            // Disallowing of optional property assignments happens in the grammar checker.
+            var questionToken = parseOptionalToken(53 /* QuestionToken */);
+            if (asteriskToken || token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
+                return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
+            }
+            // check if it is short-hand property assignment or normal property assignment
+            // NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production
+            // CoverInitializedName[Yield] :
+            //     IdentifierReference[?Yield] Initializer[In, ?Yield]
+            // this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern
+            var isShorthandPropertyAssignment = tokenIsIdentifier && (token === 24 /* CommaToken */ || token === 16 /* CloseBraceToken */ || token === 56 /* EqualsToken */);
+            if (isShorthandPropertyAssignment) {
+                var shorthandDeclaration = createNode(254 /* ShorthandPropertyAssignment */, fullStart);
+                shorthandDeclaration.name = propertyName;
+                shorthandDeclaration.questionToken = questionToken;
+                var equalsToken = parseOptionalToken(56 /* EqualsToken */);
+                if (equalsToken) {
+                    shorthandDeclaration.equalsToken = equalsToken;
+                    shorthandDeclaration.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                }
+                return addJSDocComment(finishNode(shorthandDeclaration));
+            }
+            else {
+                var propertyAssignment = createNode(253 /* PropertyAssignment */, fullStart);
+                propertyAssignment.modifiers = modifiers;
+                propertyAssignment.name = propertyName;
+                propertyAssignment.questionToken = questionToken;
+                parseExpected(54 /* ColonToken */);
+                propertyAssignment.initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                return addJSDocComment(finishNode(propertyAssignment));
+            }
+        }
+        function parseObjectLiteralExpression() {
+            var node = createNode(171 /* ObjectLiteralExpression */);
+            parseExpected(15 /* OpenBraceToken */);
+            if (scanner.hasPrecedingLineBreak()) {
+                node.multiLine = true;
+            }
+            node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimiter*/ true);
+            parseExpected(16 /* CloseBraceToken */);
+            return finishNode(node);
+        }
+        function parseFunctionExpression() {
+            // GeneratorExpression:
+            //      function* BindingIdentifier [Yield][opt](FormalParameters[Yield]){ GeneratorBody }
+            //
+            // FunctionExpression:
+            //      function BindingIdentifier[opt](FormalParameters){ FunctionBody }
+            var saveDecoratorContext = inDecoratorContext();
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ false);
+            }
+            var node = createNode(179 /* FunctionExpression */);
+            setModifiers(node, parseModifiers());
+            parseExpected(87 /* FunctionKeyword */);
+            node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
+            var isGenerator = !!node.asteriskToken;
+            var isAsync = !!(node.flags & 256 /* Async */);
+            node.name =
+                isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
+                    isGenerator ? doInYieldContext(parseOptionalIdentifier) :
+                        isAsync ? doInAwaitContext(parseOptionalIdentifier) :
+                            parseOptionalIdentifier();
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false);
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ true);
+            }
+            return addJSDocComment(finishNode(node));
+        }
+        function parseOptionalIdentifier() {
+            return isIdentifier() ? parseIdentifier() : undefined;
+        }
+        function parseNewExpression() {
+            var node = createNode(175 /* NewExpression */);
+            parseExpected(92 /* NewKeyword */);
+            node.expression = parseMemberExpressionOrHigher();
+            node.typeArguments = tryParse(parseTypeArgumentsInExpression);
+            if (node.typeArguments || token === 17 /* OpenParenToken */) {
+                node.arguments = parseArgumentList();
+            }
+            return finishNode(node);
+        }
+        // STATEMENTS
+        function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
+            var node = createNode(199 /* Block */);
+            if (parseExpected(15 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) {
+                node.statements = parseList(1 /* BlockStatements */, parseStatement);
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                node.statements = createMissingList();
+            }
+            return finishNode(node);
+        }
+        function parseFunctionBlock(allowYield, allowAwait, ignoreMissingOpenBrace, diagnosticMessage) {
+            var savedYieldContext = inYieldContext();
+            setYieldContext(allowYield);
+            var savedAwaitContext = inAwaitContext();
+            setAwaitContext(allowAwait);
+            // We may be in a [Decorator] context when parsing a function expression or
+            // arrow function. The body of the function is not in [Decorator] context.
+            var saveDecoratorContext = inDecoratorContext();
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ false);
+            }
+            var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
+            if (saveDecoratorContext) {
+                setDecoratorContext(/*val*/ true);
+            }
+            setYieldContext(savedYieldContext);
+            setAwaitContext(savedAwaitContext);
+            return block;
+        }
+        function parseEmptyStatement() {
+            var node = createNode(201 /* EmptyStatement */);
+            parseExpected(23 /* SemicolonToken */);
+            return finishNode(node);
+        }
+        function parseIfStatement() {
+            var node = createNode(203 /* IfStatement */);
+            parseExpected(88 /* IfKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            node.thenStatement = parseStatement();
+            node.elseStatement = parseOptional(80 /* ElseKeyword */) ? parseStatement() : undefined;
+            return finishNode(node);
+        }
+        function parseDoStatement() {
+            var node = createNode(204 /* DoStatement */);
+            parseExpected(79 /* DoKeyword */);
+            node.statement = parseStatement();
+            parseExpected(104 /* WhileKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            // From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html
+            // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in
+            // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
+            //  do;while(0)x will have a semicolon inserted before x.
+            parseOptional(23 /* SemicolonToken */);
+            return finishNode(node);
+        }
+        function parseWhileStatement() {
+            var node = createNode(205 /* WhileStatement */);
+            parseExpected(104 /* WhileKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            node.statement = parseStatement();
+            return finishNode(node);
+        }
+        function parseForOrForInOrForOfStatement() {
+            var pos = getNodePos();
+            parseExpected(86 /* ForKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            var initializer = undefined;
+            if (token !== 23 /* SemicolonToken */) {
+                if (token === 102 /* VarKeyword */ || token === 108 /* LetKeyword */ || token === 74 /* ConstKeyword */) {
+                    initializer = parseVariableDeclarationList(/*inForStatementInitializer*/ true);
+                }
+                else {
+                    initializer = disallowInAnd(parseExpression);
+                }
+            }
+            var forOrForInOrForOfStatement;
+            if (parseOptional(90 /* InKeyword */)) {
+                var forInStatement = createNode(207 /* ForInStatement */, pos);
+                forInStatement.initializer = initializer;
+                forInStatement.expression = allowInAnd(parseExpression);
+                parseExpected(18 /* CloseParenToken */);
+                forOrForInOrForOfStatement = forInStatement;
+            }
+            else if (parseOptional(138 /* OfKeyword */)) {
+                var forOfStatement = createNode(208 /* ForOfStatement */, pos);
+                forOfStatement.initializer = initializer;
+                forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
+                parseExpected(18 /* CloseParenToken */);
+                forOrForInOrForOfStatement = forOfStatement;
+            }
+            else {
+                var forStatement = createNode(206 /* ForStatement */, pos);
+                forStatement.initializer = initializer;
+                parseExpected(23 /* SemicolonToken */);
+                if (token !== 23 /* SemicolonToken */ && token !== 18 /* CloseParenToken */) {
+                    forStatement.condition = allowInAnd(parseExpression);
+                }
+                parseExpected(23 /* SemicolonToken */);
+                if (token !== 18 /* CloseParenToken */) {
+                    forStatement.incrementor = allowInAnd(parseExpression);
+                }
+                parseExpected(18 /* CloseParenToken */);
+                forOrForInOrForOfStatement = forStatement;
+            }
+            forOrForInOrForOfStatement.statement = parseStatement();
+            return finishNode(forOrForInOrForOfStatement);
+        }
+        function parseBreakOrContinueStatement(kind) {
+            var node = createNode(kind);
+            parseExpected(kind === 210 /* BreakStatement */ ? 70 /* BreakKeyword */ : 75 /* ContinueKeyword */);
+            if (!canParseSemicolon()) {
+                node.label = parseIdentifier();
+            }
+            parseSemicolon();
+            return finishNode(node);
+        }
+        function parseReturnStatement() {
+            var node = createNode(211 /* ReturnStatement */);
+            parseExpected(94 /* ReturnKeyword */);
+            if (!canParseSemicolon()) {
+                node.expression = allowInAnd(parseExpression);
+            }
+            parseSemicolon();
+            return finishNode(node);
+        }
+        function parseWithStatement() {
+            var node = createNode(212 /* WithStatement */);
+            parseExpected(105 /* WithKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            node.statement = parseStatement();
+            return finishNode(node);
+        }
+        function parseCaseClause() {
+            var node = createNode(249 /* CaseClause */);
+            parseExpected(71 /* CaseKeyword */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(54 /* ColonToken */);
+            node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
+            return finishNode(node);
+        }
+        function parseDefaultClause() {
+            var node = createNode(250 /* DefaultClause */);
+            parseExpected(77 /* DefaultKeyword */);
+            parseExpected(54 /* ColonToken */);
+            node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
+            return finishNode(node);
+        }
+        function parseCaseOrDefaultClause() {
+            return token === 71 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause();
+        }
+        function parseSwitchStatement() {
+            var node = createNode(213 /* SwitchStatement */);
+            parseExpected(96 /* SwitchKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = allowInAnd(parseExpression);
+            parseExpected(18 /* CloseParenToken */);
+            var caseBlock = createNode(227 /* CaseBlock */, scanner.getStartPos());
+            parseExpected(15 /* OpenBraceToken */);
+            caseBlock.clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause);
+            parseExpected(16 /* CloseBraceToken */);
+            node.caseBlock = finishNode(caseBlock);
+            return finishNode(node);
+        }
+        function parseThrowStatement() {
+            // ThrowStatement[Yield] :
+            //      throw [no LineTerminator here]Expression[In, ?Yield];
+            // Because of automatic semicolon insertion, we need to report error if this
+            // throw could be terminated with a semicolon.  Note: we can't call 'parseExpression'
+            // directly as that might consume an expression on the following line.
+            // We just return 'undefined' in that case.  The actual error will be reported in the
+            // grammar walker.
+            var node = createNode(215 /* ThrowStatement */);
+            parseExpected(98 /* ThrowKeyword */);
+            node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression);
+            parseSemicolon();
+            return finishNode(node);
+        }
+        // TODO: Review for error recovery
+        function parseTryStatement() {
+            var node = createNode(216 /* TryStatement */);
+            parseExpected(100 /* TryKeyword */);
+            node.tryBlock = parseBlock(/*ignoreMissingOpenBrace*/ false);
+            node.catchClause = token === 72 /* CatchKeyword */ ? parseCatchClause() : undefined;
+            // If we don't have a catch clause, then we must have a finally clause.  Try to parse
+            // one out no matter what.
+            if (!node.catchClause || token === 85 /* FinallyKeyword */) {
+                parseExpected(85 /* FinallyKeyword */);
+                node.finallyBlock = parseBlock(/*ignoreMissingOpenBrace*/ false);
+            }
+            return finishNode(node);
+        }
+        function parseCatchClause() {
+            var result = createNode(252 /* CatchClause */);
+            parseExpected(72 /* CatchKeyword */);
+            if (parseExpected(17 /* OpenParenToken */)) {
+                result.variableDeclaration = parseVariableDeclaration();
+            }
+            parseExpected(18 /* CloseParenToken */);
+            result.block = parseBlock(/*ignoreMissingOpenBrace*/ false);
+            return finishNode(result);
+        }
+        function parseDebuggerStatement() {
+            var node = createNode(217 /* DebuggerStatement */);
+            parseExpected(76 /* DebuggerKeyword */);
+            parseSemicolon();
+            return finishNode(node);
+        }
+        function parseExpressionOrLabeledStatement() {
+            // Avoiding having to do the lookahead for a labeled statement by just trying to parse
+            // out an expression, seeing if it is identifier and then seeing if it is followed by
+            // a colon.
+            var fullStart = scanner.getStartPos();
+            var expression = allowInAnd(parseExpression);
+            if (expression.kind === 69 /* Identifier */ && parseOptional(54 /* ColonToken */)) {
+                var labeledStatement = createNode(214 /* LabeledStatement */, fullStart);
+                labeledStatement.label = expression;
+                labeledStatement.statement = parseStatement();
+                return addJSDocComment(finishNode(labeledStatement));
+            }
+            else {
+                var expressionStatement = createNode(202 /* ExpressionStatement */, fullStart);
+                expressionStatement.expression = expression;
+                parseSemicolon();
+                return addJSDocComment(finishNode(expressionStatement));
+            }
+        }
+        function nextTokenIsIdentifierOrKeywordOnSameLine() {
+            nextToken();
+            return ts.tokenIsIdentifierOrKeyword(token) && !scanner.hasPrecedingLineBreak();
+        }
+        function nextTokenIsFunctionKeywordOnSameLine() {
+            nextToken();
+            return token === 87 /* FunctionKeyword */ && !scanner.hasPrecedingLineBreak();
+        }
+        function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() {
+            nextToken();
+            return (ts.tokenIsIdentifierOrKeyword(token) || token === 8 /* NumericLiteral */) && !scanner.hasPrecedingLineBreak();
+        }
+        function isDeclaration() {
+            while (true) {
+                switch (token) {
+                    case 102 /* VarKeyword */:
+                    case 108 /* LetKeyword */:
+                    case 74 /* ConstKeyword */:
+                    case 87 /* FunctionKeyword */:
+                    case 73 /* ClassKeyword */:
+                    case 81 /* EnumKeyword */:
+                        return true;
+                    // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers;
+                    // however, an identifier cannot be followed by another identifier on the same line. This is what we
+                    // count on to parse out the respective declarations. For instance, we exploit this to say that
+                    //
+                    //    namespace n
+                    //
+                    // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees
+                    //
+                    //    namespace
+                    //    n
+                    //
+                    // as the identifier 'namespace' on one line followed by the identifier 'n' on another.
+                    // We need to look one token ahead to see if it permissible to try parsing a declaration.
+                    //
+                    // *Note*: 'interface' is actually a strict mode reserved word. So while
+                    //
+                    //   "use strict"
+                    //   interface
+                    //   I {}
+                    //
+                    // could be legal, it would add complexity for very little gain.
+                    case 107 /* InterfaceKeyword */:
+                    case 134 /* TypeKeyword */:
+                        return nextTokenIsIdentifierOnSameLine();
+                    case 125 /* ModuleKeyword */:
+                    case 126 /* NamespaceKeyword */:
+                        return nextTokenIsIdentifierOrStringLiteralOnSameLine();
+                    case 115 /* AbstractKeyword */:
+                    case 118 /* AsyncKeyword */:
+                    case 122 /* DeclareKeyword */:
+                    case 110 /* PrivateKeyword */:
+                    case 111 /* ProtectedKeyword */:
+                    case 112 /* PublicKeyword */:
+                    case 128 /* ReadonlyKeyword */:
+                        nextToken();
+                        // ASI takes effect for this modifier.
+                        if (scanner.hasPrecedingLineBreak()) {
+                            return false;
+                        }
+                        continue;
+                    case 137 /* GlobalKeyword */:
+                        nextToken();
+                        return token === 15 /* OpenBraceToken */ || token === 69 /* Identifier */ || token === 82 /* ExportKeyword */;
+                    case 89 /* ImportKeyword */:
+                        nextToken();
+                        return token === 9 /* StringLiteral */ || token === 37 /* AsteriskToken */ ||
+                            token === 15 /* OpenBraceToken */ || ts.tokenIsIdentifierOrKeyword(token);
+                    case 82 /* ExportKeyword */:
+                        nextToken();
+                        if (token === 56 /* EqualsToken */ || token === 37 /* AsteriskToken */ ||
+                            token === 15 /* OpenBraceToken */ || token === 77 /* DefaultKeyword */ ||
+                            token === 116 /* AsKeyword */) {
+                            return true;
+                        }
+                        continue;
+                    case 113 /* StaticKeyword */:
+                        nextToken();
+                        continue;
+                    default:
+                        return false;
+                }
+            }
+        }
+        function isStartOfDeclaration() {
+            return lookAhead(isDeclaration);
+        }
+        function isStartOfStatement() {
+            switch (token) {
+                case 55 /* AtToken */:
+                case 23 /* SemicolonToken */:
+                case 15 /* OpenBraceToken */:
+                case 102 /* VarKeyword */:
+                case 108 /* LetKeyword */:
+                case 87 /* FunctionKeyword */:
+                case 73 /* ClassKeyword */:
+                case 81 /* EnumKeyword */:
+                case 88 /* IfKeyword */:
+                case 79 /* DoKeyword */:
+                case 104 /* WhileKeyword */:
+                case 86 /* ForKeyword */:
+                case 75 /* ContinueKeyword */:
+                case 70 /* BreakKeyword */:
+                case 94 /* ReturnKeyword */:
+                case 105 /* WithKeyword */:
+                case 96 /* SwitchKeyword */:
+                case 98 /* ThrowKeyword */:
+                case 100 /* TryKeyword */:
+                case 76 /* DebuggerKeyword */:
+                // 'catch' and 'finally' do not actually indicate that the code is part of a statement,
+                // however, we say they are here so that we may gracefully parse them and error later.
+                case 72 /* CatchKeyword */:
+                case 85 /* FinallyKeyword */:
+                    return true;
+                case 74 /* ConstKeyword */:
+                case 82 /* ExportKeyword */:
+                case 89 /* ImportKeyword */:
+                    return isStartOfDeclaration();
+                case 118 /* AsyncKeyword */:
+                case 122 /* DeclareKeyword */:
+                case 107 /* InterfaceKeyword */:
+                case 125 /* ModuleKeyword */:
+                case 126 /* NamespaceKeyword */:
+                case 134 /* TypeKeyword */:
+                case 137 /* GlobalKeyword */:
+                    // When these don't start a declaration, they're an identifier in an expression statement
+                    return true;
+                case 112 /* PublicKeyword */:
+                case 110 /* PrivateKeyword */:
+                case 111 /* ProtectedKeyword */:
+                case 113 /* StaticKeyword */:
+                case 128 /* ReadonlyKeyword */:
+                    // When these don't start a declaration, they may be the start of a class member if an identifier
+                    // immediately follows. Otherwise they're an identifier in an expression statement.
+                    return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+                default:
+                    return isStartOfExpression();
+            }
+        }
+        function nextTokenIsIdentifierOrStartOfDestructuring() {
+            nextToken();
+            return isIdentifier() || token === 15 /* OpenBraceToken */ || token === 19 /* OpenBracketToken */;
+        }
+        function isLetDeclaration() {
+            // In ES6 'let' always starts a lexical declaration if followed by an identifier or {
+            // or [.
+            return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring);
+        }
+        function parseStatement() {
+            switch (token) {
+                case 23 /* SemicolonToken */:
+                    return parseEmptyStatement();
+                case 15 /* OpenBraceToken */:
+                    return parseBlock(/*ignoreMissingOpenBrace*/ false);
+                case 102 /* VarKeyword */:
+                    return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                case 108 /* LetKeyword */:
+                    if (isLetDeclaration()) {
+                        return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                    }
+                    break;
+                case 87 /* FunctionKeyword */:
+                    return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                case 73 /* ClassKeyword */:
+                    return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                case 88 /* IfKeyword */:
+                    return parseIfStatement();
+                case 79 /* DoKeyword */:
+                    return parseDoStatement();
+                case 104 /* WhileKeyword */:
+                    return parseWhileStatement();
+                case 86 /* ForKeyword */:
+                    return parseForOrForInOrForOfStatement();
+                case 75 /* ContinueKeyword */:
+                    return parseBreakOrContinueStatement(209 /* ContinueStatement */);
+                case 70 /* BreakKeyword */:
+                    return parseBreakOrContinueStatement(210 /* BreakStatement */);
+                case 94 /* ReturnKeyword */:
+                    return parseReturnStatement();
+                case 105 /* WithKeyword */:
+                    return parseWithStatement();
+                case 96 /* SwitchKeyword */:
+                    return parseSwitchStatement();
+                case 98 /* ThrowKeyword */:
+                    return parseThrowStatement();
+                case 100 /* TryKeyword */:
+                // Include 'catch' and 'finally' for error recovery.
+                case 72 /* CatchKeyword */:
+                case 85 /* FinallyKeyword */:
+                    return parseTryStatement();
+                case 76 /* DebuggerKeyword */:
+                    return parseDebuggerStatement();
+                case 55 /* AtToken */:
+                    return parseDeclaration();
+                case 118 /* AsyncKeyword */:
+                case 107 /* InterfaceKeyword */:
+                case 134 /* TypeKeyword */:
+                case 125 /* ModuleKeyword */:
+                case 126 /* NamespaceKeyword */:
+                case 122 /* DeclareKeyword */:
+                case 74 /* ConstKeyword */:
+                case 81 /* EnumKeyword */:
+                case 82 /* ExportKeyword */:
+                case 89 /* ImportKeyword */:
+                case 110 /* PrivateKeyword */:
+                case 111 /* ProtectedKeyword */:
+                case 112 /* PublicKeyword */:
+                case 115 /* AbstractKeyword */:
+                case 113 /* StaticKeyword */:
+                case 128 /* ReadonlyKeyword */:
+                case 137 /* GlobalKeyword */:
+                    if (isStartOfDeclaration()) {
+                        return parseDeclaration();
+                    }
+                    break;
+            }
+            return parseExpressionOrLabeledStatement();
+        }
+        function parseDeclaration() {
+            var fullStart = getNodePos();
+            var decorators = parseDecorators();
+            var modifiers = parseModifiers();
+            switch (token) {
+                case 102 /* VarKeyword */:
+                case 108 /* LetKeyword */:
+                case 74 /* ConstKeyword */:
+                    return parseVariableStatement(fullStart, decorators, modifiers);
+                case 87 /* FunctionKeyword */:
+                    return parseFunctionDeclaration(fullStart, decorators, modifiers);
+                case 73 /* ClassKeyword */:
+                    return parseClassDeclaration(fullStart, decorators, modifiers);
+                case 107 /* InterfaceKeyword */:
+                    return parseInterfaceDeclaration(fullStart, decorators, modifiers);
+                case 134 /* TypeKeyword */:
+                    return parseTypeAliasDeclaration(fullStart, decorators, modifiers);
+                case 81 /* EnumKeyword */:
+                    return parseEnumDeclaration(fullStart, decorators, modifiers);
+                case 137 /* GlobalKeyword */:
+                case 125 /* ModuleKeyword */:
+                case 126 /* NamespaceKeyword */:
+                    return parseModuleDeclaration(fullStart, decorators, modifiers);
+                case 89 /* ImportKeyword */:
+                    return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers);
+                case 82 /* ExportKeyword */:
+                    nextToken();
+                    switch (token) {
+                        case 77 /* DefaultKeyword */:
+                        case 56 /* EqualsToken */:
+                            return parseExportAssignment(fullStart, decorators, modifiers);
+                        case 116 /* AsKeyword */:
+                            return parseNamespaceExportDeclaration(fullStart, decorators, modifiers);
+                        default:
+                            return parseExportDeclaration(fullStart, decorators, modifiers);
+                    }
+                default:
+                    if (decorators || modifiers) {
+                        // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
+                        // would follow. For recovery and error reporting purposes, return an incomplete declaration.
+                        var node = createMissingNode(239 /* MissingDeclaration */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected);
+                        node.pos = fullStart;
+                        node.decorators = decorators;
+                        setModifiers(node, modifiers);
+                        return finishNode(node);
+                    }
+            }
+        }
+        function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
+            nextToken();
+            return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 9 /* StringLiteral */);
+        }
+        function parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage) {
+            if (token !== 15 /* OpenBraceToken */ && canParseSemicolon()) {
+                parseSemicolon();
+                return;
+            }
+            return parseFunctionBlock(isGenerator, isAsync, /*ignoreMissingOpenBrace*/ false, diagnosticMessage);
+        }
+        // DECLARATIONS
+        function parseArrayBindingElement() {
+            if (token === 24 /* CommaToken */) {
+                return createNode(193 /* OmittedExpression */);
+            }
+            var node = createNode(169 /* BindingElement */);
+            node.dotDotDotToken = parseOptionalToken(22 /* DotDotDotToken */);
+            node.name = parseIdentifierOrPattern();
+            node.initializer = parseBindingElementInitializer(/*inParameter*/ false);
+            return finishNode(node);
+        }
+        function parseObjectBindingElement() {
+            var node = createNode(169 /* BindingElement */);
+            var tokenIsIdentifier = isIdentifier();
+            var propertyName = parsePropertyName();
+            if (tokenIsIdentifier && token !== 54 /* ColonToken */) {
+                node.name = propertyName;
+            }
+            else {
+                parseExpected(54 /* ColonToken */);
+                node.propertyName = propertyName;
+                node.name = parseIdentifierOrPattern();
+            }
+            node.initializer = parseBindingElementInitializer(/*inParameter*/ false);
+            return finishNode(node);
+        }
+        function parseObjectBindingPattern() {
+            var node = createNode(167 /* ObjectBindingPattern */);
+            parseExpected(15 /* OpenBraceToken */);
+            node.elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
+            parseExpected(16 /* CloseBraceToken */);
+            return finishNode(node);
+        }
+        function parseArrayBindingPattern() {
+            var node = createNode(168 /* ArrayBindingPattern */);
+            parseExpected(19 /* OpenBracketToken */);
+            node.elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
+            parseExpected(20 /* CloseBracketToken */);
+            return finishNode(node);
+        }
+        function isIdentifierOrPattern() {
+            return token === 15 /* OpenBraceToken */ || token === 19 /* OpenBracketToken */ || isIdentifier();
+        }
+        function parseIdentifierOrPattern() {
+            if (token === 19 /* OpenBracketToken */) {
+                return parseArrayBindingPattern();
+            }
+            if (token === 15 /* OpenBraceToken */) {
+                return parseObjectBindingPattern();
+            }
+            return parseIdentifier();
+        }
+        function parseVariableDeclaration() {
+            var node = createNode(218 /* VariableDeclaration */);
+            node.name = parseIdentifierOrPattern();
+            node.type = parseTypeAnnotation();
+            if (!isInOrOfKeyword(token)) {
+                node.initializer = parseInitializer(/*inParameter*/ false);
+            }
+            return finishNode(node);
+        }
+        function parseVariableDeclarationList(inForStatementInitializer) {
+            var node = createNode(219 /* VariableDeclarationList */);
+            switch (token) {
+                case 102 /* VarKeyword */:
+                    break;
+                case 108 /* LetKeyword */:
+                    node.flags |= 1024 /* Let */;
+                    break;
+                case 74 /* ConstKeyword */:
+                    node.flags |= 2048 /* Const */;
+                    break;
+                default:
+                    ts.Debug.fail();
+            }
+            nextToken();
+            // The user may have written the following:
+            //
+            //    for (let of X) { }
+            //
+            // In this case, we want to parse an empty declaration list, and then parse 'of'
+            // as a keyword. The reason this is not automatic is that 'of' is a valid identifier.
+            // So we need to look ahead to determine if 'of' should be treated as a keyword in
+            // this context.
+            // The checker will then give an error that there is an empty declaration list.
+            if (token === 138 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) {
+                node.declarations = createMissingList();
+            }
+            else {
+                var savedDisallowIn = inDisallowInContext();
+                setDisallowInContext(inForStatementInitializer);
+                node.declarations = parseDelimitedList(8 /* VariableDeclarations */, parseVariableDeclaration);
+                setDisallowInContext(savedDisallowIn);
+            }
+            return finishNode(node);
+        }
+        function canFollowContextualOfKeyword() {
+            return nextTokenIsIdentifier() && nextToken() === 18 /* CloseParenToken */;
+        }
+        function parseVariableStatement(fullStart, decorators, modifiers) {
+            var node = createNode(200 /* VariableStatement */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
+            parseSemicolon();
+            return addJSDocComment(finishNode(node));
+        }
+        function parseFunctionDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(220 /* FunctionDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(87 /* FunctionKeyword */);
+            node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
+            node.name = node.flags & 512 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
+            var isGenerator = !!node.asteriskToken;
+            var isAsync = !!(node.flags & 256 /* Async */);
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
+            return addJSDocComment(finishNode(node));
+        }
+        function parseConstructorDeclaration(pos, decorators, modifiers) {
+            var node = createNode(148 /* Constructor */, pos);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(121 /* ConstructorKeyword */);
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false, ts.Diagnostics.or_expected);
+            return addJSDocComment(finishNode(node));
+        }
+        function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) {
+            var method = createNode(147 /* MethodDeclaration */, fullStart);
+            method.decorators = decorators;
+            setModifiers(method, modifiers);
+            method.asteriskToken = asteriskToken;
+            method.name = name;
+            method.questionToken = questionToken;
+            var isGenerator = !!asteriskToken;
+            var isAsync = !!(method.flags & 256 /* Async */);
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method);
+            method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
+            return addJSDocComment(finishNode(method));
+        }
+        function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) {
+            var property = createNode(145 /* PropertyDeclaration */, fullStart);
+            property.decorators = decorators;
+            setModifiers(property, modifiers);
+            property.name = name;
+            property.questionToken = questionToken;
+            property.type = parseTypeAnnotation();
+            // For instance properties specifically, since they are evaluated inside the constructor,
+            // we do *not * want to parse yield expressions, so we specifically turn the yield context
+            // off. The grammar would look something like this:
+            //
+            //    MemberVariableDeclaration[Yield]:
+            //        AccessibilityModifier_opt   PropertyName   TypeAnnotation_opt   Initializer_opt[In];
+            //        AccessibilityModifier_opt  static_opt  PropertyName   TypeAnnotation_opt   Initializer_opt[In, ?Yield];
+            //
+            // The checker may still error in the static case to explicitly disallow the yield expression.
+            property.initializer = modifiers && modifiers.flags & 32 /* Static */
+                ? allowInAnd(parseNonParameterInitializer)
+                : doOutsideOfContext(8388608 /* YieldContext */ | 4194304 /* DisallowInContext */, parseNonParameterInitializer);
+            parseSemicolon();
+            return finishNode(property);
+        }
+        function parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers) {
+            var asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
+            var name = parsePropertyName();
+            // Note: this is not legal as per the grammar.  But we allow it in the parser and
+            // report an error in the grammar checker.
+            var questionToken = parseOptionalToken(53 /* QuestionToken */);
+            if (asteriskToken || token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
+                return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected);
+            }
+            else {
+                return parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken);
+            }
+        }
+        function parseNonParameterInitializer() {
+            return parseInitializer(/*inParameter*/ false);
+        }
+        function parseAccessorDeclaration(kind, fullStart, decorators, modifiers) {
+            var node = createNode(kind, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            node.name = parsePropertyName();
+            fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false);
+            return finishNode(node);
+        }
+        function isClassMemberModifier(idToken) {
+            switch (idToken) {
+                case 112 /* PublicKeyword */:
+                case 110 /* PrivateKeyword */:
+                case 111 /* ProtectedKeyword */:
+                case 113 /* StaticKeyword */:
+                case 128 /* ReadonlyKeyword */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        function isClassMemberStart() {
+            var idToken;
+            if (token === 55 /* AtToken */) {
+                return true;
+            }
+            // Eat up all modifiers, but hold on to the last one in case it is actually an identifier.
+            while (ts.isModifierKind(token)) {
+                idToken = token;
+                // If the idToken is a class modifier (protected, private, public, and static), it is
+                // certain that we are starting to parse class member. This allows better error recovery
+                // Example:
+                //      public foo() ...     // true
+                //      public @dec blah ... // true; we will then report an error later
+                //      export public ...    // true; we will then report an error later
+                if (isClassMemberModifier(idToken)) {
+                    return true;
+                }
+                nextToken();
+            }
+            if (token === 37 /* AsteriskToken */) {
+                return true;
+            }
+            // Try to get the first property-like token following all modifiers.
+            // This can either be an identifier or the 'get' or 'set' keywords.
+            if (isLiteralPropertyName()) {
+                idToken = token;
+                nextToken();
+            }
+            // Index signatures and computed properties are class members; we can parse.
+            if (token === 19 /* OpenBracketToken */) {
+                return true;
+            }
+            // If we were able to get any potential identifier...
+            if (idToken !== undefined) {
+                // If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse.
+                if (!ts.isKeyword(idToken) || idToken === 131 /* SetKeyword */ || idToken === 123 /* GetKeyword */) {
+                    return true;
+                }
+                // If it *is* a keyword, but not an accessor, check a little farther along
+                // to see if it should actually be parsed as a class member.
+                switch (token) {
+                    case 17 /* OpenParenToken */: // Method declaration
+                    case 25 /* LessThanToken */: // Generic Method declaration
+                    case 54 /* ColonToken */: // Type Annotation for declaration
+                    case 56 /* EqualsToken */: // Initializer for declaration
+                    case 53 /* QuestionToken */:
+                        return true;
+                    default:
+                        // Covers
+                        //  - Semicolons     (declaration termination)
+                        //  - Closing braces (end-of-class, must be declaration)
+                        //  - End-of-files   (not valid, but permitted so that it gets caught later on)
+                        //  - Line-breaks    (enabling *automatic semicolon insertion*)
+                        return canParseSemicolon();
+                }
+            }
+            return false;
+        }
+        function parseDecorators() {
+            var decorators;
+            while (true) {
+                var decoratorStart = getNodePos();
+                if (!parseOptional(55 /* AtToken */)) {
+                    break;
+                }
+                if (!decorators) {
+                    decorators = [];
+                    decorators.pos = decoratorStart;
+                }
+                var decorator = createNode(143 /* Decorator */, decoratorStart);
+                decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
+                decorators.push(finishNode(decorator));
+            }
+            if (decorators) {
+                decorators.end = getNodeEnd();
+            }
+            return decorators;
+        }
+        /*
+         * There are situations in which a modifier like 'const' will appear unexpectedly, such as on a class member.
+         * In those situations, if we are entirely sure that 'const' is not valid on its own (such as when ASI takes effect
+         * and turns it into a standalone declaration), then it is better to parse it and report an error later.
+         *
+         * In such situations, 'permitInvalidConstAsModifier' should be set to true.
+         */
+        function parseModifiers(permitInvalidConstAsModifier) {
+            var flags = 0;
+            var modifiers;
+            while (true) {
+                var modifierStart = scanner.getStartPos();
+                var modifierKind = token;
+                if (token === 74 /* ConstKeyword */ && permitInvalidConstAsModifier) {
+                    // We need to ensure that any subsequent modifiers appear on the same line
+                    // so that when 'const' is a standalone declaration, we don't issue an error.
+                    if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
+                        break;
+                    }
+                }
+                else {
+                    if (!parseAnyContextualModifier()) {
+                        break;
+                    }
+                }
+                if (!modifiers) {
+                    modifiers = [];
+                    modifiers.pos = modifierStart;
+                }
+                flags |= ts.modifierToFlag(modifierKind);
+                modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
+            }
+            if (modifiers) {
+                modifiers.flags = flags;
+                modifiers.end = scanner.getStartPos();
+            }
+            return modifiers;
+        }
+        function parseModifiersForArrowFunction() {
+            var flags = 0;
+            var modifiers;
+            if (token === 118 /* AsyncKeyword */) {
+                var modifierStart = scanner.getStartPos();
+                var modifierKind = token;
+                nextToken();
+                modifiers = [];
+                modifiers.pos = modifierStart;
+                flags |= ts.modifierToFlag(modifierKind);
+                modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
+                modifiers.flags = flags;
+                modifiers.end = scanner.getStartPos();
+            }
+            return modifiers;
+        }
+        function parseClassElement() {
+            if (token === 23 /* SemicolonToken */) {
+                var result = createNode(198 /* SemicolonClassElement */);
+                nextToken();
+                return finishNode(result);
+            }
+            var fullStart = getNodePos();
+            var decorators = parseDecorators();
+            var modifiers = parseModifiers(/*permitInvalidConstAsModifier*/ true);
+            var accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
+            if (accessor) {
+                return accessor;
+            }
+            if (token === 121 /* ConstructorKeyword */) {
+                return parseConstructorDeclaration(fullStart, decorators, modifiers);
+            }
+            if (isIndexSignature()) {
+                return parseIndexSignatureDeclaration(fullStart, decorators, modifiers);
+            }
+            // It is very important that we check this *after* checking indexers because
+            // the [ token can start an index signature or a computed property name
+            if (ts.tokenIsIdentifierOrKeyword(token) ||
+                token === 9 /* StringLiteral */ ||
+                token === 8 /* NumericLiteral */ ||
+                token === 37 /* AsteriskToken */ ||
+                token === 19 /* OpenBracketToken */) {
+                return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers);
+            }
+            if (decorators || modifiers) {
+                // treat this as a property declaration with a missing name.
+                var name_7 = createMissingNode(69 /* Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected);
+                return parsePropertyDeclaration(fullStart, decorators, modifiers, name_7, /*questionToken*/ undefined);
+            }
+            // 'isClassMemberStart' should have hinted not to attempt parsing.
+            ts.Debug.fail("Should not have attempted to parse class member declaration.");
+        }
+        function parseClassExpression() {
+            return parseClassDeclarationOrExpression(
+            /*fullStart*/ scanner.getStartPos(), 
+            /*decorators*/ undefined, 
+            /*modifiers*/ undefined, 192 /* ClassExpression */);
+        }
+        function parseClassDeclaration(fullStart, decorators, modifiers) {
+            return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 221 /* ClassDeclaration */);
+        }
+        function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) {
+            var node = createNode(kind, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(73 /* ClassKeyword */);
+            node.name = parseNameOfClassDeclarationOrExpression();
+            node.typeParameters = parseTypeParameters();
+            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ true);
+            if (parseExpected(15 /* OpenBraceToken */)) {
+                // ClassTail[Yield,Await] : (Modified) See 14.5
+                //      ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
+                node.members = parseClassMembers();
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                node.members = createMissingList();
+            }
+            return finishNode(node);
+        }
+        function parseNameOfClassDeclarationOrExpression() {
+            // implements is a future reserved word so
+            // 'class implements' might mean either
+            // - class expression with omitted name, 'implements' starts heritage clause
+            // - class with name 'implements'
+            // 'isImplementsClause' helps to disambiguate between these two cases
+            return isIdentifier() && !isImplementsClause()
+                ? parseIdentifier()
+                : undefined;
+        }
+        function isImplementsClause() {
+            return token === 106 /* ImplementsKeyword */ && lookAhead(nextTokenIsIdentifierOrKeyword);
+        }
+        function parseHeritageClauses(isClassHeritageClause) {
+            // ClassTail[Yield,Await] : (Modified) See 14.5
+            //      ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
+            if (isHeritageClause()) {
+                return parseList(20 /* HeritageClauses */, parseHeritageClause);
+            }
+            return undefined;
+        }
+        function parseHeritageClause() {
+            if (token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */) {
+                var node = createNode(251 /* HeritageClause */);
+                node.token = token;
+                nextToken();
+                node.types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments);
+                return finishNode(node);
+            }
+            return undefined;
+        }
+        function parseExpressionWithTypeArguments() {
+            var node = createNode(194 /* ExpressionWithTypeArguments */);
+            node.expression = parseLeftHandSideExpressionOrHigher();
+            if (token === 25 /* LessThanToken */) {
+                node.typeArguments = parseBracketedList(18 /* TypeArguments */, parseType, 25 /* LessThanToken */, 27 /* GreaterThanToken */);
+            }
+            return finishNode(node);
+        }
+        function isHeritageClause() {
+            return token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */;
+        }
+        function parseClassMembers() {
+            return parseList(5 /* ClassMembers */, parseClassElement);
+        }
+        function parseInterfaceDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(222 /* InterfaceDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(107 /* InterfaceKeyword */);
+            node.name = parseIdentifier();
+            node.typeParameters = parseTypeParameters();
+            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ false);
+            node.members = parseObjectTypeMembers();
+            return finishNode(node);
+        }
+        function parseTypeAliasDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(223 /* TypeAliasDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(134 /* TypeKeyword */);
+            node.name = parseIdentifier();
+            node.typeParameters = parseTypeParameters();
+            parseExpected(56 /* EqualsToken */);
+            node.type = parseType();
+            parseSemicolon();
+            return finishNode(node);
+        }
+        // In an ambient declaration, the grammar only allows integer literals as initializers.
+        // In a non-ambient declaration, the grammar allows uninitialized members only in a
+        // ConstantEnumMemberSection, which starts at the beginning of an enum declaration
+        // or any time an integer literal initializer is encountered.
+        function parseEnumMember() {
+            var node = createNode(255 /* EnumMember */, scanner.getStartPos());
+            node.name = parsePropertyName();
+            node.initializer = allowInAnd(parseNonParameterInitializer);
+            return finishNode(node);
+        }
+        function parseEnumDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(224 /* EnumDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            parseExpected(81 /* EnumKeyword */);
+            node.name = parseIdentifier();
+            if (parseExpected(15 /* OpenBraceToken */)) {
+                node.members = parseDelimitedList(6 /* EnumMembers */, parseEnumMember);
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                node.members = createMissingList();
+            }
+            return finishNode(node);
+        }
+        function parseModuleBlock() {
+            var node = createNode(226 /* ModuleBlock */, scanner.getStartPos());
+            if (parseExpected(15 /* OpenBraceToken */)) {
+                node.statements = parseList(1 /* BlockStatements */, parseStatement);
+                parseExpected(16 /* CloseBraceToken */);
+            }
+            else {
+                node.statements = createMissingList();
+            }
+            return finishNode(node);
+        }
+        function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) {
+            var node = createNode(225 /* ModuleDeclaration */, fullStart);
+            // If we are parsing a dotted namespace name, we want to
+            // propagate the 'Namespace' flag across the names if set.
+            var namespaceFlag = flags & 4096 /* Namespace */;
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            node.flags |= flags;
+            node.name = parseIdentifier();
+            node.body = parseOptional(21 /* DotToken */)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 1 /* Export */ | namespaceFlag)
+                : parseModuleBlock();
+            return finishNode(node);
+        }
+        function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(225 /* ModuleDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            if (token === 137 /* GlobalKeyword */) {
+                // parse 'global' as name of global scope augmentation
+                node.name = parseIdentifier();
+                node.flags |= 131072 /* GlobalAugmentation */;
+            }
+            else {
+                node.name = parseLiteralNode(/*internName*/ true);
+            }
+            if (token === 15 /* OpenBraceToken */) {
+                node.body = parseModuleBlock();
+            }
+            else {
+                parseSemicolon();
+            }
+            return finishNode(node);
+        }
+        function parseModuleDeclaration(fullStart, decorators, modifiers) {
+            var flags = modifiers ? modifiers.flags : 0;
+            if (token === 137 /* GlobalKeyword */) {
+                // global augmentation
+                return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers);
+            }
+            else if (parseOptional(126 /* NamespaceKeyword */)) {
+                flags |= 4096 /* Namespace */;
+            }
+            else {
+                parseExpected(125 /* ModuleKeyword */);
+                if (token === 9 /* StringLiteral */) {
+                    return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers);
+                }
+            }
+            return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags);
+        }
+        function isExternalModuleReference() {
+            return token === 129 /* RequireKeyword */ &&
+                lookAhead(nextTokenIsOpenParen);
+        }
+        function nextTokenIsOpenParen() {
+            return nextToken() === 17 /* OpenParenToken */;
+        }
+        function nextTokenIsSlash() {
+            return nextToken() === 39 /* SlashToken */;
+        }
+        function parseNamespaceExportDeclaration(fullStart, decorators, modifiers) {
+            var exportDeclaration = createNode(228 /* NamespaceExportDeclaration */, fullStart);
+            exportDeclaration.decorators = decorators;
+            exportDeclaration.modifiers = modifiers;
+            parseExpected(116 /* AsKeyword */);
+            parseExpected(126 /* NamespaceKeyword */);
+            exportDeclaration.name = parseIdentifier();
+            parseExpected(23 /* SemicolonToken */);
+            return finishNode(exportDeclaration);
+        }
+        function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) {
+            parseExpected(89 /* ImportKeyword */);
+            var afterImportPos = scanner.getStartPos();
+            var identifier;
+            if (isIdentifier()) {
+                identifier = parseIdentifier();
+                if (token !== 24 /* CommaToken */ && token !== 136 /* FromKeyword */) {
+                    // ImportEquals declaration of type:
+                    // import x = require("mod"); or
+                    // import x = M.x;
+                    var importEqualsDeclaration = createNode(229 /* ImportEqualsDeclaration */, fullStart);
+                    importEqualsDeclaration.decorators = decorators;
+                    setModifiers(importEqualsDeclaration, modifiers);
+                    importEqualsDeclaration.name = identifier;
+                    parseExpected(56 /* EqualsToken */);
+                    importEqualsDeclaration.moduleReference = parseModuleReference();
+                    parseSemicolon();
+                    return finishNode(importEqualsDeclaration);
+                }
+            }
+            // Import statement
+            var importDeclaration = createNode(230 /* ImportDeclaration */, fullStart);
+            importDeclaration.decorators = decorators;
+            setModifiers(importDeclaration, modifiers);
+            // ImportDeclaration:
+            //  import ImportClause from ModuleSpecifier ;
+            //  import ModuleSpecifier;
+            if (identifier ||
+                token === 37 /* AsteriskToken */ ||
+                token === 15 /* OpenBraceToken */) {
+                importDeclaration.importClause = parseImportClause(identifier, afterImportPos);
+                parseExpected(136 /* FromKeyword */);
+            }
+            importDeclaration.moduleSpecifier = parseModuleSpecifier();
+            parseSemicolon();
+            return finishNode(importDeclaration);
+        }
+        function parseImportClause(identifier, fullStart) {
+            // ImportClause:
+            //  ImportedDefaultBinding
+            //  NameSpaceImport
+            //  NamedImports
+            //  ImportedDefaultBinding, NameSpaceImport
+            //  ImportedDefaultBinding, NamedImports
+            var importClause = createNode(231 /* ImportClause */, fullStart);
+            if (identifier) {
+                // ImportedDefaultBinding:
+                //  ImportedBinding
+                importClause.name = identifier;
+            }
+            // If there was no default import or if there is comma token after default import
+            // parse namespace or named imports
+            if (!importClause.name ||
+                parseOptional(24 /* CommaToken */)) {
+                importClause.namedBindings = token === 37 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(233 /* NamedImports */);
+            }
+            return finishNode(importClause);
+        }
+        function parseModuleReference() {
+            return isExternalModuleReference()
+                ? parseExternalModuleReference()
+                : parseEntityName(/*allowReservedWords*/ false);
+        }
+        function parseExternalModuleReference() {
+            var node = createNode(240 /* ExternalModuleReference */);
+            parseExpected(129 /* RequireKeyword */);
+            parseExpected(17 /* OpenParenToken */);
+            node.expression = parseModuleSpecifier();
+            parseExpected(18 /* CloseParenToken */);
+            return finishNode(node);
+        }
+        function parseModuleSpecifier() {
+            if (token === 9 /* StringLiteral */) {
+                var result = parseLiteralNode();
+                internIdentifier(result.text);
+                return result;
+            }
+            else {
+                // We allow arbitrary expressions here, even though the grammar only allows string
+                // literals.  We check to ensure that it is only a string literal later in the grammar
+                // check pass.
+                return parseExpression();
+            }
+        }
+        function parseNamespaceImport() {
+            // NameSpaceImport:
+            //  * as ImportedBinding
+            var namespaceImport = createNode(232 /* NamespaceImport */);
+            parseExpected(37 /* AsteriskToken */);
+            parseExpected(116 /* AsKeyword */);
+            namespaceImport.name = parseIdentifier();
+            return finishNode(namespaceImport);
+        }
+        function parseNamedImportsOrExports(kind) {
+            var node = createNode(kind);
+            // NamedImports:
+            //  { }
+            //  { ImportsList }
+            //  { ImportsList, }
+            // ImportsList:
+            //  ImportSpecifier
+            //  ImportsList, ImportSpecifier
+            node.elements = parseBracketedList(21 /* ImportOrExportSpecifiers */, kind === 233 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 15 /* OpenBraceToken */, 16 /* CloseBraceToken */);
+            return finishNode(node);
+        }
+        function parseExportSpecifier() {
+            return parseImportOrExportSpecifier(238 /* ExportSpecifier */);
+        }
+        function parseImportSpecifier() {
+            return parseImportOrExportSpecifier(234 /* ImportSpecifier */);
+        }
+        function parseImportOrExportSpecifier(kind) {
+            var node = createNode(kind);
+            // ImportSpecifier:
+            //   BindingIdentifier
+            //   IdentifierName as BindingIdentifier
+            // ExportSpecifier:
+            //   IdentifierName
+            //   IdentifierName as IdentifierName
+            var checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier();
+            var checkIdentifierStart = scanner.getTokenPos();
+            var checkIdentifierEnd = scanner.getTextPos();
+            var identifierName = parseIdentifierName();
+            if (token === 116 /* AsKeyword */) {
+                node.propertyName = identifierName;
+                parseExpected(116 /* AsKeyword */);
+                checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier();
+                checkIdentifierStart = scanner.getTokenPos();
+                checkIdentifierEnd = scanner.getTextPos();
+                node.name = parseIdentifierName();
+            }
+            else {
+                node.name = identifierName;
+            }
+            if (kind === 234 /* ImportSpecifier */ && checkIdentifierIsKeyword) {
+                // Report error identifier expected
+                parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected);
+            }
+            return finishNode(node);
+        }
+        function parseExportDeclaration(fullStart, decorators, modifiers) {
+            var node = createNode(236 /* ExportDeclaration */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            if (parseOptional(37 /* AsteriskToken */)) {
+                parseExpected(136 /* FromKeyword */);
+                node.moduleSpecifier = parseModuleSpecifier();
+            }
+            else {
+                node.exportClause = parseNamedImportsOrExports(237 /* NamedExports */);
+                // It is not uncommon to accidentally omit the 'from' keyword. Additionally, in editing scenarios,
+                // the 'from' keyword can be parsed as a named export when the export clause is unterminated (i.e. `export { from "moduleName";`)
+                // If we don't have a 'from' keyword, see if we have a string literal such that ASI won't take effect.
+                if (token === 136 /* FromKeyword */ || (token === 9 /* StringLiteral */ && !scanner.hasPrecedingLineBreak())) {
+                    parseExpected(136 /* FromKeyword */);
+                    node.moduleSpecifier = parseModuleSpecifier();
+                }
+            }
+            parseSemicolon();
+            return finishNode(node);
+        }
+        function parseExportAssignment(fullStart, decorators, modifiers) {
+            var node = createNode(235 /* ExportAssignment */, fullStart);
+            node.decorators = decorators;
+            setModifiers(node, modifiers);
+            if (parseOptional(56 /* EqualsToken */)) {
+                node.isExportEquals = true;
+            }
+            else {
+                parseExpected(77 /* DefaultKeyword */);
+            }
+            node.expression = parseAssignmentExpressionOrHigher();
+            parseSemicolon();
+            return finishNode(node);
+        }
+        function processReferenceComments(sourceFile) {
+            var triviaScanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ false, 0 /* Standard */, sourceText);
+            var referencedFiles = [];
+            var typeReferenceDirectives = [];
+            var amdDependencies = [];
+            var amdModuleName;
+            // Keep scanning all the leading trivia in the file until we get to something that
+            // isn't trivia.  Any single line comment will be analyzed to see if it is a
+            // reference comment.
+            while (true) {
+                var kind = triviaScanner.scan();
+                if (kind !== 2 /* SingleLineCommentTrivia */) {
+                    if (ts.isTrivia(kind)) {
+                        continue;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                var range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
+                var comment = sourceText.substring(range.pos, range.end);
+                var referencePathMatchResult = ts.getFileReferenceFromReferencePath(comment, range);
+                if (referencePathMatchResult) {
+                    var fileReference = referencePathMatchResult.fileReference;
+                    sourceFile.hasNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
+                    var diagnosticMessage = referencePathMatchResult.diagnosticMessage;
+                    if (fileReference) {
+                        if (referencePathMatchResult.isTypeReferenceDirective) {
+                            typeReferenceDirectives.push(fileReference);
+                        }
+                        else {
+                            referencedFiles.push(fileReference);
+                        }
+                    }
+                    if (diagnosticMessage) {
+                        parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, diagnosticMessage));
+                    }
+                }
+                else {
+                    var amdModuleNameRegEx = /^\/\/\/\s*<amd-module\s+name\s*=\s*('|")(.+?)\1/gim;
+                    var amdModuleNameMatchResult = amdModuleNameRegEx.exec(comment);
+                    if (amdModuleNameMatchResult) {
+                        if (amdModuleName) {
+                            parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments));
+                        }
+                        amdModuleName = amdModuleNameMatchResult[2];
+                    }
+                    var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s/gim;
+                    var pathRegex = /\spath\s*=\s*('|")(.+?)\1/gim;
+                    var nameRegex = /\sname\s*=\s*('|")(.+?)\1/gim;
+                    var amdDependencyMatchResult = amdDependencyRegEx.exec(comment);
+                    if (amdDependencyMatchResult) {
+                        var pathMatchResult = pathRegex.exec(comment);
+                        var nameMatchResult = nameRegex.exec(comment);
+                        if (pathMatchResult) {
+                            var amdDependency = { path: pathMatchResult[2], name: nameMatchResult ? nameMatchResult[2] : undefined };
+                            amdDependencies.push(amdDependency);
+                        }
+                    }
+                }
+            }
+            sourceFile.referencedFiles = referencedFiles;
+            sourceFile.typeReferenceDirectives = typeReferenceDirectives;
+            sourceFile.amdDependencies = amdDependencies;
+            sourceFile.moduleName = amdModuleName;
+        }
+        function setExternalModuleIndicator(sourceFile) {
+            sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
+                return node.flags & 1 /* Export */
+                    || node.kind === 229 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 240 /* ExternalModuleReference */
+                    || node.kind === 230 /* ImportDeclaration */
+                    || node.kind === 235 /* ExportAssignment */
+                    || node.kind === 236 /* ExportDeclaration */
+                    ? node
+                    : undefined;
+            });
+        }
+        var ParsingContext;
+        (function (ParsingContext) {
+            ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements";
+            ParsingContext[ParsingContext["BlockStatements"] = 1] = "BlockStatements";
+            ParsingContext[ParsingContext["SwitchClauses"] = 2] = "SwitchClauses";
+            ParsingContext[ParsingContext["SwitchClauseStatements"] = 3] = "SwitchClauseStatements";
+            ParsingContext[ParsingContext["TypeMembers"] = 4] = "TypeMembers";
+            ParsingContext[ParsingContext["ClassMembers"] = 5] = "ClassMembers";
+            ParsingContext[ParsingContext["EnumMembers"] = 6] = "EnumMembers";
+            ParsingContext[ParsingContext["HeritageClauseElement"] = 7] = "HeritageClauseElement";
+            ParsingContext[ParsingContext["VariableDeclarations"] = 8] = "VariableDeclarations";
+            ParsingContext[ParsingContext["ObjectBindingElements"] = 9] = "ObjectBindingElements";
+            ParsingContext[ParsingContext["ArrayBindingElements"] = 10] = "ArrayBindingElements";
+            ParsingContext[ParsingContext["ArgumentExpressions"] = 11] = "ArgumentExpressions";
+            ParsingContext[ParsingContext["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers";
+            ParsingContext[ParsingContext["JsxAttributes"] = 13] = "JsxAttributes";
+            ParsingContext[ParsingContext["JsxChildren"] = 14] = "JsxChildren";
+            ParsingContext[ParsingContext["ArrayLiteralMembers"] = 15] = "ArrayLiteralMembers";
+            ParsingContext[ParsingContext["Parameters"] = 16] = "Parameters";
+            ParsingContext[ParsingContext["TypeParameters"] = 17] = "TypeParameters";
+            ParsingContext[ParsingContext["TypeArguments"] = 18] = "TypeArguments";
+            ParsingContext[ParsingContext["TupleElementTypes"] = 19] = "TupleElementTypes";
+            ParsingContext[ParsingContext["HeritageClauses"] = 20] = "HeritageClauses";
+            ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 21] = "ImportOrExportSpecifiers";
+            ParsingContext[ParsingContext["JSDocFunctionParameters"] = 22] = "JSDocFunctionParameters";
+            ParsingContext[ParsingContext["JSDocTypeArguments"] = 23] = "JSDocTypeArguments";
+            ParsingContext[ParsingContext["JSDocRecordMembers"] = 24] = "JSDocRecordMembers";
+            ParsingContext[ParsingContext["JSDocTupleTypes"] = 25] = "JSDocTupleTypes";
+            ParsingContext[ParsingContext["Count"] = 26] = "Count"; // Number of parsing contexts
+        })(ParsingContext || (ParsingContext = {}));
+        var Tristate;
+        (function (Tristate) {
+            Tristate[Tristate["False"] = 0] = "False";
+            Tristate[Tristate["True"] = 1] = "True";
+            Tristate[Tristate["Unknown"] = 2] = "Unknown";
+        })(Tristate || (Tristate = {}));
+        var JSDocParser;
+        (function (JSDocParser) {
+            function isJSDocType() {
+                switch (token) {
+                    case 37 /* AsteriskToken */:
+                    case 53 /* QuestionToken */:
+                    case 17 /* OpenParenToken */:
+                    case 19 /* OpenBracketToken */:
+                    case 49 /* ExclamationToken */:
+                    case 15 /* OpenBraceToken */:
+                    case 87 /* FunctionKeyword */:
+                    case 22 /* DotDotDotToken */:
+                    case 92 /* NewKeyword */:
+                    case 97 /* ThisKeyword */:
+                        return true;
+                }
+                return ts.tokenIsIdentifierOrKeyword(token);
+            }
+            JSDocParser.isJSDocType = isJSDocType;
+            function parseJSDocTypeExpressionForTests(content, start, length) {
+                initializeState("file.js", content, 2 /* Latest */, /*_syntaxCursor:*/ undefined, 1 /* JS */);
+                scanner.setText(content, start, length);
+                token = scanner.scan();
+                var jsDocTypeExpression = parseJSDocTypeExpression();
+                var diagnostics = parseDiagnostics;
+                clearState();
+                return jsDocTypeExpression ? { jsDocTypeExpression: jsDocTypeExpression, diagnostics: diagnostics } : undefined;
+            }
+            JSDocParser.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
+            // Parses out a JSDoc type expression.
+            /* @internal */
+            function parseJSDocTypeExpression() {
+                var result = createNode(257 /* JSDocTypeExpression */, scanner.getTokenPos());
+                parseExpected(15 /* OpenBraceToken */);
+                result.type = parseJSDocTopLevelType();
+                parseExpected(16 /* CloseBraceToken */);
+                fixupParentReferences(result);
+                return finishNode(result);
+            }
+            JSDocParser.parseJSDocTypeExpression = parseJSDocTypeExpression;
+            function parseJSDocTopLevelType() {
+                var type = parseJSDocType();
+                if (token === 47 /* BarToken */) {
+                    var unionType = createNode(261 /* JSDocUnionType */, type.pos);
+                    unionType.types = parseJSDocTypeList(type);
+                    type = finishNode(unionType);
+                }
+                if (token === 56 /* EqualsToken */) {
+                    var optionalType = createNode(268 /* JSDocOptionalType */, type.pos);
+                    nextToken();
+                    optionalType.type = type;
+                    type = finishNode(optionalType);
+                }
+                return type;
+            }
+            function parseJSDocType() {
+                var type = parseBasicTypeExpression();
+                while (true) {
+                    if (token === 19 /* OpenBracketToken */) {
+                        var arrayType = createNode(260 /* JSDocArrayType */, type.pos);
+                        arrayType.elementType = type;
+                        nextToken();
+                        parseExpected(20 /* CloseBracketToken */);
+                        type = finishNode(arrayType);
+                    }
+                    else if (token === 53 /* QuestionToken */) {
+                        var nullableType = createNode(263 /* JSDocNullableType */, type.pos);
+                        nullableType.type = type;
+                        nextToken();
+                        type = finishNode(nullableType);
+                    }
+                    else if (token === 49 /* ExclamationToken */) {
+                        var nonNullableType = createNode(264 /* JSDocNonNullableType */, type.pos);
+                        nonNullableType.type = type;
+                        nextToken();
+                        type = finishNode(nonNullableType);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                return type;
+            }
+            function parseBasicTypeExpression() {
+                switch (token) {
+                    case 37 /* AsteriskToken */:
+                        return parseJSDocAllType();
+                    case 53 /* QuestionToken */:
+                        return parseJSDocUnknownOrNullableType();
+                    case 17 /* OpenParenToken */:
+                        return parseJSDocUnionType();
+                    case 19 /* OpenBracketToken */:
+                        return parseJSDocTupleType();
+                    case 49 /* ExclamationToken */:
+                        return parseJSDocNonNullableType();
+                    case 15 /* OpenBraceToken */:
+                        return parseJSDocRecordType();
+                    case 87 /* FunctionKeyword */:
+                        return parseJSDocFunctionType();
+                    case 22 /* DotDotDotToken */:
+                        return parseJSDocVariadicType();
+                    case 92 /* NewKeyword */:
+                        return parseJSDocConstructorType();
+                    case 97 /* ThisKeyword */:
+                        return parseJSDocThisType();
+                    case 117 /* AnyKeyword */:
+                    case 132 /* StringKeyword */:
+                    case 130 /* NumberKeyword */:
+                    case 120 /* BooleanKeyword */:
+                    case 133 /* SymbolKeyword */:
+                    case 103 /* VoidKeyword */:
+                        return parseTokenNode();
+                }
+                // TODO (drosen): Parse string literal types in JSDoc as well.
+                return parseJSDocTypeReference();
+            }
+            function parseJSDocThisType() {
+                var result = createNode(272 /* JSDocThisType */);
+                nextToken();
+                parseExpected(54 /* ColonToken */);
+                result.type = parseJSDocType();
+                return finishNode(result);
+            }
+            function parseJSDocConstructorType() {
+                var result = createNode(271 /* JSDocConstructorType */);
+                nextToken();
+                parseExpected(54 /* ColonToken */);
+                result.type = parseJSDocType();
+                return finishNode(result);
+            }
+            function parseJSDocVariadicType() {
+                var result = createNode(270 /* JSDocVariadicType */);
+                nextToken();
+                result.type = parseJSDocType();
+                return finishNode(result);
+            }
+            function parseJSDocFunctionType() {
+                var result = createNode(269 /* JSDocFunctionType */);
+                nextToken();
+                parseExpected(17 /* OpenParenToken */);
+                result.parameters = parseDelimitedList(22 /* JSDocFunctionParameters */, parseJSDocParameter);
+                checkForTrailingComma(result.parameters);
+                parseExpected(18 /* CloseParenToken */);
+                if (token === 54 /* ColonToken */) {
+                    nextToken();
+                    result.type = parseJSDocType();
+                }
+                return finishNode(result);
+            }
+            function parseJSDocParameter() {
+                var parameter = createNode(142 /* Parameter */);
+                parameter.type = parseJSDocType();
+                if (parseOptional(56 /* EqualsToken */)) {
+                    parameter.questionToken = createNode(56 /* EqualsToken */);
+                }
+                return finishNode(parameter);
+            }
+            function parseJSDocTypeReference() {
+                var result = createNode(267 /* JSDocTypeReference */);
+                result.name = parseSimplePropertyName();
+                if (token === 25 /* LessThanToken */) {
+                    result.typeArguments = parseTypeArguments();
+                }
+                else {
+                    while (parseOptional(21 /* DotToken */)) {
+                        if (token === 25 /* LessThanToken */) {
+                            result.typeArguments = parseTypeArguments();
+                            break;
+                        }
+                        else {
+                            result.name = parseQualifiedName(result.name);
+                        }
+                    }
+                }
+                return finishNode(result);
+            }
+            function parseTypeArguments() {
+                // Move past the <
+                nextToken();
+                var typeArguments = parseDelimitedList(23 /* JSDocTypeArguments */, parseJSDocType);
+                checkForTrailingComma(typeArguments);
+                checkForEmptyTypeArgumentList(typeArguments);
+                parseExpected(27 /* GreaterThanToken */);
+                return typeArguments;
+            }
+            function checkForEmptyTypeArgumentList(typeArguments) {
+                if (parseDiagnostics.length === 0 && typeArguments && typeArguments.length === 0) {
+                    var start = typeArguments.pos - "<".length;
+                    var end = ts.skipTrivia(sourceText, typeArguments.end) + ">".length;
+                    return parseErrorAtPosition(start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty);
+                }
+            }
+            function parseQualifiedName(left) {
+                var result = createNode(139 /* QualifiedName */, left.pos);
+                result.left = left;
+                result.right = parseIdentifierName();
+                return finishNode(result);
+            }
+            function parseJSDocRecordType() {
+                var result = createNode(265 /* JSDocRecordType */);
+                nextToken();
+                result.members = parseDelimitedList(24 /* JSDocRecordMembers */, parseJSDocRecordMember);
+                checkForTrailingComma(result.members);
+                parseExpected(16 /* CloseBraceToken */);
+                return finishNode(result);
+            }
+            function parseJSDocRecordMember() {
+                var result = createNode(266 /* JSDocRecordMember */);
+                result.name = parseSimplePropertyName();
+                if (token === 54 /* ColonToken */) {
+                    nextToken();
+                    result.type = parseJSDocType();
+                }
+                return finishNode(result);
+            }
+            function parseJSDocNonNullableType() {
+                var result = createNode(264 /* JSDocNonNullableType */);
+                nextToken();
+                result.type = parseJSDocType();
+                return finishNode(result);
+            }
+            function parseJSDocTupleType() {
+                var result = createNode(262 /* JSDocTupleType */);
+                nextToken();
+                result.types = parseDelimitedList(25 /* JSDocTupleTypes */, parseJSDocType);
+                checkForTrailingComma(result.types);
+                parseExpected(20 /* CloseBracketToken */);
+                return finishNode(result);
+            }
+            function checkForTrailingComma(list) {
+                if (parseDiagnostics.length === 0 && list.hasTrailingComma) {
+                    var start = list.end - ",".length;
+                    parseErrorAtPosition(start, ",".length, ts.Diagnostics.Trailing_comma_not_allowed);
+                }
+            }
+            function parseJSDocUnionType() {
+                var result = createNode(261 /* JSDocUnionType */);
+                nextToken();
+                result.types = parseJSDocTypeList(parseJSDocType());
+                parseExpected(18 /* CloseParenToken */);
+                return finishNode(result);
+            }
+            function parseJSDocTypeList(firstType) {
+                ts.Debug.assert(!!firstType);
+                var types = [];
+                types.pos = firstType.pos;
+                types.push(firstType);
+                while (parseOptional(47 /* BarToken */)) {
+                    types.push(parseJSDocType());
+                }
+                types.end = scanner.getStartPos();
+                return types;
+            }
+            function parseJSDocAllType() {
+                var result = createNode(258 /* JSDocAllType */);
+                nextToken();
+                return finishNode(result);
+            }
+            function parseJSDocUnknownOrNullableType() {
+                var pos = scanner.getStartPos();
+                // skip the ?
+                nextToken();
+                // Need to lookahead to decide if this is a nullable or unknown type.
+                // Here are cases where we'll pick the unknown type:
+                //
+                //      Foo(?,
+                //      { a: ? }
+                //      Foo(?)
+                //      Foo<?>
+                //      Foo(?=
+                //      (?|
+                if (token === 24 /* CommaToken */ ||
+                    token === 16 /* CloseBraceToken */ ||
+                    token === 18 /* CloseParenToken */ ||
+                    token === 27 /* GreaterThanToken */ ||
+                    token === 56 /* EqualsToken */ ||
+                    token === 47 /* BarToken */) {
+                    var result = createNode(259 /* JSDocUnknownType */, pos);
+                    return finishNode(result);
+                }
+                else {
+                    var result = createNode(263 /* JSDocNullableType */, pos);
+                    result.type = parseJSDocType();
+                    return finishNode(result);
+                }
+            }
+            function parseIsolatedJSDocComment(content, start, length) {
+                initializeState("file.js", content, 2 /* Latest */, /*_syntaxCursor:*/ undefined, 1 /* JS */);
+                sourceFile = { languageVariant: 0 /* Standard */, text: content };
+                var jsDocComment = parseJSDocCommentWorker(start, length);
+                var diagnostics = parseDiagnostics;
+                clearState();
+                return jsDocComment ? { jsDocComment: jsDocComment, diagnostics: diagnostics } : undefined;
+            }
+            JSDocParser.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
+            function parseJSDocComment(parent, start, length) {
+                var saveToken = token;
+                var saveParseDiagnosticsLength = parseDiagnostics.length;
+                var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+                var comment = parseJSDocCommentWorker(start, length);
+                if (comment) {
+                    comment.parent = parent;
+                }
+                token = saveToken;
+                parseDiagnostics.length = saveParseDiagnosticsLength;
+                parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
+                return comment;
+            }
+            JSDocParser.parseJSDocComment = parseJSDocComment;
+            function parseJSDocCommentWorker(start, length) {
+                var content = sourceText;
+                start = start || 0;
+                var end = length === undefined ? content.length : start + length;
+                length = end - start;
+                ts.Debug.assert(start >= 0);
+                ts.Debug.assert(start <= end);
+                ts.Debug.assert(end <= content.length);
+                var tags;
+                var result;
+                // Check for /** (JSDoc opening part)
+                if (content.charCodeAt(start) === 47 /* slash */ &&
+                    content.charCodeAt(start + 1) === 42 /* asterisk */ &&
+                    content.charCodeAt(start + 2) === 42 /* asterisk */ &&
+                    content.charCodeAt(start + 3) !== 42 /* asterisk */) {
+                    // + 3 for leading /**, - 5 in total for /** */
+                    scanner.scanRange(start + 3, length - 5, function () {
+                        // Initially we can parse out a tag.  We also have seen a starting asterisk.
+                        // This is so that /** * @type */ doesn't parse.
+                        var canParseTag = true;
+                        var seenAsterisk = true;
+                        nextJSDocToken();
+                        while (token !== 1 /* EndOfFileToken */) {
+                            switch (token) {
+                                case 55 /* AtToken */:
+                                    if (canParseTag) {
+                                        parseTag();
+                                    }
+                                    // This will take us to the end of the line, so it's OK to parse a tag on the next pass through the loop
+                                    seenAsterisk = false;
+                                    break;
+                                case 4 /* NewLineTrivia */:
+                                    // After a line break, we can parse a tag, and we haven't seen an asterisk on the next line yet
+                                    canParseTag = true;
+                                    seenAsterisk = false;
+                                    break;
+                                case 37 /* AsteriskToken */:
+                                    if (seenAsterisk) {
+                                        // If we've already seen an asterisk, then we can no longer parse a tag on this line
+                                        canParseTag = false;
+                                    }
+                                    // Ignore the first asterisk on a line
+                                    seenAsterisk = true;
+                                    break;
+                                case 69 /* Identifier */:
+                                    // Anything else is doc comment text.  We can't do anything with it.  Because it
+                                    // wasn't a tag, we can no longer parse a tag on this line until we hit the next
+                                    // line break.
+                                    canParseTag = false;
+                                    break;
+                                case 1 /* EndOfFileToken */:
+                                    break;
+                            }
+                            nextJSDocToken();
+                        }
+                        result = createJSDocComment();
+                    });
+                }
+                return result;
+                function createJSDocComment() {
+                    if (!tags) {
+                        return undefined;
+                    }
+                    var result = createNode(273 /* JSDocComment */, start);
+                    result.tags = tags;
+                    return finishNode(result, end);
+                }
+                function skipWhitespace() {
+                    while (token === 5 /* WhitespaceTrivia */ || token === 4 /* NewLineTrivia */) {
+                        nextJSDocToken();
+                    }
+                }
+                function parseTag() {
+                    ts.Debug.assert(token === 55 /* AtToken */);
+                    var atToken = createNode(55 /* AtToken */, scanner.getTokenPos());
+                    atToken.end = scanner.getTextPos();
+                    nextJSDocToken();
+                    var tagName = parseJSDocIdentifierName();
+                    if (!tagName) {
+                        return;
+                    }
+                    var tag = handleTag(atToken, tagName) || handleUnknownTag(atToken, tagName);
+                    addTag(tag);
+                }
+                function handleTag(atToken, tagName) {
+                    if (tagName) {
+                        switch (tagName.text) {
+                            case "param":
+                                return handleParamTag(atToken, tagName);
+                            case "return":
+                            case "returns":
+                                return handleReturnTag(atToken, tagName);
+                            case "template":
+                                return handleTemplateTag(atToken, tagName);
+                            case "type":
+                                return handleTypeTag(atToken, tagName);
+                            case "typedef":
+                                return handleTypedefTag(atToken, tagName);
+                        }
+                    }
+                    return undefined;
+                }
+                function handleUnknownTag(atToken, tagName) {
+                    var result = createNode(274 /* JSDocTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    return finishNode(result);
+                }
+                function addTag(tag) {
+                    if (tag) {
+                        if (!tags) {
+                            tags = [];
+                            tags.pos = tag.pos;
+                        }
+                        tags.push(tag);
+                        tags.end = tag.end;
+                    }
+                }
+                function tryParseTypeExpression() {
+                    if (token !== 15 /* OpenBraceToken */) {
+                        return undefined;
+                    }
+                    var typeExpression = parseJSDocTypeExpression();
+                    return typeExpression;
+                }
+                function handleParamTag(atToken, tagName) {
+                    var typeExpression = tryParseTypeExpression();
+                    skipWhitespace();
+                    var name;
+                    var isBracketed;
+                    // Looking for something like '[foo]' or 'foo'
+                    if (parseOptionalToken(19 /* OpenBracketToken */)) {
+                        name = parseJSDocIdentifierName();
+                        isBracketed = true;
+                        // May have an optional default, e.g. '[foo = 42]'
+                        if (parseOptionalToken(56 /* EqualsToken */)) {
+                            parseExpression();
+                        }
+                        parseExpected(20 /* CloseBracketToken */);
+                    }
+                    else if (ts.tokenIsIdentifierOrKeyword(token)) {
+                        name = parseJSDocIdentifierName();
+                    }
+                    if (!name) {
+                        parseErrorAtPosition(scanner.getStartPos(), 0, ts.Diagnostics.Identifier_expected);
+                        return undefined;
+                    }
+                    var preName, postName;
+                    if (typeExpression) {
+                        postName = name;
+                    }
+                    else {
+                        preName = name;
+                    }
+                    if (!typeExpression) {
+                        typeExpression = tryParseTypeExpression();
+                    }
+                    var result = createNode(275 /* JSDocParameterTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.preParameterName = preName;
+                    result.typeExpression = typeExpression;
+                    result.postParameterName = postName;
+                    result.isBracketed = isBracketed;
+                    return finishNode(result);
+                }
+                function handleReturnTag(atToken, tagName) {
+                    if (ts.forEach(tags, function (t) { return t.kind === 276 /* JSDocReturnTag */; })) {
+                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
+                    }
+                    var result = createNode(276 /* JSDocReturnTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.typeExpression = tryParseTypeExpression();
+                    return finishNode(result);
+                }
+                function handleTypeTag(atToken, tagName) {
+                    if (ts.forEach(tags, function (t) { return t.kind === 277 /* JSDocTypeTag */; })) {
+                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
+                    }
+                    var result = createNode(277 /* JSDocTypeTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.typeExpression = tryParseTypeExpression();
+                    return finishNode(result);
+                }
+                function handlePropertyTag(atToken, tagName) {
+                    var typeExpression = tryParseTypeExpression();
+                    skipWhitespace();
+                    var name = parseJSDocIdentifierName();
+                    if (!name) {
+                        parseErrorAtPosition(scanner.getStartPos(), /*length*/ 0, ts.Diagnostics.Identifier_expected);
+                        return undefined;
+                    }
+                    var result = createNode(280 /* JSDocPropertyTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.name = name;
+                    result.typeExpression = typeExpression;
+                    return finishNode(result);
+                }
+                function handleTypedefTag(atToken, tagName) {
+                    var typeExpression = tryParseTypeExpression();
+                    skipWhitespace();
+                    var typedefTag = createNode(279 /* JSDocTypedefTag */, atToken.pos);
+                    typedefTag.atToken = atToken;
+                    typedefTag.tagName = tagName;
+                    typedefTag.name = parseJSDocIdentifierName();
+                    typedefTag.typeExpression = typeExpression;
+                    if (typeExpression) {
+                        if (typeExpression.type.kind === 267 /* JSDocTypeReference */) {
+                            var jsDocTypeReference = typeExpression.type;
+                            if (jsDocTypeReference.name.kind === 69 /* Identifier */) {
+                                var name_8 = jsDocTypeReference.name;
+                                if (name_8.text === "Object") {
+                                    typedefTag.jsDocTypeLiteral = scanChildTags();
+                                }
+                            }
+                        }
+                        if (!typedefTag.jsDocTypeLiteral) {
+                            typedefTag.jsDocTypeLiteral = typeExpression.type;
+                        }
+                    }
+                    else {
+                        typedefTag.jsDocTypeLiteral = scanChildTags();
+                    }
+                    return finishNode(typedefTag);
+                    function scanChildTags() {
+                        var jsDocTypeLiteral = createNode(281 /* JSDocTypeLiteral */, scanner.getStartPos());
+                        var resumePos = scanner.getStartPos();
+                        var canParseTag = true;
+                        var seenAsterisk = false;
+                        var parentTagTerminated = false;
+                        while (token !== 1 /* EndOfFileToken */ && !parentTagTerminated) {
+                            nextJSDocToken();
+                            switch (token) {
+                                case 55 /* AtToken */:
+                                    if (canParseTag) {
+                                        parentTagTerminated = !tryParseChildTag(jsDocTypeLiteral);
+                                    }
+                                    seenAsterisk = false;
+                                    break;
+                                case 4 /* NewLineTrivia */:
+                                    resumePos = scanner.getStartPos() - 1;
+                                    canParseTag = true;
+                                    seenAsterisk = false;
+                                    break;
+                                case 37 /* AsteriskToken */:
+                                    if (seenAsterisk) {
+                                        canParseTag = false;
+                                    }
+                                    seenAsterisk = true;
+                                    break;
+                                case 69 /* Identifier */:
+                                    canParseTag = false;
+                                case 1 /* EndOfFileToken */:
+                                    break;
+                            }
+                        }
+                        scanner.setTextPos(resumePos);
+                        return finishNode(jsDocTypeLiteral);
+                    }
+                }
+                function tryParseChildTag(parentTag) {
+                    ts.Debug.assert(token === 55 /* AtToken */);
+                    var atToken = createNode(55 /* AtToken */, scanner.getStartPos());
+                    atToken.end = scanner.getTextPos();
+                    nextJSDocToken();
+                    var tagName = parseJSDocIdentifierName();
+                    if (!tagName) {
+                        return false;
+                    }
+                    switch (tagName.text) {
+                        case "type":
+                            if (parentTag.jsDocTypeTag) {
+                                // already has a @type tag, terminate the parent tag now.
+                                return false;
+                            }
+                            parentTag.jsDocTypeTag = handleTypeTag(atToken, tagName);
+                            return true;
+                        case "prop":
+                        case "property":
+                            if (!parentTag.jsDocPropertyTags) {
+                                parentTag.jsDocPropertyTags = [];
+                            }
+                            var propertyTag = handlePropertyTag(atToken, tagName);
+                            parentTag.jsDocPropertyTags.push(propertyTag);
+                            return true;
+                    }
+                    return false;
+                }
+                function handleTemplateTag(atToken, tagName) {
+                    if (ts.forEach(tags, function (t) { return t.kind === 278 /* JSDocTemplateTag */; })) {
+                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
+                    }
+                    // Type parameter list looks like '@template T,U,V'
+                    var typeParameters = [];
+                    typeParameters.pos = scanner.getStartPos();
+                    while (true) {
+                        var name_9 = parseJSDocIdentifierName();
+                        if (!name_9) {
+                            parseErrorAtPosition(scanner.getStartPos(), 0, ts.Diagnostics.Identifier_expected);
+                            return undefined;
+                        }
+                        var typeParameter = createNode(141 /* TypeParameter */, name_9.pos);
+                        typeParameter.name = name_9;
+                        finishNode(typeParameter);
+                        typeParameters.push(typeParameter);
+                        if (token === 24 /* CommaToken */) {
+                            nextJSDocToken();
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    var result = createNode(278 /* JSDocTemplateTag */, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.typeParameters = typeParameters;
+                    finishNode(result);
+                    typeParameters.end = result.end;
+                    return result;
+                }
+                function nextJSDocToken() {
+                    return token = scanner.scanJSDocToken();
+                }
+                function parseJSDocIdentifierName() {
+                    return createJSDocIdentifier(ts.tokenIsIdentifierOrKeyword(token));
+                }
+                function createJSDocIdentifier(isIdentifier) {
+                    if (!isIdentifier) {
+                        parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
+                        return undefined;
+                    }
+                    var pos = scanner.getTokenPos();
+                    var end = scanner.getTextPos();
+                    var result = createNode(69 /* Identifier */, pos);
+                    result.text = content.substring(pos, end);
+                    finishNode(result, end);
+                    nextJSDocToken();
+                    return result;
+                }
+            }
+            JSDocParser.parseJSDocCommentWorker = parseJSDocCommentWorker;
+        })(JSDocParser = Parser.JSDocParser || (Parser.JSDocParser = {}));
+    })(Parser || (Parser = {}));
+    var IncrementalParser;
+    (function (IncrementalParser) {
+        function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
+            aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2 /* Aggressive */);
+            checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks);
+            if (ts.textChangeRangeIsUnchanged(textChangeRange)) {
+                // if the text didn't change, then we can just return our current source file as-is.
+                return sourceFile;
+            }
+            if (sourceFile.statements.length === 0) {
+                // If we don't have any statements in the current source file, then there's no real
+                // way to incrementally parse.  So just do a full parse instead.
+                return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setParentNodes*/ true, sourceFile.scriptKind);
+            }
+            // Make sure we're not trying to incrementally update a source file more than once.  Once
+            // we do an update the original source file is considered unusable from that point onwards.
+            //
+            // This is because we do incremental parsing in-place.  i.e. we take nodes from the old
+            // tree and give them new positions and parents.  From that point on, trusting the old
+            // tree at all is not possible as far too much of it may violate invariants.
+            var incrementalSourceFile = sourceFile;
+            ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
+            incrementalSourceFile.hasBeenIncrementallyParsed = true;
+            var oldText = sourceFile.text;
+            var syntaxCursor = createSyntaxCursor(sourceFile);
+            // Make the actual change larger so that we know to reparse anything whose lookahead
+            // might have intersected the change.
+            var changeRange = extendToAffectedRange(sourceFile, textChangeRange);
+            checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
+            // Ensure that extending the affected range only moved the start of the change range
+            // earlier in the file.
+            ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start);
+            ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span));
+            ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)));
+            // The is the amount the nodes after the edit range need to be adjusted.  It can be
+            // positive (if the edit added characters), negative (if the edit deleted characters)
+            // or zero (if this was a pure overwrite with nothing added/removed).
+            var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
+            // If we added or removed characters during the edit, then we need to go and adjust all
+            // the nodes after the edit.  Those nodes may move forward (if we inserted chars) or they
+            // may move backward (if we deleted chars).
+            //
+            // Doing this helps us out in two ways.  First, it means that any nodes/tokens we want
+            // to reuse are already at the appropriate position in the new text.  That way when we
+            // reuse them, we don't have to figure out if they need to be adjusted.  Second, it makes
+            // it very easy to determine if we can reuse a node.  If the node's position is at where
+            // we are in the text, then we can reuse it.  Otherwise we can't.  If the node's position
+            // is ahead of us, then we'll need to rescan tokens.  If the node's position is behind
+            // us, then we'll need to skip it or crumble it as appropriate
+            //
+            // We will also adjust the positions of nodes that intersect the change range as well.
+            // By doing this, we ensure that all the positions in the old tree are consistent, not
+            // just the positions of nodes entirely before/after the change range.  By being
+            // consistent, we can then easily map from positions to nodes in the old tree easily.
+            //
+            // Also, mark any syntax elements that intersect the changed span.  We know, up front,
+            // that we cannot reuse these elements.
+            updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks);
+            // Now that we've set up our internal incremental state just proceed and parse the
+            // source file in the normal fashion.  When possible the parser will retrieve and
+            // reuse nodes from the old tree.
+            //
+            // Note: passing in 'true' for setNodeParents is very important.  When incrementally
+            // parsing, we will be reusing nodes from the old tree, and placing it into new
+            // parents.  If we don't set the parents now, we'll end up with an observably
+            // inconsistent tree.  Setting the parents on the new tree should be very fast.  We
+            // will immediately bail out of walking any subtrees when we can see that their parents
+            // are already correct.
+            var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /*setParentNodes*/ true, sourceFile.scriptKind);
+            return result;
+        }
+        IncrementalParser.updateSourceFile = updateSourceFile;
+        function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) {
+            if (isArray) {
+                visitArray(element);
+            }
+            else {
+                visitNode(element);
+            }
+            return;
+            function visitNode(node) {
+                var text = "";
+                if (aggressiveChecks && shouldCheckNode(node)) {
+                    text = oldText.substring(node.pos, node.end);
+                }
+                // Ditch any existing LS children we may have created.  This way we can avoid
+                // moving them forward.
+                if (node._children) {
+                    node._children = undefined;
+                }
+                node.pos += delta;
+                node.end += delta;
+                if (aggressiveChecks && shouldCheckNode(node)) {
+                    ts.Debug.assert(text === newText.substring(node.pos, node.end));
+                }
+                forEachChild(node, visitNode, visitArray);
+                if (node.jsDocComments) {
+                    for (var _i = 0, _a = node.jsDocComments; _i < _a.length; _i++) {
+                        var jsDocComment = _a[_i];
+                        forEachChild(jsDocComment, visitNode, visitArray);
+                    }
+                }
+                checkNodePositions(node, aggressiveChecks);
+            }
+            function visitArray(array) {
+                array._children = undefined;
+                array.pos += delta;
+                array.end += delta;
+                for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+                    var node = array_8[_i];
+                    visitNode(node);
+                }
+            }
+        }
+        function shouldCheckNode(node) {
+            switch (node.kind) {
+                case 9 /* StringLiteral */:
+                case 8 /* NumericLiteral */:
+                case 69 /* Identifier */:
+                    return true;
+            }
+            return false;
+        }
+        function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) {
+            ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range");
+            ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range");
+            ts.Debug.assert(element.pos <= element.end);
+            // We have an element that intersects the change range in some way.  It may have its
+            // start, or its end (or both) in the changed range.  We want to adjust any part
+            // that intersects such that the final tree is in a consistent state.  i.e. all
+            // children have spans within the span of their parent, and all siblings are ordered
+            // properly.
+            // We may need to update both the 'pos' and the 'end' of the element.
+            // If the 'pos' is before the start of the change, then we don't need to touch it.
+            // If it isn't, then the 'pos' must be inside the change.  How we update it will
+            // depend if delta is  positive or negative.  If delta is positive then we have
+            // something like:
+            //
+            //  -------------------AAA-----------------
+            //  -------------------BBBCCCCCCC-----------------
+            //
+            // In this case, we consider any node that started in the change range to still be
+            // starting at the same position.
+            //
+            // however, if the delta is negative, then we instead have something like this:
+            //
+            //  -------------------XXXYYYYYYY-----------------
+            //  -------------------ZZZ-----------------
+            //
+            // In this case, any element that started in the 'X' range will keep its position.
+            // However any element that started after that will have their pos adjusted to be
+            // at the end of the new range.  i.e. any node that started in the 'Y' range will
+            // be adjusted to have their start at the end of the 'Z' range.
+            //
+            // The element will keep its position if possible.  Or Move backward to the new-end
+            // if it's in the 'Y' range.
+            element.pos = Math.min(element.pos, changeRangeNewEnd);
+            // If the 'end' is after the change range, then we always adjust it by the delta
+            // amount.  However, if the end is in the change range, then how we adjust it
+            // will depend on if delta is  positive or negative.  If delta is positive then we
+            // have something like:
+            //
+            //  -------------------AAA-----------------
+            //  -------------------BBBCCCCCCC-----------------
+            //
+            // In this case, we consider any node that ended inside the change range to keep its
+            // end position.
+            //
+            // however, if the delta is negative, then we instead have something like this:
+            //
+            //  -------------------XXXYYYYYYY-----------------
+            //  -------------------ZZZ-----------------
+            //
+            // In this case, any element that ended in the 'X' range will keep its position.
+            // However any element that ended after that will have their pos adjusted to be
+            // at the end of the new range.  i.e. any node that ended in the 'Y' range will
+            // be adjusted to have their end at the end of the 'Z' range.
+            if (element.end >= changeRangeOldEnd) {
+                // Element ends after the change range.  Always adjust the end pos.
+                element.end += delta;
+            }
+            else {
+                // Element ends in the change range.  The element will keep its position if
+                // possible. Or Move backward to the new-end if it's in the 'Y' range.
+                element.end = Math.min(element.end, changeRangeNewEnd);
+            }
+            ts.Debug.assert(element.pos <= element.end);
+            if (element.parent) {
+                ts.Debug.assert(element.pos >= element.parent.pos);
+                ts.Debug.assert(element.end <= element.parent.end);
+            }
+        }
+        function checkNodePositions(node, aggressiveChecks) {
+            if (aggressiveChecks) {
+                var pos_2 = node.pos;
+                forEachChild(node, function (child) {
+                    ts.Debug.assert(child.pos >= pos_2);
+                    pos_2 = child.end;
+                });
+                ts.Debug.assert(pos_2 <= node.end);
+            }
+        }
+        function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) {
+            visitNode(sourceFile);
+            return;
+            function visitNode(child) {
+                ts.Debug.assert(child.pos <= child.end);
+                if (child.pos > changeRangeOldEnd) {
+                    // Node is entirely past the change range.  We need to move both its pos and
+                    // end, forward or backward appropriately.
+                    moveElementEntirelyPastChangeRange(child, /*isArray*/ false, delta, oldText, newText, aggressiveChecks);
+                    return;
+                }
+                // Check if the element intersects the change range.  If it does, then it is not
+                // reusable.  Also, we'll need to recurse to see what constituent portions we may
+                // be able to use.
+                var fullEnd = child.end;
+                if (fullEnd >= changeStart) {
+                    child.intersectsChange = true;
+                    child._children = undefined;
+                    // Adjust the pos or end (or both) of the intersecting element accordingly.
+                    adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
+                    forEachChild(child, visitNode, visitArray);
+                    checkNodePositions(child, aggressiveChecks);
+                    return;
+                }
+                // Otherwise, the node is entirely before the change range.  No need to do anything with it.
+                ts.Debug.assert(fullEnd < changeStart);
+            }
+            function visitArray(array) {
+                ts.Debug.assert(array.pos <= array.end);
+                if (array.pos > changeRangeOldEnd) {
+                    // Array is entirely after the change range.  We need to move it, and move any of
+                    // its children.
+                    moveElementEntirelyPastChangeRange(array, /*isArray*/ true, delta, oldText, newText, aggressiveChecks);
+                    return;
+                }
+                // Check if the element intersects the change range.  If it does, then it is not
+                // reusable.  Also, we'll need to recurse to see what constituent portions we may
+                // be able to use.
+                var fullEnd = array.end;
+                if (fullEnd >= changeStart) {
+                    array.intersectsChange = true;
+                    array._children = undefined;
+                    // Adjust the pos or end (or both) of the intersecting array accordingly.
+                    adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
+                    for (var _i = 0, array_9 = array; _i < array_9.length; _i++) {
+                        var node = array_9[_i];
+                        visitNode(node);
+                    }
+                    return;
+                }
+                // Otherwise, the array is entirely before the change range.  No need to do anything with it.
+                ts.Debug.assert(fullEnd < changeStart);
+            }
+        }
+        function extendToAffectedRange(sourceFile, changeRange) {
+            // Consider the following code:
+            //      void foo() { /; }
+            //
+            // If the text changes with an insertion of / just before the semicolon then we end up with:
+            //      void foo() { //; }
+            //
+            // If we were to just use the changeRange a is, then we would not rescan the { token
+            // (as it does not intersect the actual original change range).  Because an edit may
+            // change the token touching it, we actually need to look back *at least* one token so
+            // that the prior token sees that change.
+            var maxLookahead = 1;
+            var start = changeRange.span.start;
+            // the first iteration aligns us with the change start. subsequent iteration move us to
+            // the left by maxLookahead tokens.  We only need to do this as long as we're not at the
+            // start of the tree.
+            for (var i = 0; start > 0 && i <= maxLookahead; i++) {
+                var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
+                ts.Debug.assert(nearestNode.pos <= start);
+                var position = nearestNode.pos;
+                start = Math.max(0, position - 1);
+            }
+            var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span));
+            var finalLength = changeRange.newLength + (changeRange.span.start - start);
+            return ts.createTextChangeRange(finalSpan, finalLength);
+        }
+        function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) {
+            var bestResult = sourceFile;
+            var lastNodeEntirelyBeforePosition;
+            forEachChild(sourceFile, visit);
+            if (lastNodeEntirelyBeforePosition) {
+                var lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition);
+                if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
+                    bestResult = lastChildOfLastEntireNodeBeforePosition;
+                }
+            }
+            return bestResult;
+            function getLastChild(node) {
+                while (true) {
+                    var lastChild = getLastChildWorker(node);
+                    if (lastChild) {
+                        node = lastChild;
+                    }
+                    else {
+                        return node;
+                    }
+                }
+            }
+            function getLastChildWorker(node) {
+                var last = undefined;
+                forEachChild(node, function (child) {
+                    if (ts.nodeIsPresent(child)) {
+                        last = child;
+                    }
+                });
+                return last;
+            }
+            function visit(child) {
+                if (ts.nodeIsMissing(child)) {
+                    // Missing nodes are effectively invisible to us.  We never even consider them
+                    // When trying to find the nearest node before us.
+                    return;
+                }
+                // If the child intersects this position, then this node is currently the nearest
+                // node that starts before the position.
+                if (child.pos <= position) {
+                    if (child.pos >= bestResult.pos) {
+                        // This node starts before the position, and is closer to the position than
+                        // the previous best node we found.  It is now the new best node.
+                        bestResult = child;
+                    }
+                    // Now, the node may overlap the position, or it may end entirely before the
+                    // position.  If it overlaps with the position, then either it, or one of its
+                    // children must be the nearest node before the position.  So we can just
+                    // recurse into this child to see if we can find something better.
+                    if (position < child.end) {
+                        // The nearest node is either this child, or one of the children inside
+                        // of it.  We've already marked this child as the best so far.  Recurse
+                        // in case one of the children is better.
+                        forEachChild(child, visit);
+                        // Once we look at the children of this node, then there's no need to
+                        // continue any further.
+                        return true;
+                    }
+                    else {
+                        ts.Debug.assert(child.end <= position);
+                        // The child ends entirely before this position.  Say you have the following
+                        // (where $ is the position)
+                        //
+                        //      <complex expr 1> ? <complex expr 2> $ : <...> <...>
+                        //
+                        // We would want to find the nearest preceding node in "complex expr 2".
+                        // To support that, we keep track of this node, and once we're done searching
+                        // for a best node, we recurse down this node to see if we can find a good
+                        // result in it.
+                        //
+                        // This approach allows us to quickly skip over nodes that are entirely
+                        // before the position, while still allowing us to find any nodes in the
+                        // last one that might be what we want.
+                        lastNodeEntirelyBeforePosition = child;
+                    }
+                }
+                else {
+                    ts.Debug.assert(child.pos > position);
+                    // We're now at a node that is entirely past the position we're searching for.
+                    // This node (and all following nodes) could never contribute to the result,
+                    // so just skip them by returning 'true' here.
+                    return true;
+                }
+            }
+        }
+        function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) {
+            var oldText = sourceFile.text;
+            if (textChangeRange) {
+                ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length);
+                if (aggressiveChecks || ts.Debug.shouldAssert(3 /* VeryAggressive */)) {
+                    var oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
+                    var newTextPrefix = newText.substr(0, textChangeRange.span.start);
+                    ts.Debug.assert(oldTextPrefix === newTextPrefix);
+                    var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length);
+                    var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length);
+                    ts.Debug.assert(oldTextSuffix === newTextSuffix);
+                }
+            }
+        }
+        function createSyntaxCursor(sourceFile) {
+            var currentArray = sourceFile.statements;
+            var currentArrayIndex = 0;
+            ts.Debug.assert(currentArrayIndex < currentArray.length);
+            var current = currentArray[currentArrayIndex];
+            var lastQueriedPosition = -1 /* Value */;
+            return {
+                currentNode: function (position) {
+                    // Only compute the current node if the position is different than the last time
+                    // we were asked.  The parser commonly asks for the node at the same position
+                    // twice.  Once to know if can read an appropriate list element at a certain point,
+                    // and then to actually read and consume the node.
+                    if (position !== lastQueriedPosition) {
+                        // Much of the time the parser will need the very next node in the array that
+                        // we just returned a node from.So just simply check for that case and move
+                        // forward in the array instead of searching for the node again.
+                        if (current && current.end === position && currentArrayIndex < (currentArray.length - 1)) {
+                            currentArrayIndex++;
+                            current = currentArray[currentArrayIndex];
+                        }
+                        // If we don't have a node, or the node we have isn't in the right position,
+                        // then try to find a viable node at the position requested.
+                        if (!current || current.pos !== position) {
+                            findHighestListElementThatStartsAtPosition(position);
+                        }
+                    }
+                    // Cache this query so that we don't do any extra work if the parser calls back
+                    // into us.  Note: this is very common as the parser will make pairs of calls like
+                    // 'isListElement -> parseListElement'.  If we were unable to find a node when
+                    // called with 'isListElement', we don't want to redo the work when parseListElement
+                    // is called immediately after.
+                    lastQueriedPosition = position;
+                    // Either we don'd have a node, or we have a node at the position being asked for.
+                    ts.Debug.assert(!current || current.pos === position);
+                    return current;
+                }
+            };
+            // Finds the highest element in the tree we can find that starts at the provided position.
+            // The element must be a direct child of some node list in the tree.  This way after we
+            // return it, we can easily return its next sibling in the list.
+            function findHighestListElementThatStartsAtPosition(position) {
+                // Clear out any cached state about the last node we found.
+                currentArray = undefined;
+                currentArrayIndex = -1 /* Value */;
+                current = undefined;
+                // Recurse into the source file to find the highest node at this position.
+                forEachChild(sourceFile, visitNode, visitArray);
+                return;
+                function visitNode(node) {
+                    if (position >= node.pos && position < node.end) {
+                        // Position was within this node.  Keep searching deeper to find the node.
+                        forEachChild(node, visitNode, visitArray);
+                        // don't proceed any further in the search.
+                        return true;
+                    }
+                    // position wasn't in this node, have to keep searching.
+                    return false;
+                }
+                function visitArray(array) {
+                    if (position >= array.pos && position < array.end) {
+                        // position was in this array.  Search through this array to see if we find a
+                        // viable element.
+                        for (var i = 0, n = array.length; i < n; i++) {
+                            var child = array[i];
+                            if (child) {
+                                if (child.pos === position) {
+                                    // Found the right node.  We're done.
+                                    currentArray = array;
+                                    currentArrayIndex = i;
+                                    current = child;
+                                    return true;
+                                }
+                                else {
+                                    if (child.pos < position && position < child.end) {
+                                        // Position in somewhere within this child.  Search in it and
+                                        // stop searching in this array.
+                                        forEachChild(child, visitNode, visitArray);
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // position wasn't in this array, have to keep searching.
+                    return false;
+                }
+            }
+        }
+        var InvalidPosition;
+        (function (InvalidPosition) {
+            InvalidPosition[InvalidPosition["Value"] = -1] = "Value";
+        })(InvalidPosition || (InvalidPosition = {}));
+    })(IncrementalParser || (IncrementalParser = {}));
+})(ts || (ts = {}));
+/// <reference path="utilities.ts"/>
+/// <reference path="parser.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    ts.bindTime = 0;
+    (function (ModuleInstanceState) {
+        ModuleInstanceState[ModuleInstanceState["NonInstantiated"] = 0] = "NonInstantiated";
+        ModuleInstanceState[ModuleInstanceState["Instantiated"] = 1] = "Instantiated";
+        ModuleInstanceState[ModuleInstanceState["ConstEnumOnly"] = 2] = "ConstEnumOnly";
+    })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {}));
+    var ModuleInstanceState = ts.ModuleInstanceState;
+    function getModuleInstanceState(node) {
+        // A module is uninstantiated if it contains only
+        // 1. interface declarations, type alias declarations
+        if (node.kind === 222 /* InterfaceDeclaration */ || node.kind === 223 /* TypeAliasDeclaration */) {
+            return 0 /* NonInstantiated */;
+        }
+        else if (ts.isConstEnumDeclaration(node)) {
+            return 2 /* ConstEnumOnly */;
+        }
+        else if ((node.kind === 230 /* ImportDeclaration */ || node.kind === 229 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) {
+            return 0 /* NonInstantiated */;
+        }
+        else if (node.kind === 226 /* ModuleBlock */) {
+            var state_1 = 0 /* NonInstantiated */;
+            ts.forEachChild(node, function (n) {
+                switch (getModuleInstanceState(n)) {
+                    case 0 /* NonInstantiated */:
+                        // child is non-instantiated - continue searching
+                        return false;
+                    case 2 /* ConstEnumOnly */:
+                        // child is const enum only - record state and continue searching
+                        state_1 = 2 /* ConstEnumOnly */;
+                        return false;
+                    case 1 /* Instantiated */:
+                        // child is instantiated - record state and stop
+                        state_1 = 1 /* Instantiated */;
+                        return true;
+                }
+            });
+            return state_1;
+        }
+        else if (node.kind === 225 /* ModuleDeclaration */) {
+            var body = node.body;
+            return body ? getModuleInstanceState(body) : 1 /* Instantiated */;
+        }
+        else {
+            return 1 /* Instantiated */;
+        }
+    }
+    ts.getModuleInstanceState = getModuleInstanceState;
+    var ContainerFlags;
+    (function (ContainerFlags) {
+        // The current node is not a container, and no container manipulation should happen before
+        // recursing into it.
+        ContainerFlags[ContainerFlags["None"] = 0] = "None";
+        // The current node is a container.  It should be set as the current container (and block-
+        // container) before recursing into it.  The current node does not have locals.  Examples:
+        //
+        //      Classes, ObjectLiterals, TypeLiterals, Interfaces...
+        ContainerFlags[ContainerFlags["IsContainer"] = 1] = "IsContainer";
+        // The current node is a block-scoped-container.  It should be set as the current block-
+        // container before recursing into it.  Examples:
+        //
+        //      Blocks (when not parented by functions), Catch clauses, For/For-in/For-of statements...
+        ContainerFlags[ContainerFlags["IsBlockScopedContainer"] = 2] = "IsBlockScopedContainer";
+        // The current node is the container of a control flow path. The current control flow should
+        // be saved and restored, and a new control flow initialized within the container.
+        ContainerFlags[ContainerFlags["IsControlFlowContainer"] = 4] = "IsControlFlowContainer";
+        ContainerFlags[ContainerFlags["IsFunctionLike"] = 8] = "IsFunctionLike";
+        ContainerFlags[ContainerFlags["IsFunctionExpression"] = 16] = "IsFunctionExpression";
+        ContainerFlags[ContainerFlags["HasLocals"] = 32] = "HasLocals";
+        ContainerFlags[ContainerFlags["IsInterface"] = 64] = "IsInterface";
+    })(ContainerFlags || (ContainerFlags = {}));
+    var binder = createBinder();
+    function bindSourceFile(file, options) {
+        var start = new Date().getTime();
+        binder(file, options);
+        ts.bindTime += new Date().getTime() - start;
+    }
+    ts.bindSourceFile = bindSourceFile;
+    function createBinder() {
+        var file;
+        var options;
+        var languageVersion;
+        var parent;
+        var container;
+        var blockScopeContainer;
+        var lastContainer;
+        var seenThisKeyword;
+        // state used by control flow analysis
+        var currentFlow;
+        var currentBreakTarget;
+        var currentContinueTarget;
+        var currentReturnTarget;
+        var currentTrueTarget;
+        var currentFalseTarget;
+        var preSwitchCaseFlow;
+        var activeLabels;
+        var hasExplicitReturn;
+        // state used for emit helpers
+        var emitFlags;
+        // If this file is an external module, then it is automatically in strict-mode according to
+        // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
+        // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
+        var inStrictMode;
+        var symbolCount = 0;
+        var Symbol;
+        var classifiableNames;
+        var unreachableFlow = { flags: 1 /* Unreachable */ };
+        var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
+        function bindSourceFile(f, opts) {
+            file = f;
+            options = opts;
+            languageVersion = ts.getEmitScriptTarget(options);
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            symbolCount = 0;
+            Symbol = ts.objectAllocator.getSymbolConstructor();
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+            file = undefined;
+            options = undefined;
+            languageVersion = undefined;
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            currentFlow = undefined;
+            currentBreakTarget = undefined;
+            currentContinueTarget = undefined;
+            currentReturnTarget = undefined;
+            currentTrueTarget = undefined;
+            currentFalseTarget = undefined;
+            activeLabels = undefined;
+            hasExplicitReturn = false;
+            emitFlags = 0 /* None */;
+        }
+        return bindSourceFile;
+        function createSymbol(flags, name) {
+            symbolCount++;
+            return new Symbol(flags, name);
+        }
+        function addDeclarationToSymbol(symbol, node, symbolFlags) {
+            symbol.flags |= symbolFlags;
+            node.symbol = symbol;
+            if (!symbol.declarations) {
+                symbol.declarations = [];
+            }
+            symbol.declarations.push(node);
+            if (symbolFlags & 1952 /* HasExports */ && !symbol.exports) {
+                symbol.exports = {};
+            }
+            if (symbolFlags & 6240 /* HasMembers */ && !symbol.members) {
+                symbol.members = {};
+            }
+            if (symbolFlags & 107455 /* Value */) {
+                var valueDeclaration = symbol.valueDeclaration;
+                if (!valueDeclaration ||
+                    (valueDeclaration.kind !== node.kind && valueDeclaration.kind === 225 /* ModuleDeclaration */)) {
+                    // other kinds of value declarations take precedence over modules
+                    symbol.valueDeclaration = node;
+                }
+            }
+        }
+        // Should not be called on a declaration with a computed property name,
+        // unless it is a well known Symbol.
+        function getDeclarationName(node) {
+            if (node.name) {
+                if (ts.isAmbientModule(node)) {
+                    return ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + node.name.text + "\"";
+                }
+                if (node.name.kind === 140 /* ComputedPropertyName */) {
+                    var nameExpression = node.name.expression;
+                    // treat computed property names where expression is string/numeric literal as just string/numeric literal
+                    if (ts.isStringOrNumericLiteral(nameExpression.kind)) {
+                        return nameExpression.text;
+                    }
+                    ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression));
+                    return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text);
+                }
+                return node.name.text;
+            }
+            switch (node.kind) {
+                case 148 /* Constructor */:
+                    return "__constructor";
+                case 156 /* FunctionType */:
+                case 151 /* CallSignature */:
+                    return "__call";
+                case 157 /* ConstructorType */:
+                case 152 /* ConstructSignature */:
+                    return "__new";
+                case 153 /* IndexSignature */:
+                    return "__index";
+                case 236 /* ExportDeclaration */:
+                    return "__export";
+                case 235 /* ExportAssignment */:
+                    return node.isExportEquals ? "export=" : "default";
+                case 187 /* BinaryExpression */:
+                    switch (ts.getSpecialPropertyAssignmentKind(node)) {
+                        case 2 /* ModuleExports */:
+                            // module.exports = ...
+                            return "export=";
+                        case 1 /* ExportsProperty */:
+                        case 4 /* ThisProperty */:
+                            // exports.x = ... or this.y = ...
+                            return node.left.name.text;
+                        case 3 /* PrototypeProperty */:
+                            // className.prototype.methodName = ...
+                            return node.left.expression.name.text;
+                    }
+                    ts.Debug.fail("Unknown binary declaration kind");
+                    break;
+                case 220 /* FunctionDeclaration */:
+                case 221 /* ClassDeclaration */:
+                    return node.flags & 512 /* Default */ ? "default" : undefined;
+                case 269 /* JSDocFunctionType */:
+                    return ts.isJSDocConstructSignature(node) ? "__new" : "__call";
+                case 142 /* Parameter */:
+                    // Parameters with names are handled at the top of this function.  Parameters
+                    // without names can only come from JSDocFunctionTypes.
+                    ts.Debug.assert(node.parent.kind === 269 /* JSDocFunctionType */);
+                    var functionType = node.parent;
+                    var index = ts.indexOf(functionType.parameters, node);
+                    return "p" + index;
+                case 279 /* JSDocTypedefTag */:
+                    var parentNode = node.parent && node.parent.parent;
+                    var nameFromParentNode = void 0;
+                    if (parentNode && parentNode.kind === 200 /* VariableStatement */) {
+                        if (parentNode.declarationList.declarations.length > 0) {
+                            var nameIdentifier = parentNode.declarationList.declarations[0].name;
+                            if (nameIdentifier.kind === 69 /* Identifier */) {
+                                nameFromParentNode = nameIdentifier.text;
+                            }
+                        }
+                    }
+                    return nameFromParentNode;
+            }
+        }
+        function getDisplayName(node) {
+            return node.name ? ts.declarationNameToString(node.name) : getDeclarationName(node);
+        }
+        /**
+         * Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names.
+         * @param symbolTable - The symbol table which node will be added to.
+         * @param parent - node's parent declaration.
+         * @param node - The declaration to be added to the symbol table
+         * @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.)
+         * @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations.
+         */
+        function declareSymbol(symbolTable, parent, node, includes, excludes) {
+            ts.Debug.assert(!ts.hasDynamicName(node));
+            var isDefaultExport = node.flags & 512 /* Default */;
+            // The exported symbol for an export default function/class node is always named "default"
+            var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
+            var symbol;
+            if (name !== undefined) {
+                // Check and see if the symbol table already has a symbol with this name.  If not,
+                // create a new symbol with this name and add it to the table.  Note that we don't
+                // give the new symbol any flags *yet*.  This ensures that it will not conflict
+                // with the 'excludes' flags we pass in.
+                //
+                // If we do get an existing symbol, see if it conflicts with the new symbol we're
+                // creating.  For example, a 'var' symbol and a 'class' symbol will conflict within
+                // the same symbol table.  If we have a conflict, report the issue on each
+                // declaration we have for this symbol, and then create a new symbol for this
+                // declaration.
+                //
+                // If we created a new symbol, either because we didn't have a symbol with this name
+                // in the symbol table, or we conflicted with an existing symbol, then just add this
+                // node as the sole declaration of the new symbol.
+                //
+                // Otherwise, we'll be merging into a compatible existing symbol (for example when
+                // you have multiple 'vars' with the same name in the same container).  In this case
+                // just add this node into the declarations list of the symbol.
+                symbol = ts.hasProperty(symbolTable, name)
+                    ? symbolTable[name]
+                    : (symbolTable[name] = createSymbol(0 /* None */, name));
+                if (name && (includes & 788448 /* Classifiable */)) {
+                    classifiableNames[name] = name;
+                }
+                if (symbol.flags & excludes) {
+                    if (node.name) {
+                        node.name.parent = node;
+                    }
+                    // Report errors every position with duplicate declaration
+                    // Report errors on previous encountered declarations
+                    var message_1 = symbol.flags & 2 /* BlockScopedVariable */
+                        ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
+                        : ts.Diagnostics.Duplicate_identifier_0;
+                    ts.forEach(symbol.declarations, function (declaration) {
+                        if (declaration.flags & 512 /* Default */) {
+                            message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
+                        }
+                    });
+                    ts.forEach(symbol.declarations, function (declaration) {
+                        file.bindDiagnostics.push(ts.createDiagnosticForNode(declaration.name || declaration, message_1, getDisplayName(declaration)));
+                    });
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(node.name || node, message_1, getDisplayName(node)));
+                    symbol = createSymbol(0 /* None */, name);
+                }
+            }
+            else {
+                symbol = createSymbol(0 /* None */, "__missing");
+            }
+            addDeclarationToSymbol(symbol, node, includes);
+            symbol.parent = parent;
+            return symbol;
+        }
+        function declareModuleMember(node, symbolFlags, symbolExcludes) {
+            var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */;
+            if (symbolFlags & 8388608 /* Alias */) {
+                if (node.kind === 238 /* ExportSpecifier */ || (node.kind === 229 /* ImportEqualsDeclaration */ && hasExportModifier)) {
+                    return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+                }
+                else {
+                    return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
+                }
+            }
+            else {
+                // Exported module members are given 2 symbols: A local symbol that is classified with an ExportValue,
+                // ExportType, or ExportContainer flag, and an associated export symbol with all the correct flags set
+                // on it. There are 2 main reasons:
+                //
+                //   1. We treat locals and exports of the same name as mutually exclusive within a container.
+                //      That means the binder will issue a Duplicate Identifier error if you mix locals and exports
+                //      with the same name in the same container.
+                //      TODO: Make this a more specific error and decouple it from the exclusion logic.
+                //   2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol,
+                //      but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way
+                //      when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.
+                // NOTE: Nested ambient modules always should go to to 'locals' table to prevent their automatic merge
+                //       during global merging in the checker. Why? The only case when ambient module is permitted inside another module is module augmentation
+                //       and this case is specially handled. Module augmentations should only be merged with original module definition
+                //       and should never be merged directly with other augmentation, and the latter case would be possible if automatic merge is allowed.
+                if (!ts.isAmbientModule(node) && (hasExportModifier || container.flags & 8192 /* ExportContext */)) {
+                    var exportKind = (symbolFlags & 107455 /* Value */ ? 1048576 /* ExportValue */ : 0) |
+                        (symbolFlags & 793056 /* Type */ ? 2097152 /* ExportType */ : 0) |
+                        (symbolFlags & 1536 /* Namespace */ ? 4194304 /* ExportNamespace */ : 0);
+                    var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
+                    local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+                    node.localSymbol = local;
+                    return local;
+                }
+                else {
+                    return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
+                }
+            }
+        }
+        // All container nodes are kept on a linked list in declaration order. This list is used by
+        // the getLocalNameOfContainer function in the type checker to validate that the local name
+        // used for a container is unique.
+        function bindContainer(node, containerFlags) {
+            // Before we recurse into a node's children, we first save the existing parent, container
+            // and block-container.  Then after we pop out of processing the children, we restore
+            // these saved values.
+            var saveContainer = container;
+            var savedBlockScopeContainer = blockScopeContainer;
+            // Depending on what kind of node this is, we may have to adjust the current container
+            // and block-container.   If the current node is a container, then it is automatically
+            // considered the current block-container as well.  Also, for containers that we know
+            // may contain locals, we proactively initialize the .locals field. We do this because
+            // it's highly likely that the .locals will be needed to place some child in (for example,
+            // a parameter, or variable declaration).
+            //
+            // However, we do not proactively create the .locals for block-containers because it's
+            // totally normal and common for block-containers to never actually have a block-scoped
+            // variable in them.  We don't want to end up allocating an object for every 'block' we
+            // run into when most of them won't be necessary.
+            //
+            // Finally, if this is a block-container, then we clear out any existing .locals object
+            // it may contain within it.  This happens in incremental scenarios.  Because we can be
+            // reusing a node from a previous compilation, that node may have had 'locals' created
+            // for it.  We must clear this so we don't accidentally move any stale data forward from
+            // a previous compilation.
+            if (containerFlags & 1 /* IsContainer */) {
+                container = blockScopeContainer = node;
+                if (containerFlags & 32 /* HasLocals */) {
+                    container.locals = {};
+                }
+                addToContainerChain(container);
+            }
+            else if (containerFlags & 2 /* IsBlockScopedContainer */) {
+                blockScopeContainer = node;
+                blockScopeContainer.locals = undefined;
+            }
+            if (containerFlags & 4 /* IsControlFlowContainer */) {
+                var saveCurrentFlow = currentFlow;
+                var saveBreakTarget = currentBreakTarget;
+                var saveContinueTarget = currentContinueTarget;
+                var saveReturnTarget = currentReturnTarget;
+                var saveActiveLabels = activeLabels;
+                var saveHasExplicitReturn = hasExplicitReturn;
+                var isIIFE = containerFlags & 16 /* IsFunctionExpression */ && !!ts.getImmediatelyInvokedFunctionExpression(node);
+                // An IIFE is considered part of the containing control flow. Return statements behave
+                // similarly to break statements that exit to a label just past the statement body.
+                if (isIIFE) {
+                    currentReturnTarget = createBranchLabel();
+                }
+                else {
+                    currentFlow = { flags: 2 /* Start */ };
+                    if (containerFlags & 16 /* IsFunctionExpression */) {
+                        currentFlow.container = node;
+                    }
+                    currentReturnTarget = undefined;
+                }
+                currentBreakTarget = undefined;
+                currentContinueTarget = undefined;
+                activeLabels = undefined;
+                hasExplicitReturn = false;
+                bindChildren(node);
+                // Reset all reachability check related flags on node (for incremental scenarios)
+                // Reset all emit helper flags on node (for incremental scenarios)
+                node.flags &= ~4030464 /* ReachabilityAndEmitFlags */;
+                if (!(currentFlow.flags & 1 /* Unreachable */) && containerFlags & 8 /* IsFunctionLike */ && ts.nodeIsPresent(node.body)) {
+                    node.flags |= 32768 /* HasImplicitReturn */;
+                    if (hasExplicitReturn)
+                        node.flags |= 65536 /* HasExplicitReturn */;
+                }
+                if (node.kind === 256 /* SourceFile */) {
+                    node.flags |= emitFlags;
+                }
+                if (isIIFE) {
+                    addAntecedent(currentReturnTarget, currentFlow);
+                    currentFlow = finishFlowLabel(currentReturnTarget);
+                }
+                else {
+                    currentFlow = saveCurrentFlow;
+                }
+                currentBreakTarget = saveBreakTarget;
+                currentContinueTarget = saveContinueTarget;
+                currentReturnTarget = saveReturnTarget;
+                activeLabels = saveActiveLabels;
+                hasExplicitReturn = saveHasExplicitReturn;
+            }
+            else if (containerFlags & 64 /* IsInterface */) {
+                seenThisKeyword = false;
+                bindChildren(node);
+                node.flags = seenThisKeyword ? node.flags | 16384 /* ContainsThis */ : node.flags & ~16384 /* ContainsThis */;
+            }
+            else {
+                bindChildren(node);
+            }
+            container = saveContainer;
+            blockScopeContainer = savedBlockScopeContainer;
+        }
+        function bindChildren(node) {
+            // Binding of JsDocComment should be done before the current block scope container changes.
+            // because the scope of JsDocComment should not be affected by whether the current node is a
+            // container or not.
+            if (ts.isInJavaScriptFile(node) && node.jsDocComments) {
+                for (var _i = 0, _a = node.jsDocComments; _i < _a.length; _i++) {
+                    var jsDocComment = _a[_i];
+                    bind(jsDocComment);
+                }
+            }
+            if (checkUnreachable(node)) {
+                ts.forEachChild(node, bind);
+                return;
+            }
+            switch (node.kind) {
+                case 205 /* WhileStatement */:
+                    bindWhileStatement(node);
+                    break;
+                case 204 /* DoStatement */:
+                    bindDoStatement(node);
+                    break;
+                case 206 /* ForStatement */:
+                    bindForStatement(node);
+                    break;
+                case 207 /* ForInStatement */:
+                case 208 /* ForOfStatement */:
+                    bindForInOrForOfStatement(node);
+                    break;
+                case 203 /* IfStatement */:
+                    bindIfStatement(node);
+                    break;
+                case 211 /* ReturnStatement */:
+                case 215 /* ThrowStatement */:
+                    bindReturnOrThrow(node);
+                    break;
+                case 210 /* BreakStatement */:
+                case 209 /* ContinueStatement */:
+                    bindBreakOrContinueStatement(node);
+                    break;
+                case 216 /* TryStatement */:
+                    bindTryStatement(node);
+                    break;
+                case 213 /* SwitchStatement */:
+                    bindSwitchStatement(node);
+                    break;
+                case 227 /* CaseBlock */:
+                    bindCaseBlock(node);
+                    break;
+                case 249 /* CaseClause */:
+                    bindCaseClause(node);
+                    break;
+                case 214 /* LabeledStatement */:
+                    bindLabeledStatement(node);
+                    break;
+                case 185 /* PrefixUnaryExpression */:
+                    bindPrefixUnaryExpressionFlow(node);
+                    break;
+                case 187 /* BinaryExpression */:
+                    bindBinaryExpressionFlow(node);
+                    break;
+                case 181 /* DeleteExpression */:
+                    bindDeleteExpressionFlow(node);
+                    break;
+                case 188 /* ConditionalExpression */:
+                    bindConditionalExpressionFlow(node);
+                    break;
+                case 218 /* VariableDeclaration */:
+                    bindVariableDeclarationFlow(node);
+                    break;
+                case 174 /* CallExpression */:
+                    bindCallExpressionFlow(node);
+                    break;
+                default:
+                    ts.forEachChild(node, bind);
+                    break;
+            }
+        }
+        function isNarrowingExpression(expr) {
+            switch (expr.kind) {
+                case 69 /* Identifier */:
+                case 97 /* ThisKeyword */:
+                case 172 /* PropertyAccessExpression */:
+                    return isNarrowableReference(expr);
+                case 174 /* CallExpression */:
+                    return hasNarrowableArgument(expr);
+                case 178 /* ParenthesizedExpression */:
+                    return isNarrowingExpression(expr.expression);
+                case 187 /* BinaryExpression */:
+                    return isNarrowingBinaryExpression(expr);
+                case 185 /* PrefixUnaryExpression */:
+                    return expr.operator === 49 /* ExclamationToken */ && isNarrowingExpression(expr.operand);
+            }
+            return false;
+        }
+        function isNarrowableReference(expr) {
+            return expr.kind === 69 /* Identifier */ ||
+                expr.kind === 97 /* ThisKeyword */ ||
+                expr.kind === 172 /* PropertyAccessExpression */ && isNarrowableReference(expr.expression);
+        }
+        function hasNarrowableArgument(expr) {
+            if (expr.arguments) {
+                for (var _i = 0, _a = expr.arguments; _i < _a.length; _i++) {
+                    var argument = _a[_i];
+                    if (isNarrowableReference(argument)) {
+                        return true;
+                    }
+                }
+            }
+            if (expr.expression.kind === 172 /* PropertyAccessExpression */ &&
+                isNarrowableReference(expr.expression.expression)) {
+                return true;
+            }
+            return false;
+        }
+        function isNarrowingNullCheckOperands(expr1, expr2) {
+            return (expr1.kind === 93 /* NullKeyword */ || expr1.kind === 69 /* Identifier */ && expr1.text === "undefined") && isNarrowableOperand(expr2);
+        }
+        function isNarrowingTypeofOperands(expr1, expr2) {
+            return expr1.kind === 182 /* TypeOfExpression */ && isNarrowableOperand(expr1.expression) && expr2.kind === 9 /* StringLiteral */;
+        }
+        function isNarrowingDiscriminant(expr) {
+            return expr.kind === 172 /* PropertyAccessExpression */ && isNarrowableReference(expr.expression);
+        }
+        function isNarrowingBinaryExpression(expr) {
+            switch (expr.operatorToken.kind) {
+                case 56 /* EqualsToken */:
+                    return isNarrowableReference(expr.left);
+                case 30 /* EqualsEqualsToken */:
+                case 31 /* ExclamationEqualsToken */:
+                case 32 /* EqualsEqualsEqualsToken */:
+                case 33 /* ExclamationEqualsEqualsToken */:
+                    return isNarrowingNullCheckOperands(expr.right, expr.left) || isNarrowingNullCheckOperands(expr.left, expr.right) ||
+                        isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right) ||
+                        isNarrowingDiscriminant(expr.left) || isNarrowingDiscriminant(expr.right);
+                case 91 /* InstanceOfKeyword */:
+                    return isNarrowableOperand(expr.left);
+                case 24 /* CommaToken */:
+                    return isNarrowingExpression(expr.right);
+            }
+            return false;
+        }
+        function isNarrowableOperand(expr) {
+            switch (expr.kind) {
+                case 178 /* ParenthesizedExpression */:
+                    return isNarrowableOperand(expr.expression);
+                case 187 /* BinaryExpression */:
+                    switch (expr.operatorToken.kind) {
+                        case 56 /* EqualsToken */:
+                            return isNarrowableOperand(expr.left);
+                        case 24 /* CommaToken */:
+                            return isNarrowableOperand(expr.right);
+                    }
+            }
+            return isNarrowableReference(expr);
+        }
+        function isNarrowingSwitchStatement(switchStatement) {
+            var expr = switchStatement.expression;
+            return expr.kind === 172 /* PropertyAccessExpression */ && isNarrowableReference(expr.expression);
+        }
+        function createBranchLabel() {
+            return {
+                flags: 4 /* BranchLabel */,
+                antecedents: undefined
+            };
+        }
+        function createLoopLabel() {
+            return {
+                flags: 8 /* LoopLabel */,
+                antecedents: undefined
+            };
+        }
+        function setFlowNodeReferenced(flow) {
+            // On first reference we set the Referenced flag, thereafter we set the Shared flag
+            flow.flags |= flow.flags & 256 /* Referenced */ ? 512 /* Shared */ : 256 /* Referenced */;
+        }
+        function addAntecedent(label, antecedent) {
+            if (!(antecedent.flags & 1 /* Unreachable */) && !ts.contains(label.antecedents, antecedent)) {
+                (label.antecedents || (label.antecedents = [])).push(antecedent);
+                setFlowNodeReferenced(antecedent);
+            }
+        }
+        function createFlowCondition(flags, antecedent, expression) {
+            if (antecedent.flags & 1 /* Unreachable */) {
+                return antecedent;
+            }
+            if (!expression) {
+                return flags & 32 /* TrueCondition */ ? antecedent : unreachableFlow;
+            }
+            if (expression.kind === 99 /* TrueKeyword */ && flags & 64 /* FalseCondition */ ||
+                expression.kind === 84 /* FalseKeyword */ && flags & 32 /* TrueCondition */) {
+                return unreachableFlow;
+            }
+            if (!isNarrowingExpression(expression)) {
+                return antecedent;
+            }
+            setFlowNodeReferenced(antecedent);
+            return {
+                flags: flags,
+                expression: expression,
+                antecedent: antecedent
+            };
+        }
+        function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
+            if (!isNarrowingSwitchStatement(switchStatement)) {
+                return antecedent;
+            }
+            setFlowNodeReferenced(antecedent);
+            return {
+                flags: 128 /* SwitchClause */,
+                switchStatement: switchStatement,
+                clauseStart: clauseStart,
+                clauseEnd: clauseEnd,
+                antecedent: antecedent
+            };
+        }
+        function createFlowAssignment(antecedent, node) {
+            setFlowNodeReferenced(antecedent);
+            return {
+                flags: 16 /* Assignment */,
+                antecedent: antecedent,
+                node: node
+            };
+        }
+        function finishFlowLabel(flow) {
+            var antecedents = flow.antecedents;
+            if (!antecedents) {
+                return unreachableFlow;
+            }
+            if (antecedents.length === 1) {
+                return antecedents[0];
+            }
+            return flow;
+        }
+        function isStatementCondition(node) {
+            var parent = node.parent;
+            switch (parent.kind) {
+                case 203 /* IfStatement */:
+                case 205 /* WhileStatement */:
+                case 204 /* DoStatement */:
+                    return parent.expression === node;
+                case 206 /* ForStatement */:
+                case 188 /* ConditionalExpression */:
+                    return parent.condition === node;
+            }
+            return false;
+        }
+        function isLogicalExpression(node) {
+            while (true) {
+                if (node.kind === 178 /* ParenthesizedExpression */) {
+                    node = node.expression;
+                }
+                else if (node.kind === 185 /* PrefixUnaryExpression */ && node.operator === 49 /* ExclamationToken */) {
+                    node = node.operand;
+                }
+                else {
+                    return node.kind === 187 /* BinaryExpression */ && (node.operatorToken.kind === 51 /* AmpersandAmpersandToken */ ||
+                        node.operatorToken.kind === 52 /* BarBarToken */);
+                }
+            }
+        }
+        function isTopLevelLogicalExpression(node) {
+            while (node.parent.kind === 178 /* ParenthesizedExpression */ ||
+                node.parent.kind === 185 /* PrefixUnaryExpression */ &&
+                    node.parent.operator === 49 /* ExclamationToken */) {
+                node = node.parent;
+            }
+            return !isStatementCondition(node) && !isLogicalExpression(node.parent);
+        }
+        function bindCondition(node, trueTarget, falseTarget) {
+            var saveTrueTarget = currentTrueTarget;
+            var saveFalseTarget = currentFalseTarget;
+            currentTrueTarget = trueTarget;
+            currentFalseTarget = falseTarget;
+            bind(node);
+            currentTrueTarget = saveTrueTarget;
+            currentFalseTarget = saveFalseTarget;
+            if (!node || !isLogicalExpression(node)) {
+                addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
+                addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
+            }
+        }
+        function bindIterativeStatement(node, breakTarget, continueTarget) {
+            var saveBreakTarget = currentBreakTarget;
+            var saveContinueTarget = currentContinueTarget;
+            currentBreakTarget = breakTarget;
+            currentContinueTarget = continueTarget;
+            bind(node);
+            currentBreakTarget = saveBreakTarget;
+            currentContinueTarget = saveContinueTarget;
+        }
+        function bindWhileStatement(node) {
+            var preWhileLabel = createLoopLabel();
+            var preBodyLabel = createBranchLabel();
+            var postWhileLabel = createBranchLabel();
+            addAntecedent(preWhileLabel, currentFlow);
+            currentFlow = preWhileLabel;
+            bindCondition(node.expression, preBodyLabel, postWhileLabel);
+            currentFlow = finishFlowLabel(preBodyLabel);
+            bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);
+            addAntecedent(preWhileLabel, currentFlow);
+            currentFlow = finishFlowLabel(postWhileLabel);
+        }
+        function bindDoStatement(node) {
+            var preDoLabel = createLoopLabel();
+            var preConditionLabel = createBranchLabel();
+            var postDoLabel = createBranchLabel();
+            addAntecedent(preDoLabel, currentFlow);
+            currentFlow = preDoLabel;
+            bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);
+            addAntecedent(preConditionLabel, currentFlow);
+            currentFlow = finishFlowLabel(preConditionLabel);
+            bindCondition(node.expression, preDoLabel, postDoLabel);
+            currentFlow = finishFlowLabel(postDoLabel);
+        }
+        function bindForStatement(node) {
+            var preLoopLabel = createLoopLabel();
+            var preBodyLabel = createBranchLabel();
+            var postLoopLabel = createBranchLabel();
+            bind(node.initializer);
+            addAntecedent(preLoopLabel, currentFlow);
+            currentFlow = preLoopLabel;
+            bindCondition(node.condition, preBodyLabel, postLoopLabel);
+            currentFlow = finishFlowLabel(preBodyLabel);
+            bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+            bind(node.incrementor);
+            addAntecedent(preLoopLabel, currentFlow);
+            currentFlow = finishFlowLabel(postLoopLabel);
+        }
+        function bindForInOrForOfStatement(node) {
+            var preLoopLabel = createLoopLabel();
+            var postLoopLabel = createBranchLabel();
+            addAntecedent(preLoopLabel, currentFlow);
+            currentFlow = preLoopLabel;
+            bind(node.expression);
+            addAntecedent(postLoopLabel, currentFlow);
+            bind(node.initializer);
+            if (node.initializer.kind !== 219 /* VariableDeclarationList */) {
+                bindAssignmentTargetFlow(node.initializer);
+            }
+            bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+            addAntecedent(preLoopLabel, currentFlow);
+            currentFlow = finishFlowLabel(postLoopLabel);
+        }
+        function bindIfStatement(node) {
+            var thenLabel = createBranchLabel();
+            var elseLabel = createBranchLabel();
+            var postIfLabel = createBranchLabel();
+            bindCondition(node.expression, thenLabel, elseLabel);
+            currentFlow = finishFlowLabel(thenLabel);
+            bind(node.thenStatement);
+            addAntecedent(postIfLabel, currentFlow);
+            currentFlow = finishFlowLabel(elseLabel);
+            bind(node.elseStatement);
+            addAntecedent(postIfLabel, currentFlow);
+            currentFlow = finishFlowLabel(postIfLabel);
+        }
+        function bindReturnOrThrow(node) {
+            bind(node.expression);
+            if (node.kind === 211 /* ReturnStatement */) {
+                hasExplicitReturn = true;
+                if (currentReturnTarget) {
+                    addAntecedent(currentReturnTarget, currentFlow);
+                }
+            }
+            currentFlow = unreachableFlow;
+        }
+        function findActiveLabel(name) {
+            if (activeLabels) {
+                for (var _i = 0, activeLabels_1 = activeLabels; _i < activeLabels_1.length; _i++) {
+                    var label = activeLabels_1[_i];
+                    if (label.name === name) {
+                        return label;
+                    }
+                }
+            }
+            return undefined;
+        }
+        function bindbreakOrContinueFlow(node, breakTarget, continueTarget) {
+            var flowLabel = node.kind === 210 /* BreakStatement */ ? breakTarget : continueTarget;
+            if (flowLabel) {
+                addAntecedent(flowLabel, currentFlow);
+                currentFlow = unreachableFlow;
+            }
+        }
+        function bindBreakOrContinueStatement(node) {
+            bind(node.label);
+            if (node.label) {
+                var activeLabel = findActiveLabel(node.label.text);
+                if (activeLabel) {
+                    activeLabel.referenced = true;
+                    bindbreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);
+                }
+            }
+            else {
+                bindbreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);
+            }
+        }
+        function bindTryStatement(node) {
+            var postFinallyLabel = createBranchLabel();
+            var preTryFlow = currentFlow;
+            // TODO: Every statement in try block is potentially an exit point!
+            bind(node.tryBlock);
+            addAntecedent(postFinallyLabel, currentFlow);
+            if (node.catchClause) {
+                currentFlow = preTryFlow;
+                bind(node.catchClause);
+                addAntecedent(postFinallyLabel, currentFlow);
+            }
+            if (node.finallyBlock) {
+                currentFlow = preTryFlow;
+                bind(node.finallyBlock);
+            }
+            currentFlow = finishFlowLabel(postFinallyLabel);
+        }
+        function bindSwitchStatement(node) {
+            var postSwitchLabel = createBranchLabel();
+            bind(node.expression);
+            var saveBreakTarget = currentBreakTarget;
+            var savePreSwitchCaseFlow = preSwitchCaseFlow;
+            currentBreakTarget = postSwitchLabel;
+            preSwitchCaseFlow = currentFlow;
+            bind(node.caseBlock);
+            addAntecedent(postSwitchLabel, currentFlow);
+            var hasDefault = ts.forEach(node.caseBlock.clauses, function (c) { return c.kind === 250 /* DefaultClause */; });
+            // We mark a switch statement as possibly exhaustive if it has no default clause and if all
+            // case clauses have unreachable end points (e.g. they all return).
+            node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
+            if (!hasDefault) {
+                addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
+            }
+            currentBreakTarget = saveBreakTarget;
+            preSwitchCaseFlow = savePreSwitchCaseFlow;
+            currentFlow = finishFlowLabel(postSwitchLabel);
+        }
+        function bindCaseBlock(node) {
+            var clauses = node.clauses;
+            var fallthroughFlow = unreachableFlow;
+            for (var i = 0; i < clauses.length; i++) {
+                var clauseStart = i;
+                while (!clauses[i].statements.length && i + 1 < clauses.length) {
+                    bind(clauses[i]);
+                    i++;
+                }
+                var preCaseLabel = createBranchLabel();
+                addAntecedent(preCaseLabel, createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1));
+                addAntecedent(preCaseLabel, fallthroughFlow);
+                currentFlow = finishFlowLabel(preCaseLabel);
+                var clause = clauses[i];
+                bind(clause);
+                fallthroughFlow = currentFlow;
+                if (!(currentFlow.flags & 1 /* Unreachable */) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, ts.Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+        function bindCaseClause(node) {
+            var saveCurrentFlow = currentFlow;
+            currentFlow = preSwitchCaseFlow;
+            bind(node.expression);
+            currentFlow = saveCurrentFlow;
+            ts.forEach(node.statements, bind);
+        }
+        function pushActiveLabel(name, breakTarget, continueTarget) {
+            var activeLabel = {
+                name: name,
+                breakTarget: breakTarget,
+                continueTarget: continueTarget,
+                referenced: false
+            };
+            (activeLabels || (activeLabels = [])).push(activeLabel);
+            return activeLabel;
+        }
+        function popActiveLabel() {
+            activeLabels.pop();
+        }
+        function bindLabeledStatement(node) {
+            var preStatementLabel = createLoopLabel();
+            var postStatementLabel = createBranchLabel();
+            bind(node.label);
+            addAntecedent(preStatementLabel, currentFlow);
+            var activeLabel = pushActiveLabel(node.label.text, postStatementLabel, preStatementLabel);
+            bind(node.statement);
+            popActiveLabel();
+            if (!activeLabel.referenced && !options.allowUnusedLabels) {
+                file.bindDiagnostics.push(ts.createDiagnosticForNode(node.label, ts.Diagnostics.Unused_label));
+            }
+            addAntecedent(postStatementLabel, currentFlow);
+            currentFlow = finishFlowLabel(postStatementLabel);
+        }
+        function bindDestructuringTargetFlow(node) {
+            if (node.kind === 187 /* BinaryExpression */ && node.operatorToken.kind === 56 /* EqualsToken */) {
+                bindAssignmentTargetFlow(node.left);
+            }
+            else {
+                bindAssignmentTargetFlow(node);
+            }
+        }
+        function bindAssignmentTargetFlow(node) {
+            if (isNarrowableReference(node)) {
+                currentFlow = createFlowAssignment(currentFlow, node);
+            }
+            else if (node.kind === 170 /* ArrayLiteralExpression */) {
+                for (var _i = 0, _a = node.elements; _i < _a.length; _i++) {
+                    var e = _a[_i];
+                    if (e.kind === 191 /* SpreadElementExpression */) {
+                        bindAssignmentTargetFlow(e.expression);
+                    }
+                    else {
+                        bindDestructuringTargetFlow(e);
+                    }
+                }
+            }
+            else if (node.kind === 171 /* ObjectLiteralExpression */) {
+                for (var _b = 0, _c = node.properties; _b < _c.length; _b++) {
+                    var p = _c[_b];
+                    if (p.kind === 253 /* PropertyAssignment */) {
+                        bindDestructuringTargetFlow(p.initializer);
+                    }
+                    else if (p.kind === 254 /* ShorthandPropertyAssignment */) {
+                        bindAssignmentTargetFlow(p.name);
+                    }
+                }
+            }
+        }
+        function bindLogicalExpression(node, trueTarget, falseTarget) {
+            var preRightLabel = createBranchLabel();
+            if (node.operatorToken.kind === 51 /* AmpersandAmpersandToken */) {
+                bindCondition(node.left, preRightLabel, falseTarget);
+            }
+            else {
+                bindCondition(node.left, trueTarget, preRightLabel);
+            }
+            currentFlow = finishFlowLabel(preRightLabel);
+            bind(node.operatorToken);
+            bindCondition(node.right, trueTarget, falseTarget);
+        }
+        function bindPrefixUnaryExpressionFlow(node) {
+            if (node.operator === 49 /* ExclamationToken */) {
+                var saveTrueTarget = currentTrueTarget;
+                currentTrueTarget = currentFalseTarget;
+                currentFalseTarget = saveTrueTarget;
+                ts.forEachChild(node, bind);
+                currentFalseTarget = currentTrueTarget;
+                currentTrueTarget = saveTrueTarget;
+            }
+            else {
+                ts.forEachChild(node, bind);
+            }
+        }
+        function bindBinaryExpressionFlow(node) {
+            var operator = node.operatorToken.kind;
+            if (operator === 51 /* AmpersandAmpersandToken */ || operator === 52 /* BarBarToken */) {
+                if (isTopLevelLogicalExpression(node)) {
+                    var postExpressionLabel = createBranchLabel();
+                    bindLogicalExpression(node, postExpressionLabel, postExpressionLabel);
+                    currentFlow = finishFlowLabel(postExpressionLabel);
+                }
+                else {
+                    bindLogicalExpression(node, currentTrueTarget, currentFalseTarget);
+                }
+            }
+            else {
+                ts.forEachChild(node, bind);
+                if (operator === 56 /* EqualsToken */ && !ts.isAssignmentTarget(node)) {
+                    bindAssignmentTargetFlow(node.left);
+                }
+            }
+        }
+        function bindDeleteExpressionFlow(node) {
+            ts.forEachChild(node, bind);
+            if (node.expression.kind === 172 /* PropertyAccessExpression */) {
+                bindAssignmentTargetFlow(node.expression);
+            }
+        }
+        function bindConditionalExpressionFlow(node) {
+            var trueLabel = createBranchLabel();
+            var falseLabel = createBranchLabel();
+            var postExpressionLabel = createBranchLabel();
+            bindCondition(node.condition, trueLabel, falseLabel);
+            currentFlow = finishFlowLabel(trueLabel);
+            bind(node.whenTrue);
+            addAntecedent(postExpressionLabel, currentFlow);
+            currentFlow = finishFlowLabel(falseLabel);
+            bind(node.whenFalse);
+            addAntecedent(postExpressionLabel, currentFlow);
+            currentFlow = finishFlowLabel(postExpressionLabel);
+        }
+        function bindInitializedVariableFlow(node) {
+            var name = node.name;
+            if (ts.isBindingPattern(name)) {
+                for (var _i = 0, _a = name.elements; _i < _a.length; _i++) {
+                    var child = _a[_i];
+                    bindInitializedVariableFlow(child);
+                }
+            }
+            else {
+                currentFlow = createFlowAssignment(currentFlow, node);
+            }
+        }
+        function bindVariableDeclarationFlow(node) {
+            ts.forEachChild(node, bind);
+            if (node.initializer || node.parent.parent.kind === 207 /* ForInStatement */ || node.parent.parent.kind === 208 /* ForOfStatement */) {
+                bindInitializedVariableFlow(node);
+            }
+        }
+        function bindCallExpressionFlow(node) {
+            // If the target of the call expression is a function expression or arrow function we have
+            // an immediately invoked function expression (IIFE). Initialize the flowNode property to
+            // the current control flow (which includes evaluation of the IIFE arguments).
+            var expr = node.expression;
+            while (expr.kind === 178 /* ParenthesizedExpression */) {
+                expr = expr.expression;
+            }
+            if (expr.kind === 179 /* FunctionExpression */ || expr.kind === 180 /* ArrowFunction */) {
+                ts.forEach(node.typeArguments, bind);
+                ts.forEach(node.arguments, bind);
+                bind(node.expression);
+            }
+            else {
+                ts.forEachChild(node, bind);
+            }
+        }
+        function getContainerFlags(node) {
+            switch (node.kind) {
+                case 192 /* ClassExpression */:
+                case 221 /* ClassDeclaration */:
+                case 224 /* EnumDeclaration */:
+                case 171 /* ObjectLiteralExpression */:
+                case 159 /* TypeLiteral */:
+                case 281 /* JSDocTypeLiteral */:
+                case 265 /* JSDocRecordType */:
+                    return 1 /* IsContainer */;
+                case 222 /* InterfaceDeclaration */:
+                    return 1 /* IsContainer */ | 64 /* IsInterface */;
+                case 269 /* JSDocFunctionType */:
+                case 225 /* ModuleDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                    return 1 /* IsContainer */ | 32 /* HasLocals */;
+                case 256 /* SourceFile */:
+                    return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
+                case 148 /* Constructor */:
+                case 220 /* FunctionDeclaration */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                case 153 /* IndexSignature */:
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                    return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 16 /* IsFunctionExpression */;
+                case 226 /* ModuleBlock */:
+                    return 4 /* IsControlFlowContainer */;
+                case 145 /* PropertyDeclaration */:
+                    return node.initializer ? 4 /* IsControlFlowContainer */ : 0;
+                case 252 /* CatchClause */:
+                case 206 /* ForStatement */:
+                case 207 /* ForInStatement */:
+                case 208 /* ForOfStatement */:
+                case 227 /* CaseBlock */:
+                    return 2 /* IsBlockScopedContainer */;
+                case 199 /* Block */:
+                    // do not treat blocks directly inside a function as a block-scoped-container.
+                    // Locals that reside in this block should go to the function locals. Otherwise 'x'
+                    // would not appear to be a redeclaration of a block scoped local in the following
+                    // example:
+                    //
+                    //      function foo() {
+                    //          var x;
+                    //          let x;
+                    //      }
+                    //
+                    // If we placed 'var x' into the function locals and 'let x' into the locals of
+                    // the block, then there would be no collision.
+                    //
+                    // By not creating a new block-scoped-container here, we ensure that both 'var x'
+                    // and 'let x' go into the Function-container's locals, and we do get a collision
+                    // conflict.
+                    return ts.isFunctionLike(node.parent) ? 0 /* None */ : 2 /* IsBlockScopedContainer */;
+            }
+            return 0 /* None */;
+        }
+        function addToContainerChain(next) {
+            if (lastContainer) {
+                lastContainer.nextContainer = next;
+            }
+            lastContainer = next;
+        }
+        function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
+            // Just call this directly so that the return type of this function stays "void".
+            return declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes);
+        }
+        function declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes) {
+            switch (container.kind) {
+                // Modules, source files, and classes need specialized handling for how their
+                // members are declared (for example, a member of a class will go into a specific
+                // symbol table depending on if it is static or not). We defer to specialized
+                // handlers to take care of declaring these child members.
+                case 225 /* ModuleDeclaration */:
+                    return declareModuleMember(node, symbolFlags, symbolExcludes);
+                case 256 /* SourceFile */:
+                    return declareSourceFileMember(node, symbolFlags, symbolExcludes);
+                case 192 /* ClassExpression */:
+                case 221 /* ClassDeclaration */:
+                    return declareClassMember(node, symbolFlags, symbolExcludes);
+                case 224 /* EnumDeclaration */:
+                    return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+                case 159 /* TypeLiteral */:
+                case 171 /* ObjectLiteralExpression */:
+                case 222 /* InterfaceDeclaration */:
+                case 265 /* JSDocRecordType */:
+                case 281 /* JSDocTypeLiteral */:
+                    // Interface/Object-types always have their children added to the 'members' of
+                    // their container. They are only accessible through an instance of their
+                    // container, and are never in scope otherwise (even inside the body of the
+                    // object / type / interface declaring them). An exception is type parameters,
+                    // which are in scope without qualification (similar to 'locals').
+                    return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                case 153 /* IndexSignature */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 148 /* Constructor */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                case 269 /* JSDocFunctionType */:
+                case 223 /* TypeAliasDeclaration */:
+                    // All the children of these container types are never visible through another
+                    // symbol (i.e. through another symbol's 'exports' or 'members').  Instead,
+                    // they're only accessed 'lexically' (i.e. from code that exists underneath
+                    // their container in the tree.  To accomplish this, we simply add their declared
+                    // symbol to the 'locals' of the container.  These symbols can then be found as
+                    // the type checker walks up the containers, checking them for matching names.
+                    return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
+            }
+        }
+        function declareClassMember(node, symbolFlags, symbolExcludes) {
+            return node.flags & 32 /* Static */
+                ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
+                : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
+        }
+        function declareSourceFileMember(node, symbolFlags, symbolExcludes) {
+            return ts.isExternalModule(file)
+                ? declareModuleMember(node, symbolFlags, symbolExcludes)
+                : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
+        }
+        function hasExportDeclarations(node) {
+            var body = node.kind === 256 /* SourceFile */ ? node : node.body;
+            if (body && (body.kind === 256 /* SourceFile */ || body.kind === 226 /* ModuleBlock */)) {
+                for (var _i = 0, _a = body.statements; _i < _a.length; _i++) {
+                    var stat = _a[_i];
+                    if (stat.kind === 236 /* ExportDeclaration */ || stat.kind === 235 /* ExportAssignment */) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function setExportContextFlag(node) {
+            // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
+            // declarations with export modifiers) is an export context in which declarations are implicitly exported.
+            if (ts.isInAmbientContext(node) && !hasExportDeclarations(node)) {
+                node.flags |= 8192 /* ExportContext */;
+            }
+            else {
+                node.flags &= ~8192 /* ExportContext */;
+            }
+        }
+        function bindModuleDeclaration(node) {
+            setExportContextFlag(node);
+            if (ts.isAmbientModule(node)) {
+                if (node.flags & 1 /* Export */) {
+                    errorOnFirstToken(node, ts.Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
+                }
+                if (ts.isExternalModuleAugmentation(node)) {
+                    declareSymbolAndAddToSymbolTable(node, 1024 /* NamespaceModule */, 0 /* NamespaceModuleExcludes */);
+                }
+                else {
+                    var pattern = void 0;
+                    if (node.name.kind === 9 /* StringLiteral */) {
+                        var text = node.name.text;
+                        if (ts.hasZeroOrOneAsteriskCharacter(text)) {
+                            pattern = ts.tryParsePattern(text);
+                        }
+                        else {
+                            errorOnFirstToken(node.name, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
+                        }
+                    }
+                    var symbol = declareSymbolAndAddToSymbolTable(node, 512 /* ValueModule */, 106639 /* ValueModuleExcludes */);
+                    if (pattern) {
+                        (file.patternAmbientModules || (file.patternAmbientModules = [])).push({ pattern: pattern, symbol: symbol });
+                    }
+                }
+            }
+            else {
+                var state = getModuleInstanceState(node);
+                if (state === 0 /* NonInstantiated */) {
+                    declareSymbolAndAddToSymbolTable(node, 1024 /* NamespaceModule */, 0 /* NamespaceModuleExcludes */);
+                }
+                else {
+                    declareSymbolAndAddToSymbolTable(node, 512 /* ValueModule */, 106639 /* ValueModuleExcludes */);
+                    if (node.symbol.flags & (16 /* Function */ | 32 /* Class */ | 256 /* RegularEnum */)) {
+                        // if module was already merged with some function, class or non-const enum
+                        // treat is a non-const-enum-only
+                        node.symbol.constEnumOnlyModule = false;
+                    }
+                    else {
+                        var currentModuleIsConstEnumOnly = state === 2 /* ConstEnumOnly */;
+                        if (node.symbol.constEnumOnlyModule === undefined) {
+                            // non-merged case - use the current state
+                            node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly;
+                        }
+                        else {
+                            // merged case: module is const enum only if all its pieces are non-instantiated or const enum
+                            node.symbol.constEnumOnlyModule = node.symbol.constEnumOnlyModule && currentModuleIsConstEnumOnly;
+                        }
+                    }
+                }
+            }
+        }
+        function bindFunctionOrConstructorType(node) {
+            // For a given function symbol "<...>(...) => T" we want to generate a symbol identical
+            // to the one we would get for: { <...>(...): T }
+            //
+            // We do that by making an anonymous type literal symbol, and then setting the function
+            // symbol as its sole member. To the rest of the system, this symbol will be  indistinguishable
+            // from an actual type literal symbol you would have gotten had you used the long form.
+            var symbol = createSymbol(131072 /* Signature */, getDeclarationName(node));
+            addDeclarationToSymbol(symbol, node, 131072 /* Signature */);
+            var typeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type");
+            addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* TypeLiteral */);
+            typeLiteralSymbol.members = (_a = {}, _a[symbol.name] = symbol, _a);
+            var _a;
+        }
+        function bindObjectLiteralExpression(node) {
+            var ElementKind;
+            (function (ElementKind) {
+                ElementKind[ElementKind["Property"] = 1] = "Property";
+                ElementKind[ElementKind["Accessor"] = 2] = "Accessor";
+            })(ElementKind || (ElementKind = {}));
+            if (inStrictMode) {
+                var seen = {};
+                for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+                    var prop = _a[_i];
+                    if (prop.name.kind !== 69 /* Identifier */) {
+                        continue;
+                    }
+                    var identifier = prop.name;
+                    // ECMA-262 11.1.5 Object Initializer
+                    // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
+                    // a.This production is contained in strict code and IsDataDescriptor(previous) is true and
+                    // IsDataDescriptor(propId.descriptor) is true.
+                    //    b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true.
+                    //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
+                    //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
+                    // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
+                    var currentKind = prop.kind === 253 /* PropertyAssignment */ || prop.kind === 254 /* ShorthandPropertyAssignment */ || prop.kind === 147 /* MethodDeclaration */
+                        ? 1 /* Property */
+                        : 2 /* Accessor */;
+                    var existingKind = seen[identifier.text];
+                    if (!existingKind) {
+                        seen[identifier.text] = currentKind;
+                        continue;
+                    }
+                    if (currentKind === 1 /* Property */ && existingKind === 1 /* Property */) {
+                        var span = ts.getErrorSpanForNode(file, identifier);
+                        file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
+                    }
+                }
+            }
+            return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object");
+        }
+        function bindAnonymousDeclaration(node, symbolFlags, name) {
+            var symbol = createSymbol(symbolFlags, name);
+            addDeclarationToSymbol(symbol, node, symbolFlags);
+        }
+        function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
+            switch (blockScopeContainer.kind) {
+                case 225 /* ModuleDeclaration */:
+                    declareModuleMember(node, symbolFlags, symbolExcludes);
+                    break;
+                case 256 /* SourceFile */:
+                    if (ts.isExternalModule(container)) {
+                        declareModuleMember(node, symbolFlags, symbolExcludes);
+                        break;
+                    }
+                // fall through.
+                default:
+                    if (!blockScopeContainer.locals) {
+                        blockScopeContainer.locals = {};
+                        addToContainerChain(blockScopeContainer);
+                    }
+                    declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
+            }
+        }
+        function bindBlockScopedVariableDeclaration(node) {
+            bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 107455 /* BlockScopedVariableExcludes */);
+        }
+        // The binder visits every node in the syntax tree so it is a convenient place to perform a single localized
+        // check for reserved words used as identifiers in strict mode code.
+        function checkStrictModeIdentifier(node) {
+            if (inStrictMode &&
+                node.originalKeywordKind >= 106 /* FirstFutureReservedWord */ &&
+                node.originalKeywordKind <= 114 /* LastFutureReservedWord */ &&
+                !ts.isIdentifierName(node) &&
+                !ts.isInAmbientContext(node)) {
+                // Report error only if there are no parse errors in file
+                if (!file.parseDiagnostics.length) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node)));
+                }
+            }
+        }
+        function getStrictModeIdentifierMessage(node) {
+            // Provide specialized messages to help the user understand why we think they're in
+            // strict mode.
+            if (ts.getContainingClass(node)) {
+                return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
+            }
+            if (file.externalModuleIndicator) {
+                return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode;
+            }
+            return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
+        }
+        function checkStrictModeBinaryExpression(node) {
+            if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) {
+                // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an
+                // Assignment operator(11.13) or of a PostfixExpression(11.3)
+                checkStrictModeEvalOrArguments(node, node.left);
+            }
+        }
+        function checkStrictModeCatchClause(node) {
+            // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the
+            // Catch production is eval or arguments
+            if (inStrictMode && node.variableDeclaration) {
+                checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
+            }
+        }
+        function checkStrictModeDeleteExpression(node) {
+            // Grammar checking
+            if (inStrictMode && node.expression.kind === 69 /* Identifier */) {
+                // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its
+                // UnaryExpression is a direct reference to a variable, function argument, or function name
+                var span = ts.getErrorSpanForNode(file, node.expression);
+                file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
+            }
+        }
+        function isEvalOrArgumentsIdentifier(node) {
+            return node.kind === 69 /* Identifier */ &&
+                (node.text === "eval" || node.text === "arguments");
+        }
+        function checkStrictModeEvalOrArguments(contextNode, name) {
+            if (name && name.kind === 69 /* Identifier */) {
+                var identifier = name;
+                if (isEvalOrArgumentsIdentifier(identifier)) {
+                    // We check first if the name is inside class declaration or class expression; if so give explicit message
+                    // otherwise report generic error message.
+                    var span = ts.getErrorSpanForNode(file, name);
+                    file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text));
+                }
+            }
+        }
+        function getStrictModeEvalOrArgumentsMessage(node) {
+            // Provide specialized messages to help the user understand why we think they're in
+            // strict mode.
+            if (ts.getContainingClass(node)) {
+                return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode;
+            }
+            if (file.externalModuleIndicator) {
+                return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode;
+            }
+            return ts.Diagnostics.Invalid_use_of_0_in_strict_mode;
+        }
+        function checkStrictModeFunctionName(node) {
+            if (inStrictMode) {
+                // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1))
+                checkStrictModeEvalOrArguments(node, node.name);
+            }
+        }
+        function getStrictModeBlockScopeFunctionDeclarationMessage(node) {
+            // Provide specialized messages to help the user understand why we think they're in
+            // strict mode.
+            if (ts.getContainingClass(node)) {
+                return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode;
+            }
+            if (file.externalModuleIndicator) {
+                return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode;
+            }
+            return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5;
+        }
+        function checkStrictModeFunctionDeclaration(node) {
+            if (languageVersion < 2 /* ES6 */) {
+                // Report error if function is not top level function declaration
+                if (blockScopeContainer.kind !== 256 /* SourceFile */ &&
+                    blockScopeContainer.kind !== 225 /* ModuleDeclaration */ &&
+                    !ts.isFunctionLike(blockScopeContainer)) {
+                    // We check first if the name is inside class declaration or class expression; if so give explicit message
+                    // otherwise report generic error message.
+                    var errorSpan = ts.getErrorSpanForNode(file, node);
+                    file.bindDiagnostics.push(ts.createFileDiagnostic(file, errorSpan.start, errorSpan.length, getStrictModeBlockScopeFunctionDeclarationMessage(node)));
+                }
+            }
+        }
+        function checkStrictModeNumericLiteral(node) {
+            if (inStrictMode && node.isOctalLiteral) {
+                file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
+            }
+        }
+        function checkStrictModePostfixUnaryExpression(node) {
+            // Grammar checking
+            // The identifier eval or arguments may not appear as the LeftHandSideExpression of an
+            // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression
+            // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator.
+            if (inStrictMode) {
+                checkStrictModeEvalOrArguments(node, node.operand);
+            }
+        }
+        function checkStrictModePrefixUnaryExpression(node) {
+            // Grammar checking
+            if (inStrictMode) {
+                if (node.operator === 41 /* PlusPlusToken */ || node.operator === 42 /* MinusMinusToken */) {
+                    checkStrictModeEvalOrArguments(node, node.operand);
+                }
+            }
+        }
+        function checkStrictModeWithStatement(node) {
+            // Grammar checking for withStatement
+            if (inStrictMode) {
+                errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+            }
+        }
+        function errorOnFirstToken(node, message, arg0, arg1, arg2) {
+            var span = ts.getSpanOfTokenAtPosition(file, node.pos);
+            file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
+        }
+        function getDestructuringParameterName(node) {
+            return "__" + ts.indexOf(node.parent.parameters, node);
+        }
+        function bind(node) {
+            if (!node) {
+                return;
+            }
+            node.parent = parent;
+            var saveInStrictMode = inStrictMode;
+            // First we bind declaration nodes to a symbol if possible. We'll both create a symbol
+            // and then potentially add the symbol to an appropriate symbol table. Possible
+            // destination symbol tables are:
+            //
+            //  1) The 'exports' table of the current container's symbol.
+            //  2) The 'members' table of the current container's symbol.
+            //  3) The 'locals' table of the current container.
+            //
+            // However, not all symbols will end up in any of these tables. 'Anonymous' symbols
+            // (like TypeLiterals for example) will not be put in any table.
+            bindWorker(node);
+            // Then we recurse into the children of the node to bind them as well. For certain
+            // symbols we do specialized work when we recurse. For example, we'll keep track of
+            // the current 'container' node when it changes. This helps us know which symbol table
+            // a local should go into for example. Since terminal nodes are known not to have
+            // children, as an optimization we don't process those.
+            if (node.kind > 138 /* LastToken */) {
+                var saveParent = parent;
+                parent = node;
+                var containerFlags = getContainerFlags(node);
+                if (containerFlags === 0 /* None */) {
+                    bindChildren(node);
+                }
+                else {
+                    bindContainer(node, containerFlags);
+                }
+                parent = saveParent;
+            }
+            inStrictMode = saveInStrictMode;
+        }
+        function updateStrictModeStatementList(statements) {
+            if (!inStrictMode) {
+                for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+                    var statement = statements_1[_i];
+                    if (!ts.isPrologueDirective(statement)) {
+                        return;
+                    }
+                    if (isUseStrictPrologueDirective(statement)) {
+                        inStrictMode = true;
+                        return;
+                    }
+                }
+            }
+        }
+        /// Should be called only on prologue directives (isPrologueDirective(node) should be true)
+        function isUseStrictPrologueDirective(node) {
+            var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression);
+            // Note: the node text must be exactly "use strict" or 'use strict'.  It is not ok for the
+            // string to contain unicode escapes (as per ES5).
+            return nodeText === '"use strict"' || nodeText === "'use strict'";
+        }
+        function bindWorker(node) {
+            switch (node.kind) {
+                /* Strict mode checks */
+                case 69 /* Identifier */:
+                case 97 /* ThisKeyword */:
+                    if (currentFlow && (ts.isExpression(node) || parent.kind === 254 /* ShorthandPropertyAssignment */)) {
+                        node.flowNode = currentFlow;
+                    }
+                    return checkStrictModeIdentifier(node);
+                case 172 /* PropertyAccessExpression */:
+                    if (currentFlow && isNarrowableReference(node)) {
+                        node.flowNode = currentFlow;
+                    }
+                    break;
+                case 187 /* BinaryExpression */:
+                    if (ts.isInJavaScriptFile(node)) {
+                        var specialKind = ts.getSpecialPropertyAssignmentKind(node);
+                        switch (specialKind) {
+                            case 1 /* ExportsProperty */:
+                                bindExportsPropertyAssignment(node);
+                                break;
+                            case 2 /* ModuleExports */:
+                                bindModuleExportsAssignment(node);
+                                break;
+                            case 3 /* PrototypeProperty */:
+                                bindPrototypePropertyAssignment(node);
+                                break;
+                            case 4 /* ThisProperty */:
+                                bindThisPropertyAssignment(node);
+                                break;
+                            case 0 /* None */:
+                                // Nothing to do
+                                break;
+                            default:
+                                ts.Debug.fail("Unknown special property assignment kind");
+                        }
+                    }
+                    return checkStrictModeBinaryExpression(node);
+                case 252 /* CatchClause */:
+                    return checkStrictModeCatchClause(node);
+                case 181 /* DeleteExpression */:
+                    return checkStrictModeDeleteExpression(node);
+                case 8 /* NumericLiteral */:
+                    return checkStrictModeNumericLiteral(node);
+                case 186 /* PostfixUnaryExpression */:
+                    return checkStrictModePostfixUnaryExpression(node);
+                case 185 /* PrefixUnaryExpression */:
+                    return checkStrictModePrefixUnaryExpression(node);
+                case 212 /* WithStatement */:
+                    return checkStrictModeWithStatement(node);
+                case 165 /* ThisType */:
+                    seenThisKeyword = true;
+                    return;
+                case 154 /* TypePredicate */:
+                    return checkTypePredicate(node);
+                case 141 /* TypeParameter */:
+                    return declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 530912 /* TypeParameterExcludes */);
+                case 142 /* Parameter */:
+                    return bindParameter(node);
+                case 218 /* VariableDeclaration */:
+                case 169 /* BindingElement */:
+                    return bindVariableDeclarationOrBindingElement(node);
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 266 /* JSDocRecordMember */:
+                    return bindPropertyOrMethodOrAccessor(node, 4 /* Property */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), 0 /* PropertyExcludes */);
+                case 280 /* JSDocPropertyTag */:
+                    return bindJSDocProperty(node);
+                case 253 /* PropertyAssignment */:
+                case 254 /* ShorthandPropertyAssignment */:
+                    return bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 0 /* PropertyExcludes */);
+                case 255 /* EnumMember */:
+                    return bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 107455 /* EnumMemberExcludes */);
+                case 247 /* JsxSpreadAttribute */:
+                    emitFlags |= 1073741824 /* HasJsxSpreadAttribute */;
+                    return;
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                case 153 /* IndexSignature */:
+                    return declareSymbolAndAddToSymbolTable(node, 131072 /* Signature */, 0 /* None */);
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                    // If this is an ObjectLiteralExpression method, then it sits in the same space
+                    // as other properties in the object literal.  So we use SymbolFlags.PropertyExcludes
+                    // so that it will conflict with any other object literal members with the same
+                    // name.
+                    return bindPropertyOrMethodOrAccessor(node, 8192 /* Method */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), ts.isObjectLiteralMethod(node) ? 0 /* PropertyExcludes */ : 99263 /* MethodExcludes */);
+                case 220 /* FunctionDeclaration */:
+                    return bindFunctionDeclaration(node);
+                case 148 /* Constructor */:
+                    return declareSymbolAndAddToSymbolTable(node, 16384 /* Constructor */, /*symbolExcludes:*/ 0 /* None */);
+                case 149 /* GetAccessor */:
+                    return bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 41919 /* GetAccessorExcludes */);
+                case 150 /* SetAccessor */:
+                    return bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 74687 /* SetAccessorExcludes */);
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                case 269 /* JSDocFunctionType */:
+                    return bindFunctionOrConstructorType(node);
+                case 159 /* TypeLiteral */:
+                case 281 /* JSDocTypeLiteral */:
+                case 265 /* JSDocRecordType */:
+                    return bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type");
+                case 171 /* ObjectLiteralExpression */:
+                    return bindObjectLiteralExpression(node);
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    return bindFunctionExpression(node);
+                case 174 /* CallExpression */:
+                    if (ts.isInJavaScriptFile(node)) {
+                        bindCallExpression(node);
+                    }
+                    break;
+                // Members of classes, interfaces, and modules
+                case 192 /* ClassExpression */:
+                case 221 /* ClassDeclaration */:
+                    // All classes are automatically in strict mode in ES6.
+                    inStrictMode = true;
+                    return bindClassLikeDeclaration(node);
+                case 222 /* InterfaceDeclaration */:
+                    return bindBlockScopedDeclaration(node, 64 /* Interface */, 792960 /* InterfaceExcludes */);
+                case 279 /* JSDocTypedefTag */:
+                case 223 /* TypeAliasDeclaration */:
+                    return bindBlockScopedDeclaration(node, 524288 /* TypeAlias */, 793056 /* TypeAliasExcludes */);
+                case 224 /* EnumDeclaration */:
+                    return bindEnumDeclaration(node);
+                case 225 /* ModuleDeclaration */:
+                    return bindModuleDeclaration(node);
+                // Imports and exports
+                case 229 /* ImportEqualsDeclaration */:
+                case 232 /* NamespaceImport */:
+                case 234 /* ImportSpecifier */:
+                case 238 /* ExportSpecifier */:
+                    return declareSymbolAndAddToSymbolTable(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */);
+                case 228 /* NamespaceExportDeclaration */:
+                    return bindNamespaceExportDeclaration(node);
+                case 231 /* ImportClause */:
+                    return bindImportClause(node);
+                case 236 /* ExportDeclaration */:
+                    return bindExportDeclaration(node);
+                case 235 /* ExportAssignment */:
+                    return bindExportAssignment(node);
+                case 256 /* SourceFile */:
+                    updateStrictModeStatementList(node.statements);
+                    return bindSourceFileIfExternalModule();
+                case 199 /* Block */:
+                    if (!ts.isFunctionLike(node.parent)) {
+                        return;
+                    }
+                // Fall through
+                case 226 /* ModuleBlock */:
+                    return updateStrictModeStatementList(node.statements);
+            }
+        }
+        function checkTypePredicate(node) {
+            var parameterName = node.parameterName, type = node.type;
+            if (parameterName && parameterName.kind === 69 /* Identifier */) {
+                checkStrictModeIdentifier(parameterName);
+            }
+            if (parameterName && parameterName.kind === 165 /* ThisType */) {
+                seenThisKeyword = true;
+            }
+            bind(type);
+        }
+        function bindSourceFileIfExternalModule() {
+            setExportContextFlag(file);
+            if (ts.isExternalModule(file)) {
+                bindSourceFileAsExternalModule();
+            }
+        }
+        function bindSourceFileAsExternalModule() {
+            bindAnonymousDeclaration(file, 512 /* ValueModule */, "\"" + ts.removeFileExtension(file.fileName) + "\"");
+        }
+        function bindExportAssignment(node) {
+            var boundExpression = node.kind === 235 /* ExportAssignment */ ? node.expression : node.right;
+            if (!container.symbol || !container.symbol.exports) {
+                // Export assignment in some sort of block construct
+                bindAnonymousDeclaration(node, 8388608 /* Alias */, getDeclarationName(node));
+            }
+            else if (boundExpression.kind === 69 /* Identifier */ && node.kind === 235 /* ExportAssignment */) {
+                // An export default clause with an identifier exports all meanings of that identifier
+                declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* Alias */, 0 /* PropertyExcludes */ | 8388608 /* AliasExcludes */);
+            }
+            else {
+                // An export default clause with an expression exports a value
+                declareSymbol(container.symbol.exports, container.symbol, node, 4 /* Property */, 0 /* PropertyExcludes */ | 8388608 /* AliasExcludes */);
+            }
+        }
+        function bindNamespaceExportDeclaration(node) {
+            if (node.modifiers && node.modifiers.length) {
+                file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Modifiers_cannot_appear_here));
+            }
+            if (node.parent.kind !== 256 /* SourceFile */) {
+                file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Global_module_exports_may_only_appear_at_top_level));
+                return;
+            }
+            else {
+                var parent_6 = node.parent;
+                if (!ts.isExternalModule(parent_6)) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Global_module_exports_may_only_appear_in_module_files));
+                    return;
+                }
+                if (!parent_6.isDeclarationFile) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Global_module_exports_may_only_appear_in_declaration_files));
+                    return;
+                }
+            }
+            file.symbol.globalExports = file.symbol.globalExports || {};
+            declareSymbol(file.symbol.globalExports, file.symbol, node, 8388608 /* Alias */, 8388608 /* AliasExcludes */);
+        }
+        function bindExportDeclaration(node) {
+            if (!container.symbol || !container.symbol.exports) {
+                // Export * in some sort of block construct
+                bindAnonymousDeclaration(node, 1073741824 /* ExportStar */, getDeclarationName(node));
+            }
+            else if (!node.exportClause) {
+                // All export * declarations are collected in an __export symbol
+                declareSymbol(container.symbol.exports, container.symbol, node, 1073741824 /* ExportStar */, 0 /* None */);
+            }
+        }
+        function bindImportClause(node) {
+            if (node.name) {
+                declareSymbolAndAddToSymbolTable(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */);
+            }
+        }
+        function setCommonJsModuleIndicator(node) {
+            if (!file.commonJsModuleIndicator) {
+                file.commonJsModuleIndicator = node;
+                bindSourceFileAsExternalModule();
+            }
+        }
+        function bindExportsPropertyAssignment(node) {
+            // When we create a property via 'exports.foo = bar', the 'exports.foo' property access
+            // expression is the declaration
+            setCommonJsModuleIndicator(node);
+            declareSymbol(file.symbol.exports, file.symbol, node.left, 4 /* Property */ | 7340032 /* Export */, 0 /* None */);
+        }
+        function bindModuleExportsAssignment(node) {
+            // 'module.exports = expr' assignment
+            setCommonJsModuleIndicator(node);
+            declareSymbol(file.symbol.exports, file.symbol, node, 4 /* Property */ | 7340032 /* Export */ | 512 /* ValueModule */, 0 /* None */);
+        }
+        function bindThisPropertyAssignment(node) {
+            // Declare a 'member' in case it turns out the container was an ES5 class or ES6 constructor
+            var assignee;
+            if (container.kind === 220 /* FunctionDeclaration */ || container.kind === 220 /* FunctionDeclaration */) {
+                assignee = container;
+            }
+            else if (container.kind === 148 /* Constructor */) {
+                assignee = container.parent;
+            }
+            else {
+                return;
+            }
+            assignee.symbol.members = assignee.symbol.members || {};
+            // It's acceptable for multiple 'this' assignments of the same identifier to occur
+            declareSymbol(assignee.symbol.members, assignee.symbol, node, 4 /* Property */, 0 /* PropertyExcludes */ & ~4 /* Property */);
+        }
+        function bindPrototypePropertyAssignment(node) {
+            // We saw a node of the form 'x.prototype.y = z'. Declare a 'member' y on x if x was a function.
+            // Look up the function in the local scope, since prototype assignments should
+            // follow the function declaration
+            var leftSideOfAssignment = node.left;
+            var classPrototype = leftSideOfAssignment.expression;
+            var constructorFunction = classPrototype.expression;
+            // Fix up parent pointers since we're going to use these nodes before we bind into them
+            leftSideOfAssignment.parent = node;
+            constructorFunction.parent = classPrototype;
+            classPrototype.parent = leftSideOfAssignment;
+            var funcSymbol = container.locals[constructorFunction.text];
+            if (!funcSymbol || !(funcSymbol.flags & 16 /* Function */ || ts.isDeclarationOfFunctionExpression(funcSymbol))) {
+                return;
+            }
+            // Set up the members collection if it doesn't exist already
+            if (!funcSymbol.members) {
+                funcSymbol.members = {};
+            }
+            // Declare the method/property
+            declareSymbol(funcSymbol.members, funcSymbol, leftSideOfAssignment, 4 /* Property */, 0 /* PropertyExcludes */);
+        }
+        function bindCallExpression(node) {
+            // We're only inspecting call expressions to detect CommonJS modules, so we can skip
+            // this check if we've already seen the module indicator
+            if (!file.commonJsModuleIndicator && ts.isRequireCall(node, /*checkArgumentIsStringLiteral*/ false)) {
+                setCommonJsModuleIndicator(node);
+            }
+        }
+        function bindClassLikeDeclaration(node) {
+            if (!ts.isDeclarationFile(file) && !ts.isInAmbientContext(node)) {
+                if (ts.getClassExtendsHeritageClauseElement(node) !== undefined) {
+                    emitFlags |= 262144 /* HasClassExtends */;
+                }
+                if (ts.nodeIsDecorated(node)) {
+                    emitFlags |= 524288 /* HasDecorators */;
+                }
+            }
+            if (node.kind === 221 /* ClassDeclaration */) {
+                bindBlockScopedDeclaration(node, 32 /* Class */, 899519 /* ClassExcludes */);
+            }
+            else {
+                var bindingName = node.name ? node.name.text : "__class";
+                bindAnonymousDeclaration(node, 32 /* Class */, bindingName);
+                // Add name of class expression into the map for semantic classifier
+                if (node.name) {
+                    classifiableNames[node.name.text] = node.name.text;
+                }
+            }
+            var symbol = node.symbol;
+            // TypeScript 1.0 spec (April 2014): 8.4
+            // Every class automatically contains a static property member named 'prototype', the
+            // type of which is an instantiation of the class type with type Any supplied as a type
+            // argument for each type parameter. It is an error to explicitly declare a static
+            // property member with the name 'prototype'.
+            //
+            // Note: we check for this here because this class may be merging into a module.  The
+            // module might have an exported variable called 'prototype'.  We can't allow that as
+            // that would clash with the built-in 'prototype' for the class.
+            var prototypeSymbol = createSymbol(4 /* Property */ | 134217728 /* Prototype */, "prototype");
+            if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) {
+                if (node.name) {
+                    node.name.parent = node;
+                }
+                file.bindDiagnostics.push(ts.createDiagnosticForNode(symbol.exports[prototypeSymbol.name].declarations[0], ts.Diagnostics.Duplicate_identifier_0, prototypeSymbol.name));
+            }
+            symbol.exports[prototypeSymbol.name] = prototypeSymbol;
+            prototypeSymbol.parent = symbol;
+        }
+        function bindEnumDeclaration(node) {
+            return ts.isConst(node)
+                ? bindBlockScopedDeclaration(node, 128 /* ConstEnum */, 899967 /* ConstEnumExcludes */)
+                : bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */);
+        }
+        function bindVariableDeclarationOrBindingElement(node) {
+            if (inStrictMode) {
+                checkStrictModeEvalOrArguments(node, node.name);
+            }
+            if (!ts.isBindingPattern(node.name)) {
+                if (ts.isBlockOrCatchScoped(node)) {
+                    bindBlockScopedVariableDeclaration(node);
+                }
+                else if (ts.isParameterDeclaration(node)) {
+                    // It is safe to walk up parent chain to find whether the node is a destructing parameter declaration
+                    // because its parent chain has already been set up, since parents are set before descending into children.
+                    //
+                    // If node is a binding element in parameter declaration, we need to use ParameterExcludes.
+                    // Using ParameterExcludes flag allows the compiler to report an error on duplicate identifiers in Parameter Declaration
+                    // For example:
+                    //      function foo([a,a]) {} // Duplicate Identifier error
+                    //      function bar(a,a) {}   // Duplicate Identifier error, parameter declaration in this case is handled in bindParameter
+                    //                             // which correctly set excluded symbols
+                    declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 107455 /* ParameterExcludes */);
+                }
+                else {
+                    declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 107454 /* FunctionScopedVariableExcludes */);
+                }
+            }
+        }
+        function bindParameter(node) {
+            if (!ts.isDeclarationFile(file) &&
+                !ts.isInAmbientContext(node) &&
+                ts.nodeIsDecorated(node)) {
+                emitFlags |= (524288 /* HasDecorators */ | 1048576 /* HasParamDecorators */);
+            }
+            if (inStrictMode) {
+                // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a
+                // strict mode FunctionLikeDeclaration or FunctionExpression(13.1)
+                checkStrictModeEvalOrArguments(node, node.name);
+            }
+            if (ts.isBindingPattern(node.name)) {
+                bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, getDestructuringParameterName(node));
+            }
+            else {
+                declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 107455 /* ParameterExcludes */);
+            }
+            // If this is a property-parameter, then also declare the property symbol into the
+            // containing class.
+            if (ts.isParameterPropertyDeclaration(node)) {
+                var classDeclaration = node.parent.parent;
+                declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), 0 /* PropertyExcludes */);
+            }
+        }
+        function bindFunctionDeclaration(node) {
+            if (!ts.isDeclarationFile(file) && !ts.isInAmbientContext(node)) {
+                if (ts.isAsyncFunctionLike(node)) {
+                    emitFlags |= 2097152 /* HasAsyncFunctions */;
+                }
+            }
+            checkStrictModeFunctionName(node);
+            if (inStrictMode) {
+                checkStrictModeFunctionDeclaration(node);
+                bindBlockScopedDeclaration(node, 16 /* Function */, 106927 /* FunctionExcludes */);
+            }
+            else {
+                declareSymbolAndAddToSymbolTable(node, 16 /* Function */, 106927 /* FunctionExcludes */);
+            }
+        }
+        function bindFunctionExpression(node) {
+            if (!ts.isDeclarationFile(file) && !ts.isInAmbientContext(node)) {
+                if (ts.isAsyncFunctionLike(node)) {
+                    emitFlags |= 2097152 /* HasAsyncFunctions */;
+                }
+            }
+            if (currentFlow) {
+                node.flowNode = currentFlow;
+            }
+            checkStrictModeFunctionName(node);
+            var bindingName = node.name ? node.name.text : "__function";
+            return bindAnonymousDeclaration(node, 16 /* Function */, bindingName);
+        }
+        function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
+            if (!ts.isDeclarationFile(file) && !ts.isInAmbientContext(node)) {
+                if (ts.isAsyncFunctionLike(node)) {
+                    emitFlags |= 2097152 /* HasAsyncFunctions */;
+                }
+                if (ts.nodeIsDecorated(node)) {
+                    emitFlags |= 524288 /* HasDecorators */;
+                }
+            }
+            return ts.hasDynamicName(node)
+                ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
+                : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
+        }
+        function bindJSDocProperty(node) {
+            return declareSymbolAndAddToSymbolTable(node, 4 /* Property */, 0 /* PropertyExcludes */);
+        }
+        // reachability checks
+        function shouldReportErrorOnModuleDeclaration(node) {
+            var instanceState = getModuleInstanceState(node);
+            return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && options.preserveConstEnums);
+        }
+        function checkUnreachable(node) {
+            if (!(currentFlow.flags & 1 /* Unreachable */)) {
+                return false;
+            }
+            if (currentFlow === unreachableFlow) {
+                var reportError = 
+                // report error on all statements except empty ones
+                (ts.isStatement(node) && node.kind !== 201 /* EmptyStatement */) ||
+                    // report error on class declarations
+                    node.kind === 221 /* ClassDeclaration */ ||
+                    // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+                    (node.kind === 225 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)) ||
+                    // report error on regular enums and const enums if preserveConstEnums is set
+                    (node.kind === 224 /* EnumDeclaration */ && (!ts.isConstEnumDeclaration(node) || options.preserveConstEnums));
+                if (reportError) {
+                    currentFlow = reportedUnreachableFlow;
+                    // unreachable code is reported if
+                    // - user has explicitly asked about it AND
+                    // - statement is in not ambient context (statements in ambient context is already an error
+                    //   so we should not report extras) AND
+                    //   - node is not variable statement OR
+                    //   - node is block scoped variable statement OR
+                    //   - node is not block scoped variable statement and at least one variable declaration has initializer
+                    //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
+                    //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
+                    var reportUnreachableCode = !options.allowUnreachableCode &&
+                        !ts.isInAmbientContext(node) &&
+                        (node.kind !== 200 /* VariableStatement */ ||
+                            ts.getCombinedNodeFlags(node.declarationList) & 3072 /* BlockScoped */ ||
+                            ts.forEach(node.declarationList.declarations, function (d) { return d.initializer; }));
+                    if (reportUnreachableCode) {
+                        errorOnFirstToken(node, ts.Diagnostics.Unreachable_code_detected);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+})(ts || (ts = {}));
+/// <reference path="binder.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var nextSymbolId = 1;
+    var nextNodeId = 1;
+    var nextMergeId = 1;
+    var nextFlowId = 1;
+    function getNodeId(node) {
+        if (!node.id) {
+            node.id = nextNodeId;
+            nextNodeId++;
+        }
+        return node.id;
+    }
+    ts.getNodeId = getNodeId;
+    ts.checkTime = 0;
+    function getSymbolId(symbol) {
+        if (!symbol.id) {
+            symbol.id = nextSymbolId;
+            nextSymbolId++;
+        }
+        return symbol.id;
+    }
+    ts.getSymbolId = getSymbolId;
+    function createTypeChecker(host, produceDiagnostics) {
+        // Cancellation that controls whether or not we can cancel in the middle of type checking.
+        // In general cancelling is *not* safe for the type checker.  We might be in the middle of
+        // computing something, and we will leave our internals in an inconsistent state.  Callers
+        // who set the cancellation token should catch if a cancellation exception occurs, and
+        // should throw away and create a new TypeChecker.
+        //
+        // Currently we only support setting the cancellation token when getting diagnostics.  This
+        // is because diagnostics can be quite expensive, and we want to allow hosts to bail out if
+        // they no longer need the information (for example, if the user started editing again).
+        var cancellationToken;
+        var Symbol = ts.objectAllocator.getSymbolConstructor();
+        var Type = ts.objectAllocator.getTypeConstructor();
+        var Signature = ts.objectAllocator.getSignatureConstructor();
+        var typeCount = 0;
+        var symbolCount = 0;
+        var emptyArray = [];
+        var emptySymbols = {};
+        var compilerOptions = host.getCompilerOptions();
+        var languageVersion = compilerOptions.target || 0 /* ES3 */;
+        var modulekind = ts.getEmitModuleKind(compilerOptions);
+        var noUnusedIdentifiers = !!compilerOptions.noUnusedLocals || !!compilerOptions.noUnusedParameters;
+        var allowSyntheticDefaultImports = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ts.ModuleKind.System;
+        var strictNullChecks = compilerOptions.strictNullChecks;
+        var emitResolver = createResolver();
+        var undefinedSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "undefined");
+        undefinedSymbol.declarations = [];
+        var argumentsSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "arguments");
+        var checker = {
+            getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); },
+            getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); },
+            getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount") + symbolCount; },
+            getTypeCount: function () { return typeCount; },
+            isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; },
+            isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; },
+            isUnknownSymbol: function (symbol) { return symbol === unknownSymbol; },
+            getDiagnostics: getDiagnostics,
+            getGlobalDiagnostics: getGlobalDiagnostics,
+            getTypeOfSymbolAtLocation: getTypeOfSymbolAtLocation,
+            getSymbolsOfParameterPropertyDeclaration: getSymbolsOfParameterPropertyDeclaration,
+            getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol,
+            getPropertiesOfType: getPropertiesOfType,
+            getPropertyOfType: getPropertyOfType,
+            getSignaturesOfType: getSignaturesOfType,
+            getIndexTypeOfType: getIndexTypeOfType,
+            getBaseTypes: getBaseTypes,
+            getReturnTypeOfSignature: getReturnTypeOfSignature,
+            getNonNullableType: getNonNullableType,
+            getSymbolsInScope: getSymbolsInScope,
+            getSymbolAtLocation: getSymbolAtLocation,
+            getShorthandAssignmentValueSymbol: getShorthandAssignmentValueSymbol,
+            getExportSpecifierLocalTargetSymbol: getExportSpecifierLocalTargetSymbol,
+            getTypeAtLocation: getTypeOfNode,
+            getPropertySymbolOfDestructuringAssignment: getPropertySymbolOfDestructuringAssignment,
+            typeToString: typeToString,
+            getSymbolDisplayBuilder: getSymbolDisplayBuilder,
+            symbolToString: symbolToString,
+            getAugmentedPropertiesOfType: getAugmentedPropertiesOfType,
+            getRootSymbols: getRootSymbols,
+            getContextualType: getContextualType,
+            getFullyQualifiedName: getFullyQualifiedName,
+            getResolvedSignature: getResolvedSignature,
+            getConstantValue: getConstantValue,
+            isValidPropertyAccess: isValidPropertyAccess,
+            getSignatureFromDeclaration: getSignatureFromDeclaration,
+            isImplementationOfOverload: isImplementationOfOverload,
+            getAliasedSymbol: resolveAlias,
+            getEmitResolver: getEmitResolver,
+            getExportsOfModule: getExportsOfModuleAsArray,
+            getJsxElementAttributesType: getJsxElementAttributesType,
+            getJsxIntrinsicTagNames: getJsxIntrinsicTagNames,
+            isOptionalParameter: isOptionalParameter
+        };
+        var unknownSymbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "unknown");
+        var resolvingSymbol = createSymbol(67108864 /* Transient */, "__resolving__");
+        var anyType = createIntrinsicType(1 /* Any */, "any");
+        var stringType = createIntrinsicType(2 /* String */, "string");
+        var numberType = createIntrinsicType(4 /* Number */, "number");
+        var booleanType = createIntrinsicType(8 /* Boolean */, "boolean");
+        var esSymbolType = createIntrinsicType(16777216 /* ESSymbol */, "symbol");
+        var voidType = createIntrinsicType(16 /* Void */, "void");
+        var undefinedType = createIntrinsicType(32 /* Undefined */, "undefined");
+        var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32 /* Undefined */ | 2097152 /* ContainsWideningType */, "undefined");
+        var nullType = createIntrinsicType(64 /* Null */, "null");
+        var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(64 /* Null */ | 2097152 /* ContainsWideningType */, "null");
+        var unknownType = createIntrinsicType(1 /* Any */, "unknown");
+        var neverType = createIntrinsicType(134217728 /* Never */, "never");
+        var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        var emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        emptyGenericType.instantiations = {};
+        var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated
+        // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.
+        anyFunctionType.flags |= 8388608 /* ContainsAnyFunctionType */;
+        var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        var anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false);
+        var unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, unknownType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false);
+        var enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);
+        var globals = {};
+        /**
+         * List of every ambient module with a "*" wildcard.
+         * Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches.
+         * This is only used if there is no exact match.
+        */
+        var patternAmbientModules;
+        var getGlobalESSymbolConstructorSymbol;
+        var getGlobalPromiseConstructorSymbol;
+        var globalObjectType;
+        var globalFunctionType;
+        var globalArrayType;
+        var globalReadonlyArrayType;
+        var globalStringType;
+        var globalNumberType;
+        var globalBooleanType;
+        var globalRegExpType;
+        var anyArrayType;
+        var anyReadonlyArrayType;
+        // The library files are only loaded when the feature is used.
+        // This allows users to just specify library files they want to used through --lib
+        // and they will not get an error from not having unrelated library files
+        var getGlobalTemplateStringsArrayType;
+        var getGlobalESSymbolType;
+        var getGlobalIterableType;
+        var getGlobalIteratorType;
+        var getGlobalIterableIteratorType;
+        var getGlobalClassDecoratorType;
+        var getGlobalParameterDecoratorType;
+        var getGlobalPropertyDecoratorType;
+        var getGlobalMethodDecoratorType;
+        var getGlobalTypedPropertyDescriptorType;
+        var getGlobalPromiseType;
+        var tryGetGlobalPromiseType;
+        var getGlobalPromiseLikeType;
+        var getInstantiatedGlobalPromiseLikeType;
+        var getGlobalPromiseConstructorLikeType;
+        var getGlobalThenableType;
+        var jsxElementClassType;
+        var deferredNodes;
+        var deferredUnusedIdentifierNodes;
+        var flowLoopStart = 0;
+        var flowLoopCount = 0;
+        var visitedFlowCount = 0;
+        var tupleTypes = {};
+        var unionTypes = {};
+        var intersectionTypes = {};
+        var stringLiteralTypes = {};
+        var resolutionTargets = [];
+        var resolutionResults = [];
+        var resolutionPropertyNames = [];
+        var mergedSymbols = [];
+        var symbolLinks = [];
+        var nodeLinks = [];
+        var flowLoopCaches = [];
+        var flowLoopNodes = [];
+        var flowLoopKeys = [];
+        var flowLoopTypes = [];
+        var visitedFlowNodes = [];
+        var visitedFlowTypes = [];
+        var potentialThisCollisions = [];
+        var awaitedTypeStack = [];
+        var diagnostics = ts.createDiagnosticCollection();
+        var TypeFacts;
+        (function (TypeFacts) {
+            TypeFacts[TypeFacts["None"] = 0] = "None";
+            TypeFacts[TypeFacts["TypeofEQString"] = 1] = "TypeofEQString";
+            TypeFacts[TypeFacts["TypeofEQNumber"] = 2] = "TypeofEQNumber";
+            TypeFacts[TypeFacts["TypeofEQBoolean"] = 4] = "TypeofEQBoolean";
+            TypeFacts[TypeFacts["TypeofEQSymbol"] = 8] = "TypeofEQSymbol";
+            TypeFacts[TypeFacts["TypeofEQObject"] = 16] = "TypeofEQObject";
+            TypeFacts[TypeFacts["TypeofEQFunction"] = 32] = "TypeofEQFunction";
+            TypeFacts[TypeFacts["TypeofEQHostObject"] = 64] = "TypeofEQHostObject";
+            TypeFacts[TypeFacts["TypeofNEString"] = 128] = "TypeofNEString";
+            TypeFacts[TypeFacts["TypeofNENumber"] = 256] = "TypeofNENumber";
+            TypeFacts[TypeFacts["TypeofNEBoolean"] = 512] = "TypeofNEBoolean";
+            TypeFacts[TypeFacts["TypeofNESymbol"] = 1024] = "TypeofNESymbol";
+            TypeFacts[TypeFacts["TypeofNEObject"] = 2048] = "TypeofNEObject";
+            TypeFacts[TypeFacts["TypeofNEFunction"] = 4096] = "TypeofNEFunction";
+            TypeFacts[TypeFacts["TypeofNEHostObject"] = 8192] = "TypeofNEHostObject";
+            TypeFacts[TypeFacts["EQUndefined"] = 16384] = "EQUndefined";
+            TypeFacts[TypeFacts["EQNull"] = 32768] = "EQNull";
+            TypeFacts[TypeFacts["EQUndefinedOrNull"] = 65536] = "EQUndefinedOrNull";
+            TypeFacts[TypeFacts["NEUndefined"] = 131072] = "NEUndefined";
+            TypeFacts[TypeFacts["NENull"] = 262144] = "NENull";
+            TypeFacts[TypeFacts["NEUndefinedOrNull"] = 524288] = "NEUndefinedOrNull";
+            TypeFacts[TypeFacts["Truthy"] = 1048576] = "Truthy";
+            TypeFacts[TypeFacts["Falsy"] = 2097152] = "Falsy";
+            TypeFacts[TypeFacts["All"] = 4194303] = "All";
+            // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
+            // The presence of a particular fact means that the given test is true for some (and possibly all) values
+            // of that kind of type.
+            TypeFacts[TypeFacts["StringStrictFacts"] = 4079361] = "StringStrictFacts";
+            TypeFacts[TypeFacts["StringFacts"] = 4194049] = "StringFacts";
+            TypeFacts[TypeFacts["NumberStrictFacts"] = 4079234] = "NumberStrictFacts";
+            TypeFacts[TypeFacts["NumberFacts"] = 4193922] = "NumberFacts";
+            TypeFacts[TypeFacts["BooleanStrictFacts"] = 4078980] = "BooleanStrictFacts";
+            TypeFacts[TypeFacts["BooleanFacts"] = 4193668] = "BooleanFacts";
+            TypeFacts[TypeFacts["SymbolStrictFacts"] = 1981320] = "SymbolStrictFacts";
+            TypeFacts[TypeFacts["SymbolFacts"] = 4193160] = "SymbolFacts";
+            TypeFacts[TypeFacts["ObjectStrictFacts"] = 1972176] = "ObjectStrictFacts";
+            TypeFacts[TypeFacts["ObjectFacts"] = 4184016] = "ObjectFacts";
+            TypeFacts[TypeFacts["FunctionStrictFacts"] = 1970144] = "FunctionStrictFacts";
+            TypeFacts[TypeFacts["FunctionFacts"] = 4181984] = "FunctionFacts";
+            TypeFacts[TypeFacts["UndefinedFacts"] = 2457472] = "UndefinedFacts";
+            TypeFacts[TypeFacts["NullFacts"] = 2340752] = "NullFacts";
+        })(TypeFacts || (TypeFacts = {}));
+        var typeofEQFacts = {
+            "string": 1 /* TypeofEQString */,
+            "number": 2 /* TypeofEQNumber */,
+            "boolean": 4 /* TypeofEQBoolean */,
+            "symbol": 8 /* TypeofEQSymbol */,
+            "undefined": 16384 /* EQUndefined */,
+            "object": 16 /* TypeofEQObject */,
+            "function": 32 /* TypeofEQFunction */
+        };
+        var typeofNEFacts = {
+            "string": 128 /* TypeofNEString */,
+            "number": 256 /* TypeofNENumber */,
+            "boolean": 512 /* TypeofNEBoolean */,
+            "symbol": 1024 /* TypeofNESymbol */,
+            "undefined": 131072 /* NEUndefined */,
+            "object": 2048 /* TypeofNEObject */,
+            "function": 4096 /* TypeofNEFunction */
+        };
+        var typeofTypesByName = {
+            "string": stringType,
+            "number": numberType,
+            "boolean": booleanType,
+            "symbol": esSymbolType,
+            "undefined": undefinedType
+        };
+        var jsxElementType;
+        /** Things we lazy load from the JSX namespace */
+        var jsxTypes = {};
+        var JsxNames = {
+            JSX: "JSX",
+            IntrinsicElements: "IntrinsicElements",
+            ElementClass: "ElementClass",
+            ElementAttributesPropertyNameContainer: "ElementAttributesProperty",
+            Element: "Element",
+            IntrinsicAttributes: "IntrinsicAttributes",
+            IntrinsicClassAttributes: "IntrinsicClassAttributes"
+        };
+        var subtypeRelation = {};
+        var assignableRelation = {};
+        var comparableRelation = {};
+        var identityRelation = {};
+        // This is for caching the result of getSymbolDisplayBuilder. Do not access directly.
+        var _displayBuilder;
+        var TypeSystemPropertyName;
+        (function (TypeSystemPropertyName) {
+            TypeSystemPropertyName[TypeSystemPropertyName["Type"] = 0] = "Type";
+            TypeSystemPropertyName[TypeSystemPropertyName["ResolvedBaseConstructorType"] = 1] = "ResolvedBaseConstructorType";
+            TypeSystemPropertyName[TypeSystemPropertyName["DeclaredType"] = 2] = "DeclaredType";
+            TypeSystemPropertyName[TypeSystemPropertyName["ResolvedReturnType"] = 3] = "ResolvedReturnType";
+        })(TypeSystemPropertyName || (TypeSystemPropertyName = {}));
+        var builtinGlobals = (_a = {},
+            _a[undefinedSymbol.name] = undefinedSymbol,
+            _a
+        );
+        initializeTypeChecker();
+        return checker;
+        function getEmitResolver(sourceFile, cancellationToken) {
+            // Ensure we have all the type information in place for this file so that all the
+            // emitter questions of this resolver will return the right information.
+            getDiagnostics(sourceFile, cancellationToken);
+            return emitResolver;
+        }
+        function error(location, message, arg0, arg1, arg2) {
+            var diagnostic = location
+                ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2)
+                : ts.createCompilerDiagnostic(message, arg0, arg1, arg2);
+            diagnostics.add(diagnostic);
+        }
+        function createSymbol(flags, name) {
+            symbolCount++;
+            return new Symbol(flags, name);
+        }
+        function getExcludedSymbolFlags(flags) {
+            var result = 0;
+            if (flags & 2 /* BlockScopedVariable */)
+                result |= 107455 /* BlockScopedVariableExcludes */;
+            if (flags & 1 /* FunctionScopedVariable */)
+                result |= 107454 /* FunctionScopedVariableExcludes */;
+            if (flags & 4 /* Property */)
+                result |= 0 /* PropertyExcludes */;
+            if (flags & 8 /* EnumMember */)
+                result |= 107455 /* EnumMemberExcludes */;
+            if (flags & 16 /* Function */)
+                result |= 106927 /* FunctionExcludes */;
+            if (flags & 32 /* Class */)
+                result |= 899519 /* ClassExcludes */;
+            if (flags & 64 /* Interface */)
+                result |= 792960 /* InterfaceExcludes */;
+            if (flags & 256 /* RegularEnum */)
+                result |= 899327 /* RegularEnumExcludes */;
+            if (flags & 128 /* ConstEnum */)
+                result |= 899967 /* ConstEnumExcludes */;
+            if (flags & 512 /* ValueModule */)
+                result |= 106639 /* ValueModuleExcludes */;
+            if (flags & 8192 /* Method */)
+                result |= 99263 /* MethodExcludes */;
+            if (flags & 32768 /* GetAccessor */)
+                result |= 41919 /* GetAccessorExcludes */;
+            if (flags & 65536 /* SetAccessor */)
+                result |= 74687 /* SetAccessorExcludes */;
+            if (flags & 262144 /* TypeParameter */)
+                result |= 530912 /* TypeParameterExcludes */;
+            if (flags & 524288 /* TypeAlias */)
+                result |= 793056 /* TypeAliasExcludes */;
+            if (flags & 8388608 /* Alias */)
+                result |= 8388608 /* AliasExcludes */;
+            return result;
+        }
+        function recordMergedSymbol(target, source) {
+            if (!source.mergeId) {
+                source.mergeId = nextMergeId;
+                nextMergeId++;
+            }
+            mergedSymbols[source.mergeId] = target;
+        }
+        function cloneSymbol(symbol) {
+            var result = createSymbol(symbol.flags | 33554432 /* Merged */, symbol.name);
+            result.declarations = symbol.declarations.slice(0);
+            result.parent = symbol.parent;
+            if (symbol.valueDeclaration)
+                result.valueDeclaration = symbol.valueDeclaration;
+            if (symbol.constEnumOnlyModule)
+                result.constEnumOnlyModule = true;
+            if (symbol.members)
+                result.members = cloneSymbolTable(symbol.members);
+            if (symbol.exports)
+                result.exports = cloneSymbolTable(symbol.exports);
+            recordMergedSymbol(result, symbol);
+            return result;
+        }
+        function mergeSymbol(target, source) {
+            if (!(target.flags & getExcludedSymbolFlags(source.flags))) {
+                if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
+                    // reset flag when merging instantiated module into value module that has only const enums
+                    target.constEnumOnlyModule = false;
+                }
+                target.flags |= source.flags;
+                if (source.valueDeclaration &&
+                    (!target.valueDeclaration ||
+                        (target.valueDeclaration.kind === 225 /* ModuleDeclaration */ && source.valueDeclaration.kind !== 225 /* ModuleDeclaration */))) {
+                    // other kinds of value declarations take precedence over modules
+                    target.valueDeclaration = source.valueDeclaration;
+                }
+                ts.forEach(source.declarations, function (node) {
+                    target.declarations.push(node);
+                });
+                if (source.members) {
+                    if (!target.members)
+                        target.members = {};
+                    mergeSymbolTable(target.members, source.members);
+                }
+                if (source.exports) {
+                    if (!target.exports)
+                        target.exports = {};
+                    mergeSymbolTable(target.exports, source.exports);
+                }
+                recordMergedSymbol(target, source);
+            }
+            else {
+                var message_2 = target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */
+                    ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0;
+                ts.forEach(source.declarations, function (node) {
+                    error(node.name ? node.name : node, message_2, symbolToString(source));
+                });
+                ts.forEach(target.declarations, function (node) {
+                    error(node.name ? node.name : node, message_2, symbolToString(source));
+                });
+            }
+        }
+        function cloneSymbolTable(symbolTable) {
+            var result = {};
+            for (var id in symbolTable) {
+                if (ts.hasProperty(symbolTable, id)) {
+                    result[id] = symbolTable[id];
+                }
+            }
+            return result;
+        }
+        function mergeSymbolTable(target, source) {
+            for (var id in source) {
+                if (ts.hasProperty(source, id)) {
+                    if (!ts.hasProperty(target, id)) {
+                        target[id] = source[id];
+                    }
+                    else {
+                        var symbol = target[id];
+                        if (!(symbol.flags & 33554432 /* Merged */)) {
+                            target[id] = symbol = cloneSymbol(symbol);
+                        }
+                        mergeSymbol(symbol, source[id]);
+                    }
+                }
+            }
+        }
+        function mergeModuleAugmentation(moduleName) {
+            var moduleAugmentation = moduleName.parent;
+            if (moduleAugmentation.symbol.declarations[0] !== moduleAugmentation) {
+                // this is a combined symbol for multiple augmentations within the same file.
+                // its symbol already has accumulated information for all declarations
+                // so we need to add it just once - do the work only for first declaration
+                ts.Debug.assert(moduleAugmentation.symbol.declarations.length > 1);
+                return;
+            }
+            if (ts.isGlobalScopeAugmentation(moduleAugmentation)) {
+                mergeSymbolTable(globals, moduleAugmentation.symbol.exports);
+            }
+            else {
+                // find a module that about to be augmented
+                // do not validate names of augmentations that are defined in ambient context
+                var moduleNotFoundError = !ts.isInAmbientContext(moduleName.parent.parent)
+                    ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found
+                    : undefined;
+                var mainModule = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError);
+                if (!mainModule) {
+                    return;
+                }
+                // obtain item referenced by 'export='
+                mainModule = resolveExternalModuleSymbol(mainModule);
+                if (mainModule.flags & 1536 /* Namespace */) {
+                    // if module symbol has already been merged - it is safe to use it.
+                    // otherwise clone it
+                    mainModule = mainModule.flags & 33554432 /* Merged */ ? mainModule : cloneSymbol(mainModule);
+                    mergeSymbol(mainModule, moduleAugmentation.symbol);
+                }
+                else {
+                    error(moduleName, ts.Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text);
+                }
+            }
+        }
+        function addToSymbolTable(target, source, message) {
+            for (var id in source) {
+                if (ts.hasProperty(source, id)) {
+                    if (ts.hasProperty(target, id)) {
+                        // Error on redeclarations
+                        ts.forEach(target[id].declarations, addDeclarationDiagnostic(id, message));
+                    }
+                    else {
+                        target[id] = source[id];
+                    }
+                }
+            }
+            function addDeclarationDiagnostic(id, message) {
+                return function (declaration) { return diagnostics.add(ts.createDiagnosticForNode(declaration, message, id)); };
+            }
+        }
+        function getSymbolLinks(symbol) {
+            if (symbol.flags & 67108864 /* Transient */)
+                return symbol;
+            var id = getSymbolId(symbol);
+            return symbolLinks[id] || (symbolLinks[id] = {});
+        }
+        function getNodeLinks(node) {
+            var nodeId = getNodeId(node);
+            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+        }
+        function isGlobalSourceFile(node) {
+            return node.kind === 256 /* SourceFile */ && !ts.isExternalOrCommonJsModule(node);
+        }
+        function getSymbol(symbols, name, meaning) {
+            if (meaning && ts.hasProperty(symbols, name)) {
+                var symbol = symbols[name];
+                ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
+                if (symbol.flags & meaning) {
+                    return symbol;
+                }
+                if (symbol.flags & 8388608 /* Alias */) {
+                    var target = resolveAlias(symbol);
+                    // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
+                    if (target === unknownSymbol || target.flags & meaning) {
+                        return symbol;
+                    }
+                }
+            }
+            // return undefined if we can't find a symbol.
+        }
+        /**
+         * Get symbols that represent parameter-property-declaration as parameter and as property declaration
+         * @param parameter a parameterDeclaration node
+         * @param parameterName a name of the parameter to get the symbols for.
+         * @return a tuple of two symbols
+         */
+        function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
+            var constructorDeclaration = parameter.parent;
+            var classDeclaration = parameter.parent.parent;
+            var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 107455 /* Value */);
+            var propertySymbol = getSymbol(classDeclaration.symbol.members, parameterName, 107455 /* Value */);
+            if (parameterSymbol && propertySymbol) {
+                return [parameterSymbol, propertySymbol];
+            }
+            ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
+        }
+        function isBlockScopedNameDeclaredBeforeUse(declaration, usage) {
+            var declarationFile = ts.getSourceFileOfNode(declaration);
+            var useFile = ts.getSourceFileOfNode(usage);
+            if (declarationFile !== useFile) {
+                if ((modulekind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
+                    (!compilerOptions.outFile && !compilerOptions.out)) {
+                    // nodes are in different files and order cannot be determines
+                    return true;
+                }
+                var sourceFiles = host.getSourceFiles();
+                return ts.indexOf(sourceFiles, declarationFile) <= ts.indexOf(sourceFiles, useFile);
+            }
+            if (declaration.pos <= usage.pos) {
+                // declaration is before usage
+                // still might be illegal if usage is in the initializer of the variable declaration
+                return declaration.kind !== 218 /* VariableDeclaration */ ||
+                    !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
+            }
+            // declaration is after usage
+            // can be legal if usage is deferred (i.e. inside function or in initializer of instance property)
+            return isUsedInFunctionOrNonStaticProperty(declaration, usage);
+            function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage) {
+                var container = ts.getEnclosingBlockScopeContainer(declaration);
+                switch (declaration.parent.parent.kind) {
+                    case 200 /* VariableStatement */:
+                    case 206 /* ForStatement */:
+                    case 208 /* ForOfStatement */:
+                        // variable statement/for/for-of statement case,
+                        // use site should not be inside variable declaration (initializer of declaration or binding element)
+                        if (isSameScopeDescendentOf(usage, declaration, container)) {
+                            return true;
+                        }
+                        break;
+                }
+                switch (declaration.parent.parent.kind) {
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                        // ForIn/ForOf case - use site should not be used in expression part
+                        if (isSameScopeDescendentOf(usage, declaration.parent.parent.expression, container)) {
+                            return true;
+                        }
+                }
+                return false;
+            }
+            function isUsedInFunctionOrNonStaticProperty(declaration, usage) {
+                var container = ts.getEnclosingBlockScopeContainer(declaration);
+                var current = usage;
+                while (current) {
+                    if (current === container) {
+                        return false;
+                    }
+                    if (ts.isFunctionLike(current)) {
+                        return true;
+                    }
+                    var initializerOfNonStaticProperty = current.parent &&
+                        current.parent.kind === 145 /* PropertyDeclaration */ &&
+                        (current.parent.flags & 32 /* Static */) === 0 &&
+                        current.parent.initializer === current;
+                    if (initializerOfNonStaticProperty) {
+                        return true;
+                    }
+                    current = current.parent;
+                }
+                return false;
+            }
+        }
+        // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
+        // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
+        // the given name can be found.
+        function resolveName(location, name, meaning, nameNotFoundMessage, nameArg) {
+            var result;
+            var lastLocation;
+            var propertyWithInvalidInitializer;
+            var errorLocation = location;
+            var grandparent;
+            var isInExternalModule = false;
+            loop: while (location) {
+                // Locals of a source file are not in scope (because they get merged into the global symbol table)
+                if (location.locals && !isGlobalSourceFile(location)) {
+                    if (result = getSymbol(location.locals, name, meaning)) {
+                        var useResult = true;
+                        if (ts.isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
+                            // symbol lookup restrictions for function-like declarations
+                            // - Type parameters of a function are in scope in the entire function declaration, including the parameter
+                            //   list and return type. However, local types are only in scope in the function body.
+                            // - parameters are only in the scope of function body
+                            // This restriction does not apply to JSDoc comment types because they are parented
+                            // at a higher level than type parameters would normally be
+                            if (meaning & result.flags & 793056 /* Type */ && lastLocation.kind !== 273 /* JSDocComment */) {
+                                useResult = result.flags & 262144 /* TypeParameter */
+                                    ? lastLocation === location.type ||
+                                        lastLocation.kind === 142 /* Parameter */ ||
+                                        lastLocation.kind === 141 /* TypeParameter */
+                                    : false;
+                            }
+                            if (meaning & 107455 /* Value */ && result.flags & 1 /* FunctionScopedVariable */) {
+                                // parameters are visible only inside function body, parameter list and return type
+                                // technically for parameter list case here we might mix parameters and variables declared in function,
+                                // however it is detected separately when checking initializers of parameters
+                                // to make sure that they reference no variables declared after them.
+                                useResult =
+                                    lastLocation.kind === 142 /* Parameter */ ||
+                                        (lastLocation === location.type &&
+                                            result.valueDeclaration.kind === 142 /* Parameter */);
+                            }
+                        }
+                        if (useResult) {
+                            break loop;
+                        }
+                        else {
+                            result = undefined;
+                        }
+                    }
+                }
+                switch (location.kind) {
+                    case 256 /* SourceFile */:
+                        if (!ts.isExternalOrCommonJsModule(location))
+                            break;
+                        isInExternalModule = true;
+                    case 225 /* ModuleDeclaration */:
+                        var moduleExports = getSymbolOfNode(location).exports;
+                        if (location.kind === 256 /* SourceFile */ || ts.isAmbientModule(location)) {
+                            // It's an external module. First see if the module has an export default and if the local
+                            // name of that export default matches.
+                            if (result = moduleExports["default"]) {
+                                var localSymbol = ts.getLocalSymbolForExportDefault(result);
+                                if (localSymbol && (result.flags & meaning) && localSymbol.name === name) {
+                                    break loop;
+                                }
+                                result = undefined;
+                            }
+                            // Because of module/namespace merging, a module's exports are in scope,
+                            // yet we never want to treat an export specifier as putting a member in scope.
+                            // Therefore, if the name we find is purely an export specifier, it is not actually considered in scope.
+                            // Two things to note about this:
+                            //     1. We have to check this without calling getSymbol. The problem with calling getSymbol
+                            //        on an export specifier is that it might find the export specifier itself, and try to
+                            //        resolve it as an alias. This will cause the checker to consider the export specifier
+                            //        a circular alias reference when it might not be.
+                            //     2. We check === SymbolFlags.Alias in order to check that the symbol is *purely*
+                            //        an alias. If we used &, we'd be throwing out symbols that have non alias aspects,
+                            //        which is not the desired behavior.
+                            if (ts.hasProperty(moduleExports, name) &&
+                                moduleExports[name].flags === 8388608 /* Alias */ &&
+                                ts.getDeclarationOfKind(moduleExports[name], 238 /* ExportSpecifier */)) {
+                                break;
+                            }
+                        }
+                        if (result = getSymbol(moduleExports, name, meaning & 8914931 /* ModuleMember */)) {
+                            break loop;
+                        }
+                        break;
+                    case 224 /* EnumDeclaration */:
+                        if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) {
+                            break loop;
+                        }
+                        break;
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                        // TypeScript 1.0 spec (April 2014): 8.4.1
+                        // Initializer expressions for instance member variables are evaluated in the scope
+                        // of the class constructor body but are not permitted to reference parameters or
+                        // local variables of the constructor. This effectively means that entities from outer scopes
+                        // by the same name as a constructor parameter or local variable are inaccessible
+                        // in initializer expressions for instance member variables.
+                        if (ts.isClassLike(location.parent) && !(location.flags & 32 /* Static */)) {
+                            var ctor = findConstructorDeclaration(location.parent);
+                            if (ctor && ctor.locals) {
+                                if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) {
+                                    // Remember the property node, it will be used later to report appropriate error
+                                    propertyWithInvalidInitializer = location;
+                                }
+                            }
+                        }
+                        break;
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                        if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) {
+                            if (lastLocation && lastLocation.flags & 32 /* Static */) {
+                                // TypeScript 1.0 spec (April 2014): 3.4.1
+                                // The scope of a type parameter extends over the entire declaration with which the type
+                                // parameter list is associated, with the exception of static member declarations in classes.
+                                error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                                return undefined;
+                            }
+                            break loop;
+                        }
+                        if (location.kind === 192 /* ClassExpression */ && meaning & 32 /* Class */) {
+                            var className = location.name;
+                            if (className && name === className.text) {
+                                result = location.symbol;
+                                break loop;
+                            }
+                        }
+                        break;
+                    // It is not legal to reference a class's own type parameters from a computed property name that
+                    // belongs to the class. For example:
+                    //
+                    //   function foo<T>() { return '' }
+                    //   class C<T> { // <-- Class's own type parameter T
+                    //       [foo<T>()]() { } // <-- Reference to T from class's own computed property
+                    //   }
+                    //
+                    case 140 /* ComputedPropertyName */:
+                        grandparent = location.parent.parent;
+                        if (ts.isClassLike(grandparent) || grandparent.kind === 222 /* InterfaceDeclaration */) {
+                            // A reference to this grandparent's type parameters would be an error
+                            if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) {
+                                error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                                return undefined;
+                            }
+                        }
+                        break;
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 148 /* Constructor */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 220 /* FunctionDeclaration */:
+                    case 180 /* ArrowFunction */:
+                        if (meaning & 3 /* Variable */ && name === "arguments") {
+                            result = argumentsSymbol;
+                            break loop;
+                        }
+                        break;
+                    case 179 /* FunctionExpression */:
+                        if (meaning & 3 /* Variable */ && name === "arguments") {
+                            result = argumentsSymbol;
+                            break loop;
+                        }
+                        if (meaning & 16 /* Function */) {
+                            var functionName = location.name;
+                            if (functionName && name === functionName.text) {
+                                result = location.symbol;
+                                break loop;
+                            }
+                        }
+                        break;
+                    case 143 /* Decorator */:
+                        // Decorators are resolved at the class declaration. Resolving at the parameter
+                        // or member would result in looking up locals in the method.
+                        //
+                        //   function y() {}
+                        //   class C {
+                        //       method(@y x, y) {} // <-- decorator y should be resolved at the class declaration, not the parameter.
+                        //   }
+                        //
+                        if (location.parent && location.parent.kind === 142 /* Parameter */) {
+                            location = location.parent;
+                        }
+                        //
+                        //   function y() {}
+                        //   class C {
+                        //       @y method(x, y) {} // <-- decorator y should be resolved at the class declaration, not the method.
+                        //   }
+                        //
+                        if (location.parent && ts.isClassElement(location.parent)) {
+                            location = location.parent;
+                        }
+                        break;
+                }
+                lastLocation = location;
+                location = location.parent;
+            }
+            if (result && nameNotFoundMessage && noUnusedIdentifiers) {
+                result.isReferenced = true;
+            }
+            if (!result) {
+                result = getSymbol(globals, name, meaning);
+            }
+            if (!result) {
+                if (nameNotFoundMessage) {
+                    if (!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
+                        !checkAndReportErrorForExtendingInterface(errorLocation)) {
+                        error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg));
+                    }
+                }
+                return undefined;
+            }
+            // Perform extra checks only if error reporting was requested
+            if (nameNotFoundMessage) {
+                if (propertyWithInvalidInitializer) {
+                    // We have a match, but the reference occurred within a property initializer and the identifier also binds
+                    // to a local variable in the constructor where the code will be emitted.
+                    var propertyName = propertyWithInvalidInitializer.name;
+                    error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg));
+                    return undefined;
+                }
+                // Only check for block-scoped variable if we are looking for the
+                // name with variable meaning
+                //      For example,
+                //          declare module foo {
+                //              interface bar {}
+                //          }
+                //      const foo/*1*/: foo/*2*/.bar;
+                // The foo at /*1*/ and /*2*/ will share same symbol with two meaning
+                // block - scope variable and namespace module. However, only when we
+                // try to resolve name in /*1*/ which is used in variable position,
+                // we want to check for block- scoped
+                if (meaning & 2 /* BlockScopedVariable */) {
+                    var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+                    if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */) {
+                        checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
+                    }
+                }
+                // If we're in an external module, we can't reference symbols created from UMD export declarations
+                if (result && isInExternalModule) {
+                    var decls = result.declarations;
+                    if (decls && decls.length === 1 && decls[0].kind === 228 /* NamespaceExportDeclaration */) {
+                        error(errorLocation, ts.Diagnostics.Identifier_0_must_be_imported_from_a_module, name);
+                    }
+                }
+            }
+            return result;
+        }
+        function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
+            if (!errorLocation || (errorLocation.kind === 69 /* Identifier */ && (isTypeReferenceIdentifier(errorLocation)) || isInTypeQuery(errorLocation))) {
+                return false;
+            }
+            var container = ts.getThisContainer(errorLocation, /* includeArrowFunctions */ true);
+            var location = container;
+            while (location) {
+                if (ts.isClassLike(location.parent)) {
+                    var classSymbol = getSymbolOfNode(location.parent);
+                    if (!classSymbol) {
+                        break;
+                    }
+                    // Check to see if a static member exists.
+                    var constructorType = getTypeOfSymbol(classSymbol);
+                    if (getPropertyOfType(constructorType, name)) {
+                        error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg), symbolToString(classSymbol));
+                        return true;
+                    }
+                    // No static member is present.
+                    // Check if we're in an instance method and look for a relevant instance member.
+                    if (location === container && !(location.flags & 32 /* Static */)) {
+                        var instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType;
+                        if (getPropertyOfType(instanceType, name)) {
+                            error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg));
+                            return true;
+                        }
+                    }
+                }
+                location = location.parent;
+            }
+            return false;
+        }
+        function checkAndReportErrorForExtendingInterface(errorLocation) {
+            var parentClassExpression = errorLocation;
+            while (parentClassExpression) {
+                var kind = parentClassExpression.kind;
+                if (kind === 69 /* Identifier */ || kind === 172 /* PropertyAccessExpression */) {
+                    parentClassExpression = parentClassExpression.parent;
+                    continue;
+                }
+                if (kind === 194 /* ExpressionWithTypeArguments */) {
+                    break;
+                }
+                return false;
+            }
+            if (!parentClassExpression) {
+                return false;
+            }
+            var expression = parentClassExpression.expression;
+            if (resolveEntityName(expression, 64 /* Interface */, /*ignoreErrors*/ true)) {
+                error(errorLocation, ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, ts.getTextOfNode(expression));
+                return true;
+            }
+            return false;
+        }
+        function checkResolvedBlockScopedVariable(result, errorLocation) {
+            ts.Debug.assert((result.flags & 2 /* BlockScopedVariable */) !== 0);
+            // Block-scoped variables cannot be used before their definition
+            var declaration = ts.forEach(result.declarations, function (d) { return ts.isBlockOrCatchScoped(d) ? d : undefined; });
+            ts.Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined");
+            if (!isBlockScopedNameDeclaredBeforeUse(ts.getAncestor(declaration, 218 /* VariableDeclaration */), errorLocation)) {
+                error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, ts.declarationNameToString(declaration.name));
+            }
+        }
+        /* Starting from 'initial' node walk up the parent chain until 'stopAt' node is reached.
+         * If at any point current node is equal to 'parent' node - return true.
+         * Return false if 'stopAt' node is reached or isFunctionLike(current) === true.
+         */
+        function isSameScopeDescendentOf(initial, parent, stopAt) {
+            if (!parent) {
+                return false;
+            }
+            for (var current = initial; current && current !== stopAt && !ts.isFunctionLike(current); current = current.parent) {
+                if (current === parent) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function getAnyImportSyntax(node) {
+            if (ts.isAliasSymbolDeclaration(node)) {
+                if (node.kind === 229 /* ImportEqualsDeclaration */) {
+                    return node;
+                }
+                while (node && node.kind !== 230 /* ImportDeclaration */) {
+                    node = node.parent;
+                }
+                return node;
+            }
+        }
+        function getDeclarationOfAliasSymbol(symbol) {
+            return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; });
+        }
+        function getTargetOfImportEqualsDeclaration(node) {
+            if (node.moduleReference.kind === 240 /* ExternalModuleReference */) {
+                return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)));
+            }
+            return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node);
+        }
+        function getTargetOfImportClause(node) {
+            var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);
+            if (moduleSymbol) {
+                var exportDefaultSymbol = ts.isShorthandAmbientModule(moduleSymbol.valueDeclaration) ?
+                    moduleSymbol :
+                    moduleSymbol.exports["export="] ?
+                        getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") :
+                        resolveSymbol(moduleSymbol.exports["default"]);
+                if (!exportDefaultSymbol && !allowSyntheticDefaultImports) {
+                    error(node.name, ts.Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
+                }
+                else if (!exportDefaultSymbol && allowSyntheticDefaultImports) {
+                    return resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                }
+                return exportDefaultSymbol;
+            }
+        }
+        function getTargetOfNamespaceImport(node) {
+            var moduleSpecifier = node.parent.parent.moduleSpecifier;
+            return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier);
+        }
+        // This function creates a synthetic symbol that combines the value side of one symbol with the
+        // type/namespace side of another symbol. Consider this example:
+        //
+        //   declare module graphics {
+        //       interface Point {
+        //           x: number;
+        //           y: number;
+        //       }
+        //   }
+        //   declare var graphics: {
+        //       Point: new (x: number, y: number) => graphics.Point;
+        //   }
+        //   declare module "graphics" {
+        //       export = graphics;
+        //   }
+        //
+        // An 'import { Point } from "graphics"' needs to create a symbol that combines the value side 'Point'
+        // property with the type/namespace side interface 'Point'.
+        function combineValueAndTypeSymbols(valueSymbol, typeSymbol) {
+            if (valueSymbol.flags & (793056 /* Type */ | 1536 /* Namespace */)) {
+                return valueSymbol;
+            }
+            var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
+            result.declarations = ts.concatenate(valueSymbol.declarations, typeSymbol.declarations);
+            result.parent = valueSymbol.parent || typeSymbol.parent;
+            if (valueSymbol.valueDeclaration)
+                result.valueDeclaration = valueSymbol.valueDeclaration;
+            if (typeSymbol.members)
+                result.members = typeSymbol.members;
+            if (valueSymbol.exports)
+                result.exports = valueSymbol.exports;
+            return result;
+        }
+        function getExportOfModule(symbol, name) {
+            if (symbol.flags & 1536 /* Module */) {
+                var exports = getExportsOfSymbol(symbol);
+                if (ts.hasProperty(exports, name)) {
+                    return resolveSymbol(exports[name]);
+                }
+            }
+        }
+        function getPropertyOfVariable(symbol, name) {
+            if (symbol.flags & 3 /* Variable */) {
+                var typeAnnotation = symbol.valueDeclaration.type;
+                if (typeAnnotation) {
+                    return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
+                }
+            }
+        }
+        function getExternalModuleMember(node, specifier) {
+            var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+            var targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier);
+            if (targetSymbol) {
+                var name_10 = specifier.propertyName || specifier.name;
+                if (name_10.text) {
+                    if (ts.isShorthandAmbientModule(moduleSymbol.valueDeclaration)) {
+                        return moduleSymbol;
+                    }
+                    var symbolFromVariable = void 0;
+                    // First check if module was specified with "export=". If so, get the member from the resolved type
+                    if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports["export="]) {
+                        symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name_10.text);
+                    }
+                    else {
+                        symbolFromVariable = getPropertyOfVariable(targetSymbol, name_10.text);
+                    }
+                    // if symbolFromVariable is export - get its final target
+                    symbolFromVariable = resolveSymbol(symbolFromVariable);
+                    var symbolFromModule = getExportOfModule(targetSymbol, name_10.text);
+                    var symbol = symbolFromModule && symbolFromVariable ?
+                        combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
+                        symbolFromModule || symbolFromVariable;
+                    if (!symbol) {
+                        error(name_10, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), ts.declarationNameToString(name_10));
+                    }
+                    return symbol;
+                }
+            }
+        }
+        function getTargetOfImportSpecifier(node) {
+            return getExternalModuleMember(node.parent.parent.parent, node);
+        }
+        function getTargetOfNamespaceExportDeclaration(node) {
+            return resolveExternalModuleSymbol(node.parent.symbol);
+        }
+        function getTargetOfExportSpecifier(node) {
+            return node.parent.parent.moduleSpecifier ?
+                getExternalModuleMember(node.parent.parent, node) :
+                resolveEntityName(node.propertyName || node.name, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */);
+        }
+        function getTargetOfExportAssignment(node) {
+            return resolveEntityName(node.expression, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */);
+        }
+        function getTargetOfAliasDeclaration(node) {
+            switch (node.kind) {
+                case 229 /* ImportEqualsDeclaration */:
+                    return getTargetOfImportEqualsDeclaration(node);
+                case 231 /* ImportClause */:
+                    return getTargetOfImportClause(node);
+                case 232 /* NamespaceImport */:
+                    return getTargetOfNamespaceImport(node);
+                case 234 /* ImportSpecifier */:
+                    return getTargetOfImportSpecifier(node);
+                case 238 /* ExportSpecifier */:
+                    return getTargetOfExportSpecifier(node);
+                case 235 /* ExportAssignment */:
+                    return getTargetOfExportAssignment(node);
+                case 228 /* NamespaceExportDeclaration */:
+                    return getTargetOfNamespaceExportDeclaration(node);
+            }
+        }
+        function resolveSymbol(symbol) {
+            return symbol && symbol.flags & 8388608 /* Alias */ && !(symbol.flags & (107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */)) ? resolveAlias(symbol) : symbol;
+        }
+        function resolveAlias(symbol) {
+            ts.Debug.assert((symbol.flags & 8388608 /* Alias */) !== 0, "Should only get Alias here.");
+            var links = getSymbolLinks(symbol);
+            if (!links.target) {
+                links.target = resolvingSymbol;
+                var node = getDeclarationOfAliasSymbol(symbol);
+                var target = getTargetOfAliasDeclaration(node);
+                if (links.target === resolvingSymbol) {
+                    links.target = target || unknownSymbol;
+                }
+                else {
+                    error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
+                }
+            }
+            else if (links.target === resolvingSymbol) {
+                links.target = unknownSymbol;
+            }
+            return links.target;
+        }
+        function markExportAsReferenced(node) {
+            var symbol = getSymbolOfNode(node);
+            var target = resolveAlias(symbol);
+            if (target) {
+                var markAlias = target === unknownSymbol ||
+                    ((target.flags & 107455 /* Value */) && !isConstEnumOrConstEnumOnlyModule(target));
+                if (markAlias) {
+                    markAliasSymbolAsReferenced(symbol);
+                }
+            }
+        }
+        // When an alias symbol is referenced, we need to mark the entity it references as referenced and in turn repeat that until
+        // we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of
+        // the alias as an expression (which recursively takes us back here if the target references another alias).
+        function markAliasSymbolAsReferenced(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.referenced) {
+                links.referenced = true;
+                var node = getDeclarationOfAliasSymbol(symbol);
+                if (node.kind === 235 /* ExportAssignment */) {
+                    // export default <symbol>
+                    checkExpressionCached(node.expression);
+                }
+                else if (node.kind === 238 /* ExportSpecifier */) {
+                    // export { <symbol> } or export { <symbol> as foo }
+                    checkExpressionCached(node.propertyName || node.name);
+                }
+                else if (ts.isInternalModuleImportEqualsDeclaration(node)) {
+                    // import foo = <symbol>
+                    checkExpressionCached(node.moduleReference);
+                }
+            }
+        }
+        // This function is only for imports with entity names
+        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration, dontResolveAlias) {
+            // There are three things we might try to look for. In the following examples,
+            // the search term is enclosed in |...|:
+            //
+            //     import a = |b|; // Namespace
+            //     import a = |b.c|; // Value, type, namespace
+            //     import a = |b.c|.d; // Namespace
+            if (entityName.kind === 69 /* Identifier */ && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
+                entityName = entityName.parent;
+            }
+            // Check for case 1 and 3 in the above example
+            if (entityName.kind === 69 /* Identifier */ || entityName.parent.kind === 139 /* QualifiedName */) {
+                return resolveEntityName(entityName, 1536 /* Namespace */, /*ignoreErrors*/ false, dontResolveAlias);
+            }
+            else {
+                // Case 2 in above example
+                // entityName.kind could be a QualifiedName or a Missing identifier
+                ts.Debug.assert(entityName.parent.kind === 229 /* ImportEqualsDeclaration */);
+                return resolveEntityName(entityName, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, /*ignoreErrors*/ false, dontResolveAlias);
+            }
+        }
+        function getFullyQualifiedName(symbol) {
+            return symbol.parent ? getFullyQualifiedName(symbol.parent) + "." + symbolToString(symbol) : symbolToString(symbol);
+        }
+        // Resolves a qualified name and any involved aliases
+        function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias) {
+            if (ts.nodeIsMissing(name)) {
+                return undefined;
+            }
+            var symbol;
+            if (name.kind === 69 /* Identifier */) {
+                var message = meaning === 1536 /* Namespace */ ? ts.Diagnostics.Cannot_find_namespace_0 : ts.Diagnostics.Cannot_find_name_0;
+                symbol = resolveName(name, name.text, meaning, ignoreErrors ? undefined : message, name);
+                if (!symbol) {
+                    return undefined;
+                }
+            }
+            else if (name.kind === 139 /* QualifiedName */ || name.kind === 172 /* PropertyAccessExpression */) {
+                var left = name.kind === 139 /* QualifiedName */ ? name.left : name.expression;
+                var right = name.kind === 139 /* QualifiedName */ ? name.right : name.name;
+                var namespace = resolveEntityName(left, 1536 /* Namespace */, ignoreErrors);
+                if (!namespace || ts.nodeIsMissing(right)) {
+                    return undefined;
+                }
+                else if (namespace === unknownSymbol) {
+                    return namespace;
+                }
+                symbol = getSymbol(getExportsOfSymbol(namespace), right.text, meaning);
+                if (!symbol) {
+                    if (!ignoreErrors) {
+                        error(right, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(right));
+                    }
+                    return undefined;
+                }
+            }
+            else {
+                ts.Debug.fail("Unknown entity name kind.");
+            }
+            ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
+            return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
+        }
+        function resolveExternalModuleName(location, moduleReferenceExpression) {
+            return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ts.Diagnostics.Cannot_find_module_0);
+        }
+        function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError) {
+            if (moduleReferenceExpression.kind !== 9 /* StringLiteral */) {
+                return;
+            }
+            var moduleReferenceLiteral = moduleReferenceExpression;
+            // Module names are escaped in our symbol table.  However, string literal values aren't.
+            // Escape the name in the "require(...)" clause to ensure we find the right symbol.
+            var moduleName = ts.escapeIdentifier(moduleReferenceLiteral.text);
+            if (moduleName === undefined) {
+                return;
+            }
+            var isRelative = ts.isExternalModuleNameRelative(moduleName);
+            if (!isRelative) {
+                var symbol = getSymbol(globals, '"' + moduleName + '"', 512 /* ValueModule */);
+                if (symbol) {
+                    // merged symbol is module declaration symbol combined with all augmentations
+                    return getMergedSymbol(symbol);
+                }
+            }
+            var resolvedModule = ts.getResolvedModule(ts.getSourceFileOfNode(location), moduleReferenceLiteral.text);
+            var sourceFile = resolvedModule && host.getSourceFile(resolvedModule.resolvedFileName);
+            if (sourceFile) {
+                if (sourceFile.symbol) {
+                    // merged symbol is module declaration symbol combined with all augmentations
+                    return getMergedSymbol(sourceFile.symbol);
+                }
+                if (moduleNotFoundError) {
+                    // report errors only if it was requested
+                    error(moduleReferenceLiteral, ts.Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
+                }
+                return undefined;
+            }
+            if (patternAmbientModules) {
+                var pattern = ts.findBestPatternMatch(patternAmbientModules, function (_) { return _.pattern; }, moduleName);
+                if (pattern) {
+                    return getMergedSymbol(pattern.symbol);
+                }
+            }
+            if (moduleNotFoundError) {
+                // report errors only if it was requested
+                error(moduleReferenceLiteral, moduleNotFoundError, moduleName);
+            }
+            return undefined;
+        }
+        // An external module with an 'export =' declaration resolves to the target of the 'export =' declaration,
+        // and an external module with no 'export =' declaration resolves to the module itself.
+        function resolveExternalModuleSymbol(moduleSymbol) {
+            return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports["export="])) || moduleSymbol;
+        }
+        // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export ='
+        // references a symbol that is at least declared as a module or a variable. The target of the 'export =' may
+        // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable).
+        function resolveESModuleSymbol(moduleSymbol, moduleReferenceExpression) {
+            var symbol = resolveExternalModuleSymbol(moduleSymbol);
+            if (symbol && !(symbol.flags & (1536 /* Module */ | 3 /* Variable */))) {
+                error(moduleReferenceExpression, ts.Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol));
+                symbol = undefined;
+            }
+            return symbol;
+        }
+        function hasExportAssignmentSymbol(moduleSymbol) {
+            return moduleSymbol.exports["export="] !== undefined;
+        }
+        function getExportsOfModuleAsArray(moduleSymbol) {
+            return symbolsToArray(getExportsOfModule(moduleSymbol));
+        }
+        function getExportsOfSymbol(symbol) {
+            return symbol.flags & 1536 /* Module */ ? getExportsOfModule(symbol) : symbol.exports || emptySymbols;
+        }
+        function getExportsOfModule(moduleSymbol) {
+            var links = getSymbolLinks(moduleSymbol);
+            return links.resolvedExports || (links.resolvedExports = getExportsForModule(moduleSymbol));
+        }
+        /**
+         * Extends one symbol table with another while collecting information on name collisions for error message generation into the `lookupTable` argument
+         * Not passing `lookupTable` and `exportNode` disables this collection, and just extends the tables
+         */
+        function extendExportSymbols(target, source, lookupTable, exportNode) {
+            for (var id in source) {
+                if (id !== "default" && !ts.hasProperty(target, id)) {
+                    target[id] = source[id];
+                    if (lookupTable && exportNode) {
+                        lookupTable[id] = {
+                            specifierText: ts.getTextOfNode(exportNode.moduleSpecifier)
+                        };
+                    }
+                }
+                else if (lookupTable && exportNode && id !== "default" && ts.hasProperty(target, id) && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
+                    if (!lookupTable[id].exportsWithDuplicate) {
+                        lookupTable[id].exportsWithDuplicate = [exportNode];
+                    }
+                    else {
+                        lookupTable[id].exportsWithDuplicate.push(exportNode);
+                    }
+                }
+            }
+        }
+        function getExportsForModule(moduleSymbol) {
+            var visitedSymbols = [];
+            return visit(moduleSymbol) || moduleSymbol.exports;
+            // The ES6 spec permits export * declarations in a module to circularly reference the module itself. For example,
+            // module 'a' can 'export * from "b"' and 'b' can 'export * from "a"' without error.
+            function visit(symbol) {
+                if (!(symbol && symbol.flags & 1952 /* HasExports */ && !ts.contains(visitedSymbols, symbol))) {
+                    return;
+                }
+                visitedSymbols.push(symbol);
+                var symbols = cloneSymbolTable(symbol.exports);
+                // All export * declarations are collected in an __export symbol by the binder
+                var exportStars = symbol.exports["__export"];
+                if (exportStars) {
+                    var nestedSymbols = {};
+                    var lookupTable = {};
+                    for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) {
+                        var node = _a[_i];
+                        var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
+                        var exportedSymbols = visit(resolvedModule);
+                        extendExportSymbols(nestedSymbols, exportedSymbols, lookupTable, node);
+                    }
+                    for (var id in lookupTable) {
+                        var exportsWithDuplicate = lookupTable[id].exportsWithDuplicate;
+                        // It's not an error if the file with multiple `export *`s with duplicate names exports a member with that name itself
+                        if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || ts.hasProperty(symbols, id)) {
+                            continue;
+                        }
+                        for (var _b = 0, exportsWithDuplicate_1 = exportsWithDuplicate; _b < exportsWithDuplicate_1.length; _b++) {
+                            var node = exportsWithDuplicate_1[_b];
+                            diagnostics.add(ts.createDiagnosticForNode(node, ts.Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, lookupTable[id].specifierText, id));
+                        }
+                    }
+                    extendExportSymbols(symbols, nestedSymbols);
+                }
+                return symbols;
+            }
+        }
+        function getMergedSymbol(symbol) {
+            var merged;
+            return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol;
+        }
+        function getSymbolOfNode(node) {
+            return getMergedSymbol(node.symbol);
+        }
+        function getParentOfSymbol(symbol) {
+            return getMergedSymbol(symbol.parent);
+        }
+        function getExportSymbolOfValueSymbolIfExported(symbol) {
+            return symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0
+                ? getMergedSymbol(symbol.exportSymbol)
+                : symbol;
+        }
+        function symbolIsValue(symbol) {
+            // If it is an instantiated symbol, then it is a value if the symbol it is an
+            // instantiation of is a value.
+            if (symbol.flags & 16777216 /* Instantiated */) {
+                return symbolIsValue(getSymbolLinks(symbol).target);
+            }
+            // If the symbol has the value flag, it is trivially a value.
+            if (symbol.flags & 107455 /* Value */) {
+                return true;
+            }
+            // If it is an alias, then it is a value if the symbol it resolves to is a value.
+            if (symbol.flags & 8388608 /* Alias */) {
+                return (resolveAlias(symbol).flags & 107455 /* Value */) !== 0;
+            }
+            return false;
+        }
+        function findConstructorDeclaration(node) {
+            var members = node.members;
+            for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+                var member = members_1[_i];
+                if (member.kind === 148 /* Constructor */ && ts.nodeIsPresent(member.body)) {
+                    return member;
+                }
+            }
+        }
+        function createType(flags) {
+            var result = new Type(checker, flags);
+            result.id = typeCount;
+            typeCount++;
+            return result;
+        }
+        function createIntrinsicType(kind, intrinsicName) {
+            var type = createType(kind);
+            type.intrinsicName = intrinsicName;
+            return type;
+        }
+        function createObjectType(kind, symbol) {
+            var type = createType(kind);
+            type.symbol = symbol;
+            return type;
+        }
+        // A reserved member name starts with two underscores, but the third character cannot be an underscore
+        // or the @ symbol. A third underscore indicates an escaped form of an identifer that started
+        // with at least two underscores. The @ character indicates that the name is denoted by a well known ES
+        // Symbol instance.
+        function isReservedMemberName(name) {
+            return name.charCodeAt(0) === 95 /* _ */ &&
+                name.charCodeAt(1) === 95 /* _ */ &&
+                name.charCodeAt(2) !== 95 /* _ */ &&
+                name.charCodeAt(2) !== 64 /* at */;
+        }
+        function getNamedMembers(members) {
+            var result;
+            for (var id in members) {
+                if (ts.hasProperty(members, id)) {
+                    if (!isReservedMemberName(id)) {
+                        if (!result)
+                            result = [];
+                        var symbol = members[id];
+                        if (symbolIsValue(symbol)) {
+                            result.push(symbol);
+                        }
+                    }
+                }
+            }
+            return result || emptyArray;
+        }
+        function setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
+            type.members = members;
+            type.properties = getNamedMembers(members);
+            type.callSignatures = callSignatures;
+            type.constructSignatures = constructSignatures;
+            if (stringIndexInfo)
+                type.stringIndexInfo = stringIndexInfo;
+            if (numberIndexInfo)
+                type.numberIndexInfo = numberIndexInfo;
+            return type;
+        }
+        function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
+            return setObjectTypeMembers(createObjectType(65536 /* Anonymous */, symbol), members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+        }
+        function forEachSymbolTableInScope(enclosingDeclaration, callback) {
+            var result;
+            for (var location_1 = enclosingDeclaration; location_1; location_1 = location_1.parent) {
+                // Locals of a source file are not in scope (because they get merged into the global symbol table)
+                if (location_1.locals && !isGlobalSourceFile(location_1)) {
+                    if (result = callback(location_1.locals)) {
+                        return result;
+                    }
+                }
+                switch (location_1.kind) {
+                    case 256 /* SourceFile */:
+                        if (!ts.isExternalOrCommonJsModule(location_1)) {
+                            break;
+                        }
+                    case 225 /* ModuleDeclaration */:
+                        if (result = callback(getSymbolOfNode(location_1).exports)) {
+                            return result;
+                        }
+                        break;
+                }
+            }
+            return callback(globals);
+        }
+        function getQualifiedLeftMeaning(rightMeaning) {
+            // If we are looking in value space, the parent meaning is value, other wise it is namespace
+            return rightMeaning === 107455 /* Value */ ? 107455 /* Value */ : 1536 /* Namespace */;
+        }
+        function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing) {
+            function getAccessibleSymbolChainFromSymbolTable(symbols) {
+                function canQualifySymbol(symbolFromSymbolTable, meaning) {
+                    // If the symbol is equivalent and doesn't need further qualification, this symbol is accessible
+                    if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) {
+                        return true;
+                    }
+                    // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
+                    var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
+                    return !!accessibleParent;
+                }
+                function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol) {
+                    if (symbol === (resolvedAliasSymbol || symbolFromSymbolTable)) {
+                        // if the symbolFromSymbolTable is not external module (it could be if it was determined as ambient external module and would be in globals table)
+                        // and if symbolFromSymbolTable or alias resolution matches the symbol,
+                        // check the symbol can be qualified, it is only then this symbol is accessible
+                        return !ts.forEach(symbolFromSymbolTable.declarations, hasExternalModuleSymbol) &&
+                            canQualifySymbol(symbolFromSymbolTable, meaning);
+                    }
+                }
+                // If symbol is directly available by its name in the symbol table
+                if (isAccessible(ts.lookUp(symbols, symbol.name))) {
+                    return [symbol];
+                }
+                // Check if symbol is any of the alias
+                return ts.forEachValue(symbols, function (symbolFromSymbolTable) {
+                    if (symbolFromSymbolTable.flags & 8388608 /* Alias */
+                        && symbolFromSymbolTable.name !== "export="
+                        && !ts.getDeclarationOfKind(symbolFromSymbolTable, 238 /* ExportSpecifier */)) {
+                        if (!useOnlyExternalAliasing ||
+                            // Is this external alias, then use it to name
+                            ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) {
+                            var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
+                            if (isAccessible(symbolFromSymbolTable, resolveAlias(symbolFromSymbolTable))) {
+                                return [symbolFromSymbolTable];
+                            }
+                            // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
+                            // but only if the symbolFromSymbolTable can be qualified
+                            var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
+                            if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
+                                return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
+                            }
+                        }
+                    }
+                });
+            }
+            if (symbol) {
+                if (!(isPropertyOrMethodDeclarationSymbol(symbol))) {
+                    return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
+                }
+            }
+        }
+        function needsQualification(symbol, enclosingDeclaration, meaning) {
+            var qualify = false;
+            forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) {
+                // If symbol of this name is not available in the symbol table we are ok
+                if (!ts.hasProperty(symbolTable, symbol.name)) {
+                    // Continue to the next symbol table
+                    return false;
+                }
+                // If the symbol with this name is present it should refer to the symbol
+                var symbolFromSymbolTable = symbolTable[symbol.name];
+                if (symbolFromSymbolTable === symbol) {
+                    // No need to qualify
+                    return true;
+                }
+                // Qualify if the symbol from symbol table has same meaning as expected
+                symbolFromSymbolTable = (symbolFromSymbolTable.flags & 8388608 /* Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 238 /* ExportSpecifier */)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
+                if (symbolFromSymbolTable.flags & meaning) {
+                    qualify = true;
+                    return true;
+                }
+                // Continue to the next symbol table
+                return false;
+            });
+            return qualify;
+        }
+        function isPropertyOrMethodDeclarationSymbol(symbol) {
+            if (symbol.declarations && symbol.declarations.length) {
+                for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                    var declaration = _a[_i];
+                    switch (declaration.kind) {
+                        case 145 /* PropertyDeclaration */:
+                        case 147 /* MethodDeclaration */:
+                        case 149 /* GetAccessor */:
+                        case 150 /* SetAccessor */:
+                            continue;
+                        default:
+                            return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function isSymbolAccessible(symbol, enclosingDeclaration, meaning) {
+            if (symbol && enclosingDeclaration && !(symbol.flags & 262144 /* TypeParameter */)) {
+                var initialSymbol = symbol;
+                var meaningToLook = meaning;
+                while (symbol) {
+                    // Symbol is accessible if it by itself is accessible
+                    var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
+                    if (accessibleSymbolChain) {
+                        var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
+                        if (!hasAccessibleDeclarations) {
+                            return {
+                                accessibility: 1 /* NotAccessible */,
+                                errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
+                                errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, 1536 /* Namespace */) : undefined
+                            };
+                        }
+                        return hasAccessibleDeclarations;
+                    }
+                    // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible.
+                    // It could be a qualified symbol and hence verify the path
+                    // e.g.:
+                    // module m {
+                    //     export class c {
+                    //     }
+                    // }
+                    // const x: typeof m.c
+                    // In the above example when we start with checking if typeof m.c symbol is accessible,
+                    // we are going to see if c can be accessed in scope directly.
+                    // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
+                    // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
+                    meaningToLook = getQualifiedLeftMeaning(meaning);
+                    symbol = getParentOfSymbol(symbol);
+                }
+                // This could be a symbol that is not exported in the external module
+                // or it could be a symbol from different external module that is not aliased and hence cannot be named
+                var symbolExternalModule = ts.forEach(initialSymbol.declarations, getExternalModuleContainer);
+                if (symbolExternalModule) {
+                    var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
+                    if (symbolExternalModule !== enclosingExternalModule) {
+                        // name from different external module that is not visible
+                        return {
+                            accessibility: 2 /* CannotBeNamed */,
+                            errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
+                            errorModuleName: symbolToString(symbolExternalModule)
+                        };
+                    }
+                }
+                // Just a local name that is not accessible
+                return {
+                    accessibility: 1 /* NotAccessible */,
+                    errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning)
+                };
+            }
+            return { accessibility: 0 /* Accessible */ };
+            function getExternalModuleContainer(declaration) {
+                for (; declaration; declaration = declaration.parent) {
+                    if (hasExternalModuleSymbol(declaration)) {
+                        return getSymbolOfNode(declaration);
+                    }
+                }
+            }
+        }
+        function hasExternalModuleSymbol(declaration) {
+            return ts.isAmbientModule(declaration) || (declaration.kind === 256 /* SourceFile */ && ts.isExternalOrCommonJsModule(declaration));
+        }
+        function hasVisibleDeclarations(symbol) {
+            var aliasesToMakeVisible;
+            if (ts.forEach(symbol.declarations, function (declaration) { return !getIsDeclarationVisible(declaration); })) {
+                return undefined;
+            }
+            return { accessibility: 0 /* Accessible */, aliasesToMakeVisible: aliasesToMakeVisible };
+            function getIsDeclarationVisible(declaration) {
+                if (!isDeclarationVisible(declaration)) {
+                    // Mark the unexported alias as visible if its parent is visible
+                    // because these kind of aliases can be used to name types in declaration file
+                    var anyImportSyntax = getAnyImportSyntax(declaration);
+                    if (anyImportSyntax &&
+                        !(anyImportSyntax.flags & 1 /* Export */) &&
+                        isDeclarationVisible(anyImportSyntax.parent)) {
+                        getNodeLinks(declaration).isVisible = true;
+                        if (aliasesToMakeVisible) {
+                            if (!ts.contains(aliasesToMakeVisible, anyImportSyntax)) {
+                                aliasesToMakeVisible.push(anyImportSyntax);
+                            }
+                        }
+                        else {
+                            aliasesToMakeVisible = [anyImportSyntax];
+                        }
+                        return true;
+                    }
+                    // Declaration is not visible
+                    return false;
+                }
+                return true;
+            }
+        }
+        function isEntityNameVisible(entityName, enclosingDeclaration) {
+            // get symbol of the first identifier of the entityName
+            var meaning;
+            if (entityName.parent.kind === 158 /* TypeQuery */ || ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
+                // Typeof value
+                meaning = 107455 /* Value */ | 1048576 /* ExportValue */;
+            }
+            else if (entityName.kind === 139 /* QualifiedName */ || entityName.kind === 172 /* PropertyAccessExpression */ ||
+                entityName.parent.kind === 229 /* ImportEqualsDeclaration */) {
+                // Left identifier from type reference or TypeAlias
+                // Entity name of the import declaration
+                meaning = 1536 /* Namespace */;
+            }
+            else {
+                // Type Reference or TypeAlias entity = Identifier
+                meaning = 793056 /* Type */;
+            }
+            var firstIdentifier = getFirstIdentifier(entityName);
+            var symbol = resolveName(enclosingDeclaration, firstIdentifier.text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
+            // Verify if the symbol is accessible
+            return (symbol && hasVisibleDeclarations(symbol)) || {
+                accessibility: 1 /* NotAccessible */,
+                errorSymbolName: ts.getTextOfNode(firstIdentifier),
+                errorNode: firstIdentifier
+            };
+        }
+        function writeKeyword(writer, kind) {
+            writer.writeKeyword(ts.tokenToString(kind));
+        }
+        function writePunctuation(writer, kind) {
+            writer.writePunctuation(ts.tokenToString(kind));
+        }
+        function writeSpace(writer) {
+            writer.writeSpace(" ");
+        }
+        function symbolToString(symbol, enclosingDeclaration, meaning) {
+            var writer = ts.getSingleLineStringWriter();
+            getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning);
+            var result = writer.string();
+            ts.releaseStringWriter(writer);
+            return result;
+        }
+        function signatureToString(signature, enclosingDeclaration, flags, kind) {
+            var writer = ts.getSingleLineStringWriter();
+            getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags, kind);
+            var result = writer.string();
+            ts.releaseStringWriter(writer);
+            return result;
+        }
+        function typeToString(type, enclosingDeclaration, flags) {
+            var writer = ts.getSingleLineStringWriter();
+            getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+            var result = writer.string();
+            ts.releaseStringWriter(writer);
+            var maxLength = compilerOptions.noErrorTruncation || flags & 4 /* NoTruncation */ ? undefined : 100;
+            if (maxLength && result.length >= maxLength) {
+                result = result.substr(0, maxLength - "...".length) + "...";
+            }
+            return result;
+        }
+        function typePredicateToString(typePredicate, enclosingDeclaration, flags) {
+            var writer = ts.getSingleLineStringWriter();
+            getSymbolDisplayBuilder().buildTypePredicateDisplay(typePredicate, writer, enclosingDeclaration, flags);
+            var result = writer.string();
+            ts.releaseStringWriter(writer);
+            return result;
+        }
+        function visibilityToString(flags) {
+            if (flags === 8 /* Private */) {
+                return "private";
+            }
+            if (flags === 16 /* Protected */) {
+                return "protected";
+            }
+            return "public";
+        }
+        function getTypeAliasForTypeLiteral(type) {
+            if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */) {
+                var node = type.symbol.declarations[0].parent;
+                while (node.kind === 164 /* ParenthesizedType */) {
+                    node = node.parent;
+                }
+                if (node.kind === 223 /* TypeAliasDeclaration */) {
+                    return getSymbolOfNode(node);
+                }
+            }
+            return undefined;
+        }
+        function isTopLevelInExternalModuleAugmentation(node) {
+            return node && node.parent &&
+                node.parent.kind === 226 /* ModuleBlock */ &&
+                ts.isExternalModuleAugmentation(node.parent.parent);
+        }
+        function getSymbolDisplayBuilder() {
+            function getNameOfSymbol(symbol) {
+                if (symbol.declarations && symbol.declarations.length) {
+                    var declaration = symbol.declarations[0];
+                    if (declaration.name) {
+                        return ts.declarationNameToString(declaration.name);
+                    }
+                    switch (declaration.kind) {
+                        case 192 /* ClassExpression */:
+                            return "(Anonymous class)";
+                        case 179 /* FunctionExpression */:
+                        case 180 /* ArrowFunction */:
+                            return "(Anonymous function)";
+                    }
+                }
+                return symbol.name;
+            }
+            /**
+             * Writes only the name of the symbol out to the writer. Uses the original source text
+             * for the name of the symbol if it is available to match how the user wrote the name.
+             */
+            function appendSymbolNameOnly(symbol, writer) {
+                writer.writeSymbol(getNameOfSymbol(symbol), symbol);
+            }
+            /**
+             * Writes a property access or element access with the name of the symbol out to the writer.
+             * Uses the original source text for the name of the symbol if it is available to match how the user wrote the name,
+             * ensuring that any names written with literals use element accesses.
+             */
+            function appendPropertyOrElementAccessForSymbol(symbol, writer) {
+                var symbolName = getNameOfSymbol(symbol);
+                var firstChar = symbolName.charCodeAt(0);
+                var needsElementAccess = !ts.isIdentifierStart(firstChar, languageVersion);
+                if (needsElementAccess) {
+                    writePunctuation(writer, 19 /* OpenBracketToken */);
+                    if (ts.isSingleOrDoubleQuote(firstChar)) {
+                        writer.writeStringLiteral(symbolName);
+                    }
+                    else {
+                        writer.writeSymbol(symbolName, symbol);
+                    }
+                    writePunctuation(writer, 20 /* CloseBracketToken */);
+                }
+                else {
+                    writePunctuation(writer, 21 /* DotToken */);
+                    writer.writeSymbol(symbolName, symbol);
+                }
+            }
+            /**
+             * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
+             * Meaning needs to be specified if the enclosing declaration is given
+             */
+            function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) {
+                var parentSymbol;
+                function appendParentTypeArgumentsAndSymbolName(symbol) {
+                    if (parentSymbol) {
+                        // Write type arguments of instantiated class/interface here
+                        if (flags & 1 /* WriteTypeParametersOrArguments */) {
+                            if (symbol.flags & 16777216 /* Instantiated */) {
+                                buildDisplayForTypeArgumentsAndDelimiters(getTypeParametersOfClassOrInterface(parentSymbol), symbol.mapper, writer, enclosingDeclaration);
+                            }
+                            else {
+                                buildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration);
+                            }
+                        }
+                        appendPropertyOrElementAccessForSymbol(symbol, writer);
+                    }
+                    else {
+                        appendSymbolNameOnly(symbol, writer);
+                    }
+                    parentSymbol = symbol;
+                }
+                // const the writer know we just wrote out a symbol.  The declaration emitter writer uses
+                // this to determine if an import it has previously seen (and not written out) needs
+                // to be written to the file once the walk of the tree is complete.
+                //
+                // NOTE(cyrusn): This approach feels somewhat unfortunate.  A simple pass over the tree
+                // up front (for example, during checking) could determine if we need to emit the imports
+                // and we could then access that data during declaration emit.
+                writer.trackSymbol(symbol, enclosingDeclaration, meaning);
+                function walkSymbol(symbol, meaning) {
+                    if (symbol) {
+                        var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & 2 /* UseOnlyExternalAliasing */));
+                        if (!accessibleSymbolChain ||
+                            needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
+                            // Go up and add our parent.
+                            walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning));
+                        }
+                        if (accessibleSymbolChain) {
+                            for (var _i = 0, accessibleSymbolChain_1 = accessibleSymbolChain; _i < accessibleSymbolChain_1.length; _i++) {
+                                var accessibleSymbol = accessibleSymbolChain_1[_i];
+                                appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
+                            }
+                        }
+                        else {
+                            // If we didn't find accessible symbol chain for this symbol, break if this is external module
+                            if (!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) {
+                                return;
+                            }
+                            // if this is anonymous type break
+                            if (symbol.flags & 2048 /* TypeLiteral */ || symbol.flags & 4096 /* ObjectLiteral */) {
+                                return;
+                            }
+                            appendParentTypeArgumentsAndSymbolName(symbol);
+                        }
+                    }
+                }
+                // Get qualified name if the symbol is not a type parameter
+                // and there is an enclosing declaration or we specifically
+                // asked for it
+                var isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
+                var typeFormatFlag = 128 /* UseFullyQualifiedType */ & typeFlags;
+                if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) {
+                    walkSymbol(symbol, meaning);
+                    return;
+                }
+                return appendParentTypeArgumentsAndSymbolName(symbol);
+            }
+            function buildTypeDisplay(type, writer, enclosingDeclaration, globalFlags, symbolStack) {
+                var globalFlagsToPass = globalFlags & 16 /* WriteOwnNameForAnyLike */;
+                var inObjectTypeLiteral = false;
+                return writeType(type, globalFlags);
+                function writeType(type, flags) {
+                    // Write undefined/null type as any
+                    if (type.flags & 150995071 /* Intrinsic */) {
+                        // Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving
+                        writer.writeKeyword(!(globalFlags & 16 /* WriteOwnNameForAnyLike */) && isTypeAny(type)
+                            ? "any"
+                            : type.intrinsicName);
+                    }
+                    else if (type.flags & 33554432 /* ThisType */) {
+                        if (inObjectTypeLiteral) {
+                            writer.reportInaccessibleThisError();
+                        }
+                        writer.writeKeyword("this");
+                    }
+                    else if (type.flags & 4096 /* Reference */) {
+                        writeTypeReference(type, flags);
+                    }
+                    else if (type.flags & (1024 /* Class */ | 2048 /* Interface */ | 128 /* Enum */ | 512 /* TypeParameter */)) {
+                        // The specified symbol flags need to be reinterpreted as type flags
+                        buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793056 /* Type */, 0 /* None */, flags);
+                    }
+                    else if (type.flags & 8192 /* Tuple */) {
+                        writeTupleType(type);
+                    }
+                    else if (type.flags & 49152 /* UnionOrIntersection */) {
+                        writeUnionOrIntersectionType(type, flags);
+                    }
+                    else if (type.flags & 65536 /* Anonymous */) {
+                        writeAnonymousType(type, flags);
+                    }
+                    else if (type.flags & 256 /* StringLiteral */) {
+                        writer.writeStringLiteral("\"" + ts.escapeString(type.text) + "\"");
+                    }
+                    else {
+                        // Should never get here
+                        // { ... }
+                        writePunctuation(writer, 15 /* OpenBraceToken */);
+                        writeSpace(writer);
+                        writePunctuation(writer, 22 /* DotDotDotToken */);
+                        writeSpace(writer);
+                        writePunctuation(writer, 16 /* CloseBraceToken */);
+                    }
+                }
+                function writeTypeList(types, delimiter) {
+                    for (var i = 0; i < types.length; i++) {
+                        if (i > 0) {
+                            if (delimiter !== 24 /* CommaToken */) {
+                                writeSpace(writer);
+                            }
+                            writePunctuation(writer, delimiter);
+                            writeSpace(writer);
+                        }
+                        writeType(types[i], delimiter === 24 /* CommaToken */ ? 0 /* None */ : 64 /* InElementType */);
+                    }
+                }
+                function writeSymbolTypeReference(symbol, typeArguments, pos, end, flags) {
+                    // Unnamed function expressions and arrow functions have reserved names that we don't want to display
+                    if (symbol.flags & 32 /* Class */ || !isReservedMemberName(symbol.name)) {
+                        buildSymbolDisplay(symbol, writer, enclosingDeclaration, 793056 /* Type */, 0 /* None */, flags);
+                    }
+                    if (pos < end) {
+                        writePunctuation(writer, 25 /* LessThanToken */);
+                        writeType(typeArguments[pos], 256 /* InFirstTypeArgument */);
+                        pos++;
+                        while (pos < end) {
+                            writePunctuation(writer, 24 /* CommaToken */);
+                            writeSpace(writer);
+                            writeType(typeArguments[pos], 0 /* None */);
+                            pos++;
+                        }
+                        writePunctuation(writer, 27 /* GreaterThanToken */);
+                    }
+                }
+                function writeTypeReference(type, flags) {
+                    var typeArguments = type.typeArguments || emptyArray;
+                    if (type.target === globalArrayType && !(flags & 1 /* WriteArrayAsGenericType */)) {
+                        writeType(typeArguments[0], 64 /* InElementType */);
+                        writePunctuation(writer, 19 /* OpenBracketToken */);
+                        writePunctuation(writer, 20 /* CloseBracketToken */);
+                    }
+                    else {
+                        // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
+                        // for outer type parameters, and f and g are the respective declaring containers of those
+                        // type parameters.
+                        var outerTypeParameters = type.target.outerTypeParameters;
+                        var i = 0;
+                        if (outerTypeParameters) {
+                            var length_1 = outerTypeParameters.length;
+                            while (i < length_1) {
+                                // Find group of type arguments for type parameters with the same declaring container.
+                                var start = i;
+                                var parent_7 = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
+                                do {
+                                    i++;
+                                } while (i < length_1 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent_7);
+                                // When type parameters are their own type arguments for the whole group (i.e. we have
+                                // the default outer type arguments), we don't show the group.
+                                if (!ts.rangeEquals(outerTypeParameters, typeArguments, start, i)) {
+                                    writeSymbolTypeReference(parent_7, typeArguments, start, i, flags);
+                                    writePunctuation(writer, 21 /* DotToken */);
+                                }
+                            }
+                        }
+                        var typeParameterCount = (type.target.typeParameters || emptyArray).length;
+                        writeSymbolTypeReference(type.symbol, typeArguments, i, typeParameterCount, flags);
+                    }
+                }
+                function writeTupleType(type) {
+                    writePunctuation(writer, 19 /* OpenBracketToken */);
+                    writeTypeList(type.elementTypes, 24 /* CommaToken */);
+                    writePunctuation(writer, 20 /* CloseBracketToken */);
+                }
+                function writeUnionOrIntersectionType(type, flags) {
+                    if (flags & 64 /* InElementType */) {
+                        writePunctuation(writer, 17 /* OpenParenToken */);
+                    }
+                    writeTypeList(type.types, type.flags & 16384 /* Union */ ? 47 /* BarToken */ : 46 /* AmpersandToken */);
+                    if (flags & 64 /* InElementType */) {
+                        writePunctuation(writer, 18 /* CloseParenToken */);
+                    }
+                }
+                function writeAnonymousType(type, flags) {
+                    var symbol = type.symbol;
+                    if (symbol) {
+                        // Always use 'typeof T' for type of class, enum, and module objects
+                        if (symbol.flags & (32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
+                            writeTypeOfSymbol(type, flags);
+                        }
+                        else if (shouldWriteTypeOfFunctionSymbol()) {
+                            writeTypeOfSymbol(type, flags);
+                        }
+                        else if (ts.contains(symbolStack, symbol)) {
+                            // If type is an anonymous type literal in a type alias declaration, use type alias name
+                            var typeAlias = getTypeAliasForTypeLiteral(type);
+                            if (typeAlias) {
+                                // The specified symbol flags need to be reinterpreted as type flags
+                                buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056 /* Type */, 0 /* None */, flags);
+                            }
+                            else {
+                                // Recursive usage, use any
+                                writeKeyword(writer, 117 /* AnyKeyword */);
+                            }
+                        }
+                        else {
+                            // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
+                            // of types allows us to catch circular references to instantiations of the same anonymous type
+                            if (!symbolStack) {
+                                symbolStack = [];
+                            }
+                            symbolStack.push(symbol);
+                            writeLiteralType(type, flags);
+                            symbolStack.pop();
+                        }
+                    }
+                    else {
+                        // Anonymous types with no symbol are never circular
+                        writeLiteralType(type, flags);
+                    }
+                    function shouldWriteTypeOfFunctionSymbol() {
+                        var isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */ &&
+                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 32 /* Static */; }));
+                        var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) &&
+                            (symbol.parent ||
+                                ts.forEach(symbol.declarations, function (declaration) {
+                                    return declaration.parent.kind === 256 /* SourceFile */ || declaration.parent.kind === 226 /* ModuleBlock */;
+                                }));
+                        if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
+                            // typeof is allowed only for static/non local functions
+                            return !!(flags & 2 /* UseTypeOfFunction */) ||
+                                (ts.contains(symbolStack, symbol)); // it is type of the symbol uses itself recursively
+                        }
+                    }
+                }
+                function writeTypeOfSymbol(type, typeFormatFlags) {
+                    writeKeyword(writer, 101 /* TypeOfKeyword */);
+                    writeSpace(writer);
+                    buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 107455 /* Value */, 0 /* None */, typeFormatFlags);
+                }
+                function writeIndexSignature(info, keyword) {
+                    if (info) {
+                        if (info.isReadonly) {
+                            writeKeyword(writer, 128 /* ReadonlyKeyword */);
+                            writeSpace(writer);
+                        }
+                        writePunctuation(writer, 19 /* OpenBracketToken */);
+                        writer.writeParameter(info.declaration ? ts.declarationNameToString(info.declaration.parameters[0].name) : "x");
+                        writePunctuation(writer, 54 /* ColonToken */);
+                        writeSpace(writer);
+                        writeKeyword(writer, keyword);
+                        writePunctuation(writer, 20 /* CloseBracketToken */);
+                        writePunctuation(writer, 54 /* ColonToken */);
+                        writeSpace(writer);
+                        writeType(info.type, 0 /* None */);
+                        writePunctuation(writer, 23 /* SemicolonToken */);
+                        writer.writeLine();
+                    }
+                }
+                function writePropertyWithModifiers(prop) {
+                    if (isReadonlySymbol(prop)) {
+                        writeKeyword(writer, 128 /* ReadonlyKeyword */);
+                        writeSpace(writer);
+                    }
+                    buildSymbolDisplay(prop, writer);
+                    if (prop.flags & 536870912 /* Optional */) {
+                        writePunctuation(writer, 53 /* QuestionToken */);
+                    }
+                }
+                function shouldAddParenthesisAroundFunctionType(callSignature, flags) {
+                    if (flags & 64 /* InElementType */) {
+                        return true;
+                    }
+                    else if (flags & 256 /* InFirstTypeArgument */) {
+                        // Add parenthesis around function type for the first type argument to avoid ambiguity
+                        var typeParameters = callSignature.target && (flags & 32 /* WriteTypeArgumentsOfSignature */) ?
+                            callSignature.target.typeParameters : callSignature.typeParameters;
+                        return typeParameters && typeParameters.length !== 0;
+                    }
+                    return false;
+                }
+                function writeLiteralType(type, flags) {
+                    var resolved = resolveStructuredTypeMembers(type);
+                    if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
+                        if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
+                            writePunctuation(writer, 15 /* OpenBraceToken */);
+                            writePunctuation(writer, 16 /* CloseBraceToken */);
+                            return;
+                        }
+                        if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
+                            var parenthesizeSignature = shouldAddParenthesisAroundFunctionType(resolved.callSignatures[0], flags);
+                            if (parenthesizeSignature) {
+                                writePunctuation(writer, 17 /* OpenParenToken */);
+                            }
+                            buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8 /* WriteArrowStyleSignature */, /*kind*/ undefined, symbolStack);
+                            if (parenthesizeSignature) {
+                                writePunctuation(writer, 18 /* CloseParenToken */);
+                            }
+                            return;
+                        }
+                        if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
+                            if (flags & 64 /* InElementType */) {
+                                writePunctuation(writer, 17 /* OpenParenToken */);
+                            }
+                            writeKeyword(writer, 92 /* NewKeyword */);
+                            writeSpace(writer);
+                            buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8 /* WriteArrowStyleSignature */, /*kind*/ undefined, symbolStack);
+                            if (flags & 64 /* InElementType */) {
+                                writePunctuation(writer, 18 /* CloseParenToken */);
+                            }
+                            return;
+                        }
+                    }
+                    var saveInObjectTypeLiteral = inObjectTypeLiteral;
+                    inObjectTypeLiteral = true;
+                    writePunctuation(writer, 15 /* OpenBraceToken */);
+                    writer.writeLine();
+                    writer.increaseIndent();
+                    for (var _i = 0, _a = resolved.callSignatures; _i < _a.length; _i++) {
+                        var signature = _a[_i];
+                        buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, /*kind*/ undefined, symbolStack);
+                        writePunctuation(writer, 23 /* SemicolonToken */);
+                        writer.writeLine();
+                    }
+                    for (var _b = 0, _c = resolved.constructSignatures; _b < _c.length; _b++) {
+                        var signature = _c[_b];
+                        buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, 1 /* Construct */, symbolStack);
+                        writePunctuation(writer, 23 /* SemicolonToken */);
+                        writer.writeLine();
+                    }
+                    writeIndexSignature(resolved.stringIndexInfo, 132 /* StringKeyword */);
+                    writeIndexSignature(resolved.numberIndexInfo, 130 /* NumberKeyword */);
+                    for (var _d = 0, _e = resolved.properties; _d < _e.length; _d++) {
+                        var p = _e[_d];
+                        var t = getTypeOfSymbol(p);
+                        if (p.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(t).length) {
+                            var signatures = getSignaturesOfType(t, 0 /* Call */);
+                            for (var _f = 0, signatures_1 = signatures; _f < signatures_1.length; _f++) {
+                                var signature = signatures_1[_f];
+                                writePropertyWithModifiers(p);
+                                buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, /*kind*/ undefined, symbolStack);
+                                writePunctuation(writer, 23 /* SemicolonToken */);
+                                writer.writeLine();
+                            }
+                        }
+                        else {
+                            writePropertyWithModifiers(p);
+                            writePunctuation(writer, 54 /* ColonToken */);
+                            writeSpace(writer);
+                            writeType(t, 0 /* None */);
+                            writePunctuation(writer, 23 /* SemicolonToken */);
+                            writer.writeLine();
+                        }
+                    }
+                    writer.decreaseIndent();
+                    writePunctuation(writer, 16 /* CloseBraceToken */);
+                    inObjectTypeLiteral = saveInObjectTypeLiteral;
+                }
+            }
+            function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration, flags) {
+                var targetSymbol = getTargetSymbol(symbol);
+                if (targetSymbol.flags & 32 /* Class */ || targetSymbol.flags & 64 /* Interface */ || targetSymbol.flags & 524288 /* TypeAlias */) {
+                    buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaration, flags);
+                }
+            }
+            function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) {
+                appendSymbolNameOnly(tp.symbol, writer);
+                var constraint = getConstraintOfTypeParameter(tp);
+                if (constraint) {
+                    writeSpace(writer);
+                    writeKeyword(writer, 83 /* ExtendsKeyword */);
+                    writeSpace(writer);
+                    buildTypeDisplay(constraint, writer, enclosingDeclaration, flags, symbolStack);
+                }
+            }
+            function buildParameterDisplay(p, writer, enclosingDeclaration, flags, symbolStack) {
+                var parameterNode = p.valueDeclaration;
+                if (ts.isRestParameter(parameterNode)) {
+                    writePunctuation(writer, 22 /* DotDotDotToken */);
+                }
+                if (ts.isBindingPattern(parameterNode.name)) {
+                    buildBindingPatternDisplay(parameterNode.name, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                else {
+                    appendSymbolNameOnly(p, writer);
+                }
+                if (isOptionalParameter(parameterNode)) {
+                    writePunctuation(writer, 53 /* QuestionToken */);
+                }
+                writePunctuation(writer, 54 /* ColonToken */);
+                writeSpace(writer);
+                buildTypeDisplay(getTypeOfSymbol(p), writer, enclosingDeclaration, flags, symbolStack);
+            }
+            function buildBindingPatternDisplay(bindingPattern, writer, enclosingDeclaration, flags, symbolStack) {
+                // We have to explicitly emit square bracket and bracket because these tokens are not stored inside the node.
+                if (bindingPattern.kind === 167 /* ObjectBindingPattern */) {
+                    writePunctuation(writer, 15 /* OpenBraceToken */);
+                    buildDisplayForCommaSeparatedList(bindingPattern.elements, writer, function (e) { return buildBindingElementDisplay(e, writer, enclosingDeclaration, flags, symbolStack); });
+                    writePunctuation(writer, 16 /* CloseBraceToken */);
+                }
+                else if (bindingPattern.kind === 168 /* ArrayBindingPattern */) {
+                    writePunctuation(writer, 19 /* OpenBracketToken */);
+                    var elements = bindingPattern.elements;
+                    buildDisplayForCommaSeparatedList(elements, writer, function (e) { return buildBindingElementDisplay(e, writer, enclosingDeclaration, flags, symbolStack); });
+                    if (elements && elements.hasTrailingComma) {
+                        writePunctuation(writer, 24 /* CommaToken */);
+                    }
+                    writePunctuation(writer, 20 /* CloseBracketToken */);
+                }
+            }
+            function buildBindingElementDisplay(bindingElement, writer, enclosingDeclaration, flags, symbolStack) {
+                if (bindingElement.kind === 193 /* OmittedExpression */) {
+                    return;
+                }
+                ts.Debug.assert(bindingElement.kind === 169 /* BindingElement */);
+                if (bindingElement.propertyName) {
+                    writer.writeSymbol(ts.getTextOfNode(bindingElement.propertyName), bindingElement.symbol);
+                    writePunctuation(writer, 54 /* ColonToken */);
+                    writeSpace(writer);
+                }
+                if (ts.isBindingPattern(bindingElement.name)) {
+                    buildBindingPatternDisplay(bindingElement.name, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                else {
+                    if (bindingElement.dotDotDotToken) {
+                        writePunctuation(writer, 22 /* DotDotDotToken */);
+                    }
+                    appendSymbolNameOnly(bindingElement.symbol, writer);
+                }
+            }
+            function buildDisplayForTypeParametersAndDelimiters(typeParameters, writer, enclosingDeclaration, flags, symbolStack) {
+                if (typeParameters && typeParameters.length) {
+                    writePunctuation(writer, 25 /* LessThanToken */);
+                    buildDisplayForCommaSeparatedList(typeParameters, writer, function (p) { return buildTypeParameterDisplay(p, writer, enclosingDeclaration, flags, symbolStack); });
+                    writePunctuation(writer, 27 /* GreaterThanToken */);
+                }
+            }
+            function buildDisplayForCommaSeparatedList(list, writer, action) {
+                for (var i = 0; i < list.length; i++) {
+                    if (i > 0) {
+                        writePunctuation(writer, 24 /* CommaToken */);
+                        writeSpace(writer);
+                    }
+                    action(list[i]);
+                }
+            }
+            function buildDisplayForTypeArgumentsAndDelimiters(typeParameters, mapper, writer, enclosingDeclaration, flags, symbolStack) {
+                if (typeParameters && typeParameters.length) {
+                    writePunctuation(writer, 25 /* LessThanToken */);
+                    var flags_1 = 256 /* InFirstTypeArgument */;
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        if (i > 0) {
+                            writePunctuation(writer, 24 /* CommaToken */);
+                            writeSpace(writer);
+                            flags_1 = 0 /* None */;
+                        }
+                        buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, flags_1);
+                    }
+                    writePunctuation(writer, 27 /* GreaterThanToken */);
+                }
+            }
+            function buildDisplayForParametersAndDelimiters(thisParameter, parameters, writer, enclosingDeclaration, flags, symbolStack) {
+                writePunctuation(writer, 17 /* OpenParenToken */);
+                if (thisParameter) {
+                    buildParameterDisplay(thisParameter, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                for (var i = 0; i < parameters.length; i++) {
+                    if (i > 0 || thisParameter) {
+                        writePunctuation(writer, 24 /* CommaToken */);
+                        writeSpace(writer);
+                    }
+                    buildParameterDisplay(parameters[i], writer, enclosingDeclaration, flags, symbolStack);
+                }
+                writePunctuation(writer, 18 /* CloseParenToken */);
+            }
+            function buildTypePredicateDisplay(predicate, writer, enclosingDeclaration, flags, symbolStack) {
+                if (ts.isIdentifierTypePredicate(predicate)) {
+                    writer.writeParameter(predicate.parameterName);
+                }
+                else {
+                    writeKeyword(writer, 97 /* ThisKeyword */);
+                }
+                writeSpace(writer);
+                writeKeyword(writer, 124 /* IsKeyword */);
+                writeSpace(writer);
+                buildTypeDisplay(predicate.type, writer, enclosingDeclaration, flags, symbolStack);
+            }
+            function buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, symbolStack) {
+                if (flags & 8 /* WriteArrowStyleSignature */) {
+                    writeSpace(writer);
+                    writePunctuation(writer, 34 /* EqualsGreaterThanToken */);
+                }
+                else {
+                    writePunctuation(writer, 54 /* ColonToken */);
+                }
+                writeSpace(writer);
+                if (signature.typePredicate) {
+                    buildTypePredicateDisplay(signature.typePredicate, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                else {
+                    var returnType = getReturnTypeOfSignature(signature);
+                    buildTypeDisplay(returnType, writer, enclosingDeclaration, flags, symbolStack);
+                }
+            }
+            function buildSignatureDisplay(signature, writer, enclosingDeclaration, flags, kind, symbolStack) {
+                if (kind === 1 /* Construct */) {
+                    writeKeyword(writer, 92 /* NewKeyword */);
+                    writeSpace(writer);
+                }
+                if (signature.target && (flags & 32 /* WriteTypeArgumentsOfSignature */)) {
+                    // Instantiated signature, write type arguments instead
+                    // This is achieved by passing in the mapper separately
+                    buildDisplayForTypeArgumentsAndDelimiters(signature.target.typeParameters, signature.mapper, writer, enclosingDeclaration);
+                }
+                else {
+                    buildDisplayForTypeParametersAndDelimiters(signature.typeParameters, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                buildDisplayForParametersAndDelimiters(signature.thisParameter, signature.parameters, writer, enclosingDeclaration, flags, symbolStack);
+                buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, symbolStack);
+            }
+            return _displayBuilder || (_displayBuilder = {
+                buildSymbolDisplay: buildSymbolDisplay,
+                buildTypeDisplay: buildTypeDisplay,
+                buildTypeParameterDisplay: buildTypeParameterDisplay,
+                buildTypePredicateDisplay: buildTypePredicateDisplay,
+                buildParameterDisplay: buildParameterDisplay,
+                buildDisplayForParametersAndDelimiters: buildDisplayForParametersAndDelimiters,
+                buildDisplayForTypeParametersAndDelimiters: buildDisplayForTypeParametersAndDelimiters,
+                buildTypeParameterDisplayFromSymbol: buildTypeParameterDisplayFromSymbol,
+                buildSignatureDisplay: buildSignatureDisplay,
+                buildReturnTypeDisplay: buildReturnTypeDisplay
+            });
+        }
+        function isDeclarationVisible(node) {
+            if (node) {
+                var links = getNodeLinks(node);
+                if (links.isVisible === undefined) {
+                    links.isVisible = !!determineIfDeclarationIsVisible();
+                }
+                return links.isVisible;
+            }
+            return false;
+            function determineIfDeclarationIsVisible() {
+                switch (node.kind) {
+                    case 169 /* BindingElement */:
+                        return isDeclarationVisible(node.parent.parent);
+                    case 218 /* VariableDeclaration */:
+                        if (ts.isBindingPattern(node.name) &&
+                            !node.name.elements.length) {
+                            // If the binding pattern is empty, this variable declaration is not visible
+                            return false;
+                        }
+                    // Otherwise fall through
+                    case 225 /* ModuleDeclaration */:
+                    case 221 /* ClassDeclaration */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                    case 220 /* FunctionDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 229 /* ImportEqualsDeclaration */:
+                        // external module augmentation is always visible
+                        if (ts.isExternalModuleAugmentation(node)) {
+                            return true;
+                        }
+                        var parent_8 = getDeclarationContainer(node);
+                        // If the node is not exported or it is not ambient module element (except import declaration)
+                        if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) &&
+                            !(node.kind !== 229 /* ImportEqualsDeclaration */ && parent_8.kind !== 256 /* SourceFile */ && ts.isInAmbientContext(parent_8))) {
+                            return isGlobalSourceFile(parent_8);
+                        }
+                        // Exported members/ambient module elements (exception import declaration) are visible if parent is visible
+                        return isDeclarationVisible(parent_8);
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        if (node.flags & (8 /* Private */ | 16 /* Protected */)) {
+                            // Private/protected properties/methods are not visible
+                            return false;
+                        }
+                    // Public properties/methods are visible if its parents are visible, so const it fall into next case statement
+                    case 148 /* Constructor */:
+                    case 152 /* ConstructSignature */:
+                    case 151 /* CallSignature */:
+                    case 153 /* IndexSignature */:
+                    case 142 /* Parameter */:
+                    case 226 /* ModuleBlock */:
+                    case 156 /* FunctionType */:
+                    case 157 /* ConstructorType */:
+                    case 159 /* TypeLiteral */:
+                    case 155 /* TypeReference */:
+                    case 160 /* ArrayType */:
+                    case 161 /* TupleType */:
+                    case 162 /* UnionType */:
+                    case 163 /* IntersectionType */:
+                    case 164 /* ParenthesizedType */:
+                        return isDeclarationVisible(node.parent);
+                    // Default binding, import specifier and namespace import is visible
+                    // only on demand so by default it is not visible
+                    case 231 /* ImportClause */:
+                    case 232 /* NamespaceImport */:
+                    case 234 /* ImportSpecifier */:
+                        return false;
+                    // Type parameters are always visible
+                    case 141 /* TypeParameter */:
+                    // Source file is always visible
+                    case 256 /* SourceFile */:
+                        return true;
+                    // Export assignments do not create name bindings outside the module
+                    case 235 /* ExportAssignment */:
+                        return false;
+                    default:
+                        return false;
+                }
+            }
+        }
+        function collectLinkedAliases(node) {
+            var exportSymbol;
+            if (node.parent && node.parent.kind === 235 /* ExportAssignment */) {
+                exportSymbol = resolveName(node.parent, node.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */, ts.Diagnostics.Cannot_find_name_0, node);
+            }
+            else if (node.parent.kind === 238 /* ExportSpecifier */) {
+                var exportSpecifier = node.parent;
+                exportSymbol = exportSpecifier.parent.parent.moduleSpecifier ?
+                    getExternalModuleMember(exportSpecifier.parent.parent, exportSpecifier) :
+                    resolveEntityName(exportSpecifier.propertyName || exportSpecifier.name, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */);
+            }
+            var result = [];
+            if (exportSymbol) {
+                buildVisibleNodeList(exportSymbol.declarations);
+            }
+            return result;
+            function buildVisibleNodeList(declarations) {
+                ts.forEach(declarations, function (declaration) {
+                    getNodeLinks(declaration).isVisible = true;
+                    var resultNode = getAnyImportSyntax(declaration) || declaration;
+                    if (!ts.contains(result, resultNode)) {
+                        result.push(resultNode);
+                    }
+                    if (ts.isInternalModuleImportEqualsDeclaration(declaration)) {
+                        // Add the referenced top container visible
+                        var internalModuleReference = declaration.moduleReference;
+                        var firstIdentifier = getFirstIdentifier(internalModuleReference);
+                        var importSymbol = resolveName(declaration, firstIdentifier.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, undefined, undefined);
+                        if (importSymbol) {
+                            buildVisibleNodeList(importSymbol.declarations);
+                        }
+                    }
+                });
+            }
+        }
+        /**
+         * Push an entry on the type resolution stack. If an entry with the given target and the given property name
+         * is already on the stack, and no entries in between already have a type, then a circularity has occurred.
+         * In this case, the result values of the existing entry and all entries pushed after it are changed to false,
+         * and the value false is returned. Otherwise, the new entry is just pushed onto the stack, and true is returned.
+         * In order to see if the same query has already been done before, the target object and the propertyName both
+         * must match the one passed in.
+         *
+         * @param target The symbol, type, or signature whose type is being queried
+         * @param propertyName The property name that should be used to query the target for its type
+         */
+        function pushTypeResolution(target, propertyName) {
+            var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
+            if (resolutionCycleStartIndex >= 0) {
+                // A cycle was found
+                var length_2 = resolutionTargets.length;
+                for (var i = resolutionCycleStartIndex; i < length_2; i++) {
+                    resolutionResults[i] = false;
+                }
+                return false;
+            }
+            resolutionTargets.push(target);
+            resolutionResults.push(/*items*/ true);
+            resolutionPropertyNames.push(propertyName);
+            return true;
+        }
+        function findResolutionCycleStartIndex(target, propertyName) {
+            for (var i = resolutionTargets.length - 1; i >= 0; i--) {
+                if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) {
+                    return -1;
+                }
+                if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        function hasType(target, propertyName) {
+            if (propertyName === 0 /* Type */) {
+                return getSymbolLinks(target).type;
+            }
+            if (propertyName === 2 /* DeclaredType */) {
+                return getSymbolLinks(target).declaredType;
+            }
+            if (propertyName === 1 /* ResolvedBaseConstructorType */) {
+                ts.Debug.assert(!!(target.flags & 1024 /* Class */));
+                return target.resolvedBaseConstructorType;
+            }
+            if (propertyName === 3 /* ResolvedReturnType */) {
+                return target.resolvedReturnType;
+            }
+            ts.Debug.fail("Unhandled TypeSystemPropertyName " + propertyName);
+        }
+        // Pop an entry from the type resolution stack and return its associated result value. The result value will
+        // be true if no circularities were detected, or false if a circularity was found.
+        function popTypeResolution() {
+            resolutionTargets.pop();
+            resolutionPropertyNames.pop();
+            return resolutionResults.pop();
+        }
+        function getDeclarationContainer(node) {
+            node = ts.getRootDeclaration(node);
+            while (node) {
+                switch (node.kind) {
+                    case 218 /* VariableDeclaration */:
+                    case 219 /* VariableDeclarationList */:
+                    case 234 /* ImportSpecifier */:
+                    case 233 /* NamedImports */:
+                    case 232 /* NamespaceImport */:
+                    case 231 /* ImportClause */:
+                        node = node.parent;
+                        break;
+                    default:
+                        return node.parent;
+                }
+            }
+        }
+        function getTypeOfPrototypeProperty(prototype) {
+            // TypeScript 1.0 spec (April 2014): 8.4
+            // Every class automatically contains a static property member named 'prototype',
+            // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
+            // It is an error to explicitly declare a static property member with the name 'prototype'.
+            var classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
+            return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType;
+        }
+        // Return the type of the given property in the given type, or undefined if no such property exists
+        function getTypeOfPropertyOfType(type, name) {
+            var prop = getPropertyOfType(type, name);
+            return prop ? getTypeOfSymbol(prop) : undefined;
+        }
+        function isTypeAny(type) {
+            return type && (type.flags & 1 /* Any */) !== 0;
+        }
+        function isTypeNever(type) {
+            return type && (type.flags & 134217728 /* Never */) !== 0;
+        }
+        // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
+        // assigned by contextual typing.
+        function getTypeForBindingElementParent(node) {
+            var symbol = getSymbolOfNode(node);
+            return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false);
+        }
+        function getTextOfPropertyName(name) {
+            switch (name.kind) {
+                case 69 /* Identifier */:
+                    return name.text;
+                case 9 /* StringLiteral */:
+                case 8 /* NumericLiteral */:
+                    return name.text;
+                case 140 /* ComputedPropertyName */:
+                    if (ts.isStringOrNumericLiteral(name.expression.kind)) {
+                        return name.expression.text;
+                    }
+            }
+            return undefined;
+        }
+        function isComputedNonLiteralName(name) {
+            return name.kind === 140 /* ComputedPropertyName */ && !ts.isStringOrNumericLiteral(name.expression.kind);
+        }
+        /** Return the inferred type for a binding element */
+        function getTypeForBindingElement(declaration) {
+            var pattern = declaration.parent;
+            var parentType = getTypeForBindingElementParent(pattern.parent);
+            // If parent has the unknown (error) type, then so does this binding element
+            if (parentType === unknownType) {
+                return unknownType;
+            }
+            // If no type was specified or inferred for parent, or if the specified or inferred type is any,
+            // infer from the initializer of the binding element if one is present. Otherwise, go with the
+            // undefined or any type of the parent.
+            if (!parentType || isTypeAny(parentType)) {
+                if (declaration.initializer) {
+                    return checkExpressionCached(declaration.initializer);
+                }
+                return parentType;
+            }
+            var type;
+            if (pattern.kind === 167 /* ObjectBindingPattern */) {
+                // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form)
+                var name_11 = declaration.propertyName || declaration.name;
+                if (isComputedNonLiteralName(name_11)) {
+                    // computed properties with non-literal names are treated as 'any'
+                    return anyType;
+                }
+                if (declaration.initializer) {
+                    getContextualType(declaration.initializer);
+                }
+                // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature,
+                // or otherwise the type of the string index signature.
+                var text = getTextOfPropertyName(name_11);
+                type = getTypeOfPropertyOfType(parentType, text) ||
+                    isNumericLiteralName(text) && getIndexTypeOfType(parentType, 1 /* Number */) ||
+                    getIndexTypeOfType(parentType, 0 /* String */);
+                if (!type) {
+                    error(name_11, ts.Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), ts.declarationNameToString(name_11));
+                    return unknownType;
+                }
+            }
+            else {
+                // This elementType will be used if the specific property corresponding to this index is not
+                // present (aka the tuple element property). This call also checks that the parentType is in
+                // fact an iterable or array (depending on target language).
+                var elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
+                if (!declaration.dotDotDotToken) {
+                    // Use specific property type when parent is a tuple or numeric index type when parent is an array
+                    var propName = "" + ts.indexOf(pattern.elements, declaration);
+                    type = isTupleLikeType(parentType)
+                        ? getTypeOfPropertyOfType(parentType, propName)
+                        : elementType;
+                    if (!type) {
+                        if (isTupleType(parentType)) {
+                            error(declaration, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), parentType.elementTypes.length, pattern.elements.length);
+                        }
+                        else {
+                            error(declaration, ts.Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
+                        }
+                        return unknownType;
+                    }
+                }
+                else {
+                    // Rest element has an array type with the same element type as the parent type
+                    type = createArrayType(elementType);
+                }
+            }
+            // In strict null checking mode, if a default value of a non-undefined type is specified, remove
+            // undefined from the final type.
+            if (strictNullChecks && declaration.initializer && !(getCombinedTypeFlags(checkExpressionCached(declaration.initializer)) & 32 /* Undefined */)) {
+                type = getTypeWithFacts(type, 131072 /* NEUndefined */);
+            }
+            return type;
+        }
+        function getTypeForVariableLikeDeclarationFromJSDocComment(declaration) {
+            var jsDocType = getJSDocTypeForVariableLikeDeclarationFromJSDocComment(declaration);
+            if (jsDocType) {
+                return getTypeFromTypeNode(jsDocType);
+            }
+        }
+        function getJSDocTypeForVariableLikeDeclarationFromJSDocComment(declaration) {
+            // First, see if this node has an @type annotation on it directly.
+            var typeTag = ts.getJSDocTypeTag(declaration);
+            if (typeTag && typeTag.typeExpression) {
+                return typeTag.typeExpression.type;
+            }
+            if (declaration.kind === 218 /* VariableDeclaration */ &&
+                declaration.parent.kind === 219 /* VariableDeclarationList */ &&
+                declaration.parent.parent.kind === 200 /* VariableStatement */) {
+                // @type annotation might have been on the variable statement, try that instead.
+                var annotation = ts.getJSDocTypeTag(declaration.parent.parent);
+                if (annotation && annotation.typeExpression) {
+                    return annotation.typeExpression.type;
+                }
+            }
+            else if (declaration.kind === 142 /* Parameter */) {
+                // If it's a parameter, see if the parent has a jsdoc comment with an @param
+                // annotation.
+                var paramTag = ts.getCorrespondingJSDocParameterTag(declaration);
+                if (paramTag && paramTag.typeExpression) {
+                    return paramTag.typeExpression.type;
+                }
+            }
+            return undefined;
+        }
+        function addOptionality(type, optional) {
+            return strictNullChecks && optional ? addTypeKind(type, 32 /* Undefined */) : type;
+        }
+        // Return the inferred type for a variable, parameter, or property declaration
+        function getTypeForVariableLikeDeclaration(declaration, includeOptionality) {
+            if (declaration.flags & 134217728 /* JavaScriptFile */) {
+                // If this is a variable in a JavaScript file, then use the JSDoc type (if it has
+                // one as its type), otherwise fallback to the below standard TS codepaths to
+                // try to figure it out.
+                var type = getTypeForVariableLikeDeclarationFromJSDocComment(declaration);
+                if (type && type !== unknownType) {
+                    return type;
+                }
+            }
+            // A variable declared in a for..in statement is always of type string
+            if (declaration.parent.parent.kind === 207 /* ForInStatement */) {
+                return stringType;
+            }
+            if (declaration.parent.parent.kind === 208 /* ForOfStatement */) {
+                // checkRightHandSideOfForOf will return undefined if the for-of expression type was
+                // missing properties/signatures required to get its iteratedType (like
+                // [Symbol.iterator] or next). This may be because we accessed properties from anyType,
+                // or it may have led to an error inside getElementTypeOfIterable.
+                return checkRightHandSideOfForOf(declaration.parent.parent.expression) || anyType;
+            }
+            if (ts.isBindingPattern(declaration.parent)) {
+                return getTypeForBindingElement(declaration);
+            }
+            // Use type from type annotation if one is present
+            if (declaration.type) {
+                return addOptionality(getTypeFromTypeNode(declaration.type), /*optional*/ declaration.questionToken && includeOptionality);
+            }
+            if (declaration.kind === 142 /* Parameter */) {
+                var func = declaration.parent;
+                // For a parameter of a set accessor, use the type of the get accessor if one is present
+                if (func.kind === 150 /* SetAccessor */ && !ts.hasDynamicName(func)) {
+                    var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 149 /* GetAccessor */);
+                    if (getter) {
+                        var getterSignature = getSignatureFromDeclaration(getter);
+                        var thisParameter = getAccessorThisParameter(func);
+                        if (thisParameter && declaration === thisParameter) {
+                            // Use the type from the *getter*
+                            ts.Debug.assert(!thisParameter.type);
+                            return getTypeOfSymbol(getterSignature.thisParameter);
+                        }
+                        return getReturnTypeOfSignature(getterSignature);
+                    }
+                }
+                // Use contextual parameter type if one is available
+                var type = declaration.symbol.name === "this"
+                    ? getContextuallyTypedThisType(func)
+                    : getContextuallyTypedParameterType(declaration);
+                if (type) {
+                    return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
+                }
+            }
+            // Use the type of the initializer expression if one is present
+            if (declaration.initializer) {
+                return addOptionality(checkExpressionCached(declaration.initializer), /*optional*/ declaration.questionToken && includeOptionality);
+            }
+            // If it is a short-hand property assignment, use the type of the identifier
+            if (declaration.kind === 254 /* ShorthandPropertyAssignment */) {
+                return checkIdentifier(declaration.name);
+            }
+            // If the declaration specifies a binding pattern, use the type implied by the binding pattern
+            if (ts.isBindingPattern(declaration.name)) {
+                return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ false);
+            }
+            // No type specified and nothing can be inferred
+            return undefined;
+        }
+        // Return the type implied by a binding pattern element. This is the type of the initializer of the element if
+        // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding
+        // pattern. Otherwise, it is the type any.
+        function getTypeFromBindingElement(element, includePatternInType) {
+            if (element.initializer) {
+                var type = checkExpressionCached(element.initializer);
+                reportErrorsFromWidening(element, type);
+                return getWidenedType(type);
+            }
+            if (ts.isBindingPattern(element.name)) {
+                return getTypeFromBindingPattern(element.name, includePatternInType);
+            }
+            if (compilerOptions.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element)) {
+                reportImplicitAnyError(element, anyType);
+            }
+            return anyType;
+        }
+        // Return the type implied by an object binding pattern
+        function getTypeFromObjectBindingPattern(pattern, includePatternInType) {
+            var members = {};
+            var hasComputedProperties = false;
+            ts.forEach(pattern.elements, function (e) {
+                var name = e.propertyName || e.name;
+                if (isComputedNonLiteralName(name)) {
+                    // do not include computed properties in the implied type
+                    hasComputedProperties = true;
+                    return;
+                }
+                var text = getTextOfPropertyName(name);
+                var flags = 4 /* Property */ | 67108864 /* Transient */ | (e.initializer ? 536870912 /* Optional */ : 0);
+                var symbol = createSymbol(flags, text);
+                symbol.type = getTypeFromBindingElement(e, includePatternInType);
+                symbol.bindingElement = e;
+                members[symbol.name] = symbol;
+            });
+            var result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined);
+            if (includePatternInType) {
+                result.pattern = pattern;
+            }
+            if (hasComputedProperties) {
+                result.flags |= 67108864 /* ObjectLiteralPatternWithComputedProperties */;
+            }
+            return result;
+        }
+        // Return the type implied by an array binding pattern
+        function getTypeFromArrayBindingPattern(pattern, includePatternInType) {
+            var elements = pattern.elements;
+            if (elements.length === 0 || elements[elements.length - 1].dotDotDotToken) {
+                return languageVersion >= 2 /* ES6 */ ? createIterableType(anyType) : anyArrayType;
+            }
+            // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
+            var elementTypes = ts.map(elements, function (e) { return e.kind === 193 /* OmittedExpression */ ? anyType : getTypeFromBindingElement(e, includePatternInType); });
+            if (includePatternInType) {
+                var result = createNewTupleType(elementTypes);
+                result.pattern = pattern;
+                return result;
+            }
+            return createTupleType(elementTypes);
+        }
+        // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
+        // and without regard to its context (i.e. without regard any type annotation or initializer associated with the
+        // declaration in which the binding pattern is contained). For example, the implied type of [x, y] is [any, any]
+        // and the implied type of { x, y: z = 1 } is { x: any; y: number; }. The type implied by a binding pattern is
+        // used as the contextual type of an initializer associated with the binding pattern. Also, for a destructuring
+        // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of
+        // the parameter.
+        function getTypeFromBindingPattern(pattern, includePatternInType) {
+            return pattern.kind === 167 /* ObjectBindingPattern */
+                ? getTypeFromObjectBindingPattern(pattern, includePatternInType)
+                : getTypeFromArrayBindingPattern(pattern, includePatternInType);
+        }
+        // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type
+        // specified in a type annotation or inferred from an initializer. However, in the case of a destructuring declaration it
+        // is a bit more involved. For example:
+        //
+        //   var [x, s = ""] = [1, "one"];
+        //
+        // Here, the array literal [1, "one"] is contextually typed by the type [any, string], which is the implied type of the
+        // binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the
+        // tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string.
+        function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) {
+            var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true);
+            if (type) {
+                if (reportErrors) {
+                    reportErrorsFromWidening(declaration, type);
+                }
+                // During a normal type check we'll never get to here with a property assignment (the check of the containing
+                // object literal uses a different path). We exclude widening only so that language services and type verification
+                // tools see the actual type.
+                if (declaration.kind === 253 /* PropertyAssignment */) {
+                    return type;
+                }
+                return getWidenedType(type);
+            }
+            // Rest parameters default to type any[], other parameters default to type any
+            type = declaration.dotDotDotToken ? anyArrayType : anyType;
+            // Report implicit any errors unless this is a private property within an ambient declaration
+            if (reportErrors && compilerOptions.noImplicitAny) {
+                if (!declarationBelongsToPrivateAmbientMember(declaration)) {
+                    reportImplicitAnyError(declaration, type);
+                }
+            }
+            return type;
+        }
+        function declarationBelongsToPrivateAmbientMember(declaration) {
+            var root = ts.getRootDeclaration(declaration);
+            var memberDeclaration = root.kind === 142 /* Parameter */ ? root.parent : root;
+            return isPrivateWithinAmbient(memberDeclaration);
+        }
+        function getTypeOfVariableOrParameterOrProperty(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                // Handle prototype property
+                if (symbol.flags & 134217728 /* Prototype */) {
+                    return links.type = getTypeOfPrototypeProperty(symbol);
+                }
+                // Handle catch clause variables
+                var declaration = symbol.valueDeclaration;
+                if (declaration.parent.kind === 252 /* CatchClause */) {
+                    return links.type = anyType;
+                }
+                // Handle export default expressions
+                if (declaration.kind === 235 /* ExportAssignment */) {
+                    return links.type = checkExpression(declaration.expression);
+                }
+                // Handle variable, parameter or property
+                if (!pushTypeResolution(symbol, 0 /* Type */)) {
+                    return unknownType;
+                }
+                var type = undefined;
+                // Handle module.exports = expr or this.p = expr
+                if (declaration.kind === 187 /* BinaryExpression */) {
+                    type = getUnionType(ts.map(symbol.declarations, function (decl) { return checkExpressionCached(decl.right); }));
+                }
+                else if (declaration.kind === 172 /* PropertyAccessExpression */) {
+                    // Declarations only exist for property access expressions for certain
+                    // special assignment kinds
+                    if (declaration.parent.kind === 187 /* BinaryExpression */) {
+                        // Handle exports.p = expr  or className.prototype.method = expr
+                        type = checkExpressionCached(declaration.parent.right);
+                    }
+                }
+                if (type === undefined) {
+                    type = getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
+                }
+                if (!popTypeResolution()) {
+                    if (symbol.valueDeclaration.type) {
+                        // Variable has type annotation that circularly references the variable itself
+                        type = unknownType;
+                        error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    else {
+                        // Variable has initializer that circularly references the variable itself
+                        type = anyType;
+                        if (compilerOptions.noImplicitAny) {
+                            error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol));
+                        }
+                    }
+                }
+                links.type = type;
+            }
+            return links.type;
+        }
+        function getAnnotatedAccessorType(accessor) {
+            if (accessor) {
+                if (accessor.kind === 149 /* GetAccessor */) {
+                    return accessor.type && getTypeFromTypeNode(accessor.type);
+                }
+                else {
+                    var setterTypeAnnotation = ts.getSetAccessorTypeAnnotationNode(accessor);
+                    return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation);
+                }
+            }
+            return undefined;
+        }
+        function getAnnotatedAccessorThisParameter(accessor) {
+            var parameter = getAccessorThisParameter(accessor);
+            return parameter && parameter.symbol;
+        }
+        function getThisTypeOfDeclaration(declaration) {
+            return getThisTypeOfSignature(getSignatureFromDeclaration(declaration));
+        }
+        function getTypeOfAccessors(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                var getter = ts.getDeclarationOfKind(symbol, 149 /* GetAccessor */);
+                var setter = ts.getDeclarationOfKind(symbol, 150 /* SetAccessor */);
+                if (getter && getter.flags & 134217728 /* JavaScriptFile */) {
+                    var jsDocType = getTypeForVariableLikeDeclarationFromJSDocComment(getter);
+                    if (jsDocType) {
+                        return links.type = jsDocType;
+                    }
+                }
+                if (!pushTypeResolution(symbol, 0 /* Type */)) {
+                    return unknownType;
+                }
+                var type = void 0;
+                // First try to see if the user specified a return type on the get-accessor.
+                var getterReturnType = getAnnotatedAccessorType(getter);
+                if (getterReturnType) {
+                    type = getterReturnType;
+                }
+                else {
+                    // If the user didn't specify a return type, try to use the set-accessor's parameter type.
+                    var setterParameterType = getAnnotatedAccessorType(setter);
+                    if (setterParameterType) {
+                        type = setterParameterType;
+                    }
+                    else {
+                        // If there are no specified types, try to infer it from the body of the get accessor if it exists.
+                        if (getter && getter.body) {
+                            type = getReturnTypeFromBody(getter);
+                        }
+                        else {
+                            if (compilerOptions.noImplicitAny) {
+                                error(setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation, symbolToString(symbol));
+                            }
+                            type = anyType;
+                        }
+                    }
+                }
+                if (!popTypeResolution()) {
+                    type = anyType;
+                    if (compilerOptions.noImplicitAny) {
+                        var getter_1 = ts.getDeclarationOfKind(symbol, 149 /* GetAccessor */);
+                        error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+                    }
+                }
+                links.type = type;
+            }
+            return links.type;
+        }
+        function getTypeOfFuncClassEnumModule(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                if (symbol.valueDeclaration.kind === 225 /* ModuleDeclaration */ && ts.isShorthandAmbientModule(symbol.valueDeclaration)) {
+                    links.type = anyType;
+                }
+                else {
+                    var type = createObjectType(65536 /* Anonymous */, symbol);
+                    links.type = strictNullChecks && symbol.flags & 536870912 /* Optional */ ?
+                        addTypeKind(type, 32 /* Undefined */) : type;
+                }
+            }
+            return links.type;
+        }
+        function getTypeOfEnumMember(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
+            }
+            return links.type;
+        }
+        function getTypeOfAlias(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                var targetSymbol = resolveAlias(symbol);
+                // It only makes sense to get the type of a value symbol. If the result of resolving
+                // the alias is not a value, then it has no type. To get the type associated with a
+                // type symbol, call getDeclaredTypeOfSymbol.
+                // This check is important because without it, a call to getTypeOfSymbol could end
+                // up recursively calling getTypeOfAlias, causing a stack overflow.
+                links.type = targetSymbol.flags & 107455 /* Value */
+                    ? getTypeOfSymbol(targetSymbol)
+                    : unknownType;
+            }
+            return links.type;
+        }
+        function getTypeOfInstantiatedSymbol(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
+            }
+            return links.type;
+        }
+        function getTypeOfSymbol(symbol) {
+            if (symbol.flags & 16777216 /* Instantiated */) {
+                return getTypeOfInstantiatedSymbol(symbol);
+            }
+            if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
+                return getTypeOfVariableOrParameterOrProperty(symbol);
+            }
+            if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
+                return getTypeOfFuncClassEnumModule(symbol);
+            }
+            if (symbol.flags & 8 /* EnumMember */) {
+                return getTypeOfEnumMember(symbol);
+            }
+            if (symbol.flags & 98304 /* Accessor */) {
+                return getTypeOfAccessors(symbol);
+            }
+            if (symbol.flags & 8388608 /* Alias */) {
+                return getTypeOfAlias(symbol);
+            }
+            return unknownType;
+        }
+        function getTargetType(type) {
+            return type.flags & 4096 /* Reference */ ? type.target : type;
+        }
+        function hasBaseType(type, checkBase) {
+            return check(type);
+            function check(type) {
+                var target = getTargetType(type);
+                return target === checkBase || ts.forEach(getBaseTypes(target), check);
+            }
+        }
+        // Appends the type parameters given by a list of declarations to a set of type parameters and returns the resulting set.
+        // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set
+        // in-place and returns the same array.
+        function appendTypeParameters(typeParameters, declarations) {
+            for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+                var declaration = declarations_2[_i];
+                var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
+                if (!typeParameters) {
+                    typeParameters = [tp];
+                }
+                else if (!ts.contains(typeParameters, tp)) {
+                    typeParameters.push(tp);
+                }
+            }
+            return typeParameters;
+        }
+        // Appends the outer type parameters of a node to a set of type parameters and returns the resulting set. The function
+        // allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set in-place and
+        // returns the same array.
+        function appendOuterTypeParameters(typeParameters, node) {
+            while (true) {
+                node = node.parent;
+                if (!node) {
+                    return typeParameters;
+                }
+                if (node.kind === 221 /* ClassDeclaration */ || node.kind === 192 /* ClassExpression */ ||
+                    node.kind === 220 /* FunctionDeclaration */ || node.kind === 179 /* FunctionExpression */ ||
+                    node.kind === 147 /* MethodDeclaration */ || node.kind === 180 /* ArrowFunction */) {
+                    var declarations = node.typeParameters;
+                    if (declarations) {
+                        return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations);
+                    }
+                }
+            }
+        }
+        // The outer type parameters are those defined by enclosing generic classes, methods, or functions.
+        function getOuterTypeParametersOfClassOrInterface(symbol) {
+            var declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 222 /* InterfaceDeclaration */);
+            return appendOuterTypeParameters(undefined, declaration);
+        }
+        // The local type parameters are the combined set of type parameters from all declarations of the class,
+        // interface, or type alias.
+        function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) {
+            var result;
+            for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                var node = _a[_i];
+                if (node.kind === 222 /* InterfaceDeclaration */ || node.kind === 221 /* ClassDeclaration */ ||
+                    node.kind === 192 /* ClassExpression */ || node.kind === 223 /* TypeAliasDeclaration */) {
+                    var declaration = node;
+                    if (declaration.typeParameters) {
+                        result = appendTypeParameters(result, declaration.typeParameters);
+                    }
+                }
+            }
+            return result;
+        }
+        // The full set of type parameters for a generic class or interface type consists of its outer type parameters plus
+        // its locally declared type parameters.
+        function getTypeParametersOfClassOrInterface(symbol) {
+            return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
+        }
+        function isConstructorType(type) {
+            return type.flags & 80896 /* ObjectType */ && getSignaturesOfType(type, 1 /* Construct */).length > 0;
+        }
+        function getBaseTypeNodeOfClass(type) {
+            return ts.getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration);
+        }
+        function getConstructorsForTypeArguments(type, typeArgumentNodes) {
+            var typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0;
+            return ts.filter(getSignaturesOfType(type, 1 /* Construct */), function (sig) { return (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount; });
+        }
+        function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes) {
+            var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes);
+            if (typeArgumentNodes) {
+                var typeArguments_1 = ts.map(typeArgumentNodes, getTypeFromTypeNode);
+                signatures = ts.map(signatures, function (sig) { return getSignatureInstantiation(sig, typeArguments_1); });
+            }
+            return signatures;
+        }
+        // The base constructor of a class can resolve to
+        // undefinedType if the class has no extends clause,
+        // unknownType if an error occurred during resolution of the extends expression,
+        // nullType if the extends expression is the null value, or
+        // an object type with at least one construct signature.
+        function getBaseConstructorTypeOfClass(type) {
+            if (!type.resolvedBaseConstructorType) {
+                var baseTypeNode = getBaseTypeNodeOfClass(type);
+                if (!baseTypeNode) {
+                    return type.resolvedBaseConstructorType = undefinedType;
+                }
+                if (!pushTypeResolution(type, 1 /* ResolvedBaseConstructorType */)) {
+                    return unknownType;
+                }
+                var baseConstructorType = checkExpression(baseTypeNode.expression);
+                if (baseConstructorType.flags & 80896 /* ObjectType */) {
+                    // Resolving the members of a class requires us to resolve the base class of that class.
+                    // We force resolution here such that we catch circularities now.
+                    resolveStructuredTypeMembers(baseConstructorType);
+                }
+                if (!popTypeResolution()) {
+                    error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
+                    return type.resolvedBaseConstructorType = unknownType;
+                }
+                if (baseConstructorType !== unknownType && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
+                    error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
+                    return type.resolvedBaseConstructorType = unknownType;
+                }
+                type.resolvedBaseConstructorType = baseConstructorType;
+            }
+            return type.resolvedBaseConstructorType;
+        }
+        function getBaseTypes(type) {
+            var isClass = type.symbol.flags & 32 /* Class */;
+            var isInterface = type.symbol.flags & 64 /* Interface */;
+            if (!type.resolvedBaseTypes) {
+                if (!isClass && !isInterface) {
+                    ts.Debug.fail("type must be class or interface");
+                }
+                if (isClass) {
+                    resolveBaseTypesOfClass(type);
+                }
+                if (isInterface) {
+                    resolveBaseTypesOfInterface(type);
+                }
+            }
+            return type.resolvedBaseTypes;
+        }
+        function resolveBaseTypesOfClass(type) {
+            type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
+            var baseConstructorType = getBaseConstructorTypeOfClass(type);
+            if (!(baseConstructorType.flags & 80896 /* ObjectType */)) {
+                return;
+            }
+            var baseTypeNode = getBaseTypeNodeOfClass(type);
+            var baseType;
+            var originalBaseType = baseConstructorType && baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined;
+            if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 /* Class */ &&
+                areAllOuterTypeParametersApplied(originalBaseType)) {
+                // When base constructor type is a class with no captured type arguments we know that the constructors all have the same type parameters as the
+                // class and all return the instance type of the class. There is no need for further checks and we can apply the
+                // type arguments in the same manner as a type reference to get the same error reporting experience.
+                baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol);
+            }
+            else {
+                // The class derives from a "class-like" constructor function, check that we have at least one construct signature
+                // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere
+                // we check that all instantiated signatures return the same type.
+                var constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments);
+                if (!constructors.length) {
+                    error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
+                    return;
+                }
+                baseType = getReturnTypeOfSignature(constructors[0]);
+            }
+            if (baseType === unknownType) {
+                return;
+            }
+            if (!(getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */))) {
+                error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType));
+                return;
+            }
+            if (type === baseType || hasBaseType(baseType, type)) {
+                error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, 1 /* WriteArrayAsGenericType */));
+                return;
+            }
+            if (type.resolvedBaseTypes === emptyArray) {
+                type.resolvedBaseTypes = [baseType];
+            }
+            else {
+                type.resolvedBaseTypes.push(baseType);
+            }
+        }
+        function areAllOuterTypeParametersApplied(type) {
+            // An unapplied type parameter has its symbol still the same as the matching argument symbol.
+            // Since parameters are applied outer-to-inner, only the last outer parameter needs to be checked.
+            var outerTypeParameters = type.outerTypeParameters;
+            if (outerTypeParameters) {
+                var last = outerTypeParameters.length - 1;
+                var typeArguments = type.typeArguments;
+                return outerTypeParameters[last].symbol !== typeArguments[last].symbol;
+            }
+            return true;
+        }
+        function resolveBaseTypesOfInterface(type) {
+            type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
+            for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
+                var declaration = _a[_i];
+                if (declaration.kind === 222 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) {
+                    for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) {
+                        var node = _c[_b];
+                        var baseType = getTypeFromTypeNode(node);
+                        if (baseType !== unknownType) {
+                            if (getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */)) {
+                                if (type !== baseType && !hasBaseType(baseType, type)) {
+                                    if (type.resolvedBaseTypes === emptyArray) {
+                                        type.resolvedBaseTypes = [baseType];
+                                    }
+                                    else {
+                                        type.resolvedBaseTypes.push(baseType);
+                                    }
+                                }
+                                else {
+                                    error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, 1 /* WriteArrayAsGenericType */));
+                                }
+                            }
+                            else {
+                                error(node, ts.Diagnostics.An_interface_may_only_extend_a_class_or_another_interface);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Returns true if the interface given by the symbol is free of "this" references. Specifically, the result is
+        // true if the interface itself contains no references to "this" in its body, if all base types are interfaces,
+        // and if none of the base interfaces have a "this" type.
+        function isIndependentInterface(symbol) {
+            for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                var declaration = _a[_i];
+                if (declaration.kind === 222 /* InterfaceDeclaration */) {
+                    if (declaration.flags & 16384 /* ContainsThis */) {
+                        return false;
+                    }
+                    var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
+                    if (baseTypeNodes) {
+                        for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+                            var node = baseTypeNodes_1[_b];
+                            if (ts.isSupportedExpressionWithTypeArguments(node)) {
+                                var baseSymbol = resolveEntityName(node.expression, 793056 /* Type */, /*ignoreErrors*/ true);
+                                if (!baseSymbol || !(baseSymbol.flags & 64 /* Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        function getDeclaredTypeOfClassOrInterface(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.declaredType) {
+                var kind = symbol.flags & 32 /* Class */ ? 1024 /* Class */ : 2048 /* Interface */;
+                var type = links.declaredType = createObjectType(kind, symbol);
+                var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
+                var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+                // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type
+                // because it is not feasible to analyze all members to determine if the "this" type escapes the class (in particular,
+                // property types inferred from initializers and method return types inferred from return statements are very hard
+                // to exhaustively analyze). We give interfaces a "this" type if we can't definitely determine that they are free of
+                // "this" references.
+                if (outerTypeParameters || localTypeParameters || kind === 1024 /* Class */ || !isIndependentInterface(symbol)) {
+                    type.flags |= 4096 /* Reference */;
+                    type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters);
+                    type.outerTypeParameters = outerTypeParameters;
+                    type.localTypeParameters = localTypeParameters;
+                    type.instantiations = {};
+                    type.instantiations[getTypeListId(type.typeParameters)] = type;
+                    type.target = type;
+                    type.typeArguments = type.typeParameters;
+                    type.thisType = createType(512 /* TypeParameter */ | 33554432 /* ThisType */);
+                    type.thisType.symbol = symbol;
+                    type.thisType.constraint = type;
+                }
+            }
+            return links.declaredType;
+        }
+        function getDeclaredTypeOfTypeAlias(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.declaredType) {
+                // Note that we use the links object as the target here because the symbol object is used as the unique
+                // identity for resolution of the 'type' property in SymbolLinks.
+                if (!pushTypeResolution(symbol, 2 /* DeclaredType */)) {
+                    return unknownType;
+                }
+                var type = void 0;
+                var declaration = ts.getDeclarationOfKind(symbol, 279 /* JSDocTypedefTag */);
+                if (declaration) {
+                    if (declaration.jsDocTypeLiteral) {
+                        type = getTypeFromTypeNode(declaration.jsDocTypeLiteral);
+                    }
+                    else {
+                        type = getTypeFromTypeNode(declaration.typeExpression.type);
+                    }
+                }
+                else {
+                    declaration = ts.getDeclarationOfKind(symbol, 223 /* TypeAliasDeclaration */);
+                    type = getTypeFromTypeNode(declaration.type);
+                }
+                if (popTypeResolution()) {
+                    links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+                    if (links.typeParameters) {
+                        // Initialize the instantiation cache for generic type aliases. The declared type corresponds to
+                        // an instantiation of the type alias with the type parameters supplied as type arguments.
+                        links.instantiations = {};
+                        links.instantiations[getTypeListId(links.typeParameters)] = type;
+                    }
+                }
+                else {
+                    type = unknownType;
+                    error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
+                }
+                links.declaredType = type;
+            }
+            return links.declaredType;
+        }
+        function getDeclaredTypeOfEnum(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.declaredType) {
+                var type = createType(128 /* Enum */);
+                type.symbol = symbol;
+                links.declaredType = type;
+            }
+            return links.declaredType;
+        }
+        function getDeclaredTypeOfTypeParameter(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.declaredType) {
+                var type = createType(512 /* TypeParameter */);
+                type.symbol = symbol;
+                if (!ts.getDeclarationOfKind(symbol, 141 /* TypeParameter */).constraint) {
+                    type.constraint = noConstraintType;
+                }
+                links.declaredType = type;
+            }
+            return links.declaredType;
+        }
+        function getDeclaredTypeOfAlias(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.declaredType) {
+                links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol));
+            }
+            return links.declaredType;
+        }
+        function getDeclaredTypeOfSymbol(symbol) {
+            ts.Debug.assert((symbol.flags & 16777216 /* Instantiated */) === 0);
+            if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
+                return getDeclaredTypeOfClassOrInterface(symbol);
+            }
+            if (symbol.flags & 524288 /* TypeAlias */) {
+                return getDeclaredTypeOfTypeAlias(symbol);
+            }
+            if (symbol.flags & 384 /* Enum */) {
+                return getDeclaredTypeOfEnum(symbol);
+            }
+            if (symbol.flags & 262144 /* TypeParameter */) {
+                return getDeclaredTypeOfTypeParameter(symbol);
+            }
+            if (symbol.flags & 8388608 /* Alias */) {
+                return getDeclaredTypeOfAlias(symbol);
+            }
+            return unknownType;
+        }
+        // A type reference is considered independent if each type argument is considered independent.
+        function isIndependentTypeReference(node) {
+            if (node.typeArguments) {
+                for (var _i = 0, _a = node.typeArguments; _i < _a.length; _i++) {
+                    var typeNode = _a[_i];
+                    if (!isIndependentType(typeNode)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        // A type is considered independent if it the any, string, number, boolean, symbol, or void keyword, a string
+        // literal type, an array with an element type that is considered independent, or a type reference that is
+        // considered independent.
+        function isIndependentType(node) {
+            switch (node.kind) {
+                case 117 /* AnyKeyword */:
+                case 132 /* StringKeyword */:
+                case 130 /* NumberKeyword */:
+                case 120 /* BooleanKeyword */:
+                case 133 /* SymbolKeyword */:
+                case 103 /* VoidKeyword */:
+                case 135 /* UndefinedKeyword */:
+                case 93 /* NullKeyword */:
+                case 127 /* NeverKeyword */:
+                case 166 /* StringLiteralType */:
+                    return true;
+                case 160 /* ArrayType */:
+                    return isIndependentType(node.elementType);
+                case 155 /* TypeReference */:
+                    return isIndependentTypeReference(node);
+            }
+            return false;
+        }
+        // A variable-like declaration is considered independent (free of this references) if it has a type annotation
+        // that specifies an independent type, or if it has no type annotation and no initializer (and thus of type any).
+        function isIndependentVariableLikeDeclaration(node) {
+            return node.type && isIndependentType(node.type) || !node.type && !node.initializer;
+        }
+        // A function-like declaration is considered independent (free of this references) if it has a return type
+        // annotation that is considered independent and if each parameter is considered independent.
+        function isIndependentFunctionLikeDeclaration(node) {
+            if (node.kind !== 148 /* Constructor */ && (!node.type || !isIndependentType(node.type))) {
+                return false;
+            }
+            for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
+                var parameter = _a[_i];
+                if (!isIndependentVariableLikeDeclaration(parameter)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Returns true if the class or interface member given by the symbol is free of "this" references. The
+        // function may return false for symbols that are actually free of "this" references because it is not
+        // feasible to perform a complete analysis in all cases. In particular, property members with types
+        // inferred from their initializers and function members with inferred return types are conservatively
+        // assumed not to be free of "this" references.
+        function isIndependentMember(symbol) {
+            if (symbol.declarations && symbol.declarations.length === 1) {
+                var declaration = symbol.declarations[0];
+                if (declaration) {
+                    switch (declaration.kind) {
+                        case 145 /* PropertyDeclaration */:
+                        case 144 /* PropertySignature */:
+                            return isIndependentVariableLikeDeclaration(declaration);
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                        case 148 /* Constructor */:
+                            return isIndependentFunctionLikeDeclaration(declaration);
+                    }
+                }
+            }
+            return false;
+        }
+        function createSymbolTable(symbols) {
+            var result = {};
+            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                var symbol = symbols_1[_i];
+                result[symbol.name] = symbol;
+            }
+            return result;
+        }
+        // The mappingThisOnly flag indicates that the only type parameter being mapped is "this". When the flag is true,
+        // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation.
+        function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
+            var result = {};
+            for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                var symbol = symbols_2[_i];
+                result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
+            }
+            return result;
+        }
+        function addInheritedMembers(symbols, baseSymbols) {
+            for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+                var s = baseSymbols_1[_i];
+                if (!ts.hasProperty(symbols, s.name)) {
+                    symbols[s.name] = s;
+                }
+            }
+        }
+        function resolveDeclaredMembers(type) {
+            if (!type.declaredProperties) {
+                var symbol = type.symbol;
+                type.declaredProperties = getNamedMembers(symbol.members);
+                type.declaredCallSignatures = getSignaturesOfSymbol(symbol.members["__call"]);
+                type.declaredConstructSignatures = getSignaturesOfSymbol(symbol.members["__new"]);
+                type.declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, 0 /* String */);
+                type.declaredNumberIndexInfo = getIndexInfoOfSymbol(symbol, 1 /* Number */);
+            }
+            return type;
+        }
+        function getTypeWithThisArgument(type, thisArgument) {
+            if (type.flags & 4096 /* Reference */) {
+                return createTypeReference(type.target, ts.concatenate(type.typeArguments, [thisArgument || type.target.thisType]));
+            }
+            return type;
+        }
+        function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
+            var mapper = identityMapper;
+            var members = source.symbol.members;
+            var callSignatures = source.declaredCallSignatures;
+            var constructSignatures = source.declaredConstructSignatures;
+            var stringIndexInfo = source.declaredStringIndexInfo;
+            var numberIndexInfo = source.declaredNumberIndexInfo;
+            if (!ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = createTypeMapper(typeParameters, typeArguments);
+                members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
+                callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
+                constructSignatures = instantiateList(source.declaredConstructSignatures, mapper, instantiateSignature);
+                stringIndexInfo = instantiateIndexInfo(source.declaredStringIndexInfo, mapper);
+                numberIndexInfo = instantiateIndexInfo(source.declaredNumberIndexInfo, mapper);
+            }
+            var baseTypes = getBaseTypes(source);
+            if (baseTypes.length) {
+                if (members === source.symbol.members) {
+                    members = createSymbolTable(source.declaredProperties);
+                }
+                var thisArgument = ts.lastOrUndefined(typeArguments);
+                for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+                    var baseType = baseTypes_1[_i];
+                    var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
+                    addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
+                    callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */));
+                    constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* Construct */));
+                    stringIndexInfo = stringIndexInfo || getIndexInfoOfType(instantiatedBaseType, 0 /* String */);
+                    numberIndexInfo = numberIndexInfo || getIndexInfoOfType(instantiatedBaseType, 1 /* Number */);
+                }
+            }
+            setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+        }
+        function resolveClassOrInterfaceMembers(type) {
+            resolveObjectTypeMembers(type, resolveDeclaredMembers(type), emptyArray, emptyArray);
+        }
+        function resolveTypeReferenceMembers(type) {
+            var source = resolveDeclaredMembers(type.target);
+            var typeParameters = ts.concatenate(source.typeParameters, [source.thisType]);
+            var typeArguments = type.typeArguments && type.typeArguments.length === typeParameters.length ?
+                type.typeArguments : ts.concatenate(type.typeArguments, [type]);
+            resolveObjectTypeMembers(type, source, typeParameters, typeArguments);
+        }
+        function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, typePredicate, minArgumentCount, hasRestParameter, hasStringLiterals) {
+            var sig = new Signature(checker);
+            sig.declaration = declaration;
+            sig.typeParameters = typeParameters;
+            sig.parameters = parameters;
+            sig.thisParameter = thisParameter;
+            sig.resolvedReturnType = resolvedReturnType;
+            sig.typePredicate = typePredicate;
+            sig.minArgumentCount = minArgumentCount;
+            sig.hasRestParameter = hasRestParameter;
+            sig.hasStringLiterals = hasStringLiterals;
+            return sig;
+        }
+        function cloneSignature(sig) {
+            return createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, sig.resolvedReturnType, sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals);
+        }
+        function getDefaultConstructSignatures(classType) {
+            var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+            var baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
+            if (baseSignatures.length === 0) {
+                return [createSignature(undefined, classType.localTypeParameters, undefined, emptyArray, classType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false)];
+            }
+            var baseTypeNode = getBaseTypeNodeOfClass(classType);
+            var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode);
+            var typeArgCount = typeArguments ? typeArguments.length : 0;
+            var result = [];
+            for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+                var baseSig = baseSignatures_1[_i];
+                var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
+                if (typeParamCount === typeArgCount) {
+                    var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
+                    sig.typeParameters = classType.localTypeParameters;
+                    sig.resolvedReturnType = classType;
+                    result.push(sig);
+                }
+            }
+            return result;
+        }
+        function createTupleTypeMemberSymbols(memberTypes) {
+            var members = {};
+            for (var i = 0; i < memberTypes.length; i++) {
+                var symbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i);
+                symbol.type = memberTypes[i];
+                members[i] = symbol;
+            }
+            return members;
+        }
+        function resolveTupleTypeMembers(type) {
+            var arrayElementType = getUnionType(type.elementTypes, /*noSubtypeReduction*/ true);
+            // Make the tuple type itself the 'this' type by including an extra type argument
+            var arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
+            var members = createTupleTypeMemberSymbols(type.elementTypes);
+            addInheritedMembers(members, arrayType.properties);
+            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
+        }
+        function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
+            for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+                var s = signatureList_1[_i];
+                if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypesIdentical)) {
+                    return s;
+                }
+            }
+        }
+        function findMatchingSignatures(signatureLists, signature, listIndex) {
+            if (signature.typeParameters) {
+                // We require an exact match for generic signatures, so we only return signatures from the first
+                // signature list and only if they have exact matches in the other signature lists.
+                if (listIndex > 0) {
+                    return undefined;
+                }
+                for (var i = 1; i < signatureLists.length; i++) {
+                    if (!findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false)) {
+                        return undefined;
+                    }
+                }
+                return [signature];
+            }
+            var result = undefined;
+            for (var i = 0; i < signatureLists.length; i++) {
+                // Allow matching non-generic signatures to have excess parameters and different return types
+                var match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ true, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true);
+                if (!match) {
+                    return undefined;
+                }
+                if (!ts.contains(result, match)) {
+                    (result || (result = [])).push(match);
+                }
+            }
+            return result;
+        }
+        // The signatures of a union type are those signatures that are present in each of the constituent types.
+        // Generic signatures must match exactly, but non-generic signatures are allowed to have extra optional
+        // parameters and may differ in return types. When signatures differ in return types, the resulting return
+        // type is the union of the constituent return types.
+        function getUnionSignatures(types, kind) {
+            var signatureLists = ts.map(types, function (t) { return getSignaturesOfType(t, kind); });
+            var result = undefined;
+            for (var i = 0; i < signatureLists.length; i++) {
+                for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) {
+                    var signature = _a[_i];
+                    // Only process signatures with parameter lists that aren't already in the result list
+                    if (!result || !findMatchingSignature(result, signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true)) {
+                        var unionSignatures = findMatchingSignatures(signatureLists, signature, i);
+                        if (unionSignatures) {
+                            var s = signature;
+                            // Union the result types when more than one signature matches
+                            if (unionSignatures.length > 1) {
+                                s = cloneSignature(signature);
+                                if (ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; })) {
+                                    var thisType = getUnionType(ts.map(unionSignatures, function (sig) { return getTypeOfSymbol(sig.thisParameter) || anyType; }));
+                                    s.thisParameter = createTransientSymbol(signature.thisParameter, thisType);
+                                }
+                                // Clear resolved return type we possibly got from cloneSignature
+                                s.resolvedReturnType = undefined;
+                                s.unionSignatures = unionSignatures;
+                            }
+                            (result || (result = [])).push(s);
+                        }
+                    }
+                }
+            }
+            return result || emptyArray;
+        }
+        function getUnionIndexInfo(types, kind) {
+            var indexTypes = [];
+            var isAnyReadonly = false;
+            for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+                var type = types_1[_i];
+                var indexInfo = getIndexInfoOfType(type, kind);
+                if (!indexInfo) {
+                    return undefined;
+                }
+                indexTypes.push(indexInfo.type);
+                isAnyReadonly = isAnyReadonly || indexInfo.isReadonly;
+            }
+            return createIndexInfo(getUnionType(indexTypes), isAnyReadonly);
+        }
+        function resolveUnionTypeMembers(type) {
+            // The members and properties collections are empty for union types. To get all properties of a union
+            // type use getPropertiesOfType (only the language service uses this).
+            var callSignatures = getUnionSignatures(type.types, 0 /* Call */);
+            var constructSignatures = getUnionSignatures(type.types, 1 /* Construct */);
+            var stringIndexInfo = getUnionIndexInfo(type.types, 0 /* String */);
+            var numberIndexInfo = getUnionIndexInfo(type.types, 1 /* Number */);
+            setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+        }
+        function intersectTypes(type1, type2) {
+            return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]);
+        }
+        function intersectIndexInfos(info1, info2) {
+            return !info1 ? info2 : !info2 ? info1 : createIndexInfo(getIntersectionType([info1.type, info2.type]), info1.isReadonly && info2.isReadonly);
+        }
+        function resolveIntersectionTypeMembers(type) {
+            // The members and properties collections are empty for intersection types. To get all properties of an
+            // intersection type use getPropertiesOfType (only the language service uses this).
+            var callSignatures = emptyArray;
+            var constructSignatures = emptyArray;
+            var stringIndexInfo = undefined;
+            var numberIndexInfo = undefined;
+            for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                var t = _a[_i];
+                callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(t, 0 /* Call */));
+                constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(t, 1 /* Construct */));
+                stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, 0 /* String */));
+                numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, 1 /* Number */));
+            }
+            setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+        }
+        function resolveAnonymousTypeMembers(type) {
+            var symbol = type.symbol;
+            if (type.target) {
+                var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
+                var callSignatures = instantiateList(getSignaturesOfType(type.target, 0 /* Call */), type.mapper, instantiateSignature);
+                var constructSignatures = instantiateList(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper, instantiateSignature);
+                var stringIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 0 /* String */), type.mapper);
+                var numberIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 1 /* Number */), type.mapper);
+                setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+            }
+            else if (symbol.flags & 2048 /* TypeLiteral */) {
+                var members = symbol.members;
+                var callSignatures = getSignaturesOfSymbol(members["__call"]);
+                var constructSignatures = getSignaturesOfSymbol(members["__new"]);
+                var stringIndexInfo = getIndexInfoOfSymbol(symbol, 0 /* String */);
+                var numberIndexInfo = getIndexInfoOfSymbol(symbol, 1 /* Number */);
+                setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+            }
+            else {
+                // Combinations of function, class, enum and module
+                var members = emptySymbols;
+                var constructSignatures = emptyArray;
+                if (symbol.flags & 1952 /* HasExports */) {
+                    members = getExportsOfSymbol(symbol);
+                }
+                if (symbol.flags & 32 /* Class */) {
+                    var classType = getDeclaredTypeOfClassOrInterface(symbol);
+                    constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]);
+                    if (!constructSignatures.length) {
+                        constructSignatures = getDefaultConstructSignatures(classType);
+                    }
+                    var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                    if (baseConstructorType.flags & 80896 /* ObjectType */) {
+                        members = createSymbolTable(getNamedMembers(members));
+                        addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType));
+                    }
+                }
+                var numberIndexInfo = symbol.flags & 384 /* Enum */ ? enumNumberIndexInfo : undefined;
+                setObjectTypeMembers(type, members, emptyArray, constructSignatures, undefined, numberIndexInfo);
+                // We resolve the members before computing the signatures because a signature may use
+                // typeof with a qualified name expression that circularly references the type we are
+                // in the process of resolving (see issue #6072). The temporarily empty signature list
+                // will never be observed because a qualified name can't reference signatures.
+                if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
+                    type.callSignatures = getSignaturesOfSymbol(symbol);
+                }
+            }
+        }
+        function resolveStructuredTypeMembers(type) {
+            if (!type.members) {
+                if (type.flags & 4096 /* Reference */) {
+                    resolveTypeReferenceMembers(type);
+                }
+                else if (type.flags & (1024 /* Class */ | 2048 /* Interface */)) {
+                    resolveClassOrInterfaceMembers(type);
+                }
+                else if (type.flags & 65536 /* Anonymous */) {
+                    resolveAnonymousTypeMembers(type);
+                }
+                else if (type.flags & 8192 /* Tuple */) {
+                    resolveTupleTypeMembers(type);
+                }
+                else if (type.flags & 16384 /* Union */) {
+                    resolveUnionTypeMembers(type);
+                }
+                else if (type.flags & 32768 /* Intersection */) {
+                    resolveIntersectionTypeMembers(type);
+                }
+            }
+            return type;
+        }
+        /** Return properties of an object type or an empty array for other types */
+        function getPropertiesOfObjectType(type) {
+            if (type.flags & 80896 /* ObjectType */) {
+                return resolveStructuredTypeMembers(type).properties;
+            }
+            return emptyArray;
+        }
+        /** If the given type is an object type and that type has a property by the given name,
+         * return the symbol for that property. Otherwise return undefined. */
+        function getPropertyOfObjectType(type, name) {
+            if (type.flags & 80896 /* ObjectType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                if (ts.hasProperty(resolved.members, name)) {
+                    var symbol = resolved.members[name];
+                    if (symbolIsValue(symbol)) {
+                        return symbol;
+                    }
+                }
+            }
+        }
+        function getPropertiesOfUnionOrIntersectionType(type) {
+            for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                var current = _a[_i];
+                for (var _b = 0, _c = getPropertiesOfType(current); _b < _c.length; _b++) {
+                    var prop = _c[_b];
+                    getPropertyOfUnionOrIntersectionType(type, prop.name);
+                }
+                // The properties of a union type are those that are present in all constituent types, so
+                // we only need to check the properties of the first type
+                if (type.flags & 16384 /* Union */) {
+                    break;
+                }
+            }
+            return type.resolvedProperties ? symbolsToArray(type.resolvedProperties) : emptyArray;
+        }
+        function getPropertiesOfType(type) {
+            type = getApparentType(type);
+            return type.flags & 49152 /* UnionOrIntersection */ ? getPropertiesOfUnionOrIntersectionType(type) : getPropertiesOfObjectType(type);
+        }
+        /**
+         * The apparent type of a type parameter is the base constraint instantiated with the type parameter
+         * as the type argument for the 'this' type.
+         */
+        function getApparentTypeOfTypeParameter(type) {
+            if (!type.resolvedApparentType) {
+                var constraintType = getConstraintOfTypeParameter(type);
+                while (constraintType && constraintType.flags & 512 /* TypeParameter */) {
+                    constraintType = getConstraintOfTypeParameter(constraintType);
+                }
+                type.resolvedApparentType = getTypeWithThisArgument(constraintType || emptyObjectType, type);
+            }
+            return type.resolvedApparentType;
+        }
+        /**
+         * For a type parameter, return the base constraint of the type parameter. For the string, number,
+         * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
+         * type itself. Note that the apparent type of a union type is the union type itself.
+         */
+        function getApparentType(type) {
+            if (type.flags & 512 /* TypeParameter */) {
+                type = getApparentTypeOfTypeParameter(type);
+            }
+            if (type.flags & 258 /* StringLike */) {
+                type = globalStringType;
+            }
+            else if (type.flags & 132 /* NumberLike */) {
+                type = globalNumberType;
+            }
+            else if (type.flags & 8 /* Boolean */) {
+                type = globalBooleanType;
+            }
+            else if (type.flags & 16777216 /* ESSymbol */) {
+                type = getGlobalESSymbolType();
+            }
+            return type;
+        }
+        function createUnionOrIntersectionProperty(containingType, name) {
+            var types = containingType.types;
+            var props;
+            // Flags we want to propagate to the result if they exist in all source symbols
+            var commonFlags = (containingType.flags & 32768 /* Intersection */) ? 536870912 /* Optional */ : 0 /* None */;
+            var isReadonly = false;
+            for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+                var current = types_2[_i];
+                var type = getApparentType(current);
+                if (type !== unknownType) {
+                    var prop = getPropertyOfType(type, name);
+                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */))) {
+                        commonFlags &= prop.flags;
+                        if (!props) {
+                            props = [prop];
+                        }
+                        else if (!ts.contains(props, prop)) {
+                            props.push(prop);
+                        }
+                        if (isReadonlySymbol(prop)) {
+                            isReadonly = true;
+                        }
+                    }
+                    else if (containingType.flags & 16384 /* Union */) {
+                        // A union type requires the property to be present in all constituent types
+                        return undefined;
+                    }
+                }
+            }
+            if (!props) {
+                return undefined;
+            }
+            if (props.length === 1) {
+                return props[0];
+            }
+            var propTypes = [];
+            var declarations = [];
+            for (var _a = 0, props_1 = props; _a < props_1.length; _a++) {
+                var prop = props_1[_a];
+                if (prop.declarations) {
+                    ts.addRange(declarations, prop.declarations);
+                }
+                propTypes.push(getTypeOfSymbol(prop));
+            }
+            var result = createSymbol(4 /* Property */ |
+                67108864 /* Transient */ |
+                268435456 /* SyntheticProperty */ |
+                commonFlags, name);
+            result.containingType = containingType;
+            result.declarations = declarations;
+            result.isReadonly = isReadonly;
+            result.type = containingType.flags & 16384 /* Union */ ? getUnionType(propTypes) : getIntersectionType(propTypes);
+            return result;
+        }
+        function getPropertyOfUnionOrIntersectionType(type, name) {
+            var properties = type.resolvedProperties || (type.resolvedProperties = {});
+            if (ts.hasProperty(properties, name)) {
+                return properties[name];
+            }
+            var property = createUnionOrIntersectionProperty(type, name);
+            if (property) {
+                properties[name] = property;
+            }
+            return property;
+        }
+        // Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
+        // necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
+        // Object and Function as appropriate.
+        function getPropertyOfType(type, name) {
+            type = getApparentType(type);
+            if (type.flags & 80896 /* ObjectType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                if (ts.hasProperty(resolved.members, name)) {
+                    var symbol = resolved.members[name];
+                    if (symbolIsValue(symbol)) {
+                        return symbol;
+                    }
+                }
+                if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) {
+                    var symbol = getPropertyOfObjectType(globalFunctionType, name);
+                    if (symbol) {
+                        return symbol;
+                    }
+                }
+                return getPropertyOfObjectType(globalObjectType, name);
+            }
+            if (type.flags & 49152 /* UnionOrIntersection */) {
+                return getPropertyOfUnionOrIntersectionType(type, name);
+            }
+            return undefined;
+        }
+        function getSignaturesOfStructuredType(type, kind) {
+            if (type.flags & 130048 /* StructuredType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                return kind === 0 /* Call */ ? resolved.callSignatures : resolved.constructSignatures;
+            }
+            return emptyArray;
+        }
+        /**
+         * Return the signatures of the given kind in the given type. Creates synthetic union signatures when necessary and
+         * maps primitive types and type parameters are to their apparent types.
+         */
+        function getSignaturesOfType(type, kind) {
+            return getSignaturesOfStructuredType(getApparentType(type), kind);
+        }
+        function getIndexInfoOfStructuredType(type, kind) {
+            if (type.flags & 130048 /* StructuredType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                return kind === 0 /* String */ ? resolved.stringIndexInfo : resolved.numberIndexInfo;
+            }
+        }
+        function getIndexTypeOfStructuredType(type, kind) {
+            var info = getIndexInfoOfStructuredType(type, kind);
+            return info && info.type;
+        }
+        // Return the indexing info of the given kind in the given type. Creates synthetic union index types when necessary and
+        // maps primitive types and type parameters are to their apparent types.
+        function getIndexInfoOfType(type, kind) {
+            return getIndexInfoOfStructuredType(getApparentType(type), kind);
+        }
+        // Return the index type of the given kind in the given type. Creates synthetic union index types when necessary and
+        // maps primitive types and type parameters are to their apparent types.
+        function getIndexTypeOfType(type, kind) {
+            return getIndexTypeOfStructuredType(getApparentType(type), kind);
+        }
+        function getImplicitIndexTypeOfType(type, kind) {
+            if (isObjectLiteralType(type)) {
+                var propTypes = [];
+                for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
+                    var prop = _a[_i];
+                    if (kind === 0 /* String */ || isNumericLiteralName(prop.name)) {
+                        propTypes.push(getTypeOfSymbol(prop));
+                    }
+                }
+                if (propTypes.length) {
+                    return getUnionType(propTypes);
+                }
+            }
+            return undefined;
+        }
+        function getTypeParametersFromJSDocTemplate(declaration) {
+            if (declaration.flags & 134217728 /* JavaScriptFile */) {
+                var templateTag = ts.getJSDocTemplateTag(declaration);
+                if (templateTag) {
+                    return getTypeParametersFromDeclaration(templateTag.typeParameters);
+                }
+            }
+            return undefined;
+        }
+        // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual
+        // type checking functions).
+        function getTypeParametersFromDeclaration(typeParameterDeclarations) {
+            var result = [];
+            ts.forEach(typeParameterDeclarations, function (node) {
+                var tp = getDeclaredTypeOfTypeParameter(node.symbol);
+                if (!ts.contains(result, tp)) {
+                    result.push(tp);
+                }
+            });
+            return result;
+        }
+        function symbolsToArray(symbols) {
+            var result = [];
+            for (var id in symbols) {
+                if (!isReservedMemberName(id)) {
+                    result.push(symbols[id]);
+                }
+            }
+            return result;
+        }
+        function isJSDocOptionalParameter(node) {
+            if (node.flags & 134217728 /* JavaScriptFile */) {
+                if (node.type && node.type.kind === 268 /* JSDocOptionalType */) {
+                    return true;
+                }
+                var paramTag = ts.getCorrespondingJSDocParameterTag(node);
+                if (paramTag) {
+                    if (paramTag.isBracketed) {
+                        return true;
+                    }
+                    if (paramTag.typeExpression) {
+                        return paramTag.typeExpression.type.kind === 268 /* JSDocOptionalType */;
+                    }
+                }
+            }
+        }
+        function isOptionalParameter(node) {
+            if (ts.hasQuestionToken(node) || isJSDocOptionalParameter(node)) {
+                return true;
+            }
+            if (node.initializer) {
+                var signatureDeclaration = node.parent;
+                var signature = getSignatureFromDeclaration(signatureDeclaration);
+                var parameterIndex = ts.indexOf(signatureDeclaration.parameters, node);
+                ts.Debug.assert(parameterIndex >= 0);
+                return parameterIndex >= signature.minArgumentCount;
+            }
+            return false;
+        }
+        function createTypePredicateFromTypePredicateNode(node) {
+            if (node.parameterName.kind === 69 /* Identifier */) {
+                var parameterName = node.parameterName;
+                return {
+                    kind: 1 /* Identifier */,
+                    parameterName: parameterName ? parameterName.text : undefined,
+                    parameterIndex: parameterName ? getTypePredicateParameterIndex(node.parent.parameters, parameterName) : undefined,
+                    type: getTypeFromTypeNode(node.type)
+                };
+            }
+            else {
+                return {
+                    kind: 0 /* This */,
+                    type: getTypeFromTypeNode(node.type)
+                };
+            }
+        }
+        function getSignatureFromDeclaration(declaration) {
+            var links = getNodeLinks(declaration);
+            if (!links.resolvedSignature) {
+                var parameters = [];
+                var hasStringLiterals = false;
+                var minArgumentCount = -1;
+                var thisParameter = undefined;
+                var hasThisParameter = void 0;
+                var isJSConstructSignature = ts.isJSDocConstructSignature(declaration);
+                // If this is a JSDoc construct signature, then skip the first parameter in the
+                // parameter list.  The first parameter represents the return type of the construct
+                // signature.
+                for (var i = isJSConstructSignature ? 1 : 0, n = declaration.parameters.length; i < n; i++) {
+                    var param = declaration.parameters[i];
+                    var paramSymbol = param.symbol;
+                    // Include parameter symbol instead of property symbol in the signature
+                    if (paramSymbol && !!(paramSymbol.flags & 4 /* Property */) && !ts.isBindingPattern(param.name)) {
+                        var resolvedSymbol = resolveName(param, paramSymbol.name, 107455 /* Value */, undefined, undefined);
+                        paramSymbol = resolvedSymbol;
+                    }
+                    if (i === 0 && paramSymbol.name === "this") {
+                        hasThisParameter = true;
+                        thisParameter = param.symbol;
+                    }
+                    else {
+                        parameters.push(paramSymbol);
+                    }
+                    if (param.type && param.type.kind === 166 /* StringLiteralType */) {
+                        hasStringLiterals = true;
+                    }
+                    if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) {
+                        if (minArgumentCount < 0) {
+                            minArgumentCount = i - (hasThisParameter ? 1 : 0);
+                        }
+                    }
+                    else {
+                        // If we see any required parameters, it means the prior ones were not in fact optional.
+                        minArgumentCount = -1;
+                    }
+                }
+                // If only one accessor includes a this-type annotation, the other behaves as if it had the same type annotation
+                if ((declaration.kind === 149 /* GetAccessor */ || declaration.kind === 150 /* SetAccessor */) &&
+                    !ts.hasDynamicName(declaration) &&
+                    (!hasThisParameter || !thisParameter)) {
+                    var otherKind = declaration.kind === 149 /* GetAccessor */ ? 150 /* SetAccessor */ : 149 /* GetAccessor */;
+                    var other = ts.getDeclarationOfKind(declaration.symbol, otherKind);
+                    if (other) {
+                        thisParameter = getAnnotatedAccessorThisParameter(other);
+                    }
+                }
+                if (minArgumentCount < 0) {
+                    minArgumentCount = declaration.parameters.length - (hasThisParameter ? 1 : 0);
+                }
+                if (isJSConstructSignature) {
+                    minArgumentCount--;
+                }
+                var classType = declaration.kind === 148 /* Constructor */ ?
+                    getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol))
+                    : undefined;
+                var typeParameters = classType ? classType.localTypeParameters :
+                    declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) :
+                        getTypeParametersFromJSDocTemplate(declaration);
+                var returnType = getSignatureReturnTypeFromDeclaration(declaration, minArgumentCount, isJSConstructSignature, classType);
+                var typePredicate = declaration.type && declaration.type.kind === 154 /* TypePredicate */ ?
+                    createTypePredicateFromTypePredicateNode(declaration.type) :
+                    undefined;
+                links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, returnType, typePredicate, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals);
+            }
+            return links.resolvedSignature;
+        }
+        function getSignatureReturnTypeFromDeclaration(declaration, minArgumentCount, isJSConstructSignature, classType) {
+            if (isJSConstructSignature) {
+                return getTypeFromTypeNode(declaration.parameters[0].type);
+            }
+            else if (classType) {
+                return classType;
+            }
+            else if (declaration.type) {
+                return getTypeFromTypeNode(declaration.type);
+            }
+            if (declaration.flags & 134217728 /* JavaScriptFile */) {
+                var type = getReturnTypeFromJSDocComment(declaration);
+                if (type && type !== unknownType) {
+                    return type;
+                }
+            }
+            // TypeScript 1.0 spec (April 2014):
+            // If only one accessor includes a type annotation, the other behaves as if it had the same type annotation.
+            if (declaration.kind === 149 /* GetAccessor */ && !ts.hasDynamicName(declaration)) {
+                var setter = ts.getDeclarationOfKind(declaration.symbol, 150 /* SetAccessor */);
+                return getAnnotatedAccessorType(setter);
+            }
+            if (ts.nodeIsMissing(declaration.body)) {
+                return anyType;
+            }
+        }
+        function getSignaturesOfSymbol(symbol) {
+            if (!symbol)
+                return emptyArray;
+            var result = [];
+            for (var i = 0, len = symbol.declarations.length; i < len; i++) {
+                var node = symbol.declarations[i];
+                switch (node.kind) {
+                    case 156 /* FunctionType */:
+                    case 157 /* ConstructorType */:
+                    case 220 /* FunctionDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 148 /* Constructor */:
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 153 /* IndexSignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 269 /* JSDocFunctionType */:
+                        // Don't include signature if node is the implementation of an overloaded function. A node is considered
+                        // an implementation node if it has a body and the previous node is of the same kind and immediately
+                        // precedes the implementation node (i.e. has the same parent and ends where the implementation starts).
+                        if (i > 0 && node.body) {
+                            var previous = symbol.declarations[i - 1];
+                            if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) {
+                                break;
+                            }
+                        }
+                        result.push(getSignatureFromDeclaration(node));
+                }
+            }
+            return result;
+        }
+        function resolveExternalModuleTypeByLiteral(name) {
+            var moduleSym = resolveExternalModuleName(name, name);
+            if (moduleSym) {
+                var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
+                if (resolvedModuleSymbol) {
+                    return getTypeOfSymbol(resolvedModuleSymbol);
+                }
+            }
+            return anyType;
+        }
+        function getThisTypeOfSignature(signature) {
+            if (signature.thisParameter) {
+                return getTypeOfSymbol(signature.thisParameter);
+            }
+        }
+        function getReturnTypeOfSignature(signature) {
+            if (!signature.resolvedReturnType) {
+                if (!pushTypeResolution(signature, 3 /* ResolvedReturnType */)) {
+                    return unknownType;
+                }
+                var type = void 0;
+                if (signature.target) {
+                    type = instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper);
+                }
+                else if (signature.unionSignatures) {
+                    type = getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature));
+                }
+                else {
+                    type = getReturnTypeFromBody(signature.declaration);
+                }
+                if (!popTypeResolution()) {
+                    type = anyType;
+                    if (compilerOptions.noImplicitAny) {
+                        var declaration = signature.declaration;
+                        if (declaration.name) {
+                            error(declaration.name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(declaration.name));
+                        }
+                        else {
+                            error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
+                        }
+                    }
+                }
+                signature.resolvedReturnType = type;
+            }
+            return signature.resolvedReturnType;
+        }
+        function getRestTypeOfSignature(signature) {
+            if (signature.hasRestParameter) {
+                var type = getTypeOfSymbol(ts.lastOrUndefined(signature.parameters));
+                if (type.flags & 4096 /* Reference */ && type.target === globalArrayType) {
+                    return type.typeArguments[0];
+                }
+            }
+            return anyType;
+        }
+        function getSignatureInstantiation(signature, typeArguments) {
+            return instantiateSignature(signature, createTypeMapper(signature.typeParameters, typeArguments), /*eraseTypeParameters*/ true);
+        }
+        function getErasedSignature(signature) {
+            if (!signature.typeParameters)
+                return signature;
+            if (!signature.erasedSignatureCache) {
+                signature.erasedSignatureCache = instantiateSignature(signature, createTypeEraser(signature.typeParameters), /*eraseTypeParameters*/ true);
+            }
+            return signature.erasedSignatureCache;
+        }
+        function getOrCreateTypeFromSignature(signature) {
+            // There are two ways to declare a construct signature, one is by declaring a class constructor
+            // using the constructor keyword, and the other is declaring a bare construct signature in an
+            // object type literal or interface (using the new keyword). Each way of declaring a constructor
+            // will result in a different declaration kind.
+            if (!signature.isolatedSignatureType) {
+                var isConstructor = signature.declaration.kind === 148 /* Constructor */ || signature.declaration.kind === 152 /* ConstructSignature */;
+                var type = createObjectType(65536 /* Anonymous */ | 262144 /* FromSignature */);
+                type.members = emptySymbols;
+                type.properties = emptyArray;
+                type.callSignatures = !isConstructor ? [signature] : emptyArray;
+                type.constructSignatures = isConstructor ? [signature] : emptyArray;
+                signature.isolatedSignatureType = type;
+            }
+            return signature.isolatedSignatureType;
+        }
+        function getIndexSymbol(symbol) {
+            return symbol.members["__index"];
+        }
+        function getIndexDeclarationOfSymbol(symbol, kind) {
+            var syntaxKind = kind === 1 /* Number */ ? 130 /* NumberKeyword */ : 132 /* StringKeyword */;
+            var indexSymbol = getIndexSymbol(symbol);
+            if (indexSymbol) {
+                for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
+                    var decl = _a[_i];
+                    var node = decl;
+                    if (node.parameters.length === 1) {
+                        var parameter = node.parameters[0];
+                        if (parameter && parameter.type && parameter.type.kind === syntaxKind) {
+                            return node;
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
+        function createIndexInfo(type, isReadonly, declaration) {
+            return { type: type, isReadonly: isReadonly, declaration: declaration };
+        }
+        function getIndexInfoOfSymbol(symbol, kind) {
+            var declaration = getIndexDeclarationOfSymbol(symbol, kind);
+            if (declaration) {
+                return createIndexInfo(declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, (declaration.flags & 64 /* Readonly */) !== 0, declaration);
+            }
+            return undefined;
+        }
+        function getConstraintDeclaration(type) {
+            return ts.getDeclarationOfKind(type.symbol, 141 /* TypeParameter */).constraint;
+        }
+        function hasConstraintReferenceTo(type, target) {
+            var checked;
+            while (type && !(type.flags & 33554432 /* ThisType */) && type.flags & 512 /* TypeParameter */ && !ts.contains(checked, type)) {
+                if (type === target) {
+                    return true;
+                }
+                (checked || (checked = [])).push(type);
+                var constraintDeclaration = getConstraintDeclaration(type);
+                type = constraintDeclaration && getTypeFromTypeNode(constraintDeclaration);
+            }
+            return false;
+        }
+        function getConstraintOfTypeParameter(typeParameter) {
+            if (!typeParameter.constraint) {
+                if (typeParameter.target) {
+                    var targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
+                    typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
+                }
+                else {
+                    var constraintDeclaration = getConstraintDeclaration(typeParameter);
+                    var constraint = getTypeFromTypeNode(constraintDeclaration);
+                    if (hasConstraintReferenceTo(constraint, typeParameter)) {
+                        error(constraintDeclaration, ts.Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(typeParameter));
+                        constraint = unknownType;
+                    }
+                    typeParameter.constraint = constraint;
+                }
+            }
+            return typeParameter.constraint === noConstraintType ? undefined : typeParameter.constraint;
+        }
+        function getParentSymbolOfTypeParameter(typeParameter) {
+            return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 141 /* TypeParameter */).parent);
+        }
+        function getTypeListId(types) {
+            if (types) {
+                switch (types.length) {
+                    case 1:
+                        return "" + types[0].id;
+                    case 2:
+                        return types[0].id + "," + types[1].id;
+                    default:
+                        var result = "";
+                        for (var i = 0; i < types.length; i++) {
+                            if (i > 0) {
+                                result += ",";
+                            }
+                            result += types[i].id;
+                        }
+                        return result;
+                }
+            }
+            return "";
+        }
+        // This function is used to propagate certain flags when creating new object type references and union types.
+        // It is only necessary to do so if a constituent type might be the undefined type, the null type, the type
+        // of an object literal or the anyFunctionType. This is because there are operations in the type checker
+        // that care about the presence of such types at arbitrary depth in a containing type.
+        function getPropagatingFlagsOfTypes(types, excludeKinds) {
+            var result = 0;
+            for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+                var type = types_3[_i];
+                if (!(type.flags & excludeKinds)) {
+                    result |= type.flags;
+                }
+            }
+            return result & 14680064 /* PropagatingFlags */;
+        }
+        function createTypeReference(target, typeArguments) {
+            var id = getTypeListId(typeArguments);
+            var type = target.instantiations[id];
+            if (!type) {
+                var propagatedFlags = typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
+                var flags = 4096 /* Reference */ | propagatedFlags;
+                type = target.instantiations[id] = createObjectType(flags, target.symbol);
+                type.target = target;
+                type.typeArguments = typeArguments;
+            }
+            return type;
+        }
+        // Get type from reference to class or interface
+        function getTypeFromClassOrInterfaceReference(node, symbol) {
+            var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
+            var typeParameters = type.localTypeParameters;
+            if (typeParameters) {
+                if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) {
+                    error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, 1 /* WriteArrayAsGenericType */), typeParameters.length);
+                    return unknownType;
+                }
+                // In a type reference, the outer type parameters of the referenced class or interface are automatically
+                // supplied as type arguments and the type reference only specifies arguments for the local type parameters
+                // of the class or interface.
+                return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(node.typeArguments, getTypeFromTypeNode)));
+            }
+            if (node.typeArguments) {
+                error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type));
+                return unknownType;
+            }
+            return type;
+        }
+        // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include
+        // references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the
+        // declared type. Instantiations are cached using the type identities of the type arguments as the key.
+        function getTypeFromTypeAliasReference(node, symbol) {
+            var type = getDeclaredTypeOfSymbol(symbol);
+            var links = getSymbolLinks(symbol);
+            var typeParameters = links.typeParameters;
+            if (typeParameters) {
+                if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) {
+                    error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length);
+                    return unknownType;
+                }
+                var typeArguments = ts.map(node.typeArguments, getTypeFromTypeNode);
+                var id = getTypeListId(typeArguments);
+                return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments)));
+            }
+            if (node.typeArguments) {
+                error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol));
+                return unknownType;
+            }
+            return type;
+        }
+        // Get type from reference to named type that cannot be generic (enum or type parameter)
+        function getTypeFromNonGenericTypeReference(node, symbol) {
+            if (node.typeArguments) {
+                error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol));
+                return unknownType;
+            }
+            return getDeclaredTypeOfSymbol(symbol);
+        }
+        function getTypeReferenceName(node) {
+            switch (node.kind) {
+                case 155 /* TypeReference */:
+                    return node.typeName;
+                case 267 /* JSDocTypeReference */:
+                    return node.name;
+                case 194 /* ExpressionWithTypeArguments */:
+                    // We only support expressions that are simple qualified names. For other
+                    // expressions this produces undefined.
+                    if (ts.isSupportedExpressionWithTypeArguments(node)) {
+                        return node.expression;
+                    }
+            }
+            return undefined;
+        }
+        function resolveTypeReferenceName(node, typeReferenceName) {
+            if (!typeReferenceName) {
+                return unknownSymbol;
+            }
+            return resolveEntityName(typeReferenceName, 793056 /* Type */) || unknownSymbol;
+        }
+        function getTypeReferenceType(node, symbol) {
+            if (symbol === unknownSymbol) {
+                return unknownType;
+            }
+            if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
+                return getTypeFromClassOrInterfaceReference(node, symbol);
+            }
+            if (symbol.flags & 524288 /* TypeAlias */) {
+                return getTypeFromTypeAliasReference(node, symbol);
+            }
+            if (symbol.flags & 107455 /* Value */ && node.kind === 267 /* JSDocTypeReference */) {
+                // A JSDocTypeReference may have resolved to a value (as opposed to a type). In
+                // that case, the type of this reference is just the type of the value we resolved
+                // to.
+                return getTypeOfSymbol(symbol);
+            }
+            return getTypeFromNonGenericTypeReference(node, symbol);
+        }
+        function getTypeFromTypeReference(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                var symbol = void 0;
+                var type = void 0;
+                if (node.kind === 267 /* JSDocTypeReference */) {
+                    var typeReferenceName = getTypeReferenceName(node);
+                    symbol = resolveTypeReferenceName(node, typeReferenceName);
+                    type = getTypeReferenceType(node, symbol);
+                    links.resolvedSymbol = symbol;
+                    links.resolvedType = type;
+                }
+                else {
+                    // We only support expressions that are simple qualified names. For other expressions this produces undefined.
+                    var typeNameOrExpression = node.kind === 155 /* TypeReference */ ? node.typeName :
+                        ts.isSupportedExpressionWithTypeArguments(node) ? node.expression :
+                            undefined;
+                    symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, 793056 /* Type */) || unknownSymbol;
+                    type = symbol === unknownSymbol ? unknownType :
+                        symbol.flags & (32 /* Class */ | 64 /* Interface */) ? getTypeFromClassOrInterfaceReference(node, symbol) :
+                            symbol.flags & 524288 /* TypeAlias */ ? getTypeFromTypeAliasReference(node, symbol) :
+                                getTypeFromNonGenericTypeReference(node, symbol);
+                }
+                // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the
+                // type reference in checkTypeReferenceOrExpressionWithTypeArguments.
+                links.resolvedSymbol = symbol;
+                links.resolvedType = type;
+            }
+            return links.resolvedType;
+        }
+        function getTypeFromTypeQueryNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                // TypeScript 1.0 spec (April 2014): 3.6.3
+                // The expression is processed as an identifier expression (section 4.3)
+                // or property access expression(section 4.10),
+                // the widened type(section 3.9) of which becomes the result.
+                links.resolvedType = getWidenedType(checkExpression(node.exprName));
+            }
+            return links.resolvedType;
+        }
+        function getTypeOfGlobalSymbol(symbol, arity) {
+            function getTypeDeclaration(symbol) {
+                var declarations = symbol.declarations;
+                for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+                    var declaration = declarations_3[_i];
+                    switch (declaration.kind) {
+                        case 221 /* ClassDeclaration */:
+                        case 222 /* InterfaceDeclaration */:
+                        case 224 /* EnumDeclaration */:
+                            return declaration;
+                    }
+                }
+            }
+            if (!symbol) {
+                return arity ? emptyGenericType : emptyObjectType;
+            }
+            var type = getDeclaredTypeOfSymbol(symbol);
+            if (!(type.flags & 80896 /* ObjectType */)) {
+                error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
+                return arity ? emptyGenericType : emptyObjectType;
+            }
+            if ((type.typeParameters ? type.typeParameters.length : 0) !== arity) {
+                error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbol.name, arity);
+                return arity ? emptyGenericType : emptyObjectType;
+            }
+            return type;
+        }
+        function getGlobalValueSymbol(name) {
+            return getGlobalSymbol(name, 107455 /* Value */, ts.Diagnostics.Cannot_find_global_value_0);
+        }
+        function getGlobalTypeSymbol(name) {
+            return getGlobalSymbol(name, 793056 /* Type */, ts.Diagnostics.Cannot_find_global_type_0);
+        }
+        function getGlobalSymbol(name, meaning, diagnostic) {
+            return resolveName(undefined, name, meaning, diagnostic, name);
+        }
+        function getGlobalType(name, arity) {
+            if (arity === void 0) { arity = 0; }
+            return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity);
+        }
+        /**
+         * Returns a type that is inside a namespace at the global scope, e.g.
+         * getExportedTypeFromNamespace('JSX', 'Element') returns the JSX.Element type
+         */
+        function getExportedTypeFromNamespace(namespace, name) {
+            var namespaceSymbol = getGlobalSymbol(namespace, 1536 /* Namespace */, /*diagnosticMessage*/ undefined);
+            var typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, 793056 /* Type */);
+            return typeSymbol && getDeclaredTypeOfSymbol(typeSymbol);
+        }
+        /**
+          * Creates a TypeReference for a generic `TypedPropertyDescriptor<T>`.
+          */
+        function createTypedPropertyDescriptorType(propertyType) {
+            var globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType();
+            return globalTypedPropertyDescriptorType !== emptyGenericType
+                ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType])
+                : emptyObjectType;
+        }
+        /**
+         * Instantiates a global type that is generic with some element type, and returns that instantiation.
+         */
+        function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
+            return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
+        }
+        function createIterableType(elementType) {
+            return createTypeFromGenericGlobalType(getGlobalIterableType(), [elementType]);
+        }
+        function createIterableIteratorType(elementType) {
+            return createTypeFromGenericGlobalType(getGlobalIterableIteratorType(), [elementType]);
+        }
+        function createArrayType(elementType) {
+            return createTypeFromGenericGlobalType(globalArrayType, [elementType]);
+        }
+        function getTypeFromArrayTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
+            }
+            return links.resolvedType;
+        }
+        function createTupleType(elementTypes) {
+            var id = getTypeListId(elementTypes);
+            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes));
+        }
+        function createNewTupleType(elementTypes) {
+            var propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
+            var type = createObjectType(8192 /* Tuple */ | propagatedFlags);
+            type.elementTypes = elementTypes;
+            return type;
+        }
+        function getTypeFromTupleTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = createTupleType(ts.map(node.elementTypes, getTypeFromTypeNode));
+            }
+            return links.resolvedType;
+        }
+        function addTypeToSet(typeSet, type, typeSetKind) {
+            if (type.flags & typeSetKind) {
+                addTypesToSet(typeSet, type.types, typeSetKind);
+            }
+            else if (type.flags & (1 /* Any */ | 32 /* Undefined */ | 64 /* Null */)) {
+                if (type.flags & 1 /* Any */)
+                    typeSet.containsAny = true;
+                if (type.flags & 32 /* Undefined */)
+                    typeSet.containsUndefined = true;
+                if (type.flags & 64 /* Null */)
+                    typeSet.containsNull = true;
+                if (!(type.flags & 2097152 /* ContainsWideningType */))
+                    typeSet.containsNonWideningType = true;
+            }
+            else if (type !== neverType && !ts.contains(typeSet, type)) {
+                typeSet.push(type);
+            }
+        }
+        // Add the given types to the given type set. Order is preserved, duplicates are removed,
+        // and nested types of the given kind are flattened into the set.
+        function addTypesToSet(typeSet, types, typeSetKind) {
+            for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+                var type = types_4[_i];
+                addTypeToSet(typeSet, type, typeSetKind);
+            }
+        }
+        function isSubtypeOfAny(candidate, types) {
+            for (var i = 0, len = types.length; i < len; i++) {
+                if (candidate !== types[i] && isTypeSubtypeOf(candidate, types[i])) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function removeSubtypes(types) {
+            var i = types.length;
+            while (i > 0) {
+                i--;
+                if (isSubtypeOfAny(types[i], types)) {
+                    types.splice(i, 1);
+                }
+            }
+        }
+        // We reduce the constituent type set to only include types that aren't subtypes of other types, unless
+        // the noSubtypeReduction flag is specified, in which case we perform a simple deduplication based on
+        // object identity. Subtype reduction is possible only when union types are known not to circularly
+        // reference themselves (as is the case with union types created by expression constructs such as array
+        // literals and the || and ?: operators). Named types can circularly reference themselves and therefore
+        // cannot be deduplicated during their declaration. For example, "type Item = string | (() => Item" is
+        // a named type that circularly references itself.
+        function getUnionType(types, noSubtypeReduction) {
+            if (types.length === 0) {
+                return neverType;
+            }
+            if (types.length === 1) {
+                return types[0];
+            }
+            var typeSet = [];
+            addTypesToSet(typeSet, types, 16384 /* Union */);
+            if (typeSet.containsAny) {
+                return anyType;
+            }
+            if (strictNullChecks) {
+                if (typeSet.containsNull)
+                    typeSet.push(nullType);
+                if (typeSet.containsUndefined)
+                    typeSet.push(undefinedType);
+            }
+            if (!noSubtypeReduction) {
+                removeSubtypes(typeSet);
+            }
+            if (typeSet.length === 0) {
+                return typeSet.containsNull ? typeSet.containsNonWideningType ? nullType : nullWideningType :
+                    typeSet.containsUndefined ? typeSet.containsNonWideningType ? undefinedType : undefinedWideningType :
+                        neverType;
+            }
+            else if (typeSet.length === 1) {
+                return typeSet[0];
+            }
+            var id = getTypeListId(typeSet);
+            var type = unionTypes[id];
+            if (!type) {
+                var propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ 96 /* Nullable */);
+                type = unionTypes[id] = createObjectType(16384 /* Union */ | propagatedFlags);
+                type.types = typeSet;
+            }
+            return type;
+        }
+        function getTypeFromUnionTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
+            }
+            return links.resolvedType;
+        }
+        // We do not perform structural deduplication on intersection types. Intersection types are created only by the &
+        // type operator and we can't reduce those because we want to support recursive intersection types. For example,
+        // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
+        // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
+        // for intersections of types with signatures can be deterministic.
+        function getIntersectionType(types) {
+            if (types.length === 0) {
+                return emptyObjectType;
+            }
+            var typeSet = [];
+            addTypesToSet(typeSet, types, 32768 /* Intersection */);
+            if (typeSet.containsAny) {
+                return anyType;
+            }
+            if (strictNullChecks) {
+                if (typeSet.containsNull)
+                    typeSet.push(nullType);
+                if (typeSet.containsUndefined)
+                    typeSet.push(undefinedType);
+            }
+            if (typeSet.length === 1) {
+                return typeSet[0];
+            }
+            var id = getTypeListId(typeSet);
+            var type = intersectionTypes[id];
+            if (!type) {
+                var propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ 96 /* Nullable */);
+                type = intersectionTypes[id] = createObjectType(32768 /* Intersection */ | propagatedFlags);
+                type.types = typeSet;
+            }
+            return type;
+        }
+        function getTypeFromIntersectionTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode));
+            }
+            return links.resolvedType;
+        }
+        function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                // Deferred resolution of members is handled by resolveObjectTypeMembers
+                links.resolvedType = createObjectType(65536 /* Anonymous */, node.symbol);
+            }
+            return links.resolvedType;
+        }
+        function getStringLiteralTypeForText(text) {
+            if (ts.hasProperty(stringLiteralTypes, text)) {
+                return stringLiteralTypes[text];
+            }
+            var type = stringLiteralTypes[text] = createType(256 /* StringLiteral */);
+            type.text = text;
+            return type;
+        }
+        function getTypeFromStringLiteralTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = getStringLiteralTypeForText(ts.unescapeIdentifier(node.text));
+            }
+            return links.resolvedType;
+        }
+        function getTypeFromJSDocVariadicType(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                var type = getTypeFromTypeNode(node.type);
+                links.resolvedType = type ? createArrayType(type) : unknownType;
+            }
+            return links.resolvedType;
+        }
+        function getTypeFromJSDocTupleType(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                var types = ts.map(node.types, getTypeFromTypeNode);
+                links.resolvedType = createTupleType(types);
+            }
+            return links.resolvedType;
+        }
+        function getThisType(node) {
+            var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
+            var parent = container && container.parent;
+            if (parent && (ts.isClassLike(parent) || parent.kind === 222 /* InterfaceDeclaration */)) {
+                if (!(container.flags & 32 /* Static */) &&
+                    (container.kind !== 148 /* Constructor */ || ts.isNodeDescendentOf(node, container.body))) {
+                    return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
+                }
+            }
+            error(node, ts.Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
+            return unknownType;
+        }
+        function getTypeFromThisTypeNode(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = getThisType(node);
+            }
+            return links.resolvedType;
+        }
+        function getTypeFromTypeNode(node) {
+            switch (node.kind) {
+                case 117 /* AnyKeyword */:
+                case 258 /* JSDocAllType */:
+                case 259 /* JSDocUnknownType */:
+                    return anyType;
+                case 132 /* StringKeyword */:
+                    return stringType;
+                case 130 /* NumberKeyword */:
+                    return numberType;
+                case 120 /* BooleanKeyword */:
+                    return booleanType;
+                case 133 /* SymbolKeyword */:
+                    return esSymbolType;
+                case 103 /* VoidKeyword */:
+                    return voidType;
+                case 135 /* UndefinedKeyword */:
+                    return undefinedType;
+                case 93 /* NullKeyword */:
+                    return nullType;
+                case 127 /* NeverKeyword */:
+                    return neverType;
+                case 165 /* ThisType */:
+                case 97 /* ThisKeyword */:
+                    return getTypeFromThisTypeNode(node);
+                case 166 /* StringLiteralType */:
+                    return getTypeFromStringLiteralTypeNode(node);
+                case 155 /* TypeReference */:
+                case 267 /* JSDocTypeReference */:
+                    return getTypeFromTypeReference(node);
+                case 154 /* TypePredicate */:
+                    return booleanType;
+                case 194 /* ExpressionWithTypeArguments */:
+                    return getTypeFromTypeReference(node);
+                case 158 /* TypeQuery */:
+                    return getTypeFromTypeQueryNode(node);
+                case 160 /* ArrayType */:
+                case 260 /* JSDocArrayType */:
+                    return getTypeFromArrayTypeNode(node);
+                case 161 /* TupleType */:
+                    return getTypeFromTupleTypeNode(node);
+                case 162 /* UnionType */:
+                case 261 /* JSDocUnionType */:
+                    return getTypeFromUnionTypeNode(node);
+                case 163 /* IntersectionType */:
+                    return getTypeFromIntersectionTypeNode(node);
+                case 164 /* ParenthesizedType */:
+                case 263 /* JSDocNullableType */:
+                case 264 /* JSDocNonNullableType */:
+                case 271 /* JSDocConstructorType */:
+                case 272 /* JSDocThisType */:
+                case 268 /* JSDocOptionalType */:
+                    return getTypeFromTypeNode(node.type);
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                case 159 /* TypeLiteral */:
+                case 281 /* JSDocTypeLiteral */:
+                case 269 /* JSDocFunctionType */:
+                case 265 /* JSDocRecordType */:
+                    return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
+                // This function assumes that an identifier or qualified name is a type expression
+                // Callers should first ensure this by calling isTypeNode
+                case 69 /* Identifier */:
+                case 139 /* QualifiedName */:
+                    var symbol = getSymbolAtLocation(node);
+                    return symbol && getDeclaredTypeOfSymbol(symbol);
+                case 262 /* JSDocTupleType */:
+                    return getTypeFromJSDocTupleType(node);
+                case 270 /* JSDocVariadicType */:
+                    return getTypeFromJSDocVariadicType(node);
+                default:
+                    return unknownType;
+            }
+        }
+        function instantiateList(items, mapper, instantiator) {
+            if (items && items.length) {
+                var result = [];
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var v = items_1[_i];
+                    result.push(instantiator(v, mapper));
+                }
+                return result;
+            }
+            return items;
+        }
+        function createUnaryTypeMapper(source, target) {
+            return function (t) { return t === source ? target : t; };
+        }
+        function createBinaryTypeMapper(source1, target1, source2, target2) {
+            return function (t) { return t === source1 ? target1 : t === source2 ? target2 : t; };
+        }
+        function createArrayTypeMapper(sources, targets) {
+            return function (t) {
+                for (var i = 0; i < sources.length; i++) {
+                    if (t === sources[i]) {
+                        return targets ? targets[i] : anyType;
+                    }
+                }
+                return t;
+            };
+        }
+        function createTypeMapper(sources, targets) {
+            var count = sources.length;
+            var mapper = count == 1 ? createUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) :
+                count == 2 ? createBinaryTypeMapper(sources[0], targets ? targets[0] : anyType, sources[1], targets ? targets[1] : anyType) :
+                    createArrayTypeMapper(sources, targets);
+            mapper.mappedTypes = sources;
+            return mapper;
+        }
+        function createTypeEraser(sources) {
+            return createTypeMapper(sources, undefined);
+        }
+        function getInferenceMapper(context) {
+            if (!context.mapper) {
+                var mapper = function (t) {
+                    var typeParameters = context.typeParameters;
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        if (t === typeParameters[i]) {
+                            context.inferences[i].isFixed = true;
+                            return getInferredType(context, i);
+                        }
+                    }
+                    return t;
+                };
+                mapper.mappedTypes = context.typeParameters;
+                mapper.context = context;
+                context.mapper = mapper;
+            }
+            return context.mapper;
+        }
+        function identityMapper(type) {
+            return type;
+        }
+        function combineTypeMappers(mapper1, mapper2) {
+            var mapper = function (t) { return instantiateType(mapper1(t), mapper2); };
+            mapper.mappedTypes = mapper1.mappedTypes;
+            return mapper;
+        }
+        function cloneTypeParameter(typeParameter) {
+            var result = createType(512 /* TypeParameter */);
+            result.symbol = typeParameter.symbol;
+            result.target = typeParameter;
+            return result;
+        }
+        function cloneTypePredicate(predicate, mapper) {
+            if (ts.isIdentifierTypePredicate(predicate)) {
+                return {
+                    kind: 1 /* Identifier */,
+                    parameterName: predicate.parameterName,
+                    parameterIndex: predicate.parameterIndex,
+                    type: instantiateType(predicate.type, mapper)
+                };
+            }
+            else {
+                return {
+                    kind: 0 /* This */,
+                    type: instantiateType(predicate.type, mapper)
+                };
+            }
+        }
+        function instantiateSignature(signature, mapper, eraseTypeParameters) {
+            var freshTypeParameters;
+            var freshTypePredicate;
+            if (signature.typeParameters && !eraseTypeParameters) {
+                // First create a fresh set of type parameters, then include a mapping from the old to the
+                // new type parameters in the mapper function. Finally store this mapper in the new type
+                // parameters such that we can use it when instantiating constraints.
+                freshTypeParameters = ts.map(signature.typeParameters, cloneTypeParameter);
+                mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
+                for (var _i = 0, freshTypeParameters_1 = freshTypeParameters; _i < freshTypeParameters_1.length; _i++) {
+                    var tp = freshTypeParameters_1[_i];
+                    tp.mapper = mapper;
+                }
+            }
+            if (signature.typePredicate) {
+                freshTypePredicate = cloneTypePredicate(signature.typePredicate, mapper);
+            }
+            var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), instantiateType(signature.resolvedReturnType, mapper), freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals);
+            result.target = signature;
+            result.mapper = mapper;
+            return result;
+        }
+        function instantiateSymbol(symbol, mapper) {
+            if (symbol.flags & 16777216 /* Instantiated */) {
+                var links = getSymbolLinks(symbol);
+                // If symbol being instantiated is itself a instantiation, fetch the original target and combine the
+                // type mappers. This ensures that original type identities are properly preserved and that aliases
+                // always reference a non-aliases.
+                symbol = links.target;
+                mapper = combineTypeMappers(links.mapper, mapper);
+            }
+            // Keep the flags from the symbol we're instantiating.  Mark that is instantiated, and
+            // also transient so that we can just store data on it directly.
+            var result = createSymbol(16777216 /* Instantiated */ | 67108864 /* Transient */ | symbol.flags, symbol.name);
+            result.declarations = symbol.declarations;
+            result.parent = symbol.parent;
+            result.target = symbol;
+            result.mapper = mapper;
+            if (symbol.valueDeclaration) {
+                result.valueDeclaration = symbol.valueDeclaration;
+            }
+            return result;
+        }
+        function instantiateAnonymousType(type, mapper) {
+            if (mapper.instantiations) {
+                var cachedType = mapper.instantiations[type.id];
+                if (cachedType) {
+                    return cachedType;
+                }
+            }
+            else {
+                mapper.instantiations = [];
+            }
+            // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it
+            var result = createObjectType(65536 /* Anonymous */ | 131072 /* Instantiated */, type.symbol);
+            result.target = type;
+            result.mapper = mapper;
+            mapper.instantiations[type.id] = result;
+            return result;
+        }
+        function isSymbolInScopeOfMappedTypeParameter(symbol, mapper) {
+            var mappedTypes = mapper.mappedTypes;
+            // Starting with the parent of the symbol's declaration, check if the mapper maps any of
+            // the type parameters introduced by enclosing declarations. We just pick the first
+            // declaration since multiple declarations will all have the same parent anyway.
+            var node = symbol.declarations[0].parent;
+            while (node) {
+                switch (node.kind) {
+                    case 156 /* FunctionType */:
+                    case 157 /* ConstructorType */:
+                    case 220 /* FunctionDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 148 /* Constructor */:
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 153 /* IndexSignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                        var declaration = node;
+                        if (declaration.typeParameters) {
+                            for (var _i = 0, _a = declaration.typeParameters; _i < _a.length; _i++) {
+                                var d = _a[_i];
+                                if (ts.contains(mappedTypes, getDeclaredTypeOfTypeParameter(getSymbolOfNode(d)))) {
+                                    return true;
+                                }
+                            }
+                        }
+                        if (ts.isClassLike(node) || node.kind === 222 /* InterfaceDeclaration */) {
+                            var thisType = getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType;
+                            if (thisType && ts.contains(mappedTypes, thisType)) {
+                                return true;
+                            }
+                        }
+                        break;
+                    case 225 /* ModuleDeclaration */:
+                    case 256 /* SourceFile */:
+                        return false;
+                }
+                node = node.parent;
+            }
+            return false;
+        }
+        function instantiateType(type, mapper) {
+            if (type && mapper !== identityMapper) {
+                if (type.flags & 512 /* TypeParameter */) {
+                    return mapper(type);
+                }
+                if (type.flags & 65536 /* Anonymous */) {
+                    // If the anonymous type originates in a declaration of a function, method, class, or
+                    // interface, in an object type literal, or in an object literal expression, we may need
+                    // to instantiate the type because it might reference a type parameter. We skip instantiation
+                    // if none of the type parameters that are in scope in the type's declaration are mapped by
+                    // the given mapper, however we can only do that analysis if the type isn't itself an
+                    // instantiation.
+                    return type.symbol &&
+                        type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) &&
+                        (type.flags & 131072 /* Instantiated */ || isSymbolInScopeOfMappedTypeParameter(type.symbol, mapper)) ?
+                        instantiateAnonymousType(type, mapper) : type;
+                }
+                if (type.flags & 4096 /* Reference */) {
+                    return createTypeReference(type.target, instantiateList(type.typeArguments, mapper, instantiateType));
+                }
+                if (type.flags & 8192 /* Tuple */) {
+                    return createTupleType(instantiateList(type.elementTypes, mapper, instantiateType));
+                }
+                if (type.flags & 16384 /* Union */) {
+                    return getUnionType(instantiateList(type.types, mapper, instantiateType), /*noSubtypeReduction*/ true);
+                }
+                if (type.flags & 32768 /* Intersection */) {
+                    return getIntersectionType(instantiateList(type.types, mapper, instantiateType));
+                }
+            }
+            return type;
+        }
+        function instantiateIndexInfo(info, mapper) {
+            return info && createIndexInfo(instantiateType(info.type, mapper), info.isReadonly, info.declaration);
+        }
+        // Returns true if the given expression contains (at any level of nesting) a function or arrow expression
+        // that is subject to contextual typing.
+        function isContextSensitive(node) {
+            ts.Debug.assert(node.kind !== 147 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
+            switch (node.kind) {
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    return isContextSensitiveFunctionLikeDeclaration(node);
+                case 171 /* ObjectLiteralExpression */:
+                    return ts.forEach(node.properties, isContextSensitive);
+                case 170 /* ArrayLiteralExpression */:
+                    return ts.forEach(node.elements, isContextSensitive);
+                case 188 /* ConditionalExpression */:
+                    return isContextSensitive(node.whenTrue) ||
+                        isContextSensitive(node.whenFalse);
+                case 187 /* BinaryExpression */:
+                    return node.operatorToken.kind === 52 /* BarBarToken */ &&
+                        (isContextSensitive(node.left) || isContextSensitive(node.right));
+                case 253 /* PropertyAssignment */:
+                    return isContextSensitive(node.initializer);
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                    return isContextSensitiveFunctionLikeDeclaration(node);
+                case 178 /* ParenthesizedExpression */:
+                    return isContextSensitive(node.expression);
+            }
+            return false;
+        }
+        function isContextSensitiveFunctionLikeDeclaration(node) {
+            var areAllParametersUntyped = !ts.forEach(node.parameters, function (p) { return p.type; });
+            var isNullaryArrow = node.kind === 180 /* ArrowFunction */ && !node.parameters.length;
+            return !node.typeParameters && areAllParametersUntyped && !isNullaryArrow;
+        }
+        function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
+            return (isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);
+        }
+        function getTypeWithoutSignatures(type) {
+            if (type.flags & 80896 /* ObjectType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                if (resolved.constructSignatures.length) {
+                    var result = createObjectType(65536 /* Anonymous */, type.symbol);
+                    result.members = resolved.members;
+                    result.properties = resolved.properties;
+                    result.callSignatures = emptyArray;
+                    result.constructSignatures = emptyArray;
+                    type = result;
+                }
+            }
+            return type;
+        }
+        // TYPE CHECKING
+        function isTypeIdenticalTo(source, target) {
+            return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined);
+        }
+        function compareTypesIdentical(source, target) {
+            return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined) ? -1 /* True */ : 0 /* False */;
+        }
+        function compareTypesAssignable(source, target) {
+            return checkTypeRelatedTo(source, target, assignableRelation, /*errorNode*/ undefined) ? -1 /* True */ : 0 /* False */;
+        }
+        function isTypeSubtypeOf(source, target) {
+            return checkTypeSubtypeOf(source, target, /*errorNode*/ undefined);
+        }
+        function isTypeAssignableTo(source, target) {
+            return checkTypeAssignableTo(source, target, /*errorNode*/ undefined);
+        }
+        /**
+         * This is *not* a bi-directional relationship.
+         * If one needs to check both directions for comparability, use a second call to this function or 'checkTypeComparableTo'.
+         */
+        function isTypeComparableTo(source, target) {
+            return checkTypeComparableTo(source, target, /*errorNode*/ undefined);
+        }
+        function areTypesComparable(type1, type2) {
+            return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1);
+        }
+        function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) {
+            return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain);
+        }
+        function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain) {
+            return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain);
+        }
+        /**
+         * This is *not* a bi-directional relationship.
+         * If one needs to check both directions for comparability, use a second call to this function or 'isTypeComparableTo'.
+         */
+        function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) {
+            return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain);
+        }
+        function isSignatureAssignableTo(source, target, ignoreReturnTypes) {
+            return compareSignaturesRelated(source, target, ignoreReturnTypes, /*reportErrors*/ false, /*errorReporter*/ undefined, compareTypesAssignable) !== 0 /* False */;
+        }
+        /**
+         * See signatureRelatedTo, compareSignaturesIdentical
+         */
+        function compareSignaturesRelated(source, target, ignoreReturnTypes, reportErrors, errorReporter, compareTypes) {
+            // TODO (drosen): De-duplicate code between related functions.
+            if (source === target) {
+                return -1 /* True */;
+            }
+            if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) {
+                return 0 /* False */;
+            }
+            // Spec 1.0 Section 3.8.3 & 3.8.4:
+            // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
+            source = getErasedSignature(source);
+            target = getErasedSignature(target);
+            var result = -1 /* True */;
+            var sourceThisType = getThisTypeOfSignature(source);
+            if (sourceThisType && sourceThisType !== voidType) {
+                var targetThisType = getThisTypeOfSignature(target);
+                if (targetThisType) {
+                    // void sources are assignable to anything.
+                    var related = compareTypes(sourceThisType, targetThisType, /*reportErrors*/ false)
+                        || compareTypes(targetThisType, sourceThisType, reportErrors);
+                    if (!related) {
+                        if (reportErrors) {
+                            errorReporter(ts.Diagnostics.The_this_types_of_each_signature_are_incompatible);
+                        }
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+            }
+            var sourceMax = getNumNonRestParameters(source);
+            var targetMax = getNumNonRestParameters(target);
+            var checkCount = getNumParametersToCheckForSignatureRelatability(source, sourceMax, target, targetMax);
+            var sourceParams = source.parameters;
+            var targetParams = target.parameters;
+            for (var i = 0; i < checkCount; i++) {
+                var s = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source);
+                var t = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target);
+                var related = compareTypes(s, t, /*reportErrors*/ false) || compareTypes(t, s, reportErrors);
+                if (!related) {
+                    if (reportErrors) {
+                        errorReporter(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, sourceParams[i < sourceMax ? i : sourceMax].name, targetParams[i < targetMax ? i : targetMax].name);
+                    }
+                    return 0 /* False */;
+                }
+                result &= related;
+            }
+            if (!ignoreReturnTypes) {
+                var targetReturnType = getReturnTypeOfSignature(target);
+                if (targetReturnType === voidType) {
+                    return result;
+                }
+                var sourceReturnType = getReturnTypeOfSignature(source);
+                // The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions
+                if (target.typePredicate) {
+                    if (source.typePredicate) {
+                        result &= compareTypePredicateRelatedTo(source.typePredicate, target.typePredicate, reportErrors, errorReporter, compareTypes);
+                    }
+                    else if (ts.isIdentifierTypePredicate(target.typePredicate)) {
+                        if (reportErrors) {
+                            errorReporter(ts.Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source));
+                        }
+                        return 0 /* False */;
+                    }
+                }
+                else {
+                    result &= compareTypes(sourceReturnType, targetReturnType, reportErrors);
+                }
+            }
+            return result;
+        }
+        function compareTypePredicateRelatedTo(source, target, reportErrors, errorReporter, compareTypes) {
+            if (source.kind !== target.kind) {
+                if (reportErrors) {
+                    errorReporter(ts.Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
+                    errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+                }
+                return 0 /* False */;
+            }
+            if (source.kind === 1 /* Identifier */) {
+                var sourceIdentifierPredicate = source;
+                var targetIdentifierPredicate = target;
+                if (sourceIdentifierPredicate.parameterIndex !== targetIdentifierPredicate.parameterIndex) {
+                    if (reportErrors) {
+                        errorReporter(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceIdentifierPredicate.parameterName, targetIdentifierPredicate.parameterName);
+                        errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+                    }
+                    return 0 /* False */;
+                }
+            }
+            var related = compareTypes(source.type, target.type, reportErrors);
+            if (related === 0 /* False */ && reportErrors) {
+                errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+            }
+            return related;
+        }
+        function isImplementationCompatibleWithOverload(implementation, overload) {
+            var erasedSource = getErasedSignature(implementation);
+            var erasedTarget = getErasedSignature(overload);
+            // First see if the return types are compatible in either direction.
+            var sourceReturnType = getReturnTypeOfSignature(erasedSource);
+            var targetReturnType = getReturnTypeOfSignature(erasedTarget);
+            if (targetReturnType === voidType
+                || checkTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation, /*errorNode*/ undefined)
+                || checkTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation, /*errorNode*/ undefined)) {
+                return isSignatureAssignableTo(erasedSource, erasedTarget, /*ignoreReturnTypes*/ true);
+            }
+            return false;
+        }
+        function getNumNonRestParameters(signature) {
+            var numParams = signature.parameters.length;
+            return signature.hasRestParameter ?
+                numParams - 1 :
+                numParams;
+        }
+        function getNumParametersToCheckForSignatureRelatability(source, sourceNonRestParamCount, target, targetNonRestParamCount) {
+            if (source.hasRestParameter === target.hasRestParameter) {
+                if (source.hasRestParameter) {
+                    // If both have rest parameters, get the max and add 1 to
+                    // compensate for the rest parameter.
+                    return Math.max(sourceNonRestParamCount, targetNonRestParamCount) + 1;
+                }
+                else {
+                    return Math.min(sourceNonRestParamCount, targetNonRestParamCount);
+                }
+            }
+            else {
+                // Return the count for whichever signature doesn't have rest parameters.
+                return source.hasRestParameter ?
+                    targetNonRestParamCount :
+                    sourceNonRestParamCount;
+            }
+        }
+        /**
+         * Checks if 'source' is related to 'target' (e.g.: is a assignable to).
+         * @param source The left-hand-side of the relation.
+         * @param target The right-hand-side of the relation.
+         * @param relation The relation considered. One of 'identityRelation', 'subtypeRelation', 'assignableRelation', or 'comparableRelation'.
+         * Used as both to determine which checks are performed and as a cache of previously computed results.
+         * @param errorNode The suggested node upon which all errors will be reported, if defined. This may or may not be the actual node used.
+         * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used.
+         * @param containingMessageChain A chain of errors to prepend any new errors found.
+         */
+        function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain) {
+            var errorInfo;
+            var sourceStack;
+            var targetStack;
+            var maybeStack;
+            var expandingFlags;
+            var depth = 0;
+            var overflow = false;
+            ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
+            var result = isRelatedTo(source, target, /*reportErrors*/ !!errorNode, headMessage);
+            if (overflow) {
+                error(errorNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
+            }
+            else if (errorInfo) {
+                if (containingMessageChain) {
+                    errorInfo = ts.concatenateDiagnosticMessageChains(containingMessageChain, errorInfo);
+                }
+                diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo));
+            }
+            return result !== 0 /* False */;
+            function reportError(message, arg0, arg1, arg2) {
+                ts.Debug.assert(!!errorNode);
+                errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
+            }
+            function reportRelationError(message, source, target) {
+                var sourceType = typeToString(source);
+                var targetType = typeToString(target);
+                if (sourceType === targetType) {
+                    sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, 128 /* UseFullyQualifiedType */);
+                    targetType = typeToString(target, /*enclosingDeclaration*/ undefined, 128 /* UseFullyQualifiedType */);
+                }
+                if (!message) {
+                    message = relation === comparableRelation ?
+                        ts.Diagnostics.Type_0_is_not_comparable_to_type_1 :
+                        ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
+                }
+                reportError(message, sourceType, targetType);
+            }
+            // Compare two types and return
+            // Ternary.True if they are related with no assumptions,
+            // Ternary.Maybe if they are related with assumptions of other relationships, or
+            // Ternary.False if they are not related.
+            function isRelatedTo(source, target, reportErrors, headMessage) {
+                var result;
+                // both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases
+                if (source === target)
+                    return -1 /* True */;
+                if (relation === identityRelation) {
+                    return isIdenticalTo(source, target);
+                }
+                if (!(target.flags & 134217728 /* Never */)) {
+                    if (target.flags & 1 /* Any */ || source.flags & 134217728 /* Never */)
+                        return -1 /* True */;
+                    if (source.flags & 32 /* Undefined */) {
+                        if (!strictNullChecks || target.flags & (32 /* Undefined */ | 16 /* Void */))
+                            return -1 /* True */;
+                    }
+                    if (source.flags & 64 /* Null */) {
+                        if (!strictNullChecks || target.flags & 64 /* Null */)
+                            return -1 /* True */;
+                    }
+                    if (source.flags & 128 /* Enum */ && target === numberType)
+                        return -1 /* True */;
+                    if (source.flags & 128 /* Enum */ && target.flags & 128 /* Enum */) {
+                        if (result = enumRelatedTo(source, target, reportErrors)) {
+                            return result;
+                        }
+                    }
+                    if (source.flags & 256 /* StringLiteral */ && target === stringType)
+                        return -1 /* True */;
+                    if (relation === assignableRelation || relation === comparableRelation) {
+                        if (source.flags & 1 /* Any */)
+                            return -1 /* True */;
+                        if (source === numberType && target.flags & 128 /* Enum */)
+                            return -1 /* True */;
+                    }
+                    if (source.flags & 8 /* Boolean */ && target.flags & 8 /* Boolean */) {
+                        return -1 /* True */;
+                    }
+                }
+                if (source.flags & 1048576 /* FreshObjectLiteral */) {
+                    if (hasExcessProperties(source, target, reportErrors)) {
+                        if (reportErrors) {
+                            reportRelationError(headMessage, source, target);
+                        }
+                        return 0 /* False */;
+                    }
+                    // Above we check for excess properties with respect to the entire target type. When union
+                    // and intersection types are further deconstructed on the target side, we don't want to
+                    // make the check again (as it might fail for a partial target type). Therefore we obtain
+                    // the regular source type and proceed with that.
+                    if (target.flags & 49152 /* UnionOrIntersection */) {
+                        source = getRegularTypeOfObjectLiteral(source);
+                    }
+                }
+                var saveErrorInfo = errorInfo;
+                // Note that these checks are specifically ordered to produce correct results.
+                if (source.flags & 16384 /* Union */) {
+                    if (relation === comparableRelation) {
+                        result = someTypeRelatedToType(source, target, reportErrors);
+                    }
+                    else {
+                        result = eachTypeRelatedToType(source, target, reportErrors);
+                    }
+                    if (result) {
+                        return result;
+                    }
+                }
+                else if (target.flags & 32768 /* Intersection */) {
+                    result = typeRelatedToEachType(source, target, reportErrors);
+                    if (result) {
+                        return result;
+                    }
+                }
+                else {
+                    // It is necessary to try these "some" checks on both sides because there may be nested "each" checks
+                    // on either side that need to be prioritized. For example, A | B = (A | B) & (C | D) or
+                    // A & B = (A & B) | (C & D).
+                    if (source.flags & 32768 /* Intersection */) {
+                        // Check to see if any constituents of the intersection are immediately related to the target.
+                        //
+                        // Don't report errors though. Checking whether a constituent is related to the source is not actually
+                        // useful and leads to some confusing error messages. Instead it is better to let the below checks
+                        // take care of this, or to not elaborate at all. For instance,
+                        //
+                        //    - For an object type (such as 'C = A & B'), users are usually more interested in structural errors.
+                        //
+                        //    - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection
+                        //          than to report that 'D' is not assignable to 'A' or 'B'.
+                        //
+                        //    - For a primitive type or type parameter (such as 'number = A & B') there is no point in
+                        //          breaking the intersection apart.
+                        if (result = someTypeRelatedToType(source, target, /*reportErrors*/ false)) {
+                            return result;
+                        }
+                    }
+                    if (target.flags & 16384 /* Union */) {
+                        if (result = typeRelatedToSomeType(source, target, reportErrors && !(source.flags & 16777726 /* Primitive */))) {
+                            return result;
+                        }
+                    }
+                }
+                if (source.flags & 512 /* TypeParameter */) {
+                    var constraint = getConstraintOfTypeParameter(source);
+                    if (!constraint || constraint.flags & 1 /* Any */) {
+                        constraint = emptyObjectType;
+                    }
+                    // The constraint may need to be further instantiated with its 'this' type.
+                    constraint = getTypeWithThisArgument(constraint, source);
+                    // Report constraint errors only if the constraint is not the empty object type
+                    var reportConstraintErrors = reportErrors && constraint !== emptyObjectType;
+                    if (result = isRelatedTo(constraint, target, reportConstraintErrors)) {
+                        errorInfo = saveErrorInfo;
+                        return result;
+                    }
+                }
+                else {
+                    if (source.flags & 4096 /* Reference */ && target.flags & 4096 /* Reference */ && source.target === target.target) {
+                        // We have type references to same target type, see if relationship holds for all type arguments
+                        if (result = typeArgumentsRelatedTo(source, target, reportErrors)) {
+                            return result;
+                        }
+                    }
+                    // Even if relationship doesn't hold for unions, intersections, or generic type references,
+                    // it may hold in a structural comparison.
+                    var apparentSource = getApparentType(source);
+                    // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates
+                    // to X. Failing both of those we want to check if the aggregation of A and B's members structurally
+                    // relates to X. Thus, we include intersection types on the source side here.
+                    if (apparentSource.flags & (80896 /* ObjectType */ | 32768 /* Intersection */) && target.flags & 80896 /* ObjectType */) {
+                        // Report structural errors only if we haven't reported any errors yet
+                        var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo && !(source.flags & 16777726 /* Primitive */);
+                        if (result = objectTypeRelatedTo(apparentSource, source, target, reportStructuralErrors)) {
+                            errorInfo = saveErrorInfo;
+                            return result;
+                        }
+                    }
+                }
+                if (reportErrors) {
+                    reportRelationError(headMessage, source, target);
+                }
+                return 0 /* False */;
+            }
+            function isIdenticalTo(source, target) {
+                var result;
+                if (source.flags & 80896 /* ObjectType */ && target.flags & 80896 /* ObjectType */) {
+                    if (source.flags & 4096 /* Reference */ && target.flags & 4096 /* Reference */ && source.target === target.target) {
+                        // We have type references to same target type, see if all type arguments are identical
+                        if (result = typeArgumentsRelatedTo(source, target, /*reportErrors*/ false)) {
+                            return result;
+                        }
+                    }
+                    return objectTypeRelatedTo(source, source, target, /*reportErrors*/ false);
+                }
+                if (source.flags & 16384 /* Union */ && target.flags & 16384 /* Union */ ||
+                    source.flags & 32768 /* Intersection */ && target.flags & 32768 /* Intersection */) {
+                    if (result = eachTypeRelatedToSomeType(source, target, /*reportErrors*/ false)) {
+                        if (result &= eachTypeRelatedToSomeType(target, source, /*reportErrors*/ false)) {
+                            return result;
+                        }
+                    }
+                }
+                return 0 /* False */;
+            }
+            // Check if a property with the given name is known anywhere in the given type. In an object type, a property
+            // is considered known if the object type is empty and the check is for assignability, if the object type has
+            // index signatures, or if the property is actually declared in the object type. In a union or intersection
+            // type, a property is considered known if it is known in any constituent type.
+            function isKnownProperty(type, name) {
+                if (type.flags & 80896 /* ObjectType */) {
+                    var resolved = resolveStructuredTypeMembers(type);
+                    if ((relation === assignableRelation || relation === comparableRelation) && (type === globalObjectType || isEmptyObjectType(resolved)) ||
+                        resolved.stringIndexInfo ||
+                        (resolved.numberIndexInfo && isNumericLiteralName(name)) ||
+                        getPropertyOfType(type, name)) {
+                        return true;
+                    }
+                }
+                else if (type.flags & 49152 /* UnionOrIntersection */) {
+                    for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                        var t = _a[_i];
+                        if (isKnownProperty(t, name)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            function isEmptyObjectType(t) {
+                return t.properties.length === 0 &&
+                    t.callSignatures.length === 0 &&
+                    t.constructSignatures.length === 0 &&
+                    !t.stringIndexInfo &&
+                    !t.numberIndexInfo;
+            }
+            function hasExcessProperties(source, target, reportErrors) {
+                if (!(target.flags & 67108864 /* ObjectLiteralPatternWithComputedProperties */) && maybeTypeOfKind(target, 80896 /* ObjectType */)) {
+                    for (var _i = 0, _a = getPropertiesOfObjectType(source); _i < _a.length; _i++) {
+                        var prop = _a[_i];
+                        if (!isKnownProperty(target, prop.name)) {
+                            if (reportErrors) {
+                                // We know *exactly* where things went wrong when comparing the types.
+                                // Use this property as the error node as this will be more helpful in
+                                // reasoning about what went wrong.
+                                ts.Debug.assert(!!errorNode);
+                                errorNode = prop.valueDeclaration;
+                                reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target));
+                            }
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            function eachTypeRelatedToSomeType(source, target, reportErrors) {
+                var result = -1 /* True */;
+                var sourceTypes = source.types;
+                for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+                    var sourceType = sourceTypes_1[_i];
+                    var related = typeRelatedToSomeType(sourceType, target, /*reportErrors*/ false);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            function typeRelatedToSomeType(source, target, reportErrors) {
+                var targetTypes = target.types;
+                var len = targetTypes.length;
+                // The null and undefined types are guaranteed to be at the end of the constituent type list. In order
+                // to produce the best possible errors we first check the nullable types, such that the last type we
+                // check and report errors from is a non-nullable type if one is present.
+                while (len >= 2 && targetTypes[len - 1].flags & 96 /* Nullable */) {
+                    var related = isRelatedTo(source, targetTypes[len - 1], /*reportErrors*/ false);
+                    if (related) {
+                        return related;
+                    }
+                    len--;
+                }
+                // Now check the non-nullable types and report errors on the last one.
+                for (var i = 0; i < len; i++) {
+                    var related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1);
+                    if (related) {
+                        return related;
+                    }
+                }
+                return 0 /* False */;
+            }
+            function typeRelatedToEachType(source, target, reportErrors) {
+                var result = -1 /* True */;
+                var targetTypes = target.types;
+                for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+                    var targetType = targetTypes_1[_i];
+                    var related = isRelatedTo(source, targetType, reportErrors);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            function someTypeRelatedToType(source, target, reportErrors) {
+                var sourceTypes = source.types;
+                var len = sourceTypes.length;
+                // The null and undefined types are guaranteed to be at the end of the constituent type list. In order
+                // to produce the best possible errors we first check the nullable types, such that the last type we
+                // check and report errors from is a non-nullable type if one is present.
+                while (len >= 2 && sourceTypes[len - 1].flags & 96 /* Nullable */) {
+                    var related = isRelatedTo(sourceTypes[len - 1], target, /*reportErrors*/ false);
+                    if (related) {
+                        return related;
+                    }
+                    len--;
+                }
+                // Now check the non-nullable types and report errors on the last one.
+                for (var i = 0; i < len; i++) {
+                    var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1);
+                    if (related) {
+                        return related;
+                    }
+                }
+                return 0 /* False */;
+            }
+            function eachTypeRelatedToType(source, target, reportErrors) {
+                var result = -1 /* True */;
+                var sourceTypes = source.types;
+                for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) {
+                    var sourceType = sourceTypes_2[_i];
+                    var related = isRelatedTo(sourceType, target, reportErrors);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            function typeArgumentsRelatedTo(source, target, reportErrors) {
+                var sources = source.typeArguments || emptyArray;
+                var targets = target.typeArguments || emptyArray;
+                if (sources.length !== targets.length && relation === identityRelation) {
+                    return 0 /* False */;
+                }
+                var length = sources.length <= targets.length ? sources.length : targets.length;
+                var result = -1 /* True */;
+                for (var i = 0; i < length; i++) {
+                    var related = isRelatedTo(sources[i], targets[i], reportErrors);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            // Determine if two object types are related by structure. First, check if the result is already available in the global cache.
+            // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true.
+            // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are
+            // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion
+            // and issue an error. Otherwise, actually compare the structure of the two types.
+            function objectTypeRelatedTo(source, originalSource, target, reportErrors) {
+                if (overflow) {
+                    return 0 /* False */;
+                }
+                var id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
+                var related = relation[id];
+                if (related !== undefined) {
+                    if (reportErrors && related === 2 /* Failed */) {
+                        // We are elaborating errors and the cached result is an unreported failure. Record the result as a reported
+                        // failure and continue computing the relation such that errors get reported.
+                        relation[id] = 3 /* FailedAndReported */;
+                    }
+                    else {
+                        return related === 1 /* Succeeded */ ? -1 /* True */ : 0 /* False */;
+                    }
+                }
+                if (depth > 0) {
+                    for (var i = 0; i < depth; i++) {
+                        // If source and target are already being compared, consider them related with assumptions
+                        if (maybeStack[i][id]) {
+                            return 1 /* Maybe */;
+                        }
+                    }
+                    if (depth === 100) {
+                        overflow = true;
+                        return 0 /* False */;
+                    }
+                }
+                else {
+                    sourceStack = [];
+                    targetStack = [];
+                    maybeStack = [];
+                    expandingFlags = 0;
+                }
+                sourceStack[depth] = source;
+                targetStack[depth] = target;
+                maybeStack[depth] = {};
+                maybeStack[depth][id] = 1 /* Succeeded */;
+                depth++;
+                var saveExpandingFlags = expandingFlags;
+                if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth))
+                    expandingFlags |= 1;
+                if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth))
+                    expandingFlags |= 2;
+                var result;
+                if (expandingFlags === 3) {
+                    result = 1 /* Maybe */;
+                }
+                else {
+                    result = propertiesRelatedTo(source, target, reportErrors);
+                    if (result) {
+                        result &= signaturesRelatedTo(source, target, 0 /* Call */, reportErrors);
+                        if (result) {
+                            result &= signaturesRelatedTo(source, target, 1 /* Construct */, reportErrors);
+                            if (result) {
+                                result &= indexTypesRelatedTo(source, originalSource, target, 0 /* String */, reportErrors);
+                                if (result) {
+                                    result &= indexTypesRelatedTo(source, originalSource, target, 1 /* Number */, reportErrors);
+                                }
+                            }
+                        }
+                    }
+                }
+                expandingFlags = saveExpandingFlags;
+                depth--;
+                if (result) {
+                    var maybeCache = maybeStack[depth];
+                    // If result is definitely true, copy assumptions to global cache, else copy to next level up
+                    var destinationCache = (result === -1 /* True */ || depth === 0) ? relation : maybeStack[depth - 1];
+                    ts.copyMap(maybeCache, destinationCache);
+                }
+                else {
+                    // A false result goes straight into global cache (when something is false under assumptions it
+                    // will also be false without assumptions)
+                    relation[id] = reportErrors ? 3 /* FailedAndReported */ : 2 /* Failed */;
+                }
+                return result;
+            }
+            function propertiesRelatedTo(source, target, reportErrors) {
+                if (relation === identityRelation) {
+                    return propertiesIdenticalTo(source, target);
+                }
+                var result = -1 /* True */;
+                var properties = getPropertiesOfObjectType(target);
+                var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 524288 /* ObjectLiteral */);
+                for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                    var targetProp = properties_1[_i];
+                    var sourceProp = getPropertyOfType(source, targetProp.name);
+                    if (sourceProp !== targetProp) {
+                        if (!sourceProp) {
+                            if (!(targetProp.flags & 536870912 /* Optional */) || requireOptionalProperties) {
+                                if (reportErrors) {
+                                    reportError(ts.Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source));
+                                }
+                                return 0 /* False */;
+                            }
+                        }
+                        else if (!(targetProp.flags & 134217728 /* Prototype */)) {
+                            var sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
+                            var targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
+                            if (sourcePropFlags & 8 /* Private */ || targetPropFlags & 8 /* Private */) {
+                                if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
+                                    if (reportErrors) {
+                                        if (sourcePropFlags & 8 /* Private */ && targetPropFlags & 8 /* Private */) {
+                                            reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
+                                        }
+                                        else {
+                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 /* Private */ ? source : target), typeToString(sourcePropFlags & 8 /* Private */ ? target : source));
+                                        }
+                                    }
+                                    return 0 /* False */;
+                                }
+                            }
+                            else if (targetPropFlags & 16 /* Protected */) {
+                                var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32 /* Class */;
+                                var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(getParentOfSymbol(sourceProp)) : undefined;
+                                var targetClass = getDeclaredTypeOfSymbol(getParentOfSymbol(targetProp));
+                                if (!sourceClass || !hasBaseType(sourceClass, targetClass)) {
+                                    if (reportErrors) {
+                                        reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(sourceClass || source), typeToString(targetClass));
+                                    }
+                                    return 0 /* False */;
+                                }
+                            }
+                            else if (sourcePropFlags & 16 /* Protected */) {
+                                if (reportErrors) {
+                                    reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
+                                }
+                                return 0 /* False */;
+                            }
+                            var related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
+                            if (!related) {
+                                if (reportErrors) {
+                                    reportError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
+                                }
+                                return 0 /* False */;
+                            }
+                            result &= related;
+                            if (sourceProp.flags & 536870912 /* Optional */ && !(targetProp.flags & 536870912 /* Optional */)) {
+                                // TypeScript 1.0 spec (April 2014): 3.8.3
+                                // S is a subtype of a type T, and T is a supertype of S if ...
+                                // S' and T are object types and, for each member M in T..
+                                // M is a property and S' contains a property N where
+                                // if M is a required property, N is also a required property
+                                // (M - property in T)
+                                // (N - property in S)
+                                if (reportErrors) {
+                                    reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
+                                }
+                                return 0 /* False */;
+                            }
+                        }
+                    }
+                }
+                return result;
+            }
+            function propertiesIdenticalTo(source, target) {
+                if (!(source.flags & 80896 /* ObjectType */ && target.flags & 80896 /* ObjectType */)) {
+                    return 0 /* False */;
+                }
+                var sourceProperties = getPropertiesOfObjectType(source);
+                var targetProperties = getPropertiesOfObjectType(target);
+                if (sourceProperties.length !== targetProperties.length) {
+                    return 0 /* False */;
+                }
+                var result = -1 /* True */;
+                for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+                    var sourceProp = sourceProperties_1[_i];
+                    var targetProp = getPropertyOfObjectType(target, sourceProp.name);
+                    if (!targetProp) {
+                        return 0 /* False */;
+                    }
+                    var related = compareProperties(sourceProp, targetProp, isRelatedTo);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            function signaturesRelatedTo(source, target, kind, reportErrors) {
+                if (relation === identityRelation) {
+                    return signaturesIdenticalTo(source, target, kind);
+                }
+                if (target === anyFunctionType || source === anyFunctionType) {
+                    return -1 /* True */;
+                }
+                var sourceSignatures = getSignaturesOfType(source, kind);
+                var targetSignatures = getSignaturesOfType(target, kind);
+                if (kind === 1 /* Construct */ && sourceSignatures.length && targetSignatures.length) {
+                    if (isAbstractConstructorType(source) && !isAbstractConstructorType(target)) {
+                        // An abstract constructor type is not assignable to a non-abstract constructor type
+                        // as it would otherwise be possible to new an abstract class. Note that the assignability
+                        // check we perform for an extends clause excludes construct signatures from the target,
+                        // so this check never proceeds.
+                        if (reportErrors) {
+                            reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
+                        }
+                        return 0 /* False */;
+                    }
+                    if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors)) {
+                        return 0 /* False */;
+                    }
+                }
+                var result = -1 /* True */;
+                var saveErrorInfo = errorInfo;
+                outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+                    var t = targetSignatures_1[_i];
+                    // Only elaborate errors from the first failure
+                    var shouldElaborateErrors = reportErrors;
+                    for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
+                        var s = sourceSignatures_1[_a];
+                        var related = signatureRelatedTo(s, t, shouldElaborateErrors);
+                        if (related) {
+                            result &= related;
+                            errorInfo = saveErrorInfo;
+                            continue outer;
+                        }
+                        shouldElaborateErrors = false;
+                    }
+                    if (shouldElaborateErrors) {
+                        reportError(ts.Diagnostics.Type_0_provides_no_match_for_the_signature_1, typeToString(source), signatureToString(t, /*enclosingDeclaration*/ undefined, /*flags*/ undefined, kind));
+                    }
+                    return 0 /* False */;
+                }
+                return result;
+            }
+            /**
+             * See signatureAssignableTo, compareSignaturesIdentical
+             */
+            function signatureRelatedTo(source, target, reportErrors) {
+                return compareSignaturesRelated(source, target, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
+            }
+            function signaturesIdenticalTo(source, target, kind) {
+                var sourceSignatures = getSignaturesOfType(source, kind);
+                var targetSignatures = getSignaturesOfType(target, kind);
+                if (sourceSignatures.length !== targetSignatures.length) {
+                    return 0 /* False */;
+                }
+                var result = -1 /* True */;
+                for (var i = 0, len = sourceSignatures.length; i < len; i++) {
+                    var related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false, isRelatedTo);
+                    if (!related) {
+                        return 0 /* False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            function eachPropertyRelatedTo(source, target, kind, reportErrors) {
+                var result = -1 /* True */;
+                for (var _i = 0, _a = getPropertiesOfObjectType(source); _i < _a.length; _i++) {
+                    var prop = _a[_i];
+                    if (kind === 0 /* String */ || isNumericLiteralName(prop.name)) {
+                        var related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors);
+                        if (!related) {
+                            if (reportErrors) {
+                                reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
+                            }
+                            return 0 /* False */;
+                        }
+                        result &= related;
+                    }
+                }
+                return result;
+            }
+            function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors) {
+                var related = isRelatedTo(sourceInfo.type, targetInfo.type, reportErrors);
+                if (!related && reportErrors) {
+                    reportError(ts.Diagnostics.Index_signatures_are_incompatible);
+                }
+                return related;
+            }
+            function indexTypesRelatedTo(source, originalSource, target, kind, reportErrors) {
+                if (relation === identityRelation) {
+                    return indexTypesIdenticalTo(source, target, kind);
+                }
+                var targetInfo = getIndexInfoOfType(target, kind);
+                if (!targetInfo || ((targetInfo.type.flags & 1 /* Any */) && !(originalSource.flags & 16777726 /* Primitive */))) {
+                    // Index signature of type any permits assignment from everything but primitives
+                    return -1 /* True */;
+                }
+                var sourceInfo = getIndexInfoOfType(source, kind) ||
+                    kind === 1 /* Number */ && getIndexInfoOfType(source, 0 /* String */);
+                if (sourceInfo) {
+                    return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors);
+                }
+                if (isObjectLiteralType(source)) {
+                    var related = -1 /* True */;
+                    if (kind === 0 /* String */) {
+                        var sourceNumberInfo = getIndexInfoOfType(source, 1 /* Number */);
+                        if (sourceNumberInfo) {
+                            related = indexInfoRelatedTo(sourceNumberInfo, targetInfo, reportErrors);
+                        }
+                    }
+                    if (related) {
+                        related &= eachPropertyRelatedTo(source, targetInfo.type, kind, reportErrors);
+                    }
+                    return related;
+                }
+                if (reportErrors) {
+                    reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
+                }
+                return 0 /* False */;
+            }
+            function indexTypesIdenticalTo(source, target, indexKind) {
+                var targetInfo = getIndexInfoOfType(target, indexKind);
+                var sourceInfo = getIndexInfoOfType(source, indexKind);
+                if (!sourceInfo && !targetInfo) {
+                    return -1 /* True */;
+                }
+                if (sourceInfo && targetInfo && sourceInfo.isReadonly === targetInfo.isReadonly) {
+                    return isRelatedTo(sourceInfo.type, targetInfo.type);
+                }
+                return 0 /* False */;
+            }
+            function enumRelatedTo(source, target, reportErrors) {
+                if (source.symbol.name !== target.symbol.name ||
+                    source.symbol.flags & 128 /* ConstEnum */ ||
+                    target.symbol.flags & 128 /* ConstEnum */) {
+                    return 0 /* False */;
+                }
+                var targetEnumType = getTypeOfSymbol(target.symbol);
+                for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(source.symbol)); _i < _a.length; _i++) {
+                    var property = _a[_i];
+                    if (property.flags & 8 /* EnumMember */) {
+                        var targetProperty = getPropertyOfType(targetEnumType, property.name);
+                        if (!targetProperty || !(targetProperty.flags & 8 /* EnumMember */)) {
+                            if (reportErrors) {
+                                reportError(ts.Diagnostics.Property_0_is_missing_in_type_1, property.name, typeToString(target, /*enclosingDeclaration*/ undefined, 128 /* UseFullyQualifiedType */));
+                            }
+                            return 0 /* False */;
+                        }
+                    }
+                }
+                return -1 /* True */;
+            }
+            function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) {
+                if (!sourceSignature.declaration || !targetSignature.declaration) {
+                    return true;
+                }
+                var sourceAccessibility = sourceSignature.declaration.flags & (8 /* Private */ | 16 /* Protected */);
+                var targetAccessibility = targetSignature.declaration.flags & (8 /* Private */ | 16 /* Protected */);
+                // A public, protected and private signature is assignable to a private signature.
+                if (targetAccessibility === 8 /* Private */) {
+                    return true;
+                }
+                // A public and protected signature is assignable to a protected signature.
+                if (targetAccessibility === 16 /* Protected */ && sourceAccessibility !== 8 /* Private */) {
+                    return true;
+                }
+                // Only a public signature is assignable to public signature.
+                if (targetAccessibility !== 16 /* Protected */ && !sourceAccessibility) {
+                    return true;
+                }
+                if (reportErrors) {
+                    reportError(ts.Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility));
+                }
+                return false;
+            }
+        }
+        // Return true if the given type is the constructor type for an abstract class
+        function isAbstractConstructorType(type) {
+            if (type.flags & 65536 /* Anonymous */) {
+                var symbol = type.symbol;
+                if (symbol && symbol.flags & 32 /* Class */) {
+                    var declaration = getClassLikeDeclarationOfSymbol(symbol);
+                    if (declaration && declaration.flags & 128 /* Abstract */) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case
+        // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible,
+        // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding.
+        // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at
+        // some level beyond that.
+        function isDeeplyNestedGeneric(type, stack, depth) {
+            // We track type references (created by createTypeReference) and instantiated types (created by instantiateType)
+            if (type.flags & (4096 /* Reference */ | 131072 /* Instantiated */) && depth >= 5) {
+                var symbol = type.symbol;
+                var count = 0;
+                for (var i = 0; i < depth; i++) {
+                    var t = stack[i];
+                    if (t.flags & (4096 /* Reference */ | 131072 /* Instantiated */) && t.symbol === symbol) {
+                        count++;
+                        if (count >= 5)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function isPropertyIdenticalTo(sourceProp, targetProp) {
+            return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
+        }
+        function compareProperties(sourceProp, targetProp, compareTypes) {
+            // Two members are considered identical when
+            // - they are public properties with identical names, optionality, and types,
+            // - they are private or protected properties originating in the same declaration and having identical types
+            if (sourceProp === targetProp) {
+                return -1 /* True */;
+            }
+            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (8 /* Private */ | 16 /* Protected */);
+            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (8 /* Private */ | 16 /* Protected */);
+            if (sourcePropAccessibility !== targetPropAccessibility) {
+                return 0 /* False */;
+            }
+            if (sourcePropAccessibility) {
+                if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) {
+                    return 0 /* False */;
+                }
+            }
+            else {
+                if ((sourceProp.flags & 536870912 /* Optional */) !== (targetProp.flags & 536870912 /* Optional */)) {
+                    return 0 /* False */;
+                }
+            }
+            if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
+                return 0 /* False */;
+            }
+            return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+        }
+        function isMatchingSignature(source, target, partialMatch) {
+            // A source signature matches a target signature if the two signatures have the same number of required,
+            // optional, and rest parameters.
+            if (source.parameters.length === target.parameters.length &&
+                source.minArgumentCount === target.minArgumentCount &&
+                source.hasRestParameter === target.hasRestParameter) {
+                return true;
+            }
+            // A source signature partially matches a target signature if the target signature has no fewer required
+            // parameters and no more overall parameters than the source signature (where a signature with a rest
+            // parameter is always considered to have more overall parameters than one without).
+            if (partialMatch && source.minArgumentCount <= target.minArgumentCount && (source.hasRestParameter && !target.hasRestParameter ||
+                source.hasRestParameter === target.hasRestParameter && source.parameters.length >= target.parameters.length)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * See signatureRelatedTo, compareSignaturesIdentical
+         */
+        function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) {
+            // TODO (drosen): De-duplicate code between related functions.
+            if (source === target) {
+                return -1 /* True */;
+            }
+            if (!(isMatchingSignature(source, target, partialMatch))) {
+                return 0 /* False */;
+            }
+            // Check that the two signatures have the same number of type parameters. We might consider
+            // also checking that any type parameter constraints match, but that would require instantiating
+            // the constraints with a common set of type arguments to get relatable entities in places where
+            // type parameters occur in the constraints. The complexity of doing that doesn't seem worthwhile,
+            // particularly as we're comparing erased versions of the signatures below.
+            if ((source.typeParameters ? source.typeParameters.length : 0) !== (target.typeParameters ? target.typeParameters.length : 0)) {
+                return 0 /* False */;
+            }
+            // Spec 1.0 Section 3.8.3 & 3.8.4:
+            // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
+            source = getErasedSignature(source);
+            target = getErasedSignature(target);
+            var result = -1 /* True */;
+            if (!ignoreThisTypes) {
+                var sourceThisType = getThisTypeOfSignature(source);
+                if (sourceThisType) {
+                    var targetThisType = getThisTypeOfSignature(target);
+                    if (targetThisType) {
+                        var related = compareTypes(sourceThisType, targetThisType);
+                        if (!related) {
+                            return 0 /* False */;
+                        }
+                        result &= related;
+                    }
+                }
+            }
+            var targetLen = target.parameters.length;
+            for (var i = 0; i < targetLen; i++) {
+                var s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source) : getTypeOfParameter(source.parameters[i]);
+                var t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target) : getTypeOfParameter(target.parameters[i]);
+                var related = compareTypes(s, t);
+                if (!related) {
+                    return 0 /* False */;
+                }
+                result &= related;
+            }
+            if (!ignoreReturnTypes) {
+                result &= compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+            }
+            return result;
+        }
+        function isRestParameterIndex(signature, parameterIndex) {
+            return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
+        }
+        function isSupertypeOfEach(candidate, types) {
+            for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+                var t = types_5[_i];
+                if (candidate !== t && !isTypeSubtypeOf(t, candidate))
+                    return false;
+            }
+            return true;
+        }
+        function getCombinedFlagsOfTypes(types) {
+            var flags = 0;
+            for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+                var t = types_6[_i];
+                flags |= t.flags;
+            }
+            return flags;
+        }
+        function getCommonSupertype(types) {
+            if (!strictNullChecks) {
+                return ts.forEach(types, function (t) { return isSupertypeOfEach(t, types) ? t : undefined; });
+            }
+            var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 96 /* Nullable */); });
+            if (!primaryTypes.length) {
+                return getUnionType(types);
+            }
+            var supertype = ts.forEach(primaryTypes, function (t) { return isSupertypeOfEach(t, primaryTypes) ? t : undefined; });
+            return supertype && addTypeKind(supertype, getCombinedFlagsOfTypes(types) & 96 /* Nullable */);
+        }
+        function reportNoCommonSupertypeError(types, errorLocation, errorMessageChainHead) {
+            // The downfallType/bestSupertypeDownfallType is the first type that caused a particular candidate
+            // to not be the common supertype. So if it weren't for this one downfallType (and possibly others),
+            // the type in question could have been the common supertype.
+            var bestSupertype;
+            var bestSupertypeDownfallType;
+            var bestSupertypeScore = 0;
+            for (var i = 0; i < types.length; i++) {
+                var score = 0;
+                var downfallType = undefined;
+                for (var j = 0; j < types.length; j++) {
+                    if (isTypeSubtypeOf(types[j], types[i])) {
+                        score++;
+                    }
+                    else if (!downfallType) {
+                        downfallType = types[j];
+                    }
+                }
+                ts.Debug.assert(!!downfallType, "If there is no common supertype, each type should have a downfallType");
+                if (score > bestSupertypeScore) {
+                    bestSupertype = types[i];
+                    bestSupertypeDownfallType = downfallType;
+                    bestSupertypeScore = score;
+                }
+                // types.length - 1 is the maximum score, given that getCommonSupertype returned false
+                if (bestSupertypeScore === types.length - 1) {
+                    break;
+                }
+            }
+            // In the following errors, the {1} slot is before the {0} slot because checkTypeSubtypeOf supplies the
+            // subtype as the first argument to the error
+            checkTypeSubtypeOf(bestSupertypeDownfallType, bestSupertype, errorLocation, ts.Diagnostics.Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0, errorMessageChainHead);
+        }
+        function isArrayType(type) {
+            return type.flags & 4096 /* Reference */ && type.target === globalArrayType;
+        }
+        function isArrayLikeType(type) {
+            // A type is array-like if it is a reference to the global Array or global ReadonlyArray type,
+            // or if it is not the undefined or null type and if it is assignable to ReadonlyArray<any>
+            return type.flags & 4096 /* Reference */ && (type.target === globalArrayType || type.target === globalReadonlyArrayType) ||
+                !(type.flags & 96 /* Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType);
+        }
+        function isTupleLikeType(type) {
+            return !!getPropertyOfType(type, "0");
+        }
+        function isStringLiteralUnionType(type) {
+            return type.flags & 256 /* StringLiteral */ ? true :
+                type.flags & 16384 /* Union */ ? ts.forEach(type.types, isStringLiteralUnionType) :
+                    false;
+        }
+        /**
+         * Check if a Type was written as a tuple type literal.
+         * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
+         */
+        function isTupleType(type) {
+            return !!(type.flags & 8192 /* Tuple */);
+        }
+        function getCombinedTypeFlags(type) {
+            return type.flags & 16384 /* Union */ ? getCombinedFlagsOfTypes(type.types) : type.flags;
+        }
+        function addTypeKind(type, kind) {
+            if ((getCombinedTypeFlags(type) & kind) === kind) {
+                return type;
+            }
+            var types = [type];
+            if (kind & 2 /* String */)
+                types.push(stringType);
+            if (kind & 4 /* Number */)
+                types.push(numberType);
+            if (kind & 8 /* Boolean */)
+                types.push(booleanType);
+            if (kind & 16 /* Void */)
+                types.push(voidType);
+            if (kind & 32 /* Undefined */)
+                types.push(undefinedType);
+            if (kind & 64 /* Null */)
+                types.push(nullType);
+            return getUnionType(types);
+        }
+        function getNonNullableType(type) {
+            return strictNullChecks ? getTypeWithFacts(type, 524288 /* NEUndefinedOrNull */) : type;
+        }
+        /**
+         * Return true if type was inferred from an object literal or written as an object type literal
+         * with no call or construct signatures.
+         */
+        function isObjectLiteralType(type) {
+            return type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */)) !== 0 &&
+                getSignaturesOfType(type, 0 /* Call */).length === 0 &&
+                getSignaturesOfType(type, 1 /* Construct */).length === 0;
+        }
+        function createTransientSymbol(source, type) {
+            var symbol = createSymbol(source.flags | 67108864 /* Transient */, source.name);
+            symbol.declarations = source.declarations;
+            symbol.parent = source.parent;
+            symbol.type = type;
+            symbol.target = source;
+            if (source.valueDeclaration) {
+                symbol.valueDeclaration = source.valueDeclaration;
+            }
+            return symbol;
+        }
+        function transformTypeOfMembers(type, f) {
+            var members = {};
+            for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) {
+                var property = _a[_i];
+                var original = getTypeOfSymbol(property);
+                var updated = f(original);
+                members[property.name] = updated === original ? property : createTransientSymbol(property, updated);
+            }
+            ;
+            return members;
+        }
+        /**
+         * If the the provided object literal is subject to the excess properties check,
+         * create a new that is exempt. Recursively mark object literal members as exempt.
+         * Leave signatures alone since they are not subject to the check.
+         */
+        function getRegularTypeOfObjectLiteral(type) {
+            if (!(type.flags & 1048576 /* FreshObjectLiteral */)) {
+                return type;
+            }
+            var regularType = type.regularType;
+            if (regularType) {
+                return regularType;
+            }
+            var resolved = type;
+            var members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
+            var regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, resolved.numberIndexInfo);
+            regularNew.flags = resolved.flags & ~1048576 /* FreshObjectLiteral */;
+            type.regularType = regularNew;
+            return regularNew;
+        }
+        function getWidenedTypeOfObjectLiteral(type) {
+            var members = transformTypeOfMembers(type, function (prop) {
+                var widened = getWidenedType(prop);
+                return prop === widened ? prop : widened;
+            });
+            var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);
+            var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);
+            return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));
+        }
+        function getWidenedConstituentType(type) {
+            return type.flags & 96 /* Nullable */ ? type : getWidenedType(type);
+        }
+        function getWidenedType(type) {
+            if (type.flags & 6291456 /* RequiresWidening */) {
+                if (type.flags & 96 /* Nullable */) {
+                    return anyType;
+                }
+                if (type.flags & 524288 /* ObjectLiteral */) {
+                    return getWidenedTypeOfObjectLiteral(type);
+                }
+                if (type.flags & 16384 /* Union */) {
+                    return getUnionType(ts.map(type.types, getWidenedConstituentType), /*noSubtypeReduction*/ true);
+                }
+                if (isArrayType(type)) {
+                    return createArrayType(getWidenedType(type.typeArguments[0]));
+                }
+                if (isTupleType(type)) {
+                    return createTupleType(ts.map(type.elementTypes, getWidenedType));
+                }
+            }
+            return type;
+        }
+        /**
+         * Reports implicit any errors that occur as a result of widening 'null' and 'undefined'
+         * to 'any'. A call to reportWideningErrorsInType is normally accompanied by a call to
+         * getWidenedType. But in some cases getWidenedType is called without reporting errors
+         * (type argument inference is an example).
+         *
+         * The return value indicates whether an error was in fact reported. The particular circumstances
+         * are on a best effort basis. Currently, if the null or undefined that causes widening is inside
+         * an object literal property (arbitrarily deeply), this function reports an error. If no error is
+         * reported, reportImplicitAnyError is a suitable fallback to report a general error.
+         */
+        function reportWideningErrorsInType(type) {
+            var errorReported = false;
+            if (type.flags & 16384 /* Union */) {
+                for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (reportWideningErrorsInType(t)) {
+                        errorReported = true;
+                    }
+                }
+            }
+            if (isArrayType(type)) {
+                return reportWideningErrorsInType(type.typeArguments[0]);
+            }
+            if (isTupleType(type)) {
+                for (var _b = 0, _c = type.elementTypes; _b < _c.length; _b++) {
+                    var t = _c[_b];
+                    if (reportWideningErrorsInType(t)) {
+                        errorReported = true;
+                    }
+                }
+            }
+            if (type.flags & 524288 /* ObjectLiteral */) {
+                for (var _d = 0, _e = getPropertiesOfObjectType(type); _d < _e.length; _d++) {
+                    var p = _e[_d];
+                    var t = getTypeOfSymbol(p);
+                    if (t.flags & 2097152 /* ContainsWideningType */) {
+                        if (!reportWideningErrorsInType(t)) {
+                            error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t)));
+                        }
+                        errorReported = true;
+                    }
+                }
+            }
+            return errorReported;
+        }
+        function reportImplicitAnyError(declaration, type) {
+            var typeAsString = typeToString(getWidenedType(type));
+            var diagnostic;
+            switch (declaration.kind) {
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type;
+                    break;
+                case 142 /* Parameter */:
+                    diagnostic = declaration.dotDotDotToken ?
+                        ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type :
+                        ts.Diagnostics.Parameter_0_implicitly_has_an_1_type;
+                    break;
+                case 169 /* BindingElement */:
+                    diagnostic = ts.Diagnostics.Binding_element_0_implicitly_has_an_1_type;
+                    break;
+                case 220 /* FunctionDeclaration */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    if (!declaration.name) {
+                        error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
+                        return;
+                    }
+                    diagnostic = ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
+                    break;
+                default:
+                    diagnostic = ts.Diagnostics.Variable_0_implicitly_has_an_1_type;
+            }
+            error(declaration, diagnostic, ts.declarationNameToString(declaration.name), typeAsString);
+        }
+        function reportErrorsFromWidening(declaration, type) {
+            if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & 2097152 /* ContainsWideningType */) {
+                // Report implicit any error within type if possible, otherwise report error on declaration
+                if (!reportWideningErrorsInType(type)) {
+                    reportImplicitAnyError(declaration, type);
+                }
+            }
+        }
+        function forEachMatchingParameterType(source, target, callback) {
+            var sourceMax = source.parameters.length;
+            var targetMax = target.parameters.length;
+            var count;
+            if (source.hasRestParameter && target.hasRestParameter) {
+                count = Math.max(sourceMax, targetMax);
+            }
+            else if (source.hasRestParameter) {
+                count = targetMax;
+            }
+            else if (target.hasRestParameter) {
+                count = sourceMax;
+            }
+            else {
+                count = Math.min(sourceMax, targetMax);
+            }
+            for (var i = 0; i < count; i++) {
+                callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i));
+            }
+        }
+        function createInferenceContext(typeParameters, inferUnionTypes) {
+            var inferences = ts.map(typeParameters, createTypeInferencesObject);
+            return {
+                typeParameters: typeParameters,
+                inferUnionTypes: inferUnionTypes,
+                inferences: inferences,
+                inferredTypes: new Array(typeParameters.length)
+            };
+        }
+        function createTypeInferencesObject() {
+            return {
+                primary: undefined,
+                secondary: undefined,
+                isFixed: false
+            };
+        }
+        function inferTypes(context, source, target) {
+            var sourceStack;
+            var targetStack;
+            var depth = 0;
+            var inferiority = 0;
+            var visited = {};
+            inferFromTypes(source, target);
+            function isInProcess(source, target) {
+                for (var i = 0; i < depth; i++) {
+                    if (source === sourceStack[i] && target === targetStack[i]) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function inferFromTypes(source, target) {
+                if (source.flags & 16384 /* Union */ && target.flags & 16384 /* Union */ ||
+                    source.flags & 32768 /* Intersection */ && target.flags & 32768 /* Intersection */) {
+                    // Source and target are both unions or both intersections. First, find each
+                    // target constituent type that has an identically matching source constituent
+                    // type, and for each such target constituent type infer from the type to itself.
+                    // When inferring from a type to itself we effectively find all type parameter
+                    // occurrences within that type and infer themselves as their type arguments.
+                    var matchingTypes = void 0;
+                    for (var _i = 0, _a = target.types; _i < _a.length; _i++) {
+                        var t = _a[_i];
+                        if (typeIdenticalToSomeType(t, source.types)) {
+                            (matchingTypes || (matchingTypes = [])).push(t);
+                            inferFromTypes(t, t);
+                        }
+                    }
+                    // Next, to improve the quality of inferences, reduce the source and target types by
+                    // removing the identically matched constituents. For example, when inferring from
+                    // 'string | string[]' to 'string | T' we reduce the types to 'string[]' and 'T'.
+                    if (matchingTypes) {
+                        source = removeTypesFromUnionOrIntersection(source, matchingTypes);
+                        target = removeTypesFromUnionOrIntersection(target, matchingTypes);
+                    }
+                }
+                if (target.flags & 512 /* TypeParameter */) {
+                    // If target is a type parameter, make an inference, unless the source type contains
+                    // the anyFunctionType (the wildcard type that's used to avoid contextually typing functions).
+                    // Because the anyFunctionType is internal, it should not be exposed to the user by adding
+                    // it as an inference candidate. Hopefully, a better candidate will come along that does
+                    // not contain anyFunctionType when we come back to this argument for its second round
+                    // of inference.
+                    if (source.flags & 8388608 /* ContainsAnyFunctionType */) {
+                        return;
+                    }
+                    var typeParameters = context.typeParameters;
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        if (target === typeParameters[i]) {
+                            var inferences = context.inferences[i];
+                            if (!inferences.isFixed) {
+                                // Any inferences that are made to a type parameter in a union type are inferior
+                                // to inferences made to a flat (non-union) type. This is because if we infer to
+                                // T | string[], we really don't know if we should be inferring to T or not (because
+                                // the correct constituent on the target side could be string[]). Therefore, we put
+                                // such inferior inferences into a secondary bucket, and only use them if the primary
+                                // bucket is empty.
+                                var candidates = inferiority ?
+                                    inferences.secondary || (inferences.secondary = []) :
+                                    inferences.primary || (inferences.primary = []);
+                                if (!ts.contains(candidates, source)) {
+                                    candidates.push(source);
+                                }
+                            }
+                            return;
+                        }
+                    }
+                }
+                else if (source.flags & 4096 /* Reference */ && target.flags & 4096 /* Reference */ && source.target === target.target) {
+                    // If source and target are references to the same generic type, infer from type arguments
+                    var sourceTypes = source.typeArguments || emptyArray;
+                    var targetTypes = target.typeArguments || emptyArray;
+                    var count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
+                    for (var i = 0; i < count; i++) {
+                        inferFromTypes(sourceTypes[i], targetTypes[i]);
+                    }
+                }
+                else if (source.flags & 8192 /* Tuple */ && target.flags & 8192 /* Tuple */ && source.elementTypes.length === target.elementTypes.length) {
+                    // If source and target are tuples of the same size, infer from element types
+                    var sourceTypes = source.elementTypes;
+                    var targetTypes = target.elementTypes;
+                    for (var i = 0; i < sourceTypes.length; i++) {
+                        inferFromTypes(sourceTypes[i], targetTypes[i]);
+                    }
+                }
+                else if (target.flags & 49152 /* UnionOrIntersection */) {
+                    var targetTypes = target.types;
+                    var typeParameterCount = 0;
+                    var typeParameter = void 0;
+                    // First infer to each type in union or intersection that isn't a type parameter
+                    for (var _b = 0, targetTypes_2 = targetTypes; _b < targetTypes_2.length; _b++) {
+                        var t = targetTypes_2[_b];
+                        if (t.flags & 512 /* TypeParameter */ && ts.contains(context.typeParameters, t)) {
+                            typeParameter = t;
+                            typeParameterCount++;
+                        }
+                        else {
+                            inferFromTypes(source, t);
+                        }
+                    }
+                    // Next, if target containings a single naked type parameter, make a secondary inference to that type
+                    // parameter. This gives meaningful results for union types in co-variant positions and intersection
+                    // types in contra-variant positions (such as callback parameters).
+                    if (typeParameterCount === 1) {
+                        inferiority++;
+                        inferFromTypes(source, typeParameter);
+                        inferiority--;
+                    }
+                }
+                else if (source.flags & 49152 /* UnionOrIntersection */) {
+                    // Source is a union or intersection type, infer from each constituent type
+                    var sourceTypes = source.types;
+                    for (var _c = 0, sourceTypes_3 = sourceTypes; _c < sourceTypes_3.length; _c++) {
+                        var sourceType = sourceTypes_3[_c];
+                        inferFromTypes(sourceType, target);
+                    }
+                }
+                else {
+                    source = getApparentType(source);
+                    if (source.flags & 80896 /* ObjectType */ && (target.flags & 4096 /* Reference */ && target.typeArguments ||
+                        target.flags & 8192 /* Tuple */ ||
+                        target.flags & 65536 /* Anonymous */ && target.symbol && target.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */ | 32 /* Class */))) {
+                        // If source is an object type, and target is a type reference with type arguments, a tuple type,
+                        // the type of a method, or a type literal, infer from members
+                        if (isInProcess(source, target)) {
+                            return;
+                        }
+                        if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) {
+                            return;
+                        }
+                        var key = source.id + "," + target.id;
+                        if (ts.hasProperty(visited, key)) {
+                            return;
+                        }
+                        visited[key] = true;
+                        if (depth === 0) {
+                            sourceStack = [];
+                            targetStack = [];
+                        }
+                        sourceStack[depth] = source;
+                        targetStack[depth] = target;
+                        depth++;
+                        inferFromProperties(source, target);
+                        inferFromSignatures(source, target, 0 /* Call */);
+                        inferFromSignatures(source, target, 1 /* Construct */);
+                        inferFromIndexTypes(source, target);
+                        depth--;
+                    }
+                }
+            }
+            function inferFromProperties(source, target) {
+                var properties = getPropertiesOfObjectType(target);
+                for (var _i = 0, properties_2 = properties; _i < properties_2.length; _i++) {
+                    var targetProp = properties_2[_i];
+                    var sourceProp = getPropertyOfObjectType(source, targetProp.name);
+                    if (sourceProp) {
+                        inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+                    }
+                }
+            }
+            function inferFromSignatures(source, target, kind) {
+                var sourceSignatures = getSignaturesOfType(source, kind);
+                var targetSignatures = getSignaturesOfType(target, kind);
+                var sourceLen = sourceSignatures.length;
+                var targetLen = targetSignatures.length;
+                var len = sourceLen < targetLen ? sourceLen : targetLen;
+                for (var i = 0; i < len; i++) {
+                    inferFromSignature(getErasedSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+                }
+            }
+            function inferFromSignature(source, target) {
+                forEachMatchingParameterType(source, target, inferFromTypes);
+                if (source.typePredicate && target.typePredicate && source.typePredicate.kind === target.typePredicate.kind) {
+                    inferFromTypes(source.typePredicate.type, target.typePredicate.type);
+                }
+                else {
+                    inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+                }
+            }
+            function inferFromIndexTypes(source, target) {
+                var targetStringIndexType = getIndexTypeOfType(target, 0 /* String */);
+                if (targetStringIndexType) {
+                    var sourceIndexType = getIndexTypeOfType(source, 0 /* String */) ||
+                        getImplicitIndexTypeOfType(source, 0 /* String */);
+                    if (sourceIndexType) {
+                        inferFromTypes(sourceIndexType, targetStringIndexType);
+                    }
+                }
+                var targetNumberIndexType = getIndexTypeOfType(target, 1 /* Number */);
+                if (targetNumberIndexType) {
+                    var sourceIndexType = getIndexTypeOfType(source, 1 /* Number */) ||
+                        getIndexTypeOfType(source, 0 /* String */) ||
+                        getImplicitIndexTypeOfType(source, 1 /* Number */);
+                    if (sourceIndexType) {
+                        inferFromTypes(sourceIndexType, targetNumberIndexType);
+                    }
+                }
+            }
+        }
+        function typeIdenticalToSomeType(type, types) {
+            for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
+                var t = types_7[_i];
+                if (isTypeIdenticalTo(t, type)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        /**
+         * Return a new union or intersection type computed by removing a given set of types
+         * from a given union or intersection type.
+         */
+        function removeTypesFromUnionOrIntersection(type, typesToRemove) {
+            var reducedTypes = [];
+            for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                var t = _a[_i];
+                if (!typeIdenticalToSomeType(t, typesToRemove)) {
+                    reducedTypes.push(t);
+                }
+            }
+            return type.flags & 16384 /* Union */ ? getUnionType(reducedTypes, /*noSubtypeReduction*/ true) : getIntersectionType(reducedTypes);
+        }
+        function getInferenceCandidates(context, index) {
+            var inferences = context.inferences[index];
+            return inferences.primary || inferences.secondary || emptyArray;
+        }
+        function getInferredType(context, index) {
+            var inferredType = context.inferredTypes[index];
+            var inferenceSucceeded;
+            if (!inferredType) {
+                var inferences = getInferenceCandidates(context, index);
+                if (inferences.length) {
+                    // Infer widened union or supertype, or the unknown type for no common supertype
+                    var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
+                    inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : unknownType;
+                    inferenceSucceeded = !!unionOrSuperType;
+                }
+                else {
+                    // Infer the empty object type when no inferences were made. It is important to remember that
+                    // in this case, inference still succeeds, meaning there is no error for not having inference
+                    // candidates. An inference error only occurs when there are *conflicting* candidates, i.e.
+                    // candidates with no common supertype.
+                    inferredType = emptyObjectType;
+                    inferenceSucceeded = true;
+                }
+                context.inferredTypes[index] = inferredType;
+                // Only do the constraint check if inference succeeded (to prevent cascading errors)
+                if (inferenceSucceeded) {
+                    var constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
+                    if (constraint) {
+                        var instantiatedConstraint = instantiateType(constraint, getInferenceMapper(context));
+                        if (!isTypeAssignableTo(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
+                            context.inferredTypes[index] = inferredType = instantiatedConstraint;
+                        }
+                    }
+                }
+                else if (context.failedTypeParameterIndex === undefined || context.failedTypeParameterIndex > index) {
+                    // If inference failed, it is necessary to record the index of the failed type parameter (the one we are on).
+                    // It might be that inference has already failed on a later type parameter on a previous call to inferTypeArguments.
+                    // So if this failure is on preceding type parameter, this type parameter is the new failure index.
+                    context.failedTypeParameterIndex = index;
+                }
+            }
+            return inferredType;
+        }
+        function getInferredTypes(context) {
+            for (var i = 0; i < context.inferredTypes.length; i++) {
+                getInferredType(context, i);
+            }
+            return context.inferredTypes;
+        }
+        // EXPRESSION TYPE CHECKING
+        function getResolvedSymbol(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedSymbol) {
+                links.resolvedSymbol = !ts.nodeIsMissing(node) && resolveName(node, node.text, 107455 /* Value */ | 1048576 /* ExportValue */, ts.Diagnostics.Cannot_find_name_0, node) || unknownSymbol;
+            }
+            return links.resolvedSymbol;
+        }
+        function isInTypeQuery(node) {
+            // TypeScript 1.0 spec (April 2014): 3.6.3
+            // A type query consists of the keyword typeof followed by an expression.
+            // The expression is restricted to a single identifier or a sequence of identifiers separated by periods
+            while (node) {
+                switch (node.kind) {
+                    case 158 /* TypeQuery */:
+                        return true;
+                    case 69 /* Identifier */:
+                    case 139 /* QualifiedName */:
+                        node = node.parent;
+                        continue;
+                    default:
+                        return false;
+                }
+            }
+            ts.Debug.fail("should not get here");
+        }
+        // Return the flow cache key for a "dotted name" (i.e. a sequence of identifiers
+        // separated by dots). The key consists of the id of the symbol referenced by the
+        // leftmost identifier followed by zero or more property names separated by dots.
+        // The result is undefined if the reference isn't a dotted name.
+        function getFlowCacheKey(node) {
+            if (node.kind === 69 /* Identifier */) {
+                var symbol = getResolvedSymbol(node);
+                return symbol !== unknownSymbol ? "" + getSymbolId(symbol) : undefined;
+            }
+            if (node.kind === 97 /* ThisKeyword */) {
+                return "0";
+            }
+            if (node.kind === 172 /* PropertyAccessExpression */) {
+                var key = getFlowCacheKey(node.expression);
+                return key && key + "." + node.name.text;
+            }
+            return undefined;
+        }
+        function isNullOrUndefinedLiteral(node) {
+            return node.kind === 93 /* NullKeyword */ ||
+                node.kind === 69 /* Identifier */ && getResolvedSymbol(node) === undefinedSymbol;
+        }
+        function getLeftmostIdentifierOrThis(node) {
+            switch (node.kind) {
+                case 69 /* Identifier */:
+                case 97 /* ThisKeyword */:
+                    return node;
+                case 172 /* PropertyAccessExpression */:
+                    return getLeftmostIdentifierOrThis(node.expression);
+            }
+            return undefined;
+        }
+        function isMatchingReference(source, target) {
+            if (source.kind === target.kind) {
+                switch (source.kind) {
+                    case 69 /* Identifier */:
+                        return getResolvedSymbol(source) === getResolvedSymbol(target);
+                    case 97 /* ThisKeyword */:
+                        return true;
+                    case 172 /* PropertyAccessExpression */:
+                        return source.name.text === target.name.text &&
+                            isMatchingReference(source.expression, target.expression);
+                }
+            }
+            return false;
+        }
+        function containsMatchingReference(source, target) {
+            while (source.kind === 172 /* PropertyAccessExpression */) {
+                source = source.expression;
+                if (isMatchingReference(source, target)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function isOrContainsMatchingReference(source, target) {
+            return isMatchingReference(source, target) || containsMatchingReference(source, target);
+        }
+        function hasMatchingArgument(callExpression, reference) {
+            if (callExpression.arguments) {
+                for (var _i = 0, _a = callExpression.arguments; _i < _a.length; _i++) {
+                    var argument = _a[_i];
+                    if (isOrContainsMatchingReference(reference, argument)) {
+                        return true;
+                    }
+                }
+            }
+            if (callExpression.expression.kind === 172 /* PropertyAccessExpression */ &&
+                isOrContainsMatchingReference(reference, callExpression.expression.expression)) {
+                return true;
+            }
+            return false;
+        }
+        function getFlowNodeId(flow) {
+            if (!flow.id) {
+                flow.id = nextFlowId;
+                nextFlowId++;
+            }
+            return flow.id;
+        }
+        function typeMaybeAssignableTo(source, target) {
+            if (!(source.flags & 16384 /* Union */)) {
+                return isTypeAssignableTo(source, target);
+            }
+            for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
+                var t = _a[_i];
+                if (isTypeAssignableTo(t, target)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Remove those constituent types of declaredType to which no constituent type of assignedType is assignable.
+        // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
+        // we remove type string.
+        function getAssignmentReducedType(declaredType, assignedType) {
+            if (declaredType !== assignedType && declaredType.flags & 16384 /* Union */) {
+                var reducedTypes = ts.filter(declaredType.types, function (t) { return typeMaybeAssignableTo(assignedType, t); });
+                if (reducedTypes.length) {
+                    return reducedTypes.length === 1 ? reducedTypes[0] : getUnionType(reducedTypes);
+                }
+            }
+            return declaredType;
+        }
+        function getTypeFacts(type) {
+            var flags = type.flags;
+            if (flags & 258 /* StringLike */) {
+                return strictNullChecks ? 4079361 /* StringStrictFacts */ : 4194049 /* StringFacts */;
+            }
+            if (flags & 132 /* NumberLike */) {
+                return strictNullChecks ? 4079234 /* NumberStrictFacts */ : 4193922 /* NumberFacts */;
+            }
+            if (flags & 8 /* Boolean */) {
+                return strictNullChecks ? 4078980 /* BooleanStrictFacts */ : 4193668 /* BooleanFacts */;
+            }
+            if (flags & 80896 /* ObjectType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                return resolved.callSignatures.length || resolved.constructSignatures.length || isTypeSubtypeOf(type, globalFunctionType) ?
+                    strictNullChecks ? 1970144 /* FunctionStrictFacts */ : 4181984 /* FunctionFacts */ :
+                    strictNullChecks ? 1972176 /* ObjectStrictFacts */ : 4184016 /* ObjectFacts */;
+            }
+            if (flags & (16 /* Void */ | 32 /* Undefined */)) {
+                return 2457472 /* UndefinedFacts */;
+            }
+            if (flags & 64 /* Null */) {
+                return 2340752 /* NullFacts */;
+            }
+            if (flags & 16777216 /* ESSymbol */) {
+                return strictNullChecks ? 1981320 /* SymbolStrictFacts */ : 4193160 /* SymbolFacts */;
+            }
+            if (flags & 512 /* TypeParameter */) {
+                var constraint = getConstraintOfTypeParameter(type);
+                return constraint ? getTypeFacts(constraint) : 4194303 /* All */;
+            }
+            if (flags & 32768 /* Intersection */) {
+                return ts.reduceLeft(type.types, function (flags, type) { return flags |= getTypeFacts(type); }, 0 /* None */);
+            }
+            return 4194303 /* All */;
+        }
+        function getTypeWithFacts(type, include) {
+            if (!(type.flags & 16384 /* Union */)) {
+                return getTypeFacts(type) & include ? type : neverType;
+            }
+            var firstType;
+            var types;
+            for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                var t = _a[_i];
+                if (getTypeFacts(t) & include) {
+                    if (!firstType) {
+                        firstType = t;
+                    }
+                    else {
+                        if (!types) {
+                            types = [firstType];
+                        }
+                        types.push(t);
+                    }
+                }
+            }
+            return firstType ? types ? getUnionType(types, /*noSubtypeReduction*/ true) : firstType : neverType;
+        }
+        function getTypeWithDefault(type, defaultExpression) {
+            if (defaultExpression) {
+                var defaultType = checkExpression(defaultExpression);
+                return getUnionType([getTypeWithFacts(type, 131072 /* NEUndefined */), defaultType]);
+            }
+            return type;
+        }
+        function getTypeOfDestructuredProperty(type, name) {
+            var text = getTextOfPropertyName(name);
+            return getTypeOfPropertyOfType(type, text) ||
+                isNumericLiteralName(text) && getIndexTypeOfType(type, 1 /* Number */) ||
+                getIndexTypeOfType(type, 0 /* String */) ||
+                unknownType;
+        }
+        function getTypeOfDestructuredArrayElement(type, index) {
+            return isTupleLikeType(type) && getTypeOfPropertyOfType(type, "" + index) ||
+                checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) ||
+                unknownType;
+        }
+        function getTypeOfDestructuredSpreadElement(type) {
+            return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) || unknownType);
+        }
+        function getAssignedTypeOfBinaryExpression(node) {
+            return node.parent.kind === 170 /* ArrayLiteralExpression */ || node.parent.kind === 253 /* PropertyAssignment */ ?
+                getTypeWithDefault(getAssignedType(node), node.right) :
+                checkExpression(node.right);
+        }
+        function getAssignedTypeOfArrayLiteralElement(node, element) {
+            return getTypeOfDestructuredArrayElement(getAssignedType(node), ts.indexOf(node.elements, element));
+        }
+        function getAssignedTypeOfSpreadElement(node) {
+            return getTypeOfDestructuredSpreadElement(getAssignedType(node.parent));
+        }
+        function getAssignedTypeOfPropertyAssignment(node) {
+            return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name);
+        }
+        function getAssignedTypeOfShorthandPropertyAssignment(node) {
+            return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer);
+        }
+        function getAssignedType(node) {
+            var parent = node.parent;
+            switch (parent.kind) {
+                case 207 /* ForInStatement */:
+                    return stringType;
+                case 208 /* ForOfStatement */:
+                    return checkRightHandSideOfForOf(parent.expression) || unknownType;
+                case 187 /* BinaryExpression */:
+                    return getAssignedTypeOfBinaryExpression(parent);
+                case 181 /* DeleteExpression */:
+                    return undefinedType;
+                case 170 /* ArrayLiteralExpression */:
+                    return getAssignedTypeOfArrayLiteralElement(parent, node);
+                case 191 /* SpreadElementExpression */:
+                    return getAssignedTypeOfSpreadElement(parent);
+                case 253 /* PropertyAssignment */:
+                    return getAssignedTypeOfPropertyAssignment(parent);
+                case 254 /* ShorthandPropertyAssignment */:
+                    return getAssignedTypeOfShorthandPropertyAssignment(parent);
+            }
+            return unknownType;
+        }
+        function getInitialTypeOfBindingElement(node) {
+            var pattern = node.parent;
+            var parentType = getInitialType(pattern.parent);
+            var type = pattern.kind === 167 /* ObjectBindingPattern */ ?
+                getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) :
+                !node.dotDotDotToken ?
+                    getTypeOfDestructuredArrayElement(parentType, ts.indexOf(pattern.elements, node)) :
+                    getTypeOfDestructuredSpreadElement(parentType);
+            return getTypeWithDefault(type, node.initializer);
+        }
+        function getTypeOfInitializer(node) {
+            // Return the cached type if one is available. If the type of the variable was inferred
+            // from its initializer, we'll already have cached the type. Otherwise we compute it now
+            // without caching such that transient types are reflected.
+            var links = getNodeLinks(node);
+            return links.resolvedType || checkExpression(node);
+        }
+        function getInitialTypeOfVariableDeclaration(node) {
+            if (node.initializer) {
+                return getTypeOfInitializer(node.initializer);
+            }
+            if (node.parent.parent.kind === 207 /* ForInStatement */) {
+                return stringType;
+            }
+            if (node.parent.parent.kind === 208 /* ForOfStatement */) {
+                return checkRightHandSideOfForOf(node.parent.parent.expression) || unknownType;
+            }
+            return unknownType;
+        }
+        function getInitialType(node) {
+            return node.kind === 218 /* VariableDeclaration */ ?
+                getInitialTypeOfVariableDeclaration(node) :
+                getInitialTypeOfBindingElement(node);
+        }
+        function getReferenceFromExpression(node) {
+            switch (node.kind) {
+                case 178 /* ParenthesizedExpression */:
+                    return getReferenceFromExpression(node.expression);
+                case 187 /* BinaryExpression */:
+                    switch (node.operatorToken.kind) {
+                        case 56 /* EqualsToken */:
+                            return getReferenceFromExpression(node.left);
+                        case 24 /* CommaToken */:
+                            return getReferenceFromExpression(node.right);
+                    }
+            }
+            return node;
+        }
+        function getTypeOfSwitchClause(clause) {
+            if (clause.kind === 249 /* CaseClause */) {
+                var expr = clause.expression;
+                return expr.kind === 9 /* StringLiteral */ ? getStringLiteralTypeForText(expr.text) : checkExpression(expr);
+            }
+            return undefined;
+        }
+        function getSwitchClauseTypes(switchStatement) {
+            var links = getNodeLinks(switchStatement);
+            if (!links.switchTypes) {
+                // If all case clauses specify expressions that have unit types, we return an array
+                // of those unit types. Otherwise we return an empty array.
+                var types = ts.map(switchStatement.caseBlock.clauses, getTypeOfSwitchClause);
+                links.switchTypes = ts.forEach(types, function (t) { return !t || t.flags & 256 /* StringLiteral */; }) ? types : emptyArray;
+            }
+            return links.switchTypes;
+        }
+        function eachTypeContainedIn(source, types) {
+            return source.flags & 16384 /* Union */ ? !ts.forEach(source.types, function (t) { return !ts.contains(types, t); }) : ts.contains(types, source);
+        }
+        function filterType(type, f) {
+            return type.flags & 16384 /* Union */ ?
+                getUnionType(ts.filter(type.types, f)) :
+                f(type) ? type : neverType;
+        }
+        function getFlowTypeOfReference(reference, declaredType, assumeInitialized, includeOuterFunctions) {
+            var key;
+            if (!reference.flowNode || assumeInitialized && !(declaredType.flags & 16908175 /* Narrowable */)) {
+                return declaredType;
+            }
+            var initialType = assumeInitialized ? declaredType : addTypeKind(declaredType, 32 /* Undefined */);
+            var visitedFlowStart = visitedFlowCount;
+            var result = getTypeAtFlowNode(reference.flowNode);
+            visitedFlowCount = visitedFlowStart;
+            if (reference.parent.kind === 196 /* NonNullExpression */ && getTypeWithFacts(result, 524288 /* NEUndefinedOrNull */) === neverType) {
+                return declaredType;
+            }
+            return result;
+            function getTypeAtFlowNode(flow) {
+                while (true) {
+                    if (flow.flags & 512 /* Shared */) {
+                        // We cache results of flow type resolution for shared nodes that were previously visited in
+                        // the same getFlowTypeOfReference invocation. A node is considered shared when it is the
+                        // antecedent of more than one node.
+                        for (var i = visitedFlowStart; i < visitedFlowCount; i++) {
+                            if (visitedFlowNodes[i] === flow) {
+                                return visitedFlowTypes[i];
+                            }
+                        }
+                    }
+                    var type = void 0;
+                    if (flow.flags & 16 /* Assignment */) {
+                        type = getTypeAtFlowAssignment(flow);
+                        if (!type) {
+                            flow = flow.antecedent;
+                            continue;
+                        }
+                    }
+                    else if (flow.flags & 96 /* Condition */) {
+                        type = getTypeAtFlowCondition(flow);
+                    }
+                    else if (flow.flags & 128 /* SwitchClause */) {
+                        type = getTypeAtSwitchClause(flow);
+                    }
+                    else if (flow.flags & 12 /* Label */) {
+                        if (flow.antecedents.length === 1) {
+                            flow = flow.antecedents[0];
+                            continue;
+                        }
+                        type = flow.flags & 4 /* BranchLabel */ ?
+                            getTypeAtFlowBranchLabel(flow) :
+                            getTypeAtFlowLoopLabel(flow);
+                    }
+                    else if (flow.flags & 2 /* Start */) {
+                        // Check if we should continue with the control flow of the containing function.
+                        var container = flow.container;
+                        if (container && includeOuterFunctions) {
+                            flow = container.flowNode;
+                            continue;
+                        }
+                        // At the top of the flow we have the initial type.
+                        type = initialType;
+                    }
+                    else {
+                        // Unreachable code errors are reported in the binding phase. Here we
+                        // simply return the declared type to reduce follow-on errors.
+                        type = declaredType;
+                    }
+                    if (flow.flags & 512 /* Shared */) {
+                        // Record visited node and the associated type in the cache.
+                        visitedFlowNodes[visitedFlowCount] = flow;
+                        visitedFlowTypes[visitedFlowCount] = type;
+                        visitedFlowCount++;
+                    }
+                    return type;
+                }
+            }
+            function getTypeAtFlowAssignment(flow) {
+                var node = flow.node;
+                // Assignments only narrow the computed type if the declared type is a union type. Thus, we
+                // only need to evaluate the assigned type if the declared type is a union type.
+                if ((node.kind === 218 /* VariableDeclaration */ || node.kind === 169 /* BindingElement */) &&
+                    reference.kind === 69 /* Identifier */ &&
+                    getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(reference)) === getSymbolOfNode(node)) {
+                    return declaredType.flags & 16384 /* Union */ ?
+                        getAssignmentReducedType(declaredType, getInitialType(node)) :
+                        declaredType;
+                }
+                // If the node is not a variable declaration or binding element, it is an identifier
+                // or a dotted name that is the target of an assignment. If we have a match, reduce
+                // the declared type by the assigned type.
+                if (isMatchingReference(reference, node)) {
+                    return declaredType.flags & 16384 /* Union */ ?
+                        getAssignmentReducedType(declaredType, getAssignedType(node)) :
+                        declaredType;
+                }
+                // We didn't have a direct match. However, if the reference is a dotted name, this
+                // may be an assignment to a left hand part of the reference. For example, for a
+                // reference 'x.y.z', we may be at an assignment to 'x.y' or 'x'. In that case,
+                // return the declared type.
+                if (containsMatchingReference(reference, node)) {
+                    return declaredType;
+                }
+                // Assignment doesn't affect reference
+                return undefined;
+            }
+            function getTypeAtFlowCondition(flow) {
+                var type = getTypeAtFlowNode(flow.antecedent);
+                if (type !== neverType) {
+                    // If we have an antecedent type (meaning we're reachable in some way), we first
+                    // attempt to narrow the antecedent type. If that produces the nothing type, then
+                    // we take the type guard as an indication that control could reach here in a
+                    // manner not understood by the control flow analyzer (e.g. a function argument
+                    // has an invalid type, or a nested function has possibly made an assignment to a
+                    // captured variable). We proceed by reverting to the declared type and then
+                    // narrow that.
+                    var assumeTrue = (flow.flags & 32 /* TrueCondition */) !== 0;
+                    type = narrowType(type, flow.expression, assumeTrue);
+                    if (type === neverType) {
+                        type = narrowType(declaredType, flow.expression, assumeTrue);
+                    }
+                }
+                return type;
+            }
+            function getTypeAtSwitchClause(flow) {
+                var type = getTypeAtFlowNode(flow.antecedent);
+                return narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+            }
+            function getTypeAtFlowBranchLabel(flow) {
+                var antecedentTypes = [];
+                for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
+                    var antecedent = _a[_i];
+                    var type = getTypeAtFlowNode(antecedent);
+                    // If the type at a particular antecedent path is the declared type and the
+                    // reference is known to always be assigned (i.e. when declared and initial types
+                    // are the same), there is no reason to process more antecedents since the only
+                    // possible outcome is subtypes that will be removed in the final union type anyway.
+                    if (type === declaredType && declaredType === initialType) {
+                        return type;
+                    }
+                    if (!ts.contains(antecedentTypes, type)) {
+                        antecedentTypes.push(type);
+                    }
+                }
+                return getUnionType(antecedentTypes);
+            }
+            function getTypeAtFlowLoopLabel(flow) {
+                // If we have previously computed the control flow type for the reference at
+                // this flow loop junction, return the cached type.
+                var id = getFlowNodeId(flow);
+                var cache = flowLoopCaches[id] || (flowLoopCaches[id] = {});
+                if (!key) {
+                    key = getFlowCacheKey(reference);
+                }
+                if (cache[key]) {
+                    return cache[key];
+                }
+                // If this flow loop junction and reference are already being processed, return
+                // the union of the types computed for each branch so far. We should never see
+                // an empty array here because the first antecedent of a loop junction is always
+                // the non-looping control flow path that leads to the top.
+                for (var i = flowLoopStart; i < flowLoopCount; i++) {
+                    if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key) {
+                        return getUnionType(flowLoopTypes[i]);
+                    }
+                }
+                // Add the flow loop junction and reference to the in-process stack and analyze
+                // each antecedent code path.
+                var antecedentTypes = [];
+                flowLoopNodes[flowLoopCount] = flow;
+                flowLoopKeys[flowLoopCount] = key;
+                flowLoopTypes[flowLoopCount] = antecedentTypes;
+                for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
+                    var antecedent = _a[_i];
+                    flowLoopCount++;
+                    var type = getTypeAtFlowNode(antecedent);
+                    flowLoopCount--;
+                    // If we see a value appear in the cache it is a sign that control flow  analysis
+                    // was restarted and completed by checkExpressionCached. We can simply pick up
+                    // the resulting type and bail out.
+                    if (cache[key]) {
+                        return cache[key];
+                    }
+                    if (!ts.contains(antecedentTypes, type)) {
+                        antecedentTypes.push(type);
+                    }
+                    // If the type at a particular antecedent path is the declared type there is no
+                    // reason to process more antecedents since the only possible outcome is subtypes
+                    // that will be removed in the final union type anyway.
+                    if (type === declaredType) {
+                        break;
+                    }
+                }
+                return cache[key] = getUnionType(antecedentTypes);
+            }
+            function narrowTypeByTruthiness(type, expr, assumeTrue) {
+                return isMatchingReference(reference, expr) ? getTypeWithFacts(type, assumeTrue ? 1048576 /* Truthy */ : 2097152 /* Falsy */) : type;
+            }
+            function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
+                switch (expr.operatorToken.kind) {
+                    case 56 /* EqualsToken */:
+                        return narrowTypeByTruthiness(type, expr.left, assumeTrue);
+                    case 30 /* EqualsEqualsToken */:
+                    case 31 /* ExclamationEqualsToken */:
+                    case 32 /* EqualsEqualsEqualsToken */:
+                    case 33 /* ExclamationEqualsEqualsToken */:
+                        var left = expr.left;
+                        var operator = expr.operatorToken.kind;
+                        var right = expr.right;
+                        if (isNullOrUndefinedLiteral(right)) {
+                            return narrowTypeByNullCheck(type, left, operator, right, assumeTrue);
+                        }
+                        if (isNullOrUndefinedLiteral(left)) {
+                            return narrowTypeByNullCheck(type, right, operator, left, assumeTrue);
+                        }
+                        if (left.kind === 182 /* TypeOfExpression */ && right.kind === 9 /* StringLiteral */) {
+                            return narrowTypeByTypeof(type, left, operator, right, assumeTrue);
+                        }
+                        if (right.kind === 182 /* TypeOfExpression */ && left.kind === 9 /* StringLiteral */) {
+                            return narrowTypeByTypeof(type, right, operator, left, assumeTrue);
+                        }
+                        if (left.kind === 172 /* PropertyAccessExpression */) {
+                            return narrowTypeByDiscriminant(type, left, operator, right, assumeTrue);
+                        }
+                        if (right.kind === 172 /* PropertyAccessExpression */) {
+                            return narrowTypeByDiscriminant(type, right, operator, left, assumeTrue);
+                        }
+                        break;
+                    case 91 /* InstanceOfKeyword */:
+                        return narrowTypeByInstanceof(type, expr, assumeTrue);
+                    case 24 /* CommaToken */:
+                        return narrowType(type, expr.right, assumeTrue);
+                }
+                return type;
+            }
+            function narrowTypeByNullCheck(type, target, operator, literal, assumeTrue) {
+                // We have '==', '!=', '===', or '!==' operator with 'null' or 'undefined' as value
+                if (operator === 31 /* ExclamationEqualsToken */ || operator === 33 /* ExclamationEqualsEqualsToken */) {
+                    assumeTrue = !assumeTrue;
+                }
+                if (!strictNullChecks || !isMatchingReference(reference, getReferenceFromExpression(target))) {
+                    return type;
+                }
+                var doubleEquals = operator === 30 /* EqualsEqualsToken */ || operator === 31 /* ExclamationEqualsToken */;
+                var facts = doubleEquals ?
+                    assumeTrue ? 65536 /* EQUndefinedOrNull */ : 524288 /* NEUndefinedOrNull */ :
+                    literal.kind === 93 /* NullKeyword */ ?
+                        assumeTrue ? 32768 /* EQNull */ : 262144 /* NENull */ :
+                        assumeTrue ? 16384 /* EQUndefined */ : 131072 /* NEUndefined */;
+                return getTypeWithFacts(type, facts);
+            }
+            function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
+                // We have '==', '!=', '====', or !==' operator with 'typeof xxx' and string literal operands
+                var target = getReferenceFromExpression(typeOfExpr.expression);
+                if (!isMatchingReference(reference, target)) {
+                    // For a reference of the form 'x.y', a 'typeof x === ...' type guard resets the
+                    // narrowed type of 'y' to its declared type.
+                    if (containsMatchingReference(reference, target)) {
+                        return declaredType;
+                    }
+                    return type;
+                }
+                if (operator === 31 /* ExclamationEqualsToken */ || operator === 33 /* ExclamationEqualsEqualsToken */) {
+                    assumeTrue = !assumeTrue;
+                }
+                if (assumeTrue && !(type.flags & 16384 /* Union */)) {
+                    // We narrow a non-union type to an exact primitive type if the non-union type
+                    // is a supertype of that primtive type. For example, type 'any' can be narrowed
+                    // to one of the primitive types.
+                    var targetType = ts.getProperty(typeofTypesByName, literal.text);
+                    if (targetType && isTypeSubtypeOf(targetType, type)) {
+                        return targetType;
+                    }
+                }
+                var facts = assumeTrue ?
+                    ts.getProperty(typeofEQFacts, literal.text) || 64 /* TypeofEQHostObject */ :
+                    ts.getProperty(typeofNEFacts, literal.text) || 8192 /* TypeofNEHostObject */;
+                return getTypeWithFacts(type, facts);
+            }
+            function narrowTypeByDiscriminant(type, propAccess, operator, value, assumeTrue) {
+                // We have '==', '!=', '===', or '!==' operator with property access as target
+                if (!isMatchingReference(reference, propAccess.expression)) {
+                    return type;
+                }
+                var propName = propAccess.name.text;
+                var propType = getTypeOfPropertyOfType(type, propName);
+                if (!propType || !isStringLiteralUnionType(propType)) {
+                    return type;
+                }
+                var discriminantType = value.kind === 9 /* StringLiteral */ ? getStringLiteralTypeForText(value.text) : checkExpression(value);
+                if (!isStringLiteralUnionType(discriminantType)) {
+                    return type;
+                }
+                if (operator === 31 /* ExclamationEqualsToken */ || operator === 33 /* ExclamationEqualsEqualsToken */) {
+                    assumeTrue = !assumeTrue;
+                }
+                if (assumeTrue) {
+                    return filterType(type, function (t) { return areTypesComparable(getTypeOfPropertyOfType(t, propName), discriminantType); });
+                }
+                if (discriminantType.flags & 256 /* StringLiteral */) {
+                    return filterType(type, function (t) { return getTypeOfPropertyOfType(t, propName) !== discriminantType; });
+                }
+                return type;
+            }
+            function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
+                // We have switch statement with property access expression
+                if (!isMatchingReference(reference, switchStatement.expression.expression)) {
+                    return type;
+                }
+                var propName = switchStatement.expression.name.text;
+                var propType = getTypeOfPropertyOfType(type, propName);
+                if (!propType || !isStringLiteralUnionType(propType)) {
+                    return type;
+                }
+                var switchTypes = getSwitchClauseTypes(switchStatement);
+                if (!switchTypes.length) {
+                    return type;
+                }
+                var clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
+                var hasDefaultClause = clauseStart === clauseEnd || ts.contains(clauseTypes, undefined);
+                var caseTypes = hasDefaultClause ? ts.filter(clauseTypes, function (t) { return !!t; }) : clauseTypes;
+                var discriminantType = caseTypes.length ? getUnionType(caseTypes) : undefined;
+                var caseType = discriminantType && filterType(type, function (t) { return isTypeComparableTo(discriminantType, getTypeOfPropertyOfType(t, propName)); });
+                if (!hasDefaultClause) {
+                    return caseType;
+                }
+                var defaultType = filterType(type, function (t) { return !eachTypeContainedIn(getTypeOfPropertyOfType(t, propName), switchTypes); });
+                return caseType ? getUnionType([caseType, defaultType]) : defaultType;
+            }
+            function narrowTypeByInstanceof(type, expr, assumeTrue) {
+                var left = getReferenceFromExpression(expr.left);
+                if (!isMatchingReference(reference, left)) {
+                    // For a reference of the form 'x.y', an 'x instanceof T' type guard resets the
+                    // narrowed type of 'y' to its declared type.
+                    if (containsMatchingReference(reference, left)) {
+                        return declaredType;
+                    }
+                    return type;
+                }
+                // We never narrow type any in an instanceof guard
+                if (isTypeAny(type)) {
+                    return type;
+                }
+                // Check that right operand is a function type with a prototype property
+                var rightType = checkExpression(expr.right);
+                if (!isTypeSubtypeOf(rightType, globalFunctionType)) {
+                    return type;
+                }
+                var targetType;
+                var prototypeProperty = getPropertyOfType(rightType, "prototype");
+                if (prototypeProperty) {
+                    // Target type is type of the prototype property
+                    var prototypePropertyType = getTypeOfSymbol(prototypeProperty);
+                    if (!isTypeAny(prototypePropertyType)) {
+                        targetType = prototypePropertyType;
+                    }
+                }
+                if (!targetType) {
+                    // Target type is type of construct signature
+                    var constructSignatures = void 0;
+                    if (rightType.flags & 2048 /* Interface */) {
+                        constructSignatures = resolveDeclaredMembers(rightType).declaredConstructSignatures;
+                    }
+                    else if (rightType.flags & 65536 /* Anonymous */) {
+                        constructSignatures = getSignaturesOfType(rightType, 1 /* Construct */);
+                    }
+                    if (constructSignatures && constructSignatures.length) {
+                        targetType = getUnionType(ts.map(constructSignatures, function (signature) { return getReturnTypeOfSignature(getErasedSignature(signature)); }));
+                    }
+                }
+                if (targetType) {
+                    return getNarrowedType(type, targetType, assumeTrue);
+                }
+                return type;
+            }
+            function getNarrowedType(type, candidate, assumeTrue) {
+                if (!assumeTrue) {
+                    return type.flags & 16384 /* Union */ ?
+                        getUnionType(ts.filter(type.types, function (t) { return !isTypeSubtypeOf(t, candidate); })) :
+                        type;
+                }
+                // If the current type is a union type, remove all constituents that aren't assignable to
+                // the candidate type. If one or more constituents remain, return a union of those.
+                if (type.flags & 16384 /* Union */) {
+                    var assignableConstituents = ts.filter(type.types, function (t) { return isTypeAssignableTo(t, candidate); });
+                    if (assignableConstituents.length) {
+                        return getUnionType(assignableConstituents);
+                    }
+                }
+                // If the candidate type is assignable to the target type, narrow to the candidate type.
+                // Otherwise, if the current type is assignable to the candidate, keep the current type.
+                // Otherwise, the types are completely unrelated, so narrow to the empty type.
+                var targetType = type.flags & 512 /* TypeParameter */ ? getApparentType(type) : type;
+                return isTypeAssignableTo(candidate, targetType) ? candidate :
+                    isTypeAssignableTo(type, candidate) ? type :
+                        getIntersectionType([type, candidate]);
+            }
+            function narrowTypeByTypePredicate(type, callExpression, assumeTrue) {
+                if (type.flags & 1 /* Any */ || !hasMatchingArgument(callExpression, reference)) {
+                    return type;
+                }
+                var signature = getResolvedSignature(callExpression);
+                var predicate = signature.typePredicate;
+                if (!predicate) {
+                    return type;
+                }
+                if (ts.isIdentifierTypePredicate(predicate)) {
+                    var predicateArgument = callExpression.arguments[predicate.parameterIndex];
+                    if (predicateArgument) {
+                        if (isMatchingReference(reference, predicateArgument)) {
+                            return getNarrowedType(type, predicate.type, assumeTrue);
+                        }
+                        if (containsMatchingReference(reference, predicateArgument)) {
+                            return declaredType;
+                        }
+                    }
+                }
+                else {
+                    var invokedExpression = skipParenthesizedNodes(callExpression.expression);
+                    if (invokedExpression.kind === 173 /* ElementAccessExpression */ || invokedExpression.kind === 172 /* PropertyAccessExpression */) {
+                        var accessExpression = invokedExpression;
+                        var possibleReference = skipParenthesizedNodes(accessExpression.expression);
+                        if (isMatchingReference(reference, possibleReference)) {
+                            return getNarrowedType(type, predicate.type, assumeTrue);
+                        }
+                        if (containsMatchingReference(reference, possibleReference)) {
+                            return declaredType;
+                        }
+                    }
+                }
+                return type;
+            }
+            // Narrow the given type based on the given expression having the assumed boolean value. The returned type
+            // will be a subtype or the same type as the argument.
+            function narrowType(type, expr, assumeTrue) {
+                switch (expr.kind) {
+                    case 69 /* Identifier */:
+                    case 97 /* ThisKeyword */:
+                    case 172 /* PropertyAccessExpression */:
+                        return narrowTypeByTruthiness(type, expr, assumeTrue);
+                    case 174 /* CallExpression */:
+                        return narrowTypeByTypePredicate(type, expr, assumeTrue);
+                    case 178 /* ParenthesizedExpression */:
+                        return narrowType(type, expr.expression, assumeTrue);
+                    case 187 /* BinaryExpression */:
+                        return narrowTypeByBinaryExpression(type, expr, assumeTrue);
+                    case 185 /* PrefixUnaryExpression */:
+                        if (expr.operator === 49 /* ExclamationToken */) {
+                            return narrowType(type, expr.operand, !assumeTrue);
+                        }
+                        break;
+                }
+                return type;
+            }
+        }
+        function getTypeOfSymbolAtLocation(symbol, location) {
+            // If we have an identifier or a property access at the given location, if the location is
+            // an dotted name expression, and if the location is not an assignment target, obtain the type
+            // of the expression (which will reflect control flow analysis). If the expression indeed
+            // resolved to the given symbol, return the narrowed type.
+            if (location.kind === 69 /* Identifier */) {
+                if (ts.isRightSideOfQualifiedNameOrPropertyAccess(location)) {
+                    location = location.parent;
+                }
+                if (ts.isExpression(location) && !ts.isAssignmentTarget(location)) {
+                    var type = checkExpression(location);
+                    if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
+                        return type;
+                    }
+                }
+            }
+            // The location isn't a reference to the given symbol, meaning we're being asked
+            // a hypothetical question of what type the symbol would have if there was a reference
+            // to it at the given location. Since we have no control flow information for the
+            // hypotherical reference (control flow information is created and attached by the
+            // binder), we simply return the declared type of the symbol.
+            return getTypeOfSymbol(symbol);
+        }
+        function skipParenthesizedNodes(expression) {
+            while (expression.kind === 178 /* ParenthesizedExpression */) {
+                expression = expression.expression;
+            }
+            return expression;
+        }
+        function getControlFlowContainer(node) {
+            while (true) {
+                node = node.parent;
+                if (ts.isFunctionLike(node) || node.kind === 226 /* ModuleBlock */ || node.kind === 256 /* SourceFile */ || node.kind === 145 /* PropertyDeclaration */) {
+                    return node;
+                }
+            }
+        }
+        function isDeclarationIncludedInFlow(reference, declaration, includeOuterFunctions) {
+            var declarationContainer = getControlFlowContainer(declaration);
+            var container = getControlFlowContainer(reference);
+            while (container !== declarationContainer &&
+                (container.kind === 179 /* FunctionExpression */ || container.kind === 180 /* ArrowFunction */) &&
+                (includeOuterFunctions || ts.getImmediatelyInvokedFunctionExpression(container))) {
+                container = getControlFlowContainer(container);
+            }
+            return container === declarationContainer;
+        }
+        function checkIdentifier(node) {
+            var symbol = getResolvedSymbol(node);
+            // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects.
+            // Although in down-level emit of arrow function, we emit it using function expression which means that
+            // arguments objects will be bound to the inner object; emitting arrow function natively in ES6, arguments objects
+            // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior.
+            // To avoid that we will give an error to users if they use arguments objects in arrow function so that they
+            // can explicitly bound arguments objects
+            if (symbol === argumentsSymbol) {
+                var container = ts.getContainingFunction(node);
+                if (container.kind === 180 /* ArrowFunction */) {
+                    if (languageVersion < 2 /* ES6 */) {
+                        error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
+                    }
+                }
+                if (node.flags & 33554432 /* AwaitContext */) {
+                    getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
+                }
+            }
+            if (symbol.flags & 8388608 /* Alias */ && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
+                markAliasSymbolAsReferenced(symbol);
+            }
+            var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
+            // Due to the emit for class decorators, any reference to the class from inside of the class body
+            // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
+            // behavior of class names in ES6.
+            if (languageVersion === 2 /* ES6 */
+                && localOrExportSymbol.flags & 32 /* Class */
+                && localOrExportSymbol.valueDeclaration.kind === 221 /* ClassDeclaration */
+                && ts.nodeIsDecorated(localOrExportSymbol.valueDeclaration)) {
+                var container = ts.getContainingClass(node);
+                while (container !== undefined) {
+                    if (container === localOrExportSymbol.valueDeclaration && container.name !== node) {
+                        getNodeLinks(container).flags |= 524288 /* ClassWithBodyScopedClassBinding */;
+                        getNodeLinks(node).flags |= 1048576 /* BodyScopedClassBinding */;
+                        break;
+                    }
+                    container = ts.getContainingClass(container);
+                }
+            }
+            checkCollisionWithCapturedSuperVariable(node, node);
+            checkCollisionWithCapturedThisVariable(node, node);
+            checkNestedBlockScopedBinding(node, symbol);
+            var type = getTypeOfSymbol(localOrExportSymbol);
+            if (!(localOrExportSymbol.flags & 3 /* Variable */) || ts.isAssignmentTarget(node)) {
+                return type;
+            }
+            var declaration = localOrExportSymbol.valueDeclaration;
+            var includeOuterFunctions = isReadonlySymbol(localOrExportSymbol);
+            var assumeInitialized = !strictNullChecks || (type.flags & 1 /* Any */) !== 0 || !declaration ||
+                ts.getRootDeclaration(declaration).kind === 142 /* Parameter */ || ts.isInAmbientContext(declaration) ||
+                !isDeclarationIncludedInFlow(node, declaration, includeOuterFunctions);
+            var flowType = getFlowTypeOfReference(node, type, assumeInitialized, includeOuterFunctions);
+            if (!assumeInitialized && !(getCombinedTypeFlags(type) & 32 /* Undefined */) && getCombinedTypeFlags(flowType) & 32 /* Undefined */) {
+                error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
+                // Return the declared type to reduce follow-on errors
+                return type;
+            }
+            return flowType;
+        }
+        function isInsideFunction(node, threshold) {
+            var current = node;
+            while (current && current !== threshold) {
+                if (ts.isFunctionLike(current)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function checkNestedBlockScopedBinding(node, symbol) {
+            if (languageVersion >= 2 /* ES6 */ ||
+                (symbol.flags & (2 /* BlockScopedVariable */ | 32 /* Class */)) === 0 ||
+                symbol.valueDeclaration.parent.kind === 252 /* CatchClause */) {
+                return;
+            }
+            // 1. walk from the use site up to the declaration and check
+            // if there is anything function like between declaration and use-site (is binding/class is captured in function).
+            // 2. walk from the declaration up to the boundary of lexical environment and check
+            // if there is an iteration statement in between declaration and boundary (is binding/class declared inside iteration statement)
+            var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+            var usedInFunction = isInsideFunction(node.parent, container);
+            var current = container;
+            var containedInIterationStatement = false;
+            while (current && !ts.nodeStartsNewLexicalEnvironment(current)) {
+                if (ts.isIterationStatement(current, /*lookInLabeledStatements*/ false)) {
+                    containedInIterationStatement = true;
+                    break;
+                }
+                current = current.parent;
+            }
+            if (containedInIterationStatement) {
+                if (usedInFunction) {
+                    // mark iteration statement as containing block-scoped binding captured in some function
+                    getNodeLinks(current).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+                }
+                // mark variables that are declared in loop initializer and reassigned inside the body of ForStatement.
+                // if body of ForStatement will be converted to function then we'll need a extra machinery to propagate reassigned values back.
+                if (container.kind === 206 /* ForStatement */ &&
+                    ts.getAncestor(symbol.valueDeclaration, 219 /* VariableDeclarationList */).parent === container &&
+                    isAssignedInBodyOfForStatement(node, container)) {
+                    getNodeLinks(symbol.valueDeclaration).flags |= 2097152 /* NeedsLoopOutParameter */;
+                }
+                // set 'declared inside loop' bit on the block-scoped binding
+                getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* BlockScopedBindingInLoop */;
+            }
+            if (usedInFunction) {
+                getNodeLinks(symbol.valueDeclaration).flags |= 131072 /* CapturedBlockScopedBinding */;
+            }
+        }
+        function isAssignedInBodyOfForStatement(node, container) {
+            var current = node;
+            // skip parenthesized nodes
+            while (current.parent.kind === 178 /* ParenthesizedExpression */) {
+                current = current.parent;
+            }
+            // check if node is used as LHS in some assignment expression
+            var isAssigned = false;
+            if (ts.isAssignmentTarget(current)) {
+                isAssigned = true;
+            }
+            else if ((current.parent.kind === 185 /* PrefixUnaryExpression */ || current.parent.kind === 186 /* PostfixUnaryExpression */)) {
+                var expr = current.parent;
+                isAssigned = expr.operator === 41 /* PlusPlusToken */ || expr.operator === 42 /* MinusMinusToken */;
+            }
+            if (!isAssigned) {
+                return false;
+            }
+            // at this point we know that node is the target of assignment
+            // now check that modification happens inside the statement part of the ForStatement
+            while (current !== container) {
+                if (current === container.statement) {
+                    return true;
+                }
+                else {
+                    current = current.parent;
+                }
+            }
+            return false;
+        }
+        function captureLexicalThis(node, container) {
+            getNodeLinks(node).flags |= 2 /* LexicalThis */;
+            if (container.kind === 145 /* PropertyDeclaration */ || container.kind === 148 /* Constructor */) {
+                var classNode = container.parent;
+                getNodeLinks(classNode).flags |= 4 /* CaptureThis */;
+            }
+            else {
+                getNodeLinks(container).flags |= 4 /* CaptureThis */;
+            }
+        }
+        function findFirstSuperCall(n) {
+            if (ts.isSuperCallExpression(n)) {
+                return n;
+            }
+            else if (ts.isFunctionLike(n)) {
+                return undefined;
+            }
+            return ts.forEachChild(n, findFirstSuperCall);
+        }
+        /**
+         * Return a cached result if super-statement is already found.
+         * Otherwise, find a super statement in a given constructor function and cache the result in the node-links of the constructor
+         *
+         * @param constructor constructor-function to look for super statement
+         */
+        function getSuperCallInConstructor(constructor) {
+            var links = getNodeLinks(constructor);
+            // Only trying to find super-call if we haven't yet tried to find one.  Once we try, we will record the result
+            if (links.hasSuperCall === undefined) {
+                links.superCall = findFirstSuperCall(constructor.body);
+                links.hasSuperCall = links.superCall ? true : false;
+            }
+            return links.superCall;
+        }
+        /**
+         * Check if the given class-declaration extends null then return true.
+         * Otherwise, return false
+         * @param classDecl a class declaration to check if it extends null
+         */
+        function classDeclarationExtendsNull(classDecl) {
+            var classSymbol = getSymbolOfNode(classDecl);
+            var classInstanceType = getDeclaredTypeOfSymbol(classSymbol);
+            var baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType);
+            return baseConstructorType === nullWideningType;
+        }
+        function checkThisExpression(node) {
+            // Stop at the first arrow function so that we can
+            // tell whether 'this' needs to be captured.
+            var container = ts.getThisContainer(node, /* includeArrowFunctions */ true);
+            var needToCaptureLexicalThis = false;
+            if (container.kind === 148 /* Constructor */) {
+                var containingClassDecl = container.parent;
+                var baseTypeNode = ts.getClassExtendsHeritageClauseElement(containingClassDecl);
+                // If a containing class does not have extends clause or the class extends null
+                // skip checking whether super statement is called before "this" accessing.
+                if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
+                    var superCall = getSuperCallInConstructor(container);
+                    // We should give an error in the following cases:
+                    //      - No super-call
+                    //      - "this" is accessing before super-call.
+                    //          i.e super(this)
+                    //              this.x; super();
+                    // We want to make sure that super-call is done before accessing "this" so that
+                    // "this" is not accessed as a parameter of the super-call.
+                    if (!superCall || superCall.end > node.pos) {
+                        // In ES6, super inside constructor of class-declaration has to precede "this" accessing
+                        error(node, ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class);
+                    }
+                }
+            }
+            // Now skip arrow functions to get the "real" owner of 'this'.
+            if (container.kind === 180 /* ArrowFunction */) {
+                container = ts.getThisContainer(container, /* includeArrowFunctions */ false);
+                // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code
+                needToCaptureLexicalThis = (languageVersion < 2 /* ES6 */);
+            }
+            switch (container.kind) {
+                case 225 /* ModuleDeclaration */:
+                    error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body);
+                    // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks
+                    break;
+                case 224 /* EnumDeclaration */:
+                    error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location);
+                    // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks
+                    break;
+                case 148 /* Constructor */:
+                    if (isInConstructorArgumentInitializer(node, container)) {
+                        error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments);
+                    }
+                    break;
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    if (container.flags & 32 /* Static */) {
+                        error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
+                    }
+                    break;
+                case 140 /* ComputedPropertyName */:
+                    error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
+                    break;
+            }
+            if (needToCaptureLexicalThis) {
+                captureLexicalThis(node, container);
+            }
+            if (ts.isFunctionLike(container) &&
+                (!isInParameterInitializerBeforeContainingFunction(node) || getFunctionLikeThisParameter(container))) {
+                // Note: a parameter initializer should refer to class-this unless function-this is explicitly annotated.
+                // If this is a function in a JS file, it might be a class method. Check if it's the RHS
+                // of a x.prototype.y = function [name]() { .... }
+                if (container.kind === 179 /* FunctionExpression */ &&
+                    ts.isInJavaScriptFile(container.parent) &&
+                    ts.getSpecialPropertyAssignmentKind(container.parent) === 3 /* PrototypeProperty */) {
+                    // Get the 'x' of 'x.prototype.y = f' (here, 'f' is 'container')
+                    var className = container.parent // x.prototype.y = f
+                        .left // x.prototype.y
+                        .expression // x.prototype
+                        .expression; // x
+                    var classSymbol = checkExpression(className).symbol;
+                    if (classSymbol && classSymbol.members && (classSymbol.flags & 16 /* Function */)) {
+                        return getInferredClassType(classSymbol);
+                    }
+                }
+                var type = getContextuallyTypedThisType(container);
+                if (type) {
+                    return type;
+                }
+                var thisType = getThisTypeOfDeclaration(container);
+                if (thisType) {
+                    return thisType;
+                }
+            }
+            if (ts.isClassLike(container.parent)) {
+                var symbol = getSymbolOfNode(container.parent);
+                var type = container.flags & 32 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+                return getFlowTypeOfReference(node, type, /*assumeInitialized*/ true, /*includeOuterFunctions*/ true);
+            }
+            if (ts.isInJavaScriptFile(node)) {
+                var type = getTypeForThisExpressionFromJSDoc(container);
+                if (type && type !== unknownType) {
+                    return type;
+                }
+            }
+            if (compilerOptions.noImplicitThis) {
+                // With noImplicitThis, functions may not reference 'this' if it has type 'any'
+                error(node, ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
+            }
+            return anyType;
+        }
+        function getTypeForThisExpressionFromJSDoc(node) {
+            var typeTag = ts.getJSDocTypeTag(node);
+            if (typeTag && typeTag.typeExpression && typeTag.typeExpression.type && typeTag.typeExpression.type.kind === 269 /* JSDocFunctionType */) {
+                var jsDocFunctionType = typeTag.typeExpression.type;
+                if (jsDocFunctionType.parameters.length > 0 && jsDocFunctionType.parameters[0].type.kind === 272 /* JSDocThisType */) {
+                    return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
+                }
+            }
+        }
+        function isInConstructorArgumentInitializer(node, constructorDecl) {
+            for (var n = node; n && n !== constructorDecl; n = n.parent) {
+                if (n.kind === 142 /* Parameter */) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function checkSuperExpression(node) {
+            var isCallExpression = node.parent.kind === 174 /* CallExpression */ && node.parent.expression === node;
+            var container = ts.getSuperContainer(node, /*stopOnFunctions*/ true);
+            var needToCaptureLexicalThis = false;
+            if (!isCallExpression) {
+                // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting
+                while (container && container.kind === 180 /* ArrowFunction */) {
+                    container = ts.getSuperContainer(container, /*stopOnFunctions*/ true);
+                    needToCaptureLexicalThis = languageVersion < 2 /* ES6 */;
+                }
+            }
+            var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
+            var nodeCheckFlag = 0;
+            if (!canUseSuperExpression) {
+                // issue more specific error if super is used in computed property name
+                // class A { foo() { return "1" }}
+                // class B {
+                //     [super.foo()]() {}
+                // }
+                var current = node;
+                while (current && current !== container && current.kind !== 140 /* ComputedPropertyName */) {
+                    current = current.parent;
+                }
+                if (current && current.kind === 140 /* ComputedPropertyName */) {
+                    error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
+                }
+                else if (isCallExpression) {
+                    error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
+                }
+                else if (!container || !container.parent || !(ts.isClassLike(container.parent) || container.parent.kind === 171 /* ObjectLiteralExpression */)) {
+                    error(node, ts.Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
+                }
+                else {
+                    error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
+                }
+                return unknownType;
+            }
+            if ((container.flags & 32 /* Static */) || isCallExpression) {
+                nodeCheckFlag = 512 /* SuperStatic */;
+            }
+            else {
+                nodeCheckFlag = 256 /* SuperInstance */;
+            }
+            getNodeLinks(node).flags |= nodeCheckFlag;
+            // Due to how we emit async functions, we need to specialize the emit for an async method that contains a `super` reference.
+            // This is due to the fact that we emit the body of an async function inside of a generator function. As generator
+            // functions cannot reference `super`, we emit a helper inside of the method body, but outside of the generator. This helper
+            // uses an arrow function, which is permitted to reference `super`.
+            //
+            // There are two primary ways we can access `super` from within an async method. The first is getting the value of a property
+            // or indexed access on super, either as part of a right-hand-side expression or call expression. The second is when setting the value
+            // of a property or indexed access, either as part of an assignment expression or destructuring assignment.
+            //
+            // The simplest case is reading a value, in which case we will emit something like the following:
+            //
+            //  // ts
+            //  ...
+            //  async asyncMethod() {
+            //    let x = await super.asyncMethod();
+            //    return x;
+            //  }
+            //  ...
+            //
+            //  // js
+            //  ...
+            //  asyncMethod() {
+            //      const _super = name => super[name];
+            //      return __awaiter(this, arguments, Promise, function *() {
+            //          let x = yield _super("asyncMethod").call(this);
+            //          return x;
+            //      });
+            //  }
+            //  ...
+            //
+            // The more complex case is when we wish to assign a value, especially as part of a destructuring assignment. As both cases
+            // are legal in ES6, but also likely less frequent, we emit the same more complex helper for both scenarios:
+            //
+            //  // ts
+            //  ...
+            //  async asyncMethod(ar: Promise<any[]>) {
+            //      [super.a, super.b] = await ar;
+            //  }
+            //  ...
+            //
+            //  // js
+            //  ...
+            //  asyncMethod(ar) {
+            //      const _super = (function (geti, seti) {
+            //          const cache = Object.create(null);
+            //          return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });
+            //      })(name => super[name], (name, value) => super[name] = value);
+            //      return __awaiter(this, arguments, Promise, function *() {
+            //          [_super("a").value, _super("b").value] = yield ar;
+            //      });
+            //  }
+            //  ...
+            //
+            // This helper creates an object with a "value" property that wraps the `super` property or indexed access for both get and set.
+            // This is required for destructuring assignments, as a call expression cannot be used as the target of a destructuring assignment
+            // while a property access can.
+            if (container.kind === 147 /* MethodDeclaration */ && container.flags & 256 /* Async */) {
+                if (ts.isSuperPropertyOrElementAccess(node.parent) && ts.isAssignmentTarget(node.parent)) {
+                    getNodeLinks(container).flags |= 4096 /* AsyncMethodWithSuperBinding */;
+                }
+                else {
+                    getNodeLinks(container).flags |= 2048 /* AsyncMethodWithSuper */;
+                }
+            }
+            if (needToCaptureLexicalThis) {
+                // call expressions are allowed only in constructors so they should always capture correct 'this'
+                // super property access expressions can also appear in arrow functions -
+                // in this case they should also use correct lexical this
+                captureLexicalThis(node.parent, container);
+            }
+            if (container.parent.kind === 171 /* ObjectLiteralExpression */) {
+                if (languageVersion < 2 /* ES6 */) {
+                    error(node, ts.Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
+                    return unknownType;
+                }
+                else {
+                    // for object literal assume that type of 'super' is 'any'
+                    return anyType;
+                }
+            }
+            // at this point the only legal case for parent is ClassLikeDeclaration
+            var classLikeDeclaration = container.parent;
+            var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
+            var baseClassType = classType && getBaseTypes(classType)[0];
+            if (!baseClassType) {
+                if (!ts.getClassExtendsHeritageClauseElement(classLikeDeclaration)) {
+                    error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class);
+                }
+                return unknownType;
+            }
+            if (container.kind === 148 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) {
+                // issue custom error message for super property access in constructor arguments (to be aligned with old compiler)
+                error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
+                return unknownType;
+            }
+            return nodeCheckFlag === 512 /* SuperStatic */
+                ? getBaseConstructorTypeOfClass(classType)
+                : getTypeWithThisArgument(baseClassType, classType.thisType);
+            function isLegalUsageOfSuperExpression(container) {
+                if (!container) {
+                    return false;
+                }
+                if (isCallExpression) {
+                    // TS 1.0 SPEC (April 2014): 4.8.1
+                    // Super calls are only permitted in constructors of derived classes
+                    return container.kind === 148 /* Constructor */;
+                }
+                else {
+                    // TS 1.0 SPEC (April 2014)
+                    // 'super' property access is allowed
+                    // - In a constructor, instance member function, instance member accessor, or instance member variable initializer where this references a derived class instance
+                    // - In a static member function or static member accessor
+                    // topmost container must be something that is directly nested in the class declaration\object literal expression
+                    if (ts.isClassLike(container.parent) || container.parent.kind === 171 /* ObjectLiteralExpression */) {
+                        if (container.flags & 32 /* Static */) {
+                            return container.kind === 147 /* MethodDeclaration */ ||
+                                container.kind === 146 /* MethodSignature */ ||
+                                container.kind === 149 /* GetAccessor */ ||
+                                container.kind === 150 /* SetAccessor */;
+                        }
+                        else {
+                            return container.kind === 147 /* MethodDeclaration */ ||
+                                container.kind === 146 /* MethodSignature */ ||
+                                container.kind === 149 /* GetAccessor */ ||
+                                container.kind === 150 /* SetAccessor */ ||
+                                container.kind === 145 /* PropertyDeclaration */ ||
+                                container.kind === 144 /* PropertySignature */ ||
+                                container.kind === 148 /* Constructor */;
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+        function getContextuallyTypedThisType(func) {
+            if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== 180 /* ArrowFunction */) {
+                var contextualSignature = getContextualSignature(func);
+                if (contextualSignature) {
+                    return getThisTypeOfSignature(contextualSignature);
+                }
+            }
+            return undefined;
+        }
+        // Return contextual type of parameter or undefined if no contextual type is available
+        function getContextuallyTypedParameterType(parameter) {
+            var func = parameter.parent;
+            if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
+                var iife = ts.getImmediatelyInvokedFunctionExpression(func);
+                if (iife) {
+                    var indexOfParameter = ts.indexOf(func.parameters, parameter);
+                    if (iife.arguments && indexOfParameter < iife.arguments.length) {
+                        if (parameter.dotDotDotToken) {
+                            var restTypes = [];
+                            for (var i = indexOfParameter; i < iife.arguments.length; i++) {
+                                restTypes.push(getTypeOfExpression(iife.arguments[i]));
+                            }
+                            return createArrayType(getUnionType(restTypes));
+                        }
+                        var links = getNodeLinks(iife);
+                        var cached = links.resolvedSignature;
+                        links.resolvedSignature = anySignature;
+                        var type = checkExpression(iife.arguments[indexOfParameter]);
+                        links.resolvedSignature = cached;
+                        return type;
+                    }
+                }
+                var contextualSignature = getContextualSignature(func);
+                if (contextualSignature) {
+                    var funcHasRestParameters = ts.hasRestParameter(func);
+                    var len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
+                    var indexOfParameter = ts.indexOf(func.parameters, parameter);
+                    if (indexOfParameter < len) {
+                        return getTypeAtPosition(contextualSignature, indexOfParameter);
+                    }
+                    // If last parameter is contextually rest parameter get its type
+                    if (funcHasRestParameters &&
+                        indexOfParameter === (func.parameters.length - 1) &&
+                        isRestParameterIndex(contextualSignature, func.parameters.length - 1)) {
+                        return getTypeOfSymbol(ts.lastOrUndefined(contextualSignature.parameters));
+                    }
+                }
+            }
+            return undefined;
+        }
+        // In a variable, parameter or property declaration with a type annotation,
+        //   the contextual type of an initializer expression is the type of the variable, parameter or property.
+        // Otherwise, in a parameter declaration of a contextually typed function expression,
+        //   the contextual type of an initializer expression is the contextual type of the parameter.
+        // Otherwise, in a variable or parameter declaration with a binding pattern name,
+        //   the contextual type of an initializer expression is the type implied by the binding pattern.
+        // Otherwise, in a binding pattern inside a variable or parameter declaration,
+        //   the contextual type of an initializer expression is the type annotation of the containing declaration, if present.
+        function getContextualTypeForInitializerExpression(node) {
+            var declaration = node.parent;
+            if (node === declaration.initializer) {
+                if (declaration.type) {
+                    return getTypeFromTypeNode(declaration.type);
+                }
+                if (declaration.kind === 142 /* Parameter */) {
+                    var type = getContextuallyTypedParameterType(declaration);
+                    if (type) {
+                        return type;
+                    }
+                }
+                if (ts.isBindingPattern(declaration.name)) {
+                    return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true);
+                }
+                if (ts.isBindingPattern(declaration.parent)) {
+                    var parentDeclaration = declaration.parent.parent;
+                    var name_12 = declaration.propertyName || declaration.name;
+                    if (ts.isVariableLike(parentDeclaration) &&
+                        parentDeclaration.type &&
+                        !ts.isBindingPattern(name_12)) {
+                        var text = getTextOfPropertyName(name_12);
+                        if (text) {
+                            return getTypeOfPropertyOfType(getTypeFromTypeNode(parentDeclaration.type), text);
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
+        function getContextualTypeForReturnExpression(node) {
+            var func = ts.getContainingFunction(node);
+            if (ts.isAsyncFunctionLike(func)) {
+                var contextualReturnType = getContextualReturnType(func);
+                if (contextualReturnType) {
+                    return getPromisedType(contextualReturnType);
+                }
+                return undefined;
+            }
+            if (func && !func.asteriskToken) {
+                return getContextualReturnType(func);
+            }
+            return undefined;
+        }
+        function getContextualTypeForYieldOperand(node) {
+            var func = ts.getContainingFunction(node);
+            if (func) {
+                var contextualReturnType = getContextualReturnType(func);
+                if (contextualReturnType) {
+                    return node.asteriskToken
+                        ? contextualReturnType
+                        : getElementTypeOfIterableIterator(contextualReturnType);
+                }
+            }
+            return undefined;
+        }
+        function isInParameterInitializerBeforeContainingFunction(node) {
+            while (node.parent && !ts.isFunctionLike(node.parent)) {
+                if (node.parent.kind === 142 /* Parameter */ && node.parent.initializer === node) {
+                    return true;
+                }
+                node = node.parent;
+            }
+            return false;
+        }
+        function getContextualReturnType(functionDecl) {
+            // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
+            // corresponding set accessor has a type annotation, return statements in the function are contextually typed
+            if (functionDecl.type ||
+                functionDecl.kind === 148 /* Constructor */ ||
+                functionDecl.kind === 149 /* GetAccessor */ && ts.getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 150 /* SetAccessor */))) {
+                return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl));
+            }
+            // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature
+            // and that call signature is non-generic, return statements are contextually typed by the return type of the signature
+            var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
+            if (signature) {
+                return getReturnTypeOfSignature(signature);
+            }
+            return undefined;
+        }
+        // In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter.
+        function getContextualTypeForArgument(callTarget, arg) {
+            var args = getEffectiveCallArguments(callTarget);
+            var argIndex = ts.indexOf(args, arg);
+            if (argIndex >= 0) {
+                var signature = getResolvedOrAnySignature(callTarget);
+                return getTypeAtPosition(signature, argIndex);
+            }
+            return undefined;
+        }
+        function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
+            if (template.parent.kind === 176 /* TaggedTemplateExpression */) {
+                return getContextualTypeForArgument(template.parent, substitutionExpression);
+            }
+            return undefined;
+        }
+        function getContextualTypeForBinaryOperand(node) {
+            var binaryExpression = node.parent;
+            var operator = binaryExpression.operatorToken.kind;
+            if (operator >= 56 /* FirstAssignment */ && operator <= 68 /* LastAssignment */) {
+                // In an assignment expression, the right operand is contextually typed by the type of the left operand.
+                if (node === binaryExpression.right) {
+                    return checkExpression(binaryExpression.left);
+                }
+            }
+            else if (operator === 52 /* BarBarToken */) {
+                // When an || expression has a contextual type, the operands are contextually typed by that type. When an ||
+                // expression has no contextual type, the right operand is contextually typed by the type of the left operand.
+                var type = getContextualType(binaryExpression);
+                if (!type && node === binaryExpression.right) {
+                    type = checkExpression(binaryExpression.left);
+                }
+                return type;
+            }
+            else if (operator === 51 /* AmpersandAmpersandToken */ || operator === 24 /* CommaToken */) {
+                if (node === binaryExpression.right) {
+                    return getContextualType(binaryExpression);
+                }
+            }
+            return undefined;
+        }
+        // Apply a mapping function to a contextual type and return the resulting type. If the contextual type
+        // is a union type, the mapping function is applied to each constituent type and a union of the resulting
+        // types is returned.
+        function applyToContextualType(type, mapper) {
+            if (!(type.flags & 16384 /* Union */)) {
+                return mapper(type);
+            }
+            var types = type.types;
+            var mappedType;
+            var mappedTypes;
+            for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+                var current = types_8[_i];
+                var t = mapper(current);
+                if (t) {
+                    if (!mappedType) {
+                        mappedType = t;
+                    }
+                    else if (!mappedTypes) {
+                        mappedTypes = [mappedType, t];
+                    }
+                    else {
+                        mappedTypes.push(t);
+                    }
+                }
+            }
+            return mappedTypes ? getUnionType(mappedTypes) : mappedType;
+        }
+        function getTypeOfPropertyOfContextualType(type, name) {
+            return applyToContextualType(type, function (t) {
+                var prop = t.flags & 130048 /* StructuredType */ ? getPropertyOfType(t, name) : undefined;
+                return prop ? getTypeOfSymbol(prop) : undefined;
+            });
+        }
+        function getIndexTypeOfContextualType(type, kind) {
+            return applyToContextualType(type, function (t) { return getIndexTypeOfStructuredType(t, kind); });
+        }
+        // Return true if the given contextual type is a tuple-like type
+        function contextualTypeIsTupleLikeType(type) {
+            return !!(type.flags & 16384 /* Union */ ? ts.forEach(type.types, isTupleLikeType) : isTupleLikeType(type));
+        }
+        // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of
+        // the matching property in T, if one exists. Otherwise, it is the type of the numeric index signature in T, if one
+        // exists. Otherwise, it is the type of the string index signature in T, if one exists.
+        function getContextualTypeForObjectLiteralMethod(node) {
+            ts.Debug.assert(ts.isObjectLiteralMethod(node));
+            if (isInsideWithStatementBody(node)) {
+                // We cannot answer semantic questions within a with block, do not proceed any further
+                return undefined;
+            }
+            return getContextualTypeForObjectLiteralElement(node);
+        }
+        function getContextualTypeForObjectLiteralElement(element) {
+            var objectLiteral = element.parent;
+            var type = getApparentTypeOfContextualType(objectLiteral);
+            if (type) {
+                if (!ts.hasDynamicName(element)) {
+                    // For a (non-symbol) computed property, there is no reason to look up the name
+                    // in the type. It will just be "__computed", which does not appear in any
+                    // SymbolTable.
+                    var symbolName = getSymbolOfNode(element).name;
+                    var propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
+                    if (propertyType) {
+                        return propertyType;
+                    }
+                }
+                return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1 /* Number */) ||
+                    getIndexTypeOfContextualType(type, 0 /* String */);
+            }
+            return undefined;
+        }
+        // In an array literal contextually typed by a type T, the contextual type of an element expression at index N is
+        // the type of the property with the numeric name N in T, if one exists. Otherwise, if T has a numeric index signature,
+        // it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated
+        // type of T.
+        function getContextualTypeForElementExpression(node) {
+            var arrayLiteral = node.parent;
+            var type = getApparentTypeOfContextualType(arrayLiteral);
+            if (type) {
+                var index = ts.indexOf(arrayLiteral.elements, node);
+                return getTypeOfPropertyOfContextualType(type, "" + index)
+                    || getIndexTypeOfContextualType(type, 1 /* Number */)
+                    || (languageVersion >= 2 /* ES6 */ ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined);
+            }
+            return undefined;
+        }
+        // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type.
+        function getContextualTypeForConditionalOperand(node) {
+            var conditional = node.parent;
+            return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined;
+        }
+        function getContextualTypeForJsxAttribute(attribute) {
+            var kind = attribute.kind;
+            var jsxElement = attribute.parent;
+            var attrsType = getJsxElementAttributesType(jsxElement);
+            if (attribute.kind === 246 /* JsxAttribute */) {
+                if (!attrsType || isTypeAny(attrsType)) {
+                    return undefined;
+                }
+                return getTypeOfPropertyOfType(attrsType, attribute.name.text);
+            }
+            else if (attribute.kind === 247 /* JsxSpreadAttribute */) {
+                return attrsType;
+            }
+            ts.Debug.fail("Expected JsxAttribute or JsxSpreadAttribute, got ts.SyntaxKind[" + kind + "]");
+        }
+        // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily
+        // be "pushed" onto a node using the contextualType property.
+        function getApparentTypeOfContextualType(node) {
+            var type = getContextualType(node);
+            return type && getApparentType(type);
+        }
+        /**
+         * Woah! Do you really want to use this function?
+         *
+         * Unless you're trying to get the *non-apparent* type for a
+         * value-literal type or you're authoring relevant portions of this algorithm,
+         * you probably meant to use 'getApparentTypeOfContextualType'.
+         * Otherwise this may not be very useful.
+         *
+         * In cases where you *are* working on this function, you should understand
+         * when it is appropriate to use 'getContextualType' and 'getApparentTypeOfContextualType'.
+         *
+         *   - Use 'getContextualType' when you are simply going to propagate the result to the expression.
+         *   - Use 'getApparentTypeOfContextualType' when you're going to need the members of the type.
+         *
+         * @param node the expression whose contextual type will be returned.
+         * @returns the contextual type of an expression.
+         */
+        function getContextualType(node) {
+            if (isInsideWithStatementBody(node)) {
+                // We cannot answer semantic questions within a with block, do not proceed any further
+                return undefined;
+            }
+            if (node.contextualType) {
+                return node.contextualType;
+            }
+            var parent = node.parent;
+            switch (parent.kind) {
+                case 218 /* VariableDeclaration */:
+                case 142 /* Parameter */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 169 /* BindingElement */:
+                    return getContextualTypeForInitializerExpression(node);
+                case 180 /* ArrowFunction */:
+                case 211 /* ReturnStatement */:
+                    return getContextualTypeForReturnExpression(node);
+                case 190 /* YieldExpression */:
+                    return getContextualTypeForYieldOperand(parent);
+                case 174 /* CallExpression */:
+                case 175 /* NewExpression */:
+                    return getContextualTypeForArgument(parent, node);
+                case 177 /* TypeAssertionExpression */:
+                case 195 /* AsExpression */:
+                    return getTypeFromTypeNode(parent.type);
+                case 187 /* BinaryExpression */:
+                    return getContextualTypeForBinaryOperand(node);
+                case 253 /* PropertyAssignment */:
+                    return getContextualTypeForObjectLiteralElement(parent);
+                case 170 /* ArrayLiteralExpression */:
+                    return getContextualTypeForElementExpression(node);
+                case 188 /* ConditionalExpression */:
+                    return getContextualTypeForConditionalOperand(node);
+                case 197 /* TemplateSpan */:
+                    ts.Debug.assert(parent.parent.kind === 189 /* TemplateExpression */);
+                    return getContextualTypeForSubstitutionExpression(parent.parent, node);
+                case 178 /* ParenthesizedExpression */:
+                    return getContextualType(parent);
+                case 248 /* JsxExpression */:
+                    return getContextualType(parent);
+                case 246 /* JsxAttribute */:
+                case 247 /* JsxSpreadAttribute */:
+                    return getContextualTypeForJsxAttribute(parent);
+            }
+            return undefined;
+        }
+        // If the given type is an object or union type, if that type has a single signature, and if
+        // that signature is non-generic, return the signature. Otherwise return undefined.
+        function getNonGenericSignature(type) {
+            var signatures = getSignaturesOfStructuredType(type, 0 /* Call */);
+            if (signatures.length === 1) {
+                var signature = signatures[0];
+                if (!signature.typeParameters) {
+                    return signature;
+                }
+            }
+        }
+        function isFunctionExpressionOrArrowFunction(node) {
+            return node.kind === 179 /* FunctionExpression */ || node.kind === 180 /* ArrowFunction */;
+        }
+        function getContextualSignatureForFunctionLikeDeclaration(node) {
+            // Only function expressions, arrow functions, and object literal methods are contextually typed.
+            return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
+                ? getContextualSignature(node)
+                : undefined;
+        }
+        function getContextualTypeForFunctionLikeDeclaration(node) {
+            return ts.isObjectLiteralMethod(node) ?
+                getContextualTypeForObjectLiteralMethod(node) :
+                getApparentTypeOfContextualType(node);
+        }
+        // Return the contextual signature for a given expression node. A contextual type provides a
+        // contextual signature if it has a single call signature and if that call signature is non-generic.
+        // If the contextual type is a union type, get the signature from each type possible and if they are
+        // all identical ignoring their return type, the result is same signature but with return type as
+        // union type of return types from these signatures
+        function getContextualSignature(node) {
+            ts.Debug.assert(node.kind !== 147 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
+            var type = getContextualTypeForFunctionLikeDeclaration(node);
+            if (!type) {
+                return undefined;
+            }
+            if (!(type.flags & 16384 /* Union */)) {
+                return getNonGenericSignature(type);
+            }
+            var signatureList;
+            var types = type.types;
+            for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+                var current = types_9[_i];
+                var signature = getNonGenericSignature(current);
+                if (signature) {
+                    if (!signatureList) {
+                        // This signature will contribute to contextual union signature
+                        signatureList = [signature];
+                    }
+                    else if (!compareSignaturesIdentical(signatureList[0], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true, compareTypesIdentical)) {
+                        // Signatures aren't identical, do not use
+                        return undefined;
+                    }
+                    else {
+                        // Use this signature for contextual union signature
+                        signatureList.push(signature);
+                    }
+                }
+            }
+            // Result is union of signatures collected (return type is union of return types of this signature set)
+            var result;
+            if (signatureList) {
+                result = cloneSignature(signatureList[0]);
+                // Clear resolved return type we possibly got from cloneSignature
+                result.resolvedReturnType = undefined;
+                result.unionSignatures = signatureList;
+            }
+            return result;
+        }
+        /**
+         * Detect if the mapper implies an inference context. Specifically, there are 4 possible values
+         * for a mapper. Let's go through each one of them:
+         *
+         *    1. undefined - this means we are not doing inferential typing, but we may do contextual typing,
+         *       which could cause us to assign a parameter a type
+         *    2. identityMapper - means we want to avoid assigning a parameter a type, whether or not we are in
+         *       inferential typing (context is undefined for the identityMapper)
+         *    3. a mapper created by createInferenceMapper - we are doing inferential typing, we want to assign
+         *       types to parameters and fix type parameters (context is defined)
+         *    4. an instantiation mapper created by createTypeMapper or createTypeEraser - this should never be
+         *       passed as the contextual mapper when checking an expression (context is undefined for these)
+         *
+         * isInferentialContext is detecting if we are in case 3
+         */
+        function isInferentialContext(mapper) {
+            return mapper && mapper.context;
+        }
+        function checkSpreadElementExpression(node, contextualMapper) {
+            // It is usually not safe to call checkExpressionCached if we can be contextually typing.
+            // You can tell that we are contextually typing because of the contextualMapper parameter.
+            // While it is true that a spread element can have a contextual type, it does not do anything
+            // with this type. It is neither affected by it, nor does it propagate it to its operand.
+            // So the fact that contextualMapper is passed is not important, because the operand of a spread
+            // element is not contextually typed.
+            var arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper);
+            return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false);
+        }
+        function hasDefaultValue(node) {
+            return (node.kind === 169 /* BindingElement */ && !!node.initializer) ||
+                (node.kind === 187 /* BinaryExpression */ && node.operatorToken.kind === 56 /* EqualsToken */);
+        }
+        function checkArrayLiteral(node, contextualMapper) {
+            var elements = node.elements;
+            var hasSpreadElement = false;
+            var elementTypes = [];
+            var inDestructuringPattern = ts.isAssignmentTarget(node);
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var e = elements_1[_i];
+                if (inDestructuringPattern && e.kind === 191 /* SpreadElementExpression */) {
+                    // Given the following situation:
+                    //    var c: {};
+                    //    [...c] = ["", 0];
+                    //
+                    // c is represented in the tree as a spread element in an array literal.
+                    // But c really functions as a rest element, and its purpose is to provide
+                    // a contextual type for the right hand side of the assignment. Therefore,
+                    // instead of calling checkExpression on "...c", which will give an error
+                    // if c is not iterable/array-like, we need to act as if we are trying to
+                    // get the contextual element type from it. So we do something similar to
+                    // getContextualTypeForElementExpression, which will crucially not error
+                    // if there is no index type / iterated type.
+                    var restArrayType = checkExpression(e.expression, contextualMapper);
+                    var restElementType = getIndexTypeOfType(restArrayType, 1 /* Number */) ||
+                        (languageVersion >= 2 /* ES6 */ ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
+                    if (restElementType) {
+                        elementTypes.push(restElementType);
+                    }
+                }
+                else {
+                    var type = checkExpression(e, contextualMapper);
+                    elementTypes.push(type);
+                }
+                hasSpreadElement = hasSpreadElement || e.kind === 191 /* SpreadElementExpression */;
+            }
+            if (!hasSpreadElement) {
+                // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
+                // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
+                if (inDestructuringPattern && elementTypes.length) {
+                    var type = createNewTupleType(elementTypes);
+                    type.pattern = node;
+                    return type;
+                }
+                var contextualType = getApparentTypeOfContextualType(node);
+                if (contextualType && contextualTypeIsTupleLikeType(contextualType)) {
+                    var pattern = contextualType.pattern;
+                    // If array literal is contextually typed by a binding pattern or an assignment pattern, pad the resulting
+                    // tuple type with the corresponding binding or assignment element types to make the lengths equal.
+                    if (pattern && (pattern.kind === 168 /* ArrayBindingPattern */ || pattern.kind === 170 /* ArrayLiteralExpression */)) {
+                        var patternElements = pattern.elements;
+                        for (var i = elementTypes.length; i < patternElements.length; i++) {
+                            var patternElement = patternElements[i];
+                            if (hasDefaultValue(patternElement)) {
+                                elementTypes.push(contextualType.elementTypes[i]);
+                            }
+                            else {
+                                if (patternElement.kind !== 193 /* OmittedExpression */) {
+                                    error(patternElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
+                                }
+                                elementTypes.push(unknownType);
+                            }
+                        }
+                    }
+                    if (elementTypes.length) {
+                        return createTupleType(elementTypes);
+                    }
+                }
+            }
+            return createArrayType(elementTypes.length ? getUnionType(elementTypes) : strictNullChecks ? neverType : undefinedWideningType);
+        }
+        function isNumericName(name) {
+            return name.kind === 140 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text);
+        }
+        function isNumericComputedName(name) {
+            // It seems odd to consider an expression of type Any to result in a numeric name,
+            // but this behavior is consistent with checkIndexedAccess
+            return isTypeAnyOrAllConstituentTypesHaveKind(checkComputedPropertyName(name), 132 /* NumberLike */);
+        }
+        function isTypeAnyOrAllConstituentTypesHaveKind(type, kind) {
+            return isTypeAny(type) || isTypeOfKind(type, kind);
+        }
+        function isNumericLiteralName(name) {
+            // The intent of numeric names is that
+            //     - they are names with text in a numeric form, and that
+            //     - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
+            //         acquired by applying the abstract 'ToNumber' operation on the name's text.
+            //
+            // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name.
+            // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold.
+            //
+            // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)'
+            // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'.
+            // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names
+            // because their 'ToString' representation is not equal to their original text.
+            // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1.
+            //
+            // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'.
+            // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation.
+            // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number.
+            //
+            // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional.
+            // This is desired behavior, because when indexing with them as numeric entities, you are indexing
+            // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
+            return (+name).toString() === name;
+        }
+        function checkComputedPropertyName(node) {
+            var links = getNodeLinks(node.expression);
+            if (!links.resolvedType) {
+                links.resolvedType = checkExpression(node.expression);
+                // This will allow types number, string, symbol or any. It will also allow enums, the unknown
+                // type, and any union of these types (like string | number).
+                if (!isTypeAnyOrAllConstituentTypesHaveKind(links.resolvedType, 132 /* NumberLike */ | 258 /* StringLike */ | 16777216 /* ESSymbol */)) {
+                    error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
+                }
+                else {
+                    checkThatExpressionIsProperSymbolReference(node.expression, links.resolvedType, /*reportError*/ true);
+                }
+            }
+            return links.resolvedType;
+        }
+        function getObjectLiteralIndexInfo(node, properties, kind) {
+            var propTypes = [];
+            for (var i = 0; i < properties.length; i++) {
+                if (kind === 0 /* String */ || isNumericName(node.properties[i].name)) {
+                    propTypes.push(getTypeOfSymbol(properties[i]));
+                }
+            }
+            var unionType = propTypes.length ? getUnionType(propTypes) : undefinedType;
+            return createIndexInfo(unionType, /*isReadonly*/ false);
+        }
+        function checkObjectLiteral(node, contextualMapper) {
+            var inDestructuringPattern = ts.isAssignmentTarget(node);
+            // Grammar checking
+            checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
+            var propertiesTable = {};
+            var propertiesArray = [];
+            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualTypeHasPattern = contextualType && contextualType.pattern &&
+                (contextualType.pattern.kind === 167 /* ObjectBindingPattern */ || contextualType.pattern.kind === 171 /* ObjectLiteralExpression */);
+            var typeFlags = 0;
+            var patternWithComputedProperties = false;
+            var hasComputedStringProperty = false;
+            var hasComputedNumberProperty = false;
+            for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+                var memberDecl = _a[_i];
+                var member = memberDecl.symbol;
+                if (memberDecl.kind === 253 /* PropertyAssignment */ ||
+                    memberDecl.kind === 254 /* ShorthandPropertyAssignment */ ||
+                    ts.isObjectLiteralMethod(memberDecl)) {
+                    var type = void 0;
+                    if (memberDecl.kind === 253 /* PropertyAssignment */) {
+                        type = checkPropertyAssignment(memberDecl, contextualMapper);
+                    }
+                    else if (memberDecl.kind === 147 /* MethodDeclaration */) {
+                        type = checkObjectLiteralMethod(memberDecl, contextualMapper);
+                    }
+                    else {
+                        ts.Debug.assert(memberDecl.kind === 254 /* ShorthandPropertyAssignment */);
+                        type = checkExpression(memberDecl.name, contextualMapper);
+                    }
+                    typeFlags |= type.flags;
+                    var prop = createSymbol(4 /* Property */ | 67108864 /* Transient */ | member.flags, member.name);
+                    if (inDestructuringPattern) {
+                        // If object literal is an assignment pattern and if the assignment pattern specifies a default value
+                        // for the property, make the property optional.
+                        var isOptional = (memberDecl.kind === 253 /* PropertyAssignment */ && hasDefaultValue(memberDecl.initializer)) ||
+                            (memberDecl.kind === 254 /* ShorthandPropertyAssignment */ && memberDecl.objectAssignmentInitializer);
+                        if (isOptional) {
+                            prop.flags |= 536870912 /* Optional */;
+                        }
+                        if (ts.hasDynamicName(memberDecl)) {
+                            patternWithComputedProperties = true;
+                        }
+                    }
+                    else if (contextualTypeHasPattern && !(contextualType.flags & 67108864 /* ObjectLiteralPatternWithComputedProperties */)) {
+                        // If object literal is contextually typed by the implied type of a binding pattern, and if the
+                        // binding pattern specifies a default value for the property, make the property optional.
+                        var impliedProp = getPropertyOfType(contextualType, member.name);
+                        if (impliedProp) {
+                            prop.flags |= impliedProp.flags & 536870912 /* Optional */;
+                        }
+                        else if (!compilerOptions.suppressExcessPropertyErrors) {
+                            error(memberDecl.name, ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(member), typeToString(contextualType));
+                        }
+                    }
+                    prop.declarations = member.declarations;
+                    prop.parent = member.parent;
+                    if (member.valueDeclaration) {
+                        prop.valueDeclaration = member.valueDeclaration;
+                    }
+                    prop.type = type;
+                    prop.target = member;
+                    member = prop;
+                }
+                else {
+                    // TypeScript 1.0 spec (April 2014)
+                    // A get accessor declaration is processed in the same manner as
+                    // an ordinary function declaration(section 6.1) with no parameters.
+                    // A set accessor declaration is processed in the same manner
+                    // as an ordinary function declaration with a single parameter and a Void return type.
+                    ts.Debug.assert(memberDecl.kind === 149 /* GetAccessor */ || memberDecl.kind === 150 /* SetAccessor */);
+                    checkAccessorDeclaration(memberDecl);
+                }
+                if (ts.hasDynamicName(memberDecl)) {
+                    if (isNumericName(memberDecl.name)) {
+                        hasComputedNumberProperty = true;
+                    }
+                    else {
+                        hasComputedStringProperty = true;
+                    }
+                }
+                else {
+                    propertiesTable[member.name] = member;
+                }
+                propertiesArray.push(member);
+            }
+            // If object literal is contextually typed by the implied type of a binding pattern, augment the result
+            // type with those properties for which the binding pattern specifies a default value.
+            if (contextualTypeHasPattern) {
+                for (var _b = 0, _c = getPropertiesOfType(contextualType); _b < _c.length; _b++) {
+                    var prop = _c[_b];
+                    if (!ts.hasProperty(propertiesTable, prop.name)) {
+                        if (!(prop.flags & 536870912 /* Optional */)) {
+                            error(prop.valueDeclaration || prop.bindingElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
+                        }
+                        propertiesTable[prop.name] = prop;
+                        propertiesArray.push(prop);
+                    }
+                }
+            }
+            var stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, propertiesArray, 0 /* String */) : undefined;
+            var numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, propertiesArray, 1 /* Number */) : undefined;
+            var result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
+            var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 1048576 /* FreshObjectLiteral */;
+            result.flags |= 524288 /* ObjectLiteral */ | 4194304 /* ContainsObjectLiteral */ | freshObjectLiteralFlag | (typeFlags & 14680064 /* PropagatingFlags */) | (patternWithComputedProperties ? 67108864 /* ObjectLiteralPatternWithComputedProperties */ : 0);
+            if (inDestructuringPattern) {
+                result.pattern = node;
+            }
+            return result;
+        }
+        function checkJsxSelfClosingElement(node) {
+            checkJsxOpeningLikeElement(node);
+            return jsxElementType || anyType;
+        }
+        function checkJsxElement(node) {
+            // Check attributes
+            checkJsxOpeningLikeElement(node.openingElement);
+            // Perform resolution on the closing tag so that rename/go to definition/etc work
+            if (isJsxIntrinsicIdentifier(node.closingElement.tagName)) {
+                getIntrinsicTagSymbol(node.closingElement);
+            }
+            else {
+                checkExpression(node.closingElement.tagName);
+            }
+            // Check children
+            for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
+                var child = _a[_i];
+                switch (child.kind) {
+                    case 248 /* JsxExpression */:
+                        checkJsxExpression(child);
+                        break;
+                    case 241 /* JsxElement */:
+                        checkJsxElement(child);
+                        break;
+                    case 242 /* JsxSelfClosingElement */:
+                        checkJsxSelfClosingElement(child);
+                        break;
+                }
+            }
+            return jsxElementType || anyType;
+        }
+        /**
+         * Returns true iff the JSX element name would be a valid JS identifier, ignoring restrictions about keywords not being identifiers
+         */
+        function isUnhyphenatedJsxName(name) {
+            // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers
+            return name.indexOf("-") < 0;
+        }
+        /**
+         * Returns true iff React would emit this tag name as a string rather than an identifier or qualified name
+         */
+        function isJsxIntrinsicIdentifier(tagName) {
+            // TODO (yuisu): comment
+            if (tagName.kind === 172 /* PropertyAccessExpression */ || tagName.kind === 97 /* ThisKeyword */) {
+                return false;
+            }
+            else {
+                return ts.isIntrinsicJsxName(tagName.text);
+            }
+        }
+        function checkJsxAttribute(node, elementAttributesType, nameTable) {
+            var correspondingPropType = undefined;
+            // Look up the corresponding property for this attribute
+            if (elementAttributesType === emptyObjectType && isUnhyphenatedJsxName(node.name.text)) {
+                // If there is no 'props' property, you may not have non-"data-" attributes
+                error(node.parent, ts.Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, getJsxElementPropertiesName());
+            }
+            else if (elementAttributesType && !isTypeAny(elementAttributesType)) {
+                var correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text);
+                correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol);
+                if (isUnhyphenatedJsxName(node.name.text)) {
+                    // Maybe there's a string indexer?
+                    var indexerType = getIndexTypeOfType(elementAttributesType, 0 /* String */);
+                    if (indexerType) {
+                        correspondingPropType = indexerType;
+                    }
+                    else {
+                        // If there's no corresponding property with this name, error
+                        if (!correspondingPropType) {
+                            error(node.name, ts.Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType));
+                            return unknownType;
+                        }
+                    }
+                }
+            }
+            var exprType;
+            if (node.initializer) {
+                exprType = checkExpression(node.initializer);
+            }
+            else {
+                // <Elem attr /> is sugar for <Elem attr={true} />
+                exprType = booleanType;
+            }
+            if (correspondingPropType) {
+                checkTypeAssignableTo(exprType, correspondingPropType, node);
+            }
+            nameTable[node.name.text] = true;
+            return exprType;
+        }
+        function checkJsxSpreadAttribute(node, elementAttributesType, nameTable) {
+            var type = checkExpression(node.expression);
+            var props = getPropertiesOfType(type);
+            for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+                var prop = props_2[_i];
+                // Is there a corresponding property in the element attributes type? Skip checking of properties
+                // that have already been assigned to, as these are not actually pushed into the resulting type
+                if (!nameTable[prop.name]) {
+                    var targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
+                    if (targetPropSym) {
+                        var msg = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name);
+                        checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg);
+                    }
+                    nameTable[prop.name] = true;
+                }
+            }
+            return type;
+        }
+        function getJsxType(name) {
+            if (jsxTypes[name] === undefined) {
+                return jsxTypes[name] = getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType;
+            }
+            return jsxTypes[name];
+        }
+        /**
+          * Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic
+          * property (in which case nodeLinks.jsxFlags will be IntrinsicNamedElement) or an intrinsic
+          * string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement).
+          * May also return unknownSymbol if both of these lookups fail.
+          */
+        function getIntrinsicTagSymbol(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedSymbol) {
+                var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements);
+                if (intrinsicElementsType !== unknownType) {
+                    // Property case
+                    var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.text);
+                    if (intrinsicProp) {
+                        links.jsxFlags |= 1 /* IntrinsicNamedElement */;
+                        return links.resolvedSymbol = intrinsicProp;
+                    }
+                    // Intrinsic string indexer case
+                    var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0 /* String */);
+                    if (indexSignatureType) {
+                        links.jsxFlags |= 2 /* IntrinsicIndexedElement */;
+                        return links.resolvedSymbol = intrinsicElementsType.symbol;
+                    }
+                    // Wasn't found
+                    error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, node.tagName.text, "JSX." + JsxNames.IntrinsicElements);
+                    return links.resolvedSymbol = unknownSymbol;
+                }
+                else {
+                    if (compilerOptions.noImplicitAny) {
+                        error(node, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, JsxNames.IntrinsicElements);
+                    }
+                    return links.resolvedSymbol = unknownSymbol;
+                }
+            }
+            return links.resolvedSymbol;
+        }
+        /**
+         * Given a JSX element that is a class element, finds the Element Instance Type. If the
+         * element is not a class element, or the class element type cannot be determined, returns 'undefined'.
+         * For example, in the element <MyClass>, the element instance type is `MyClass` (not `typeof MyClass`).
+         */
+        function getJsxElementInstanceType(node, valueType) {
+            ts.Debug.assert(!(valueType.flags & 16384 /* Union */));
+            if (isTypeAny(valueType)) {
+                // Short-circuit if the class tag is using an element type 'any'
+                return anyType;
+            }
+            // Resolve the signatures, preferring constructor
+            var signatures = getSignaturesOfType(valueType, 1 /* Construct */);
+            if (signatures.length === 0) {
+                // No construct signatures, try call signatures
+                signatures = getSignaturesOfType(valueType, 0 /* Call */);
+                if (signatures.length === 0) {
+                    // We found no signatures at all, which is an error
+                    error(node.tagName, ts.Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, ts.getTextOfNode(node.tagName));
+                    return unknownType;
+                }
+            }
+            return getUnionType(signatures.map(getReturnTypeOfSignature));
+        }
+        /// e.g. "props" for React.d.ts,
+        /// or 'undefined' if ElementAttributesProperty doesn't exist (which means all
+        ///     non-intrinsic elements' attributes type is 'any'),
+        /// or '' if it has 0 properties (which means every
+        ///     non-intrinsic elements' attributes type is the element instance type)
+        function getJsxElementPropertiesName() {
+            // JSX
+            var jsxNamespace = getGlobalSymbol(JsxNames.JSX, 1536 /* Namespace */, /*diagnosticMessage*/ undefined);
+            // JSX.ElementAttributesProperty [symbol]
+            var attribsPropTypeSym = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementAttributesPropertyNameContainer, 793056 /* Type */);
+            // JSX.ElementAttributesProperty [type]
+            var attribPropType = attribsPropTypeSym && getDeclaredTypeOfSymbol(attribsPropTypeSym);
+            // The properties of JSX.ElementAttributesProperty
+            var attribProperties = attribPropType && getPropertiesOfType(attribPropType);
+            if (attribProperties) {
+                // Element Attributes has zero properties, so the element attributes type will be the class instance type
+                if (attribProperties.length === 0) {
+                    return "";
+                }
+                else if (attribProperties.length === 1) {
+                    return attribProperties[0].name;
+                }
+                else {
+                    error(attribsPropTypeSym.declarations[0], ts.Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, JsxNames.ElementAttributesPropertyNameContainer);
+                    return undefined;
+                }
+            }
+            else {
+                // No interface exists, so the element attributes type will be an implicit any
+                return undefined;
+            }
+        }
+        /**
+         * Given React element instance type and the class type, resolve the Jsx type
+         * Pass elemType to handle individual type in the union typed element type.
+         */
+        function getResolvedJsxType(node, elemType, elemClassType) {
+            if (!elemType) {
+                elemType = checkExpression(node.tagName);
+            }
+            if (elemType.flags & 16384 /* Union */) {
+                var types = elemType.types;
+                return getUnionType(types.map(function (type) {
+                    return getResolvedJsxType(node, type, elemClassType);
+                }));
+            }
+            // If the elemType is a string type, we have to return anyType to prevent an error downstream as we will try to find construct or call signature of the type
+            if (elemType.flags & 2 /* String */) {
+                return anyType;
+            }
+            else if (elemType.flags & 256 /* StringLiteral */) {
+                // If the elemType is a stringLiteral type, we can then provide a check to make sure that the string literal type is one of the Jsx intrinsic element type
+                var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements);
+                if (intrinsicElementsType !== unknownType) {
+                    var stringLiteralTypeName = elemType.text;
+                    var intrinsicProp = getPropertyOfType(intrinsicElementsType, stringLiteralTypeName);
+                    if (intrinsicProp) {
+                        return getTypeOfSymbol(intrinsicProp);
+                    }
+                    var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0 /* String */);
+                    if (indexSignatureType) {
+                        return indexSignatureType;
+                    }
+                    error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, stringLiteralTypeName, "JSX." + JsxNames.IntrinsicElements);
+                }
+                // If we need to report an error, we already done so here. So just return any to prevent any more error downstream
+                return anyType;
+            }
+            // Get the element instance type (the result of newing or invoking this tag)
+            var elemInstanceType = getJsxElementInstanceType(node, elemType);
+            if (!elemClassType || !isTypeAssignableTo(elemInstanceType, elemClassType)) {
+                // Is this is a stateless function component? See if its single signature's return type is
+                // assignable to the JSX Element Type
+                if (jsxElementType) {
+                    var callSignatures = elemType && getSignaturesOfType(elemType, 0 /* Call */);
+                    var callSignature = callSignatures && callSignatures.length > 0 && callSignatures[0];
+                    var callReturnType = callSignature && getReturnTypeOfSignature(callSignature);
+                    var paramType = callReturnType && (callSignature.parameters.length === 0 ? emptyObjectType : getTypeOfSymbol(callSignature.parameters[0]));
+                    if (callReturnType && isTypeAssignableTo(callReturnType, jsxElementType)) {
+                        // Intersect in JSX.IntrinsicAttributes if it exists
+                        var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes);
+                        if (intrinsicAttributes !== unknownType) {
+                            paramType = intersectTypes(intrinsicAttributes, paramType);
+                        }
+                        return paramType;
+                    }
+                }
+            }
+            // Issue an error if this return type isn't assignable to JSX.ElementClass
+            if (elemClassType) {
+                checkTypeRelatedTo(elemInstanceType, elemClassType, assignableRelation, node, ts.Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements);
+            }
+            if (isTypeAny(elemInstanceType)) {
+                return elemInstanceType;
+            }
+            var propsName = getJsxElementPropertiesName();
+            if (propsName === undefined) {
+                // There is no type ElementAttributesProperty, return 'any'
+                return anyType;
+            }
+            else if (propsName === "") {
+                // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead
+                return elemInstanceType;
+            }
+            else {
+                var attributesType = getTypeOfPropertyOfType(elemInstanceType, propsName);
+                if (!attributesType) {
+                    // There is no property named 'props' on this instance type
+                    return emptyObjectType;
+                }
+                else if (isTypeAny(attributesType) || (attributesType === unknownType)) {
+                    // Props is of type 'any' or unknown
+                    return attributesType;
+                }
+                else if (attributesType.flags & 16384 /* Union */) {
+                    // Props cannot be a union type
+                    error(node.tagName, ts.Diagnostics.JSX_element_attributes_type_0_may_not_be_a_union_type, typeToString(attributesType));
+                    return anyType;
+                }
+                else {
+                    // Normal case -- add in IntrinsicClassElements<T> and IntrinsicElements
+                    var apparentAttributesType = attributesType;
+                    var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes);
+                    if (intrinsicClassAttribs !== unknownType) {
+                        var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
+                        if (typeParams) {
+                            if (typeParams.length === 1) {
+                                apparentAttributesType = intersectTypes(createTypeReference(intrinsicClassAttribs, [elemInstanceType]), apparentAttributesType);
+                            }
+                        }
+                        else {
+                            apparentAttributesType = intersectTypes(attributesType, intrinsicClassAttribs);
+                        }
+                    }
+                    var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes);
+                    if (intrinsicAttribs !== unknownType) {
+                        apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
+                    }
+                    return apparentAttributesType;
+                }
+            }
+        }
+        /**
+         * Given an opening/self-closing element, get the 'element attributes type', i.e. the type that tells
+         * us which attributes are valid on a given element.
+         */
+        function getJsxElementAttributesType(node) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedJsxType) {
+                if (isJsxIntrinsicIdentifier(node.tagName)) {
+                    var symbol = getIntrinsicTagSymbol(node);
+                    if (links.jsxFlags & 1 /* IntrinsicNamedElement */) {
+                        return links.resolvedJsxType = getTypeOfSymbol(symbol);
+                    }
+                    else if (links.jsxFlags & 2 /* IntrinsicIndexedElement */) {
+                        return links.resolvedJsxType = getIndexInfoOfSymbol(symbol, 0 /* String */).type;
+                    }
+                    else {
+                        return links.resolvedJsxType = unknownType;
+                    }
+                }
+                else {
+                    var elemClassType = getJsxGlobalElementClassType();
+                    return links.resolvedJsxType = getResolvedJsxType(node, undefined, elemClassType);
+                }
+            }
+            return links.resolvedJsxType;
+        }
+        /**
+         * Given a JSX attribute, returns the symbol for the corresponds property
+         * of the element attributes type. Will return unknownSymbol for attributes
+         * that have no matching element attributes type property.
+         */
+        function getJsxAttributePropertySymbol(attrib) {
+            var attributesType = getJsxElementAttributesType(attrib.parent);
+            var prop = getPropertyOfType(attributesType, attrib.name.text);
+            return prop || unknownSymbol;
+        }
+        function getJsxGlobalElementClassType() {
+            if (!jsxElementClassType) {
+                jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
+            }
+            return jsxElementClassType;
+        }
+        /// Returns all the properties of the Jsx.IntrinsicElements interface
+        function getJsxIntrinsicTagNames() {
+            var intrinsics = getJsxType(JsxNames.IntrinsicElements);
+            return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
+        }
+        function checkJsxPreconditions(errorNode) {
+            // Preconditions for using JSX
+            if ((compilerOptions.jsx || 0 /* None */) === 0 /* None */) {
+                error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
+            }
+            if (jsxElementType === undefined) {
+                if (compilerOptions.noImplicitAny) {
+                    error(errorNode, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist);
+                }
+            }
+        }
+        function checkJsxOpeningLikeElement(node) {
+            checkGrammarJsxElement(node);
+            checkJsxPreconditions(node);
+            // The reactNamespace symbol should be marked as 'used' so we don't incorrectly elide its import. And if there
+            // is no reactNamespace symbol in scope when targeting React emit, we should issue an error.
+            var reactRefErr = compilerOptions.jsx === 2 /* React */ ? ts.Diagnostics.Cannot_find_name_0 : undefined;
+            var reactNamespace = compilerOptions.reactNamespace ? compilerOptions.reactNamespace : "React";
+            var reactSym = resolveName(node.tagName, reactNamespace, 107455 /* Value */, reactRefErr, reactNamespace);
+            if (reactSym) {
+                getSymbolLinks(reactSym).referenced = true;
+            }
+            var targetAttributesType = getJsxElementAttributesType(node);
+            var nameTable = {};
+            // Process this array in right-to-left order so we know which
+            // attributes (mostly from spreads) are being overwritten and
+            // thus should have their types ignored
+            var sawSpreadedAny = false;
+            for (var i = node.attributes.length - 1; i >= 0; i--) {
+                if (node.attributes[i].kind === 246 /* JsxAttribute */) {
+                    checkJsxAttribute((node.attributes[i]), targetAttributesType, nameTable);
+                }
+                else {
+                    ts.Debug.assert(node.attributes[i].kind === 247 /* JsxSpreadAttribute */);
+                    var spreadType = checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable);
+                    if (isTypeAny(spreadType)) {
+                        sawSpreadedAny = true;
+                    }
+                }
+            }
+            // Check that all required properties have been provided. If an 'any'
+            // was spreaded in, though, assume that it provided all required properties
+            if (targetAttributesType && !sawSpreadedAny) {
+                var targetProperties = getPropertiesOfType(targetAttributesType);
+                for (var i = 0; i < targetProperties.length; i++) {
+                    if (!(targetProperties[i].flags & 536870912 /* Optional */) &&
+                        nameTable[targetProperties[i].name] === undefined) {
+                        error(node, ts.Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType));
+                    }
+                }
+            }
+        }
+        function checkJsxExpression(node) {
+            if (node.expression) {
+                return checkExpression(node.expression);
+            }
+            else {
+                return unknownType;
+            }
+        }
+        // If a symbol is a synthesized symbol with no value declaration, we assume it is a property. Example of this are the synthesized
+        // '.prototype' property as well as synthesized tuple index properties.
+        function getDeclarationKindFromSymbol(s) {
+            return s.valueDeclaration ? s.valueDeclaration.kind : 145 /* PropertyDeclaration */;
+        }
+        function getDeclarationFlagsFromSymbol(s) {
+            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 4 /* Public */ | 32 /* Static */ : 0;
+        }
+        /**
+         * Check whether the requested property access is valid.
+         * Returns true if node is a valid property access, and false otherwise.
+         * @param node The node to be checked.
+         * @param left The left hand side of the property access (e.g.: the super in `super.foo`).
+         * @param type The type of left.
+         * @param prop The symbol for the right hand side of the property access.
+         */
+        function checkClassPropertyAccess(node, left, type, prop) {
+            var flags = getDeclarationFlagsFromSymbol(prop);
+            var declaringClass = getDeclaredTypeOfSymbol(getParentOfSymbol(prop));
+            var errorNode = node.kind === 172 /* PropertyAccessExpression */ || node.kind === 218 /* VariableDeclaration */ ?
+                node.name :
+                node.right;
+            if (left.kind === 95 /* SuperKeyword */) {
+                // TS 1.0 spec (April 2014): 4.8.2
+                // - In a constructor, instance member function, instance member accessor, or
+                //   instance member variable initializer where this references a derived class instance,
+                //   a super property access is permitted and must specify a public instance member function of the base class.
+                // - In a static member function or static member accessor
+                //   where this references the constructor function object of a derived class,
+                //   a super property access is permitted and must specify a public static member function of the base class.
+                if (languageVersion < 2 /* ES6 */ && getDeclarationKindFromSymbol(prop) !== 147 /* MethodDeclaration */) {
+                    // `prop` refers to a *property* declared in the super class
+                    // rather than a *method*, so it does not satisfy the above criteria.
+                    error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
+                    return false;
+                }
+                if (flags & 128 /* Abstract */) {
+                    // A method cannot be accessed in a super property access if the method is abstract.
+                    // This error could mask a private property access error. But, a member
+                    // cannot simultaneously be private and abstract, so this will trigger an
+                    // additional error elsewhere.
+                    error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass));
+                    return false;
+                }
+            }
+            // Public properties are otherwise accessible.
+            if (!(flags & (8 /* Private */ | 16 /* Protected */))) {
+                return true;
+            }
+            // Property is known to be private or protected at this point
+            // Private property is accessible if the property is within the declaring class
+            if (flags & 8 /* Private */) {
+                var declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
+                if (!isNodeWithinClass(node, declaringClassDeclaration)) {
+                    error(errorNode, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass));
+                    return false;
+                }
+                return true;
+            }
+            // Property is known to be protected at this point
+            // All protected properties of a supertype are accessible in a super access
+            if (left.kind === 95 /* SuperKeyword */) {
+                return true;
+            }
+            // Get the enclosing class that has the declaring class as its base type
+            var enclosingClass = forEachEnclosingClass(node, function (enclosingDeclaration) {
+                var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
+                return hasBaseType(enclosingClass, declaringClass) ? enclosingClass : undefined;
+            });
+            // A protected property is accessible if the property is within the declaring class or classes derived from it
+            if (!enclosingClass) {
+                error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass));
+                return false;
+            }
+            // No further restrictions for static properties
+            if (flags & 32 /* Static */) {
+                return true;
+            }
+            // An instance property must be accessed through an instance of the enclosing class
+            if (type.flags & 33554432 /* ThisType */) {
+                // get the original type -- represented as the type constraint of the 'this' type
+                type = getConstraintOfTypeParameter(type);
+            }
+            // TODO: why is the first part of this check here?
+            if (!(getTargetType(type).flags & (1024 /* Class */ | 2048 /* Interface */) && hasBaseType(type, enclosingClass))) {
+                error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass));
+                return false;
+            }
+            return true;
+        }
+        function checkNonNullExpression(node) {
+            var type = checkExpression(node);
+            if (strictNullChecks) {
+                var kind = getCombinedTypeFlags(type) & 96 /* Nullable */;
+                if (kind) {
+                    error(node, kind & 32 /* Undefined */ ? kind & 64 /* Null */ ?
+                        ts.Diagnostics.Object_is_possibly_null_or_undefined :
+                        ts.Diagnostics.Object_is_possibly_undefined :
+                        ts.Diagnostics.Object_is_possibly_null);
+                }
+                return getNonNullableType(type);
+            }
+            return type;
+        }
+        function checkPropertyAccessExpression(node) {
+            return checkPropertyAccessExpressionOrQualifiedName(node, node.expression, node.name);
+        }
+        function checkQualifiedName(node) {
+            return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right);
+        }
+        function checkPropertyAccessExpressionOrQualifiedName(node, left, right) {
+            var type = checkNonNullExpression(left);
+            if (isTypeAny(type)) {
+                return type;
+            }
+            var apparentType = getApparentType(getWidenedType(type));
+            if (apparentType === unknownType || (type.flags & 512 /* TypeParameter */ && isTypeAny(apparentType))) {
+                // handle cases when type is Type parameter with invalid or any constraint
+                return apparentType;
+            }
+            var prop = getPropertyOfType(apparentType, right.text);
+            if (!prop) {
+                if (right.text && !checkAndReportErrorForExtendingInterface(node)) {
+                    error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(right), typeToString(type.flags & 33554432 /* ThisType */ ? apparentType : type));
+                }
+                return unknownType;
+            }
+            if (noUnusedIdentifiers &&
+                (prop.flags & 106500 /* ClassMember */) &&
+                prop.valueDeclaration && (prop.valueDeclaration.flags & 8 /* Private */)) {
+                if (prop.flags & 16777216 /* Instantiated */) {
+                    getSymbolLinks(prop).target.isReferenced = true;
+                }
+                else {
+                    prop.isReferenced = true;
+                }
+            }
+            getNodeLinks(node).resolvedSymbol = prop;
+            if (prop.parent && prop.parent.flags & 32 /* Class */) {
+                checkClassPropertyAccess(node, left, apparentType, prop);
+            }
+            var propType = getTypeOfSymbol(prop);
+            // Only compute control flow type if this is a property access expression that isn't an
+            // assignment target, and the referenced property was declared as a variable, property,
+            // accessor, or optional method.
+            if (node.kind !== 172 /* PropertyAccessExpression */ || ts.isAssignmentTarget(node) ||
+                !(prop.flags & (3 /* Variable */ | 4 /* Property */ | 98304 /* Accessor */)) &&
+                    !(prop.flags & 8192 /* Method */ && propType.flags & 16384 /* Union */)) {
+                return propType;
+            }
+            return getFlowTypeOfReference(node, propType, /*assumeInitialized*/ true, /*includeOuterFunctions*/ false);
+        }
+        function isValidPropertyAccess(node, propertyName) {
+            var left = node.kind === 172 /* PropertyAccessExpression */
+                ? node.expression
+                : node.left;
+            var type = checkExpression(left);
+            if (type !== unknownType && !isTypeAny(type)) {
+                var prop = getPropertyOfType(getWidenedType(type), propertyName);
+                if (prop && prop.parent && prop.parent.flags & 32 /* Class */) {
+                    return checkClassPropertyAccess(node, left, type, prop);
+                }
+            }
+            return true;
+        }
+        /**
+         * Return the symbol of the for-in variable declared or referenced by the given for-in statement.
+         */
+        function getForInVariableSymbol(node) {
+            var initializer = node.initializer;
+            if (initializer.kind === 219 /* VariableDeclarationList */) {
+                var variable = initializer.declarations[0];
+                if (variable && !ts.isBindingPattern(variable.name)) {
+                    return getSymbolOfNode(variable);
+                }
+            }
+            else if (initializer.kind === 69 /* Identifier */) {
+                return getResolvedSymbol(initializer);
+            }
+            return undefined;
+        }
+        /**
+         * Return true if the given type is considered to have numeric property names.
+         */
+        function hasNumericPropertyNames(type) {
+            return getIndexTypeOfType(type, 1 /* Number */) && !getIndexTypeOfType(type, 0 /* String */);
+        }
+        /**
+         * Return true if given node is an expression consisting of an identifier (possibly parenthesized)
+         * that references a for-in variable for an object with numeric property names.
+         */
+        function isForInVariableForNumericPropertyNames(expr) {
+            var e = skipParenthesizedNodes(expr);
+            if (e.kind === 69 /* Identifier */) {
+                var symbol = getResolvedSymbol(e);
+                if (symbol.flags & 3 /* Variable */) {
+                    var child = expr;
+                    var node = expr.parent;
+                    while (node) {
+                        if (node.kind === 207 /* ForInStatement */ &&
+                            child === node.statement &&
+                            getForInVariableSymbol(node) === symbol &&
+                            hasNumericPropertyNames(checkExpression(node.expression))) {
+                            return true;
+                        }
+                        child = node;
+                        node = node.parent;
+                    }
+                }
+            }
+            return false;
+        }
+        function checkIndexedAccess(node) {
+            // Grammar checking
+            if (!node.argumentExpression) {
+                var sourceFile = ts.getSourceFileOfNode(node);
+                if (node.parent.kind === 175 /* NewExpression */ && node.parent.expression === node) {
+                    var start = ts.skipTrivia(sourceFile.text, node.expression.end);
+                    var end = node.end;
+                    grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
+                }
+                else {
+                    var start = node.end - "]".length;
+                    var end = node.end;
+                    grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Expression_expected);
+                }
+            }
+            // Obtain base constraint such that we can bail out if the constraint is an unknown type
+            var objectType = getApparentType(checkNonNullExpression(node.expression));
+            var indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
+            if (objectType === unknownType) {
+                return unknownType;
+            }
+            var isConstEnum = isConstEnumObjectType(objectType);
+            if (isConstEnum &&
+                (!node.argumentExpression || node.argumentExpression.kind !== 9 /* StringLiteral */)) {
+                error(node.argumentExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
+                return unknownType;
+            }
+            // TypeScript 1.0 spec (April 2014): 4.10 Property Access
+            // - If IndexExpr is a string literal or a numeric literal and ObjExpr's apparent type has a property with the name
+            //    given by that literal(converted to its string representation in the case of a numeric literal), the property access is of the type of that property.
+            // - Otherwise, if ObjExpr's apparent type has a numeric index signature and IndexExpr is of type Any, the Number primitive type, or an enum type,
+            //    the property access is of the type of that index signature.
+            // - Otherwise, if ObjExpr's apparent type has a string index signature and IndexExpr is of type Any, the String or Number primitive type, or an enum type,
+            //    the property access is of the type of that index signature.
+            // - Otherwise, if IndexExpr is of type Any, the String or Number primitive type, or an enum type, the property access is of type Any.
+            // See if we can index as a property.
+            if (node.argumentExpression) {
+                var name_13 = getPropertyNameForIndexedAccess(node.argumentExpression, indexType);
+                if (name_13 !== undefined) {
+                    var prop = getPropertyOfType(objectType, name_13);
+                    if (prop) {
+                        getNodeLinks(node).resolvedSymbol = prop;
+                        return getTypeOfSymbol(prop);
+                    }
+                    else if (isConstEnum) {
+                        error(node.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_const_enum_1, name_13, symbolToString(objectType.symbol));
+                        return unknownType;
+                    }
+                }
+            }
+            // Check for compatible indexer types.
+            if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, 258 /* StringLike */ | 132 /* NumberLike */ | 16777216 /* ESSymbol */)) {
+                // Try to use a number indexer.
+                if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, 132 /* NumberLike */) || isForInVariableForNumericPropertyNames(node.argumentExpression)) {
+                    var numberIndexInfo = getIndexInfoOfType(objectType, 1 /* Number */);
+                    if (numberIndexInfo) {
+                        getNodeLinks(node).resolvedIndexInfo = numberIndexInfo;
+                        return numberIndexInfo.type;
+                    }
+                }
+                // Try to use string indexing.
+                var stringIndexInfo = getIndexInfoOfType(objectType, 0 /* String */);
+                if (stringIndexInfo) {
+                    getNodeLinks(node).resolvedIndexInfo = stringIndexInfo;
+                    return stringIndexInfo.type;
+                }
+                // Fall back to any.
+                if (compilerOptions.noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !isTypeAny(objectType)) {
+                    error(node, getIndexTypeOfType(objectType, 1 /* Number */) ?
+                        ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number :
+                        ts.Diagnostics.Index_signature_of_object_type_implicitly_has_an_any_type);
+                }
+                return anyType;
+            }
+            // REVIEW: Users should know the type that was actually used.
+            error(node, ts.Diagnostics.An_index_expression_argument_must_be_of_type_string_number_symbol_or_any);
+            return unknownType;
+        }
+        /**
+         * If indexArgumentExpression is a string literal or number literal, returns its text.
+         * If indexArgumentExpression is a constant value, returns its string value.
+         * If indexArgumentExpression is a well known symbol, returns the property name corresponding
+         *    to this symbol, as long as it is a proper symbol reference.
+         * Otherwise, returns undefined.
+         */
+        function getPropertyNameForIndexedAccess(indexArgumentExpression, indexArgumentType) {
+            if (indexArgumentExpression.kind === 9 /* StringLiteral */ || indexArgumentExpression.kind === 8 /* NumericLiteral */) {
+                return indexArgumentExpression.text;
+            }
+            if (indexArgumentExpression.kind === 173 /* ElementAccessExpression */ || indexArgumentExpression.kind === 172 /* PropertyAccessExpression */) {
+                var value = getConstantValue(indexArgumentExpression);
+                if (value !== undefined) {
+                    return value.toString();
+                }
+            }
+            if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) {
+                var rightHandSideName = indexArgumentExpression.name.text;
+                return ts.getPropertyNameForKnownSymbolName(rightHandSideName);
+            }
+            return undefined;
+        }
+        /**
+         * A proper symbol reference requires the following:
+         *   1. The property access denotes a property that exists
+         *   2. The expression is of the form Symbol.<identifier>
+         *   3. The property access is of the primitive type symbol.
+         *   4. Symbol in this context resolves to the global Symbol object
+         */
+        function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) {
+            if (expressionType === unknownType) {
+                // There is already an error, so no need to report one.
+                return false;
+            }
+            if (!ts.isWellKnownSymbolSyntactically(expression)) {
+                return false;
+            }
+            // Make sure the property type is the primitive symbol type
+            if ((expressionType.flags & 16777216 /* ESSymbol */) === 0) {
+                if (reportError) {
+                    error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression));
+                }
+                return false;
+            }
+            // The name is Symbol.<someName>, so make sure Symbol actually resolves to the
+            // global Symbol object
+            var leftHandSide = expression.expression;
+            var leftHandSideSymbol = getResolvedSymbol(leftHandSide);
+            if (!leftHandSideSymbol) {
+                return false;
+            }
+            var globalESSymbol = getGlobalESSymbolConstructorSymbol();
+            if (!globalESSymbol) {
+                // Already errored when we tried to look up the symbol
+                return false;
+            }
+            if (leftHandSideSymbol !== globalESSymbol) {
+                if (reportError) {
+                    error(leftHandSide, ts.Diagnostics.Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object);
+                }
+                return false;
+            }
+            return true;
+        }
+        function resolveUntypedCall(node) {
+            if (node.kind === 176 /* TaggedTemplateExpression */) {
+                checkExpression(node.template);
+            }
+            else if (node.kind !== 143 /* Decorator */) {
+                ts.forEach(node.arguments, function (argument) {
+                    checkExpression(argument);
+                });
+            }
+            return anySignature;
+        }
+        function resolveErrorCall(node) {
+            resolveUntypedCall(node);
+            return unknownSignature;
+        }
+        // Re-order candidate signatures into the result array. Assumes the result array to be empty.
+        // The candidate list orders groups in reverse, but within a group signatures are kept in declaration order
+        // A nit here is that we reorder only signatures that belong to the same symbol,
+        // so order how inherited signatures are processed is still preserved.
+        // interface A { (x: string): void }
+        // interface B extends A { (x: 'foo'): string }
+        // const b: B;
+        // b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void]
+        function reorderCandidates(signatures, result) {
+            var lastParent;
+            var lastSymbol;
+            var cutoffIndex = 0;
+            var index;
+            var specializedIndex = -1;
+            var spliceIndex;
+            ts.Debug.assert(!result.length);
+            for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+                var signature = signatures_2[_i];
+                var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
+                var parent_9 = signature.declaration && signature.declaration.parent;
+                if (!lastSymbol || symbol === lastSymbol) {
+                    if (lastParent && parent_9 === lastParent) {
+                        index++;
+                    }
+                    else {
+                        lastParent = parent_9;
+                        index = cutoffIndex;
+                    }
+                }
+                else {
+                    // current declaration belongs to a different symbol
+                    // set cutoffIndex so re-orderings in the future won't change result set from 0 to cutoffIndex
+                    index = cutoffIndex = result.length;
+                    lastParent = parent_9;
+                }
+                lastSymbol = symbol;
+                // specialized signatures always need to be placed before non-specialized signatures regardless
+                // of the cutoff position; see GH#1133
+                if (signature.hasStringLiterals) {
+                    specializedIndex++;
+                    spliceIndex = specializedIndex;
+                    // The cutoff index always needs to be greater than or equal to the specialized signature index
+                    // in order to prevent non-specialized signatures from being added before a specialized
+                    // signature.
+                    cutoffIndex++;
+                }
+                else {
+                    spliceIndex = index;
+                }
+                result.splice(spliceIndex, 0, signature);
+            }
+        }
+        function getSpreadArgumentIndex(args) {
+            for (var i = 0; i < args.length; i++) {
+                var arg = args[i];
+                if (arg && arg.kind === 191 /* SpreadElementExpression */) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        function hasCorrectArity(node, args, signature, signatureHelpTrailingComma) {
+            if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
+            var argCount; // Apparent number of arguments we will have in this call
+            var typeArguments; // Type arguments (undefined if none)
+            var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments
+            var isDecorator;
+            var spreadArgIndex = -1;
+            if (node.kind === 176 /* TaggedTemplateExpression */) {
+                var tagExpression = node;
+                // Even if the call is incomplete, we'll have a missing expression as our last argument,
+                // so we can say the count is just the arg list length
+                argCount = args.length;
+                typeArguments = undefined;
+                if (tagExpression.template.kind === 189 /* TemplateExpression */) {
+                    // If a tagged template expression lacks a tail literal, the call is incomplete.
+                    // Specifically, a template only can end in a TemplateTail or a Missing literal.
+                    var templateExpression = tagExpression.template;
+                    var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans);
+                    ts.Debug.assert(lastSpan !== undefined); // we should always have at least one span.
+                    callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
+                }
+                else {
+                    // If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
+                    // then this might actually turn out to be a TemplateHead in the future;
+                    // so we consider the call to be incomplete.
+                    var templateLiteral = tagExpression.template;
+                    ts.Debug.assert(templateLiteral.kind === 11 /* NoSubstitutionTemplateLiteral */);
+                    callIsIncomplete = !!templateLiteral.isUnterminated;
+                }
+            }
+            else if (node.kind === 143 /* Decorator */) {
+                isDecorator = true;
+                typeArguments = undefined;
+                argCount = getEffectiveArgumentCount(node, /*args*/ undefined, signature);
+            }
+            else {
+                var callExpression = node;
+                if (!callExpression.arguments) {
+                    // This only happens when we have something of the form: 'new C'
+                    ts.Debug.assert(callExpression.kind === 175 /* NewExpression */);
+                    return signature.minArgumentCount === 0;
+                }
+                argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;
+                // If we are missing the close paren, the call is incomplete.
+                callIsIncomplete = callExpression.arguments.end === callExpression.end;
+                typeArguments = callExpression.typeArguments;
+                spreadArgIndex = getSpreadArgumentIndex(args);
+            }
+            // If the user supplied type arguments, but the number of type arguments does not match
+            // the declared number of type parameters, the call has an incorrect arity.
+            var hasRightNumberOfTypeArgs = !typeArguments ||
+                (signature.typeParameters && typeArguments.length === signature.typeParameters.length);
+            if (!hasRightNumberOfTypeArgs) {
+                return false;
+            }
+            // If spread arguments are present, check that they correspond to a rest parameter. If so, no
+            // further checking is necessary.
+            if (spreadArgIndex >= 0) {
+                return isRestParameterIndex(signature, spreadArgIndex);
+            }
+            // Too many arguments implies incorrect arity.
+            if (!signature.hasRestParameter && argCount > signature.parameters.length) {
+                return false;
+            }
+            // If the call is incomplete, we should skip the lower bound check.
+            var hasEnoughArguments = argCount >= signature.minArgumentCount;
+            return callIsIncomplete || hasEnoughArguments;
+        }
+        // If type has a single call signature and no other members, return that signature. Otherwise, return undefined.
+        function getSingleCallSignature(type) {
+            if (type.flags & 80896 /* ObjectType */) {
+                var resolved = resolveStructuredTypeMembers(type);
+                if (resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0 &&
+                    resolved.properties.length === 0 && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
+                    return resolved.callSignatures[0];
+                }
+            }
+            return undefined;
+        }
+        // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec)
+        function instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper) {
+            var context = createInferenceContext(signature.typeParameters, /*inferUnionTypes*/ true);
+            forEachMatchingParameterType(contextualSignature, signature, function (source, target) {
+                // Type parameters from outer context referenced by source type are fixed by instantiation of the source type
+                inferTypes(context, instantiateType(source, contextualMapper), target);
+            });
+            return getSignatureInstantiation(signature, getInferredTypes(context));
+        }
+        function inferTypeArguments(node, signature, args, excludeArgument, context) {
+            var typeParameters = signature.typeParameters;
+            var inferenceMapper = getInferenceMapper(context);
+            // Clear out all the inference results from the last time inferTypeArguments was called on this context
+            for (var i = 0; i < typeParameters.length; i++) {
+                // As an optimization, we don't have to clear (and later recompute) inferred types
+                // for type parameters that have already been fixed on the previous call to inferTypeArguments.
+                // It would be just as correct to reset all of them. But then we'd be repeating the same work
+                // for the type parameters that were fixed, namely the work done by getInferredType.
+                if (!context.inferences[i].isFixed) {
+                    context.inferredTypes[i] = undefined;
+                }
+            }
+            // On this call to inferTypeArguments, we may get more inferences for certain type parameters that were not
+            // fixed last time. This means that a type parameter that failed inference last time may succeed this time,
+            // or vice versa. Therefore, the failedTypeParameterIndex is useless if it points to an unfixed type parameter,
+            // because it may change. So here we reset it. However, getInferredType will not revisit any type parameters
+            // that were previously fixed. So if a fixed type parameter failed previously, it will fail again because
+            // it will contain the exact same set of inferences. So if we reset the index from a fixed type parameter,
+            // we will lose information that we won't recover this time around.
+            if (context.failedTypeParameterIndex !== undefined && !context.inferences[context.failedTypeParameterIndex].isFixed) {
+                context.failedTypeParameterIndex = undefined;
+            }
+            var thisType = getThisTypeOfSignature(signature);
+            if (thisType) {
+                var thisArgumentNode = getThisArgumentOfCall(node);
+                var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType;
+                inferTypes(context, thisArgumentType, thisType);
+            }
+            // We perform two passes over the arguments. In the first pass we infer from all arguments, but use
+            // wildcards for all context sensitive function expressions.
+            var argCount = getEffectiveArgumentCount(node, args, signature);
+            for (var i = 0; i < argCount; i++) {
+                var arg = getEffectiveArgument(node, args, i);
+                // If the effective argument is 'undefined', then it is an argument that is present but is synthetic.
+                if (arg === undefined || arg.kind !== 193 /* OmittedExpression */) {
+                    var paramType = getTypeAtPosition(signature, i);
+                    var argType = getEffectiveArgumentType(node, i, arg);
+                    // If the effective argument type is 'undefined', there is no synthetic type
+                    // for the argument. In that case, we should check the argument.
+                    if (argType === undefined) {
+                        // For context sensitive arguments we pass the identityMapper, which is a signal to treat all
+                        // context sensitive function expressions as wildcards
+                        var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper;
+                        argType = checkExpressionWithContextualType(arg, paramType, mapper);
+                    }
+                    inferTypes(context, argType, paramType);
+                }
+            }
+            // In the second pass we visit only context sensitive arguments, and only those that aren't excluded, this
+            // time treating function expressions normally (which may cause previously inferred type arguments to be fixed
+            // as we construct types for contextually typed parameters)
+            // Decorators will not have `excludeArgument`, as their arguments cannot be contextually typed.
+            // Tagged template expressions will always have `undefined` for `excludeArgument[0]`.
+            if (excludeArgument) {
+                for (var i = 0; i < argCount; i++) {
+                    // No need to check for omitted args and template expressions, their exclusion value is always undefined
+                    if (excludeArgument[i] === false) {
+                        var arg = args[i];
+                        var paramType = getTypeAtPosition(signature, i);
+                        inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType);
+                    }
+                }
+            }
+            getInferredTypes(context);
+        }
+        function checkTypeArguments(signature, typeArgumentNodes, typeArgumentTypes, reportErrors, headMessage) {
+            var typeParameters = signature.typeParameters;
+            var typeArgumentsAreAssignable = true;
+            var mapper;
+            for (var i = 0; i < typeParameters.length; i++) {
+                if (typeArgumentsAreAssignable /* so far */) {
+                    var constraint = getConstraintOfTypeParameter(typeParameters[i]);
+                    if (constraint) {
+                        var errorInfo = void 0;
+                        var typeArgumentHeadMessage = ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
+                        if (reportErrors && headMessage) {
+                            errorInfo = ts.chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage);
+                            typeArgumentHeadMessage = headMessage;
+                        }
+                        if (!mapper) {
+                            mapper = createTypeMapper(typeParameters, typeArgumentTypes);
+                        }
+                        var typeArgument = typeArgumentTypes[i];
+                        typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), reportErrors ? typeArgumentNodes[i] : undefined, typeArgumentHeadMessage, errorInfo);
+                    }
+                }
+            }
+            return typeArgumentsAreAssignable;
+        }
+        function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) {
+            var thisType = getThisTypeOfSignature(signature);
+            if (thisType && thisType !== voidType && node.kind !== 175 /* NewExpression */) {
+                // If the called expression is not of the form `x.f` or `x["f"]`, then sourceType = voidType
+                // If the signature's 'this' type is voidType, then the check is skipped -- anything is compatible.
+                // If the expression is a new expression, then the check is skipped.
+                var thisArgumentNode = getThisArgumentOfCall(node);
+                var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType;
+                var errorNode = reportErrors ? (thisArgumentNode || node) : undefined;
+                var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
+                if (!checkTypeRelatedTo(thisArgumentType, getThisTypeOfSignature(signature), relation, errorNode, headMessage_1)) {
+                    return false;
+                }
+            }
+            var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
+            var argCount = getEffectiveArgumentCount(node, args, signature);
+            for (var i = 0; i < argCount; i++) {
+                var arg = getEffectiveArgument(node, args, i);
+                // If the effective argument is 'undefined', then it is an argument that is present but is synthetic.
+                if (arg === undefined || arg.kind !== 193 /* OmittedExpression */) {
+                    // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter)
+                    var paramType = getTypeAtPosition(signature, i);
+                    var argType = getEffectiveArgumentType(node, i, arg);
+                    // If the effective argument type is 'undefined', there is no synthetic type
+                    // for the argument. In that case, we should check the argument.
+                    if (argType === undefined) {
+                        argType = arg.kind === 9 /* StringLiteral */ && !reportErrors
+                            ? getStringLiteralTypeForText(arg.text)
+                            : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined);
+                    }
+                    // Use argument expression as error location when reporting errors
+                    var errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined;
+                    if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        /**
+         * Returns the this argument in calls like x.f(...) and x[f](...). Undefined otherwise.
+         */
+        function getThisArgumentOfCall(node) {
+            if (node.kind === 174 /* CallExpression */) {
+                var callee = node.expression;
+                if (callee.kind === 172 /* PropertyAccessExpression */) {
+                    return callee.expression;
+                }
+                else if (callee.kind === 173 /* ElementAccessExpression */) {
+                    return callee.expression;
+                }
+            }
+        }
+        /**
+         * Returns the effective arguments for an expression that works like a function invocation.
+         *
+         * If 'node' is a CallExpression or a NewExpression, then its argument list is returned.
+         * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution
+         *    expressions, where the first element of the list is `undefined`.
+         * If 'node' is a Decorator, the argument list will be `undefined`, and its arguments and types
+         *    will be supplied from calls to `getEffectiveArgumentCount` and `getEffectiveArgumentType`.
+         */
+        function getEffectiveCallArguments(node) {
+            var args;
+            if (node.kind === 176 /* TaggedTemplateExpression */) {
+                var template = node.template;
+                args = [undefined];
+                if (template.kind === 189 /* TemplateExpression */) {
+                    ts.forEach(template.templateSpans, function (span) {
+                        args.push(span.expression);
+                    });
+                }
+            }
+            else if (node.kind === 143 /* Decorator */) {
+                // For a decorator, we return undefined as we will determine
+                // the number and types of arguments for a decorator using
+                // `getEffectiveArgumentCount` and `getEffectiveArgumentType` below.
+                return undefined;
+            }
+            else {
+                args = node.arguments || emptyArray;
+            }
+            return args;
+        }
+        /**
+          * Returns the effective argument count for a node that works like a function invocation.
+          * If 'node' is a Decorator, the number of arguments is derived from the decoration
+          *    target and the signature:
+          *    If 'node.target' is a class declaration or class expression, the effective argument
+          *       count is 1.
+          *    If 'node.target' is a parameter declaration, the effective argument count is 3.
+          *    If 'node.target' is a property declaration, the effective argument count is 2.
+          *    If 'node.target' is a method or accessor declaration, the effective argument count
+          *       is 3, although it can be 2 if the signature only accepts two arguments, allowing
+          *       us to match a property decorator.
+          * Otherwise, the argument count is the length of the 'args' array.
+          */
+        function getEffectiveArgumentCount(node, args, signature) {
+            if (node.kind === 143 /* Decorator */) {
+                switch (node.parent.kind) {
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                        // A class decorator will have one argument (see `ClassDecorator` in core.d.ts)
+                        return 1;
+                    case 145 /* PropertyDeclaration */:
+                        // A property declaration decorator will have two arguments (see
+                        // `PropertyDecorator` in core.d.ts)
+                        return 2;
+                    case 147 /* MethodDeclaration */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        // A method or accessor declaration decorator will have two or three arguments (see
+                        // `PropertyDecorator` and `MethodDecorator` in core.d.ts)
+                        // If we are emitting decorators for ES3, we will only pass two arguments.
+                        if (languageVersion === 0 /* ES3 */) {
+                            return 2;
+                        }
+                        // If the method decorator signature only accepts a target and a key, we will only
+                        // type check those arguments.
+                        return signature.parameters.length >= 3 ? 3 : 2;
+                    case 142 /* Parameter */:
+                        // A parameter declaration decorator will have three arguments (see
+                        // `ParameterDecorator` in core.d.ts)
+                        return 3;
+                }
+            }
+            else {
+                return args.length;
+            }
+        }
+        /**
+          * Returns the effective type of the first argument to a decorator.
+          * If 'node' is a class declaration or class expression, the effective argument type
+          *    is the type of the static side of the class.
+          * If 'node' is a parameter declaration, the effective argument type is either the type
+          *    of the static or instance side of the class for the parameter's parent method,
+          *    depending on whether the method is declared static.
+          *    For a constructor, the type is always the type of the static side of the class.
+          * If 'node' is a property, method, or accessor declaration, the effective argument
+          *    type is the type of the static or instance side of the parent class for class
+          *    element, depending on whether the element is declared static.
+          */
+        function getEffectiveDecoratorFirstArgumentType(node) {
+            // The first argument to a decorator is its `target`.
+            if (node.kind === 221 /* ClassDeclaration */) {
+                // For a class decorator, the `target` is the type of the class (e.g. the
+                // "static" or "constructor" side of the class)
+                var classSymbol = getSymbolOfNode(node);
+                return getTypeOfSymbol(classSymbol);
+            }
+            if (node.kind === 142 /* Parameter */) {
+                // For a parameter decorator, the `target` is the parent type of the
+                // parameter's containing method.
+                node = node.parent;
+                if (node.kind === 148 /* Constructor */) {
+                    var classSymbol = getSymbolOfNode(node);
+                    return getTypeOfSymbol(classSymbol);
+                }
+            }
+            if (node.kind === 145 /* PropertyDeclaration */ ||
+                node.kind === 147 /* MethodDeclaration */ ||
+                node.kind === 149 /* GetAccessor */ ||
+                node.kind === 150 /* SetAccessor */) {
+                // For a property or method decorator, the `target` is the
+                // "static"-side type of the parent of the member if the member is
+                // declared "static"; otherwise, it is the "instance"-side type of the
+                // parent of the member.
+                return getParentTypeOfClassElement(node);
+            }
+            ts.Debug.fail("Unsupported decorator target.");
+            return unknownType;
+        }
+        /**
+          * Returns the effective type for the second argument to a decorator.
+          * If 'node' is a parameter, its effective argument type is one of the following:
+          *    If 'node.parent' is a constructor, the effective argument type is 'any', as we
+          *       will emit `undefined`.
+          *    If 'node.parent' is a member with an identifier, numeric, or string literal name,
+          *       the effective argument type will be a string literal type for the member name.
+          *    If 'node.parent' is a computed property name, the effective argument type will
+          *       either be a symbol type or the string type.
+          * If 'node' is a member with an identifier, numeric, or string literal name, the
+          *    effective argument type will be a string literal type for the member name.
+          * If 'node' is a computed property name, the effective argument type will either
+          *    be a symbol type or the string type.
+          * A class decorator does not have a second argument type.
+          */
+        function getEffectiveDecoratorSecondArgumentType(node) {
+            // The second argument to a decorator is its `propertyKey`
+            if (node.kind === 221 /* ClassDeclaration */) {
+                ts.Debug.fail("Class decorators should not have a second synthetic argument.");
+                return unknownType;
+            }
+            if (node.kind === 142 /* Parameter */) {
+                node = node.parent;
+                if (node.kind === 148 /* Constructor */) {
+                    // For a constructor parameter decorator, the `propertyKey` will be `undefined`.
+                    return anyType;
+                }
+            }
+            if (node.kind === 145 /* PropertyDeclaration */ ||
+                node.kind === 147 /* MethodDeclaration */ ||
+                node.kind === 149 /* GetAccessor */ ||
+                node.kind === 150 /* SetAccessor */) {
+                // The `propertyKey` for a property or method decorator will be a
+                // string literal type if the member name is an identifier, number, or string;
+                // otherwise, if the member name is a computed property name it will
+                // be either string or symbol.
+                var element = node;
+                switch (element.name.kind) {
+                    case 69 /* Identifier */:
+                    case 8 /* NumericLiteral */:
+                    case 9 /* StringLiteral */:
+                        return getStringLiteralTypeForText(element.name.text);
+                    case 140 /* ComputedPropertyName */:
+                        var nameType = checkComputedPropertyName(element.name);
+                        if (isTypeOfKind(nameType, 16777216 /* ESSymbol */)) {
+                            return nameType;
+                        }
+                        else {
+                            return stringType;
+                        }
+                    default:
+                        ts.Debug.fail("Unsupported property name.");
+                        return unknownType;
+                }
+            }
+            ts.Debug.fail("Unsupported decorator target.");
+            return unknownType;
+        }
+        /**
+          * Returns the effective argument type for the third argument to a decorator.
+          * If 'node' is a parameter, the effective argument type is the number type.
+          * If 'node' is a method or accessor, the effective argument type is a
+          *    `TypedPropertyDescriptor<T>` instantiated with the type of the member.
+          * Class and property decorators do not have a third effective argument.
+          */
+        function getEffectiveDecoratorThirdArgumentType(node) {
+            // The third argument to a decorator is either its `descriptor` for a method decorator
+            // or its `parameterIndex` for a parameter decorator
+            if (node.kind === 221 /* ClassDeclaration */) {
+                ts.Debug.fail("Class decorators should not have a third synthetic argument.");
+                return unknownType;
+            }
+            if (node.kind === 142 /* Parameter */) {
+                // The `parameterIndex` for a parameter decorator is always a number
+                return numberType;
+            }
+            if (node.kind === 145 /* PropertyDeclaration */) {
+                ts.Debug.fail("Property decorators should not have a third synthetic argument.");
+                return unknownType;
+            }
+            if (node.kind === 147 /* MethodDeclaration */ ||
+                node.kind === 149 /* GetAccessor */ ||
+                node.kind === 150 /* SetAccessor */) {
+                // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor<T>`
+                // for the type of the member.
+                var propertyType = getTypeOfNode(node);
+                return createTypedPropertyDescriptorType(propertyType);
+            }
+            ts.Debug.fail("Unsupported decorator target.");
+            return unknownType;
+        }
+        /**
+          * Returns the effective argument type for the provided argument to a decorator.
+          */
+        function getEffectiveDecoratorArgumentType(node, argIndex) {
+            if (argIndex === 0) {
+                return getEffectiveDecoratorFirstArgumentType(node.parent);
+            }
+            else if (argIndex === 1) {
+                return getEffectiveDecoratorSecondArgumentType(node.parent);
+            }
+            else if (argIndex === 2) {
+                return getEffectiveDecoratorThirdArgumentType(node.parent);
+            }
+            ts.Debug.fail("Decorators should not have a fourth synthetic argument.");
+            return unknownType;
+        }
+        /**
+          * Gets the effective argument type for an argument in a call expression.
+          */
+        function getEffectiveArgumentType(node, argIndex, arg) {
+            // Decorators provide special arguments, a tagged template expression provides
+            // a special first argument, and string literals get string literal types
+            // unless we're reporting errors
+            if (node.kind === 143 /* Decorator */) {
+                return getEffectiveDecoratorArgumentType(node, argIndex);
+            }
+            else if (argIndex === 0 && node.kind === 176 /* TaggedTemplateExpression */) {
+                return getGlobalTemplateStringsArrayType();
+            }
+            // This is not a synthetic argument, so we return 'undefined'
+            // to signal that the caller needs to check the argument.
+            return undefined;
+        }
+        /**
+          * Gets the effective argument expression for an argument in a call expression.
+          */
+        function getEffectiveArgument(node, args, argIndex) {
+            // For a decorator or the first argument of a tagged template expression we return undefined.
+            if (node.kind === 143 /* Decorator */ ||
+                (argIndex === 0 && node.kind === 176 /* TaggedTemplateExpression */)) {
+                return undefined;
+            }
+            return args[argIndex];
+        }
+        /**
+          * Gets the error node to use when reporting errors for an effective argument.
+          */
+        function getEffectiveArgumentErrorNode(node, argIndex, arg) {
+            if (node.kind === 143 /* Decorator */) {
+                // For a decorator, we use the expression of the decorator for error reporting.
+                return node.expression;
+            }
+            else if (argIndex === 0 && node.kind === 176 /* TaggedTemplateExpression */) {
+                // For a the first argument of a tagged template expression, we use the template of the tag for error reporting.
+                return node.template;
+            }
+            else {
+                return arg;
+            }
+        }
+        function resolveCall(node, signatures, candidatesOutArray, headMessage) {
+            var isTaggedTemplate = node.kind === 176 /* TaggedTemplateExpression */;
+            var isDecorator = node.kind === 143 /* Decorator */;
+            var typeArguments;
+            if (!isTaggedTemplate && !isDecorator) {
+                typeArguments = node.typeArguments;
+                // We already perform checking on the type arguments on the class declaration itself.
+                if (node.expression.kind !== 95 /* SuperKeyword */) {
+                    ts.forEach(typeArguments, checkSourceElement);
+                }
+            }
+            var candidates = candidatesOutArray || [];
+            // reorderCandidates fills up the candidates array directly
+            reorderCandidates(signatures, candidates);
+            if (!candidates.length) {
+                reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
+                return resolveErrorCall(node);
+            }
+            var args = getEffectiveCallArguments(node);
+            // The following applies to any value of 'excludeArgument[i]':
+            //    - true:      the argument at 'i' is susceptible to a one-time permanent contextual typing.
+            //    - undefined: the argument at 'i' is *not* susceptible to permanent contextual typing.
+            //    - false:     the argument at 'i' *was* and *has been* permanently contextually typed.
+            //
+            // The idea is that we will perform type argument inference & assignability checking once
+            // without using the susceptible parameters that are functions, and once more for each of those
+            // parameters, contextually typing each as we go along.
+            //
+            // For a tagged template, then the first argument be 'undefined' if necessary
+            // because it represents a TemplateStringsArray.
+            //
+            // For a decorator, no arguments are susceptible to contextual typing due to the fact
+            // decorators are applied to a declaration by the emitter, and not to an expression.
+            var excludeArgument;
+            if (!isDecorator) {
+                // We do not need to call `getEffectiveArgumentCount` here as it only
+                // applies when calculating the number of arguments for a decorator.
+                for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) {
+                    if (isContextSensitive(args[i])) {
+                        if (!excludeArgument) {
+                            excludeArgument = new Array(args.length);
+                        }
+                        excludeArgument[i] = true;
+                    }
+                }
+            }
+            // The following variables are captured and modified by calls to chooseOverload.
+            // If overload resolution or type argument inference fails, we want to report the
+            // best error possible. The best error is one which says that an argument was not
+            // assignable to a parameter. This implies that everything else about the overload
+            // was fine. So if there is any overload that is only incorrect because of an
+            // argument, we will report an error on that one.
+            //
+            //     function foo(s: string) {}
+            //     function foo(n: number) {} // Report argument error on this overload
+            //     function foo() {}
+            //     foo(true);
+            //
+            // If none of the overloads even made it that far, there are two possibilities.
+            // There was a problem with type arguments for some overload, in which case
+            // report an error on that. Or none of the overloads even had correct arity,
+            // in which case give an arity error.
+            //
+            //     function foo<T>(x: T, y: T) {} // Report type argument inference error
+            //     function foo() {}
+            //     foo(0, true);
+            //
+            var candidateForArgumentError;
+            var candidateForTypeArgumentError;
+            var resultOfFailedInference;
+            var result;
+            // If we are in signature help, a trailing comma indicates that we intend to provide another argument,
+            // so we will only accept overloads with arity at least 1 higher than the current number of provided arguments.
+            var signatureHelpTrailingComma = candidatesOutArray && node.kind === 174 /* CallExpression */ && node.arguments.hasTrailingComma;
+            // Section 4.12.1:
+            // if the candidate list contains one or more signatures for which the type of each argument
+            // expression is a subtype of each corresponding parameter type, the return type of the first
+            // of those signatures becomes the return type of the function call.
+            // Otherwise, the return type of the first signature in the candidate list becomes the return
+            // type of the function call.
+            //
+            // Whether the call is an error is determined by assignability of the arguments. The subtype pass
+            // is just important for choosing the best signature. So in the case where there is only one
+            // signature, the subtype pass is useless. So skipping it is an optimization.
+            if (candidates.length > 1) {
+                result = chooseOverload(candidates, subtypeRelation, signatureHelpTrailingComma);
+            }
+            if (!result) {
+                // Reinitialize these pointers for round two
+                candidateForArgumentError = undefined;
+                candidateForTypeArgumentError = undefined;
+                resultOfFailedInference = undefined;
+                result = chooseOverload(candidates, assignableRelation, signatureHelpTrailingComma);
+            }
+            if (result) {
+                return result;
+            }
+            // No signatures were applicable. Now report errors based on the last applicable signature with
+            // no arguments excluded from assignability checks.
+            // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
+            // skip the checkApplicableSignature check.
+            if (candidateForArgumentError) {
+                // excludeArgument is undefined, in this case also equivalent to [undefined, undefined, ...]
+                // The importance of excludeArgument is to prevent us from typing function expression parameters
+                // in arguments too early. If possible, we'd like to only type them once we know the correct
+                // overload. However, this matters for the case where the call is correct. When the call is
+                // an error, we don't need to exclude any arguments, although it would cause no harm to do so.
+                checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
+            }
+            else if (candidateForTypeArgumentError) {
+                if (!isTaggedTemplate && !isDecorator && typeArguments) {
+                    var typeArguments_2 = node.typeArguments;
+                    checkTypeArguments(candidateForTypeArgumentError, typeArguments_2, ts.map(typeArguments_2, getTypeFromTypeNode), /*reportErrors*/ true, headMessage);
+                }
+                else {
+                    ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0);
+                    var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex];
+                    var inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex);
+                    var diagnosticChainHead = ts.chainDiagnosticMessages(/*details*/ undefined, // details will be provided by call to reportNoCommonSupertypeError
+                    ts.Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter));
+                    if (headMessage) {
+                        diagnosticChainHead = ts.chainDiagnosticMessages(diagnosticChainHead, headMessage);
+                    }
+                    reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead);
+                }
+            }
+            else {
+                reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
+            }
+            // No signature was applicable. We have already reported the errors for the invalid signature.
+            // If this is a type resolution session, e.g. Language Service, try to get better information that anySignature.
+            // Pick the first candidate that matches the arity. This way we can get a contextual type for cases like:
+            //  declare function f(a: { xa: number; xb: number; });
+            //  f({ |
+            if (!produceDiagnostics) {
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
+                    if (hasCorrectArity(node, args, candidate)) {
+                        if (candidate.typeParameters && typeArguments) {
+                            candidate = getSignatureInstantiation(candidate, ts.map(typeArguments, getTypeFromTypeNode));
+                        }
+                        return candidate;
+                    }
+                }
+            }
+            return resolveErrorCall(node);
+            function reportError(message, arg0, arg1, arg2) {
+                var errorInfo;
+                errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
+                if (headMessage) {
+                    errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage);
+                }
+                diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
+            }
+            function chooseOverload(candidates, relation, signatureHelpTrailingComma) {
+                if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
+                for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+                    var originalCandidate = candidates_2[_i];
+                    if (!hasCorrectArity(node, args, originalCandidate, signatureHelpTrailingComma)) {
+                        continue;
+                    }
+                    var candidate = void 0;
+                    var typeArgumentsAreValid = void 0;
+                    var inferenceContext = originalCandidate.typeParameters
+                        ? createInferenceContext(originalCandidate.typeParameters, /*inferUnionTypes*/ false)
+                        : undefined;
+                    while (true) {
+                        candidate = originalCandidate;
+                        if (candidate.typeParameters) {
+                            var typeArgumentTypes = void 0;
+                            if (typeArguments) {
+                                typeArgumentTypes = ts.map(typeArguments, getTypeFromTypeNode);
+                                typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, /*reportErrors*/ false);
+                            }
+                            else {
+                                inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext);
+                                typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined;
+                                typeArgumentTypes = inferenceContext.inferredTypes;
+                            }
+                            if (!typeArgumentsAreValid) {
+                                break;
+                            }
+                            candidate = getSignatureInstantiation(candidate, typeArgumentTypes);
+                        }
+                        if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
+                            break;
+                        }
+                        var index = excludeArgument ? ts.indexOf(excludeArgument, true) : -1;
+                        if (index < 0) {
+                            return candidate;
+                        }
+                        excludeArgument[index] = false;
+                    }
+                    // A post-mortem of this iteration of the loop. The signature was not applicable,
+                    // so we want to track it as a candidate for reporting an error. If the candidate
+                    // had no type parameters, or had no issues related to type arguments, we can
+                    // report an error based on the arguments. If there was an issue with type
+                    // arguments, then we can only report an error based on the type arguments.
+                    if (originalCandidate.typeParameters) {
+                        var instantiatedCandidate = candidate;
+                        if (typeArgumentsAreValid) {
+                            candidateForArgumentError = instantiatedCandidate;
+                        }
+                        else {
+                            candidateForTypeArgumentError = originalCandidate;
+                            if (!typeArguments) {
+                                resultOfFailedInference = inferenceContext;
+                            }
+                        }
+                    }
+                    else {
+                        ts.Debug.assert(originalCandidate === candidate);
+                        candidateForArgumentError = originalCandidate;
+                    }
+                }
+                return undefined;
+            }
+        }
+        function resolveCallExpression(node, candidatesOutArray) {
+            if (node.expression.kind === 95 /* SuperKeyword */) {
+                var superType = checkSuperExpression(node.expression);
+                if (superType !== unknownType) {
+                    // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated
+                    // with the type arguments specified in the extends clause.
+                    var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getContainingClass(node));
+                    if (baseTypeNode) {
+                        var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments);
+                        return resolveCall(node, baseConstructors, candidatesOutArray);
+                    }
+                }
+                return resolveUntypedCall(node);
+            }
+            var funcType = checkNonNullExpression(node.expression);
+            var apparentType = getApparentType(funcType);
+            if (apparentType === unknownType) {
+                // Another error has already been reported
+                return resolveErrorCall(node);
+            }
+            // Technically, this signatures list may be incomplete. We are taking the apparent type,
+            // but we are not including call signatures that may have been added to the Object or
+            // Function interface, since they have none by default. This is a bit of a leap of faith
+            // that the user will not add any.
+            var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
+            var constructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */);
+            // TS 1.0 spec: 4.12
+            // If FuncExpr is of type Any, or of an object type that has no call or construct signatures
+            // but is a subtype of the Function interface, the call is an untyped function call. In an
+            // untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
+            // types are provided for the argument expressions, and the result is always of type Any.
+            // We exclude union types because we may have a union of function types that happen to have
+            // no common signatures.
+            if (isTypeAny(funcType) ||
+                (isTypeAny(apparentType) && funcType.flags & 512 /* TypeParameter */) ||
+                (!callSignatures.length && !constructSignatures.length && !(funcType.flags & 16384 /* Union */) && isTypeAssignableTo(funcType, globalFunctionType))) {
+                // The unknownType indicates that an error already occurred (and was reported).  No
+                // need to report another error in this case.
+                if (funcType !== unknownType && node.typeArguments) {
+                    error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
+                }
+                return resolveUntypedCall(node);
+            }
+            // If FuncExpr's apparent type(section 3.8.1) is a function type, the call is a typed function call.
+            // TypeScript employs overload resolution in typed function calls in order to support functions
+            // with multiple call signatures.
+            if (!callSignatures.length) {
+                if (constructSignatures.length) {
+                    error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
+                }
+                else {
+                    error(node, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature);
+                }
+                return resolveErrorCall(node);
+            }
+            return resolveCall(node, callSignatures, candidatesOutArray);
+        }
+        function resolveNewExpression(node, candidatesOutArray) {
+            if (node.arguments && languageVersion < 1 /* ES5 */) {
+                var spreadIndex = getSpreadArgumentIndex(node.arguments);
+                if (spreadIndex >= 0) {
+                    error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
+                }
+            }
+            var expressionType = checkNonNullExpression(node.expression);
+            // If expressionType's apparent type(section 3.8.1) is an object type with one or
+            // more construct signatures, the expression is processed in the same manner as a
+            // function call, but using the construct signatures as the initial set of candidate
+            // signatures for overload resolution. The result type of the function call becomes
+            // the result type of the operation.
+            expressionType = getApparentType(expressionType);
+            if (expressionType === unknownType) {
+                // Another error has already been reported
+                return resolveErrorCall(node);
+            }
+            // If the expression is a class of abstract type, then it cannot be instantiated.
+            // Note, only class declarations can be declared abstract.
+            // In the case of a merged class-module or class-interface declaration,
+            // only the class declaration node will have the Abstract flag set.
+            var valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
+            if (valueDecl && valueDecl.flags & 128 /* Abstract */) {
+                error(node, ts.Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, ts.declarationNameToString(valueDecl.name));
+                return resolveErrorCall(node);
+            }
+            // TS 1.0 spec: 4.11
+            // If expressionType is of type Any, Args can be any argument
+            // list and the result of the operation is of type Any.
+            if (isTypeAny(expressionType)) {
+                if (node.typeArguments) {
+                    error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
+                }
+                return resolveUntypedCall(node);
+            }
+            // Technically, this signatures list may be incomplete. We are taking the apparent type,
+            // but we are not including construct signatures that may have been added to the Object or
+            // Function interface, since they have none by default. This is a bit of a leap of faith
+            // that the user will not add any.
+            var constructSignatures = getSignaturesOfType(expressionType, 1 /* Construct */);
+            if (constructSignatures.length) {
+                if (!isConstructorAccessible(node, constructSignatures[0])) {
+                    return resolveErrorCall(node);
+                }
+                return resolveCall(node, constructSignatures, candidatesOutArray);
+            }
+            // If expressionType's apparent type is an object type with no construct signatures but
+            // one or more call signatures, the expression is processed as a function call. A compile-time
+            // error occurs if the result of the function call is not Void. The type of the result of the
+            // operation is Any. It is an error to have a Void this type.
+            var callSignatures = getSignaturesOfType(expressionType, 0 /* Call */);
+            if (callSignatures.length) {
+                var signature = resolveCall(node, callSignatures, candidatesOutArray);
+                if (getReturnTypeOfSignature(signature) !== voidType) {
+                    error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
+                }
+                if (getThisTypeOfSignature(signature) === voidType) {
+                    error(node, ts.Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void);
+                }
+                return signature;
+            }
+            error(node, ts.Diagnostics.Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature);
+            return resolveErrorCall(node);
+        }
+        function isConstructorAccessible(node, signature) {
+            if (!signature || !signature.declaration) {
+                return true;
+            }
+            var declaration = signature.declaration;
+            var flags = declaration.flags;
+            // Public constructor is accessible.
+            if (!(flags & (8 /* Private */ | 16 /* Protected */))) {
+                return true;
+            }
+            var declaringClassDeclaration = getClassLikeDeclarationOfSymbol(declaration.parent.symbol);
+            var declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
+            // A private or protected constructor can only be instantiated within it's own class
+            if (!isNodeWithinClass(node, declaringClassDeclaration)) {
+                if (flags & 8 /* Private */) {
+                    error(node, ts.Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
+                }
+                if (flags & 16 /* Protected */) {
+                    error(node, ts.Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
+                }
+                return false;
+            }
+            return true;
+        }
+        function resolveTaggedTemplateExpression(node, candidatesOutArray) {
+            var tagType = checkExpression(node.tag);
+            var apparentType = getApparentType(tagType);
+            if (apparentType === unknownType) {
+                // Another error has already been reported
+                return resolveErrorCall(node);
+            }
+            var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
+            if (isTypeAny(tagType) || (!callSignatures.length && !(tagType.flags & 16384 /* Union */) && isTypeAssignableTo(tagType, globalFunctionType))) {
+                return resolveUntypedCall(node);
+            }
+            if (!callSignatures.length) {
+                error(node, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature);
+                return resolveErrorCall(node);
+            }
+            return resolveCall(node, callSignatures, candidatesOutArray);
+        }
+        /**
+          * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression.
+          */
+        function getDiagnosticHeadMessageForDecoratorResolution(node) {
+            switch (node.parent.kind) {
+                case 221 /* ClassDeclaration */:
+                case 192 /* ClassExpression */:
+                    return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression;
+                case 142 /* Parameter */:
+                    return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression;
+                case 145 /* PropertyDeclaration */:
+                    return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression;
+                case 147 /* MethodDeclaration */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                    return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression;
+            }
+        }
+        /**
+          * Resolves a decorator as if it were a call expression.
+          */
+        function resolveDecorator(node, candidatesOutArray) {
+            var funcType = checkExpression(node.expression);
+            var apparentType = getApparentType(funcType);
+            if (apparentType === unknownType) {
+                return resolveErrorCall(node);
+            }
+            var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
+            if (funcType === anyType || (!callSignatures.length && !(funcType.flags & 16384 /* Union */) && isTypeAssignableTo(funcType, globalFunctionType))) {
+                return resolveUntypedCall(node);
+            }
+            var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+            if (!callSignatures.length) {
+                var errorInfo = void 0;
+                errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature);
+                errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage);
+                diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
+                return resolveErrorCall(node);
+            }
+            return resolveCall(node, callSignatures, candidatesOutArray, headMessage);
+        }
+        function resolveSignature(node, candidatesOutArray) {
+            switch (node.kind) {
+                case 174 /* CallExpression */:
+                    return resolveCallExpression(node, candidatesOutArray);
+                case 175 /* NewExpression */:
+                    return resolveNewExpression(node, candidatesOutArray);
+                case 176 /* TaggedTemplateExpression */:
+                    return resolveTaggedTemplateExpression(node, candidatesOutArray);
+                case 143 /* Decorator */:
+                    return resolveDecorator(node, candidatesOutArray);
+            }
+            ts.Debug.fail("Branch in 'resolveSignature' should be unreachable.");
+        }
+        // candidatesOutArray is passed by signature help in the language service, and collectCandidates
+        // must fill it up with the appropriate candidate signatures
+        function getResolvedSignature(node, candidatesOutArray) {
+            var links = getNodeLinks(node);
+            // If getResolvedSignature has already been called, we will have cached the resolvedSignature.
+            // However, it is possible that either candidatesOutArray was not passed in the first time,
+            // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work
+            // to correctly fill the candidatesOutArray.
+            var cached = links.resolvedSignature;
+            if (cached && cached !== anySignature && !candidatesOutArray) {
+                return cached;
+            }
+            links.resolvedSignature = anySignature;
+            var result = resolveSignature(node, candidatesOutArray);
+            // If signature resolution originated in control flow type analysis (for example to compute the
+            // assigned type in a flow assignment) we don't cache the result as it may be based on temporary
+            // types from the control flow analysis.
+            links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
+            return result;
+        }
+        function getResolvedOrAnySignature(node) {
+            // If we're already in the process of resolving the given signature, don't resolve again as
+            // that could cause infinite recursion. Instead, return anySignature.
+            return getNodeLinks(node).resolvedSignature === anySignature ? anySignature : getResolvedSignature(node);
+        }
+        function getInferredClassType(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.inferredClassType) {
+                links.inferredClassType = createAnonymousType(undefined, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined);
+            }
+            return links.inferredClassType;
+        }
+        /**
+         * Syntactically and semantically checks a call or new expression.
+         * @param node The call/new expression to be checked.
+         * @returns On success, the expression's signature's return type. On failure, anyType.
+         */
+        function checkCallExpression(node) {
+            // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
+            checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
+            var signature = getResolvedSignature(node);
+            if (node.expression.kind === 95 /* SuperKeyword */) {
+                return voidType;
+            }
+            if (node.kind === 175 /* NewExpression */) {
+                var declaration = signature.declaration;
+                if (declaration &&
+                    declaration.kind !== 148 /* Constructor */ &&
+                    declaration.kind !== 152 /* ConstructSignature */ &&
+                    declaration.kind !== 157 /* ConstructorType */ &&
+                    !ts.isJSDocConstructSignature(declaration)) {
+                    // When resolved signature is a call signature (and not a construct signature) the result type is any, unless
+                    // the declaring function had members created through 'x.prototype.y = expr' or 'this.y = expr' psuedodeclarations
+                    // in a JS file
+                    // Note:JS inferred classes might come from a variable declaration instead of a function declaration.
+                    // In this case, using getResolvedSymbol directly is required to avoid losing the members from the declaration.
+                    var funcSymbol = node.expression.kind === 69 /* Identifier */ ?
+                        getResolvedSymbol(node.expression) :
+                        checkExpression(node.expression).symbol;
+                    if (funcSymbol && funcSymbol.members && (funcSymbol.flags & 16 /* Function */ || ts.isDeclarationOfFunctionExpression(funcSymbol))) {
+                        return getInferredClassType(funcSymbol);
+                    }
+                    else if (compilerOptions.noImplicitAny) {
+                        error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
+                    }
+                    return anyType;
+                }
+            }
+            // In JavaScript files, calls to any identifier 'require' are treated as external module imports
+            if (ts.isInJavaScriptFile(node) && ts.isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
+                return resolveExternalModuleTypeByLiteral(node.arguments[0]);
+            }
+            return getReturnTypeOfSignature(signature);
+        }
+        function checkTaggedTemplateExpression(node) {
+            return getReturnTypeOfSignature(getResolvedSignature(node));
+        }
+        function checkAssertion(node) {
+            var exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
+            checkSourceElement(node.type);
+            var targetType = getTypeFromTypeNode(node.type);
+            if (produceDiagnostics && targetType !== unknownType) {
+                var widenedType = getWidenedType(exprType);
+                if (!isTypeComparableTo(targetType, widenedType)) {
+                    checkTypeComparableTo(exprType, targetType, node, ts.Diagnostics.Type_0_cannot_be_converted_to_type_1);
+                }
+            }
+            return targetType;
+        }
+        function checkNonNullAssertion(node) {
+            return getNonNullableType(checkExpression(node.expression));
+        }
+        function getTypeOfParameter(symbol) {
+            var type = getTypeOfSymbol(symbol);
+            if (strictNullChecks) {
+                var declaration = symbol.valueDeclaration;
+                if (declaration && declaration.initializer) {
+                    return addTypeKind(type, 32 /* Undefined */);
+                }
+            }
+            return type;
+        }
+        function getTypeAtPosition(signature, pos) {
+            return signature.hasRestParameter ?
+                pos < signature.parameters.length - 1 ? getTypeOfParameter(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
+                pos < signature.parameters.length ? getTypeOfParameter(signature.parameters[pos]) : anyType;
+        }
+        function assignContextualParameterTypes(signature, context, mapper) {
+            var len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            for (var i = 0; i < len; i++) {
+                var parameter = signature.parameters[i];
+                var contextualParameterType = getTypeAtPosition(context, i);
+                assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
+            }
+            if (signature.hasRestParameter && isRestParameterIndex(context, signature.parameters.length - 1)) {
+                var parameter = ts.lastOrUndefined(signature.parameters);
+                var contextualParameterType = getTypeOfSymbol(ts.lastOrUndefined(context.parameters));
+                assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
+            }
+        }
+        // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push
+        // the destructured type into the contained binding elements.
+        function assignBindingElementTypes(node) {
+            if (ts.isBindingPattern(node.name)) {
+                for (var _i = 0, _a = node.name.elements; _i < _a.length; _i++) {
+                    var element = _a[_i];
+                    if (element.kind !== 193 /* OmittedExpression */) {
+                        if (element.name.kind === 69 /* Identifier */) {
+                            getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
+                        }
+                        assignBindingElementTypes(element);
+                    }
+                }
+            }
+        }
+        function assignTypeToParameterAndFixTypeParameters(parameter, contextualType, mapper) {
+            var links = getSymbolLinks(parameter);
+            if (!links.type) {
+                links.type = instantiateType(contextualType, mapper);
+                // if inference didn't come up with anything but {}, fall back to the binding pattern if present.
+                if (links.type === emptyObjectType &&
+                    (parameter.valueDeclaration.name.kind === 167 /* ObjectBindingPattern */ ||
+                        parameter.valueDeclaration.name.kind === 168 /* ArrayBindingPattern */)) {
+                    links.type = getTypeFromBindingPattern(parameter.valueDeclaration.name);
+                }
+                assignBindingElementTypes(parameter.valueDeclaration);
+            }
+            else if (isInferentialContext(mapper)) {
+                // Even if the parameter already has a type, it might be because it was given a type while
+                // processing the function as an argument to a prior signature during overload resolution.
+                // If this was the case, it may have caused some type parameters to be fixed. So here,
+                // we need to ensure that type parameters at the same positions get fixed again. This is
+                // done by calling instantiateType to attach the mapper to the contextualType, and then
+                // calling inferTypes to force a walk of contextualType so that all the correct fixing
+                // happens. The choice to pass in links.type may seem kind of arbitrary, but it serves
+                // to make sure that all the correct positions in contextualType are reached by the walk.
+                // Here is an example:
+                //
+                //      interface Base {
+                //          baseProp;
+                //      }
+                //      interface Derived extends Base {
+                //          toBase(): Base;
+                //      }
+                //
+                //      var derived: Derived;
+                //
+                //      declare function foo<T>(x: T, func: (p: T) => T): T;
+                //      declare function foo<T>(x: T, func: (p: T) => T): T;
+                //
+                //      var result = foo(derived, d => d.toBase());
+                //
+                // We are typing d while checking the second overload. But we've already given d
+                // a type (Derived) from the first overload. However, we still want to fix the
+                // T in the second overload so that we do not infer Base as a candidate for T
+                // (inferring Base would make type argument inference inconsistent between the two
+                // overloads).
+                inferTypes(mapper.context, links.type, instantiateType(contextualType, mapper));
+            }
+        }
+        function getReturnTypeFromJSDocComment(func) {
+            var returnTag = ts.getJSDocReturnTag(func);
+            if (returnTag && returnTag.typeExpression) {
+                return getTypeFromTypeNode(returnTag.typeExpression.type);
+            }
+            return undefined;
+        }
+        function createPromiseType(promisedType) {
+            // creates a `Promise<T>` type where `T` is the promisedType argument
+            var globalPromiseType = getGlobalPromiseType();
+            if (globalPromiseType !== emptyGenericType) {
+                // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
+                promisedType = getAwaitedType(promisedType);
+                return createTypeReference(globalPromiseType, [promisedType]);
+            }
+            return emptyObjectType;
+        }
+        function createPromiseReturnType(func, promisedType) {
+            var promiseType = createPromiseType(promisedType);
+            if (promiseType === emptyObjectType) {
+                error(func, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
+                return unknownType;
+            }
+            return promiseType;
+        }
+        function getReturnTypeFromBody(func, contextualMapper) {
+            var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
+            if (!func.body) {
+                return unknownType;
+            }
+            var isAsync = ts.isAsyncFunctionLike(func);
+            var type;
+            if (func.body.kind !== 199 /* Block */) {
+                type = checkExpressionCached(func.body, contextualMapper);
+                if (isAsync) {
+                    // From within an async function you can return either a non-promise value or a promise. Any
+                    // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
+                    // return type of the body should be unwrapped to its awaited type, which we will wrap in
+                    // the native Promise<T> type later in this function.
+                    type = checkAwaitedType(type, func, ts.Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
+                }
+            }
+            else {
+                var types = void 0;
+                var funcIsGenerator = !!func.asteriskToken;
+                if (funcIsGenerator) {
+                    types = checkAndAggregateYieldOperandTypes(func, contextualMapper);
+                    if (types.length === 0) {
+                        var iterableIteratorAny = createIterableIteratorType(anyType);
+                        if (compilerOptions.noImplicitAny) {
+                            error(func.asteriskToken, ts.Diagnostics.Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type, typeToString(iterableIteratorAny));
+                        }
+                        return iterableIteratorAny;
+                    }
+                }
+                else {
+                    types = checkAndAggregateReturnExpressionTypes(func, contextualMapper);
+                    if (!types) {
+                        // For an async function, the return type will not be never, but rather a Promise for never.
+                        return isAsync ? createPromiseReturnType(func, neverType) : neverType;
+                    }
+                    if (types.length === 0) {
+                        // For an async function, the return type will not be void, but rather a Promise for void.
+                        return isAsync ? createPromiseReturnType(func, voidType) : voidType;
+                    }
+                }
+                // When yield/return statements are contextually typed we allow the return type to be a union type.
+                // Otherwise we require the yield/return expressions to have a best common supertype.
+                type = contextualSignature ? getUnionType(types) : getCommonSupertype(types);
+                if (!type) {
+                    if (funcIsGenerator) {
+                        error(func, ts.Diagnostics.No_best_common_type_exists_among_yield_expressions);
+                        return createIterableIteratorType(unknownType);
+                    }
+                    else {
+                        error(func, ts.Diagnostics.No_best_common_type_exists_among_return_expressions);
+                        // Defer to unioning the return types so we get a) downstream errors earlier and b) better Salsa experience
+                        return isAsync ? createPromiseReturnType(func, getUnionType(types)) : getUnionType(types);
+                    }
+                }
+                if (funcIsGenerator) {
+                    type = createIterableIteratorType(type);
+                }
+            }
+            if (!contextualSignature) {
+                reportErrorsFromWidening(func, type);
+            }
+            var widenedType = getWidenedType(type);
+            // From within an async function you can return either a non-promise value or a promise. Any
+            // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
+            // return type of the body is awaited type of the body, wrapped in a native Promise<T> type.
+            return isAsync ? createPromiseReturnType(func, widenedType) : widenedType;
+        }
+        function checkAndAggregateYieldOperandTypes(func, contextualMapper) {
+            var aggregatedTypes = [];
+            ts.forEachYieldExpression(func.body, function (yieldExpression) {
+                var expr = yieldExpression.expression;
+                if (expr) {
+                    var type = checkExpressionCached(expr, contextualMapper);
+                    if (yieldExpression.asteriskToken) {
+                        // A yield* expression effectively yields everything that its operand yields
+                        type = checkElementTypeOfIterable(type, yieldExpression.expression);
+                    }
+                    if (!ts.contains(aggregatedTypes, type)) {
+                        aggregatedTypes.push(type);
+                    }
+                }
+            });
+            return aggregatedTypes;
+        }
+        function isExhaustiveSwitchStatement(node) {
+            var expr = node.expression;
+            if (!node.possiblyExhaustive || expr.kind !== 172 /* PropertyAccessExpression */) {
+                return false;
+            }
+            var type = checkExpression(expr.expression);
+            if (!(type.flags & 16384 /* Union */)) {
+                return false;
+            }
+            var propName = expr.name.text;
+            var propType = getTypeOfPropertyOfType(type, propName);
+            if (!propType || !isStringLiteralUnionType(propType)) {
+                return false;
+            }
+            var switchTypes = getSwitchClauseTypes(node);
+            if (!switchTypes.length) {
+                return false;
+            }
+            return eachTypeContainedIn(propType, switchTypes);
+        }
+        function functionHasImplicitReturn(func) {
+            if (!(func.flags & 32768 /* HasImplicitReturn */)) {
+                return false;
+            }
+            var lastStatement = ts.lastOrUndefined(func.body.statements);
+            if (lastStatement && lastStatement.kind === 213 /* SwitchStatement */ && isExhaustiveSwitchStatement(lastStatement)) {
+                return false;
+            }
+            return true;
+        }
+        function checkAndAggregateReturnExpressionTypes(func, contextualMapper) {
+            var isAsync = ts.isAsyncFunctionLike(func);
+            var aggregatedTypes = [];
+            var hasReturnWithNoExpression = functionHasImplicitReturn(func);
+            var hasReturnOfTypeNever = false;
+            ts.forEachReturnStatement(func.body, function (returnStatement) {
+                var expr = returnStatement.expression;
+                if (expr) {
+                    var type = checkExpressionCached(expr, contextualMapper);
+                    if (isAsync) {
+                        // From within an async function you can return either a non-promise value or a promise. Any
+                        // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
+                        // return type of the body should be unwrapped to its awaited type, which should be wrapped in
+                        // the native Promise<T> type by the caller.
+                        type = checkAwaitedType(type, func, ts.Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
+                    }
+                    if (type === neverType) {
+                        hasReturnOfTypeNever = true;
+                    }
+                    else if (!ts.contains(aggregatedTypes, type)) {
+                        aggregatedTypes.push(type);
+                    }
+                }
+                else {
+                    hasReturnWithNoExpression = true;
+                }
+            });
+            if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever ||
+                func.kind === 179 /* FunctionExpression */ || func.kind === 180 /* ArrowFunction */)) {
+                return undefined;
+            }
+            if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression) {
+                if (!ts.contains(aggregatedTypes, undefinedType)) {
+                    aggregatedTypes.push(undefinedType);
+                }
+            }
+            return aggregatedTypes;
+        }
+        /**
+         * TypeScript Specification 1.0 (6.3) - July 2014
+         *   An explicitly typed function whose return type isn't the Void type,
+         *   the Any type, or a union type containing the Void or Any type as a constituent
+         *   must have at least one return statement somewhere in its body.
+         *   An exception to this rule is if the function implementation consists of a single 'throw' statement.
+         *
+         * @param returnType - return type of the function, can be undefined if return type is not explicitly specified
+         */
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
+            if (!produceDiagnostics) {
+                return;
+            }
+            // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions.
+            if (returnType && maybeTypeOfKind(returnType, 1 /* Any */ | 16 /* Void */)) {
+                return;
+            }
+            // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
+            // also if HasImplicitReturn flag is not set this means that all codepaths in function body end with return or throw
+            if (ts.nodeIsMissing(func.body) || func.body.kind !== 199 /* Block */ || !functionHasImplicitReturn(func)) {
+                return;
+            }
+            var hasExplicitReturn = func.flags & 65536 /* HasExplicitReturn */;
+            if (returnType === neverType) {
+                error(func.type, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
+            }
+            else if (returnType && !hasExplicitReturn) {
+                // minimal check: function has syntactic return type annotation and no explicit return statements in the body
+                // this function does not conform to the specification.
+                // NOTE: having returnType !== undefined is a precondition for entering this branch so func.type will always be present
+                error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
+            }
+            else if (returnType && strictNullChecks && !isTypeAssignableTo(undefinedType, returnType)) {
+                error(func.type, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
+            }
+            else if (compilerOptions.noImplicitReturns) {
+                if (!returnType) {
+                    // If return type annotation is omitted check if function has any explicit return statements.
+                    // If it does not have any - its inferred return type is void - don't do any checks.
+                    // Otherwise get inferred return type from function body and report error only if it is not void / anytype
+                    if (!hasExplicitReturn) {
+                        return;
+                    }
+                    var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
+                    if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
+                        return;
+                    }
+                }
+                error(func.type || func, ts.Diagnostics.Not_all_code_paths_return_a_value);
+            }
+        }
+        function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
+            ts.Debug.assert(node.kind !== 147 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
+            // Grammar checking
+            var hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
+            if (!hasGrammarError && node.kind === 179 /* FunctionExpression */) {
+                checkGrammarForGenerator(node);
+            }
+            // The identityMapper object is used to indicate that function expressions are wildcards
+            if (contextualMapper === identityMapper && isContextSensitive(node)) {
+                checkNodeDeferred(node);
+                return anyFunctionType;
+            }
+            var links = getNodeLinks(node);
+            var type = getTypeOfSymbol(node.symbol);
+            var contextSensitive = isContextSensitive(node);
+            var mightFixTypeParameters = contextSensitive && isInferentialContext(contextualMapper);
+            // Check if function expression is contextually typed and assign parameter types if so.
+            // See the comment in assignTypeToParameterAndFixTypeParameters to understand why we need to
+            // check mightFixTypeParameters.
+            if (mightFixTypeParameters || !(links.flags & 1024 /* ContextChecked */)) {
+                var contextualSignature = getContextualSignature(node);
+                // If a type check is started at a function expression that is an argument of a function call, obtaining the
+                // contextual type may recursively get back to here during overload resolution of the call. If so, we will have
+                // already assigned contextual types.
+                var contextChecked = !!(links.flags & 1024 /* ContextChecked */);
+                if (mightFixTypeParameters || !contextChecked) {
+                    links.flags |= 1024 /* ContextChecked */;
+                    if (contextualSignature) {
+                        var signature = getSignaturesOfType(type, 0 /* Call */)[0];
+                        if (contextSensitive) {
+                            assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper);
+                        }
+                        if (mightFixTypeParameters || !node.type && !signature.resolvedReturnType) {
+                            var returnType = getReturnTypeFromBody(node, contextualMapper);
+                            if (!signature.resolvedReturnType) {
+                                signature.resolvedReturnType = returnType;
+                            }
+                        }
+                    }
+                    if (!contextChecked) {
+                        checkSignatureDeclaration(node);
+                        checkNodeDeferred(node);
+                    }
+                }
+            }
+            if (produceDiagnostics && node.kind !== 147 /* MethodDeclaration */ && node.kind !== 146 /* MethodSignature */) {
+                checkCollisionWithCapturedSuperVariable(node, node.name);
+                checkCollisionWithCapturedThisVariable(node, node.name);
+            }
+            return type;
+        }
+        function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) {
+            ts.Debug.assert(node.kind !== 147 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
+            var isAsync = ts.isAsyncFunctionLike(node);
+            var returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type));
+            if (!node.asteriskToken) {
+                // return is not necessary in the body of generators
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+            }
+            if (node.body) {
+                if (!node.type) {
+                    // There are some checks that are only performed in getReturnTypeFromBody, that may produce errors
+                    // we need. An example is the noImplicitAny errors resulting from widening the return expression
+                    // of a function. Because checking of function expression bodies is deferred, there was never an
+                    // appropriate time to do this during the main walk of the file (see the comment at the top of
+                    // checkFunctionExpressionBodies). So it must be done now.
+                    getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+                }
+                if (node.body.kind === 199 /* Block */) {
+                    checkSourceElement(node.body);
+                }
+                else {
+                    // From within an async function you can return either a non-promise value or a promise. Any
+                    // Promise/A+ compatible implementation will always assimilate any foreign promise, so we
+                    // should not be checking assignability of a promise to the return type. Instead, we need to
+                    // check assignability of the awaited type of the expression body against the promised type of
+                    // its return type annotation.
+                    var exprType = checkExpression(node.body);
+                    if (returnOrPromisedType) {
+                        if (isAsync) {
+                            var awaitedType = checkAwaitedType(exprType, node.body, ts.Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member);
+                            checkTypeAssignableTo(awaitedType, returnOrPromisedType, node.body);
+                        }
+                        else {
+                            checkTypeAssignableTo(exprType, returnOrPromisedType, node.body);
+                        }
+                    }
+                }
+                registerForUnusedIdentifiersCheck(node);
+            }
+        }
+        function checkArithmeticOperandType(operand, type, diagnostic) {
+            if (!isTypeAnyOrAllConstituentTypesHaveKind(type, 132 /* NumberLike */)) {
+                error(operand, diagnostic);
+                return false;
+            }
+            return true;
+        }
+        function isReadonlySymbol(symbol) {
+            // The following symbols are considered read-only:
+            // Properties with a 'readonly' modifier
+            // Variables declared with 'const'
+            // Get accessors without matching set accessors
+            // Enum members
+            // Unions and intersections of the above (unions and intersections eagerly set isReadonly on creation)
+            return symbol.isReadonly ||
+                symbol.flags & 4 /* Property */ && (getDeclarationFlagsFromSymbol(symbol) & 64 /* Readonly */) !== 0 ||
+                symbol.flags & 3 /* Variable */ && (getDeclarationFlagsFromSymbol(symbol) & 2048 /* Const */) !== 0 ||
+                symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) ||
+                (symbol.flags & 8 /* EnumMember */) !== 0;
+        }
+        function isReferenceToReadonlyEntity(expr, symbol) {
+            if (isReadonlySymbol(symbol)) {
+                // Allow assignments to readonly properties within constructors of the same class declaration.
+                if (symbol.flags & 4 /* Property */ &&
+                    (expr.kind === 172 /* PropertyAccessExpression */ || expr.kind === 173 /* ElementAccessExpression */) &&
+                    expr.expression.kind === 97 /* ThisKeyword */) {
+                    // Look for if this is the constructor for the class that `symbol` is a property of.
+                    var func = ts.getContainingFunction(expr);
+                    if (!(func && func.kind === 148 /* Constructor */))
+                        return true;
+                    // If func.parent is a class and symbol is a (readonly) property of that class, or
+                    // if func is a constructor and symbol is a (readonly) parameter property declared in it,
+                    // then symbol is writeable here.
+                    return !(func.parent === symbol.valueDeclaration.parent || func === symbol.valueDeclaration.parent);
+                }
+                return true;
+            }
+            return false;
+        }
+        function isReferenceThroughNamespaceImport(expr) {
+            if (expr.kind === 172 /* PropertyAccessExpression */ || expr.kind === 173 /* ElementAccessExpression */) {
+                var node = skipParenthesizedNodes(expr.expression);
+                if (node.kind === 69 /* Identifier */) {
+                    var symbol = getNodeLinks(node).resolvedSymbol;
+                    if (symbol.flags & 8388608 /* Alias */) {
+                        var declaration = getDeclarationOfAliasSymbol(symbol);
+                        return declaration && declaration.kind === 232 /* NamespaceImport */;
+                    }
+                }
+            }
+            return false;
+        }
+        function checkReferenceExpression(expr, invalidReferenceMessage, constantVariableMessage) {
+            // References are combinations of identifiers, parentheses, and property accesses.
+            var node = skipParenthesizedNodes(expr);
+            if (node.kind !== 69 /* Identifier */ && node.kind !== 172 /* PropertyAccessExpression */ && node.kind !== 173 /* ElementAccessExpression */) {
+                error(expr, invalidReferenceMessage);
+                return false;
+            }
+            // Because we get the symbol from the resolvedSymbol property, it might be of kind
+            // SymbolFlags.ExportValue. In this case it is necessary to get the actual export
+            // symbol, which will have the correct flags set on it.
+            var links = getNodeLinks(node);
+            var symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
+            if (symbol) {
+                if (symbol !== unknownSymbol && symbol !== argumentsSymbol) {
+                    // Only variables (and not functions, classes, namespaces, enum objects, or enum members)
+                    // are considered references when referenced using a simple identifier.
+                    if (node.kind === 69 /* Identifier */ && !(symbol.flags & 3 /* Variable */)) {
+                        error(expr, invalidReferenceMessage);
+                        return false;
+                    }
+                    if (isReferenceToReadonlyEntity(node, symbol) || isReferenceThroughNamespaceImport(node)) {
+                        error(expr, constantVariableMessage);
+                        return false;
+                    }
+                }
+            }
+            else if (node.kind === 173 /* ElementAccessExpression */) {
+                if (links.resolvedIndexInfo && links.resolvedIndexInfo.isReadonly) {
+                    error(expr, constantVariableMessage);
+                    return false;
+                }
+            }
+            return true;
+        }
+        function checkDeleteExpression(node) {
+            checkExpression(node.expression);
+            return booleanType;
+        }
+        function checkTypeOfExpression(node) {
+            checkExpression(node.expression);
+            return stringType;
+        }
+        function checkVoidExpression(node) {
+            checkExpression(node.expression);
+            return undefinedWideningType;
+        }
+        function checkAwaitExpression(node) {
+            // Grammar checking
+            if (produceDiagnostics) {
+                if (!(node.flags & 33554432 /* AwaitContext */)) {
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.await_expression_is_only_allowed_within_an_async_function);
+                }
+                if (isInParameterInitializerBeforeContainingFunction(node)) {
+                    error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
+                }
+            }
+            var operandType = checkExpression(node.expression);
+            return checkAwaitedType(operandType, node);
+        }
+        function checkPrefixUnaryExpression(node) {
+            var operandType = checkExpression(node.operand);
+            switch (node.operator) {
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 50 /* TildeToken */:
+                    if (maybeTypeOfKind(operandType, 16777216 /* ESSymbol */)) {
+                        error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator));
+                    }
+                    return numberType;
+                case 49 /* ExclamationToken */:
+                    return booleanType;
+                case 41 /* PlusPlusToken */:
+                case 42 /* MinusMinusToken */:
+                    var ok = checkArithmeticOperandType(node.operand, getNonNullableType(operandType), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
+                    if (ok) {
+                        // run check only if former checks succeeded to avoid reporting cascading errors
+                        checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant_or_a_read_only_property);
+                    }
+                    return numberType;
+            }
+            return unknownType;
+        }
+        function checkPostfixUnaryExpression(node) {
+            var operandType = checkExpression(node.operand);
+            var ok = checkArithmeticOperandType(node.operand, getNonNullableType(operandType), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
+            if (ok) {
+                // run check only if former checks succeeded to avoid reporting cascading errors
+                checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant_or_a_read_only_property);
+            }
+            return numberType;
+        }
+        // Return true if type might be of the given kind. A union or intersection type might be of a given
+        // kind if at least one constituent type is of the given kind.
+        function maybeTypeOfKind(type, kind) {
+            if (type.flags & kind) {
+                return true;
+            }
+            if (type.flags & 49152 /* UnionOrIntersection */) {
+                var types = type.types;
+                for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+                    var t = types_10[_i];
+                    if (maybeTypeOfKind(t, kind)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        // Return true if type is of the given kind. A union type is of a given kind if all constituent types
+        // are of the given kind. An intersection type is of a given kind if at least one constituent type is
+        // of the given kind.
+        function isTypeOfKind(type, kind) {
+            if (type.flags & kind) {
+                return true;
+            }
+            if (type.flags & 16384 /* Union */) {
+                var types = type.types;
+                for (var _i = 0, types_11 = types; _i < types_11.length; _i++) {
+                    var t = types_11[_i];
+                    if (!isTypeOfKind(t, kind)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (type.flags & 32768 /* Intersection */) {
+                var types = type.types;
+                for (var _a = 0, types_12 = types; _a < types_12.length; _a++) {
+                    var t = types_12[_a];
+                    if (isTypeOfKind(t, kind)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function isConstEnumObjectType(type) {
+            return type.flags & (80896 /* ObjectType */ | 65536 /* Anonymous */) && type.symbol && isConstEnumSymbol(type.symbol);
+        }
+        function isConstEnumSymbol(symbol) {
+            return (symbol.flags & 128 /* ConstEnum */) !== 0;
+        }
+        function checkInstanceOfExpression(left, right, leftType, rightType) {
+            // TypeScript 1.0 spec (April 2014): 4.15.4
+            // The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type,
+            // and the right operand to be of type Any or a subtype of the 'Function' interface type.
+            // The result is always of the Boolean primitive type.
+            // NOTE: do not raise error if leftType is unknown as related error was already reported
+            if (isTypeOfKind(leftType, 16777726 /* Primitive */)) {
+                error(left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
+            }
+            // NOTE: do not raise error if right is unknown as related error was already reported
+            if (!(isTypeAny(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
+                error(right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
+            }
+            return booleanType;
+        }
+        function checkInExpression(left, right, leftType, rightType) {
+            // TypeScript 1.0 spec (April 2014): 4.15.5
+            // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
+            // and the right operand to be of type Any, an object type, or a type parameter type.
+            // The result is always of the Boolean primitive type.
+            if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258 /* StringLike */ | 132 /* NumberLike */ | 16777216 /* ESSymbol */)) {
+                error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
+            }
+            if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, 80896 /* ObjectType */ | 512 /* TypeParameter */)) {
+                error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
+            }
+            return booleanType;
+        }
+        function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
+            var properties = node.properties;
+            for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+                var p = properties_3[_i];
+                checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, contextualMapper);
+            }
+            return sourceType;
+        }
+        function checkObjectLiteralDestructuringPropertyAssignment(objectLiteralType, property, contextualMapper) {
+            if (property.kind === 253 /* PropertyAssignment */ || property.kind === 254 /* ShorthandPropertyAssignment */) {
+                var name_14 = property.name;
+                if (name_14.kind === 140 /* ComputedPropertyName */) {
+                    checkComputedPropertyName(name_14);
+                }
+                if (isComputedNonLiteralName(name_14)) {
+                    return undefined;
+                }
+                var text = getTextOfPropertyName(name_14);
+                var type = isTypeAny(objectLiteralType)
+                    ? objectLiteralType
+                    : getTypeOfPropertyOfType(objectLiteralType, text) ||
+                        isNumericLiteralName(text) && getIndexTypeOfType(objectLiteralType, 1 /* Number */) ||
+                        getIndexTypeOfType(objectLiteralType, 0 /* String */);
+                if (type) {
+                    if (property.kind === 254 /* ShorthandPropertyAssignment */) {
+                        return checkDestructuringAssignment(property, type);
+                    }
+                    else {
+                        // non-shorthand property assignments should always have initializers
+                        return checkDestructuringAssignment(property.initializer, type);
+                    }
+                }
+                else {
+                    error(name_14, ts.Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(objectLiteralType), ts.declarationNameToString(name_14));
+                }
+            }
+            else {
+                error(property, ts.Diagnostics.Property_assignment_expected);
+            }
+        }
+        function checkArrayLiteralAssignment(node, sourceType, contextualMapper) {
+            // This elementType will be used if the specific property corresponding to this index is not
+            // present (aka the tuple element property). This call also checks that the parentType is in
+            // fact an iterable or array (depending on target language).
+            var elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false) || unknownType;
+            var elements = node.elements;
+            for (var i = 0; i < elements.length; i++) {
+                checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, elementType, contextualMapper);
+            }
+            return sourceType;
+        }
+        function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, contextualMapper) {
+            var elements = node.elements;
+            var element = elements[elementIndex];
+            if (element.kind !== 193 /* OmittedExpression */) {
+                if (element.kind !== 191 /* SpreadElementExpression */) {
+                    var propName = "" + elementIndex;
+                    var type = isTypeAny(sourceType)
+                        ? sourceType
+                        : isTupleLikeType(sourceType)
+                            ? getTypeOfPropertyOfType(sourceType, propName)
+                            : elementType;
+                    if (type) {
+                        return checkDestructuringAssignment(element, type, contextualMapper);
+                    }
+                    else {
+                        if (isTupleType(sourceType)) {
+                            error(element, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), sourceType.elementTypes.length, elements.length);
+                        }
+                        else {
+                            error(element, ts.Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
+                        }
+                    }
+                }
+                else {
+                    if (elementIndex < elements.length - 1) {
+                        error(element, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
+                    }
+                    else {
+                        var restExpression = element.expression;
+                        if (restExpression.kind === 187 /* BinaryExpression */ && restExpression.operatorToken.kind === 56 /* EqualsToken */) {
+                            error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
+                        }
+                        else {
+                            return checkDestructuringAssignment(restExpression, createArrayType(elementType), contextualMapper);
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
+        function checkDestructuringAssignment(exprOrAssignment, sourceType, contextualMapper) {
+            var target;
+            if (exprOrAssignment.kind === 254 /* ShorthandPropertyAssignment */) {
+                var prop = exprOrAssignment;
+                if (prop.objectAssignmentInitializer) {
+                    // In strict null checking mode, if a default value of a non-undefined type is specified, remove
+                    // undefined from the final type.
+                    if (strictNullChecks &&
+                        !(getCombinedTypeFlags(checkExpression(prop.objectAssignmentInitializer)) & 32 /* Undefined */)) {
+                        sourceType = getTypeWithFacts(sourceType, 131072 /* NEUndefined */);
+                    }
+                    checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, contextualMapper);
+                }
+                target = exprOrAssignment.name;
+            }
+            else {
+                target = exprOrAssignment;
+            }
+            if (target.kind === 187 /* BinaryExpression */ && target.operatorToken.kind === 56 /* EqualsToken */) {
+                checkBinaryExpression(target, contextualMapper);
+                target = target.left;
+            }
+            if (target.kind === 171 /* ObjectLiteralExpression */) {
+                return checkObjectLiteralAssignment(target, sourceType, contextualMapper);
+            }
+            if (target.kind === 170 /* ArrayLiteralExpression */) {
+                return checkArrayLiteralAssignment(target, sourceType, contextualMapper);
+            }
+            return checkReferenceAssignment(target, sourceType, contextualMapper);
+        }
+        function checkReferenceAssignment(target, sourceType, contextualMapper) {
+            var targetType = checkExpression(target, contextualMapper);
+            if (checkReferenceExpression(target, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant_or_a_read_only_property)) {
+                checkTypeAssignableTo(sourceType, targetType, target, /*headMessage*/ undefined);
+            }
+            return sourceType;
+        }
+        function isTypeEqualityComparableTo(source, target) {
+            return (target.flags & 96 /* Nullable */) !== 0 || isTypeComparableTo(source, target);
+        }
+        function checkBinaryExpression(node, contextualMapper) {
+            return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, contextualMapper, node);
+        }
+        function checkBinaryLikeExpression(left, operatorToken, right, contextualMapper, errorNode) {
+            var operator = operatorToken.kind;
+            if (operator === 56 /* EqualsToken */ && (left.kind === 171 /* ObjectLiteralExpression */ || left.kind === 170 /* ArrayLiteralExpression */)) {
+                return checkDestructuringAssignment(left, checkExpression(right, contextualMapper), contextualMapper);
+            }
+            var leftType = checkExpression(left, contextualMapper);
+            var rightType = checkExpression(right, contextualMapper);
+            switch (operator) {
+                case 37 /* AsteriskToken */:
+                case 38 /* AsteriskAsteriskToken */:
+                case 59 /* AsteriskEqualsToken */:
+                case 60 /* AsteriskAsteriskEqualsToken */:
+                case 39 /* SlashToken */:
+                case 61 /* SlashEqualsToken */:
+                case 40 /* PercentToken */:
+                case 62 /* PercentEqualsToken */:
+                case 36 /* MinusToken */:
+                case 58 /* MinusEqualsToken */:
+                case 43 /* LessThanLessThanToken */:
+                case 63 /* LessThanLessThanEqualsToken */:
+                case 44 /* GreaterThanGreaterThanToken */:
+                case 64 /* GreaterThanGreaterThanEqualsToken */:
+                case 45 /* GreaterThanGreaterThanGreaterThanToken */:
+                case 65 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
+                case 47 /* BarToken */:
+                case 67 /* BarEqualsToken */:
+                case 48 /* CaretToken */:
+                case 68 /* CaretEqualsToken */:
+                case 46 /* AmpersandToken */:
+                case 66 /* AmpersandEqualsToken */:
+                    // TypeScript 1.0 spec (April 2014): 4.19.1
+                    // These operators require their operands to be of type Any, the Number primitive type,
+                    // or an enum type. Operands of an enum type are treated
+                    // as having the primitive type Number. If one operand is the null or undefined value,
+                    // it is treated as having the type of the other operand.
+                    // The result is always of the Number primitive type.
+                    if (leftType.flags & 96 /* Nullable */)
+                        leftType = rightType;
+                    if (rightType.flags & 96 /* Nullable */)
+                        rightType = leftType;
+                    leftType = getNonNullableType(leftType);
+                    rightType = getNonNullableType(rightType);
+                    var suggestedOperator = void 0;
+                    // if a user tries to apply a bitwise operator to 2 boolean operands
+                    // try and return them a helpful suggestion
+                    if ((leftType.flags & 8 /* Boolean */) &&
+                        (rightType.flags & 8 /* Boolean */) &&
+                        (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) {
+                        error(errorNode || operatorToken, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(operatorToken.kind), ts.tokenToString(suggestedOperator));
+                    }
+                    else {
+                        // otherwise just check each operand separately and report errors as normal
+                        var leftOk = checkArithmeticOperandType(left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        var rightOk = checkArithmeticOperandType(right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        if (leftOk && rightOk) {
+                            checkAssignmentOperator(numberType);
+                        }
+                    }
+                    return numberType;
+                case 35 /* PlusToken */:
+                case 57 /* PlusEqualsToken */:
+                    // TypeScript 1.0 spec (April 2014): 4.19.2
+                    // The binary + operator requires both operands to be of the Number primitive type or an enum type,
+                    // or at least one of the operands to be of type Any or the String primitive type.
+                    // If one operand is the null or undefined value, it is treated as having the type of the other operand.
+                    if (leftType.flags & 96 /* Nullable */)
+                        leftType = rightType;
+                    if (rightType.flags & 96 /* Nullable */)
+                        rightType = leftType;
+                    leftType = getNonNullableType(leftType);
+                    rightType = getNonNullableType(rightType);
+                    var resultType = void 0;
+                    if (isTypeOfKind(leftType, 132 /* NumberLike */) && isTypeOfKind(rightType, 132 /* NumberLike */)) {
+                        // Operands of an enum type are treated as having the primitive type Number.
+                        // If both operands are of the Number primitive type, the result is of the Number primitive type.
+                        resultType = numberType;
+                    }
+                    else {
+                        if (isTypeOfKind(leftType, 258 /* StringLike */) || isTypeOfKind(rightType, 258 /* StringLike */)) {
+                            // If one or both operands are of the String primitive type, the result is of the String primitive type.
+                            resultType = stringType;
+                        }
+                        else if (isTypeAny(leftType) || isTypeAny(rightType)) {
+                            // Otherwise, the result is of type Any.
+                            // NOTE: unknown type here denotes error type. Old compiler treated this case as any type so do we.
+                            resultType = leftType === unknownType || rightType === unknownType ? unknownType : anyType;
+                        }
+                        // Symbols are not allowed at all in arithmetic expressions
+                        if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
+                            return resultType;
+                        }
+                    }
+                    if (!resultType) {
+                        reportOperatorError();
+                        return anyType;
+                    }
+                    if (operator === 57 /* PlusEqualsToken */) {
+                        checkAssignmentOperator(resultType);
+                    }
+                    return resultType;
+                case 25 /* LessThanToken */:
+                case 27 /* GreaterThanToken */:
+                case 28 /* LessThanEqualsToken */:
+                case 29 /* GreaterThanEqualsToken */:
+                    if (checkForDisallowedESSymbolOperand(operator)) {
+                        if (!isTypeComparableTo(leftType, rightType) && !isTypeComparableTo(rightType, leftType)) {
+                            reportOperatorError();
+                        }
+                    }
+                    return booleanType;
+                case 30 /* EqualsEqualsToken */:
+                case 31 /* ExclamationEqualsToken */:
+                case 32 /* EqualsEqualsEqualsToken */:
+                case 33 /* ExclamationEqualsEqualsToken */:
+                    if (!isTypeEqualityComparableTo(leftType, rightType) && !isTypeEqualityComparableTo(rightType, leftType)) {
+                        reportOperatorError();
+                    }
+                    return booleanType;
+                case 91 /* InstanceOfKeyword */:
+                    return checkInstanceOfExpression(left, right, leftType, rightType);
+                case 90 /* InKeyword */:
+                    return checkInExpression(left, right, leftType, rightType);
+                case 51 /* AmpersandAmpersandToken */:
+                    return strictNullChecks ? addTypeKind(rightType, getCombinedTypeFlags(leftType) & 112 /* Falsy */) : rightType;
+                case 52 /* BarBarToken */:
+                    return getUnionType([getNonNullableType(leftType), rightType]);
+                case 56 /* EqualsToken */:
+                    checkAssignmentOperator(rightType);
+                    return getRegularTypeOfObjectLiteral(rightType);
+                case 24 /* CommaToken */:
+                    return rightType;
+            }
+            // Return true if there was no error, false if there was an error.
+            function checkForDisallowedESSymbolOperand(operator) {
+                var offendingSymbolOperand = maybeTypeOfKind(leftType, 16777216 /* ESSymbol */) ? left :
+                    maybeTypeOfKind(rightType, 16777216 /* ESSymbol */) ? right :
+                        undefined;
+                if (offendingSymbolOperand) {
+                    error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator));
+                    return false;
+                }
+                return true;
+            }
+            function getSuggestedBooleanOperator(operator) {
+                switch (operator) {
+                    case 47 /* BarToken */:
+                    case 67 /* BarEqualsToken */:
+                        return 52 /* BarBarToken */;
+                    case 48 /* CaretToken */:
+                    case 68 /* CaretEqualsToken */:
+                        return 33 /* ExclamationEqualsEqualsToken */;
+                    case 46 /* AmpersandToken */:
+                    case 66 /* AmpersandEqualsToken */:
+                        return 51 /* AmpersandAmpersandToken */;
+                    default:
+                        return undefined;
+                }
+            }
+            function checkAssignmentOperator(valueType) {
+                if (produceDiagnostics && operator >= 56 /* FirstAssignment */ && operator <= 68 /* LastAssignment */) {
+                    // TypeScript 1.0 spec (April 2014): 4.17
+                    // An assignment of the form
+                    //    VarExpr = ValueExpr
+                    // requires VarExpr to be classified as a reference
+                    // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1)
+                    // and the type of the non - compound operation to be assignable to the type of VarExpr.
+                    var ok = checkReferenceExpression(left, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant_or_a_read_only_property);
+                    // Use default messages
+                    if (ok) {
+                        // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
+                        checkTypeAssignableTo(valueType, leftType, left, /*headMessage*/ undefined);
+                    }
+                }
+            }
+            function reportOperatorError() {
+                error(errorNode || operatorToken, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), typeToString(leftType), typeToString(rightType));
+            }
+        }
+        function isYieldExpressionInClass(node) {
+            var current = node;
+            var parent = node.parent;
+            while (parent) {
+                if (ts.isFunctionLike(parent) && current === parent.body) {
+                    return false;
+                }
+                else if (ts.isClassLike(current)) {
+                    return true;
+                }
+                current = parent;
+                parent = parent.parent;
+            }
+            return false;
+        }
+        function checkYieldExpression(node) {
+            // Grammar checking
+            if (produceDiagnostics) {
+                if (!(node.flags & 8388608 /* YieldContext */) || isYieldExpressionInClass(node)) {
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
+                }
+                if (isInParameterInitializerBeforeContainingFunction(node)) {
+                    error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
+                }
+            }
+            if (node.expression) {
+                var func = ts.getContainingFunction(node);
+                // If the user's code is syntactically correct, the func should always have a star. After all,
+                // we are in a yield context.
+                if (func && func.asteriskToken) {
+                    var expressionType = checkExpressionCached(node.expression, /*contextualMapper*/ undefined);
+                    var expressionElementType = void 0;
+                    var nodeIsYieldStar = !!node.asteriskToken;
+                    if (nodeIsYieldStar) {
+                        expressionElementType = checkElementTypeOfIterable(expressionType, node.expression);
+                    }
+                    // There is no point in doing an assignability check if the function
+                    // has no explicit return type because the return type is directly computed
+                    // from the yield expressions.
+                    if (func.type) {
+                        var signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType;
+                        if (nodeIsYieldStar) {
+                            checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined);
+                        }
+                        else {
+                            checkTypeAssignableTo(expressionType, signatureElementType, node.expression, /*headMessage*/ undefined);
+                        }
+                    }
+                }
+            }
+            // Both yield and yield* expressions have type 'any'
+            return anyType;
+        }
+        function checkConditionalExpression(node, contextualMapper) {
+            checkExpression(node.condition);
+            var type1 = checkExpression(node.whenTrue, contextualMapper);
+            var type2 = checkExpression(node.whenFalse, contextualMapper);
+            return getUnionType([type1, type2]);
+        }
+        function checkStringLiteralExpression(node) {
+            var contextualType = getContextualType(node);
+            if (contextualType && isStringLiteralUnionType(contextualType)) {
+                return getStringLiteralTypeForText(node.text);
+            }
+            return stringType;
+        }
+        function checkTemplateExpression(node) {
+            // We just want to check each expressions, but we are unconcerned with
+            // the type of each expression, as any value may be coerced into a string.
+            // It is worth asking whether this is what we really want though.
+            // A place where we actually *are* concerned with the expressions' types are
+            // in tagged templates.
+            ts.forEach(node.templateSpans, function (templateSpan) {
+                checkExpression(templateSpan.expression);
+            });
+            return stringType;
+        }
+        function checkExpressionWithContextualType(node, contextualType, contextualMapper) {
+            var saveContextualType = node.contextualType;
+            node.contextualType = contextualType;
+            var result = checkExpression(node, contextualMapper);
+            node.contextualType = saveContextualType;
+            return result;
+        }
+        function checkExpressionCached(node, contextualMapper) {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                // When computing a type that we're going to cache, we need to ignore any ongoing control flow
+                // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart
+                // to the top of the stack ensures all transient types are computed from a known point.
+                var saveFlowLoopStart = flowLoopStart;
+                flowLoopStart = flowLoopCount;
+                links.resolvedType = checkExpression(node, contextualMapper);
+                flowLoopStart = saveFlowLoopStart;
+            }
+            return links.resolvedType;
+        }
+        function checkPropertyAssignment(node, contextualMapper) {
+            // Do not use hasDynamicName here, because that returns false for well known symbols.
+            // We want to perform checkComputedPropertyName for all computed properties, including
+            // well known symbols.
+            if (node.name.kind === 140 /* ComputedPropertyName */) {
+                checkComputedPropertyName(node.name);
+            }
+            return checkExpression(node.initializer, contextualMapper);
+        }
+        function checkObjectLiteralMethod(node, contextualMapper) {
+            // Grammar checking
+            checkGrammarMethod(node);
+            // Do not use hasDynamicName here, because that returns false for well known symbols.
+            // We want to perform checkComputedPropertyName for all computed properties, including
+            // well known symbols.
+            if (node.name.kind === 140 /* ComputedPropertyName */) {
+                checkComputedPropertyName(node.name);
+            }
+            var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
+            return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper);
+        }
+        function instantiateTypeWithSingleGenericCallSignature(node, type, contextualMapper) {
+            if (isInferentialContext(contextualMapper)) {
+                var signature = getSingleCallSignature(type);
+                if (signature && signature.typeParameters) {
+                    var contextualType = getApparentTypeOfContextualType(node);
+                    if (contextualType) {
+                        var contextualSignature = getSingleCallSignature(contextualType);
+                        if (contextualSignature && !contextualSignature.typeParameters) {
+                            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper));
+                        }
+                    }
+                }
+            }
+            return type;
+        }
+        // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When
+        // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the
+        // expression is being inferentially typed (section 4.15.2 in spec) and provides the type mapper to use in
+        // conjunction with the generic contextual type. When contextualMapper is equal to the identityMapper function
+        // object, it serves as an indicator that all contained function and arrow expressions should be considered to
+        // have the wildcard function type; this form of type check is used during overload resolution to exclude
+        // contextually typed function and arrow expressions in the initial phase.
+        function checkExpression(node, contextualMapper) {
+            var type;
+            if (node.kind === 139 /* QualifiedName */) {
+                type = checkQualifiedName(node);
+            }
+            else {
+                var uninstantiatedType = checkExpressionWorker(node, contextualMapper);
+                type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper);
+            }
+            if (isConstEnumObjectType(type)) {
+                // enum object type for const enums are only permitted in:
+                // - 'left' in property access
+                // - 'object' in indexed access
+                // - target in rhs of import statement
+                var ok = (node.parent.kind === 172 /* PropertyAccessExpression */ && node.parent.expression === node) ||
+                    (node.parent.kind === 173 /* ElementAccessExpression */ && node.parent.expression === node) ||
+                    ((node.kind === 69 /* Identifier */ || node.kind === 139 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node));
+                if (!ok) {
+                    error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment);
+                }
+            }
+            return type;
+        }
+        function checkNumericLiteral(node) {
+            // Grammar checking
+            checkGrammarNumericLiteral(node);
+            return numberType;
+        }
+        function checkExpressionWorker(node, contextualMapper) {
+            switch (node.kind) {
+                case 69 /* Identifier */:
+                    return checkIdentifier(node);
+                case 97 /* ThisKeyword */:
+                    return checkThisExpression(node);
+                case 95 /* SuperKeyword */:
+                    return checkSuperExpression(node);
+                case 93 /* NullKeyword */:
+                    return nullWideningType;
+                case 99 /* TrueKeyword */:
+                case 84 /* FalseKeyword */:
+                    return booleanType;
+                case 8 /* NumericLiteral */:
+                    return checkNumericLiteral(node);
+                case 189 /* TemplateExpression */:
+                    return checkTemplateExpression(node);
+                case 9 /* StringLiteral */:
+                    return checkStringLiteralExpression(node);
+                case 11 /* NoSubstitutionTemplateLiteral */:
+                    return stringType;
+                case 10 /* RegularExpressionLiteral */:
+                    return globalRegExpType;
+                case 170 /* ArrayLiteralExpression */:
+                    return checkArrayLiteral(node, contextualMapper);
+                case 171 /* ObjectLiteralExpression */:
+                    return checkObjectLiteral(node, contextualMapper);
+                case 172 /* PropertyAccessExpression */:
+                    return checkPropertyAccessExpression(node);
+                case 173 /* ElementAccessExpression */:
+                    return checkIndexedAccess(node);
+                case 174 /* CallExpression */:
+                case 175 /* NewExpression */:
+                    return checkCallExpression(node);
+                case 176 /* TaggedTemplateExpression */:
+                    return checkTaggedTemplateExpression(node);
+                case 178 /* ParenthesizedExpression */:
+                    return checkExpression(node.expression, contextualMapper);
+                case 192 /* ClassExpression */:
+                    return checkClassExpression(node);
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
+                case 182 /* TypeOfExpression */:
+                    return checkTypeOfExpression(node);
+                case 177 /* TypeAssertionExpression */:
+                case 195 /* AsExpression */:
+                    return checkAssertion(node);
+                case 196 /* NonNullExpression */:
+                    return checkNonNullAssertion(node);
+                case 181 /* DeleteExpression */:
+                    return checkDeleteExpression(node);
+                case 183 /* VoidExpression */:
+                    return checkVoidExpression(node);
+                case 184 /* AwaitExpression */:
+                    return checkAwaitExpression(node);
+                case 185 /* PrefixUnaryExpression */:
+                    return checkPrefixUnaryExpression(node);
+                case 186 /* PostfixUnaryExpression */:
+                    return checkPostfixUnaryExpression(node);
+                case 187 /* BinaryExpression */:
+                    return checkBinaryExpression(node, contextualMapper);
+                case 188 /* ConditionalExpression */:
+                    return checkConditionalExpression(node, contextualMapper);
+                case 191 /* SpreadElementExpression */:
+                    return checkSpreadElementExpression(node, contextualMapper);
+                case 193 /* OmittedExpression */:
+                    return undefinedWideningType;
+                case 190 /* YieldExpression */:
+                    return checkYieldExpression(node);
+                case 248 /* JsxExpression */:
+                    return checkJsxExpression(node);
+                case 241 /* JsxElement */:
+                    return checkJsxElement(node);
+                case 242 /* JsxSelfClosingElement */:
+                    return checkJsxSelfClosingElement(node);
+                case 243 /* JsxOpeningElement */:
+                    ts.Debug.fail("Shouldn't ever directly check a JsxOpeningElement");
+            }
+            return unknownType;
+        }
+        // DECLARATION AND STATEMENT TYPE CHECKING
+        function checkTypeParameter(node) {
+            // Grammar Checking
+            if (node.expression) {
+                grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected);
+            }
+            checkSourceElement(node.constraint);
+            getConstraintOfTypeParameter(getDeclaredTypeOfTypeParameter(getSymbolOfNode(node)));
+            if (produceDiagnostics) {
+                checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0);
+            }
+        }
+        function checkParameter(node) {
+            // Grammar checking
+            // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the
+            // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code
+            // or if its FunctionBody is strict code(11.1.5).
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node);
+            checkVariableLikeDeclaration(node);
+            var func = ts.getContainingFunction(node);
+            if (node.flags & 92 /* ParameterPropertyModifier */) {
+                func = ts.getContainingFunction(node);
+                if (!(func.kind === 148 /* Constructor */ && ts.nodeIsPresent(func.body))) {
+                    error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
+                }
+            }
+            if (node.questionToken && ts.isBindingPattern(node.name) && func.body) {
+                error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
+            }
+            if (node.name.text === "this") {
+                if (ts.indexOf(func.parameters, node) !== 0) {
+                    error(node, ts.Diagnostics.A_this_parameter_must_be_the_first_parameter);
+                }
+                if (func.kind === 148 /* Constructor */ || func.kind === 152 /* ConstructSignature */ || func.kind === 157 /* ConstructorType */) {
+                    error(node, ts.Diagnostics.A_constructor_cannot_have_a_this_parameter);
+                }
+            }
+            // Only check rest parameter type if it's not a binding pattern. Since binding patterns are
+            // not allowed in a rest parameter, we already have an error from checkGrammarParameterList.
+            if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isArrayType(getTypeOfSymbol(node.symbol))) {
+                error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type);
+            }
+        }
+        function isSyntacticallyValidGenerator(node) {
+            if (!node.asteriskToken || !node.body) {
+                return false;
+            }
+            return node.kind === 147 /* MethodDeclaration */ ||
+                node.kind === 220 /* FunctionDeclaration */ ||
+                node.kind === 179 /* FunctionExpression */;
+        }
+        function getTypePredicateParameterIndex(parameterList, parameter) {
+            if (parameterList) {
+                for (var i = 0; i < parameterList.length; i++) {
+                    var param = parameterList[i];
+                    if (param.name.kind === 69 /* Identifier */ &&
+                        param.name.text === parameter.text) {
+                        return i;
+                    }
+                }
+            }
+            return -1;
+        }
+        function checkTypePredicate(node) {
+            var parent = getTypePredicateParent(node);
+            if (!parent) {
+                // The parent must not be valid.
+                error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
+                return;
+            }
+            var typePredicate = getSignatureFromDeclaration(parent).typePredicate;
+            if (!typePredicate) {
+                return;
+            }
+            var parameterName = node.parameterName;
+            if (ts.isThisTypePredicate(typePredicate)) {
+                getTypeFromThisTypeNode(parameterName);
+            }
+            else {
+                if (typePredicate.parameterIndex >= 0) {
+                    if (parent.parameters[typePredicate.parameterIndex].dotDotDotToken) {
+                        error(parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
+                    }
+                    else {
+                        var leadingError = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type);
+                        checkTypeAssignableTo(typePredicate.type, getTypeOfNode(parent.parameters[typePredicate.parameterIndex]), node.type, 
+                        /*headMessage*/ undefined, leadingError);
+                    }
+                }
+                else if (parameterName) {
+                    var hasReportedError = false;
+                    for (var _i = 0, _a = parent.parameters; _i < _a.length; _i++) {
+                        var name_15 = _a[_i].name;
+                        if (ts.isBindingPattern(name_15) &&
+                            checkIfTypePredicateVariableIsDeclaredInBindingPattern(name_15, parameterName, typePredicate.parameterName)) {
+                            hasReportedError = true;
+                            break;
+                        }
+                    }
+                    if (!hasReportedError) {
+                        error(node.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
+                    }
+                }
+            }
+        }
+        function getTypePredicateParent(node) {
+            switch (node.parent.kind) {
+                case 180 /* ArrowFunction */:
+                case 151 /* CallSignature */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 156 /* FunctionType */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                    var parent_10 = node.parent;
+                    if (node === parent_10.type) {
+                        return parent_10;
+                    }
+            }
+        }
+        function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) {
+            for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
+                var name_16 = _a[_i].name;
+                if (name_16.kind === 69 /* Identifier */ &&
+                    name_16.text === predicateVariableName) {
+                    error(predicateVariableNode, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, predicateVariableName);
+                    return true;
+                }
+                else if (name_16.kind === 168 /* ArrayBindingPattern */ ||
+                    name_16.kind === 167 /* ObjectBindingPattern */) {
+                    if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(name_16, predicateVariableNode, predicateVariableName)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        function checkSignatureDeclaration(node) {
+            // Grammar checking
+            if (node.kind === 153 /* IndexSignature */) {
+                checkGrammarIndexSignature(node);
+            }
+            else if (node.kind === 156 /* FunctionType */ || node.kind === 220 /* FunctionDeclaration */ || node.kind === 157 /* ConstructorType */ ||
+                node.kind === 151 /* CallSignature */ || node.kind === 148 /* Constructor */ ||
+                node.kind === 152 /* ConstructSignature */) {
+                checkGrammarFunctionLikeDeclaration(node);
+            }
+            checkTypeParameters(node.typeParameters);
+            ts.forEach(node.parameters, checkParameter);
+            if (node.type) {
+                checkSourceElement(node.type);
+            }
+            if (produceDiagnostics) {
+                checkCollisionWithArgumentsInGeneratedCode(node);
+                if (compilerOptions.noImplicitAny && !node.type) {
+                    switch (node.kind) {
+                        case 152 /* ConstructSignature */:
+                            error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
+                            break;
+                        case 151 /* CallSignature */:
+                            error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
+                            break;
+                    }
+                }
+                if (node.type) {
+                    if (languageVersion >= 2 /* ES6 */ && isSyntacticallyValidGenerator(node)) {
+                        var returnType = getTypeFromTypeNode(node.type);
+                        if (returnType === voidType) {
+                            error(node.type, ts.Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+                        }
+                        else {
+                            var generatorElementType = getElementTypeOfIterableIterator(returnType) || anyType;
+                            var iterableIteratorInstantiation = createIterableIteratorType(generatorElementType);
+                            // Naively, one could check that IterableIterator<any> is assignable to the return type annotation.
+                            // However, that would not catch the error in the following case.
+                            //
+                            //    interface BadGenerator extends Iterable<number>, Iterator<string> { }
+                            //    function* g(): BadGenerator { } // Iterable and Iterator have different types!
+                            //
+                            checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type);
+                        }
+                    }
+                    else if (ts.isAsyncFunctionLike(node)) {
+                        checkAsyncFunctionReturnType(node);
+                    }
+                }
+                if (!node.body) {
+                    checkUnusedTypeParameters(node);
+                }
+            }
+        }
+        function checkClassForDuplicateDeclarations(node) {
+            var getter = 1, setter = 2, property = getter | setter;
+            var instanceNames = {};
+            var staticNames = {};
+            for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+                var member = _a[_i];
+                if (member.kind === 148 /* Constructor */) {
+                    for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
+                        var param = _c[_b];
+                        if (ts.isParameterPropertyDeclaration(param)) {
+                            addName(instanceNames, param.name, param.name.text, property);
+                        }
+                    }
+                }
+                else {
+                    var isStatic = ts.forEach(member.modifiers, function (m) { return m.kind === 113 /* StaticKeyword */; });
+                    var names = isStatic ? staticNames : instanceNames;
+                    var memberName = member.name && ts.getPropertyNameForPropertyNameNode(member.name);
+                    if (memberName) {
+                        switch (member.kind) {
+                            case 149 /* GetAccessor */:
+                                addName(names, member.name, memberName, getter);
+                                break;
+                            case 150 /* SetAccessor */:
+                                addName(names, member.name, memberName, setter);
+                                break;
+                            case 145 /* PropertyDeclaration */:
+                                addName(names, member.name, memberName, property);
+                                break;
+                        }
+                    }
+                }
+            }
+            function addName(names, location, name, meaning) {
+                if (ts.hasProperty(names, name)) {
+                    var prev = names[name];
+                    if (prev & meaning) {
+                        error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location));
+                    }
+                    else {
+                        names[name] = prev | meaning;
+                    }
+                }
+                else {
+                    names[name] = meaning;
+                }
+            }
+        }
+        function checkObjectTypeForDuplicateDeclarations(node) {
+            var names = {};
+            for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+                var member = _a[_i];
+                if (member.kind == 144 /* PropertySignature */) {
+                    var memberName = void 0;
+                    switch (member.name.kind) {
+                        case 9 /* StringLiteral */:
+                        case 8 /* NumericLiteral */:
+                        case 69 /* Identifier */:
+                            memberName = member.name.text;
+                            break;
+                        default:
+                            continue;
+                    }
+                    if (ts.hasProperty(names, memberName)) {
+                        error(member.symbol.valueDeclaration.name, ts.Diagnostics.Duplicate_identifier_0, memberName);
+                        error(member.name, ts.Diagnostics.Duplicate_identifier_0, memberName);
+                    }
+                    else {
+                        names[memberName] = true;
+                    }
+                }
+            }
+        }
+        function checkTypeForDuplicateIndexSignatures(node) {
+            if (node.kind === 222 /* InterfaceDeclaration */) {
+                var nodeSymbol = getSymbolOfNode(node);
+                // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration
+                // to prevent this run check only for the first declaration of a given kind
+                if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
+                    return;
+                }
+            }
+            // TypeScript 1.0 spec (April 2014)
+            // 3.7.4: An object type can contain at most one string index signature and one numeric index signature.
+            // 8.5: A class declaration can have at most one string index member declaration and one numeric index member declaration
+            var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
+            if (indexSymbol) {
+                var seenNumericIndexer = false;
+                var seenStringIndexer = false;
+                for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
+                    var decl = _a[_i];
+                    var declaration = decl;
+                    if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
+                        switch (declaration.parameters[0].type.kind) {
+                            case 132 /* StringKeyword */:
+                                if (!seenStringIndexer) {
+                                    seenStringIndexer = true;
+                                }
+                                else {
+                                    error(declaration, ts.Diagnostics.Duplicate_string_index_signature);
+                                }
+                                break;
+                            case 130 /* NumberKeyword */:
+                                if (!seenNumericIndexer) {
+                                    seenNumericIndexer = true;
+                                }
+                                else {
+                                    error(declaration, ts.Diagnostics.Duplicate_number_index_signature);
+                                }
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        function checkPropertyDeclaration(node) {
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarProperty(node) || checkGrammarComputedPropertyName(node.name);
+            checkVariableLikeDeclaration(node);
+        }
+        function checkMethodDeclaration(node) {
+            // Grammar checking
+            checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name);
+            // Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration
+            checkFunctionOrMethodDeclaration(node);
+            // Abstract methods cannot have an implementation.
+            // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node.
+            if (node.flags & 128 /* Abstract */ && node.body) {
+                error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
+            }
+        }
+        function checkConstructorDeclaration(node) {
+            // Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function.
+            checkSignatureDeclaration(node);
+            // Grammar check for checking only related to constructorDeclaration
+            checkGrammarConstructorTypeParameters(node) || checkGrammarConstructorTypeAnnotation(node);
+            checkSourceElement(node.body);
+            registerForUnusedIdentifiersCheck(node);
+            var symbol = getSymbolOfNode(node);
+            var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind);
+            // Only type check the symbol once
+            if (node === firstDeclaration) {
+                checkFunctionOrConstructorSymbol(symbol);
+            }
+            // exit early in the case of signature - super checks are not relevant to them
+            if (ts.nodeIsMissing(node.body)) {
+                return;
+            }
+            if (!produceDiagnostics) {
+                return;
+            }
+            function containsSuperCallAsComputedPropertyName(n) {
+                return n.name && containsSuperCall(n.name);
+            }
+            function containsSuperCall(n) {
+                if (ts.isSuperCallExpression(n)) {
+                    return true;
+                }
+                else if (ts.isFunctionLike(n)) {
+                    return false;
+                }
+                else if (ts.isClassLike(n)) {
+                    return ts.forEach(n.members, containsSuperCallAsComputedPropertyName);
+                }
+                return ts.forEachChild(n, containsSuperCall);
+            }
+            function markThisReferencesAsErrors(n) {
+                if (n.kind === 97 /* ThisKeyword */) {
+                    error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location);
+                }
+                else if (n.kind !== 179 /* FunctionExpression */ && n.kind !== 220 /* FunctionDeclaration */) {
+                    ts.forEachChild(n, markThisReferencesAsErrors);
+                }
+            }
+            function isInstancePropertyWithInitializer(n) {
+                return n.kind === 145 /* PropertyDeclaration */ &&
+                    !(n.flags & 32 /* Static */) &&
+                    !!n.initializer;
+            }
+            // TS 1.0 spec (April 2014): 8.3.2
+            // Constructors of classes with no extends clause may not contain super calls, whereas
+            // constructors of derived classes must contain at least one super call somewhere in their function body.
+            var containingClassDecl = node.parent;
+            if (ts.getClassExtendsHeritageClauseElement(containingClassDecl)) {
+                var classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
+                var superCall = getSuperCallInConstructor(node);
+                if (superCall) {
+                    if (classExtendsNull) {
+                        error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
+                    }
+                    // The first statement in the body of a constructor (excluding prologue directives) must be a super call
+                    // if both of the following are true:
+                    // - The containing class is a derived class.
+                    // - The constructor declares parameter properties
+                    //   or the containing class declares instance member variables with initializers.
+                    var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) ||
+                        ts.forEach(node.parameters, function (p) { return p.flags & 92 /* ParameterPropertyModifier */; });
+                    // Skip past any prologue directives to find the first statement
+                    // to ensure that it was a super call.
+                    if (superCallShouldBeFirst) {
+                        var statements = node.body.statements;
+                        var superCallStatement = void 0;
+                        for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+                            var statement = statements_2[_i];
+                            if (statement.kind === 202 /* ExpressionStatement */ && ts.isSuperCallExpression(statement.expression)) {
+                                superCallStatement = statement;
+                                break;
+                            }
+                            if (!ts.isPrologueDirective(statement)) {
+                                break;
+                            }
+                        }
+                        if (!superCallStatement) {
+                            error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties);
+                        }
+                    }
+                }
+                else if (!classExtendsNull) {
+                    error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
+                }
+            }
+        }
+        function checkAccessorDeclaration(node) {
+            if (produceDiagnostics) {
+                // Grammar checking accessors
+                checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
+                checkDecorators(node);
+                checkSignatureDeclaration(node);
+                if (node.kind === 149 /* GetAccessor */) {
+                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && (node.flags & 32768 /* HasImplicitReturn */)) {
+                        if (node.flags & 65536 /* HasExplicitReturn */) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
+                        }
+                    }
+                }
+                // Do not use hasDynamicName here, because that returns false for well known symbols.
+                // We want to perform checkComputedPropertyName for all computed properties, including
+                // well known symbols.
+                if (node.name.kind === 140 /* ComputedPropertyName */) {
+                    checkComputedPropertyName(node.name);
+                }
+                if (!ts.hasDynamicName(node)) {
+                    // TypeScript 1.0 spec (April 2014): 8.4.3
+                    // Accessors for the same member name must specify the same accessibility.
+                    var otherKind = node.kind === 149 /* GetAccessor */ ? 150 /* SetAccessor */ : 149 /* GetAccessor */;
+                    var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind);
+                    if (otherAccessor) {
+                        if (((node.flags & 28 /* AccessibilityModifier */) !== (otherAccessor.flags & 28 /* AccessibilityModifier */))) {
+                            error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
+                        }
+                        if (((node.flags & 128 /* Abstract */) !== (otherAccessor.flags & 128 /* Abstract */))) {
+                            error(node.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
+                        }
+                        // TypeScript 1.0 spec (April 2014): 4.5
+                        // If both accessors include type annotations, the specified types must be identical.
+                        checkAccessorDeclarationTypesIdentical(node, otherAccessor, getAnnotatedAccessorType, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type);
+                        checkAccessorDeclarationTypesIdentical(node, otherAccessor, getThisTypeOfDeclaration, ts.Diagnostics.get_and_set_accessor_must_have_the_same_this_type);
+                    }
+                }
+                getTypeOfAccessors(getSymbolOfNode(node));
+            }
+            if (node.parent.kind !== 171 /* ObjectLiteralExpression */) {
+                checkSourceElement(node.body);
+                registerForUnusedIdentifiersCheck(node);
+            }
+            else {
+                checkNodeDeferred(node);
+            }
+        }
+        function checkAccessorDeclarationTypesIdentical(first, second, getAnnotatedType, message) {
+            var firstType = getAnnotatedType(first);
+            var secondType = getAnnotatedType(second);
+            if (firstType && secondType && !isTypeIdenticalTo(firstType, secondType)) {
+                error(first, message);
+            }
+        }
+        function checkAccessorDeferred(node) {
+            checkSourceElement(node.body);
+            registerForUnusedIdentifiersCheck(node);
+        }
+        function checkMissingDeclaration(node) {
+            checkDecorators(node);
+        }
+        function checkTypeArgumentConstraints(typeParameters, typeArgumentNodes) {
+            var typeArguments;
+            var mapper;
+            var result = true;
+            for (var i = 0; i < typeParameters.length; i++) {
+                var constraint = getConstraintOfTypeParameter(typeParameters[i]);
+                if (constraint) {
+                    if (!typeArguments) {
+                        typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode);
+                        mapper = createTypeMapper(typeParameters, typeArguments);
+                    }
+                    var typeArgument = typeArguments[i];
+                    result = result && checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), typeArgumentNodes[i], ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
+                }
+            }
+            return result;
+        }
+        function checkTypeReferenceNode(node) {
+            checkGrammarTypeArguments(node, node.typeArguments);
+            var type = getTypeFromTypeReference(node);
+            if (type !== unknownType) {
+                if (node.typeArguments) {
+                    // Do type argument local checks only if referenced type is successfully resolved
+                    ts.forEach(node.typeArguments, checkSourceElement);
+                    if (produceDiagnostics) {
+                        var symbol = getNodeLinks(node).resolvedSymbol;
+                        var typeParameters = symbol.flags & 524288 /* TypeAlias */ ? getSymbolLinks(symbol).typeParameters : type.target.localTypeParameters;
+                        checkTypeArgumentConstraints(typeParameters, node.typeArguments);
+                    }
+                }
+            }
+        }
+        function checkTypeQuery(node) {
+            getTypeFromTypeQueryNode(node);
+        }
+        function checkTypeLiteral(node) {
+            ts.forEach(node.members, checkSourceElement);
+            if (produceDiagnostics) {
+                var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
+                checkIndexConstraints(type);
+                checkTypeForDuplicateIndexSignatures(node);
+                checkObjectTypeForDuplicateDeclarations(node);
+            }
+        }
+        function checkArrayType(node) {
+            checkSourceElement(node.elementType);
+        }
+        function checkTupleType(node) {
+            // Grammar checking
+            var hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes);
+            if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) {
+                grammarErrorOnNode(node, ts.Diagnostics.A_tuple_type_element_list_cannot_be_empty);
+            }
+            ts.forEach(node.elementTypes, checkSourceElement);
+        }
+        function checkUnionOrIntersectionType(node) {
+            ts.forEach(node.types, checkSourceElement);
+        }
+        function isPrivateWithinAmbient(node) {
+            return (node.flags & 8 /* Private */) && ts.isInAmbientContext(node);
+        }
+        function getEffectiveDeclarationFlags(n, flagsToCheck) {
+            var flags = ts.getCombinedNodeFlags(n);
+            // children of classes (even ambient classes) should not be marked as ambient or export
+            // because those flags have no useful semantics there.
+            if (n.parent.kind !== 222 /* InterfaceDeclaration */ &&
+                n.parent.kind !== 221 /* ClassDeclaration */ &&
+                n.parent.kind !== 192 /* ClassExpression */ &&
+                ts.isInAmbientContext(n)) {
+                if (!(flags & 2 /* Ambient */)) {
+                    // It is nested in an ambient context, which means it is automatically exported
+                    flags |= 1 /* Export */;
+                }
+                flags |= 2 /* Ambient */;
+            }
+            return flags & flagsToCheck;
+        }
+        function checkFunctionOrConstructorSymbol(symbol) {
+            if (!produceDiagnostics) {
+                return;
+            }
+            function getCanonicalOverload(overloads, implementation) {
+                // Consider the canonical set of flags to be the flags of the bodyDeclaration or the first declaration
+                // Error on all deviations from this canonical set of flags
+                // The caveat is that if some overloads are defined in lib.d.ts, we don't want to
+                // report the errors on those. To achieve this, we will say that the implementation is
+                // the canonical signature only if it is in the same container as the first overload
+                var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
+                return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
+            }
+            function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) {
+                // Error if some overloads have a flag that is not shared by all overloads. To find the
+                // deviations, we XOR someOverloadFlags with allOverloadFlags
+                var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
+                if (someButNotAllOverloadFlags !== 0) {
+                    var canonicalFlags_1 = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
+                    ts.forEach(overloads, function (o) {
+                        var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags_1;
+                        if (deviation & 1 /* Export */) {
+                            error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
+                        }
+                        else if (deviation & 2 /* Ambient */) {
+                            error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
+                        }
+                        else if (deviation & (8 /* Private */ | 16 /* Protected */)) {
+                            error(o.name || o, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
+                        }
+                        else if (deviation & 128 /* Abstract */) {
+                            error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
+                        }
+                    });
+                }
+            }
+            function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) {
+                if (someHaveQuestionToken !== allHaveQuestionToken) {
+                    var canonicalHasQuestionToken_1 = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation));
+                    ts.forEach(overloads, function (o) {
+                        var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken_1;
+                        if (deviation) {
+                            error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required);
+                        }
+                    });
+                }
+            }
+            var flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 8 /* Private */ | 16 /* Protected */ | 128 /* Abstract */;
+            var someNodeFlags = 0;
+            var allNodeFlags = flagsToCheck;
+            var someHaveQuestionToken = false;
+            var allHaveQuestionToken = true;
+            var hasOverloads = false;
+            var bodyDeclaration;
+            var lastSeenNonAmbientDeclaration;
+            var previousDeclaration;
+            var declarations = symbol.declarations;
+            var isConstructor = (symbol.flags & 16384 /* Constructor */) !== 0;
+            function reportImplementationExpectedError(node) {
+                if (node.name && ts.nodeIsMissing(node.name)) {
+                    return;
+                }
+                var seen = false;
+                var subsequentNode = ts.forEachChild(node.parent, function (c) {
+                    if (seen) {
+                        return c;
+                    }
+                    else {
+                        seen = c === node;
+                    }
+                });
+                // We may be here because of some extra nodes between overloads that could not be parsed into a valid node.
+                // In this case the subsequent node is not really consecutive (.pos !== node.end), and we must ignore it here.
+                if (subsequentNode && subsequentNode.pos === node.end) {
+                    if (subsequentNode.kind === node.kind) {
+                        var errorNode_1 = subsequentNode.name || subsequentNode;
+                        // TODO(jfreeman): These are methods, so handle computed name case
+                        if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) {
+                            var reportError = (node.kind === 147 /* MethodDeclaration */ || node.kind === 146 /* MethodSignature */) &&
+                                (node.flags & 32 /* Static */) !== (subsequentNode.flags & 32 /* Static */);
+                            // we can get here in two cases
+                            // 1. mixed static and instance class members
+                            // 2. something with the same name was defined before the set of overloads that prevents them from merging
+                            // here we'll report error only for the first case since for second we should already report error in binder
+                            if (reportError) {
+                                var diagnostic = node.flags & 32 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+                                error(errorNode_1, diagnostic);
+                            }
+                            return;
+                        }
+                        else if (ts.nodeIsPresent(subsequentNode.body)) {
+                            error(errorNode_1, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name));
+                            return;
+                        }
+                    }
+                }
+                var errorNode = node.name || node;
+                if (isConstructor) {
+                    error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing);
+                }
+                else {
+                    // Report different errors regarding non-consecutive blocks of declarations depending on whether
+                    // the node in question is abstract.
+                    if (node.flags & 128 /* Abstract */) {
+                        error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
+                    }
+                    else {
+                        error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
+                    }
+                }
+            }
+            var duplicateFunctionDeclaration = false;
+            var multipleConstructorImplementation = false;
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var current = declarations_4[_i];
+                var node = current;
+                var inAmbientContext = ts.isInAmbientContext(node);
+                var inAmbientContextOrInterface = node.parent.kind === 222 /* InterfaceDeclaration */ || node.parent.kind === 159 /* TypeLiteral */ || inAmbientContext;
+                if (inAmbientContextOrInterface) {
+                    // check if declarations are consecutive only if they are non-ambient
+                    // 1. ambient declarations can be interleaved
+                    // i.e. this is legal
+                    //     declare function foo();
+                    //     declare function bar();
+                    //     declare function foo();
+                    // 2. mixing ambient and non-ambient declarations is a separate error that will be reported - do not want to report an extra one
+                    previousDeclaration = undefined;
+                }
+                if (node.kind === 220 /* FunctionDeclaration */ || node.kind === 147 /* MethodDeclaration */ || node.kind === 146 /* MethodSignature */ || node.kind === 148 /* Constructor */) {
+                    var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
+                    someNodeFlags |= currentNodeFlags;
+                    allNodeFlags &= currentNodeFlags;
+                    someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node);
+                    allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node);
+                    if (ts.nodeIsPresent(node.body) && bodyDeclaration) {
+                        if (isConstructor) {
+                            multipleConstructorImplementation = true;
+                        }
+                        else {
+                            duplicateFunctionDeclaration = true;
+                        }
+                    }
+                    else if (previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) {
+                        reportImplementationExpectedError(previousDeclaration);
+                    }
+                    if (ts.nodeIsPresent(node.body)) {
+                        if (!bodyDeclaration) {
+                            bodyDeclaration = node;
+                        }
+                    }
+                    else {
+                        hasOverloads = true;
+                    }
+                    previousDeclaration = node;
+                    if (!inAmbientContextOrInterface) {
+                        lastSeenNonAmbientDeclaration = node;
+                    }
+                }
+            }
+            if (multipleConstructorImplementation) {
+                ts.forEach(declarations, function (declaration) {
+                    error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed);
+                });
+            }
+            if (duplicateFunctionDeclaration) {
+                ts.forEach(declarations, function (declaration) {
+                    error(declaration.name, ts.Diagnostics.Duplicate_function_implementation);
+                });
+            }
+            // Abstract methods can't have an implementation -- in particular, they don't need one.
+            if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
+                !(lastSeenNonAmbientDeclaration.flags & 128 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
+                reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
+            }
+            if (hasOverloads) {
+                checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags);
+                checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
+                if (bodyDeclaration) {
+                    var signatures = getSignaturesOfSymbol(symbol);
+                    var bodySignature = getSignatureFromDeclaration(bodyDeclaration);
+                    for (var _a = 0, signatures_3 = signatures; _a < signatures_3.length; _a++) {
+                        var signature = signatures_3[_a];
+                        if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
+                            error(signature.declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        function checkExportsOnMergedDeclarations(node) {
+            if (!produceDiagnostics) {
+                return;
+            }
+            // if localSymbol is defined on node then node itself is exported - check is required
+            var symbol = node.localSymbol;
+            if (!symbol) {
+                // local symbol is undefined => this declaration is non-exported.
+                // however symbol might contain other declarations that are exported
+                symbol = getSymbolOfNode(node);
+                if (!(symbol.flags & 7340032 /* Export */)) {
+                    // this is a pure local symbol (all declarations are non-exported) - no need to check anything
+                    return;
+                }
+            }
+            // run the check only for the first declaration in the list
+            if (ts.getDeclarationOfKind(symbol, node.kind) !== node) {
+                return;
+            }
+            // we use SymbolFlags.ExportValue, SymbolFlags.ExportType and SymbolFlags.ExportNamespace
+            // to denote disjoint declarationSpaces (without making new enum type).
+            var exportedDeclarationSpaces = 0 /* None */;
+            var nonExportedDeclarationSpaces = 0 /* None */;
+            var defaultExportedDeclarationSpaces = 0 /* None */;
+            for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                var d = _a[_i];
+                var declarationSpaces = getDeclarationSpaces(d);
+                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 512 /* Default */);
+                if (effectiveDeclarationFlags & 1 /* Export */) {
+                    if (effectiveDeclarationFlags & 512 /* Default */) {
+                        defaultExportedDeclarationSpaces |= declarationSpaces;
+                    }
+                    else {
+                        exportedDeclarationSpaces |= declarationSpaces;
+                    }
+                }
+                else {
+                    nonExportedDeclarationSpaces |= declarationSpaces;
+                }
+            }
+            // Spaces for anything not declared a 'default export'.
+            var nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
+            var commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
+            var commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
+            if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
+                // declaration spaces for exported and non-exported declarations intersect
+                for (var _b = 0, _c = symbol.declarations; _b < _c.length; _b++) {
+                    var d = _c[_b];
+                    var declarationSpaces = getDeclarationSpaces(d);
+                    // Only error on the declarations that contributed to the intersecting spaces.
+                    if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
+                        error(d.name, ts.Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, ts.declarationNameToString(d.name));
+                    }
+                    else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) {
+                        error(d.name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(d.name));
+                    }
+                }
+            }
+            function getDeclarationSpaces(d) {
+                switch (d.kind) {
+                    case 222 /* InterfaceDeclaration */:
+                        return 2097152 /* ExportType */;
+                    case 225 /* ModuleDeclaration */:
+                        return ts.isAmbientModule(d) || ts.getModuleInstanceState(d) !== 0 /* NonInstantiated */
+                            ? 4194304 /* ExportNamespace */ | 1048576 /* ExportValue */
+                            : 4194304 /* ExportNamespace */;
+                    case 221 /* ClassDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                        return 2097152 /* ExportType */ | 1048576 /* ExportValue */;
+                    case 229 /* ImportEqualsDeclaration */:
+                        var result_1 = 0;
+                        var target = resolveAlias(getSymbolOfNode(d));
+                        ts.forEach(target.declarations, function (d) { result_1 |= getDeclarationSpaces(d); });
+                        return result_1;
+                    default:
+                        return 1048576 /* ExportValue */;
+                }
+            }
+        }
+        function checkNonThenableType(type, location, message) {
+            type = getWidenedType(type);
+            if (!isTypeAny(type) && !isTypeNever(type) && isTypeAssignableTo(type, getGlobalThenableType())) {
+                if (location) {
+                    if (!message) {
+                        message = ts.Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member;
+                    }
+                    error(location, message);
+                }
+                return unknownType;
+            }
+            return type;
+        }
+        /**
+          * Gets the "promised type" of a promise.
+          * @param type The type of the promise.
+          * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback.
+          */
+        function getPromisedType(promise) {
+            //
+            //  { // promise
+            //      then( // thenFunction
+            //          onfulfilled: ( // onfulfilledParameterType
+            //              value: T // valueParameterType
+            //          ) => any
+            //      ): any;
+            //  }
+            //
+            if (isTypeAny(promise)) {
+                return undefined;
+            }
+            if (promise.flags & 4096 /* Reference */) {
+                if (promise.target === tryGetGlobalPromiseType()
+                    || promise.target === getGlobalPromiseLikeType()) {
+                    return promise.typeArguments[0];
+                }
+            }
+            var globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType();
+            if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) {
+                return undefined;
+            }
+            var thenFunction = getTypeOfPropertyOfType(promise, "then");
+            if (!thenFunction || isTypeAny(thenFunction)) {
+                return undefined;
+            }
+            var thenSignatures = getSignaturesOfType(thenFunction, 0 /* Call */);
+            if (thenSignatures.length === 0) {
+                return undefined;
+            }
+            var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(thenSignatures, getTypeOfFirstParameterOfSignature)), 131072 /* NEUndefined */);
+            if (isTypeAny(onfulfilledParameterType)) {
+                return undefined;
+            }
+            var onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0 /* Call */);
+            if (onfulfilledParameterSignatures.length === 0) {
+                return undefined;
+            }
+            return getUnionType(ts.map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature));
+        }
+        function getTypeOfFirstParameterOfSignature(signature) {
+            return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : neverType;
+        }
+        /**
+          * Gets the "awaited type" of a type.
+          * @param type The type to await.
+          * @remarks The "awaited type" of an expression is its "promised type" if the expression is a
+          * Promise-like type; otherwise, it is the type of the expression. This is used to reflect
+          * The runtime behavior of the `await` keyword.
+          */
+        function getAwaitedType(type) {
+            return checkAwaitedType(type, /*location*/ undefined, /*message*/ undefined);
+        }
+        function checkAwaitedType(type, location, message) {
+            return checkAwaitedTypeWorker(type);
+            function checkAwaitedTypeWorker(type) {
+                if (type.flags & 16384 /* Union */) {
+                    var types = [];
+                    for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+                        var constituentType = _a[_i];
+                        types.push(checkAwaitedTypeWorker(constituentType));
+                    }
+                    return getUnionType(types);
+                }
+                else {
+                    var promisedType = getPromisedType(type);
+                    if (promisedType === undefined) {
+                        // The type was not a PromiseLike, so it could not be unwrapped any further.
+                        // As long as the type does not have a callable "then" property, it is
+                        // safe to return the type; otherwise, an error will have been reported in
+                        // the call to checkNonThenableType and we will return unknownType.
+                        //
+                        // An example of a non-promise "thenable" might be:
+                        //
+                        //  await { then(): void {} }
+                        //
+                        // The "thenable" does not match the minimal definition for a PromiseLike. When
+                        // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise
+                        // will never settle. We treat this as an error to help flag an early indicator
+                        // of a runtime problem. If the user wants to return this value from an async
+                        // function, they would need to wrap it in some other value. If they want it to
+                        // be treated as a promise, they can cast to <any>.
+                        return checkNonThenableType(type, location, message);
+                    }
+                    else {
+                        if (type.id === promisedType.id || ts.indexOf(awaitedTypeStack, promisedType.id) >= 0) {
+                            // We have a bad actor in the form of a promise whose promised type is
+                            // the same promise type, or a mutually recursive promise. Return the
+                            // unknown type as we cannot guess the shape. If this were the actual
+                            // case in the JavaScript, this Promise would never resolve.
+                            //
+                            // An example of a bad actor with a singly-recursive promise type might
+                            // be:
+                            //
+                            //  interface BadPromise {
+                            //      then(
+                            //          onfulfilled: (value: BadPromise) => any,
+                            //          onrejected: (error: any) => any): BadPromise;
+                            //  }
+                            //
+                            // The above interface will pass the PromiseLike check, and return a
+                            // promised type of `BadPromise`. Since this is a self reference, we
+                            // don't want to keep recursing ad infinitum.
+                            //
+                            // An example of a bad actor in the form of a mutually-recursive
+                            // promise type might be:
+                            //
+                            //  interface BadPromiseA {
+                            //      then(
+                            //          onfulfilled: (value: BadPromiseB) => any,
+                            //          onrejected: (error: any) => any): BadPromiseB;
+                            //  }
+                            //
+                            //  interface BadPromiseB {
+                            //      then(
+                            //          onfulfilled: (value: BadPromiseA) => any,
+                            //          onrejected: (error: any) => any): BadPromiseA;
+                            //  }
+                            //
+                            if (location) {
+                                error(location, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, symbolToString(type.symbol));
+                            }
+                            return unknownType;
+                        }
+                        // Keep track of the type we're about to unwrap to avoid bad recursive promise types.
+                        // See the comments above for more information.
+                        awaitedTypeStack.push(type.id);
+                        var awaitedType = checkAwaitedTypeWorker(promisedType);
+                        awaitedTypeStack.pop();
+                        return awaitedType;
+                    }
+                }
+            }
+        }
+        /**
+         * Checks that the return type provided is an instantiation of the global Promise<T> type
+         * and returns the awaited type of the return type.
+         *
+         * @param returnType The return type of a FunctionLikeDeclaration
+         * @param location The node on which to report the error.
+         */
+        function checkCorrectPromiseType(returnType, location) {
+            if (returnType === unknownType) {
+                // The return type already had some other error, so we ignore and return
+                // the unknown type.
+                return unknownType;
+            }
+            var globalPromiseType = getGlobalPromiseType();
+            if (globalPromiseType === emptyGenericType
+                || globalPromiseType === getTargetType(returnType)) {
+                // Either we couldn't resolve the global promise type, which would have already
+                // reported an error, or we could resolve it and the return type is a valid type
+                // reference to the global type. In either case, we return the awaited type for
+                // the return type.
+                return checkAwaitedType(returnType, location, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
+            }
+            // The promise type was not a valid type reference to the global promise type, so we
+            // report an error and return the unknown type.
+            error(location, ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+            return unknownType;
+        }
+        /**
+          * Checks the return type of an async function to ensure it is a compatible
+          * Promise implementation.
+          * @param node The signature to check
+          * @param returnType The return type for the function
+          * @remarks
+          * This checks that an async function has a valid Promise-compatible return type,
+          * and returns the *awaited type* of the promise. An async function has a valid
+          * Promise-compatible return type if the resolved value of the return type has a
+          * construct signature that takes in an `initializer` function that in turn supplies
+          * a `resolve` function as one of its arguments and results in an object with a
+          * callable `then` signature.
+          */
+        function checkAsyncFunctionReturnType(node) {
+            if (languageVersion >= 2 /* ES6 */) {
+                var returnType = getTypeFromTypeNode(node.type);
+                return checkCorrectPromiseType(returnType, node.type);
+            }
+            var globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType();
+            if (globalPromiseConstructorLikeType === emptyObjectType) {
+                // If we couldn't resolve the global PromiseConstructorLike type we cannot verify
+                // compatibility with __awaiter.
+                return unknownType;
+            }
+            // As part of our emit for an async function, we will need to emit the entity name of
+            // the return type annotation as an expression. To meet the necessary runtime semantics
+            // for __awaiter, we must also check that the type of the declaration (e.g. the static
+            // side or "constructor" of the promise type) is compatible `PromiseConstructorLike`.
+            //
+            // An example might be (from lib.es6.d.ts):
+            //
+            //  interface Promise<T> { ... }
+            //  interface PromiseConstructor {
+            //      new <T>(...): Promise<T>;
+            //  }
+            //  declare var Promise: PromiseConstructor;
+            //
+            // When an async function declares a return type annotation of `Promise<T>`, we
+            // need to get the type of the `Promise` variable declaration above, which would
+            // be `PromiseConstructor`.
+            //
+            // The same case applies to a class:
+            //
+            //  declare class Promise<T> {
+            //      constructor(...);
+            //      then<U>(...): Promise<U>;
+            //  }
+            //
+            // When we get the type of the `Promise` symbol here, we get the type of the static
+            // side of the `Promise` class, which would be `{ new <T>(...): Promise<T> }`.
+            var promiseType = getTypeFromTypeNode(node.type);
+            if (promiseType === unknownType && compilerOptions.isolatedModules) {
+                // If we are compiling with isolatedModules, we may not be able to resolve the
+                // type as a value. As such, we will just return unknownType;
+                return unknownType;
+            }
+            var promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
+            if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
+                var typeName = promiseConstructor
+                    ? symbolToString(promiseConstructor)
+                    : typeToString(promiseType);
+                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
+                return unknownType;
+            }
+            // If the Promise constructor, resolved locally, is an alias symbol we should mark it as referenced.
+            checkReturnTypeAnnotationAsExpression(node);
+            // Validate the promise constructor type.
+            var promiseConstructorType = getTypeOfSymbol(promiseConstructor);
+            if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type)) {
+                return unknownType;
+            }
+            // Verify there is no local declaration that could collide with the promise constructor.
+            var promiseName = ts.getEntityNameFromTypeNode(node.type);
+            var promiseNameOrNamespaceRoot = getFirstIdentifier(promiseName);
+            var rootSymbol = getSymbol(node.locals, promiseNameOrNamespaceRoot.text, 107455 /* Value */);
+            if (rootSymbol) {
+                error(rootSymbol.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, promiseNameOrNamespaceRoot.text, getFullyQualifiedName(promiseConstructor));
+                return unknownType;
+            }
+            // Get and return the awaited type of the return type.
+            return checkAwaitedType(promiseType, node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
+        }
+        /** Check a decorator */
+        function checkDecorator(node) {
+            var signature = getResolvedSignature(node);
+            var returnType = getReturnTypeOfSignature(signature);
+            if (returnType.flags & 1 /* Any */) {
+                return;
+            }
+            var expectedReturnType;
+            var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+            var errorInfo;
+            switch (node.parent.kind) {
+                case 221 /* ClassDeclaration */:
+                    var classSymbol = getSymbolOfNode(node.parent);
+                    var classConstructorType = getTypeOfSymbol(classSymbol);
+                    expectedReturnType = getUnionType([classConstructorType, voidType]);
+                    break;
+                case 142 /* Parameter */:
+                    expectedReturnType = voidType;
+                    errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any);
+                    break;
+                case 145 /* PropertyDeclaration */:
+                    expectedReturnType = voidType;
+                    errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any);
+                    break;
+                case 147 /* MethodDeclaration */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                    var methodType = getTypeOfNode(node.parent);
+                    var descriptorType = createTypedPropertyDescriptorType(methodType);
+                    expectedReturnType = getUnionType([descriptorType, voidType]);
+                    break;
+            }
+            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, errorInfo);
+        }
+        /** Checks a type reference node as an expression. */
+        function checkTypeNodeAsExpression(node) {
+            // When we are emitting type metadata for decorators, we need to try to check the type
+            // as if it were an expression so that we can emit the type in a value position when we
+            // serialize the type metadata.
+            if (node && node.kind === 155 /* TypeReference */) {
+                var root = getFirstIdentifier(node.typeName);
+                var meaning = root.parent.kind === 155 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */;
+                // Resolve type so we know which symbol is referenced
+                var rootSymbol = resolveName(root, root.text, meaning | 8388608 /* Alias */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                // Resolved symbol is alias
+                if (rootSymbol && rootSymbol.flags & 8388608 /* Alias */) {
+                    var aliasTarget = resolveAlias(rootSymbol);
+                    // If alias has value symbol - mark alias as referenced
+                    if (aliasTarget.flags & 107455 /* Value */ && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol))) {
+                        markAliasSymbolAsReferenced(rootSymbol);
+                    }
+                }
+            }
+        }
+        /**
+          * Checks the type annotation of an accessor declaration or property declaration as
+          * an expression if it is a type reference to a type with a value declaration.
+          */
+        function checkTypeAnnotationAsExpression(node) {
+            checkTypeNodeAsExpression(node.type);
+        }
+        function checkReturnTypeAnnotationAsExpression(node) {
+            checkTypeNodeAsExpression(node.type);
+        }
+        /** Checks the type annotation of the parameters of a function/method or the constructor of a class as expressions */
+        function checkParameterTypeAnnotationsAsExpressions(node) {
+            // ensure all type annotations with a value declaration are checked as an expression
+            for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
+                var parameter = _a[_i];
+                checkTypeAnnotationAsExpression(parameter);
+            }
+        }
+        /** Check the decorators of a node */
+        function checkDecorators(node) {
+            if (!node.decorators) {
+                return;
+            }
+            // skip this check for nodes that cannot have decorators. These should have already had an error reported by
+            // checkGrammarDecorators.
+            if (!ts.nodeCanBeDecorated(node)) {
+                return;
+            }
+            if (!compilerOptions.experimentalDecorators) {
+                error(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning);
+            }
+            if (compilerOptions.emitDecoratorMetadata) {
+                // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator.
+                switch (node.kind) {
+                    case 221 /* ClassDeclaration */:
+                        var constructor = ts.getFirstConstructorWithBody(node);
+                        if (constructor) {
+                            checkParameterTypeAnnotationsAsExpressions(constructor);
+                        }
+                        break;
+                    case 147 /* MethodDeclaration */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        checkParameterTypeAnnotationsAsExpressions(node);
+                        checkReturnTypeAnnotationAsExpression(node);
+                        break;
+                    case 145 /* PropertyDeclaration */:
+                    case 142 /* Parameter */:
+                        checkTypeAnnotationAsExpression(node);
+                        break;
+                }
+            }
+            ts.forEach(node.decorators, checkDecorator);
+        }
+        function checkFunctionDeclaration(node) {
+            if (produceDiagnostics) {
+                checkFunctionOrMethodDeclaration(node) || checkGrammarForGenerator(node);
+                checkCollisionWithCapturedSuperVariable(node, node.name);
+                checkCollisionWithCapturedThisVariable(node, node.name);
+                checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+            }
+        }
+        function checkFunctionOrMethodDeclaration(node) {
+            checkDecorators(node);
+            checkSignatureDeclaration(node);
+            var isAsync = ts.isAsyncFunctionLike(node);
+            // Do not use hasDynamicName here, because that returns false for well known symbols.
+            // We want to perform checkComputedPropertyName for all computed properties, including
+            // well known symbols.
+            if (node.name && node.name.kind === 140 /* ComputedPropertyName */) {
+                // This check will account for methods in class/interface declarations,
+                // as well as accessors in classes/object literals
+                checkComputedPropertyName(node.name);
+            }
+            if (!ts.hasDynamicName(node)) {
+                // first we want to check the local symbol that contain this declaration
+                // - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol
+                // - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode
+                var symbol = getSymbolOfNode(node);
+                var localSymbol = node.localSymbol || symbol;
+                // Since the javascript won't do semantic analysis like typescript,
+                // if the javascript file comes before the typescript file and both contain same name functions,
+                // checkFunctionOrConstructorSymbol wouldn't be called if we didnt ignore javascript function.
+                var firstDeclaration = ts.forEach(localSymbol.declarations, 
+                // Get first non javascript function declaration
+                function (declaration) { return declaration.kind === node.kind && !ts.isSourceFileJavaScript(ts.getSourceFileOfNode(declaration)) ?
+                    declaration : undefined; });
+                // Only type check the symbol once
+                if (node === firstDeclaration) {
+                    checkFunctionOrConstructorSymbol(localSymbol);
+                }
+                if (symbol.parent) {
+                    // run check once for the first declaration
+                    if (ts.getDeclarationOfKind(symbol, node.kind) === node) {
+                        // run check on export symbol to check that modifiers agree across all exported declarations
+                        checkFunctionOrConstructorSymbol(symbol);
+                    }
+                }
+            }
+            checkSourceElement(node.body);
+            if (!node.asteriskToken) {
+                var returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type));
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+            }
+            if (produceDiagnostics && !node.type) {
+                // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
+                // in an ambient context
+                if (compilerOptions.noImplicitAny && ts.nodeIsMissing(node.body) && !isPrivateWithinAmbient(node)) {
+                    reportImplicitAnyError(node, anyType);
+                }
+                if (node.asteriskToken && ts.nodeIsPresent(node.body)) {
+                    // A generator with a body and no type annotation can still cause errors. It can error if the
+                    // yielded values have no common supertype, or it can give an implicit any error if it has no
+                    // yielded values. The only way to trigger these errors is to try checking its return type.
+                    getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+                }
+            }
+            registerForUnusedIdentifiersCheck(node);
+        }
+        function registerForUnusedIdentifiersCheck(node) {
+            if (deferredUnusedIdentifierNodes) {
+                deferredUnusedIdentifierNodes.push(node);
+            }
+        }
+        function checkUnusedIdentifiers() {
+            if (deferredUnusedIdentifierNodes) {
+                for (var _i = 0, deferredUnusedIdentifierNodes_1 = deferredUnusedIdentifierNodes; _i < deferredUnusedIdentifierNodes_1.length; _i++) {
+                    var node = deferredUnusedIdentifierNodes_1[_i];
+                    switch (node.kind) {
+                        case 256 /* SourceFile */:
+                        case 225 /* ModuleDeclaration */:
+                            checkUnusedModuleMembers(node);
+                            break;
+                        case 221 /* ClassDeclaration */:
+                        case 192 /* ClassExpression */:
+                            checkUnusedClassMembers(node);
+                            checkUnusedTypeParameters(node);
+                            break;
+                        case 222 /* InterfaceDeclaration */:
+                            checkUnusedTypeParameters(node);
+                            break;
+                        case 199 /* Block */:
+                        case 227 /* CaseBlock */:
+                        case 206 /* ForStatement */:
+                        case 207 /* ForInStatement */:
+                        case 208 /* ForOfStatement */:
+                            checkUnusedLocalsAndParameters(node);
+                            break;
+                        case 148 /* Constructor */:
+                        case 179 /* FunctionExpression */:
+                        case 220 /* FunctionDeclaration */:
+                        case 180 /* ArrowFunction */:
+                        case 147 /* MethodDeclaration */:
+                        case 149 /* GetAccessor */:
+                        case 150 /* SetAccessor */:
+                            if (node.body) {
+                                checkUnusedLocalsAndParameters(node);
+                            }
+                            checkUnusedTypeParameters(node);
+                            break;
+                        case 146 /* MethodSignature */:
+                        case 151 /* CallSignature */:
+                        case 152 /* ConstructSignature */:
+                        case 153 /* IndexSignature */:
+                        case 156 /* FunctionType */:
+                        case 157 /* ConstructorType */:
+                            checkUnusedTypeParameters(node);
+                            break;
+                    }
+                    ;
+                }
+            }
+        }
+        function checkUnusedLocalsAndParameters(node) {
+            if (node.parent.kind !== 222 /* InterfaceDeclaration */ && noUnusedIdentifiers && !ts.isInAmbientContext(node)) {
+                var _loop_1 = function(key) {
+                    if (ts.hasProperty(node.locals, key)) {
+                        var local_1 = node.locals[key];
+                        if (!local_1.isReferenced) {
+                            if (local_1.valueDeclaration && local_1.valueDeclaration.kind === 142 /* Parameter */) {
+                                var parameter = local_1.valueDeclaration;
+                                if (compilerOptions.noUnusedParameters &&
+                                    !ts.isParameterPropertyDeclaration(parameter) &&
+                                    !parameterIsThisKeyword(parameter) &&
+                                    !parameterNameStartsWithUnderscore(parameter)) {
+                                    error(local_1.valueDeclaration.name, ts.Diagnostics._0_is_declared_but_never_used, local_1.name);
+                                }
+                            }
+                            else if (compilerOptions.noUnusedLocals) {
+                                ts.forEach(local_1.declarations, function (d) { return error(d.name || d, ts.Diagnostics._0_is_declared_but_never_used, local_1.name); });
+                            }
+                        }
+                    }
+                };
+                for (var key in node.locals) {
+                    _loop_1(key);
+                }
+            }
+        }
+        function parameterIsThisKeyword(parameter) {
+            return parameter.name && parameter.name.originalKeywordKind === 97 /* ThisKeyword */;
+        }
+        function parameterNameStartsWithUnderscore(parameter) {
+            return parameter.name && parameter.name.kind === 69 /* Identifier */ && parameter.name.text.charCodeAt(0) === 95 /* _ */;
+        }
+        function checkUnusedClassMembers(node) {
+            if (compilerOptions.noUnusedLocals && !ts.isInAmbientContext(node)) {
+                if (node.members) {
+                    for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+                        var member = _a[_i];
+                        if (member.kind === 147 /* MethodDeclaration */ || member.kind === 145 /* PropertyDeclaration */) {
+                            if (!member.symbol.isReferenced && member.flags & 8 /* Private */) {
+                                error(member.name, ts.Diagnostics._0_is_declared_but_never_used, member.symbol.name);
+                            }
+                        }
+                        else if (member.kind === 148 /* Constructor */) {
+                            for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
+                                var parameter = _c[_b];
+                                if (!parameter.symbol.isReferenced && parameter.flags & 8 /* Private */) {
+                                    error(parameter.name, ts.Diagnostics._0_is_declared_but_never_used, parameter.symbol.name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        function checkUnusedTypeParameters(node) {
+            if (compilerOptions.noUnusedLocals && !ts.isInAmbientContext(node)) {
+                if (node.typeParameters) {
+                    for (var _i = 0, _a = node.typeParameters; _i < _a.length; _i++) {
+                        var typeParameter = _a[_i];
+                        if (!typeParameter.symbol.isReferenced) {
+                            error(typeParameter.name, ts.Diagnostics._0_is_declared_but_never_used, typeParameter.symbol.name);
+                        }
+                    }
+                }
+            }
+        }
+        function checkUnusedModuleMembers(node) {
+            if (compilerOptions.noUnusedLocals && !ts.isInAmbientContext(node)) {
+                for (var key in node.locals) {
+                    if (ts.hasProperty(node.locals, key)) {
+                        var local = node.locals[key];
+                        if (!local.isReferenced && !local.exportSymbol) {
+                            for (var _i = 0, _a = local.declarations; _i < _a.length; _i++) {
+                                var declaration = _a[_i];
+                                if (!ts.isAmbientModule(declaration)) {
+                                    error(declaration.name, ts.Diagnostics._0_is_declared_but_never_used, local.name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        function checkBlock(node) {
+            // Grammar checking for SyntaxKind.Block
+            if (node.kind === 199 /* Block */) {
+                checkGrammarStatementInAmbientContext(node);
+            }
+            ts.forEach(node.statements, checkSourceElement);
+            if (node.locals) {
+                registerForUnusedIdentifiersCheck(node);
+            }
+        }
+        function checkCollisionWithArgumentsInGeneratedCode(node) {
+            // no rest parameters \ declaration context \ overload - no codegen impact
+            if (!ts.hasDeclaredRestParameter(node) || ts.isInAmbientContext(node) || ts.nodeIsMissing(node.body)) {
+                return;
+            }
+            ts.forEach(node.parameters, function (p) {
+                if (p.name && !ts.isBindingPattern(p.name) && p.name.text === argumentsSymbol.name) {
+                    error(p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
+                }
+            });
+        }
+        function needCollisionCheckForIdentifier(node, identifier, name) {
+            if (!(identifier && identifier.text === name)) {
+                return false;
+            }
+            if (node.kind === 145 /* PropertyDeclaration */ ||
+                node.kind === 144 /* PropertySignature */ ||
+                node.kind === 147 /* MethodDeclaration */ ||
+                node.kind === 146 /* MethodSignature */ ||
+                node.kind === 149 /* GetAccessor */ ||
+                node.kind === 150 /* SetAccessor */) {
+                // it is ok to have member named '_super' or '_this' - member access is always qualified
+                return false;
+            }
+            if (ts.isInAmbientContext(node)) {
+                // ambient context - no codegen impact
+                return false;
+            }
+            var root = ts.getRootDeclaration(node);
+            if (root.kind === 142 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) {
+                // just an overload - no codegen impact
+                return false;
+            }
+            return true;
+        }
+        function checkCollisionWithCapturedThisVariable(node, name) {
+            if (needCollisionCheckForIdentifier(node, name, "_this")) {
+                potentialThisCollisions.push(node);
+            }
+        }
+        // this function will run after checking the source file so 'CaptureThis' is correct for all nodes
+        function checkIfThisIsCapturedInEnclosingScope(node) {
+            var current = node;
+            while (current) {
+                if (getNodeCheckFlags(current) & 4 /* CaptureThis */) {
+                    var isDeclaration_1 = node.kind !== 69 /* Identifier */;
+                    if (isDeclaration_1) {
+                        error(node.name, ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
+                    }
+                    else {
+                        error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference);
+                    }
+                    return;
+                }
+                current = current.parent;
+            }
+        }
+        function checkCollisionWithCapturedSuperVariable(node, name) {
+            if (!needCollisionCheckForIdentifier(node, name, "_super")) {
+                return;
+            }
+            // bubble up and find containing type
+            var enclosingClass = ts.getContainingClass(node);
+            // if containing type was not found or it is ambient - exit (no codegen)
+            if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) {
+                return;
+            }
+            if (ts.getClassExtendsHeritageClauseElement(enclosingClass)) {
+                var isDeclaration_2 = node.kind !== 69 /* Identifier */;
+                if (isDeclaration_2) {
+                    error(node, ts.Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference);
+                }
+                else {
+                    error(node, ts.Diagnostics.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference);
+                }
+            }
+        }
+        function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
+            if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
+                return;
+            }
+            // Uninstantiated modules shouldnt do this check
+            if (node.kind === 225 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) {
+                return;
+            }
+            // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent
+            var parent = getDeclarationContainer(node);
+            if (parent.kind === 256 /* SourceFile */ && ts.isExternalOrCommonJsModule(parent)) {
+                // If the declaration happens to be in external module, report error that require and exports are reserved keywords
+                error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name));
+            }
+        }
+        function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) {
+            if (!needCollisionCheckForIdentifier(node, name, "Promise")) {
+                return;
+            }
+            // Uninstantiated modules shouldnt do this check
+            if (node.kind === 225 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) {
+                return;
+            }
+            // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent
+            var parent = getDeclarationContainer(node);
+            if (parent.kind === 256 /* SourceFile */ && ts.isExternalOrCommonJsModule(parent) && parent.flags & 2097152 /* HasAsyncFunctions */) {
+                // If the declaration happens to be in external module, report error that Promise is a reserved identifier.
+                error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, ts.declarationNameToString(name), ts.declarationNameToString(name));
+            }
+        }
+        function checkVarDeclaredNamesNotShadowed(node) {
+            // - ScriptBody : StatementList
+            // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList
+            // also occurs in the VarDeclaredNames of StatementList.
+            // - Block : { StatementList }
+            // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList
+            // also occurs in the VarDeclaredNames of StatementList.
+            // Variable declarations are hoisted to the top of their function scope. They can shadow
+            // block scoped declarations, which bind tighter. this will not be flagged as duplicate definition
+            // by the binder as the declaration scope is different.
+            // A non-initialized declaration is a no-op as the block declaration will resolve before the var
+            // declaration. the problem is if the declaration has an initializer. this will act as a write to the
+            // block declared value. this is fine for let, but not const.
+            // Only consider declarations with initializers, uninitialized const declarations will not
+            // step on a let/const variable.
+            // Do not consider const and const declarations, as duplicate block-scoped declarations
+            // are handled by the binder.
+            // We are only looking for const declarations that step on let\const declarations from a
+            // different scope. e.g.:
+            //      {
+            //          const x = 0; // localDeclarationSymbol obtained after name resolution will correspond to this declaration
+            //          const x = 0; // symbol for this declaration will be 'symbol'
+            //      }
+            // skip block-scoped variables and parameters
+            if ((ts.getCombinedNodeFlags(node) & 3072 /* BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) {
+                return;
+            }
+            // skip variable declarations that don't have initializers
+            // NOTE: in ES6 spec initializer is required in variable declarations where name is binding pattern
+            // so we'll always treat binding elements as initialized
+            if (node.kind === 218 /* VariableDeclaration */ && !node.initializer) {
+                return;
+            }
+            var symbol = getSymbolOfNode(node);
+            if (symbol.flags & 1 /* FunctionScopedVariable */) {
+                var localDeclarationSymbol = resolveName(node, node.name.text, 3 /* Variable */, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
+                if (localDeclarationSymbol &&
+                    localDeclarationSymbol !== symbol &&
+                    localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) {
+                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 3072 /* BlockScoped */) {
+                        var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 219 /* VariableDeclarationList */);
+                        var container = varDeclList.parent.kind === 200 /* VariableStatement */ && varDeclList.parent.parent
+                            ? varDeclList.parent.parent
+                            : undefined;
+                        // names of block-scoped and function scoped variables can collide only
+                        // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting)
+                        var namesShareScope = container &&
+                            (container.kind === 199 /* Block */ && ts.isFunctionLike(container.parent) ||
+                                container.kind === 226 /* ModuleBlock */ ||
+                                container.kind === 225 /* ModuleDeclaration */ ||
+                                container.kind === 256 /* SourceFile */);
+                        // here we know that function scoped variable is shadowed by block scoped one
+                        // if they are defined in the same scope - binder has already reported redeclaration error
+                        // otherwise if variable has an initializer - show error that initialization will fail
+                        // since LHS will be block scoped name instead of function scoped
+                        if (!namesShareScope) {
+                            var name_17 = symbolToString(localDeclarationSymbol);
+                            error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name_17, name_17);
+                        }
+                    }
+                }
+            }
+        }
+        // Check that a parameter initializer contains no references to parameters declared to the right of itself
+        function checkParameterInitializer(node) {
+            if (ts.getRootDeclaration(node).kind !== 142 /* Parameter */) {
+                return;
+            }
+            var func = ts.getContainingFunction(node);
+            visit(node.initializer);
+            function visit(n) {
+                if (ts.isTypeNode(n) || ts.isDeclarationName(n)) {
+                    // do not dive in types
+                    // skip declaration names (i.e. in object literal expressions)
+                    return;
+                }
+                if (n.kind === 172 /* PropertyAccessExpression */) {
+                    // skip property names in property access expression
+                    return visit(n.expression);
+                }
+                else if (n.kind === 69 /* Identifier */) {
+                    // check FunctionLikeDeclaration.locals (stores parameters\function local variable)
+                    // if it contains entry with a specified name
+                    var symbol = resolveName(n, n.text, 107455 /* Value */ | 8388608 /* Alias */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                    if (!symbol || symbol === unknownSymbol || !symbol.valueDeclaration) {
+                        return;
+                    }
+                    if (symbol.valueDeclaration === node) {
+                        error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name));
+                        return;
+                    }
+                    // locals map for function contain both parameters and function locals
+                    // so we need to do a bit of extra work to check if reference is legal
+                    var enclosingContainer = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+                    if (enclosingContainer === func) {
+                        if (symbol.valueDeclaration.kind === 142 /* Parameter */) {
+                            // it is ok to reference parameter in initializer if either
+                            // - parameter is located strictly on the left of current parameter declaration
+                            if (symbol.valueDeclaration.pos < node.pos) {
+                                return;
+                            }
+                            // - parameter is wrapped in function-like entity
+                            var current = n;
+                            while (current !== node.initializer) {
+                                if (ts.isFunctionLike(current.parent)) {
+                                    return;
+                                }
+                                // computed property names/initializers in instance property declaration of class like entities
+                                // are executed in constructor and thus deferred
+                                if (current.parent.kind === 145 /* PropertyDeclaration */ &&
+                                    !(current.parent.flags & 32 /* Static */) &&
+                                    ts.isClassLike(current.parent.parent)) {
+                                    return;
+                                }
+                                current = current.parent;
+                            }
+                        }
+                        error(n, ts.Diagnostics.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(node.name), ts.declarationNameToString(n));
+                    }
+                }
+                else {
+                    return ts.forEachChild(n, visit);
+                }
+            }
+        }
+        // Check variable, parameter, or property declaration
+        function checkVariableLikeDeclaration(node) {
+            checkDecorators(node);
+            checkSourceElement(node.type);
+            // For a computed property, just check the initializer and exit
+            // Do not use hasDynamicName here, because that returns false for well known symbols.
+            // We want to perform checkComputedPropertyName for all computed properties, including
+            // well known symbols.
+            if (node.name.kind === 140 /* ComputedPropertyName */) {
+                checkComputedPropertyName(node.name);
+                if (node.initializer) {
+                    checkExpressionCached(node.initializer);
+                }
+            }
+            if (node.kind === 169 /* BindingElement */) {
+                // check computed properties inside property names of binding elements
+                if (node.propertyName && node.propertyName.kind === 140 /* ComputedPropertyName */) {
+                    checkComputedPropertyName(node.propertyName);
+                }
+                // check private/protected variable access
+                var parent_11 = node.parent.parent;
+                var parentType = getTypeForBindingElementParent(parent_11);
+                var name_18 = node.propertyName || node.name;
+                var property = getPropertyOfType(parentType, getTextOfPropertyName(name_18));
+                if (parent_11.initializer && property && getParentOfSymbol(property)) {
+                    checkClassPropertyAccess(parent_11, parent_11.initializer, parentType, property);
+                }
+            }
+            // For a binding pattern, check contained binding elements
+            if (ts.isBindingPattern(node.name)) {
+                ts.forEach(node.name.elements, checkSourceElement);
+            }
+            // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body
+            if (node.initializer && ts.getRootDeclaration(node).kind === 142 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
+                error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
+                return;
+            }
+            // For a binding pattern, validate the initializer and exit
+            if (ts.isBindingPattern(node.name)) {
+                // Don't validate for-in initializer as it is already an error
+                if (node.initializer && node.parent.parent.kind !== 207 /* ForInStatement */) {
+                    checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, /*headMessage*/ undefined);
+                    checkParameterInitializer(node);
+                }
+                return;
+            }
+            var symbol = getSymbolOfNode(node);
+            var type = getTypeOfVariableOrParameterOrProperty(symbol);
+            if (node === symbol.valueDeclaration) {
+                // Node is the primary declaration of the symbol, just validate the initializer
+                // Don't validate for-in initializer as it is already an error
+                if (node.initializer && node.parent.parent.kind !== 207 /* ForInStatement */) {
+                    checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, /*headMessage*/ undefined);
+                    checkParameterInitializer(node);
+                }
+            }
+            else {
+                // Node is a secondary declaration, check that type is identical to primary declaration and check that
+                // initializer is consistent with type associated with the node
+                var declarationType = getWidenedTypeForVariableLikeDeclaration(node);
+                if (type !== unknownType && declarationType !== unknownType && !isTypeIdenticalTo(type, declarationType)) {
+                    error(node.name, ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, ts.declarationNameToString(node.name), typeToString(type), typeToString(declarationType));
+                }
+                if (node.initializer) {
+                    checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, /*headMessage*/ undefined);
+                }
+                if (!areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
+                    error(symbol.valueDeclaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
+                    error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
+                }
+            }
+            if (node.kind !== 145 /* PropertyDeclaration */ && node.kind !== 144 /* PropertySignature */) {
+                // We know we don't have a binding pattern or computed name here
+                checkExportsOnMergedDeclarations(node);
+                if (node.kind === 218 /* VariableDeclaration */ || node.kind === 169 /* BindingElement */) {
+                    checkVarDeclaredNamesNotShadowed(node);
+                }
+                checkCollisionWithCapturedSuperVariable(node, node.name);
+                checkCollisionWithCapturedThisVariable(node, node.name);
+                checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+            }
+        }
+        function areDeclarationFlagsIdentical(left, right) {
+            if ((left.kind === 142 /* Parameter */ && right.kind === 218 /* VariableDeclaration */) ||
+                (left.kind === 218 /* VariableDeclaration */ && right.kind === 142 /* Parameter */)) {
+                // Differences in optionality between parameters and variables are allowed.
+                return true;
+            }
+            if (ts.hasQuestionToken(left) !== ts.hasQuestionToken(right)) {
+                return false;
+            }
+            var interestingFlags = 8 /* Private */ |
+                16 /* Protected */ |
+                256 /* Async */ |
+                128 /* Abstract */ |
+                64 /* Readonly */ |
+                32 /* Static */;
+            return (left.flags & interestingFlags) === (right.flags & interestingFlags);
+        }
+        function checkVariableDeclaration(node) {
+            checkGrammarVariableDeclaration(node);
+            return checkVariableLikeDeclaration(node);
+        }
+        function checkBindingElement(node) {
+            checkGrammarBindingElement(node);
+            return checkVariableLikeDeclaration(node);
+        }
+        function checkVariableStatement(node) {
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarVariableDeclarationList(node.declarationList) || checkGrammarForDisallowedLetOrConstStatement(node);
+            ts.forEach(node.declarationList.declarations, checkSourceElement);
+        }
+        function checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node) {
+            // We only disallow modifier on a method declaration if it is a property of object-literal-expression
+            if (node.modifiers && node.parent.kind === 171 /* ObjectLiteralExpression */) {
+                if (ts.isAsyncFunctionLike(node)) {
+                    if (node.modifiers.length > 1) {
+                        return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                }
+                else {
+                    return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+                }
+            }
+        }
+        function checkExpressionStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            checkExpression(node.expression);
+        }
+        function checkIfStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            checkExpression(node.expression);
+            checkSourceElement(node.thenStatement);
+            if (node.thenStatement.kind === 201 /* EmptyStatement */) {
+                error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+            }
+            checkSourceElement(node.elseStatement);
+        }
+        function checkDoStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            checkSourceElement(node.statement);
+            checkExpression(node.expression);
+        }
+        function checkWhileStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            checkExpression(node.expression);
+            checkSourceElement(node.statement);
+        }
+        function checkForStatement(node) {
+            // Grammar checking
+            if (!checkGrammarStatementInAmbientContext(node)) {
+                if (node.initializer && node.initializer.kind === 219 /* VariableDeclarationList */) {
+                    checkGrammarVariableDeclarationList(node.initializer);
+                }
+            }
+            if (node.initializer) {
+                if (node.initializer.kind === 219 /* VariableDeclarationList */) {
+                    ts.forEach(node.initializer.declarations, checkVariableDeclaration);
+                }
+                else {
+                    checkExpression(node.initializer);
+                }
+            }
+            if (node.condition)
+                checkExpression(node.condition);
+            if (node.incrementor)
+                checkExpression(node.incrementor);
+            checkSourceElement(node.statement);
+            if (node.locals) {
+                registerForUnusedIdentifiersCheck(node);
+            }
+        }
+        function checkForOfStatement(node) {
+            checkGrammarForInOrForOfStatement(node);
+            // Check the LHS and RHS
+            // If the LHS is a declaration, just check it as a variable declaration, which will in turn check the RHS
+            // via checkRightHandSideOfForOf.
+            // If the LHS is an expression, check the LHS, as a destructuring assignment or as a reference.
+            // Then check that the RHS is assignable to it.
+            if (node.initializer.kind === 219 /* VariableDeclarationList */) {
+                checkForInOrForOfVariableDeclaration(node);
+            }
+            else {
+                var varExpr = node.initializer;
+                var iteratedType = checkRightHandSideOfForOf(node.expression);
+                // There may be a destructuring assignment on the left side
+                if (varExpr.kind === 170 /* ArrayLiteralExpression */ || varExpr.kind === 171 /* ObjectLiteralExpression */) {
+                    // iteratedType may be undefined. In this case, we still want to check the structure of
+                    // varExpr, in particular making sure it's a valid LeftHandSideExpression. But we'd like
+                    // to short circuit the type relation checking as much as possible, so we pass the unknownType.
+                    checkDestructuringAssignment(varExpr, iteratedType || unknownType);
+                }
+                else {
+                    var leftType = checkExpression(varExpr);
+                    checkReferenceExpression(varExpr, /*invalidReferenceMessage*/ ts.Diagnostics.Invalid_left_hand_side_in_for_of_statement, 
+                    /*constantVariableMessage*/ ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_be_a_constant_or_a_read_only_property);
+                    // iteratedType will be undefined if the rightType was missing properties/signatures
+                    // required to get its iteratedType (like [Symbol.iterator] or next). This may be
+                    // because we accessed properties from anyType, or it may have led to an error inside
+                    // getElementTypeOfIterable.
+                    if (iteratedType) {
+                        checkTypeAssignableTo(iteratedType, leftType, varExpr, /*headMessage*/ undefined);
+                    }
+                }
+            }
+            checkSourceElement(node.statement);
+            if (node.locals) {
+                registerForUnusedIdentifiersCheck(node);
+            }
+        }
+        function checkForInStatement(node) {
+            // Grammar checking
+            checkGrammarForInOrForOfStatement(node);
+            // TypeScript 1.0 spec  (April 2014): 5.4
+            // In a 'for-in' statement of the form
+            // for (let VarDecl in Expr) Statement
+            //   VarDecl must be a variable declaration without a type annotation that declares a variable of type Any,
+            //   and Expr must be an expression of type Any, an object type, or a type parameter type.
+            if (node.initializer.kind === 219 /* VariableDeclarationList */) {
+                var variable = node.initializer.declarations[0];
+                if (variable && ts.isBindingPattern(variable.name)) {
+                    error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
+                }
+                checkForInOrForOfVariableDeclaration(node);
+            }
+            else {
+                // In a 'for-in' statement of the form
+                // for (Var in Expr) Statement
+                //   Var must be an expression classified as a reference of type Any or the String primitive type,
+                //   and Expr must be an expression of type Any, an object type, or a type parameter type.
+                var varExpr = node.initializer;
+                var leftType = checkExpression(varExpr);
+                if (varExpr.kind === 170 /* ArrayLiteralExpression */ || varExpr.kind === 171 /* ObjectLiteralExpression */) {
+                    error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
+                }
+                else if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258 /* StringLike */)) {
+                    error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
+                }
+                else {
+                    // run check only former check succeeded to avoid cascading errors
+                    checkReferenceExpression(varExpr, ts.Diagnostics.Invalid_left_hand_side_in_for_in_statement, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_constant_or_a_read_only_property);
+                }
+            }
+            var rightType = checkNonNullExpression(node.expression);
+            // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
+            // in this case error about missing name is already reported - do not report extra one
+            if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, 80896 /* ObjectType */ | 512 /* TypeParameter */)) {
+                error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter);
+            }
+            checkSourceElement(node.statement);
+            if (node.locals) {
+                registerForUnusedIdentifiersCheck(node);
+            }
+        }
+        function checkForInOrForOfVariableDeclaration(iterationStatement) {
+            var variableDeclarationList = iterationStatement.initializer;
+            // checkGrammarForInOrForOfStatement will check that there is exactly one declaration.
+            if (variableDeclarationList.declarations.length >= 1) {
+                var decl = variableDeclarationList.declarations[0];
+                checkVariableDeclaration(decl);
+            }
+        }
+        function checkRightHandSideOfForOf(rhsExpression) {
+            var expressionType = checkNonNullExpression(rhsExpression);
+            return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true);
+        }
+        function checkIteratedTypeOrElementType(inputType, errorNode, allowStringInput) {
+            if (isTypeAny(inputType)) {
+                return inputType;
+            }
+            if (languageVersion >= 2 /* ES6 */) {
+                return checkElementTypeOfIterable(inputType, errorNode);
+            }
+            if (allowStringInput) {
+                return checkElementTypeOfArrayOrString(inputType, errorNode);
+            }
+            if (isArrayLikeType(inputType)) {
+                var indexType = getIndexTypeOfType(inputType, 1 /* Number */);
+                if (indexType) {
+                    return indexType;
+                }
+            }
+            if (errorNode) {
+                error(errorNode, ts.Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType));
+            }
+            return unknownType;
+        }
+        /**
+         * When errorNode is undefined, it means we should not report any errors.
+         */
+        function checkElementTypeOfIterable(iterable, errorNode) {
+            var elementType = getElementTypeOfIterable(iterable, errorNode);
+            // Now even though we have extracted the iteratedType, we will have to validate that the type
+            // passed in is actually an Iterable.
+            if (errorNode && elementType) {
+                checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode);
+            }
+            return elementType || anyType;
+        }
+        /**
+         * We want to treat type as an iterable, and get the type it is an iterable of. The iterable
+         * must have the following structure (annotated with the names of the variables below):
+         *
+         * { // iterable
+         *     [Symbol.iterator]: { // iteratorFunction
+         *         (): Iterator<T>
+         *     }
+         * }
+         *
+         * T is the type we are after. At every level that involves analyzing return types
+         * of signatures, we union the return types of all the signatures.
+         *
+         * Another thing to note is that at any step of this process, we could run into a dead end,
+         * meaning either the property is missing, or we run into the anyType. If either of these things
+         * happens, we return undefined to signal that we could not find the iterated type. If a property
+         * is missing, and the previous step did not result in 'any', then we also give an error if the
+         * caller requested it. Then the caller can decide what to do in the case where there is no iterated
+         * type. This is different from returning anyType, because that would signify that we have matched the
+         * whole pattern and that T (above) is 'any'.
+         */
+        function getElementTypeOfIterable(type, errorNode) {
+            if (isTypeAny(type)) {
+                return undefined;
+            }
+            var typeAsIterable = type;
+            if (!typeAsIterable.iterableElementType) {
+                // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable<number>),
+                // then just grab its type argument.
+                if ((type.flags & 4096 /* Reference */) && type.target === getGlobalIterableType()) {
+                    typeAsIterable.iterableElementType = type.typeArguments[0];
+                }
+                else {
+                    var iteratorFunction = getTypeOfPropertyOfType(type, ts.getPropertyNameForKnownSymbolName("iterator"));
+                    if (isTypeAny(iteratorFunction)) {
+                        return undefined;
+                    }
+                    var iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, 0 /* Call */) : emptyArray;
+                    if (iteratorFunctionSignatures.length === 0) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
+                        }
+                        return undefined;
+                    }
+                    typeAsIterable.iterableElementType = getElementTypeOfIterator(getUnionType(ts.map(iteratorFunctionSignatures, getReturnTypeOfSignature)), errorNode);
+                }
+            }
+            return typeAsIterable.iterableElementType;
+        }
+        /**
+         * This function has very similar logic as getElementTypeOfIterable, except that it operates on
+         * Iterators instead of Iterables. Here is the structure:
+         *
+         *  { // iterator
+         *      next: { // iteratorNextFunction
+         *          (): { // iteratorNextResult
+         *              value: T // iteratorNextValue
+         *          }
+         *      }
+         *  }
+         *
+         */
+        function getElementTypeOfIterator(type, errorNode) {
+            if (isTypeAny(type)) {
+                return undefined;
+            }
+            var typeAsIterator = type;
+            if (!typeAsIterator.iteratorElementType) {
+                // As an optimization, if the type is instantiated directly using the globalIteratorType (Iterator<number>),
+                // then just grab its type argument.
+                if ((type.flags & 4096 /* Reference */) && type.target === getGlobalIteratorType()) {
+                    typeAsIterator.iteratorElementType = type.typeArguments[0];
+                }
+                else {
+                    var iteratorNextFunction = getTypeOfPropertyOfType(type, "next");
+                    if (isTypeAny(iteratorNextFunction)) {
+                        return undefined;
+                    }
+                    var iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, 0 /* Call */) : emptyArray;
+                    if (iteratorNextFunctionSignatures.length === 0) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.An_iterator_must_have_a_next_method);
+                        }
+                        return undefined;
+                    }
+                    var iteratorNextResult = getUnionType(ts.map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
+                    if (isTypeAny(iteratorNextResult)) {
+                        return undefined;
+                    }
+                    var iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
+                    if (!iteratorNextValue) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                        }
+                        return undefined;
+                    }
+                    typeAsIterator.iteratorElementType = iteratorNextValue;
+                }
+            }
+            return typeAsIterator.iteratorElementType;
+        }
+        function getElementTypeOfIterableIterator(type) {
+            if (isTypeAny(type)) {
+                return undefined;
+            }
+            // As an optimization, if the type is instantiated directly using the globalIterableIteratorType (IterableIterator<number>),
+            // then just grab its type argument.
+            if ((type.flags & 4096 /* Reference */) && type.target === getGlobalIterableIteratorType()) {
+                return type.typeArguments[0];
+            }
+            return getElementTypeOfIterable(type, /*errorNode*/ undefined) ||
+                getElementTypeOfIterator(type, /*errorNode*/ undefined);
+        }
+        /**
+         * This function does the following steps:
+         *   1. Break up arrayOrStringType (possibly a union) into its string constituents and array constituents.
+         *   2. Take the element types of the array constituents.
+         *   3. Return the union of the element types, and string if there was a string constituent.
+         *
+         * For example:
+         *     string -> string
+         *     number[] -> number
+         *     string[] | number[] -> string | number
+         *     string | number[] -> string | number
+         *     string | string[] | number[] -> string | number
+         *
+         * It also errors if:
+         *   1. Some constituent is neither a string nor an array.
+         *   2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable).
+         */
+        function checkElementTypeOfArrayOrString(arrayOrStringType, errorNode) {
+            ts.Debug.assert(languageVersion < 2 /* ES6 */);
+            // After we remove all types that are StringLike, we will know if there was a string constituent
+            // based on whether the remaining type is the same as the initial type.
+            var arrayType = arrayOrStringType;
+            if (arrayOrStringType.flags & 16384 /* Union */) {
+                arrayType = getUnionType(ts.filter(arrayOrStringType.types, function (t) { return !(t.flags & 258 /* StringLike */); }));
+            }
+            else if (arrayOrStringType.flags & 258 /* StringLike */) {
+                arrayType = neverType;
+            }
+            var hasStringConstituent = arrayOrStringType !== arrayType;
+            var reportedError = false;
+            if (hasStringConstituent) {
+                if (languageVersion < 1 /* ES5 */) {
+                    error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
+                    reportedError = true;
+                }
+                // Now that we've removed all the StringLike types, if no constituents remain, then the entire
+                // arrayOrStringType was a string.
+                if (arrayType === neverType) {
+                    return stringType;
+                }
+            }
+            if (!isArrayLikeType(arrayType)) {
+                if (!reportedError) {
+                    // Which error we report depends on whether there was a string constituent. For example,
+                    // if the input type is number | string, we want to say that number is not an array type.
+                    // But if the input was just number, we want to say that number is not an array type
+                    // or a string type.
+                    var diagnostic = hasStringConstituent
+                        ? ts.Diagnostics.Type_0_is_not_an_array_type
+                        : ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type;
+                    error(errorNode, diagnostic, typeToString(arrayType));
+                }
+                return hasStringConstituent ? stringType : unknownType;
+            }
+            var arrayElementType = getIndexTypeOfType(arrayType, 1 /* Number */) || unknownType;
+            if (hasStringConstituent) {
+                // This is just an optimization for the case where arrayOrStringType is string | string[]
+                if (arrayElementType.flags & 258 /* StringLike */) {
+                    return stringType;
+                }
+                return getUnionType([arrayElementType, stringType]);
+            }
+            return arrayElementType;
+        }
+        function checkBreakOrContinueStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node);
+            // TODO: Check that target label is valid
+        }
+        function isGetAccessorWithAnnotatedSetAccessor(node) {
+            return !!(node.kind === 149 /* GetAccessor */ && ts.getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 150 /* SetAccessor */)));
+        }
+        function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
+            var unwrappedReturnType = ts.isAsyncFunctionLike(func) ? getPromisedType(returnType) : returnType;
+            return unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16 /* Void */ | 1 /* Any */);
+        }
+        function checkReturnStatement(node) {
+            // Grammar checking
+            if (!checkGrammarStatementInAmbientContext(node)) {
+                var functionBlock = ts.getContainingFunction(node);
+                if (!functionBlock) {
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
+                }
+            }
+            var func = ts.getContainingFunction(node);
+            if (func) {
+                var signature = getSignatureFromDeclaration(func);
+                var returnType = getReturnTypeOfSignature(signature);
+                if (strictNullChecks || node.expression || returnType === neverType) {
+                    var exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
+                    if (func.asteriskToken) {
+                        // A generator does not need its return expressions checked against its return type.
+                        // Instead, the yield expressions are checked against the element type.
+                        // TODO: Check return expressions of generators when return type tracking is added
+                        // for generators.
+                        return;
+                    }
+                    if (func.kind === 150 /* SetAccessor */) {
+                        if (node.expression) {
+                            error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value);
+                        }
+                    }
+                    else if (func.kind === 148 /* Constructor */) {
+                        if (node.expression && !checkTypeAssignableTo(exprType, returnType, node.expression)) {
+                            error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
+                        }
+                    }
+                    else if (func.type || isGetAccessorWithAnnotatedSetAccessor(func)) {
+                        if (ts.isAsyncFunctionLike(func)) {
+                            var promisedType = getPromisedType(returnType);
+                            var awaitedType = checkAwaitedType(exprType, node.expression || node, ts.Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
+                            if (promisedType) {
+                                // If the function has a return type, but promisedType is
+                                // undefined, an error will be reported in checkAsyncFunctionReturnType
+                                // so we don't need to report one here.
+                                checkTypeAssignableTo(awaitedType, promisedType, node.expression || node);
+                            }
+                        }
+                        else {
+                            checkTypeAssignableTo(exprType, returnType, node.expression || node);
+                        }
+                    }
+                }
+                else if (func.kind !== 148 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) {
+                    // The function has a return type, but the return statement doesn't have an expression.
+                    error(node, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                }
+            }
+        }
+        function checkWithStatement(node) {
+            // Grammar checking for withStatement
+            if (!checkGrammarStatementInAmbientContext(node)) {
+                if (node.flags & 33554432 /* AwaitContext */) {
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
+                }
+            }
+            checkExpression(node.expression);
+            error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any);
+        }
+        function checkSwitchStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            var firstDefaultClause;
+            var hasDuplicateDefaultClause = false;
+            var expressionType = checkExpression(node.expression);
+            ts.forEach(node.caseBlock.clauses, function (clause) {
+                // Grammar check for duplicate default clauses, skip if we already report duplicate default clause
+                if (clause.kind === 250 /* DefaultClause */ && !hasDuplicateDefaultClause) {
+                    if (firstDefaultClause === undefined) {
+                        firstDefaultClause = clause;
+                    }
+                    else {
+                        var sourceFile = ts.getSourceFileOfNode(node);
+                        var start = ts.skipTrivia(sourceFile.text, clause.pos);
+                        var end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end;
+                        grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
+                        hasDuplicateDefaultClause = true;
+                    }
+                }
+                if (produceDiagnostics && clause.kind === 249 /* CaseClause */) {
+                    var caseClause = clause;
+                    // TypeScript 1.0 spec (April 2014): 5.9
+                    // In a 'switch' statement, each 'case' expression must be of a type that is comparable
+                    // to or from the type of the 'switch' expression.
+                    var caseType = checkExpression(caseClause.expression);
+                    if (!isTypeEqualityComparableTo(expressionType, caseType)) {
+                        // expressionType is not comparable to caseType, try the reversed check and report errors if it fails
+                        checkTypeComparableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined);
+                    }
+                }
+                ts.forEach(clause.statements, checkSourceElement);
+            });
+            if (node.caseBlock.locals) {
+                registerForUnusedIdentifiersCheck(node.caseBlock);
+            }
+        }
+        function checkLabeledStatement(node) {
+            // Grammar checking
+            if (!checkGrammarStatementInAmbientContext(node)) {
+                var current = node.parent;
+                while (current) {
+                    if (ts.isFunctionLike(current)) {
+                        break;
+                    }
+                    if (current.kind === 214 /* LabeledStatement */ && current.label.text === node.label.text) {
+                        var sourceFile = ts.getSourceFileOfNode(node);
+                        grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label));
+                        break;
+                    }
+                    current = current.parent;
+                }
+            }
+            // ensure that label is unique
+            checkSourceElement(node.statement);
+        }
+        function checkThrowStatement(node) {
+            // Grammar checking
+            if (!checkGrammarStatementInAmbientContext(node)) {
+                if (node.expression === undefined) {
+                    grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here);
+                }
+            }
+            if (node.expression) {
+                checkExpression(node.expression);
+            }
+        }
+        function checkTryStatement(node) {
+            // Grammar checking
+            checkGrammarStatementInAmbientContext(node);
+            checkBlock(node.tryBlock);
+            var catchClause = node.catchClause;
+            if (catchClause) {
+                // Grammar checking
+                if (catchClause.variableDeclaration) {
+                    if (catchClause.variableDeclaration.name.kind !== 69 /* Identifier */) {
+                        grammarErrorOnFirstToken(catchClause.variableDeclaration.name, ts.Diagnostics.Catch_clause_variable_name_must_be_an_identifier);
+                    }
+                    else if (catchClause.variableDeclaration.type) {
+                        grammarErrorOnFirstToken(catchClause.variableDeclaration.type, ts.Diagnostics.Catch_clause_variable_cannot_have_a_type_annotation);
+                    }
+                    else if (catchClause.variableDeclaration.initializer) {
+                        grammarErrorOnFirstToken(catchClause.variableDeclaration.initializer, ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
+                    }
+                    else {
+                        var identifierName = catchClause.variableDeclaration.name.text;
+                        var locals = catchClause.block.locals;
+                        if (locals && ts.hasProperty(locals, identifierName)) {
+                            var localSymbol = locals[identifierName];
+                            if (localSymbol && (localSymbol.flags & 2 /* BlockScopedVariable */) !== 0) {
+                                grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName);
+                            }
+                        }
+                    }
+                }
+                checkBlock(catchClause.block);
+            }
+            if (node.finallyBlock) {
+                checkBlock(node.finallyBlock);
+            }
+        }
+        function checkIndexConstraints(type) {
+            var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1 /* Number */);
+            var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0 /* String */);
+            var stringIndexType = getIndexTypeOfType(type, 0 /* String */);
+            var numberIndexType = getIndexTypeOfType(type, 1 /* Number */);
+            if (stringIndexType || numberIndexType) {
+                ts.forEach(getPropertiesOfObjectType(type), function (prop) {
+                    var propType = getTypeOfSymbol(prop);
+                    checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */);
+                    checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */);
+                });
+                if (type.flags & 1024 /* Class */ && ts.isClassLike(type.symbol.valueDeclaration)) {
+                    var classDeclaration = type.symbol.valueDeclaration;
+                    for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
+                        var member = _a[_i];
+                        // Only process instance properties with computed names here.
+                        // Static properties cannot be in conflict with indexers,
+                        // and properties with literal names were already checked.
+                        if (!(member.flags & 32 /* Static */) && ts.hasDynamicName(member)) {
+                            var propType = getTypeOfSymbol(member.symbol);
+                            checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */);
+                            checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */);
+                        }
+                    }
+                }
+            }
+            var errorNode;
+            if (stringIndexType && numberIndexType) {
+                errorNode = declaredNumberIndexer || declaredStringIndexer;
+                // condition 'errorNode === undefined' may appear if types does not declare nor string neither number indexer
+                if (!errorNode && (type.flags & 2048 /* Interface */)) {
+                    var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0 /* String */) && getIndexTypeOfType(base, 1 /* Number */); });
+                    errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0];
+                }
+            }
+            if (errorNode && !isTypeAssignableTo(numberIndexType, stringIndexType)) {
+                error(errorNode, ts.Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1, typeToString(numberIndexType), typeToString(stringIndexType));
+            }
+            function checkIndexConstraintForProperty(prop, propertyType, containingType, indexDeclaration, indexType, indexKind) {
+                if (!indexType) {
+                    return;
+                }
+                // index is numeric and property name is not valid numeric literal
+                if (indexKind === 1 /* Number */ && !isNumericName(prop.valueDeclaration.name)) {
+                    return;
+                }
+                // perform property check if property or indexer is declared in 'type'
+                // this allows to rule out cases when both property and indexer are inherited from the base class
+                var errorNode;
+                if (prop.valueDeclaration.name.kind === 140 /* ComputedPropertyName */ || prop.parent === containingType.symbol) {
+                    errorNode = prop.valueDeclaration;
+                }
+                else if (indexDeclaration) {
+                    errorNode = indexDeclaration;
+                }
+                else if (containingType.flags & 2048 /* Interface */) {
+                    // for interfaces property and indexer might be inherited from different bases
+                    // check if any base class already has both property and indexer.
+                    // check should be performed only if 'type' is the first type that brings property\indexer together
+                    var someBaseClassHasBothPropertyAndIndexer = ts.forEach(getBaseTypes(containingType), function (base) { return getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind); });
+                    errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
+                }
+                if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
+                    var errorMessage = indexKind === 0 /* String */
+                        ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
+                        : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
+                    error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType));
+                }
+            }
+        }
+        function checkTypeNameIsReserved(name, message) {
+            // TS 1.0 spec (April 2014): 3.6.1
+            // The predefined type keywords are reserved and cannot be used as names of user defined types.
+            switch (name.text) {
+                case "any":
+                case "number":
+                case "boolean":
+                case "string":
+                case "symbol":
+                case "void":
+                    error(name, message, name.text);
+            }
+        }
+        /** Check each type parameter and check that type parameters have no duplicate type parameter declarations */
+        function checkTypeParameters(typeParameterDeclarations) {
+            if (typeParameterDeclarations) {
+                for (var i = 0, n = typeParameterDeclarations.length; i < n; i++) {
+                    var node = typeParameterDeclarations[i];
+                    checkTypeParameter(node);
+                    if (produceDiagnostics) {
+                        for (var j = 0; j < i; j++) {
+                            if (typeParameterDeclarations[j].symbol === node.symbol) {
+                                error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        /** Check that type parameter lists are identical across multiple declarations */
+        function checkTypeParameterListsIdentical(node, symbol) {
+            if (symbol.declarations.length === 1) {
+                return;
+            }
+            var firstDecl;
+            for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                var declaration = _a[_i];
+                if (declaration.kind === 221 /* ClassDeclaration */ || declaration.kind === 222 /* InterfaceDeclaration */) {
+                    if (!firstDecl) {
+                        firstDecl = declaration;
+                    }
+                    else if (!areTypeParametersIdentical(firstDecl.typeParameters, node.typeParameters)) {
+                        error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, node.name.text);
+                    }
+                }
+            }
+        }
+        function checkClassExpression(node) {
+            checkClassLikeDeclaration(node);
+            checkNodeDeferred(node);
+            return getTypeOfSymbol(getSymbolOfNode(node));
+        }
+        function checkClassExpressionDeferred(node) {
+            ts.forEach(node.members, checkSourceElement);
+            registerForUnusedIdentifiersCheck(node);
+        }
+        function checkClassDeclaration(node) {
+            if (!node.name && !(node.flags & 512 /* Default */)) {
+                grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
+            }
+            checkClassLikeDeclaration(node);
+            ts.forEach(node.members, checkSourceElement);
+            registerForUnusedIdentifiersCheck(node);
+        }
+        function checkClassLikeDeclaration(node) {
+            checkGrammarClassDeclarationHeritageClauses(node);
+            checkDecorators(node);
+            if (node.name) {
+                checkTypeNameIsReserved(node.name, ts.Diagnostics.Class_name_cannot_be_0);
+                checkCollisionWithCapturedThisVariable(node, node.name);
+                checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+            }
+            checkTypeParameters(node.typeParameters);
+            checkExportsOnMergedDeclarations(node);
+            var symbol = getSymbolOfNode(node);
+            var type = getDeclaredTypeOfSymbol(symbol);
+            var typeWithThis = getTypeWithThisArgument(type);
+            var staticType = getTypeOfSymbol(symbol);
+            checkTypeParameterListsIdentical(node, symbol);
+            checkClassForDuplicateDeclarations(node);
+            var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node);
+            if (baseTypeNode) {
+                var baseTypes = getBaseTypes(type);
+                if (baseTypes.length && produceDiagnostics) {
+                    var baseType_1 = baseTypes[0];
+                    var staticBaseType = getBaseConstructorTypeOfClass(type);
+                    checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
+                    checkSourceElement(baseTypeNode.expression);
+                    if (baseTypeNode.typeArguments) {
+                        ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
+                        for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); _i < _a.length; _i++) {
+                            var constructor = _a[_i];
+                            if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) {
+                                break;
+                            }
+                        }
+                    }
+                    checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType_1, type.thisType), node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
+                    checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                    if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32 /* Class */)) {
+                        // When the static base type is a "class-like" constructor function (but not actually a class), we verify
+                        // that all instantiated base constructor signatures return the same type. We can simply compare the type
+                        // references (as opposed to checking the structure of the types) because elsewhere we have already checked
+                        // that the base type is a class or interface type (and not, for example, an anonymous object type).
+                        var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments);
+                        if (ts.forEach(constructors, function (sig) { return getReturnTypeOfSignature(sig) !== baseType_1; })) {
+                            error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type);
+                        }
+                    }
+                    checkKindsOfPropertyMemberOverrides(type, baseType_1);
+                }
+            }
+            var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node);
+            if (implementedTypeNodes) {
+                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+                    var typeRefNode = implementedTypeNodes_1[_b];
+                    if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) {
+                        error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
+                    }
+                    checkTypeReferenceNode(typeRefNode);
+                    if (produceDiagnostics) {
+                        var t = getTypeFromTypeNode(typeRefNode);
+                        if (t !== unknownType) {
+                            var declaredType = (t.flags & 4096 /* Reference */) ? t.target : t;
+                            if (declaredType.flags & (1024 /* Class */ | 2048 /* Interface */)) {
+                                checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(t, type.thisType), node.name || node, ts.Diagnostics.Class_0_incorrectly_implements_interface_1);
+                            }
+                            else {
+                                error(typeRefNode, ts.Diagnostics.A_class_may_only_implement_another_class_or_interface);
+                            }
+                        }
+                    }
+                }
+            }
+            if (produceDiagnostics) {
+                checkIndexConstraints(type);
+                checkTypeForDuplicateIndexSignatures(node);
+            }
+        }
+        function checkBaseTypeAccessibility(type, node) {
+            var signatures = getSignaturesOfType(type, 1 /* Construct */);
+            if (signatures.length) {
+                var declaration = signatures[0].declaration;
+                if (declaration && declaration.flags & 8 /* Private */) {
+                    var typeClassDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
+                    if (!isNodeWithinClass(node, typeClassDeclaration)) {
+                        error(node, ts.Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, node.expression.text);
+                    }
+                }
+            }
+        }
+        function getTargetSymbol(s) {
+            // if symbol is instantiated its flags are not copied from the 'target'
+            // so we'll need to get back original 'target' symbol to work with correct set of flags
+            return s.flags & 16777216 /* Instantiated */ ? getSymbolLinks(s).target : s;
+        }
+        function getClassLikeDeclarationOfSymbol(symbol) {
+            return ts.forEach(symbol.declarations, function (d) { return ts.isClassLike(d) ? d : undefined; });
+        }
+        function checkKindsOfPropertyMemberOverrides(type, baseType) {
+            // TypeScript 1.0 spec (April 2014): 8.2.3
+            // A derived class inherits all members from its base class it doesn't override.
+            // Inheritance means that a derived class implicitly contains all non - overridden members of the base class.
+            // Both public and private property members are inherited, but only public property members can be overridden.
+            // A property member in a derived class is said to override a property member in a base class
+            // when the derived class property member has the same name and kind(instance or static)
+            // as the base class property member.
+            // The type of an overriding property member must be assignable(section 3.8.4)
+            // to the type of the overridden property member, or otherwise a compile - time error occurs.
+            // Base class instance member functions can be overridden by derived class instance member functions,
+            // but not by other kinds of members.
+            // Base class instance member variables and accessors can be overridden by
+            // derived class instance member variables and accessors, but not by other kinds of members.
+            // NOTE: assignability is checked in checkClassDeclaration
+            var baseProperties = getPropertiesOfObjectType(baseType);
+            for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
+                var base = getTargetSymbol(baseProperty);
+                if (base.flags & 134217728 /* Prototype */) {
+                    continue;
+                }
+                var derived = getTargetSymbol(getPropertyOfObjectType(type, base.name));
+                var baseDeclarationFlags = getDeclarationFlagsFromSymbol(base);
+                ts.Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
+                if (derived) {
+                    // In order to resolve whether the inherited method was overridden in the base class or not,
+                    // we compare the Symbols obtained. Since getTargetSymbol returns the symbol on the *uninstantiated*
+                    // type declaration, derived and base resolve to the same symbol even in the case of generic classes.
+                    if (derived === base) {
+                        // derived class inherits base without override/redeclaration
+                        var derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
+                        // It is an error to inherit an abstract member without implementing it or being declared abstract.
+                        // If there is no declaration for the derived class (as in the case of class expressions),
+                        // then the class cannot be declared abstract.
+                        if (baseDeclarationFlags & 128 /* Abstract */ && (!derivedClassDecl || !(derivedClassDecl.flags & 128 /* Abstract */))) {
+                            if (derivedClassDecl.kind === 192 /* ClassExpression */) {
+                                error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
+                            }
+                            else {
+                                error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType));
+                            }
+                        }
+                    }
+                    else {
+                        // derived overrides base.
+                        var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
+                        if ((baseDeclarationFlags & 8 /* Private */) || (derivedDeclarationFlags & 8 /* Private */)) {
+                            // either base or derived property is private - not override, skip it
+                            continue;
+                        }
+                        if ((baseDeclarationFlags & 32 /* Static */) !== (derivedDeclarationFlags & 32 /* Static */)) {
+                            // value of 'static' is not the same for properties - not override, skip it
+                            continue;
+                        }
+                        if ((base.flags & derived.flags & 8192 /* Method */) || ((base.flags & 98308 /* PropertyOrAccessor */) && (derived.flags & 98308 /* PropertyOrAccessor */))) {
+                            // method is overridden with method or property/accessor is overridden with property/accessor - correct case
+                            continue;
+                        }
+                        var errorMessage = void 0;
+                        if (base.flags & 8192 /* Method */) {
+                            if (derived.flags & 98304 /* Accessor */) {
+                                errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+                            }
+                            else {
+                                ts.Debug.assert((derived.flags & 4 /* Property */) !== 0);
+                                errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property;
+                            }
+                        }
+                        else if (base.flags & 4 /* Property */) {
+                            ts.Debug.assert((derived.flags & 8192 /* Method */) !== 0);
+                            errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+                        }
+                        else {
+                            ts.Debug.assert((base.flags & 98304 /* Accessor */) !== 0);
+                            ts.Debug.assert((derived.flags & 8192 /* Method */) !== 0);
+                            errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+                        }
+                        error(derived.valueDeclaration.name, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
+                    }
+                }
+            }
+        }
+        function isAccessor(kind) {
+            return kind === 149 /* GetAccessor */ || kind === 150 /* SetAccessor */;
+        }
+        function areTypeParametersIdentical(list1, list2) {
+            if (!list1 && !list2) {
+                return true;
+            }
+            if (!list1 || !list2 || list1.length !== list2.length) {
+                return false;
+            }
+            // TypeScript 1.0 spec (April 2014):
+            // When a generic interface has multiple declarations,  all declarations must have identical type parameter
+            // lists, i.e. identical type parameter names with identical constraints in identical order.
+            for (var i = 0, len = list1.length; i < len; i++) {
+                var tp1 = list1[i];
+                var tp2 = list2[i];
+                if (tp1.name.text !== tp2.name.text) {
+                    return false;
+                }
+                if (!tp1.constraint && !tp2.constraint) {
+                    continue;
+                }
+                if (!tp1.constraint || !tp2.constraint) {
+                    return false;
+                }
+                if (!isTypeIdenticalTo(getTypeFromTypeNode(tp1.constraint), getTypeFromTypeNode(tp2.constraint))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        function checkInheritedPropertiesAreIdentical(type, typeNode) {
+            var baseTypes = getBaseTypes(type);
+            if (baseTypes.length < 2) {
+                return true;
+            }
+            var seen = {};
+            ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; });
+            var ok = true;
+            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+                var base = baseTypes_2[_i];
+                var properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
+                for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) {
+                    var prop = properties_4[_a];
+                    if (!ts.hasProperty(seen, prop.name)) {
+                        seen[prop.name] = { prop: prop, containingType: base };
+                    }
+                    else {
+                        var existing = seen[prop.name];
+                        var isInheritedProperty = existing.containingType !== type;
+                        if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
+                            ok = false;
+                            var typeName1 = typeToString(existing.containingType);
+                            var typeName2 = typeToString(base);
+                            var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
+                            errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
+                            diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo));
+                        }
+                    }
+                }
+            }
+            return ok;
+        }
+        function checkInterfaceDeclaration(node) {
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node);
+            checkTypeParameters(node.typeParameters);
+            if (produceDiagnostics) {
+                checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0);
+                checkExportsOnMergedDeclarations(node);
+                var symbol = getSymbolOfNode(node);
+                checkTypeParameterListsIdentical(node, symbol);
+                // Only check this symbol once
+                var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 222 /* InterfaceDeclaration */);
+                if (node === firstInterfaceDecl) {
+                    var type = getDeclaredTypeOfSymbol(symbol);
+                    var typeWithThis = getTypeWithThisArgument(type);
+                    // run subsequent checks only if first set succeeded
+                    if (checkInheritedPropertiesAreIdentical(type, node.name)) {
+                        for (var _i = 0, _a = getBaseTypes(type); _i < _a.length; _i++) {
+                            var baseType = _a[_i];
+                            checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1);
+                        }
+                        checkIndexConstraints(type);
+                    }
+                }
+                checkObjectTypeForDuplicateDeclarations(node);
+            }
+            ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) {
+                if (!ts.isSupportedExpressionWithTypeArguments(heritageElement)) {
+                    error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
+                }
+                checkTypeReferenceNode(heritageElement);
+            });
+            ts.forEach(node.members, checkSourceElement);
+            if (produceDiagnostics) {
+                checkTypeForDuplicateIndexSignatures(node);
+                checkUnusedTypeParameters(node);
+            }
+        }
+        function checkTypeAliasDeclaration(node) {
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node);
+            checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0);
+            checkSourceElement(node.type);
+        }
+        function computeEnumMemberValues(node) {
+            var nodeLinks = getNodeLinks(node);
+            if (!(nodeLinks.flags & 16384 /* EnumValuesComputed */)) {
+                var enumSymbol = getSymbolOfNode(node);
+                var enumType = getDeclaredTypeOfSymbol(enumSymbol);
+                var autoValue = 0; // set to undefined when enum member is non-constant
+                var ambient = ts.isInAmbientContext(node);
+                var enumIsConst = ts.isConst(node);
+                for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+                    var member = _a[_i];
+                    if (isComputedNonLiteralName(member.name)) {
+                        error(member.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums);
+                    }
+                    else {
+                        var text = getTextOfPropertyName(member.name);
+                        if (isNumericLiteralName(text)) {
+                            error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name);
+                        }
+                    }
+                    var previousEnumMemberIsNonConstant = autoValue === undefined;
+                    var initializer = member.initializer;
+                    if (initializer) {
+                        autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient);
+                    }
+                    else if (ambient && !enumIsConst) {
+                        // In ambient enum declarations that specify no const modifier, enum member declarations
+                        // that omit a value are considered computed members (as opposed to having auto-incremented values assigned).
+                        autoValue = undefined;
+                    }
+                    else if (previousEnumMemberIsNonConstant) {
+                        // If the member declaration specifies no value, the member is considered a constant enum member.
+                        // If the member is the first member in the enum declaration, it is assigned the value zero.
+                        // Otherwise, it is assigned the value of the immediately preceding member plus one,
+                        // and an error occurs if the immediately preceding member is not a constant enum member
+                        error(member.name, ts.Diagnostics.Enum_member_must_have_initializer);
+                    }
+                    if (autoValue !== undefined) {
+                        getNodeLinks(member).enumMemberValue = autoValue;
+                        autoValue++;
+                    }
+                }
+                nodeLinks.flags |= 16384 /* EnumValuesComputed */;
+            }
+            function computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient) {
+                // Controls if error should be reported after evaluation of constant value is completed
+                // Can be false if another more precise error was already reported during evaluation.
+                var reportError = true;
+                var value = evalConstant(initializer);
+                if (reportError) {
+                    if (value === undefined) {
+                        if (enumIsConst) {
+                            error(initializer, ts.Diagnostics.In_const_enum_declarations_member_initializer_must_be_constant_expression);
+                        }
+                        else if (ambient) {
+                            error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
+                        }
+                        else {
+                            // Only here do we need to check that the initializer is assignable to the enum type.
+                            checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined);
+                        }
+                    }
+                    else if (enumIsConst) {
+                        if (isNaN(value)) {
+                            error(initializer, ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN);
+                        }
+                        else if (!isFinite(value)) {
+                            error(initializer, ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
+                        }
+                    }
+                }
+                return value;
+                function evalConstant(e) {
+                    switch (e.kind) {
+                        case 185 /* PrefixUnaryExpression */:
+                            var value_1 = evalConstant(e.operand);
+                            if (value_1 === undefined) {
+                                return undefined;
+                            }
+                            switch (e.operator) {
+                                case 35 /* PlusToken */: return value_1;
+                                case 36 /* MinusToken */: return -value_1;
+                                case 50 /* TildeToken */: return ~value_1;
+                            }
+                            return undefined;
+                        case 187 /* BinaryExpression */:
+                            var left = evalConstant(e.left);
+                            if (left === undefined) {
+                                return undefined;
+                            }
+                            var right = evalConstant(e.right);
+                            if (right === undefined) {
+                                return undefined;
+                            }
+                            switch (e.operatorToken.kind) {
+                                case 47 /* BarToken */: return left | right;
+                                case 46 /* AmpersandToken */: return left & right;
+                                case 44 /* GreaterThanGreaterThanToken */: return left >> right;
+                                case 45 /* GreaterThanGreaterThanGreaterThanToken */: return left >>> right;
+                                case 43 /* LessThanLessThanToken */: return left << right;
+                                case 48 /* CaretToken */: return left ^ right;
+                                case 37 /* AsteriskToken */: return left * right;
+                                case 39 /* SlashToken */: return left / right;
+                                case 35 /* PlusToken */: return left + right;
+                                case 36 /* MinusToken */: return left - right;
+                                case 40 /* PercentToken */: return left % right;
+                            }
+                            return undefined;
+                        case 8 /* NumericLiteral */:
+                            return +e.text;
+                        case 178 /* ParenthesizedExpression */:
+                            return evalConstant(e.expression);
+                        case 69 /* Identifier */:
+                        case 173 /* ElementAccessExpression */:
+                        case 172 /* PropertyAccessExpression */:
+                            var member = initializer.parent;
+                            var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent));
+                            var enumType_1;
+                            var propertyName = void 0;
+                            if (e.kind === 69 /* Identifier */) {
+                                // unqualified names can refer to member that reside in different declaration of the enum so just doing name resolution won't work.
+                                // instead pick current enum type and later try to fetch member from the type
+                                enumType_1 = currentType;
+                                propertyName = e.text;
+                            }
+                            else {
+                                var expression = void 0;
+                                if (e.kind === 173 /* ElementAccessExpression */) {
+                                    if (e.argumentExpression === undefined ||
+                                        e.argumentExpression.kind !== 9 /* StringLiteral */) {
+                                        return undefined;
+                                    }
+                                    expression = e.expression;
+                                    propertyName = e.argumentExpression.text;
+                                }
+                                else {
+                                    expression = e.expression;
+                                    propertyName = e.name.text;
+                                }
+                                // expression part in ElementAccess\PropertyAccess should be either identifier or dottedName
+                                var current = expression;
+                                while (current) {
+                                    if (current.kind === 69 /* Identifier */) {
+                                        break;
+                                    }
+                                    else if (current.kind === 172 /* PropertyAccessExpression */) {
+                                        current = current.expression;
+                                    }
+                                    else {
+                                        return undefined;
+                                    }
+                                }
+                                enumType_1 = checkExpression(expression);
+                                // allow references to constant members of other enums
+                                if (!(enumType_1.symbol && (enumType_1.symbol.flags & 384 /* Enum */))) {
+                                    return undefined;
+                                }
+                            }
+                            if (propertyName === undefined) {
+                                return undefined;
+                            }
+                            var property = getPropertyOfObjectType(enumType_1, propertyName);
+                            if (!property || !(property.flags & 8 /* EnumMember */)) {
+                                return undefined;
+                            }
+                            var propertyDecl = property.valueDeclaration;
+                            // self references are illegal
+                            if (member === propertyDecl) {
+                                return undefined;
+                            }
+                            // illegal case: forward reference
+                            if (!isBlockScopedNameDeclaredBeforeUse(propertyDecl, member)) {
+                                reportError = false;
+                                error(e, ts.Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
+                                return undefined;
+                            }
+                            return getNodeLinks(propertyDecl).enumMemberValue;
+                    }
+                }
+            }
+        }
+        function checkEnumDeclaration(node) {
+            if (!produceDiagnostics) {
+                return;
+            }
+            // Grammar checking
+            checkGrammarDecorators(node) || checkGrammarModifiers(node);
+            checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0);
+            checkCollisionWithCapturedThisVariable(node, node.name);
+            checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+            checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+            checkExportsOnMergedDeclarations(node);
+            computeEnumMemberValues(node);
+            var enumIsConst = ts.isConst(node);
+            if (compilerOptions.isolatedModules && enumIsConst && ts.isInAmbientContext(node)) {
+                error(node.name, ts.Diagnostics.Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided);
+            }
+            // Spec 2014 - Section 9.3:
+            // It isn't possible for one enum declaration to continue the automatic numbering sequence of another,
+            // and when an enum type has multiple declarations, only one declaration is permitted to omit a value
+            // for the first member.
+            //
+            // Only perform this check once per symbol
+            var enumSymbol = getSymbolOfNode(node);
+            var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind);
+            if (node === firstDeclaration) {
+                if (enumSymbol.declarations.length > 1) {
+                    // check that const is placed\omitted on all enum declarations
+                    ts.forEach(enumSymbol.declarations, function (decl) {
+                        if (ts.isConstEnumDeclaration(decl) !== enumIsConst) {
+                            error(decl.name, ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
+                        }
+                    });
+                }
+                var seenEnumMissingInitialInitializer_1 = false;
+                ts.forEach(enumSymbol.declarations, function (declaration) {
+                    // return true if we hit a violation of the rule, false otherwise
+                    if (declaration.kind !== 224 /* EnumDeclaration */) {
+                        return false;
+                    }
+                    var enumDeclaration = declaration;
+                    if (!enumDeclaration.members.length) {
+                        return false;
+                    }
+                    var firstEnumMember = enumDeclaration.members[0];
+                    if (!firstEnumMember.initializer) {
+                        if (seenEnumMissingInitialInitializer_1) {
+                            error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
+                        }
+                        else {
+                            seenEnumMissingInitialInitializer_1 = true;
+                        }
+                    }
+                });
+            }
+        }
+        function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
+            var declarations = symbol.declarations;
+            for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                var declaration = declarations_5[_i];
+                if ((declaration.kind === 221 /* ClassDeclaration */ ||
+                    (declaration.kind === 220 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) &&
+                    !ts.isInAmbientContext(declaration)) {
+                    return declaration;
+                }
+            }
+            return undefined;
+        }
+        function inSameLexicalScope(node1, node2) {
+            var container1 = ts.getEnclosingBlockScopeContainer(node1);
+            var container2 = ts.getEnclosingBlockScopeContainer(node2);
+            if (isGlobalSourceFile(container1)) {
+                return isGlobalSourceFile(container2);
+            }
+            else if (isGlobalSourceFile(container2)) {
+                return false;
+            }
+            else {
+                return container1 === container2;
+            }
+        }
+        function checkModuleDeclaration(node) {
+            if (produceDiagnostics) {
+                // Grammar checking
+                var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
+                var inAmbientContext = ts.isInAmbientContext(node);
+                if (isGlobalAugmentation && !inAmbientContext) {
+                    error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
+                }
+                var isAmbientExternalModule = ts.isAmbientModule(node);
+                var contextErrorMessage = isAmbientExternalModule
+                    ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
+                    : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
+                if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
+                    // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors.
+                    return;
+                }
+                if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node)) {
+                    if (!inAmbientContext && node.name.kind === 9 /* StringLiteral */) {
+                        grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names);
+                    }
+                }
+                checkCollisionWithCapturedThisVariable(node, node.name);
+                checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+                checkExportsOnMergedDeclarations(node);
+                var symbol = getSymbolOfNode(node);
+                // The following checks only apply on a non-ambient instantiated module declaration.
+                if (symbol.flags & 512 /* ValueModule */
+                    && symbol.declarations.length > 1
+                    && !inAmbientContext
+                    && ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.isolatedModules)) {
+                    var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
+                    if (firstNonAmbientClassOrFunc) {
+                        if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
+                            error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
+                        }
+                        else if (node.pos < firstNonAmbientClassOrFunc.pos) {
+                            error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
+                        }
+                    }
+                    // if the module merges with a class declaration in the same lexical scope,
+                    // we need to track this to ensure the correct emit.
+                    var mergedClass = ts.getDeclarationOfKind(symbol, 221 /* ClassDeclaration */);
+                    if (mergedClass &&
+                        inSameLexicalScope(node, mergedClass)) {
+                        getNodeLinks(node).flags |= 32768 /* LexicalModuleMergesWithClass */;
+                    }
+                }
+                if (isAmbientExternalModule) {
+                    if (ts.isExternalModuleAugmentation(node)) {
+                        // body of the augmentation should be checked for consistency only if augmentation was applied to its target (either global scope or module)
+                        // otherwise we'll be swamped in cascading errors.
+                        // We can detect if augmentation was applied using following rules:
+                        // - augmentation for a global scope is always applied
+                        // - augmentation for some external module is applied if symbol for augmentation is merged (it was combined with target module).
+                        var checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & 33554432 /* Merged */);
+                        if (checkBody && node.body) {
+                            // body of ambient external module is always a module block
+                            for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
+                                var statement = _a[_i];
+                                checkModuleAugmentationElement(statement, isGlobalAugmentation);
+                            }
+                        }
+                    }
+                    else if (isGlobalSourceFile(node.parent)) {
+                        if (isGlobalAugmentation) {
+                            error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
+                        }
+                        else if (ts.isExternalModuleNameRelative(node.name.text)) {
+                            error(node.name, ts.Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name);
+                        }
+                    }
+                    else {
+                        if (isGlobalAugmentation) {
+                            error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
+                        }
+                        else {
+                            // Node is not an augmentation and is not located on the script level.
+                            // This means that this is declaration of ambient module that is located in other module or namespace which is prohibited.
+                            error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces);
+                        }
+                    }
+                }
+            }
+            if (compilerOptions.noImplicitAny && !node.body) {
+                // Ambient shorthand module is an implicit any
+                reportImplicitAnyError(node, anyType);
+            }
+            if (node.body) {
+                checkSourceElement(node.body);
+                if (!ts.isGlobalScopeAugmentation(node)) {
+                    registerForUnusedIdentifiersCheck(node);
+                }
+            }
+        }
+        function checkModuleAugmentationElement(node, isGlobalAugmentation) {
+            switch (node.kind) {
+                case 200 /* VariableStatement */:
+                    // error each individual name in variable statement instead of marking the entire variable statement
+                    for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
+                        var decl = _a[_i];
+                        checkModuleAugmentationElement(decl, isGlobalAugmentation);
+                    }
+                    break;
+                case 235 /* ExportAssignment */:
+                case 236 /* ExportDeclaration */:
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations);
+                    break;
+                case 229 /* ImportEqualsDeclaration */:
+                case 230 /* ImportDeclaration */:
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
+                    break;
+                case 169 /* BindingElement */:
+                case 218 /* VariableDeclaration */:
+                    var name_19 = node.name;
+                    if (ts.isBindingPattern(name_19)) {
+                        for (var _b = 0, _c = name_19.elements; _b < _c.length; _b++) {
+                            var el = _c[_b];
+                            // mark individual names in binding pattern
+                            checkModuleAugmentationElement(el, isGlobalAugmentation);
+                        }
+                        break;
+                    }
+                // fallthrough
+                case 221 /* ClassDeclaration */:
+                case 224 /* EnumDeclaration */:
+                case 220 /* FunctionDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 225 /* ModuleDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                    if (isGlobalAugmentation) {
+                        return;
+                    }
+                    var symbol = getSymbolOfNode(node);
+                    if (symbol) {
+                        // module augmentations cannot introduce new names on the top level scope of the module
+                        // this is done it two steps
+                        // 1. quick check - if symbol for node is not merged - this is local symbol to this augmentation - report error
+                        // 2. main check - report error if value declaration of the parent symbol is module augmentation)
+                        var reportError = !(symbol.flags & 33554432 /* Merged */);
+                        if (!reportError) {
+                            // symbol should not originate in augmentation
+                            reportError = ts.isExternalModuleAugmentation(symbol.parent.declarations[0]);
+                        }
+                    }
+                    break;
+            }
+        }
+        function getFirstIdentifier(node) {
+            while (true) {
+                if (node.kind === 139 /* QualifiedName */) {
+                    node = node.left;
+                }
+                else if (node.kind === 172 /* PropertyAccessExpression */) {
+                    node = node.expression;
+                }
+                else {
+                    break;
+                }
+            }
+            ts.Debug.assert(node.kind === 69 /* Identifier */);
+            return node;
+        }
+        function checkExternalImportOrExportDeclaration(node) {
+            var moduleName = ts.getExternalModuleName(node);
+            if (!ts.nodeIsMissing(moduleName) && moduleName.kind !== 9 /* StringLiteral */) {
+                error(moduleName, ts.Diagnostics.String_literal_expected);
+                return false;
+            }
+            var inAmbientExternalModule = node.parent.kind === 226 /* ModuleBlock */ && ts.isAmbientModule(node.parent.parent);
+            if (node.parent.kind !== 256 /* SourceFile */ && !inAmbientExternalModule) {
+                error(moduleName, node.kind === 236 /* ExportDeclaration */ ?
+                    ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace :
+                    ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module);
+                return false;
+            }
+            if (inAmbientExternalModule && ts.isExternalModuleNameRelative(moduleName.text)) {
+                // we have already reported errors on top level imports\exports in external module augmentations in checkModuleDeclaration
+                // no need to do this again.
+                if (!isTopLevelInExternalModuleAugmentation(node)) {
+                    // TypeScript 1.0 spec (April 2013): 12.1.6
+                    // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference
+                    // other external modules only through top - level external module names.
+                    // Relative external module names are not permitted.
+                    error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name);
+                    return false;
+                }
+            }
+            return true;
+        }
+        function checkAliasSymbol(node) {
+            var symbol = getSymbolOfNode(node);
+            var target = resolveAlias(symbol);
+            if (target !== unknownSymbol) {
+                // For external modules symbol represent local symbol for an alias.
+                // This local symbol will merge any other local declarations (excluding other aliases)
+                // and symbol.flags will contains combined representation for all merged declaration.
+                // Based on symbol.flags we can compute a set of excluded meanings (meaning that resolved alias should not have,
+                // otherwise it will conflict with some local declaration). Note that in addition to normal flags we include matching SymbolFlags.Export*
+                // in order to prevent collisions with declarations that were exported from the current module (they still contribute to local names).
+                var excludedMeanings = (symbol.flags & (107455 /* Value */ | 1048576 /* ExportValue */) ? 107455 /* Value */ : 0) |
+                    (symbol.flags & 793056 /* Type */ ? 793056 /* Type */ : 0) |
+                    (symbol.flags & 1536 /* Namespace */ ? 1536 /* Namespace */ : 0);
+                if (target.flags & excludedMeanings) {
+                    var message = node.kind === 238 /* ExportSpecifier */ ?
+                        ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
+                        ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
+                    error(node, message, symbolToString(symbol));
+                }
+            }
+        }
+        function checkImportBinding(node) {
+            checkCollisionWithCapturedThisVariable(node, node.name);
+            checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+            checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+            checkAliasSymbol(node);
+        }
+        function checkImportDeclaration(node) {
+            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+                // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
+                return;
+            }
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1023 /* Modifier */)) {
+                grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
+            }
+            if (checkExternalImportOrExportDeclaration(node)) {
+                var importClause = node.importClause;
+                if (importClause) {
+                    if (importClause.name) {
+                        checkImportBinding(importClause);
+                    }
+                    if (importClause.namedBindings) {
+                        if (importClause.namedBindings.kind === 232 /* NamespaceImport */) {
+                            checkImportBinding(importClause.namedBindings);
+                        }
+                        else {
+                            ts.forEach(importClause.namedBindings.elements, checkImportBinding);
+                        }
+                    }
+                }
+            }
+        }
+        function checkImportEqualsDeclaration(node) {
+            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+                // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
+                return;
+            }
+            checkGrammarDecorators(node) || checkGrammarModifiers(node);
+            if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
+                checkImportBinding(node);
+                if (node.flags & 1 /* Export */) {
+                    markExportAsReferenced(node);
+                }
+                if (ts.isInternalModuleImportEqualsDeclaration(node)) {
+                    var target = resolveAlias(getSymbolOfNode(node));
+                    if (target !== unknownSymbol) {
+                        if (target.flags & 107455 /* Value */) {
+                            // Target is a value symbol, check that it is not hidden by a local declaration with the same name
+                            var moduleName = getFirstIdentifier(node.moduleReference);
+                            if (!(resolveEntityName(moduleName, 107455 /* Value */ | 1536 /* Namespace */).flags & 1536 /* Namespace */)) {
+                                error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
+                            }
+                        }
+                        if (target.flags & 793056 /* Type */) {
+                            checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
+                        }
+                    }
+                }
+                else {
+                    if (modulekind === ts.ModuleKind.ES6 && !ts.isInAmbientContext(node)) {
+                        // Import equals declaration is deprecated in es6 or above
+                        grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
+                    }
+                }
+            }
+        }
+        function checkExportDeclaration(node) {
+            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
+                // If we hit an export in an illegal context, just bail out to avoid cascading errors.
+                return;
+            }
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1023 /* Modifier */)) {
+                grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
+            }
+            if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
+                if (node.exportClause) {
+                    // export { x, y }
+                    // export { x, y } from "foo"
+                    ts.forEach(node.exportClause.elements, checkExportSpecifier);
+                    var inAmbientExternalModule = node.parent.kind === 226 /* ModuleBlock */ && ts.isAmbientModule(node.parent.parent);
+                    if (node.parent.kind !== 256 /* SourceFile */ && !inAmbientExternalModule) {
+                        error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
+                    }
+                }
+                else {
+                    // export * from "foo"
+                    var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+                    if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) {
+                        error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
+                    }
+                }
+            }
+        }
+        function checkGrammarModuleElementContext(node, errorMessage) {
+            if (node.parent.kind !== 256 /* SourceFile */ && node.parent.kind !== 226 /* ModuleBlock */ && node.parent.kind !== 225 /* ModuleDeclaration */) {
+                return grammarErrorOnFirstToken(node, errorMessage);
+            }
+        }
+        function checkExportSpecifier(node) {
+            checkAliasSymbol(node);
+            if (!node.parent.parent.moduleSpecifier) {
+                var exportedName = node.propertyName || node.name;
+                // find immediate value referenced by exported name (SymbolFlags.Alias is set so we don't chase down aliases)
+                var symbol = resolveName(exportedName, exportedName.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */, 
+                /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                if (symbol && (symbol === undefinedSymbol || isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
+                    error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, exportedName.text);
+                }
+                else {
+                    markExportAsReferenced(node);
+                }
+            }
+        }
+        function checkExportAssignment(node) {
+            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) {
+                // If we hit an export assignment in an illegal context, just bail out to avoid cascading errors.
+                return;
+            }
+            var container = node.parent.kind === 256 /* SourceFile */ ? node.parent : node.parent.parent;
+            if (container.kind === 225 /* ModuleDeclaration */ && !ts.isAmbientModule(container)) {
+                error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
+                return;
+            }
+            // Grammar checking
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1023 /* Modifier */)) {
+                grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
+            }
+            if (node.expression.kind === 69 /* Identifier */) {
+                markExportAsReferenced(node);
+            }
+            else {
+                checkExpressionCached(node.expression);
+            }
+            checkExternalModuleExports(container);
+            if (node.isExportEquals && !ts.isInAmbientContext(node)) {
+                if (modulekind === ts.ModuleKind.ES6) {
+                    // export assignment is not supported in es6 modules
+                    grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_export_default_or_another_module_format_instead);
+                }
+                else if (modulekind === ts.ModuleKind.System) {
+                    // system modules does not support export assignment
+                    grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
+                }
+            }
+        }
+        function hasExportedMembers(moduleSymbol) {
+            for (var id in moduleSymbol.exports) {
+                if (id !== "export=") {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function checkExternalModuleExports(node) {
+            var moduleSymbol = getSymbolOfNode(node);
+            var links = getSymbolLinks(moduleSymbol);
+            if (!links.exportsChecked) {
+                var exportEqualsSymbol = moduleSymbol.exports["export="];
+                if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
+                    var declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
+                    if (!isTopLevelInExternalModuleAugmentation(declaration)) {
+                        error(declaration, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
+                    }
+                }
+                // Checks for export * conflicts
+                var exports = getExportsOfModule(moduleSymbol);
+                for (var id in exports) {
+                    if (id === "__export") {
+                        continue;
+                    }
+                    var _a = exports[id], declarations = _a.declarations, flags = _a.flags;
+                    // ECMA262: 15.2.1.1 It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
+                    // (TS Exceptions: namespaces, function overloads, enums, and interfaces)
+                    if (flags & (1536 /* Namespace */ | 64 /* Interface */ | 384 /* Enum */)) {
+                        continue;
+                    }
+                    var exportedDeclarationsCount = ts.countWhere(declarations, isNotOverload);
+                    if (flags & 524288 /* TypeAlias */ && exportedDeclarationsCount <= 2) {
+                        // it is legal to merge type alias with other values
+                        // so count should be either 1 (just type alias) or 2 (type alias + merged value)
+                        continue;
+                    }
+                    if (exportedDeclarationsCount > 1) {
+                        for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                            var declaration = declarations_6[_i];
+                            if (isNotOverload(declaration)) {
+                                diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Cannot_redeclare_exported_variable_0, id));
+                            }
+                        }
+                    }
+                }
+                links.exportsChecked = true;
+            }
+            function isNotOverload(declaration) {
+                return declaration.kind !== 220 /* FunctionDeclaration */ || !!declaration.body;
+            }
+        }
+        function checkSourceElement(node) {
+            if (!node) {
+                return;
+            }
+            var kind = node.kind;
+            if (cancellationToken) {
+                // Only bother checking on a few construct kinds.  We don't want to be excessively
+                // hitting the cancellation token on every node we check.
+                switch (kind) {
+                    case 225 /* ModuleDeclaration */:
+                    case 221 /* ClassDeclaration */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 220 /* FunctionDeclaration */:
+                        cancellationToken.throwIfCancellationRequested();
+                }
+            }
+            switch (kind) {
+                case 141 /* TypeParameter */:
+                    return checkTypeParameter(node);
+                case 142 /* Parameter */:
+                    return checkParameter(node);
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    return checkPropertyDeclaration(node);
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                    return checkSignatureDeclaration(node);
+                case 153 /* IndexSignature */:
+                    return checkSignatureDeclaration(node);
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                    return checkMethodDeclaration(node);
+                case 148 /* Constructor */:
+                    return checkConstructorDeclaration(node);
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                    return checkAccessorDeclaration(node);
+                case 155 /* TypeReference */:
+                    return checkTypeReferenceNode(node);
+                case 154 /* TypePredicate */:
+                    return checkTypePredicate(node);
+                case 158 /* TypeQuery */:
+                    return checkTypeQuery(node);
+                case 159 /* TypeLiteral */:
+                    return checkTypeLiteral(node);
+                case 160 /* ArrayType */:
+                    return checkArrayType(node);
+                case 161 /* TupleType */:
+                    return checkTupleType(node);
+                case 162 /* UnionType */:
+                case 163 /* IntersectionType */:
+                    return checkUnionOrIntersectionType(node);
+                case 164 /* ParenthesizedType */:
+                    return checkSourceElement(node.type);
+                case 220 /* FunctionDeclaration */:
+                    return checkFunctionDeclaration(node);
+                case 199 /* Block */:
+                case 226 /* ModuleBlock */:
+                    return checkBlock(node);
+                case 200 /* VariableStatement */:
+                    return checkVariableStatement(node);
+                case 202 /* ExpressionStatement */:
+                    return checkExpressionStatement(node);
+                case 203 /* IfStatement */:
+                    return checkIfStatement(node);
+                case 204 /* DoStatement */:
+                    return checkDoStatement(node);
+                case 205 /* WhileStatement */:
+                    return checkWhileStatement(node);
+                case 206 /* ForStatement */:
+                    return checkForStatement(node);
+                case 207 /* ForInStatement */:
+                    return checkForInStatement(node);
+                case 208 /* ForOfStatement */:
+                    return checkForOfStatement(node);
+                case 209 /* ContinueStatement */:
+                case 210 /* BreakStatement */:
+                    return checkBreakOrContinueStatement(node);
+                case 211 /* ReturnStatement */:
+                    return checkReturnStatement(node);
+                case 212 /* WithStatement */:
+                    return checkWithStatement(node);
+                case 213 /* SwitchStatement */:
+                    return checkSwitchStatement(node);
+                case 214 /* LabeledStatement */:
+                    return checkLabeledStatement(node);
+                case 215 /* ThrowStatement */:
+                    return checkThrowStatement(node);
+                case 216 /* TryStatement */:
+                    return checkTryStatement(node);
+                case 218 /* VariableDeclaration */:
+                    return checkVariableDeclaration(node);
+                case 169 /* BindingElement */:
+                    return checkBindingElement(node);
+                case 221 /* ClassDeclaration */:
+                    return checkClassDeclaration(node);
+                case 222 /* InterfaceDeclaration */:
+                    return checkInterfaceDeclaration(node);
+                case 223 /* TypeAliasDeclaration */:
+                    return checkTypeAliasDeclaration(node);
+                case 224 /* EnumDeclaration */:
+                    return checkEnumDeclaration(node);
+                case 225 /* ModuleDeclaration */:
+                    return checkModuleDeclaration(node);
+                case 230 /* ImportDeclaration */:
+                    return checkImportDeclaration(node);
+                case 229 /* ImportEqualsDeclaration */:
+                    return checkImportEqualsDeclaration(node);
+                case 236 /* ExportDeclaration */:
+                    return checkExportDeclaration(node);
+                case 235 /* ExportAssignment */:
+                    return checkExportAssignment(node);
+                case 201 /* EmptyStatement */:
+                    checkGrammarStatementInAmbientContext(node);
+                    return;
+                case 217 /* DebuggerStatement */:
+                    checkGrammarStatementInAmbientContext(node);
+                    return;
+                case 239 /* MissingDeclaration */:
+                    return checkMissingDeclaration(node);
+            }
+        }
+        // Function and class expression bodies are checked after all statements in the enclosing body. This is
+        // to ensure constructs like the following are permitted:
+        //     const foo = function () {
+        //        const s = foo();
+        //        return "hello";
+        //     }
+        // Here, performing a full type check of the body of the function expression whilst in the process of
+        // determining the type of foo would cause foo to be given type any because of the recursive reference.
+        // Delaying the type check of the body ensures foo has been assigned a type.
+        function checkNodeDeferred(node) {
+            if (deferredNodes) {
+                deferredNodes.push(node);
+            }
+        }
+        function checkDeferredNodes() {
+            for (var _i = 0, deferredNodes_1 = deferredNodes; _i < deferredNodes_1.length; _i++) {
+                var node = deferredNodes_1[_i];
+                switch (node.kind) {
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        checkFunctionExpressionOrObjectLiteralMethodDeferred(node);
+                        break;
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        checkAccessorDeferred(node);
+                        break;
+                    case 192 /* ClassExpression */:
+                        checkClassExpressionDeferred(node);
+                        break;
+                }
+            }
+        }
+        function checkSourceFile(node) {
+            var start = new Date().getTime();
+            checkSourceFileWorker(node);
+            ts.checkTime += new Date().getTime() - start;
+        }
+        // Fully type check a source file and collect the relevant diagnostics.
+        function checkSourceFileWorker(node) {
+            var links = getNodeLinks(node);
+            if (!(links.flags & 1 /* TypeChecked */)) {
+                // If skipLibCheck is enabled, skip type checking if file is a declaration file.
+                // If skipDefaultLibCheck is enabled, skip type checking if file contains a
+                // '/// <reference no-default-lib="true"/>' directive.
+                if (compilerOptions.skipLibCheck && node.isDeclarationFile || compilerOptions.skipDefaultLibCheck && node.hasNoDefaultLib) {
+                    return;
+                }
+                // Grammar checking
+                checkGrammarSourceFile(node);
+                potentialThisCollisions.length = 0;
+                deferredNodes = [];
+                deferredUnusedIdentifierNodes = produceDiagnostics && noUnusedIdentifiers ? [] : undefined;
+                ts.forEach(node.statements, checkSourceElement);
+                checkDeferredNodes();
+                if (ts.isExternalModule(node)) {
+                    registerForUnusedIdentifiersCheck(node);
+                }
+                if (!node.isDeclarationFile) {
+                    checkUnusedIdentifiers();
+                }
+                deferredNodes = undefined;
+                deferredUnusedIdentifierNodes = undefined;
+                if (ts.isExternalOrCommonJsModule(node)) {
+                    checkExternalModuleExports(node);
+                }
+                if (potentialThisCollisions.length) {
+                    ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope);
+                    potentialThisCollisions.length = 0;
+                }
+                links.flags |= 1 /* TypeChecked */;
+            }
+        }
+        function getDiagnostics(sourceFile, ct) {
+            try {
+                // Record the cancellation token so it can be checked later on during checkSourceElement.
+                // Do this in a finally block so we can ensure that it gets reset back to nothing after
+                // this call is done.
+                cancellationToken = ct;
+                return getDiagnosticsWorker(sourceFile);
+            }
+            finally {
+                cancellationToken = undefined;
+            }
+        }
+        function getDiagnosticsWorker(sourceFile) {
+            throwIfNonDiagnosticsProducing();
+            if (sourceFile) {
+                checkSourceFile(sourceFile);
+                return diagnostics.getDiagnostics(sourceFile.fileName);
+            }
+            ts.forEach(host.getSourceFiles(), checkSourceFile);
+            return diagnostics.getDiagnostics();
+        }
+        function getGlobalDiagnostics() {
+            throwIfNonDiagnosticsProducing();
+            return diagnostics.getGlobalDiagnostics();
+        }
+        function throwIfNonDiagnosticsProducing() {
+            if (!produceDiagnostics) {
+                throw new Error("Trying to get diagnostics from a type checker that does not produce them.");
+            }
+        }
+        // Language service support
+        function isInsideWithStatementBody(node) {
+            if (node) {
+                while (node.parent) {
+                    if (node.parent.kind === 212 /* WithStatement */ && node.parent.statement === node) {
+                        return true;
+                    }
+                    node = node.parent;
+                }
+            }
+            return false;
+        }
+        function getSymbolsInScope(location, meaning) {
+            var symbols = {};
+            var memberFlags = 0;
+            if (isInsideWithStatementBody(location)) {
+                // We cannot answer semantic questions within a with block, do not proceed any further
+                return [];
+            }
+            populateSymbols();
+            return symbolsToArray(symbols);
+            function populateSymbols() {
+                while (location) {
+                    if (location.locals && !isGlobalSourceFile(location)) {
+                        copySymbols(location.locals, meaning);
+                    }
+                    switch (location.kind) {
+                        case 256 /* SourceFile */:
+                            if (!ts.isExternalOrCommonJsModule(location)) {
+                                break;
+                            }
+                        case 225 /* ModuleDeclaration */:
+                            copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */);
+                            break;
+                        case 224 /* EnumDeclaration */:
+                            copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */);
+                            break;
+                        case 192 /* ClassExpression */:
+                            var className = location.name;
+                            if (className) {
+                                copySymbol(location.symbol, meaning);
+                            }
+                        // fall through; this fall-through is necessary because we would like to handle
+                        // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration
+                        case 221 /* ClassDeclaration */:
+                        case 222 /* InterfaceDeclaration */:
+                            // If we didn't come from static member of class or interface,
+                            // add the type parameters into the symbol table
+                            // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol.
+                            // Note: that the memberFlags come from previous iteration.
+                            if (!(memberFlags & 32 /* Static */)) {
+                                copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */);
+                            }
+                            break;
+                        case 179 /* FunctionExpression */:
+                            var funcName = location.name;
+                            if (funcName) {
+                                copySymbol(location.symbol, meaning);
+                            }
+                            break;
+                    }
+                    if (ts.introducesArgumentsExoticObject(location)) {
+                        copySymbol(argumentsSymbol, meaning);
+                    }
+                    memberFlags = location.flags;
+                    location = location.parent;
+                }
+                copySymbols(globals, meaning);
+            }
+            /**
+             * Copy the given symbol into symbol tables if the symbol has the given meaning
+             * and it doesn't already existed in the symbol table
+             * @param key a key for storing in symbol table; if undefined, use symbol.name
+             * @param symbol the symbol to be added into symbol table
+             * @param meaning meaning of symbol to filter by before adding to symbol table
+             */
+            function copySymbol(symbol, meaning) {
+                if (symbol.flags & meaning) {
+                    var id = symbol.name;
+                    // We will copy all symbol regardless of its reserved name because
+                    // symbolsToArray will check whether the key is a reserved name and
+                    // it will not copy symbol with reserved name to the array
+                    if (!ts.hasProperty(symbols, id)) {
+                        symbols[id] = symbol;
+                    }
+                }
+            }
+            function copySymbols(source, meaning) {
+                if (meaning) {
+                    for (var id in source) {
+                        var symbol = source[id];
+                        copySymbol(symbol, meaning);
+                    }
+                }
+            }
+        }
+        function isTypeDeclarationName(name) {
+            return name.kind === 69 /* Identifier */ &&
+                isTypeDeclaration(name.parent) &&
+                name.parent.name === name;
+        }
+        function isTypeDeclaration(node) {
+            switch (node.kind) {
+                case 141 /* TypeParameter */:
+                case 221 /* ClassDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                case 224 /* EnumDeclaration */:
+                    return true;
+            }
+        }
+        // True if the given identifier is part of a type reference
+        function isTypeReferenceIdentifier(entityName) {
+            var node = entityName;
+            while (node.parent && node.parent.kind === 139 /* QualifiedName */) {
+                node = node.parent;
+            }
+            return node.parent && (node.parent.kind === 155 /* TypeReference */ || node.parent.kind === 267 /* JSDocTypeReference */);
+        }
+        function isHeritageClauseElementIdentifier(entityName) {
+            var node = entityName;
+            while (node.parent && node.parent.kind === 172 /* PropertyAccessExpression */) {
+                node = node.parent;
+            }
+            return node.parent && node.parent.kind === 194 /* ExpressionWithTypeArguments */;
+        }
+        function forEachEnclosingClass(node, callback) {
+            var result;
+            while (true) {
+                node = ts.getContainingClass(node);
+                if (!node)
+                    break;
+                if (result = callback(node))
+                    break;
+            }
+            return result;
+        }
+        function isNodeWithinClass(node, classDeclaration) {
+            return !!forEachEnclosingClass(node, function (n) { return n === classDeclaration; });
+        }
+        function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) {
+            while (nodeOnRightSide.parent.kind === 139 /* QualifiedName */) {
+                nodeOnRightSide = nodeOnRightSide.parent;
+            }
+            if (nodeOnRightSide.parent.kind === 229 /* ImportEqualsDeclaration */) {
+                return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent;
+            }
+            if (nodeOnRightSide.parent.kind === 235 /* ExportAssignment */) {
+                return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent;
+            }
+            return undefined;
+        }
+        function isInRightSideOfImportOrExportAssignment(node) {
+            return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
+        }
+        function getSymbolOfEntityNameOrPropertyAccessExpression(entityName) {
+            if (ts.isDeclarationName(entityName)) {
+                return getSymbolOfNode(entityName.parent);
+            }
+            if (ts.isInJavaScriptFile(entityName) && entityName.parent.kind === 172 /* PropertyAccessExpression */) {
+                var specialPropertyAssignmentKind = ts.getSpecialPropertyAssignmentKind(entityName.parent.parent);
+                switch (specialPropertyAssignmentKind) {
+                    case 1 /* ExportsProperty */:
+                    case 3 /* PrototypeProperty */:
+                        return getSymbolOfNode(entityName.parent);
+                    case 4 /* ThisProperty */:
+                    case 2 /* ModuleExports */:
+                        return getSymbolOfNode(entityName.parent.parent);
+                    default:
+                }
+            }
+            if (entityName.parent.kind === 235 /* ExportAssignment */) {
+                return resolveEntityName(entityName, 
+                /*all meanings*/ 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */);
+            }
+            if (entityName.kind !== 172 /* PropertyAccessExpression */) {
+                if (isInRightSideOfImportOrExportAssignment(entityName)) {
+                    // Since we already checked for ExportAssignment, this really could only be an Import
+                    var importEqualsDeclaration = ts.getAncestor(entityName, 229 /* ImportEqualsDeclaration */);
+                    ts.Debug.assert(importEqualsDeclaration !== undefined);
+                    return getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
+                }
+            }
+            if (ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
+                entityName = entityName.parent;
+            }
+            if (isHeritageClauseElementIdentifier(entityName)) {
+                var meaning = 0 /* None */;
+                // In an interface or class, we're definitely interested in a type.
+                if (entityName.parent.kind === 194 /* ExpressionWithTypeArguments */) {
+                    meaning = 793056 /* Type */;
+                    // In a class 'extends' clause we are also looking for a value.
+                    if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
+                        meaning |= 107455 /* Value */;
+                    }
+                }
+                else {
+                    meaning = 1536 /* Namespace */;
+                }
+                meaning |= 8388608 /* Alias */;
+                return resolveEntityName(entityName, meaning);
+            }
+            else if (ts.isExpression(entityName)) {
+                if (ts.nodeIsMissing(entityName)) {
+                    // Missing entity name.
+                    return undefined;
+                }
+                if (entityName.kind === 69 /* Identifier */) {
+                    if (ts.isJSXTagName(entityName) && isJsxIntrinsicIdentifier(entityName)) {
+                        return getIntrinsicTagSymbol(entityName.parent);
+                    }
+                    return resolveEntityName(entityName, 107455 /* Value */, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
+                }
+                else if (entityName.kind === 172 /* PropertyAccessExpression */) {
+                    var symbol = getNodeLinks(entityName).resolvedSymbol;
+                    if (!symbol) {
+                        checkPropertyAccessExpression(entityName);
+                    }
+                    return getNodeLinks(entityName).resolvedSymbol;
+                }
+                else if (entityName.kind === 139 /* QualifiedName */) {
+                    var symbol = getNodeLinks(entityName).resolvedSymbol;
+                    if (!symbol) {
+                        checkQualifiedName(entityName);
+                    }
+                    return getNodeLinks(entityName).resolvedSymbol;
+                }
+            }
+            else if (isTypeReferenceIdentifier(entityName)) {
+                var meaning = (entityName.parent.kind === 155 /* TypeReference */ || entityName.parent.kind === 267 /* JSDocTypeReference */) ? 793056 /* Type */ : 1536 /* Namespace */;
+                return resolveEntityName(entityName, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
+            }
+            else if (entityName.parent.kind === 246 /* JsxAttribute */) {
+                return getJsxAttributePropertySymbol(entityName.parent);
+            }
+            if (entityName.parent.kind === 154 /* TypePredicate */) {
+                return resolveEntityName(entityName, /*meaning*/ 1 /* FunctionScopedVariable */);
+            }
+            // Do we want to return undefined here?
+            return undefined;
+        }
+        function getSymbolAtLocation(node) {
+            if (node.kind === 256 /* SourceFile */) {
+                return ts.isExternalModule(node) ? getMergedSymbol(node.symbol) : undefined;
+            }
+            if (isInsideWithStatementBody(node)) {
+                // We cannot answer semantic questions within a with block, do not proceed any further
+                return undefined;
+            }
+            if (ts.isDeclarationName(node)) {
+                // This is a declaration, call getSymbolOfNode
+                return getSymbolOfNode(node.parent);
+            }
+            else if (ts.isLiteralComputedPropertyDeclarationName(node)) {
+                return getSymbolOfNode(node.parent.parent);
+            }
+            if (node.kind === 69 /* Identifier */) {
+                if (isInRightSideOfImportOrExportAssignment(node)) {
+                    return getSymbolOfEntityNameOrPropertyAccessExpression(node);
+                }
+                else if (node.parent.kind === 169 /* BindingElement */ &&
+                    node.parent.parent.kind === 167 /* ObjectBindingPattern */ &&
+                    node === node.parent.propertyName) {
+                    var typeOfPattern = getTypeOfNode(node.parent.parent);
+                    var propertyDeclaration = typeOfPattern && getPropertyOfType(typeOfPattern, node.text);
+                    if (propertyDeclaration) {
+                        return propertyDeclaration;
+                    }
+                }
+            }
+            switch (node.kind) {
+                case 69 /* Identifier */:
+                case 172 /* PropertyAccessExpression */:
+                case 139 /* QualifiedName */:
+                    return getSymbolOfEntityNameOrPropertyAccessExpression(node);
+                case 97 /* ThisKeyword */:
+                    var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
+                    if (ts.isFunctionLike(container)) {
+                        var sig = getSignatureFromDeclaration(container);
+                        if (sig.thisParameter) {
+                            return sig.thisParameter;
+                        }
+                    }
+                // fallthrough
+                case 95 /* SuperKeyword */:
+                    var type = ts.isExpression(node) ? checkExpression(node) : getTypeFromTypeNode(node);
+                    return type.symbol;
+                case 165 /* ThisType */:
+                    return getTypeFromTypeNode(node).symbol;
+                case 121 /* ConstructorKeyword */:
+                    // constructor keyword for an overload, should take us to the definition if it exist
+                    var constructorDeclaration = node.parent;
+                    if (constructorDeclaration && constructorDeclaration.kind === 148 /* Constructor */) {
+                        return constructorDeclaration.parent.symbol;
+                    }
+                    return undefined;
+                case 9 /* StringLiteral */:
+                    // External module name in an import declaration
+                    if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) &&
+                        ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) ||
+                        ((node.parent.kind === 230 /* ImportDeclaration */ || node.parent.kind === 236 /* ExportDeclaration */) &&
+                            node.parent.moduleSpecifier === node)) {
+                        return resolveExternalModuleName(node, node);
+                    }
+                // Fall through
+                case 8 /* NumericLiteral */:
+                    // index access
+                    if (node.parent.kind === 173 /* ElementAccessExpression */ && node.parent.argumentExpression === node) {
+                        var objectType = checkExpression(node.parent.expression);
+                        if (objectType === unknownType)
+                            return undefined;
+                        var apparentType = getApparentType(objectType);
+                        if (apparentType === unknownType)
+                            return undefined;
+                        return getPropertyOfType(apparentType, node.text);
+                    }
+                    break;
+            }
+            return undefined;
+        }
+        function getShorthandAssignmentValueSymbol(location) {
+            // The function returns a value symbol of an identifier in the short-hand property assignment.
+            // This is necessary as an identifier in short-hand property assignment can contains two meaning:
+            // property name and property value.
+            if (location && location.kind === 254 /* ShorthandPropertyAssignment */) {
+                return resolveEntityName(location.name, 107455 /* Value */ | 8388608 /* Alias */);
+            }
+            return undefined;
+        }
+        /** Returns the target of an export specifier without following aliases */
+        function getExportSpecifierLocalTargetSymbol(node) {
+            return node.parent.parent.moduleSpecifier ?
+                getExternalModuleMember(node.parent.parent, node) :
+                resolveEntityName(node.propertyName || node.name, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */);
+        }
+        function getTypeOfNode(node) {
+            if (isInsideWithStatementBody(node)) {
+                // We cannot answer semantic questions within a with block, do not proceed any further
+                return unknownType;
+            }
+            if (ts.isTypeNode(node)) {
+                return getTypeFromTypeNode(node);
+            }
+            if (ts.isExpression(node)) {
+                return getTypeOfExpression(node);
+            }
+            if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(node)) {
+                // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the
+                // extends clause of a class. We handle that case here.
+                return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0];
+            }
+            if (isTypeDeclaration(node)) {
+                // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
+                var symbol = getSymbolOfNode(node);
+                return getDeclaredTypeOfSymbol(symbol);
+            }
+            if (isTypeDeclarationName(node)) {
+                var symbol = getSymbolAtLocation(node);
+                return symbol && getDeclaredTypeOfSymbol(symbol);
+            }
+            if (ts.isDeclaration(node)) {
+                // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
+                var symbol = getSymbolOfNode(node);
+                return getTypeOfSymbol(symbol);
+            }
+            if (ts.isDeclarationName(node)) {
+                var symbol = getSymbolAtLocation(node);
+                return symbol && getTypeOfSymbol(symbol);
+            }
+            if (ts.isBindingPattern(node)) {
+                return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true);
+            }
+            if (isInRightSideOfImportOrExportAssignment(node)) {
+                var symbol = getSymbolAtLocation(node);
+                var declaredType = symbol && getDeclaredTypeOfSymbol(symbol);
+                return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
+            }
+            return unknownType;
+        }
+        // Gets the type of object literal or array literal of destructuring assignment.
+        // { a } from
+        //     for ( { a } of elems) {
+        //     }
+        // [ a ] from
+        //     [a] = [ some array ...]
+        function getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(expr) {
+            ts.Debug.assert(expr.kind === 171 /* ObjectLiteralExpression */ || expr.kind === 170 /* ArrayLiteralExpression */);
+            // If this is from "for of"
+            //     for ( { a } of elems) {
+            //     }
+            if (expr.parent.kind === 208 /* ForOfStatement */) {
+                var iteratedType = checkRightHandSideOfForOf(expr.parent.expression);
+                return checkDestructuringAssignment(expr, iteratedType || unknownType);
+            }
+            // If this is from "for" initializer
+            //     for ({a } = elems[0];.....) { }
+            if (expr.parent.kind === 187 /* BinaryExpression */) {
+                var iteratedType = checkExpression(expr.parent.right);
+                return checkDestructuringAssignment(expr, iteratedType || unknownType);
+            }
+            // If this is from nested object binding pattern
+            //     for ({ skills: { primary, secondary } } = multiRobot, i = 0; i < 1; i++) {
+            if (expr.parent.kind === 253 /* PropertyAssignment */) {
+                var typeOfParentObjectLiteral = getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(expr.parent.parent);
+                return checkObjectLiteralDestructuringPropertyAssignment(typeOfParentObjectLiteral || unknownType, expr.parent);
+            }
+            // Array literal assignment - array destructuring pattern
+            ts.Debug.assert(expr.parent.kind === 170 /* ArrayLiteralExpression */);
+            //    [{ property1: p1, property2 }] = elems;
+            var typeOfArrayLiteral = getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(expr.parent);
+            var elementType = checkIteratedTypeOrElementType(typeOfArrayLiteral || unknownType, expr.parent, /*allowStringInput*/ false) || unknownType;
+            return checkArrayLiteralDestructuringElementAssignment(expr.parent, typeOfArrayLiteral, ts.indexOf(expr.parent.elements, expr), elementType || unknownType);
+        }
+        // Gets the property symbol corresponding to the property in destructuring assignment
+        // 'property1' from
+        //     for ( { property1: a } of elems) {
+        //     }
+        // 'property1' at location 'a' from:
+        //     [a] = [ property1, property2 ]
+        function getPropertySymbolOfDestructuringAssignment(location) {
+            // Get the type of the object or array literal and then look for property of given name in the type
+            var typeOfObjectLiteral = getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(location.parent.parent);
+            return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.text);
+        }
+        function getTypeOfExpression(expr) {
+            if (ts.isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
+                expr = expr.parent;
+            }
+            return checkExpression(expr);
+        }
+        /**
+          * Gets either the static or instance type of a class element, based on
+          * whether the element is declared as "static".
+          */
+        function getParentTypeOfClassElement(node) {
+            var classSymbol = getSymbolOfNode(node.parent);
+            return node.flags & 32 /* Static */
+                ? getTypeOfSymbol(classSymbol)
+                : getDeclaredTypeOfSymbol(classSymbol);
+        }
+        // Return the list of properties of the given type, augmented with properties from Function
+        // if the type has call or construct signatures
+        function getAugmentedPropertiesOfType(type) {
+            type = getApparentType(type);
+            var propsByName = createSymbolTable(getPropertiesOfType(type));
+            if (getSignaturesOfType(type, 0 /* Call */).length || getSignaturesOfType(type, 1 /* Construct */).length) {
+                ts.forEach(getPropertiesOfType(globalFunctionType), function (p) {
+                    if (!ts.hasProperty(propsByName, p.name)) {
+                        propsByName[p.name] = p;
+                    }
+                });
+            }
+            return getNamedMembers(propsByName);
+        }
+        function getRootSymbols(symbol) {
+            if (symbol.flags & 268435456 /* SyntheticProperty */) {
+                var symbols_3 = [];
+                var name_20 = symbol.name;
+                ts.forEach(getSymbolLinks(symbol).containingType.types, function (t) {
+                    var symbol = getPropertyOfType(t, name_20);
+                    if (symbol) {
+                        symbols_3.push(symbol);
+                    }
+                });
+                return symbols_3;
+            }
+            else if (symbol.flags & 67108864 /* Transient */) {
+                var target = void 0;
+                var next = symbol;
+                while (next = getSymbolLinks(next).target) {
+                    target = next;
+                }
+                if (target) {
+                    return [target];
+                }
+            }
+            return [symbol];
+        }
+        // Emitter support
+        function isArgumentsLocalBinding(node) {
+            return getReferencedValueSymbol(node) === argumentsSymbol;
+        }
+        function moduleExportsSomeValue(moduleReferenceExpression) {
+            var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
+            if (!moduleSymbol) {
+                // module not found - be conservative
+                return true;
+            }
+            var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
+            // if module has export assignment then 'resolveExternalModuleSymbol' will return resolved symbol for export assignment
+            // otherwise it will return moduleSymbol itself
+            moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
+            var symbolLinks = getSymbolLinks(moduleSymbol);
+            if (symbolLinks.exportsSomeValue === undefined) {
+                // for export assignments - check if resolved symbol for RHS is itself a value
+                // otherwise - check if at least one export is value
+                symbolLinks.exportsSomeValue = hasExportAssignment
+                    ? !!(moduleSymbol.flags & 107455 /* Value */)
+                    : ts.forEachValue(getExportsOfModule(moduleSymbol), isValue);
+            }
+            return symbolLinks.exportsSomeValue;
+            function isValue(s) {
+                s = resolveSymbol(s);
+                return s && !!(s.flags & 107455 /* Value */);
+            }
+        }
+        // When resolved as an expression identifier, if the given node references an exported entity, return the declaration
+        // node of the exported entity's container. Otherwise, return undefined.
+        function getReferencedExportContainer(node) {
+            var symbol = getReferencedValueSymbol(node);
+            if (symbol) {
+                if (symbol.flags & 1048576 /* ExportValue */) {
+                    // If we reference an exported entity within the same module declaration, then whether
+                    // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the
+                    // kinds that we do NOT prefix.
+                    var exportSymbol = getMergedSymbol(symbol.exportSymbol);
+                    if (exportSymbol.flags & 944 /* ExportHasLocal */) {
+                        return undefined;
+                    }
+                    symbol = exportSymbol;
+                }
+                var parentSymbol = getParentOfSymbol(symbol);
+                if (parentSymbol) {
+                    if (parentSymbol.flags & 512 /* ValueModule */ && parentSymbol.valueDeclaration.kind === 256 /* SourceFile */) {
+                        // If `node` accesses an export and that export isn't in the same file, then symbol is a namespace export, so return undefined.
+                        if (parentSymbol.valueDeclaration === ts.getSourceFileOfNode(node)) {
+                            return parentSymbol.valueDeclaration;
+                        }
+                    }
+                    for (var n = node.parent; n; n = n.parent) {
+                        if ((n.kind === 225 /* ModuleDeclaration */ || n.kind === 224 /* EnumDeclaration */) && getSymbolOfNode(n) === parentSymbol) {
+                            return n;
+                        }
+                    }
+                }
+            }
+        }
+        // When resolved as an expression identifier, if the given node references an import, return the declaration of
+        // that import. Otherwise, return undefined.
+        function getReferencedImportDeclaration(node) {
+            var symbol = getReferencedValueSymbol(node);
+            return symbol && symbol.flags & 8388608 /* Alias */ ? getDeclarationOfAliasSymbol(symbol) : undefined;
+        }
+        function isSymbolOfDeclarationWithCollidingName(symbol) {
+            if (symbol.flags & 418 /* BlockScoped */) {
+                var links = getSymbolLinks(symbol);
+                if (links.isDeclarationWithCollidingName === undefined) {
+                    var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+                    if (ts.isStatementWithLocals(container)) {
+                        var nodeLinks_1 = getNodeLinks(symbol.valueDeclaration);
+                        if (!!resolveName(container.parent, symbol.name, 107455 /* Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined)) {
+                            // redeclaration - always should be renamed
+                            links.isDeclarationWithCollidingName = true;
+                        }
+                        else if (nodeLinks_1.flags & 131072 /* CapturedBlockScopedBinding */) {
+                            // binding is captured in the function
+                            // should be renamed if:
+                            // - binding is not top level - top level bindings never collide with anything
+                            // AND
+                            //   - binding is not declared in loop, should be renamed to avoid name reuse across siblings
+                            //     let a, b
+                            //     { let x = 1; a = () => x;  }
+                            //     { let x = 100; b = () => x; }
+                            //     console.log(a()); // should print '1'
+                            //     console.log(b()); // should print '100'
+                            //     OR
+                            //   - binding is declared inside loop but not in inside initializer of iteration statement or directly inside loop body
+                            //     * variables from initializer are passed to rewritten loop body as parameters so they are not captured directly
+                            //     * variables that are declared immediately in loop body will become top level variable after loop is rewritten and thus
+                            //       they will not collide with anything
+                            var isDeclaredInLoop = nodeLinks_1.flags & 262144 /* BlockScopedBindingInLoop */;
+                            var inLoopInitializer = ts.isIterationStatement(container, /*lookInLabeledStatements*/ false);
+                            var inLoopBodyBlock = container.kind === 199 /* Block */ && ts.isIterationStatement(container.parent, /*lookInLabeledStatements*/ false);
+                            links.isDeclarationWithCollidingName = !ts.isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || (!inLoopInitializer && !inLoopBodyBlock));
+                        }
+                        else {
+                            links.isDeclarationWithCollidingName = false;
+                        }
+                    }
+                }
+                return links.isDeclarationWithCollidingName;
+            }
+            return false;
+        }
+        // When resolved as an expression identifier, if the given node references a nested block scoped entity with
+        // a name that either hides an existing name or might hide it when compiled downlevel,
+        // return the declaration of that entity. Otherwise, return undefined.
+        function getReferencedDeclarationWithCollidingName(node) {
+            var symbol = getReferencedValueSymbol(node);
+            return symbol && isSymbolOfDeclarationWithCollidingName(symbol) ? symbol.valueDeclaration : undefined;
+        }
+        // Return true if the given node is a declaration of a nested block scoped entity with a name that either hides an
+        // existing name or might hide a name when compiled downlevel
+        function isDeclarationWithCollidingName(node) {
+            return isSymbolOfDeclarationWithCollidingName(getSymbolOfNode(node));
+        }
+        function isValueAliasDeclaration(node) {
+            switch (node.kind) {
+                case 229 /* ImportEqualsDeclaration */:
+                case 231 /* ImportClause */:
+                case 232 /* NamespaceImport */:
+                case 234 /* ImportSpecifier */:
+                case 238 /* ExportSpecifier */:
+                    return isAliasResolvedToValue(getSymbolOfNode(node));
+                case 236 /* ExportDeclaration */:
+                    var exportClause = node.exportClause;
+                    return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration);
+                case 235 /* ExportAssignment */:
+                    return node.expression && node.expression.kind === 69 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true;
+            }
+            return false;
+        }
+        function isTopLevelValueImportEqualsWithEntityName(node) {
+            if (node.parent.kind !== 256 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) {
+                // parent is not source file or it is not reference to internal module
+                return false;
+            }
+            var isValue = isAliasResolvedToValue(getSymbolOfNode(node));
+            return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
+        }
+        function isAliasResolvedToValue(symbol) {
+            var target = resolveAlias(symbol);
+            if (target === unknownSymbol) {
+                return true;
+            }
+            // const enums and modules that contain only const enums are not considered values from the emit perspective
+            // unless 'preserveConstEnums' option is set to true
+            return target.flags & 107455 /* Value */ &&
+                (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target));
+        }
+        function isConstEnumOrConstEnumOnlyModule(s) {
+            return isConstEnumSymbol(s) || s.constEnumOnlyModule;
+        }
+        function isReferencedAliasDeclaration(node, checkChildren) {
+            if (ts.isAliasSymbolDeclaration(node)) {
+                var symbol = getSymbolOfNode(node);
+                if (getSymbolLinks(symbol).referenced) {
+                    return true;
+                }
+            }
+            if (checkChildren) {
+                return ts.forEachChild(node, function (node) { return isReferencedAliasDeclaration(node, checkChildren); });
+            }
+            return false;
+        }
+        function isImplementationOfOverload(node) {
+            if (ts.nodeIsPresent(node.body)) {
+                var symbol = getSymbolOfNode(node);
+                var signaturesOfSymbol = getSignaturesOfSymbol(symbol);
+                // If this function body corresponds to function with multiple signature, it is implementation of overload
+                // e.g.: function foo(a: string): string;
+                //       function foo(a: number): number;
+                //       function foo(a: any) { // This is implementation of the overloads
+                //           return a;
+                //       }
+                return signaturesOfSymbol.length > 1 ||
+                    // If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+                    // e.g.: function foo(a: string): string;
+                    //       function foo(a: any) { // This is implementation of the overloads
+                    //           return a;
+                    //       }
+                    (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node);
+            }
+            return false;
+        }
+        function getNodeCheckFlags(node) {
+            return getNodeLinks(node).flags;
+        }
+        function getEnumMemberValue(node) {
+            computeEnumMemberValues(node.parent);
+            return getNodeLinks(node).enumMemberValue;
+        }
+        function getConstantValue(node) {
+            if (node.kind === 255 /* EnumMember */) {
+                return getEnumMemberValue(node);
+            }
+            var symbol = getNodeLinks(node).resolvedSymbol;
+            if (symbol && (symbol.flags & 8 /* EnumMember */)) {
+                // inline property\index accesses only for const enums
+                if (ts.isConstEnumDeclaration(symbol.valueDeclaration.parent)) {
+                    return getEnumMemberValue(symbol.valueDeclaration);
+                }
+            }
+            return undefined;
+        }
+        function isFunctionType(type) {
+            return type.flags & 80896 /* ObjectType */ && getSignaturesOfType(type, 0 /* Call */).length > 0;
+        }
+        function getTypeReferenceSerializationKind(typeName) {
+            // Resolve the symbol as a value to ensure the type can be reached at runtime during emit.
+            var valueSymbol = resolveEntityName(typeName, 107455 /* Value */, /*ignoreErrors*/ true);
+            var constructorType = valueSymbol ? getTypeOfSymbol(valueSymbol) : undefined;
+            if (constructorType && isConstructorType(constructorType)) {
+                return ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
+            }
+            // Resolve the symbol as a type so that we can provide a more useful hint for the type serializer.
+            var typeSymbol = resolveEntityName(typeName, 793056 /* Type */, /*ignoreErrors*/ true);
+            // We might not be able to resolve type symbol so use unknown type in that case (eg error case)
+            if (!typeSymbol) {
+                return ts.TypeReferenceSerializationKind.ObjectType;
+            }
+            var type = getDeclaredTypeOfSymbol(typeSymbol);
+            if (type === unknownType) {
+                return ts.TypeReferenceSerializationKind.Unknown;
+            }
+            else if (type.flags & 1 /* Any */) {
+                return ts.TypeReferenceSerializationKind.ObjectType;
+            }
+            else if (isTypeOfKind(type, 16 /* Void */)) {
+                return ts.TypeReferenceSerializationKind.VoidType;
+            }
+            else if (isTypeOfKind(type, 8 /* Boolean */)) {
+                return ts.TypeReferenceSerializationKind.BooleanType;
+            }
+            else if (isTypeOfKind(type, 132 /* NumberLike */)) {
+                return ts.TypeReferenceSerializationKind.NumberLikeType;
+            }
+            else if (isTypeOfKind(type, 258 /* StringLike */)) {
+                return ts.TypeReferenceSerializationKind.StringLikeType;
+            }
+            else if (isTypeOfKind(type, 8192 /* Tuple */)) {
+                return ts.TypeReferenceSerializationKind.ArrayLikeType;
+            }
+            else if (isTypeOfKind(type, 16777216 /* ESSymbol */)) {
+                return ts.TypeReferenceSerializationKind.ESSymbolType;
+            }
+            else if (isFunctionType(type)) {
+                return ts.TypeReferenceSerializationKind.TypeWithCallSignature;
+            }
+            else if (isArrayType(type)) {
+                return ts.TypeReferenceSerializationKind.ArrayLikeType;
+            }
+            else {
+                return ts.TypeReferenceSerializationKind.ObjectType;
+            }
+        }
+        function writeTypeOfDeclaration(declaration, enclosingDeclaration, flags, writer) {
+            // Get type of the symbol if this is the valid symbol otherwise get type at location
+            var symbol = getSymbolOfNode(declaration);
+            var type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */))
+                ? getTypeOfSymbol(symbol)
+                : unknownType;
+            getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+        }
+        function writeReturnTypeOfSignatureDeclaration(signatureDeclaration, enclosingDeclaration, flags, writer) {
+            var signature = getSignatureFromDeclaration(signatureDeclaration);
+            getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags);
+        }
+        function writeTypeOfExpression(expr, enclosingDeclaration, flags, writer) {
+            var type = getWidenedType(getTypeOfExpression(expr));
+            getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+        }
+        function writeBaseConstructorTypeOfClass(node, enclosingDeclaration, flags, writer) {
+            var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(node));
+            resolveBaseTypesOfClass(classType);
+            var baseType = classType.resolvedBaseTypes.length ? classType.resolvedBaseTypes[0] : unknownType;
+            getSymbolDisplayBuilder().buildTypeDisplay(baseType, writer, enclosingDeclaration, flags);
+        }
+        function hasGlobalName(name) {
+            return ts.hasProperty(globals, name);
+        }
+        function getReferencedValueSymbol(reference) {
+            return getNodeLinks(reference).resolvedSymbol ||
+                resolveName(reference, reference.text, 107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */, 
+                /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+        }
+        function getReferencedValueDeclaration(reference) {
+            ts.Debug.assert(!ts.nodeIsSynthesized(reference));
+            var symbol = getReferencedValueSymbol(reference);
+            return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
+        }
+        function createResolver() {
+            // this variable and functions that use it are deliberately moved here from the outer scope
+            // to avoid scope pollution
+            var resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
+            var fileToDirective;
+            if (resolvedTypeReferenceDirectives) {
+                // populate reverse mapping: file path -> type reference directive that was resolved to this file
+                fileToDirective = ts.createFileMap();
+                for (var key in resolvedTypeReferenceDirectives) {
+                    if (!ts.hasProperty(resolvedTypeReferenceDirectives, key)) {
+                        continue;
+                    }
+                    var resolvedDirective = resolvedTypeReferenceDirectives[key];
+                    if (!resolvedDirective) {
+                        continue;
+                    }
+                    var file = host.getSourceFile(resolvedDirective.resolvedFileName);
+                    fileToDirective.set(file.path, key);
+                }
+            }
+            return {
+                getReferencedExportContainer: getReferencedExportContainer,
+                getReferencedImportDeclaration: getReferencedImportDeclaration,
+                getReferencedDeclarationWithCollidingName: getReferencedDeclarationWithCollidingName,
+                isDeclarationWithCollidingName: isDeclarationWithCollidingName,
+                isValueAliasDeclaration: isValueAliasDeclaration,
+                hasGlobalName: hasGlobalName,
+                isReferencedAliasDeclaration: isReferencedAliasDeclaration,
+                getNodeCheckFlags: getNodeCheckFlags,
+                isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName,
+                isDeclarationVisible: isDeclarationVisible,
+                isImplementationOfOverload: isImplementationOfOverload,
+                writeTypeOfDeclaration: writeTypeOfDeclaration,
+                writeReturnTypeOfSignatureDeclaration: writeReturnTypeOfSignatureDeclaration,
+                writeTypeOfExpression: writeTypeOfExpression,
+                writeBaseConstructorTypeOfClass: writeBaseConstructorTypeOfClass,
+                isSymbolAccessible: isSymbolAccessible,
+                isEntityNameVisible: isEntityNameVisible,
+                getConstantValue: getConstantValue,
+                collectLinkedAliases: collectLinkedAliases,
+                getReferencedValueDeclaration: getReferencedValueDeclaration,
+                getTypeReferenceSerializationKind: getTypeReferenceSerializationKind,
+                isOptionalParameter: isOptionalParameter,
+                moduleExportsSomeValue: moduleExportsSomeValue,
+                isArgumentsLocalBinding: isArgumentsLocalBinding,
+                getExternalModuleFileFromDeclaration: getExternalModuleFileFromDeclaration,
+                getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName,
+                getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol
+            };
+            // defined here to avoid outer scope pollution
+            function getTypeReferenceDirectivesForEntityName(node) {
+                // program does not have any files with type reference directives - bail out
+                if (!fileToDirective) {
+                    return undefined;
+                }
+                // property access can only be used as values
+                // qualified names can only be used as types\namespaces
+                // identifiers are treated as values only if they appear in type queries
+                var meaning = (node.kind === 172 /* PropertyAccessExpression */) || (node.kind === 69 /* Identifier */ && isInTypeQuery(node))
+                    ? 107455 /* Value */ | 1048576 /* ExportValue */
+                    : 793056 /* Type */ | 1536 /* Namespace */;
+                var symbol = resolveEntityName(node, meaning, /*ignoreErrors*/ true);
+                return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined;
+            }
+            // defined here to avoid outer scope pollution
+            function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
+                // program does not have any files with type reference directives - bail out
+                if (!fileToDirective) {
+                    return undefined;
+                }
+                if (!isSymbolFromTypeDeclarationFile(symbol)) {
+                    return undefined;
+                }
+                // check what declarations in the symbol can contribute to the target meaning
+                var typeReferenceDirectives;
+                for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                    var decl = _a[_i];
+                    // check meaning of the local symbol to see if declaration needs to be analyzed further
+                    if (decl.symbol && decl.symbol.flags & meaning) {
+                        var file = ts.getSourceFileOfNode(decl);
+                        var typeReferenceDirective = fileToDirective.get(file.path);
+                        if (typeReferenceDirective) {
+                            (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
+                        }
+                    }
+                }
+                return typeReferenceDirectives;
+            }
+            function isSymbolFromTypeDeclarationFile(symbol) {
+                // bail out if symbol does not have associated declarations (i.e. this is transient symbol created for property in binding pattern)
+                if (!symbol.declarations) {
+                    return false;
+                }
+                // walk the parent chain for symbols to make sure that top level parent symbol is in the global scope
+                // external modules cannot define or contribute to type declaration files
+                var current = symbol;
+                while (true) {
+                    var parent_12 = getParentOfSymbol(current);
+                    if (parent_12) {
+                        current = parent_12;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (current.valueDeclaration && current.valueDeclaration.kind === 256 /* SourceFile */ && current.flags & 512 /* ValueModule */) {
+                    return false;
+                }
+                // check that at least one declaration of top level symbol originates from type declaration file
+                for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+                    var decl = _a[_i];
+                    var file = ts.getSourceFileOfNode(decl);
+                    if (fileToDirective.contains(file.path)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        function getExternalModuleFileFromDeclaration(declaration) {
+            var specifier = ts.getExternalModuleName(declaration);
+            var moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, /*moduleNotFoundError*/ undefined);
+            if (!moduleSymbol) {
+                return undefined;
+            }
+            return ts.getDeclarationOfKind(moduleSymbol, 256 /* SourceFile */);
+        }
+        function initializeTypeChecker() {
+            // Bind all source files and propagate errors
+            ts.forEach(host.getSourceFiles(), function (file) {
+                ts.bindSourceFile(file, compilerOptions);
+            });
+            var augmentations;
+            // Initialize global symbol table
+            ts.forEach(host.getSourceFiles(), function (file) {
+                if (!ts.isExternalOrCommonJsModule(file)) {
+                    mergeSymbolTable(globals, file.locals);
+                }
+                if (file.patternAmbientModules && file.patternAmbientModules.length) {
+                    patternAmbientModules = ts.concatenate(patternAmbientModules, file.patternAmbientModules);
+                }
+                if (file.moduleAugmentations.length) {
+                    (augmentations || (augmentations = [])).push(file.moduleAugmentations);
+                }
+                if (file.symbol && file.symbol.globalExports) {
+                    mergeSymbolTable(globals, file.symbol.globalExports);
+                }
+            });
+            if (augmentations) {
+                // merge module augmentations.
+                // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed
+                for (var _i = 0, augmentations_1 = augmentations; _i < augmentations_1.length; _i++) {
+                    var list = augmentations_1[_i];
+                    for (var _a = 0, list_2 = list; _a < list_2.length; _a++) {
+                        var augmentation = list_2[_a];
+                        mergeModuleAugmentation(augmentation);
+                    }
+                }
+            }
+            // Setup global builtins
+            addToSymbolTable(globals, builtinGlobals, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
+            getSymbolLinks(undefinedSymbol).type = undefinedWideningType;
+            getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments");
+            getSymbolLinks(unknownSymbol).type = unknownType;
+            // Initialize special types
+            globalArrayType = getGlobalType("Array", /*arity*/ 1);
+            globalObjectType = getGlobalType("Object");
+            globalFunctionType = getGlobalType("Function");
+            globalStringType = getGlobalType("String");
+            globalNumberType = getGlobalType("Number");
+            globalBooleanType = getGlobalType("Boolean");
+            globalRegExpType = getGlobalType("RegExp");
+            jsxElementType = getExportedTypeFromNamespace("JSX", JsxNames.Element);
+            getGlobalClassDecoratorType = ts.memoize(function () { return getGlobalType("ClassDecorator"); });
+            getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); });
+            getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); });
+            getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); });
+            getGlobalTypedPropertyDescriptorType = ts.memoize(function () { return getGlobalType("TypedPropertyDescriptor", /*arity*/ 1); });
+            getGlobalESSymbolConstructorSymbol = ts.memoize(function () { return getGlobalValueSymbol("Symbol"); });
+            getGlobalPromiseType = ts.memoize(function () { return getGlobalType("Promise", /*arity*/ 1); });
+            tryGetGlobalPromiseType = ts.memoize(function () { return getGlobalSymbol("Promise", 793056 /* Type */, /*diagnostic*/ undefined) && getGlobalPromiseType(); });
+            getGlobalPromiseLikeType = ts.memoize(function () { return getGlobalType("PromiseLike", /*arity*/ 1); });
+            getInstantiatedGlobalPromiseLikeType = ts.memoize(createInstantiatedPromiseLikeType);
+            getGlobalPromiseConstructorSymbol = ts.memoize(function () { return getGlobalValueSymbol("Promise"); });
+            getGlobalPromiseConstructorLikeType = ts.memoize(function () { return getGlobalType("PromiseConstructorLike"); });
+            getGlobalThenableType = ts.memoize(createThenableType);
+            getGlobalTemplateStringsArrayType = ts.memoize(function () { return getGlobalType("TemplateStringsArray"); });
+            if (languageVersion >= 2 /* ES6 */) {
+                getGlobalESSymbolType = ts.memoize(function () { return getGlobalType("Symbol"); });
+                getGlobalIterableType = ts.memoize(function () { return getGlobalType("Iterable", /*arity*/ 1); });
+                getGlobalIteratorType = ts.memoize(function () { return getGlobalType("Iterator", /*arity*/ 1); });
+                getGlobalIterableIteratorType = ts.memoize(function () { return getGlobalType("IterableIterator", /*arity*/ 1); });
+            }
+            else {
+                getGlobalESSymbolType = ts.memoize(function () { return emptyObjectType; });
+                getGlobalIterableType = ts.memoize(function () { return emptyGenericType; });
+                getGlobalIteratorType = ts.memoize(function () { return emptyGenericType; });
+                getGlobalIterableIteratorType = ts.memoize(function () { return emptyGenericType; });
+            }
+            anyArrayType = createArrayType(anyType);
+            var symbol = getGlobalSymbol("ReadonlyArray", 793056 /* Type */, /*diagnostic*/ undefined);
+            globalReadonlyArrayType = symbol && getTypeOfGlobalSymbol(symbol, /*arity*/ 1);
+            anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
+        }
+        function createInstantiatedPromiseLikeType() {
+            var promiseLikeType = getGlobalPromiseLikeType();
+            if (promiseLikeType !== emptyGenericType) {
+                return createTypeReference(promiseLikeType, [anyType]);
+            }
+            return emptyObjectType;
+        }
+        function createThenableType() {
+            // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`.
+            var thenPropertySymbol = createSymbol(67108864 /* Transient */ | 4 /* Property */, "then");
+            getSymbolLinks(thenPropertySymbol).type = globalFunctionType;
+            var thenableType = createObjectType(65536 /* Anonymous */);
+            thenableType.properties = [thenPropertySymbol];
+            thenableType.members = createSymbolTable(thenableType.properties);
+            thenableType.callSignatures = [];
+            thenableType.constructSignatures = [];
+            return thenableType;
+        }
+        // GRAMMAR CHECKING
+        function checkGrammarDecorators(node) {
+            if (!node.decorators) {
+                return false;
+            }
+            if (!ts.nodeCanBeDecorated(node)) {
+                if (node.kind === 147 /* MethodDeclaration */ && !ts.nodeIsPresent(node.body)) {
+                    return grammarErrorOnFirstToken(node, ts.Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
+                }
+                else {
+                    return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here);
+                }
+            }
+            else if (node.kind === 149 /* GetAccessor */ || node.kind === 150 /* SetAccessor */) {
+                var accessors = ts.getAllAccessorDeclarations(node.parent.members, node);
+                if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) {
+                    return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
+                }
+            }
+            return false;
+        }
+        function checkGrammarModifiers(node) {
+            switch (node.kind) {
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 148 /* Constructor */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 153 /* IndexSignature */:
+                case 225 /* ModuleDeclaration */:
+                case 230 /* ImportDeclaration */:
+                case 229 /* ImportEqualsDeclaration */:
+                case 236 /* ExportDeclaration */:
+                case 235 /* ExportAssignment */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                case 142 /* Parameter */:
+                    break;
+                case 220 /* FunctionDeclaration */:
+                    if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 118 /* AsyncKeyword */) &&
+                        node.parent.kind !== 226 /* ModuleBlock */ && node.parent.kind !== 256 /* SourceFile */) {
+                        return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                    break;
+                case 221 /* ClassDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 200 /* VariableStatement */:
+                case 223 /* TypeAliasDeclaration */:
+                    if (node.modifiers && node.parent.kind !== 226 /* ModuleBlock */ && node.parent.kind !== 256 /* SourceFile */) {
+                        return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                    break;
+                case 224 /* EnumDeclaration */:
+                    if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 74 /* ConstKeyword */) &&
+                        node.parent.kind !== 226 /* ModuleBlock */ && node.parent.kind !== 256 /* SourceFile */) {
+                        return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                    break;
+                default:
+                    return false;
+            }
+            if (!node.modifiers) {
+                return;
+            }
+            var lastStatic, lastPrivate, lastProtected, lastDeclare, lastAsync, lastReadonly;
+            var flags = 0;
+            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
+                var modifier = _a[_i];
+                if (modifier.kind !== 128 /* ReadonlyKeyword */) {
+                    if (node.kind === 144 /* PropertySignature */ || node.kind === 146 /* MethodSignature */) {
+                        return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_member, ts.tokenToString(modifier.kind));
+                    }
+                    if (node.kind === 153 /* IndexSignature */) {
+                        return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_an_index_signature, ts.tokenToString(modifier.kind));
+                    }
+                }
+                switch (modifier.kind) {
+                    case 74 /* ConstKeyword */:
+                        if (node.kind !== 224 /* EnumDeclaration */ && node.parent.kind === 221 /* ClassDeclaration */) {
+                            return grammarErrorOnNode(node, ts.Diagnostics.A_class_member_cannot_have_the_0_keyword, ts.tokenToString(74 /* ConstKeyword */));
+                        }
+                        break;
+                    case 112 /* PublicKeyword */:
+                    case 111 /* ProtectedKeyword */:
+                    case 110 /* PrivateKeyword */:
+                        var text = visibilityToString(ts.modifierToFlag(modifier.kind));
+                        if (modifier.kind === 111 /* ProtectedKeyword */) {
+                            lastProtected = modifier;
+                        }
+                        else if (modifier.kind === 110 /* PrivateKeyword */) {
+                            lastPrivate = modifier;
+                        }
+                        if (flags & 28 /* AccessibilityModifier */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
+                        }
+                        else if (flags & 32 /* Static */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
+                        }
+                        else if (flags & 64 /* Readonly */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
+                        }
+                        else if (flags & 256 /* Async */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
+                        }
+                        else if (node.parent.kind === 226 /* ModuleBlock */ || node.parent.kind === 256 /* SourceFile */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
+                        }
+                        else if (flags & 128 /* Abstract */) {
+                            if (modifier.kind === 110 /* PrivateKeyword */) {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
+                            }
+                            else {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract");
+                            }
+                        }
+                        flags |= ts.modifierToFlag(modifier.kind);
+                        break;
+                    case 113 /* StaticKeyword */:
+                        if (flags & 32 /* Static */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
+                        }
+                        else if (flags & 64 /* Readonly */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
+                        }
+                        else if (flags & 256 /* Async */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
+                        }
+                        else if (node.parent.kind === 226 /* ModuleBlock */ || node.parent.kind === 256 /* SourceFile */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
+                        }
+                        else if (node.kind === 142 /* Parameter */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
+                        }
+                        else if (flags & 128 /* Abstract */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
+                        }
+                        flags |= 32 /* Static */;
+                        lastStatic = modifier;
+                        break;
+                    case 128 /* ReadonlyKeyword */:
+                        if (flags & 64 /* Readonly */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "readonly");
+                        }
+                        else if (node.kind !== 145 /* PropertyDeclaration */ && node.kind !== 144 /* PropertySignature */ && node.kind !== 153 /* IndexSignature */ && node.kind !== 142 /* Parameter */) {
+                            // If node.kind === SyntaxKind.Parameter, checkParameter report an error if it's not a parameter property.
+                            return grammarErrorOnNode(modifier, ts.Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
+                        }
+                        flags |= 64 /* Readonly */;
+                        lastReadonly = modifier;
+                        break;
+                    case 82 /* ExportKeyword */:
+                        if (flags & 1 /* Export */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
+                        }
+                        else if (flags & 2 /* Ambient */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
+                        }
+                        else if (flags & 128 /* Abstract */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
+                        }
+                        else if (flags & 256 /* Async */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
+                        }
+                        else if (node.parent.kind === 221 /* ClassDeclaration */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export");
+                        }
+                        else if (node.kind === 142 /* Parameter */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
+                        }
+                        flags |= 1 /* Export */;
+                        break;
+                    case 122 /* DeclareKeyword */:
+                        if (flags & 2 /* Ambient */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
+                        }
+                        else if (flags & 256 /* Async */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
+                        }
+                        else if (node.parent.kind === 221 /* ClassDeclaration */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare");
+                        }
+                        else if (node.kind === 142 /* Parameter */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
+                        }
+                        else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 226 /* ModuleBlock */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
+                        }
+                        flags |= 2 /* Ambient */;
+                        lastDeclare = modifier;
+                        break;
+                    case 115 /* AbstractKeyword */:
+                        if (flags & 128 /* Abstract */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
+                        }
+                        if (node.kind !== 221 /* ClassDeclaration */) {
+                            if (node.kind !== 147 /* MethodDeclaration */ &&
+                                node.kind !== 145 /* PropertyDeclaration */ &&
+                                node.kind !== 149 /* GetAccessor */ &&
+                                node.kind !== 150 /* SetAccessor */) {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
+                            }
+                            if (!(node.parent.kind === 221 /* ClassDeclaration */ && node.parent.flags & 128 /* Abstract */)) {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
+                            }
+                            if (flags & 32 /* Static */) {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
+                            }
+                            if (flags & 8 /* Private */) {
+                                return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
+                            }
+                        }
+                        flags |= 128 /* Abstract */;
+                        break;
+                    case 118 /* AsyncKeyword */:
+                        if (flags & 256 /* Async */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
+                        }
+                        else if (flags & 2 /* Ambient */ || ts.isInAmbientContext(node.parent)) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
+                        }
+                        else if (node.kind === 142 /* Parameter */) {
+                            return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
+                        }
+                        flags |= 256 /* Async */;
+                        lastAsync = modifier;
+                        break;
+                }
+            }
+            if (node.kind === 148 /* Constructor */) {
+                if (flags & 32 /* Static */) {
+                    return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
+                }
+                if (flags & 128 /* Abstract */) {
+                    return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
+                }
+                else if (flags & 256 /* Async */) {
+                    return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
+                }
+                else if (flags & 64 /* Readonly */) {
+                    return grammarErrorOnNode(lastReadonly, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "readonly");
+                }
+                return;
+            }
+            else if ((node.kind === 230 /* ImportDeclaration */ || node.kind === 229 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
+                return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
+            }
+            else if (node.kind === 142 /* Parameter */ && (flags & 92 /* ParameterPropertyModifier */) && ts.isBindingPattern(node.name)) {
+                return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
+            }
+            else if (node.kind === 142 /* Parameter */ && (flags & 92 /* ParameterPropertyModifier */) && node.dotDotDotToken) {
+                return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
+            }
+            if (flags & 256 /* Async */) {
+                return checkGrammarAsyncModifier(node, lastAsync);
+            }
+        }
+        function checkGrammarAsyncModifier(node, asyncModifier) {
+            if (languageVersion < 2 /* ES6 */) {
+                return grammarErrorOnNode(asyncModifier, ts.Diagnostics.Async_functions_are_only_available_when_targeting_ECMAScript_2015_or_higher);
+            }
+            switch (node.kind) {
+                case 147 /* MethodDeclaration */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    if (!node.asteriskToken) {
+                        return false;
+                    }
+                    break;
+            }
+            return grammarErrorOnNode(asyncModifier, ts.Diagnostics._0_modifier_cannot_be_used_here, "async");
+        }
+        function checkGrammarForDisallowedTrailingComma(list) {
+            if (list && list.hasTrailingComma) {
+                var start = list.end - ",".length;
+                var end = list.end;
+                var sourceFile = ts.getSourceFileOfNode(list[0]);
+                return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Trailing_comma_not_allowed);
+            }
+        }
+        function checkGrammarTypeParameterList(node, typeParameters, file) {
+            if (checkGrammarForDisallowedTrailingComma(typeParameters)) {
+                return true;
+            }
+            if (typeParameters && typeParameters.length === 0) {
+                var start = typeParameters.pos - "<".length;
+                var end = ts.skipTrivia(file.text, typeParameters.end) + ">".length;
+                return grammarErrorAtPos(file, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty);
+            }
+        }
+        function checkGrammarParameterList(parameters) {
+            var seenOptionalParameter = false;
+            var parameterCount = parameters.length;
+            for (var i = 0; i < parameterCount; i++) {
+                var parameter = parameters[i];
+                if (parameter.dotDotDotToken) {
+                    if (i !== (parameterCount - 1)) {
+                        return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
+                    }
+                    if (ts.isBindingPattern(parameter.name)) {
+                        return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
+                    }
+                    if (parameter.questionToken) {
+                        return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional);
+                    }
+                    if (parameter.initializer) {
+                        return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer);
+                    }
+                }
+                else if (parameter.questionToken) {
+                    seenOptionalParameter = true;
+                    if (parameter.initializer) {
+                        return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
+                    }
+                }
+                else if (seenOptionalParameter && !parameter.initializer) {
+                    return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
+                }
+            }
+        }
+        function checkGrammarFunctionLikeDeclaration(node) {
+            // Prevent cascading error by short-circuit
+            var file = ts.getSourceFileOfNode(node);
+            return checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters, file) ||
+                checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file);
+        }
+        function checkGrammarArrowFunction(node, file) {
+            if (node.kind === 180 /* ArrowFunction */) {
+                var arrowFunction = node;
+                var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line;
+                var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line;
+                if (startLine !== endLine) {
+                    return grammarErrorOnNode(arrowFunction.equalsGreaterThanToken, ts.Diagnostics.Line_terminator_not_permitted_before_arrow);
+                }
+            }
+            return false;
+        }
+        function checkGrammarIndexSignatureParameters(node) {
+            var parameter = node.parameters[0];
+            if (node.parameters.length !== 1) {
+                if (parameter) {
+                    return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+                }
+                else {
+                    return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+                }
+            }
+            if (parameter.dotDotDotToken) {
+                return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
+            }
+            if (parameter.flags & 1023 /* Modifier */) {
+                return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
+            }
+            if (parameter.questionToken) {
+                return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
+            }
+            if (parameter.initializer) {
+                return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
+            }
+            if (!parameter.type) {
+                return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
+            }
+            if (parameter.type.kind !== 132 /* StringKeyword */ && parameter.type.kind !== 130 /* NumberKeyword */) {
+                return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number);
+            }
+            if (!node.type) {
+                return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation);
+            }
+        }
+        function checkGrammarIndexSignature(node) {
+            // Prevent cascading error by short-circuit
+            return checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarIndexSignatureParameters(node);
+        }
+        function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) {
+            if (typeArguments && typeArguments.length === 0) {
+                var sourceFile = ts.getSourceFileOfNode(node);
+                var start = typeArguments.pos - "<".length;
+                var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
+                return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty);
+            }
+        }
+        function checkGrammarTypeArguments(node, typeArguments) {
+            return checkGrammarForDisallowedTrailingComma(typeArguments) ||
+                checkGrammarForAtLeastOneTypeArgument(node, typeArguments);
+        }
+        function checkGrammarForOmittedArgument(node, args) {
+            if (args) {
+                var sourceFile = ts.getSourceFileOfNode(node);
+                for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                    var arg = args_1[_i];
+                    if (arg.kind === 193 /* OmittedExpression */) {
+                        return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
+                    }
+                }
+            }
+        }
+        function checkGrammarArguments(node, args) {
+            return checkGrammarForOmittedArgument(node, args);
+        }
+        function checkGrammarHeritageClause(node) {
+            var types = node.types;
+            if (checkGrammarForDisallowedTrailingComma(types)) {
+                return true;
+            }
+            if (types && types.length === 0) {
+                var listType = ts.tokenToString(node.token);
+                var sourceFile = ts.getSourceFileOfNode(node);
+                return grammarErrorAtPos(sourceFile, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType);
+            }
+        }
+        function checkGrammarClassDeclarationHeritageClauses(node) {
+            var seenExtendsClause = false;
+            var seenImplementsClause = false;
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && node.heritageClauses) {
+                for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+                    var heritageClause = _a[_i];
+                    if (heritageClause.token === 83 /* ExtendsKeyword */) {
+                        if (seenExtendsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
+                        }
+                        if (seenImplementsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause);
+                        }
+                        if (heritageClause.types.length > 1) {
+                            return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class);
+                        }
+                        seenExtendsClause = true;
+                    }
+                    else {
+                        ts.Debug.assert(heritageClause.token === 106 /* ImplementsKeyword */);
+                        if (seenImplementsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen);
+                        }
+                        seenImplementsClause = true;
+                    }
+                    // Grammar checking heritageClause inside class declaration
+                    checkGrammarHeritageClause(heritageClause);
+                }
+            }
+        }
+        function checkGrammarInterfaceDeclaration(node) {
+            var seenExtendsClause = false;
+            if (node.heritageClauses) {
+                for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+                    var heritageClause = _a[_i];
+                    if (heritageClause.token === 83 /* ExtendsKeyword */) {
+                        if (seenExtendsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
+                        }
+                        seenExtendsClause = true;
+                    }
+                    else {
+                        ts.Debug.assert(heritageClause.token === 106 /* ImplementsKeyword */);
+                        return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause);
+                    }
+                    // Grammar checking heritageClause inside class declaration
+                    checkGrammarHeritageClause(heritageClause);
+                }
+            }
+            return false;
+        }
+        function checkGrammarComputedPropertyName(node) {
+            // If node is not a computedPropertyName, just skip the grammar checking
+            if (node.kind !== 140 /* ComputedPropertyName */) {
+                return false;
+            }
+            var computedPropertyName = node;
+            if (computedPropertyName.expression.kind === 187 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 24 /* CommaToken */) {
+                return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
+            }
+        }
+        function checkGrammarForGenerator(node) {
+            if (node.asteriskToken) {
+                ts.Debug.assert(node.kind === 220 /* FunctionDeclaration */ ||
+                    node.kind === 179 /* FunctionExpression */ ||
+                    node.kind === 147 /* MethodDeclaration */);
+                if (ts.isInAmbientContext(node)) {
+                    return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
+                }
+                if (!node.body) {
+                    return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
+                }
+                if (languageVersion < 2 /* ES6 */) {
+                    return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher);
+                }
+            }
+        }
+        function checkGrammarForInvalidQuestionMark(node, questionToken, message) {
+            if (questionToken) {
+                return grammarErrorOnNode(questionToken, message);
+            }
+        }
+        function checkGrammarObjectLiteralExpression(node, inDestructuring) {
+            var seen = {};
+            var Property = 1;
+            var GetAccessor = 2;
+            var SetAccessor = 4;
+            var GetOrSetAccessor = GetAccessor | SetAccessor;
+            var _loop_2 = function(prop) {
+                var name_21 = prop.name;
+                if (prop.kind === 193 /* OmittedExpression */ ||
+                    name_21.kind === 140 /* ComputedPropertyName */) {
+                    // If the name is not a ComputedPropertyName, the grammar checking will skip it
+                    checkGrammarComputedPropertyName(name_21);
+                }
+                if (prop.kind === 254 /* ShorthandPropertyAssignment */ && !inDestructuring && prop.objectAssignmentInitializer) {
+                    // having objectAssignmentInitializer is only valid in ObjectAssignmentPattern
+                    // outside of destructuring it is a syntax error
+                    return { value: grammarErrorOnNode(prop.equalsToken, ts.Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment) };
+                }
+                // Modifiers are never allowed on properties except for 'async' on a method declaration
+                ts.forEach(prop.modifiers, function (mod) {
+                    if (mod.kind !== 118 /* AsyncKeyword */ || prop.kind !== 147 /* MethodDeclaration */) {
+                        grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod));
+                    }
+                });
+                // ECMA-262 11.1.5 Object Initializer
+                // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
+                // a.This production is contained in strict code and IsDataDescriptor(previous) is true and
+                // IsDataDescriptor(propId.descriptor) is true.
+                //    b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true.
+                //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
+                //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
+                // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
+                var currentKind = void 0;
+                if (prop.kind === 253 /* PropertyAssignment */ || prop.kind === 254 /* ShorthandPropertyAssignment */) {
+                    // Grammar checking for computedPropertyName and shorthandPropertyAssignment
+                    checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional);
+                    if (name_21.kind === 8 /* NumericLiteral */) {
+                        checkGrammarNumericLiteral(name_21);
+                    }
+                    currentKind = Property;
+                }
+                else if (prop.kind === 147 /* MethodDeclaration */) {
+                    currentKind = Property;
+                }
+                else if (prop.kind === 149 /* GetAccessor */) {
+                    currentKind = GetAccessor;
+                }
+                else if (prop.kind === 150 /* SetAccessor */) {
+                    currentKind = SetAccessor;
+                }
+                else {
+                    ts.Debug.fail("Unexpected syntax kind:" + prop.kind);
+                }
+                var effectiveName = ts.getPropertyNameForPropertyNameNode(name_21);
+                if (effectiveName === undefined) {
+                    return "continue";
+                }
+                if (!ts.hasProperty(seen, effectiveName)) {
+                    seen[effectiveName] = currentKind;
+                }
+                else {
+                    var existingKind = seen[effectiveName];
+                    if (currentKind === Property && existingKind === Property) {
+                        grammarErrorOnNode(name_21, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name_21));
+                    }
+                    else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) {
+                        if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) {
+                            seen[effectiveName] = currentKind | existingKind;
+                        }
+                        else {
+                            return { value: grammarErrorOnNode(name_21, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name) };
+                        }
+                    }
+                    else {
+                        return { value: grammarErrorOnNode(name_21, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name) };
+                    }
+                }
+            };
+            for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+                var prop = _a[_i];
+                var state_3 = _loop_2(prop);
+                if (typeof state_3 === "object") return state_3.value;
+            }
+        }
+        function checkGrammarJsxElement(node) {
+            var seen = {};
+            for (var _i = 0, _a = node.attributes; _i < _a.length; _i++) {
+                var attr = _a[_i];
+                if (attr.kind === 247 /* JsxSpreadAttribute */) {
+                    continue;
+                }
+                var jsxAttr = attr;
+                var name_22 = jsxAttr.name;
+                if (!ts.hasProperty(seen, name_22.text)) {
+                    seen[name_22.text] = true;
+                }
+                else {
+                    return grammarErrorOnNode(name_22, ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
+                }
+                var initializer = jsxAttr.initializer;
+                if (initializer && initializer.kind === 248 /* JsxExpression */ && !initializer.expression) {
+                    return grammarErrorOnNode(jsxAttr.initializer, ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
+                }
+            }
+        }
+        function checkGrammarForInOrForOfStatement(forInOrOfStatement) {
+            if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {
+                return true;
+            }
+            if (forInOrOfStatement.initializer.kind === 219 /* VariableDeclarationList */) {
+                var variableList = forInOrOfStatement.initializer;
+                if (!checkGrammarVariableDeclarationList(variableList)) {
+                    var declarations = variableList.declarations;
+                    // declarations.length can be zero if there is an error in variable declaration in for-of or for-in
+                    // See http://www.ecma-international.org/ecma-262/6.0/#sec-for-in-and-for-of-statements for details
+                    // For example:
+                    //      var let = 10;
+                    //      for (let of [1,2,3]) {} // this is invalid ES6 syntax
+                    //      for (let in [1,2,3]) {} // this is invalid ES6 syntax
+                    // We will then want to skip on grammar checking on variableList declaration
+                    if (!declarations.length) {
+                        return false;
+                    }
+                    if (declarations.length > 1) {
+                        var diagnostic = forInOrOfStatement.kind === 207 /* ForInStatement */
+                            ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement
+                            : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
+                        return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
+                    }
+                    var firstDeclaration = declarations[0];
+                    if (firstDeclaration.initializer) {
+                        var diagnostic = forInOrOfStatement.kind === 207 /* ForInStatement */
+                            ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer
+                            : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
+                        return grammarErrorOnNode(firstDeclaration.name, diagnostic);
+                    }
+                    if (firstDeclaration.type) {
+                        var diagnostic = forInOrOfStatement.kind === 207 /* ForInStatement */
+                            ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation
+                            : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation;
+                        return grammarErrorOnNode(firstDeclaration, diagnostic);
+                    }
+                }
+            }
+            return false;
+        }
+        function checkGrammarAccessor(accessor) {
+            var kind = accessor.kind;
+            if (languageVersion < 1 /* ES5 */) {
+                return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
+            }
+            else if (ts.isInAmbientContext(accessor)) {
+                return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_be_declared_in_an_ambient_context);
+            }
+            else if (accessor.body === undefined && !(accessor.flags & 128 /* Abstract */)) {
+                return grammarErrorAtPos(ts.getSourceFileOfNode(accessor), accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
+            }
+            else if (accessor.typeParameters) {
+                return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters);
+            }
+            else if (!doesAccessorHaveCorrectParameterCount(accessor)) {
+                return grammarErrorOnNode(accessor.name, kind === 149 /* GetAccessor */ ?
+                    ts.Diagnostics.A_get_accessor_cannot_have_parameters :
+                    ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
+            }
+            else if (kind === 150 /* SetAccessor */) {
+                if (accessor.type) {
+                    return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
+                }
+                else {
+                    var parameter = accessor.parameters[0];
+                    if (parameter.dotDotDotToken) {
+                        return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
+                    }
+                    else if (parameter.questionToken) {
+                        return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
+                    }
+                    else if (parameter.initializer) {
+                        return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
+                    }
+                }
+            }
+        }
+        /** Does the accessor have the right number of parameters?
+
+            A get accessor has no parameters or a single `this` parameter.
+            A set accessor has one parameter or a `this` parameter and one more parameter */
+        function doesAccessorHaveCorrectParameterCount(accessor) {
+            return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 149 /* GetAccessor */ ? 0 : 1);
+        }
+        function getAccessorThisParameter(accessor) {
+            if (accessor.parameters.length === (accessor.kind === 149 /* GetAccessor */ ? 1 : 2) &&
+                accessor.parameters[0].name.kind === 69 /* Identifier */ &&
+                accessor.parameters[0].name.originalKeywordKind === 97 /* ThisKeyword */) {
+                return accessor.parameters[0];
+            }
+        }
+        function getFunctionLikeThisParameter(func) {
+            if (func.parameters.length &&
+                func.parameters[0].name.kind === 69 /* Identifier */ &&
+                func.parameters[0].name.originalKeywordKind === 97 /* ThisKeyword */) {
+                return func.parameters[0];
+            }
+        }
+        function checkGrammarForNonSymbolComputedProperty(node, message) {
+            if (ts.isDynamicName(node)) {
+                return grammarErrorOnNode(node, message);
+            }
+        }
+        function checkGrammarMethod(node) {
+            if (checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node) ||
+                checkGrammarFunctionLikeDeclaration(node) ||
+                checkGrammarForGenerator(node)) {
+                return true;
+            }
+            if (node.parent.kind === 171 /* ObjectLiteralExpression */) {
+                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional)) {
+                    return true;
+                }
+                else if (node.body === undefined) {
+                    return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
+                }
+            }
+            if (ts.isClassLike(node.parent)) {
+                // Technically, computed properties in ambient contexts is disallowed
+                // for property declarations and accessors too, not just methods.
+                // However, property declarations disallow computed names in general,
+                // and accessors are not allowed in ambient contexts in general,
+                // so this error only really matters for methods.
+                if (ts.isInAmbientContext(node)) {
+                    return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol);
+                }
+                else if (!node.body) {
+                    return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol);
+                }
+            }
+            else if (node.parent.kind === 222 /* InterfaceDeclaration */) {
+                return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol);
+            }
+            else if (node.parent.kind === 159 /* TypeLiteral */) {
+                return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol);
+            }
+        }
+        function checkGrammarBreakOrContinueStatement(node) {
+            var current = node;
+            while (current) {
+                if (ts.isFunctionLike(current)) {
+                    return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary);
+                }
+                switch (current.kind) {
+                    case 214 /* LabeledStatement */:
+                        if (node.label && current.label.text === node.label.text) {
+                            // found matching label - verify that label usage is correct
+                            // continue can only target labels that are on iteration statements
+                            var isMisplacedContinueLabel = node.kind === 209 /* ContinueStatement */
+                                && !ts.isIterationStatement(current.statement, /*lookInLabeledStatement*/ true);
+                            if (isMisplacedContinueLabel) {
+                                return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
+                            }
+                            return false;
+                        }
+                        break;
+                    case 213 /* SwitchStatement */:
+                        if (node.kind === 210 /* BreakStatement */ && !node.label) {
+                            // unlabeled break within switch statement - ok
+                            return false;
+                        }
+                        break;
+                    default:
+                        if (ts.isIterationStatement(current, /*lookInLabeledStatement*/ false) && !node.label) {
+                            // unlabeled break or continue within iteration statement - ok
+                            return false;
+                        }
+                        break;
+                }
+                current = current.parent;
+            }
+            if (node.label) {
+                var message = node.kind === 210 /* BreakStatement */
+                    ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
+                    : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
+                return grammarErrorOnNode(node, message);
+            }
+            else {
+                var message = node.kind === 210 /* BreakStatement */
+                    ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
+                    : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
+                return grammarErrorOnNode(node, message);
+            }
+        }
+        function checkGrammarBindingElement(node) {
+            if (node.dotDotDotToken) {
+                var elements = node.parent.elements;
+                if (node !== ts.lastOrUndefined(elements)) {
+                    return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
+                }
+                if (node.name.kind === 168 /* ArrayBindingPattern */ || node.name.kind === 167 /* ObjectBindingPattern */) {
+                    return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
+                }
+                if (node.initializer) {
+                    // Error on equals token which immediate precedes the initializer
+                    return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
+                }
+            }
+        }
+        function checkGrammarVariableDeclaration(node) {
+            if (node.parent.parent.kind !== 207 /* ForInStatement */ && node.parent.parent.kind !== 208 /* ForOfStatement */) {
+                if (ts.isInAmbientContext(node)) {
+                    if (node.initializer) {
+                        // Error on equals token which immediate precedes the initializer
+                        var equalsTokenLength = "=".length;
+                        return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - equalsTokenLength, equalsTokenLength, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+                    }
+                }
+                else if (!node.initializer) {
+                    if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) {
+                        return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer);
+                    }
+                    if (ts.isConst(node)) {
+                        return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized);
+                    }
+                }
+            }
+            var checkLetConstNames = (ts.isLet(node) || ts.isConst(node));
+            // 1. LexicalDeclaration : LetOrConst BindingList ;
+            // It is a Syntax Error if the BoundNames of BindingList contains "let".
+            // 2. ForDeclaration: ForDeclaration : LetOrConst ForBinding
+            // It is a Syntax Error if the BoundNames of ForDeclaration contains "let".
+            // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code
+            // and its Identifier is eval or arguments
+            return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name);
+        }
+        function checkGrammarNameInLetOrConstDeclarations(name) {
+            if (name.kind === 69 /* Identifier */) {
+                if (name.originalKeywordKind === 108 /* LetKeyword */) {
+                    return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
+                }
+            }
+            else {
+                var elements = name.elements;
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
+                    if (element.kind !== 193 /* OmittedExpression */) {
+                        checkGrammarNameInLetOrConstDeclarations(element.name);
+                    }
+                }
+            }
+        }
+        function checkGrammarVariableDeclarationList(declarationList) {
+            var declarations = declarationList.declarations;
+            if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
+                return true;
+            }
+            if (!declarationList.declarations.length) {
+                return grammarErrorAtPos(ts.getSourceFileOfNode(declarationList), declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty);
+            }
+        }
+        function allowLetAndConstDeclarations(parent) {
+            switch (parent.kind) {
+                case 203 /* IfStatement */:
+                case 204 /* DoStatement */:
+                case 205 /* WhileStatement */:
+                case 212 /* WithStatement */:
+                case 206 /* ForStatement */:
+                case 207 /* ForInStatement */:
+                case 208 /* ForOfStatement */:
+                    return false;
+                case 214 /* LabeledStatement */:
+                    return allowLetAndConstDeclarations(parent.parent);
+            }
+            return true;
+        }
+        function checkGrammarForDisallowedLetOrConstStatement(node) {
+            if (!allowLetAndConstDeclarations(node.parent)) {
+                if (ts.isLet(node.declarationList)) {
+                    return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
+                }
+                else if (ts.isConst(node.declarationList)) {
+                    return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
+                }
+            }
+        }
+        function hasParseDiagnostics(sourceFile) {
+            return sourceFile.parseDiagnostics.length > 0;
+        }
+        function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+            var sourceFile = ts.getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+                diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+        function grammarErrorAtPos(sourceFile, start, length, message, arg0, arg1, arg2) {
+            if (!hasParseDiagnostics(sourceFile)) {
+                diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+        function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
+            var sourceFile = ts.getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                diagnostics.add(ts.createDiagnosticForNode(node, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+        function checkGrammarConstructorTypeParameters(node) {
+            if (node.typeParameters) {
+                return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
+            }
+        }
+        function checkGrammarConstructorTypeAnnotation(node) {
+            if (node.type) {
+                return grammarErrorOnNode(node.type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
+            }
+        }
+        function checkGrammarProperty(node) {
+            if (ts.isClassLike(node.parent)) {
+                if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) {
+                    return true;
+                }
+            }
+            else if (node.parent.kind === 222 /* InterfaceDeclaration */) {
+                if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) {
+                    return true;
+                }
+                if (node.initializer) {
+                    return grammarErrorOnNode(node.initializer, ts.Diagnostics.An_interface_property_cannot_have_an_initializer);
+                }
+            }
+            else if (node.parent.kind === 159 /* TypeLiteral */) {
+                if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) {
+                    return true;
+                }
+                if (node.initializer) {
+                    return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer);
+                }
+            }
+            if (ts.isInAmbientContext(node) && node.initializer) {
+                return grammarErrorOnFirstToken(node.initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+            }
+        }
+        function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
+            // A declare modifier is required for any top level .d.ts declaration except export=, export default,
+            // interfaces and imports categories:
+            //
+            //  DeclarationElement:
+            //     ExportAssignment
+            //     export_opt   InterfaceDeclaration
+            //     export_opt   TypeAliasDeclaration
+            //     export_opt   ImportDeclaration
+            //     export_opt   ExternalImportDeclaration
+            //     export_opt   AmbientDeclaration
+            //
+            // TODO: The spec needs to be amended to reflect this grammar.
+            if (node.kind === 222 /* InterfaceDeclaration */ ||
+                node.kind === 223 /* TypeAliasDeclaration */ ||
+                node.kind === 230 /* ImportDeclaration */ ||
+                node.kind === 229 /* ImportEqualsDeclaration */ ||
+                node.kind === 236 /* ExportDeclaration */ ||
+                node.kind === 235 /* ExportAssignment */ ||
+                (node.flags & 2 /* Ambient */) ||
+                (node.flags & (1 /* Export */ | 512 /* Default */))) {
+                return false;
+            }
+            return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
+        }
+        function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) {
+            for (var _i = 0, _a = file.statements; _i < _a.length; _i++) {
+                var decl = _a[_i];
+                if (ts.isDeclaration(decl) || decl.kind === 200 /* VariableStatement */) {
+                    if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        function checkGrammarSourceFile(node) {
+            return ts.isInAmbientContext(node) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
+        }
+        function checkGrammarStatementInAmbientContext(node) {
+            if (ts.isInAmbientContext(node)) {
+                // An accessors is already reported about the ambient context
+                if (isAccessor(node.parent.kind)) {
+                    return getNodeLinks(node).hasReportedStatementInAmbientContext = true;
+                }
+                // Find containing block which is either Block, ModuleBlock, SourceFile
+                var links = getNodeLinks(node);
+                if (!links.hasReportedStatementInAmbientContext && ts.isFunctionLike(node.parent)) {
+                    return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
+                }
+                // We are either parented by another statement, or some sort of block.
+                // If we're in a block, we only want to really report an error once
+                // to prevent noisiness.  So use a bit on the block to indicate if
+                // this has already been reported, and don't report if it has.
+                //
+                if (node.parent.kind === 199 /* Block */ || node.parent.kind === 226 /* ModuleBlock */ || node.parent.kind === 256 /* SourceFile */) {
+                    var links_1 = getNodeLinks(node.parent);
+                    // Check if the containing block ever report this error
+                    if (!links_1.hasReportedStatementInAmbientContext) {
+                        return links_1.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
+                    }
+                }
+                else {
+                }
+            }
+        }
+        function checkGrammarNumericLiteral(node) {
+            // Grammar checking
+            if (node.isOctalLiteral && languageVersion >= 1 /* ES5 */) {
+                return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
+            }
+        }
+        function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
+            var sourceFile = ts.getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+                diagnostics.add(ts.createFileDiagnostic(sourceFile, ts.textSpanEnd(span), /*length*/ 0, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+        var _a;
+    }
+    ts.createTypeChecker = createTypeChecker;
+})(ts || (ts = {}));
+/// <reference path="checker.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var nullSourceMapWriter;
+    // Used for initialize lastEncodedSourceMapSpan and reset lastEncodedSourceMapSpan when updateLastEncodedAndRecordedSpans
+    var defaultLastEncodedSourceMapSpan = {
+        emittedLine: 1,
+        emittedColumn: 1,
+        sourceLine: 1,
+        sourceColumn: 1,
+        sourceIndex: 0
+    };
+    function getNullSourceMapWriter() {
+        if (nullSourceMapWriter === undefined) {
+            nullSourceMapWriter = {
+                getSourceMapData: function () { return undefined; },
+                setSourceFile: function (sourceFile) { },
+                emitStart: function (range) { },
+                emitEnd: function (range, stopOverridingSpan) { },
+                emitPos: function (pos) { },
+                changeEmitSourcePos: function () { },
+                getText: function () { return undefined; },
+                getSourceMappingURL: function () { return undefined; },
+                initialize: function (filePath, sourceMapFilePath, sourceFiles, isBundledEmit) { },
+                reset: function () { }
+            };
+        }
+        return nullSourceMapWriter;
+    }
+    ts.getNullSourceMapWriter = getNullSourceMapWriter;
+    function createSourceMapWriter(host, writer) {
+        var compilerOptions = host.getCompilerOptions();
+        var currentSourceFile;
+        var sourceMapDir; // The directory in which sourcemap will be
+        var stopOverridingSpan = false;
+        var modifyLastSourcePos = false;
+        // Current source map file and its index in the sources list
+        var sourceMapSourceIndex;
+        // Last recorded and encoded spans
+        var lastRecordedSourceMapSpan;
+        var lastEncodedSourceMapSpan;
+        var lastEncodedNameIndex;
+        // Source map data
+        var sourceMapData;
+        return {
+            getSourceMapData: function () { return sourceMapData; },
+            setSourceFile: setSourceFile,
+            emitPos: emitPos,
+            emitStart: emitStart,
+            emitEnd: emitEnd,
+            changeEmitSourcePos: changeEmitSourcePos,
+            getText: getText,
+            getSourceMappingURL: getSourceMappingURL,
+            initialize: initialize,
+            reset: reset
+        };
+        function initialize(filePath, sourceMapFilePath, sourceFiles, isBundledEmit) {
+            if (sourceMapData) {
+                reset();
+            }
+            currentSourceFile = undefined;
+            // Current source map file and its index in the sources list
+            sourceMapSourceIndex = -1;
+            // Last recorded and encoded spans
+            lastRecordedSourceMapSpan = undefined;
+            lastEncodedSourceMapSpan = defaultLastEncodedSourceMapSpan;
+            lastEncodedNameIndex = 0;
+            // Initialize source map data
+            sourceMapData = {
+                sourceMapFilePath: sourceMapFilePath,
+                jsSourceMappingURL: !compilerOptions.inlineSourceMap ? ts.getBaseFileName(ts.normalizeSlashes(sourceMapFilePath)) : undefined,
+                sourceMapFile: ts.getBaseFileName(ts.normalizeSlashes(filePath)),
+                sourceMapSourceRoot: compilerOptions.sourceRoot || "",
+                sourceMapSources: [],
+                inputSourceFileNames: [],
+                sourceMapNames: [],
+                sourceMapMappings: "",
+                sourceMapSourcesContent: compilerOptions.inlineSources ? [] : undefined,
+                sourceMapDecodedMappings: []
+            };
+            // Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the
+            // relative paths of the sources list in the sourcemap
+            sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot);
+            if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== 47 /* slash */) {
+                sourceMapData.sourceMapSourceRoot += ts.directorySeparator;
+            }
+            if (compilerOptions.mapRoot) {
+                sourceMapDir = ts.normalizeSlashes(compilerOptions.mapRoot);
+                if (!isBundledEmit) {
+                    ts.Debug.assert(sourceFiles.length === 1);
+                    // For modules or multiple emit files the mapRoot will have directory structure like the sources
+                    // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map
+                    sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(sourceFiles[0], host, sourceMapDir));
+                }
+                if (!ts.isRootedDiskPath(sourceMapDir) && !ts.isUrl(sourceMapDir)) {
+                    // The relative paths are relative to the common directory
+                    sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
+                    sourceMapData.jsSourceMappingURL = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(filePath)), // get the relative sourceMapDir path based on jsFilePath
+                    ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap
+                    host.getCurrentDirectory(), host.getCanonicalFileName, 
+                    /*isAbsolutePathAnUrl*/ true);
+                }
+                else {
+                    sourceMapData.jsSourceMappingURL = ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL);
+                }
+            }
+            else {
+                sourceMapDir = ts.getDirectoryPath(ts.normalizePath(filePath));
+            }
+        }
+        function reset() {
+            currentSourceFile = undefined;
+            sourceMapDir = undefined;
+            sourceMapSourceIndex = undefined;
+            lastRecordedSourceMapSpan = undefined;
+            lastEncodedSourceMapSpan = undefined;
+            lastEncodedNameIndex = undefined;
+            sourceMapData = undefined;
+        }
+        function updateLastEncodedAndRecordedSpans() {
+            if (modifyLastSourcePos) {
+                // Reset the source pos
+                modifyLastSourcePos = false;
+                // Change Last recorded Map with last encoded emit line and character
+                lastRecordedSourceMapSpan.emittedLine = lastEncodedSourceMapSpan.emittedLine;
+                lastRecordedSourceMapSpan.emittedColumn = lastEncodedSourceMapSpan.emittedColumn;
+                // Pop sourceMapDecodedMappings to remove last entry
+                sourceMapData.sourceMapDecodedMappings.pop();
+                // Point the lastEncodedSourceMapSpace to the previous encoded sourceMapSpan
+                // If the list is empty which indicates that we are at the beginning of the file,
+                // we have to reset it to default value (same value when we first initialize sourceMapWriter)
+                lastEncodedSourceMapSpan = sourceMapData.sourceMapDecodedMappings.length ?
+                    sourceMapData.sourceMapDecodedMappings[sourceMapData.sourceMapDecodedMappings.length - 1] :
+                    defaultLastEncodedSourceMapSpan;
+                // TODO: Update lastEncodedNameIndex
+                // Since we dont support this any more, lets not worry about it right now.
+                // When we start supporting nameIndex, we will get back to this
+                // Change the encoded source map
+                var sourceMapMappings = sourceMapData.sourceMapMappings;
+                var lenthToSet = sourceMapMappings.length - 1;
+                for (; lenthToSet >= 0; lenthToSet--) {
+                    var currentChar = sourceMapMappings.charAt(lenthToSet);
+                    if (currentChar === ",") {
+                        // Separator for the entry found
+                        break;
+                    }
+                    if (currentChar === ";" && lenthToSet !== 0 && sourceMapMappings.charAt(lenthToSet - 1) !== ";") {
+                        // Last line separator found
+                        break;
+                    }
+                }
+                sourceMapData.sourceMapMappings = sourceMapMappings.substr(0, Math.max(0, lenthToSet));
+            }
+        }
+        // Encoding for sourcemap span
+        function encodeLastRecordedSourceMapSpan() {
+            if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) {
+                return;
+            }
+            var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn;
+            // Line/Comma delimiters
+            if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) {
+                // Emit comma to separate the entry
+                if (sourceMapData.sourceMapMappings) {
+                    sourceMapData.sourceMapMappings += ",";
+                }
+            }
+            else {
+                // Emit line delimiters
+                for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) {
+                    sourceMapData.sourceMapMappings += ";";
+                }
+                prevEncodedEmittedColumn = 1;
+            }
+            // 1. Relative Column 0 based
+            sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn);
+            // 2. Relative sourceIndex
+            sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex);
+            // 3. Relative sourceLine 0 based
+            sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine);
+            // 4. Relative sourceColumn 0 based
+            sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn);
+            // 5. Relative namePosition 0 based
+            if (lastRecordedSourceMapSpan.nameIndex >= 0) {
+                ts.Debug.assert(false, "We do not support name index right now, Make sure to update updateLastEncodedAndRecordedSpans when we start using this");
+                sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex);
+                lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex;
+            }
+            lastEncodedSourceMapSpan = lastRecordedSourceMapSpan;
+            sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan);
+        }
+        function emitPos(pos) {
+            if (pos === -1) {
+                return;
+            }
+            var sourceLinePos = ts.getLineAndCharacterOfPosition(currentSourceFile, pos);
+            // Convert the location to be one-based.
+            sourceLinePos.line++;
+            sourceLinePos.character++;
+            var emittedLine = writer.getLine();
+            var emittedColumn = writer.getColumn();
+            // If this location wasn't recorded or the location in source is going backwards, record the span
+            if (!lastRecordedSourceMapSpan ||
+                lastRecordedSourceMapSpan.emittedLine !== emittedLine ||
+                lastRecordedSourceMapSpan.emittedColumn !== emittedColumn ||
+                (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex &&
+                    (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line ||
+                        (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) {
+                // Encode the last recordedSpan before assigning new
+                encodeLastRecordedSourceMapSpan();
+                // New span
+                lastRecordedSourceMapSpan = {
+                    emittedLine: emittedLine,
+                    emittedColumn: emittedColumn,
+                    sourceLine: sourceLinePos.line,
+                    sourceColumn: sourceLinePos.character,
+                    sourceIndex: sourceMapSourceIndex
+                };
+                stopOverridingSpan = false;
+            }
+            else if (!stopOverridingSpan) {
+                // Take the new pos instead since there is no change in emittedLine and column since last location
+                lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line;
+                lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character;
+                lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex;
+            }
+            updateLastEncodedAndRecordedSpans();
+        }
+        function getStartPos(range) {
+            var rangeHasDecorators = !!range.decorators;
+            return range.pos !== -1 ? ts.skipTrivia(currentSourceFile.text, rangeHasDecorators ? range.decorators.end : range.pos) : -1;
+        }
+        function emitStart(range) {
+            emitPos(getStartPos(range));
+        }
+        function emitEnd(range, stopOverridingEnd) {
+            emitPos(range.end);
+            stopOverridingSpan = stopOverridingEnd;
+        }
+        function changeEmitSourcePos() {
+            ts.Debug.assert(!modifyLastSourcePos);
+            modifyLastSourcePos = true;
+        }
+        function setSourceFile(sourceFile) {
+            currentSourceFile = sourceFile;
+            // Add the file to tsFilePaths
+            // If sourceroot option: Use the relative path corresponding to the common directory path
+            // otherwise source locations relative to map file location
+            var sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;
+            var source = ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, currentSourceFile.fileName, host.getCurrentDirectory(), host.getCanonicalFileName, 
+            /*isAbsolutePathAnUrl*/ true);
+            sourceMapSourceIndex = ts.indexOf(sourceMapData.sourceMapSources, source);
+            if (sourceMapSourceIndex === -1) {
+                sourceMapSourceIndex = sourceMapData.sourceMapSources.length;
+                sourceMapData.sourceMapSources.push(source);
+                // The one that can be used from program to get the actual source file
+                sourceMapData.inputSourceFileNames.push(sourceFile.fileName);
+                if (compilerOptions.inlineSources) {
+                    sourceMapData.sourceMapSourcesContent.push(sourceFile.text);
+                }
+            }
+        }
+        function getText() {
+            encodeLastRecordedSourceMapSpan();
+            return ts.stringify({
+                version: 3,
+                file: sourceMapData.sourceMapFile,
+                sourceRoot: sourceMapData.sourceMapSourceRoot,
+                sources: sourceMapData.sourceMapSources,
+                names: sourceMapData.sourceMapNames,
+                mappings: sourceMapData.sourceMapMappings,
+                sourcesContent: sourceMapData.sourceMapSourcesContent
+            });
+        }
+        function getSourceMappingURL() {
+            if (compilerOptions.inlineSourceMap) {
+                // Encode the sourceMap into the sourceMap url
+                var base64SourceMapText = ts.convertToBase64(getText());
+                return sourceMapData.jsSourceMappingURL = "data:application/json;base64," + base64SourceMapText;
+            }
+            else {
+                return sourceMapData.jsSourceMappingURL;
+            }
+        }
+    }
+    ts.createSourceMapWriter = createSourceMapWriter;
+    var base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    function base64FormatEncode(inValue) {
+        if (inValue < 64) {
+            return base64Chars.charAt(inValue);
+        }
+        throw TypeError(inValue + ": not a 64 based value");
+    }
+    function base64VLQFormatEncode(inValue) {
+        // Add a new least significant bit that has the sign of the value.
+        // if negative number the least significant bit that gets added to the number has value 1
+        // else least significant bit value that gets added is 0
+        // eg. -1 changes to binary : 01 [1] => 3
+        //     +1 changes to binary : 01 [0] => 2
+        if (inValue < 0) {
+            inValue = ((-inValue) << 1) + 1;
+        }
+        else {
+            inValue = inValue << 1;
+        }
+        // Encode 5 bits at a time starting from least significant bits
+        var encodedStr = "";
+        do {
+            var currentDigit = inValue & 31; // 11111
+            inValue = inValue >> 5;
+            if (inValue > 0) {
+                // There are still more digits to decode, set the msb (6th bit)
+                currentDigit = currentDigit | 32;
+            }
+            encodedStr = encodedStr + base64FormatEncode(currentDigit);
+        } while (inValue > 0);
+        return encodedStr;
+    }
+})(ts || (ts = {}));
+/// <reference path="checker.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    function getDeclarationDiagnostics(host, resolver, targetSourceFile) {
+        var declarationDiagnostics = ts.createDiagnosticCollection();
+        ts.forEachExpectedEmitFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
+        return declarationDiagnostics.getDiagnostics(targetSourceFile ? targetSourceFile.fileName : undefined);
+        function getDeclarationDiagnosticsFromFile(_a, sources, isBundledEmit) {
+            var declarationFilePath = _a.declarationFilePath;
+            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sources, isBundledEmit);
+        }
+    }
+    ts.getDeclarationDiagnostics = getDeclarationDiagnostics;
+    function emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit) {
+        var newLine = host.getNewLine();
+        var compilerOptions = host.getCompilerOptions();
+        var write;
+        var writeLine;
+        var increaseIndent;
+        var decreaseIndent;
+        var writeTextOfNode;
+        var writer;
+        createAndSetNewTextWriterWithSymbolWriter();
+        var enclosingDeclaration;
+        var resultHasExternalModuleIndicator;
+        var currentText;
+        var currentLineMap;
+        var currentIdentifiers;
+        var isCurrentFileExternalModule;
+        var reportedDeclarationError = false;
+        var errorNameNode;
+        var emitJsDocComments = compilerOptions.removeComments ? function (declaration) { } : writeJsDocComments;
+        var emit = compilerOptions.stripInternal ? stripInternal : emitNode;
+        var noDeclare;
+        var moduleElementDeclarationEmitInfo = [];
+        var asynchronousSubModuleDeclarationEmitInfo;
+        // Contains the reference paths that needs to go in the declaration file.
+        // Collecting this separately because reference paths need to be first thing in the declaration file
+        // and we could be collecting these paths from multiple files into single one with --out option
+        var referencesOutput = "";
+        var usedTypeDirectiveReferences;
+        // Emit references corresponding to each file
+        var emittedReferencedFiles = [];
+        var addedGlobalFileReference = false;
+        var allSourcesModuleElementDeclarationEmitInfo = [];
+        ts.forEach(sourceFiles, function (sourceFile) {
+            // Dont emit for javascript file
+            if (ts.isSourceFileJavaScript(sourceFile)) {
+                return;
+            }
+            // Check what references need to be added
+            if (!compilerOptions.noResolve) {
+                ts.forEach(sourceFile.referencedFiles, function (fileReference) {
+                    var referencedFile = ts.tryResolveScriptReference(host, sourceFile, fileReference);
+                    // Emit reference in dts, if the file reference was not already emitted
+                    if (referencedFile && !ts.contains(emittedReferencedFiles, referencedFile)) {
+                        // Add a reference to generated dts file,
+                        // global file reference is added only
+                        //  - if it is not bundled emit (because otherwise it would be self reference)
+                        //  - and it is not already added
+                        if (writeReferencePath(referencedFile, !isBundledEmit && !addedGlobalFileReference)) {
+                            addedGlobalFileReference = true;
+                        }
+                        emittedReferencedFiles.push(referencedFile);
+                    }
+                });
+            }
+            resultHasExternalModuleIndicator = false;
+            if (!isBundledEmit || !ts.isExternalModule(sourceFile)) {
+                noDeclare = false;
+                emitSourceFile(sourceFile);
+            }
+            else if (ts.isExternalModule(sourceFile)) {
+                noDeclare = true;
+                write("declare module \"" + ts.getResolvedExternalModuleName(host, sourceFile) + "\" {");
+                writeLine();
+                increaseIndent();
+                emitSourceFile(sourceFile);
+                decreaseIndent();
+                write("}");
+                writeLine();
+            }
+            // create asynchronous output for the importDeclarations
+            if (moduleElementDeclarationEmitInfo.length) {
+                var oldWriter = writer;
+                ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) {
+                    if (aliasEmitInfo.isVisible && !aliasEmitInfo.asynchronousOutput) {
+                        ts.Debug.assert(aliasEmitInfo.node.kind === 230 /* ImportDeclaration */);
+                        createAndSetNewTextWriterWithSymbolWriter();
+                        ts.Debug.assert(aliasEmitInfo.indent === 0 || (aliasEmitInfo.indent === 1 && isBundledEmit));
+                        for (var i = 0; i < aliasEmitInfo.indent; i++) {
+                            increaseIndent();
+                        }
+                        writeImportDeclaration(aliasEmitInfo.node);
+                        aliasEmitInfo.asynchronousOutput = writer.getText();
+                        for (var i = 0; i < aliasEmitInfo.indent; i++) {
+                            decreaseIndent();
+                        }
+                    }
+                });
+                setWriter(oldWriter);
+                allSourcesModuleElementDeclarationEmitInfo = allSourcesModuleElementDeclarationEmitInfo.concat(moduleElementDeclarationEmitInfo);
+                moduleElementDeclarationEmitInfo = [];
+            }
+            if (!isBundledEmit && ts.isExternalModule(sourceFile) && sourceFile.moduleAugmentations.length && !resultHasExternalModuleIndicator) {
+                // if file was external module with augmentations - this fact should be preserved in .d.ts as well.
+                // in case if we didn't write any external module specifiers in .d.ts we need to emit something
+                // that will force compiler to think that this file is an external module - 'export {}' is a reasonable choice here.
+                write("export {};");
+                writeLine();
+            }
+        });
+        if (usedTypeDirectiveReferences) {
+            for (var directive in usedTypeDirectiveReferences) {
+                if (ts.hasProperty(usedTypeDirectiveReferences, directive)) {
+                    referencesOutput += "/// <reference types=\"" + directive + "\" />" + newLine;
+                }
+            }
+        }
+        return {
+            reportedDeclarationError: reportedDeclarationError,
+            moduleElementDeclarationEmitInfo: allSourcesModuleElementDeclarationEmitInfo,
+            synchronousDeclarationOutput: writer.getText(),
+            referencesOutput: referencesOutput
+        };
+        function hasInternalAnnotation(range) {
+            var comment = currentText.substring(range.pos, range.end);
+            return comment.indexOf("@internal") >= 0;
+        }
+        function stripInternal(node) {
+            if (node) {
+                var leadingCommentRanges = ts.getLeadingCommentRanges(currentText, node.pos);
+                if (ts.forEach(leadingCommentRanges, hasInternalAnnotation)) {
+                    return;
+                }
+                emitNode(node);
+            }
+        }
+        function createAndSetNewTextWriterWithSymbolWriter() {
+            var writer = ts.createTextWriter(newLine);
+            writer.trackSymbol = trackSymbol;
+            writer.reportInaccessibleThisError = reportInaccessibleThisError;
+            writer.writeKeyword = writer.write;
+            writer.writeOperator = writer.write;
+            writer.writePunctuation = writer.write;
+            writer.writeSpace = writer.write;
+            writer.writeStringLiteral = writer.writeLiteral;
+            writer.writeParameter = writer.write;
+            writer.writeSymbol = writer.write;
+            setWriter(writer);
+        }
+        function setWriter(newWriter) {
+            writer = newWriter;
+            write = newWriter.write;
+            writeTextOfNode = newWriter.writeTextOfNode;
+            writeLine = newWriter.writeLine;
+            increaseIndent = newWriter.increaseIndent;
+            decreaseIndent = newWriter.decreaseIndent;
+        }
+        function writeAsynchronousModuleElements(nodes) {
+            var oldWriter = writer;
+            ts.forEach(nodes, function (declaration) {
+                var nodeToCheck;
+                if (declaration.kind === 218 /* VariableDeclaration */) {
+                    nodeToCheck = declaration.parent.parent;
+                }
+                else if (declaration.kind === 233 /* NamedImports */ || declaration.kind === 234 /* ImportSpecifier */ || declaration.kind === 231 /* ImportClause */) {
+                    ts.Debug.fail("We should be getting ImportDeclaration instead to write");
+                }
+                else {
+                    nodeToCheck = declaration;
+                }
+                var moduleElementEmitInfo = ts.forEach(moduleElementDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; });
+                if (!moduleElementEmitInfo && asynchronousSubModuleDeclarationEmitInfo) {
+                    moduleElementEmitInfo = ts.forEach(asynchronousSubModuleDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; });
+                }
+                // If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration
+                // then we don't need to write it at this point. We will write it when we actually see its declaration
+                // Eg.
+                // export function bar(a: foo.Foo) { }
+                // import foo = require("foo");
+                // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing,
+                // we would write alias foo declaration when we visit it since it would now be marked as visible
+                if (moduleElementEmitInfo) {
+                    if (moduleElementEmitInfo.node.kind === 230 /* ImportDeclaration */) {
+                        // we have to create asynchronous output only after we have collected complete information
+                        // because it is possible to enable multiple bindings as asynchronously visible
+                        moduleElementEmitInfo.isVisible = true;
+                    }
+                    else {
+                        createAndSetNewTextWriterWithSymbolWriter();
+                        for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) {
+                            increaseIndent();
+                        }
+                        if (nodeToCheck.kind === 225 /* ModuleDeclaration */) {
+                            ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined);
+                            asynchronousSubModuleDeclarationEmitInfo = [];
+                        }
+                        writeModuleElement(nodeToCheck);
+                        if (nodeToCheck.kind === 225 /* ModuleDeclaration */) {
+                            moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo;
+                            asynchronousSubModuleDeclarationEmitInfo = undefined;
+                        }
+                        moduleElementEmitInfo.asynchronousOutput = writer.getText();
+                    }
+                }
+            });
+            setWriter(oldWriter);
+        }
+        function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) {
+            if (!typeReferenceDirectives) {
+                return;
+            }
+            if (!usedTypeDirectiveReferences) {
+                usedTypeDirectiveReferences = {};
+            }
+            for (var _i = 0, typeReferenceDirectives_1 = typeReferenceDirectives; _i < typeReferenceDirectives_1.length; _i++) {
+                var directive = typeReferenceDirectives_1[_i];
+                if (!ts.hasProperty(usedTypeDirectiveReferences, directive)) {
+                    usedTypeDirectiveReferences[directive] = directive;
+                }
+            }
+        }
+        function handleSymbolAccessibilityError(symbolAccessibilityResult) {
+            if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
+                // write the aliases
+                if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
+                    writeAsynchronousModuleElements(symbolAccessibilityResult.aliasesToMakeVisible);
+                }
+            }
+            else {
+                // Report error
+                reportedDeclarationError = true;
+                var errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
+                if (errorInfo) {
+                    if (errorInfo.typeName) {
+                        emitterDiagnostics.add(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, ts.getTextOfNodeFromSourceText(currentText, errorInfo.typeName), symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName));
+                    }
+                    else {
+                        emitterDiagnostics.add(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName));
+                    }
+                }
+            }
+        }
+        function trackSymbol(symbol, enclosingDeclaration, meaning) {
+            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
+            recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
+        }
+        function reportInaccessibleThisError() {
+            if (errorNameNode) {
+                reportedDeclarationError = true;
+                emitterDiagnostics.add(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_this_type_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode)));
+            }
+        }
+        function writeTypeOfDeclaration(declaration, type, getSymbolAccessibilityDiagnostic) {
+            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
+            write(": ");
+            if (type) {
+                // Write the type
+                emitType(type);
+            }
+            else {
+                errorNameNode = declaration.name;
+                resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer);
+                errorNameNode = undefined;
+            }
+        }
+        function writeReturnTypeAtSignature(signature, getSymbolAccessibilityDiagnostic) {
+            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
+            write(": ");
+            if (signature.type) {
+                // Write the type
+                emitType(signature.type);
+            }
+            else {
+                errorNameNode = signature.name;
+                resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer);
+                errorNameNode = undefined;
+            }
+        }
+        function emitLines(nodes) {
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
+                emit(node);
+            }
+        }
+        function emitSeparatedList(nodes, separator, eachNodeEmitFn, canEmitFn) {
+            var currentWriterPos = writer.getTextPos();
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
+                if (!canEmitFn || canEmitFn(node)) {
+                    if (currentWriterPos !== writer.getTextPos()) {
+                        write(separator);
+                    }
+                    currentWriterPos = writer.getTextPos();
+                    eachNodeEmitFn(node);
+                }
+            }
+        }
+        function emitCommaList(nodes, eachNodeEmitFn, canEmitFn) {
+            emitSeparatedList(nodes, ", ", eachNodeEmitFn, canEmitFn);
+        }
+        function writeJsDocComments(declaration) {
+            if (declaration) {
+                var jsDocComments = ts.getJsDocCommentsFromText(declaration, currentText);
+                ts.emitNewLineBeforeLeadingComments(currentLineMap, writer, declaration, jsDocComments);
+                // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
+                ts.emitComments(currentText, currentLineMap, writer, jsDocComments, /*trailingSeparator*/ true, newLine, ts.writeCommentRange);
+            }
+        }
+        function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type, getSymbolAccessibilityDiagnostic) {
+            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
+            emitType(type);
+        }
+        function emitType(type) {
+            switch (type.kind) {
+                case 117 /* AnyKeyword */:
+                case 132 /* StringKeyword */:
+                case 130 /* NumberKeyword */:
+                case 120 /* BooleanKeyword */:
+                case 133 /* SymbolKeyword */:
+                case 103 /* VoidKeyword */:
+                case 135 /* UndefinedKeyword */:
+                case 93 /* NullKeyword */:
+                case 127 /* NeverKeyword */:
+                case 165 /* ThisType */:
+                case 166 /* StringLiteralType */:
+                    return writeTextOfNode(currentText, type);
+                case 194 /* ExpressionWithTypeArguments */:
+                    return emitExpressionWithTypeArguments(type);
+                case 155 /* TypeReference */:
+                    return emitTypeReference(type);
+                case 158 /* TypeQuery */:
+                    return emitTypeQuery(type);
+                case 160 /* ArrayType */:
+                    return emitArrayType(type);
+                case 161 /* TupleType */:
+                    return emitTupleType(type);
+                case 162 /* UnionType */:
+                    return emitUnionType(type);
+                case 163 /* IntersectionType */:
+                    return emitIntersectionType(type);
+                case 164 /* ParenthesizedType */:
+                    return emitParenType(type);
+                case 156 /* FunctionType */:
+                case 157 /* ConstructorType */:
+                    return emitSignatureDeclarationWithJsDocComments(type);
+                case 159 /* TypeLiteral */:
+                    return emitTypeLiteral(type);
+                case 69 /* Identifier */:
+                    return emitEntityName(type);
+                case 139 /* QualifiedName */:
+                    return emitEntityName(type);
+                case 154 /* TypePredicate */:
+                    return emitTypePredicate(type);
+            }
+            function writeEntityName(entityName) {
+                if (entityName.kind === 69 /* Identifier */) {
+                    writeTextOfNode(currentText, entityName);
+                }
+                else {
+                    var left = entityName.kind === 139 /* QualifiedName */ ? entityName.left : entityName.expression;
+                    var right = entityName.kind === 139 /* QualifiedName */ ? entityName.right : entityName.name;
+                    writeEntityName(left);
+                    write(".");
+                    writeTextOfNode(currentText, right);
+                }
+            }
+            function emitEntityName(entityName) {
+                var visibilityResult = resolver.isEntityNameVisible(entityName, 
+                // Aliases can be written asynchronously so use correct enclosing declaration
+                entityName.parent.kind === 229 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration);
+                handleSymbolAccessibilityError(visibilityResult);
+                recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));
+                writeEntityName(entityName);
+            }
+            function emitExpressionWithTypeArguments(node) {
+                if (ts.isSupportedExpressionWithTypeArguments(node)) {
+                    ts.Debug.assert(node.expression.kind === 69 /* Identifier */ || node.expression.kind === 172 /* PropertyAccessExpression */);
+                    emitEntityName(node.expression);
+                    if (node.typeArguments) {
+                        write("<");
+                        emitCommaList(node.typeArguments, emitType);
+                        write(">");
+                    }
+                }
+            }
+            function emitTypeReference(type) {
+                emitEntityName(type.typeName);
+                if (type.typeArguments) {
+                    write("<");
+                    emitCommaList(type.typeArguments, emitType);
+                    write(">");
+                }
+            }
+            function emitTypePredicate(type) {
+                writeTextOfNode(currentText, type.parameterName);
+                write(" is ");
+                emitType(type.type);
+            }
+            function emitTypeQuery(type) {
+                write("typeof ");
+                emitEntityName(type.exprName);
+            }
+            function emitArrayType(type) {
+                emitType(type.elementType);
+                write("[]");
+            }
+            function emitTupleType(type) {
+                write("[");
+                emitCommaList(type.elementTypes, emitType);
+                write("]");
+            }
+            function emitUnionType(type) {
+                emitSeparatedList(type.types, " | ", emitType);
+            }
+            function emitIntersectionType(type) {
+                emitSeparatedList(type.types, " & ", emitType);
+            }
+            function emitParenType(type) {
+                write("(");
+                emitType(type.type);
+                write(")");
+            }
+            function emitTypeLiteral(type) {
+                write("{");
+                if (type.members.length) {
+                    writeLine();
+                    increaseIndent();
+                    // write members
+                    emitLines(type.members);
+                    decreaseIndent();
+                }
+                write("}");
+            }
+        }
+        function emitSourceFile(node) {
+            currentText = node.text;
+            currentLineMap = ts.getLineStarts(node);
+            currentIdentifiers = node.identifiers;
+            isCurrentFileExternalModule = ts.isExternalModule(node);
+            enclosingDeclaration = node;
+            ts.emitDetachedComments(currentText, currentLineMap, writer, ts.writeCommentRange, node, newLine, true /* remove comments */);
+            emitLines(node.statements);
+        }
+        // Return a temp variable name to be used in `export default` statements.
+        // The temp name will be of the form _default_counter.
+        // Note that export default is only allowed at most once in a module, so we
+        // do not need to keep track of created temp names.
+        function getExportDefaultTempVariableName() {
+            var baseName = "_default";
+            if (!ts.hasProperty(currentIdentifiers, baseName)) {
+                return baseName;
+            }
+            var count = 0;
+            while (true) {
+                count++;
+                var name_23 = baseName + "_" + count;
+                if (!ts.hasProperty(currentIdentifiers, name_23)) {
+                    return name_23;
+                }
+            }
+        }
+        function emitExportAssignment(node) {
+            if (node.expression.kind === 69 /* Identifier */) {
+                write(node.isExportEquals ? "export = " : "export default ");
+                writeTextOfNode(currentText, node.expression);
+            }
+            else {
+                // Expression
+                var tempVarName = getExportDefaultTempVariableName();
+                if (!noDeclare) {
+                    write("declare ");
+                }
+                write("var ");
+                write(tempVarName);
+                write(": ");
+                writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;
+                resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer);
+                write(";");
+                writeLine();
+                write(node.isExportEquals ? "export = " : "export default ");
+                write(tempVarName);
+            }
+            write(";");
+            writeLine();
+            // Make all the declarations visible for the export name
+            if (node.expression.kind === 69 /* Identifier */) {
+                var nodes = resolver.collectLinkedAliases(node.expression);
+                // write each of these declarations asynchronously
+                writeAsynchronousModuleElements(nodes);
+            }
+            function getDefaultExportAccessibilityDiagnostic(diagnostic) {
+                return {
+                    diagnosticMessage: ts.Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
+                    errorNode: node
+                };
+            }
+        }
+        function isModuleElementVisible(node) {
+            return resolver.isDeclarationVisible(node);
+        }
+        function emitModuleElement(node, isModuleElementVisible) {
+            if (isModuleElementVisible) {
+                writeModuleElement(node);
+            }
+            else if (node.kind === 229 /* ImportEqualsDeclaration */ ||
+                (node.parent.kind === 256 /* SourceFile */ && isCurrentFileExternalModule)) {
+                var isVisible = void 0;
+                if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 256 /* SourceFile */) {
+                    // Import declaration of another module that is visited async so lets put it in right spot
+                    asynchronousSubModuleDeclarationEmitInfo.push({
+                        node: node,
+                        outputPos: writer.getTextPos(),
+                        indent: writer.getIndent(),
+                        isVisible: isVisible
+                    });
+                }
+                else {
+                    if (node.kind === 230 /* ImportDeclaration */) {
+                        var importDeclaration = node;
+                        if (importDeclaration.importClause) {
+                            isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
+                                isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
+                        }
+                    }
+                    moduleElementDeclarationEmitInfo.push({
+                        node: node,
+                        outputPos: writer.getTextPos(),
+                        indent: writer.getIndent(),
+                        isVisible: isVisible
+                    });
+                }
+            }
+        }
+        function writeModuleElement(node) {
+            switch (node.kind) {
+                case 220 /* FunctionDeclaration */:
+                    return writeFunctionDeclaration(node);
+                case 200 /* VariableStatement */:
+                    return writeVariableStatement(node);
+                case 222 /* InterfaceDeclaration */:
+                    return writeInterfaceDeclaration(node);
+                case 221 /* ClassDeclaration */:
+                    return writeClassDeclaration(node);
+                case 223 /* TypeAliasDeclaration */:
+                    return writeTypeAliasDeclaration(node);
+                case 224 /* EnumDeclaration */:
+                    return writeEnumDeclaration(node);
+                case 225 /* ModuleDeclaration */:
+                    return writeModuleDeclaration(node);
+                case 229 /* ImportEqualsDeclaration */:
+                    return writeImportEqualsDeclaration(node);
+                case 230 /* ImportDeclaration */:
+                    return writeImportDeclaration(node);
+                default:
+                    ts.Debug.fail("Unknown symbol kind");
+            }
+        }
+        function emitModuleElementDeclarationFlags(node) {
+            // If the node is parented in the current source file we need to emit export declare or just export
+            if (node.parent.kind === 256 /* SourceFile */) {
+                // If the node is exported
+                if (node.flags & 1 /* Export */) {
+                    write("export ");
+                }
+                if (node.flags & 512 /* Default */) {
+                    write("default ");
+                }
+                else if (node.kind !== 222 /* InterfaceDeclaration */ && !noDeclare) {
+                    write("declare ");
+                }
+            }
+        }
+        function emitClassMemberDeclarationFlags(flags) {
+            if (flags & 8 /* Private */) {
+                write("private ");
+            }
+            else if (flags & 16 /* Protected */) {
+                write("protected ");
+            }
+            if (flags & 32 /* Static */) {
+                write("static ");
+            }
+            if (flags & 64 /* Readonly */) {
+                write("readonly ");
+            }
+            if (flags & 128 /* Abstract */) {
+                write("abstract ");
+            }
+        }
+        function writeImportEqualsDeclaration(node) {
+            // note usage of writer. methods instead of aliases created, just to make sure we are using
+            // correct writer especially to handle asynchronous alias writing
+            emitJsDocComments(node);
+            if (node.flags & 1 /* Export */) {
+                write("export ");
+            }
+            write("import ");
+            writeTextOfNode(currentText, node.name);
+            write(" = ");
+            if (ts.isInternalModuleImportEqualsDeclaration(node)) {
+                emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.moduleReference, getImportEntityNameVisibilityError);
+                write(";");
+            }
+            else {
+                write("require(");
+                emitExternalModuleSpecifier(node);
+                write(");");
+            }
+            writer.writeLine();
+            function getImportEntityNameVisibilityError(symbolAccessibilityResult) {
+                return {
+                    diagnosticMessage: ts.Diagnostics.Import_declaration_0_is_using_private_name_1,
+                    errorNode: node,
+                    typeName: node.name
+                };
+            }
+        }
+        function isVisibleNamedBinding(namedBindings) {
+            if (namedBindings) {
+                if (namedBindings.kind === 232 /* NamespaceImport */) {
+                    return resolver.isDeclarationVisible(namedBindings);
+                }
+                else {
+                    return ts.forEach(namedBindings.elements, function (namedImport) { return resolver.isDeclarationVisible(namedImport); });
+                }
+            }
+        }
+        function writeImportDeclaration(node) {
+            emitJsDocComments(node);
+            if (node.flags & 1 /* Export */) {
+                write("export ");
+            }
+            write("import ");
+            if (node.importClause) {
+                var currentWriterPos = writer.getTextPos();
+                if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {
+                    writeTextOfNode(currentText, node.importClause.name);
+                }
+                if (node.importClause.namedBindings && isVisibleNamedBinding(node.importClause.namedBindings)) {
+                    if (currentWriterPos !== writer.getTextPos()) {
+                        // If the default binding was emitted, write the separated
+                        write(", ");
+                    }
+                    if (node.importClause.namedBindings.kind === 232 /* NamespaceImport */) {
+                        write("* as ");
+                        writeTextOfNode(currentText, node.importClause.namedBindings.name);
+                    }
+                    else {
+                        write("{ ");
+                        emitCommaList(node.importClause.namedBindings.elements, emitImportOrExportSpecifier, resolver.isDeclarationVisible);
+                        write(" }");
+                    }
+                }
+                write(" from ");
+            }
+            emitExternalModuleSpecifier(node);
+            write(";");
+            writer.writeLine();
+        }
+        function emitExternalModuleSpecifier(parent) {
+            // emitExternalModuleSpecifier is usually called when we emit something in the.d.ts file that will make it an external module (i.e. import/export declarations).
+            // the only case when it is not true is when we call it to emit correct name for module augmentation - d.ts files with just module augmentations are not considered
+            // external modules since they are indistinguishable from script files with ambient modules. To fix this in such d.ts files we'll emit top level 'export {}'
+            // so compiler will treat them as external modules.
+            resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent.kind !== 225 /* ModuleDeclaration */;
+            var moduleSpecifier;
+            if (parent.kind === 229 /* ImportEqualsDeclaration */) {
+                var node = parent;
+                moduleSpecifier = ts.getExternalModuleImportEqualsDeclarationExpression(node);
+            }
+            else if (parent.kind === 225 /* ModuleDeclaration */) {
+                moduleSpecifier = parent.name;
+            }
+            else {
+                var node = parent;
+                moduleSpecifier = node.moduleSpecifier;
+            }
+            if (moduleSpecifier.kind === 9 /* StringLiteral */ && isBundledEmit && (compilerOptions.out || compilerOptions.outFile)) {
+                var moduleName = ts.getExternalModuleNameFromDeclaration(host, resolver, parent);
+                if (moduleName) {
+                    write('"');
+                    write(moduleName);
+                    write('"');
+                    return;
+                }
+            }
+            writeTextOfNode(currentText, moduleSpecifier);
+        }
+        function emitImportOrExportSpecifier(node) {
+            if (node.propertyName) {
+                writeTextOfNode(currentText, node.propertyName);
+                write(" as ");
+            }
+            writeTextOfNode(currentText, node.name);
+        }
+        function emitExportSpecifier(node) {
+            emitImportOrExportSpecifier(node);
+            // Make all the declarations visible for the export name
+            var nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
+            // write each of these declarations asynchronously
+            writeAsynchronousModuleElements(nodes);
+        }
+        function emitExportDeclaration(node) {
+            emitJsDocComments(node);
+            write("export ");
+            if (node.exportClause) {
+                write("{ ");
+                emitCommaList(node.exportClause.elements, emitExportSpecifier);
+                write(" }");
+            }
+            else {
+                write("*");
+            }
+            if (node.moduleSpecifier) {
+                write(" from ");
+                emitExternalModuleSpecifier(node);
+            }
+            write(";");
+            writer.writeLine();
+        }
+        function writeModuleDeclaration(node) {
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            if (ts.isGlobalScopeAugmentation(node)) {
+                write("global ");
+            }
+            else {
+                if (node.flags & 4096 /* Namespace */) {
+                    write("namespace ");
+                }
+                else {
+                    write("module ");
+                }
+                if (ts.isExternalModuleAugmentation(node)) {
+                    emitExternalModuleSpecifier(node);
+                }
+                else {
+                    writeTextOfNode(currentText, node.name);
+                }
+            }
+            while (node.body && node.body.kind !== 226 /* ModuleBlock */) {
+                node = node.body;
+                write(".");
+                writeTextOfNode(currentText, node.name);
+            }
+            var prevEnclosingDeclaration = enclosingDeclaration;
+            if (node.body) {
+                enclosingDeclaration = node;
+                write(" {");
+                writeLine();
+                increaseIndent();
+                emitLines(node.body.statements);
+                decreaseIndent();
+                write("}");
+                writeLine();
+                enclosingDeclaration = prevEnclosingDeclaration;
+            }
+            else {
+                write(";");
+            }
+        }
+        function writeTypeAliasDeclaration(node) {
+            var prevEnclosingDeclaration = enclosingDeclaration;
+            enclosingDeclaration = node;
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            write("type ");
+            writeTextOfNode(currentText, node.name);
+            emitTypeParameters(node.typeParameters);
+            write(" = ");
+            emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.type, getTypeAliasDeclarationVisibilityError);
+            write(";");
+            writeLine();
+            enclosingDeclaration = prevEnclosingDeclaration;
+            function getTypeAliasDeclarationVisibilityError(symbolAccessibilityResult) {
+                return {
+                    diagnosticMessage: ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
+                    errorNode: node.type,
+                    typeName: node.name
+                };
+            }
+        }
+        function writeEnumDeclaration(node) {
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            if (ts.isConst(node)) {
+                write("const ");
+            }
+            write("enum ");
+            writeTextOfNode(currentText, node.name);
+            write(" {");
+            writeLine();
+            increaseIndent();
+            emitLines(node.members);
+            decreaseIndent();
+            write("}");
+            writeLine();
+        }
+        function emitEnumMemberDeclaration(node) {
+            emitJsDocComments(node);
+            writeTextOfNode(currentText, node.name);
+            var enumMemberValue = resolver.getConstantValue(node);
+            if (enumMemberValue !== undefined) {
+                write(" = ");
+                write(enumMemberValue.toString());
+            }
+            write(",");
+            writeLine();
+        }
+        function isPrivateMethodTypeParameter(node) {
+            return node.parent.kind === 147 /* MethodDeclaration */ && (node.parent.flags & 8 /* Private */);
+        }
+        function emitTypeParameters(typeParameters) {
+            function emitTypeParameter(node) {
+                increaseIndent();
+                emitJsDocComments(node);
+                decreaseIndent();
+                writeTextOfNode(currentText, node.name);
+                // If there is constraint present and this is not a type parameter of the private method emit the constraint
+                if (node.constraint && !isPrivateMethodTypeParameter(node)) {
+                    write(" extends ");
+                    if (node.parent.kind === 156 /* FunctionType */ ||
+                        node.parent.kind === 157 /* ConstructorType */ ||
+                        (node.parent.parent && node.parent.parent.kind === 159 /* TypeLiteral */)) {
+                        ts.Debug.assert(node.parent.kind === 147 /* MethodDeclaration */ ||
+                            node.parent.kind === 146 /* MethodSignature */ ||
+                            node.parent.kind === 156 /* FunctionType */ ||
+                            node.parent.kind === 157 /* ConstructorType */ ||
+                            node.parent.kind === 151 /* CallSignature */ ||
+                            node.parent.kind === 152 /* ConstructSignature */);
+                        emitType(node.constraint);
+                    }
+                    else {
+                        emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.constraint, getTypeParameterConstraintVisibilityError);
+                    }
+                }
+                function getTypeParameterConstraintVisibilityError(symbolAccessibilityResult) {
+                    // Type parameter constraints are named by user so we should always be able to name it
+                    var diagnosticMessage;
+                    switch (node.parent.kind) {
+                        case 221 /* ClassDeclaration */:
+                            diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;
+                            break;
+                        case 222 /* InterfaceDeclaration */:
+                            diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;
+                            break;
+                        case 152 /* ConstructSignature */:
+                            diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
+                            break;
+                        case 151 /* CallSignature */:
+                            diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
+                            break;
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                            if (node.parent.flags & 32 /* Static */) {
+                                diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
+                            }
+                            else if (node.parent.parent.kind === 221 /* ClassDeclaration */) {
+                                diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
+                            }
+                            else {
+                                diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
+                            }
+                            break;
+                        case 220 /* FunctionDeclaration */:
+                            diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
+                            break;
+                        default:
+                            ts.Debug.fail("This is unknown parent for type parameter: " + node.parent.kind);
+                    }
+                    return {
+                        diagnosticMessage: diagnosticMessage,
+                        errorNode: node,
+                        typeName: node.name
+                    };
+                }
+            }
+            if (typeParameters) {
+                write("<");
+                emitCommaList(typeParameters, emitTypeParameter);
+                write(">");
+            }
+        }
+        function emitHeritageClause(typeReferences, isImplementsList) {
+            if (typeReferences) {
+                write(isImplementsList ? " implements " : " extends ");
+                emitCommaList(typeReferences, emitTypeOfTypeReference);
+            }
+            function emitTypeOfTypeReference(node) {
+                if (ts.isSupportedExpressionWithTypeArguments(node)) {
+                    emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
+                }
+                else if (!isImplementsList && node.expression.kind === 93 /* NullKeyword */) {
+                    write("null");
+                }
+                else {
+                    writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;
+                    resolver.writeBaseConstructorTypeOfClass(enclosingDeclaration, enclosingDeclaration, 2 /* UseTypeOfFunction */, writer);
+                }
+                function getHeritageClauseVisibilityError(symbolAccessibilityResult) {
+                    var diagnosticMessage;
+                    // Heritage clause is written by user so it can always be named
+                    if (node.parent.parent.kind === 221 /* ClassDeclaration */) {
+                        // Class or Interface implemented/extended is inaccessible
+                        diagnosticMessage = isImplementsList ?
+                            ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 :
+                            ts.Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1;
+                    }
+                    else {
+                        // interface is inaccessible
+                        diagnosticMessage = ts.Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;
+                    }
+                    return {
+                        diagnosticMessage: diagnosticMessage,
+                        errorNode: node,
+                        typeName: node.parent.parent.name
+                    };
+                }
+            }
+        }
+        function writeClassDeclaration(node) {
+            function emitParameterProperties(constructorDeclaration) {
+                if (constructorDeclaration) {
+                    ts.forEach(constructorDeclaration.parameters, function (param) {
+                        if (param.flags & 92 /* ParameterPropertyModifier */) {
+                            emitPropertyDeclaration(param);
+                        }
+                    });
+                }
+            }
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            if (node.flags & 128 /* Abstract */) {
+                write("abstract ");
+            }
+            write("class ");
+            writeTextOfNode(currentText, node.name);
+            var prevEnclosingDeclaration = enclosingDeclaration;
+            enclosingDeclaration = node;
+            emitTypeParameters(node.typeParameters);
+            var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node);
+            if (baseTypeNode) {
+                emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
+            }
+            emitHeritageClause(ts.getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
+            write(" {");
+            writeLine();
+            increaseIndent();
+            emitParameterProperties(ts.getFirstConstructorWithBody(node));
+            emitLines(node.members);
+            decreaseIndent();
+            write("}");
+            writeLine();
+            enclosingDeclaration = prevEnclosingDeclaration;
+        }
+        function writeInterfaceDeclaration(node) {
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            write("interface ");
+            writeTextOfNode(currentText, node.name);
+            var prevEnclosingDeclaration = enclosingDeclaration;
+            enclosingDeclaration = node;
+            emitTypeParameters(node.typeParameters);
+            emitHeritageClause(ts.getInterfaceBaseTypeNodes(node), /*isImplementsList*/ false);
+            write(" {");
+            writeLine();
+            increaseIndent();
+            emitLines(node.members);
+            decreaseIndent();
+            write("}");
+            writeLine();
+            enclosingDeclaration = prevEnclosingDeclaration;
+        }
+        function emitPropertyDeclaration(node) {
+            if (ts.hasDynamicName(node)) {
+                return;
+            }
+            emitJsDocComments(node);
+            emitClassMemberDeclarationFlags(node.flags);
+            emitVariableDeclaration(node);
+            write(";");
+            writeLine();
+        }
+        function emitVariableDeclaration(node) {
+            // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
+            // so there is no check needed to see if declaration is visible
+            if (node.kind !== 218 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) {
+                if (ts.isBindingPattern(node.name)) {
+                    emitBindingPattern(node.name);
+                }
+                else {
+                    // If this node is a computed name, it can only be a symbol, because we've already skipped
+                    // it if it's not a well known symbol. In that case, the text of the name will be exactly
+                    // what we want, namely the name expression enclosed in brackets.
+                    writeTextOfNode(currentText, node.name);
+                    // If optional property emit ?
+                    if ((node.kind === 145 /* PropertyDeclaration */ || node.kind === 144 /* PropertySignature */ || node.kind === 142 /* Parameter */) && ts.hasQuestionToken(node)) {
+                        write("?");
+                    }
+                    if ((node.kind === 145 /* PropertyDeclaration */ || node.kind === 144 /* PropertySignature */) && node.parent.kind === 159 /* TypeLiteral */) {
+                        emitTypeOfVariableDeclarationFromTypeLiteral(node);
+                    }
+                    else if (!(node.flags & 8 /* Private */)) {
+                        writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
+                    }
+                }
+            }
+            function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
+                if (node.kind === 218 /* VariableDeclaration */) {
+                    return symbolAccessibilityResult.errorModuleName ?
+                        symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                            ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                            ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 :
+                        ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
+                }
+                else if (node.kind === 145 /* PropertyDeclaration */ || node.kind === 144 /* PropertySignature */) {
+                    // TODO(jfreeman): Deal with computed properties in error reporting.
+                    if (node.flags & 32 /* Static */) {
+                        return symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
+                    }
+                    else if (node.parent.kind === 221 /* ClassDeclaration */) {
+                        return symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
+                    }
+                    else {
+                        // Interfaces cannot have types that cannot be named
+                        return symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
+                    }
+                }
+            }
+            function getVariableDeclarationTypeVisibilityError(symbolAccessibilityResult) {
+                var diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
+                return diagnosticMessage !== undefined ? {
+                    diagnosticMessage: diagnosticMessage,
+                    errorNode: node,
+                    typeName: node.name
+                } : undefined;
+            }
+            function emitBindingPattern(bindingPattern) {
+                // Only select non-omitted expression from the bindingPattern's elements.
+                // We have to do this to avoid emitting trailing commas.
+                // For example:
+                //      original: var [, c,,] = [ 2,3,4]
+                //      emitted: declare var c: number; // instead of declare var c:number, ;
+                var elements = [];
+                for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) {
+                    var element = _a[_i];
+                    if (element.kind !== 193 /* OmittedExpression */) {
+                        elements.push(element);
+                    }
+                }
+                emitCommaList(elements, emitBindingElement);
+            }
+            function emitBindingElement(bindingElement) {
+                function getBindingElementTypeVisibilityError(symbolAccessibilityResult) {
+                    var diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
+                    return diagnosticMessage !== undefined ? {
+                        diagnosticMessage: diagnosticMessage,
+                        errorNode: bindingElement,
+                        typeName: bindingElement.name
+                    } : undefined;
+                }
+                if (bindingElement.name) {
+                    if (ts.isBindingPattern(bindingElement.name)) {
+                        emitBindingPattern(bindingElement.name);
+                    }
+                    else {
+                        writeTextOfNode(currentText, bindingElement.name);
+                        writeTypeOfDeclaration(bindingElement, /*type*/ undefined, getBindingElementTypeVisibilityError);
+                    }
+                }
+            }
+        }
+        function emitTypeOfVariableDeclarationFromTypeLiteral(node) {
+            // if this is property of type literal,
+            // or is parameter of method/call/construct/index signature of type literal
+            // emit only if type is specified
+            if (node.type) {
+                write(": ");
+                emitType(node.type);
+            }
+        }
+        function isVariableStatementVisible(node) {
+            return ts.forEach(node.declarationList.declarations, function (varDeclaration) { return resolver.isDeclarationVisible(varDeclaration); });
+        }
+        function writeVariableStatement(node) {
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            if (ts.isLet(node.declarationList)) {
+                write("let ");
+            }
+            else if (ts.isConst(node.declarationList)) {
+                write("const ");
+            }
+            else {
+                write("var ");
+            }
+            emitCommaList(node.declarationList.declarations, emitVariableDeclaration, resolver.isDeclarationVisible);
+            write(";");
+            writeLine();
+        }
+        function emitAccessorDeclaration(node) {
+            if (ts.hasDynamicName(node)) {
+                return;
+            }
+            var accessors = ts.getAllAccessorDeclarations(node.parent.members, node);
+            var accessorWithTypeAnnotation;
+            if (node === accessors.firstAccessor) {
+                emitJsDocComments(accessors.getAccessor);
+                emitJsDocComments(accessors.setAccessor);
+                emitClassMemberDeclarationFlags(node.flags | (accessors.setAccessor ? 0 : 64 /* Readonly */));
+                writeTextOfNode(currentText, node.name);
+                if (!(node.flags & 8 /* Private */)) {
+                    accessorWithTypeAnnotation = node;
+                    var type = getTypeAnnotationFromAccessor(node);
+                    if (!type) {
+                        // couldn't get type for the first accessor, try the another one
+                        var anotherAccessor = node.kind === 149 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor;
+                        type = getTypeAnnotationFromAccessor(anotherAccessor);
+                        if (type) {
+                            accessorWithTypeAnnotation = anotherAccessor;
+                        }
+                    }
+                    writeTypeOfDeclaration(node, type, getAccessorDeclarationTypeVisibilityError);
+                }
+                write(";");
+                writeLine();
+            }
+            function getTypeAnnotationFromAccessor(accessor) {
+                if (accessor) {
+                    return accessor.kind === 149 /* GetAccessor */
+                        ? accessor.type // Getter - return type
+                        : accessor.parameters.length > 0
+                            ? accessor.parameters[0].type // Setter parameter type
+                            : undefined;
+                }
+            }
+            function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) {
+                var diagnosticMessage;
+                if (accessorWithTypeAnnotation.kind === 150 /* SetAccessor */) {
+                    // Setters have to have type named and cannot infer it so, the type should always be named
+                    if (accessorWithTypeAnnotation.parent.flags & 32 /* Static */) {
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
+                    }
+                    else {
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1;
+                    }
+                    return {
+                        diagnosticMessage: diagnosticMessage,
+                        errorNode: accessorWithTypeAnnotation.parameters[0],
+                        // TODO(jfreeman): Investigate why we are passing node.name instead of node.parameters[0].name
+                        typeName: accessorWithTypeAnnotation.name
+                    };
+                }
+                else {
+                    if (accessorWithTypeAnnotation.flags & 32 /* Static */) {
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
+                                ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0;
+                    }
+                    else {
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
+                                ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0;
+                    }
+                    return {
+                        diagnosticMessage: diagnosticMessage,
+                        errorNode: accessorWithTypeAnnotation.name,
+                        typeName: undefined
+                    };
+                }
+            }
+        }
+        function writeFunctionDeclaration(node) {
+            if (ts.hasDynamicName(node)) {
+                return;
+            }
+            // If we are emitting Method/Constructor it isn't moduleElement and hence already determined to be emitting
+            // so no need to verify if the declaration is visible
+            if (!resolver.isImplementationOfOverload(node)) {
+                emitJsDocComments(node);
+                if (node.kind === 220 /* FunctionDeclaration */) {
+                    emitModuleElementDeclarationFlags(node);
+                }
+                else if (node.kind === 147 /* MethodDeclaration */ || node.kind === 148 /* Constructor */) {
+                    emitClassMemberDeclarationFlags(node.flags);
+                }
+                if (node.kind === 220 /* FunctionDeclaration */) {
+                    write("function ");
+                    writeTextOfNode(currentText, node.name);
+                }
+                else if (node.kind === 148 /* Constructor */) {
+                    write("constructor");
+                }
+                else {
+                    writeTextOfNode(currentText, node.name);
+                    if (ts.hasQuestionToken(node)) {
+                        write("?");
+                    }
+                }
+                emitSignatureDeclaration(node);
+            }
+        }
+        function emitSignatureDeclarationWithJsDocComments(node) {
+            emitJsDocComments(node);
+            emitSignatureDeclaration(node);
+        }
+        function emitSignatureDeclaration(node) {
+            var prevEnclosingDeclaration = enclosingDeclaration;
+            enclosingDeclaration = node;
+            var closeParenthesizedFunctionType = false;
+            if (node.kind === 153 /* IndexSignature */) {
+                // Index signature can have readonly modifier
+                emitClassMemberDeclarationFlags(node.flags);
+                write("[");
+            }
+            else {
+                // Construct signature or constructor type write new Signature
+                if (node.kind === 152 /* ConstructSignature */ || node.kind === 157 /* ConstructorType */) {
+                    write("new ");
+                }
+                else if (node.kind === 156 /* FunctionType */) {
+                    var currentOutput = writer.getText();
+                    // Do not generate incorrect type when function type with type parameters is type argument
+                    // This could happen if user used space between two '<' making it error free
+                    // e.g var x: A< <Tany>(a: Tany)=>Tany>;
+                    if (node.typeParameters && currentOutput.charAt(currentOutput.length - 1) === "<") {
+                        closeParenthesizedFunctionType = true;
+                        write("(");
+                    }
+                }
+                emitTypeParameters(node.typeParameters);
+                write("(");
+            }
+            // Parameters
+            emitCommaList(node.parameters, emitParameterDeclaration);
+            if (node.kind === 153 /* IndexSignature */) {
+                write("]");
+            }
+            else {
+                write(")");
+            }
+            // If this is not a constructor and is not private, emit the return type
+            var isFunctionTypeOrConstructorType = node.kind === 156 /* FunctionType */ || node.kind === 157 /* ConstructorType */;
+            if (isFunctionTypeOrConstructorType || node.parent.kind === 159 /* TypeLiteral */) {
+                // Emit type literal signature return type only if specified
+                if (node.type) {
+                    write(isFunctionTypeOrConstructorType ? " => " : ": ");
+                    emitType(node.type);
+                }
+            }
+            else if (node.kind !== 148 /* Constructor */ && !(node.flags & 8 /* Private */)) {
+                writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
+            }
+            enclosingDeclaration = prevEnclosingDeclaration;
+            if (!isFunctionTypeOrConstructorType) {
+                write(";");
+                writeLine();
+            }
+            else if (closeParenthesizedFunctionType) {
+                write(")");
+            }
+            function getReturnTypeVisibilityError(symbolAccessibilityResult) {
+                var diagnosticMessage;
+                switch (node.kind) {
+                    case 152 /* ConstructSignature */:
+                        // Interfaces cannot have return types that cannot be named
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0;
+                        break;
+                    case 151 /* CallSignature */:
+                        // Interfaces cannot have return types that cannot be named
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0;
+                        break;
+                    case 153 /* IndexSignature */:
+                        // Interfaces cannot have return types that cannot be named
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0;
+                        break;
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        if (node.flags & 32 /* Static */) {
+                            diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                                symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                    ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
+                                    ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
+                                ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0;
+                        }
+                        else if (node.parent.kind === 221 /* ClassDeclaration */) {
+                            diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                                symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                    ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
+                                    ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
+                                ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0;
+                        }
+                        else {
+                            // Interfaces cannot have return types that cannot be named
+                            diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                                ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
+                                ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0;
+                        }
+                        break;
+                    case 220 /* FunctionDeclaration */:
+                        diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
+                                ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 :
+                            ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0;
+                        break;
+                    default:
+                        ts.Debug.fail("This is unknown kind for signature: " + node.kind);
+                }
+                return {
+                    diagnosticMessage: diagnosticMessage,
+                    errorNode: node.name || node
+                };
+            }
+        }
+        function emitParameterDeclaration(node) {
+            increaseIndent();
+            emitJsDocComments(node);
+            if (node.dotDotDotToken) {
+                write("...");
+            }
+            if (ts.isBindingPattern(node.name)) {
+                // For bindingPattern, we can't simply writeTextOfNode from the source file
+                // because we want to omit the initializer and using writeTextOfNode will result in initializer get emitted.
+                // Therefore, we will have to recursively emit each element in the bindingPattern.
+                emitBindingPattern(node.name);
+            }
+            else {
+                writeTextOfNode(currentText, node.name);
+            }
+            if (resolver.isOptionalParameter(node)) {
+                write("?");
+            }
+            decreaseIndent();
+            if (node.parent.kind === 156 /* FunctionType */ ||
+                node.parent.kind === 157 /* ConstructorType */ ||
+                node.parent.parent.kind === 159 /* TypeLiteral */) {
+                emitTypeOfVariableDeclarationFromTypeLiteral(node);
+            }
+            else if (!(node.parent.flags & 8 /* Private */)) {
+                writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
+            }
+            function getParameterDeclarationTypeVisibilityError(symbolAccessibilityResult) {
+                var diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
+                return diagnosticMessage !== undefined ? {
+                    diagnosticMessage: diagnosticMessage,
+                    errorNode: node,
+                    typeName: node.name
+                } : undefined;
+            }
+            function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
+                switch (node.parent.kind) {
+                    case 148 /* Constructor */:
+                        return symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
+                    case 152 /* ConstructSignature */:
+                        // Interfaces cannot have parameter types that cannot be named
+                        return symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
+                    case 151 /* CallSignature */:
+                        // Interfaces cannot have parameter types that cannot be named
+                        return symbolAccessibilityResult.errorModuleName ?
+                            ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        if (node.parent.flags & 32 /* Static */) {
+                            return symbolAccessibilityResult.errorModuleName ?
+                                symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                    ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                    ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                                ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
+                        }
+                        else if (node.parent.parent.kind === 221 /* ClassDeclaration */) {
+                            return symbolAccessibilityResult.errorModuleName ?
+                                symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                    ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                    ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
+                                ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
+                        }
+                        else {
+                            // Interfaces cannot have parameter types that cannot be named
+                            return symbolAccessibilityResult.errorModuleName ?
+                                ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
+                                ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
+                        }
+                    case 220 /* FunctionDeclaration */:
+                        return symbolAccessibilityResult.errorModuleName ?
+                            symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ?
+                                ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
+                                ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 :
+                            ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
+                    default:
+                        ts.Debug.fail("This is unknown parent for parameter: " + node.parent.kind);
+                }
+            }
+            function emitBindingPattern(bindingPattern) {
+                // We have to explicitly emit square bracket and bracket because these tokens are not store inside the node.
+                if (bindingPattern.kind === 167 /* ObjectBindingPattern */) {
+                    write("{");
+                    emitCommaList(bindingPattern.elements, emitBindingElement);
+                    write("}");
+                }
+                else if (bindingPattern.kind === 168 /* ArrayBindingPattern */) {
+                    write("[");
+                    var elements = bindingPattern.elements;
+                    emitCommaList(elements, emitBindingElement);
+                    if (elements && elements.hasTrailingComma) {
+                        write(", ");
+                    }
+                    write("]");
+                }
+            }
+            function emitBindingElement(bindingElement) {
+                if (bindingElement.kind === 193 /* OmittedExpression */) {
+                    // If bindingElement is an omittedExpression (i.e. containing elision),
+                    // we will emit blank space (although this may differ from users' original code,
+                    // it allows emitSeparatedList to write separator appropriately)
+                    // Example:
+                    //      original: function foo([, x, ,]) {}
+                    //      emit    : function foo([ , x,  , ]) {}
+                    write(" ");
+                }
+                else if (bindingElement.kind === 169 /* BindingElement */) {
+                    if (bindingElement.propertyName) {
+                        // bindingElement has propertyName property in the following case:
+                        //      { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y"
+                        // We have to explicitly emit the propertyName before descending into its binding elements.
+                        // Example:
+                        //      original: function foo({y: [a,b,c]}) {}
+                        //      emit    : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void;
+                        writeTextOfNode(currentText, bindingElement.propertyName);
+                        write(": ");
+                    }
+                    if (bindingElement.name) {
+                        if (ts.isBindingPattern(bindingElement.name)) {
+                            // If it is a nested binding pattern, we will recursively descend into each element and emit each one separately.
+                            // In the case of rest element, we will omit rest element.
+                            // Example:
+                            //      original: function foo([a, [[b]], c] = [1,[["string"]], 3]) {}
+                            //      emit    : declare function foo([a, [[b]], c]: [number, [[string]], number]): void;
+                            //      original with rest: function foo([a, ...c]) {}
+                            //      emit              : declare function foo([a, ...c]): void;
+                            emitBindingPattern(bindingElement.name);
+                        }
+                        else {
+                            ts.Debug.assert(bindingElement.name.kind === 69 /* Identifier */);
+                            // If the node is just an identifier, we will simply emit the text associated with the node's name
+                            // Example:
+                            //      original: function foo({y = 10, x}) {}
+                            //      emit    : declare function foo({y, x}: {number, any}): void;
+                            if (bindingElement.dotDotDotToken) {
+                                write("...");
+                            }
+                            writeTextOfNode(currentText, bindingElement.name);
+                        }
+                    }
+                }
+            }
+        }
+        function emitNode(node) {
+            switch (node.kind) {
+                case 220 /* FunctionDeclaration */:
+                case 225 /* ModuleDeclaration */:
+                case 229 /* ImportEqualsDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 221 /* ClassDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                case 224 /* EnumDeclaration */:
+                    return emitModuleElement(node, isModuleElementVisible(node));
+                case 200 /* VariableStatement */:
+                    return emitModuleElement(node, isVariableStatementVisible(node));
+                case 230 /* ImportDeclaration */:
+                    // Import declaration without import clause is visible, otherwise it is not visible
+                    return emitModuleElement(node, /*isModuleElementVisible*/ !node.importClause);
+                case 236 /* ExportDeclaration */:
+                    return emitExportDeclaration(node);
+                case 148 /* Constructor */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                    return writeFunctionDeclaration(node);
+                case 152 /* ConstructSignature */:
+                case 151 /* CallSignature */:
+                case 153 /* IndexSignature */:
+                    return emitSignatureDeclarationWithJsDocComments(node);
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                    return emitAccessorDeclaration(node);
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    return emitPropertyDeclaration(node);
+                case 255 /* EnumMember */:
+                    return emitEnumMemberDeclaration(node);
+                case 235 /* ExportAssignment */:
+                    return emitExportAssignment(node);
+                case 256 /* SourceFile */:
+                    return emitSourceFile(node);
+            }
+        }
+        /**
+         * Adds the reference to referenced file, returns true if global file reference was emitted
+         * @param referencedFile
+         * @param addBundledFileReference Determines if global file reference corresponding to bundled file should be emitted or not
+         */
+        function writeReferencePath(referencedFile, addBundledFileReference) {
+            var declFileName;
+            var addedBundledEmitReference = false;
+            if (ts.isDeclarationFile(referencedFile)) {
+                // Declaration file, use declaration file name
+                declFileName = referencedFile.fileName;
+            }
+            else {
+                // Get the declaration file path
+                ts.forEachExpectedEmitFile(host, getDeclFileName, referencedFile);
+            }
+            if (declFileName) {
+                declFileName = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizeSlashes(declarationFilePath)), declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, 
+                /*isAbsolutePathAnUrl*/ false);
+                referencesOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
+            }
+            return addedBundledEmitReference;
+            function getDeclFileName(emitFileNames, sourceFiles, isBundledEmit) {
+                // Dont add reference path to this file if it is a bundled emit and caller asked not emit bundled file path
+                if (isBundledEmit && !addBundledFileReference) {
+                    return;
+                }
+                ts.Debug.assert(!!emitFileNames.declarationFilePath || ts.isSourceFileJavaScript(referencedFile), "Declaration file is not present only for javascript files");
+                declFileName = emitFileNames.declarationFilePath || emitFileNames.jsFilePath;
+                addedBundledEmitReference = isBundledEmit;
+            }
+        }
+    }
+    /* @internal */
+    function writeDeclarationFile(declarationFilePath, sourceFiles, isBundledEmit, host, resolver, emitterDiagnostics) {
+        var emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit);
+        var emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath) || host.getCompilerOptions().noEmit;
+        if (!emitSkipped) {
+            var declarationOutput = emitDeclarationResult.referencesOutput
+                + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
+            ts.writeFile(host, emitterDiagnostics, declarationFilePath, declarationOutput, host.getCompilerOptions().emitBOM, sourceFiles);
+        }
+        return emitSkipped;
+        function getDeclarationOutput(synchronousDeclarationOutput, moduleElementDeclarationEmitInfo) {
+            var appliedSyncOutputPos = 0;
+            var declarationOutput = "";
+            // apply asynchronous additions to the synchronous output
+            ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) {
+                if (aliasEmitInfo.asynchronousOutput) {
+                    declarationOutput += synchronousDeclarationOutput.substring(appliedSyncOutputPos, aliasEmitInfo.outputPos);
+                    declarationOutput += getDeclarationOutput(aliasEmitInfo.asynchronousOutput, aliasEmitInfo.subModuleElementDeclarationEmitInfo);
+                    appliedSyncOutputPos = aliasEmitInfo.outputPos;
+                }
+            });
+            declarationOutput += synchronousDeclarationOutput.substring(appliedSyncOutputPos);
+            return declarationOutput;
+        }
+    }
+    ts.writeDeclarationFile = writeDeclarationFile;
+})(ts || (ts = {}));
+/// <reference path="checker.ts"/>
+/// <reference path="sourcemap.ts" />
+/// <reference path="declarationEmitter.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    function getResolvedExternalModuleName(host, file) {
+        return file.moduleName || ts.getExternalModuleNameFromPath(host, file.fileName);
+    }
+    ts.getResolvedExternalModuleName = getResolvedExternalModuleName;
+    function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
+        var file = resolver.getExternalModuleFileFromDeclaration(declaration);
+        if (!file || ts.isDeclarationFile(file)) {
+            return undefined;
+        }
+        return getResolvedExternalModuleName(host, file);
+    }
+    ts.getExternalModuleNameFromDeclaration = getExternalModuleNameFromDeclaration;
+    var Jump;
+    (function (Jump) {
+        Jump[Jump["Break"] = 2] = "Break";
+        Jump[Jump["Continue"] = 4] = "Continue";
+        Jump[Jump["Return"] = 8] = "Return";
+    })(Jump || (Jump = {}));
+    var entities = {
+        "quot": 0x0022,
+        "amp": 0x0026,
+        "apos": 0x0027,
+        "lt": 0x003C,
+        "gt": 0x003E,
+        "nbsp": 0x00A0,
+        "iexcl": 0x00A1,
+        "cent": 0x00A2,
+        "pound": 0x00A3,
+        "curren": 0x00A4,
+        "yen": 0x00A5,
+        "brvbar": 0x00A6,
+        "sect": 0x00A7,
+        "uml": 0x00A8,
+        "copy": 0x00A9,
+        "ordf": 0x00AA,
+        "laquo": 0x00AB,
+        "not": 0x00AC,
+        "shy": 0x00AD,
+        "reg": 0x00AE,
+        "macr": 0x00AF,
+        "deg": 0x00B0,
+        "plusmn": 0x00B1,
+        "sup2": 0x00B2,
+        "sup3": 0x00B3,
+        "acute": 0x00B4,
+        "micro": 0x00B5,
+        "para": 0x00B6,
+        "middot": 0x00B7,
+        "cedil": 0x00B8,
+        "sup1": 0x00B9,
+        "ordm": 0x00BA,
+        "raquo": 0x00BB,
+        "frac14": 0x00BC,
+        "frac12": 0x00BD,
+        "frac34": 0x00BE,
+        "iquest": 0x00BF,
+        "Agrave": 0x00C0,
+        "Aacute": 0x00C1,
+        "Acirc": 0x00C2,
+        "Atilde": 0x00C3,
+        "Auml": 0x00C4,
+        "Aring": 0x00C5,
+        "AElig": 0x00C6,
+        "Ccedil": 0x00C7,
+        "Egrave": 0x00C8,
+        "Eacute": 0x00C9,
+        "Ecirc": 0x00CA,
+        "Euml": 0x00CB,
+        "Igrave": 0x00CC,
+        "Iacute": 0x00CD,
+        "Icirc": 0x00CE,
+        "Iuml": 0x00CF,
+        "ETH": 0x00D0,
+        "Ntilde": 0x00D1,
+        "Ograve": 0x00D2,
+        "Oacute": 0x00D3,
+        "Ocirc": 0x00D4,
+        "Otilde": 0x00D5,
+        "Ouml": 0x00D6,
+        "times": 0x00D7,
+        "Oslash": 0x00D8,
+        "Ugrave": 0x00D9,
+        "Uacute": 0x00DA,
+        "Ucirc": 0x00DB,
+        "Uuml": 0x00DC,
+        "Yacute": 0x00DD,
+        "THORN": 0x00DE,
+        "szlig": 0x00DF,
+        "agrave": 0x00E0,
+        "aacute": 0x00E1,
+        "acirc": 0x00E2,
+        "atilde": 0x00E3,
+        "auml": 0x00E4,
+        "aring": 0x00E5,
+        "aelig": 0x00E6,
+        "ccedil": 0x00E7,
+        "egrave": 0x00E8,
+        "eacute": 0x00E9,
+        "ecirc": 0x00EA,
+        "euml": 0x00EB,
+        "igrave": 0x00EC,
+        "iacute": 0x00ED,
+        "icirc": 0x00EE,
+        "iuml": 0x00EF,
+        "eth": 0x00F0,
+        "ntilde": 0x00F1,
+        "ograve": 0x00F2,
+        "oacute": 0x00F3,
+        "ocirc": 0x00F4,
+        "otilde": 0x00F5,
+        "ouml": 0x00F6,
+        "divide": 0x00F7,
+        "oslash": 0x00F8,
+        "ugrave": 0x00F9,
+        "uacute": 0x00FA,
+        "ucirc": 0x00FB,
+        "uuml": 0x00FC,
+        "yacute": 0x00FD,
+        "thorn": 0x00FE,
+        "yuml": 0x00FF,
+        "OElig": 0x0152,
+        "oelig": 0x0153,
+        "Scaron": 0x0160,
+        "scaron": 0x0161,
+        "Yuml": 0x0178,
+        "fnof": 0x0192,
+        "circ": 0x02C6,
+        "tilde": 0x02DC,
+        "Alpha": 0x0391,
+        "Beta": 0x0392,
+        "Gamma": 0x0393,
+        "Delta": 0x0394,
+        "Epsilon": 0x0395,
+        "Zeta": 0x0396,
+        "Eta": 0x0397,
+        "Theta": 0x0398,
+        "Iota": 0x0399,
+        "Kappa": 0x039A,
+        "Lambda": 0x039B,
+        "Mu": 0x039C,
+        "Nu": 0x039D,
+        "Xi": 0x039E,
+        "Omicron": 0x039F,
+        "Pi": 0x03A0,
+        "Rho": 0x03A1,
+        "Sigma": 0x03A3,
+        "Tau": 0x03A4,
+        "Upsilon": 0x03A5,
+        "Phi": 0x03A6,
+        "Chi": 0x03A7,
+        "Psi": 0x03A8,
+        "Omega": 0x03A9,
+        "alpha": 0x03B1,
+        "beta": 0x03B2,
+        "gamma": 0x03B3,
+        "delta": 0x03B4,
+        "epsilon": 0x03B5,
+        "zeta": 0x03B6,
+        "eta": 0x03B7,
+        "theta": 0x03B8,
+        "iota": 0x03B9,
+        "kappa": 0x03BA,
+        "lambda": 0x03BB,
+        "mu": 0x03BC,
+        "nu": 0x03BD,
+        "xi": 0x03BE,
+        "omicron": 0x03BF,
+        "pi": 0x03C0,
+        "rho": 0x03C1,
+        "sigmaf": 0x03C2,
+        "sigma": 0x03C3,
+        "tau": 0x03C4,
+        "upsilon": 0x03C5,
+        "phi": 0x03C6,
+        "chi": 0x03C7,
+        "psi": 0x03C8,
+        "omega": 0x03C9,
+        "thetasym": 0x03D1,
+        "upsih": 0x03D2,
+        "piv": 0x03D6,
+        "ensp": 0x2002,
+        "emsp": 0x2003,
+        "thinsp": 0x2009,
+        "zwnj": 0x200C,
+        "zwj": 0x200D,
+        "lrm": 0x200E,
+        "rlm": 0x200F,
+        "ndash": 0x2013,
+        "mdash": 0x2014,
+        "lsquo": 0x2018,
+        "rsquo": 0x2019,
+        "sbquo": 0x201A,
+        "ldquo": 0x201C,
+        "rdquo": 0x201D,
+        "bdquo": 0x201E,
+        "dagger": 0x2020,
+        "Dagger": 0x2021,
+        "bull": 0x2022,
+        "hellip": 0x2026,
+        "permil": 0x2030,
+        "prime": 0x2032,
+        "Prime": 0x2033,
+        "lsaquo": 0x2039,
+        "rsaquo": 0x203A,
+        "oline": 0x203E,
+        "frasl": 0x2044,
+        "euro": 0x20AC,
+        "image": 0x2111,
+        "weierp": 0x2118,
+        "real": 0x211C,
+        "trade": 0x2122,
+        "alefsym": 0x2135,
+        "larr": 0x2190,
+        "uarr": 0x2191,
+        "rarr": 0x2192,
+        "darr": 0x2193,
+        "harr": 0x2194,
+        "crarr": 0x21B5,
+        "lArr": 0x21D0,
+        "uArr": 0x21D1,
+        "rArr": 0x21D2,
+        "dArr": 0x21D3,
+        "hArr": 0x21D4,
+        "forall": 0x2200,
+        "part": 0x2202,
+        "exist": 0x2203,
+        "empty": 0x2205,
+        "nabla": 0x2207,
+        "isin": 0x2208,
+        "notin": 0x2209,
+        "ni": 0x220B,
+        "prod": 0x220F,
+        "sum": 0x2211,
+        "minus": 0x2212,
+        "lowast": 0x2217,
+        "radic": 0x221A,
+        "prop": 0x221D,
+        "infin": 0x221E,
+        "ang": 0x2220,
+        "and": 0x2227,
+        "or": 0x2228,
+        "cap": 0x2229,
+        "cup": 0x222A,
+        "int": 0x222B,
+        "there4": 0x2234,
+        "sim": 0x223C,
+        "cong": 0x2245,
+        "asymp": 0x2248,
+        "ne": 0x2260,
+        "equiv": 0x2261,
+        "le": 0x2264,
+        "ge": 0x2265,
+        "sub": 0x2282,
+        "sup": 0x2283,
+        "nsub": 0x2284,
+        "sube": 0x2286,
+        "supe": 0x2287,
+        "oplus": 0x2295,
+        "otimes": 0x2297,
+        "perp": 0x22A5,
+        "sdot": 0x22C5,
+        "lceil": 0x2308,
+        "rceil": 0x2309,
+        "lfloor": 0x230A,
+        "rfloor": 0x230B,
+        "lang": 0x2329,
+        "rang": 0x232A,
+        "loz": 0x25CA,
+        "spades": 0x2660,
+        "clubs": 0x2663,
+        "hearts": 0x2665,
+        "diams": 0x2666
+    };
+    // Flags enum to track count of temp variables and a few dedicated names
+    var TempFlags;
+    (function (TempFlags) {
+        TempFlags[TempFlags["Auto"] = 0] = "Auto";
+        TempFlags[TempFlags["CountMask"] = 268435455] = "CountMask";
+        TempFlags[TempFlags["_i"] = 268435456] = "_i";
+    })(TempFlags || (TempFlags = {}));
+    var CopyDirection;
+    (function (CopyDirection) {
+        CopyDirection[CopyDirection["ToOriginal"] = 0] = "ToOriginal";
+        CopyDirection[CopyDirection["ToOutParameter"] = 1] = "ToOutParameter";
+    })(CopyDirection || (CopyDirection = {}));
+    // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
+    function emitFiles(resolver, host, targetSourceFile) {
+        // emit output for the __extends helper function
+        var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};";
+        var assignHelper = "\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n            t[p] = s[p];\n    }\n    return t;\n};";
+        // emit output for the __decorate helper function
+        var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};";
+        // emit output for the __metadata helper function
+        var metadataHelper = "\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};";
+        // emit output for the __param helper function
+        var paramHelper = "\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};";
+        var awaiterHelper = "\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments)).next());\n    });\n};";
+        var compilerOptions = host.getCompilerOptions();
+        var languageVersion = ts.getEmitScriptTarget(compilerOptions);
+        var modulekind = ts.getEmitModuleKind(compilerOptions);
+        var sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
+        var emittedFilesList = compilerOptions.listEmittedFiles ? [] : undefined;
+        var emitterDiagnostics = ts.createDiagnosticCollection();
+        var emitSkipped = false;
+        var newLine = host.getNewLine();
+        var emitJavaScript = createFileEmitter();
+        ts.forEachExpectedEmitFile(host, emitFile, targetSourceFile);
+        return {
+            emitSkipped: emitSkipped,
+            diagnostics: emitterDiagnostics.getDiagnostics(),
+            emittedFiles: emittedFilesList,
+            sourceMaps: sourceMapDataList
+        };
+        function isUniqueLocalName(name, container) {
+            for (var node = container; ts.isNodeDescendentOf(node, container); node = node.nextContainer) {
+                if (node.locals && ts.hasProperty(node.locals, name)) {
+                    // We conservatively include alias symbols to cover cases where they're emitted as locals
+                    if (node.locals[name].flags & (107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        function setLabeledJump(state, isBreak, labelText, labelMarker) {
+            if (isBreak) {
+                if (!state.labeledNonLocalBreaks) {
+                    state.labeledNonLocalBreaks = {};
+                }
+                state.labeledNonLocalBreaks[labelText] = labelMarker;
+            }
+            else {
+                if (!state.labeledNonLocalContinues) {
+                    state.labeledNonLocalContinues = {};
+                }
+                state.labeledNonLocalContinues[labelText] = labelMarker;
+            }
+        }
+        function hoistVariableDeclarationFromLoop(state, declaration) {
+            if (!state.hoistedLocalVariables) {
+                state.hoistedLocalVariables = [];
+            }
+            visit(declaration.name);
+            function visit(node) {
+                if (node.kind === 69 /* Identifier */) {
+                    state.hoistedLocalVariables.push(node);
+                }
+                else {
+                    for (var _a = 0, _b = node.elements; _a < _b.length; _a++) {
+                        var element = _b[_a];
+                        visit(element.name);
+                    }
+                }
+            }
+        }
+        function createFileEmitter() {
+            var writer = ts.createTextWriter(newLine);
+            var write = writer.write, writeTextOfNode = writer.writeTextOfNode, writeLine = writer.writeLine, increaseIndent = writer.increaseIndent, decreaseIndent = writer.decreaseIndent;
+            var sourceMap = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? ts.createSourceMapWriter(host, writer) : ts.getNullSourceMapWriter();
+            var setSourceFile = sourceMap.setSourceFile, emitStart = sourceMap.emitStart, emitEnd = sourceMap.emitEnd, emitPos = sourceMap.emitPos;
+            var currentSourceFile;
+            var currentText;
+            var currentLineMap;
+            var currentFileIdentifiers;
+            var renamedDependencies;
+            var isEs6Module;
+            var isCurrentFileExternalModule;
+            // name of an exporter function if file is a System external module
+            // System.register([...], function (<exporter>) {...})
+            // exporting in System modules looks like:
+            // export var x; ... x = 1
+            // =>
+            // var x;... exporter("x", x = 1)
+            var exportFunctionForFile;
+            var contextObjectForFile;
+            var generatedNameSet;
+            var nodeToGeneratedName;
+            var computedPropertyNamesToGeneratedNames;
+            var decoratedClassAliases;
+            var convertedLoopState;
+            var extendsEmitted;
+            var assignEmitted;
+            var decorateEmitted;
+            var paramEmitted;
+            var awaiterEmitted;
+            var tempFlags = 0;
+            var tempVariables;
+            var tempParameters;
+            var externalImports;
+            var exportSpecifiers;
+            var exportEquals;
+            var hasExportStarsToExportValues;
+            var detachedCommentsInfo;
+            /** Sourcemap data that will get encoded */
+            var sourceMapData;
+            /** Is the file being emitted into its own file */
+            var isOwnFileEmit;
+            /** If removeComments is true, no leading-comments needed to be emitted **/
+            var emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos) { } : emitLeadingCommentsOfPositionWorker;
+            var setSourceMapWriterEmit = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? changeSourceMapEmit : function (writer) { };
+            var moduleEmitDelegates = (_a = {},
+                _a[ts.ModuleKind.ES6] = emitES6Module,
+                _a[ts.ModuleKind.AMD] = emitAMDModule,
+                _a[ts.ModuleKind.System] = emitSystemModule,
+                _a[ts.ModuleKind.UMD] = emitUMDModule,
+                _a[ts.ModuleKind.CommonJS] = emitCommonJSModule,
+                _a
+            );
+            var bundleEmitDelegates = (_b = {},
+                _b[ts.ModuleKind.ES6] = function () { },
+                _b[ts.ModuleKind.AMD] = emitAMDModule,
+                _b[ts.ModuleKind.System] = emitSystemModule,
+                _b[ts.ModuleKind.UMD] = function () { },
+                _b[ts.ModuleKind.CommonJS] = function () { },
+                _b
+            );
+            return doEmit;
+            function doEmit(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit) {
+                sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
+                generatedNameSet = {};
+                nodeToGeneratedName = [];
+                decoratedClassAliases = [];
+                isOwnFileEmit = !isBundledEmit;
+                // Emit helpers from all the files
+                if (isBundledEmit && modulekind) {
+                    ts.forEach(sourceFiles, emitEmitHelpers);
+                }
+                // Do not call emit directly. It does not set the currentSourceFile.
+                ts.forEach(sourceFiles, emitSourceFile);
+                writeLine();
+                var sourceMappingURL = sourceMap.getSourceMappingURL();
+                if (sourceMappingURL) {
+                    write("//# sourceMappingURL=" + sourceMappingURL);
+                }
+                writeEmittedFiles(writer.getText(), jsFilePath, sourceMapFilePath, /*writeByteOrderMark*/ compilerOptions.emitBOM, sourceFiles);
+                // reset the state
+                sourceMap.reset();
+                writer.reset();
+                currentSourceFile = undefined;
+                currentText = undefined;
+                currentLineMap = undefined;
+                exportFunctionForFile = undefined;
+                contextObjectForFile = undefined;
+                generatedNameSet = undefined;
+                nodeToGeneratedName = undefined;
+                decoratedClassAliases = undefined;
+                computedPropertyNamesToGeneratedNames = undefined;
+                convertedLoopState = undefined;
+                extendsEmitted = false;
+                decorateEmitted = false;
+                paramEmitted = false;
+                awaiterEmitted = false;
+                assignEmitted = false;
+                tempFlags = 0;
+                tempVariables = undefined;
+                tempParameters = undefined;
+                externalImports = undefined;
+                exportSpecifiers = undefined;
+                exportEquals = undefined;
+                hasExportStarsToExportValues = undefined;
+                detachedCommentsInfo = undefined;
+                sourceMapData = undefined;
+                isEs6Module = false;
+                renamedDependencies = undefined;
+                isCurrentFileExternalModule = false;
+            }
+            function emitSourceFile(sourceFile) {
+                currentSourceFile = sourceFile;
+                currentText = sourceFile.text;
+                currentLineMap = ts.getLineStarts(sourceFile);
+                exportFunctionForFile = undefined;
+                contextObjectForFile = undefined;
+                isEs6Module = sourceFile.symbol && sourceFile.symbol.exports && !!sourceFile.symbol.exports["___esModule"];
+                renamedDependencies = sourceFile.renamedDependencies;
+                currentFileIdentifiers = sourceFile.identifiers;
+                isCurrentFileExternalModule = ts.isExternalModule(sourceFile);
+                setSourceFile(sourceFile);
+                emitNodeWithCommentsAndWithoutSourcemap(sourceFile);
+            }
+            function isUniqueName(name) {
+                return !resolver.hasGlobalName(name) &&
+                    !ts.hasProperty(currentFileIdentifiers, name) &&
+                    !ts.hasProperty(generatedNameSet, name);
+            }
+            // Return the next available name in the pattern _a ... _z, _0, _1, ...
+            // TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.
+            // Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
+            function makeTempVariableName(flags) {
+                if (flags && !(tempFlags & flags)) {
+                    var name_24 = flags === 268435456 /* _i */ ? "_i" : "_n";
+                    if (isUniqueName(name_24)) {
+                        tempFlags |= flags;
+                        return name_24;
+                    }
+                }
+                while (true) {
+                    var count = tempFlags & 268435455 /* CountMask */;
+                    tempFlags++;
+                    // Skip over 'i' and 'n'
+                    if (count !== 8 && count !== 13) {
+                        var name_25 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);
+                        if (isUniqueName(name_25)) {
+                            return name_25;
+                        }
+                    }
+                }
+            }
+            // Generate a name that is unique within the current file and doesn't conflict with any names
+            // in global scope. The name is formed by adding an '_n' suffix to the specified base name,
+            // where n is a positive integer. Note that names generated by makeTempVariableName and
+            // makeUniqueName are guaranteed to never conflict.
+            function makeUniqueName(baseName) {
+                // Find the first unique 'name_n', where n is a positive number
+                if (baseName.charCodeAt(baseName.length - 1) !== 95 /* _ */) {
+                    baseName += "_";
+                }
+                var i = 1;
+                while (true) {
+                    var generatedName = baseName + i;
+                    if (isUniqueName(generatedName)) {
+                        return generatedNameSet[generatedName] = generatedName;
+                    }
+                    i++;
+                }
+            }
+            function generateNameForModuleOrEnum(node) {
+                var name = node.name.text;
+                // Use module/enum name itself if it is unique, otherwise make a unique variation
+                return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
+            }
+            function generateNameForImportOrExportDeclaration(node) {
+                var expr = ts.getExternalModuleName(node);
+                var baseName = expr.kind === 9 /* StringLiteral */ ?
+                    ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module";
+                return makeUniqueName(baseName);
+            }
+            function generateNameForExportDefault() {
+                return makeUniqueName("default");
+            }
+            function generateNameForClassExpression() {
+                return makeUniqueName("class");
+            }
+            function generateNameForNode(node) {
+                switch (node.kind) {
+                    case 69 /* Identifier */:
+                        return makeUniqueName(node.text);
+                    case 225 /* ModuleDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                        return generateNameForModuleOrEnum(node);
+                    case 230 /* ImportDeclaration */:
+                    case 236 /* ExportDeclaration */:
+                        return generateNameForImportOrExportDeclaration(node);
+                    case 220 /* FunctionDeclaration */:
+                    case 221 /* ClassDeclaration */:
+                    case 235 /* ExportAssignment */:
+                        return generateNameForExportDefault();
+                    case 192 /* ClassExpression */:
+                        return generateNameForClassExpression();
+                    default:
+                        ts.Debug.fail();
+                }
+            }
+            function getGeneratedNameForNode(node) {
+                var id = ts.getNodeId(node);
+                return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = ts.unescapeIdentifier(generateNameForNode(node)));
+            }
+            /** Write emitted output to disk */
+            function writeEmittedFiles(emitOutput, jsFilePath, sourceMapFilePath, writeByteOrderMark, sourceFiles) {
+                if (compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) {
+                    ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(), /*writeByteOrderMark*/ false, sourceFiles);
+                }
+                if (sourceMapDataList) {
+                    sourceMapDataList.push(sourceMap.getSourceMapData());
+                }
+                ts.writeFile(host, emitterDiagnostics, jsFilePath, emitOutput, writeByteOrderMark, sourceFiles);
+            }
+            // Create a temporary variable with a unique unused name.
+            function createTempVariable(flags) {
+                var result = ts.createSynthesizedNode(69 /* Identifier */);
+                result.text = makeTempVariableName(flags);
+                return result;
+            }
+            function recordTempDeclaration(name) {
+                if (!tempVariables) {
+                    tempVariables = [];
+                }
+                tempVariables.push(name);
+            }
+            function createAndRecordTempVariable(flags) {
+                var temp = createTempVariable(flags);
+                recordTempDeclaration(temp);
+                return temp;
+            }
+            function emitTempDeclarations(newLine) {
+                if (tempVariables) {
+                    if (newLine) {
+                        writeLine();
+                    }
+                    else {
+                        write(" ");
+                    }
+                    write("var ");
+                    emitCommaList(tempVariables);
+                    write(";");
+                }
+            }
+            /** Emit the text for the given token that comes after startPos
+              * This by default writes the text provided with the given tokenKind
+              * but if optional emitFn callback is provided the text is emitted using the callback instead of default text
+              * @param tokenKind the kind of the token to search and emit
+              * @param startPos the position in the source to start searching for the token
+              * @param emitFn if given will be invoked to emit the text instead of actual token emit */
+            function emitToken(tokenKind, startPos, emitFn) {
+                var tokenStartPos = ts.skipTrivia(currentText, startPos);
+                emitPos(tokenStartPos);
+                var tokenString = ts.tokenToString(tokenKind);
+                if (emitFn) {
+                    emitFn();
+                }
+                else {
+                    write(tokenString);
+                }
+                var tokenEndPos = tokenStartPos + tokenString.length;
+                emitPos(tokenEndPos);
+                return tokenEndPos;
+            }
+            function emitOptional(prefix, node) {
+                if (node) {
+                    write(prefix);
+                    emit(node);
+                }
+            }
+            function emitParenthesizedIf(node, parenthesized) {
+                if (parenthesized) {
+                    write("(");
+                }
+                emit(node);
+                if (parenthesized) {
+                    write(")");
+                }
+            }
+            function emitLinePreservingList(parent, nodes, allowTrailingComma, spacesBetweenBraces) {
+                ts.Debug.assert(nodes.length > 0);
+                increaseIndent();
+                if (nodeStartPositionsAreOnSameLine(parent, nodes[0])) {
+                    if (spacesBetweenBraces) {
+                        write(" ");
+                    }
+                }
+                else {
+                    writeLine();
+                }
+                for (var i = 0, n = nodes.length; i < n; i++) {
+                    if (i) {
+                        if (nodeEndIsOnSameLineAsNodeStart(nodes[i - 1], nodes[i])) {
+                            write(", ");
+                        }
+                        else {
+                            write(",");
+                            writeLine();
+                        }
+                    }
+                    emit(nodes[i]);
+                }
+                if (nodes.hasTrailingComma && allowTrailingComma) {
+                    write(",");
+                }
+                decreaseIndent();
+                if (nodeEndPositionsAreOnSameLine(parent, ts.lastOrUndefined(nodes))) {
+                    if (spacesBetweenBraces) {
+                        write(" ");
+                    }
+                }
+                else {
+                    writeLine();
+                }
+            }
+            function emitList(nodes, start, count, multiLine, trailingComma, leadingComma, noTrailingNewLine, emitNode) {
+                if (!emitNode) {
+                    emitNode = emit;
+                }
+                for (var i = 0; i < count; i++) {
+                    if (multiLine) {
+                        if (i || leadingComma) {
+                            write(",");
+                        }
+                        writeLine();
+                    }
+                    else {
+                        if (i || leadingComma) {
+                            write(", ");
+                        }
+                    }
+                    var node = nodes[start + i];
+                    // This emitting is to make sure we emit following comment properly
+                    //   ...(x, /*comment1*/ y)...
+                    //         ^ => node.pos
+                    // "comment1" is not considered leading comment for "y" but rather
+                    // considered as trailing comment of the previous node.
+                    emitTrailingCommentsOfPosition(node.pos);
+                    emitNode(node);
+                    leadingComma = true;
+                }
+                if (trailingComma) {
+                    write(",");
+                }
+                if (multiLine && !noTrailingNewLine) {
+                    writeLine();
+                }
+                return count;
+            }
+            function emitCommaList(nodes) {
+                if (nodes) {
+                    emitList(nodes, 0, nodes.length, /*multiLine*/ false, /*trailingComma*/ false);
+                }
+            }
+            function emitLines(nodes) {
+                emitLinesStartingAt(nodes, /*startIndex*/ 0);
+            }
+            function emitLinesStartingAt(nodes, startIndex) {
+                for (var i = startIndex; i < nodes.length; i++) {
+                    writeLine();
+                    emit(nodes[i]);
+                }
+            }
+            function isBinaryOrOctalIntegerLiteral(node, text) {
+                if (node.kind === 8 /* NumericLiteral */ && text.length > 1) {
+                    switch (text.charCodeAt(1)) {
+                        case 98 /* b */:
+                        case 66 /* B */:
+                        case 111 /* o */:
+                        case 79 /* O */:
+                            return true;
+                    }
+                }
+                return false;
+            }
+            function emitLiteral(node) {
+                var text = getLiteralText(node);
+                if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap) && (node.kind === 9 /* StringLiteral */ || ts.isTemplateLiteralKind(node.kind))) {
+                    writer.writeLiteral(text);
+                }
+                else if (languageVersion < 2 /* ES6 */ && isBinaryOrOctalIntegerLiteral(node, text)) {
+                    write(node.text);
+                }
+                else {
+                    write(text);
+                }
+            }
+            function getLiteralText(node) {
+                // Any template literal or string literal with an extended escape
+                // (e.g. "\u{0067}") will need to be downleveled as a escaped string literal.
+                if (languageVersion < 2 /* ES6 */ && (ts.isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {
+                    return getQuotedEscapedLiteralText('"', node.text, '"');
+                }
+                // If we don't need to downlevel and we can reach the original source text using
+                // the node's parent reference, then simply get the text as it was originally written.
+                if (node.parent) {
+                    return ts.getTextOfNodeFromSourceText(currentText, node);
+                }
+                // If we can't reach the original source text, use the canonical form if it's a number,
+                // or an escaped quoted form of the original text if it's string-like.
+                switch (node.kind) {
+                    case 9 /* StringLiteral */:
+                        return getQuotedEscapedLiteralText('"', node.text, '"');
+                    case 11 /* NoSubstitutionTemplateLiteral */:
+                        return getQuotedEscapedLiteralText("`", node.text, "`");
+                    case 12 /* TemplateHead */:
+                        return getQuotedEscapedLiteralText("`", node.text, "${");
+                    case 13 /* TemplateMiddle */:
+                        return getQuotedEscapedLiteralText("}", node.text, "${");
+                    case 14 /* TemplateTail */:
+                        return getQuotedEscapedLiteralText("}", node.text, "`");
+                    case 8 /* NumericLiteral */:
+                        return node.text;
+                }
+                ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for.");
+            }
+            function getQuotedEscapedLiteralText(leftQuote, text, rightQuote) {
+                return leftQuote + ts.escapeNonAsciiCharacters(ts.escapeString(text)) + rightQuote;
+            }
+            function emitDownlevelRawTemplateLiteral(node) {
+                // Find original source text, since we need to emit the raw strings of the tagged template.
+                // The raw strings contain the (escaped) strings of what the user wrote.
+                // Examples: `\n` is converted to "\\n", a template string with a newline to "\n".
+                var text = ts.getTextOfNodeFromSourceText(currentText, node);
+                // text contains the original source, it will also contain quotes ("`"), dollar signs and braces ("${" and "}"),
+                // thus we need to remove those characters.
+                // First template piece starts with "`", others with "}"
+                // Last template piece ends with "`", others with "${"
+                var isLast = node.kind === 11 /* NoSubstitutionTemplateLiteral */ || node.kind === 14 /* TemplateTail */;
+                text = text.substring(1, text.length - (isLast ? 1 : 2));
+                // Newline normalization:
+                // ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's
+                // <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for both TV and TRV.
+                text = text.replace(/\r\n?/g, "\n");
+                text = ts.escapeString(text);
+                write("\"" + text + "\"");
+            }
+            function emitDownlevelTaggedTemplateArray(node, literalEmitter) {
+                write("[");
+                if (node.template.kind === 11 /* NoSubstitutionTemplateLiteral */) {
+                    literalEmitter(node.template);
+                }
+                else {
+                    literalEmitter(node.template.head);
+                    ts.forEach(node.template.templateSpans, function (child) {
+                        write(", ");
+                        literalEmitter(child.literal);
+                    });
+                }
+                write("]");
+            }
+            function emitDownlevelTaggedTemplate(node) {
+                var tempVariable = createAndRecordTempVariable(0 /* Auto */);
+                write("(");
+                emit(tempVariable);
+                write(" = ");
+                emitDownlevelTaggedTemplateArray(node, emit);
+                write(", ");
+                emit(tempVariable);
+                write(".raw = ");
+                emitDownlevelTaggedTemplateArray(node, emitDownlevelRawTemplateLiteral);
+                write(", ");
+                emitParenthesizedIf(node.tag, needsParenthesisForPropertyAccessOrInvocation(node.tag));
+                write("(");
+                emit(tempVariable);
+                // Now we emit the expressions
+                if (node.template.kind === 189 /* TemplateExpression */) {
+                    ts.forEach(node.template.templateSpans, function (templateSpan) {
+                        write(", ");
+                        var needsParens = templateSpan.expression.kind === 187 /* BinaryExpression */
+                            && templateSpan.expression.operatorToken.kind === 24 /* CommaToken */;
+                        emitParenthesizedIf(templateSpan.expression, needsParens);
+                    });
+                }
+                write("))");
+            }
+            function emitTemplateExpression(node) {
+                // In ES6 mode and above, we can simply emit each portion of a template in order, but in
+                // ES3 & ES5 we must convert the template expression into a series of string concatenations.
+                if (languageVersion >= 2 /* ES6 */) {
+                    ts.forEachChild(node, emit);
+                    return;
+                }
+                var emitOuterParens = ts.isExpression(node.parent)
+                    && templateNeedsParens(node, node.parent);
+                if (emitOuterParens) {
+                    write("(");
+                }
+                var headEmitted = false;
+                if (shouldEmitTemplateHead()) {
+                    emitLiteral(node.head);
+                    headEmitted = true;
+                }
+                for (var i = 0, n = node.templateSpans.length; i < n; i++) {
+                    var templateSpan = node.templateSpans[i];
+                    // Check if the expression has operands and binds its operands less closely than binary '+'.
+                    // If it does, we need to wrap the expression in parentheses. Otherwise, something like
+                    //    `abc${ 1 << 2 }`
+                    // becomes
+                    //    "abc" + 1 << 2 + ""
+                    // which is really
+                    //    ("abc" + 1) << (2 + "")
+                    // rather than
+                    //    "abc" + (1 << 2) + ""
+                    var needsParens = templateSpan.expression.kind !== 178 /* ParenthesizedExpression */
+                        && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */;
+                    if (i > 0 || headEmitted) {
+                        // If this is the first span and the head was not emitted, then this templateSpan's
+                        // expression will be the first to be emitted. Don't emit the preceding ' + ' in that
+                        // case.
+                        write(" + ");
+                    }
+                    emitParenthesizedIf(templateSpan.expression, needsParens);
+                    // Only emit if the literal is non-empty.
+                    // The binary '+' operator is left-associative, so the first string concatenation
+                    // with the head will force the result up to this point to be a string.
+                    // Emitting a '+ ""' has no semantic effect for middles and tails.
+                    if (templateSpan.literal.text.length !== 0) {
+                        write(" + ");
+                        emitLiteral(templateSpan.literal);
+                    }
+                }
+                if (emitOuterParens) {
+                    write(")");
+                }
+                function shouldEmitTemplateHead() {
+                    // If this expression has an empty head literal and the first template span has a non-empty
+                    // literal, then emitting the empty head literal is not necessary.
+                    //     `${ foo } and ${ bar }`
+                    // can be emitted as
+                    //     foo + " and " + bar
+                    // This is because it is only required that one of the first two operands in the emit
+                    // output must be a string literal, so that the other operand and all following operands
+                    // are forced into strings.
+                    //
+                    // If the first template span has an empty literal, then the head must still be emitted.
+                    //     `${ foo }${ bar }`
+                    // must still be emitted as
+                    //     "" + foo + bar
+                    // There is always atleast one templateSpan in this code path, since
+                    // NoSubstitutionTemplateLiterals are directly emitted via emitLiteral()
+                    ts.Debug.assert(node.templateSpans.length !== 0);
+                    return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0;
+                }
+                function templateNeedsParens(template, parent) {
+                    switch (parent.kind) {
+                        case 174 /* CallExpression */:
+                        case 175 /* NewExpression */:
+                            return parent.expression === template;
+                        case 176 /* TaggedTemplateExpression */:
+                        case 178 /* ParenthesizedExpression */:
+                            return false;
+                        default:
+                            return comparePrecedenceToBinaryPlus(parent) !== -1 /* LessThan */;
+                    }
+                }
+                /**
+                 * Returns whether the expression has lesser, greater,
+                 * or equal precedence to the binary '+' operator
+                 */
+                function comparePrecedenceToBinaryPlus(expression) {
+                    // All binary expressions have lower precedence than '+' apart from '*', '/', and '%'
+                    // which have greater precedence and '-' which has equal precedence.
+                    // All unary operators have a higher precedence apart from yield.
+                    // Arrow functions and conditionals have a lower precedence,
+                    // although we convert the former into regular function expressions in ES5 mode,
+                    // and in ES6 mode this function won't get called anyway.
+                    //
+                    // TODO (drosen): Note that we need to account for the upcoming 'yield' and
+                    //                spread ('...') unary operators that are anticipated for ES6.
+                    switch (expression.kind) {
+                        case 187 /* BinaryExpression */:
+                            switch (expression.operatorToken.kind) {
+                                case 37 /* AsteriskToken */:
+                                case 39 /* SlashToken */:
+                                case 40 /* PercentToken */:
+                                    return 1 /* GreaterThan */;
+                                case 35 /* PlusToken */:
+                                case 36 /* MinusToken */:
+                                    return 0 /* EqualTo */;
+                                default:
+                                    return -1 /* LessThan */;
+                            }
+                        case 190 /* YieldExpression */:
+                        case 188 /* ConditionalExpression */:
+                            return -1 /* LessThan */;
+                        default:
+                            return 1 /* GreaterThan */;
+                    }
+                }
+            }
+            function emitTemplateSpan(span) {
+                emit(span.expression);
+                emit(span.literal);
+            }
+            function jsxEmitReact(node) {
+                /// Emit a tag name, which is either '"div"' for lower-cased names, or
+                /// 'Div' for upper-cased or dotted names
+                function emitTagName(name) {
+                    if (name.kind === 69 /* Identifier */ && ts.isIntrinsicJsxName(name.text)) {
+                        write('"');
+                        emit(name);
+                        write('"');
+                    }
+                    else {
+                        emit(name);
+                    }
+                }
+                /// Emit an attribute name, which is quoted if it needs to be quoted. Because
+                /// these emit into an object literal property name, we don't need to be worried
+                /// about keywords, just non-identifier characters
+                function emitAttributeName(name) {
+                    if (/^[A-Za-z_]\w*$/.test(name.text)) {
+                        emit(name);
+                    }
+                    else {
+                        write('"');
+                        emit(name);
+                        write('"');
+                    }
+                }
+                /// Emit an name/value pair for an attribute (e.g. "x: 3")
+                function emitJsxAttribute(node) {
+                    emitAttributeName(node.name);
+                    write(": ");
+                    if (node.initializer) {
+                        emit(node.initializer);
+                    }
+                    else {
+                        write("true");
+                    }
+                }
+                function emitJsxElement(openingNode, children) {
+                    var syntheticReactRef = ts.createSynthesizedNode(69 /* Identifier */);
+                    syntheticReactRef.text = compilerOptions.reactNamespace ? compilerOptions.reactNamespace : "React";
+                    syntheticReactRef.parent = openingNode;
+                    // Call React.createElement(tag, ...
+                    emitLeadingComments(openingNode);
+                    emitExpressionIdentifier(syntheticReactRef);
+                    write(".createElement(");
+                    emitTagName(openingNode.tagName);
+                    write(", ");
+                    // Attribute list
+                    if (openingNode.attributes.length === 0) {
+                        // When there are no attributes, React wants "null"
+                        write("null");
+                    }
+                    else {
+                        // Either emit one big object literal (no spread attribs), or
+                        // a call to the __assign helper
+                        var attrs = openingNode.attributes;
+                        if (ts.forEach(attrs, function (attr) { return attr.kind === 247 /* JsxSpreadAttribute */; })) {
+                            write("__assign(");
+                            var haveOpenedObjectLiteral = false;
+                            for (var i = 0; i < attrs.length; i++) {
+                                if (attrs[i].kind === 247 /* JsxSpreadAttribute */) {
+                                    // If this is the first argument, we need to emit a {} as the first argument
+                                    if (i === 0) {
+                                        write("{}, ");
+                                    }
+                                    if (haveOpenedObjectLiteral) {
+                                        write("}");
+                                        haveOpenedObjectLiteral = false;
+                                    }
+                                    if (i > 0) {
+                                        write(", ");
+                                    }
+                                    emit(attrs[i].expression);
+                                }
+                                else {
+                                    ts.Debug.assert(attrs[i].kind === 246 /* JsxAttribute */);
+                                    if (haveOpenedObjectLiteral) {
+                                        write(", ");
+                                    }
+                                    else {
+                                        haveOpenedObjectLiteral = true;
+                                        if (i > 0) {
+                                            write(", ");
+                                        }
+                                        write("{");
+                                    }
+                                    emitJsxAttribute(attrs[i]);
+                                }
+                            }
+                            if (haveOpenedObjectLiteral)
+                                write("}");
+                            write(")"); // closing paren to React.__spread(
+                        }
+                        else {
+                            // One object literal with all the attributes in them
+                            write("{");
+                            for (var i = 0, n = attrs.length; i < n; i++) {
+                                if (i > 0) {
+                                    write(", ");
+                                }
+                                emitJsxAttribute(attrs[i]);
+                            }
+                            write("}");
+                        }
+                    }
+                    // Children
+                    if (children) {
+                        var firstChild = void 0;
+                        var multipleEmittableChildren = false;
+                        for (var i = 0, n = children.length; i < n; i++) {
+                            var jsxChild = children[i];
+                            if (isJsxChildEmittable(jsxChild)) {
+                                // we need to decide whether to emit in single line or multiple lines as indented list
+                                // store firstChild reference, if we see another emittable child, then emit accordingly
+                                if (!firstChild) {
+                                    write(", ");
+                                    firstChild = jsxChild;
+                                }
+                                else {
+                                    // more than one emittable child, emit indented list
+                                    if (!multipleEmittableChildren) {
+                                        multipleEmittableChildren = true;
+                                        increaseIndent();
+                                        writeLine();
+                                        emit(firstChild);
+                                    }
+                                    write(", ");
+                                    writeLine();
+                                    emit(jsxChild);
+                                }
+                            }
+                        }
+                        if (multipleEmittableChildren) {
+                            decreaseIndent();
+                        }
+                        else if (firstChild) {
+                            if (firstChild.kind !== 241 /* JsxElement */ && firstChild.kind !== 242 /* JsxSelfClosingElement */) {
+                                emit(firstChild);
+                            }
+                            else {
+                                // If the only child is jsx element, put it on a new indented line
+                                increaseIndent();
+                                writeLine();
+                                emit(firstChild);
+                                writeLine();
+                                decreaseIndent();
+                            }
+                        }
+                    }
+                    // Closing paren
+                    write(")"); // closes "React.createElement("
+                    emitTrailingComments(openingNode);
+                }
+                if (node.kind === 241 /* JsxElement */) {
+                    emitJsxElement(node.openingElement, node.children);
+                }
+                else {
+                    ts.Debug.assert(node.kind === 242 /* JsxSelfClosingElement */);
+                    emitJsxElement(node);
+                }
+            }
+            function jsxEmitPreserve(node) {
+                function emitJsxAttribute(node) {
+                    emit(node.name);
+                    if (node.initializer) {
+                        write("=");
+                        emit(node.initializer);
+                    }
+                }
+                function emitJsxSpreadAttribute(node) {
+                    write("{...");
+                    emit(node.expression);
+                    write("}");
+                }
+                function emitAttributes(attribs) {
+                    for (var i = 0, n = attribs.length; i < n; i++) {
+                        if (i > 0) {
+                            write(" ");
+                        }
+                        if (attribs[i].kind === 247 /* JsxSpreadAttribute */) {
+                            emitJsxSpreadAttribute(attribs[i]);
+                        }
+                        else {
+                            ts.Debug.assert(attribs[i].kind === 246 /* JsxAttribute */);
+                            emitJsxAttribute(attribs[i]);
+                        }
+                    }
+                }
+                function emitJsxOpeningOrSelfClosingElement(node) {
+                    write("<");
+                    emit(node.tagName);
+                    if (node.attributes.length > 0 || (node.kind === 242 /* JsxSelfClosingElement */)) {
+                        write(" ");
+                    }
+                    emitAttributes(node.attributes);
+                    if (node.kind === 242 /* JsxSelfClosingElement */) {
+                        write("/>");
+                    }
+                    else {
+                        write(">");
+                    }
+                }
+                function emitJsxClosingElement(node) {
+                    write("</");
+                    emit(node.tagName);
+                    write(">");
+                }
+                function emitJsxElement(node) {
+                    emitJsxOpeningOrSelfClosingElement(node.openingElement);
+                    for (var i = 0, n = node.children.length; i < n; i++) {
+                        emit(node.children[i]);
+                    }
+                    emitJsxClosingElement(node.closingElement);
+                }
+                if (node.kind === 241 /* JsxElement */) {
+                    emitJsxElement(node);
+                }
+                else {
+                    ts.Debug.assert(node.kind === 242 /* JsxSelfClosingElement */);
+                    emitJsxOpeningOrSelfClosingElement(node);
+                }
+            }
+            // This function specifically handles numeric/string literals for enum and accessor 'identifiers'.
+            // In a sense, it does not actually emit identifiers as much as it declares a name for a specific property.
+            // For example, this is utilized when feeding in a result to Object.defineProperty.
+            function emitExpressionForPropertyName(node) {
+                ts.Debug.assert(node.kind !== 169 /* BindingElement */);
+                if (node.kind === 9 /* StringLiteral */) {
+                    emitLiteral(node);
+                }
+                else if (node.kind === 140 /* ComputedPropertyName */) {
+                    // if this is a decorated computed property, we will need to capture the result
+                    // of the property expression so that we can apply decorators later. This is to ensure
+                    // we don't introduce unintended side effects:
+                    //
+                    //   class C {
+                    //     [_a = x]() { }
+                    //   }
+                    //
+                    // The emit for the decorated computed property decorator is:
+                    //
+                    //   __decorate([dec], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a));
+                    //
+                    if (ts.nodeIsDecorated(node.parent)) {
+                        if (!computedPropertyNamesToGeneratedNames) {
+                            computedPropertyNamesToGeneratedNames = [];
+                        }
+                        var generatedName = computedPropertyNamesToGeneratedNames[ts.getNodeId(node)];
+                        if (generatedName) {
+                            // we have already generated a variable for this node, write that value instead.
+                            write(generatedName);
+                            return;
+                        }
+                        generatedName = createAndRecordTempVariable(0 /* Auto */).text;
+                        computedPropertyNamesToGeneratedNames[ts.getNodeId(node)] = generatedName;
+                        write(generatedName);
+                        write(" = ");
+                    }
+                    emit(node.expression);
+                }
+                else {
+                    write('"');
+                    if (node.kind === 8 /* NumericLiteral */) {
+                        write(node.text);
+                    }
+                    else {
+                        writeTextOfNode(currentText, node);
+                    }
+                    write('"');
+                }
+            }
+            function isExpressionIdentifier(node) {
+                var parent = node.parent;
+                switch (parent.kind) {
+                    case 170 /* ArrayLiteralExpression */:
+                    case 195 /* AsExpression */:
+                    case 184 /* AwaitExpression */:
+                    case 187 /* BinaryExpression */:
+                    case 174 /* CallExpression */:
+                    case 249 /* CaseClause */:
+                    case 140 /* ComputedPropertyName */:
+                    case 188 /* ConditionalExpression */:
+                    case 143 /* Decorator */:
+                    case 181 /* DeleteExpression */:
+                    case 204 /* DoStatement */:
+                    case 173 /* ElementAccessExpression */:
+                    case 235 /* ExportAssignment */:
+                    case 202 /* ExpressionStatement */:
+                    case 194 /* ExpressionWithTypeArguments */:
+                    case 206 /* ForStatement */:
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                    case 203 /* IfStatement */:
+                    case 245 /* JsxClosingElement */:
+                    case 242 /* JsxSelfClosingElement */:
+                    case 243 /* JsxOpeningElement */:
+                    case 247 /* JsxSpreadAttribute */:
+                    case 248 /* JsxExpression */:
+                    case 175 /* NewExpression */:
+                    case 196 /* NonNullExpression */:
+                    case 178 /* ParenthesizedExpression */:
+                    case 186 /* PostfixUnaryExpression */:
+                    case 185 /* PrefixUnaryExpression */:
+                    case 211 /* ReturnStatement */:
+                    case 254 /* ShorthandPropertyAssignment */:
+                    case 191 /* SpreadElementExpression */:
+                    case 213 /* SwitchStatement */:
+                    case 176 /* TaggedTemplateExpression */:
+                    case 197 /* TemplateSpan */:
+                    case 215 /* ThrowStatement */:
+                    case 177 /* TypeAssertionExpression */:
+                    case 182 /* TypeOfExpression */:
+                    case 183 /* VoidExpression */:
+                    case 205 /* WhileStatement */:
+                    case 212 /* WithStatement */:
+                    case 190 /* YieldExpression */:
+                        return true;
+                    case 169 /* BindingElement */:
+                    case 255 /* EnumMember */:
+                    case 142 /* Parameter */:
+                    case 253 /* PropertyAssignment */:
+                    case 145 /* PropertyDeclaration */:
+                    case 218 /* VariableDeclaration */:
+                        return parent.initializer === node;
+                    case 172 /* PropertyAccessExpression */:
+                        return parent.expression === node;
+                    case 180 /* ArrowFunction */:
+                    case 179 /* FunctionExpression */:
+                        return parent.body === node;
+                    case 229 /* ImportEqualsDeclaration */:
+                        return parent.moduleReference === node;
+                    case 139 /* QualifiedName */:
+                        return parent.left === node;
+                }
+                return false;
+            }
+            function emitExpressionIdentifier(node) {
+                var container = resolver.getReferencedExportContainer(node);
+                if (container) {
+                    if (container.kind === 256 /* SourceFile */) {
+                        // Identifier references module export
+                        if (modulekind !== ts.ModuleKind.ES6 && modulekind !== ts.ModuleKind.System) {
+                            write("exports.");
+                        }
+                    }
+                    else {
+                        // Identifier references namespace export
+                        write(getGeneratedNameForNode(container));
+                        write(".");
+                    }
+                }
+                else {
+                    if (modulekind !== ts.ModuleKind.ES6) {
+                        var declaration = resolver.getReferencedImportDeclaration(node);
+                        if (declaration) {
+                            if (declaration.kind === 231 /* ImportClause */) {
+                                // Identifier references default import
+                                write(getGeneratedNameForNode(declaration.parent));
+                                write(languageVersion === 0 /* ES3 */ ? '["default"]' : ".default");
+                                return;
+                            }
+                            else if (declaration.kind === 234 /* ImportSpecifier */) {
+                                // Identifier references named import
+                                write(getGeneratedNameForNode(declaration.parent.parent.parent));
+                                var name_26 = declaration.propertyName || declaration.name;
+                                var identifier = ts.getTextOfNodeFromSourceText(currentText, name_26);
+                                if (languageVersion === 0 /* ES3 */ && identifier === "default") {
+                                    write('["default"]');
+                                }
+                                else {
+                                    write(".");
+                                    write(identifier);
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    if (languageVersion < 2 /* ES6 */) {
+                        var declaration = resolver.getReferencedDeclarationWithCollidingName(node);
+                        if (declaration) {
+                            write(getGeneratedNameForNode(declaration.name));
+                            return;
+                        }
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & 1048576 /* BodyScopedClassBinding */) {
+                        // Due to the emit for class decorators, any reference to the class from inside of the class body
+                        // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
+                        // behavior of class names in ES6.
+                        var declaration = resolver.getReferencedValueDeclaration(node);
+                        if (declaration) {
+                            var classAlias = decoratedClassAliases[ts.getNodeId(declaration)];
+                            if (classAlias !== undefined) {
+                                write(classAlias);
+                                return;
+                            }
+                        }
+                    }
+                }
+                if (ts.nodeIsSynthesized(node)) {
+                    write(node.text);
+                }
+                else {
+                    writeTextOfNode(currentText, node);
+                }
+            }
+            function isNameOfNestedBlockScopedRedeclarationOrCapturedBinding(node) {
+                if (languageVersion < 2 /* ES6 */) {
+                    var parent_13 = node.parent;
+                    switch (parent_13.kind) {
+                        case 169 /* BindingElement */:
+                        case 221 /* ClassDeclaration */:
+                        case 224 /* EnumDeclaration */:
+                        case 218 /* VariableDeclaration */:
+                            return parent_13.name === node && resolver.isDeclarationWithCollidingName(parent_13);
+                    }
+                }
+                return false;
+            }
+            function getClassExpressionInPropertyAccessInStaticPropertyDeclaration(node) {
+                if (languageVersion >= 2 /* ES6 */) {
+                    var parent_14 = node.parent;
+                    if (parent_14.kind === 172 /* PropertyAccessExpression */ && parent_14.expression === node) {
+                        parent_14 = parent_14.parent;
+                        while (parent_14 && parent_14.kind !== 145 /* PropertyDeclaration */) {
+                            parent_14 = parent_14.parent;
+                        }
+                        return parent_14 && parent_14.kind === 145 /* PropertyDeclaration */ && (parent_14.flags & 32 /* Static */) !== 0 &&
+                            parent_14.parent.kind === 192 /* ClassExpression */ ? parent_14.parent : undefined;
+                    }
+                }
+                return undefined;
+            }
+            function emitIdentifier(node) {
+                if (convertedLoopState) {
+                    if (node.text == "arguments" && resolver.isArgumentsLocalBinding(node)) {
+                        // in converted loop body arguments cannot be used directly.
+                        var name_27 = convertedLoopState.argumentsName || (convertedLoopState.argumentsName = makeUniqueName("arguments"));
+                        write(name_27);
+                        return;
+                    }
+                }
+                if (!node.parent) {
+                    write(node.text);
+                }
+                else if (isExpressionIdentifier(node)) {
+                    var classExpression = getClassExpressionInPropertyAccessInStaticPropertyDeclaration(node);
+                    if (classExpression) {
+                        var declaration = resolver.getReferencedValueDeclaration(node);
+                        if (declaration === classExpression) {
+                            write(getGeneratedNameForNode(declaration.name));
+                            return;
+                        }
+                    }
+                    emitExpressionIdentifier(node);
+                }
+                else if (isNameOfNestedBlockScopedRedeclarationOrCapturedBinding(node)) {
+                    write(getGeneratedNameForNode(node));
+                }
+                else if (ts.nodeIsSynthesized(node)) {
+                    write(node.text);
+                }
+                else {
+                    writeTextOfNode(currentText, node);
+                }
+            }
+            function emitThis(node) {
+                if (resolver.getNodeCheckFlags(node) & 2 /* LexicalThis */) {
+                    write("_this");
+                }
+                else if (convertedLoopState) {
+                    write(convertedLoopState.thisName || (convertedLoopState.thisName = makeUniqueName("this")));
+                }
+                else {
+                    write("this");
+                }
+            }
+            function emitSuper(node) {
+                if (languageVersion >= 2 /* ES6 */) {
+                    write("super");
+                }
+                else {
+                    var flags = resolver.getNodeCheckFlags(node);
+                    if (flags & 256 /* SuperInstance */) {
+                        write("_super.prototype");
+                    }
+                    else {
+                        write("_super");
+                    }
+                }
+            }
+            function emitObjectBindingPattern(node) {
+                write("{ ");
+                var elements = node.elements;
+                emitList(elements, 0, elements.length, /*multiLine*/ false, /*trailingComma*/ elements.hasTrailingComma);
+                write(" }");
+            }
+            function emitArrayBindingPattern(node) {
+                write("[");
+                var elements = node.elements;
+                emitList(elements, 0, elements.length, /*multiLine*/ false, /*trailingComma*/ elements.hasTrailingComma);
+                write("]");
+            }
+            function emitBindingElement(node) {
+                if (node.propertyName) {
+                    emit(node.propertyName);
+                    write(": ");
+                }
+                if (node.dotDotDotToken) {
+                    write("...");
+                }
+                if (ts.isBindingPattern(node.name)) {
+                    emit(node.name);
+                }
+                else {
+                    emitModuleMemberName(node);
+                }
+                emitOptional(" = ", node.initializer);
+            }
+            function emitSpreadElementExpression(node) {
+                write("...");
+                emit(node.expression);
+            }
+            function emitYieldExpression(node) {
+                write(ts.tokenToString(114 /* YieldKeyword */));
+                if (node.asteriskToken) {
+                    write("*");
+                }
+                if (node.expression) {
+                    write(" ");
+                    emit(node.expression);
+                }
+            }
+            function emitAwaitExpression(node) {
+                var needsParenthesis = needsParenthesisForAwaitExpressionAsYield(node);
+                if (needsParenthesis) {
+                    write("(");
+                }
+                write(ts.tokenToString(114 /* YieldKeyword */));
+                write(" ");
+                emit(node.expression);
+                if (needsParenthesis) {
+                    write(")");
+                }
+            }
+            function needsParenthesisForAwaitExpressionAsYield(node) {
+                if (node.parent.kind === 187 /* BinaryExpression */ && !ts.isAssignmentOperator(node.parent.operatorToken.kind)) {
+                    return true;
+                }
+                else if (node.parent.kind === 188 /* ConditionalExpression */ && node.parent.condition === node) {
+                    return true;
+                }
+                return false;
+            }
+            function needsParenthesisForPropertyAccessOrInvocation(node) {
+                switch (node.kind) {
+                    case 69 /* Identifier */:
+                    case 170 /* ArrayLiteralExpression */:
+                    case 172 /* PropertyAccessExpression */:
+                    case 173 /* ElementAccessExpression */:
+                    case 174 /* CallExpression */:
+                    case 178 /* ParenthesizedExpression */:
+                        // This list is not exhaustive and only includes those cases that are relevant
+                        // to the check in emitArrayLiteral. More cases can be added as needed.
+                        return false;
+                }
+                return true;
+            }
+            function emitListWithSpread(elements, needsUniqueCopy, multiLine, trailingComma, useConcat) {
+                var pos = 0;
+                var group = 0;
+                var length = elements.length;
+                while (pos < length) {
+                    // Emit using the pattern <group0>.concat(<group1>, <group2>, ...)
+                    if (group === 1 && useConcat) {
+                        write(".concat(");
+                    }
+                    else if (group > 0) {
+                        write(", ");
+                    }
+                    var e = elements[pos];
+                    if (e.kind === 191 /* SpreadElementExpression */) {
+                        e = e.expression;
+                        emitParenthesizedIf(e, /*parenthesized*/ group === 0 && needsParenthesisForPropertyAccessOrInvocation(e));
+                        pos++;
+                        if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 170 /* ArrayLiteralExpression */) {
+                            write(".slice()");
+                        }
+                    }
+                    else {
+                        var i = pos;
+                        while (i < length && elements[i].kind !== 191 /* SpreadElementExpression */) {
+                            i++;
+                        }
+                        write("[");
+                        if (multiLine) {
+                            increaseIndent();
+                        }
+                        emitList(elements, pos, i - pos, multiLine, trailingComma && i === length);
+                        if (multiLine) {
+                            decreaseIndent();
+                        }
+                        write("]");
+                        pos = i;
+                    }
+                    group++;
+                }
+                if (group > 1) {
+                    if (useConcat) {
+                        write(")");
+                    }
+                }
+            }
+            function isSpreadElementExpression(node) {
+                return node.kind === 191 /* SpreadElementExpression */;
+            }
+            function emitArrayLiteral(node) {
+                var elements = node.elements;
+                if (elements.length === 0) {
+                    write("[]");
+                }
+                else if (languageVersion >= 2 /* ES6 */ || !ts.forEach(elements, isSpreadElementExpression)) {
+                    write("[");
+                    emitLinePreservingList(node, node.elements, elements.hasTrailingComma, /*spacesBetweenBraces*/ false);
+                    write("]");
+                }
+                else {
+                    emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ node.multiLine, 
+                    /*trailingComma*/ elements.hasTrailingComma, /*useConcat*/ true);
+                }
+            }
+            function emitObjectLiteralBody(node, numElements) {
+                if (numElements === 0) {
+                    write("{}");
+                    return;
+                }
+                write("{");
+                if (numElements > 0) {
+                    var properties = node.properties;
+                    // If we are not doing a downlevel transformation for object literals,
+                    // then try to preserve the original shape of the object literal.
+                    // Otherwise just try to preserve the formatting.
+                    if (numElements === properties.length) {
+                        emitLinePreservingList(node, properties, /*allowTrailingComma*/ languageVersion >= 1 /* ES5 */, /*spacesBetweenBraces*/ true);
+                    }
+                    else {
+                        var multiLine = node.multiLine;
+                        if (!multiLine) {
+                            write(" ");
+                        }
+                        else {
+                            increaseIndent();
+                        }
+                        emitList(properties, 0, numElements, /*multiLine*/ multiLine, /*trailingComma*/ false);
+                        if (!multiLine) {
+                            write(" ");
+                        }
+                        else {
+                            decreaseIndent();
+                        }
+                    }
+                }
+                write("}");
+            }
+            function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) {
+                var multiLine = node.multiLine;
+                var properties = node.properties;
+                write("(");
+                if (multiLine) {
+                    increaseIndent();
+                }
+                // For computed properties, we need to create a unique handle to the object
+                // literal so we can modify it without risking internal assignments tainting the object.
+                var tempVar = createAndRecordTempVariable(0 /* Auto */);
+                // Write out the first non-computed properties
+                // (or all properties if none of them are computed),
+                // then emit the rest through indexing on the temp variable.
+                emit(tempVar);
+                write(" = ");
+                emitObjectLiteralBody(node, firstComputedPropertyIndex);
+                for (var i = firstComputedPropertyIndex, n = properties.length; i < n; i++) {
+                    writeComma();
+                    var property = properties[i];
+                    emitStart(property);
+                    if (property.kind === 149 /* GetAccessor */ || property.kind === 150 /* SetAccessor */) {
+                        // TODO (drosen): Reconcile with 'emitMemberFunctions'.
+                        var accessors = ts.getAllAccessorDeclarations(node.properties, property);
+                        if (property !== accessors.firstAccessor) {
+                            continue;
+                        }
+                        write("Object.defineProperty(");
+                        emit(tempVar);
+                        write(", ");
+                        emitStart(property.name);
+                        emitExpressionForPropertyName(property.name);
+                        emitEnd(property.name);
+                        write(", {");
+                        increaseIndent();
+                        if (accessors.getAccessor) {
+                            writeLine();
+                            emitLeadingComments(accessors.getAccessor);
+                            write("get: ");
+                            emitStart(accessors.getAccessor);
+                            write("function ");
+                            emitSignatureAndBody(accessors.getAccessor);
+                            emitEnd(accessors.getAccessor);
+                            emitTrailingComments(accessors.getAccessor);
+                            write(",");
+                        }
+                        if (accessors.setAccessor) {
+                            writeLine();
+                            emitLeadingComments(accessors.setAccessor);
+                            write("set: ");
+                            emitStart(accessors.setAccessor);
+                            write("function ");
+                            emitSignatureAndBody(accessors.setAccessor);
+                            emitEnd(accessors.setAccessor);
+                            emitTrailingComments(accessors.setAccessor);
+                            write(",");
+                        }
+                        writeLine();
+                        write("enumerable: true,");
+                        writeLine();
+                        write("configurable: true");
+                        decreaseIndent();
+                        writeLine();
+                        write("})");
+                        emitEnd(property);
+                    }
+                    else {
+                        emitLeadingComments(property);
+                        emitStart(property.name);
+                        emit(tempVar);
+                        emitMemberAccessForPropertyName(property.name);
+                        emitEnd(property.name);
+                        write(" = ");
+                        if (property.kind === 253 /* PropertyAssignment */) {
+                            emit(property.initializer);
+                        }
+                        else if (property.kind === 254 /* ShorthandPropertyAssignment */) {
+                            emitExpressionIdentifier(property.name);
+                        }
+                        else if (property.kind === 147 /* MethodDeclaration */) {
+                            emitFunctionDeclaration(property);
+                        }
+                        else {
+                            ts.Debug.fail("ObjectLiteralElement type not accounted for: " + property.kind);
+                        }
+                    }
+                    emitEnd(property);
+                }
+                writeComma();
+                emit(tempVar);
+                if (multiLine) {
+                    decreaseIndent();
+                    writeLine();
+                }
+                write(")");
+                function writeComma() {
+                    if (multiLine) {
+                        write(",");
+                        writeLine();
+                    }
+                    else {
+                        write(", ");
+                    }
+                }
+            }
+            function emitObjectLiteral(node) {
+                var properties = node.properties;
+                if (languageVersion < 2 /* ES6 */) {
+                    var numProperties = properties.length;
+                    // Find the first computed property.
+                    // Everything until that point can be emitted as part of the initial object literal.
+                    var numInitialNonComputedProperties = numProperties;
+                    for (var i = 0, n = properties.length; i < n; i++) {
+                        if (properties[i].name.kind === 140 /* ComputedPropertyName */) {
+                            numInitialNonComputedProperties = i;
+                            break;
+                        }
+                    }
+                    var hasComputedProperty = numInitialNonComputedProperties !== properties.length;
+                    if (hasComputedProperty) {
+                        emitDownlevelObjectLiteralWithComputedProperties(node, numInitialNonComputedProperties);
+                        return;
+                    }
+                }
+                // Ordinary case: either the object has no computed properties
+                // or we're compiling with an ES6+ target.
+                emitObjectLiteralBody(node, properties.length);
+            }
+            function createBinaryExpression(left, operator, right, startsOnNewLine) {
+                var result = ts.createSynthesizedNode(187 /* BinaryExpression */, startsOnNewLine);
+                result.operatorToken = ts.createSynthesizedNode(operator);
+                result.left = left;
+                result.right = right;
+                return result;
+            }
+            function createPropertyAccessExpression(expression, name) {
+                var result = ts.createSynthesizedNode(172 /* PropertyAccessExpression */);
+                result.expression = parenthesizeForAccess(expression);
+                result.name = name;
+                return result;
+            }
+            function createElementAccessExpression(expression, argumentExpression) {
+                var result = ts.createSynthesizedNode(173 /* ElementAccessExpression */);
+                result.expression = parenthesizeForAccess(expression);
+                result.argumentExpression = argumentExpression;
+                return result;
+            }
+            function parenthesizeForAccess(expr) {
+                // When diagnosing whether the expression needs parentheses, the decision should be based
+                // on the innermost expression in a chain of nested type assertions.
+                while (expr.kind === 177 /* TypeAssertionExpression */ ||
+                    expr.kind === 195 /* AsExpression */ ||
+                    expr.kind === 196 /* NonNullExpression */) {
+                    expr = expr.expression;
+                }
+                // isLeftHandSideExpression is almost the correct criterion for when it is not necessary
+                // to parenthesize the expression before a dot. The known exceptions are:
+                //
+                //    NewExpression:
+                //       new C.x        -> not the same as (new C).x
+                //    NumberLiteral
+                //       1.x            -> not the same as (1).x
+                //
+                if (ts.isLeftHandSideExpression(expr) &&
+                    expr.kind !== 175 /* NewExpression */ &&
+                    expr.kind !== 8 /* NumericLiteral */) {
+                    return expr;
+                }
+                var node = ts.createSynthesizedNode(178 /* ParenthesizedExpression */);
+                node.expression = expr;
+                return node;
+            }
+            function emitComputedPropertyName(node) {
+                write("[");
+                emitExpressionForPropertyName(node);
+                write("]");
+            }
+            function emitMethod(node) {
+                if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) {
+                    write("*");
+                }
+                emit(node.name);
+                if (languageVersion < 2 /* ES6 */) {
+                    write(": function ");
+                }
+                emitSignatureAndBody(node);
+            }
+            function emitPropertyAssignment(node) {
+                emit(node.name);
+                write(": ");
+                // This is to ensure that we emit comment in the following case:
+                //      For example:
+                //          obj = {
+                //              id: /*comment1*/ ()=>void
+                //          }
+                // "comment1" is not considered to be leading comment for node.initializer
+                // but rather a trailing comment on the previous node.
+                emitTrailingCommentsOfPosition(node.initializer.pos);
+                emit(node.initializer);
+            }
+            // Return true if identifier resolves to an exported member of a namespace
+            function isExportReference(node) {
+                var container = resolver.getReferencedExportContainer(node);
+                return !!container;
+            }
+            // Return true if identifier resolves to an imported identifier
+            function isImportedReference(node) {
+                var declaration = resolver.getReferencedImportDeclaration(node);
+                return declaration && (declaration.kind === 231 /* ImportClause */ || declaration.kind === 234 /* ImportSpecifier */);
+            }
+            function emitShorthandPropertyAssignment(node) {
+                // The name property of a short-hand property assignment is considered an expression position, so here
+                // we manually emit the identifier to avoid rewriting.
+                writeTextOfNode(currentText, node.name);
+                // If emitting pre-ES6 code, or if the name requires rewriting when resolved as an expression identifier,
+                // we emit a normal property assignment. For example:
+                //   module m {
+                //       export let y;
+                //   }
+                //   module m {
+                //       let obj = { y };
+                //   }
+                // Here we need to emit obj = { y : m.y } regardless of the output target.
+                // The same rules apply for imported identifiers when targeting module formats with indirect access to
+                // the imported identifiers. For example, when targeting CommonJS:
+                //
+                //   import {foo} from './foo';
+                //   export const baz = { foo };
+                //
+                // Must be transformed into:
+                //
+                //   const foo_1 = require('./foo');
+                //   exports.baz = { foo: foo_1.foo };
+                //
+                if (languageVersion < 2 /* ES6 */ || (modulekind !== ts.ModuleKind.ES6 && isImportedReference(node.name)) || isExportReference(node.name)) {
+                    // Emit identifier as an identifier
+                    write(": ");
+                    emitExpressionIdentifier(node.name);
+                }
+                if (languageVersion >= 2 /* ES6 */ && node.objectAssignmentInitializer) {
+                    write(" = ");
+                    emit(node.objectAssignmentInitializer);
+                }
+            }
+            function tryEmitConstantValue(node) {
+                var constantValue = tryGetConstEnumValue(node);
+                if (constantValue !== undefined) {
+                    write(constantValue.toString());
+                    if (!compilerOptions.removeComments) {
+                        var propertyName = node.kind === 172 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression);
+                        write(" /* " + propertyName + " */");
+                    }
+                    return true;
+                }
+                return false;
+            }
+            function tryGetConstEnumValue(node) {
+                if (compilerOptions.isolatedModules) {
+                    return undefined;
+                }
+                return node.kind === 172 /* PropertyAccessExpression */ || node.kind === 173 /* ElementAccessExpression */
+                    ? resolver.getConstantValue(node)
+                    : undefined;
+            }
+            // Returns 'true' if the code was actually indented, false otherwise.
+            // If the code is not indented, an optional valueToWriteWhenNotIndenting will be
+            // emitted instead.
+            function indentIfOnDifferentLines(parent, node1, node2, valueToWriteWhenNotIndenting) {
+                var realNodesAreOnDifferentLines = !ts.nodeIsSynthesized(parent) && !nodeEndIsOnSameLineAsNodeStart(node1, node2);
+                // Always use a newline for synthesized code if the synthesizer desires it.
+                var synthesizedNodeIsOnDifferentLine = synthesizedNodeStartsOnNewLine(node2);
+                if (realNodesAreOnDifferentLines || synthesizedNodeIsOnDifferentLine) {
+                    increaseIndent();
+                    writeLine();
+                    return true;
+                }
+                else {
+                    if (valueToWriteWhenNotIndenting) {
+                        write(valueToWriteWhenNotIndenting);
+                    }
+                    return false;
+                }
+            }
+            function emitPropertyAccess(node) {
+                if (tryEmitConstantValue(node)) {
+                    return;
+                }
+                if (languageVersion === 2 /* ES6 */ &&
+                    node.expression.kind === 95 /* SuperKeyword */ &&
+                    isInAsyncMethodWithSuperInES6(node)) {
+                    var name_28 = ts.createSynthesizedNode(9 /* StringLiteral */);
+                    name_28.text = node.name.text;
+                    emitSuperAccessInAsyncMethod(node.expression, name_28);
+                    return;
+                }
+                emit(node.expression);
+                var dotRangeStart = ts.nodeIsSynthesized(node.expression) ? -1 : node.expression.end;
+                var dotRangeEnd = ts.nodeIsSynthesized(node.expression) ? -1 : ts.skipTrivia(currentText, node.expression.end) + 1;
+                var dotToken = { pos: dotRangeStart, end: dotRangeEnd };
+                var indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, dotToken);
+                // 1 .toString is a valid property access, emit a space after the literal
+                // Also emit a space if expression is a integer const enum value - it will appear in generated code as numeric literal
+                var shouldEmitSpace = false;
+                if (!indentedBeforeDot) {
+                    if (node.expression.kind === 8 /* NumericLiteral */) {
+                        // check if numeric literal was originally written with a dot
+                        var text = ts.getTextOfNodeFromSourceText(currentText, node.expression);
+                        shouldEmitSpace = text.indexOf(ts.tokenToString(21 /* DotToken */)) < 0;
+                    }
+                    else {
+                        // check if constant enum value is integer
+                        var constantValue = tryGetConstEnumValue(node.expression);
+                        // isFinite handles cases when constantValue is undefined
+                        shouldEmitSpace = isFinite(constantValue) && Math.floor(constantValue) === constantValue;
+                    }
+                }
+                if (shouldEmitSpace) {
+                    write(" .");
+                }
+                else {
+                    write(".");
+                }
+                var indentedAfterDot = indentIfOnDifferentLines(node, dotToken, node.name);
+                emit(node.name);
+                decreaseIndentIf(indentedBeforeDot, indentedAfterDot);
+            }
+            function emitQualifiedName(node) {
+                emit(node.left);
+                write(".");
+                emit(node.right);
+            }
+            function emitQualifiedNameAsExpression(node, useFallback) {
+                if (node.left.kind === 69 /* Identifier */) {
+                    emitEntityNameAsExpression(node.left, useFallback);
+                }
+                else if (useFallback) {
+                    var temp = createAndRecordTempVariable(0 /* Auto */);
+                    write("(");
+                    emitNodeWithoutSourceMap(temp);
+                    write(" = ");
+                    emitEntityNameAsExpression(node.left, /*useFallback*/ true);
+                    write(") && ");
+                    emitNodeWithoutSourceMap(temp);
+                }
+                else {
+                    emitEntityNameAsExpression(node.left, /*useFallback*/ false);
+                }
+                write(".");
+                emit(node.right);
+            }
+            function emitEntityNameAsExpression(node, useFallback) {
+                switch (node.kind) {
+                    case 69 /* Identifier */:
+                        if (useFallback) {
+                            write("typeof ");
+                            emitExpressionIdentifier(node);
+                            write(" !== 'undefined' && ");
+                        }
+                        emitExpressionIdentifier(node);
+                        break;
+                    case 139 /* QualifiedName */:
+                        emitQualifiedNameAsExpression(node, useFallback);
+                        break;
+                    default:
+                        emitNodeWithoutSourceMap(node);
+                        break;
+                }
+            }
+            function emitIndexedAccess(node) {
+                if (tryEmitConstantValue(node)) {
+                    return;
+                }
+                if (languageVersion === 2 /* ES6 */ &&
+                    node.expression.kind === 95 /* SuperKeyword */ &&
+                    isInAsyncMethodWithSuperInES6(node)) {
+                    emitSuperAccessInAsyncMethod(node.expression, node.argumentExpression);
+                    return;
+                }
+                emit(node.expression);
+                write("[");
+                emit(node.argumentExpression);
+                write("]");
+            }
+            function hasSpreadElement(elements) {
+                return ts.forEach(elements, function (e) { return e.kind === 191 /* SpreadElementExpression */; });
+            }
+            function skipParentheses(node) {
+                while (node.kind === 178 /* ParenthesizedExpression */ ||
+                    node.kind === 177 /* TypeAssertionExpression */ ||
+                    node.kind === 195 /* AsExpression */ ||
+                    node.kind === 196 /* NonNullExpression */) {
+                    node = node.expression;
+                }
+                return node;
+            }
+            function emitCallTarget(node) {
+                if (node.kind === 69 /* Identifier */ || node.kind === 97 /* ThisKeyword */ || node.kind === 95 /* SuperKeyword */) {
+                    emit(node);
+                    return node;
+                }
+                var temp = createAndRecordTempVariable(0 /* Auto */);
+                write("(");
+                emit(temp);
+                write(" = ");
+                emit(node);
+                write(")");
+                return temp;
+            }
+            function emitCallWithSpread(node) {
+                var target;
+                var expr = skipParentheses(node.expression);
+                if (expr.kind === 172 /* PropertyAccessExpression */) {
+                    // Target will be emitted as "this" argument
+                    target = emitCallTarget(expr.expression);
+                    write(".");
+                    emit(expr.name);
+                }
+                else if (expr.kind === 173 /* ElementAccessExpression */) {
+                    // Target will be emitted as "this" argument
+                    target = emitCallTarget(expr.expression);
+                    write("[");
+                    emit(expr.argumentExpression);
+                    write("]");
+                }
+                else if (expr.kind === 95 /* SuperKeyword */) {
+                    target = expr;
+                    write("_super");
+                }
+                else {
+                    emit(node.expression);
+                }
+                write(".apply(");
+                if (target) {
+                    if (target.kind === 95 /* SuperKeyword */) {
+                        // Calls of form super(...) and super.foo(...)
+                        emitThis(target);
+                    }
+                    else {
+                        // Calls of form obj.foo(...)
+                        emit(target);
+                    }
+                }
+                else {
+                    // Calls of form foo(...)
+                    write("void 0");
+                }
+                write(", ");
+                emitListWithSpread(node.arguments, /*needsUniqueCopy*/ false, /*multiLine*/ false, /*trailingComma*/ false, /*useConcat*/ true);
+                write(")");
+            }
+            function isInAsyncMethodWithSuperInES6(node) {
+                if (languageVersion === 2 /* ES6 */) {
+                    var container = ts.getSuperContainer(node, /*includeFunctions*/ false);
+                    if (container && resolver.getNodeCheckFlags(container) & (2048 /* AsyncMethodWithSuper */ | 4096 /* AsyncMethodWithSuperBinding */)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function emitSuperAccessInAsyncMethod(superNode, argumentExpression) {
+                var container = ts.getSuperContainer(superNode, /*includeFunctions*/ false);
+                var isSuperBinding = resolver.getNodeCheckFlags(container) & 4096 /* AsyncMethodWithSuperBinding */;
+                write("_super(");
+                emit(argumentExpression);
+                write(isSuperBinding ? ").value" : ")");
+            }
+            function emitCallExpression(node) {
+                if (languageVersion < 2 /* ES6 */ && hasSpreadElement(node.arguments)) {
+                    emitCallWithSpread(node);
+                    return;
+                }
+                var expression = node.expression;
+                var superCall = false;
+                var isAsyncMethodWithSuper = false;
+                if (expression.kind === 95 /* SuperKeyword */) {
+                    emitSuper(expression);
+                    superCall = true;
+                }
+                else {
+                    superCall = ts.isSuperPropertyOrElementAccess(expression);
+                    isAsyncMethodWithSuper = superCall && isInAsyncMethodWithSuperInES6(node);
+                    emit(expression);
+                }
+                if (superCall && (languageVersion < 2 /* ES6 */ || isAsyncMethodWithSuper)) {
+                    write(".call(");
+                    emitThis(expression);
+                    if (node.arguments.length) {
+                        write(", ");
+                        emitCommaList(node.arguments);
+                    }
+                    write(")");
+                }
+                else {
+                    write("(");
+                    emitCommaList(node.arguments);
+                    write(")");
+                }
+            }
+            function emitNewExpression(node) {
+                write("new ");
+                // Spread operator logic is supported in new expressions in ES5 using a combination
+                // of Function.prototype.bind() and Function.prototype.apply().
+                //
+                //     Example:
+                //
+                //         var args = [1, 2, 3, 4, 5];
+                //         new Array(...args);
+                //
+                //     is compiled into the following ES5:
+                //
+                //         var args = [1, 2, 3, 4, 5];
+                //         new (Array.bind.apply(Array, [void 0].concat(args)));
+                //
+                // The 'thisArg' to 'bind' is ignored when invoking the result of 'bind' with 'new',
+                // Thus, we set it to undefined ('void 0').
+                if (languageVersion === 1 /* ES5 */ &&
+                    node.arguments &&
+                    hasSpreadElement(node.arguments)) {
+                    write("(");
+                    var target = emitCallTarget(node.expression);
+                    write(".bind.apply(");
+                    emit(target);
+                    write(", [void 0].concat(");
+                    emitListWithSpread(node.arguments, /*needsUniqueCopy*/ false, /*multiLine*/ false, /*trailingComma*/ false, /*useConcat*/ false);
+                    write(")))");
+                    write("()");
+                }
+                else {
+                    emit(node.expression);
+                    if (node.arguments) {
+                        write("(");
+                        emitCommaList(node.arguments);
+                        write(")");
+                    }
+                }
+            }
+            function emitTaggedTemplateExpression(node) {
+                if (languageVersion >= 2 /* ES6 */) {
+                    emit(node.tag);
+                    write(" ");
+                    emit(node.template);
+                }
+                else {
+                    emitDownlevelTaggedTemplate(node);
+                }
+            }
+            function emitParenExpression(node) {
+                // If the node is synthesized, it means the emitter put the parentheses there,
+                // not the user. If we didn't want them, the emitter would not have put them
+                // there.
+                if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 180 /* ArrowFunction */) {
+                    if (node.expression.kind === 177 /* TypeAssertionExpression */ ||
+                        node.expression.kind === 195 /* AsExpression */ ||
+                        node.expression.kind === 196 /* NonNullExpression */) {
+                        var operand = node.expression.expression;
+                        // Make sure we consider all nested cast expressions, e.g.:
+                        // (<any><number><any>-A).x;
+                        while (operand.kind === 177 /* TypeAssertionExpression */ ||
+                            operand.kind === 195 /* AsExpression */ ||
+                            operand.kind === 196 /* NonNullExpression */) {
+                            operand = operand.expression;
+                        }
+                        // We have an expression of the form: (<Type>SubExpr)
+                        // Emitting this as (SubExpr) is really not desirable. We would like to emit the subexpr as is.
+                        // Omitting the parentheses, however, could cause change in the semantics of the generated
+                        // code if the casted expression has a lower precedence than the rest of the expression, e.g.:
+                        //      (<any>new A).foo should be emitted as (new A).foo and not new A.foo
+                        //      (<any>typeof A).toString() should be emitted as (typeof A).toString() and not typeof A.toString()
+                        //      new (<any>A()) should be emitted as new (A()) and not new A()
+                        //      (<any>function foo() { })() should be emitted as an IIF (function foo(){})() and not declaration function foo(){} ()
+                        if (operand.kind !== 185 /* PrefixUnaryExpression */ &&
+                            operand.kind !== 183 /* VoidExpression */ &&
+                            operand.kind !== 182 /* TypeOfExpression */ &&
+                            operand.kind !== 181 /* DeleteExpression */ &&
+                            operand.kind !== 186 /* PostfixUnaryExpression */ &&
+                            operand.kind !== 175 /* NewExpression */ &&
+                            !(operand.kind === 174 /* CallExpression */ && node.parent.kind === 175 /* NewExpression */) &&
+                            !(operand.kind === 179 /* FunctionExpression */ && node.parent.kind === 174 /* CallExpression */) &&
+                            !(operand.kind === 8 /* NumericLiteral */ && node.parent.kind === 172 /* PropertyAccessExpression */)) {
+                            emit(operand);
+                            return;
+                        }
+                    }
+                }
+                write("(");
+                emit(node.expression);
+                write(")");
+            }
+            function emitDeleteExpression(node) {
+                write(ts.tokenToString(78 /* DeleteKeyword */));
+                write(" ");
+                emit(node.expression);
+            }
+            function emitVoidExpression(node) {
+                write(ts.tokenToString(103 /* VoidKeyword */));
+                write(" ");
+                emit(node.expression);
+            }
+            function emitTypeOfExpression(node) {
+                write(ts.tokenToString(101 /* TypeOfKeyword */));
+                write(" ");
+                emit(node.expression);
+            }
+            function isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node) {
+                if (!isCurrentFileSystemExternalModule() || node.kind !== 69 /* Identifier */ || ts.nodeIsSynthesized(node)) {
+                    return false;
+                }
+                var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 218 /* VariableDeclaration */ || node.parent.kind === 169 /* BindingElement */);
+                var targetDeclaration = isVariableDeclarationOrBindingElement
+                    ? node.parent
+                    : resolver.getReferencedValueDeclaration(node);
+                return isSourceFileLevelDeclarationInSystemJsModule(targetDeclaration, /*isExported*/ true);
+            }
+            function isNameOfExportedDeclarationInNonES6Module(node) {
+                if (modulekind === ts.ModuleKind.System || node.kind !== 69 /* Identifier */ || ts.nodeIsSynthesized(node)) {
+                    return false;
+                }
+                return !exportEquals && exportSpecifiers && ts.hasProperty(exportSpecifiers, node.text);
+            }
+            function emitPrefixUnaryExpression(node) {
+                var isPlusPlusOrMinusMinus = (node.operator === 41 /* PlusPlusToken */
+                    || node.operator === 42 /* MinusMinusToken */);
+                var externalExportChanged = isPlusPlusOrMinusMinus &&
+                    isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand);
+                if (externalExportChanged) {
+                    // emit
+                    // ++x
+                    // as
+                    // exports('x', ++x)
+                    write(exportFunctionForFile + "(\"");
+                    emitNodeWithoutSourceMap(node.operand);
+                    write("\", ");
+                }
+                var internalExportChanged = isPlusPlusOrMinusMinus &&
+                    isNameOfExportedDeclarationInNonES6Module(node.operand);
+                if (internalExportChanged) {
+                    emitAliasEqual(node.operand);
+                }
+                write(ts.tokenToString(node.operator));
+                // In some cases, we need to emit a space between the operator and the operand. One obvious case
+                // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
+                // and minus expressions in certain cases. Specifically, consider the following two cases (parens
+                // are just for clarity of exposition, and not part of the source code):
+                //
+                //  (+(+1))
+                //  (+(++1))
+                //
+                // We need to emit a space in both cases. In the first case, the absence of a space will make
+                // the resulting expression a prefix increment operation. And in the second, it will make the resulting
+                // expression a prefix increment whose operand is a plus expression - (++(+x))
+                // The same is true of minus of course.
+                if (node.operand.kind === 185 /* PrefixUnaryExpression */) {
+                    var operand = node.operand;
+                    if (node.operator === 35 /* PlusToken */ && (operand.operator === 35 /* PlusToken */ || operand.operator === 41 /* PlusPlusToken */)) {
+                        write(" ");
+                    }
+                    else if (node.operator === 36 /* MinusToken */ && (operand.operator === 36 /* MinusToken */ || operand.operator === 42 /* MinusMinusToken */)) {
+                        write(" ");
+                    }
+                }
+                emit(node.operand);
+                if (externalExportChanged) {
+                    write(")");
+                }
+            }
+            function emitPostfixUnaryExpression(node) {
+                var externalExportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand);
+                var internalExportChanged = isNameOfExportedDeclarationInNonES6Module(node.operand);
+                if (externalExportChanged) {
+                    // export function returns the value that was passes as the second argument
+                    // however for postfix unary expressions result value should be the value before modification.
+                    // emit 'x++' as '(export('x', ++x) - 1)' and 'x--' as '(export('x', --x) + 1)'
+                    write("(" + exportFunctionForFile + "(\"");
+                    emitNodeWithoutSourceMap(node.operand);
+                    write("\", ");
+                    write(ts.tokenToString(node.operator));
+                    emit(node.operand);
+                    if (node.operator === 41 /* PlusPlusToken */) {
+                        write(") - 1)");
+                    }
+                    else {
+                        write(") + 1)");
+                    }
+                }
+                else if (internalExportChanged) {
+                    emitAliasEqual(node.operand);
+                    emit(node.operand);
+                    if (node.operator === 41 /* PlusPlusToken */) {
+                        write(" += 1");
+                    }
+                    else {
+                        write(" -= 1");
+                    }
+                }
+                else {
+                    emit(node.operand);
+                    write(ts.tokenToString(node.operator));
+                }
+            }
+            function shouldHoistDeclarationInSystemJsModule(node) {
+                return isSourceFileLevelDeclarationInSystemJsModule(node, /*isExported*/ false);
+            }
+            /*
+             * Checks if given node is a source file level declaration (not nested in module/function).
+             * If 'isExported' is true - then declaration must also be exported.
+             * This function is used in two cases:
+             * - check if node is a exported source file level value to determine
+             *   if we should also export the value after its it changed
+             * - check if node is a source level declaration to emit it differently,
+             *   i.e non-exported variable statement 'var x = 1' is hoisted so
+             *   we we emit variable statement 'var' should be dropped.
+             */
+            function isSourceFileLevelDeclarationInSystemJsModule(node, isExported) {
+                if (!node || !isCurrentFileSystemExternalModule()) {
+                    return false;
+                }
+                var current = ts.getRootDeclaration(node).parent;
+                while (current) {
+                    if (current.kind === 256 /* SourceFile */) {
+                        return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0);
+                    }
+                    else if (ts.isDeclaration(current)) {
+                        return false;
+                    }
+                    else {
+                        current = current.parent;
+                    }
+                }
+            }
+            /**
+             * Emit ES7 exponentiation operator downlevel using Math.pow
+             * @param node a binary expression node containing exponentiationOperator (**, **=)
+             */
+            function emitExponentiationOperator(node) {
+                var leftHandSideExpression = node.left;
+                if (node.operatorToken.kind === 60 /* AsteriskAsteriskEqualsToken */) {
+                    var synthesizedLHS = void 0;
+                    var shouldEmitParentheses = false;
+                    if (ts.isElementAccessExpression(leftHandSideExpression)) {
+                        shouldEmitParentheses = true;
+                        write("(");
+                        synthesizedLHS = ts.createSynthesizedNode(173 /* ElementAccessExpression */, /*startsOnNewLine*/ false);
+                        var identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefineTempVariablesInPlace*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
+                        synthesizedLHS.expression = identifier;
+                        if (leftHandSideExpression.argumentExpression.kind !== 8 /* NumericLiteral */ &&
+                            leftHandSideExpression.argumentExpression.kind !== 9 /* StringLiteral */) {
+                            var tempArgumentExpression = createAndRecordTempVariable(268435456 /* _i */);
+                            synthesizedLHS.argumentExpression = tempArgumentExpression;
+                            emitAssignment(tempArgumentExpression, leftHandSideExpression.argumentExpression, /*shouldEmitCommaBeforeAssignment*/ true, leftHandSideExpression.expression);
+                        }
+                        else {
+                            synthesizedLHS.argumentExpression = leftHandSideExpression.argumentExpression;
+                        }
+                        write(", ");
+                    }
+                    else if (ts.isPropertyAccessExpression(leftHandSideExpression)) {
+                        shouldEmitParentheses = true;
+                        write("(");
+                        synthesizedLHS = ts.createSynthesizedNode(172 /* PropertyAccessExpression */, /*startsOnNewLine*/ false);
+                        var identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefineTempVariablesInPlace*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
+                        synthesizedLHS.expression = identifier;
+                        synthesizedLHS.name = leftHandSideExpression.name;
+                        write(", ");
+                    }
+                    emit(synthesizedLHS || leftHandSideExpression);
+                    write(" = ");
+                    write("Math.pow(");
+                    emit(synthesizedLHS || leftHandSideExpression);
+                    write(", ");
+                    emit(node.right);
+                    write(")");
+                    if (shouldEmitParentheses) {
+                        write(")");
+                    }
+                }
+                else {
+                    write("Math.pow(");
+                    emit(leftHandSideExpression);
+                    write(", ");
+                    emit(node.right);
+                    write(")");
+                }
+            }
+            function emitAliasEqual(name) {
+                for (var _a = 0, _b = exportSpecifiers[name.text]; _a < _b.length; _a++) {
+                    var specifier = _b[_a];
+                    emitStart(specifier.name);
+                    emitContainingModuleName(specifier);
+                    if (languageVersion === 0 /* ES3 */ && name.text === "default") {
+                        write('["default"]');
+                    }
+                    else {
+                        write(".");
+                        emitNodeWithCommentsAndWithoutSourcemap(specifier.name);
+                    }
+                    emitEnd(specifier.name);
+                    write(" = ");
+                }
+                return true;
+            }
+            function emitBinaryExpression(node) {
+                if (languageVersion < 2 /* ES6 */ && node.operatorToken.kind === 56 /* EqualsToken */ &&
+                    (node.left.kind === 171 /* ObjectLiteralExpression */ || node.left.kind === 170 /* ArrayLiteralExpression */)) {
+                    emitDestructuring(node, node.parent.kind === 202 /* ExpressionStatement */);
+                }
+                else {
+                    var isAssignment = ts.isAssignmentOperator(node.operatorToken.kind);
+                    var externalExportChanged = isAssignment &&
+                        isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.left);
+                    if (externalExportChanged) {
+                        // emit assignment 'x <op> y' as 'exports("x", x <op> y)'
+                        write(exportFunctionForFile + "(\"");
+                        emitNodeWithoutSourceMap(node.left);
+                        write("\", ");
+                    }
+                    var internalExportChanged = isAssignment &&
+                        isNameOfExportedDeclarationInNonES6Module(node.left);
+                    if (internalExportChanged) {
+                        // export { foo }
+                        // emit foo = 2 as exports.foo = foo = 2
+                        emitAliasEqual(node.left);
+                    }
+                    if (node.operatorToken.kind === 38 /* AsteriskAsteriskToken */ || node.operatorToken.kind === 60 /* AsteriskAsteriskEqualsToken */) {
+                        // Downleveled emit exponentiation operator using Math.pow
+                        emitExponentiationOperator(node);
+                    }
+                    else {
+                        emit(node.left);
+                        // Add indentation before emit the operator if the operator is on different line
+                        // For example:
+                        //      3
+                        //      + 2;
+                        //   emitted as
+                        //      3
+                        //          + 2;
+                        var indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== 24 /* CommaToken */ ? " " : undefined);
+                        write(ts.tokenToString(node.operatorToken.kind));
+                        var indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " ");
+                        emit(node.right);
+                        decreaseIndentIf(indentedBeforeOperator, indentedAfterOperator);
+                    }
+                    if (externalExportChanged) {
+                        write(")");
+                    }
+                }
+            }
+            function synthesizedNodeStartsOnNewLine(node) {
+                return ts.nodeIsSynthesized(node) && node.startsOnNewLine;
+            }
+            function emitConditionalExpression(node) {
+                emit(node.condition);
+                var indentedBeforeQuestion = indentIfOnDifferentLines(node, node.condition, node.questionToken, " ");
+                write("?");
+                var indentedAfterQuestion = indentIfOnDifferentLines(node, node.questionToken, node.whenTrue, " ");
+                emit(node.whenTrue);
+                decreaseIndentIf(indentedBeforeQuestion, indentedAfterQuestion);
+                var indentedBeforeColon = indentIfOnDifferentLines(node, node.whenTrue, node.colonToken, " ");
+                write(":");
+                var indentedAfterColon = indentIfOnDifferentLines(node, node.colonToken, node.whenFalse, " ");
+                emit(node.whenFalse);
+                decreaseIndentIf(indentedBeforeColon, indentedAfterColon);
+            }
+            // Helper function to decrease the indent if we previously indented.  Allows multiple
+            // previous indent values to be considered at a time.  This also allows caller to just
+            // call this once, passing in all their appropriate indent values, instead of needing
+            // to call this helper function multiple times.
+            function decreaseIndentIf(value1, value2) {
+                if (value1) {
+                    decreaseIndent();
+                }
+                if (value2) {
+                    decreaseIndent();
+                }
+            }
+            function isSingleLineEmptyBlock(node) {
+                if (node && node.kind === 199 /* Block */) {
+                    var block = node;
+                    return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block);
+                }
+            }
+            function emitBlock(node) {
+                if (isSingleLineEmptyBlock(node)) {
+                    emitToken(15 /* OpenBraceToken */, node.pos);
+                    write(" ");
+                    emitToken(16 /* CloseBraceToken */, node.statements.end);
+                    return;
+                }
+                emitToken(15 /* OpenBraceToken */, node.pos);
+                increaseIndent();
+                if (node.kind === 226 /* ModuleBlock */) {
+                    ts.Debug.assert(node.parent.kind === 225 /* ModuleDeclaration */);
+                    emitCaptureThisForNodeIfNecessary(node.parent);
+                }
+                emitLines(node.statements);
+                if (node.kind === 226 /* ModuleBlock */) {
+                    emitTempDeclarations(/*newLine*/ true);
+                }
+                decreaseIndent();
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.statements.end);
+            }
+            function emitEmbeddedStatement(node) {
+                if (node.kind === 199 /* Block */) {
+                    write(" ");
+                    emit(node);
+                }
+                else {
+                    increaseIndent();
+                    writeLine();
+                    emit(node);
+                    decreaseIndent();
+                }
+            }
+            function emitExpressionStatement(node) {
+                emitParenthesizedIf(node.expression, /*parenthesized*/ node.expression.kind === 180 /* ArrowFunction */);
+                write(";");
+            }
+            function emitIfStatement(node) {
+                var endPos = emitToken(88 /* IfKeyword */, node.pos);
+                write(" ");
+                endPos = emitToken(17 /* OpenParenToken */, endPos);
+                emit(node.expression);
+                emitToken(18 /* CloseParenToken */, node.expression.end);
+                emitEmbeddedStatement(node.thenStatement);
+                if (node.elseStatement) {
+                    writeLine();
+                    emitToken(80 /* ElseKeyword */, node.thenStatement.end);
+                    if (node.elseStatement.kind === 203 /* IfStatement */) {
+                        write(" ");
+                        emit(node.elseStatement);
+                    }
+                    else {
+                        emitEmbeddedStatement(node.elseStatement);
+                    }
+                }
+            }
+            function emitDoStatement(node) {
+                emitLoop(node, emitDoStatementWorker);
+            }
+            function emitDoStatementWorker(node, loop) {
+                write("do");
+                if (loop) {
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
+                }
+                if (node.statement.kind === 199 /* Block */) {
+                    write(" ");
+                }
+                else {
+                    writeLine();
+                }
+                write("while (");
+                emit(node.expression);
+                write(");");
+            }
+            function emitWhileStatement(node) {
+                emitLoop(node, emitWhileStatementWorker);
+            }
+            function emitWhileStatementWorker(node, loop) {
+                write("while (");
+                emit(node.expression);
+                write(")");
+                if (loop) {
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
+                }
+            }
+            /**
+             * Returns true if start of variable declaration list was emitted.
+             * Returns false if nothing was written - this can happen for source file level variable declarations
+             *     in system modules where such variable declarations are hoisted.
+             */
+            function tryEmitStartOfVariableDeclarationList(decl) {
+                if (shouldHoistVariable(decl, /*checkIfSourceFileLevelDecl*/ true)) {
+                    // variables in variable declaration list were already hoisted
+                    return false;
+                }
+                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 3072 /* BlockScoped */) === 0) {
+                    // we are inside a converted loop - this can only happen in downlevel scenarios
+                    // record names for all variable declarations
+                    for (var _a = 0, _b = decl.declarations; _a < _b.length; _a++) {
+                        var varDecl = _b[_a];
+                        hoistVariableDeclarationFromLoop(convertedLoopState, varDecl);
+                    }
+                    return false;
+                }
+                emitStart(decl);
+                if (decl && languageVersion >= 2 /* ES6 */) {
+                    if (ts.isLet(decl)) {
+                        write("let ");
+                    }
+                    else if (ts.isConst(decl)) {
+                        write("const ");
+                    }
+                    else {
+                        write("var ");
+                    }
+                }
+                else {
+                    write("var ");
+                }
+                // Note here we specifically dont emit end so that if we are going to emit binding pattern
+                // we can alter the source map correctly
+                return true;
+            }
+            function emitVariableDeclarationListSkippingUninitializedEntries(list) {
+                var started = false;
+                for (var _a = 0, _b = list.declarations; _a < _b.length; _a++) {
+                    var decl = _b[_a];
+                    if (!decl.initializer) {
+                        continue;
+                    }
+                    if (!started) {
+                        started = true;
+                    }
+                    else {
+                        write(", ");
+                    }
+                    emit(decl);
+                }
+                return started;
+            }
+            function shouldConvertLoopBody(node) {
+                return languageVersion < 2 /* ES6 */ &&
+                    (resolver.getNodeCheckFlags(node) & 65536 /* LoopWithCapturedBlockScopedBinding */) !== 0;
+            }
+            function emitLoop(node, loopEmitter) {
+                var shouldConvert = shouldConvertLoopBody(node);
+                if (!shouldConvert) {
+                    loopEmitter(node, /* convertedLoop*/ undefined);
+                }
+                else {
+                    var loop = convertLoopBody(node);
+                    if (node.parent.kind === 214 /* LabeledStatement */) {
+                        // if parent of the loop was labeled statement - attach the label to loop skipping converted loop body
+                        emitLabelAndColon(node.parent);
+                    }
+                    loopEmitter(node, loop);
+                }
+            }
+            function convertLoopBody(node) {
+                var functionName = makeUniqueName("_loop");
+                var loopInitializer;
+                switch (node.kind) {
+                    case 206 /* ForStatement */:
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                        var initializer = node.initializer;
+                        if (initializer && initializer.kind === 219 /* VariableDeclarationList */) {
+                            loopInitializer = node.initializer;
+                        }
+                        break;
+                }
+                var loopParameters;
+                var loopOutParameters;
+                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 3072 /* BlockScoped */)) {
+                    // if loop initializer contains block scoped variables - they should be passed to converted loop body as parameters
+                    loopParameters = [];
+                    for (var _a = 0, _b = loopInitializer.declarations; _a < _b.length; _a++) {
+                        var varDeclaration = _b[_a];
+                        processVariableDeclaration(varDeclaration.name);
+                    }
+                }
+                var bodyIsBlock = node.statement.kind === 199 /* Block */;
+                var paramList = loopParameters ? loopParameters.join(", ") : "";
+                writeLine();
+                write("var " + functionName + " = function(" + paramList + ")");
+                var convertedOuterLoopState = convertedLoopState;
+                convertedLoopState = { loopOutParameters: loopOutParameters };
+                if (convertedOuterLoopState) {
+                    // convertedOuterLoopState !== undefined means that this converted loop is nested in another converted loop.
+                    // if outer converted loop has already accumulated some state - pass it through
+                    if (convertedOuterLoopState.argumentsName) {
+                        // outer loop has already used 'arguments' so we've already have some name to alias it
+                        // use the same name in all nested loops
+                        convertedLoopState.argumentsName = convertedOuterLoopState.argumentsName;
+                    }
+                    if (convertedOuterLoopState.thisName) {
+                        // outer loop has already used 'this' so we've already have some name to alias it
+                        // use the same name in all nested loops
+                        convertedLoopState.thisName = convertedOuterLoopState.thisName;
+                    }
+                    if (convertedOuterLoopState.hoistedLocalVariables) {
+                        // we've already collected some non-block scoped variable declarations in enclosing loop
+                        // use the same storage in nested loop
+                        convertedLoopState.hoistedLocalVariables = convertedOuterLoopState.hoistedLocalVariables;
+                    }
+                }
+                write(" {");
+                writeLine();
+                increaseIndent();
+                if (bodyIsBlock) {
+                    emitLines(node.statement.statements);
+                }
+                else {
+                    emit(node.statement);
+                }
+                writeLine();
+                // end of loop body -> copy out parameter
+                copyLoopOutParameters(convertedLoopState, 1 /* ToOutParameter */, /*emitAsStatements*/ true);
+                decreaseIndent();
+                writeLine();
+                write("};");
+                writeLine();
+                if (loopOutParameters) {
+                    // declare variables to hold out params for loop body
+                    write("var ");
+                    for (var i = 0; i < loopOutParameters.length; i++) {
+                        if (i !== 0) {
+                            write(", ");
+                        }
+                        write(loopOutParameters[i].outParamName);
+                    }
+                    write(";");
+                    writeLine();
+                }
+                if (convertedLoopState.argumentsName) {
+                    // if alias for arguments is set
+                    if (convertedOuterLoopState) {
+                        // pass it to outer converted loop
+                        convertedOuterLoopState.argumentsName = convertedLoopState.argumentsName;
+                    }
+                    else {
+                        // this is top level converted loop and we need to create an alias for 'arguments' object
+                        write("var " + convertedLoopState.argumentsName + " = arguments;");
+                        writeLine();
+                    }
+                }
+                if (convertedLoopState.thisName) {
+                    // if alias for this is set
+                    if (convertedOuterLoopState) {
+                        // pass it to outer converted loop
+                        convertedOuterLoopState.thisName = convertedLoopState.thisName;
+                    }
+                    else {
+                        // this is top level converted loop so we need to create an alias for 'this' here
+                        // NOTE:
+                        // if converted loops were all nested in arrow function then we'll always emit '_this' so convertedLoopState.thisName will not be set.
+                        // If it is set this means that all nested loops are not nested in arrow function and it is safe to capture 'this'.
+                        write("var " + convertedLoopState.thisName + " = this;");
+                        writeLine();
+                    }
+                }
+                if (convertedLoopState.hoistedLocalVariables) {
+                    // if hoistedLocalVariables !== undefined this means that we've possibly collected some variable declarations to be hoisted later
+                    if (convertedOuterLoopState) {
+                        // pass them to outer converted loop
+                        convertedOuterLoopState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables;
+                    }
+                    else {
+                        // deduplicate and hoist collected variable declarations
+                        write("var ");
+                        var seen = void 0;
+                        for (var _c = 0, _d = convertedLoopState.hoistedLocalVariables; _c < _d.length; _c++) {
+                            var id = _d[_c];
+                            // Don't initialize seen unless we have at least one element.
+                            // Emit a comma to separate for all but the first element.
+                            if (!seen) {
+                                seen = {};
+                            }
+                            else {
+                                write(", ");
+                            }
+                            if (!ts.hasProperty(seen, id.text)) {
+                                emit(id);
+                                seen[id.text] = id.text;
+                            }
+                        }
+                        write(";");
+                        writeLine();
+                    }
+                }
+                var currentLoopState = convertedLoopState;
+                convertedLoopState = convertedOuterLoopState;
+                return { functionName: functionName, paramList: paramList, state: currentLoopState };
+                function processVariableDeclaration(name) {
+                    if (name.kind === 69 /* Identifier */) {
+                        var nameText = isNameOfNestedBlockScopedRedeclarationOrCapturedBinding(name)
+                            ? getGeneratedNameForNode(name)
+                            : name.text;
+                        loopParameters.push(nameText);
+                        if (resolver.getNodeCheckFlags(name.parent) & 2097152 /* NeedsLoopOutParameter */) {
+                            var reassignedVariable = { originalName: name, outParamName: makeUniqueName("out_" + nameText) };
+                            (loopOutParameters || (loopOutParameters = [])).push(reassignedVariable);
+                        }
+                    }
+                    else {
+                        for (var _a = 0, _b = name.elements; _a < _b.length; _a++) {
+                            var element = _b[_a];
+                            processVariableDeclaration(element.name);
+                        }
+                    }
+                }
+            }
+            function emitNormalLoopBody(node, emitAsEmbeddedStatement) {
+                var saveAllowedNonLabeledJumps;
+                if (convertedLoopState) {
+                    // we get here if we are trying to emit normal loop loop inside converted loop
+                    // set allowedNonLabeledJumps to Break | Continue to mark that break\continue inside the loop should be emitted as is
+                    saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
+                    convertedLoopState.allowedNonLabeledJumps = 2 /* Break */ | 4 /* Continue */;
+                }
+                if (emitAsEmbeddedStatement) {
+                    emitEmbeddedStatement(node.statement);
+                }
+                else if (node.statement.kind === 199 /* Block */) {
+                    emitLines(node.statement.statements);
+                }
+                else {
+                    writeLine();
+                    emit(node.statement);
+                }
+                if (convertedLoopState) {
+                    convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
+                }
+            }
+            function copyLoopOutParameters(state, copyDirection, emitAsStatements) {
+                if (state.loopOutParameters) {
+                    for (var _a = 0, _b = state.loopOutParameters; _a < _b.length; _a++) {
+                        var outParam = _b[_a];
+                        if (copyDirection === 0 /* ToOriginal */) {
+                            emitIdentifier(outParam.originalName);
+                            write(" = " + outParam.outParamName);
+                        }
+                        else {
+                            write(outParam.outParamName + " = ");
+                            emitIdentifier(outParam.originalName);
+                        }
+                        if (emitAsStatements) {
+                            write(";");
+                            writeLine();
+                        }
+                        else {
+                            write(", ");
+                        }
+                    }
+                }
+            }
+            function emitConvertedLoopCall(loop, emitAsBlock) {
+                if (emitAsBlock) {
+                    write(" {");
+                    writeLine();
+                    increaseIndent();
+                }
+                // loop is considered simple if it does not have any return statements or break\continue that transfer control outside of the loop
+                // simple loops are emitted as just 'loop()';
+                // NOTE: if loop uses only 'continue' it still will be emitted as simple loop
+                var isSimpleLoop = !(loop.state.nonLocalJumps & ~4 /* Continue */) &&
+                    !loop.state.labeledNonLocalBreaks &&
+                    !loop.state.labeledNonLocalContinues;
+                var loopResult = makeUniqueName("state");
+                if (!isSimpleLoop) {
+                    write("var " + loopResult + " = ");
+                }
+                write(loop.functionName + "(" + loop.paramList + ");");
+                writeLine();
+                copyLoopOutParameters(loop.state, 0 /* ToOriginal */, /*emitAsStatements*/ true);
+                if (!isSimpleLoop) {
+                    // for non simple loops we need to store result returned from converted loop function and use it to do dispatching
+                    // converted loop function can return:
+                    // - object - used when body of the converted loop contains return statement. Property "value" of this object stores retuned value
+                    // - string - used to dispatch jumps. "break" and "continue" are used to non-labeled jumps, other values are used to transfer control to
+                    //   different labels
+                    writeLine();
+                    if (loop.state.nonLocalJumps & 8 /* Return */) {
+                        write("if (typeof " + loopResult + " === \"object\") ");
+                        if (convertedLoopState) {
+                            // we are currently nested in another converted loop - return unwrapped result
+                            write("return " + loopResult + ";");
+                            // propagate 'hasReturn' flag to outer loop
+                            convertedLoopState.nonLocalJumps |= 8 /* Return */;
+                        }
+                        else {
+                            // top level converted loop - return unwrapped value
+                            write("return " + loopResult + ".value;");
+                        }
+                        writeLine();
+                    }
+                    if (loop.state.nonLocalJumps & 2 /* Break */) {
+                        write("if (" + loopResult + " === \"break\") break;");
+                        writeLine();
+                    }
+                    // in case of labeled breaks emit code that either breaks to some known label inside outer loop or delegates jump decision to outer loop
+                    emitDispatchTableForLabeledJumps(loopResult, loop.state, convertedLoopState);
+                }
+                if (emitAsBlock) {
+                    writeLine();
+                    decreaseIndent();
+                    write("}");
+                }
+                function emitDispatchTableForLabeledJumps(loopResultVariable, currentLoop, outerLoop) {
+                    if (!currentLoop.labeledNonLocalBreaks && !currentLoop.labeledNonLocalContinues) {
+                        return;
+                    }
+                    write("switch(" + loopResultVariable + ") {");
+                    increaseIndent();
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalBreaks, /*isBreak*/ true, loopResultVariable, outerLoop);
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalContinues, /*isBreak*/ false, loopResultVariable, outerLoop);
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+                function emitDispatchEntriesForLabeledJumps(table, isBreak, loopResultVariable, outerLoop) {
+                    if (!table) {
+                        return;
+                    }
+                    for (var labelText in table) {
+                        var labelMarker = table[labelText];
+                        writeLine();
+                        write("case \"" + labelMarker + "\": ");
+                        // if there are no outer converted loop or outer label in question is located inside outer converted loop
+                        // then emit labeled break\continue
+                        // otherwise propagate pair 'label -> marker' to outer converted loop and emit 'return labelMarker' so outer loop can later decide what to do
+                        if (!outerLoop || (outerLoop.labels && outerLoop.labels[labelText])) {
+                            if (isBreak) {
+                                write("break ");
+                            }
+                            else {
+                                write("continue ");
+                            }
+                            write(labelText + ";");
+                        }
+                        else {
+                            setLabeledJump(outerLoop, isBreak, labelText, labelMarker);
+                            write("return " + loopResultVariable + ";");
+                        }
+                    }
+                }
+            }
+            function emitForStatement(node) {
+                emitLoop(node, emitForStatementWorker);
+            }
+            function emitForStatementWorker(node, loop) {
+                var endPos = emitToken(86 /* ForKeyword */, node.pos);
+                write(" ");
+                endPos = emitToken(17 /* OpenParenToken */, endPos);
+                if (node.initializer && node.initializer.kind === 219 /* VariableDeclarationList */) {
+                    var variableDeclarationList = node.initializer;
+                    var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList);
+                    if (startIsEmitted) {
+                        emitCommaList(variableDeclarationList.declarations);
+                    }
+                    else {
+                        emitVariableDeclarationListSkippingUninitializedEntries(variableDeclarationList);
+                    }
+                }
+                else if (node.initializer) {
+                    emit(node.initializer);
+                }
+                write(";");
+                emitOptional(" ", node.condition);
+                write(";");
+                emitOptional(" ", node.incrementor);
+                write(")");
+                if (loop) {
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
+                }
+            }
+            function emitForInOrForOfStatement(node) {
+                if (languageVersion < 2 /* ES6 */ && node.kind === 208 /* ForOfStatement */) {
+                    emitLoop(node, emitDownLevelForOfStatementWorker);
+                }
+                else {
+                    emitLoop(node, emitForInOrForOfStatementWorker);
+                }
+            }
+            function emitForInOrForOfStatementWorker(node, loop) {
+                var endPos = emitToken(86 /* ForKeyword */, node.pos);
+                write(" ");
+                endPos = emitToken(17 /* OpenParenToken */, endPos);
+                if (node.initializer.kind === 219 /* VariableDeclarationList */) {
+                    var variableDeclarationList = node.initializer;
+                    if (variableDeclarationList.declarations.length >= 1) {
+                        tryEmitStartOfVariableDeclarationList(variableDeclarationList);
+                        emit(variableDeclarationList.declarations[0]);
+                    }
+                }
+                else {
+                    emit(node.initializer);
+                }
+                if (node.kind === 207 /* ForInStatement */) {
+                    write(" in ");
+                }
+                else {
+                    write(" of ");
+                }
+                emit(node.expression);
+                emitToken(18 /* CloseParenToken */, node.expression.end);
+                if (loop) {
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
+                }
+            }
+            function emitDownLevelForOfStatementWorker(node, loop) {
+                // The following ES6 code:
+                //
+                //    for (let v of expr) { }
+                //
+                // should be emitted as
+                //
+                //    for (let _i = 0, _a = expr; _i < _a.length; _i++) {
+                //        let v = _a[_i];
+                //    }
+                //
+                // where _a and _i are temps emitted to capture the RHS and the counter,
+                // respectively.
+                // When the left hand side is an expression instead of a let declaration,
+                // the "let v" is not emitted.
+                // When the left hand side is a let/const, the v is renamed if there is
+                // another v in scope.
+                // Note that all assignments to the LHS are emitted in the body, including
+                // all destructuring.
+                // Note also that because an extra statement is needed to assign to the LHS,
+                // for-of bodies are always emitted as blocks.
+                var endPos = emitToken(86 /* ForKeyword */, node.pos);
+                write(" ");
+                endPos = emitToken(17 /* OpenParenToken */, endPos);
+                // Do not emit the LHS let declaration yet, because it might contain destructuring.
+                // Do not call recordTempDeclaration because we are declaring the temps
+                // right here. Recording means they will be declared later.
+                // In the case where the user wrote an identifier as the RHS, like this:
+                //
+                //     for (let v of arr) { }
+                //
+                // we can't reuse 'arr' because it might be modified within the body of the loop.
+                var counter = createTempVariable(268435456 /* _i */);
+                var rhsReference = ts.createSynthesizedNode(69 /* Identifier */);
+                rhsReference.text = node.expression.kind === 69 /* Identifier */ ?
+                    makeUniqueName(node.expression.text) :
+                    makeTempVariableName(0 /* Auto */);
+                // This is the let keyword for the counter and rhsReference. The let keyword for
+                // the LHS will be emitted inside the body.
+                emitStart(node.expression);
+                write("var ");
+                // _i = 0
+                emitNodeWithoutSourceMap(counter);
+                write(" = 0");
+                emitEnd(node.expression);
+                // , _a = expr
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
+                write("; ");
+                // _i < _a.length;
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(counter);
+                write(" < ");
+                emitNodeWithCommentsAndWithoutSourcemap(rhsReference);
+                write(".length");
+                emitEnd(node.expression);
+                write("; ");
+                // _i++)
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(counter);
+                write("++");
+                emitEnd(node.expression);
+                emitToken(18 /* CloseParenToken */, node.expression.end);
+                // Body
+                write(" {");
+                writeLine();
+                increaseIndent();
+                // Initialize LHS
+                // let v = _a[_i];
+                var rhsIterationValue = createElementAccessExpression(rhsReference, counter);
+                emitStart(node.initializer);
+                if (node.initializer.kind === 219 /* VariableDeclarationList */) {
+                    write("var ");
+                    var variableDeclarationList = node.initializer;
+                    if (variableDeclarationList.declarations.length > 0) {
+                        var declaration = variableDeclarationList.declarations[0];
+                        if (ts.isBindingPattern(declaration.name)) {
+                            // This works whether the declaration is a var, let, or const.
+                            // It will use rhsIterationValue _a[_i] as the initializer.
+                            emitDestructuring(declaration, /*isAssignmentExpressionStatement*/ false, rhsIterationValue);
+                        }
+                        else {
+                            // The following call does not include the initializer, so we have
+                            // to emit it separately.
+                            emitNodeWithCommentsAndWithoutSourcemap(declaration);
+                            write(" = ");
+                            emitNodeWithoutSourceMap(rhsIterationValue);
+                        }
+                    }
+                    else {
+                        // It's an empty declaration list. This can only happen in an error case, if the user wrote
+                        //     for (let of []) {}
+                        emitNodeWithoutSourceMap(createTempVariable(0 /* Auto */));
+                        write(" = ");
+                        emitNodeWithoutSourceMap(rhsIterationValue);
+                    }
+                }
+                else {
+                    // Initializer is an expression. Emit the expression in the body, so that it's
+                    // evaluated on every iteration.
+                    var assignmentExpression = createBinaryExpression(node.initializer, 56 /* EqualsToken */, rhsIterationValue, /*startsOnNewLine*/ false);
+                    if (node.initializer.kind === 170 /* ArrayLiteralExpression */ || node.initializer.kind === 171 /* ObjectLiteralExpression */) {
+                        // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause
+                        // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash.
+                        emitDestructuring(assignmentExpression, /*isAssignmentExpressionStatement*/ true, /*value*/ undefined);
+                    }
+                    else {
+                        emitNodeWithCommentsAndWithoutSourcemap(assignmentExpression);
+                    }
+                }
+                emitEnd(node.initializer);
+                write(";");
+                if (loop) {
+                    writeLine();
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ false);
+                }
+                else {
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ false);
+                }
+                writeLine();
+                decreaseIndent();
+                write("}");
+            }
+            function emitBreakOrContinueStatement(node) {
+                if (convertedLoopState) {
+                    // check if we can emit break\continue as is
+                    // it is possible if either
+                    //   - break\continue is statement labeled and label is located inside the converted loop
+                    //   - break\continue is non-labeled and located in non-converted loop\switch statement
+                    var jump = node.kind === 210 /* BreakStatement */ ? 2 /* Break */ : 4 /* Continue */;
+                    var canUseBreakOrContinue = (node.label && convertedLoopState.labels && convertedLoopState.labels[node.label.text]) ||
+                        (!node.label && (convertedLoopState.allowedNonLabeledJumps & jump));
+                    if (!canUseBreakOrContinue) {
+                        write("return ");
+                        // explicit exit from loop -> copy out parameters
+                        copyLoopOutParameters(convertedLoopState, 1 /* ToOutParameter */, /*emitAsStatements*/ false);
+                        if (!node.label) {
+                            if (node.kind === 210 /* BreakStatement */) {
+                                convertedLoopState.nonLocalJumps |= 2 /* Break */;
+                                write("\"break\";");
+                            }
+                            else {
+                                convertedLoopState.nonLocalJumps |= 4 /* Continue */;
+                                // note: return value is emitted only to simplify debugging, call to converted loop body does not do any dispatching on it.
+                                write("\"continue\";");
+                            }
+                        }
+                        else {
+                            var labelMarker = void 0;
+                            if (node.kind === 210 /* BreakStatement */) {
+                                labelMarker = "break-" + node.label.text;
+                                setLabeledJump(convertedLoopState, /*isBreak*/ true, node.label.text, labelMarker);
+                            }
+                            else {
+                                labelMarker = "continue-" + node.label.text;
+                                setLabeledJump(convertedLoopState, /*isBreak*/ false, node.label.text, labelMarker);
+                            }
+                            write("\"" + labelMarker + "\";");
+                        }
+                        return;
+                    }
+                }
+                emitToken(node.kind === 210 /* BreakStatement */ ? 70 /* BreakKeyword */ : 75 /* ContinueKeyword */, node.pos);
+                emitOptional(" ", node.label);
+                write(";");
+            }
+            function emitReturnStatement(node) {
+                if (convertedLoopState) {
+                    convertedLoopState.nonLocalJumps |= 8 /* Return */;
+                    write("return { value: ");
+                    if (node.expression) {
+                        emit(node.expression);
+                    }
+                    else {
+                        write("void 0");
+                    }
+                    write(" };");
+                    return;
+                }
+                emitToken(94 /* ReturnKeyword */, node.pos);
+                emitOptional(" ", node.expression);
+                write(";");
+            }
+            function emitWithStatement(node) {
+                write("with (");
+                emit(node.expression);
+                write(")");
+                emitEmbeddedStatement(node.statement);
+            }
+            function emitSwitchStatement(node) {
+                var endPos = emitToken(96 /* SwitchKeyword */, node.pos);
+                write(" ");
+                emitToken(17 /* OpenParenToken */, endPos);
+                emit(node.expression);
+                endPos = emitToken(18 /* CloseParenToken */, node.expression.end);
+                write(" ");
+                var saveAllowedNonLabeledJumps;
+                if (convertedLoopState) {
+                    saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
+                    // for switch statement allow only non-labeled break
+                    convertedLoopState.allowedNonLabeledJumps |= 2 /* Break */;
+                }
+                emitCaseBlock(node.caseBlock, endPos);
+                if (convertedLoopState) {
+                    convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
+                }
+            }
+            function emitCaseBlock(node, startPos) {
+                emitToken(15 /* OpenBraceToken */, startPos);
+                increaseIndent();
+                emitLines(node.clauses);
+                decreaseIndent();
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.clauses.end);
+            }
+            function nodeStartPositionsAreOnSameLine(node1, node2) {
+                return ts.getLineOfLocalPositionFromLineMap(currentLineMap, ts.skipTrivia(currentText, node1.pos)) ===
+                    ts.getLineOfLocalPositionFromLineMap(currentLineMap, ts.skipTrivia(currentText, node2.pos));
+            }
+            function nodeEndPositionsAreOnSameLine(node1, node2) {
+                return ts.getLineOfLocalPositionFromLineMap(currentLineMap, node1.end) ===
+                    ts.getLineOfLocalPositionFromLineMap(currentLineMap, node2.end);
+            }
+            function nodeEndIsOnSameLineAsNodeStart(node1, node2) {
+                return ts.getLineOfLocalPositionFromLineMap(currentLineMap, node1.end) ===
+                    ts.getLineOfLocalPositionFromLineMap(currentLineMap, ts.skipTrivia(currentText, node2.pos));
+            }
+            function emitCaseOrDefaultClause(node) {
+                if (node.kind === 249 /* CaseClause */) {
+                    write("case ");
+                    emit(node.expression);
+                    write(":");
+                }
+                else {
+                    write("default:");
+                }
+                if (node.statements.length === 1 && nodeStartPositionsAreOnSameLine(node, node.statements[0])) {
+                    write(" ");
+                    emit(node.statements[0]);
+                }
+                else {
+                    increaseIndent();
+                    emitLines(node.statements);
+                    decreaseIndent();
+                }
+            }
+            function emitThrowStatement(node) {
+                write("throw ");
+                emit(node.expression);
+                write(";");
+            }
+            function emitTryStatement(node) {
+                write("try ");
+                emit(node.tryBlock);
+                emit(node.catchClause);
+                if (node.finallyBlock) {
+                    writeLine();
+                    write("finally ");
+                    emit(node.finallyBlock);
+                }
+            }
+            function emitCatchClause(node) {
+                writeLine();
+                var endPos = emitToken(72 /* CatchKeyword */, node.pos);
+                write(" ");
+                emitToken(17 /* OpenParenToken */, endPos);
+                emit(node.variableDeclaration);
+                emitToken(18 /* CloseParenToken */, node.variableDeclaration ? node.variableDeclaration.end : endPos);
+                write(" ");
+                emitBlock(node.block);
+            }
+            function emitDebuggerStatement(node) {
+                emitToken(76 /* DebuggerKeyword */, node.pos);
+                write(";");
+            }
+            function emitLabelAndColon(node) {
+                emit(node.label);
+                write(": ");
+            }
+            function emitLabeledStatement(node) {
+                if (!ts.isIterationStatement(node.statement, /* lookInLabeledStatements */ false) || !shouldConvertLoopBody(node.statement)) {
+                    emitLabelAndColon(node);
+                }
+                if (convertedLoopState) {
+                    if (!convertedLoopState.labels) {
+                        convertedLoopState.labels = {};
+                    }
+                    convertedLoopState.labels[node.label.text] = node.label.text;
+                }
+                emit(node.statement);
+                if (convertedLoopState) {
+                    convertedLoopState.labels[node.label.text] = undefined;
+                }
+            }
+            function getContainingModule(node) {
+                do {
+                    node = node.parent;
+                } while (node && node.kind !== 225 /* ModuleDeclaration */);
+                return node;
+            }
+            function emitContainingModuleName(node) {
+                var container = getContainingModule(node);
+                write(container ? getGeneratedNameForNode(container) : "exports");
+            }
+            function emitModuleMemberName(node) {
+                emitStart(node.name);
+                if (ts.getCombinedNodeFlags(node) & 1 /* Export */) {
+                    var container = getContainingModule(node);
+                    if (container) {
+                        write(getGeneratedNameForNode(container));
+                        write(".");
+                    }
+                    else if (modulekind !== ts.ModuleKind.ES6 && modulekind !== ts.ModuleKind.System) {
+                        write("exports.");
+                    }
+                }
+                emitNodeWithCommentsAndWithoutSourcemap(node.name);
+                emitEnd(node.name);
+            }
+            function createVoidZero() {
+                var zero = ts.createSynthesizedNode(8 /* NumericLiteral */);
+                zero.text = "0";
+                var result = ts.createSynthesizedNode(183 /* VoidExpression */);
+                result.expression = zero;
+                return result;
+            }
+            function emitEs6ExportDefaultCompat(node) {
+                if (node.parent.kind === 256 /* SourceFile */) {
+                    ts.Debug.assert(!!(node.flags & 512 /* Default */) || node.kind === 235 /* ExportAssignment */);
+                    // only allow export default at a source file level
+                    if (modulekind === ts.ModuleKind.CommonJS || modulekind === ts.ModuleKind.AMD || modulekind === ts.ModuleKind.UMD) {
+                        if (!isEs6Module) {
+                            if (languageVersion !== 0 /* ES3 */) {
+                                // default value of configurable, enumerable, writable are `false`.
+                                write('Object.defineProperty(exports, "__esModule", { value: true });');
+                                writeLine();
+                            }
+                            else {
+                                write("exports.__esModule = true;");
+                                writeLine();
+                            }
+                        }
+                    }
+                }
+            }
+            function emitExportMemberAssignment(node) {
+                if (node.flags & 1 /* Export */) {
+                    writeLine();
+                    emitStart(node);
+                    // emit call to exporter only for top level nodes
+                    if (modulekind === ts.ModuleKind.System && node.parent === currentSourceFile) {
+                        // emit export default <smth> as
+                        // export("default", <smth>)
+                        write(exportFunctionForFile + "(\"");
+                        if (node.flags & 512 /* Default */) {
+                            write("default");
+                        }
+                        else {
+                            emitNodeWithCommentsAndWithoutSourcemap(node.name);
+                        }
+                        write("\", ");
+                        emitDeclarationName(node);
+                        write(")");
+                    }
+                    else {
+                        if (node.flags & 512 /* Default */) {
+                            emitEs6ExportDefaultCompat(node);
+                            if (languageVersion === 0 /* ES3 */) {
+                                write('exports["default"]');
+                            }
+                            else {
+                                write("exports.default");
+                            }
+                        }
+                        else {
+                            emitModuleMemberName(node);
+                        }
+                        write(" = ");
+                        emitDeclarationName(node);
+                    }
+                    emitEnd(node);
+                    write(";");
+                }
+            }
+            function emitExportMemberAssignments(name) {
+                if (modulekind === ts.ModuleKind.System) {
+                    return;
+                }
+                if (!exportEquals && exportSpecifiers && ts.hasProperty(exportSpecifiers, name.text)) {
+                    for (var _a = 0, _b = exportSpecifiers[name.text]; _a < _b.length; _a++) {
+                        var specifier = _b[_a];
+                        writeLine();
+                        emitStart(specifier.name);
+                        emitContainingModuleName(specifier);
+                        write(".");
+                        emitNodeWithCommentsAndWithoutSourcemap(specifier.name);
+                        emitEnd(specifier.name);
+                        write(" = ");
+                        emitExpressionIdentifier(name);
+                        write(";");
+                    }
+                }
+            }
+            function emitExportSpecifierInSystemModule(specifier) {
+                ts.Debug.assert(modulekind === ts.ModuleKind.System);
+                if (!resolver.getReferencedValueDeclaration(specifier.propertyName || specifier.name) && !resolver.isValueAliasDeclaration(specifier)) {
+                    return;
+                }
+                writeLine();
+                emitStart(specifier.name);
+                write(exportFunctionForFile + "(\"");
+                emitNodeWithCommentsAndWithoutSourcemap(specifier.name);
+                write("\", ");
+                emitExpressionIdentifier(specifier.propertyName || specifier.name);
+                write(")");
+                emitEnd(specifier.name);
+                write(";");
+            }
+            /**
+             * Emit an assignment to a given identifier, 'name', with a given expression, 'value'.
+             * @param name an identifier as a left-hand-side operand of the assignment
+             * @param value an expression as a right-hand-side operand of the assignment
+             * @param shouldEmitCommaBeforeAssignment a boolean indicating whether to prefix an assignment with comma
+             */
+            function emitAssignment(name, value, shouldEmitCommaBeforeAssignment, nodeForSourceMap) {
+                if (shouldEmitCommaBeforeAssignment) {
+                    write(", ");
+                }
+                var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name);
+                if (exportChanged) {
+                    write(exportFunctionForFile + "(\"");
+                    emitNodeWithCommentsAndWithoutSourcemap(name);
+                    write("\", ");
+                }
+                var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 218 /* VariableDeclaration */ || name.parent.kind === 169 /* BindingElement */);
+                // If this is first var declaration, we need to start at var/let/const keyword instead
+                // otherwise use nodeForSourceMap as the start position
+                emitStart(isFirstVariableDeclaration(nodeForSourceMap) ? nodeForSourceMap.parent : nodeForSourceMap);
+                withTemporaryNoSourceMap(function () {
+                    if (isVariableDeclarationOrBindingElement) {
+                        emitModuleMemberName(name.parent);
+                    }
+                    else {
+                        emit(name);
+                    }
+                    write(" = ");
+                    emit(value);
+                });
+                emitEnd(nodeForSourceMap, /*stopOverridingSpan*/ true);
+                if (exportChanged) {
+                    write(")");
+                }
+            }
+            /**
+             * Create temporary variable, emit an assignment of the variable the given expression
+             * @param expression an expression to assign to the newly created temporary variable
+             * @param canDefineTempVariablesInPlace a boolean indicating whether you can define the temporary variable at an assignment location
+             * @param shouldEmitCommaBeforeAssignment a boolean indicating whether an assignment should prefix with comma
+             */
+            function emitTempVariableAssignment(expression, canDefineTempVariablesInPlace, shouldEmitCommaBeforeAssignment, sourceMapNode) {
+                var identifier = createTempVariable(0 /* Auto */);
+                if (!canDefineTempVariablesInPlace) {
+                    recordTempDeclaration(identifier);
+                }
+                emitAssignment(identifier, expression, shouldEmitCommaBeforeAssignment, sourceMapNode || expression.parent);
+                return identifier;
+            }
+            function isFirstVariableDeclaration(root) {
+                return root.kind === 218 /* VariableDeclaration */ &&
+                    root.parent.kind === 219 /* VariableDeclarationList */ &&
+                    root.parent.declarations[0] === root;
+            }
+            function emitDestructuring(root, isAssignmentExpressionStatement, value) {
+                var emitCount = 0;
+                // An exported declaration is actually emitted as an assignment (to a property on the module object), so
+                // temporary variables in an exported declaration need to have real declarations elsewhere
+                // Also temporary variables should be explicitly allocated for source level declarations when module target is system
+                // because actual variable declarations are hoisted
+                var canDefineTempVariablesInPlace = false;
+                if (root.kind === 218 /* VariableDeclaration */) {
+                    var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */;
+                    var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
+                    canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
+                }
+                else if (root.kind === 142 /* Parameter */) {
+                    canDefineTempVariablesInPlace = true;
+                }
+                if (root.kind === 187 /* BinaryExpression */) {
+                    emitAssignmentExpression(root);
+                }
+                else {
+                    ts.Debug.assert(!isAssignmentExpressionStatement);
+                    // If first variable declaration of variable statement correct the start location
+                    if (isFirstVariableDeclaration(root)) {
+                        // Use emit location of "var " as next emit start entry
+                        sourceMap.changeEmitSourcePos();
+                    }
+                    emitBindingElement(root, value);
+                }
+                /**
+                 * Ensures that there exists a declared identifier whose value holds the given expression.
+                 * This function is useful to ensure that the expression's value can be read from in subsequent expressions.
+                 * Unless 'reuseIdentifierExpressions' is false, 'expr' will be returned if it is just an identifier.
+                 *
+                 * @param expr the expression whose value needs to be bound.
+                 * @param reuseIdentifierExpressions true if identifier expressions can simply be returned;
+                 *                                   false if it is necessary to always emit an identifier.
+                 */
+                function ensureIdentifier(expr, reuseIdentifierExpressions, sourceMapNode) {
+                    if (expr.kind === 69 /* Identifier */ && reuseIdentifierExpressions) {
+                        return expr;
+                    }
+                    var identifier = emitTempVariableAssignment(expr, canDefineTempVariablesInPlace, emitCount > 0, sourceMapNode);
+                    emitCount++;
+                    return identifier;
+                }
+                function createDefaultValueCheck(value, defaultValue, sourceMapNode) {
+                    // The value expression will be evaluated twice, so for anything but a simple identifier
+                    // we need to generate a temporary variable
+                    // If the temporary variable needs to be emitted use the source Map node for assignment of that statement
+                    value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, sourceMapNode);
+                    // Return the expression 'value === void 0 ? defaultValue : value'
+                    var equals = ts.createSynthesizedNode(187 /* BinaryExpression */);
+                    equals.left = value;
+                    equals.operatorToken = ts.createSynthesizedNode(32 /* EqualsEqualsEqualsToken */);
+                    equals.right = createVoidZero();
+                    return createConditionalExpression(equals, defaultValue, value);
+                }
+                function createConditionalExpression(condition, whenTrue, whenFalse) {
+                    var cond = ts.createSynthesizedNode(188 /* ConditionalExpression */);
+                    cond.condition = condition;
+                    cond.questionToken = ts.createSynthesizedNode(53 /* QuestionToken */);
+                    cond.whenTrue = whenTrue;
+                    cond.colonToken = ts.createSynthesizedNode(54 /* ColonToken */);
+                    cond.whenFalse = whenFalse;
+                    return cond;
+                }
+                function createNumericLiteral(value) {
+                    var node = ts.createSynthesizedNode(8 /* NumericLiteral */);
+                    node.text = "" + value;
+                    return node;
+                }
+                function createPropertyAccessForDestructuringProperty(object, propName) {
+                    var index;
+                    var nameIsComputed = propName.kind === 140 /* ComputedPropertyName */;
+                    if (nameIsComputed) {
+                        // TODO to handle when we look into sourcemaps for computed properties, for now use propName
+                        index = ensureIdentifier(propName.expression, /*reuseIdentifierExpressions*/ false, propName);
+                    }
+                    else {
+                        // We create a synthetic copy of the identifier in order to avoid the rewriting that might
+                        // otherwise occur when the identifier is emitted.
+                        index = ts.createSynthesizedNode(propName.kind);
+                        // We need to unescape identifier here because when parsing an identifier prefixing with "__"
+                        // the parser need to append "_" in order to escape colliding with magic identifiers such as "__proto__"
+                        // Therefore, in order to correctly emit identifiers that are written in original TypeScript file,
+                        // we will unescapeIdentifier to remove additional underscore (if no underscore is added, the function will return original input string)
+                        index.text = ts.unescapeIdentifier(propName.text);
+                    }
+                    return !nameIsComputed && index.kind === 69 /* Identifier */
+                        ? createPropertyAccessExpression(object, index)
+                        : createElementAccessExpression(object, index);
+                }
+                function createSliceCall(value, sliceIndex) {
+                    var call = ts.createSynthesizedNode(174 /* CallExpression */);
+                    var sliceIdentifier = ts.createSynthesizedNode(69 /* Identifier */);
+                    sliceIdentifier.text = "slice";
+                    call.expression = createPropertyAccessExpression(value, sliceIdentifier);
+                    call.arguments = ts.createSynthesizedNodeArray();
+                    call.arguments[0] = createNumericLiteral(sliceIndex);
+                    return call;
+                }
+                function emitObjectLiteralAssignment(target, value, sourceMapNode) {
+                    var properties = target.properties;
+                    if (properties.length !== 1) {
+                        // For anything but a single element destructuring we need to generate a temporary
+                        // to ensure value is evaluated exactly once.
+                        // When doing so we want to highlight the passed in source map node since thats the one needing this temp assignment
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, sourceMapNode);
+                    }
+                    for (var _a = 0, properties_5 = properties; _a < properties_5.length; _a++) {
+                        var p = properties_5[_a];
+                        if (p.kind === 253 /* PropertyAssignment */ || p.kind === 254 /* ShorthandPropertyAssignment */) {
+                            var propName = p.name;
+                            var target_1 = p.kind === 254 /* ShorthandPropertyAssignment */ ? p : p.initializer || propName;
+                            // Assignment for target = value.propName should highlight whole property, hence use p as source map node
+                            emitDestructuringAssignment(target_1, createPropertyAccessForDestructuringProperty(value, propName), p);
+                        }
+                    }
+                }
+                function emitArrayLiteralAssignment(target, value, sourceMapNode) {
+                    var elements = target.elements;
+                    if (elements.length !== 1) {
+                        // For anything but a single element destructuring we need to generate a temporary
+                        // to ensure value is evaluated exactly once.
+                        // When doing so we want to highlight the passed in source map node since thats the one needing this temp assignment
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, sourceMapNode);
+                    }
+                    for (var i = 0; i < elements.length; i++) {
+                        var e = elements[i];
+                        if (e.kind !== 193 /* OmittedExpression */) {
+                            // Assignment for target = value.propName should highlight whole property, hence use e as source map node
+                            if (e.kind !== 191 /* SpreadElementExpression */) {
+                                emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i)), e);
+                            }
+                            else if (i === elements.length - 1) {
+                                emitDestructuringAssignment(e.expression, createSliceCall(value, i), e);
+                            }
+                        }
+                    }
+                }
+                function emitDestructuringAssignment(target, value, sourceMapNode) {
+                    // When emitting target = value use source map node to highlight, including any temporary assignments needed for this
+                    if (target.kind === 254 /* ShorthandPropertyAssignment */) {
+                        if (target.objectAssignmentInitializer) {
+                            value = createDefaultValueCheck(value, target.objectAssignmentInitializer, sourceMapNode);
+                        }
+                        target = target.name;
+                    }
+                    else if (target.kind === 187 /* BinaryExpression */ && target.operatorToken.kind === 56 /* EqualsToken */) {
+                        value = createDefaultValueCheck(value, target.right, sourceMapNode);
+                        target = target.left;
+                    }
+                    if (target.kind === 171 /* ObjectLiteralExpression */) {
+                        emitObjectLiteralAssignment(target, value, sourceMapNode);
+                    }
+                    else if (target.kind === 170 /* ArrayLiteralExpression */) {
+                        emitArrayLiteralAssignment(target, value, sourceMapNode);
+                    }
+                    else {
+                        emitAssignment(target, value, /*shouldEmitCommaBeforeAssignment*/ emitCount > 0, sourceMapNode);
+                        emitCount++;
+                    }
+                }
+                function emitAssignmentExpression(root) {
+                    var target = root.left;
+                    var value = root.right;
+                    if (ts.isEmptyObjectLiteralOrArrayLiteral(target)) {
+                        emit(value);
+                    }
+                    else if (isAssignmentExpressionStatement) {
+                        // Source map node for root.left = root.right is root
+                        // but if root is synthetic, which could be in below case, use the target which is { a }
+                        // for ({a} of {a: string}) {
+                        // }
+                        emitDestructuringAssignment(target, value, ts.nodeIsSynthesized(root) ? target : root);
+                    }
+                    else {
+                        if (root.parent.kind !== 178 /* ParenthesizedExpression */) {
+                            write("(");
+                        }
+                        // Temporary assignment needed to emit root should highlight whole binary expression
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, root);
+                        // Source map node for root.left = root.right is root
+                        emitDestructuringAssignment(target, value, root);
+                        write(", ");
+                        emit(value);
+                        if (root.parent.kind !== 178 /* ParenthesizedExpression */) {
+                            write(")");
+                        }
+                    }
+                }
+                function emitBindingElement(target, value) {
+                    // Any temporary assignments needed to emit target = value should point to target
+                    if (target.initializer) {
+                        // Combine value and initializer
+                        value = value ? createDefaultValueCheck(value, target.initializer, target) : target.initializer;
+                    }
+                    else if (!value) {
+                        // Use 'void 0' in absence of value and initializer
+                        value = createVoidZero();
+                    }
+                    if (ts.isBindingPattern(target.name)) {
+                        var pattern = target.name;
+                        var elements = pattern.elements;
+                        var numElements = elements.length;
+                        if (numElements !== 1) {
+                            // For anything other than a single-element destructuring we need to generate a temporary
+                            // to ensure value is evaluated exactly once. Additionally, if we have zero elements
+                            // we need to emit *something* to ensure that in case a 'var' keyword was already emitted,
+                            // so in that case, we'll intentionally create that temporary.
+                            value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ numElements !== 0, target);
+                        }
+                        for (var i = 0; i < numElements; i++) {
+                            var element = elements[i];
+                            if (pattern.kind === 167 /* ObjectBindingPattern */) {
+                                // Rewrite element to a declaration with an initializer that fetches property
+                                var propName = element.propertyName || element.name;
+                                emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName));
+                            }
+                            else if (element.kind !== 193 /* OmittedExpression */) {
+                                if (!element.dotDotDotToken) {
+                                    // Rewrite element to a declaration that accesses array element at index i
+                                    emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i)));
+                                }
+                                else if (i === numElements - 1) {
+                                    emitBindingElement(element, createSliceCall(value, i));
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        emitAssignment(target.name, value, /*shouldEmitCommaBeforeAssignment*/ emitCount > 0, target);
+                        emitCount++;
+                    }
+                }
+            }
+            function emitVariableDeclaration(node) {
+                if (ts.isBindingPattern(node.name)) {
+                    var isExported = ts.getCombinedNodeFlags(node) & 1 /* Export */;
+                    if (languageVersion >= 2 /* ES6 */ && (!isExported || modulekind === ts.ModuleKind.ES6)) {
+                        // emit ES6 destructuring only if target module is ES6 or variable is not exported
+                        // exported variables in CJS/AMD are prefixed with 'exports.' so result javascript { exports.toString } = 1; is illegal
+                        var isTopLevelDeclarationInSystemModule = modulekind === ts.ModuleKind.System &&
+                            shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ true);
+                        if (isTopLevelDeclarationInSystemModule) {
+                            // In System modules top level variables are hoisted
+                            // so variable declarations with destructuring are turned into destructuring assignments.
+                            // As a result, they will need parentheses to disambiguate object binding assignments from blocks.
+                            write("(");
+                        }
+                        emit(node.name);
+                        emitOptional(" = ", node.initializer);
+                        if (isTopLevelDeclarationInSystemModule) {
+                            write(")");
+                        }
+                    }
+                    else {
+                        emitDestructuring(node, /*isAssignmentExpressionStatement*/ false);
+                    }
+                }
+                else {
+                    var initializer = node.initializer;
+                    if (!initializer &&
+                        languageVersion < 2 /* ES6 */ &&
+                        // for names - binding patterns that lack initializer there is no point to emit explicit initializer
+                        // since downlevel codegen for destructuring will fail in the absence of initializer so all binding elements will say uninitialized
+                        node.name.kind === 69 /* Identifier */) {
+                        var container = ts.getEnclosingBlockScopeContainer(node);
+                        var flags = resolver.getNodeCheckFlags(node);
+                        // nested let bindings might need to be initialized explicitly to preserve ES6 semantic
+                        // { let x = 1; }
+                        // { let x; } // x here should be undefined. not 1
+                        // NOTES:
+                        // Top level bindings never collide with anything and thus don't require explicit initialization.
+                        // As for nested let bindings there are two cases:
+                        // - nested let bindings that were not renamed definitely should be initialized explicitly
+                        //   { let x = 1; }
+                        //   { let x; if (some-condition) { x = 1}; if (x) { /*1*/ } }
+                        //   Without explicit initialization code in /*1*/ can be executed even if some-condition is evaluated to false
+                        // - renaming introduces fresh name that should not collide with any existing names, however renamed bindings sometimes also should be
+                        //   explicitly initialized. One particular case: non-captured binding declared inside loop body (but not in loop initializer)
+                        //   let x;
+                        //   for (;;) {
+                        //       let x;
+                        //   }
+                        //   in downlevel codegen inner 'x' will be renamed so it won't collide with outer 'x' however it will should be reset on every iteration
+                        //   as if it was declared anew.
+                        //   * Why non-captured binding - because if loop contains block scoped binding captured in some function then loop body will be rewritten
+                        //   to have a fresh scope on every iteration so everything will just work.
+                        //   * Why loop initializer is excluded - since we've introduced a fresh name it already will be undefined.
+                        var isCapturedInFunction = flags & 131072 /* CapturedBlockScopedBinding */;
+                        var isDeclaredInLoop = flags & 262144 /* BlockScopedBindingInLoop */;
+                        var emittedAsTopLevel = ts.isBlockScopedContainerTopLevel(container) ||
+                            (isCapturedInFunction && isDeclaredInLoop && container.kind === 199 /* Block */ && ts.isIterationStatement(container.parent, /*lookInLabeledStatements*/ false));
+                        var emittedAsNestedLetDeclaration = ts.getCombinedNodeFlags(node) & 1024 /* Let */ &&
+                            !emittedAsTopLevel;
+                        var emitExplicitInitializer = emittedAsNestedLetDeclaration &&
+                            container.kind !== 207 /* ForInStatement */ &&
+                            container.kind !== 208 /* ForOfStatement */ &&
+                            (!resolver.isDeclarationWithCollidingName(node) ||
+                                (isDeclaredInLoop && !isCapturedInFunction && !ts.isIterationStatement(container, /*lookInLabeledStatements*/ false)));
+                        if (emitExplicitInitializer) {
+                            initializer = createVoidZero();
+                        }
+                    }
+                    var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.name);
+                    if (exportChanged) {
+                        write(exportFunctionForFile + "(\"");
+                        emitNodeWithCommentsAndWithoutSourcemap(node.name);
+                        write("\", ");
+                    }
+                    emitModuleMemberName(node);
+                    emitOptional(" = ", initializer);
+                    if (exportChanged) {
+                        write(")");
+                    }
+                }
+            }
+            function emitExportVariableAssignments(node) {
+                if (node.kind === 193 /* OmittedExpression */) {
+                    return;
+                }
+                var name = node.name;
+                if (name.kind === 69 /* Identifier */) {
+                    emitExportMemberAssignments(name);
+                }
+                else if (ts.isBindingPattern(name)) {
+                    ts.forEach(name.elements, emitExportVariableAssignments);
+                }
+            }
+            function isES6ExportedDeclaration(node) {
+                return !!(node.flags & 1 /* Export */) &&
+                    modulekind === ts.ModuleKind.ES6 &&
+                    node.parent.kind === 256 /* SourceFile */;
+            }
+            function emitVariableStatement(node) {
+                var startIsEmitted = false;
+                if (node.flags & 1 /* Export */) {
+                    if (isES6ExportedDeclaration(node)) {
+                        // Exported ES6 module member
+                        write("export ");
+                        startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList);
+                    }
+                }
+                else {
+                    startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList);
+                }
+                if (startIsEmitted) {
+                    emitCommaList(node.declarationList.declarations);
+                    write(";");
+                }
+                else {
+                    var atLeastOneItem = emitVariableDeclarationListSkippingUninitializedEntries(node.declarationList);
+                    if (atLeastOneItem) {
+                        write(";");
+                    }
+                }
+                if (modulekind !== ts.ModuleKind.ES6 && node.parent === currentSourceFile) {
+                    ts.forEach(node.declarationList.declarations, emitExportVariableAssignments);
+                }
+            }
+            function shouldEmitLeadingAndTrailingCommentsForVariableStatement(node) {
+                // If we're not exporting the variables, there's nothing special here.
+                // Always emit comments for these nodes.
+                if (!(node.flags & 1 /* Export */)) {
+                    return true;
+                }
+                // If we are exporting, but it's a top-level ES6 module exports,
+                // we'll emit the declaration list verbatim, so emit comments too.
+                if (isES6ExportedDeclaration(node)) {
+                    return true;
+                }
+                // Otherwise, only emit if we have at least one initializer present.
+                for (var _a = 0, _b = node.declarationList.declarations; _a < _b.length; _a++) {
+                    var declaration = _b[_a];
+                    if (declaration.initializer) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function emitParameter(node) {
+                if (languageVersion < 2 /* ES6 */) {
+                    if (ts.isBindingPattern(node.name)) {
+                        var name_29 = createTempVariable(0 /* Auto */);
+                        if (!tempParameters) {
+                            tempParameters = [];
+                        }
+                        tempParameters.push(name_29);
+                        emit(name_29);
+                    }
+                    else {
+                        emit(node.name);
+                    }
+                }
+                else {
+                    if (node.dotDotDotToken) {
+                        write("...");
+                    }
+                    emit(node.name);
+                    emitOptional(" = ", node.initializer);
+                }
+            }
+            function emitDefaultValueAssignments(node) {
+                if (languageVersion < 2 /* ES6 */) {
+                    var tempIndex_1 = 0;
+                    ts.forEach(node.parameters, function (parameter) {
+                        // A rest parameter cannot have a binding pattern or an initializer,
+                        // so let's just ignore it.
+                        if (parameter.dotDotDotToken) {
+                            return;
+                        }
+                        var paramName = parameter.name, initializer = parameter.initializer;
+                        if (ts.isBindingPattern(paramName)) {
+                            // In cases where a binding pattern is simply '[]' or '{}',
+                            // we usually don't want to emit a var declaration; however, in the presence
+                            // of an initializer, we must emit that expression to preserve side effects.
+                            var hasBindingElements = paramName.elements.length > 0;
+                            if (hasBindingElements || initializer) {
+                                writeLine();
+                                write("var ");
+                                if (hasBindingElements) {
+                                    emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex_1]);
+                                }
+                                else {
+                                    emit(tempParameters[tempIndex_1]);
+                                    write(" = ");
+                                    emit(initializer);
+                                }
+                                write(";");
+                            }
+                            // Regardless of whether we will emit a var declaration for the binding pattern, we generate the temporary
+                            // variable for the parameter (see: emitParameter)
+                            tempIndex_1++;
+                        }
+                        else if (initializer) {
+                            writeLine();
+                            emitStart(parameter);
+                            write("if (");
+                            emitNodeWithoutSourceMap(paramName);
+                            write(" === void 0)");
+                            emitEnd(parameter);
+                            write(" { ");
+                            emitStart(parameter);
+                            emitNodeWithCommentsAndWithoutSourcemap(paramName);
+                            write(" = ");
+                            emitNodeWithCommentsAndWithoutSourcemap(initializer);
+                            emitEnd(parameter);
+                            write("; }");
+                        }
+                    });
+                }
+            }
+            function emitRestParameter(node) {
+                if (languageVersion < 2 /* ES6 */ && ts.hasDeclaredRestParameter(node)) {
+                    var restIndex = node.parameters.length - 1;
+                    var restParam = node.parameters[restIndex];
+                    // A rest parameter cannot have a binding pattern, so let's just ignore it if it does.
+                    if (ts.isBindingPattern(restParam.name)) {
+                        return;
+                    }
+                    var tempName = createTempVariable(268435456 /* _i */).text;
+                    writeLine();
+                    emitLeadingComments(restParam);
+                    emitStart(restParam);
+                    write("var ");
+                    emitNodeWithCommentsAndWithoutSourcemap(restParam.name);
+                    write(" = [];");
+                    emitEnd(restParam);
+                    emitTrailingComments(restParam);
+                    writeLine();
+                    write("for (");
+                    emitStart(restParam);
+                    write("var " + tempName + " = " + restIndex + ";");
+                    emitEnd(restParam);
+                    write(" ");
+                    emitStart(restParam);
+                    write(tempName + " < arguments.length;");
+                    emitEnd(restParam);
+                    write(" ");
+                    emitStart(restParam);
+                    write(tempName + "++");
+                    emitEnd(restParam);
+                    write(") {");
+                    increaseIndent();
+                    writeLine();
+                    emitStart(restParam);
+                    emitNodeWithCommentsAndWithoutSourcemap(restParam.name);
+                    write("[" + tempName + " - " + restIndex + "] = arguments[" + tempName + "];");
+                    emitEnd(restParam);
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+            }
+            function emitAccessor(node) {
+                write(node.kind === 149 /* GetAccessor */ ? "get " : "set ");
+                emit(node.name);
+                emitSignatureAndBody(node);
+            }
+            function shouldEmitAsArrowFunction(node) {
+                return node.kind === 180 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */;
+            }
+            function emitDeclarationName(node) {
+                if (node.name) {
+                    emitNodeWithCommentsAndWithoutSourcemap(node.name);
+                }
+                else {
+                    write(getGeneratedNameForNode(node));
+                }
+            }
+            function shouldEmitFunctionName(node) {
+                if (node.kind === 179 /* FunctionExpression */) {
+                    // Emit name if one is present
+                    return !!node.name;
+                }
+                if (node.kind === 220 /* FunctionDeclaration */) {
+                    // Emit name if one is present, or emit generated name in down-level case (for export default case)
+                    return !!node.name || modulekind !== ts.ModuleKind.ES6;
+                }
+            }
+            function emitFunctionDeclaration(node) {
+                if (ts.nodeIsMissing(node.body)) {
+                    return emitCommentsOnNotEmittedNode(node);
+                }
+                // TODO (yuisu) : we should not have special cases to condition emitting comments
+                // but have one place to fix check for these conditions.
+                var kind = node.kind, parent = node.parent;
+                if (kind !== 147 /* MethodDeclaration */ &&
+                    kind !== 146 /* MethodSignature */ &&
+                    parent &&
+                    parent.kind !== 253 /* PropertyAssignment */ &&
+                    parent.kind !== 174 /* CallExpression */ &&
+                    parent.kind !== 170 /* ArrayLiteralExpression */) {
+                    // 1. Methods will emit comments at their assignment declaration sites.
+                    //
+                    // 2. If the function is a property of object literal, emitting leading-comments
+                    //    is done by emitNodeWithoutSourceMap which then call this function.
+                    //    In particular, we would like to avoid emit comments twice in following case:
+                    //
+                    //          var obj = {
+                    //              id:
+                    //                  /*comment*/ () => void
+                    //          }
+                    //
+                    // 3. If the function is an argument in call expression, emitting of comments will be
+                    //    taken care of in emit list of arguments inside of 'emitCallExpression'.
+                    //
+                    // 4. If the function is in an array literal, 'emitLinePreservingList' will take care
+                    //    of leading comments.
+                    emitLeadingComments(node);
+                }
+                emitStart(node);
+                // For targeting below es6, emit functions-like declaration including arrow function using function keyword.
+                // When targeting ES6, emit arrow function natively in ES6 by omitting function keyword and using fat arrow instead
+                if (!shouldEmitAsArrowFunction(node)) {
+                    if (isES6ExportedDeclaration(node)) {
+                        write("export ");
+                        if (node.flags & 512 /* Default */) {
+                            write("default ");
+                        }
+                    }
+                    write("function");
+                    if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) {
+                        write("*");
+                    }
+                    write(" ");
+                }
+                if (shouldEmitFunctionName(node)) {
+                    emitDeclarationName(node);
+                }
+                emitSignatureAndBody(node);
+                if (modulekind !== ts.ModuleKind.ES6 && kind === 220 /* FunctionDeclaration */ && parent === currentSourceFile && node.name) {
+                    emitExportMemberAssignments(node.name);
+                }
+                emitEnd(node);
+                if (kind !== 147 /* MethodDeclaration */ &&
+                    kind !== 146 /* MethodSignature */ &&
+                    kind !== 180 /* ArrowFunction */) {
+                    emitTrailingComments(node);
+                }
+            }
+            function emitCaptureThisForNodeIfNecessary(node) {
+                if (resolver.getNodeCheckFlags(node) & 4 /* CaptureThis */) {
+                    writeLine();
+                    emitStart(node);
+                    write("var _this = this;");
+                    emitEnd(node);
+                }
+            }
+            function emitSignatureParameters(node) {
+                increaseIndent();
+                write("(");
+                if (node) {
+                    var parameters = node.parameters;
+                    var skipCount = node.parameters.length && node.parameters[0].name.text === "this" ? 1 : 0;
+                    var omitCount = languageVersion < 2 /* ES6 */ && ts.hasDeclaredRestParameter(node) ? 1 : 0;
+                    emitList(parameters, skipCount, parameters.length - omitCount - skipCount, /*multiLine*/ false, /*trailingComma*/ false);
+                }
+                write(")");
+                decreaseIndent();
+            }
+            function emitSignatureParametersForArrow(node) {
+                // Check whether the parameter list needs parentheses and preserve no-parenthesis
+                if (node.parameters.length === 1 && node.pos === node.parameters[0].pos) {
+                    emit(node.parameters[0]);
+                    return;
+                }
+                emitSignatureParameters(node);
+            }
+            function emitAsyncFunctionBodyForES6(node) {
+                var promiseConstructor = ts.getEntityNameFromTypeNode(node.type);
+                var isArrowFunction = node.kind === 180 /* ArrowFunction */;
+                var hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192 /* CaptureArguments */) !== 0;
+                // An async function is emit as an outer function that calls an inner
+                // generator function. To preserve lexical bindings, we pass the current
+                // `this` and `arguments` objects to `__awaiter`. The generator function
+                // passed to `__awaiter` is executed inside of the callback to the
+                // promise constructor.
+                //
+                // The emit for an async arrow without a lexical `arguments` binding might be:
+                //
+                //  // input
+                //  let a = async (b) => { await b; }
+                //
+                //  // output
+                //  let a = (b) => __awaiter(this, void 0, void 0, function* () {
+                //      yield b;
+                //  });
+                //
+                // The emit for an async arrow with a lexical `arguments` binding might be:
+                //
+                //  // input
+                //  let a = async (b) => { await arguments[0]; }
+                //
+                //  // output
+                //  let a = (b) => __awaiter(this, arguments, void 0, function* (arguments) {
+                //      yield arguments[0];
+                //  });
+                //
+                // The emit for an async function expression without a lexical `arguments` binding
+                // might be:
+                //
+                //  // input
+                //  let a = async function (b) {
+                //      await b;
+                //  }
+                //
+                //  // output
+                //  let a = function (b) {
+                //      return __awaiter(this, void 0, void 0, function* () {
+                //          yield b;
+                //      });
+                //  }
+                //
+                // The emit for an async function expression with a lexical `arguments` binding
+                // might be:
+                //
+                //  // input
+                //  let a = async function (b) {
+                //      await arguments[0];
+                //  }
+                //
+                //  // output
+                //  let a = function (b) {
+                //      return __awaiter(this, arguments, void 0, function* (_arguments) {
+                //          yield _arguments[0];
+                //      });
+                //  }
+                //
+                // The emit for an async function expression with a lexical `arguments` binding
+                // and a return type annotation might be:
+                //
+                //  // input
+                //  let a = async function (b): MyPromise<any> {
+                //      await arguments[0];
+                //  }
+                //
+                //  // output
+                //  let a = function (b) {
+                //      return __awaiter(this, arguments, MyPromise, function* (_arguments) {
+                //          yield _arguments[0];
+                //      });
+                //  }
+                //
+                // If this is not an async arrow, emit the opening brace of the function body
+                // and the start of the return statement.
+                if (!isArrowFunction) {
+                    write(" {");
+                    increaseIndent();
+                    writeLine();
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* AsyncMethodWithSuperBinding */) {
+                        writeLines("\nconst _super = (function (geti, seti) {\n    const cache = Object.create(null);\n    return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n})(name => super[name], (name, value) => super[name] = value);");
+                        writeLine();
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* AsyncMethodWithSuper */) {
+                        write("const _super = name => super[name];");
+                        writeLine();
+                    }
+                    write("return");
+                }
+                write(" __awaiter(this");
+                if (hasLexicalArguments) {
+                    write(", arguments, ");
+                }
+                else {
+                    write(", void 0, ");
+                }
+                if (languageVersion >= 2 /* ES6 */ || !promiseConstructor) {
+                    write("void 0");
+                }
+                else {
+                    emitEntityNameAsExpression(promiseConstructor, /*useFallback*/ false);
+                }
+                // Emit the call to __awaiter.
+                write(", function* ()");
+                // Emit the signature and body for the inner generator function.
+                emitFunctionBody(node);
+                write(")");
+                // If this is not an async arrow, emit the closing brace of the outer function body.
+                if (!isArrowFunction) {
+                    write(";");
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+            }
+            function emitFunctionBody(node) {
+                if (!node.body) {
+                    // There can be no body when there are parse errors.  Just emit an empty block
+                    // in that case.
+                    write(" { }");
+                }
+                else {
+                    if (node.body.kind === 199 /* Block */) {
+                        emitBlockFunctionBody(node, node.body);
+                    }
+                    else {
+                        emitExpressionFunctionBody(node, node.body);
+                    }
+                }
+            }
+            function emitSignatureAndBody(node) {
+                var saveConvertedLoopState = convertedLoopState;
+                var saveTempFlags = tempFlags;
+                var saveTempVariables = tempVariables;
+                var saveTempParameters = tempParameters;
+                convertedLoopState = undefined;
+                tempFlags = 0;
+                tempVariables = undefined;
+                tempParameters = undefined;
+                // When targeting ES6, emit arrow function natively in ES6
+                if (shouldEmitAsArrowFunction(node)) {
+                    emitSignatureParametersForArrow(node);
+                    write(" =>");
+                }
+                else {
+                    emitSignatureParameters(node);
+                }
+                var isAsync = ts.isAsyncFunctionLike(node);
+                if (isAsync) {
+                    emitAsyncFunctionBodyForES6(node);
+                }
+                else {
+                    emitFunctionBody(node);
+                }
+                if (!isES6ExportedDeclaration(node)) {
+                    emitExportMemberAssignment(node);
+                }
+                ts.Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+                tempFlags = saveTempFlags;
+                tempVariables = saveTempVariables;
+                tempParameters = saveTempParameters;
+            }
+            // Returns true if any preamble code was emitted.
+            function emitFunctionBodyPreamble(node) {
+                emitCaptureThisForNodeIfNecessary(node);
+                emitDefaultValueAssignments(node);
+                emitRestParameter(node);
+            }
+            function emitExpressionFunctionBody(node, body) {
+                if (languageVersion < 2 /* ES6 */ || node.flags & 256 /* Async */) {
+                    emitDownLevelExpressionFunctionBody(node, body);
+                    return;
+                }
+                // For es6 and higher we can emit the expression as is.  However, in the case
+                // where the expression might end up looking like a block when emitted, we'll
+                // also wrap it in parentheses first.  For example if you have: a => <foo>{}
+                // then we need to generate: a => ({})
+                write(" ");
+                // Unwrap all type assertions.
+                var current = body;
+                while (current.kind === 177 /* TypeAssertionExpression */) {
+                    current = current.expression;
+                }
+                emitParenthesizedIf(body, current.kind === 171 /* ObjectLiteralExpression */);
+            }
+            function emitDownLevelExpressionFunctionBody(node, body) {
+                write(" {");
+                increaseIndent();
+                var outPos = writer.getTextPos();
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
+                emitFunctionBodyPreamble(node);
+                var preambleEmitted = writer.getTextPos() !== outPos;
+                decreaseIndent();
+                // If we didn't have to emit any preamble code, then attempt to keep the arrow
+                // function on one line.
+                if (!preambleEmitted && nodeStartPositionsAreOnSameLine(node, body)) {
+                    write(" ");
+                    emitStart(body);
+                    write("return ");
+                    emit(body);
+                    emitEnd(body);
+                    write(";");
+                    emitTempDeclarations(/*newLine*/ false);
+                    write(" ");
+                }
+                else {
+                    increaseIndent();
+                    writeLine();
+                    emitLeadingComments(node.body);
+                    emitStart(body);
+                    write("return ");
+                    emit(body);
+                    emitEnd(body);
+                    write(";");
+                    emitTrailingComments(node.body);
+                    emitTempDeclarations(/*newLine*/ true);
+                    decreaseIndent();
+                    writeLine();
+                }
+                emitStart(node.body);
+                write("}");
+                emitEnd(node.body);
+            }
+            function emitBlockFunctionBody(node, body) {
+                write(" {");
+                var initialTextPos = writer.getTextPos();
+                increaseIndent();
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
+                // Emit all the directive prologues (like "use strict").  These have to come before
+                // any other preamble code we write (like parameter initializers).
+                var startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
+                emitFunctionBodyPreamble(node);
+                decreaseIndent();
+                var preambleEmitted = writer.getTextPos() !== initialTextPos;
+                if (!preambleEmitted && nodeEndIsOnSameLineAsNodeStart(body, body)) {
+                    for (var _a = 0, _b = body.statements; _a < _b.length; _a++) {
+                        var statement = _b[_a];
+                        write(" ");
+                        emit(statement);
+                    }
+                    emitTempDeclarations(/*newLine*/ false);
+                    write(" ");
+                    emitLeadingCommentsOfPosition(body.statements.end);
+                }
+                else {
+                    increaseIndent();
+                    emitLinesStartingAt(body.statements, startIndex);
+                    emitTempDeclarations(/*newLine*/ true);
+                    writeLine();
+                    emitLeadingCommentsOfPosition(body.statements.end);
+                    decreaseIndent();
+                }
+                emitToken(16 /* CloseBraceToken */, body.statements.end);
+            }
+            /**
+             * Return the statement at a given index if it is a super-call statement
+             * @param ctor a constructor declaration
+             * @param index an index to constructor's body to check
+             */
+            function getSuperCallAtGivenIndex(ctor, index) {
+                if (!ctor.body) {
+                    return undefined;
+                }
+                var statements = ctor.body.statements;
+                if (!statements || index >= statements.length) {
+                    return undefined;
+                }
+                var statement = statements[index];
+                if (statement.kind === 202 /* ExpressionStatement */) {
+                    return ts.isSuperCallExpression(statement.expression) ? statement : undefined;
+                }
+            }
+            function emitParameterPropertyAssignments(node) {
+                ts.forEach(node.parameters, function (param) {
+                    if (param.flags & 92 /* ParameterPropertyModifier */) {
+                        writeLine();
+                        emitStart(param);
+                        emitStart(param.name);
+                        write("this.");
+                        emitNodeWithoutSourceMap(param.name);
+                        emitEnd(param.name);
+                        write(" = ");
+                        emit(param.name);
+                        write(";");
+                        emitEnd(param);
+                    }
+                });
+            }
+            function emitMemberAccessForPropertyName(memberName) {
+                // This does not emit source map because it is emitted by caller as caller
+                // is aware how the property name changes to the property access
+                // eg. public x = 10; becomes this.x and static x = 10 becomes className.x
+                if (memberName.kind === 9 /* StringLiteral */ || memberName.kind === 8 /* NumericLiteral */) {
+                    write("[");
+                    emitNodeWithCommentsAndWithoutSourcemap(memberName);
+                    write("]");
+                }
+                else if (memberName.kind === 140 /* ComputedPropertyName */) {
+                    emitComputedPropertyName(memberName);
+                }
+                else {
+                    write(".");
+                    emitNodeWithCommentsAndWithoutSourcemap(memberName);
+                }
+            }
+            function getInitializedProperties(node, isStatic) {
+                var properties = [];
+                for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
+                    var member = _b[_a];
+                    if (member.kind === 145 /* PropertyDeclaration */ && isStatic === ((member.flags & 32 /* Static */) !== 0) && member.initializer) {
+                        properties.push(member);
+                    }
+                }
+                return properties;
+            }
+            function emitPropertyDeclarations(node, properties) {
+                for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+                    var property = properties_6[_a];
+                    emitPropertyDeclaration(node, property);
+                }
+            }
+            function emitPropertyDeclaration(node, property, receiver, isExpression) {
+                writeLine();
+                emitLeadingComments(property);
+                emitStart(property);
+                emitStart(property.name);
+                if (receiver) {
+                    write(receiver);
+                }
+                else {
+                    if (property.flags & 32 /* Static */) {
+                        emitDeclarationName(node);
+                    }
+                    else {
+                        write("this");
+                    }
+                }
+                emitMemberAccessForPropertyName(property.name);
+                emitEnd(property.name);
+                write(" = ");
+                emit(property.initializer);
+                if (!isExpression) {
+                    write(";");
+                }
+                emitEnd(property);
+                emitTrailingComments(property);
+            }
+            function emitMemberFunctionsForES5AndLower(node) {
+                ts.forEach(node.members, function (member) {
+                    if (member.kind === 198 /* SemicolonClassElement */) {
+                        writeLine();
+                        write(";");
+                    }
+                    else if (member.kind === 147 /* MethodDeclaration */ || node.kind === 146 /* MethodSignature */) {
+                        if (!member.body) {
+                            return emitCommentsOnNotEmittedNode(member);
+                        }
+                        writeLine();
+                        emitLeadingComments(member);
+                        emitStart(member);
+                        emitStart(member.name);
+                        emitClassMemberPrefix(node, member);
+                        emitMemberAccessForPropertyName(member.name);
+                        emitEnd(member.name);
+                        write(" = ");
+                        emitFunctionDeclaration(member);
+                        emitEnd(member);
+                        write(";");
+                        emitTrailingComments(member);
+                    }
+                    else if (member.kind === 149 /* GetAccessor */ || member.kind === 150 /* SetAccessor */) {
+                        var accessors = ts.getAllAccessorDeclarations(node.members, member);
+                        if (member === accessors.firstAccessor) {
+                            writeLine();
+                            emitStart(member);
+                            write("Object.defineProperty(");
+                            emitStart(member.name);
+                            emitClassMemberPrefix(node, member);
+                            write(", ");
+                            emitExpressionForPropertyName(member.name);
+                            emitEnd(member.name);
+                            write(", {");
+                            increaseIndent();
+                            if (accessors.getAccessor) {
+                                writeLine();
+                                emitLeadingComments(accessors.getAccessor);
+                                write("get: ");
+                                emitStart(accessors.getAccessor);
+                                write("function ");
+                                emitSignatureAndBody(accessors.getAccessor);
+                                emitEnd(accessors.getAccessor);
+                                emitTrailingComments(accessors.getAccessor);
+                                write(",");
+                            }
+                            if (accessors.setAccessor) {
+                                writeLine();
+                                emitLeadingComments(accessors.setAccessor);
+                                write("set: ");
+                                emitStart(accessors.setAccessor);
+                                write("function ");
+                                emitSignatureAndBody(accessors.setAccessor);
+                                emitEnd(accessors.setAccessor);
+                                emitTrailingComments(accessors.setAccessor);
+                                write(",");
+                            }
+                            writeLine();
+                            write("enumerable: true,");
+                            writeLine();
+                            write("configurable: true");
+                            decreaseIndent();
+                            writeLine();
+                            write("});");
+                            emitEnd(member);
+                        }
+                    }
+                });
+            }
+            function emitMemberFunctionsForES6AndHigher(node) {
+                for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
+                    var member = _b[_a];
+                    if ((member.kind === 147 /* MethodDeclaration */ || node.kind === 146 /* MethodSignature */) && !member.body) {
+                        emitCommentsOnNotEmittedNode(member);
+                    }
+                    else if (member.kind === 147 /* MethodDeclaration */ ||
+                        member.kind === 149 /* GetAccessor */ ||
+                        member.kind === 150 /* SetAccessor */) {
+                        writeLine();
+                        emitLeadingComments(member);
+                        emitStart(member);
+                        if (member.flags & 32 /* Static */) {
+                            write("static ");
+                        }
+                        if (member.kind === 149 /* GetAccessor */) {
+                            write("get ");
+                        }
+                        else if (member.kind === 150 /* SetAccessor */) {
+                            write("set ");
+                        }
+                        if (member.asteriskToken) {
+                            write("*");
+                        }
+                        emit(member.name);
+                        emitSignatureAndBody(member);
+                        emitEnd(member);
+                        emitTrailingComments(member);
+                    }
+                    else if (member.kind === 198 /* SemicolonClassElement */) {
+                        writeLine();
+                        write(";");
+                    }
+                }
+            }
+            function emitConstructor(node, baseTypeElement) {
+                var saveConvertedLoopState = convertedLoopState;
+                var saveTempFlags = tempFlags;
+                var saveTempVariables = tempVariables;
+                var saveTempParameters = tempParameters;
+                convertedLoopState = undefined;
+                tempFlags = 0;
+                tempVariables = undefined;
+                tempParameters = undefined;
+                emitConstructorWorker(node, baseTypeElement);
+                ts.Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+                tempFlags = saveTempFlags;
+                tempVariables = saveTempVariables;
+                tempParameters = saveTempParameters;
+            }
+            function emitConstructorWorker(node, baseTypeElement) {
+                // Check if we have property assignment inside class declaration.
+                // If there is property assignment, we need to emit constructor whether users define it or not
+                // If there is no property assignment, we can omit constructor if users do not define it
+                var hasInstancePropertyWithInitializer = false;
+                // Emit the constructor overload pinned comments
+                ts.forEach(node.members, function (member) {
+                    if (member.kind === 148 /* Constructor */ && !member.body) {
+                        emitCommentsOnNotEmittedNode(member);
+                    }
+                    // Check if there is any non-static property assignment
+                    if (member.kind === 145 /* PropertyDeclaration */ && member.initializer && (member.flags & 32 /* Static */) === 0) {
+                        hasInstancePropertyWithInitializer = true;
+                    }
+                });
+                var ctor = ts.getFirstConstructorWithBody(node);
+                // For target ES6 and above, if there is no user-defined constructor and there is no property assignment
+                // do not emit constructor in class declaration.
+                if (languageVersion >= 2 /* ES6 */ && !ctor && !hasInstancePropertyWithInitializer) {
+                    return;
+                }
+                if (ctor) {
+                    emitLeadingComments(ctor);
+                }
+                emitStart(ctor || node);
+                if (languageVersion < 2 /* ES6 */) {
+                    write("function ");
+                    emitDeclarationName(node);
+                    emitSignatureParameters(ctor);
+                }
+                else {
+                    write("constructor");
+                    if (ctor) {
+                        emitSignatureParameters(ctor);
+                    }
+                    else {
+                        // Based on EcmaScript6 section 14.5.14: Runtime Semantics: ClassDefinitionEvaluation.
+                        // If constructor is empty, then,
+                        //      If ClassHeritageopt is present, then
+                        //          Let constructor be the result of parsing the String "constructor(... args){ super (...args);}" using the syntactic grammar with the goal symbol MethodDefinition.
+                        //      Else,
+                        //          Let constructor be the result of parsing the String "constructor( ){ }" using the syntactic grammar with the goal symbol MethodDefinition
+                        if (baseTypeElement) {
+                            write("(...args)");
+                        }
+                        else {
+                            write("()");
+                        }
+                    }
+                }
+                var startIndex = 0;
+                write(" {");
+                increaseIndent();
+                if (ctor) {
+                    // Emit all the directive prologues (like "use strict").  These have to come before
+                    // any other preamble code we write (like parameter initializers).
+                    startIndex = emitDirectivePrologues(ctor.body.statements, /*startWithNewLine*/ true);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
+                }
+                emitCaptureThisForNodeIfNecessary(node);
+                var superCall;
+                if (ctor) {
+                    emitDefaultValueAssignments(ctor);
+                    emitRestParameter(ctor);
+                    if (baseTypeElement) {
+                        superCall = getSuperCallAtGivenIndex(ctor, startIndex);
+                        if (superCall) {
+                            writeLine();
+                            emit(superCall);
+                        }
+                    }
+                    emitParameterPropertyAssignments(ctor);
+                }
+                else {
+                    if (baseTypeElement) {
+                        writeLine();
+                        emitStart(baseTypeElement);
+                        if (languageVersion < 2 /* ES6 */) {
+                            write("_super.apply(this, arguments);");
+                        }
+                        else {
+                            write("super(...args);");
+                        }
+                        emitEnd(baseTypeElement);
+                    }
+                }
+                emitPropertyDeclarations(node, getInitializedProperties(node, /*isStatic*/ false));
+                if (ctor) {
+                    var statements = ctor.body.statements;
+                    if (superCall) {
+                        statements = statements.slice(1);
+                    }
+                    emitLinesStartingAt(statements, startIndex);
+                }
+                emitTempDeclarations(/*newLine*/ true);
+                writeLine();
+                if (ctor) {
+                    emitLeadingCommentsOfPosition(ctor.body.statements.end);
+                }
+                decreaseIndent();
+                emitToken(16 /* CloseBraceToken */, ctor ? ctor.body.statements.end : node.members.end);
+                emitEnd(ctor || node);
+                if (ctor) {
+                    emitTrailingComments(ctor);
+                }
+            }
+            function emitClassExpression(node) {
+                return emitClassLikeDeclaration(node);
+            }
+            function emitClassDeclaration(node) {
+                return emitClassLikeDeclaration(node);
+            }
+            function emitClassLikeDeclaration(node) {
+                if (languageVersion < 2 /* ES6 */) {
+                    emitClassLikeDeclarationBelowES6(node);
+                }
+                else {
+                    emitClassLikeDeclarationForES6AndHigher(node);
+                }
+                if (modulekind !== ts.ModuleKind.ES6 && node.parent === currentSourceFile && node.name) {
+                    emitExportMemberAssignments(node.name);
+                }
+            }
+            function emitClassLikeDeclarationForES6AndHigher(node) {
+                var decoratedClassAlias;
+                var isHoistedDeclarationInSystemModule = shouldHoistDeclarationInSystemJsModule(node);
+                var isDecorated = ts.nodeIsDecorated(node);
+                var rewriteAsClassExpression = isDecorated || isHoistedDeclarationInSystemModule;
+                if (node.kind === 221 /* ClassDeclaration */) {
+                    if (rewriteAsClassExpression) {
+                        // When we emit an ES6 class that has a class decorator, we must tailor the
+                        // emit to certain specific cases.
+                        //
+                        // In the simplest case, we emit the class declaration as a let declaration, and
+                        // evaluate decorators after the close of the class body:
+                        //
+                        //  TypeScript                      | Javascript
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let C = class C {
+                        //  class C {                       | }
+                        //  }                               | C = __decorate([dec], C);
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | export let C = class C {
+                        //  export class C {                | }
+                        //  }                               | C = __decorate([dec], C);
+                        //  ---------------------------------------------------------------------
+                        //  [Example 1]
+                        //
+                        // If a class declaration contains a reference to itself *inside* of the class body,
+                        // this introduces two bindings to the class: One outside of the class body, and one
+                        // inside of the class body. If we apply decorators as in [Example 1] above, there
+                        // is the possibility that the decorator `dec` will return a new value for the
+                        // constructor, which would result in the binding inside of the class no longer
+                        // pointing to the same reference as the binding outside of the class.
+                        //
+                        // As a result, we must instead rewrite all references to the class *inside* of the
+                        // class body to instead point to a local temporary alias for the class:
+                        //
+                        //  TypeScript                      | Javascript
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let C_1 = class C {
+                        //  class C {                       |   static x() { return C_1.y; }
+                        //    static x() { return C.y; }    | }
+                        //    static y = 1;                 | let C = C_1;
+                        //  }                               | C.y = 1;
+                        //                                  | C = C_1 = __decorate([dec], C);
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let C_1 = class C {
+                        //  export class C {                |   static x() { return C_1.y; }
+                        //    static x() { return C.y; }    | }
+                        //    static y = 1;                 | export let C = C_1;
+                        //  }                               | C.y = 1;
+                        //                                  | C = C_1 = __decorate([dec], C);
+                        //  ---------------------------------------------------------------------
+                        //  [Example 2]
+                        //
+                        // If a class declaration is the default export of a module, we instead emit
+                        // the export after the decorated declaration:
+                        //
+                        //  TypeScript                      | Javascript
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let default_1 = class {
+                        //  export default class {          | }
+                        //  }                               | default_1 = __decorate([dec], default_1);
+                        //                                  | export default default_1;
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let C = class C {
+                        //  export default class {          | }
+                        //  }                               | C = __decorate([dec], C);
+                        //                                  | export default C;
+                        //  ---------------------------------------------------------------------
+                        //  [Example 3]
+                        //
+                        // If the class declaration is the default export and a reference to itself
+                        // inside of the class body, we must emit both an alias for the class *and*
+                        // move the export after the declaration:
+                        //
+                        //  TypeScript                      | Javascript
+                        //  --------------------------------|------------------------------------
+                        //  @dec                            | let C_1 = class C {
+                        //  export default class C {        |   static x() { return C_1.y; }
+                        //    static x() { return C.y; }    | };
+                        //    static y = 1;                 | let C = C_1;
+                        //  }                               | C.y = 1;
+                        //                                  | C = C_1 = __decorate([dec], C);
+                        //                                  | export default C;
+                        //  ---------------------------------------------------------------------
+                        //  [Example 4]
+                        //
+                        // NOTE: we reuse the same rewriting logic for cases when targeting ES6 and module kind is System.
+                        // Because of hoisting top level class declaration need to be emitted as class expressions.
+                        // Double bind case is only required if node is decorated.
+                        if (isDecorated && resolver.getNodeCheckFlags(node) & 524288 /* ClassWithBodyScopedClassBinding */) {
+                            decoratedClassAlias = ts.unescapeIdentifier(makeUniqueName(node.name ? node.name.text : "default"));
+                            decoratedClassAliases[ts.getNodeId(node)] = decoratedClassAlias;
+                        }
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512 /* Default */) && decoratedClassAlias === undefined) {
+                            write("export ");
+                        }
+                        if (!isHoistedDeclarationInSystemModule) {
+                            write("let ");
+                        }
+                        if (decoratedClassAlias !== undefined) {
+                            write("" + decoratedClassAlias);
+                        }
+                        else {
+                            emitDeclarationName(node);
+                        }
+                        write(" = ");
+                    }
+                    else if (isES6ExportedDeclaration(node)) {
+                        write("export ");
+                        if (node.flags & 512 /* Default */) {
+                            write("default ");
+                        }
+                    }
+                }
+                // If the class has static properties, and it's a class expression, then we'll need
+                // to specialize the emit a bit.  for a class expression of the form:
+                //
+                //      class C { static a = 1; static b = 2; ... }
+                //
+                // We'll emit:
+                //
+                //      (_temp = class C { ... }, _temp.a = 1, _temp.b = 2, _temp)
+                //
+                // This keeps the expression as an expression, while ensuring that the static parts
+                // of it have been initialized by the time it is used.
+                var staticProperties = getInitializedProperties(node, /*isStatic*/ true);
+                var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 192 /* ClassExpression */;
+                var generatedName;
+                if (isClassExpressionWithStaticProperties) {
+                    generatedName = getGeneratedNameForNode(node.name);
+                    var synthesizedNode = ts.createSynthesizedNode(69 /* Identifier */);
+                    synthesizedNode.text = generatedName;
+                    recordTempDeclaration(synthesizedNode);
+                    write("(");
+                    increaseIndent();
+                    emit(synthesizedNode);
+                    write(" = ");
+                }
+                write("class");
+                // emit name if
+                // - node has a name
+                // - this is default export with static initializers
+                if (node.name || (node.flags & 512 /* Default */ && (staticProperties.length > 0 || modulekind !== ts.ModuleKind.ES6) && !rewriteAsClassExpression)) {
+                    write(" ");
+                    emitDeclarationName(node);
+                }
+                var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node);
+                if (baseTypeNode) {
+                    write(" extends ");
+                    emit(baseTypeNode.expression);
+                }
+                write(" {");
+                increaseIndent();
+                writeLine();
+                emitConstructor(node, baseTypeNode);
+                emitMemberFunctionsForES6AndHigher(node);
+                decreaseIndent();
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.members.end);
+                if (rewriteAsClassExpression) {
+                    if (decoratedClassAlias !== undefined) {
+                        write(";");
+                        writeLine();
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512 /* Default */)) {
+                            write("export ");
+                        }
+                        write("let ");
+                        emitDeclarationName(node);
+                        write(" = " + decoratedClassAlias);
+                    }
+                    decoratedClassAliases[ts.getNodeId(node)] = undefined;
+                    write(";");
+                }
+                // Emit static property assignment. Because classDeclaration is lexically evaluated,
+                // it is safe to emit static property assignment after classDeclaration
+                // From ES6 specification:
+                //      HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using
+                //                                  a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.
+                if (isClassExpressionWithStaticProperties) {
+                    for (var _a = 0, staticProperties_1 = staticProperties; _a < staticProperties_1.length; _a++) {
+                        var property = staticProperties_1[_a];
+                        write(",");
+                        writeLine();
+                        emitPropertyDeclaration(node, property, /*receiver*/ generatedName, /*isExpression*/ true);
+                    }
+                    write(",");
+                    writeLine();
+                    write(generatedName);
+                    decreaseIndent();
+                    write(")");
+                }
+                else {
+                    writeLine();
+                    emitPropertyDeclarations(node, staticProperties);
+                    emitDecoratorsOfClass(node, decoratedClassAlias);
+                }
+                if (!(node.flags & 1 /* Export */)) {
+                    return;
+                }
+                if (modulekind !== ts.ModuleKind.ES6) {
+                    emitExportMemberAssignment(node);
+                }
+                else {
+                    // If this is an exported class, but not on the top level (i.e. on an internal
+                    // module), export it
+                    if (node.flags & 512 /* Default */) {
+                        // if this is a top level default export of decorated class, write the export after the declaration.
+                        if (isDecorated) {
+                            writeLine();
+                            write("export default ");
+                            emitDeclarationName(node);
+                            write(";");
+                        }
+                    }
+                    else if (node.parent.kind !== 256 /* SourceFile */) {
+                        writeLine();
+                        emitStart(node);
+                        emitModuleMemberName(node);
+                        write(" = ");
+                        emitDeclarationName(node);
+                        emitEnd(node);
+                        write(";");
+                    }
+                }
+            }
+            function emitClassLikeDeclarationBelowES6(node) {
+                var isES6ExportedClass = isES6ExportedDeclaration(node);
+                if (node.kind === 221 /* ClassDeclaration */) {
+                    if (isES6ExportedClass && !(node.flags & 512 /* Default */)) {
+                        write("export ");
+                    }
+                    // source file level classes in system modules are hoisted so 'var's for them are already defined
+                    if (!shouldHoistDeclarationInSystemJsModule(node)) {
+                        write("var ");
+                    }
+                    emitDeclarationName(node);
+                    write(" = ");
+                }
+                write("(function (");
+                var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node);
+                if (baseTypeNode) {
+                    write("_super");
+                }
+                write(") {");
+                var saveTempFlags = tempFlags;
+                var saveTempVariables = tempVariables;
+                var saveTempParameters = tempParameters;
+                var saveComputedPropertyNamesToGeneratedNames = computedPropertyNamesToGeneratedNames;
+                var saveConvertedLoopState = convertedLoopState;
+                convertedLoopState = undefined;
+                tempFlags = 0;
+                tempVariables = undefined;
+                tempParameters = undefined;
+                computedPropertyNamesToGeneratedNames = undefined;
+                increaseIndent();
+                if (baseTypeNode) {
+                    writeLine();
+                    emitStart(baseTypeNode);
+                    write("__extends(");
+                    emitDeclarationName(node);
+                    write(", _super);");
+                    emitEnd(baseTypeNode);
+                }
+                writeLine();
+                emitConstructor(node, baseTypeNode);
+                emitMemberFunctionsForES5AndLower(node);
+                emitPropertyDeclarations(node, getInitializedProperties(node, /*isStatic*/ true));
+                writeLine();
+                emitDecoratorsOfClass(node, /*decoratedClassAlias*/ undefined);
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.members.end, function () {
+                    write("return ");
+                    emitDeclarationName(node);
+                });
+                write(";");
+                emitTempDeclarations(/*newLine*/ true);
+                ts.Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+                tempFlags = saveTempFlags;
+                tempVariables = saveTempVariables;
+                tempParameters = saveTempParameters;
+                computedPropertyNamesToGeneratedNames = saveComputedPropertyNamesToGeneratedNames;
+                decreaseIndent();
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.members.end);
+                emitStart(node);
+                write("(");
+                if (baseTypeNode) {
+                    emit(baseTypeNode.expression);
+                }
+                write("))");
+                if (node.kind === 221 /* ClassDeclaration */) {
+                    write(";");
+                }
+                emitEnd(node);
+                if (node.kind === 221 /* ClassDeclaration */ && !isES6ExportedClass) {
+                    emitExportMemberAssignment(node);
+                }
+                else if (isES6ExportedClass && (node.flags & 512 /* Default */)) {
+                    writeLine();
+                    write("export default ");
+                    emitDeclarationName(node);
+                    write(";");
+                }
+            }
+            function emitClassMemberPrefix(node, member) {
+                emitDeclarationName(node);
+                if (!(member.flags & 32 /* Static */)) {
+                    write(".prototype");
+                }
+            }
+            function emitDecoratorsOfClass(node, decoratedClassAlias) {
+                emitDecoratorsOfMembers(node, /*staticFlag*/ 0);
+                emitDecoratorsOfMembers(node, 32 /* Static */);
+                emitDecoratorsOfConstructor(node, decoratedClassAlias);
+            }
+            function emitDecoratorsOfConstructor(node, decoratedClassAlias) {
+                var decorators = node.decorators;
+                var constructor = ts.getFirstConstructorWithBody(node);
+                var firstParameterDecorator = constructor && ts.forEach(constructor.parameters, function (parameter) { return parameter.decorators; });
+                // skip decoration of the constructor if neither it nor its parameters are decorated
+                if (!decorators && !firstParameterDecorator) {
+                    return;
+                }
+                // Emit the call to __decorate. Given the class:
+                //
+                //   @dec
+                //   class C {
+                //   }
+                //
+                // The emit for the class is:
+                //
+                //   C = __decorate([dec], C);
+                //
+                writeLine();
+                emitStart(node.decorators || firstParameterDecorator);
+                emitDeclarationName(node);
+                if (decoratedClassAlias !== undefined) {
+                    write(" = " + decoratedClassAlias);
+                }
+                write(" = __decorate([");
+                increaseIndent();
+                writeLine();
+                var decoratorCount = decorators ? decorators.length : 0;
+                var argumentsWritten = emitList(decorators, 0, decoratorCount, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ false, /*noTrailingNewLine*/ true, function (decorator) { return emit(decorator.expression); });
+                if (firstParameterDecorator) {
+                    argumentsWritten += emitDecoratorsOfParameters(constructor, /*leadingComma*/ argumentsWritten > 0);
+                }
+                emitSerializedTypeMetadata(node, /*leadingComma*/ argumentsWritten >= 0);
+                decreaseIndent();
+                writeLine();
+                write("], ");
+                emitDeclarationName(node);
+                write(")");
+                emitEnd(node.decorators || firstParameterDecorator);
+                write(";");
+                writeLine();
+            }
+            function emitDecoratorsOfMembers(node, staticFlag) {
+                for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
+                    var member = _b[_a];
+                    // only emit members in the correct group
+                    if ((member.flags & 32 /* Static */) !== staticFlag) {
+                        continue;
+                    }
+                    // skip members that cannot be decorated (such as the constructor)
+                    if (!ts.nodeCanBeDecorated(member)) {
+                        continue;
+                    }
+                    // skip an accessor declaration if it is not the first accessor
+                    var decorators = void 0;
+                    var functionLikeMember = void 0;
+                    if (ts.isAccessor(member)) {
+                        var accessors = ts.getAllAccessorDeclarations(node.members, member);
+                        if (member !== accessors.firstAccessor) {
+                            continue;
+                        }
+                        // get the decorators from the first accessor with decorators
+                        decorators = accessors.firstAccessor.decorators;
+                        if (!decorators && accessors.secondAccessor) {
+                            decorators = accessors.secondAccessor.decorators;
+                        }
+                        // we only decorate parameters of the set accessor
+                        functionLikeMember = accessors.setAccessor;
+                    }
+                    else {
+                        decorators = member.decorators;
+                        // we only decorate the parameters here if this is a method
+                        if (member.kind === 147 /* MethodDeclaration */) {
+                            functionLikeMember = member;
+                        }
+                    }
+                    var firstParameterDecorator = functionLikeMember && ts.forEach(functionLikeMember.parameters, function (parameter) { return parameter.decorators; });
+                    // skip a member if it or any of its parameters are not decorated
+                    if (!decorators && !firstParameterDecorator) {
+                        continue;
+                    }
+                    // Emit the call to __decorate. Given the following:
+                    //
+                    //   class C {
+                    //     @dec method(@dec2 x) {}
+                    //     @dec get accessor() {}
+                    //     @dec prop;
+                    //   }
+                    //
+                    // The emit for a method is:
+                    //
+                    //   __decorate([
+                    //       dec,
+                    //       __param(0, dec2),
+                    //       __metadata("design:type", Function),
+                    //       __metadata("design:paramtypes", [Object]),
+                    //       __metadata("design:returntype", void 0)
+                    //   ], C.prototype, "method", undefined);
+                    //
+                    // The emit for an accessor is:
+                    //
+                    //   __decorate([
+                    //       dec
+                    //   ], C.prototype, "accessor", undefined);
+                    //
+                    // The emit for a property is:
+                    //
+                    //   __decorate([
+                    //       dec
+                    //   ], C.prototype, "prop");
+                    //
+                    writeLine();
+                    emitStart(decorators || firstParameterDecorator);
+                    write("__decorate([");
+                    increaseIndent();
+                    writeLine();
+                    var decoratorCount = decorators ? decorators.length : 0;
+                    var argumentsWritten = emitList(decorators, 0, decoratorCount, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ false, /*noTrailingNewLine*/ true, function (decorator) { return emit(decorator.expression); });
+                    if (firstParameterDecorator) {
+                        argumentsWritten += emitDecoratorsOfParameters(functionLikeMember, argumentsWritten > 0);
+                    }
+                    emitSerializedTypeMetadata(member, argumentsWritten > 0);
+                    decreaseIndent();
+                    writeLine();
+                    write("], ");
+                    emitClassMemberPrefix(node, member);
+                    write(", ");
+                    emitExpressionForPropertyName(member.name);
+                    if (languageVersion > 0 /* ES3 */) {
+                        if (member.kind !== 145 /* PropertyDeclaration */) {
+                            // We emit `null` here to indicate to `__decorate` that it can invoke `Object.getOwnPropertyDescriptor` directly.
+                            // We have this extra argument here so that we can inject an explicit property descriptor at a later date.
+                            write(", null");
+                        }
+                        else {
+                            // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it
+                            // should not invoke `Object.getOwnPropertyDescriptor`.
+                            write(", void 0");
+                        }
+                    }
+                    write(")");
+                    emitEnd(decorators || firstParameterDecorator);
+                    write(";");
+                    writeLine();
+                }
+            }
+            function emitDecoratorsOfParameters(node, leadingComma) {
+                var argumentsWritten = 0;
+                if (node) {
+                    var parameterIndex_1 = 0;
+                    for (var _a = 0, _b = node.parameters; _a < _b.length; _a++) {
+                        var parameter = _b[_a];
+                        if (ts.nodeIsDecorated(parameter)) {
+                            var decorators = parameter.decorators;
+                            argumentsWritten += emitList(decorators, 0, decorators.length, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ leadingComma, /*noTrailingNewLine*/ true, function (decorator) {
+                                write("__param(" + parameterIndex_1 + ", ");
+                                emit(decorator.expression);
+                                write(")");
+                            });
+                            leadingComma = true;
+                        }
+                        parameterIndex_1++;
+                    }
+                }
+                return argumentsWritten;
+            }
+            function shouldEmitTypeMetadata(node) {
+                // This method determines whether to emit the "design:type" metadata based on the node's kind.
+                // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata
+                // compiler option is set.
+                switch (node.kind) {
+                    case 147 /* MethodDeclaration */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 145 /* PropertyDeclaration */:
+                        return true;
+                }
+                return false;
+            }
+            function shouldEmitReturnTypeMetadata(node) {
+                // This method determines whether to emit the "design:returntype" metadata based on the node's kind.
+                // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata
+                // compiler option is set.
+                switch (node.kind) {
+                    case 147 /* MethodDeclaration */:
+                        return true;
+                }
+                return false;
+            }
+            function shouldEmitParamTypesMetadata(node) {
+                // This method determines whether to emit the "design:paramtypes" metadata based on the node's kind.
+                // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata
+                // compiler option is set.
+                switch (node.kind) {
+                    case 221 /* ClassDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 150 /* SetAccessor */:
+                        return true;
+                }
+                return false;
+            }
+            /** Serializes the type of a declaration to an appropriate JS constructor value. Used by the __metadata decorator for a class member. */
+            function emitSerializedTypeOfNode(node) {
+                // serialization of the type of a declaration uses the following rules:
+                //
+                // * The serialized type of a ClassDeclaration is "Function"
+                // * The serialized type of a ParameterDeclaration is the serialized type of its type annotation.
+                // * The serialized type of a PropertyDeclaration is the serialized type of its type annotation.
+                // * The serialized type of an AccessorDeclaration is the serialized type of the return type annotation of its getter or parameter type annotation of its setter.
+                // * The serialized type of any other FunctionLikeDeclaration is "Function".
+                // * The serialized type of any other node is "void 0".
+                //
+                // For rules on serializing type annotations, see `serializeTypeNode`.
+                switch (node.kind) {
+                    case 221 /* ClassDeclaration */:
+                        write("Function");
+                        return;
+                    case 145 /* PropertyDeclaration */:
+                        emitSerializedTypeNode(node.type);
+                        return;
+                    case 142 /* Parameter */:
+                        emitSerializedTypeNode(node.type);
+                        return;
+                    case 149 /* GetAccessor */:
+                        emitSerializedTypeNode(node.type);
+                        return;
+                    case 150 /* SetAccessor */:
+                        emitSerializedTypeNode(ts.getSetAccessorTypeAnnotationNode(node));
+                        return;
+                }
+                if (ts.isFunctionLike(node)) {
+                    write("Function");
+                    return;
+                }
+                write("void 0");
+            }
+            function emitSerializedTypeNode(node) {
+                if (node) {
+                    switch (node.kind) {
+                        case 103 /* VoidKeyword */:
+                            write("void 0");
+                            return;
+                        case 164 /* ParenthesizedType */:
+                            emitSerializedTypeNode(node.type);
+                            return;
+                        case 156 /* FunctionType */:
+                        case 157 /* ConstructorType */:
+                            write("Function");
+                            return;
+                        case 160 /* ArrayType */:
+                        case 161 /* TupleType */:
+                            write("Array");
+                            return;
+                        case 154 /* TypePredicate */:
+                        case 120 /* BooleanKeyword */:
+                            write("Boolean");
+                            return;
+                        case 132 /* StringKeyword */:
+                        case 166 /* StringLiteralType */:
+                            write("String");
+                            return;
+                        case 130 /* NumberKeyword */:
+                            write("Number");
+                            return;
+                        case 133 /* SymbolKeyword */:
+                            write("Symbol");
+                            return;
+                        case 155 /* TypeReference */:
+                            emitSerializedTypeReferenceNode(node);
+                            return;
+                        case 158 /* TypeQuery */:
+                        case 159 /* TypeLiteral */:
+                        case 162 /* UnionType */:
+                        case 163 /* IntersectionType */:
+                        case 117 /* AnyKeyword */:
+                        case 165 /* ThisType */:
+                            break;
+                        default:
+                            ts.Debug.fail("Cannot serialize unexpected type node.");
+                            break;
+                    }
+                }
+                write("Object");
+            }
+            /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */
+            function emitSerializedTypeReferenceNode(node) {
+                var location = node.parent;
+                while (ts.isDeclaration(location) || ts.isTypeNode(location)) {
+                    location = location.parent;
+                }
+                // Clone the type name and parent it to a location outside of the current declaration.
+                var typeName = ts.cloneEntityName(node.typeName, location);
+                var result = resolver.getTypeReferenceSerializationKind(typeName);
+                switch (result) {
+                    case ts.TypeReferenceSerializationKind.Unknown:
+                        var temp = createAndRecordTempVariable(0 /* Auto */);
+                        write("(typeof (");
+                        emitNodeWithoutSourceMap(temp);
+                        write(" = ");
+                        emitEntityNameAsExpression(typeName, /*useFallback*/ true);
+                        write(") === 'function' && ");
+                        emitNodeWithoutSourceMap(temp);
+                        write(") || Object");
+                        break;
+                    case ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue:
+                        emitEntityNameAsExpression(typeName, /*useFallback*/ false);
+                        break;
+                    case ts.TypeReferenceSerializationKind.VoidType:
+                        write("void 0");
+                        break;
+                    case ts.TypeReferenceSerializationKind.BooleanType:
+                        write("Boolean");
+                        break;
+                    case ts.TypeReferenceSerializationKind.NumberLikeType:
+                        write("Number");
+                        break;
+                    case ts.TypeReferenceSerializationKind.StringLikeType:
+                        write("String");
+                        break;
+                    case ts.TypeReferenceSerializationKind.ArrayLikeType:
+                        write("Array");
+                        break;
+                    case ts.TypeReferenceSerializationKind.ESSymbolType:
+                        if (languageVersion < 2 /* ES6 */) {
+                            write("typeof Symbol === 'function' ? Symbol : Object");
+                        }
+                        else {
+                            write("Symbol");
+                        }
+                        break;
+                    case ts.TypeReferenceSerializationKind.TypeWithCallSignature:
+                        write("Function");
+                        break;
+                    case ts.TypeReferenceSerializationKind.ObjectType:
+                        write("Object");
+                        break;
+                }
+            }
+            /** Serializes the parameter types of a function or the constructor of a class. Used by the __metadata decorator for a method or set accessor. */
+            function emitSerializedParameterTypesOfNode(node) {
+                // serialization of parameter types uses the following rules:
+                //
+                // * If the declaration is a class, the parameters of the first constructor with a body are used.
+                // * If the declaration is function-like and has a body, the parameters of the function are used.
+                //
+                // For the rules on serializing the type of each parameter declaration, see `serializeTypeOfDeclaration`.
+                if (node) {
+                    var valueDeclaration = void 0;
+                    if (node.kind === 221 /* ClassDeclaration */) {
+                        valueDeclaration = ts.getFirstConstructorWithBody(node);
+                    }
+                    else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) {
+                        valueDeclaration = node;
+                    }
+                    if (valueDeclaration) {
+                        var parameters = valueDeclaration.parameters;
+                        var parameterCount = parameters.length;
+                        if (parameterCount > 0) {
+                            for (var i = 0; i < parameterCount; i++) {
+                                if (i > 0) {
+                                    write(", ");
+                                }
+                                if (parameters[i].dotDotDotToken) {
+                                    var parameterType = parameters[i].type;
+                                    if (parameterType && parameterType.kind === 160 /* ArrayType */) {
+                                        parameterType = parameterType.elementType;
+                                    }
+                                    else if (parameterType && parameterType.kind === 155 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) {
+                                        parameterType = parameterType.typeArguments[0];
+                                    }
+                                    else {
+                                        parameterType = undefined;
+                                    }
+                                    emitSerializedTypeNode(parameterType);
+                                }
+                                else {
+                                    emitSerializedTypeOfNode(parameters[i]);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            /** Serializes the return type of function. Used by the __metadata decorator for a method. */
+            function emitSerializedReturnTypeOfNode(node) {
+                if (node && ts.isFunctionLike(node)) {
+                    if (node.type) {
+                        emitSerializedTypeNode(node.type);
+                        return;
+                    }
+                    else if (ts.isAsyncFunctionLike(node)) {
+                        write("Promise");
+                        return;
+                    }
+                }
+                write("void 0");
+            }
+            function emitSerializedTypeMetadata(node, writeComma) {
+                // This method emits the serialized type metadata for a decorator target.
+                // The caller should have already tested whether the node has decorators.
+                var argumentsWritten = 0;
+                if (compilerOptions.emitDecoratorMetadata) {
+                    if (shouldEmitTypeMetadata(node)) {
+                        if (writeComma) {
+                            write(", ");
+                        }
+                        writeLine();
+                        write("__metadata('design:type', ");
+                        emitSerializedTypeOfNode(node);
+                        write(")");
+                        argumentsWritten++;
+                    }
+                    if (shouldEmitParamTypesMetadata(node)) {
+                        if (writeComma || argumentsWritten) {
+                            write(", ");
+                        }
+                        writeLine();
+                        write("__metadata('design:paramtypes', [");
+                        emitSerializedParameterTypesOfNode(node);
+                        write("])");
+                        argumentsWritten++;
+                    }
+                    if (shouldEmitReturnTypeMetadata(node)) {
+                        if (writeComma || argumentsWritten) {
+                            write(", ");
+                        }
+                        writeLine();
+                        write("__metadata('design:returntype', ");
+                        emitSerializedReturnTypeOfNode(node);
+                        write(")");
+                        argumentsWritten++;
+                    }
+                }
+                return argumentsWritten;
+            }
+            function emitInterfaceDeclaration(node) {
+                emitCommentsOnNotEmittedNode(node);
+            }
+            function shouldEmitEnumDeclaration(node) {
+                var isConstEnum = ts.isConst(node);
+                return !isConstEnum || compilerOptions.preserveConstEnums || compilerOptions.isolatedModules;
+            }
+            function emitEnumDeclaration(node) {
+                // const enums are completely erased during compilation.
+                if (!shouldEmitEnumDeclaration(node)) {
+                    return;
+                }
+                if (!shouldHoistDeclarationInSystemJsModule(node)) {
+                    // do not emit var if variable was already hoisted
+                    var isES6ExportedEnum = isES6ExportedDeclaration(node);
+                    if (!(node.flags & 1 /* Export */) || (isES6ExportedEnum && isFirstDeclarationOfKind(node, node.symbol && node.symbol.declarations, 224 /* EnumDeclaration */))) {
+                        emitStart(node);
+                        if (isES6ExportedEnum) {
+                            write("export ");
+                        }
+                        write("var ");
+                        emit(node.name);
+                        emitEnd(node);
+                        write(";");
+                    }
+                }
+                writeLine();
+                emitStart(node);
+                write("(function (");
+                emitStart(node.name);
+                write(getGeneratedNameForNode(node));
+                emitEnd(node.name);
+                write(") {");
+                increaseIndent();
+                emitLines(node.members);
+                decreaseIndent();
+                writeLine();
+                emitToken(16 /* CloseBraceToken */, node.members.end);
+                write(")(");
+                emitModuleMemberName(node);
+                write(" || (");
+                emitModuleMemberName(node);
+                write(" = {}));");
+                emitEnd(node);
+                if (!isES6ExportedDeclaration(node) && node.flags & 1 /* Export */ && !shouldHoistDeclarationInSystemJsModule(node)) {
+                    // do not emit var if variable was already hoisted
+                    writeLine();
+                    emitStart(node);
+                    write("var ");
+                    emit(node.name);
+                    write(" = ");
+                    emitModuleMemberName(node);
+                    emitEnd(node);
+                    write(";");
+                }
+                if (modulekind !== ts.ModuleKind.ES6 && node.parent === currentSourceFile) {
+                    if (modulekind === ts.ModuleKind.System && (node.flags & 1 /* Export */)) {
+                        // write the call to exporter for enum
+                        writeLine();
+                        write(exportFunctionForFile + "(\"");
+                        emitDeclarationName(node);
+                        write("\", ");
+                        emitDeclarationName(node);
+                        write(");");
+                    }
+                    emitExportMemberAssignments(node.name);
+                }
+            }
+            function emitEnumMember(node) {
+                var enumParent = node.parent;
+                emitStart(node);
+                write(getGeneratedNameForNode(enumParent));
+                write("[");
+                write(getGeneratedNameForNode(enumParent));
+                write("[");
+                emitExpressionForPropertyName(node.name);
+                write("] = ");
+                writeEnumMemberDeclarationValue(node);
+                write("] = ");
+                emitExpressionForPropertyName(node.name);
+                emitEnd(node);
+                write(";");
+            }
+            function writeEnumMemberDeclarationValue(member) {
+                var value = resolver.getConstantValue(member);
+                if (value !== undefined) {
+                    write(value.toString());
+                    return;
+                }
+                else if (member.initializer) {
+                    emit(member.initializer);
+                }
+                else {
+                    write("undefined");
+                }
+            }
+            function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) {
+                if (moduleDeclaration.body && moduleDeclaration.body.kind === 225 /* ModuleDeclaration */) {
+                    var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body);
+                    return recursiveInnerModule || moduleDeclaration.body;
+                }
+            }
+            function shouldEmitModuleDeclaration(node) {
+                return ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.isolatedModules);
+            }
+            function isModuleMergedWithES6Class(node) {
+                return languageVersion === 2 /* ES6 */ && !!(resolver.getNodeCheckFlags(node) & 32768 /* LexicalModuleMergesWithClass */);
+            }
+            function isFirstDeclarationOfKind(node, declarations, kind) {
+                return !ts.forEach(declarations, function (declaration) { return declaration.kind === kind && declaration.pos < node.pos; });
+            }
+            function emitModuleDeclaration(node) {
+                // Emit only if this module is non-ambient.
+                var shouldEmit = shouldEmitModuleDeclaration(node);
+                if (!shouldEmit) {
+                    return emitCommentsOnNotEmittedNode(node);
+                }
+                var hoistedInDeclarationScope = shouldHoistDeclarationInSystemJsModule(node);
+                var emitVarForModule = !hoistedInDeclarationScope && !isModuleMergedWithES6Class(node);
+                if (emitVarForModule) {
+                    var isES6ExportedNamespace = isES6ExportedDeclaration(node);
+                    if (!isES6ExportedNamespace || isFirstDeclarationOfKind(node, node.symbol && node.symbol.declarations, 225 /* ModuleDeclaration */)) {
+                        emitStart(node);
+                        if (isES6ExportedNamespace) {
+                            write("export ");
+                        }
+                        write("var ");
+                        emit(node.name);
+                        write(";");
+                        emitEnd(node);
+                        writeLine();
+                    }
+                }
+                emitStart(node);
+                write("(function (");
+                emitStart(node.name);
+                write(getGeneratedNameForNode(node));
+                emitEnd(node.name);
+                write(") ");
+                ts.Debug.assert(node.body !== undefined); // node.body must exist, as this is a non-ambient module
+                if (node.body.kind === 226 /* ModuleBlock */) {
+                    var saveConvertedLoopState = convertedLoopState;
+                    var saveTempFlags = tempFlags;
+                    var saveTempVariables = tempVariables;
+                    convertedLoopState = undefined;
+                    tempFlags = 0;
+                    tempVariables = undefined;
+                    emit(node.body);
+                    ts.Debug.assert(convertedLoopState === undefined);
+                    convertedLoopState = saveConvertedLoopState;
+                    tempFlags = saveTempFlags;
+                    tempVariables = saveTempVariables;
+                }
+                else {
+                    write("{");
+                    increaseIndent();
+                    emitCaptureThisForNodeIfNecessary(node);
+                    writeLine();
+                    emit(node.body);
+                    decreaseIndent();
+                    writeLine();
+                    var moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body;
+                    emitToken(16 /* CloseBraceToken */, moduleBlock.statements.end);
+                }
+                write(")(");
+                // write moduleDecl = containingModule.m only if it is not exported es6 module member
+                if ((node.flags & 1 /* Export */) && !isES6ExportedDeclaration(node)) {
+                    emit(node.name);
+                    write(" = ");
+                }
+                emitModuleMemberName(node);
+                write(" || (");
+                emitModuleMemberName(node);
+                write(" = {}));");
+                emitEnd(node);
+                if (!isES6ExportedDeclaration(node) && node.name.kind === 69 /* Identifier */ && node.parent === currentSourceFile) {
+                    if (modulekind === ts.ModuleKind.System && (node.flags & 1 /* Export */)) {
+                        writeLine();
+                        write(exportFunctionForFile + "(\"");
+                        emitDeclarationName(node);
+                        write("\", ");
+                        emitDeclarationName(node);
+                        write(");");
+                    }
+                    emitExportMemberAssignments(node.name);
+                }
+            }
+            /*
+             * Some bundlers (SystemJS builder) sometimes want to rename dependencies.
+             * Here we check if alternative name was provided for a given moduleName and return it if possible.
+             */
+            function tryRenameExternalModule(moduleName) {
+                if (renamedDependencies && ts.hasProperty(renamedDependencies, moduleName.text)) {
+                    return "\"" + renamedDependencies[moduleName.text] + "\"";
+                }
+                return undefined;
+            }
+            function emitRequire(moduleName) {
+                if (moduleName.kind === 9 /* StringLiteral */) {
+                    write("require(");
+                    var text = tryRenameExternalModule(moduleName);
+                    if (text) {
+                        write(text);
+                    }
+                    else {
+                        emitStart(moduleName);
+                        emitLiteral(moduleName);
+                        emitEnd(moduleName);
+                    }
+                    emitToken(18 /* CloseParenToken */, moduleName.end);
+                }
+                else {
+                    write("require()");
+                }
+            }
+            function getNamespaceDeclarationNode(node) {
+                if (node.kind === 229 /* ImportEqualsDeclaration */) {
+                    return node;
+                }
+                var importClause = node.importClause;
+                if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 232 /* NamespaceImport */) {
+                    return importClause.namedBindings;
+                }
+            }
+            function isDefaultImport(node) {
+                return node.kind === 230 /* ImportDeclaration */ && node.importClause && !!node.importClause.name;
+            }
+            function emitExportImportAssignments(node) {
+                if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) {
+                    emitExportMemberAssignments(node.name);
+                }
+                ts.forEachChild(node, emitExportImportAssignments);
+            }
+            function emitImportDeclaration(node) {
+                if (modulekind !== ts.ModuleKind.ES6) {
+                    return emitExternalImportDeclaration(node);
+                }
+                // ES6 import
+                if (node.importClause) {
+                    var shouldEmitDefaultBindings = resolver.isReferencedAliasDeclaration(node.importClause);
+                    var shouldEmitNamedBindings = node.importClause.namedBindings && resolver.isReferencedAliasDeclaration(node.importClause.namedBindings, /* checkChildren */ true);
+                    if (shouldEmitDefaultBindings || shouldEmitNamedBindings) {
+                        write("import ");
+                        emitStart(node.importClause);
+                        if (shouldEmitDefaultBindings) {
+                            emit(node.importClause.name);
+                            if (shouldEmitNamedBindings) {
+                                write(", ");
+                            }
+                        }
+                        if (shouldEmitNamedBindings) {
+                            emitLeadingComments(node.importClause.namedBindings);
+                            emitStart(node.importClause.namedBindings);
+                            if (node.importClause.namedBindings.kind === 232 /* NamespaceImport */) {
+                                write("* as ");
+                                emit(node.importClause.namedBindings.name);
+                            }
+                            else {
+                                write("{ ");
+                                emitExportOrImportSpecifierList(node.importClause.namedBindings.elements, resolver.isReferencedAliasDeclaration);
+                                write(" }");
+                            }
+                            emitEnd(node.importClause.namedBindings);
+                            emitTrailingComments(node.importClause.namedBindings);
+                        }
+                        emitEnd(node.importClause);
+                        write(" from ");
+                        emit(node.moduleSpecifier);
+                        write(";");
+                    }
+                }
+                else {
+                    write("import ");
+                    emit(node.moduleSpecifier);
+                    write(";");
+                }
+            }
+            function emitExternalImportDeclaration(node) {
+                if (ts.contains(externalImports, node)) {
+                    var isExportedImport = node.kind === 229 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0;
+                    var namespaceDeclaration = getNamespaceDeclarationNode(node);
+                    var varOrConst = (languageVersion <= 1 /* ES5 */) ? "var " : "const ";
+                    if (modulekind !== ts.ModuleKind.AMD) {
+                        emitLeadingComments(node);
+                        emitStart(node);
+                        if (namespaceDeclaration && !isDefaultImport(node)) {
+                            // import x = require("foo")
+                            // import * as x from "foo"
+                            if (!isExportedImport) {
+                                write(varOrConst);
+                            }
+                            ;
+                            emitModuleMemberName(namespaceDeclaration);
+                            write(" = ");
+                        }
+                        else {
+                            // import "foo"
+                            // import x from "foo"
+                            // import { x, y } from "foo"
+                            // import d, * as x from "foo"
+                            // import d, { x, y } from "foo"
+                            var isNakedImport = 230 /* ImportDeclaration */ && !node.importClause;
+                            if (!isNakedImport) {
+                                write(varOrConst);
+                                write(getGeneratedNameForNode(node));
+                                write(" = ");
+                            }
+                        }
+                        emitRequire(ts.getExternalModuleName(node));
+                        if (namespaceDeclaration && isDefaultImport(node)) {
+                            // import d, * as x from "foo"
+                            write(", ");
+                            emitModuleMemberName(namespaceDeclaration);
+                            write(" = ");
+                            write(getGeneratedNameForNode(node));
+                        }
+                        write(";");
+                        emitEnd(node);
+                        emitExportImportAssignments(node);
+                        emitTrailingComments(node);
+                    }
+                    else {
+                        if (isExportedImport) {
+                            emitModuleMemberName(namespaceDeclaration);
+                            write(" = ");
+                            emit(namespaceDeclaration.name);
+                            write(";");
+                        }
+                        else if (namespaceDeclaration && isDefaultImport(node)) {
+                            // import d, * as x from "foo"
+                            write(varOrConst);
+                            emitModuleMemberName(namespaceDeclaration);
+                            write(" = ");
+                            write(getGeneratedNameForNode(node));
+                            write(";");
+                        }
+                        emitExportImportAssignments(node);
+                    }
+                }
+            }
+            function emitImportEqualsDeclaration(node) {
+                if (ts.isExternalModuleImportEqualsDeclaration(node)) {
+                    emitExternalImportDeclaration(node);
+                    return;
+                }
+                // preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when
+                // - current file is not external module
+                // - import declaration is top level and target is value imported by entity name
+                if (resolver.isReferencedAliasDeclaration(node) ||
+                    (!isCurrentFileExternalModule && resolver.isTopLevelValueImportEqualsWithEntityName(node))) {
+                    emitLeadingComments(node);
+                    emitStart(node);
+                    // variable declaration for import-equals declaration can be hoisted in system modules
+                    // in this case 'var' should be omitted and emit should contain only initialization
+                    var variableDeclarationIsHoisted = shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ true);
+                    // is it top level export import v = a.b.c in system module?
+                    // if yes - it needs to be rewritten as exporter('v', v = a.b.c)
+                    var isExported = isSourceFileLevelDeclarationInSystemJsModule(node, /*isExported*/ true);
+                    if (!variableDeclarationIsHoisted) {
+                        ts.Debug.assert(!isExported);
+                        if (isES6ExportedDeclaration(node)) {
+                            write("export ");
+                            write("var ");
+                        }
+                        else if (!(node.flags & 1 /* Export */)) {
+                            write("var ");
+                        }
+                    }
+                    if (isExported) {
+                        write(exportFunctionForFile + "(\"");
+                        emitNodeWithoutSourceMap(node.name);
+                        write("\", ");
+                    }
+                    emitModuleMemberName(node);
+                    write(" = ");
+                    emit(node.moduleReference);
+                    if (isExported) {
+                        write(")");
+                    }
+                    write(";");
+                    emitEnd(node);
+                    emitExportImportAssignments(node);
+                    emitTrailingComments(node);
+                }
+            }
+            function emitExportDeclaration(node) {
+                ts.Debug.assert(modulekind !== ts.ModuleKind.System);
+                if (modulekind !== ts.ModuleKind.ES6) {
+                    if (node.moduleSpecifier && (!node.exportClause || resolver.isValueAliasDeclaration(node))) {
+                        emitStart(node);
+                        var generatedName = getGeneratedNameForNode(node);
+                        if (node.exportClause) {
+                            // export { x, y, ... } from "foo"
+                            if (modulekind !== ts.ModuleKind.AMD) {
+                                write("var ");
+                                write(generatedName);
+                                write(" = ");
+                                emitRequire(ts.getExternalModuleName(node));
+                                write(";");
+                            }
+                            for (var _a = 0, _b = node.exportClause.elements; _a < _b.length; _a++) {
+                                var specifier = _b[_a];
+                                if (resolver.isValueAliasDeclaration(specifier)) {
+                                    writeLine();
+                                    emitStart(specifier);
+                                    emitContainingModuleName(specifier);
+                                    write(".");
+                                    emitNodeWithCommentsAndWithoutSourcemap(specifier.name);
+                                    write(" = ");
+                                    write(generatedName);
+                                    write(".");
+                                    emitNodeWithCommentsAndWithoutSourcemap(specifier.propertyName || specifier.name);
+                                    write(";");
+                                    emitEnd(specifier);
+                                }
+                            }
+                        }
+                        else {
+                            // export * from "foo"
+                            if (hasExportStarsToExportValues && resolver.moduleExportsSomeValue(node.moduleSpecifier)) {
+                                writeLine();
+                                write("__export(");
+                                if (modulekind !== ts.ModuleKind.AMD) {
+                                    emitRequire(ts.getExternalModuleName(node));
+                                }
+                                else {
+                                    write(generatedName);
+                                }
+                                write(");");
+                            }
+                        }
+                        emitEnd(node);
+                    }
+                }
+                else {
+                    if (!node.exportClause || resolver.isValueAliasDeclaration(node)) {
+                        write("export ");
+                        if (node.exportClause) {
+                            // export { x, y, ... }
+                            write("{ ");
+                            emitExportOrImportSpecifierList(node.exportClause.elements, resolver.isValueAliasDeclaration);
+                            write(" }");
+                        }
+                        else {
+                            write("*");
+                        }
+                        if (node.moduleSpecifier) {
+                            write(" from ");
+                            emit(node.moduleSpecifier);
+                        }
+                        write(";");
+                    }
+                }
+            }
+            function emitExportOrImportSpecifierList(specifiers, shouldEmit) {
+                ts.Debug.assert(modulekind === ts.ModuleKind.ES6);
+                var needsComma = false;
+                for (var _a = 0, specifiers_1 = specifiers; _a < specifiers_1.length; _a++) {
+                    var specifier = specifiers_1[_a];
+                    if (shouldEmit(specifier)) {
+                        if (needsComma) {
+                            write(", ");
+                        }
+                        if (specifier.propertyName) {
+                            emit(specifier.propertyName);
+                            write(" as ");
+                        }
+                        emit(specifier.name);
+                        needsComma = true;
+                    }
+                }
+            }
+            function emitExportAssignment(node) {
+                if (!node.isExportEquals && resolver.isValueAliasDeclaration(node)) {
+                    if (modulekind === ts.ModuleKind.ES6) {
+                        writeLine();
+                        emitStart(node);
+                        write("export default ");
+                        var expression = node.expression;
+                        emit(expression);
+                        if (expression.kind !== 220 /* FunctionDeclaration */ &&
+                            expression.kind !== 221 /* ClassDeclaration */) {
+                            write(";");
+                        }
+                        emitEnd(node);
+                    }
+                    else {
+                        writeLine();
+                        emitStart(node);
+                        if (modulekind === ts.ModuleKind.System) {
+                            write(exportFunctionForFile + "(\"default\",");
+                            emit(node.expression);
+                            write(")");
+                        }
+                        else {
+                            emitEs6ExportDefaultCompat(node);
+                            emitContainingModuleName(node);
+                            if (languageVersion === 0 /* ES3 */) {
+                                write('["default"] = ');
+                            }
+                            else {
+                                write(".default = ");
+                            }
+                            emit(node.expression);
+                        }
+                        write(";");
+                        emitEnd(node);
+                    }
+                }
+            }
+            function collectExternalModuleInfo(sourceFile) {
+                externalImports = [];
+                exportSpecifiers = {};
+                exportEquals = undefined;
+                hasExportStarsToExportValues = false;
+                for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) {
+                    var node = _b[_a];
+                    switch (node.kind) {
+                        case 230 /* ImportDeclaration */:
+                            if (!node.importClause ||
+                                resolver.isReferencedAliasDeclaration(node.importClause, /*checkChildren*/ true)) {
+                                // import "mod"
+                                // import x from "mod" where x is referenced
+                                // import * as x from "mod" where x is referenced
+                                // import { x, y } from "mod" where at least one import is referenced
+                                externalImports.push(node);
+                            }
+                            break;
+                        case 229 /* ImportEqualsDeclaration */:
+                            if (node.moduleReference.kind === 240 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) {
+                                // import x = require("mod") where x is referenced
+                                externalImports.push(node);
+                            }
+                            break;
+                        case 236 /* ExportDeclaration */:
+                            if (node.moduleSpecifier) {
+                                if (!node.exportClause) {
+                                    // export * from "mod"
+                                    if (resolver.moduleExportsSomeValue(node.moduleSpecifier)) {
+                                        externalImports.push(node);
+                                        hasExportStarsToExportValues = true;
+                                    }
+                                }
+                                else if (resolver.isValueAliasDeclaration(node)) {
+                                    // export { x, y } from "mod" where at least one export is a value symbol
+                                    externalImports.push(node);
+                                }
+                            }
+                            else {
+                                // export { x, y }
+                                for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) {
+                                    var specifier = _d[_c];
+                                    var name_30 = (specifier.propertyName || specifier.name).text;
+                                    (exportSpecifiers[name_30] || (exportSpecifiers[name_30] = [])).push(specifier);
+                                }
+                            }
+                            break;
+                        case 235 /* ExportAssignment */:
+                            if (node.isExportEquals && !exportEquals) {
+                                // export = x
+                                exportEquals = node;
+                            }
+                            break;
+                    }
+                }
+            }
+            function emitExportStarHelper() {
+                if (hasExportStarsToExportValues) {
+                    writeLine();
+                    write("function __export(m) {");
+                    increaseIndent();
+                    writeLine();
+                    write("for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];");
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+            }
+            function getLocalNameForExternalImport(node) {
+                var namespaceDeclaration = getNamespaceDeclarationNode(node);
+                if (namespaceDeclaration && !isDefaultImport(node)) {
+                    return ts.getTextOfNodeFromSourceText(currentText, namespaceDeclaration.name);
+                }
+                if (node.kind === 230 /* ImportDeclaration */ && node.importClause) {
+                    return getGeneratedNameForNode(node);
+                }
+                if (node.kind === 236 /* ExportDeclaration */ && node.moduleSpecifier) {
+                    return getGeneratedNameForNode(node);
+                }
+            }
+            function getExternalModuleNameText(importNode, emitRelativePathAsModuleName) {
+                if (emitRelativePathAsModuleName) {
+                    var name_31 = getExternalModuleNameFromDeclaration(host, resolver, importNode);
+                    if (name_31) {
+                        return "\"" + name_31 + "\"";
+                    }
+                }
+                var moduleName = ts.getExternalModuleName(importNode);
+                if (moduleName.kind === 9 /* StringLiteral */) {
+                    return tryRenameExternalModule(moduleName) || getLiteralText(moduleName);
+                }
+                return undefined;
+            }
+            function emitVariableDeclarationsForImports() {
+                if (externalImports.length === 0) {
+                    return;
+                }
+                writeLine();
+                var started = false;
+                for (var _a = 0, externalImports_1 = externalImports; _a < externalImports_1.length; _a++) {
+                    var importNode = externalImports_1[_a];
+                    // do not create variable declaration for exports and imports that lack import clause
+                    var skipNode = importNode.kind === 236 /* ExportDeclaration */ ||
+                        (importNode.kind === 230 /* ImportDeclaration */ && !importNode.importClause);
+                    if (skipNode) {
+                        continue;
+                    }
+                    if (!started) {
+                        write("var ");
+                        started = true;
+                    }
+                    else {
+                        write(", ");
+                    }
+                    write(getLocalNameForExternalImport(importNode));
+                }
+                if (started) {
+                    write(";");
+                }
+            }
+            function emitLocalStorageForExportedNamesIfNecessary(exportedDeclarations) {
+                // when resolving exports local exported entries/indirect exported entries in the module
+                // should always win over entries with similar names that were added via star exports
+                // to support this we store names of local/indirect exported entries in a set.
+                // this set is used to filter names brought by star exports.
+                if (!hasExportStarsToExportValues) {
+                    // local names set is needed only in presence of star exports
+                    return undefined;
+                }
+                // local names set should only be added if we have anything exported
+                if (!exportedDeclarations && ts.isEmpty(exportSpecifiers)) {
+                    // no exported declarations (export var ...) or export specifiers (export {x})
+                    // check if we have any non star export declarations.
+                    var hasExportDeclarationWithExportClause = false;
+                    for (var _a = 0, externalImports_2 = externalImports; _a < externalImports_2.length; _a++) {
+                        var externalImport = externalImports_2[_a];
+                        if (externalImport.kind === 236 /* ExportDeclaration */ && externalImport.exportClause) {
+                            hasExportDeclarationWithExportClause = true;
+                            break;
+                        }
+                    }
+                    if (!hasExportDeclarationWithExportClause) {
+                        // we still need to emit exportStar helper
+                        return emitExportStarFunction(/*localNames*/ undefined);
+                    }
+                }
+                var exportedNamesStorageRef = makeUniqueName("exportedNames");
+                writeLine();
+                write("var " + exportedNamesStorageRef + " = {");
+                increaseIndent();
+                var started = false;
+                if (exportedDeclarations) {
+                    for (var i = 0; i < exportedDeclarations.length; i++) {
+                        // write name of exported declaration, i.e 'export var x...'
+                        writeExportedName(exportedDeclarations[i]);
+                    }
+                }
+                if (exportSpecifiers) {
+                    for (var n in exportSpecifiers) {
+                        for (var _b = 0, _c = exportSpecifiers[n]; _b < _c.length; _b++) {
+                            var specifier = _c[_b];
+                            // write name of export specified, i.e. 'export {x}'
+                            writeExportedName(specifier.name);
+                        }
+                    }
+                }
+                for (var _d = 0, externalImports_3 = externalImports; _d < externalImports_3.length; _d++) {
+                    var externalImport = externalImports_3[_d];
+                    if (externalImport.kind !== 236 /* ExportDeclaration */) {
+                        continue;
+                    }
+                    var exportDecl = externalImport;
+                    if (!exportDecl.exportClause) {
+                        // export * from ...
+                        continue;
+                    }
+                    for (var _e = 0, _f = exportDecl.exportClause.elements; _e < _f.length; _e++) {
+                        var element = _f[_e];
+                        // write name of indirectly exported entry, i.e. 'export {x} from ...'
+                        writeExportedName(element.name || element.propertyName);
+                    }
+                }
+                decreaseIndent();
+                writeLine();
+                write("};");
+                return emitExportStarFunction(exportedNamesStorageRef);
+                function emitExportStarFunction(localNames) {
+                    var exportStarFunction = makeUniqueName("exportStar");
+                    writeLine();
+                    // define an export star helper function
+                    write("function " + exportStarFunction + "(m) {");
+                    increaseIndent();
+                    writeLine();
+                    write("var exports = {};");
+                    writeLine();
+                    write("for(var n in m) {");
+                    increaseIndent();
+                    writeLine();
+                    write("if (n !== \"default\"");
+                    if (localNames) {
+                        write("&& !" + localNames + ".hasOwnProperty(n)");
+                    }
+                    write(") exports[n] = m[n];");
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                    writeLine();
+                    write(exportFunctionForFile + "(exports);");
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                    return exportStarFunction;
+                }
+                function writeExportedName(node) {
+                    // do not record default exports
+                    // they are local to module and never overwritten (explicitly skipped) by star export
+                    if (node.kind !== 69 /* Identifier */ && node.flags & 512 /* Default */) {
+                        return;
+                    }
+                    if (started) {
+                        write(",");
+                    }
+                    else {
+                        started = true;
+                    }
+                    writeLine();
+                    write("'");
+                    if (node.kind === 69 /* Identifier */) {
+                        emitNodeWithCommentsAndWithoutSourcemap(node);
+                    }
+                    else {
+                        emitDeclarationName(node);
+                    }
+                    write("': true");
+                }
+            }
+            function processTopLevelVariableAndFunctionDeclarations(node) {
+                // per ES6 spec:
+                // 15.2.1.16.4 ModuleDeclarationInstantiation() Concrete Method
+                // - var declarations are initialized to undefined - 14.a.ii
+                // - function/generator declarations are instantiated - 16.a.iv
+                // this means that after module is instantiated but before its evaluation
+                // exported functions are already accessible at import sites
+                // in theory we should hoist only exported functions and its dependencies
+                // in practice to simplify things we'll hoist all source level functions and variable declaration
+                // including variables declarations for module and class declarations
+                var hoistedVars;
+                var hoistedFunctionDeclarations;
+                var exportedDeclarations;
+                visit(node);
+                if (hoistedVars) {
+                    writeLine();
+                    write("var ");
+                    var seen = {};
+                    for (var i = 0; i < hoistedVars.length; i++) {
+                        var local = hoistedVars[i];
+                        var name_32 = local.kind === 69 /* Identifier */
+                            ? local
+                            : local.name;
+                        if (name_32) {
+                            // do not emit duplicate entries (in case of declaration merging) in the list of hoisted variables
+                            var text = ts.unescapeIdentifier(name_32.text);
+                            if (ts.hasProperty(seen, text)) {
+                                continue;
+                            }
+                            else {
+                                seen[text] = text;
+                            }
+                        }
+                        if (i !== 0) {
+                            write(", ");
+                        }
+                        if (local.kind === 221 /* ClassDeclaration */ || local.kind === 225 /* ModuleDeclaration */ || local.kind === 224 /* EnumDeclaration */) {
+                            emitDeclarationName(local);
+                        }
+                        else {
+                            emit(local);
+                        }
+                        var flags = ts.getCombinedNodeFlags(local.kind === 69 /* Identifier */ ? local.parent : local);
+                        if (flags & 1 /* Export */) {
+                            if (!exportedDeclarations) {
+                                exportedDeclarations = [];
+                            }
+                            exportedDeclarations.push(local);
+                        }
+                    }
+                    write(";");
+                }
+                if (hoistedFunctionDeclarations) {
+                    for (var _a = 0, hoistedFunctionDeclarations_1 = hoistedFunctionDeclarations; _a < hoistedFunctionDeclarations_1.length; _a++) {
+                        var f = hoistedFunctionDeclarations_1[_a];
+                        writeLine();
+                        emit(f);
+                        if (f.flags & 1 /* Export */) {
+                            if (!exportedDeclarations) {
+                                exportedDeclarations = [];
+                            }
+                            exportedDeclarations.push(f);
+                        }
+                    }
+                }
+                return exportedDeclarations;
+                function visit(node) {
+                    if (node.flags & 2 /* Ambient */) {
+                        return;
+                    }
+                    if (node.kind === 220 /* FunctionDeclaration */) {
+                        if (!hoistedFunctionDeclarations) {
+                            hoistedFunctionDeclarations = [];
+                        }
+                        hoistedFunctionDeclarations.push(node);
+                        return;
+                    }
+                    if (node.kind === 221 /* ClassDeclaration */) {
+                        if (!hoistedVars) {
+                            hoistedVars = [];
+                        }
+                        hoistedVars.push(node);
+                        return;
+                    }
+                    if (node.kind === 224 /* EnumDeclaration */) {
+                        if (shouldEmitEnumDeclaration(node)) {
+                            if (!hoistedVars) {
+                                hoistedVars = [];
+                            }
+                            hoistedVars.push(node);
+                        }
+                        return;
+                    }
+                    if (node.kind === 225 /* ModuleDeclaration */) {
+                        if (shouldEmitModuleDeclaration(node)) {
+                            if (!hoistedVars) {
+                                hoistedVars = [];
+                            }
+                            hoistedVars.push(node);
+                        }
+                        return;
+                    }
+                    if (node.kind === 218 /* VariableDeclaration */ || node.kind === 169 /* BindingElement */) {
+                        if (shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ false)) {
+                            var name_33 = node.name;
+                            if (name_33.kind === 69 /* Identifier */) {
+                                if (!hoistedVars) {
+                                    hoistedVars = [];
+                                }
+                                hoistedVars.push(name_33);
+                            }
+                            else {
+                                ts.forEachChild(name_33, visit);
+                            }
+                        }
+                        return;
+                    }
+                    if (ts.isInternalModuleImportEqualsDeclaration(node) && resolver.isValueAliasDeclaration(node)) {
+                        if (!hoistedVars) {
+                            hoistedVars = [];
+                        }
+                        hoistedVars.push(node.name);
+                        return;
+                    }
+                    if (ts.isBindingPattern(node)) {
+                        ts.forEach(node.elements, visit);
+                        return;
+                    }
+                    if (!ts.isDeclaration(node)) {
+                        ts.forEachChild(node, visit);
+                    }
+                }
+            }
+            function shouldHoistVariable(node, checkIfSourceFileLevelDecl) {
+                if (checkIfSourceFileLevelDecl && !shouldHoistDeclarationInSystemJsModule(node)) {
+                    return false;
+                }
+                // hoist variable if
+                // - it is not block scoped
+                // - it is top level block scoped
+                // if block scoped variables are nested in some another block then
+                // no other functions can use them except ones that are defined at least in the same block
+                return (ts.getCombinedNodeFlags(node) & 3072 /* BlockScoped */) === 0 ||
+                    ts.getEnclosingBlockScopeContainer(node).kind === 256 /* SourceFile */;
+            }
+            function isCurrentFileSystemExternalModule() {
+                return modulekind === ts.ModuleKind.System && isCurrentFileExternalModule;
+            }
+            function emitSystemModuleBody(node, dependencyGroups, startIndex) {
+                // shape of the body in system modules:
+                // function (exports) {
+                //     <list of local aliases for imports>
+                //     <hoisted function declarations>
+                //     <hoisted variable declarations>
+                //     return {
+                //         setters: [
+                //             <list of setter function for imports>
+                //         ],
+                //         execute: function() {
+                //             <module statements>
+                //         }
+                //     }
+                //     <temp declarations>
+                // }
+                // I.e:
+                // import {x} from 'file1'
+                // var y = 1;
+                // export function foo() { return y + x(); }
+                // console.log(y);
+                // will be transformed to
+                // function(exports) {
+                //     var file1; // local alias
+                //     var y;
+                //     function foo() { return y + file1.x(); }
+                //     exports("foo", foo);
+                //     return {
+                //         setters: [
+                //             function(v) { file1 = v }
+                //         ],
+                //         execute(): function() {
+                //             y = 1;
+                //             console.log(y);
+                //         }
+                //     };
+                // }
+                emitVariableDeclarationsForImports();
+                writeLine();
+                var exportedDeclarations = processTopLevelVariableAndFunctionDeclarations(node);
+                var exportStarFunction = emitLocalStorageForExportedNamesIfNecessary(exportedDeclarations);
+                writeLine();
+                write("return {");
+                increaseIndent();
+                writeLine();
+                emitSetters(exportStarFunction, dependencyGroups);
+                writeLine();
+                emitExecute(node, startIndex);
+                decreaseIndent();
+                writeLine();
+                write("}"); // return
+                emitTempDeclarations(/*newLine*/ true);
+            }
+            function emitSetters(exportStarFunction, dependencyGroups) {
+                write("setters:[");
+                for (var i = 0; i < dependencyGroups.length; i++) {
+                    if (i !== 0) {
+                        write(",");
+                    }
+                    writeLine();
+                    increaseIndent();
+                    var group = dependencyGroups[i];
+                    // derive a unique name for parameter from the first named entry in the group
+                    var parameterName = makeUniqueName(ts.forEach(group, getLocalNameForExternalImport) || "");
+                    write("function (" + parameterName + ") {");
+                    increaseIndent();
+                    for (var _a = 0, group_1 = group; _a < group_1.length; _a++) {
+                        var entry = group_1[_a];
+                        var importVariableName = getLocalNameForExternalImport(entry) || "";
+                        switch (entry.kind) {
+                            case 230 /* ImportDeclaration */:
+                                if (!entry.importClause) {
+                                    // 'import "..."' case
+                                    // module is imported only for side-effects, no emit required
+                                    break;
+                                }
+                            // fall-through
+                            case 229 /* ImportEqualsDeclaration */:
+                                ts.Debug.assert(importVariableName !== "");
+                                writeLine();
+                                // save import into the local
+                                write(importVariableName + " = " + parameterName + ";");
+                                writeLine();
+                                break;
+                            case 236 /* ExportDeclaration */:
+                                ts.Debug.assert(importVariableName !== "");
+                                if (entry.exportClause) {
+                                    // export {a, b as c} from 'foo'
+                                    // emit as:
+                                    // exports_({
+                                    //    "a": _["a"],
+                                    //    "c": _["b"]
+                                    // });
+                                    writeLine();
+                                    write(exportFunctionForFile + "({");
+                                    writeLine();
+                                    increaseIndent();
+                                    for (var i_1 = 0, len = entry.exportClause.elements.length; i_1 < len; i_1++) {
+                                        if (i_1 !== 0) {
+                                            write(",");
+                                            writeLine();
+                                        }
+                                        var e = entry.exportClause.elements[i_1];
+                                        write("\"");
+                                        emitNodeWithCommentsAndWithoutSourcemap(e.name);
+                                        write("\": " + parameterName + "[\"");
+                                        emitNodeWithCommentsAndWithoutSourcemap(e.propertyName || e.name);
+                                        write("\"]");
+                                    }
+                                    decreaseIndent();
+                                    writeLine();
+                                    write("});");
+                                }
+                                else {
+                                    // collectExternalModuleInfo prefilters star exports to keep only ones that export values
+                                    // this means that check 'resolver.moduleExportsSomeValue' is redundant and can be omitted here
+                                    writeLine();
+                                    // export * from 'foo'
+                                    // emit as:
+                                    // exportStar(_foo);
+                                    write(exportStarFunction + "(" + parameterName + ");");
+                                }
+                                writeLine();
+                                break;
+                        }
+                    }
+                    decreaseIndent();
+                    write("}");
+                    decreaseIndent();
+                }
+                write("],");
+            }
+            function emitExecute(node, startIndex) {
+                write("execute: function() {");
+                increaseIndent();
+                writeLine();
+                for (var i = startIndex; i < node.statements.length; i++) {
+                    var statement = node.statements[i];
+                    switch (statement.kind) {
+                        // - function declarations are not emitted because they were already hoisted
+                        // - import declarations are not emitted since they are already handled in setters
+                        // - export declarations with module specifiers are not emitted since they were already written in setters
+                        // - export declarations without module specifiers are emitted preserving the order
+                        case 220 /* FunctionDeclaration */:
+                        case 230 /* ImportDeclaration */:
+                            continue;
+                        case 236 /* ExportDeclaration */:
+                            if (!statement.moduleSpecifier) {
+                                for (var _a = 0, _b = statement.exportClause.elements; _a < _b.length; _a++) {
+                                    var element = _b[_a];
+                                    // write call to exporter function for every export specifier in exports list
+                                    emitExportSpecifierInSystemModule(element);
+                                }
+                            }
+                            continue;
+                        case 229 /* ImportEqualsDeclaration */:
+                            if (!ts.isInternalModuleImportEqualsDeclaration(statement)) {
+                                // - import equals declarations that import external modules are not emitted
+                                continue;
+                            }
+                        // fall-though for import declarations that import internal modules
+                        default:
+                            writeLine();
+                            emit(statement);
+                    }
+                }
+                decreaseIndent();
+                writeLine();
+                write("}"); // execute
+            }
+            function writeModuleName(node, emitRelativePathAsModuleName) {
+                var moduleName = node.moduleName;
+                if (moduleName || (emitRelativePathAsModuleName && (moduleName = getResolvedExternalModuleName(host, node)))) {
+                    write("\"" + moduleName + "\", ");
+                }
+            }
+            function emitSystemModule(node, emitRelativePathAsModuleName) {
+                collectExternalModuleInfo(node);
+                // System modules has the following shape
+                // System.register(['dep-1', ... 'dep-n'], function(exports) {/* module body function */})
+                // 'exports' here is a function 'exports<T>(name: string, value: T): T' that is used to publish exported values.
+                // 'exports' returns its 'value' argument so in most cases expressions
+                // that mutate exported values can be rewritten as:
+                // expr -> exports('name', expr).
+                // The only exception in this rule is postfix unary operators,
+                // see comment to 'emitPostfixUnaryExpression' for more details
+                ts.Debug.assert(!exportFunctionForFile);
+                // make sure that  name of 'exports' function does not conflict with existing identifiers
+                exportFunctionForFile = makeUniqueName("exports");
+                contextObjectForFile = makeUniqueName("context");
+                writeLine();
+                write("System.register(");
+                writeModuleName(node, emitRelativePathAsModuleName);
+                write("[");
+                var groupIndices = {};
+                var dependencyGroups = [];
+                for (var i = 0; i < externalImports.length; i++) {
+                    var text = getExternalModuleNameText(externalImports[i], emitRelativePathAsModuleName);
+                    if (text === undefined) {
+                        continue;
+                    }
+                    // text should be quoted string
+                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same
+                    var key = text.substr(1, text.length - 2);
+                    if (ts.hasProperty(groupIndices, key)) {
+                        // deduplicate/group entries in dependency list by the dependency name
+                        var groupIndex = groupIndices[key];
+                        dependencyGroups[groupIndex].push(externalImports[i]);
+                        continue;
+                    }
+                    else {
+                        groupIndices[key] = dependencyGroups.length;
+                        dependencyGroups.push([externalImports[i]]);
+                    }
+                    if (i !== 0) {
+                        write(", ");
+                    }
+                    write(text);
+                }
+                write("], function(" + exportFunctionForFile + ", " + contextObjectForFile + ") {");
+                writeLine();
+                increaseIndent();
+                var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict);
+                writeLine();
+                write("var __moduleName = " + contextObjectForFile + " && " + contextObjectForFile + ".id;");
+                writeLine();
+                emitEmitHelpers(node);
+                emitCaptureThisForNodeIfNecessary(node);
+                emitSystemModuleBody(node, dependencyGroups, startIndex);
+                decreaseIndent();
+                writeLine();
+                write("});");
+            }
+            function getAMDDependencyNames(node, includeNonAmdDependencies, emitRelativePathAsModuleName) {
+                // names of modules with corresponding parameter in the factory function
+                var aliasedModuleNames = [];
+                // names of modules with no corresponding parameters in factory function
+                var unaliasedModuleNames = [];
+                var importAliasNames = []; // names of the parameters in the factory function; these
+                // parameters need to match the indexes of the corresponding
+                // module names in aliasedModuleNames.
+                // Fill in amd-dependency tags
+                for (var _a = 0, _b = node.amdDependencies; _a < _b.length; _a++) {
+                    var amdDependency = _b[_a];
+                    if (amdDependency.name) {
+                        aliasedModuleNames.push('"' + amdDependency.path + '"');
+                        importAliasNames.push(amdDependency.name);
+                    }
+                    else {
+                        unaliasedModuleNames.push('"' + amdDependency.path + '"');
+                    }
+                }
+                for (var _c = 0, externalImports_4 = externalImports; _c < externalImports_4.length; _c++) {
+                    var importNode = externalImports_4[_c];
+                    // Find the name of the external module
+                    var externalModuleName = getExternalModuleNameText(importNode, emitRelativePathAsModuleName);
+                    // Find the name of the module alias, if there is one
+                    var importAliasName = getLocalNameForExternalImport(importNode);
+                    if (includeNonAmdDependencies && importAliasName) {
+                        aliasedModuleNames.push(externalModuleName);
+                        importAliasNames.push(importAliasName);
+                    }
+                    else {
+                        unaliasedModuleNames.push(externalModuleName);
+                    }
+                }
+                return { aliasedModuleNames: aliasedModuleNames, unaliasedModuleNames: unaliasedModuleNames, importAliasNames: importAliasNames };
+            }
+            function emitAMDDependencies(node, includeNonAmdDependencies, emitRelativePathAsModuleName) {
+                // An AMD define function has the following shape:
+                //     define(id?, dependencies?, factory);
+                //
+                // This has the shape of
+                //     define(name, ["module1", "module2"], function (module1Alias) {
+                // The location of the alias in the parameter list in the factory function needs to
+                // match the position of the module name in the dependency list.
+                //
+                // To ensure this is true in cases of modules with no aliases, e.g.:
+                // `import "module"` or `<amd-dependency path= "a.css" />`
+                // we need to add modules without alias names to the end of the dependencies list
+                var dependencyNames = getAMDDependencyNames(node, includeNonAmdDependencies, emitRelativePathAsModuleName);
+                emitAMDDependencyList(dependencyNames);
+                write(", ");
+                emitAMDFactoryHeader(dependencyNames);
+            }
+            function emitAMDDependencyList(_a) {
+                var aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames;
+                write('["require", "exports"');
+                if (aliasedModuleNames.length) {
+                    write(", ");
+                    write(aliasedModuleNames.join(", "));
+                }
+                if (unaliasedModuleNames.length) {
+                    write(", ");
+                    write(unaliasedModuleNames.join(", "));
+                }
+                write("]");
+            }
+            function emitAMDFactoryHeader(_a) {
+                var importAliasNames = _a.importAliasNames;
+                write("function (require, exports");
+                if (importAliasNames.length) {
+                    write(", ");
+                    write(importAliasNames.join(", "));
+                }
+                write(") {");
+            }
+            function emitAMDModule(node, emitRelativePathAsModuleName) {
+                emitEmitHelpers(node);
+                collectExternalModuleInfo(node);
+                writeLine();
+                write("define(");
+                writeModuleName(node, emitRelativePathAsModuleName);
+                emitAMDDependencies(node, /*includeNonAmdDependencies*/ true, emitRelativePathAsModuleName);
+                increaseIndent();
+                var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict);
+                emitExportStarHelper();
+                emitCaptureThisForNodeIfNecessary(node);
+                emitLinesStartingAt(node.statements, startIndex);
+                emitExportEquals(/*emitAsReturn*/ true);
+                emitTempDeclarations(/*newLine*/ true);
+                decreaseIndent();
+                writeLine();
+                write("});");
+            }
+            function emitCommonJSModule(node) {
+                var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict);
+                emitEmitHelpers(node);
+                collectExternalModuleInfo(node);
+                emitExportStarHelper();
+                emitCaptureThisForNodeIfNecessary(node);
+                emitLinesStartingAt(node.statements, startIndex);
+                emitExportEquals(/*emitAsReturn*/ false);
+                emitTempDeclarations(/*newLine*/ true);
+            }
+            function emitUMDModule(node) {
+                emitEmitHelpers(node);
+                collectExternalModuleInfo(node);
+                var dependencyNames = getAMDDependencyNames(node, /*includeNonAmdDependencies*/ false);
+                // Module is detected first to support Browserify users that load into a browser with an AMD loader
+                writeLines("(function (factory) {\n    if (typeof module === 'object' && typeof module.exports === 'object') {\n        var v = factory(require, exports); if (v !== undefined) module.exports = v;\n    }\n    else if (typeof define === 'function' && define.amd) {\n        define(");
+                emitAMDDependencyList(dependencyNames);
+                write(", factory);");
+                writeLines("    }\n})(");
+                emitAMDFactoryHeader(dependencyNames);
+                increaseIndent();
+                var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict);
+                emitExportStarHelper();
+                emitCaptureThisForNodeIfNecessary(node);
+                emitLinesStartingAt(node.statements, startIndex);
+                emitExportEquals(/*emitAsReturn*/ true);
+                emitTempDeclarations(/*newLine*/ true);
+                decreaseIndent();
+                writeLine();
+                write("});");
+            }
+            function emitES6Module(node) {
+                externalImports = undefined;
+                exportSpecifiers = undefined;
+                exportEquals = undefined;
+                hasExportStarsToExportValues = false;
+                var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
+                emitEmitHelpers(node);
+                emitCaptureThisForNodeIfNecessary(node);
+                emitLinesStartingAt(node.statements, startIndex);
+                emitTempDeclarations(/*newLine*/ true);
+                // Emit exportDefault if it exists will happen as part
+                // or normal statement emit.
+            }
+            function emitExportEquals(emitAsReturn) {
+                if (exportEquals && resolver.isValueAliasDeclaration(exportEquals)) {
+                    writeLine();
+                    emitStart(exportEquals);
+                    write(emitAsReturn ? "return " : "module.exports = ");
+                    emit(exportEquals.expression);
+                    write(";");
+                    emitEnd(exportEquals);
+                }
+            }
+            function emitJsxElement(node) {
+                switch (compilerOptions.jsx) {
+                    case 2 /* React */:
+                        jsxEmitReact(node);
+                        break;
+                    case 1 /* Preserve */:
+                    // Fall back to preserve if None was specified (we'll error earlier)
+                    default:
+                        jsxEmitPreserve(node);
+                        break;
+                }
+            }
+            function trimReactWhitespaceAndApplyEntities(node) {
+                var result = undefined;
+                var text = ts.getTextOfNode(node, /*includeTrivia*/ true);
+                var firstNonWhitespace = 0;
+                var lastNonWhitespace = -1;
+                // JSX trims whitespace at the end and beginning of lines, except that the
+                // start/end of a tag is considered a start/end of a line only if that line is
+                // on the same line as the closing tag. See examples in tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx
+                for (var i = 0; i < text.length; i++) {
+                    var c = text.charCodeAt(i);
+                    if (ts.isLineBreak(c)) {
+                        if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) {
+                            var part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
+                            result = (result ? result + "\" + ' ' + \"" : "") + ts.escapeString(part);
+                        }
+                        firstNonWhitespace = -1;
+                    }
+                    else if (!ts.isWhiteSpaceSingleLine(c)) {
+                        lastNonWhitespace = i;
+                        if (firstNonWhitespace === -1) {
+                            firstNonWhitespace = i;
+                        }
+                    }
+                }
+                if (firstNonWhitespace !== -1) {
+                    var part = text.substr(firstNonWhitespace);
+                    result = (result ? result + "\" + ' ' + \"" : "") + ts.escapeString(part);
+                }
+                if (result) {
+                    // Replace entities like &nbsp;
+                    result = result.replace(/&(\w+);/g, function (s, m) {
+                        if (entities[m] !== undefined) {
+                            var ch = String.fromCharCode(entities[m]);
+                            // &quot; needs to be escaped
+                            return ch === '"' ? "\\\"" : ch;
+                        }
+                        else {
+                            return s;
+                        }
+                    });
+                }
+                return result;
+            }
+            function isJsxChildEmittable(child) {
+                if (child.kind === 248 /* JsxExpression */) {
+                    // Don't emit empty expressions
+                    return !!child.expression;
+                }
+                else if (child.kind === 244 /* JsxText */) {
+                    // Don't emit empty strings
+                    return !!getTextToEmit(child);
+                }
+                return true;
+            }
+            ;
+            function getTextToEmit(node) {
+                switch (compilerOptions.jsx) {
+                    case 2 /* React */:
+                        var text = trimReactWhitespaceAndApplyEntities(node);
+                        if (text === undefined || text.length === 0) {
+                            return undefined;
+                        }
+                        else {
+                            return text;
+                        }
+                    case 1 /* Preserve */:
+                    default:
+                        return ts.getTextOfNode(node, /*includeTrivia*/ true);
+                }
+            }
+            function emitJsxText(node) {
+                switch (compilerOptions.jsx) {
+                    case 2 /* React */:
+                        write('"');
+                        write(trimReactWhitespaceAndApplyEntities(node));
+                        write('"');
+                        break;
+                    case 1 /* Preserve */:
+                    default:
+                        writer.writeLiteral(ts.getTextOfNode(node, /*includeTrivia*/ true));
+                        break;
+                }
+            }
+            function emitJsxExpression(node) {
+                if (node.expression) {
+                    switch (compilerOptions.jsx) {
+                        case 1 /* Preserve */:
+                        default:
+                            write("{");
+                            emit(node.expression);
+                            write("}");
+                            break;
+                        case 2 /* React */:
+                            emit(node.expression);
+                            break;
+                    }
+                }
+            }
+            function isUseStrictPrologue(node) {
+                return node.expression.text === "use strict";
+            }
+            function ensureUseStrictPrologue(startWithNewLine, writeUseStrict) {
+                if (writeUseStrict) {
+                    if (startWithNewLine) {
+                        writeLine();
+                    }
+                    write("\"use strict\";");
+                }
+            }
+            function emitDirectivePrologues(statements, startWithNewLine, ensureUseStrict) {
+                var foundUseStrict = false;
+                for (var i = 0; i < statements.length; i++) {
+                    if (ts.isPrologueDirective(statements[i])) {
+                        if (isUseStrictPrologue(statements[i])) {
+                            foundUseStrict = true;
+                        }
+                        if (startWithNewLine || i > 0) {
+                            writeLine();
+                        }
+                        emit(statements[i]);
+                    }
+                    else {
+                        ensureUseStrictPrologue(startWithNewLine || i > 0, !foundUseStrict && ensureUseStrict);
+                        // return index of the first non prologue directive
+                        return i;
+                    }
+                }
+                ensureUseStrictPrologue(startWithNewLine, !foundUseStrict && ensureUseStrict);
+                return statements.length;
+            }
+            function writeLines(text) {
+                var lines = text.split(/\r\n|\r|\n/g);
+                for (var i = 0; i < lines.length; i++) {
+                    var line = lines[i];
+                    if (line.length) {
+                        writeLine();
+                        write(line);
+                    }
+                }
+            }
+            function emitEmitHelpers(node) {
+                // Only emit helpers if the user did not say otherwise.
+                if (!compilerOptions.noEmitHelpers) {
+                    // Only Emit __extends function when target ES5.
+                    // For target ES6 and above, we can emit classDeclaration as is.
+                    if (languageVersion < 2 /* ES6 */ && !extendsEmitted && node.flags & 262144 /* HasClassExtends */) {
+                        writeLines(extendsHelper);
+                        extendsEmitted = true;
+                    }
+                    if (compilerOptions.jsx !== 1 /* Preserve */ && !assignEmitted && (node.flags & 1073741824 /* HasJsxSpreadAttribute */)) {
+                        writeLines(assignHelper);
+                        assignEmitted = true;
+                    }
+                    if (!decorateEmitted && node.flags & 524288 /* HasDecorators */) {
+                        writeLines(decorateHelper);
+                        if (compilerOptions.emitDecoratorMetadata) {
+                            writeLines(metadataHelper);
+                        }
+                        decorateEmitted = true;
+                    }
+                    if (!paramEmitted && node.flags & 1048576 /* HasParamDecorators */) {
+                        writeLines(paramHelper);
+                        paramEmitted = true;
+                    }
+                    if (!awaiterEmitted && node.flags & 2097152 /* HasAsyncFunctions */) {
+                        writeLines(awaiterHelper);
+                        awaiterEmitted = true;
+                    }
+                }
+            }
+            function emitSourceFileNode(node) {
+                // Start new file on new line
+                writeLine();
+                emitShebang();
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
+                if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
+                    if (isOwnFileEmit || (!ts.isExternalModule(node) && compilerOptions.isolatedModules)) {
+                        var emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[ts.ModuleKind.CommonJS];
+                        emitModule(node);
+                    }
+                    else {
+                        bundleEmitDelegates[modulekind](node, /*emitRelativePathAsModuleName*/ true);
+                    }
+                }
+                else {
+                    // emit prologue directives prior to __extends
+                    var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
+                    externalImports = undefined;
+                    exportSpecifiers = undefined;
+                    exportEquals = undefined;
+                    hasExportStarsToExportValues = false;
+                    emitEmitHelpers(node);
+                    emitCaptureThisForNodeIfNecessary(node);
+                    emitLinesStartingAt(node.statements, startIndex);
+                    emitTempDeclarations(/*newLine*/ true);
+                }
+                emitLeadingComments(node.endOfFileToken);
+            }
+            function emit(node) {
+                emitNodeConsideringCommentsOption(node, emitNodeWithSourceMap);
+            }
+            function emitNodeWithCommentsAndWithoutSourcemap(node) {
+                emitNodeConsideringCommentsOption(node, emitNodeWithoutSourceMap);
+            }
+            function emitNodeConsideringCommentsOption(node, emitNodeConsideringSourcemap) {
+                if (node) {
+                    if (node.flags & 2 /* Ambient */) {
+                        return emitCommentsOnNotEmittedNode(node);
+                    }
+                    if (isSpecializedCommentHandling(node)) {
+                        // This is the node that will handle its own comments and sourcemap
+                        return emitNodeWithoutSourceMap(node);
+                    }
+                    var emitComments_1 = shouldEmitLeadingAndTrailingComments(node);
+                    if (emitComments_1) {
+                        emitLeadingComments(node);
+                    }
+                    emitNodeConsideringSourcemap(node);
+                    if (emitComments_1) {
+                        emitTrailingComments(node);
+                    }
+                }
+            }
+            function emitNodeWithSourceMap(node) {
+                if (node) {
+                    emitStart(node);
+                    emitNodeWithoutSourceMap(node);
+                    emitEnd(node);
+                }
+            }
+            function emitNodeWithoutSourceMap(node) {
+                if (node) {
+                    emitJavaScriptWorker(node);
+                }
+            }
+            function changeSourceMapEmit(writer) {
+                sourceMap = writer;
+                emitStart = writer.emitStart;
+                emitEnd = writer.emitEnd;
+                emitPos = writer.emitPos;
+                setSourceFile = writer.setSourceFile;
+            }
+            function withTemporaryNoSourceMap(callback) {
+                var prevSourceMap = sourceMap;
+                setSourceMapWriterEmit(ts.getNullSourceMapWriter());
+                callback();
+                setSourceMapWriterEmit(prevSourceMap);
+            }
+            function isSpecializedCommentHandling(node) {
+                switch (node.kind) {
+                    // All of these entities are emitted in a specialized fashion.  As such, we allow
+                    // the specialized methods for each to handle the comments on the nodes.
+                    case 222 /* InterfaceDeclaration */:
+                    case 220 /* FunctionDeclaration */:
+                    case 230 /* ImportDeclaration */:
+                    case 229 /* ImportEqualsDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                    case 235 /* ExportAssignment */:
+                        return true;
+                }
+            }
+            function shouldEmitLeadingAndTrailingComments(node) {
+                switch (node.kind) {
+                    case 200 /* VariableStatement */:
+                        return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node);
+                    case 225 /* ModuleDeclaration */:
+                        // Only emit the leading/trailing comments for a module if we're actually
+                        // emitting the module as well.
+                        return shouldEmitModuleDeclaration(node);
+                    case 224 /* EnumDeclaration */:
+                        // Only emit the leading/trailing comments for an enum if we're actually
+                        // emitting the module as well.
+                        return shouldEmitEnumDeclaration(node);
+                }
+                // If the node is emitted in specialized fashion, dont emit comments as this node will handle
+                // emitting comments when emitting itself
+                ts.Debug.assert(!isSpecializedCommentHandling(node));
+                // If this is the expression body of an arrow function that we're down-leveling,
+                // then we don't want to emit comments when we emit the body.  It will have already
+                // been taken care of when we emitted the 'return' statement for the function
+                // expression body.
+                if (node.kind !== 199 /* Block */ &&
+                    node.parent &&
+                    node.parent.kind === 180 /* ArrowFunction */ &&
+                    node.parent.body === node &&
+                    languageVersion <= 1 /* ES5 */) {
+                    return false;
+                }
+                // Emit comments for everything else.
+                return true;
+            }
+            function emitJavaScriptWorker(node) {
+                // Check if the node can be emitted regardless of the ScriptTarget
+                switch (node.kind) {
+                    case 69 /* Identifier */:
+                        return emitIdentifier(node);
+                    case 142 /* Parameter */:
+                        return emitParameter(node);
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        return emitMethod(node);
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        return emitAccessor(node);
+                    case 97 /* ThisKeyword */:
+                        return emitThis(node);
+                    case 95 /* SuperKeyword */:
+                        return emitSuper(node);
+                    case 93 /* NullKeyword */:
+                        return write("null");
+                    case 99 /* TrueKeyword */:
+                        return write("true");
+                    case 84 /* FalseKeyword */:
+                        return write("false");
+                    case 8 /* NumericLiteral */:
+                    case 9 /* StringLiteral */:
+                    case 10 /* RegularExpressionLiteral */:
+                    case 11 /* NoSubstitutionTemplateLiteral */:
+                    case 12 /* TemplateHead */:
+                    case 13 /* TemplateMiddle */:
+                    case 14 /* TemplateTail */:
+                        return emitLiteral(node);
+                    case 189 /* TemplateExpression */:
+                        return emitTemplateExpression(node);
+                    case 197 /* TemplateSpan */:
+                        return emitTemplateSpan(node);
+                    case 241 /* JsxElement */:
+                    case 242 /* JsxSelfClosingElement */:
+                        return emitJsxElement(node);
+                    case 244 /* JsxText */:
+                        return emitJsxText(node);
+                    case 248 /* JsxExpression */:
+                        return emitJsxExpression(node);
+                    case 139 /* QualifiedName */:
+                        return emitQualifiedName(node);
+                    case 167 /* ObjectBindingPattern */:
+                        return emitObjectBindingPattern(node);
+                    case 168 /* ArrayBindingPattern */:
+                        return emitArrayBindingPattern(node);
+                    case 169 /* BindingElement */:
+                        return emitBindingElement(node);
+                    case 170 /* ArrayLiteralExpression */:
+                        return emitArrayLiteral(node);
+                    case 171 /* ObjectLiteralExpression */:
+                        return emitObjectLiteral(node);
+                    case 253 /* PropertyAssignment */:
+                        return emitPropertyAssignment(node);
+                    case 254 /* ShorthandPropertyAssignment */:
+                        return emitShorthandPropertyAssignment(node);
+                    case 140 /* ComputedPropertyName */:
+                        return emitComputedPropertyName(node);
+                    case 172 /* PropertyAccessExpression */:
+                        return emitPropertyAccess(node);
+                    case 173 /* ElementAccessExpression */:
+                        return emitIndexedAccess(node);
+                    case 174 /* CallExpression */:
+                        return emitCallExpression(node);
+                    case 175 /* NewExpression */:
+                        return emitNewExpression(node);
+                    case 176 /* TaggedTemplateExpression */:
+                        return emitTaggedTemplateExpression(node);
+                    case 177 /* TypeAssertionExpression */:
+                    case 195 /* AsExpression */:
+                    case 196 /* NonNullExpression */:
+                        return emit(node.expression);
+                    case 178 /* ParenthesizedExpression */:
+                        return emitParenExpression(node);
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                        return emitFunctionDeclaration(node);
+                    case 181 /* DeleteExpression */:
+                        return emitDeleteExpression(node);
+                    case 182 /* TypeOfExpression */:
+                        return emitTypeOfExpression(node);
+                    case 183 /* VoidExpression */:
+                        return emitVoidExpression(node);
+                    case 184 /* AwaitExpression */:
+                        return emitAwaitExpression(node);
+                    case 185 /* PrefixUnaryExpression */:
+                        return emitPrefixUnaryExpression(node);
+                    case 186 /* PostfixUnaryExpression */:
+                        return emitPostfixUnaryExpression(node);
+                    case 187 /* BinaryExpression */:
+                        return emitBinaryExpression(node);
+                    case 188 /* ConditionalExpression */:
+                        return emitConditionalExpression(node);
+                    case 191 /* SpreadElementExpression */:
+                        return emitSpreadElementExpression(node);
+                    case 190 /* YieldExpression */:
+                        return emitYieldExpression(node);
+                    case 193 /* OmittedExpression */:
+                        return;
+                    case 199 /* Block */:
+                    case 226 /* ModuleBlock */:
+                        return emitBlock(node);
+                    case 200 /* VariableStatement */:
+                        return emitVariableStatement(node);
+                    case 201 /* EmptyStatement */:
+                        return write(";");
+                    case 202 /* ExpressionStatement */:
+                        return emitExpressionStatement(node);
+                    case 203 /* IfStatement */:
+                        return emitIfStatement(node);
+                    case 204 /* DoStatement */:
+                        return emitDoStatement(node);
+                    case 205 /* WhileStatement */:
+                        return emitWhileStatement(node);
+                    case 206 /* ForStatement */:
+                        return emitForStatement(node);
+                    case 208 /* ForOfStatement */:
+                    case 207 /* ForInStatement */:
+                        return emitForInOrForOfStatement(node);
+                    case 209 /* ContinueStatement */:
+                    case 210 /* BreakStatement */:
+                        return emitBreakOrContinueStatement(node);
+                    case 211 /* ReturnStatement */:
+                        return emitReturnStatement(node);
+                    case 212 /* WithStatement */:
+                        return emitWithStatement(node);
+                    case 213 /* SwitchStatement */:
+                        return emitSwitchStatement(node);
+                    case 249 /* CaseClause */:
+                    case 250 /* DefaultClause */:
+                        return emitCaseOrDefaultClause(node);
+                    case 214 /* LabeledStatement */:
+                        return emitLabeledStatement(node);
+                    case 215 /* ThrowStatement */:
+                        return emitThrowStatement(node);
+                    case 216 /* TryStatement */:
+                        return emitTryStatement(node);
+                    case 252 /* CatchClause */:
+                        return emitCatchClause(node);
+                    case 217 /* DebuggerStatement */:
+                        return emitDebuggerStatement(node);
+                    case 218 /* VariableDeclaration */:
+                        return emitVariableDeclaration(node);
+                    case 192 /* ClassExpression */:
+                        return emitClassExpression(node);
+                    case 221 /* ClassDeclaration */:
+                        return emitClassDeclaration(node);
+                    case 222 /* InterfaceDeclaration */:
+                        return emitInterfaceDeclaration(node);
+                    case 224 /* EnumDeclaration */:
+                        return emitEnumDeclaration(node);
+                    case 255 /* EnumMember */:
+                        return emitEnumMember(node);
+                    case 225 /* ModuleDeclaration */:
+                        return emitModuleDeclaration(node);
+                    case 230 /* ImportDeclaration */:
+                        return emitImportDeclaration(node);
+                    case 229 /* ImportEqualsDeclaration */:
+                        return emitImportEqualsDeclaration(node);
+                    case 236 /* ExportDeclaration */:
+                        return emitExportDeclaration(node);
+                    case 235 /* ExportAssignment */:
+                        return emitExportAssignment(node);
+                    case 256 /* SourceFile */:
+                        return emitSourceFileNode(node);
+                }
+            }
+            function hasDetachedComments(pos) {
+                return detachedCommentsInfo !== undefined && ts.lastOrUndefined(detachedCommentsInfo).nodePos === pos;
+            }
+            function getLeadingCommentsWithoutDetachedComments() {
+                // get the leading comments from detachedPos
+                var leadingComments = ts.getLeadingCommentRanges(currentText, ts.lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos);
+                if (detachedCommentsInfo.length - 1) {
+                    detachedCommentsInfo.pop();
+                }
+                else {
+                    detachedCommentsInfo = undefined;
+                }
+                return leadingComments;
+            }
+            /**
+             * Determine if the given comment is a triple-slash
+             *
+             * @return true if the comment is a triple-slash comment else false
+             **/
+            function isTripleSlashComment(comment) {
+                // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text
+                // so that we don't end up computing comment string and doing match for all // comments
+                if (currentText.charCodeAt(comment.pos + 1) === 47 /* slash */ &&
+                    comment.pos + 2 < comment.end &&
+                    currentText.charCodeAt(comment.pos + 2) === 47 /* slash */) {
+                    var textSubStr = currentText.substring(comment.pos, comment.end);
+                    return textSubStr.match(ts.fullTripleSlashReferencePathRegEx) ||
+                        textSubStr.match(ts.fullTripleSlashAMDReferencePathRegEx) ?
+                        true : false;
+                }
+                return false;
+            }
+            function getLeadingCommentsToEmit(node) {
+                // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments
+                if (node.parent) {
+                    if (node.parent.kind === 256 /* SourceFile */ || node.pos !== node.parent.pos) {
+                        if (hasDetachedComments(node.pos)) {
+                            // get comments without detached comments
+                            return getLeadingCommentsWithoutDetachedComments();
+                        }
+                        else {
+                            // get the leading comments from the node
+                            return ts.getLeadingCommentRangesOfNodeFromText(node, currentText);
+                        }
+                    }
+                }
+            }
+            function getTrailingCommentsToEmit(node) {
+                // Emit the trailing comments only if the parent's pos doesn't match because parent should take care of emitting these comments
+                if (node.parent) {
+                    if (node.parent.kind === 256 /* SourceFile */ || node.end !== node.parent.end) {
+                        return ts.getTrailingCommentRanges(currentText, node.end);
+                    }
+                }
+            }
+            /**
+             * Emit comments associated with node that will not be emitted into JS file
+             */
+            function emitCommentsOnNotEmittedNode(node) {
+                emitLeadingCommentsWorker(node, /*isEmittedNode*/ false);
+            }
+            function emitLeadingComments(node) {
+                return emitLeadingCommentsWorker(node, /*isEmittedNode*/ true);
+            }
+            function emitLeadingCommentsWorker(node, isEmittedNode) {
+                if (compilerOptions.removeComments) {
+                    return;
+                }
+                var leadingComments;
+                if (isEmittedNode) {
+                    leadingComments = getLeadingCommentsToEmit(node);
+                }
+                else {
+                    // If the node will not be emitted in JS, remove all the comments(normal, pinned and ///) associated with the node,
+                    // unless it is a triple slash comment at the top of the file.
+                    // For Example:
+                    //      /// <reference-path ...>
+                    //      declare var x;
+                    //      /// <reference-path ...>
+                    //      interface F {}
+                    //  The first /// will NOT be removed while the second one will be removed even though both node will not be emitted
+                    if (node.pos === 0) {
+                        leadingComments = ts.filter(getLeadingCommentsToEmit(node), isTripleSlashComment);
+                    }
+                }
+                ts.emitNewLineBeforeLeadingComments(currentLineMap, writer, node, leadingComments);
+                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+                ts.emitComments(currentText, currentLineMap, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
+            }
+            function emitTrailingComments(node) {
+                if (compilerOptions.removeComments) {
+                    return;
+                }
+                // Emit the trailing comments only if the parent's end doesn't match
+                var trailingComments = getTrailingCommentsToEmit(node);
+                // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
+                ts.emitComments(currentText, currentLineMap, writer, trailingComments, /*trailingSeparator*/ false, newLine, writeComment);
+            }
+            /**
+             * Emit trailing comments at the position. The term trailing comment is used here to describe following comment:
+             *      x, /comment1/ y
+             *        ^ => pos; the function will emit "comment1" in the emitJS
+             */
+            function emitTrailingCommentsOfPosition(pos) {
+                if (compilerOptions.removeComments) {
+                    return;
+                }
+                var trailingComments = ts.getTrailingCommentRanges(currentText, pos);
+                // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
+                ts.emitComments(currentText, currentLineMap, writer, trailingComments, /*trailingSeparator*/ true, newLine, writeComment);
+            }
+            function emitLeadingCommentsOfPositionWorker(pos) {
+                if (compilerOptions.removeComments) {
+                    return;
+                }
+                var leadingComments;
+                if (hasDetachedComments(pos)) {
+                    // get comments without detached comments
+                    leadingComments = getLeadingCommentsWithoutDetachedComments();
+                }
+                else {
+                    // get the leading comments from the node
+                    leadingComments = ts.getLeadingCommentRanges(currentText, pos);
+                }
+                ts.emitNewLineBeforeLeadingComments(currentLineMap, writer, { pos: pos, end: pos }, leadingComments);
+                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+                ts.emitComments(currentText, currentLineMap, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
+            }
+            function emitDetachedCommentsAndUpdateCommentsInfo(node) {
+                var currentDetachedCommentInfo = ts.emitDetachedComments(currentText, currentLineMap, writer, writeComment, node, newLine, compilerOptions.removeComments);
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
+                    }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
+                    }
+                }
+            }
+            function writeComment(text, lineMap, writer, comment, newLine) {
+                emitPos(comment.pos);
+                ts.writeCommentRange(text, lineMap, writer, comment, newLine);
+                emitPos(comment.end);
+            }
+            function emitShebang() {
+                var shebang = ts.getShebang(currentText);
+                if (shebang) {
+                    write(shebang);
+                    writeLine();
+                }
+            }
+            var _a, _b;
+        }
+        function emitFile(_a, sourceFiles, isBundledEmit) {
+            var jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath;
+            // Make sure not to write js File and source map file if any of them cannot be written
+            if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit) {
+                emitJavaScript(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
+            }
+            else {
+                emitSkipped = true;
+            }
+            if (declarationFilePath) {
+                emitSkipped = ts.writeDeclarationFile(declarationFilePath, sourceFiles, isBundledEmit, host, resolver, emitterDiagnostics) || emitSkipped;
+            }
+            if (!emitSkipped && emittedFilesList) {
+                emittedFilesList.push(jsFilePath);
+                if (sourceMapFilePath) {
+                    emittedFilesList.push(sourceMapFilePath);
+                }
+                if (declarationFilePath) {
+                    emittedFilesList.push(declarationFilePath);
+                }
+            }
+        }
+    }
+    ts.emitFiles = emitFiles;
+})(ts || (ts = {}));
+/// <reference path="sys.ts" />
+/// <reference path="emitter.ts" />
+/// <reference path="core.ts" />
+var ts;
+(function (ts) {
+    /* @internal */ ts.programTime = 0;
+    /* @internal */ ts.emitTime = 0;
+    /* @internal */ ts.ioReadTime = 0;
+    /* @internal */ ts.ioWriteTime = 0;
+    /** The version of the TypeScript compiler release */
+    ts.version = "2.0.0";
+    var emptyArray = [];
+    var defaultTypeRoots = ["node_modules/@types"];
+    function findConfigFile(searchPath, fileExists) {
+        while (true) {
+            var fileName = ts.combinePaths(searchPath, "tsconfig.json");
+            if (fileExists(fileName)) {
+                return fileName;
+            }
+            var parentPath = ts.getDirectoryPath(searchPath);
+            if (parentPath === searchPath) {
+                break;
+            }
+            searchPath = parentPath;
+        }
+        return undefined;
+    }
+    ts.findConfigFile = findConfigFile;
+    function resolveTripleslashReference(moduleName, containingFile) {
+        var basePath = ts.getDirectoryPath(containingFile);
+        var referencedFileName = ts.isRootedDiskPath(moduleName) ? moduleName : ts.combinePaths(basePath, moduleName);
+        return ts.normalizePath(referencedFileName);
+    }
+    ts.resolveTripleslashReference = resolveTripleslashReference;
+    /* @internal */
+    function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) {
+        var commonPathComponents;
+        var failed = ts.forEach(fileNames, function (sourceFile) {
+            // Each file contributes into common source file path
+            var sourcePathComponents = ts.getNormalizedPathComponents(sourceFile, currentDirectory);
+            sourcePathComponents.pop(); // The base file name is not part of the common directory path
+            if (!commonPathComponents) {
+                // first file
+                commonPathComponents = sourcePathComponents;
+                return;
+            }
+            for (var i = 0, n = Math.min(commonPathComponents.length, sourcePathComponents.length); i < n; i++) {
+                if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {
+                    if (i === 0) {
+                        // Failed to find any common path component
+                        return true;
+                    }
+                    // New common path found that is 0 -> i-1
+                    commonPathComponents.length = i;
+                    break;
+                }
+            }
+            // If the sourcePathComponents was shorter than the commonPathComponents, truncate to the sourcePathComponents
+            if (sourcePathComponents.length < commonPathComponents.length) {
+                commonPathComponents.length = sourcePathComponents.length;
+            }
+        });
+        // A common path can not be found when paths span multiple drives on windows, for example
+        if (failed) {
+            return "";
+        }
+        if (!commonPathComponents) {
+            return currentDirectory;
+        }
+        return ts.getNormalizedPathFromPathComponents(commonPathComponents);
+    }
+    ts.computeCommonSourceDirectoryOfFilenames = computeCommonSourceDirectoryOfFilenames;
+    function trace(host, message) {
+        host.trace(ts.formatMessage.apply(undefined, arguments));
+    }
+    function isTraceEnabled(compilerOptions, host) {
+        return compilerOptions.traceResolution && host.trace !== undefined;
+    }
+    /* @internal */
+    function hasZeroOrOneAsteriskCharacter(str) {
+        var seenAsterisk = false;
+        for (var i = 0; i < str.length; i++) {
+            if (str.charCodeAt(i) === 42 /* asterisk */) {
+                if (!seenAsterisk) {
+                    seenAsterisk = true;
+                }
+                else {
+                    // have already seen asterisk
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    ts.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter;
+    function createResolvedModule(resolvedFileName, isExternalLibraryImport, failedLookupLocations) {
+        return { resolvedModule: resolvedFileName ? { resolvedFileName: resolvedFileName, isExternalLibraryImport: isExternalLibraryImport } : undefined, failedLookupLocations: failedLookupLocations };
+    }
+    function moduleHasNonRelativeName(moduleName) {
+        if (ts.isRootedDiskPath(moduleName)) {
+            return false;
+        }
+        var i = moduleName.lastIndexOf("./", 1);
+        var startsWithDotSlashOrDotDotSlash = i === 0 || (i === 1 && moduleName.charCodeAt(0) === 46 /* dot */);
+        return !startsWithDotSlashOrDotDotSlash;
+    }
+    function tryReadTypesSection(packageJsonPath, baseDirectory, state) {
+        var jsonContent;
+        try {
+            var jsonText = state.host.readFile(packageJsonPath);
+            jsonContent = jsonText ? JSON.parse(jsonText) : {};
+        }
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
+            jsonContent = {};
+        }
+        var typesFile;
+        var fieldName;
+        // first try to read content of 'typings' section (backward compatibility)
+        if (jsonContent.typings) {
+            if (typeof jsonContent.typings === "string") {
+                fieldName = "typings";
+                typesFile = jsonContent.typings;
+            }
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "typings", typeof jsonContent.typings);
+                }
+            }
+        }
+        // then read 'types'
+        if (!typesFile && jsonContent.types) {
+            if (typeof jsonContent.types === "string") {
+                fieldName = "types";
+                typesFile = jsonContent.types;
+            }
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "types", typeof jsonContent.types);
+                }
+            }
+        }
+        if (typesFile) {
+            var typesFilePath = ts.normalizePath(ts.combinePaths(baseDirectory, typesFile));
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
+            }
+            return typesFilePath;
+        }
+        // Use the main module for inferring types if no types package specified and the allowJs is set
+        if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.No_types_specified_in_package_json_but_allowJs_is_set_so_returning_main_value_of_0, jsonContent.main);
+            }
+            var mainFilePath = ts.normalizePath(ts.combinePaths(baseDirectory, jsonContent.main));
+            return mainFilePath;
+        }
+        return undefined;
+    }
+    var typeReferenceExtensions = [".d.ts"];
+    function getEffectiveTypeRoots(options, host) {
+        if (options.typeRoots) {
+            return options.typeRoots;
+        }
+        var currentDirectory;
+        if (options.configFilePath) {
+            currentDirectory = ts.getDirectoryPath(options.configFilePath);
+        }
+        else if (host.getCurrentDirectory) {
+            currentDirectory = host.getCurrentDirectory();
+        }
+        if (!currentDirectory) {
+            return undefined;
+        }
+        return ts.map(defaultTypeRoots, function (d) { return ts.combinePaths(currentDirectory, d); });
+    }
+    /**
+     * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
+     * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
+     * is assumed to be the same as root directory of the project.
+     */
+    function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host) {
+        var traceEnabled = isTraceEnabled(options, host);
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            skipTsx: true,
+            traceEnabled: traceEnabled
+        };
+        var typeRoots = getEffectiveTypeRoots(options, host);
+        if (traceEnabled) {
+            if (containingFile === undefined) {
+                if (typeRoots === undefined) {
+                    trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
+                }
+                else {
+                    trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
+                }
+            }
+            else {
+                if (typeRoots === undefined) {
+                    trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
+                }
+                else {
+                    trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
+                }
+            }
+        }
+        var failedLookupLocations = [];
+        // Check primary library paths
+        if (typeRoots && typeRoots.length) {
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
+            }
+            var primarySearchPaths = typeRoots;
+            for (var _i = 0, primarySearchPaths_1 = primarySearchPaths; _i < primarySearchPaths_1.length; _i++) {
+                var typeRoot = primarySearchPaths_1[_i];
+                var candidate = ts.combinePaths(typeRoot, typeReferenceDirectiveName);
+                var candidateDirectory = ts.getDirectoryPath(candidate);
+                var resolvedFile_1 = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations, !directoryProbablyExists(candidateDirectory, host), moduleResolutionState);
+                if (resolvedFile_1) {
+                    if (traceEnabled) {
+                        trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile_1, true);
+                    }
+                    return {
+                        resolvedTypeReferenceDirective: { primary: true, resolvedFileName: resolvedFile_1 },
+                        failedLookupLocations: failedLookupLocations
+                    };
+                }
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
+            }
+        }
+        var resolvedFile;
+        var initialLocationForSecondaryLookup;
+        if (containingFile) {
+            initialLocationForSecondaryLookup = ts.getDirectoryPath(containingFile);
+        }
+        if (initialLocationForSecondaryLookup !== undefined) {
+            // check secondary locations
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
+            }
+            resolvedFile = loadModuleFromNodeModules(typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState);
+            if (traceEnabled) {
+                if (resolvedFile) {
+                    trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, false);
+                }
+                else {
+                    trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
+                }
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
+            }
+        }
+        return {
+            resolvedTypeReferenceDirective: resolvedFile
+                ? { primary: false, resolvedFileName: resolvedFile }
+                : undefined,
+            failedLookupLocations: failedLookupLocations
+        };
+    }
+    ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
+    function resolveModuleName(moduleName, containingFile, compilerOptions, host) {
+        var traceEnabled = isTraceEnabled(compilerOptions, host);
+        if (traceEnabled) {
+            trace(host, ts.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
+        }
+        var moduleResolution = compilerOptions.moduleResolution;
+        if (moduleResolution === undefined) {
+            moduleResolution = ts.getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic;
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]);
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts.ModuleResolutionKind[moduleResolution]);
+            }
+        }
+        var result;
+        switch (moduleResolution) {
+            case ts.ModuleResolutionKind.NodeJs:
+                result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host);
+                break;
+            case ts.ModuleResolutionKind.Classic:
+                result = classicNameResolver(moduleName, containingFile, compilerOptions, host);
+                break;
+        }
+        if (traceEnabled) {
+            if (result.resolvedModule) {
+                trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
+            }
+            else {
+                trace(host, ts.Diagnostics.Module_name_0_was_not_resolved, moduleName);
+            }
+        }
+        return result;
+    }
+    ts.resolveModuleName = resolveModuleName;
+    /**
+     * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to
+     * mitigate differences between design time structure of the project and its runtime counterpart so the same import name
+     * can be resolved successfully by TypeScript compiler and runtime module loader.
+     * If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will
+     * fallback to standard resolution routine.
+     *
+     * - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative
+     * names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then candidate location to resolve module name 'c/d' will
+     * be '/a/b/c/d'
+     * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names
+     * will be resolved based on the content of the module name.
+     * Structure of 'paths' compiler options
+     * 'paths': {
+     *    pattern-1: [...substitutions],
+     *    pattern-2: [...substitutions],
+     *    ...
+     *    pattern-n: [...substitutions]
+     * }
+     * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against
+     * all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case.
+     * If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>.
+     * <MatchedStar> denotes part of the module name between <prefix> and <suffix>.
+     * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.
+     * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module
+     * from the candidate location.
+     * Substitution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every
+     * substitution in the list and replace '*' with <MatchedStar> string. If candidate location is not rooted it
+     * will be converted to absolute using baseUrl.
+     * For example:
+     * baseUrl: /a/b/c
+     * "paths": {
+     *     // match all module names
+     *     "*": [
+     *         "*",        // use matched name as is,
+     *                     // <matched name> will be looked as /a/b/c/<matched name>
+     *
+     *         "folder1/*" // substitution will convert matched name to 'folder1/<matched name>',
+     *                     // since it is not rooted then final candidate location will be /a/b/c/folder1/<matched name>
+     *     ],
+     *     // match module names that start with 'components/'
+     *     "components/*": [ "/root/components/*" ] // substitution will convert /components/folder1/<matched name> to '/root/components/folder1/<matched name>',
+     *                                              // it is rooted so it will be final candidate location
+     * }
+     *
+     * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if
+     * they were in the same location. For example lets say there are two files
+     * '/local/src/content/file1.ts'
+     * '/shared/components/contracts/src/content/protocols/file2.ts'
+     * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so
+     * if file1 has the following import 'import {x} from "./protocols/file2"' it will be resolved successfully in runtime.
+     * 'rootDirs' provides the way to tell compiler that in order to get the whole project it should behave as if content of all
+     * root dirs were merged together.
+     * I.e. for the example above 'rootDirs' will have two entries: [ '/local/src', '/shared/components/contracts/src' ].
+     * Compiler will first convert './protocols/file2' into absolute path relative to the location of containing file:
+     * '/local/src/content/protocols/file2' and try to load it - failure.
+     * Then it will search 'rootDirs' looking for a longest matching prefix of this absolute path and if such prefix is found - absolute path will
+     * be converted to a path relative to found rootDir entry './content/protocols/file2' (*). As a last step compiler will check all remaining
+     * entries in 'rootDirs', use them to build absolute path out of (*) and try to resolve module from this location.
+     */
+    function tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, loader, failedLookupLocations, supportedExtensions, state) {
+        if (moduleHasNonRelativeName(moduleName)) {
+            return tryLoadModuleUsingBaseUrl(moduleName, loader, failedLookupLocations, supportedExtensions, state);
+        }
+        else {
+            return tryLoadModuleUsingRootDirs(moduleName, containingDirectory, loader, failedLookupLocations, supportedExtensions, state);
+        }
+    }
+    function tryLoadModuleUsingRootDirs(moduleName, containingDirectory, loader, failedLookupLocations, supportedExtensions, state) {
+        if (!state.compilerOptions.rootDirs) {
+            return undefined;
+        }
+        if (state.traceEnabled) {
+            trace(state.host, ts.Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
+        }
+        var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+        var matchedRootDir;
+        var matchedNormalizedPrefix;
+        for (var _i = 0, _a = state.compilerOptions.rootDirs; _i < _a.length; _i++) {
+            var rootDir = _a[_i];
+            // rootDirs are expected to be absolute
+            // in case of tsconfig.json this will happen automatically - compiler will expand relative names
+            // using location of tsconfig.json as base location
+            var normalizedRoot = ts.normalizePath(rootDir);
+            if (!ts.endsWith(normalizedRoot, ts.directorySeparator)) {
+                normalizedRoot += ts.directorySeparator;
+            }
+            var isLongestMatchingPrefix = ts.startsWith(candidate, normalizedRoot) &&
+                (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
+            }
+            if (isLongestMatchingPrefix) {
+                matchedNormalizedPrefix = normalizedRoot;
+                matchedRootDir = rootDir;
+            }
+        }
+        if (matchedNormalizedPrefix) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
+            }
+            var suffix = candidate.substr(matchedNormalizedPrefix.length);
+            // first - try to load from a initial location
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
+            }
+            var resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(containingDirectory, state.host), state);
+            if (resolvedFileName) {
+                return resolvedFileName;
+            }
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Trying_other_entries_in_rootDirs);
+            }
+            // then try to resolve using remaining entries in rootDirs
+            for (var _b = 0, _c = state.compilerOptions.rootDirs; _b < _c.length; _b++) {
+                var rootDir = _c[_b];
+                if (rootDir === matchedRootDir) {
+                    // skip the initially matched entry
+                    continue;
+                }
+                var candidate_1 = ts.combinePaths(ts.normalizePath(rootDir), suffix);
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate_1);
+                }
+                var baseDirectory = ts.getDirectoryPath(candidate_1);
+                var resolvedFileName_1 = loader(candidate_1, supportedExtensions, failedLookupLocations, !directoryProbablyExists(baseDirectory, state.host), state);
+                if (resolvedFileName_1) {
+                    return resolvedFileName_1;
+                }
+            }
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Module_resolution_using_rootDirs_has_failed);
+            }
+        }
+        return undefined;
+    }
+    function tryLoadModuleUsingBaseUrl(moduleName, loader, failedLookupLocations, supportedExtensions, state) {
+        if (!state.compilerOptions.baseUrl) {
+            return undefined;
+        }
+        if (state.traceEnabled) {
+            trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, state.compilerOptions.baseUrl, moduleName);
+        }
+        // string is for exact match
+        var matchedPattern = undefined;
+        if (state.compilerOptions.paths) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
+            }
+            matchedPattern = matchPatternOrExact(ts.getKeys(state.compilerOptions.paths), moduleName);
+        }
+        if (matchedPattern) {
+            var matchedStar = typeof matchedPattern === "string" ? undefined : matchedText(matchedPattern, moduleName);
+            var matchedPatternText = typeof matchedPattern === "string" ? matchedPattern : patternText(matchedPattern);
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
+            }
+            for (var _i = 0, _a = state.compilerOptions.paths[matchedPatternText]; _i < _a.length; _i++) {
+                var subst = _a[_i];
+                var path = matchedStar ? subst.replace("*", matchedStar) : subst;
+                var candidate = ts.normalizePath(ts.combinePaths(state.compilerOptions.baseUrl, path));
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
+                }
+                var resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
+                if (resolvedFileName) {
+                    return resolvedFileName;
+                }
+            }
+            return undefined;
+        }
+        else {
+            var candidate = ts.normalizePath(ts.combinePaths(state.compilerOptions.baseUrl, moduleName));
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, state.compilerOptions.baseUrl, candidate);
+            }
+            return loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
+        }
+    }
+    /**
+     * patternStrings contains both pattern strings (containing "*") and regular strings.
+     * Return an exact match if possible, or a pattern match, or undefined.
+     * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
+     */
+    function matchPatternOrExact(patternStrings, candidate) {
+        var patterns = [];
+        for (var _i = 0, patternStrings_1 = patternStrings; _i < patternStrings_1.length; _i++) {
+            var patternString = patternStrings_1[_i];
+            var pattern = tryParsePattern(patternString);
+            if (pattern) {
+                patterns.push(pattern);
+            }
+            else if (patternString === candidate) {
+                // pattern was matched as is - no need to search further
+                return patternString;
+            }
+        }
+        return findBestPatternMatch(patterns, function (_) { return _; }, candidate);
+    }
+    function patternText(_a) {
+        var prefix = _a.prefix, suffix = _a.suffix;
+        return prefix + "*" + suffix;
+    }
+    /**
+     * Given that candidate matches pattern, returns the text matching the '*'.
+     * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
+     */
+    function matchedText(pattern, candidate) {
+        ts.Debug.assert(isPatternMatch(pattern, candidate));
+        return candidate.substr(pattern.prefix.length, candidate.length - pattern.suffix.length);
+    }
+    /** Return the object corresponding to the best pattern to match `candidate`. */
+    /* @internal */
+    function findBestPatternMatch(values, getPattern, candidate) {
+        var matchedValue = undefined;
+        // use length of prefix as betterness criteria
+        var longestMatchPrefixLength = -1;
+        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+            var v = values_1[_i];
+            var pattern = getPattern(v);
+            if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
+                longestMatchPrefixLength = pattern.prefix.length;
+                matchedValue = v;
+            }
+        }
+        return matchedValue;
+    }
+    ts.findBestPatternMatch = findBestPatternMatch;
+    function isPatternMatch(_a, candidate) {
+        var prefix = _a.prefix, suffix = _a.suffix;
+        return candidate.length >= prefix.length + suffix.length &&
+            ts.startsWith(candidate, prefix) &&
+            ts.endsWith(candidate, suffix);
+    }
+    /* @internal */
+    function tryParsePattern(pattern) {
+        // This should be verified outside of here and a proper error thrown.
+        ts.Debug.assert(hasZeroOrOneAsteriskCharacter(pattern));
+        var indexOfStar = pattern.indexOf("*");
+        return indexOfStar === -1 ? undefined : {
+            prefix: pattern.substr(0, indexOfStar),
+            suffix: pattern.substr(indexOfStar + 1)
+        };
+    }
+    ts.tryParsePattern = tryParsePattern;
+    function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host) {
+        var containingDirectory = ts.getDirectoryPath(containingFile);
+        var supportedExtensions = ts.getSupportedExtensions(compilerOptions);
+        var traceEnabled = isTraceEnabled(compilerOptions, host);
+        var failedLookupLocations = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, skipTsx: false };
+        var resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, nodeLoadModuleByRelativeName, failedLookupLocations, supportedExtensions, state);
+        var isExternalLibraryImport = false;
+        if (!resolvedFileName) {
+            if (moduleHasNonRelativeName(moduleName)) {
+                if (traceEnabled) {
+                    trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
+                }
+                resolvedFileName = loadModuleFromNodeModules(moduleName, containingDirectory, failedLookupLocations, state);
+                isExternalLibraryImport = resolvedFileName !== undefined;
+            }
+            else {
+                var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+                resolvedFileName = nodeLoadModuleByRelativeName(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+            }
+        }
+        if (resolvedFileName && host.realpath) {
+            var originalFileName = resolvedFileName;
+            resolvedFileName = ts.normalizePath(host.realpath(resolvedFileName));
+            if (traceEnabled) {
+                trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, originalFileName, resolvedFileName);
+            }
+        }
+        return createResolvedModule(resolvedFileName, isExternalLibraryImport, failedLookupLocations);
+    }
+    ts.nodeModuleNameResolver = nodeModuleNameResolver;
+    function nodeLoadModuleByRelativeName(candidate, supportedExtensions, failedLookupLocations, onlyRecordFailures, state) {
+        if (state.traceEnabled) {
+            trace(state.host, ts.Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
+        }
+        var resolvedFileName = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, onlyRecordFailures, state);
+        return resolvedFileName || loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+    }
+    /* @internal */
+    function directoryProbablyExists(directoryName, host) {
+        // if host does not support 'directoryExists' assume that directory will exist
+        return !host.directoryExists || host.directoryExists(directoryName);
+    }
+    ts.directoryProbablyExists = directoryProbablyExists;
+    /**
+     * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
+     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
+     */
+    function loadModuleFromFile(candidate, extensions, failedLookupLocation, onlyRecordFailures, state) {
+        // First try to keep/add an extension: importing "./foo.ts" can be matched by a file "./foo.ts", and "./foo" by "./foo.d.ts"
+        var resolvedByAddingOrKeepingExtension = loadModuleFromFileWorker(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
+        if (resolvedByAddingOrKeepingExtension) {
+            return resolvedByAddingOrKeepingExtension;
+        }
+        // Then try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one, e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
+        if (ts.hasJavaScriptFileExtension(candidate)) {
+            var extensionless = ts.removeFileExtension(candidate);
+            if (state.traceEnabled) {
+                var extension = candidate.substring(extensionless.length);
+                trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
+            }
+            return loadModuleFromFileWorker(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+        }
+    }
+    function loadModuleFromFileWorker(candidate, extensions, failedLookupLocation, onlyRecordFailures, state) {
+        if (!onlyRecordFailures) {
+            // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
+            var directory = ts.getDirectoryPath(candidate);
+            if (directory) {
+                onlyRecordFailures = !directoryProbablyExists(directory, state.host);
+            }
+        }
+        return ts.forEach(extensions, tryLoad);
+        function tryLoad(ext) {
+            if (state.skipTsx && ts.isJsxOrTsxExtension(ext)) {
+                return undefined;
+            }
+            var fileName = ts.fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
+            if (!onlyRecordFailures && state.host.fileExists(fileName)) {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
+                }
+                return fileName;
+            }
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName);
+                }
+                failedLookupLocation.push(fileName);
+                return undefined;
+            }
+        }
+    }
+    function loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocation, onlyRecordFailures, state) {
+        var packageJsonPath = ts.combinePaths(candidate, "package.json");
+        var directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
+        if (directoryExists && state.host.fileExists(packageJsonPath)) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
+            }
+            var typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
+            if (typesFile) {
+                var result = loadModuleFromFile(typesFile, extensions, failedLookupLocation, !directoryProbablyExists(ts.getDirectoryPath(typesFile), state.host), state);
+                if (result) {
+                    return result;
+                }
+            }
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.package_json_does_not_have_types_field);
+                }
+            }
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.File_0_does_not_exist, packageJsonPath);
+            }
+            // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results
+            failedLookupLocation.push(packageJsonPath);
+        }
+        return loadModuleFromFile(ts.combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
+    }
+    function loadModuleFromNodeModulesFolder(moduleName, directory, failedLookupLocations, state) {
+        var nodeModulesFolder = ts.combinePaths(directory, "node_modules");
+        var nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+        var candidate = ts.normalizePath(ts.combinePaths(nodeModulesFolder, moduleName));
+        var supportedExtensions = ts.getSupportedExtensions(state.compilerOptions);
+        var result = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, !nodeModulesFolderExists, state);
+        if (result) {
+            return result;
+        }
+        result = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state);
+        if (result) {
+            return result;
+        }
+    }
+    function loadModuleFromNodeModules(moduleName, directory, failedLookupLocations, state) {
+        directory = ts.normalizeSlashes(directory);
+        while (true) {
+            var baseName = ts.getBaseFileName(directory);
+            if (baseName !== "node_modules") {
+                // Try to load source from the package
+                var packageResult = loadModuleFromNodeModulesFolder(moduleName, directory, failedLookupLocations, state);
+                if (packageResult && ts.hasTypeScriptFileExtension(packageResult)) {
+                    // Always prefer a TypeScript (.ts, .tsx, .d.ts) file shipped with the package
+                    return packageResult;
+                }
+                else {
+                    // Else prefer a types package over non-TypeScript results (e.g. JavaScript files)
+                    var typesResult = loadModuleFromNodeModulesFolder(ts.combinePaths("@types", moduleName), directory, failedLookupLocations, state);
+                    if (typesResult || packageResult) {
+                        return typesResult || packageResult;
+                    }
+                }
+            }
+            var parentPath = ts.getDirectoryPath(directory);
+            if (parentPath === directory) {
+                break;
+            }
+            directory = parentPath;
+        }
+        return undefined;
+    }
+    function classicNameResolver(moduleName, containingFile, compilerOptions, host) {
+        var traceEnabled = isTraceEnabled(compilerOptions, host);
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, skipTsx: !compilerOptions.jsx };
+        var failedLookupLocations = [];
+        var supportedExtensions = ts.getSupportedExtensions(compilerOptions);
+        var containingDirectory = ts.getDirectoryPath(containingFile);
+        var resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, loadModuleFromFile, failedLookupLocations, supportedExtensions, state);
+        if (resolvedFileName) {
+            return createResolvedModule(resolvedFileName, /*isExternalLibraryImport*/ false, failedLookupLocations);
+        }
+        var referencedSourceFile;
+        if (moduleHasNonRelativeName(moduleName)) {
+            while (true) {
+                var searchName = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+                referencedSourceFile = loadModuleFromFile(searchName, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+                if (referencedSourceFile) {
+                    break;
+                }
+                var parentPath = ts.getDirectoryPath(containingDirectory);
+                if (parentPath === containingDirectory) {
+                    break;
+                }
+                containingDirectory = parentPath;
+            }
+        }
+        else {
+            var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+            referencedSourceFile = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+        }
+        return referencedSourceFile
+            ? { resolvedModule: { resolvedFileName: referencedSourceFile }, failedLookupLocations: failedLookupLocations }
+            : { resolvedModule: undefined, failedLookupLocations: failedLookupLocations };
+    }
+    ts.classicNameResolver = classicNameResolver;
+    /* @internal */
+    ts.defaultInitCompilerOptions = {
+        module: ts.ModuleKind.CommonJS,
+        target: 1 /* ES5 */,
+        noImplicitAny: false,
+        sourceMap: false
+    };
+    function createCompilerHost(options, setParentNodes) {
+        var existingDirectories = {};
+        function getCanonicalFileName(fileName) {
+            // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
+            // otherwise use toLowerCase as a canonical form.
+            return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+        }
+        // returned by CScript sys environment
+        var unsupportedFileEncodingErrorCode = -2147024809;
+        function getSourceFile(fileName, languageVersion, onError) {
+            var text;
+            try {
+                var start = new Date().getTime();
+                text = ts.sys.readFile(fileName, options.charset);
+                ts.ioReadTime += new Date().getTime() - start;
+            }
+            catch (e) {
+                if (onError) {
+                    onError(e.number === unsupportedFileEncodingErrorCode
+                        ? ts.createCompilerDiagnostic(ts.Diagnostics.Unsupported_file_encoding).messageText
+                        : e.message);
+                }
+                text = "";
+            }
+            return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined;
+        }
+        function directoryExists(directoryPath) {
+            if (ts.hasProperty(existingDirectories, directoryPath)) {
+                return true;
+            }
+            if (ts.sys.directoryExists(directoryPath)) {
+                existingDirectories[directoryPath] = true;
+                return true;
+            }
+            return false;
+        }
+        function ensureDirectoriesExist(directoryPath) {
+            if (directoryPath.length > ts.getRootLength(directoryPath) && !directoryExists(directoryPath)) {
+                var parentDirectory = ts.getDirectoryPath(directoryPath);
+                ensureDirectoriesExist(parentDirectory);
+                ts.sys.createDirectory(directoryPath);
+            }
+        }
+        var outputFingerprints;
+        function writeFileIfUpdated(fileName, data, writeByteOrderMark) {
+            if (!outputFingerprints) {
+                outputFingerprints = {};
+            }
+            var hash = ts.sys.createHash(data);
+            var mtimeBefore = ts.sys.getModifiedTime(fileName);
+            if (mtimeBefore && ts.hasProperty(outputFingerprints, fileName)) {
+                var fingerprint = outputFingerprints[fileName];
+                // If output has not been changed, and the file has no external modification
+                if (fingerprint.byteOrderMark === writeByteOrderMark &&
+                    fingerprint.hash === hash &&
+                    fingerprint.mtime.getTime() === mtimeBefore.getTime()) {
+                    return;
+                }
+            }
+            ts.sys.writeFile(fileName, data, writeByteOrderMark);
+            var mtimeAfter = ts.sys.getModifiedTime(fileName);
+            outputFingerprints[fileName] = {
+                hash: hash,
+                byteOrderMark: writeByteOrderMark,
+                mtime: mtimeAfter
+            };
+        }
+        function writeFile(fileName, data, writeByteOrderMark, onError) {
+            try {
+                var start = new Date().getTime();
+                ensureDirectoriesExist(ts.getDirectoryPath(ts.normalizePath(fileName)));
+                if (ts.isWatchSet(options) && ts.sys.createHash && ts.sys.getModifiedTime) {
+                    writeFileIfUpdated(fileName, data, writeByteOrderMark);
+                }
+                else {
+                    ts.sys.writeFile(fileName, data, writeByteOrderMark);
+                }
+                ts.ioWriteTime += new Date().getTime() - start;
+            }
+            catch (e) {
+                if (onError) {
+                    onError(e.message);
+                }
+            }
+        }
+        function getDefaultLibLocation() {
+            return ts.getDirectoryPath(ts.normalizePath(ts.sys.getExecutingFilePath()));
+        }
+        var newLine = ts.getNewLineCharacter(options);
+        var realpath = ts.sys.realpath && (function (path) { return ts.sys.realpath(path); });
+        return {
+            getSourceFile: getSourceFile,
+            getDefaultLibLocation: getDefaultLibLocation,
+            getDefaultLibFileName: function (options) { return ts.combinePaths(getDefaultLibLocation(), ts.getDefaultLibFileName(options)); },
+            writeFile: writeFile,
+            getCurrentDirectory: ts.memoize(function () { return ts.sys.getCurrentDirectory(); }),
+            useCaseSensitiveFileNames: function () { return ts.sys.useCaseSensitiveFileNames; },
+            getCanonicalFileName: getCanonicalFileName,
+            getNewLine: function () { return newLine; },
+            fileExists: function (fileName) { return ts.sys.fileExists(fileName); },
+            readFile: function (fileName) { return ts.sys.readFile(fileName); },
+            trace: function (s) { return ts.sys.write(s + newLine); },
+            directoryExists: function (directoryName) { return ts.sys.directoryExists(directoryName); },
+            getDirectories: function (path) { return ts.sys.getDirectories(path); },
+            realpath: realpath
+        };
+    }
+    ts.createCompilerHost = createCompilerHost;
+    function getPreEmitDiagnostics(program, sourceFile, cancellationToken) {
+        var diagnostics = program.getOptionsDiagnostics(cancellationToken).concat(program.getSyntacticDiagnostics(sourceFile, cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSemanticDiagnostics(sourceFile, cancellationToken));
+        if (program.getCompilerOptions().declaration) {
+            diagnostics = diagnostics.concat(program.getDeclarationDiagnostics(sourceFile, cancellationToken));
+        }
+        return ts.sortAndDeduplicateDiagnostics(diagnostics);
+    }
+    ts.getPreEmitDiagnostics = getPreEmitDiagnostics;
+    function flattenDiagnosticMessageText(messageText, newLine) {
+        if (typeof messageText === "string") {
+            return messageText;
+        }
+        else {
+            var diagnosticChain = messageText;
+            var result = "";
+            var indent = 0;
+            while (diagnosticChain) {
+                if (indent) {
+                    result += newLine;
+                    for (var i = 0; i < indent; i++) {
+                        result += "  ";
+                    }
+                }
+                result += diagnosticChain.messageText;
+                indent++;
+                diagnosticChain = diagnosticChain.next;
+            }
+            return result;
+        }
+    }
+    ts.flattenDiagnosticMessageText = flattenDiagnosticMessageText;
+    function loadWithLocalCache(names, containingFile, loader) {
+        if (names.length === 0) {
+            return [];
+        }
+        var resolutions = [];
+        var cache = {};
+        for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
+            var name_34 = names_1[_i];
+            var result = void 0;
+            if (ts.hasProperty(cache, name_34)) {
+                result = cache[name_34];
+            }
+            else {
+                result = loader(name_34, containingFile);
+                cache[name_34] = result;
+            }
+            resolutions.push(result);
+        }
+        return resolutions;
+    }
+    function getInferredTypesRoot(options, rootFiles, host) {
+        return computeCommonSourceDirectoryOfFilenames(rootFiles, host.getCurrentDirectory(), function (f) { return host.getCanonicalFileName(f); });
+    }
+    /**
+      * Given a set of options and a set of root files, returns the set of type directive names
+      *   that should be included for this program automatically.
+      * This list could either come from the config file,
+      *   or from enumerating the types root + initial secondary types lookup location.
+      * More type directives might appear in the program later as a result of loading actual source files;
+      *   this list is only the set of defaults that are implicitly included.
+      */
+    function getAutomaticTypeDirectiveNames(options, rootFiles, host) {
+        // Use explicit type list from tsconfig.json
+        if (options.types) {
+            return options.types;
+        }
+        // Walk the primary type lookup locations
+        var result = [];
+        if (host.directoryExists && host.getDirectories) {
+            var typeRoots = getEffectiveTypeRoots(options, host);
+            if (typeRoots) {
+                for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) {
+                    var root = typeRoots_1[_i];
+                    if (host.directoryExists(root)) {
+                        result = result.concat(host.getDirectories(root));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;
+    function createProgram(rootNames, options, host, oldProgram) {
+        var program;
+        var files = [];
+        var commonSourceDirectory;
+        var diagnosticsProducingTypeChecker;
+        var noDiagnosticsTypeChecker;
+        var classifiableNames;
+        var resolvedTypeReferenceDirectives = {};
+        var fileProcessingDiagnostics = ts.createDiagnosticCollection();
+        // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
+        // This works as imported modules are discovered recursively in a depth first manner, specifically:
+        // - For each root file, findSourceFile is called.
+        // - This calls processImportedModules for each module imported in the source file.
+        // - This calls resolveModuleNames, and then calls findSourceFile for each resolved module.
+        // As all these operations happen - and are nested - within the createProgram call, they close over the below variables.
+        // The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses.
+        var maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 2;
+        var currentNodeModulesJsDepth = 0;
+        // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track
+        // this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed.
+        var modulesWithElidedImports = {};
+        // Track source files that are JavaScript files found by searching under node_modules, as these shouldn't be compiled.
+        var sourceFilesFoundSearchingNodeModules = {};
+        var start = new Date().getTime();
+        host = host || createCompilerHost(options);
+        var skipDefaultLib = options.noLib;
+        var programDiagnostics = ts.createDiagnosticCollection();
+        var currentDirectory = host.getCurrentDirectory();
+        var supportedExtensions = ts.getSupportedExtensions(options);
+        // Map storing if there is emit blocking diagnostics for given input
+        var hasEmitBlockingDiagnostics = ts.createFileMap(getCanonicalFileName);
+        var resolveModuleNamesWorker;
+        if (host.resolveModuleNames) {
+            resolveModuleNamesWorker = function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); };
+        }
+        else {
+            var loader_1 = function (moduleName, containingFile) { return resolveModuleName(moduleName, containingFile, options, host).resolvedModule; };
+            resolveModuleNamesWorker = function (moduleNames, containingFile) { return loadWithLocalCache(moduleNames, containingFile, loader_1); };
+        }
+        var resolveTypeReferenceDirectiveNamesWorker;
+        if (host.resolveTypeReferenceDirectives) {
+            resolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile) { return host.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile); };
+        }
+        else {
+            var loader_2 = function (typesRef, containingFile) { return resolveTypeReferenceDirective(typesRef, containingFile, options, host).resolvedTypeReferenceDirective; };
+            resolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile) { return loadWithLocalCache(typeReferenceDirectiveNames, containingFile, loader_2); };
+        }
+        var filesByName = ts.createFileMap();
+        // stores 'filename -> file association' ignoring case
+        // used to track cases when two file names differ only in casing
+        var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createFileMap(function (fileName) { return fileName.toLowerCase(); }) : undefined;
+        if (!tryReuseStructureFromOldProgram()) {
+            ts.forEach(rootNames, function (name) { return processRootFile(name, /*isDefaultLib*/ false); });
+            // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
+            var typeReferences = getAutomaticTypeDirectiveNames(options, rootNames, host);
+            if (typeReferences) {
+                var inferredRoot = getInferredTypesRoot(options, rootNames, host);
+                var containingFilename = ts.combinePaths(inferredRoot, "__inferred type names__.ts");
+                var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
+                for (var i = 0; i < typeReferences.length; i++) {
+                    processTypeReferenceDirective(typeReferences[i], resolutions[i]);
+                }
+            }
+            // Do not process the default library if:
+            //  - The '--noLib' flag is used.
+            //  - A 'no-default-lib' reference comment is encountered in
+            //      processing the root files.
+            if (!skipDefaultLib) {
+                // If '--lib' is not specified, include default library file according to '--target'
+                // otherwise, using options specified in '--lib' instead of '--target' default library file
+                if (!options.lib) {
+                    processRootFile(host.getDefaultLibFileName(options), /*isDefaultLib*/ true);
+                }
+                else {
+                    var libDirectory_1 = host.getDefaultLibLocation ? host.getDefaultLibLocation() : ts.getDirectoryPath(host.getDefaultLibFileName(options));
+                    ts.forEach(options.lib, function (libFileName) {
+                        processRootFile(ts.combinePaths(libDirectory_1, libFileName), /*isDefaultLib*/ true);
+                    });
+                }
+            }
+        }
+        // unconditionally set oldProgram to undefined to prevent it from being captured in closure
+        oldProgram = undefined;
+        program = {
+            getRootFileNames: function () { return rootNames; },
+            getSourceFile: getSourceFile,
+            getSourceFileByPath: getSourceFileByPath,
+            getSourceFiles: function () { return files; },
+            getCompilerOptions: function () { return options; },
+            getSyntacticDiagnostics: getSyntacticDiagnostics,
+            getOptionsDiagnostics: getOptionsDiagnostics,
+            getGlobalDiagnostics: getGlobalDiagnostics,
+            getSemanticDiagnostics: getSemanticDiagnostics,
+            getDeclarationDiagnostics: getDeclarationDiagnostics,
+            getTypeChecker: getTypeChecker,
+            getClassifiableNames: getClassifiableNames,
+            getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker,
+            getCommonSourceDirectory: getCommonSourceDirectory,
+            emit: emit,
+            getCurrentDirectory: function () { return currentDirectory; },
+            getNodeCount: function () { return getDiagnosticsProducingTypeChecker().getNodeCount(); },
+            getIdentifierCount: function () { return getDiagnosticsProducingTypeChecker().getIdentifierCount(); },
+            getSymbolCount: function () { return getDiagnosticsProducingTypeChecker().getSymbolCount(); },
+            getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); },
+            getFileProcessingDiagnostics: function () { return fileProcessingDiagnostics; },
+            getResolvedTypeReferenceDirectives: function () { return resolvedTypeReferenceDirectives; }
+        };
+        verifyCompilerOptions();
+        ts.programTime += new Date().getTime() - start;
+        return program;
+        function getCommonSourceDirectory() {
+            if (typeof commonSourceDirectory === "undefined") {
+                if (options.rootDir && checkSourceFilesBelongToPath(files, options.rootDir)) {
+                    // If a rootDir is specified and is valid use it as the commonSourceDirectory
+                    commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, currentDirectory);
+                }
+                else {
+                    commonSourceDirectory = computeCommonSourceDirectory(files);
+                }
+                if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) {
+                    // Make sure directory path ends with directory separator so this string can directly
+                    // used to replace with "" to get the relative path of the source file and the relative path doesn't
+                    // start with / making it rooted path
+                    commonSourceDirectory += ts.directorySeparator;
+                }
+            }
+            return commonSourceDirectory;
+        }
+        function getClassifiableNames() {
+            if (!classifiableNames) {
+                // Initialize a checker so that all our files are bound.
+                getTypeChecker();
+                classifiableNames = {};
+                for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
+                    var sourceFile = files_2[_i];
+                    ts.copyMap(sourceFile.classifiableNames, classifiableNames);
+                }
+            }
+            return classifiableNames;
+        }
+        function tryReuseStructureFromOldProgram() {
+            if (!oldProgram) {
+                return false;
+            }
+            // check properties that can affect structure of the program or module resolution strategy
+            // if any of these properties has changed - structure cannot be reused
+            var oldOptions = oldProgram.getCompilerOptions();
+            if ((oldOptions.module !== options.module) ||
+                (oldOptions.moduleResolution !== options.moduleResolution) ||
+                (oldOptions.noResolve !== options.noResolve) ||
+                (oldOptions.target !== options.target) ||
+                (oldOptions.noLib !== options.noLib) ||
+                (oldOptions.jsx !== options.jsx) ||
+                (oldOptions.allowJs !== options.allowJs) ||
+                (oldOptions.rootDir !== options.rootDir) ||
+                (oldOptions.configFilePath !== options.configFilePath) ||
+                (oldOptions.baseUrl !== options.baseUrl) ||
+                (oldOptions.maxNodeModuleJsDepth !== options.maxNodeModuleJsDepth) ||
+                !ts.arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
+                !ts.arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
+                !ts.mapIsEqualTo(oldOptions.paths, options.paths)) {
+                return false;
+            }
+            ts.Debug.assert(!oldProgram.structureIsReused);
+            // there is an old program, check if we can reuse its structure
+            var oldRootNames = oldProgram.getRootFileNames();
+            if (!ts.arrayIsEqualTo(oldRootNames, rootNames)) {
+                return false;
+            }
+            if (!ts.arrayIsEqualTo(options.types, oldOptions.types)) {
+                return false;
+            }
+            // check if program source files has changed in the way that can affect structure of the program
+            var newSourceFiles = [];
+            var filePaths = [];
+            var modifiedSourceFiles = [];
+            for (var _i = 0, _a = oldProgram.getSourceFiles(); _i < _a.length; _i++) {
+                var oldSourceFile = _a[_i];
+                var newSourceFile = host.getSourceFileByPath
+                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.path, options.target)
+                    : host.getSourceFile(oldSourceFile.fileName, options.target);
+                if (!newSourceFile) {
+                    return false;
+                }
+                newSourceFile.path = oldSourceFile.path;
+                filePaths.push(newSourceFile.path);
+                if (oldSourceFile !== newSourceFile) {
+                    if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
+                        // value of no-default-lib has changed
+                        // this will affect if default library is injected into the list of files
+                        return false;
+                    }
+                    // check tripleslash references
+                    if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
+                        // tripleslash references has changed
+                        return false;
+                    }
+                    // check imports and module augmentations
+                    collectExternalModuleReferences(newSourceFile);
+                    if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
+                        // imports has changed
+                        return false;
+                    }
+                    if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
+                        // moduleAugmentations has changed
+                        return false;
+                    }
+                    if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
+                        // 'types' references has changed
+                        return false;
+                    }
+                    var newSourceFilePath = ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
+                    if (resolveModuleNamesWorker) {
+                        var moduleNames = ts.map(ts.concatenate(newSourceFile.imports, newSourceFile.moduleAugmentations), getTextOfLiteral);
+                        var resolutions = resolveModuleNamesWorker(moduleNames, newSourceFilePath);
+                        // ensure that module resolution results are still correct
+                        var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, ts.moduleResolutionIsEqualTo);
+                        if (resolutionsChanged) {
+                            return false;
+                        }
+                    }
+                    if (resolveTypeReferenceDirectiveNamesWorker) {
+                        var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (x) { return x.fileName; });
+                        var resolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFilePath);
+                        // ensure that types resolutions are still correct
+                        var resolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, resolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, ts.typeDirectiveIsEqualTo);
+                        if (resolutionsChanged) {
+                            return false;
+                        }
+                    }
+                    // pass the cache of module/types resolutions from the old source file
+                    newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
+                    newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
+                    modifiedSourceFiles.push(newSourceFile);
+                }
+                else {
+                    // file has no changes - use it as is
+                    newSourceFile = oldSourceFile;
+                }
+                // if file has passed all checks it should be safe to reuse it
+                newSourceFiles.push(newSourceFile);
+            }
+            // update fileName -> file mapping
+            for (var i = 0, len = newSourceFiles.length; i < len; i++) {
+                filesByName.set(filePaths[i], newSourceFiles[i]);
+            }
+            files = newSourceFiles;
+            fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
+            for (var _b = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _b < modifiedSourceFiles_1.length; _b++) {
+                var modifiedFile = modifiedSourceFiles_1[_b];
+                fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
+            }
+            resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
+            oldProgram.structureIsReused = true;
+            return true;
+        }
+        function getEmitHost(writeFileCallback) {
+            return {
+                getCanonicalFileName: getCanonicalFileName,
+                getCommonSourceDirectory: program.getCommonSourceDirectory,
+                getCompilerOptions: program.getCompilerOptions,
+                getCurrentDirectory: function () { return currentDirectory; },
+                getNewLine: function () { return host.getNewLine(); },
+                getSourceFile: program.getSourceFile,
+                getSourceFileByPath: program.getSourceFileByPath,
+                getSourceFiles: program.getSourceFiles,
+                isSourceFileFromExternalLibrary: function (file) { return !!ts.lookUp(sourceFilesFoundSearchingNodeModules, file.path); },
+                writeFile: writeFileCallback || (function (fileName, data, writeByteOrderMark, onError, sourceFiles) { return host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles); }),
+                isEmitBlocked: isEmitBlocked
+            };
+        }
+        function getDiagnosticsProducingTypeChecker() {
+            return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ true));
+        }
+        function getTypeChecker() {
+            return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ false));
+        }
+        function emit(sourceFile, writeFileCallback, cancellationToken) {
+            var _this = this;
+            return runWithCancellationToken(function () { return emitWorker(_this, sourceFile, writeFileCallback, cancellationToken); });
+        }
+        function isEmitBlocked(emitFileName) {
+            return hasEmitBlockingDiagnostics.contains(ts.toPath(emitFileName, currentDirectory, getCanonicalFileName));
+        }
+        function emitWorker(program, sourceFile, writeFileCallback, cancellationToken) {
+            var declarationDiagnostics = [];
+            if (options.noEmit) {
+                return { diagnostics: declarationDiagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };
+            }
+            // If the noEmitOnError flag is set, then check if we have any errors so far.  If so,
+            // immediately bail out.  Note that we pass 'undefined' for 'sourceFile' so that we
+            // get any preEmit diagnostics, not just the ones
+            if (options.noEmitOnError) {
+                var diagnostics = program.getOptionsDiagnostics(cancellationToken).concat(program.getSyntacticDiagnostics(sourceFile, cancellationToken), program.getGlobalDiagnostics(cancellationToken), program.getSemanticDiagnostics(sourceFile, cancellationToken));
+                if (diagnostics.length === 0 && program.getCompilerOptions().declaration) {
+                    declarationDiagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken);
+                }
+                if (diagnostics.length > 0 || declarationDiagnostics.length > 0) {
+                    return {
+                        diagnostics: ts.concatenate(diagnostics, declarationDiagnostics),
+                        sourceMaps: undefined,
+                        emittedFiles: undefined,
+                        emitSkipped: true
+                    };
+                }
+            }
+            // Create the emit resolver outside of the "emitTime" tracking code below.  That way
+            // any cost associated with it (like type checking) are appropriate associated with
+            // the type-checking counter.
+            //
+            // If the -out option is specified, we should not pass the source file to getEmitResolver.
+            // This is because in the -out scenario all files need to be emitted, and therefore all
+            // files need to be type checked. And the way to specify that all files need to be type
+            // checked is to not pass the file to getEmitResolver.
+            var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
+            var start = new Date().getTime();
+            var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile);
+            ts.emitTime += new Date().getTime() - start;
+            return emitResult;
+        }
+        function getSourceFile(fileName) {
+            return getSourceFileByPath(ts.toPath(fileName, currentDirectory, getCanonicalFileName));
+        }
+        function getSourceFileByPath(path) {
+            return filesByName.get(path);
+        }
+        function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
+            if (sourceFile) {
+                return getDiagnostics(sourceFile, cancellationToken);
+            }
+            var allDiagnostics = [];
+            ts.forEach(program.getSourceFiles(), function (sourceFile) {
+                if (cancellationToken) {
+                    cancellationToken.throwIfCancellationRequested();
+                }
+                ts.addRange(allDiagnostics, getDiagnostics(sourceFile, cancellationToken));
+            });
+            return ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+        }
+        function getSyntacticDiagnostics(sourceFile, cancellationToken) {
+            return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken);
+        }
+        function getSemanticDiagnostics(sourceFile, cancellationToken) {
+            return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);
+        }
+        function getDeclarationDiagnostics(sourceFile, cancellationToken) {
+            var options = program.getCompilerOptions();
+            // collect diagnostics from the program only once if either no source file was specified or out/outFile is set (bundled emit)
+            if (!sourceFile || options.out || options.outFile) {
+                return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
+            }
+            else {
+                return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken);
+            }
+        }
+        function getSyntacticDiagnosticsForFile(sourceFile, cancellationToken) {
+            return sourceFile.parseDiagnostics;
+        }
+        function runWithCancellationToken(func) {
+            try {
+                return func();
+            }
+            catch (e) {
+                if (e instanceof ts.OperationCanceledException) {
+                    // We were canceled while performing the operation.  Because our type checker
+                    // might be a bad state, we need to throw it away.
+                    //
+                    // Note: we are overly aggressive here.  We do not actually *have* to throw away
+                    // the "noDiagnosticsTypeChecker".  However, for simplicity, i'd like to keep
+                    // the lifetimes of these two TypeCheckers the same.  Also, we generally only
+                    // cancel when the user has made a change anyways.  And, in that case, we (the
+                    // program instance) will get thrown away anyways.  So trying to keep one of
+                    // these type checkers alive doesn't serve much purpose.
+                    noDiagnosticsTypeChecker = undefined;
+                    diagnosticsProducingTypeChecker = undefined;
+                }
+                throw e;
+            }
+        }
+        function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) {
+            return runWithCancellationToken(function () {
+                var typeChecker = getDiagnosticsProducingTypeChecker();
+                ts.Debug.assert(!!sourceFile.bindDiagnostics);
+                var bindDiagnostics = sourceFile.bindDiagnostics;
+                // For JavaScript files, we don't want to report the normal typescript semantic errors.
+                // Instead, we just report errors for using TypeScript-only constructs from within a
+                // JavaScript file.
+                var checkDiagnostics = ts.isSourceFileJavaScript(sourceFile) ?
+                    getJavaScriptSemanticDiagnosticsForFile(sourceFile, cancellationToken) :
+                    typeChecker.getDiagnostics(sourceFile, cancellationToken);
+                var fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);
+                var programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
+                return bindDiagnostics.concat(checkDiagnostics).concat(fileProcessingDiagnosticsInFile).concat(programDiagnosticsInFile);
+            });
+        }
+        function getJavaScriptSemanticDiagnosticsForFile(sourceFile, cancellationToken) {
+            return runWithCancellationToken(function () {
+                var diagnostics = [];
+                walk(sourceFile);
+                return diagnostics;
+                function walk(node) {
+                    if (!node) {
+                        return false;
+                    }
+                    switch (node.kind) {
+                        case 229 /* ImportEqualsDeclaration */:
+                            diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 235 /* ExportAssignment */:
+                            if (node.isExportEquals) {
+                                diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_a_ts_file));
+                                return true;
+                            }
+                            break;
+                        case 221 /* ClassDeclaration */:
+                            var classDeclaration = node;
+                            if (checkModifiers(classDeclaration.modifiers) ||
+                                checkTypeParameters(classDeclaration.typeParameters)) {
+                                return true;
+                            }
+                            break;
+                        case 251 /* HeritageClause */:
+                            var heritageClause = node;
+                            if (heritageClause.token === 106 /* ImplementsKeyword */) {
+                                diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file));
+                                return true;
+                            }
+                            break;
+                        case 222 /* InterfaceDeclaration */:
+                            diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 225 /* ModuleDeclaration */:
+                            diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.module_declarations_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 223 /* TypeAliasDeclaration */:
+                            diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.type_aliases_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                        case 148 /* Constructor */:
+                        case 149 /* GetAccessor */:
+                        case 150 /* SetAccessor */:
+                        case 179 /* FunctionExpression */:
+                        case 220 /* FunctionDeclaration */:
+                        case 180 /* ArrowFunction */:
+                        case 220 /* FunctionDeclaration */:
+                            var functionDeclaration = node;
+                            if (checkModifiers(functionDeclaration.modifiers) ||
+                                checkTypeParameters(functionDeclaration.typeParameters) ||
+                                checkTypeAnnotation(functionDeclaration.type)) {
+                                return true;
+                            }
+                            break;
+                        case 200 /* VariableStatement */:
+                            var variableStatement = node;
+                            if (checkModifiers(variableStatement.modifiers)) {
+                                return true;
+                            }
+                            break;
+                        case 218 /* VariableDeclaration */:
+                            var variableDeclaration = node;
+                            if (checkTypeAnnotation(variableDeclaration.type)) {
+                                return true;
+                            }
+                            break;
+                        case 174 /* CallExpression */:
+                        case 175 /* NewExpression */:
+                            var expression = node;
+                            if (expression.typeArguments && expression.typeArguments.length > 0) {
+                                var start_2 = expression.typeArguments.pos;
+                                diagnostics.push(ts.createFileDiagnostic(sourceFile, start_2, expression.typeArguments.end - start_2, ts.Diagnostics.type_arguments_can_only_be_used_in_a_ts_file));
+                                return true;
+                            }
+                            break;
+                        case 142 /* Parameter */:
+                            var parameter = node;
+                            if (parameter.modifiers) {
+                                var start_3 = parameter.modifiers.pos;
+                                diagnostics.push(ts.createFileDiagnostic(sourceFile, start_3, parameter.modifiers.end - start_3, ts.Diagnostics.parameter_modifiers_can_only_be_used_in_a_ts_file));
+                                return true;
+                            }
+                            if (parameter.questionToken) {
+                                diagnostics.push(ts.createDiagnosticForNode(parameter.questionToken, ts.Diagnostics._0_can_only_be_used_in_a_ts_file, "?"));
+                                return true;
+                            }
+                            if (parameter.type) {
+                                diagnostics.push(ts.createDiagnosticForNode(parameter.type, ts.Diagnostics.types_can_only_be_used_in_a_ts_file));
+                                return true;
+                            }
+                            break;
+                        case 145 /* PropertyDeclaration */:
+                            var propertyDeclaration = node;
+                            if (propertyDeclaration.modifiers) {
+                                for (var _i = 0, _a = propertyDeclaration.modifiers; _i < _a.length; _i++) {
+                                    var modifier = _a[_i];
+                                    if (modifier.kind !== 113 /* StaticKeyword */) {
+                                        diagnostics.push(ts.createDiagnosticForNode(modifier, ts.Diagnostics._0_can_only_be_used_in_a_ts_file, ts.tokenToString(modifier.kind)));
+                                        return true;
+                                    }
+                                }
+                            }
+                            if (checkTypeAnnotation(node.type)) {
+                                return true;
+                            }
+                            break;
+                        case 224 /* EnumDeclaration */:
+                            diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 177 /* TypeAssertionExpression */:
+                            var typeAssertionExpression = node;
+                            diagnostics.push(ts.createDiagnosticForNode(typeAssertionExpression.type, ts.Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file));
+                            return true;
+                        case 143 /* Decorator */:
+                            if (!options.experimentalDecorators) {
+                                diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning));
+                            }
+                            return true;
+                    }
+                    return ts.forEachChild(node, walk);
+                }
+                function checkTypeParameters(typeParameters) {
+                    if (typeParameters) {
+                        var start_4 = typeParameters.pos;
+                        diagnostics.push(ts.createFileDiagnostic(sourceFile, start_4, typeParameters.end - start_4, ts.Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));
+                        return true;
+                    }
+                    return false;
+                }
+                function checkTypeAnnotation(type) {
+                    if (type) {
+                        diagnostics.push(ts.createDiagnosticForNode(type, ts.Diagnostics.types_can_only_be_used_in_a_ts_file));
+                        return true;
+                    }
+                    return false;
+                }
+                function checkModifiers(modifiers) {
+                    if (modifiers) {
+                        for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
+                            var modifier = modifiers_1[_i];
+                            switch (modifier.kind) {
+                                case 112 /* PublicKeyword */:
+                                case 110 /* PrivateKeyword */:
+                                case 111 /* ProtectedKeyword */:
+                                case 128 /* ReadonlyKeyword */:
+                                case 122 /* DeclareKeyword */:
+                                    diagnostics.push(ts.createDiagnosticForNode(modifier, ts.Diagnostics._0_can_only_be_used_in_a_ts_file, ts.tokenToString(modifier.kind)));
+                                    return true;
+                                // These are all legal modifiers.
+                                case 113 /* StaticKeyword */:
+                                case 82 /* ExportKeyword */:
+                                case 74 /* ConstKeyword */:
+                                case 77 /* DefaultKeyword */:
+                                case 115 /* AbstractKeyword */:
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+        }
+        function getDeclarationDiagnosticsWorker(sourceFile, cancellationToken) {
+            return runWithCancellationToken(function () {
+                var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
+                // Don't actually write any files since we're just getting diagnostics.
+                var writeFile = function () { };
+                return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile);
+            });
+        }
+        function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) {
+            return ts.isDeclarationFile(sourceFile) ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
+        }
+        function getOptionsDiagnostics() {
+            var allDiagnostics = [];
+            ts.addRange(allDiagnostics, fileProcessingDiagnostics.getGlobalDiagnostics());
+            ts.addRange(allDiagnostics, programDiagnostics.getGlobalDiagnostics());
+            return ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+        }
+        function getGlobalDiagnostics() {
+            var allDiagnostics = [];
+            ts.addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics());
+            return ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+        }
+        function hasExtension(fileName) {
+            return ts.getBaseFileName(fileName).indexOf(".") >= 0;
+        }
+        function processRootFile(fileName, isDefaultLib) {
+            processSourceFile(ts.normalizePath(fileName), isDefaultLib, /*isReference*/ true);
+        }
+        function fileReferenceIsEqualTo(a, b) {
+            return a.fileName === b.fileName;
+        }
+        function moduleNameIsEqualTo(a, b) {
+            return a.text === b.text;
+        }
+        function getTextOfLiteral(literal) {
+            return literal.text;
+        }
+        function collectExternalModuleReferences(file) {
+            if (file.imports) {
+                return;
+            }
+            var isJavaScriptFile = ts.isSourceFileJavaScript(file);
+            var isExternalModuleFile = ts.isExternalModule(file);
+            var imports;
+            var moduleAugmentations;
+            for (var _i = 0, _a = file.statements; _i < _a.length; _i++) {
+                var node = _a[_i];
+                collectModuleReferences(node, /*inAmbientModule*/ false);
+                if (isJavaScriptFile) {
+                    collectRequireCalls(node);
+                }
+            }
+            file.imports = imports || emptyArray;
+            file.moduleAugmentations = moduleAugmentations || emptyArray;
+            return;
+            function collectModuleReferences(node, inAmbientModule) {
+                switch (node.kind) {
+                    case 230 /* ImportDeclaration */:
+                    case 229 /* ImportEqualsDeclaration */:
+                    case 236 /* ExportDeclaration */:
+                        var moduleNameExpr = ts.getExternalModuleName(node);
+                        if (!moduleNameExpr || moduleNameExpr.kind !== 9 /* StringLiteral */) {
+                            break;
+                        }
+                        if (!moduleNameExpr.text) {
+                            break;
+                        }
+                        // TypeScript 1.0 spec (April 2014): 12.1.6
+                        // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference other external modules
+                        // only through top - level external module names. Relative external module names are not permitted.
+                        if (!inAmbientModule || !ts.isExternalModuleNameRelative(moduleNameExpr.text)) {
+                            (imports || (imports = [])).push(moduleNameExpr);
+                        }
+                        break;
+                    case 225 /* ModuleDeclaration */:
+                        if (ts.isAmbientModule(node) && (inAmbientModule || node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) {
+                            var moduleName = node.name;
+                            // Ambient module declarations can be interpreted as augmentations for some existing external modules.
+                            // This will happen in two cases:
+                            // - if current file is external module then module augmentation is a ambient module declaration defined in the top level scope
+                            // - if current file is not external module then module augmentation is an ambient module declaration with non-relative module name
+                            //   immediately nested in top level ambient module declaration .
+                            if (isExternalModuleFile || (inAmbientModule && !ts.isExternalModuleNameRelative(moduleName.text))) {
+                                (moduleAugmentations || (moduleAugmentations = [])).push(moduleName);
+                            }
+                            else if (!inAmbientModule) {
+                                // An AmbientExternalModuleDeclaration declares an external module.
+                                // This type of declaration is permitted only in the global module.
+                                // The StringLiteral must specify a top - level external module name.
+                                // Relative external module names are not permitted
+                                // NOTE: body of ambient module is always a module block, if it exists
+                                var body = node.body;
+                                if (body) {
+                                    for (var _i = 0, _a = body.statements; _i < _a.length; _i++) {
+                                        var statement = _a[_i];
+                                        collectModuleReferences(statement, /*inAmbientModule*/ true);
+                                    }
+                                }
+                            }
+                        }
+                }
+            }
+            function collectRequireCalls(node) {
+                if (ts.isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
+                    (imports || (imports = [])).push(node.arguments[0]);
+                }
+                else {
+                    ts.forEachChild(node, collectRequireCalls);
+                }
+            }
+        }
+        /**
+          * 'isReference' indicates whether the file was brought in via a reference directive (rather than an import declaration)
+          */
+        function processSourceFile(fileName, isDefaultLib, isReference, refFile, refPos, refEnd) {
+            var diagnosticArgument;
+            var diagnostic;
+            if (hasExtension(fileName)) {
+                if (!options.allowNonTsExtensions && !ts.forEach(supportedExtensions, function (extension) { return ts.fileExtensionIs(host.getCanonicalFileName(fileName), extension); })) {
+                    diagnostic = ts.Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1;
+                    diagnosticArgument = [fileName, "'" + supportedExtensions.join("', '") + "'"];
+                }
+                else if (!findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, isReference, refFile, refPos, refEnd)) {
+                    diagnostic = ts.Diagnostics.File_0_not_found;
+                    diagnosticArgument = [fileName];
+                }
+                else if (refFile && host.getCanonicalFileName(fileName) === host.getCanonicalFileName(refFile.fileName)) {
+                    diagnostic = ts.Diagnostics.A_file_cannot_have_a_reference_to_itself;
+                    diagnosticArgument = [fileName];
+                }
+            }
+            else {
+                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, isReference, refFile, refPos, refEnd);
+                if (!nonTsFile) {
+                    if (options.allowNonTsExtensions) {
+                        diagnostic = ts.Diagnostics.File_0_not_found;
+                        diagnosticArgument = [fileName];
+                    }
+                    else if (!ts.forEach(supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.toPath(fileName + extension, currentDirectory, getCanonicalFileName), isDefaultLib, isReference, refFile, refPos, refEnd); })) {
+                        diagnostic = ts.Diagnostics.File_0_not_found;
+                        fileName += ".ts";
+                        diagnosticArgument = [fileName];
+                    }
+                }
+            }
+            if (diagnostic) {
+                if (refFile !== undefined && refEnd !== undefined && refPos !== undefined) {
+                    fileProcessingDiagnostics.add(ts.createFileDiagnostic.apply(void 0, [refFile, refPos, refEnd - refPos, diagnostic].concat(diagnosticArgument)));
+                }
+                else {
+                    fileProcessingDiagnostics.add(ts.createCompilerDiagnostic.apply(void 0, [diagnostic].concat(diagnosticArgument)));
+                }
+            }
+        }
+        function reportFileNamesDifferOnlyInCasingError(fileName, existingFileName, refFile, refPos, refEnd) {
+            if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) {
+                fileProcessingDiagnostics.add(ts.createFileDiagnostic(refFile, refPos, refEnd - refPos, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, existingFileName));
+            }
+            else {
+                fileProcessingDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, existingFileName));
+            }
+        }
+        // Get source file from normalized fileName
+        function findSourceFile(fileName, path, isDefaultLib, isReference, refFile, refPos, refEnd) {
+            if (filesByName.contains(path)) {
+                var file_1 = filesByName.get(path);
+                // try to check if we've already seen this file but with a different casing in path
+                // NOTE: this only makes sense for case-insensitive file systems
+                if (file_1 && options.forceConsistentCasingInFileNames && ts.getNormalizedAbsolutePath(file_1.fileName, currentDirectory) !== ts.getNormalizedAbsolutePath(fileName, currentDirectory)) {
+                    reportFileNamesDifferOnlyInCasingError(fileName, file_1.fileName, refFile, refPos, refEnd);
+                }
+                // See if we need to reprocess the imports due to prior skipped imports
+                if (file_1 && ts.lookUp(modulesWithElidedImports, file_1.path)) {
+                    if (currentNodeModulesJsDepth < maxNodeModulesJsDepth) {
+                        modulesWithElidedImports[file_1.path] = false;
+                        processImportedModules(file_1, ts.getDirectoryPath(fileName));
+                    }
+                }
+                return file_1;
+            }
+            // We haven't looked for this file, do so now and cache result
+            var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) {
+                if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) {
+                    fileProcessingDiagnostics.add(ts.createFileDiagnostic(refFile, refPos, refEnd - refPos, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage));
+                }
+                else {
+                    fileProcessingDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage));
+                }
+            });
+            filesByName.set(path, file);
+            if (file) {
+                file.path = path;
+                if (host.useCaseSensitiveFileNames()) {
+                    // for case-sensitive file systems check if we've already seen some file with similar filename ignoring case
+                    var existingFile = filesByNameIgnoreCase.get(path);
+                    if (existingFile) {
+                        reportFileNamesDifferOnlyInCasingError(fileName, existingFile.fileName, refFile, refPos, refEnd);
+                    }
+                    else {
+                        filesByNameIgnoreCase.set(path, file);
+                    }
+                }
+                skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib;
+                var basePath = ts.getDirectoryPath(fileName);
+                if (!options.noResolve) {
+                    processReferencedFiles(file, basePath, isDefaultLib);
+                    processTypeReferenceDirectives(file);
+                }
+                // always process imported modules to record module name resolutions
+                processImportedModules(file, basePath);
+                if (isDefaultLib) {
+                    files.unshift(file);
+                }
+                else {
+                    files.push(file);
+                }
+            }
+            return file;
+        }
+        function processReferencedFiles(file, basePath, isDefaultLib) {
+            ts.forEach(file.referencedFiles, function (ref) {
+                var referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
+                processSourceFile(referencedFileName, isDefaultLib, /*isReference*/ true, file, ref.pos, ref.end);
+            });
+        }
+        function processTypeReferenceDirectives(file) {
+            var typeDirectives = ts.map(file.typeReferenceDirectives, function (l) { return l.fileName; });
+            var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file.fileName);
+            for (var i = 0; i < typeDirectives.length; i++) {
+                var ref = file.typeReferenceDirectives[i];
+                var resolvedTypeReferenceDirective = resolutions[i];
+                // store resolved type directive on the file
+                ts.setResolvedTypeReferenceDirective(file, ref.fileName, resolvedTypeReferenceDirective);
+                processTypeReferenceDirective(ref.fileName, resolvedTypeReferenceDirective, file, ref.pos, ref.end);
+            }
+        }
+        function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, refFile, refPos, refEnd) {
+            // If we already found this library as a primary reference - nothing to do
+            var previousResolution = resolvedTypeReferenceDirectives[typeReferenceDirective];
+            if (previousResolution && previousResolution.primary) {
+                return;
+            }
+            var saveResolution = true;
+            if (resolvedTypeReferenceDirective) {
+                if (resolvedTypeReferenceDirective.primary) {
+                    // resolved from the primary path
+                    processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*isReference*/ true, refFile, refPos, refEnd);
+                }
+                else {
+                    // If we already resolved to this file, it must have been a secondary reference. Check file contents
+                    // for sameness and possibly issue an error
+                    if (previousResolution) {
+                        var otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName);
+                        if (otherFileText !== getSourceFile(previousResolution.resolvedFileName).text) {
+                            fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, ts.Diagnostics.Conflicting_library_definitions_for_0_found_at_1_and_2_Copy_the_correct_file_to_the_typings_folder_to_resolve_this_conflict, typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName));
+                        }
+                        // don't overwrite previous resolution result
+                        saveResolution = false;
+                    }
+                    else {
+                        // First resolution of this library
+                        processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*isReference*/ true, refFile, refPos, refEnd);
+                    }
+                }
+            }
+            else {
+                fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, ts.Diagnostics.Cannot_find_type_definition_file_for_0, typeReferenceDirective));
+            }
+            if (saveResolution) {
+                resolvedTypeReferenceDirectives[typeReferenceDirective] = resolvedTypeReferenceDirective;
+            }
+        }
+        function createDiagnostic(refFile, refPos, refEnd, message) {
+            var args = [];
+            for (var _i = 4; _i < arguments.length; _i++) {
+                args[_i - 4] = arguments[_i];
+            }
+            if (refFile === undefined || refPos === undefined || refEnd === undefined) {
+                return ts.createCompilerDiagnostic.apply(void 0, [message].concat(args));
+            }
+            else {
+                return ts.createFileDiagnostic.apply(void 0, [refFile, refPos, refEnd - refPos, message].concat(args));
+            }
+        }
+        function getCanonicalFileName(fileName) {
+            return host.getCanonicalFileName(fileName);
+        }
+        function processImportedModules(file, basePath) {
+            collectExternalModuleReferences(file);
+            if (file.imports.length || file.moduleAugmentations.length) {
+                file.resolvedModules = {};
+                var moduleNames = ts.map(ts.concatenate(file.imports, file.moduleAugmentations), getTextOfLiteral);
+                var resolutions = resolveModuleNamesWorker(moduleNames, ts.getNormalizedAbsolutePath(file.fileName, currentDirectory));
+                for (var i = 0; i < moduleNames.length; i++) {
+                    var resolution = resolutions[i];
+                    ts.setResolvedModule(file, moduleNames[i], resolution);
+                    var resolvedPath = resolution ? ts.toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName) : undefined;
+                    // add file to program only if:
+                    // - resolution was successful
+                    // - noResolve is falsy
+                    // - module name comes from the list of imports
+                    // - it's not a top level JavaScript module that exceeded the search max
+                    var isFromNodeModulesSearch = resolution && resolution.isExternalLibraryImport;
+                    var isJsFileFromNodeModules = isFromNodeModulesSearch && ts.hasJavaScriptFileExtension(resolution.resolvedFileName);
+                    if (isFromNodeModulesSearch) {
+                        sourceFilesFoundSearchingNodeModules[resolvedPath] = true;
+                    }
+                    if (isJsFileFromNodeModules) {
+                        currentNodeModulesJsDepth++;
+                    }
+                    var elideImport = isJsFileFromNodeModules && currentNodeModulesJsDepth > maxNodeModulesJsDepth;
+                    var shouldAddFile = resolution && !options.noResolve && i < file.imports.length && !elideImport;
+                    if (elideImport) {
+                        modulesWithElidedImports[file.path] = true;
+                    }
+                    else if (shouldAddFile) {
+                        findSourceFile(resolution.resolvedFileName, resolvedPath, 
+                        /*isDefaultLib*/ false, /*isReference*/ false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                    }
+                    if (isJsFileFromNodeModules) {
+                        currentNodeModulesJsDepth--;
+                    }
+                }
+            }
+            else {
+                // no imports - drop cached module resolutions
+                file.resolvedModules = undefined;
+            }
+            return;
+        }
+        function computeCommonSourceDirectory(sourceFiles) {
+            var fileNames = [];
+            for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) {
+                var file = sourceFiles_2[_i];
+                if (!file.isDeclarationFile) {
+                    fileNames.push(file.fileName);
+                }
+            }
+            return computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName);
+        }
+        function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) {
+            var allFilesBelongToPath = true;
+            if (sourceFiles) {
+                var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory));
+                for (var _i = 0, sourceFiles_3 = sourceFiles; _i < sourceFiles_3.length; _i++) {
+                    var sourceFile = sourceFiles_3[_i];
+                    if (!ts.isDeclarationFile(sourceFile)) {
+                        var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
+                        if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
+                            programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, sourceFile.fileName, options.rootDir));
+                            allFilesBelongToPath = false;
+                        }
+                    }
+                }
+            }
+            return allFilesBelongToPath;
+        }
+        function verifyCompilerOptions() {
+            if (options.isolatedModules) {
+                if (options.declaration) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "declaration", "isolatedModules"));
+                }
+                if (options.noEmitOnError) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noEmitOnError", "isolatedModules"));
+                }
+                if (options.out) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules"));
+                }
+                if (options.outFile) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules"));
+                }
+            }
+            if (options.inlineSourceMap) {
+                if (options.sourceMap) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap"));
+                }
+                if (options.mapRoot) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap"));
+                }
+            }
+            if (options.paths && options.baseUrl === undefined) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_paths_cannot_be_used_without_specifying_baseUrl_option));
+            }
+            if (options.paths) {
+                for (var key in options.paths) {
+                    if (!ts.hasProperty(options.paths, key)) {
+                        continue;
+                    }
+                    if (!hasZeroOrOneAsteriskCharacter(key)) {
+                        programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, key));
+                    }
+                    if (ts.isArray(options.paths[key])) {
+                        for (var _i = 0, _a = options.paths[key]; _i < _a.length; _i++) {
+                            var subst = _a[_i];
+                            var typeOfSubst = typeof subst;
+                            if (typeOfSubst === "string") {
+                                if (!hasZeroOrOneAsteriskCharacter(subst)) {
+                                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Substitution_0_in_pattern_1_in_can_have_at_most_one_Asterisk_character, subst, key));
+                                }
+                            }
+                            else {
+                                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst));
+                            }
+                        }
+                    }
+                    else {
+                        programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Substitutions_for_pattern_0_should_be_an_array, key));
+                    }
+                }
+            }
+            if (!options.sourceMap && !options.inlineSourceMap) {
+                if (options.inlineSources) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources"));
+                }
+                if (options.sourceRoot) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot"));
+                }
+            }
+            if (options.out && options.outFile) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile"));
+            }
+            if (options.mapRoot && !options.sourceMap) {
+                // Error to specify --mapRoot without --sourcemap
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "mapRoot", "sourceMap"));
+            }
+            if (options.declarationDir) {
+                if (!options.declaration) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "declarationDir", "declaration"));
+                }
+                if (options.out || options.outFile) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile"));
+                }
+            }
+            if (options.lib && options.noLib) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"));
+            }
+            var languageVersion = options.target || 0 /* ES3 */;
+            var outFile = options.outFile || options.out;
+            var firstExternalModuleSourceFile = ts.forEach(files, function (f) { return ts.isExternalModule(f) ? f : undefined; });
+            if (options.isolatedModules) {
+                if (options.module === ts.ModuleKind.None && languageVersion < 2 /* ES6 */) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher));
+                }
+                var firstNonExternalModuleSourceFile = ts.forEach(files, function (f) { return !ts.isExternalModule(f) && !ts.isDeclarationFile(f) ? f : undefined; });
+                if (firstNonExternalModuleSourceFile) {
+                    var span = ts.getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
+                    programDiagnostics.add(ts.createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided));
+                }
+            }
+            else if (firstExternalModuleSourceFile && languageVersion < 2 /* ES6 */ && options.module === ts.ModuleKind.None) {
+                // We cannot use createDiagnosticFromNode because nodes do not have parents yet
+                var span = ts.getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
+                programDiagnostics.add(ts.createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
+            }
+            // Cannot specify module gen that isn't amd or system with --out
+            if (outFile) {
+                if (options.module && !(options.module === ts.ModuleKind.AMD || options.module === ts.ModuleKind.System)) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile"));
+                }
+                else if (options.module === undefined && firstExternalModuleSourceFile) {
+                    var span = ts.getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
+                    programDiagnostics.add(ts.createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile"));
+                }
+            }
+            // there has to be common source directory if user specified --outdir || --sourceRoot
+            // if user specified --mapRoot, there needs to be common source directory if there would be multiple files being emitted
+            if (options.outDir ||
+                options.sourceRoot ||
+                options.mapRoot) {
+                // Precalculate and cache the common source directory
+                var dir = getCommonSourceDirectory();
+                // If we failed to find a good common directory, but outDir is specified and at least one of our files is on a windows drive/URL/other resource, add a failure
+                if (options.outDir && dir === "" && ts.forEach(files, function (file) { return ts.getRootLength(file.fileName) > 1; })) {
+                    programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files));
+                }
+            }
+            if (!options.noEmit && options.allowJs && options.declaration) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "allowJs", "declaration"));
+            }
+            if (options.emitDecoratorMetadata &&
+                !options.experimentalDecorators) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"));
+            }
+            if (options.reactNamespace && !ts.isIdentifier(options.reactNamespace, languageVersion)) {
+                programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace));
+            }
+            // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
+            if (!options.noEmit && !options.suppressOutputPathCheck) {
+                var emitHost = getEmitHost();
+                var emitFilesSeen_1 = ts.createFileMap(!host.useCaseSensitiveFileNames() ? function (key) { return key.toLocaleLowerCase(); } : undefined);
+                ts.forEachExpectedEmitFile(emitHost, function (emitFileNames, sourceFiles, isBundledEmit) {
+                    verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen_1);
+                    verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen_1);
+                });
+            }
+            // Verify that all the emit files are unique and don't overwrite input files
+            function verifyEmitFilePath(emitFileName, emitFilesSeen) {
+                if (emitFileName) {
+                    var emitFilePath = ts.toPath(emitFileName, currentDirectory, getCanonicalFileName);
+                    // Report error if the output overwrites input file
+                    if (filesByName.contains(emitFilePath)) {
+                        createEmitBlockingDiagnostics(emitFileName, emitFilePath, ts.Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file);
+                    }
+                    // Report error if multiple files write into same file
+                    if (emitFilesSeen.contains(emitFilePath)) {
+                        // Already seen the same emit file - report error
+                        createEmitBlockingDiagnostics(emitFileName, emitFilePath, ts.Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files);
+                    }
+                    else {
+                        emitFilesSeen.set(emitFilePath, true);
+                    }
+                }
+            }
+        }
+        function createEmitBlockingDiagnostics(emitFileName, emitFilePath, message) {
+            hasEmitBlockingDiagnostics.set(ts.toPath(emitFileName, currentDirectory, getCanonicalFileName), true);
+            programDiagnostics.add(ts.createCompilerDiagnostic(message, emitFileName));
+        }
+    }
+    ts.createProgram = createProgram;
+})(ts || (ts = {}));
+/// <reference path="sys.ts"/>
+/// <reference path="types.ts"/>
+/// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
+/// <reference path="scanner.ts"/>
+var ts;
+(function (ts) {
+    /* @internal */
+    ts.optionDeclarations = [
+        {
+            name: "charset",
+            type: "string"
+        },
+        {
+            name: "declaration",
+            shortName: "d",
+            type: "boolean",
+            description: ts.Diagnostics.Generates_corresponding_d_ts_file
+        },
+        {
+            name: "declarationDir",
+            type: "string",
+            isFilePath: true,
+            paramType: ts.Diagnostics.DIRECTORY
+        },
+        {
+            name: "diagnostics",
+            type: "boolean"
+        },
+        {
+            name: "emitBOM",
+            type: "boolean"
+        },
+        {
+            name: "help",
+            shortName: "h",
+            type: "boolean",
+            description: ts.Diagnostics.Print_this_message
+        },
+        {
+            name: "help",
+            shortName: "?",
+            type: "boolean"
+        },
+        {
+            name: "init",
+            type: "boolean",
+            description: ts.Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file
+        },
+        {
+            name: "inlineSourceMap",
+            type: "boolean"
+        },
+        {
+            name: "inlineSources",
+            type: "boolean"
+        },
+        {
+            name: "jsx",
+            type: {
+                "preserve": 1 /* Preserve */,
+                "react": 2 /* React */
+            },
+            paramType: ts.Diagnostics.KIND,
+            description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_or_react
+        },
+        {
+            name: "reactNamespace",
+            type: "string",
+            description: ts.Diagnostics.Specify_the_object_invoked_for_createElement_and_spread_when_targeting_react_JSX_emit
+        },
+        {
+            name: "listFiles",
+            type: "boolean"
+        },
+        {
+            name: "locale",
+            type: "string"
+        },
+        {
+            name: "mapRoot",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
+            paramType: ts.Diagnostics.LOCATION
+        },
+        {
+            name: "module",
+            shortName: "m",
+            type: {
+                "none": ts.ModuleKind.None,
+                "commonjs": ts.ModuleKind.CommonJS,
+                "amd": ts.ModuleKind.AMD,
+                "system": ts.ModuleKind.System,
+                "umd": ts.ModuleKind.UMD,
+                "es6": ts.ModuleKind.ES6,
+                "es2015": ts.ModuleKind.ES2015
+            },
+            description: ts.Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
+            paramType: ts.Diagnostics.KIND
+        },
+        {
+            name: "newLine",
+            type: {
+                "crlf": 0 /* CarriageReturnLineFeed */,
+                "lf": 1 /* LineFeed */
+            },
+            description: ts.Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix,
+            paramType: ts.Diagnostics.NEWLINE
+        },
+        {
+            name: "noEmit",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_emit_outputs
+        },
+        {
+            name: "noEmitHelpers",
+            type: "boolean"
+        },
+        {
+            name: "noEmitOnError",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported
+        },
+        {
+            name: "noImplicitAny",
+            type: "boolean",
+            description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type
+        },
+        {
+            name: "noImplicitThis",
+            type: "boolean",
+            description: ts.Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type
+        },
+        {
+            name: "noUnusedLocals",
+            type: "boolean",
+            description: ts.Diagnostics.Report_Errors_on_Unused_Locals
+        },
+        {
+            name: "noUnusedParameters",
+            type: "boolean",
+            description: ts.Diagnostics.Report_Errors_on_Unused_Parameters
+        },
+        {
+            name: "noLib",
+            type: "boolean"
+        },
+        {
+            name: "noResolve",
+            type: "boolean"
+        },
+        {
+            name: "skipDefaultLibCheck",
+            type: "boolean"
+        },
+        {
+            name: "skipLibCheck",
+            type: "boolean",
+            description: ts.Diagnostics.Skip_type_checking_of_declaration_files
+        },
+        {
+            name: "out",
+            type: "string",
+            isFilePath: false,
+            // for correct behaviour, please use outFile
+            paramType: ts.Diagnostics.FILE
+        },
+        {
+            name: "outFile",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file,
+            paramType: ts.Diagnostics.FILE
+        },
+        {
+            name: "outDir",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Redirect_output_structure_to_the_directory,
+            paramType: ts.Diagnostics.DIRECTORY
+        },
+        {
+            name: "preserveConstEnums",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
+        },
+        {
+            name: "pretty",
+            description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
+        {
+            name: "project",
+            shortName: "p",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Compile_the_project_in_the_given_directory,
+            paramType: ts.Diagnostics.DIRECTORY
+        },
+        {
+            name: "removeComments",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_emit_comments_to_output
+        },
+        {
+            name: "rootDir",
+            type: "string",
+            isFilePath: true,
+            paramType: ts.Diagnostics.LOCATION,
+            description: ts.Diagnostics.Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir
+        },
+        {
+            name: "isolatedModules",
+            type: "boolean"
+        },
+        {
+            name: "sourceMap",
+            type: "boolean",
+            description: ts.Diagnostics.Generates_corresponding_map_file
+        },
+        {
+            name: "sourceRoot",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations,
+            paramType: ts.Diagnostics.LOCATION
+        },
+        {
+            name: "suppressExcessPropertyErrors",
+            type: "boolean",
+            description: ts.Diagnostics.Suppress_excess_property_checks_for_object_literals,
+            experimental: true
+        },
+        {
+            name: "suppressImplicitAnyIndexErrors",
+            type: "boolean",
+            description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures
+        },
+        {
+            name: "stripInternal",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation,
+            experimental: true
+        },
+        {
+            name: "target",
+            shortName: "t",
+            type: {
+                "es3": 0 /* ES3 */,
+                "es5": 1 /* ES5 */,
+                "es6": 2 /* ES6 */,
+                "es2015": 2 /* ES2015 */
+            },
+            description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015,
+            paramType: ts.Diagnostics.VERSION
+        },
+        {
+            name: "version",
+            shortName: "v",
+            type: "boolean",
+            description: ts.Diagnostics.Print_the_compiler_s_version
+        },
+        {
+            name: "watch",
+            shortName: "w",
+            type: "boolean",
+            description: ts.Diagnostics.Watch_input_files
+        },
+        {
+            name: "experimentalDecorators",
+            type: "boolean",
+            description: ts.Diagnostics.Enables_experimental_support_for_ES7_decorators
+        },
+        {
+            name: "emitDecoratorMetadata",
+            type: "boolean",
+            experimental: true,
+            description: ts.Diagnostics.Enables_experimental_support_for_emitting_type_metadata_for_decorators
+        },
+        {
+            name: "moduleResolution",
+            type: {
+                "node": ts.ModuleResolutionKind.NodeJs,
+                "classic": ts.ModuleResolutionKind.Classic
+            },
+            description: ts.Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6
+        },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
+        {
+            name: "forceConsistentCasingInFileNames",
+            type: "boolean",
+            description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
+        },
+        {
+            name: "baseUrl",
+            type: "string",
+            isFilePath: true,
+            description: ts.Diagnostics.Base_directory_to_resolve_non_absolute_module_names
+        },
+        {
+            // this option can only be specified in tsconfig.json
+            // use type = object to copy the value as-is
+            name: "paths",
+            type: "object",
+            isTSConfigOnly: true
+        },
+        {
+            // this option can only be specified in tsconfig.json
+            // use type = object to copy the value as-is
+            name: "rootDirs",
+            type: "list",
+            isTSConfigOnly: true,
+            element: {
+                name: "rootDirs",
+                type: "string",
+                isFilePath: true
+            }
+        },
+        {
+            name: "typeRoots",
+            type: "list",
+            element: {
+                name: "typeRoots",
+                type: "string",
+                isFilePath: true
+            }
+        },
+        {
+            name: "types",
+            type: "list",
+            element: {
+                name: "types",
+                type: "string"
+            },
+            description: ts.Diagnostics.Type_declaration_files_to_be_included_in_compilation
+        },
+        {
+            name: "traceResolution",
+            type: "boolean",
+            description: ts.Diagnostics.Enable_tracing_of_the_name_resolution_process
+        },
+        {
+            name: "allowJs",
+            type: "boolean",
+            description: ts.Diagnostics.Allow_javascript_files_to_be_compiled
+        },
+        {
+            name: "allowSyntheticDefaultImports",
+            type: "boolean",
+            description: ts.Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking
+        },
+        {
+            name: "noImplicitUseStrict",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_emit_use_strict_directives_in_module_output
+        },
+        {
+            name: "maxNodeModuleJsDepth",
+            type: "number",
+            description: ts.Diagnostics.The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files
+        },
+        {
+            name: "listEmittedFiles",
+            type: "boolean"
+        },
+        {
+            name: "lib",
+            type: "list",
+            element: {
+                name: "lib",
+                type: {
+                    // JavaScript only
+                    "es5": "lib.es5.d.ts",
+                    "es6": "lib.es2015.d.ts",
+                    "es2015": "lib.es2015.d.ts",
+                    "es7": "lib.es2016.d.ts",
+                    "es2016": "lib.es2016.d.ts",
+                    "es2017": "lib.es2017.d.ts",
+                    // Host only
+                    "dom": "lib.dom.d.ts",
+                    "webworker": "lib.webworker.d.ts",
+                    "scripthost": "lib.scripthost.d.ts",
+                    // ES2015 Or ESNext By-feature options
+                    "es2015.core": "lib.es2015.core.d.ts",
+                    "es2015.collection": "lib.es2015.collection.d.ts",
+                    "es2015.generator": "lib.es2015.generator.d.ts",
+                    "es2015.iterable": "lib.es2015.iterable.d.ts",
+                    "es2015.promise": "lib.es2015.promise.d.ts",
+                    "es2015.proxy": "lib.es2015.proxy.d.ts",
+                    "es2015.reflect": "lib.es2015.reflect.d.ts",
+                    "es2015.symbol": "lib.es2015.symbol.d.ts",
+                    "es2015.symbol.wellknown": "lib.es2015.symbol.wellknown.d.ts",
+                    "es2016.array.include": "lib.es2016.array.include.d.ts",
+                    "es2017.object": "lib.es2017.object.d.ts",
+                    "es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts"
+                }
+            },
+            description: ts.Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon
+        },
+        {
+            name: "disableSizeLimit",
+            type: "boolean"
+        },
+        {
+            name: "strictNullChecks",
+            type: "boolean",
+            description: ts.Diagnostics.Enable_strict_null_checks
+        }
+    ];
+    /* @internal */
+    ts.typingOptionDeclarations = [
+        {
+            name: "enableAutoDiscovery",
+            type: "boolean"
+        },
+        {
+            name: "include",
+            type: "list",
+            element: {
+                name: "include",
+                type: "string"
+            }
+        },
+        {
+            name: "exclude",
+            type: "list",
+            element: {
+                name: "exclude",
+                type: "string"
+            }
+        }
+    ];
+    var optionNameMapCache;
+    /* @internal */
+    function getOptionNameMap() {
+        if (optionNameMapCache) {
+            return optionNameMapCache;
+        }
+        var optionNameMap = {};
+        var shortOptionNames = {};
+        ts.forEach(ts.optionDeclarations, function (option) {
+            optionNameMap[option.name.toLowerCase()] = option;
+            if (option.shortName) {
+                shortOptionNames[option.shortName] = option.name;
+            }
+        });
+        optionNameMapCache = { optionNameMap: optionNameMap, shortOptionNames: shortOptionNames };
+        return optionNameMapCache;
+    }
+    ts.getOptionNameMap = getOptionNameMap;
+    /* @internal */
+    function createCompilerDiagnosticForInvalidCustomType(opt) {
+        var namesOfType = [];
+        ts.forEachKey(opt.type, function (key) {
+            namesOfType.push(" '" + key + "'");
+        });
+        return ts.createCompilerDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--" + opt.name, namesOfType);
+    }
+    ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType;
+    /* @internal */
+    function parseCustomTypeOption(opt, value, errors) {
+        var key = trimString((value || "")).toLowerCase();
+        var map = opt.type;
+        if (ts.hasProperty(map, key)) {
+            return map[key];
+        }
+        else {
+            errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
+        }
+    }
+    ts.parseCustomTypeOption = parseCustomTypeOption;
+    /* @internal */
+    function parseListTypeOption(opt, value, errors) {
+        if (value === void 0) { value = ""; }
+        value = trimString(value);
+        if (ts.startsWith(value, "-")) {
+            return undefined;
+        }
+        if (value === "") {
+            return [];
+        }
+        var values = value.split(",");
+        switch (opt.element.type) {
+            case "number":
+                return ts.map(values, parseInt);
+            case "string":
+                return ts.map(values, function (v) { return v || ""; });
+            default:
+                return ts.filter(ts.map(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); }), function (v) { return !!v; });
+        }
+    }
+    ts.parseListTypeOption = parseListTypeOption;
+    /* @internal */
+    function parseCommandLine(commandLine, readFile) {
+        var options = {};
+        var fileNames = [];
+        var errors = [];
+        var _a = getOptionNameMap(), optionNameMap = _a.optionNameMap, shortOptionNames = _a.shortOptionNames;
+        parseStrings(commandLine);
+        return {
+            options: options,
+            fileNames: fileNames,
+            errors: errors
+        };
+        function parseStrings(args) {
+            var i = 0;
+            while (i < args.length) {
+                var s = args[i];
+                i++;
+                if (s.charCodeAt(0) === 64 /* at */) {
+                    parseResponseFile(s.slice(1));
+                }
+                else if (s.charCodeAt(0) === 45 /* minus */) {
+                    s = s.slice(s.charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase();
+                    // Try to translate short option names to their full equivalents.
+                    if (ts.hasProperty(shortOptionNames, s)) {
+                        s = shortOptionNames[s];
+                    }
+                    if (ts.hasProperty(optionNameMap, s)) {
+                        var opt = optionNameMap[s];
+                        if (opt.isTSConfigOnly) {
+                            errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));
+                        }
+                        else {
+                            // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).
+                            if (!args[i] && opt.type !== "boolean") {
+                                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_expects_an_argument, opt.name));
+                            }
+                            switch (opt.type) {
+                                case "number":
+                                    options[opt.name] = parseInt(args[i]);
+                                    i++;
+                                    break;
+                                case "boolean":
+                                    options[opt.name] = true;
+                                    break;
+                                case "string":
+                                    options[opt.name] = args[i] || "";
+                                    i++;
+                                    break;
+                                case "list":
+                                    var result = parseListTypeOption(opt, args[i], errors);
+                                    options[opt.name] = result || [];
+                                    if (result) {
+                                        i++;
+                                    }
+                                    break;
+                                // If not a primitive, the possible types are specified in what is effectively a map of options.
+                                default:
+                                    options[opt.name] = parseCustomTypeOption(opt, args[i], errors);
+                                    i++;
+                                    break;
+                            }
+                        }
+                    }
+                    else {
+                        errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_compiler_option_0, s));
+                    }
+                }
+                else {
+                    fileNames.push(s);
+                }
+            }
+        }
+        function parseResponseFile(fileName) {
+            var text = readFile ? readFile(fileName) : ts.sys.readFile(fileName);
+            if (!text) {
+                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, fileName));
+                return;
+            }
+            var args = [];
+            var pos = 0;
+            while (true) {
+                while (pos < text.length && text.charCodeAt(pos) <= 32 /* space */)
+                    pos++;
+                if (pos >= text.length)
+                    break;
+                var start = pos;
+                if (text.charCodeAt(start) === 34 /* doubleQuote */) {
+                    pos++;
+                    while (pos < text.length && text.charCodeAt(pos) !== 34 /* doubleQuote */)
+                        pos++;
+                    if (pos < text.length) {
+                        args.push(text.substring(start + 1, pos));
+                        pos++;
+                    }
+                    else {
+                        errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
+                    }
+                }
+                else {
+                    while (text.charCodeAt(pos) > 32 /* space */)
+                        pos++;
+                    args.push(text.substring(start, pos));
+                }
+            }
+            parseStrings(args);
+        }
+    }
+    ts.parseCommandLine = parseCommandLine;
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName, readFile) {
+        var text = "";
+        try {
+            text = readFile(fileName);
+        }
+        catch (e) {
+            return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message) };
+        }
+        return parseConfigFileTextToJson(fileName, text);
+    }
+    ts.readConfigFile = readConfigFile;
+    /**
+      * Parse the text of the tsconfig.json file
+      * @param fileName The path to the config file
+      * @param jsonText The text of the config file
+      */
+    function parseConfigFileTextToJson(fileName, jsonText) {
+        try {
+            var jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
+        }
+        catch (e) {
+            return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
+        }
+    }
+    ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+    /**
+     * Remove the comments from a json like text.
+     * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
+     *
+     * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
+     */
+    function removeComments(jsonText) {
+        var output = "";
+        var scanner = ts.createScanner(1 /* ES5 */, /* skipTrivia */ false, 0 /* Standard */, jsonText);
+        var token;
+        while ((token = scanner.scan()) !== 1 /* EndOfFileToken */) {
+            switch (token) {
+                case 2 /* SingleLineCommentTrivia */:
+                case 3 /* MultiLineCommentTrivia */:
+                    // replace comments with whitespace to preserve original character positions
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
+    // Skip over any minified JavaScript files (ending in ".min.js")
+    // Skip over dotted files and folders as well
+    var ignoreFileNamePattern = /(\.min\.js$)|([\\/]\.[\w.])/;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param host Instance of ParseConfigHost used to enumerate files in folder.
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName) {
+        if (existingOptions === void 0) { existingOptions = {}; }
+        var errors = [];
+        var compilerOptions = convertCompilerOptionsFromJsonWorker(json["compilerOptions"], basePath, errors, configFileName);
+        var options = ts.extend(existingOptions, compilerOptions);
+        var typingOptions = convertTypingOptionsFromJsonWorker(json["typingOptions"], basePath, errors, configFileName);
+        options.configFilePath = configFileName;
+        var _a = getFileNames(errors), fileNames = _a.fileNames, wildcardDirectories = _a.wildcardDirectories;
+        return {
+            options: options,
+            fileNames: fileNames,
+            typingOptions: typingOptions,
+            raw: json,
+            errors: errors,
+            wildcardDirectories: wildcardDirectories
+        };
+        function getFileNames(errors) {
+            var fileNames;
+            if (ts.hasProperty(json, "files")) {
+                if (ts.isArray(json["files"])) {
+                    fileNames = json["files"];
+                }
+                else {
+                    errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array"));
+                }
+            }
+            var includeSpecs;
+            if (ts.hasProperty(json, "include")) {
+                if (ts.isArray(json["include"])) {
+                    includeSpecs = json["include"];
+                }
+                else {
+                    errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "include", "Array"));
+                }
+            }
+            var excludeSpecs;
+            if (ts.hasProperty(json, "exclude")) {
+                if (ts.isArray(json["exclude"])) {
+                    excludeSpecs = json["exclude"];
+                }
+                else {
+                    errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "exclude", "Array"));
+                }
+            }
+            else if (ts.hasProperty(json, "excludes")) {
+                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
+            }
+            else {
+                // By default, exclude common package folders
+                excludeSpecs = ["node_modules", "bower_components", "jspm_packages"];
+            }
+            // Always exclude the output directory unless explicitly included
+            var outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];
+            if (outDir) {
+                excludeSpecs.push(outDir);
+            }
+            if (fileNames === undefined && includeSpecs === undefined) {
+                includeSpecs = ["**/*"];
+            }
+            return matchFileNames(fileNames, includeSpecs, excludeSpecs, basePath, options, host, errors);
+        }
+    }
+    ts.parseJsonConfigFileContent = parseJsonConfigFileContent;
+    function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) {
+        var errors = [];
+        var options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
+        return { options: options, errors: errors };
+    }
+    ts.convertCompilerOptionsFromJson = convertCompilerOptionsFromJson;
+    function convertTypingOptionsFromJson(jsonOptions, basePath, configFileName) {
+        var errors = [];
+        var options = convertTypingOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
+        return { options: options, errors: errors };
+    }
+    ts.convertTypingOptionsFromJson = convertTypingOptionsFromJson;
+    function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
+        var options = ts.getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true } : {};
+        convertOptionsFromJson(ts.optionDeclarations, jsonOptions, basePath, options, ts.Diagnostics.Unknown_compiler_option_0, errors);
+        return options;
+    }
+    function convertTypingOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
+        var options = ts.getBaseFileName(configFileName) === "jsconfig.json"
+            ? { enableAutoDiscovery: true, include: [], exclude: [] }
+            : { enableAutoDiscovery: false, include: [], exclude: [] };
+        convertOptionsFromJson(ts.typingOptionDeclarations, jsonOptions, basePath, options, ts.Diagnostics.Unknown_typing_option_0, errors);
+        return options;
+    }
+    function convertOptionsFromJson(optionDeclarations, jsonOptions, basePath, defaultOptions, diagnosticMessage, errors) {
+        if (!jsonOptions) {
+            return;
+        }
+        var optionNameMap = ts.arrayToMap(optionDeclarations, function (opt) { return opt.name; });
+        for (var id in jsonOptions) {
+            if (ts.hasProperty(optionNameMap, id)) {
+                var opt = optionNameMap[id];
+                defaultOptions[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
+            }
+            else {
+                errors.push(ts.createCompilerDiagnostic(diagnosticMessage, id));
+            }
+        }
+    }
+    function convertJsonOption(opt, value, basePath, errors) {
+        var optType = opt.type;
+        var expectedType = typeof optType === "string" ? optType : "string";
+        if (optType === "list" && ts.isArray(value)) {
+            return convertJsonOptionOfListType(opt, value, basePath, errors);
+        }
+        else if (typeof value === expectedType) {
+            if (typeof optType !== "string") {
+                return convertJsonOptionOfCustomType(opt, value, errors);
+            }
+            else {
+                if (opt.isFilePath) {
+                    value = ts.normalizePath(ts.combinePaths(basePath, value));
+                    if (value === "") {
+                        value = ".";
+                    }
+                }
+            }
+            return value;
+        }
+        else {
+            errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, expectedType));
+        }
+    }
+    function convertJsonOptionOfCustomType(opt, value, errors) {
+        var key = value.toLowerCase();
+        if (ts.hasProperty(opt.type, key)) {
+            return opt.type[key];
+        }
+        else {
+            errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
+        }
+    }
+    function convertJsonOptionOfListType(option, values, basePath, errors) {
+        return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; });
+    }
+    function trimString(s) {
+        return typeof s.trim === "function" ? s.trim() : s.replace(/^[\s]+|[\s]+$/g, "");
+    }
+    /**
+     * Tests for a path that ends in a recursive directory wildcard.
+     * Matches **, \**, **\, and \**\, but not a**b.
+     *
+     * NOTE: used \ in place of / above to avoid issues with multiline comments.
+     *
+     * Breakdown:
+     *  (^|\/)      # matches either the beginning of the string or a directory separator.
+     *  \*\*        # matches the recursive directory wildcard "**".
+     *  \/?$        # matches an optional trailing directory separator at the end of the string.
+     */
+    var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
+    /**
+     * Tests for a path with multiple recursive directory wildcards.
+     * Matches **\** and **\a\**, but not **\a**b.
+     *
+     * NOTE: used \ in place of / above to avoid issues with multiline comments.
+     *
+     * Breakdown:
+     *  (^|\/)      # matches either the beginning of the string or a directory separator.
+     *  \*\*\/      # matches a recursive directory wildcard "**" followed by a directory separator.
+     *  (.*\/)?     # optionally matches any number of characters followed by a directory separator.
+     *  \*\*        # matches a recursive directory wildcard "**"
+     *  ($|\/)      # matches either the end of the string or a directory separator.
+     */
+    var invalidMultipleRecursionPatterns = /(^|\/)\*\*\/(.*\/)?\*\*($|\/)/;
+    /**
+     * Tests for a path where .. appears after a recursive directory wildcard.
+     * Matches **\..\*, **\a\..\*, and **\.., but not ..\**\*
+     *
+     * NOTE: used \ in place of / above to avoid issues with multiline comments.
+     *
+     * Breakdown:
+     *  (^|\/)      # matches either the beginning of the string or a directory separator.
+     *  \*\*\/      # matches a recursive directory wildcard "**" followed by a directory separator.
+     *  (.*\/)?     # optionally matches any number of characters followed by a directory separator.
+     *  \.\.        # matches a parent directory path component ".."
+     *  ($|\/)      # matches either the end of the string or a directory separator.
+     */
+    var invalidDotDotAfterRecursiveWildcardPattern = /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/;
+    /**
+     * Tests for a path containing a wildcard character in a directory component of the path.
+     * Matches \*\, \?\, and \a*b\, but not \a\ or \a\*.
+     *
+     * NOTE: used \ in place of / above to avoid issues with multiline comments.
+     *
+     * Breakdown:
+     *  \/          # matches a directory separator.
+     *  [^/]*?      # matches any number of characters excluding directory separators (non-greedy).
+     *  [*?]        # matches either a wildcard character (* or ?)
+     *  [^/]*       # matches any number of characters excluding directory separators (greedy).
+     *  \/          # matches a directory separator.
+     */
+    var watchRecursivePattern = /\/[^/]*?[*?][^/]*\//;
+    /**
+     * Matches the portion of a wildcard path that does not contain wildcards.
+     * Matches \a of \a\*, or \a\b\c of \a\b\c\?\d.
+     *
+     * NOTE: used \ in place of / above to avoid issues with multiline comments.
+     *
+     * Breakdown:
+     *  ^                   # matches the beginning of the string
+     *  [^*?]*              # matches any number of non-wildcard characters
+     *  (?=\/[^/]*[*?])     # lookahead that matches a directory separator followed by
+     *                      # a path component that contains at least one wildcard character (* or ?).
+     */
+    var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
+    /**
+     * Expands an array of file specifications.
+     *
+     * @param fileNames The literal file names to include.
+     * @param include The wildcard file specifications to include.
+     * @param exclude The wildcard file specifications to exclude.
+     * @param basePath The base path for any relative file specifications.
+     * @param options Compiler options.
+     * @param host The host used to resolve files and directories.
+     * @param errors An array for diagnostic reporting.
+     */
+    function matchFileNames(fileNames, include, exclude, basePath, options, host, errors) {
+        basePath = ts.normalizePath(basePath);
+        // The exclude spec list is converted into a regular expression, which allows us to quickly
+        // test whether a file or directory should be excluded before recursively traversing the
+        // file system.
+        var keyMapper = host.useCaseSensitiveFileNames ? caseSensitiveKeyMapper : caseInsensitiveKeyMapper;
+        // Literal file names (provided via the "files" array in tsconfig.json) are stored in a
+        // file map with a possibly case insensitive key. We use this map later when when including
+        // wildcard paths.
+        var literalFileMap = {};
+        // Wildcard paths (provided via the "includes" array in tsconfig.json) are stored in a
+        // file map with a possibly case insensitive key. We use this map to store paths matched
+        // via wildcard, and to handle extension priority.
+        var wildcardFileMap = {};
+        if (include) {
+            include = validateSpecs(include, errors, /*allowTrailingRecursion*/ false);
+        }
+        if (exclude) {
+            exclude = validateSpecs(exclude, errors, /*allowTrailingRecursion*/ true);
+        }
+        // Wildcard directories (provided as part of a wildcard path) are stored in a
+        // file map that marks whether it was a regular wildcard match (with a `*` or `?` token),
+        // or a recursive directory. This information is used by filesystem watchers to monitor for
+        // new entries in these paths.
+        var wildcardDirectories = getWildcardDirectories(include, exclude, basePath, host.useCaseSensitiveFileNames);
+        // Rather than requery this for each file and filespec, we query the supported extensions
+        // once and store it on the expansion context.
+        var supportedExtensions = ts.getSupportedExtensions(options);
+        // Literal files are always included verbatim. An "include" or "exclude" specification cannot
+        // remove a literal file.
+        if (fileNames) {
+            for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
+                var fileName = fileNames_1[_i];
+                var file = ts.combinePaths(basePath, fileName);
+                literalFileMap[keyMapper(file)] = file;
+            }
+        }
+        if (include && include.length > 0) {
+            for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensions, exclude, include); _a < _b.length; _a++) {
+                var file = _b[_a];
+                // If we have already included a literal or wildcard path with a
+                // higher priority extension, we should skip this file.
+                //
+                // This handles cases where we may encounter both <file>.ts and
+                // <file>.d.ts (or <file>.js if "allowJs" is enabled) in the same
+                // directory when they are compilation outputs.
+                if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
+                    continue;
+                }
+                if (ignoreFileNamePattern.test(file)) {
+                    continue;
+                }
+                // We may have included a wildcard path with a lower priority
+                // extension due to the user-defined order of entries in the
+                // "include" array. If there is a lower priority extension in the
+                // same directory, we should remove it.
+                removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
+                var key = keyMapper(file);
+                if (!ts.hasProperty(literalFileMap, key) && !ts.hasProperty(wildcardFileMap, key)) {
+                    wildcardFileMap[key] = file;
+                }
+            }
+        }
+        var literalFiles = ts.reduceProperties(literalFileMap, addFileToOutput, []);
+        var wildcardFiles = ts.reduceProperties(wildcardFileMap, addFileToOutput, []);
+        wildcardFiles.sort(host.useCaseSensitiveFileNames ? ts.compareStrings : ts.compareStringsCaseInsensitive);
+        return {
+            fileNames: literalFiles.concat(wildcardFiles),
+            wildcardDirectories: wildcardDirectories
+        };
+    }
+    function validateSpecs(specs, errors, allowTrailingRecursion) {
+        var validSpecs = [];
+        for (var _i = 0, specs_2 = specs; _i < specs_2.length; _i++) {
+            var spec = specs_2[_i];
+            if (!allowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
+                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec));
+            }
+            else if (invalidMultipleRecursionPatterns.test(spec)) {
+                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_specification_cannot_contain_multiple_recursive_directory_wildcards_Asterisk_Asterisk_Colon_0, spec));
+            }
+            else if (invalidDotDotAfterRecursiveWildcardPattern.test(spec)) {
+                errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec));
+            }
+            else {
+                validSpecs.push(spec);
+            }
+        }
+        return validSpecs;
+    }
+    /**
+     * Gets directories in a set of include patterns that should be watched for changes.
+     */
+    function getWildcardDirectories(include, exclude, path, useCaseSensitiveFileNames) {
+        // We watch a directory recursively if it contains a wildcard anywhere in a directory segment
+        // of the pattern:
+        //
+        //  /a/b/**/d   - Watch /a/b recursively to catch changes to any d in any subfolder recursively
+        //  /a/b/*/d    - Watch /a/b recursively to catch any d in any immediate subfolder, even if a new subfolder is added
+        //
+        // We watch a directory without recursion if it contains a wildcard in the file segment of
+        // the pattern:
+        //
+        //  /a/b/*      - Watch /a/b directly to catch any new file
+        //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
+        var rawExcludeRegex = ts.getRegularExpressionForWildcard(exclude, path, "exclude");
+        var excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
+        var wildcardDirectories = {};
+        if (include !== undefined) {
+            var recursiveKeys = [];
+            for (var _i = 0, include_1 = include; _i < include_1.length; _i++) {
+                var file = include_1[_i];
+                var name_35 = ts.normalizePath(ts.combinePaths(path, file));
+                if (excludeRegex && excludeRegex.test(name_35)) {
+                    continue;
+                }
+                var match = wildcardDirectoryPattern.exec(name_35);
+                if (match) {
+                    var key = useCaseSensitiveFileNames ? match[0] : match[0].toLowerCase();
+                    var flags = watchRecursivePattern.test(name_35) ? 1 /* Recursive */ : 0 /* None */;
+                    var existingFlags = ts.getProperty(wildcardDirectories, key);
+                    if (existingFlags === undefined || existingFlags < flags) {
+                        wildcardDirectories[key] = flags;
+                        if (flags === 1 /* Recursive */) {
+                            recursiveKeys.push(key);
+                        }
+                    }
+                }
+            }
+            // Remove any subpaths under an existing recursively watched directory.
+            for (var key in wildcardDirectories) {
+                if (ts.hasProperty(wildcardDirectories, key)) {
+                    for (var _a = 0, recursiveKeys_1 = recursiveKeys; _a < recursiveKeys_1.length; _a++) {
+                        var recursiveKey = recursiveKeys_1[_a];
+                        if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
+                            delete wildcardDirectories[key];
+                        }
+                    }
+                }
+            }
+        }
+        return wildcardDirectories;
+    }
+    /**
+     * Determines whether a literal or wildcard file has already been included that has a higher
+     * extension priority.
+     *
+     * @param file The path to the file.
+     * @param extensionPriority The priority of the extension.
+     * @param context The expansion context.
+     */
+    function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
+        var extensionPriority = ts.getExtensionPriority(file, extensions);
+        var adjustedExtensionPriority = ts.adjustExtensionPriority(extensionPriority);
+        for (var i = 0 /* Highest */; i < adjustedExtensionPriority; i++) {
+            var higherPriorityExtension = extensions[i];
+            var higherPriorityPath = keyMapper(ts.changeExtension(file, higherPriorityExtension));
+            if (ts.hasProperty(literalFiles, higherPriorityPath) || ts.hasProperty(wildcardFiles, higherPriorityPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Removes files included via wildcard expansion with a lower extension priority that have
+     * already been included.
+     *
+     * @param file The path to the file.
+     * @param extensionPriority The priority of the extension.
+     * @param context The expansion context.
+     */
+    function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
+        var extensionPriority = ts.getExtensionPriority(file, extensions);
+        var nextExtensionPriority = ts.getNextLowestExtensionPriority(extensionPriority);
+        for (var i = nextExtensionPriority; i < extensions.length; i++) {
+            var lowerPriorityExtension = extensions[i];
+            var lowerPriorityPath = keyMapper(ts.changeExtension(file, lowerPriorityExtension));
+            delete wildcardFiles[lowerPriorityPath];
+        }
+    }
+    /**
+     * Adds a file to an array of files.
+     *
+     * @param output The output array.
+     * @param file The file path.
+     */
+    function addFileToOutput(output, file) {
+        output.push(file);
+        return output;
+    }
+    /**
+     * Gets a case sensitive key.
+     *
+     * @param key The original key.
+     */
+    function caseSensitiveKeyMapper(key) {
+        return key;
+    }
+    /**
+     * Gets a case insensitive key.
+     *
+     * @param key The original key.
+     */
+    function caseInsensitiveKeyMapper(key) {
+        return key.toLowerCase();
+    }
+})(ts || (ts = {}));
+/* @internal */
+var ts;
+(function (ts) {
+    var OutliningElementsCollector;
+    (function (OutliningElementsCollector) {
+        function collectElements(sourceFile) {
+            var elements = [];
+            var collapseText = "...";
+            function addOutliningSpan(hintSpanNode, startElement, endElement, autoCollapse) {
+                if (hintSpanNode && startElement && endElement) {
+                    var span = {
+                        textSpan: ts.createTextSpanFromBounds(startElement.pos, endElement.end),
+                        hintSpan: ts.createTextSpanFromBounds(hintSpanNode.getStart(), hintSpanNode.end),
+                        bannerText: collapseText,
+                        autoCollapse: autoCollapse
+                    };
+                    elements.push(span);
+                }
+            }
+            function addOutliningSpanComments(commentSpan, autoCollapse) {
+                if (commentSpan) {
+                    var span = {
+                        textSpan: ts.createTextSpanFromBounds(commentSpan.pos, commentSpan.end),
+                        hintSpan: ts.createTextSpanFromBounds(commentSpan.pos, commentSpan.end),
+                        bannerText: collapseText,
+                        autoCollapse: autoCollapse
+                    };
+                    elements.push(span);
+                }
+            }
+            function addOutliningForLeadingCommentsForNode(n) {
+                var comments = ts.getLeadingCommentRangesOfNode(n, sourceFile);
+                if (comments) {
+                    var firstSingleLineCommentStart = -1;
+                    var lastSingleLineCommentEnd = -1;
+                    var isFirstSingleLineComment = true;
+                    var singleLineCommentCount = 0;
+                    for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
+                        var currentComment = comments_2[_i];
+                        // For single line comments, combine consecutive ones (2 or more) into
+                        // a single span from the start of the first till the end of the last
+                        if (currentComment.kind === 2 /* SingleLineCommentTrivia */) {
+                            if (isFirstSingleLineComment) {
+                                firstSingleLineCommentStart = currentComment.pos;
+                            }
+                            isFirstSingleLineComment = false;
+                            lastSingleLineCommentEnd = currentComment.end;
+                            singleLineCommentCount++;
+                        }
+                        else if (currentComment.kind === 3 /* MultiLineCommentTrivia */) {
+                            combineAndAddMultipleSingleLineComments(singleLineCommentCount, firstSingleLineCommentStart, lastSingleLineCommentEnd);
+                            addOutliningSpanComments(currentComment, /*autoCollapse*/ false);
+                            singleLineCommentCount = 0;
+                            lastSingleLineCommentEnd = -1;
+                            isFirstSingleLineComment = true;
+                        }
+                    }
+                    combineAndAddMultipleSingleLineComments(singleLineCommentCount, firstSingleLineCommentStart, lastSingleLineCommentEnd);
+                }
+            }
+            function combineAndAddMultipleSingleLineComments(count, start, end) {
+                // Only outline spans of two or more consecutive single line comments
+                if (count > 1) {
+                    var multipleSingleLineComments = {
+                        pos: start,
+                        end: end,
+                        kind: 2 /* SingleLineCommentTrivia */
+                    };
+                    addOutliningSpanComments(multipleSingleLineComments, /*autoCollapse*/ false);
+                }
+            }
+            function autoCollapse(node) {
+                return ts.isFunctionBlock(node) && node.parent.kind !== 180 /* ArrowFunction */;
+            }
+            var depth = 0;
+            var maxDepth = 20;
+            function walk(n) {
+                if (depth > maxDepth) {
+                    return;
+                }
+                if (ts.isDeclaration(n)) {
+                    addOutliningForLeadingCommentsForNode(n);
+                }
+                switch (n.kind) {
+                    case 199 /* Block */:
+                        if (!ts.isFunctionBlock(n)) {
+                            var parent_15 = n.parent;
+                            var openBrace = ts.findChildOfKind(n, 15 /* OpenBraceToken */, sourceFile);
+                            var closeBrace = ts.findChildOfKind(n, 16 /* CloseBraceToken */, sourceFile);
+                            // Check if the block is standalone, or 'attached' to some parent statement.
+                            // If the latter, we want to collapse the block, but consider its hint span
+                            // to be the entire span of the parent.
+                            if (parent_15.kind === 204 /* DoStatement */ ||
+                                parent_15.kind === 207 /* ForInStatement */ ||
+                                parent_15.kind === 208 /* ForOfStatement */ ||
+                                parent_15.kind === 206 /* ForStatement */ ||
+                                parent_15.kind === 203 /* IfStatement */ ||
+                                parent_15.kind === 205 /* WhileStatement */ ||
+                                parent_15.kind === 212 /* WithStatement */ ||
+                                parent_15.kind === 252 /* CatchClause */) {
+                                addOutliningSpan(parent_15, openBrace, closeBrace, autoCollapse(n));
+                                break;
+                            }
+                            if (parent_15.kind === 216 /* TryStatement */) {
+                                // Could be the try-block, or the finally-block.
+                                var tryStatement = parent_15;
+                                if (tryStatement.tryBlock === n) {
+                                    addOutliningSpan(parent_15, openBrace, closeBrace, autoCollapse(n));
+                                    break;
+                                }
+                                else if (tryStatement.finallyBlock === n) {
+                                    var finallyKeyword = ts.findChildOfKind(tryStatement, 85 /* FinallyKeyword */, sourceFile);
+                                    if (finallyKeyword) {
+                                        addOutliningSpan(finallyKeyword, openBrace, closeBrace, autoCollapse(n));
+                                        break;
+                                    }
+                                }
+                            }
+                            // Block was a standalone block.  In this case we want to only collapse
+                            // the span of the block, independent of any parent span.
+                            var span = ts.createTextSpanFromBounds(n.getStart(), n.end);
+                            elements.push({
+                                textSpan: span,
+                                hintSpan: span,
+                                bannerText: collapseText,
+                                autoCollapse: autoCollapse(n)
+                            });
+                            break;
+                        }
+                    // Fallthrough.
+                    case 226 /* ModuleBlock */: {
+                        var openBrace = ts.findChildOfKind(n, 15 /* OpenBraceToken */, sourceFile);
+                        var closeBrace = ts.findChildOfKind(n, 16 /* CloseBraceToken */, sourceFile);
+                        addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n));
+                        break;
+                    }
+                    case 221 /* ClassDeclaration */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 171 /* ObjectLiteralExpression */:
+                    case 227 /* CaseBlock */: {
+                        var openBrace = ts.findChildOfKind(n, 15 /* OpenBraceToken */, sourceFile);
+                        var closeBrace = ts.findChildOfKind(n, 16 /* CloseBraceToken */, sourceFile);
+                        addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n));
+                        break;
+                    }
+                    case 170 /* ArrayLiteralExpression */:
+                        var openBracket = ts.findChildOfKind(n, 19 /* OpenBracketToken */, sourceFile);
+                        var closeBracket = ts.findChildOfKind(n, 20 /* CloseBracketToken */, sourceFile);
+                        addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n));
+                        break;
+                }
+                depth++;
+                ts.forEachChild(n, walk);
+                depth--;
+            }
+            walk(sourceFile);
+            return elements;
+        }
+        OutliningElementsCollector.collectElements = collectElements;
+    })(OutliningElementsCollector = ts.OutliningElementsCollector || (ts.OutliningElementsCollector = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
+(function (ts) {
+    var NavigateTo;
+    (function (NavigateTo) {
+        function getNavigateToItems(program, checker, cancellationToken, searchValue, maxResultCount) {
+            var patternMatcher = ts.createPatternMatcher(searchValue);
+            var rawItems = [];
+            // This means "compare in a case insensitive manner."
+            var baseSensitivity = { sensitivity: "base" };
+            // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
+            ts.forEach(program.getSourceFiles(), function (sourceFile) {
+                cancellationToken.throwIfCancellationRequested();
+                var nameToDeclarations = sourceFile.getNamedDeclarations();
+                for (var name_36 in nameToDeclarations) {
+                    var declarations = ts.getProperty(nameToDeclarations, name_36);
+                    if (declarations) {
+                        // First do a quick check to see if the name of the declaration matches the
+                        // last portion of the (possibly) dotted name they're searching for.
+                        var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_36);
+                        if (!matches) {
+                            continue;
+                        }
+                        for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+                            var declaration = declarations_7[_i];
+                            // It was a match!  If the pattern has dots in it, then also see if the
+                            // declaration container matches as well.
+                            if (patternMatcher.patternContainsDots) {
+                                var containers = getContainers(declaration);
+                                if (!containers) {
+                                    return undefined;
+                                }
+                                matches = patternMatcher.getMatches(containers, name_36);
+                                if (!matches) {
+                                    continue;
+                                }
+                            }
+                            var fileName = sourceFile.fileName;
+                            var matchKind = bestMatchKind(matches);
+                            rawItems.push({ name: name_36, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration });
+                        }
+                    }
+                }
+            });
+            // Remove imports when the imported declaration is already in the list and has the same name.
+            rawItems = ts.filter(rawItems, function (item) {
+                var decl = item.declaration;
+                if (decl.kind === 231 /* ImportClause */ || decl.kind === 234 /* ImportSpecifier */ || decl.kind === 229 /* ImportEqualsDeclaration */) {
+                    var importer = checker.getSymbolAtLocation(decl.name);
+                    var imported = checker.getAliasedSymbol(importer);
+                    return importer.name !== imported.name;
+                }
+                else {
+                    return true;
+                }
+            });
+            rawItems.sort(compareNavigateToItems);
+            if (maxResultCount !== undefined) {
+                rawItems = rawItems.slice(0, maxResultCount);
+            }
+            var items = ts.map(rawItems, createNavigateToItem);
+            return items;
+            function allMatchesAreCaseSensitive(matches) {
+                ts.Debug.assert(matches.length > 0);
+                // This is a case sensitive match, only if all the submatches were case sensitive.
+                for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+                    var match = matches_1[_i];
+                    if (!match.isCaseSensitive) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            function getTextOfIdentifierOrLiteral(node) {
+                if (node) {
+                    if (node.kind === 69 /* Identifier */ ||
+                        node.kind === 9 /* StringLiteral */ ||
+                        node.kind === 8 /* NumericLiteral */) {
+                        return node.text;
+                    }
+                }
+                return undefined;
+            }
+            function tryAddSingleDeclarationName(declaration, containers) {
+                if (declaration && declaration.name) {
+                    var text = getTextOfIdentifierOrLiteral(declaration.name);
+                    if (text !== undefined) {
+                        containers.unshift(text);
+                    }
+                    else if (declaration.name.kind === 140 /* ComputedPropertyName */) {
+                        return tryAddComputedPropertyName(declaration.name.expression, containers, /*includeLastPortion*/ true);
+                    }
+                    else {
+                        // Don't know how to add this.
+                        return false;
+                    }
+                }
+                return true;
+            }
+            // Only added the names of computed properties if they're simple dotted expressions, like:
+            //
+            //      [X.Y.Z]() { }
+            function tryAddComputedPropertyName(expression, containers, includeLastPortion) {
+                var text = getTextOfIdentifierOrLiteral(expression);
+                if (text !== undefined) {
+                    if (includeLastPortion) {
+                        containers.unshift(text);
+                    }
+                    return true;
+                }
+                if (expression.kind === 172 /* PropertyAccessExpression */) {
+                    var propertyAccess = expression;
+                    if (includeLastPortion) {
+                        containers.unshift(propertyAccess.name.text);
+                    }
+                    return tryAddComputedPropertyName(propertyAccess.expression, containers, /*includeLastPortion*/ true);
+                }
+                return false;
+            }
+            function getContainers(declaration) {
+                var containers = [];
+                // First, if we started with a computed property name, then add all but the last
+                // portion into the container array.
+                if (declaration.name.kind === 140 /* ComputedPropertyName */) {
+                    if (!tryAddComputedPropertyName(declaration.name.expression, containers, /*includeLastPortion*/ false)) {
+                        return undefined;
+                    }
+                }
+                // Now, walk up our containers, adding all their names to the container array.
+                declaration = ts.getContainerNode(declaration);
+                while (declaration) {
+                    if (!tryAddSingleDeclarationName(declaration, containers)) {
+                        return undefined;
+                    }
+                    declaration = ts.getContainerNode(declaration);
+                }
+                return containers;
+            }
+            function bestMatchKind(matches) {
+                ts.Debug.assert(matches.length > 0);
+                var bestMatchKind = ts.PatternMatchKind.camelCase;
+                for (var _i = 0, matches_2 = matches; _i < matches_2.length; _i++) {
+                    var match = matches_2[_i];
+                    var kind = match.kind;
+                    if (kind < bestMatchKind) {
+                        bestMatchKind = kind;
+                    }
+                }
+                return bestMatchKind;
+            }
+            function compareNavigateToItems(i1, i2) {
+                // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
+                // Right now we just sort by kind first, and then by name of the item.
+                // We first sort case insensitively.  So "Aaa" will come before "bar".
+                // Then we sort case sensitively, so "aaa" will come before "Aaa".
+                return i1.matchKind - i2.matchKind ||
+                    i1.name.localeCompare(i2.name, undefined, baseSensitivity) ||
+                    i1.name.localeCompare(i2.name);
+            }
+            function createNavigateToItem(rawItem) {
+                var declaration = rawItem.declaration;
+                var container = ts.getContainerNode(declaration);
+                return {
+                    name: rawItem.name,
+                    kind: ts.getNodeKind(declaration),
+                    kindModifiers: ts.getNodeModifiers(declaration),
+                    matchKind: ts.PatternMatchKind[rawItem.matchKind],
+                    isCaseSensitive: rawItem.isCaseSensitive,
+                    fileName: rawItem.fileName,
+                    textSpan: ts.createTextSpanFromBounds(declaration.getStart(), declaration.getEnd()),
+                    // TODO(jfreeman): What should be the containerName when the container has a computed name?
+                    containerName: container && container.name ? container.name.text : "",
+                    containerKind: container && container.name ? ts.getNodeKind(container) : ""
+                };
+            }
+        }
+        NavigateTo.getNavigateToItems = getNavigateToItems;
+    })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {}));
+})(ts || (ts = {}));
+/// <reference path='services.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var NavigationBar;
+    (function (NavigationBar) {
+        function getNavigationBarItems(sourceFile) {
+            curSourceFile = sourceFile;
+            var result = ts.map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem);
+            curSourceFile = undefined;
+            return result;
+        }
+        NavigationBar.getNavigationBarItems = getNavigationBarItems;
+        // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`.
+        var curSourceFile;
+        function nodeText(node) {
+            return node.getText(curSourceFile);
+        }
+        function navigationBarNodeKind(n) {
+            return n.node.kind;
+        }
+        function pushChild(parent, child) {
+            if (parent.children) {
+                parent.children.push(child);
+            }
+            else {
+                parent.children = [child];
+            }
+        }
+        /*
+        For performance, we keep navigation bar parents on a stack rather than passing them through each recursion.
+        `parent` is the current parent and is *not* stored in parentsStack.
+        `startNode` sets a new parent and `endNode` returns to the previous parent.
+        */
+        var parentsStack = [];
+        var parent;
+        function rootNavigationBarNode(sourceFile) {
+            ts.Debug.assert(!parentsStack.length);
+            var root = { node: sourceFile, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 };
+            parent = root;
+            for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) {
+                var statement = _a[_i];
+                addChildrenRecursively(statement);
+            }
+            endNode();
+            ts.Debug.assert(!parent && !parentsStack.length);
+            return root;
+        }
+        function addLeafNode(node) {
+            pushChild(parent, emptyNavigationBarNode(node));
+        }
+        function emptyNavigationBarNode(node) {
+            return {
+                node: node,
+                additionalNodes: undefined,
+                parent: parent,
+                children: undefined,
+                indent: parent.indent + 1
+            };
+        }
+        /**
+         * Add a new level of NavigationBarNodes.
+         * This pushes to the stack, so you must call `endNode` when you are done adding to this node.
+         */
+        function startNode(node) {
+            var navNode = emptyNavigationBarNode(node);
+            pushChild(parent, navNode);
+            // Save the old parent
+            parentsStack.push(parent);
+            parent = navNode;
+        }
+        /** Call after calling `startNode` and adding children to it. */
+        function endNode() {
+            if (parent.children) {
+                mergeChildren(parent.children);
+                sortChildren(parent.children);
+            }
+            parent = parentsStack.pop();
+        }
+        function addNodeWithRecursiveChild(node, child) {
+            startNode(node);
+            addChildrenRecursively(child);
+            endNode();
+        }
+        /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */
+        function addChildrenRecursively(node) {
+            if (!node || ts.isToken(node)) {
+                return;
+            }
+            switch (node.kind) {
+                case 148 /* Constructor */:
+                    // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it.
+                    var ctr = node;
+                    addNodeWithRecursiveChild(ctr, ctr.body);
+                    // Parameter properties are children of the class, not the constructor.
+                    for (var _i = 0, _a = ctr.parameters; _i < _a.length; _i++) {
+                        var param = _a[_i];
+                        if (ts.isParameterPropertyDeclaration(param)) {
+                            addLeafNode(param);
+                        }
+                    }
+                    break;
+                case 147 /* MethodDeclaration */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 146 /* MethodSignature */:
+                    if (!ts.hasDynamicName(node)) {
+                        addNodeWithRecursiveChild(node, node.body);
+                    }
+                    break;
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                    if (!ts.hasDynamicName(node)) {
+                        addLeafNode(node);
+                    }
+                    break;
+                case 231 /* ImportClause */:
+                    var importClause = node;
+                    // Handle default import case e.g.:
+                    //    import d from "mod";
+                    if (importClause.name) {
+                        addLeafNode(importClause);
+                    }
+                    // Handle named bindings in imports e.g.:
+                    //    import * as NS from "mod";
+                    //    import {a, b as B} from "mod";
+                    var namedBindings = importClause.namedBindings;
+                    if (namedBindings) {
+                        if (namedBindings.kind === 232 /* NamespaceImport */) {
+                            addLeafNode(namedBindings);
+                        }
+                        else {
+                            for (var _b = 0, _c = namedBindings.elements; _b < _c.length; _b++) {
+                                var element = _c[_b];
+                                addLeafNode(element);
+                            }
+                        }
+                    }
+                    break;
+                case 169 /* BindingElement */:
+                case 218 /* VariableDeclaration */:
+                    var decl = node;
+                    var name_37 = decl.name;
+                    if (ts.isBindingPattern(name_37)) {
+                        addChildrenRecursively(name_37);
+                    }
+                    else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) {
+                        // For `const x = function() {}`, just use the function node, not the const.
+                        addChildrenRecursively(decl.initializer);
+                    }
+                    else {
+                        addNodeWithRecursiveChild(decl, decl.initializer);
+                    }
+                    break;
+                case 180 /* ArrowFunction */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                    addNodeWithRecursiveChild(node, node.body);
+                    break;
+                case 224 /* EnumDeclaration */:
+                    startNode(node);
+                    for (var _d = 0, _e = node.members; _d < _e.length; _d++) {
+                        var member = _e[_d];
+                        if (!isComputedProperty(member)) {
+                            addLeafNode(member);
+                        }
+                    }
+                    endNode();
+                    break;
+                case 221 /* ClassDeclaration */:
+                case 192 /* ClassExpression */:
+                case 222 /* InterfaceDeclaration */:
+                    startNode(node);
+                    for (var _f = 0, _g = node.members; _f < _g.length; _f++) {
+                        var member = _g[_f];
+                        addChildrenRecursively(member);
+                    }
+                    endNode();
+                    break;
+                case 225 /* ModuleDeclaration */:
+                    addNodeWithRecursiveChild(node, getInteriorModule(node).body);
+                    break;
+                case 238 /* ExportSpecifier */:
+                case 229 /* ImportEqualsDeclaration */:
+                case 153 /* IndexSignature */:
+                case 151 /* CallSignature */:
+                case 152 /* ConstructSignature */:
+                case 223 /* TypeAliasDeclaration */:
+                    addLeafNode(node);
+                    break;
+                default:
+                    if (node.jsDocComments) {
+                        for (var _h = 0, _j = node.jsDocComments; _h < _j.length; _h++) {
+                            var jsDocComment = _j[_h];
+                            for (var _k = 0, _l = jsDocComment.tags; _k < _l.length; _k++) {
+                                var tag = _l[_k];
+                                if (tag.kind === 279 /* JSDocTypedefTag */) {
+                                    addLeafNode(tag);
+                                }
+                            }
+                        }
+                    }
+                    ts.forEachChild(node, addChildrenRecursively);
+            }
+        }
+        /** Merge declarations of the same kind. */
+        function mergeChildren(children) {
+            var nameToItems = {};
+            ts.filterMutate(children, function (child) {
+                var decl = child.node;
+                var name = decl.name && nodeText(decl.name);
+                if (!name) {
+                    // Anonymous items are never merged.
+                    return true;
+                }
+                var itemsWithSameName = ts.getProperty(nameToItems, name);
+                if (!itemsWithSameName) {
+                    nameToItems[name] = child;
+                    return true;
+                }
+                if (itemsWithSameName instanceof Array) {
+                    for (var _i = 0, itemsWithSameName_1 = itemsWithSameName; _i < itemsWithSameName_1.length; _i++) {
+                        var itemWithSameName = itemsWithSameName_1[_i];
+                        if (tryMerge(itemWithSameName, child)) {
+                            return false;
+                        }
+                    }
+                    itemsWithSameName.push(child);
+                    return true;
+                }
+                else {
+                    var itemWithSameName = itemsWithSameName;
+                    if (tryMerge(itemWithSameName, child)) {
+                        return false;
+                    }
+                    nameToItems[name] = [itemWithSameName, child];
+                    return true;
+                }
+                function tryMerge(a, b) {
+                    if (shouldReallyMerge(a.node, b.node)) {
+                        merge(a, b);
+                        return true;
+                    }
+                    return false;
+                }
+            });
+            /** a and b have the same name, but they may not be mergeable. */
+            function shouldReallyMerge(a, b) {
+                return a.kind === b.kind && (a.kind !== 225 /* ModuleDeclaration */ || areSameModule(a, b));
+                // We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes.
+                // Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'!
+                function areSameModule(a, b) {
+                    if (a.body.kind !== b.body.kind) {
+                        return false;
+                    }
+                    if (a.body.kind !== 225 /* ModuleDeclaration */) {
+                        return true;
+                    }
+                    return areSameModule(a.body, b.body);
+                }
+            }
+            /** Merge source into target. Source should be thrown away after this is called. */
+            function merge(target, source) {
+                target.additionalNodes = target.additionalNodes || [];
+                target.additionalNodes.push(source.node);
+                if (source.additionalNodes) {
+                    (_a = target.additionalNodes).push.apply(_a, source.additionalNodes);
+                }
+                target.children = ts.concatenate(target.children, source.children);
+                if (target.children) {
+                    mergeChildren(target.children);
+                    sortChildren(target.children);
+                }
+                var _a;
+            }
+        }
+        /** Recursively ensure that each NavNode's children are in sorted order. */
+        function sortChildren(children) {
+            children.sort(compareChildren);
+        }
+        function compareChildren(child1, child2) {
+            var name1 = tryGetName(child1.node), name2 = tryGetName(child2.node);
+            if (name1 && name2) {
+                var cmp = localeCompareFix(name1, name2);
+                return cmp !== 0 ? cmp : navigationBarNodeKind(child1) - navigationBarNodeKind(child2);
+            }
+            else {
+                return name1 ? 1 : name2 ? -1 : navigationBarNodeKind(child1) - navigationBarNodeKind(child2);
+            }
+        }
+        // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
+        var collator = typeof Intl === "undefined" ? undefined : new Intl.Collator();
+        // Intl is missing in Safari, and node 0.10 treats "a" as greater than "B".
+        var localeCompareIsCorrect = collator && collator.compare("a", "B") < 0;
+        var localeCompareFix = localeCompareIsCorrect ? collator.compare : function (a, b) {
+            // This isn't perfect, but it passes all of our tests.
+            for (var i = 0; i < Math.min(a.length, b.length); i++) {
+                var chA = a.charAt(i), chB = b.charAt(i);
+                if (chA === "\"" && chB === "'") {
+                    return 1;
+                }
+                if (chA === "'" && chB === "\"") {
+                    return -1;
+                }
+                var cmp = chA.toLocaleLowerCase().localeCompare(chB.toLocaleLowerCase());
+                if (cmp !== 0) {
+                    return cmp;
+                }
+            }
+            return a.length - b.length;
+        };
+        /**
+         * This differs from getItemName because this is just used for sorting.
+         * We only sort nodes by name that have a more-or-less "direct" name, as opposed to `new()` and the like.
+         * So `new()` can still come before an `aardvark` method.
+         */
+        function tryGetName(node) {
+            if (node.kind === 225 /* ModuleDeclaration */) {
+                return getModuleName(node);
+            }
+            var decl = node;
+            if (decl.name) {
+                return ts.getPropertyNameForPropertyNameNode(decl.name);
+            }
+            switch (node.kind) {
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                case 192 /* ClassExpression */:
+                    return getFunctionOrClassName(node);
+                case 279 /* JSDocTypedefTag */:
+                    return getJSDocTypedefTagName(node);
+                default:
+                    return undefined;
+            }
+        }
+        function getItemName(node) {
+            if (node.kind === 225 /* ModuleDeclaration */) {
+                return getModuleName(node);
+            }
+            var name = node.name;
+            if (name) {
+                var text = nodeText(name);
+                if (text.length > 0) {
+                    return text;
+                }
+            }
+            switch (node.kind) {
+                case 256 /* SourceFile */:
+                    var sourceFile = node;
+                    return ts.isExternalModule(sourceFile)
+                        ? "\"" + ts.escapeString(ts.getBaseFileName(ts.removeFileExtension(ts.normalizePath(sourceFile.fileName)))) + "\""
+                        : "<global>";
+                case 180 /* ArrowFunction */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 221 /* ClassDeclaration */:
+                case 192 /* ClassExpression */:
+                    if (node.flags & 512 /* Default */) {
+                        return "default";
+                    }
+                    return getFunctionOrClassName(node);
+                case 148 /* Constructor */:
+                    return "constructor";
+                case 152 /* ConstructSignature */:
+                    return "new()";
+                case 151 /* CallSignature */:
+                    return "()";
+                case 153 /* IndexSignature */:
+                    return "[]";
+                case 279 /* JSDocTypedefTag */:
+                    return getJSDocTypedefTagName(node);
+                default:
+                    return "<unknown>";
+            }
+        }
+        function getJSDocTypedefTagName(node) {
+            if (node.name) {
+                return node.name.text;
+            }
+            else {
+                var parentNode = node.parent && node.parent.parent;
+                if (parentNode && parentNode.kind === 200 /* VariableStatement */) {
+                    if (parentNode.declarationList.declarations.length > 0) {
+                        var nameIdentifier = parentNode.declarationList.declarations[0].name;
+                        if (nameIdentifier.kind === 69 /* Identifier */) {
+                            return nameIdentifier.text;
+                        }
+                    }
+                }
+                return "<typedef>";
+            }
+        }
+        /** Flattens the NavNode tree to a list, keeping only the top-level items. */
+        function topLevelItems(root) {
+            var topLevel = [];
+            function recur(item) {
+                if (isTopLevel(item)) {
+                    topLevel.push(item);
+                    if (item.children) {
+                        for (var _i = 0, _a = item.children; _i < _a.length; _i++) {
+                            var child = _a[_i];
+                            recur(child);
+                        }
+                    }
+                }
+            }
+            recur(root);
+            return topLevel;
+            function isTopLevel(item) {
+                switch (navigationBarNodeKind(item)) {
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 224 /* EnumDeclaration */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 225 /* ModuleDeclaration */:
+                    case 256 /* SourceFile */:
+                    case 223 /* TypeAliasDeclaration */:
+                    case 279 /* JSDocTypedefTag */:
+                        return true;
+                    case 148 /* Constructor */:
+                    case 147 /* MethodDeclaration */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        return hasSomeImportantChild(item);
+                    case 180 /* ArrowFunction */:
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                        return isTopLevelFunctionDeclaration(item);
+                    default:
+                        return false;
+                }
+                function isTopLevelFunctionDeclaration(item) {
+                    if (!item.node.body) {
+                        return false;
+                    }
+                    switch (navigationBarNodeKind(item.parent)) {
+                        case 226 /* ModuleBlock */:
+                        case 256 /* SourceFile */:
+                        case 147 /* MethodDeclaration */:
+                        case 148 /* Constructor */:
+                            return true;
+                        default:
+                            return hasSomeImportantChild(item);
+                    }
+                }
+                function hasSomeImportantChild(item) {
+                    return ts.forEach(item.children, function (child) {
+                        var childKind = navigationBarNodeKind(child);
+                        return childKind !== 218 /* VariableDeclaration */ && childKind !== 169 /* BindingElement */;
+                    });
+                }
+            }
+        }
+        // NavigationBarItem requires an array, but will not mutate it, so just give it this for performance.
+        var emptyChildItemArray = [];
+        function convertToTopLevelItem(n) {
+            return {
+                text: getItemName(n.node),
+                kind: nodeKind(n.node),
+                kindModifiers: ts.getNodeModifiers(n.node),
+                spans: getSpans(n),
+                childItems: ts.map(n.children, convertToChildItem) || emptyChildItemArray,
+                indent: n.indent,
+                bolded: false,
+                grayed: false
+            };
+            function convertToChildItem(n) {
+                return {
+                    text: getItemName(n.node),
+                    kind: nodeKind(n.node),
+                    kindModifiers: ts.getNodeModifiers(n.node),
+                    spans: getSpans(n),
+                    childItems: emptyChildItemArray,
+                    indent: 0,
+                    bolded: false,
+                    grayed: false
+                };
+            }
+            function getSpans(n) {
+                var spans = [getNodeSpan(n.node)];
+                if (n.additionalNodes) {
+                    for (var _i = 0, _a = n.additionalNodes; _i < _a.length; _i++) {
+                        var node = _a[_i];
+                        spans.push(getNodeSpan(node));
+                    }
+                }
+                return spans;
+            }
+        }
+        // TODO: GH#9145: We should just use getNodeKind. No reason why navigationBar and navigateTo should have different behaviors.
+        function nodeKind(node) {
+            switch (node.kind) {
+                case 256 /* SourceFile */:
+                    return ts.ScriptElementKind.moduleElement;
+                case 255 /* EnumMember */:
+                    return ts.ScriptElementKind.memberVariableElement;
+                case 218 /* VariableDeclaration */:
+                case 169 /* BindingElement */:
+                    var variableDeclarationNode = void 0;
+                    var name_38;
+                    if (node.kind === 169 /* BindingElement */) {
+                        name_38 = node.name;
+                        variableDeclarationNode = node;
+                        // binding elements are added only for variable declarations
+                        // bubble up to the containing variable declaration
+                        while (variableDeclarationNode && variableDeclarationNode.kind !== 218 /* VariableDeclaration */) {
+                            variableDeclarationNode = variableDeclarationNode.parent;
+                        }
+                        ts.Debug.assert(!!variableDeclarationNode);
+                    }
+                    else {
+                        ts.Debug.assert(!ts.isBindingPattern(node.name));
+                        variableDeclarationNode = node;
+                        name_38 = node.name;
+                    }
+                    if (ts.isConst(variableDeclarationNode)) {
+                        return ts.ScriptElementKind.constElement;
+                    }
+                    else if (ts.isLet(variableDeclarationNode)) {
+                        return ts.ScriptElementKind.letElement;
+                    }
+                    else {
+                        return ts.ScriptElementKind.variableElement;
+                    }
+                case 180 /* ArrowFunction */:
+                    return ts.ScriptElementKind.functionElement;
+                case 279 /* JSDocTypedefTag */:
+                    return ts.ScriptElementKind.typeElement;
+                default:
+                    return ts.getNodeKind(node);
+            }
+        }
+        function getModuleName(moduleDeclaration) {
+            // We want to maintain quotation marks.
+            if (ts.isAmbientModule(moduleDeclaration)) {
+                return ts.getTextOfNode(moduleDeclaration.name);
+            }
+            // Otherwise, we need to aggregate each identifier to build up the qualified name.
+            var result = [];
+            result.push(moduleDeclaration.name.text);
+            while (moduleDeclaration.body && moduleDeclaration.body.kind === 225 /* ModuleDeclaration */) {
+                moduleDeclaration = moduleDeclaration.body;
+                result.push(moduleDeclaration.name.text);
+            }
+            return result.join(".");
+        }
+        /**
+         * For 'module A.B.C', we want to get the node for 'C'.
+         * We store 'A' as associated with a NavNode, and use getModuleName to traverse down again.
+         */
+        function getInteriorModule(decl) {
+            return decl.body.kind === 225 /* ModuleDeclaration */ ? getInteriorModule(decl.body) : decl;
+        }
+        function isComputedProperty(member) {
+            return !member.name || member.name.kind === 140 /* ComputedPropertyName */;
+        }
+        function getNodeSpan(node) {
+            return node.kind === 256 /* SourceFile */
+                ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd())
+                : ts.createTextSpanFromBounds(node.getStart(curSourceFile), node.getEnd());
+        }
+        function getFunctionOrClassName(node) {
+            if (node.name && ts.getFullWidth(node.name) > 0) {
+                return ts.declarationNameToString(node.name);
+            }
+            else if (node.parent.kind === 218 /* VariableDeclaration */) {
+                return ts.declarationNameToString(node.parent.name);
+            }
+            else if (node.parent.kind === 187 /* BinaryExpression */ &&
+                node.parent.operatorToken.kind === 56 /* EqualsToken */) {
+                return nodeText(node.parent.left);
+            }
+            else if (node.parent.kind === 253 /* PropertyAssignment */ && node.parent.name) {
+                return nodeText(node.parent.name);
+            }
+            else if (node.flags & 512 /* Default */) {
+                return "default";
+            }
+            else {
+                return ts.isClassLike(node) ? "<class>" : "<function>";
+            }
+        }
+        function isFunctionOrClassExpression(node) {
+            return node.kind === 179 /* FunctionExpression */ || node.kind === 180 /* ArrowFunction */ || node.kind === 192 /* ClassExpression */;
+        }
+    })(NavigationBar = ts.NavigationBar || (ts.NavigationBar = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
+(function (ts) {
+    // Note(cyrusn): this enum is ordered from strongest match type to weakest match type.
+    (function (PatternMatchKind) {
+        PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact";
+        PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix";
+        PatternMatchKind[PatternMatchKind["substring"] = 2] = "substring";
+        PatternMatchKind[PatternMatchKind["camelCase"] = 3] = "camelCase";
+    })(ts.PatternMatchKind || (ts.PatternMatchKind = {}));
+    var PatternMatchKind = ts.PatternMatchKind;
+    function createPatternMatch(kind, punctuationStripped, isCaseSensitive, camelCaseWeight) {
+        return {
+            kind: kind,
+            punctuationStripped: punctuationStripped,
+            isCaseSensitive: isCaseSensitive,
+            camelCaseWeight: camelCaseWeight
+        };
+    }
+    function createPatternMatcher(pattern) {
+        // We'll often see the same candidate string many times when searching (For example, when
+        // we see the name of a module that is used everywhere, or the name of an overload).  As
+        // such, we cache the information we compute about the candidate for the life of this
+        // pattern matcher so we don't have to compute it multiple times.
+        var stringToWordSpans = {};
+        pattern = pattern.trim();
+        var dotSeparatedSegments = pattern.split(".").map(function (p) { return createSegment(p.trim()); });
+        var invalidPattern = dotSeparatedSegments.length === 0 || ts.forEach(dotSeparatedSegments, segmentIsInvalid);
+        return {
+            getMatches: getMatches,
+            getMatchesForLastSegmentOfPattern: getMatchesForLastSegmentOfPattern,
+            patternContainsDots: dotSeparatedSegments.length > 1
+        };
+        // Quick checks so we can bail out when asked to match a candidate.
+        function skipMatch(candidate) {
+            return invalidPattern || !candidate;
+        }
+        function getMatchesForLastSegmentOfPattern(candidate) {
+            if (skipMatch(candidate)) {
+                return undefined;
+            }
+            return matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments));
+        }
+        function getMatches(candidateContainers, candidate) {
+            if (skipMatch(candidate)) {
+                return undefined;
+            }
+            // First, check that the last part of the dot separated pattern matches the name of the
+            // candidate.  If not, then there's no point in proceeding and doing the more
+            // expensive work.
+            var candidateMatch = matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments));
+            if (!candidateMatch) {
+                return undefined;
+            }
+            candidateContainers = candidateContainers || [];
+            // -1 because the last part was checked against the name, and only the rest
+            // of the parts are checked against the container.
+            if (dotSeparatedSegments.length - 1 > candidateContainers.length) {
+                // There weren't enough container parts to match against the pattern parts.
+                // So this definitely doesn't match.
+                return undefined;
+            }
+            // So far so good.  Now break up the container for the candidate and check if all
+            // the dotted parts match up correctly.
+            var totalMatch = candidateMatch;
+            for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i -= 1, j -= 1) {
+                var segment = dotSeparatedSegments[i];
+                var containerName = candidateContainers[j];
+                var containerMatch = matchSegment(containerName, segment);
+                if (!containerMatch) {
+                    // This container didn't match the pattern piece.  So there's no match at all.
+                    return undefined;
+                }
+                ts.addRange(totalMatch, containerMatch);
+            }
+            // Success, this symbol's full name matched against the dotted name the user was asking
+            // about.
+            return totalMatch;
+        }
+        function getWordSpans(word) {
+            if (!ts.hasProperty(stringToWordSpans, word)) {
+                stringToWordSpans[word] = breakIntoWordSpans(word);
+            }
+            return stringToWordSpans[word];
+        }
+        function matchTextChunk(candidate, chunk, punctuationStripped) {
+            var index = indexOfIgnoringCase(candidate, chunk.textLowerCase);
+            if (index === 0) {
+                if (chunk.text.length === candidate.length) {
+                    // a) Check if the part matches the candidate entirely, in an case insensitive or
+                    //    sensitive manner.  If it does, return that there was an exact match.
+                    return createPatternMatch(PatternMatchKind.exact, punctuationStripped, /*isCaseSensitive:*/ candidate === chunk.text);
+                }
+                else {
+                    // b) Check if the part is a prefix of the candidate, in a case insensitive or sensitive
+                    //    manner.  If it does, return that there was a prefix match.
+                    return createPatternMatch(PatternMatchKind.prefix, punctuationStripped, /*isCaseSensitive:*/ startsWith(candidate, chunk.text));
+                }
+            }
+            var isLowercase = chunk.isLowerCase;
+            if (isLowercase) {
+                if (index > 0) {
+                    // c) If the part is entirely lowercase, then check if it is contained anywhere in the
+                    //    candidate in a case insensitive manner.  If so, return that there was a substring
+                    //    match.
+                    //
+                    //    Note: We only have a substring match if the lowercase part is prefix match of some
+                    //    word part. That way we don't match something like 'Class' when the user types 'a'.
+                    //    But we would match 'FooAttribute' (since 'Attribute' starts with 'a').
+                    var wordSpans = getWordSpans(candidate);
+                    for (var _i = 0, wordSpans_1 = wordSpans; _i < wordSpans_1.length; _i++) {
+                        var span = wordSpans_1[_i];
+                        if (partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ true)) {
+                            return createPatternMatch(PatternMatchKind.substring, punctuationStripped, 
+                            /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false));
+                        }
+                    }
+                }
+            }
+            else {
+                // d) If the part was not entirely lowercase, then check if it is contained in the
+                //    candidate in a case *sensitive* manner. If so, return that there was a substring
+                //    match.
+                if (candidate.indexOf(chunk.text) > 0) {
+                    return createPatternMatch(PatternMatchKind.substring, punctuationStripped, /*isCaseSensitive:*/ true);
+                }
+            }
+            if (!isLowercase) {
+                // e) If the part was not entirely lowercase, then attempt a camel cased match as well.
+                if (chunk.characterSpans.length > 0) {
+                    var candidateParts = getWordSpans(candidate);
+                    var camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ false);
+                    if (camelCaseWeight !== undefined) {
+                        return createPatternMatch(PatternMatchKind.camelCase, punctuationStripped, /*isCaseSensitive:*/ true, /*camelCaseWeight:*/ camelCaseWeight);
+                    }
+                    camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ true);
+                    if (camelCaseWeight !== undefined) {
+                        return createPatternMatch(PatternMatchKind.camelCase, punctuationStripped, /*isCaseSensitive:*/ false, /*camelCaseWeight:*/ camelCaseWeight);
+                    }
+                }
+            }
+            if (isLowercase) {
+                // f) Is the pattern a substring of the candidate starting on one of the candidate's word boundaries?
+                // We could check every character boundary start of the candidate for the pattern. However, that's
+                // an m * n operation in the wost case. Instead, find the first instance of the pattern
+                // substring, and see if it starts on a capital letter. It seems unlikely that the user will try to
+                // filter the list based on a substring that starts on a capital letter and also with a lowercase one.
+                // (Pattern: fogbar, Candidate: quuxfogbarFogBar).
+                if (chunk.text.length < candidate.length) {
+                    if (index > 0 && isUpperCaseLetter(candidate.charCodeAt(index))) {
+                        return createPatternMatch(PatternMatchKind.substring, punctuationStripped, /*isCaseSensitive:*/ false);
+                    }
+                }
+            }
+            return undefined;
+        }
+        function containsSpaceOrAsterisk(text) {
+            for (var i = 0; i < text.length; i++) {
+                var ch = text.charCodeAt(i);
+                if (ch === 32 /* space */ || ch === 42 /* asterisk */) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function matchSegment(candidate, segment) {
+            // First check if the segment matches as is.  This is also useful if the segment contains
+            // characters we would normally strip when splitting into parts that we also may want to
+            // match in the candidate.  For example if the segment is "@int" and the candidate is
+            // "@int", then that will show up as an exact match here.
+            //
+            // Note: if the segment contains a space or an asterisk then we must assume that it's a
+            // multi-word segment.
+            if (!containsSpaceOrAsterisk(segment.totalTextChunk.text)) {
+                var match = matchTextChunk(candidate, segment.totalTextChunk, /*punctuationStripped:*/ false);
+                if (match) {
+                    return [match];
+                }
+            }
+            // The logic for pattern matching is now as follows:
+            //
+            // 1) Break the segment passed in into words.  Breaking is rather simple and a
+            //    good way to think about it that if gives you all the individual alphanumeric words
+            //    of the pattern.
+            //
+            // 2) For each word try to match the word against the candidate value.
+            //
+            // 3) Matching is as follows:
+            //
+            //   a) Check if the word matches the candidate entirely, in an case insensitive or
+            //    sensitive manner.  If it does, return that there was an exact match.
+            //
+            //   b) Check if the word is a prefix of the candidate, in a case insensitive or
+            //      sensitive manner.  If it does, return that there was a prefix match.
+            //
+            //   c) If the word is entirely lowercase, then check if it is contained anywhere in the
+            //      candidate in a case insensitive manner.  If so, return that there was a substring
+            //      match.
+            //
+            //      Note: We only have a substring match if the lowercase part is prefix match of
+            //      some word part. That way we don't match something like 'Class' when the user
+            //      types 'a'. But we would match 'FooAttribute' (since 'Attribute' starts with
+            //      'a').
+            //
+            //   d) If the word was not entirely lowercase, then check if it is contained in the
+            //      candidate in a case *sensitive* manner. If so, return that there was a substring
+            //      match.
+            //
+            //   e) If the word was not entirely lowercase, then attempt a camel cased match as
+            //      well.
+            //
+            //   f) The word is all lower case. Is it a case insensitive substring of the candidate starting
+            //      on a part boundary of the candidate?
+            //
+            // Only if all words have some sort of match is the pattern considered matched.
+            var subWordTextChunks = segment.subWordTextChunks;
+            var matches = undefined;
+            for (var _i = 0, subWordTextChunks_1 = subWordTextChunks; _i < subWordTextChunks_1.length; _i++) {
+                var subWordTextChunk = subWordTextChunks_1[_i];
+                // Try to match the candidate with this word
+                var result = matchTextChunk(candidate, subWordTextChunk, /*punctuationStripped:*/ true);
+                if (!result) {
+                    return undefined;
+                }
+                matches = matches || [];
+                matches.push(result);
+            }
+            return matches;
+        }
+        function partStartsWith(candidate, candidateSpan, pattern, ignoreCase, patternSpan) {
+            var patternPartStart = patternSpan ? patternSpan.start : 0;
+            var patternPartLength = patternSpan ? patternSpan.length : pattern.length;
+            if (patternPartLength > candidateSpan.length) {
+                // Pattern part is longer than the candidate part. There can never be a match.
+                return false;
+            }
+            if (ignoreCase) {
+                for (var i = 0; i < patternPartLength; i++) {
+                    var ch1 = pattern.charCodeAt(patternPartStart + i);
+                    var ch2 = candidate.charCodeAt(candidateSpan.start + i);
+                    if (toLowerCase(ch1) !== toLowerCase(ch2)) {
+                        return false;
+                    }
+                }
+            }
+            else {
+                for (var i = 0; i < patternPartLength; i++) {
+                    var ch1 = pattern.charCodeAt(patternPartStart + i);
+                    var ch2 = candidate.charCodeAt(candidateSpan.start + i);
+                    if (ch1 !== ch2) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        function tryCamelCaseMatch(candidate, candidateParts, chunk, ignoreCase) {
+            var chunkCharacterSpans = chunk.characterSpans;
+            // Note: we may have more pattern parts than candidate parts.  This is because multiple
+            // pattern parts may match a candidate part.  For example "SiUI" against "SimpleUI".
+            // We'll have 3 pattern parts Si/U/I against two candidate parts Simple/UI.  However, U
+            // and I will both match in UI.
+            var currentCandidate = 0;
+            var currentChunkSpan = 0;
+            var firstMatch = undefined;
+            var contiguous = undefined;
+            while (true) {
+                // Let's consider our termination cases
+                if (currentChunkSpan === chunkCharacterSpans.length) {
+                    // We did match! We shall assign a weight to this
+                    var weight = 0;
+                    // Was this contiguous?
+                    if (contiguous) {
+                        weight += 1;
+                    }
+                    // Did we start at the beginning of the candidate?
+                    if (firstMatch === 0) {
+                        weight += 2;
+                    }
+                    return weight;
+                }
+                else if (currentCandidate === candidateParts.length) {
+                    // No match, since we still have more of the pattern to hit
+                    return undefined;
+                }
+                var candidatePart = candidateParts[currentCandidate];
+                var gotOneMatchThisCandidate = false;
+                // Consider the case of matching SiUI against SimpleUIElement. The candidate parts
+                // will be Simple/UI/Element, and the pattern parts will be Si/U/I.  We'll match 'Si'
+                // against 'Simple' first.  Then we'll match 'U' against 'UI'. However, we want to
+                // still keep matching pattern parts against that candidate part.
+                for (; currentChunkSpan < chunkCharacterSpans.length; currentChunkSpan++) {
+                    var chunkCharacterSpan = chunkCharacterSpans[currentChunkSpan];
+                    if (gotOneMatchThisCandidate) {
+                        // We've already gotten one pattern part match in this candidate.  We will
+                        // only continue trying to consumer pattern parts if the last part and this
+                        // part are both upper case.
+                        if (!isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan - 1].start)) ||
+                            !isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan].start))) {
+                            break;
+                        }
+                    }
+                    if (!partStartsWith(candidate, candidatePart, chunk.text, ignoreCase, chunkCharacterSpan)) {
+                        break;
+                    }
+                    gotOneMatchThisCandidate = true;
+                    firstMatch = firstMatch === undefined ? currentCandidate : firstMatch;
+                    // If we were contiguous, then keep that value.  If we weren't, then keep that
+                    // value.  If we don't know, then set the value to 'true' as an initial match is
+                    // obviously contiguous.
+                    contiguous = contiguous === undefined ? true : contiguous;
+                    candidatePart = ts.createTextSpan(candidatePart.start + chunkCharacterSpan.length, candidatePart.length - chunkCharacterSpan.length);
+                }
+                // Check if we matched anything at all.  If we didn't, then we need to unset the
+                // contiguous bit if we currently had it set.
+                // If we haven't set the bit yet, then that means we haven't matched anything so
+                // far, and we don't want to change that.
+                if (!gotOneMatchThisCandidate && contiguous !== undefined) {
+                    contiguous = false;
+                }
+                // Move onto the next candidate.
+                currentCandidate++;
+            }
+        }
+    }
+    ts.createPatternMatcher = createPatternMatcher;
+    function createSegment(text) {
+        return {
+            totalTextChunk: createTextChunk(text),
+            subWordTextChunks: breakPatternIntoTextChunks(text)
+        };
+    }
+    // A segment is considered invalid if we couldn't find any words in it.
+    function segmentIsInvalid(segment) {
+        return segment.subWordTextChunks.length === 0;
+    }
+    function isUpperCaseLetter(ch) {
+        // Fast check for the ascii range.
+        if (ch >= 65 /* A */ && ch <= 90 /* Z */) {
+            return true;
+        }
+        if (ch < 127 /* maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 2 /* Latest */)) {
+            return false;
+        }
+        // TODO: find a way to determine this for any unicode characters in a
+        // non-allocating manner.
+        var str = String.fromCharCode(ch);
+        return str === str.toUpperCase();
+    }
+    function isLowerCaseLetter(ch) {
+        // Fast check for the ascii range.
+        if (ch >= 97 /* a */ && ch <= 122 /* z */) {
+            return true;
+        }
+        if (ch < 127 /* maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 2 /* Latest */)) {
+            return false;
+        }
+        // TODO: find a way to determine this for any unicode characters in a
+        // non-allocating manner.
+        var str = String.fromCharCode(ch);
+        return str === str.toLowerCase();
+    }
+    function startsWith(string, search) {
+        for (var i = 0, n = search.length; i < n; i++) {
+            if (string.charCodeAt(i) !== search.charCodeAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Assumes 'value' is already lowercase.
+    function indexOfIgnoringCase(string, value) {
+        for (var i = 0, n = string.length - value.length; i <= n; i++) {
+            if (startsWithIgnoringCase(string, value, i)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    // Assumes 'value' is already lowercase.
+    function startsWithIgnoringCase(string, value, start) {
+        for (var i = 0, n = value.length; i < n; i++) {
+            var ch1 = toLowerCase(string.charCodeAt(i + start));
+            var ch2 = value.charCodeAt(i);
+            if (ch1 !== ch2) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function toLowerCase(ch) {
+        // Fast convert for the ascii range.
+        if (ch >= 65 /* A */ && ch <= 90 /* Z */) {
+            return 97 /* a */ + (ch - 65 /* A */);
+        }
+        if (ch < 127 /* maxAsciiCharacter */) {
+            return ch;
+        }
+        // TODO: find a way to compute this for any unicode characters in a
+        // non-allocating manner.
+        return String.fromCharCode(ch).toLowerCase().charCodeAt(0);
+    }
+    function isDigit(ch) {
+        // TODO(cyrusn): Find a way to support this for unicode digits.
+        return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
+    }
+    function isWordChar(ch) {
+        return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit(ch) || ch === 95 /* _ */ || ch === 36 /* $ */;
+    }
+    function breakPatternIntoTextChunks(pattern) {
+        var result = [];
+        var wordStart = 0;
+        var wordLength = 0;
+        for (var i = 0; i < pattern.length; i++) {
+            var ch = pattern.charCodeAt(i);
+            if (isWordChar(ch)) {
+                if (wordLength === 0) {
+                    wordStart = i;
+                }
+                wordLength++;
+            }
+            else {
+                if (wordLength > 0) {
+                    result.push(createTextChunk(pattern.substr(wordStart, wordLength)));
+                    wordLength = 0;
+                }
+            }
+        }
+        if (wordLength > 0) {
+            result.push(createTextChunk(pattern.substr(wordStart, wordLength)));
+        }
+        return result;
+    }
+    function createTextChunk(text) {
+        var textLowerCase = text.toLowerCase();
+        return {
+            text: text,
+            textLowerCase: textLowerCase,
+            isLowerCase: text === textLowerCase,
+            characterSpans: breakIntoCharacterSpans(text)
+        };
+    }
+    /* @internal */ function breakIntoCharacterSpans(identifier) {
+        return breakIntoSpans(identifier, /*word:*/ false);
+    }
+    ts.breakIntoCharacterSpans = breakIntoCharacterSpans;
+    /* @internal */ function breakIntoWordSpans(identifier) {
+        return breakIntoSpans(identifier, /*word:*/ true);
+    }
+    ts.breakIntoWordSpans = breakIntoWordSpans;
+    function breakIntoSpans(identifier, word) {
+        var result = [];
+        var wordStart = 0;
+        for (var i = 1, n = identifier.length; i < n; i++) {
+            var lastIsDigit = isDigit(identifier.charCodeAt(i - 1));
+            var currentIsDigit = isDigit(identifier.charCodeAt(i));
+            var hasTransitionFromLowerToUpper = transitionFromLowerToUpper(identifier, word, i);
+            var hasTransitionFromUpperToLower = transitionFromUpperToLower(identifier, word, i, wordStart);
+            if (charIsPunctuation(identifier.charCodeAt(i - 1)) ||
+                charIsPunctuation(identifier.charCodeAt(i)) ||
+                lastIsDigit !== currentIsDigit ||
+                hasTransitionFromLowerToUpper ||
+                hasTransitionFromUpperToLower) {
+                if (!isAllPunctuation(identifier, wordStart, i)) {
+                    result.push(ts.createTextSpan(wordStart, i - wordStart));
+                }
+                wordStart = i;
+            }
+        }
+        if (!isAllPunctuation(identifier, wordStart, identifier.length)) {
+            result.push(ts.createTextSpan(wordStart, identifier.length - wordStart));
+        }
+        return result;
+    }
+    function charIsPunctuation(ch) {
+        switch (ch) {
+            case 33 /* exclamation */:
+            case 34 /* doubleQuote */:
+            case 35 /* hash */:
+            case 37 /* percent */:
+            case 38 /* ampersand */:
+            case 39 /* singleQuote */:
+            case 40 /* openParen */:
+            case 41 /* closeParen */:
+            case 42 /* asterisk */:
+            case 44 /* comma */:
+            case 45 /* minus */:
+            case 46 /* dot */:
+            case 47 /* slash */:
+            case 58 /* colon */:
+            case 59 /* semicolon */:
+            case 63 /* question */:
+            case 64 /* at */:
+            case 91 /* openBracket */:
+            case 92 /* backslash */:
+            case 93 /* closeBracket */:
+            case 95 /* _ */:
+            case 123 /* openBrace */:
+            case 125 /* closeBrace */:
+                return true;
+        }
+        return false;
+    }
+    function isAllPunctuation(identifier, start, end) {
+        for (var i = start; i < end; i++) {
+            var ch = identifier.charCodeAt(i);
+            // We don't consider _ or $ as punctuation as there may be things with that name.
+            if (!charIsPunctuation(ch) || ch === 95 /* _ */ || ch === 36 /* $ */) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function transitionFromUpperToLower(identifier, word, index, wordStart) {
+        if (word) {
+            // Cases this supports:
+            // 1) IDisposable -> I, Disposable
+            // 2) UIElement -> UI, Element
+            // 3) HTMLDocument -> HTML, Document
+            //
+            // etc.
+            if (index !== wordStart &&
+                index + 1 < identifier.length) {
+                var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index));
+                var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1));
+                if (currentIsUpper && nextIsLower) {
+                    // We have a transition from an upper to a lower letter here.  But we only
+                    // want to break if all the letters that preceded are uppercase.  i.e. if we
+                    // have "Foo" we don't want to break that into "F, oo".  But if we have
+                    // "IFoo" or "UIFoo", then we want to break that into "I, Foo" and "UI,
+                    // Foo".  i.e. the last uppercase letter belongs to the lowercase letters
+                    // that follows.  Note: this will make the following not split properly:
+                    // "HELLOthere".  However, these sorts of names do not show up in .Net
+                    // programs.
+                    for (var i = wordStart; i < index; i++) {
+                        if (!isUpperCaseLetter(identifier.charCodeAt(i))) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function transitionFromLowerToUpper(identifier, word, index) {
+        var lastIsUpper = isUpperCaseLetter(identifier.charCodeAt(index - 1));
+        var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index));
+        // See if the casing indicates we're starting a new word. Note: if we're breaking on
+        // words, then just seeing an upper case character isn't enough.  Instead, it has to
+        // be uppercase and the previous character can't be uppercase.
+        //
+        // For example, breaking "AddMetadata" on words would make: Add Metadata
+        //
+        // on characters would be: A dd M etadata
+        //
+        // Break "AM" on words would be: AM
+        //
+        // on characters would be: A M
+        //
+        // We break the search string on characters.  But we break the symbol name on words.
+        var transition = word
+            ? (currentIsUpper && !lastIsUpper)
+            : currentIsUpper;
+        return transition;
+    }
+})(ts || (ts = {}));
+///<reference path='services.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var SignatureHelp;
+    (function (SignatureHelp) {
+        // A partially written generic type expression is not guaranteed to have the correct syntax tree. the expression could be parsed as less than/greater than expression or a comma expression
+        // or some other combination depending on what the user has typed so far. For the purposes of signature help we need to consider any location after "<" as a possible generic type reference.
+        // To do this, the method will back parse the expression starting at the position required. it will try to parse the current expression as a generic type expression, if it did succeed it
+        // will return the generic identifier that started the expression (e.g. "foo" in "foo<any, |"). It is then up to the caller to ensure that this is a valid generic expression through
+        // looking up the type. The method will also keep track of the parameter index inside the expression.
+        // public static isInPartiallyWrittenTypeArgumentList(syntaxTree: TypeScript.SyntaxTree, position: number): any {
+        //    let token = Syntax.findTokenOnLeft(syntaxTree.sourceUnit(), position, /*includeSkippedTokens*/ true);
+        //    if (token && TypeScript.Syntax.hasAncestorOfKind(token, TypeScript.SyntaxKind.TypeParameterList)) {
+        //        // We are in the wrong generic list. bail out
+        //        return null;
+        //    }
+        //    let stack = 0;
+        //    let argumentIndex = 0;
+        //    whileLoop:
+        //    while (token) {
+        //        switch (token.kind()) {
+        //            case TypeScript.SyntaxKind.LessThanToken:
+        //                if (stack === 0) {
+        //                    // Found the beginning of the generic argument expression
+        //                    let lessThanToken = token;
+        //                    token = previousToken(token, /*includeSkippedTokens*/ true);
+        //                    if (!token || token.kind() !== TypeScript.SyntaxKind.IdentifierName) {
+        //                        break whileLoop;
+        //                    }
+        //                    // Found the name, return the data
+        //                    return {
+        //                        genericIdentifer: token,
+        //                        lessThanToken: lessThanToken,
+        //                        argumentIndex: argumentIndex
+        //                    };
+        //                }
+        //                else if (stack < 0) {
+        //                    // Seen one too many less than tokens, bail out
+        //                    break whileLoop;
+        //                }
+        //                else {
+        //                    stack--;
+        //                }
+        //                break;
+        //            case TypeScript.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+        //                stack++;
+        //            // Intentional fall through
+        //            case TypeScript.SyntaxKind.GreaterThanToken:
+        //                stack++;
+        //                break;
+        //            case TypeScript.SyntaxKind.CommaToken:
+        //                if (stack == 0) {
+        //                    argumentIndex++;
+        //                }
+        //                break;
+        //            case TypeScript.SyntaxKind.CloseBraceToken:
+        //                // This can be object type, skip untill we find the matching open brace token
+        //                let unmatchedOpenBraceTokens = 0;
+        //                // Skip untill the matching open brace token
+        //                token = SignatureInfoHelpers.moveBackUpTillMatchingTokenKind(token, TypeScript.SyntaxKind.CloseBraceToken, TypeScript.SyntaxKind.OpenBraceToken);
+        //                if (!token) {
+        //                    // No matching token was found. bail out
+        //                    break whileLoop;
+        //                }
+        //                break;
+        //            case TypeScript.SyntaxKind.EqualsGreaterThanToken:
+        //                // This can be a function type or a constructor type. In either case, we want to skip the function definition
+        //                token = previousToken(token, /*includeSkippedTokens*/ true);
+        //                if (token && token.kind() === TypeScript.SyntaxKind.CloseParenToken) {
+        //                    // Skip untill the matching open paren token
+        //                    token = SignatureInfoHelpers.moveBackUpTillMatchingTokenKind(token, TypeScript.SyntaxKind.CloseParenToken, TypeScript.SyntaxKind.OpenParenToken);
+        //                    if (token && token.kind() === TypeScript.SyntaxKind.GreaterThanToken) {
+        //                        // Another generic type argument list, skip it\
+        //                        token = SignatureInfoHelpers.moveBackUpTillMatchingTokenKind(token, TypeScript.SyntaxKind.GreaterThanToken, TypeScript.SyntaxKind.LessThanToken);
+        //                    }
+        //                    if (token && token.kind() === TypeScript.SyntaxKind.NewKeyword) {
+        //                        // In case this was a constructor type, skip the new keyword
+        //                        token = previousToken(token, /*includeSkippedTokens*/ true);
+        //                    }
+        //                    if (!token) {
+        //                        // No matching token was found. bail out
+        //                        break whileLoop;
+        //                    }
+        //                }
+        //                else {
+        //                    // This is not a function type. exit the main loop
+        //                    break whileLoop;
+        //                }
+        //                break;
+        //            case TypeScript.SyntaxKind.IdentifierName:
+        //            case TypeScript.SyntaxKind.AnyKeyword:
+        //            case TypeScript.SyntaxKind.NumberKeyword:
+        //            case TypeScript.SyntaxKind.StringKeyword:
+        //            case TypeScript.SyntaxKind.VoidKeyword:
+        //            case TypeScript.SyntaxKind.BooleanKeyword:
+        //            case TypeScript.SyntaxKind.DotToken:
+        //            case TypeScript.SyntaxKind.OpenBracketToken:
+        //            case TypeScript.SyntaxKind.CloseBracketToken:
+        //                // Valid tokens in a type name. Skip.
+        //                break;
+        //            default:
+        //                break whileLoop;
+        //        }
+        //        token = previousToken(token, /*includeSkippedTokens*/ true);
+        //    }
+        //    return null;
+        // }
+        // private static moveBackUpTillMatchingTokenKind(token: TypeScript.ISyntaxToken, tokenKind: TypeScript.SyntaxKind, matchingTokenKind: TypeScript.SyntaxKind): TypeScript.ISyntaxToken {
+        //    if (!token || token.kind() !== tokenKind) {
+        //        throw TypeScript.Errors.invalidOperation();
+        //    }
+        //    // Skip the current token
+        //    token = previousToken(token, /*includeSkippedTokens*/ true);
+        //    let stack = 0;
+        //    while (token) {
+        //        if (token.kind() === matchingTokenKind) {
+        //            if (stack === 0) {
+        //                // Found the matching token, return
+        //                return token;
+        //            }
+        //            else if (stack < 0) {
+        //                // tokens overlapped.. bail out.
+        //                break;
+        //            }
+        //            else {
+        //                stack--;
+        //            }
+        //        }
+        //        else if (token.kind() === tokenKind) {
+        //            stack++;
+        //        }
+        //        // Move back
+        //        token = previousToken(token, /*includeSkippedTokens*/ true);
+        //    }
+        //    // Did not find matching token
+        //    return null;
+        // }
+        var emptyArray = [];
+        (function (ArgumentListKind) {
+            ArgumentListKind[ArgumentListKind["TypeArguments"] = 0] = "TypeArguments";
+            ArgumentListKind[ArgumentListKind["CallArguments"] = 1] = "CallArguments";
+            ArgumentListKind[ArgumentListKind["TaggedTemplateArguments"] = 2] = "TaggedTemplateArguments";
+        })(SignatureHelp.ArgumentListKind || (SignatureHelp.ArgumentListKind = {}));
+        var ArgumentListKind = SignatureHelp.ArgumentListKind;
+        function getSignatureHelpItems(program, sourceFile, position, cancellationToken) {
+            var typeChecker = program.getTypeChecker();
+            // Decide whether to show signature help
+            var startingToken = ts.findTokenOnLeftOfPosition(sourceFile, position);
+            if (!startingToken) {
+                // We are at the beginning of the file
+                return undefined;
+            }
+            var argumentInfo = getContainingArgumentInfo(startingToken, position, sourceFile);
+            cancellationToken.throwIfCancellationRequested();
+            // Semantic filtering of signature help
+            if (!argumentInfo) {
+                return undefined;
+            }
+            var call = argumentInfo.invocation;
+            var candidates = [];
+            var resolvedSignature = typeChecker.getResolvedSignature(call, candidates);
+            cancellationToken.throwIfCancellationRequested();
+            if (!candidates.length) {
+                // We didn't have any sig help items produced by the TS compiler.  If this is a JS
+                // file, then see if we can figure out anything better.
+                if (ts.isSourceFileJavaScript(sourceFile)) {
+                    return createJavaScriptSignatureHelpItems(argumentInfo, program);
+                }
+                return undefined;
+            }
+            return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo, typeChecker);
+        }
+        SignatureHelp.getSignatureHelpItems = getSignatureHelpItems;
+        function createJavaScriptSignatureHelpItems(argumentInfo, program) {
+            if (argumentInfo.invocation.kind !== 174 /* CallExpression */) {
+                return undefined;
+            }
+            // See if we can find some symbol with the call expression name that has call signatures.
+            var callExpression = argumentInfo.invocation;
+            var expression = callExpression.expression;
+            var name = expression.kind === 69 /* Identifier */
+                ? expression
+                : expression.kind === 172 /* PropertyAccessExpression */
+                    ? expression.name
+                    : undefined;
+            if (!name || !name.text) {
+                return undefined;
+            }
+            var typeChecker = program.getTypeChecker();
+            for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) {
+                var sourceFile = _a[_i];
+                var nameToDeclarations = sourceFile.getNamedDeclarations();
+                var declarations = ts.getProperty(nameToDeclarations, name.text);
+                if (declarations) {
+                    for (var _b = 0, declarations_8 = declarations; _b < declarations_8.length; _b++) {
+                        var declaration = declarations_8[_b];
+                        var symbol = declaration.symbol;
+                        if (symbol) {
+                            var type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
+                            if (type) {
+                                var callSignatures = type.getCallSignatures();
+                                if (callSignatures && callSignatures.length) {
+                                    return createSignatureHelpItems(callSignatures, callSignatures[0], argumentInfo, typeChecker);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Returns relevant information for the argument list and the current argument if we are
+         * in the argument of an invocation; returns undefined otherwise.
+         */
+        function getImmediatelyContainingArgumentInfo(node, position, sourceFile) {
+            if (node.parent.kind === 174 /* CallExpression */ || node.parent.kind === 175 /* NewExpression */) {
+                var callExpression = node.parent;
+                // There are 3 cases to handle:
+                //   1. The token introduces a list, and should begin a sig help session
+                //   2. The token is either not associated with a list, or ends a list, so the session should end
+                //   3. The token is buried inside a list, and should give sig help
+                //
+                // The following are examples of each:
+                //
+                //    Case 1:
+                //          foo<#T, U>(#a, b)    -> The token introduces a list, and should begin a sig help session
+                //    Case 2:
+                //          fo#o<T, U>#(a, b)#   -> The token is either not associated with a list, or ends a list, so the session should end
+                //    Case 3:
+                //          foo<T#, U#>(a#, #b#) -> The token is buried inside a list, and should give sig help
+                // Find out if 'node' is an argument, a type argument, or neither
+                if (node.kind === 25 /* LessThanToken */ ||
+                    node.kind === 17 /* OpenParenToken */) {
+                    // Find the list that starts right *after* the < or ( token.
+                    // If the user has just opened a list, consider this item 0.
+                    var list = getChildListThatStartsWithOpenerToken(callExpression, node, sourceFile);
+                    var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos;
+                    ts.Debug.assert(list !== undefined);
+                    return {
+                        kind: isTypeArgList ? 0 /* TypeArguments */ : 1 /* CallArguments */,
+                        invocation: callExpression,
+                        argumentsSpan: getApplicableSpanForArguments(list, sourceFile),
+                        argumentIndex: 0,
+                        argumentCount: getArgumentCount(list)
+                    };
+                }
+                // findListItemInfo can return undefined if we are not in parent's argument list
+                // or type argument list. This includes cases where the cursor is:
+                //   - To the right of the closing paren, non-substitution template, or template tail.
+                //   - Between the type arguments and the arguments (greater than token)
+                //   - On the target of the call (parent.func)
+                //   - On the 'new' keyword in a 'new' expression
+                var listItemInfo = ts.findListItemInfo(node);
+                if (listItemInfo) {
+                    var list = listItemInfo.list;
+                    var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos;
+                    var argumentIndex = getArgumentIndex(list, node);
+                    var argumentCount = getArgumentCount(list);
+                    ts.Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, "argumentCount < argumentIndex, " + argumentCount + " < " + argumentIndex);
+                    return {
+                        kind: isTypeArgList ? 0 /* TypeArguments */ : 1 /* CallArguments */,
+                        invocation: callExpression,
+                        argumentsSpan: getApplicableSpanForArguments(list, sourceFile),
+                        argumentIndex: argumentIndex,
+                        argumentCount: argumentCount
+                    };
+                }
+                return undefined;
+            }
+            else if (node.kind === 11 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 176 /* TaggedTemplateExpression */) {
+                // Check if we're actually inside the template;
+                // otherwise we'll fall out and return undefined.
+                if (ts.isInsideTemplateLiteral(node, position)) {
+                    return getArgumentListInfoForTemplate(node.parent, /*argumentIndex*/ 0, sourceFile);
+                }
+            }
+            else if (node.kind === 12 /* TemplateHead */ && node.parent.parent.kind === 176 /* TaggedTemplateExpression */) {
+                var templateExpression = node.parent;
+                var tagExpression = templateExpression.parent;
+                ts.Debug.assert(templateExpression.kind === 189 /* TemplateExpression */);
+                var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1;
+                return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);
+            }
+            else if (node.parent.kind === 197 /* TemplateSpan */ && node.parent.parent.parent.kind === 176 /* TaggedTemplateExpression */) {
+                var templateSpan = node.parent;
+                var templateExpression = templateSpan.parent;
+                var tagExpression = templateExpression.parent;
+                ts.Debug.assert(templateExpression.kind === 189 /* TemplateExpression */);
+                // If we're just after a template tail, don't show signature help.
+                if (node.kind === 14 /* TemplateTail */ && !ts.isInsideTemplateLiteral(node, position)) {
+                    return undefined;
+                }
+                var spanIndex = templateExpression.templateSpans.indexOf(templateSpan);
+                var argumentIndex = getArgumentIndexForTemplatePiece(spanIndex, node, position);
+                return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);
+            }
+            return undefined;
+        }
+        function getArgumentIndex(argumentsList, node) {
+            // The list we got back can include commas.  In the presence of errors it may
+            // also just have nodes without commas.  For example "Foo(a b c)" will have 3
+            // args without commas.   We want to find what index we're at.  So we count
+            // forward until we hit ourselves, only incrementing the index if it isn't a
+            // comma.
+            //
+            // Note: the subtlety around trailing commas (in getArgumentCount) does not apply
+            // here.  That's because we're only walking forward until we hit the node we're
+            // on.  In that case, even if we're after the trailing comma, we'll still see
+            // that trailing comma in the list, and we'll have generated the appropriate
+            // arg index.
+            var argumentIndex = 0;
+            var listChildren = argumentsList.getChildren();
+            for (var _i = 0, listChildren_1 = listChildren; _i < listChildren_1.length; _i++) {
+                var child = listChildren_1[_i];
+                if (child === node) {
+                    break;
+                }
+                if (child.kind !== 24 /* CommaToken */) {
+                    argumentIndex++;
+                }
+            }
+            return argumentIndex;
+        }
+        function getArgumentCount(argumentsList) {
+            // The argument count for a list is normally the number of non-comma children it has.
+            // For example, if you have "Foo(a,b)" then there will be three children of the arg
+            // list 'a' '<comma>' 'b'.  So, in this case the arg count will be 2.  However, there
+            // is a small subtlety.  If you have  "Foo(a,)", then the child list will just have
+            // 'a' '<comma>'.  So, in the case where the last child is a comma, we increase the
+            // arg count by one to compensate.
+            //
+            // Note: this subtlety only applies to the last comma.  If you had "Foo(a,,"  then
+            // we'll have:  'a' '<comma>' '<missing>'
+            // That will give us 2 non-commas.  We then add one for the last comma, givin us an
+            // arg count of 3.
+            var listChildren = argumentsList.getChildren();
+            var argumentCount = ts.countWhere(listChildren, function (arg) { return arg.kind !== 24 /* CommaToken */; });
+            if (listChildren.length > 0 && ts.lastOrUndefined(listChildren).kind === 24 /* CommaToken */) {
+                argumentCount++;
+            }
+            return argumentCount;
+        }
+        // spanIndex is either the index for a given template span.
+        // This does not give appropriate results for a NoSubstitutionTemplateLiteral
+        function getArgumentIndexForTemplatePiece(spanIndex, node, position) {
+            // Because the TemplateStringsArray is the first argument, we have to offset each substitution expression by 1.
+            // There are three cases we can encounter:
+            //      1. We are precisely in the template literal (argIndex = 0).
+            //      2. We are in or to the right of the substitution expression (argIndex = spanIndex + 1).
+            //      3. We are directly to the right of the template literal, but because we look for the token on the left,
+            //          not enough to put us in the substitution expression; we should consider ourselves part of
+            //          the *next* span's expression by offsetting the index (argIndex = (spanIndex + 1) + 1).
+            //
+            // Example: f  `# abcd $#{#  1 + 1#  }# efghi ${ #"#hello"#  }  #  `
+            //              ^       ^ ^       ^   ^          ^ ^      ^     ^
+            // Case:        1       1 3       2   1          3 2      2     1
+            ts.Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node.");
+            if (ts.isTemplateLiteralKind(node.kind)) {
+                if (ts.isInsideTemplateLiteral(node, position)) {
+                    return 0;
+                }
+                return spanIndex + 2;
+            }
+            return spanIndex + 1;
+        }
+        function getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile) {
+            // argumentCount is either 1 or (numSpans + 1) to account for the template strings array argument.
+            var argumentCount = tagExpression.template.kind === 11 /* NoSubstitutionTemplateLiteral */
+                ? 1
+                : tagExpression.template.templateSpans.length + 1;
+            ts.Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, "argumentCount < argumentIndex, " + argumentCount + " < " + argumentIndex);
+            return {
+                kind: 2 /* TaggedTemplateArguments */,
+                invocation: tagExpression,
+                argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression, sourceFile),
+                argumentIndex: argumentIndex,
+                argumentCount: argumentCount
+            };
+        }
+        function getApplicableSpanForArguments(argumentsList, sourceFile) {
+            // We use full start and skip trivia on the end because we want to include trivia on
+            // both sides. For example,
+            //
+            //    foo(   /*comment */     a, b, c      /*comment*/     )
+            //        |                                               |
+            //
+            // The applicable span is from the first bar to the second bar (inclusive,
+            // but not including parentheses)
+            var applicableSpanStart = argumentsList.getFullStart();
+            var applicableSpanEnd = ts.skipTrivia(sourceFile.text, argumentsList.getEnd(), /*stopAfterLineBreak*/ false);
+            return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
+        }
+        function getApplicableSpanForTaggedTemplate(taggedTemplate, sourceFile) {
+            var template = taggedTemplate.template;
+            var applicableSpanStart = template.getStart();
+            var applicableSpanEnd = template.getEnd();
+            // We need to adjust the end position for the case where the template does not have a tail.
+            // Otherwise, we will not show signature help past the expression.
+            // For example,
+            //
+            //      `  ${ 1 + 1        foo(10)
+            //       |        |
+            //
+            // This is because a Missing node has no width. However, what we actually want is to include trivia
+            // leading up to the next token in case the user is about to type in a TemplateMiddle or TemplateTail.
+            if (template.kind === 189 /* TemplateExpression */) {
+                var lastSpan = ts.lastOrUndefined(template.templateSpans);
+                if (lastSpan.literal.getFullWidth() === 0) {
+                    applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, /*stopAfterLineBreak*/ false);
+                }
+            }
+            return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
+        }
+        function getContainingArgumentInfo(node, position, sourceFile) {
+            for (var n = node; n.kind !== 256 /* SourceFile */; n = n.parent) {
+                if (ts.isFunctionBlock(n)) {
+                    return undefined;
+                }
+                // If the node is not a subspan of its parent, this is a big problem.
+                // There have been crashes that might be caused by this violation.
+                if (n.pos < n.parent.pos || n.end > n.parent.end) {
+                    ts.Debug.fail("Node of kind " + n.kind + " is not a subspan of its parent of kind " + n.parent.kind);
+                }
+                var argumentInfo = getImmediatelyContainingArgumentInfo(n, position, sourceFile);
+                if (argumentInfo) {
+                    return argumentInfo;
+                }
+            }
+            return undefined;
+        }
+        SignatureHelp.getContainingArgumentInfo = getContainingArgumentInfo;
+        function getChildListThatStartsWithOpenerToken(parent, openerToken, sourceFile) {
+            var children = parent.getChildren(sourceFile);
+            var indexOfOpenerToken = children.indexOf(openerToken);
+            ts.Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1);
+            return children[indexOfOpenerToken + 1];
+        }
+        /**
+         * The selectedItemIndex could be negative for several reasons.
+         *     1. There are too many arguments for all of the overloads
+         *     2. None of the overloads were type compatible
+         * The solution here is to try to pick the best overload by picking
+         * either the first one that has an appropriate number of parameters,
+         * or the one with the most parameters.
+         */
+        function selectBestInvalidOverloadIndex(candidates, argumentCount) {
+            var maxParamsSignatureIndex = -1;
+            var maxParams = -1;
+            for (var i = 0; i < candidates.length; i++) {
+                var candidate = candidates[i];
+                if (candidate.hasRestParameter || candidate.parameters.length >= argumentCount) {
+                    return i;
+                }
+                if (candidate.parameters.length > maxParams) {
+                    maxParams = candidate.parameters.length;
+                    maxParamsSignatureIndex = i;
+                }
+            }
+            return maxParamsSignatureIndex;
+        }
+        function createSignatureHelpItems(candidates, bestSignature, argumentListInfo, typeChecker) {
+            var applicableSpan = argumentListInfo.argumentsSpan;
+            var isTypeParameterList = argumentListInfo.kind === 0 /* TypeArguments */;
+            var invocation = argumentListInfo.invocation;
+            var callTarget = ts.getInvokedExpression(invocation);
+            var callTargetSymbol = typeChecker.getSymbolAtLocation(callTarget);
+            var callTargetDisplayParts = callTargetSymbol && ts.symbolToDisplayParts(typeChecker, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined);
+            var items = ts.map(candidates, function (candidateSignature) {
+                var signatureHelpParameters;
+                var prefixDisplayParts = [];
+                var suffixDisplayParts = [];
+                if (callTargetDisplayParts) {
+                    ts.addRange(prefixDisplayParts, callTargetDisplayParts);
+                }
+                if (isTypeParameterList) {
+                    prefixDisplayParts.push(ts.punctuationPart(25 /* LessThanToken */));
+                    var typeParameters = candidateSignature.typeParameters;
+                    signatureHelpParameters = typeParameters && typeParameters.length > 0 ? ts.map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray;
+                    suffixDisplayParts.push(ts.punctuationPart(27 /* GreaterThanToken */));
+                    var parameterParts = ts.mapToDisplayParts(function (writer) {
+                        return typeChecker.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.thisParameter, candidateSignature.parameters, writer, invocation);
+                    });
+                    ts.addRange(suffixDisplayParts, parameterParts);
+                }
+                else {
+                    var typeParameterParts = ts.mapToDisplayParts(function (writer) {
+                        return typeChecker.getSymbolDisplayBuilder().buildDisplayForTypeParametersAndDelimiters(candidateSignature.typeParameters, writer, invocation);
+                    });
+                    ts.addRange(prefixDisplayParts, typeParameterParts);
+                    prefixDisplayParts.push(ts.punctuationPart(17 /* OpenParenToken */));
+                    var parameters = candidateSignature.parameters;
+                    signatureHelpParameters = parameters.length > 0 ? ts.map(parameters, createSignatureHelpParameterForParameter) : emptyArray;
+                    suffixDisplayParts.push(ts.punctuationPart(18 /* CloseParenToken */));
+                }
+                var returnTypeParts = ts.mapToDisplayParts(function (writer) {
+                    return typeChecker.getSymbolDisplayBuilder().buildReturnTypeDisplay(candidateSignature, writer, invocation);
+                });
+                ts.addRange(suffixDisplayParts, returnTypeParts);
+                return {
+                    isVariadic: candidateSignature.hasRestParameter,
+                    prefixDisplayParts: prefixDisplayParts,
+                    suffixDisplayParts: suffixDisplayParts,
+                    separatorDisplayParts: [ts.punctuationPart(24 /* CommaToken */), ts.spacePart()],
+                    parameters: signatureHelpParameters,
+                    documentation: candidateSignature.getDocumentationComment()
+                };
+            });
+            var argumentIndex = argumentListInfo.argumentIndex;
+            // argumentCount is the *apparent* number of arguments.
+            var argumentCount = argumentListInfo.argumentCount;
+            var selectedItemIndex = candidates.indexOf(bestSignature);
+            if (selectedItemIndex < 0) {
+                selectedItemIndex = selectBestInvalidOverloadIndex(candidates, argumentCount);
+            }
+            ts.Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, "argumentCount < argumentIndex, " + argumentCount + " < " + argumentIndex);
+            return {
+                items: items,
+                applicableSpan: applicableSpan,
+                selectedItemIndex: selectedItemIndex,
+                argumentIndex: argumentIndex,
+                argumentCount: argumentCount
+            };
+            function createSignatureHelpParameterForParameter(parameter) {
+                var displayParts = ts.mapToDisplayParts(function (writer) {
+                    return typeChecker.getSymbolDisplayBuilder().buildParameterDisplay(parameter, writer, invocation);
+                });
+                return {
+                    name: parameter.name,
+                    documentation: parameter.getDocumentationComment(),
+                    displayParts: displayParts,
+                    isOptional: typeChecker.isOptionalParameter(parameter.valueDeclaration)
+                };
+            }
+            function createSignatureHelpParameterForTypeParameter(typeParameter) {
+                var displayParts = ts.mapToDisplayParts(function (writer) {
+                    return typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(typeParameter, writer, invocation);
+                });
+                return {
+                    name: typeParameter.symbol.name,
+                    documentation: emptyArray,
+                    displayParts: displayParts,
+                    isOptional: false
+                };
+            }
+        }
+    })(SignatureHelp = ts.SignatureHelp || (ts.SignatureHelp = {}));
+})(ts || (ts = {}));
+// These utilities are common to multiple language service features.
+/* @internal */
+var ts;
+(function (ts) {
+    function getLineStartPositionForPosition(position, sourceFile) {
+        var lineStarts = sourceFile.getLineStarts();
+        var line = sourceFile.getLineAndCharacterOfPosition(position).line;
+        return lineStarts[line];
+    }
+    ts.getLineStartPositionForPosition = getLineStartPositionForPosition;
+    function rangeContainsRange(r1, r2) {
+        return startEndContainsRange(r1.pos, r1.end, r2);
+    }
+    ts.rangeContainsRange = rangeContainsRange;
+    function startEndContainsRange(start, end, range) {
+        return start <= range.pos && end >= range.end;
+    }
+    ts.startEndContainsRange = startEndContainsRange;
+    function rangeContainsStartEnd(range, start, end) {
+        return range.pos <= start && range.end >= end;
+    }
+    ts.rangeContainsStartEnd = rangeContainsStartEnd;
+    function rangeOverlapsWithStartEnd(r1, start, end) {
+        return startEndOverlapsWithStartEnd(r1.pos, r1.end, start, end);
+    }
+    ts.rangeOverlapsWithStartEnd = rangeOverlapsWithStartEnd;
+    function startEndOverlapsWithStartEnd(start1, end1, start2, end2) {
+        var start = Math.max(start1, start2);
+        var end = Math.min(end1, end2);
+        return start < end;
+    }
+    ts.startEndOverlapsWithStartEnd = startEndOverlapsWithStartEnd;
+    function positionBelongsToNode(candidate, position, sourceFile) {
+        return candidate.end > position || !isCompletedNode(candidate, sourceFile);
+    }
+    ts.positionBelongsToNode = positionBelongsToNode;
+    function isCompletedNode(n, sourceFile) {
+        if (ts.nodeIsMissing(n)) {
+            return false;
+        }
+        switch (n.kind) {
+            case 221 /* ClassDeclaration */:
+            case 222 /* InterfaceDeclaration */:
+            case 224 /* EnumDeclaration */:
+            case 171 /* ObjectLiteralExpression */:
+            case 167 /* ObjectBindingPattern */:
+            case 159 /* TypeLiteral */:
+            case 199 /* Block */:
+            case 226 /* ModuleBlock */:
+            case 227 /* CaseBlock */:
+            case 233 /* NamedImports */:
+            case 237 /* NamedExports */:
+                return nodeEndsWith(n, 16 /* CloseBraceToken */, sourceFile);
+            case 252 /* CatchClause */:
+                return isCompletedNode(n.block, sourceFile);
+            case 175 /* NewExpression */:
+                if (!n.arguments) {
+                    return true;
+                }
+            // fall through
+            case 174 /* CallExpression */:
+            case 178 /* ParenthesizedExpression */:
+            case 164 /* ParenthesizedType */:
+                return nodeEndsWith(n, 18 /* CloseParenToken */, sourceFile);
+            case 156 /* FunctionType */:
+            case 157 /* ConstructorType */:
+                return isCompletedNode(n.type, sourceFile);
+            case 148 /* Constructor */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+            case 220 /* FunctionDeclaration */:
+            case 179 /* FunctionExpression */:
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+            case 152 /* ConstructSignature */:
+            case 151 /* CallSignature */:
+            case 180 /* ArrowFunction */:
+                if (n.body) {
+                    return isCompletedNode(n.body, sourceFile);
+                }
+                if (n.type) {
+                    return isCompletedNode(n.type, sourceFile);
+                }
+                // Even though type parameters can be unclosed, we can get away with
+                // having at least a closing paren.
+                return hasChildOfKind(n, 18 /* CloseParenToken */, sourceFile);
+            case 225 /* ModuleDeclaration */:
+                return n.body && isCompletedNode(n.body, sourceFile);
+            case 203 /* IfStatement */:
+                if (n.elseStatement) {
+                    return isCompletedNode(n.elseStatement, sourceFile);
+                }
+                return isCompletedNode(n.thenStatement, sourceFile);
+            case 202 /* ExpressionStatement */:
+                return isCompletedNode(n.expression, sourceFile) ||
+                    hasChildOfKind(n, 23 /* SemicolonToken */);
+            case 170 /* ArrayLiteralExpression */:
+            case 168 /* ArrayBindingPattern */:
+            case 173 /* ElementAccessExpression */:
+            case 140 /* ComputedPropertyName */:
+            case 161 /* TupleType */:
+                return nodeEndsWith(n, 20 /* CloseBracketToken */, sourceFile);
+            case 153 /* IndexSignature */:
+                if (n.type) {
+                    return isCompletedNode(n.type, sourceFile);
+                }
+                return hasChildOfKind(n, 20 /* CloseBracketToken */, sourceFile);
+            case 249 /* CaseClause */:
+            case 250 /* DefaultClause */:
+                // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicity always consider them non-completed
+                return false;
+            case 206 /* ForStatement */:
+            case 207 /* ForInStatement */:
+            case 208 /* ForOfStatement */:
+            case 205 /* WhileStatement */:
+                return isCompletedNode(n.statement, sourceFile);
+            case 204 /* DoStatement */:
+                // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')';
+                var hasWhileKeyword = findChildOfKind(n, 104 /* WhileKeyword */, sourceFile);
+                if (hasWhileKeyword) {
+                    return nodeEndsWith(n, 18 /* CloseParenToken */, sourceFile);
+                }
+                return isCompletedNode(n.statement, sourceFile);
+            case 158 /* TypeQuery */:
+                return isCompletedNode(n.exprName, sourceFile);
+            case 182 /* TypeOfExpression */:
+            case 181 /* DeleteExpression */:
+            case 183 /* VoidExpression */:
+            case 190 /* YieldExpression */:
+            case 191 /* SpreadElementExpression */:
+                var unaryWordExpression = n;
+                return isCompletedNode(unaryWordExpression.expression, sourceFile);
+            case 176 /* TaggedTemplateExpression */:
+                return isCompletedNode(n.template, sourceFile);
+            case 189 /* TemplateExpression */:
+                var lastSpan = ts.lastOrUndefined(n.templateSpans);
+                return isCompletedNode(lastSpan, sourceFile);
+            case 197 /* TemplateSpan */:
+                return ts.nodeIsPresent(n.literal);
+            case 236 /* ExportDeclaration */:
+            case 230 /* ImportDeclaration */:
+                return ts.nodeIsPresent(n.moduleSpecifier);
+            case 185 /* PrefixUnaryExpression */:
+                return isCompletedNode(n.operand, sourceFile);
+            case 187 /* BinaryExpression */:
+                return isCompletedNode(n.right, sourceFile);
+            case 188 /* ConditionalExpression */:
+                return isCompletedNode(n.whenFalse, sourceFile);
+            default:
+                return true;
+        }
+    }
+    ts.isCompletedNode = isCompletedNode;
+    /*
+     * Checks if node ends with 'expectedLastToken'.
+     * If child at position 'length - 1' is 'SemicolonToken' it is skipped and 'expectedLastToken' is compared with child at position 'length - 2'.
+     */
+    function nodeEndsWith(n, expectedLastToken, sourceFile) {
+        var children = n.getChildren(sourceFile);
+        if (children.length) {
+            var last = ts.lastOrUndefined(children);
+            if (last.kind === expectedLastToken) {
+                return true;
+            }
+            else if (last.kind === 23 /* SemicolonToken */ && children.length !== 1) {
+                return children[children.length - 2].kind === expectedLastToken;
+            }
+        }
+        return false;
+    }
+    function findListItemInfo(node) {
+        var list = findContainingList(node);
+        // It is possible at this point for syntaxList to be undefined, either if
+        // node.parent had no list child, or if none of its list children contained
+        // the span of node. If this happens, return undefined. The caller should
+        // handle this case.
+        if (!list) {
+            return undefined;
+        }
+        var children = list.getChildren();
+        var listItemIndex = ts.indexOf(children, node);
+        return {
+            listItemIndex: listItemIndex,
+            list: list
+        };
+    }
+    ts.findListItemInfo = findListItemInfo;
+    function hasChildOfKind(n, kind, sourceFile) {
+        return !!findChildOfKind(n, kind, sourceFile);
+    }
+    ts.hasChildOfKind = hasChildOfKind;
+    function findChildOfKind(n, kind, sourceFile) {
+        return ts.forEach(n.getChildren(sourceFile), function (c) { return c.kind === kind && c; });
+    }
+    ts.findChildOfKind = findChildOfKind;
+    function findContainingList(node) {
+        // The node might be a list element (nonsynthetic) or a comma (synthetic). Either way, it will
+        // be parented by the container of the SyntaxList, not the SyntaxList itself.
+        // In order to find the list item index, we first need to locate SyntaxList itself and then search
+        // for the position of the relevant node (or comma).
+        var syntaxList = ts.forEach(node.parent.getChildren(), function (c) {
+            // find syntax list that covers the span of the node
+            if (c.kind === 282 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) {
+                return c;
+            }
+        });
+        // Either we didn't find an appropriate list, or the list must contain us.
+        ts.Debug.assert(!syntaxList || ts.contains(syntaxList.getChildren(), node));
+        return syntaxList;
+    }
+    ts.findContainingList = findContainingList;
+    /* Gets the token whose text has range [start, end) and
+     * position >= start and (position < end or (position === end && token is keyword or identifier))
+     */
+    function getTouchingWord(sourceFile, position, includeJsDocComment) {
+        if (includeJsDocComment === void 0) { includeJsDocComment = false; }
+        return getTouchingToken(sourceFile, position, function (n) { return isWord(n.kind); }, includeJsDocComment);
+    }
+    ts.getTouchingWord = getTouchingWord;
+    /* Gets the token whose text has range [start, end) and position >= start
+     * and (position < end or (position === end && token is keyword or identifier or numeric/string literal))
+     */
+    function getTouchingPropertyName(sourceFile, position, includeJsDocComment) {
+        if (includeJsDocComment === void 0) { includeJsDocComment = false; }
+        return getTouchingToken(sourceFile, position, function (n) { return isPropertyName(n.kind); }, includeJsDocComment);
+    }
+    ts.getTouchingPropertyName = getTouchingPropertyName;
+    /** Returns the token if position is in [start, end) or if position === end and includeItemAtEndPosition(token) === true */
+    function getTouchingToken(sourceFile, position, includeItemAtEndPosition, includeJsDocComment) {
+        if (includeJsDocComment === void 0) { includeJsDocComment = false; }
+        return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ false, includeItemAtEndPosition, includeJsDocComment);
+    }
+    ts.getTouchingToken = getTouchingToken;
+    /** Returns a token if position is in [start-of-leading-trivia, end) */
+    function getTokenAtPosition(sourceFile, position, includeJsDocComment) {
+        if (includeJsDocComment === void 0) { includeJsDocComment = false; }
+        return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ true, /*includeItemAtEndPosition*/ undefined, includeJsDocComment);
+    }
+    ts.getTokenAtPosition = getTokenAtPosition;
+    /** Get the token whose text contains the position */
+    function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includeItemAtEndPosition, includeJsDocComment) {
+        if (includeJsDocComment === void 0) { includeJsDocComment = false; }
+        var current = sourceFile;
+        outer: while (true) {
+            if (isToken(current)) {
+                // exit early
+                return current;
+            }
+            if (includeJsDocComment) {
+                var jsDocChildren = ts.filter(current.getChildren(), ts.isJSDocNode);
+                for (var _i = 0, jsDocChildren_1 = jsDocChildren; _i < jsDocChildren_1.length; _i++) {
+                    var jsDocChild = jsDocChildren_1[_i];
+                    var start = allowPositionInLeadingTrivia ? jsDocChild.getFullStart() : jsDocChild.getStart(sourceFile, includeJsDocComment);
+                    if (start <= position) {
+                        var end = jsDocChild.getEnd();
+                        if (position < end || (position === end && jsDocChild.kind === 1 /* EndOfFileToken */)) {
+                            current = jsDocChild;
+                            continue outer;
+                        }
+                        else if (includeItemAtEndPosition && end === position) {
+                            var previousToken = findPrecedingToken(position, sourceFile, jsDocChild);
+                            if (previousToken && includeItemAtEndPosition(previousToken)) {
+                                return previousToken;
+                            }
+                        }
+                    }
+                }
+            }
+            // find the child that contains 'position'
+            for (var i = 0, n = current.getChildCount(sourceFile); i < n; i++) {
+                var child = current.getChildAt(i);
+                // all jsDocComment nodes were already visited
+                if (ts.isJSDocNode(child)) {
+                    continue;
+                }
+                var start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile, includeJsDocComment);
+                if (start <= position) {
+                    var end = child.getEnd();
+                    if (position < end || (position === end && child.kind === 1 /* EndOfFileToken */)) {
+                        current = child;
+                        continue outer;
+                    }
+                    else if (includeItemAtEndPosition && end === position) {
+                        var previousToken = findPrecedingToken(position, sourceFile, child);
+                        if (previousToken && includeItemAtEndPosition(previousToken)) {
+                            return previousToken;
+                        }
+                    }
+                }
+            }
+            return current;
+        }
+    }
+    /**
+      * The token on the left of the position is the token that strictly includes the position
+      * or sits to the left of the cursor if it is on a boundary. For example
+      *
+      *   fo|o               -> will return foo
+      *   foo <comment> |bar -> will return foo
+      *
+      */
+    function findTokenOnLeftOfPosition(file, position) {
+        // Ideally, getTokenAtPosition should return a token. However, it is currently
+        // broken, so we do a check to make sure the result was indeed a token.
+        var tokenAtPosition = getTokenAtPosition(file, position);
+        if (isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) {
+            return tokenAtPosition;
+        }
+        return findPrecedingToken(position, file);
+    }
+    ts.findTokenOnLeftOfPosition = findTokenOnLeftOfPosition;
+    function findNextToken(previousToken, parent) {
+        return find(parent);
+        function find(n) {
+            if (isToken(n) && n.pos === previousToken.end) {
+                // this is token that starts at the end of previous token - return it
+                return n;
+            }
+            var children = n.getChildren();
+            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                var child = children_1[_i];
+                var shouldDiveInChildNode = 
+                // previous token is enclosed somewhere in the child
+                (child.pos <= previousToken.pos && child.end > previousToken.end) ||
+                    // previous token ends exactly at the beginning of child
+                    (child.pos === previousToken.end);
+                if (shouldDiveInChildNode && nodeHasTokens(child)) {
+                    return find(child);
+                }
+            }
+            return undefined;
+        }
+    }
+    ts.findNextToken = findNextToken;
+    function findPrecedingToken(position, sourceFile, startNode) {
+        return find(startNode || sourceFile);
+        function findRightmostToken(n) {
+            if (isToken(n) || n.kind === 244 /* JsxText */) {
+                return n;
+            }
+            var children = n.getChildren();
+            var candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length);
+            return candidate && findRightmostToken(candidate);
+        }
+        function find(n) {
+            if (isToken(n) || n.kind === 244 /* JsxText */) {
+                return n;
+            }
+            var children = n.getChildren();
+            for (var i = 0, len = children.length; i < len; i++) {
+                var child = children[i];
+                // condition 'position < child.end' checks if child node end after the position
+                // in the example below this condition will be false for 'aaaa' and 'bbbb' and true for 'ccc'
+                // aaaa___bbbb___$__ccc
+                // after we found child node with end after the position we check if start of the node is after the position.
+                // if yes - then position is in the trivia and we need to look into the previous child to find the token in question.
+                // if no - position is in the node itself so we should recurse in it.
+                // NOTE: JsxText is a weird kind of node that can contain only whitespaces (since they are not counted as trivia).
+                // if this is the case - then we should assume that token in question is located in previous child.
+                if (position < child.end && (nodeHasTokens(child) || child.kind === 244 /* JsxText */)) {
+                    var start = child.getStart(sourceFile);
+                    var lookInPreviousChild = (start >= position) ||
+                        (child.kind === 244 /* JsxText */ && start === child.end); // whitespace only JsxText
+                    if (lookInPreviousChild) {
+                        // actual start of the node is past the position - previous token should be at the end of previous child
+                        var candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ i);
+                        return candidate && findRightmostToken(candidate);
+                    }
+                    else {
+                        // candidate should be in this node
+                        return find(child);
+                    }
+                }
+            }
+            ts.Debug.assert(startNode !== undefined || n.kind === 256 /* SourceFile */);
+            // Here we know that none of child token nodes embrace the position,
+            // the only known case is when position is at the end of the file.
+            // Try to find the rightmost token in the file without filtering.
+            // Namely we are skipping the check: 'position < node.end'
+            if (children.length) {
+                var candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length);
+                return candidate && findRightmostToken(candidate);
+            }
+        }
+        /// finds last node that is considered as candidate for search (isCandidate(node) === true) starting from 'exclusiveStartPosition'
+        function findRightmostChildNodeWithTokens(children, exclusiveStartPosition) {
+            for (var i = exclusiveStartPosition - 1; i >= 0; i--) {
+                if (nodeHasTokens(children[i])) {
+                    return children[i];
+                }
+            }
+        }
+    }
+    ts.findPrecedingToken = findPrecedingToken;
+    function isInString(sourceFile, position) {
+        var previousToken = findPrecedingToken(position, sourceFile);
+        if (previousToken &&
+            (previousToken.kind === 9 /* StringLiteral */ || previousToken.kind === 166 /* StringLiteralType */)) {
+            var start = previousToken.getStart();
+            var end = previousToken.getEnd();
+            // To be "in" one of these literals, the position has to be:
+            //   1. entirely within the token text.
+            //   2. at the end position of an unterminated token.
+            //   3. at the end of a regular expression (due to trailing flags like '/foo/g').
+            if (start < position && position < end) {
+                return true;
+            }
+            if (position === end) {
+                return !!previousToken.isUnterminated;
+            }
+        }
+        return false;
+    }
+    ts.isInString = isInString;
+    function isInComment(sourceFile, position) {
+        return isInCommentHelper(sourceFile, position, /*predicate*/ undefined);
+    }
+    ts.isInComment = isInComment;
+    /**
+     * returns true if the position is in between the open and close elements of an JSX expression.
+     */
+    function isInsideJsxElementOrAttribute(sourceFile, position) {
+        var token = getTokenAtPosition(sourceFile, position);
+        if (!token) {
+            return false;
+        }
+        if (token.kind === 244 /* JsxText */) {
+            return true;
+        }
+        // <div>Hello |</div>
+        if (token.kind === 25 /* LessThanToken */ && token.parent.kind === 244 /* JsxText */) {
+            return true;
+        }
+        // <div> { | </div> or <div a={| </div>
+        if (token.kind === 25 /* LessThanToken */ && token.parent.kind === 248 /* JsxExpression */) {
+            return true;
+        }
+        // <div> {
+        // |
+        // } < /div>
+        if (token && token.kind === 16 /* CloseBraceToken */ && token.parent.kind === 248 /* JsxExpression */) {
+            return true;
+        }
+        // <div>|</div>
+        if (token.kind === 25 /* LessThanToken */ && token.parent.kind === 245 /* JsxClosingElement */) {
+            return true;
+        }
+        return false;
+    }
+    ts.isInsideJsxElementOrAttribute = isInsideJsxElementOrAttribute;
+    function isInTemplateString(sourceFile, position) {
+        var token = getTokenAtPosition(sourceFile, position);
+        return ts.isTemplateLiteralKind(token.kind) && position > token.getStart(sourceFile);
+    }
+    ts.isInTemplateString = isInTemplateString;
+    /**
+     * Returns true if the cursor at position in sourceFile is within a comment that additionally
+     * satisfies predicate, and false otherwise.
+     */
+    function isInCommentHelper(sourceFile, position, predicate) {
+        var token = getTokenAtPosition(sourceFile, position);
+        if (token && position <= token.getStart(sourceFile)) {
+            var commentRanges = ts.getLeadingCommentRanges(sourceFile.text, token.pos);
+            // The end marker of a single-line comment does not include the newline character.
+            // In the following case, we are inside a comment (^ denotes the cursor position):
+            //
+            //    // asdf   ^\n
+            //
+            // But for multi-line comments, we don't want to be inside the comment in the following case:
+            //
+            //    /* asdf */^
+            //
+            // Internally, we represent the end of the comment at the newline and closing '/', respectively.
+            return predicate ?
+                ts.forEach(commentRanges, function (c) { return c.pos < position &&
+                    (c.kind == 2 /* SingleLineCommentTrivia */ ? position <= c.end : position < c.end) &&
+                    predicate(c); }) :
+                ts.forEach(commentRanges, function (c) { return c.pos < position &&
+                    (c.kind == 2 /* SingleLineCommentTrivia */ ? position <= c.end : position < c.end); });
+        }
+        return false;
+    }
+    ts.isInCommentHelper = isInCommentHelper;
+    function hasDocComment(sourceFile, position) {
+        var token = getTokenAtPosition(sourceFile, position);
+        // First, we have to see if this position actually landed in a comment.
+        var commentRanges = ts.getLeadingCommentRanges(sourceFile.text, token.pos);
+        return ts.forEach(commentRanges, jsDocPrefix);
+        function jsDocPrefix(c) {
+            var text = sourceFile.text;
+            return text.length >= c.pos + 3 && text[c.pos] === "/" && text[c.pos + 1] === "*" && text[c.pos + 2] === "*";
+        }
+    }
+    ts.hasDocComment = hasDocComment;
+    /**
+     * Get the corresponding JSDocTag node if the position is in a jsDoc comment
+     */
+    function getJsDocTagAtPosition(sourceFile, position) {
+        var node = ts.getTokenAtPosition(sourceFile, position);
+        if (isToken(node)) {
+            switch (node.kind) {
+                case 102 /* VarKeyword */:
+                case 108 /* LetKeyword */:
+                case 74 /* ConstKeyword */:
+                    // if the current token is var, let or const, skip the VariableDeclarationList
+                    node = node.parent === undefined ? undefined : node.parent.parent;
+                    break;
+                default:
+                    node = node.parent;
+                    break;
+            }
+        }
+        if (node) {
+            if (node.jsDocComments) {
+                for (var _i = 0, _a = node.jsDocComments; _i < _a.length; _i++) {
+                    var jsDocComment = _a[_i];
+                    for (var _b = 0, _c = jsDocComment.tags; _b < _c.length; _b++) {
+                        var tag = _c[_b];
+                        if (tag.pos <= position && position <= tag.end) {
+                            return tag;
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    ts.getJsDocTagAtPosition = getJsDocTagAtPosition;
+    function nodeHasTokens(n) {
+        // If we have a token or node that has a non-zero width, it must have tokens.
+        // Note, that getWidth() does not take trivia into account.
+        return n.getWidth() !== 0;
+    }
+    function getNodeModifiers(node) {
+        var flags = ts.getCombinedNodeFlags(node);
+        var result = [];
+        if (flags & 8 /* Private */)
+            result.push(ts.ScriptElementKindModifier.privateMemberModifier);
+        if (flags & 16 /* Protected */)
+            result.push(ts.ScriptElementKindModifier.protectedMemberModifier);
+        if (flags & 4 /* Public */)
+            result.push(ts.ScriptElementKindModifier.publicMemberModifier);
+        if (flags & 32 /* Static */)
+            result.push(ts.ScriptElementKindModifier.staticModifier);
+        if (flags & 128 /* Abstract */)
+            result.push(ts.ScriptElementKindModifier.abstractModifier);
+        if (flags & 1 /* Export */)
+            result.push(ts.ScriptElementKindModifier.exportedModifier);
+        if (ts.isInAmbientContext(node))
+            result.push(ts.ScriptElementKindModifier.ambientModifier);
+        return result.length > 0 ? result.join(",") : ts.ScriptElementKindModifier.none;
+    }
+    ts.getNodeModifiers = getNodeModifiers;
+    function getTypeArgumentOrTypeParameterList(node) {
+        if (node.kind === 155 /* TypeReference */ || node.kind === 174 /* CallExpression */) {
+            return node.typeArguments;
+        }
+        if (ts.isFunctionLike(node) || node.kind === 221 /* ClassDeclaration */ || node.kind === 222 /* InterfaceDeclaration */) {
+            return node.typeParameters;
+        }
+        return undefined;
+    }
+    ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList;
+    function isToken(n) {
+        return n.kind >= 0 /* FirstToken */ && n.kind <= 138 /* LastToken */;
+    }
+    ts.isToken = isToken;
+    function isWord(kind) {
+        return kind === 69 /* Identifier */ || ts.isKeyword(kind);
+    }
+    ts.isWord = isWord;
+    function isPropertyName(kind) {
+        return kind === 9 /* StringLiteral */ || kind === 8 /* NumericLiteral */ || isWord(kind);
+    }
+    function isComment(kind) {
+        return kind === 2 /* SingleLineCommentTrivia */ || kind === 3 /* MultiLineCommentTrivia */;
+    }
+    ts.isComment = isComment;
+    function isStringOrRegularExpressionOrTemplateLiteral(kind) {
+        if (kind === 9 /* StringLiteral */
+            || kind === 166 /* StringLiteralType */
+            || kind === 10 /* RegularExpressionLiteral */
+            || ts.isTemplateLiteralKind(kind)) {
+            return true;
+        }
+        return false;
+    }
+    ts.isStringOrRegularExpressionOrTemplateLiteral = isStringOrRegularExpressionOrTemplateLiteral;
+    function isPunctuation(kind) {
+        return 15 /* FirstPunctuation */ <= kind && kind <= 68 /* LastPunctuation */;
+    }
+    ts.isPunctuation = isPunctuation;
+    function isInsideTemplateLiteral(node, position) {
+        return ts.isTemplateLiteralKind(node.kind)
+            && (node.getStart() < position && position < node.getEnd()) || (!!node.isUnterminated && position === node.getEnd());
+    }
+    ts.isInsideTemplateLiteral = isInsideTemplateLiteral;
+    function isAccessibilityModifier(kind) {
+        switch (kind) {
+            case 112 /* PublicKeyword */:
+            case 110 /* PrivateKeyword */:
+            case 111 /* ProtectedKeyword */:
+                return true;
+        }
+        return false;
+    }
+    ts.isAccessibilityModifier = isAccessibilityModifier;
+    function compareDataObjects(dst, src) {
+        for (var e in dst) {
+            if (typeof dst[e] === "object") {
+                if (!compareDataObjects(dst[e], src[e])) {
+                    return false;
+                }
+            }
+            else if (typeof dst[e] !== "function") {
+                if (dst[e] !== src[e]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    ts.compareDataObjects = compareDataObjects;
+    function isArrayLiteralOrObjectLiteralDestructuringPattern(node) {
+        if (node.kind === 170 /* ArrayLiteralExpression */ ||
+            node.kind === 171 /* ObjectLiteralExpression */) {
+            // [a,b,c] from:
+            // [a, b, c] = someExpression;
+            if (node.parent.kind === 187 /* BinaryExpression */ &&
+                node.parent.left === node &&
+                node.parent.operatorToken.kind === 56 /* EqualsToken */) {
+                return true;
+            }
+            // [a, b, c] from:
+            // for([a, b, c] of expression)
+            if (node.parent.kind === 208 /* ForOfStatement */ &&
+                node.parent.initializer === node) {
+                return true;
+            }
+            // [a, b, c] of
+            // [x, [a, b, c] ] = someExpression
+            // or
+            // {x, a: {a, b, c} } = someExpression
+            if (isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.kind === 253 /* PropertyAssignment */ ? node.parent.parent : node.parent)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ts.isArrayLiteralOrObjectLiteralDestructuringPattern = isArrayLiteralOrObjectLiteralDestructuringPattern;
+})(ts || (ts = {}));
+// Display-part writer helpers
+/* @internal */
+var ts;
+(function (ts) {
+    function isFirstDeclarationOfSymbolParameter(symbol) {
+        return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 142 /* Parameter */;
+    }
+    ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter;
+    var displayPartWriter = getDisplayPartWriter();
+    function getDisplayPartWriter() {
+        var displayParts;
+        var lineStart;
+        var indent;
+        resetWriter();
+        return {
+            displayParts: function () { return displayParts; },
+            writeKeyword: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.keyword); },
+            writeOperator: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.operator); },
+            writePunctuation: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.punctuation); },
+            writeSpace: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.space); },
+            writeStringLiteral: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.stringLiteral); },
+            writeParameter: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.parameterName); },
+            writeSymbol: writeSymbol,
+            writeLine: writeLine,
+            increaseIndent: function () { indent++; },
+            decreaseIndent: function () { indent--; },
+            clear: resetWriter,
+            trackSymbol: function () { },
+            reportInaccessibleThisError: function () { }
+        };
+        function writeIndent() {
+            if (lineStart) {
+                var indentString = ts.getIndentString(indent);
+                if (indentString) {
+                    displayParts.push(displayPart(indentString, ts.SymbolDisplayPartKind.space));
+                }
+                lineStart = false;
+            }
+        }
+        function writeKind(text, kind) {
+            writeIndent();
+            displayParts.push(displayPart(text, kind));
+        }
+        function writeSymbol(text, symbol) {
+            writeIndent();
+            displayParts.push(symbolPart(text, symbol));
+        }
+        function writeLine() {
+            displayParts.push(lineBreakPart());
+            lineStart = true;
+        }
+        function resetWriter() {
+            displayParts = [];
+            lineStart = true;
+            indent = 0;
+        }
+    }
+    function symbolPart(text, symbol) {
+        return displayPart(text, displayPartKind(symbol), symbol);
+        function displayPartKind(symbol) {
+            var flags = symbol.flags;
+            if (flags & 3 /* Variable */) {
+                return isFirstDeclarationOfSymbolParameter(symbol) ? ts.SymbolDisplayPartKind.parameterName : ts.SymbolDisplayPartKind.localName;
+            }
+            else if (flags & 4 /* Property */) {
+                return ts.SymbolDisplayPartKind.propertyName;
+            }
+            else if (flags & 32768 /* GetAccessor */) {
+                return ts.SymbolDisplayPartKind.propertyName;
+            }
+            else if (flags & 65536 /* SetAccessor */) {
+                return ts.SymbolDisplayPartKind.propertyName;
+            }
+            else if (flags & 8 /* EnumMember */) {
+                return ts.SymbolDisplayPartKind.enumMemberName;
+            }
+            else if (flags & 16 /* Function */) {
+                return ts.SymbolDisplayPartKind.functionName;
+            }
+            else if (flags & 32 /* Class */) {
+                return ts.SymbolDisplayPartKind.className;
+            }
+            else if (flags & 64 /* Interface */) {
+                return ts.SymbolDisplayPartKind.interfaceName;
+            }
+            else if (flags & 384 /* Enum */) {
+                return ts.SymbolDisplayPartKind.enumName;
+            }
+            else if (flags & 1536 /* Module */) {
+                return ts.SymbolDisplayPartKind.moduleName;
+            }
+            else if (flags & 8192 /* Method */) {
+                return ts.SymbolDisplayPartKind.methodName;
+            }
+            else if (flags & 262144 /* TypeParameter */) {
+                return ts.SymbolDisplayPartKind.typeParameterName;
+            }
+            else if (flags & 524288 /* TypeAlias */) {
+                return ts.SymbolDisplayPartKind.aliasName;
+            }
+            else if (flags & 8388608 /* Alias */) {
+                return ts.SymbolDisplayPartKind.aliasName;
+            }
+            return ts.SymbolDisplayPartKind.text;
+        }
+    }
+    ts.symbolPart = symbolPart;
+    function displayPart(text, kind, symbol) {
+        return {
+            text: text,
+            kind: ts.SymbolDisplayPartKind[kind]
+        };
+    }
+    ts.displayPart = displayPart;
+    function spacePart() {
+        return displayPart(" ", ts.SymbolDisplayPartKind.space);
+    }
+    ts.spacePart = spacePart;
+    function keywordPart(kind) {
+        return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.keyword);
+    }
+    ts.keywordPart = keywordPart;
+    function punctuationPart(kind) {
+        return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.punctuation);
+    }
+    ts.punctuationPart = punctuationPart;
+    function operatorPart(kind) {
+        return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.operator);
+    }
+    ts.operatorPart = operatorPart;
+    function textOrKeywordPart(text) {
+        var kind = ts.stringToToken(text);
+        return kind === undefined
+            ? textPart(text)
+            : keywordPart(kind);
+    }
+    ts.textOrKeywordPart = textOrKeywordPart;
+    function textPart(text) {
+        return displayPart(text, ts.SymbolDisplayPartKind.text);
+    }
+    ts.textPart = textPart;
+    var carriageReturnLineFeed = "\r\n";
+    /**
+     * The default is CRLF.
+     */
+    function getNewLineOrDefaultFromHost(host) {
+        return host.getNewLine ? host.getNewLine() : carriageReturnLineFeed;
+    }
+    ts.getNewLineOrDefaultFromHost = getNewLineOrDefaultFromHost;
+    function lineBreakPart() {
+        return displayPart("\n", ts.SymbolDisplayPartKind.lineBreak);
+    }
+    ts.lineBreakPart = lineBreakPart;
+    function mapToDisplayParts(writeDisplayParts) {
+        writeDisplayParts(displayPartWriter);
+        var result = displayPartWriter.displayParts();
+        displayPartWriter.clear();
+        return result;
+    }
+    ts.mapToDisplayParts = mapToDisplayParts;
+    function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags) {
+        return mapToDisplayParts(function (writer) {
+            typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+        });
+    }
+    ts.typeToDisplayParts = typeToDisplayParts;
+    function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags) {
+        return mapToDisplayParts(function (writer) {
+            typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags);
+        });
+    }
+    ts.symbolToDisplayParts = symbolToDisplayParts;
+    function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags) {
+        return mapToDisplayParts(function (writer) {
+            typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
+        });
+    }
+    ts.signatureToDisplayParts = signatureToDisplayParts;
+    function getDeclaredName(typeChecker, symbol, location) {
+        // If this is an export or import specifier it could have been renamed using the 'as' syntax.
+        // If so we want to search for whatever is under the cursor.
+        if (isImportOrExportSpecifierName(location)) {
+            return location.getText();
+        }
+        else if (ts.isStringOrNumericLiteral(location.kind) &&
+            location.parent.kind === 140 /* ComputedPropertyName */) {
+            return location.text;
+        }
+        // Try to get the local symbol if we're dealing with an 'export default'
+        // since that symbol has the "true" name.
+        var localExportDefaultSymbol = ts.getLocalSymbolForExportDefault(symbol);
+        var name = typeChecker.symbolToString(localExportDefaultSymbol || symbol);
+        return name;
+    }
+    ts.getDeclaredName = getDeclaredName;
+    function isImportOrExportSpecifierName(location) {
+        return location.parent &&
+            (location.parent.kind === 234 /* ImportSpecifier */ || location.parent.kind === 238 /* ExportSpecifier */) &&
+            location.parent.propertyName === location;
+    }
+    ts.isImportOrExportSpecifierName = isImportOrExportSpecifierName;
+    /**
+     * Strip off existed single quotes or double quotes from a given string
+     *
+     * @return non-quoted string
+     */
+    function stripQuotes(name) {
+        var length = name.length;
+        if (length >= 2 &&
+            name.charCodeAt(0) === name.charCodeAt(length - 1) &&
+            (name.charCodeAt(0) === 34 /* doubleQuote */ || name.charCodeAt(0) === 39 /* singleQuote */)) {
+            return name.substring(1, length - 1);
+        }
+        ;
+        return name;
+    }
+    ts.stripQuotes = stripQuotes;
+    function scriptKindIs(fileName, host) {
+        var scriptKinds = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            scriptKinds[_i - 2] = arguments[_i];
+        }
+        var scriptKind = getScriptKind(fileName, host);
+        return ts.forEach(scriptKinds, function (k) { return k === scriptKind; });
+    }
+    ts.scriptKindIs = scriptKindIs;
+    function getScriptKind(fileName, host) {
+        // First check to see if the script kind was specified by the host. Chances are the host
+        // may override the default script kind for the file extension.
+        var scriptKind;
+        if (host && host.getScriptKind) {
+            scriptKind = host.getScriptKind(fileName);
+        }
+        if (!scriptKind || scriptKind === 0 /* Unknown */) {
+            scriptKind = ts.getScriptKindFromFileName(fileName);
+        }
+        return ts.ensureScriptKind(fileName, scriptKind);
+    }
+    ts.getScriptKind = getScriptKind;
+})(ts || (ts = {}));
+// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
+// See LICENSE.txt in the project root for complete license information.
+/// <reference path='services.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var JsTyping;
+    (function (JsTyping) {
+        ;
+        ;
+        // A map of loose file names to library names
+        // that we are confident require typings
+        var safeList;
+        /**
+         * @param host is the object providing I/O related operations.
+         * @param fileNames are the file names that belong to the same project
+         * @param projectRootPath is the path to the project root directory
+         * @param safeListPath is the path used to retrieve the safe list
+         * @param packageNameToTypingLocation is the map of package names to their cached typing locations
+         * @param typingOptions are used to customize the typing inference process
+         * @param compilerOptions are used as a source for typing inference
+         */
+        function discoverTypings(host, fileNames, projectRootPath, safeListPath, packageNameToTypingLocation, typingOptions, compilerOptions) {
+            // A typing name to typing file path mapping
+            var inferredTypings = {};
+            if (!typingOptions || !typingOptions.enableAutoDiscovery) {
+                return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
+            }
+            // Only infer typings for .js and .jsx files
+            fileNames = ts.filter(ts.map(fileNames, ts.normalizePath), function (f) { return ts.scriptKindIs(f, /*LanguageServiceHost*/ undefined, 1 /* JS */, 2 /* JSX */); });
+            if (!safeList) {
+                var result = ts.readConfigFile(safeListPath, function (path) { return host.readFile(path); });
+                if (result.config) {
+                    safeList = result.config;
+                }
+                else {
+                    safeList = {};
+                }
+                ;
+            }
+            var filesToWatch = [];
+            // Directories to search for package.json, bower.json and other typing information
+            var searchDirs = [];
+            var exclude = [];
+            mergeTypings(typingOptions.include);
+            exclude = typingOptions.exclude || [];
+            var possibleSearchDirs = ts.map(fileNames, ts.getDirectoryPath);
+            if (projectRootPath !== undefined) {
+                possibleSearchDirs.push(projectRootPath);
+            }
+            searchDirs = ts.deduplicate(possibleSearchDirs);
+            for (var _i = 0, searchDirs_1 = searchDirs; _i < searchDirs_1.length; _i++) {
+                var searchDir = searchDirs_1[_i];
+                var packageJsonPath = ts.combinePaths(searchDir, "package.json");
+                getTypingNamesFromJson(packageJsonPath, filesToWatch);
+                var bowerJsonPath = ts.combinePaths(searchDir, "bower.json");
+                getTypingNamesFromJson(bowerJsonPath, filesToWatch);
+                var nodeModulesPath = ts.combinePaths(searchDir, "node_modules");
+                getTypingNamesFromNodeModuleFolder(nodeModulesPath);
+            }
+            getTypingNamesFromSourceFileNames(fileNames);
+            // Add the cached typing locations for inferred typings that are already installed
+            for (var name_39 in packageNameToTypingLocation) {
+                if (ts.hasProperty(inferredTypings, name_39) && !inferredTypings[name_39]) {
+                    inferredTypings[name_39] = packageNameToTypingLocation[name_39];
+                }
+            }
+            // Remove typings that the user has added to the exclude list
+            for (var _a = 0, exclude_1 = exclude; _a < exclude_1.length; _a++) {
+                var excludeTypingName = exclude_1[_a];
+                delete inferredTypings[excludeTypingName];
+            }
+            var newTypingNames = [];
+            var cachedTypingPaths = [];
+            for (var typing in inferredTypings) {
+                if (inferredTypings[typing] !== undefined) {
+                    cachedTypingPaths.push(inferredTypings[typing]);
+                }
+                else {
+                    newTypingNames.push(typing);
+                }
+            }
+            return { cachedTypingPaths: cachedTypingPaths, newTypingNames: newTypingNames, filesToWatch: filesToWatch };
+            /**
+             * Merge a given list of typingNames to the inferredTypings map
+             */
+            function mergeTypings(typingNames) {
+                if (!typingNames) {
+                    return;
+                }
+                for (var _i = 0, typingNames_1 = typingNames; _i < typingNames_1.length; _i++) {
+                    var typing = typingNames_1[_i];
+                    if (!ts.hasProperty(inferredTypings, typing)) {
+                        inferredTypings[typing] = undefined;
+                    }
+                }
+            }
+            /**
+             * Get the typing info from common package manager json files like package.json or bower.json
+             */
+            function getTypingNamesFromJson(jsonPath, filesToWatch) {
+                var result = ts.readConfigFile(jsonPath, function (path) { return host.readFile(path); });
+                if (result.config) {
+                    var jsonConfig = result.config;
+                    filesToWatch.push(jsonPath);
+                    if (jsonConfig.dependencies) {
+                        mergeTypings(ts.getKeys(jsonConfig.dependencies));
+                    }
+                    if (jsonConfig.devDependencies) {
+                        mergeTypings(ts.getKeys(jsonConfig.devDependencies));
+                    }
+                    if (jsonConfig.optionalDependencies) {
+                        mergeTypings(ts.getKeys(jsonConfig.optionalDependencies));
+                    }
+                    if (jsonConfig.peerDependencies) {
+                        mergeTypings(ts.getKeys(jsonConfig.peerDependencies));
+                    }
+                }
+            }
+            /**
+             * Infer typing names from given file names. For example, the file name "jquery-min.2.3.4.js"
+             * should be inferred to the 'jquery' typing name; and "angular-route.1.2.3.js" should be inferred
+             * to the 'angular-route' typing name.
+             * @param fileNames are the names for source files in the project
+             */
+            function getTypingNamesFromSourceFileNames(fileNames) {
+                var jsFileNames = ts.filter(fileNames, ts.hasJavaScriptFileExtension);
+                var inferredTypingNames = ts.map(jsFileNames, function (f) { return ts.removeFileExtension(ts.getBaseFileName(f.toLowerCase())); });
+                var cleanedTypingNames = ts.map(inferredTypingNames, function (f) { return f.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, ""); });
+                if (safeList === undefined) {
+                    mergeTypings(cleanedTypingNames);
+                }
+                else {
+                    mergeTypings(ts.filter(cleanedTypingNames, function (f) { return ts.hasProperty(safeList, f); }));
+                }
+                var hasJsxFile = ts.forEach(fileNames, function (f) { return ts.scriptKindIs(f, /*LanguageServiceHost*/ undefined, 2 /* JSX */); });
+                if (hasJsxFile) {
+                    mergeTypings(["react"]);
+                }
+            }
+            /**
+             * Infer typing names from node_module folder
+             * @param nodeModulesPath is the path to the "node_modules" folder
+             */
+            function getTypingNamesFromNodeModuleFolder(nodeModulesPath) {
+                // Todo: add support for ModuleResolutionHost too
+                if (!host.directoryExists(nodeModulesPath)) {
+                    return;
+                }
+                var typingNames = [];
+                var fileNames = host.readDirectory(nodeModulesPath, ["*.json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2);
+                for (var _i = 0, fileNames_2 = fileNames; _i < fileNames_2.length; _i++) {
+                    var fileName = fileNames_2[_i];
+                    var normalizedFileName = ts.normalizePath(fileName);
+                    if (ts.getBaseFileName(normalizedFileName) !== "package.json") {
+                        continue;
+                    }
+                    var result = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); });
+                    if (!result.config) {
+                        continue;
+                    }
+                    var packageJson = result.config;
+                    // npm 3's package.json contains a "_requiredBy" field
+                    // we should include all the top level module names for npm 2, and only module names whose
+                    // "_requiredBy" field starts with "#" or equals "/" for npm 3.
+                    if (packageJson._requiredBy &&
+                        ts.filter(packageJson._requiredBy, function (r) { return r[0] === "#" || r === "/"; }).length === 0) {
+                        continue;
+                    }
+                    // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
+                    // to download d.ts files from DefinitelyTyped
+                    if (!packageJson.name) {
+                        continue;
+                    }
+                    if (packageJson.typings) {
+                        var absolutePath = ts.getNormalizedAbsolutePath(packageJson.typings, ts.getDirectoryPath(normalizedFileName));
+                        inferredTypings[packageJson.name] = absolutePath;
+                    }
+                    else {
+                        typingNames.push(packageJson.name);
+                    }
+                }
+                mergeTypings(typingNames);
+            }
+        }
+        JsTyping.discoverTypings = discoverTypings;
+    })(JsTyping = ts.JsTyping || (ts.JsTyping = {}));
+})(ts || (ts = {}));
+/// <reference path="formatting.ts"/>
+/// <reference path="..\..\compiler\scanner.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var standardScanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ false, 0 /* Standard */);
+        var jsxScanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ false, 1 /* JSX */);
+        /**
+         * Scanner that is currently used for formatting
+         */
+        var scanner;
+        var ScanAction;
+        (function (ScanAction) {
+            ScanAction[ScanAction["Scan"] = 0] = "Scan";
+            ScanAction[ScanAction["RescanGreaterThanToken"] = 1] = "RescanGreaterThanToken";
+            ScanAction[ScanAction["RescanSlashToken"] = 2] = "RescanSlashToken";
+            ScanAction[ScanAction["RescanTemplateToken"] = 3] = "RescanTemplateToken";
+            ScanAction[ScanAction["RescanJsxIdentifier"] = 4] = "RescanJsxIdentifier";
+        })(ScanAction || (ScanAction = {}));
+        function getFormattingScanner(sourceFile, startPos, endPos) {
+            ts.Debug.assert(scanner === undefined);
+            scanner = sourceFile.languageVariant === 1 /* JSX */ ? jsxScanner : standardScanner;
+            scanner.setText(sourceFile.text);
+            scanner.setTextPos(startPos);
+            var wasNewLine = true;
+            var leadingTrivia;
+            var trailingTrivia;
+            var savedPos;
+            var lastScanAction;
+            var lastTokenInfo;
+            return {
+                advance: advance,
+                readTokenInfo: readTokenInfo,
+                isOnToken: isOnToken,
+                getCurrentLeadingTrivia: function () { return leadingTrivia; },
+                lastTrailingTriviaWasNewLine: function () { return wasNewLine; },
+                skipToEndOf: skipToEndOf,
+                close: function () {
+                    ts.Debug.assert(scanner !== undefined);
+                    lastTokenInfo = undefined;
+                    scanner.setText(undefined);
+                    scanner = undefined;
+                }
+            };
+            function advance() {
+                ts.Debug.assert(scanner !== undefined);
+                lastTokenInfo = undefined;
+                var isStarted = scanner.getStartPos() !== startPos;
+                if (isStarted) {
+                    if (trailingTrivia) {
+                        ts.Debug.assert(trailingTrivia.length !== 0);
+                        wasNewLine = ts.lastOrUndefined(trailingTrivia).kind === 4 /* NewLineTrivia */;
+                    }
+                    else {
+                        wasNewLine = false;
+                    }
+                }
+                leadingTrivia = undefined;
+                trailingTrivia = undefined;
+                if (!isStarted) {
+                    scanner.scan();
+                }
+                var pos = scanner.getStartPos();
+                // Read leading trivia and token
+                while (pos < endPos) {
+                    var t = scanner.getToken();
+                    if (!ts.isTrivia(t)) {
+                        break;
+                    }
+                    // consume leading trivia
+                    scanner.scan();
+                    var item = {
+                        pos: pos,
+                        end: scanner.getStartPos(),
+                        kind: t
+                    };
+                    pos = scanner.getStartPos();
+                    if (!leadingTrivia) {
+                        leadingTrivia = [];
+                    }
+                    leadingTrivia.push(item);
+                }
+                savedPos = scanner.getStartPos();
+            }
+            function shouldRescanGreaterThanToken(node) {
+                if (node) {
+                    switch (node.kind) {
+                        case 29 /* GreaterThanEqualsToken */:
+                        case 64 /* GreaterThanGreaterThanEqualsToken */:
+                        case 65 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
+                        case 45 /* GreaterThanGreaterThanGreaterThanToken */:
+                        case 44 /* GreaterThanGreaterThanToken */:
+                            return true;
+                    }
+                }
+                return false;
+            }
+            function shouldRescanJsxIdentifier(node) {
+                if (node.parent) {
+                    switch (node.parent.kind) {
+                        case 246 /* JsxAttribute */:
+                        case 243 /* JsxOpeningElement */:
+                        case 245 /* JsxClosingElement */:
+                        case 242 /* JsxSelfClosingElement */:
+                            return node.kind === 69 /* Identifier */;
+                    }
+                }
+                return false;
+            }
+            function shouldRescanSlashToken(container) {
+                return container.kind === 10 /* RegularExpressionLiteral */;
+            }
+            function shouldRescanTemplateToken(container) {
+                return container.kind === 13 /* TemplateMiddle */ ||
+                    container.kind === 14 /* TemplateTail */;
+            }
+            function startsWithSlashToken(t) {
+                return t === 39 /* SlashToken */ || t === 61 /* SlashEqualsToken */;
+            }
+            function readTokenInfo(n) {
+                ts.Debug.assert(scanner !== undefined);
+                if (!isOnToken()) {
+                    // scanner is not on the token (either advance was not called yet or scanner is already past the end position)
+                    return {
+                        leadingTrivia: leadingTrivia,
+                        trailingTrivia: undefined,
+                        token: undefined
+                    };
+                }
+                // normally scanner returns the smallest available token
+                // check the kind of context node to determine if scanner should have more greedy behavior and consume more text.
+                var expectedScanAction = shouldRescanGreaterThanToken(n)
+                    ? 1 /* RescanGreaterThanToken */
+                    : shouldRescanSlashToken(n)
+                        ? 2 /* RescanSlashToken */
+                        : shouldRescanTemplateToken(n)
+                            ? 3 /* RescanTemplateToken */
+                            : shouldRescanJsxIdentifier(n)
+                                ? 4 /* RescanJsxIdentifier */
+                                : 0 /* Scan */;
+                if (lastTokenInfo && expectedScanAction === lastScanAction) {
+                    // readTokenInfo was called before with the same expected scan action.
+                    // No need to re-scan text, return existing 'lastTokenInfo'
+                    // it is ok to call fixTokenKind here since it does not affect
+                    // what portion of text is consumed. In contrast rescanning can change it,
+                    // i.e. for '>=' when originally scanner eats just one character
+                    // and rescanning forces it to consume more.
+                    return fixTokenKind(lastTokenInfo, n);
+                }
+                if (scanner.getStartPos() !== savedPos) {
+                    ts.Debug.assert(lastTokenInfo !== undefined);
+                    // readTokenInfo was called before but scan action differs - rescan text
+                    scanner.setTextPos(savedPos);
+                    scanner.scan();
+                }
+                var currentToken = scanner.getToken();
+                if (expectedScanAction === 1 /* RescanGreaterThanToken */ && currentToken === 27 /* GreaterThanToken */) {
+                    currentToken = scanner.reScanGreaterToken();
+                    ts.Debug.assert(n.kind === currentToken);
+                    lastScanAction = 1 /* RescanGreaterThanToken */;
+                }
+                else if (expectedScanAction === 2 /* RescanSlashToken */ && startsWithSlashToken(currentToken)) {
+                    currentToken = scanner.reScanSlashToken();
+                    ts.Debug.assert(n.kind === currentToken);
+                    lastScanAction = 2 /* RescanSlashToken */;
+                }
+                else if (expectedScanAction === 3 /* RescanTemplateToken */ && currentToken === 16 /* CloseBraceToken */) {
+                    currentToken = scanner.reScanTemplateToken();
+                    lastScanAction = 3 /* RescanTemplateToken */;
+                }
+                else if (expectedScanAction === 4 /* RescanJsxIdentifier */ && currentToken === 69 /* Identifier */) {
+                    currentToken = scanner.scanJsxIdentifier();
+                    lastScanAction = 4 /* RescanJsxIdentifier */;
+                }
+                else {
+                    lastScanAction = 0 /* Scan */;
+                }
+                var token = {
+                    pos: scanner.getStartPos(),
+                    end: scanner.getTextPos(),
+                    kind: currentToken
+                };
+                // consume trailing trivia
+                if (trailingTrivia) {
+                    trailingTrivia = undefined;
+                }
+                while (scanner.getStartPos() < endPos) {
+                    currentToken = scanner.scan();
+                    if (!ts.isTrivia(currentToken)) {
+                        break;
+                    }
+                    var trivia = {
+                        pos: scanner.getStartPos(),
+                        end: scanner.getTextPos(),
+                        kind: currentToken
+                    };
+                    if (!trailingTrivia) {
+                        trailingTrivia = [];
+                    }
+                    trailingTrivia.push(trivia);
+                    if (currentToken === 4 /* NewLineTrivia */) {
+                        // move past new line
+                        scanner.scan();
+                        break;
+                    }
+                }
+                lastTokenInfo = {
+                    leadingTrivia: leadingTrivia,
+                    trailingTrivia: trailingTrivia,
+                    token: token
+                };
+                return fixTokenKind(lastTokenInfo, n);
+            }
+            function isOnToken() {
+                ts.Debug.assert(scanner !== undefined);
+                var current = (lastTokenInfo && lastTokenInfo.token.kind) || scanner.getToken();
+                var startPos = (lastTokenInfo && lastTokenInfo.token.pos) || scanner.getStartPos();
+                return startPos < endPos && current !== 1 /* EndOfFileToken */ && !ts.isTrivia(current);
+            }
+            // when containing node in the tree is token
+            // but its kind differs from the kind that was returned by the scanner,
+            // then kind needs to be fixed. This might happen in cases
+            // when parser interprets token differently, i.e keyword treated as identifier
+            function fixTokenKind(tokenInfo, container) {
+                if (ts.isToken(container) && tokenInfo.token.kind !== container.kind) {
+                    tokenInfo.token.kind = container.kind;
+                }
+                return tokenInfo;
+            }
+            function skipToEndOf(node) {
+                scanner.setTextPos(node.end);
+                savedPos = scanner.getStartPos();
+                lastScanAction = undefined;
+                lastTokenInfo = undefined;
+                wasNewLine = false;
+                leadingTrivia = undefined;
+                trailingTrivia = undefined;
+            }
+        }
+        formatting.getFormattingScanner = getFormattingScanner;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+/// <reference path="references.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var FormattingContext = (function () {
+            function FormattingContext(sourceFile, formattingRequestKind) {
+                this.sourceFile = sourceFile;
+                this.formattingRequestKind = formattingRequestKind;
+            }
+            FormattingContext.prototype.updateContext = function (currentRange, currentTokenParent, nextRange, nextTokenParent, commonParent) {
+                ts.Debug.assert(currentRange !== undefined, "currentTokenSpan is null");
+                ts.Debug.assert(currentTokenParent !== undefined, "currentTokenParent is null");
+                ts.Debug.assert(nextRange !== undefined, "nextTokenSpan is null");
+                ts.Debug.assert(nextTokenParent !== undefined, "nextTokenParent is null");
+                ts.Debug.assert(commonParent !== undefined, "commonParent is null");
+                this.currentTokenSpan = currentRange;
+                this.currentTokenParent = currentTokenParent;
+                this.nextTokenSpan = nextRange;
+                this.nextTokenParent = nextTokenParent;
+                this.contextNode = commonParent;
+                // drop cached results
+                this.contextNodeAllOnSameLine = undefined;
+                this.nextNodeAllOnSameLine = undefined;
+                this.tokensAreOnSameLine = undefined;
+                this.contextNodeBlockIsOnOneLine = undefined;
+                this.nextNodeBlockIsOnOneLine = undefined;
+            };
+            FormattingContext.prototype.ContextNodeAllOnSameLine = function () {
+                if (this.contextNodeAllOnSameLine === undefined) {
+                    this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode);
+                }
+                return this.contextNodeAllOnSameLine;
+            };
+            FormattingContext.prototype.NextNodeAllOnSameLine = function () {
+                if (this.nextNodeAllOnSameLine === undefined) {
+                    this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent);
+                }
+                return this.nextNodeAllOnSameLine;
+            };
+            FormattingContext.prototype.TokensAreOnSameLine = function () {
+                if (this.tokensAreOnSameLine === undefined) {
+                    var startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line;
+                    var endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line;
+                    this.tokensAreOnSameLine = (startLine === endLine);
+                }
+                return this.tokensAreOnSameLine;
+            };
+            FormattingContext.prototype.ContextNodeBlockIsOnOneLine = function () {
+                if (this.contextNodeBlockIsOnOneLine === undefined) {
+                    this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode);
+                }
+                return this.contextNodeBlockIsOnOneLine;
+            };
+            FormattingContext.prototype.NextNodeBlockIsOnOneLine = function () {
+                if (this.nextNodeBlockIsOnOneLine === undefined) {
+                    this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent);
+                }
+                return this.nextNodeBlockIsOnOneLine;
+            };
+            FormattingContext.prototype.NodeIsOnOneLine = function (node) {
+                var startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line;
+                var endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
+                return startLine === endLine;
+            };
+            FormattingContext.prototype.BlockIsOnOneLine = function (node) {
+                var openBrace = ts.findChildOfKind(node, 15 /* OpenBraceToken */, this.sourceFile);
+                var closeBrace = ts.findChildOfKind(node, 16 /* CloseBraceToken */, this.sourceFile);
+                if (openBrace && closeBrace) {
+                    var startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line;
+                    var endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line;
+                    return startLine === endLine;
+                }
+                return false;
+            };
+            return FormattingContext;
+        }());
+        formatting.FormattingContext = FormattingContext;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+/// <reference path="references.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        (function (FormattingRequestKind) {
+            FormattingRequestKind[FormattingRequestKind["FormatDocument"] = 0] = "FormatDocument";
+            FormattingRequestKind[FormattingRequestKind["FormatSelection"] = 1] = "FormatSelection";
+            FormattingRequestKind[FormattingRequestKind["FormatOnEnter"] = 2] = "FormatOnEnter";
+            FormattingRequestKind[FormattingRequestKind["FormatOnSemicolon"] = 3] = "FormatOnSemicolon";
+            FormattingRequestKind[FormattingRequestKind["FormatOnClosingCurlyBrace"] = 4] = "FormatOnClosingCurlyBrace";
+        })(formatting.FormattingRequestKind || (formatting.FormattingRequestKind = {}));
+        var FormattingRequestKind = formatting.FormattingRequestKind;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var Rule = (function () {
+            function Rule(Descriptor, Operation, Flag) {
+                if (Flag === void 0) { Flag = 0 /* None */; }
+                this.Descriptor = Descriptor;
+                this.Operation = Operation;
+                this.Flag = Flag;
+            }
+            Rule.prototype.toString = function () {
+                return "[desc=" + this.Descriptor + "," +
+                    "operation=" + this.Operation + "," +
+                    "flag=" + this.Flag + "]";
+            };
+            return Rule;
+        }());
+        formatting.Rule = Rule;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        (function (RuleAction) {
+            RuleAction[RuleAction["Ignore"] = 1] = "Ignore";
+            RuleAction[RuleAction["Space"] = 2] = "Space";
+            RuleAction[RuleAction["NewLine"] = 4] = "NewLine";
+            RuleAction[RuleAction["Delete"] = 8] = "Delete";
+        })(formatting.RuleAction || (formatting.RuleAction = {}));
+        var RuleAction = formatting.RuleAction;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var RuleDescriptor = (function () {
+            function RuleDescriptor(LeftTokenRange, RightTokenRange) {
+                this.LeftTokenRange = LeftTokenRange;
+                this.RightTokenRange = RightTokenRange;
+            }
+            RuleDescriptor.prototype.toString = function () {
+                return "[leftRange=" + this.LeftTokenRange + "," +
+                    "rightRange=" + this.RightTokenRange + "]";
+            };
+            RuleDescriptor.create1 = function (left, right) {
+                return RuleDescriptor.create4(formatting.Shared.TokenRange.FromToken(left), formatting.Shared.TokenRange.FromToken(right));
+            };
+            RuleDescriptor.create2 = function (left, right) {
+                return RuleDescriptor.create4(left, formatting.Shared.TokenRange.FromToken(right));
+            };
+            RuleDescriptor.create3 = function (left, right) {
+                return RuleDescriptor.create4(formatting.Shared.TokenRange.FromToken(left), right);
+            };
+            RuleDescriptor.create4 = function (left, right) {
+                return new RuleDescriptor(left, right);
+            };
+            return RuleDescriptor;
+        }());
+        formatting.RuleDescriptor = RuleDescriptor;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        (function (RuleFlags) {
+            RuleFlags[RuleFlags["None"] = 0] = "None";
+            RuleFlags[RuleFlags["CanDeleteNewLines"] = 1] = "CanDeleteNewLines";
+        })(formatting.RuleFlags || (formatting.RuleFlags = {}));
+        var RuleFlags = formatting.RuleFlags;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var RuleOperation = (function () {
+            function RuleOperation(Context, Action) {
+                this.Context = Context;
+                this.Action = Action;
+            }
+            RuleOperation.prototype.toString = function () {
+                return "[context=" + this.Context + "," +
+                    "action=" + this.Action + "]";
+            };
+            RuleOperation.create1 = function (action) {
+                return RuleOperation.create2(formatting.RuleOperationContext.Any, action);
+            };
+            RuleOperation.create2 = function (context, action) {
+                return new RuleOperation(context, action);
+            };
+            return RuleOperation;
+        }());
+        formatting.RuleOperation = RuleOperation;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var RuleOperationContext = (function () {
+            function RuleOperationContext() {
+                var funcs = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    funcs[_i - 0] = arguments[_i];
+                }
+                this.customContextChecks = funcs;
+            }
+            RuleOperationContext.prototype.IsAny = function () {
+                return this === RuleOperationContext.Any;
+            };
+            RuleOperationContext.prototype.InContext = function (context) {
+                if (this.IsAny()) {
+                    return true;
+                }
+                for (var _i = 0, _a = this.customContextChecks; _i < _a.length; _i++) {
+                    var check = _a[_i];
+                    if (!check(context)) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            RuleOperationContext.Any = new RuleOperationContext();
+            return RuleOperationContext;
+        }());
+        formatting.RuleOperationContext = RuleOperationContext;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var Rules = (function () {
+            function Rules() {
+                ///
+                /// Common Rules
+                ///
+                // Leave comments alone
+                this.IgnoreBeforeComment = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.Comments), formatting.RuleOperation.create1(1 /* Ignore */));
+                this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2 /* SingleLineCommentTrivia */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1 /* Ignore */));
+                // Space after keyword but not before ; or : or ?
+                this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23 /* SemicolonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 54 /* ColonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */));
+                this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 53 /* QuestionToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */));
+                this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(54 /* ColonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(53 /* QuestionToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsConditionalOperatorContext), 2 /* Space */));
+                this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(53 /* QuestionToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(23 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                // Space after }.
+                this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(16 /* CloseBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2 /* Space */));
+                // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied
+                this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(16 /* CloseBraceToken */, 80 /* ElseKeyword */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceBetweenCloseBraceAndWhile = new formatting.Rule(formatting.RuleDescriptor.create1(16 /* CloseBraceToken */, 104 /* WhileKeyword */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.NoSpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(16 /* CloseBraceToken */, formatting.Shared.TokenRange.FromTokens([18 /* CloseParenToken */, 20 /* CloseBracketToken */, 24 /* CommaToken */, 23 /* SemicolonToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // No space for dot
+                this.NoSpaceBeforeDot = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 21 /* DotToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterDot = new formatting.Rule(formatting.RuleDescriptor.create3(21 /* DotToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // No space before and after indexer
+                this.NoSpaceBeforeOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19 /* OpenBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(20 /* CloseBracketToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBeforeBlockInFunctionDeclarationContext), 8 /* Delete */));
+                // Place a space before open brace in a function declaration
+                this.FunctionOpenBraceLeftTokenRange = formatting.Shared.TokenRange.AnyIncludingMultilineComments;
+                this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */);
+                // Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc)
+                this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([69 /* Identifier */, 3 /* MultiLineCommentTrivia */, 73 /* ClassKeyword */, 82 /* ExportKeyword */, 89 /* ImportKeyword */]);
+                this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */);
+                // Place a space before open brace in a control flow construct
+                this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([18 /* CloseParenToken */, 3 /* MultiLineCommentTrivia */, 79 /* DoKeyword */, 100 /* TryKeyword */, 85 /* FinallyKeyword */, 80 /* ElseKeyword */]);
+                this.SpaceBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2 /* Space */), 1 /* CanDeleteNewLines */);
+                // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
+                this.SpaceAfterOpenBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2 /* Space */));
+                this.SpaceBeforeCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2 /* Space */));
+                this.NoSpaceBetweenEmptyBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(15 /* OpenBraceToken */, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsObjectContext), 8 /* Delete */));
+                // Insert new line after { and before } in multi-line contexts.
+                this.NewLineAfterOpenBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4 /* NewLine */));
+                // For functions and control block place } on a new line    [multi-line rule]
+                this.NewLineBeforeCloseBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.AnyIncludingMultilineComments, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4 /* NewLine */));
+                // Special handling of unary operators.
+                // Prefix operators generally shouldn't have a space between
+                // them and their target unary expression.
+                this.NoSpaceAfterUnaryPrefixOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.UnaryPrefixOperators, formatting.Shared.TokenRange.UnaryPrefixExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */));
+                this.NoSpaceAfterUnaryPreincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(41 /* PlusPlusToken */, formatting.Shared.TokenRange.UnaryPreincrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterUnaryPredecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(42 /* MinusMinusToken */, formatting.Shared.TokenRange.UnaryPredecrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceBeforeUnaryPostincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostincrementExpressions, 41 /* PlusPlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceBeforeUnaryPostdecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostdecrementExpressions, 42 /* MinusMinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // More unary operator special-casing.
+                // DevDiv 181814:  Be careful when removing leading whitespace
+                // around unary operators.  Examples:
+                //      1 - -2  --X-->  1--2
+                //      a + ++b --X-->  a+++b
+                this.SpaceAfterPostincrementWhenFollowedByAdd = new formatting.Rule(formatting.RuleDescriptor.create1(41 /* PlusPlusToken */, 35 /* PlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterAddWhenFollowedByUnaryPlus = new formatting.Rule(formatting.RuleDescriptor.create1(35 /* PlusToken */, 35 /* PlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterAddWhenFollowedByPreincrement = new formatting.Rule(formatting.RuleDescriptor.create1(35 /* PlusToken */, 41 /* PlusPlusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterPostdecrementWhenFollowedBySubtract = new formatting.Rule(formatting.RuleDescriptor.create1(42 /* MinusMinusToken */, 36 /* MinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new formatting.Rule(formatting.RuleDescriptor.create1(36 /* MinusToken */, 36 /* MinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(36 /* MinusToken */, 42 /* MinusMinusToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 24 /* CommaToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([102 /* VarKeyword */, 98 /* ThrowKeyword */, 92 /* NewKeyword */, 78 /* DeleteKeyword */, 94 /* ReturnKeyword */, 101 /* TypeOfKeyword */, 119 /* AwaitKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([108 /* LetKeyword */, 74 /* ConstKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2 /* Space */));
+                this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8 /* Delete */));
+                this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(87 /* FunctionKeyword */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */));
+                this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsFunctionDeclContext), 8 /* Delete */));
+                this.SpaceAfterVoidOperator = new formatting.Rule(formatting.RuleDescriptor.create3(103 /* VoidKeyword */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsVoidOpContext), 2 /* Space */));
+                this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(94 /* ReturnKeyword */, 23 /* SemicolonToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // Add a space between statements. All keywords except (do,else,case) has open/close parens after them.
+                // So, we have a rule to add a space for [),Any], [do,Any], [else,Any], and [case,Any]
+                this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([18 /* CloseParenToken */, 79 /* DoKeyword */, 80 /* ElseKeyword */, 71 /* CaseKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isNonJsxElementContext, Rules.IsNotForContext), 2 /* Space */));
+                // This low-pri rule takes care of "try {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter.
+                this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([100 /* TryKeyword */, 85 /* FinallyKeyword */]), 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                //      get x() {}
+                //      set x(val) {}
+                this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([123 /* GetKeyword */, 131 /* SetKeyword */]), 69 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */));
+                // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options.
+                this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                // TypeScript-specific higher priority rules
+                // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses
+                this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(121 /* ConstructorKeyword */, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // Use of module as a function call. e.g.: import m2 = module("m2");
+                this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([125 /* ModuleKeyword */, 129 /* RequireKeyword */]), 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // Add a space around certain TypeScript keywords
+                this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([115 /* AbstractKeyword */, 73 /* ClassKeyword */, 122 /* DeclareKeyword */, 77 /* DefaultKeyword */, 81 /* EnumKeyword */, 82 /* ExportKeyword */, 83 /* ExtendsKeyword */, 123 /* GetKeyword */, 106 /* ImplementsKeyword */, 89 /* ImportKeyword */, 107 /* InterfaceKeyword */, 125 /* ModuleKeyword */, 126 /* NamespaceKeyword */, 110 /* PrivateKeyword */, 112 /* PublicKeyword */, 111 /* ProtectedKeyword */, 131 /* SetKeyword */, 113 /* StaticKeyword */, 134 /* TypeKeyword */, 136 /* FromKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([83 /* ExtendsKeyword */, 106 /* ImplementsKeyword */, 136 /* FromKeyword */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" {
+                this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(9 /* StringLiteral */, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2 /* Space */));
+                // Lambda expressions
+                this.SpaceBeforeArrow = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 34 /* EqualsGreaterThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceAfterArrow = new formatting.Rule(formatting.RuleDescriptor.create3(34 /* EqualsGreaterThanToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                // Optional parameters and let args
+                this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(22 /* DotDotDotToken */, 69 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterOptionalParameters = new formatting.Rule(formatting.RuleDescriptor.create3(53 /* QuestionToken */, formatting.Shared.TokenRange.FromTokens([18 /* CloseParenToken */, 24 /* CommaToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNotBinaryOpContext), 8 /* Delete */));
+                // generics and type assertions
+                this.NoSpaceBeforeOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.TypeNames, 25 /* LessThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), 8 /* Delete */));
+                this.NoSpaceBetweenCloseParenAndAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create1(18 /* CloseParenToken */, 25 /* LessThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), 8 /* Delete */));
+                this.NoSpaceAfterOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(25 /* LessThanToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), 8 /* Delete */));
+                this.NoSpaceBeforeCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 27 /* GreaterThanToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), 8 /* Delete */));
+                this.NoSpaceAfterCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(27 /* GreaterThanToken */, formatting.Shared.TokenRange.FromTokens([17 /* OpenParenToken */, 19 /* OpenBracketToken */, 27 /* GreaterThanToken */, 24 /* CommaToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), 8 /* Delete */));
+                this.NoSpaceAfterTypeAssertion = new formatting.Rule(formatting.RuleDescriptor.create3(27 /* GreaterThanToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeAssertionContext), 8 /* Delete */));
+                // Remove spaces in empty interface literals. e.g.: x: {}
+                this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(15 /* OpenBraceToken */, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsObjectTypeContext), 8 /* Delete */));
+                // decorators
+                this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 55 /* AtToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(55 /* AtToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([115 /* AbstractKeyword */, 69 /* Identifier */, 82 /* ExportKeyword */, 77 /* DefaultKeyword */, 73 /* ClassKeyword */, 113 /* StaticKeyword */, 112 /* PublicKeyword */, 110 /* PrivateKeyword */, 111 /* ProtectedKeyword */, 123 /* GetKeyword */, 131 /* SetKeyword */, 19 /* OpenBracketToken */, 37 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */));
+                this.NoSpaceBetweenFunctionKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(87 /* FunctionKeyword */, 37 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 8 /* Delete */));
+                this.SpaceAfterStarInGeneratorDeclaration = new formatting.Rule(formatting.RuleDescriptor.create3(37 /* AsteriskToken */, formatting.Shared.TokenRange.FromTokens([69 /* Identifier */, 17 /* OpenParenToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 2 /* Space */));
+                this.NoSpaceBetweenYieldKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(114 /* YieldKeyword */, 37 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), 8 /* Delete */));
+                this.SpaceBetweenYieldOrYieldStarAndOperand = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([114 /* YieldKeyword */, 37 /* AsteriskToken */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), 2 /* Space */));
+                // Async-await
+                this.SpaceBetweenAsyncAndOpenParen = new formatting.Rule(formatting.RuleDescriptor.create1(118 /* AsyncKeyword */, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsArrowFunctionContext, Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceBetweenAsyncAndFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(118 /* AsyncKeyword */, 87 /* FunctionKeyword */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                // template string
+                this.NoSpaceBetweenTagAndTemplateString = new formatting.Rule(formatting.RuleDescriptor.create3(69 /* Identifier */, formatting.Shared.TokenRange.FromTokens([11 /* NoSubstitutionTemplateLiteral */, 12 /* TemplateHead */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // These rules are higher in priority than user-configurable rules.
+                this.HighPriorityCommonRules = [
+                    this.IgnoreBeforeComment, this.IgnoreAfterLineComment,
+                    this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQuestionMark, this.SpaceAfterQuestionMarkInConditionalOperator,
+                    this.NoSpaceAfterQuestionMark,
+                    this.NoSpaceBeforeDot, this.NoSpaceAfterDot,
+                    this.NoSpaceAfterUnaryPrefixOperator,
+                    this.NoSpaceAfterUnaryPreincrementOperator, this.NoSpaceAfterUnaryPredecrementOperator,
+                    this.NoSpaceBeforeUnaryPostincrementOperator, this.NoSpaceBeforeUnaryPostdecrementOperator,
+                    this.SpaceAfterPostincrementWhenFollowedByAdd,
+                    this.SpaceAfterAddWhenFollowedByUnaryPlus, this.SpaceAfterAddWhenFollowedByPreincrement,
+                    this.SpaceAfterPostdecrementWhenFollowedBySubtract,
+                    this.SpaceAfterSubtractWhenFollowedByUnaryMinus, this.SpaceAfterSubtractWhenFollowedByPredecrement,
+                    this.NoSpaceAfterCloseBrace,
+                    this.SpaceAfterOpenBrace, this.SpaceBeforeCloseBrace, this.NewLineBeforeCloseBraceInBlockContext,
+                    this.SpaceAfterCloseBrace, this.SpaceBetweenCloseBraceAndElse, this.SpaceBetweenCloseBraceAndWhile, this.NoSpaceBetweenEmptyBraceBrackets,
+                    this.NoSpaceBetweenFunctionKeywordAndStar, this.SpaceAfterStarInGeneratorDeclaration,
+                    this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember,
+                    this.NoSpaceBetweenYieldKeywordAndStar, this.SpaceBetweenYieldOrYieldStarAndOperand,
+                    this.NoSpaceBetweenReturnAndSemicolon,
+                    this.SpaceAfterCertainKeywords,
+                    this.SpaceAfterLetConstInVariableDeclaration,
+                    this.NoSpaceBeforeOpenParenInFuncCall,
+                    this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator,
+                    this.SpaceAfterVoidOperator,
+                    this.SpaceBetweenAsyncAndOpenParen, this.SpaceBetweenAsyncAndFunctionKeyword,
+                    this.NoSpaceBetweenTagAndTemplateString,
+                    // TypeScript-specific rules
+                    this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport,
+                    this.SpaceAfterCertainTypeScriptKeywords, this.SpaceBeforeCertainTypeScriptKeywords,
+                    this.SpaceAfterModuleName,
+                    this.SpaceBeforeArrow, this.SpaceAfterArrow,
+                    this.NoSpaceAfterEllipsis,
+                    this.NoSpaceAfterOptionalParameters,
+                    this.NoSpaceBetweenEmptyInterfaceBraceBrackets,
+                    this.NoSpaceBeforeOpenAngularBracket,
+                    this.NoSpaceBetweenCloseParenAndAngularBracket,
+                    this.NoSpaceAfterOpenAngularBracket,
+                    this.NoSpaceBeforeCloseAngularBracket,
+                    this.NoSpaceAfterCloseAngularBracket,
+                    this.NoSpaceAfterTypeAssertion,
+                    this.SpaceBeforeAt,
+                    this.NoSpaceAfterAt,
+                    this.SpaceAfterDecorator,
+                ];
+                // These rules are lower in priority than user-configurable rules.
+                this.LowPriorityCommonRules = [
+                    this.NoSpaceBeforeSemicolon,
+                    this.SpaceBeforeOpenBraceInControl, this.SpaceBeforeOpenBraceInFunction, this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock,
+                    this.NoSpaceBeforeComma,
+                    this.NoSpaceBeforeOpenBracket,
+                    this.NoSpaceAfterCloseBracket,
+                    this.SpaceAfterSemicolon,
+                    this.NoSpaceBeforeOpenParenInFuncDecl,
+                    this.SpaceBetweenStatements, this.SpaceAfterTryFinally
+                ];
+                ///
+                /// Rules controlled by user options
+                ///
+                // Insert space after comma delimiter
+                this.SpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(24 /* CommaToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isNonJsxElementContext, Rules.IsNextTokenNotCloseBracket), 2 /* Space */));
+                this.NoSpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(24 /* CommaToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isNonJsxElementContext), 8 /* Delete */));
+                // Insert space before and after binary operators
+                this.SpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.SpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */));
+                this.NoSpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 8 /* Delete */));
+                this.NoSpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsBinaryOpContext), 8 /* Delete */));
+                // Insert space after keywords in control flow statements
+                this.SpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 2 /* Space */));
+                this.NoSpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 8 /* Delete */));
+                // Open Brace braces after function
+                // TypeScript: Function can have return types, which can be made of tons of different token kinds
+                this.NewLineBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */);
+                // Open Brace braces after TypeScript module/class/interface
+                this.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */);
+                // Open Brace braces after control block
+                this.NewLineBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 15 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsBeforeMultilineBlockContext), 4 /* NewLine */), 1 /* CanDeleteNewLines */);
+                // Insert space after semicolon in for statement
+                this.SpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(23 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsForContext), 2 /* Space */));
+                this.NoSpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(23 /* SemicolonToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsForContext), 8 /* Delete */));
+                // Insert space after opening and before closing nonempty parenthesis
+                this.SpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(17 /* OpenParenToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 18 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.NoSpaceBetweenParens = new formatting.Rule(formatting.RuleDescriptor.create1(17 /* OpenParenToken */, 18 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(17 /* OpenParenToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 18 /* CloseParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // Insert space after opening and before closing nonempty brackets
+                this.SpaceAfterOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19 /* OpenBracketToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.SpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 20 /* CloseBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.NoSpaceBetweenBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(19 /* OpenBracketToken */, 20 /* CloseBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceAfterOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19 /* OpenBracketToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 20 /* CloseBracketToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                // Insert space after opening and before closing template string braces
+                this.NoSpaceAfterTemplateHeadAndMiddle = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([12 /* TemplateHead */, 13 /* TemplateMiddle */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.SpaceAfterTemplateHeadAndMiddle = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([12 /* TemplateHead */, 13 /* TemplateMiddle */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                this.NoSpaceBeforeTemplateMiddleAndTail = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([13 /* TemplateMiddle */, 14 /* TemplateTail */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 8 /* Delete */));
+                this.SpaceBeforeTemplateMiddleAndTail = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([13 /* TemplateMiddle */, 14 /* TemplateTail */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), 2 /* Space */));
+                // No space after { and before } in JSX expression
+                this.NoSpaceAfterOpenBraceInJsxExpression = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isJsxExpressionContext), 8 /* Delete */));
+                this.SpaceAfterOpenBraceInJsxExpression = new formatting.Rule(formatting.RuleDescriptor.create3(15 /* OpenBraceToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isJsxExpressionContext), 2 /* Space */));
+                this.NoSpaceBeforeCloseBraceInJsxExpression = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isJsxExpressionContext), 8 /* Delete */));
+                this.SpaceBeforeCloseBraceInJsxExpression = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16 /* CloseBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.isJsxExpressionContext), 2 /* Space */));
+                // Insert space after function keyword for anonymous functions
+                this.SpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(87 /* FunctionKeyword */, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */));
+                this.NoSpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(87 /* FunctionKeyword */, 17 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 8 /* Delete */));
+            }
+            Rules.prototype.getRuleName = function (rule) {
+                var o = this;
+                for (var name_40 in o) {
+                    if (o[name_40] === rule) {
+                        return name_40;
+                    }
+                }
+                throw new Error("Unknown rule");
+            };
+            ///
+            /// Contexts
+            ///
+            Rules.IsForContext = function (context) {
+                return context.contextNode.kind === 206 /* ForStatement */;
+            };
+            Rules.IsNotForContext = function (context) {
+                return !Rules.IsForContext(context);
+            };
+            Rules.IsBinaryOpContext = function (context) {
+                switch (context.contextNode.kind) {
+                    case 187 /* BinaryExpression */:
+                    case 188 /* ConditionalExpression */:
+                    case 195 /* AsExpression */:
+                    case 238 /* ExportSpecifier */:
+                    case 234 /* ImportSpecifier */:
+                    case 154 /* TypePredicate */:
+                    case 162 /* UnionType */:
+                    case 163 /* IntersectionType */:
+                        return true;
+                    // equals in binding elements: function foo([[x, y] = [1, 2]])
+                    case 169 /* BindingElement */:
+                    // equals in type X = ...
+                    case 223 /* TypeAliasDeclaration */:
+                    // equal in import a = module('a');
+                    case 229 /* ImportEqualsDeclaration */:
+                    // equal in let a = 0;
+                    case 218 /* VariableDeclaration */:
+                    // equal in p = 0;
+                    case 142 /* Parameter */:
+                    case 255 /* EnumMember */:
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                        return context.currentTokenSpan.kind === 56 /* EqualsToken */ || context.nextTokenSpan.kind === 56 /* EqualsToken */;
+                    // "in" keyword in for (let x in []) { }
+                    case 207 /* ForInStatement */:
+                        return context.currentTokenSpan.kind === 90 /* InKeyword */ || context.nextTokenSpan.kind === 90 /* InKeyword */;
+                    // Technically, "of" is not a binary operator, but format it the same way as "in"
+                    case 208 /* ForOfStatement */:
+                        return context.currentTokenSpan.kind === 138 /* OfKeyword */ || context.nextTokenSpan.kind === 138 /* OfKeyword */;
+                }
+                return false;
+            };
+            Rules.IsNotBinaryOpContext = function (context) {
+                return !Rules.IsBinaryOpContext(context);
+            };
+            Rules.IsConditionalOperatorContext = function (context) {
+                return context.contextNode.kind === 188 /* ConditionalExpression */;
+            };
+            Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) {
+                //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction.
+                ////
+                //// Ex:
+                //// if (1)     { ....
+                ////      * ) and { are on the same line so apply the rule. Here we don't care whether it's same or multi block context
+                ////
+                //// Ex:
+                //// if (1)
+                //// { ... }
+                ////      * ) and { are on different lines. We only need to format if the block is multiline context. So in this case we don't format.
+                ////
+                //// Ex:
+                //// if (1)
+                //// { ...
+                //// }
+                ////      * ) and { are on different lines. We only need to format if the block is multiline context. So in this case we format.
+                return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context);
+            };
+            // This check is done before an open brace in a control construct, a function, or a typescript block declaration
+            Rules.IsBeforeMultilineBlockContext = function (context) {
+                return Rules.IsBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine());
+            };
+            Rules.IsMultilineBlockContext = function (context) {
+                return Rules.IsBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
+            };
+            Rules.IsSingleLineBlockContext = function (context) {
+                return Rules.IsBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
+            };
+            Rules.IsBlockContext = function (context) {
+                return Rules.NodeIsBlockContext(context.contextNode);
+            };
+            Rules.IsBeforeBlockContext = function (context) {
+                return Rules.NodeIsBlockContext(context.nextTokenParent);
+            };
+            // IMPORTANT!!! This method must return true ONLY for nodes with open and close braces as immediate children
+            Rules.NodeIsBlockContext = function (node) {
+                if (Rules.NodeIsTypeScriptDeclWithBlockContext(node)) {
+                    // This means we are in a context that looks like a block to the user, but in the grammar is actually not a node (it's a class, module, enum, object type literal, etc).
+                    return true;
+                }
+                switch (node.kind) {
+                    case 199 /* Block */:
+                    case 227 /* CaseBlock */:
+                    case 171 /* ObjectLiteralExpression */:
+                    case 226 /* ModuleBlock */:
+                        return true;
+                }
+                return false;
+            };
+            Rules.IsFunctionDeclContext = function (context) {
+                switch (context.contextNode.kind) {
+                    case 220 /* FunctionDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    // case SyntaxKind.MemberFunctionDeclaration:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    // case SyntaxKind.MethodSignature:
+                    case 151 /* CallSignature */:
+                    case 179 /* FunctionExpression */:
+                    case 148 /* Constructor */:
+                    case 180 /* ArrowFunction */:
+                    // case SyntaxKind.ConstructorDeclaration:
+                    // case SyntaxKind.SimpleArrowFunctionExpression:
+                    // case SyntaxKind.ParenthesizedArrowFunctionExpression:
+                    case 222 /* InterfaceDeclaration */:
+                        return true;
+                }
+                return false;
+            };
+            Rules.IsFunctionDeclarationOrFunctionExpressionContext = function (context) {
+                return context.contextNode.kind === 220 /* FunctionDeclaration */ || context.contextNode.kind === 179 /* FunctionExpression */;
+            };
+            Rules.IsTypeScriptDeclWithBlockContext = function (context) {
+                return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode);
+            };
+            Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) {
+                switch (node.kind) {
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 159 /* TypeLiteral */:
+                    case 225 /* ModuleDeclaration */:
+                    case 236 /* ExportDeclaration */:
+                    case 237 /* NamedExports */:
+                    case 230 /* ImportDeclaration */:
+                    case 233 /* NamedImports */:
+                        return true;
+                }
+                return false;
+            };
+            Rules.IsAfterCodeBlockContext = function (context) {
+                switch (context.currentTokenParent.kind) {
+                    case 221 /* ClassDeclaration */:
+                    case 225 /* ModuleDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 199 /* Block */:
+                    case 252 /* CatchClause */:
+                    case 226 /* ModuleBlock */:
+                    case 213 /* SwitchStatement */:
+                        return true;
+                }
+                return false;
+            };
+            Rules.IsControlDeclContext = function (context) {
+                switch (context.contextNode.kind) {
+                    case 203 /* IfStatement */:
+                    case 213 /* SwitchStatement */:
+                    case 206 /* ForStatement */:
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                    case 205 /* WhileStatement */:
+                    case 216 /* TryStatement */:
+                    case 204 /* DoStatement */:
+                    case 212 /* WithStatement */:
+                    // TODO
+                    // case SyntaxKind.ElseClause:
+                    case 252 /* CatchClause */:
+                        return true;
+                    default:
+                        return false;
+                }
+            };
+            Rules.IsObjectContext = function (context) {
+                return context.contextNode.kind === 171 /* ObjectLiteralExpression */;
+            };
+            Rules.IsFunctionCallContext = function (context) {
+                return context.contextNode.kind === 174 /* CallExpression */;
+            };
+            Rules.IsNewContext = function (context) {
+                return context.contextNode.kind === 175 /* NewExpression */;
+            };
+            Rules.IsFunctionCallOrNewContext = function (context) {
+                return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context);
+            };
+            Rules.IsPreviousTokenNotComma = function (context) {
+                return context.currentTokenSpan.kind !== 24 /* CommaToken */;
+            };
+            Rules.IsNextTokenNotCloseBracket = function (context) {
+                return context.nextTokenSpan.kind !== 20 /* CloseBracketToken */;
+            };
+            Rules.IsArrowFunctionContext = function (context) {
+                return context.contextNode.kind === 180 /* ArrowFunction */;
+            };
+            Rules.IsNonJsxSameLineTokenContext = function (context) {
+                return context.TokensAreOnSameLine() && context.contextNode.kind !== 244 /* JsxText */;
+            };
+            Rules.isNonJsxElementContext = function (context) {
+                return context.contextNode.kind !== 241 /* JsxElement */;
+            };
+            Rules.isJsxExpressionContext = function (context) {
+                return context.contextNode.kind === 248 /* JsxExpression */;
+            };
+            Rules.IsNotBeforeBlockInFunctionDeclarationContext = function (context) {
+                return !Rules.IsFunctionDeclContext(context) && !Rules.IsBeforeBlockContext(context);
+            };
+            Rules.IsEndOfDecoratorContextOnSameLine = function (context) {
+                return context.TokensAreOnSameLine() &&
+                    context.contextNode.decorators &&
+                    Rules.NodeIsInDecoratorContext(context.currentTokenParent) &&
+                    !Rules.NodeIsInDecoratorContext(context.nextTokenParent);
+            };
+            Rules.NodeIsInDecoratorContext = function (node) {
+                while (ts.isExpression(node)) {
+                    node = node.parent;
+                }
+                return node.kind === 143 /* Decorator */;
+            };
+            Rules.IsStartOfVariableDeclarationList = function (context) {
+                return context.currentTokenParent.kind === 219 /* VariableDeclarationList */ &&
+                    context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos;
+            };
+            Rules.IsNotFormatOnEnter = function (context) {
+                return context.formattingRequestKind !== 2 /* FormatOnEnter */;
+            };
+            Rules.IsModuleDeclContext = function (context) {
+                return context.contextNode.kind === 225 /* ModuleDeclaration */;
+            };
+            Rules.IsObjectTypeContext = function (context) {
+                return context.contextNode.kind === 159 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration;
+            };
+            Rules.IsTypeArgumentOrParameterOrAssertion = function (token, parent) {
+                if (token.kind !== 25 /* LessThanToken */ && token.kind !== 27 /* GreaterThanToken */) {
+                    return false;
+                }
+                switch (parent.kind) {
+                    case 155 /* TypeReference */:
+                    case 177 /* TypeAssertionExpression */:
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 174 /* CallExpression */:
+                    case 175 /* NewExpression */:
+                    case 194 /* ExpressionWithTypeArguments */:
+                        return true;
+                    default:
+                        return false;
+                }
+            };
+            Rules.IsTypeArgumentOrParameterOrAssertionContext = function (context) {
+                return Rules.IsTypeArgumentOrParameterOrAssertion(context.currentTokenSpan, context.currentTokenParent) ||
+                    Rules.IsTypeArgumentOrParameterOrAssertion(context.nextTokenSpan, context.nextTokenParent);
+            };
+            Rules.IsTypeAssertionContext = function (context) {
+                return context.contextNode.kind === 177 /* TypeAssertionExpression */;
+            };
+            Rules.IsVoidOpContext = function (context) {
+                return context.currentTokenSpan.kind === 103 /* VoidKeyword */ && context.currentTokenParent.kind === 183 /* VoidExpression */;
+            };
+            Rules.IsYieldOrYieldStarWithOperand = function (context) {
+                return context.contextNode.kind === 190 /* YieldExpression */ && context.contextNode.expression !== undefined;
+            };
+            return Rules;
+        }());
+        formatting.Rules = Rules;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var RulesMap = (function () {
+            function RulesMap() {
+                this.map = [];
+                this.mapRowLength = 0;
+            }
+            RulesMap.create = function (rules) {
+                var result = new RulesMap();
+                result.Initialize(rules);
+                return result;
+            };
+            RulesMap.prototype.Initialize = function (rules) {
+                this.mapRowLength = 138 /* LastToken */ + 1;
+                this.map = new Array(this.mapRowLength * this.mapRowLength); // new Array<RulesBucket>(this.mapRowLength * this.mapRowLength);
+                // This array is used only during construction of the rulesbucket in the map
+                var rulesBucketConstructionStateList = new Array(this.map.length); // new Array<RulesBucketConstructionState>(this.map.length);
+                this.FillRules(rules, rulesBucketConstructionStateList);
+                return this.map;
+            };
+            RulesMap.prototype.FillRules = function (rules, rulesBucketConstructionStateList) {
+                var _this = this;
+                rules.forEach(function (rule) {
+                    _this.FillRule(rule, rulesBucketConstructionStateList);
+                });
+            };
+            RulesMap.prototype.GetRuleBucketIndex = function (row, column) {
+                var rulesBucketIndex = (row * this.mapRowLength) + column;
+                // Debug.Assert(rulesBucketIndex < this.map.Length, "Trying to access an index outside the array.");
+                return rulesBucketIndex;
+            };
+            RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) {
+                var _this = this;
+                var specificRule = rule.Descriptor.LeftTokenRange !== formatting.Shared.TokenRange.Any &&
+                    rule.Descriptor.RightTokenRange !== formatting.Shared.TokenRange.Any;
+                rule.Descriptor.LeftTokenRange.GetTokens().forEach(function (left) {
+                    rule.Descriptor.RightTokenRange.GetTokens().forEach(function (right) {
+                        var rulesBucketIndex = _this.GetRuleBucketIndex(left, right);
+                        var rulesBucket = _this.map[rulesBucketIndex];
+                        if (rulesBucket === undefined) {
+                            rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket();
+                        }
+                        rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex);
+                    });
+                });
+            };
+            RulesMap.prototype.GetRule = function (context) {
+                var bucketIndex = this.GetRuleBucketIndex(context.currentTokenSpan.kind, context.nextTokenSpan.kind);
+                var bucket = this.map[bucketIndex];
+                if (bucket) {
+                    for (var _i = 0, _a = bucket.Rules(); _i < _a.length; _i++) {
+                        var rule = _a[_i];
+                        if (rule.Operation.Context.InContext(context)) {
+                            return rule;
+                        }
+                    }
+                }
+                return undefined;
+            };
+            return RulesMap;
+        }());
+        formatting.RulesMap = RulesMap;
+        var MaskBitSize = 5;
+        var Mask = 0x1f;
+        (function (RulesPosition) {
+            RulesPosition[RulesPosition["IgnoreRulesSpecific"] = 0] = "IgnoreRulesSpecific";
+            RulesPosition[RulesPosition["IgnoreRulesAny"] = MaskBitSize * 1] = "IgnoreRulesAny";
+            RulesPosition[RulesPosition["ContextRulesSpecific"] = MaskBitSize * 2] = "ContextRulesSpecific";
+            RulesPosition[RulesPosition["ContextRulesAny"] = MaskBitSize * 3] = "ContextRulesAny";
+            RulesPosition[RulesPosition["NoContextRulesSpecific"] = MaskBitSize * 4] = "NoContextRulesSpecific";
+            RulesPosition[RulesPosition["NoContextRulesAny"] = MaskBitSize * 5] = "NoContextRulesAny";
+        })(formatting.RulesPosition || (formatting.RulesPosition = {}));
+        var RulesPosition = formatting.RulesPosition;
+        var RulesBucketConstructionState = (function () {
+            function RulesBucketConstructionState() {
+                //// The Rules list contains all the inserted rules into a rulebucket in the following order:
+                ////    1- Ignore rules with specific token combination
+                ////    2- Ignore rules with any token combination
+                ////    3- Context rules with specific token combination
+                ////    4- Context rules with any token combination
+                ////    5- Non-context rules with specific token combination
+                ////    6- Non-context rules with any token combination
+                ////
+                //// The member rulesInsertionIndexBitmap is used to describe the number of rules
+                //// in each sub-bucket (above) hence can be used to know the index of where to insert
+                //// the next rule. It's a bitmap which contains 6 different sections each is given 5 bits.
+                ////
+                //// Example:
+                //// In order to insert a rule to the end of sub-bucket (3), we get the index by adding
+                //// the values in the bitmap segments 3rd, 2nd, and 1st.
+                this.rulesInsertionIndexBitmap = 0;
+            }
+            RulesBucketConstructionState.prototype.GetInsertionIndex = function (maskPosition) {
+                var index = 0;
+                var pos = 0;
+                var indexBitmap = this.rulesInsertionIndexBitmap;
+                while (pos <= maskPosition) {
+                    index += (indexBitmap & Mask);
+                    indexBitmap >>= MaskBitSize;
+                    pos += MaskBitSize;
+                }
+                return index;
+            };
+            RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) {
+                var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask;
+                value++;
+                ts.Debug.assert((value & Mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.");
+                var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition);
+                temp |= value << maskPosition;
+                this.rulesInsertionIndexBitmap = temp;
+            };
+            return RulesBucketConstructionState;
+        }());
+        formatting.RulesBucketConstructionState = RulesBucketConstructionState;
+        var RulesBucket = (function () {
+            function RulesBucket() {
+                this.rules = [];
+            }
+            RulesBucket.prototype.Rules = function () {
+                return this.rules;
+            };
+            RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) {
+                var position;
+                if (rule.Operation.Action === 1 /* Ignore */) {
+                    position = specificTokens ?
+                        RulesPosition.IgnoreRulesSpecific :
+                        RulesPosition.IgnoreRulesAny;
+                }
+                else if (!rule.Operation.Context.IsAny()) {
+                    position = specificTokens ?
+                        RulesPosition.ContextRulesSpecific :
+                        RulesPosition.ContextRulesAny;
+                }
+                else {
+                    position = specificTokens ?
+                        RulesPosition.NoContextRulesSpecific :
+                        RulesPosition.NoContextRulesAny;
+                }
+                var state = constructionState[rulesBucketIndex];
+                if (state === undefined) {
+                    state = constructionState[rulesBucketIndex] = new RulesBucketConstructionState();
+                }
+                var index = state.GetInsertionIndex(position);
+                this.rules.splice(index, 0, rule);
+                state.IncreaseInsertionIndex(position);
+            };
+            return RulesBucket;
+        }());
+        formatting.RulesBucket = RulesBucket;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var Shared;
+        (function (Shared) {
+            var TokenRangeAccess = (function () {
+                function TokenRangeAccess(from, to, except) {
+                    this.tokens = [];
+                    for (var token = from; token <= to; token++) {
+                        if (ts.indexOf(except, token) < 0) {
+                            this.tokens.push(token);
+                        }
+                    }
+                }
+                TokenRangeAccess.prototype.GetTokens = function () {
+                    return this.tokens;
+                };
+                TokenRangeAccess.prototype.Contains = function (token) {
+                    return this.tokens.indexOf(token) >= 0;
+                };
+                return TokenRangeAccess;
+            }());
+            Shared.TokenRangeAccess = TokenRangeAccess;
+            var TokenValuesAccess = (function () {
+                function TokenValuesAccess(tks) {
+                    this.tokens = tks && tks.length ? tks : [];
+                }
+                TokenValuesAccess.prototype.GetTokens = function () {
+                    return this.tokens;
+                };
+                TokenValuesAccess.prototype.Contains = function (token) {
+                    return this.tokens.indexOf(token) >= 0;
+                };
+                return TokenValuesAccess;
+            }());
+            Shared.TokenValuesAccess = TokenValuesAccess;
+            var TokenSingleValueAccess = (function () {
+                function TokenSingleValueAccess(token) {
+                    this.token = token;
+                }
+                TokenSingleValueAccess.prototype.GetTokens = function () {
+                    return [this.token];
+                };
+                TokenSingleValueAccess.prototype.Contains = function (tokenValue) {
+                    return tokenValue === this.token;
+                };
+                return TokenSingleValueAccess;
+            }());
+            Shared.TokenSingleValueAccess = TokenSingleValueAccess;
+            var TokenAllAccess = (function () {
+                function TokenAllAccess() {
+                }
+                TokenAllAccess.prototype.GetTokens = function () {
+                    var result = [];
+                    for (var token = 0 /* FirstToken */; token <= 138 /* LastToken */; token++) {
+                        result.push(token);
+                    }
+                    return result;
+                };
+                TokenAllAccess.prototype.Contains = function (tokenValue) {
+                    return true;
+                };
+                TokenAllAccess.prototype.toString = function () {
+                    return "[allTokens]";
+                };
+                return TokenAllAccess;
+            }());
+            Shared.TokenAllAccess = TokenAllAccess;
+            var TokenRange = (function () {
+                function TokenRange(tokenAccess) {
+                    this.tokenAccess = tokenAccess;
+                }
+                TokenRange.FromToken = function (token) {
+                    return new TokenRange(new TokenSingleValueAccess(token));
+                };
+                TokenRange.FromTokens = function (tokens) {
+                    return new TokenRange(new TokenValuesAccess(tokens));
+                };
+                TokenRange.FromRange = function (f, to, except) {
+                    if (except === void 0) { except = []; }
+                    return new TokenRange(new TokenRangeAccess(f, to, except));
+                };
+                TokenRange.AllTokens = function () {
+                    return new TokenRange(new TokenAllAccess());
+                };
+                TokenRange.prototype.GetTokens = function () {
+                    return this.tokenAccess.GetTokens();
+                };
+                TokenRange.prototype.Contains = function (token) {
+                    return this.tokenAccess.Contains(token);
+                };
+                TokenRange.prototype.toString = function () {
+                    return this.tokenAccess.toString();
+                };
+                TokenRange.Any = TokenRange.AllTokens();
+                TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3 /* MultiLineCommentTrivia */]));
+                TokenRange.Keywords = TokenRange.FromRange(70 /* FirstKeyword */, 138 /* LastKeyword */);
+                TokenRange.BinaryOperators = TokenRange.FromRange(25 /* FirstBinaryOperator */, 68 /* LastBinaryOperator */);
+                TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([90 /* InKeyword */, 91 /* InstanceOfKeyword */, 138 /* OfKeyword */, 116 /* AsKeyword */, 124 /* IsKeyword */]);
+                TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([41 /* PlusPlusToken */, 42 /* MinusMinusToken */, 50 /* TildeToken */, 49 /* ExclamationToken */]);
+                TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([8 /* NumericLiteral */, 69 /* Identifier */, 17 /* OpenParenToken */, 19 /* OpenBracketToken */, 15 /* OpenBraceToken */, 97 /* ThisKeyword */, 92 /* NewKeyword */]);
+                TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([69 /* Identifier */, 17 /* OpenParenToken */, 97 /* ThisKeyword */, 92 /* NewKeyword */]);
+                TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([69 /* Identifier */, 18 /* CloseParenToken */, 20 /* CloseBracketToken */, 92 /* NewKeyword */]);
+                TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([69 /* Identifier */, 17 /* OpenParenToken */, 97 /* ThisKeyword */, 92 /* NewKeyword */]);
+                TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([69 /* Identifier */, 18 /* CloseParenToken */, 20 /* CloseBracketToken */, 92 /* NewKeyword */]);
+                TokenRange.Comments = TokenRange.FromTokens([2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */]);
+                TokenRange.TypeNames = TokenRange.FromTokens([69 /* Identifier */, 130 /* NumberKeyword */, 132 /* StringKeyword */, 120 /* BooleanKeyword */, 133 /* SymbolKeyword */, 103 /* VoidKeyword */, 117 /* AnyKeyword */]);
+                return TokenRange;
+            }());
+            Shared.TokenRange = TokenRange;
+        })(Shared = formatting.Shared || (formatting.Shared = {}));
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='..\services.ts' />
+///<reference path='formattingContext.ts' />
+///<reference path='formattingRequestKind.ts' />
+///<reference path='rule.ts' />
+///<reference path='ruleAction.ts' />
+///<reference path='ruleDescriptor.ts' />
+///<reference path='ruleFlag.ts' />
+///<reference path='ruleOperation.ts' />
+///<reference path='ruleOperationContext.ts' />
+///<reference path='rules.ts' />
+///<reference path='rulesMap.ts' />
+///<reference path='tokenRange.ts' /> 
+/// <reference path="references.ts"/>
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var RulesProvider = (function () {
+            function RulesProvider() {
+                this.globalRules = new formatting.Rules();
+            }
+            RulesProvider.prototype.getRuleName = function (rule) {
+                return this.globalRules.getRuleName(rule);
+            };
+            RulesProvider.prototype.getRuleByName = function (name) {
+                return this.globalRules[name];
+            };
+            RulesProvider.prototype.getRulesMap = function () {
+                return this.rulesMap;
+            };
+            RulesProvider.prototype.ensureUpToDate = function (options) {
+                if (!this.options || !ts.compareDataObjects(this.options, options)) {
+                    var activeRules = this.createActiveRules(options);
+                    var rulesMap = formatting.RulesMap.create(activeRules);
+                    this.activeRules = activeRules;
+                    this.rulesMap = rulesMap;
+                    this.options = ts.clone(options);
+                }
+            };
+            RulesProvider.prototype.createActiveRules = function (options) {
+                var rules = this.globalRules.HighPriorityCommonRules.slice(0);
+                if (options.InsertSpaceAfterCommaDelimiter) {
+                    rules.push(this.globalRules.SpaceAfterComma);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterComma);
+                }
+                if (options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions) {
+                    rules.push(this.globalRules.SpaceAfterAnonymousFunctionKeyword);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterAnonymousFunctionKeyword);
+                }
+                if (options.InsertSpaceAfterKeywordsInControlFlowStatements) {
+                    rules.push(this.globalRules.SpaceAfterKeywordInControl);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterKeywordInControl);
+                }
+                if (options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis) {
+                    rules.push(this.globalRules.SpaceAfterOpenParen);
+                    rules.push(this.globalRules.SpaceBeforeCloseParen);
+                    rules.push(this.globalRules.NoSpaceBetweenParens);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterOpenParen);
+                    rules.push(this.globalRules.NoSpaceBeforeCloseParen);
+                    rules.push(this.globalRules.NoSpaceBetweenParens);
+                }
+                if (options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets) {
+                    rules.push(this.globalRules.SpaceAfterOpenBracket);
+                    rules.push(this.globalRules.SpaceBeforeCloseBracket);
+                    rules.push(this.globalRules.NoSpaceBetweenBrackets);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterOpenBracket);
+                    rules.push(this.globalRules.NoSpaceBeforeCloseBracket);
+                    rules.push(this.globalRules.NoSpaceBetweenBrackets);
+                }
+                if (options.InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces) {
+                    rules.push(this.globalRules.SpaceAfterTemplateHeadAndMiddle);
+                    rules.push(this.globalRules.SpaceBeforeTemplateMiddleAndTail);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterTemplateHeadAndMiddle);
+                    rules.push(this.globalRules.NoSpaceBeforeTemplateMiddleAndTail);
+                }
+                if (options.InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces) {
+                    rules.push(this.globalRules.SpaceAfterOpenBraceInJsxExpression);
+                    rules.push(this.globalRules.SpaceBeforeCloseBraceInJsxExpression);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterOpenBraceInJsxExpression);
+                    rules.push(this.globalRules.NoSpaceBeforeCloseBraceInJsxExpression);
+                }
+                if (options.InsertSpaceAfterSemicolonInForStatements) {
+                    rules.push(this.globalRules.SpaceAfterSemicolonInFor);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceAfterSemicolonInFor);
+                }
+                if (options.InsertSpaceBeforeAndAfterBinaryOperators) {
+                    rules.push(this.globalRules.SpaceBeforeBinaryOperator);
+                    rules.push(this.globalRules.SpaceAfterBinaryOperator);
+                }
+                else {
+                    rules.push(this.globalRules.NoSpaceBeforeBinaryOperator);
+                    rules.push(this.globalRules.NoSpaceAfterBinaryOperator);
+                }
+                if (options.PlaceOpenBraceOnNewLineForControlBlocks) {
+                    rules.push(this.globalRules.NewLineBeforeOpenBraceInControl);
+                }
+                if (options.PlaceOpenBraceOnNewLineForFunctions) {
+                    rules.push(this.globalRules.NewLineBeforeOpenBraceInFunction);
+                    rules.push(this.globalRules.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock);
+                }
+                rules = rules.concat(this.globalRules.LowPriorityCommonRules);
+                return rules;
+            };
+            return RulesProvider;
+        }());
+        formatting.RulesProvider = RulesProvider;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='..\services.ts' />
+///<reference path='formattingScanner.ts' />
+///<reference path='rulesProvider.ts' />
+///<reference path='references.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var Constants;
+        (function (Constants) {
+            Constants[Constants["Unknown"] = -1] = "Unknown";
+        })(Constants || (Constants = {}));
+        function formatOnEnter(position, sourceFile, rulesProvider, options) {
+            var line = sourceFile.getLineAndCharacterOfPosition(position).line;
+            if (line === 0) {
+                return [];
+            }
+            // After the enter key, the cursor is now at a new line. The new line may or may not contain non-whitespace characters.
+            // If the new line has only whitespaces, we won't want to format this line, because that would remove the indentation as
+            // trailing whitespaces. So the end of the formatting span should be the later one between:
+            //  1. the end of the previous line
+            //  2. the last non-whitespace character in the current line
+            var endOfFormatSpan = ts.getEndLinePosition(line, sourceFile);
+            while (ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(endOfFormatSpan))) {
+                endOfFormatSpan--;
+            }
+            // if the character at the end of the span is a line break, we shouldn't include it, because it indicates we don't want to
+            // touch the current line at all. Also, on some OSes the line break consists of two characters (\r\n), we should test if the
+            // previous character before the end of format span is line break character as well.
+            if (ts.isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) {
+                endOfFormatSpan--;
+            }
+            var span = {
+                // get start position for the previous line
+                pos: ts.getStartPositionOfLine(line - 1, sourceFile),
+                // end value is exclusive so add 1 to the result
+                end: endOfFormatSpan + 1
+            };
+            return formatSpan(span, sourceFile, options, rulesProvider, 2 /* FormatOnEnter */);
+        }
+        formatting.formatOnEnter = formatOnEnter;
+        function formatOnSemicolon(position, sourceFile, rulesProvider, options) {
+            return formatOutermostParent(position, 23 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */);
+        }
+        formatting.formatOnSemicolon = formatOnSemicolon;
+        function formatOnClosingCurly(position, sourceFile, rulesProvider, options) {
+            return formatOutermostParent(position, 16 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */);
+        }
+        formatting.formatOnClosingCurly = formatOnClosingCurly;
+        function formatDocument(sourceFile, rulesProvider, options) {
+            var span = {
+                pos: 0,
+                end: sourceFile.text.length
+            };
+            return formatSpan(span, sourceFile, options, rulesProvider, 0 /* FormatDocument */);
+        }
+        formatting.formatDocument = formatDocument;
+        function formatSelection(start, end, sourceFile, rulesProvider, options) {
+            // format from the beginning of the line
+            var span = {
+                pos: ts.getLineStartPositionForPosition(start, sourceFile),
+                end: end
+            };
+            return formatSpan(span, sourceFile, options, rulesProvider, 1 /* FormatSelection */);
+        }
+        formatting.formatSelection = formatSelection;
+        function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) {
+            var parent = findOutermostParent(position, expectedLastToken, sourceFile);
+            if (!parent) {
+                return [];
+            }
+            var span = {
+                pos: ts.getLineStartPositionForPosition(parent.getStart(sourceFile), sourceFile),
+                end: parent.end
+            };
+            return formatSpan(span, sourceFile, options, rulesProvider, requestKind);
+        }
+        function findOutermostParent(position, expectedTokenKind, sourceFile) {
+            var precedingToken = ts.findPrecedingToken(position, sourceFile);
+            // when it is claimed that trigger character was typed at given position
+            // we verify that there is a token with a matching kind whose end is equal to position (because the character was just typed).
+            // If this condition is not hold - then trigger character was typed in some other context,
+            // i.e.in comment and thus should not trigger autoformatting
+            if (!precedingToken ||
+                precedingToken.kind !== expectedTokenKind ||
+                position !== precedingToken.getEnd()) {
+                return undefined;
+            }
+            // walk up and search for the parent node that ends at the same position with precedingToken.
+            // for cases like this
+            //
+            // let x = 1;
+            // while (true) {
+            // }
+            // after typing close curly in while statement we want to reformat just the while statement.
+            // However if we just walk upwards searching for the parent that has the same end value -
+            // we'll end up with the whole source file. isListElement allows to stop on the list element level
+            var current = precedingToken;
+            while (current &&
+                current.parent &&
+                current.parent.end === precedingToken.end &&
+                !isListElement(current.parent, current)) {
+                current = current.parent;
+            }
+            return current;
+        }
+        // Returns true if node is a element in some list in parent
+        // i.e. parent is class declaration with the list of members and node is one of members.
+        function isListElement(parent, node) {
+            switch (parent.kind) {
+                case 221 /* ClassDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                    return ts.rangeContainsRange(parent.members, node);
+                case 225 /* ModuleDeclaration */:
+                    var body = parent.body;
+                    return body && body.kind === 199 /* Block */ && ts.rangeContainsRange(body.statements, node);
+                case 256 /* SourceFile */:
+                case 199 /* Block */:
+                case 226 /* ModuleBlock */:
+                    return ts.rangeContainsRange(parent.statements, node);
+                case 252 /* CatchClause */:
+                    return ts.rangeContainsRange(parent.block.statements, node);
+            }
+            return false;
+        }
+        /** find node that fully contains given text range */
+        function findEnclosingNode(range, sourceFile) {
+            return find(sourceFile);
+            function find(n) {
+                var candidate = ts.forEachChild(n, function (c) { return ts.startEndContainsRange(c.getStart(sourceFile), c.end, range) && c; });
+                if (candidate) {
+                    var result = find(candidate);
+                    if (result) {
+                        return result;
+                    }
+                }
+                return n;
+            }
+        }
+        /** formatting is not applied to ranges that contain parse errors.
+          * This function will return a predicate that for a given text range will tell
+          * if there are any parse errors that overlap with the range.
+          */
+        function prepareRangeContainsErrorFunction(errors, originalRange) {
+            if (!errors.length) {
+                return rangeHasNoErrors;
+            }
+            // pick only errors that fall in range
+            var sorted = errors
+                .filter(function (d) { return ts.rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length); })
+                .sort(function (e1, e2) { return e1.start - e2.start; });
+            if (!sorted.length) {
+                return rangeHasNoErrors;
+            }
+            var index = 0;
+            return function (r) {
+                // in current implementation sequence of arguments [r1, r2...] is monotonically increasing.
+                // 'index' tracks the index of the most recent error that was checked.
+                while (true) {
+                    if (index >= sorted.length) {
+                        // all errors in the range were already checked -> no error in specified range
+                        return false;
+                    }
+                    var error = sorted[index];
+                    if (r.end <= error.start) {
+                        // specified range ends before the error refered by 'index' - no error in range
+                        return false;
+                    }
+                    if (ts.startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) {
+                        // specified range overlaps with error range
+                        return true;
+                    }
+                    index++;
+                }
+            };
+            function rangeHasNoErrors(r) {
+                return false;
+            }
+        }
+        /**
+          * Start of the original range might fall inside the comment - scanner will not yield appropriate results
+          * This function will look for token that is located before the start of target range
+          * and return its end as start position for the scanner.
+          */
+        function getScanStartPosition(enclosingNode, originalRange, sourceFile) {
+            var start = enclosingNode.getStart(sourceFile);
+            if (start === originalRange.pos && enclosingNode.end === originalRange.end) {
+                return start;
+            }
+            var precedingToken = ts.findPrecedingToken(originalRange.pos, sourceFile);
+            if (!precedingToken) {
+                // no preceding token found - start from the beginning of enclosing node
+                return enclosingNode.pos;
+            }
+            // preceding token ends after the start of original range (i.e when originalRange.pos falls in the middle of literal)
+            // start from the beginning of enclosingNode to handle the entire 'originalRange'
+            if (precedingToken.end >= originalRange.pos) {
+                return enclosingNode.pos;
+            }
+            return precedingToken.end;
+        }
+        /*
+         * For cases like
+         * if (a ||
+         *     b ||$
+         *     c) {...}
+         * If we hit Enter at $ we want line '    b ||' to be indented.
+         * Formatting will be applied to the last two lines.
+         * Node that fully encloses these lines is binary expression 'a ||...'.
+         * Initial indentation for this node will be 0.
+         * Binary expressions don't introduce new indentation scopes, however it is possible
+         * that some parent node on the same line does - like if statement in this case.
+         * Note that we are considering parents only from the same line with initial node -
+         * if parent is on the different line - its delta was already contributed
+         * to the initial indentation.
+         */
+        function getOwnOrInheritedDelta(n, options, sourceFile) {
+            var previousLine = -1 /* Unknown */;
+            var child;
+            while (n) {
+                var line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line;
+                if (previousLine !== -1 /* Unknown */ && line !== previousLine) {
+                    break;
+                }
+                if (formatting.SmartIndenter.shouldIndentChildNode(n, child)) {
+                    return options.IndentSize;
+                }
+                previousLine = line;
+                child = n;
+                n = n.parent;
+            }
+            return 0;
+        }
+        function formatSpan(originalRange, sourceFile, options, rulesProvider, requestKind) {
+            var rangeContainsError = prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange);
+            // formatting context is used by rules provider
+            var formattingContext = new formatting.FormattingContext(sourceFile, requestKind);
+            // find the smallest node that fully wraps the range and compute the initial indentation for the node
+            var enclosingNode = findEnclosingNode(originalRange, sourceFile);
+            var formattingScanner = formatting.getFormattingScanner(sourceFile, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end);
+            var initialIndentation = formatting.SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, options);
+            var previousRangeHasError;
+            var previousRange;
+            var previousParent;
+            var previousRangeStartLine;
+            var lastIndentedLine;
+            var indentationOnLastIndentedLine;
+            var edits = [];
+            formattingScanner.advance();
+            if (formattingScanner.isOnToken()) {
+                var startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line;
+                var undecoratedStartLine = startLine;
+                if (enclosingNode.decorators) {
+                    undecoratedStartLine = sourceFile.getLineAndCharacterOfPosition(ts.getNonDecoratorTokenPosOfNode(enclosingNode, sourceFile)).line;
+                }
+                var delta = getOwnOrInheritedDelta(enclosingNode, options, sourceFile);
+                processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta);
+            }
+            if (!formattingScanner.isOnToken()) {
+                var leadingTrivia = formattingScanner.getCurrentLeadingTrivia();
+                if (leadingTrivia) {
+                    processTrivia(leadingTrivia, enclosingNode, enclosingNode, undefined);
+                    trimTrailingWhitespacesForRemainingRange();
+                }
+            }
+            formattingScanner.close();
+            return edits;
+            // local functions
+            /** Tries to compute the indentation for a list element.
+              * If list element is not in range then
+              * function will pick its actual indentation
+              * so it can be pushed downstream as inherited indentation.
+              * If list element is in the range - its indentation will be equal
+              * to inherited indentation from its predecessors.
+              */
+            function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) {
+                if (ts.rangeOverlapsWithStartEnd(range, startPos, endPos) ||
+                    ts.rangeContainsStartEnd(range, startPos, endPos) /* Not to miss zero-range nodes e.g. JsxText */) {
+                    if (inheritedIndentation !== -1 /* Unknown */) {
+                        return inheritedIndentation;
+                    }
+                }
+                else {
+                    var startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line;
+                    var startLinePosition = ts.getLineStartPositionForPosition(startPos, sourceFile);
+                    var column = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, startPos, sourceFile, options);
+                    if (startLine !== parentStartLine || startPos === column) {
+                        // Use the base indent size if it is greater than
+                        // the indentation of the inherited predecessor.
+                        var baseIndentSize = formatting.SmartIndenter.getBaseIndentation(options);
+                        return baseIndentSize > column ? baseIndentSize : column;
+                    }
+                }
+                return -1 /* Unknown */;
+            }
+            function computeIndentation(node, startLine, inheritedIndentation, parent, parentDynamicIndentation, effectiveParentStartLine) {
+                var indentation = inheritedIndentation;
+                var delta = formatting.SmartIndenter.shouldIndentChildNode(node) ? options.IndentSize : 0;
+                if (effectiveParentStartLine === startLine) {
+                    // if node is located on the same line with the parent
+                    // - inherit indentation from the parent
+                    // - push children if either parent of node itself has non-zero delta
+                    indentation = startLine === lastIndentedLine
+                        ? indentationOnLastIndentedLine
+                        : parentDynamicIndentation.getIndentation();
+                    delta = Math.min(options.IndentSize, parentDynamicIndentation.getDelta(node) + delta);
+                }
+                else if (indentation === -1 /* Unknown */) {
+                    if (formatting.SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile)) {
+                        indentation = parentDynamicIndentation.getIndentation();
+                    }
+                    else {
+                        indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(node);
+                    }
+                }
+                return {
+                    indentation: indentation,
+                    delta: delta
+                };
+            }
+            function getFirstNonDecoratorTokenOfNode(node) {
+                if (node.modifiers && node.modifiers.length) {
+                    return node.modifiers[0].kind;
+                }
+                switch (node.kind) {
+                    case 221 /* ClassDeclaration */: return 73 /* ClassKeyword */;
+                    case 222 /* InterfaceDeclaration */: return 107 /* InterfaceKeyword */;
+                    case 220 /* FunctionDeclaration */: return 87 /* FunctionKeyword */;
+                    case 224 /* EnumDeclaration */: return 224 /* EnumDeclaration */;
+                    case 149 /* GetAccessor */: return 123 /* GetKeyword */;
+                    case 150 /* SetAccessor */: return 131 /* SetKeyword */;
+                    case 147 /* MethodDeclaration */:
+                        if (node.asteriskToken) {
+                            return 37 /* AsteriskToken */;
+                        }
+                    // fall-through
+                    case 145 /* PropertyDeclaration */:
+                    case 142 /* Parameter */:
+                        return node.name.kind;
+                }
+            }
+            function getDynamicIndentation(node, nodeStartLine, indentation, delta) {
+                return {
+                    getIndentationForComment: function (kind, tokenIndentation, container) {
+                        switch (kind) {
+                            // preceding comment to the token that closes the indentation scope inherits the indentation from the scope
+                            // ..  {
+                            //     // comment
+                            // }
+                            case 16 /* CloseBraceToken */:
+                            case 20 /* CloseBracketToken */:
+                            case 18 /* CloseParenToken */:
+                                return indentation + getEffectiveDelta(delta, container);
+                        }
+                        return tokenIndentation !== -1 /* Unknown */ ? tokenIndentation : indentation;
+                    },
+                    getIndentationForToken: function (line, kind, container) {
+                        if (nodeStartLine !== line && node.decorators) {
+                            if (kind === getFirstNonDecoratorTokenOfNode(node)) {
+                                // if this token is the first token following the list of decorators, we do not need to indent
+                                return indentation;
+                            }
+                        }
+                        switch (kind) {
+                            // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent
+                            case 15 /* OpenBraceToken */:
+                            case 16 /* CloseBraceToken */:
+                            case 19 /* OpenBracketToken */:
+                            case 20 /* CloseBracketToken */:
+                            case 17 /* OpenParenToken */:
+                            case 18 /* CloseParenToken */:
+                            case 80 /* ElseKeyword */:
+                            case 104 /* WhileKeyword */:
+                            case 55 /* AtToken */:
+                                return indentation;
+                            default:
+                                // if token line equals to the line of containing node (this is a first token in the node) - use node indentation
+                                return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation;
+                        }
+                    },
+                    getIndentation: function () { return indentation; },
+                    getDelta: function (child) { return getEffectiveDelta(delta, child); },
+                    recomputeIndentation: function (lineAdded) {
+                        if (node.parent && formatting.SmartIndenter.shouldIndentChildNode(node.parent, node)) {
+                            if (lineAdded) {
+                                indentation += options.IndentSize;
+                            }
+                            else {
+                                indentation -= options.IndentSize;
+                            }
+                            if (formatting.SmartIndenter.shouldIndentChildNode(node)) {
+                                delta = options.IndentSize;
+                            }
+                            else {
+                                delta = 0;
+                            }
+                        }
+                    }
+                };
+                function getEffectiveDelta(delta, child) {
+                    // Delta value should be zero when the node explicitly prevents indentation of the child node
+                    return formatting.SmartIndenter.nodeWillIndentChild(node, child, true) ? delta : 0;
+                }
+            }
+            function processNode(node, contextNode, nodeStartLine, undecoratedNodeStartLine, indentation, delta) {
+                if (!ts.rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) {
+                    return;
+                }
+                var nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta);
+                // a useful observations when tracking context node
+                //        /
+                //      [a]
+                //   /   |   \
+                //  [b] [c] [d]
+                // node 'a' is a context node for nodes 'b', 'c', 'd'
+                // except for the leftmost leaf token in [b] - in this case context node ('e') is located somewhere above 'a'
+                // this rule can be applied recursively to child nodes of 'a'.
+                //
+                // context node is set to parent node value after processing every child node
+                // context node is set to parent of the token after processing every token
+                var childContextNode = contextNode;
+                // if there are any tokens that logically belong to node and interleave child nodes
+                // such tokens will be consumed in processChildNode for for the child that follows them
+                ts.forEachChild(node, function (child) {
+                    processChildNode(child, /*inheritedIndentation*/ -1 /* Unknown */, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, /*isListItem*/ false);
+                }, function (nodes) {
+                    processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation);
+                });
+                // proceed any tokens in the node that are located after child nodes
+                while (formattingScanner.isOnToken()) {
+                    var tokenInfo = formattingScanner.readTokenInfo(node);
+                    if (tokenInfo.token.end > node.end) {
+                        break;
+                    }
+                    consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation);
+                }
+                function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    var childStartPos = child.getStart(sourceFile);
+                    var childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line;
+                    var undecoratedChildStartLine = childStartLine;
+                    if (child.decorators) {
+                        undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(ts.getNonDecoratorTokenPosOfNode(child, sourceFile)).line;
+                    }
+                    // if child is a list item - try to get its indentation
+                    var childIndentationAmount = -1 /* Unknown */;
+                    if (isListItem) {
+                        childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation);
+                        if (childIndentationAmount !== -1 /* Unknown */) {
+                            inheritedIndentation = childIndentationAmount;
+                        }
+                    }
+                    // child node is outside the target range - do not dive inside
+                    if (!ts.rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) {
+                        if (child.end < originalRange.pos) {
+                            formattingScanner.skipToEndOf(child);
+                        }
+                        return inheritedIndentation;
+                    }
+                    if (child.getFullWidth() === 0) {
+                        return inheritedIndentation;
+                    }
+                    while (formattingScanner.isOnToken()) {
+                        // proceed any parent tokens that are located prior to child.getStart()
+                        var tokenInfo = formattingScanner.readTokenInfo(node);
+                        if (tokenInfo.token.end > childStartPos) {
+                            // stop when formatting scanner advances past the beginning of the child
+                            break;
+                        }
+                        consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation);
+                    }
+                    if (!formattingScanner.isOnToken()) {
+                        return inheritedIndentation;
+                    }
+                    if (ts.isToken(child)) {
+                        // if child node is a token, it does not impact indentation, proceed it using parent indentation scope rules
+                        var tokenInfo = formattingScanner.readTokenInfo(child);
+                        ts.Debug.assert(tokenInfo.token.end === child.end);
+                        consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, child);
+                        return inheritedIndentation;
+                    }
+                    var effectiveParentStartLine = child.kind === 143 /* Decorator */ ? childStartLine : undecoratedParentStartLine;
+                    var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine);
+                    processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta);
+                    childContextNode = node;
+                    if (isFirstListItem && parent.kind === 170 /* ArrayLiteralExpression */ && inheritedIndentation === -1 /* Unknown */) {
+                        inheritedIndentation = childIndentation.indentation;
+                    }
+                    return inheritedIndentation;
+                }
+                function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
+                    var listStartToken = getOpenTokenForList(parent, nodes);
+                    var listEndToken = getCloseTokenForOpenToken(listStartToken);
+                    var listDynamicIndentation = parentDynamicIndentation;
+                    var startLine = parentStartLine;
+                    if (listStartToken !== 0 /* Unknown */) {
+                        // introduce a new indentation scope for lists (including list start and end tokens)
+                        while (formattingScanner.isOnToken()) {
+                            var tokenInfo = formattingScanner.readTokenInfo(parent);
+                            if (tokenInfo.token.end > nodes.pos) {
+                                // stop when formatting scanner moves past the beginning of node list
+                                break;
+                            }
+                            else if (tokenInfo.token.kind === listStartToken) {
+                                // consume list start token
+                                startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line;
+                                var indentation_1 = computeIndentation(tokenInfo.token, startLine, -1 /* Unknown */, parent, parentDynamicIndentation, parentStartLine);
+                                listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation_1.indentation, indentation_1.delta);
+                                consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation);
+                            }
+                            else {
+                                // consume any tokens that precede the list as child elements of 'node' using its indentation scope
+                                consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation);
+                            }
+                        }
+                    }
+                    var inheritedIndentation = -1 /* Unknown */;
+                    for (var i = 0; i < nodes.length; i++) {
+                        var child = nodes[i];
+                        inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListItem*/ true, /*isFirstListItem*/ i === 0);
+                    }
+                    if (listEndToken !== 0 /* Unknown */) {
+                        if (formattingScanner.isOnToken()) {
+                            var tokenInfo = formattingScanner.readTokenInfo(parent);
+                            // consume the list end token only if it is still belong to the parent
+                            // there might be the case when current token matches end token but does not considered as one
+                            // function (x: function) <--
+                            // without this check close paren will be interpreted as list end token for function expression which is wrong
+                            if (tokenInfo.token.kind === listEndToken && ts.rangeContainsRange(parent, tokenInfo.token)) {
+                                // consume list end token
+                                consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation);
+                            }
+                        }
+                    }
+                }
+                function consumeTokenAndAdvanceScanner(currentTokenInfo, parent, dynamicIndentation, container) {
+                    ts.Debug.assert(ts.rangeContainsRange(parent, currentTokenInfo.token));
+                    var lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine();
+                    var indentToken = false;
+                    if (currentTokenInfo.leadingTrivia) {
+                        processTrivia(currentTokenInfo.leadingTrivia, parent, childContextNode, dynamicIndentation);
+                    }
+                    var lineAdded;
+                    var isTokenInRange = ts.rangeContainsRange(originalRange, currentTokenInfo.token);
+                    var tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos);
+                    if (isTokenInRange) {
+                        var rangeHasError = rangeContainsError(currentTokenInfo.token);
+                        // save previousRange since processRange will overwrite this value with current one
+                        var savePreviousRange = previousRange;
+                        lineAdded = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation);
+                        if (rangeHasError) {
+                            // do not indent comments\token if token range overlaps with some error
+                            indentToken = false;
+                        }
+                        else {
+                            if (lineAdded !== undefined) {
+                                indentToken = lineAdded;
+                            }
+                            else {
+                                // indent token only if end line of previous range does not match start line of the token
+                                var prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line;
+                                indentToken = lastTriviaWasNewLine && tokenStart.line !== prevEndLine;
+                            }
+                        }
+                    }
+                    if (currentTokenInfo.trailingTrivia) {
+                        processTrivia(currentTokenInfo.trailingTrivia, parent, childContextNode, dynamicIndentation);
+                    }
+                    if (indentToken) {
+                        var tokenIndentation = (isTokenInRange && !rangeContainsError(currentTokenInfo.token)) ?
+                            dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind, container) :
+                            -1 /* Unknown */;
+                        var indentNextTokenOrTrivia = true;
+                        if (currentTokenInfo.leadingTrivia) {
+                            var commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind, tokenIndentation, container);
+                            for (var _i = 0, _a = currentTokenInfo.leadingTrivia; _i < _a.length; _i++) {
+                                var triviaItem = _a[_i];
+                                var triviaInRange = ts.rangeContainsRange(originalRange, triviaItem);
+                                switch (triviaItem.kind) {
+                                    case 3 /* MultiLineCommentTrivia */:
+                                        if (triviaInRange) {
+                                            indentMultilineComment(triviaItem, commentIndentation, /*firstLineIsIndented*/ !indentNextTokenOrTrivia);
+                                        }
+                                        indentNextTokenOrTrivia = false;
+                                        break;
+                                    case 2 /* SingleLineCommentTrivia */:
+                                        if (indentNextTokenOrTrivia && triviaInRange) {
+                                            insertIndentation(triviaItem.pos, commentIndentation, /*lineAdded*/ false);
+                                        }
+                                        indentNextTokenOrTrivia = false;
+                                        break;
+                                    case 4 /* NewLineTrivia */:
+                                        indentNextTokenOrTrivia = true;
+                                        break;
+                                }
+                            }
+                        }
+                        // indent token only if is it is in target range and does not overlap with any error ranges
+                        if (tokenIndentation !== -1 /* Unknown */ && indentNextTokenOrTrivia) {
+                            insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAdded);
+                            lastIndentedLine = tokenStart.line;
+                            indentationOnLastIndentedLine = tokenIndentation;
+                        }
+                    }
+                    formattingScanner.advance();
+                    childContextNode = parent;
+                }
+            }
+            function processTrivia(trivia, parent, contextNode, dynamicIndentation) {
+                for (var _i = 0, trivia_1 = trivia; _i < trivia_1.length; _i++) {
+                    var triviaItem = trivia_1[_i];
+                    if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) {
+                        var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);
+                        processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation);
+                    }
+                }
+            }
+            function processRange(range, rangeStart, parent, contextNode, dynamicIndentation) {
+                var rangeHasError = rangeContainsError(range);
+                var lineAdded;
+                if (!rangeHasError && !previousRangeHasError) {
+                    if (!previousRange) {
+                        // trim whitespaces starting from the beginning of the span up to the current line
+                        var originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos);
+                        trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line);
+                    }
+                    else {
+                        lineAdded =
+                            processPair(range, rangeStart.line, parent, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation);
+                    }
+                }
+                previousRange = range;
+                previousParent = parent;
+                previousRangeStartLine = rangeStart.line;
+                previousRangeHasError = rangeHasError;
+                return lineAdded;
+            }
+            function processPair(currentItem, currentStartLine, currentParent, previousItem, previousStartLine, previousParent, contextNode, dynamicIndentation) {
+                formattingContext.updateContext(previousItem, previousParent, currentItem, currentParent, contextNode);
+                var rule = rulesProvider.getRulesMap().GetRule(formattingContext);
+                var trimTrailingWhitespaces;
+                var lineAdded;
+                if (rule) {
+                    applyRuleEdits(rule, previousItem, previousStartLine, currentItem, currentStartLine);
+                    if (rule.Operation.Action & (2 /* Space */ | 8 /* Delete */) && currentStartLine !== previousStartLine) {
+                        lineAdded = false;
+                        // Handle the case where the next line is moved to be the end of this line.
+                        // In this case we don't indent the next line in the next pass.
+                        if (currentParent.getStart(sourceFile) === currentItem.pos) {
+                            dynamicIndentation.recomputeIndentation(/*lineAddedByFormatting*/ false);
+                        }
+                    }
+                    else if (rule.Operation.Action & 4 /* NewLine */ && currentStartLine === previousStartLine) {
+                        lineAdded = true;
+                        // Handle the case where token2 is moved to the new line.
+                        // In this case we indent token2 in the next pass but we set
+                        // sameLineIndent flag to notify the indenter that the indentation is within the line.
+                        if (currentParent.getStart(sourceFile) === currentItem.pos) {
+                            dynamicIndentation.recomputeIndentation(/*lineAddedByFormatting*/ true);
+                        }
+                    }
+                    // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line
+                    trimTrailingWhitespaces = !(rule.Operation.Action & 8 /* Delete */) && rule.Flag !== 1 /* CanDeleteNewLines */;
+                }
+                else {
+                    trimTrailingWhitespaces = true;
+                }
+                if (currentStartLine !== previousStartLine && trimTrailingWhitespaces) {
+                    // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line
+                    trimTrailingWhitespacesForLines(previousStartLine, currentStartLine, previousItem);
+                }
+                return lineAdded;
+            }
+            function insertIndentation(pos, indentation, lineAdded) {
+                var indentationString = getIndentationString(indentation, options);
+                if (lineAdded) {
+                    // new line is added before the token by the formatting rules
+                    // insert indentation string at the very beginning of the token
+                    recordReplace(pos, 0, indentationString);
+                }
+                else {
+                    var tokenStart = sourceFile.getLineAndCharacterOfPosition(pos);
+                    var startLinePosition = ts.getStartPositionOfLine(tokenStart.line, sourceFile);
+                    if (indentation !== tokenStart.character || indentationIsDifferent(indentationString, startLinePosition)) {
+                        recordReplace(startLinePosition, tokenStart.character, indentationString);
+                    }
+                }
+            }
+            function indentationIsDifferent(indentationString, startLinePosition) {
+                return indentationString !== sourceFile.text.substr(startLinePosition, indentationString.length);
+            }
+            function indentMultilineComment(commentRange, indentation, firstLineIsIndented) {
+                // split comment in lines
+                var startLine = sourceFile.getLineAndCharacterOfPosition(commentRange.pos).line;
+                var endLine = sourceFile.getLineAndCharacterOfPosition(commentRange.end).line;
+                var parts;
+                if (startLine === endLine) {
+                    if (!firstLineIsIndented) {
+                        // treat as single line comment
+                        insertIndentation(commentRange.pos, indentation, /*lineAdded*/ false);
+                    }
+                    return;
+                }
+                else {
+                    parts = [];
+                    var startPos = commentRange.pos;
+                    for (var line = startLine; line < endLine; line++) {
+                        var endOfLine = ts.getEndLinePosition(line, sourceFile);
+                        parts.push({ pos: startPos, end: endOfLine });
+                        startPos = ts.getStartPositionOfLine(line + 1, sourceFile);
+                    }
+                    parts.push({ pos: startPos, end: commentRange.end });
+                }
+                var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile);
+                var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options);
+                if (indentation === nonWhitespaceColumnInFirstPart.column) {
+                    return;
+                }
+                var startIndex = 0;
+                if (firstLineIsIndented) {
+                    startIndex = 1;
+                    startLine++;
+                }
+                // shift all parts on the delta size
+                var delta = indentation - nonWhitespaceColumnInFirstPart.column;
+                for (var i = startIndex, len = parts.length; i < len; i++, startLine++) {
+                    var startLinePos_1 = ts.getStartPositionOfLine(startLine, sourceFile);
+                    var nonWhitespaceCharacterAndColumn = i === 0
+                        ? nonWhitespaceColumnInFirstPart
+                        : formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options);
+                    var newIndentation = nonWhitespaceCharacterAndColumn.column + delta;
+                    if (newIndentation > 0) {
+                        var indentationString = getIndentationString(newIndentation, options);
+                        recordReplace(startLinePos_1, nonWhitespaceCharacterAndColumn.character, indentationString);
+                    }
+                    else {
+                        recordDelete(startLinePos_1, nonWhitespaceCharacterAndColumn.character);
+                    }
+                }
+            }
+            function trimTrailingWhitespacesForLines(line1, line2, range) {
+                for (var line = line1; line < line2; line++) {
+                    var lineStartPosition = ts.getStartPositionOfLine(line, sourceFile);
+                    var lineEndPosition = ts.getEndLinePosition(line, sourceFile);
+                    // do not trim whitespaces in comments or template expression
+                    if (range && (ts.isComment(range.kind) || ts.isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) {
+                        continue;
+                    }
+                    var whitespaceStart = getTrailingWhitespaceStartPosition(lineStartPosition, lineEndPosition);
+                    if (whitespaceStart !== -1) {
+                        ts.Debug.assert(whitespaceStart === lineStartPosition || !ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(whitespaceStart - 1)));
+                        recordDelete(whitespaceStart, lineEndPosition + 1 - whitespaceStart);
+                    }
+                }
+            }
+            /**
+             * @param start The position of the first character in range
+             * @param end The position of the last character in range
+             */
+            function getTrailingWhitespaceStartPosition(start, end) {
+                var pos = end;
+                while (pos >= start && ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(pos))) {
+                    pos--;
+                }
+                if (pos !== end) {
+                    return pos + 1;
+                }
+                return -1;
+            }
+            /**
+             * Trimming will be done for lines after the previous range
+             */
+            function trimTrailingWhitespacesForRemainingRange() {
+                var startPosition = previousRange ? previousRange.end : originalRange.pos;
+                var startLine = sourceFile.getLineAndCharacterOfPosition(startPosition).line;
+                var endLine = sourceFile.getLineAndCharacterOfPosition(originalRange.end).line;
+                trimTrailingWhitespacesForLines(startLine, endLine + 1, previousRange);
+            }
+            function newTextChange(start, len, newText) {
+                return { span: ts.createTextSpan(start, len), newText: newText };
+            }
+            function recordDelete(start, len) {
+                if (len) {
+                    edits.push(newTextChange(start, len, ""));
+                }
+            }
+            function recordReplace(start, len, newText) {
+                if (len || newText) {
+                    edits.push(newTextChange(start, len, newText));
+                }
+            }
+            function applyRuleEdits(rule, previousRange, previousStartLine, currentRange, currentStartLine) {
+                switch (rule.Operation.Action) {
+                    case 1 /* Ignore */:
+                        // no action required
+                        return;
+                    case 8 /* Delete */:
+                        if (previousRange.end !== currentRange.pos) {
+                            // delete characters starting from t1.end up to t2.pos exclusive
+                            recordDelete(previousRange.end, currentRange.pos - previousRange.end);
+                        }
+                        break;
+                    case 4 /* NewLine */:
+                        // exit early if we on different lines and rule cannot change number of newlines
+                        // if line1 and line2 are on subsequent lines then no edits are required - ok to exit
+                        // if line1 and line2 are separated with more than one newline - ok to exit since we cannot delete extra new lines
+                        if (rule.Flag !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
+                            return;
+                        }
+                        // edit should not be applied only if we have one line feed between elements
+                        var lineDelta = currentStartLine - previousStartLine;
+                        if (lineDelta !== 1) {
+                            recordReplace(previousRange.end, currentRange.pos - previousRange.end, options.NewLineCharacter);
+                        }
+                        break;
+                    case 2 /* Space */:
+                        // exit early if we on different lines and rule cannot change number of newlines
+                        if (rule.Flag !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
+                            return;
+                        }
+                        var posDelta = currentRange.pos - previousRange.end;
+                        if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange.end) !== 32 /* space */) {
+                            recordReplace(previousRange.end, currentRange.pos - previousRange.end, " ");
+                        }
+                        break;
+                }
+            }
+        }
+        function getOpenTokenForList(node, list) {
+            switch (node.kind) {
+                case 148 /* Constructor */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 180 /* ArrowFunction */:
+                    if (node.typeParameters === list) {
+                        return 25 /* LessThanToken */;
+                    }
+                    else if (node.parameters === list) {
+                        return 17 /* OpenParenToken */;
+                    }
+                    break;
+                case 174 /* CallExpression */:
+                case 175 /* NewExpression */:
+                    if (node.typeArguments === list) {
+                        return 25 /* LessThanToken */;
+                    }
+                    else if (node.arguments === list) {
+                        return 17 /* OpenParenToken */;
+                    }
+                    break;
+                case 155 /* TypeReference */:
+                    if (node.typeArguments === list) {
+                        return 25 /* LessThanToken */;
+                    }
+            }
+            return 0 /* Unknown */;
+        }
+        function getCloseTokenForOpenToken(kind) {
+            switch (kind) {
+                case 17 /* OpenParenToken */:
+                    return 18 /* CloseParenToken */;
+                case 25 /* LessThanToken */:
+                    return 27 /* GreaterThanToken */;
+            }
+            return 0 /* Unknown */;
+        }
+        var internedSizes;
+        var internedTabsIndentation;
+        var internedSpacesIndentation;
+        function getIndentationString(indentation, options) {
+            // reset interned strings if FormatCodeOptions were changed
+            var resetInternedStrings = !internedSizes || (internedSizes.tabSize !== options.TabSize || internedSizes.indentSize !== options.IndentSize);
+            if (resetInternedStrings) {
+                internedSizes = { tabSize: options.TabSize, indentSize: options.IndentSize };
+                internedTabsIndentation = internedSpacesIndentation = undefined;
+            }
+            if (!options.ConvertTabsToSpaces) {
+                var tabs = Math.floor(indentation / options.TabSize);
+                var spaces = indentation - tabs * options.TabSize;
+                var tabString = void 0;
+                if (!internedTabsIndentation) {
+                    internedTabsIndentation = [];
+                }
+                if (internedTabsIndentation[tabs] === undefined) {
+                    internedTabsIndentation[tabs] = tabString = repeat("\t", tabs);
+                }
+                else {
+                    tabString = internedTabsIndentation[tabs];
+                }
+                return spaces ? tabString + repeat(" ", spaces) : tabString;
+            }
+            else {
+                var spacesString = void 0;
+                var quotient = Math.floor(indentation / options.IndentSize);
+                var remainder = indentation % options.IndentSize;
+                if (!internedSpacesIndentation) {
+                    internedSpacesIndentation = [];
+                }
+                if (internedSpacesIndentation[quotient] === undefined) {
+                    spacesString = repeat(" ", options.IndentSize * quotient);
+                    internedSpacesIndentation[quotient] = spacesString;
+                }
+                else {
+                    spacesString = internedSpacesIndentation[quotient];
+                }
+                return remainder ? spacesString + repeat(" ", remainder) : spacesString;
+            }
+            function repeat(value, count) {
+                var s = "";
+                for (var i = 0; i < count; i++) {
+                    s += value;
+                }
+                return s;
+            }
+        }
+        formatting.getIndentationString = getIndentationString;
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+///<reference path='..\services.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var formatting;
+    (function (formatting) {
+        var SmartIndenter;
+        (function (SmartIndenter) {
+            var Value;
+            (function (Value) {
+                Value[Value["Unknown"] = -1] = "Unknown";
+            })(Value || (Value = {}));
+            function getIndentation(position, sourceFile, options) {
+                if (position > sourceFile.text.length) {
+                    return getBaseIndentation(options); // past EOF
+                }
+                // no indentation when the indent style is set to none,
+                // so we can return fast
+                if (options.IndentStyle === ts.IndentStyle.None) {
+                    return 0;
+                }
+                var precedingToken = ts.findPrecedingToken(position, sourceFile);
+                if (!precedingToken) {
+                    return getBaseIndentation(options);
+                }
+                // no indentation in string \regex\template literals
+                var precedingTokenIsLiteral = ts.isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind);
+                if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) {
+                    return 0;
+                }
+                var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
+                // indentation is first non-whitespace character in a previous line
+                // for block indentation, we should look for a line which contains something that's not
+                // whitespace.
+                if (options.IndentStyle === ts.IndentStyle.Block) {
+                    // move backwards until we find a line with a non-whitespace character,
+                    // then find the first non-whitespace character for that line.
+                    var current_1 = position;
+                    while (current_1 > 0) {
+                        var char = sourceFile.text.charCodeAt(current_1);
+                        if (!ts.isWhiteSpace(char)) {
+                            break;
+                        }
+                        current_1--;
+                    }
+                    var lineStart = ts.getLineStartPositionForPosition(current_1, sourceFile);
+                    return SmartIndenter.findFirstNonWhitespaceColumn(lineStart, current_1, sourceFile, options);
+                }
+                if (precedingToken.kind === 24 /* CommaToken */ && precedingToken.parent.kind !== 187 /* BinaryExpression */) {
+                    // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
+                    var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
+                    if (actualIndentation !== -1 /* Unknown */) {
+                        return actualIndentation;
+                    }
+                }
+                // try to find node that can contribute to indentation and includes 'position' starting from 'precedingToken'
+                // if such node is found - compute initial indentation for 'position' inside this node
+                var previous;
+                var current = precedingToken;
+                var currentStart;
+                var indentationDelta;
+                while (current) {
+                    if (ts.positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current, previous)) {
+                        currentStart = getStartLineAndCharacterForNode(current, sourceFile);
+                        if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) {
+                            indentationDelta = 0;
+                        }
+                        else {
+                            indentationDelta = lineAtPosition !== currentStart.line ? options.IndentSize : 0;
+                        }
+                        break;
+                    }
+                    // check if current node is a list item - if yes, take indentation from it
+                    var actualIndentation = getActualIndentationForListItem(current, sourceFile, options);
+                    if (actualIndentation !== -1 /* Unknown */) {
+                        return actualIndentation;
+                    }
+                    actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options);
+                    if (actualIndentation !== -1 /* Unknown */) {
+                        return actualIndentation + options.IndentSize;
+                    }
+                    previous = current;
+                    current = current.parent;
+                }
+                if (!current) {
+                    // no parent was found - return the base indentation of the SourceFile
+                    return getBaseIndentation(options);
+                }
+                return getIndentationForNodeWorker(current, currentStart, /*ignoreActualIndentationRange*/ undefined, indentationDelta, sourceFile, options);
+            }
+            SmartIndenter.getIndentation = getIndentation;
+            function getBaseIndentation(options) {
+                return options.BaseIndentSize || 0;
+            }
+            SmartIndenter.getBaseIndentation = getBaseIndentation;
+            function getIndentationForNode(n, ignoreActualIndentationRange, sourceFile, options) {
+                var start = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
+                return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, /*indentationDelta*/ 0, sourceFile, options);
+            }
+            SmartIndenter.getIndentationForNode = getIndentationForNode;
+            function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, options) {
+                var parent = current.parent;
+                var parentStart;
+                // walk upwards and collect indentations for pairs of parent-child nodes
+                // indentation is not added if parent and child nodes start on the same line or if parent is IfStatement and child starts on the same line with 'else clause'
+                while (parent) {
+                    var useActualIndentation = true;
+                    if (ignoreActualIndentationRange) {
+                        var start = current.getStart(sourceFile);
+                        useActualIndentation = start < ignoreActualIndentationRange.pos || start > ignoreActualIndentationRange.end;
+                    }
+                    if (useActualIndentation) {
+                        // check if current node is a list item - if yes, take indentation from it
+                        var actualIndentation = getActualIndentationForListItem(current, sourceFile, options);
+                        if (actualIndentation !== -1 /* Unknown */) {
+                            return actualIndentation + indentationDelta;
+                        }
+                    }
+                    parentStart = getParentStart(parent, current, sourceFile);
+                    var parentAndChildShareLine = parentStart.line === currentStart.line ||
+                        childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile);
+                    if (useActualIndentation) {
+                        // try to fetch actual indentation for current node from source text
+                        var actualIndentation = getActualIndentationForNode(current, parent, currentStart, parentAndChildShareLine, sourceFile, options);
+                        if (actualIndentation !== -1 /* Unknown */) {
+                            return actualIndentation + indentationDelta;
+                        }
+                        actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options);
+                        if (actualIndentation !== -1 /* Unknown */) {
+                            return actualIndentation + indentationDelta;
+                        }
+                    }
+                    // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line
+                    if (shouldIndentChildNode(parent, current) && !parentAndChildShareLine) {
+                        indentationDelta += options.IndentSize;
+                    }
+                    current = parent;
+                    currentStart = parentStart;
+                    parent = current.parent;
+                }
+                return indentationDelta + getBaseIndentation(options);
+            }
+            function getParentStart(parent, child, sourceFile) {
+                var containingList = getContainingList(child, sourceFile);
+                if (containingList) {
+                    return sourceFile.getLineAndCharacterOfPosition(containingList.pos);
+                }
+                return sourceFile.getLineAndCharacterOfPosition(parent.getStart(sourceFile));
+            }
+            /*
+             * Function returns Value.Unknown if indentation cannot be determined
+             */
+            function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) {
+                // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
+                var commaItemInfo = ts.findListItemInfo(commaToken);
+                if (commaItemInfo && commaItemInfo.listItemIndex > 0) {
+                    return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options);
+                }
+                else {
+                    // handle broken code gracefully
+                    return -1 /* Unknown */;
+                }
+            }
+            /*
+             * Function returns Value.Unknown if actual indentation for node should not be used (i.e because node is nested expression)
+             */
+            function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) {
+                // actual indentation is used for statements\declarations if one of cases below is true:
+                // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually
+                // - parent and child are not on the same line
+                var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) &&
+                    (parent.kind === 256 /* SourceFile */ || !parentAndChildShareLine);
+                if (!useActualIndentation) {
+                    return -1 /* Unknown */;
+                }
+                return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options);
+            }
+            function nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile) {
+                var nextToken = ts.findNextToken(precedingToken, current);
+                if (!nextToken) {
+                    return false;
+                }
+                if (nextToken.kind === 15 /* OpenBraceToken */) {
+                    // open braces are always indented at the parent level
+                    return true;
+                }
+                else if (nextToken.kind === 16 /* CloseBraceToken */) {
+                    // close braces are indented at the parent level if they are located on the same line with cursor
+                    // this means that if new line will be added at $ position, this case will be indented
+                    // class A {
+                    //    $
+                    // }
+                    /// and this one - not
+                    // class A {
+                    // $}
+                    var nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line;
+                    return lineAtPosition === nextTokenStartLine;
+                }
+                return false;
+            }
+            function getStartLineAndCharacterForNode(n, sourceFile) {
+                return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
+            }
+            function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) {
+                if (parent.kind === 203 /* IfStatement */ && parent.elseStatement === child) {
+                    var elseKeyword = ts.findChildOfKind(parent, 80 /* ElseKeyword */, sourceFile);
+                    ts.Debug.assert(elseKeyword !== undefined);
+                    var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
+                    return elseKeywordStartLine === childStartLine;
+                }
+                return false;
+            }
+            SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement;
+            function getContainingList(node, sourceFile) {
+                if (node.parent) {
+                    switch (node.parent.kind) {
+                        case 155 /* TypeReference */:
+                            if (node.parent.typeArguments &&
+                                ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) {
+                                return node.parent.typeArguments;
+                            }
+                            break;
+                        case 171 /* ObjectLiteralExpression */:
+                            return node.parent.properties;
+                        case 170 /* ArrayLiteralExpression */:
+                            return node.parent.elements;
+                        case 220 /* FunctionDeclaration */:
+                        case 179 /* FunctionExpression */:
+                        case 180 /* ArrowFunction */:
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                        case 151 /* CallSignature */:
+                        case 152 /* ConstructSignature */: {
+                            var start = node.getStart(sourceFile);
+                            if (node.parent.typeParameters &&
+                                ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) {
+                                return node.parent.typeParameters;
+                            }
+                            if (ts.rangeContainsStartEnd(node.parent.parameters, start, node.getEnd())) {
+                                return node.parent.parameters;
+                            }
+                            break;
+                        }
+                        case 175 /* NewExpression */:
+                        case 174 /* CallExpression */: {
+                            var start = node.getStart(sourceFile);
+                            if (node.parent.typeArguments &&
+                                ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) {
+                                return node.parent.typeArguments;
+                            }
+                            if (node.parent.arguments &&
+                                ts.rangeContainsStartEnd(node.parent.arguments, start, node.getEnd())) {
+                                return node.parent.arguments;
+                            }
+                            break;
+                        }
+                    }
+                }
+                return undefined;
+            }
+            function getActualIndentationForListItem(node, sourceFile, options) {
+                var containingList = getContainingList(node, sourceFile);
+                return containingList ? getActualIndentationFromList(containingList) : -1 /* Unknown */;
+                function getActualIndentationFromList(list) {
+                    var index = ts.indexOf(list, node);
+                    return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1 /* Unknown */;
+                }
+            }
+            function getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options) {
+                // actual indentation should not be used when:
+                // - node is close parenthesis - this is the end of the expression
+                if (node.kind === 18 /* CloseParenToken */) {
+                    return -1 /* Unknown */;
+                }
+                if (node.parent && (node.parent.kind === 174 /* CallExpression */ ||
+                    node.parent.kind === 175 /* NewExpression */) &&
+                    node.parent.expression !== node) {
+                    var fullCallOrNewExpression = node.parent.expression;
+                    var startingExpression = getStartingExpression(fullCallOrNewExpression);
+                    if (fullCallOrNewExpression === startingExpression) {
+                        return -1 /* Unknown */;
+                    }
+                    var fullCallOrNewExpressionEnd = sourceFile.getLineAndCharacterOfPosition(fullCallOrNewExpression.end);
+                    var startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end);
+                    if (fullCallOrNewExpressionEnd.line === startingExpressionEnd.line) {
+                        return -1 /* Unknown */;
+                    }
+                    return findColumnForFirstNonWhitespaceCharacterInLine(fullCallOrNewExpressionEnd, sourceFile, options);
+                }
+                return -1 /* Unknown */;
+                function getStartingExpression(node) {
+                    while (true) {
+                        switch (node.kind) {
+                            case 174 /* CallExpression */:
+                            case 175 /* NewExpression */:
+                            case 172 /* PropertyAccessExpression */:
+                            case 173 /* ElementAccessExpression */:
+                                node = node.expression;
+                                break;
+                            default:
+                                return node;
+                        }
+                    }
+                }
+            }
+            function deriveActualIndentationFromList(list, index, sourceFile, options) {
+                ts.Debug.assert(index >= 0 && index < list.length);
+                var node = list[index];
+                // walk toward the start of the list starting from current node and check if the line is the same for all items.
+                // if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i]
+                var lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile);
+                for (var i = index - 1; i >= 0; i--) {
+                    if (list[i].kind === 24 /* CommaToken */) {
+                        continue;
+                    }
+                    // skip list items that ends on the same line with the current list element
+                    var prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line;
+                    if (prevEndLine !== lineAndCharacter.line) {
+                        return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options);
+                    }
+                    lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile);
+                }
+                return -1 /* Unknown */;
+            }
+            function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) {
+                var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0);
+                return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);
+            }
+            /*
+                Character is the actual index of the character since the beginning of the line.
+                Column - position of the character after expanding tabs to spaces
+                "0\t2$"
+                value of 'character' for '$' is 3
+                value of 'column' for '$' is 6 (assuming that tab size is 4)
+            */
+            function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) {
+                var character = 0;
+                var column = 0;
+                for (var pos = startPos; pos < endPos; pos++) {
+                    var ch = sourceFile.text.charCodeAt(pos);
+                    if (!ts.isWhiteSpaceSingleLine(ch)) {
+                        break;
+                    }
+                    if (ch === 9 /* tab */) {
+                        column += options.TabSize + (column % options.TabSize);
+                    }
+                    else {
+                        column++;
+                    }
+                    character++;
+                }
+                return { column: column, character: character };
+            }
+            SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn;
+            function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) {
+                return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column;
+            }
+            SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn;
+            function nodeContentIsAlwaysIndented(kind) {
+                switch (kind) {
+                    case 202 /* ExpressionStatement */:
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                    case 170 /* ArrayLiteralExpression */:
+                    case 199 /* Block */:
+                    case 226 /* ModuleBlock */:
+                    case 171 /* ObjectLiteralExpression */:
+                    case 159 /* TypeLiteral */:
+                    case 161 /* TupleType */:
+                    case 227 /* CaseBlock */:
+                    case 250 /* DefaultClause */:
+                    case 249 /* CaseClause */:
+                    case 178 /* ParenthesizedExpression */:
+                    case 172 /* PropertyAccessExpression */:
+                    case 174 /* CallExpression */:
+                    case 175 /* NewExpression */:
+                    case 200 /* VariableStatement */:
+                    case 218 /* VariableDeclaration */:
+                    case 235 /* ExportAssignment */:
+                    case 211 /* ReturnStatement */:
+                    case 188 /* ConditionalExpression */:
+                    case 168 /* ArrayBindingPattern */:
+                    case 167 /* ObjectBindingPattern */:
+                    case 243 /* JsxOpeningElement */:
+                    case 242 /* JsxSelfClosingElement */:
+                    case 248 /* JsxExpression */:
+                    case 146 /* MethodSignature */:
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 142 /* Parameter */:
+                    case 156 /* FunctionType */:
+                    case 157 /* ConstructorType */:
+                    case 164 /* ParenthesizedType */:
+                    case 176 /* TaggedTemplateExpression */:
+                    case 184 /* AwaitExpression */:
+                    case 237 /* NamedExports */:
+                    case 233 /* NamedImports */:
+                    case 238 /* ExportSpecifier */:
+                    case 234 /* ImportSpecifier */:
+                        return true;
+                }
+                return false;
+            }
+            /* @internal */
+            function nodeWillIndentChild(parent, child, indentByDefault) {
+                var childKind = child ? child.kind : 0 /* Unknown */;
+                switch (parent.kind) {
+                    case 204 /* DoStatement */:
+                    case 205 /* WhileStatement */:
+                    case 207 /* ForInStatement */:
+                    case 208 /* ForOfStatement */:
+                    case 206 /* ForStatement */:
+                    case 203 /* IfStatement */:
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                    case 147 /* MethodDeclaration */:
+                    case 180 /* ArrowFunction */:
+                    case 148 /* Constructor */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        return childKind !== 199 /* Block */;
+                    case 236 /* ExportDeclaration */:
+                        return childKind !== 237 /* NamedExports */;
+                    case 230 /* ImportDeclaration */:
+                        return childKind !== 231 /* ImportClause */ ||
+                            (child.namedBindings && child.namedBindings.kind !== 233 /* NamedImports */);
+                    case 241 /* JsxElement */:
+                        return childKind !== 245 /* JsxClosingElement */;
+                }
+                // No explicit rule for given nodes so the result will follow the default value argument
+                return indentByDefault;
+            }
+            SmartIndenter.nodeWillIndentChild = nodeWillIndentChild;
+            /*
+            Function returns true when the parent node should indent the given child by an explicit rule
+            */
+            function shouldIndentChildNode(parent, child) {
+                return nodeContentIsAlwaysIndented(parent.kind) || nodeWillIndentChild(parent, child, /*indentByDefault*/ false);
+            }
+            SmartIndenter.shouldIndentChildNode = shouldIndentChildNode;
+        })(SmartIndenter = formatting.SmartIndenter || (formatting.SmartIndenter = {}));
+    })(formatting = ts.formatting || (ts.formatting = {}));
+})(ts || (ts = {}));
+/// <reference path="..\compiler\program.ts"/>
+/// <reference path="..\compiler\commandLineParser.ts"/>
+/// <reference path='breakpoints.ts' />
+/// <reference path='outliningElementsCollector.ts' />
+/// <reference path='navigateTo.ts' />
+/// <reference path='navigationBar.ts' />
+/// <reference path='patternMatcher.ts' />
+/// <reference path='signatureHelp.ts' />
+/// <reference path='utilities.ts' />
+/// <reference path='jsTyping.ts' />
+/// <reference path='formatting\formatting.ts' />
+/// <reference path='formatting\smartIndenter.ts' />
+var ts;
+(function (ts) {
+    /** The version of the language service API */
+    ts.servicesVersion = "0.5";
+    var ScriptSnapshot;
+    (function (ScriptSnapshot) {
+        var StringScriptSnapshot = (function () {
+            function StringScriptSnapshot(text) {
+                this.text = text;
+            }
+            StringScriptSnapshot.prototype.getText = function (start, end) {
+                return this.text.substring(start, end);
+            };
+            StringScriptSnapshot.prototype.getLength = function () {
+                return this.text.length;
+            };
+            StringScriptSnapshot.prototype.getChangeRange = function (oldSnapshot) {
+                // Text-based snapshots do not support incremental parsing. Return undefined
+                // to signal that to the caller.
+                return undefined;
+            };
+            return StringScriptSnapshot;
+        }());
+        function fromString(text) {
+            return new StringScriptSnapshot(text);
+        }
+        ScriptSnapshot.fromString = fromString;
+    })(ScriptSnapshot = ts.ScriptSnapshot || (ts.ScriptSnapshot = {}));
+    var scanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ true);
+    var emptyArray = [];
+    var jsDocTagNames = [
+        "augments",
+        "author",
+        "argument",
+        "borrows",
+        "class",
+        "constant",
+        "constructor",
+        "constructs",
+        "default",
+        "deprecated",
+        "description",
+        "event",
+        "example",
+        "extends",
+        "field",
+        "fileOverview",
+        "function",
+        "ignore",
+        "inner",
+        "lends",
+        "link",
+        "memberOf",
+        "name",
+        "namespace",
+        "param",
+        "private",
+        "property",
+        "public",
+        "requires",
+        "returns",
+        "see",
+        "since",
+        "static",
+        "throws",
+        "type",
+        "typedef",
+        "property",
+        "prop",
+        "version"
+    ];
+    var jsDocCompletionEntries;
+    function createNode(kind, pos, end, flags, parent) {
+        var node = new NodeObject(kind, pos, end);
+        node.flags = flags;
+        node.parent = parent;
+        return node;
+    }
+    var NodeObject = (function () {
+        function NodeObject(kind, pos, end) {
+            this.kind = kind;
+            this.pos = pos;
+            this.end = end;
+            this.flags = 0 /* None */;
+            this.parent = undefined;
+        }
+        NodeObject.prototype.getSourceFile = function () {
+            return ts.getSourceFileOfNode(this);
+        };
+        NodeObject.prototype.getStart = function (sourceFile, includeJsDocComment) {
+            return ts.getTokenPosOfNode(this, sourceFile, includeJsDocComment);
+        };
+        NodeObject.prototype.getFullStart = function () {
+            return this.pos;
+        };
+        NodeObject.prototype.getEnd = function () {
+            return this.end;
+        };
+        NodeObject.prototype.getWidth = function (sourceFile) {
+            return this.getEnd() - this.getStart(sourceFile);
+        };
+        NodeObject.prototype.getFullWidth = function () {
+            return this.end - this.pos;
+        };
+        NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) {
+            return this.getStart(sourceFile) - this.pos;
+        };
+        NodeObject.prototype.getFullText = function (sourceFile) {
+            return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);
+        };
+        NodeObject.prototype.getText = function (sourceFile) {
+            return (sourceFile || this.getSourceFile()).text.substring(this.getStart(), this.getEnd());
+        };
+        NodeObject.prototype.addSyntheticNodes = function (nodes, pos, end, useJSDocScanner) {
+            scanner.setTextPos(pos);
+            while (pos < end) {
+                var token = useJSDocScanner ? scanner.scanJSDocToken() : scanner.scan();
+                var textPos = scanner.getTextPos();
+                if (textPos <= end) {
+                    nodes.push(createNode(token, pos, textPos, 0, this));
+                }
+                pos = textPos;
+            }
+            return pos;
+        };
+        NodeObject.prototype.createSyntaxList = function (nodes) {
+            var list = createNode(282 /* SyntaxList */, nodes.pos, nodes.end, 0, this);
+            list._children = [];
+            var pos = nodes.pos;
+            for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
+                var node = nodes_4[_i];
+                if (pos < node.pos) {
+                    pos = this.addSyntheticNodes(list._children, pos, node.pos);
+                }
+                list._children.push(node);
+                pos = node.end;
+            }
+            if (pos < nodes.end) {
+                this.addSyntheticNodes(list._children, pos, nodes.end);
+            }
+            return list;
+        };
+        NodeObject.prototype.createChildren = function (sourceFile) {
+            var _this = this;
+            var children;
+            if (this.kind >= 139 /* FirstNode */) {
+                scanner.setText((sourceFile || this.getSourceFile()).text);
+                children = [];
+                var pos_3 = this.pos;
+                var useJSDocScanner_1 = this.kind >= 273 /* FirstJSDocTagNode */ && this.kind <= 281 /* LastJSDocTagNode */;
+                var processNode = function (node) {
+                    if (pos_3 < node.pos) {
+                        pos_3 = _this.addSyntheticNodes(children, pos_3, node.pos, useJSDocScanner_1);
+                    }
+                    children.push(node);
+                    pos_3 = node.end;
+                };
+                var processNodes = function (nodes) {
+                    if (pos_3 < nodes.pos) {
+                        pos_3 = _this.addSyntheticNodes(children, pos_3, nodes.pos, useJSDocScanner_1);
+                    }
+                    children.push(_this.createSyntaxList(nodes));
+                    pos_3 = nodes.end;
+                };
+                // jsDocComments need to be the first children
+                if (this.jsDocComments) {
+                    for (var _i = 0, _a = this.jsDocComments; _i < _a.length; _i++) {
+                        var jsDocComment = _a[_i];
+                        processNode(jsDocComment);
+                    }
+                }
+                ts.forEachChild(this, processNode, processNodes);
+                if (pos_3 < this.end) {
+                    this.addSyntheticNodes(children, pos_3, this.end);
+                }
+                scanner.setText(undefined);
+            }
+            this._children = children || emptyArray;
+        };
+        NodeObject.prototype.getChildCount = function (sourceFile) {
+            if (!this._children)
+                this.createChildren(sourceFile);
+            return this._children.length;
+        };
+        NodeObject.prototype.getChildAt = function (index, sourceFile) {
+            if (!this._children)
+                this.createChildren(sourceFile);
+            return this._children[index];
+        };
+        NodeObject.prototype.getChildren = function (sourceFile) {
+            if (!this._children)
+                this.createChildren(sourceFile);
+            return this._children;
+        };
+        NodeObject.prototype.getFirstToken = function (sourceFile) {
+            var children = this.getChildren(sourceFile);
+            if (!children.length) {
+                return undefined;
+            }
+            var child = children[0];
+            return child.kind < 139 /* FirstNode */ ? child : child.getFirstToken(sourceFile);
+        };
+        NodeObject.prototype.getLastToken = function (sourceFile) {
+            var children = this.getChildren(sourceFile);
+            var child = ts.lastOrUndefined(children);
+            if (!child) {
+                return undefined;
+            }
+            return child.kind < 139 /* FirstNode */ ? child : child.getLastToken(sourceFile);
+        };
+        return NodeObject;
+    }());
+    var SymbolObject = (function () {
+        function SymbolObject(flags, name) {
+            this.flags = flags;
+            this.name = name;
+        }
+        SymbolObject.prototype.getFlags = function () {
+            return this.flags;
+        };
+        SymbolObject.prototype.getName = function () {
+            return this.name;
+        };
+        SymbolObject.prototype.getDeclarations = function () {
+            return this.declarations;
+        };
+        SymbolObject.prototype.getDocumentationComment = function () {
+            if (this.documentationComment === undefined) {
+                this.documentationComment = getJsDocCommentsFromDeclarations(this.declarations, this.name, !(this.flags & 4 /* Property */));
+            }
+            return this.documentationComment;
+        };
+        return SymbolObject;
+    }());
+    function getJsDocCommentsFromDeclarations(declarations, name, canUseParsedParamTagComments) {
+        var documentationComment = [];
+        var docComments = getJsDocCommentsSeparatedByNewLines();
+        ts.forEach(docComments, function (docComment) {
+            if (documentationComment.length) {
+                documentationComment.push(ts.lineBreakPart());
+            }
+            documentationComment.push(docComment);
+        });
+        return documentationComment;
+        function getJsDocCommentsSeparatedByNewLines() {
+            var paramTag = "@param";
+            var jsDocCommentParts = [];
+            ts.forEach(declarations, function (declaration, indexOfDeclaration) {
+                // Make sure we are collecting doc comment from declaration once,
+                // In case of union property there might be same declaration multiple times
+                // which only varies in type parameter
+                // Eg. const a: Array<string> | Array<number>; a.length
+                // The property length will have two declarations of property length coming
+                // from Array<T> - Array<string> and Array<number>
+                if (ts.indexOf(declarations, declaration) === indexOfDeclaration) {
+                    var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration);
+                    // If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments
+                    if (canUseParsedParamTagComments && declaration.kind === 142 /* Parameter */) {
+                        if ((declaration.parent.kind === 179 /* FunctionExpression */ || declaration.parent.kind === 180 /* ArrowFunction */) &&
+                            declaration.parent.parent.kind === 218 /* VariableDeclaration */) {
+                            addCommentParts(declaration.parent.parent.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);
+                        }
+                        addCommentParts(declaration.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);
+                    }
+                    // If this is left side of dotted module declaration, there is no doc comments associated with this node
+                    if (declaration.kind === 225 /* ModuleDeclaration */ && declaration.body && declaration.body.kind === 225 /* ModuleDeclaration */) {
+                        return;
+                    }
+                    if ((declaration.kind === 179 /* FunctionExpression */ || declaration.kind === 180 /* ArrowFunction */) &&
+                        declaration.parent.kind === 218 /* VariableDeclaration */) {
+                        addCommentParts(declaration.parent.parent, sourceFileOfDeclaration, getCleanedJsDocComment);
+                    }
+                    // If this is dotted module name, get the doc comments from the parent
+                    while (declaration.kind === 225 /* ModuleDeclaration */ && declaration.parent.kind === 225 /* ModuleDeclaration */) {
+                        declaration = declaration.parent;
+                    }
+                    addCommentParts(declaration.kind === 218 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration, getCleanedJsDocComment);
+                    if (declaration.kind === 218 /* VariableDeclaration */) {
+                        var init = declaration.initializer;
+                        if (init && (init.kind === 179 /* FunctionExpression */ || init.kind === 180 /* ArrowFunction */)) {
+                            // Get the cleaned js doc comment text from the initializer
+                            addCommentParts(init, sourceFileOfDeclaration, getCleanedJsDocComment);
+                        }
+                    }
+                }
+            });
+            return jsDocCommentParts;
+            function addCommentParts(commented, sourceFileOfDeclaration, getCommentPart) {
+                var ranges = getJsDocCommentTextRange(commented, sourceFileOfDeclaration);
+                // Get the cleaned js doc comment text from the declaration
+                ts.forEach(ranges, function (jsDocCommentTextRange) {
+                    var cleanedComment = getCommentPart(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
+                    if (cleanedComment) {
+                        ts.addRange(jsDocCommentParts, cleanedComment);
+                    }
+                });
+            }
+            function getJsDocCommentTextRange(node, sourceFile) {
+                return ts.map(ts.getJsDocComments(node, sourceFile), function (jsDocComment) {
+                    return {
+                        pos: jsDocComment.pos + "/*".length,
+                        end: jsDocComment.end - "*/".length // Trim off comment end indicator
+                    };
+                });
+            }
+            function consumeWhiteSpacesOnTheLine(pos, end, sourceFile, maxSpacesToRemove) {
+                if (maxSpacesToRemove !== undefined) {
+                    end = Math.min(end, pos + maxSpacesToRemove);
+                }
+                for (; pos < end; pos++) {
+                    var ch = sourceFile.text.charCodeAt(pos);
+                    if (!ts.isWhiteSpaceSingleLine(ch)) {
+                        return pos;
+                    }
+                }
+                return end;
+            }
+            function consumeLineBreaks(pos, end, sourceFile) {
+                while (pos < end && ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                    pos++;
+                }
+                return pos;
+            }
+            function isName(pos, end, sourceFile, name) {
+                return pos + name.length < end &&
+                    sourceFile.text.substr(pos, name.length) === name &&
+                    ts.isWhiteSpace(sourceFile.text.charCodeAt(pos + name.length));
+            }
+            function isParamTag(pos, end, sourceFile) {
+                // If it is @param tag
+                return isName(pos, end, sourceFile, paramTag);
+            }
+            function pushDocCommentLineText(docComments, text, blankLineCount) {
+                // Add the empty lines in between texts
+                while (blankLineCount) {
+                    blankLineCount--;
+                    docComments.push(ts.textPart(""));
+                }
+                docComments.push(ts.textPart(text));
+            }
+            function getCleanedJsDocComment(pos, end, sourceFile) {
+                var spacesToRemoveAfterAsterisk;
+                var docComments = [];
+                var blankLineCount = 0;
+                var isInParamTag = false;
+                while (pos < end) {
+                    var docCommentTextOfLine = "";
+                    // First consume leading white space
+                    pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile);
+                    // If the comment starts with '*' consume the spaces on this line
+                    if (pos < end && sourceFile.text.charCodeAt(pos) === 42 /* asterisk */) {
+                        var lineStartPos = pos + 1;
+                        pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, spacesToRemoveAfterAsterisk);
+                        // Set the spaces to remove after asterisk as margin if not already set
+                        if (spacesToRemoveAfterAsterisk === undefined && pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                            spacesToRemoveAfterAsterisk = pos - lineStartPos;
+                        }
+                    }
+                    else if (spacesToRemoveAfterAsterisk === undefined) {
+                        spacesToRemoveAfterAsterisk = 0;
+                    }
+                    // Analyze text on this line
+                    while (pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                        var ch = sourceFile.text.charAt(pos);
+                        if (ch === "@") {
+                            // If it is @param tag
+                            if (isParamTag(pos, end, sourceFile)) {
+                                isInParamTag = true;
+                                pos += paramTag.length;
+                                continue;
+                            }
+                            else {
+                                isInParamTag = false;
+                            }
+                        }
+                        // Add the ch to doc text if we arent in param tag
+                        if (!isInParamTag) {
+                            docCommentTextOfLine += ch;
+                        }
+                        // Scan next character
+                        pos++;
+                    }
+                    // Continue with next line
+                    pos = consumeLineBreaks(pos, end, sourceFile);
+                    if (docCommentTextOfLine) {
+                        pushDocCommentLineText(docComments, docCommentTextOfLine, blankLineCount);
+                        blankLineCount = 0;
+                    }
+                    else if (!isInParamTag && docComments.length) {
+                        // This is blank line when there is text already parsed
+                        blankLineCount++;
+                    }
+                }
+                return docComments;
+            }
+            function getCleanedParamJsDocComment(pos, end, sourceFile) {
+                var paramHelpStringMargin;
+                var paramDocComments = [];
+                while (pos < end) {
+                    if (isParamTag(pos, end, sourceFile)) {
+                        var blankLineCount = 0;
+                        var recordedParamTag = false;
+                        // Consume leading spaces
+                        pos = consumeWhiteSpaces(pos + paramTag.length);
+                        if (pos >= end) {
+                            break;
+                        }
+                        // Ignore type expression
+                        if (sourceFile.text.charCodeAt(pos) === 123 /* openBrace */) {
+                            pos++;
+                            for (var curlies = 1; pos < end; pos++) {
+                                var charCode = sourceFile.text.charCodeAt(pos);
+                                // { character means we need to find another } to match the found one
+                                if (charCode === 123 /* openBrace */) {
+                                    curlies++;
+                                    continue;
+                                }
+                                // } char
+                                if (charCode === 125 /* closeBrace */) {
+                                    curlies--;
+                                    if (curlies === 0) {
+                                        // We do not have any more } to match the type expression is ignored completely
+                                        pos++;
+                                        break;
+                                    }
+                                    else {
+                                        // there are more { to be matched with }
+                                        continue;
+                                    }
+                                }
+                                // Found start of another tag
+                                if (charCode === 64 /* at */) {
+                                    break;
+                                }
+                            }
+                            // Consume white spaces
+                            pos = consumeWhiteSpaces(pos);
+                            if (pos >= end) {
+                                break;
+                            }
+                        }
+                        // Parameter name
+                        if (isName(pos, end, sourceFile, name)) {
+                            // Found the parameter we are looking for consume white spaces
+                            pos = consumeWhiteSpaces(pos + name.length);
+                            if (pos >= end) {
+                                break;
+                            }
+                            var paramHelpString = "";
+                            var firstLineParamHelpStringPos = pos;
+                            while (pos < end) {
+                                var ch = sourceFile.text.charCodeAt(pos);
+                                // at line break, set this comment line text and go to next line
+                                if (ts.isLineBreak(ch)) {
+                                    if (paramHelpString) {
+                                        pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);
+                                        paramHelpString = "";
+                                        blankLineCount = 0;
+                                        recordedParamTag = true;
+                                    }
+                                    else if (recordedParamTag) {
+                                        blankLineCount++;
+                                    }
+                                    // Get the pos after cleaning start of the line
+                                    setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos);
+                                    continue;
+                                }
+                                // Done scanning param help string - next tag found
+                                if (ch === 64 /* at */) {
+                                    break;
+                                }
+                                paramHelpString += sourceFile.text.charAt(pos);
+                                // Go to next character
+                                pos++;
+                            }
+                            // If there is param help text, add it top the doc comments
+                            if (paramHelpString) {
+                                pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);
+                            }
+                            paramHelpStringMargin = undefined;
+                        }
+                        // If this is the start of another tag, continue with the loop in search of param tag with symbol name
+                        if (sourceFile.text.charCodeAt(pos) === 64 /* at */) {
+                            continue;
+                        }
+                    }
+                    // Next character
+                    pos++;
+                }
+                return paramDocComments;
+                function consumeWhiteSpaces(pos) {
+                    while (pos < end && ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(pos))) {
+                        pos++;
+                    }
+                    return pos;
+                }
+                function setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos) {
+                    // Get the pos after consuming line breaks
+                    pos = consumeLineBreaks(pos, end, sourceFile);
+                    if (pos >= end) {
+                        return;
+                    }
+                    if (paramHelpStringMargin === undefined) {
+                        paramHelpStringMargin = sourceFile.getLineAndCharacterOfPosition(firstLineParamHelpStringPos).character;
+                    }
+                    // Now consume white spaces max
+                    var startOfLinePos = pos;
+                    pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile, paramHelpStringMargin);
+                    if (pos >= end) {
+                        return;
+                    }
+                    var consumedSpaces = pos - startOfLinePos;
+                    if (consumedSpaces < paramHelpStringMargin) {
+                        var ch = sourceFile.text.charCodeAt(pos);
+                        if (ch === 42 /* asterisk */) {
+                            // Consume more spaces after asterisk
+                            pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, paramHelpStringMargin - consumedSpaces - 1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    var TypeObject = (function () {
+        function TypeObject(checker, flags) {
+            this.checker = checker;
+            this.flags = flags;
+        }
+        TypeObject.prototype.getFlags = function () {
+            return this.flags;
+        };
+        TypeObject.prototype.getSymbol = function () {
+            return this.symbol;
+        };
+        TypeObject.prototype.getProperties = function () {
+            return this.checker.getPropertiesOfType(this);
+        };
+        TypeObject.prototype.getProperty = function (propertyName) {
+            return this.checker.getPropertyOfType(this, propertyName);
+        };
+        TypeObject.prototype.getApparentProperties = function () {
+            return this.checker.getAugmentedPropertiesOfType(this);
+        };
+        TypeObject.prototype.getCallSignatures = function () {
+            return this.checker.getSignaturesOfType(this, 0 /* Call */);
+        };
+        TypeObject.prototype.getConstructSignatures = function () {
+            return this.checker.getSignaturesOfType(this, 1 /* Construct */);
+        };
+        TypeObject.prototype.getStringIndexType = function () {
+            return this.checker.getIndexTypeOfType(this, 0 /* String */);
+        };
+        TypeObject.prototype.getNumberIndexType = function () {
+            return this.checker.getIndexTypeOfType(this, 1 /* Number */);
+        };
+        TypeObject.prototype.getBaseTypes = function () {
+            return this.flags & (1024 /* Class */ | 2048 /* Interface */)
+                ? this.checker.getBaseTypes(this)
+                : undefined;
+        };
+        TypeObject.prototype.getNonNullableType = function () {
+            return this.checker.getNonNullableType(this);
+        };
+        return TypeObject;
+    }());
+    var SignatureObject = (function () {
+        function SignatureObject(checker) {
+            this.checker = checker;
+        }
+        SignatureObject.prototype.getDeclaration = function () {
+            return this.declaration;
+        };
+        SignatureObject.prototype.getTypeParameters = function () {
+            return this.typeParameters;
+        };
+        SignatureObject.prototype.getParameters = function () {
+            return this.parameters;
+        };
+        SignatureObject.prototype.getReturnType = function () {
+            return this.checker.getReturnTypeOfSignature(this);
+        };
+        SignatureObject.prototype.getDocumentationComment = function () {
+            if (this.documentationComment === undefined) {
+                this.documentationComment = this.declaration ? getJsDocCommentsFromDeclarations([this.declaration], 
+                /*name*/ undefined, 
+                /*canUseParsedParamTagComments*/ false) : [];
+            }
+            return this.documentationComment;
+        };
+        return SignatureObject;
+    }());
+    var SourceFileObject = (function (_super) {
+        __extends(SourceFileObject, _super);
+        function SourceFileObject(kind, pos, end) {
+            _super.call(this, kind, pos, end);
+        }
+        SourceFileObject.prototype.update = function (newText, textChangeRange) {
+            return ts.updateSourceFile(this, newText, textChangeRange);
+        };
+        SourceFileObject.prototype.getLineAndCharacterOfPosition = function (position) {
+            return ts.getLineAndCharacterOfPosition(this, position);
+        };
+        SourceFileObject.prototype.getLineStarts = function () {
+            return ts.getLineStarts(this);
+        };
+        SourceFileObject.prototype.getPositionOfLineAndCharacter = function (line, character) {
+            return ts.getPositionOfLineAndCharacter(this, line, character);
+        };
+        SourceFileObject.prototype.getNamedDeclarations = function () {
+            if (!this.namedDeclarations) {
+                this.namedDeclarations = this.computeNamedDeclarations();
+            }
+            return this.namedDeclarations;
+        };
+        SourceFileObject.prototype.computeNamedDeclarations = function () {
+            var result = {};
+            ts.forEachChild(this, visit);
+            return result;
+            function addDeclaration(declaration) {
+                var name = getDeclarationName(declaration);
+                if (name) {
+                    var declarations = getDeclarations(name);
+                    declarations.push(declaration);
+                }
+            }
+            function getDeclarations(name) {
+                return ts.getProperty(result, name) || (result[name] = []);
+            }
+            function getDeclarationName(declaration) {
+                if (declaration.name) {
+                    var result_2 = getTextOfIdentifierOrLiteral(declaration.name);
+                    if (result_2 !== undefined) {
+                        return result_2;
+                    }
+                    if (declaration.name.kind === 140 /* ComputedPropertyName */) {
+                        var expr = declaration.name.expression;
+                        if (expr.kind === 172 /* PropertyAccessExpression */) {
+                            return expr.name.text;
+                        }
+                        return getTextOfIdentifierOrLiteral(expr);
+                    }
+                }
+                return undefined;
+            }
+            function getTextOfIdentifierOrLiteral(node) {
+                if (node) {
+                    if (node.kind === 69 /* Identifier */ ||
+                        node.kind === 9 /* StringLiteral */ ||
+                        node.kind === 8 /* NumericLiteral */) {
+                        return node.text;
+                    }
+                }
+                return undefined;
+            }
+            function visit(node) {
+                switch (node.kind) {
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        var functionDeclaration = node;
+                        var declarationName = getDeclarationName(functionDeclaration);
+                        if (declarationName) {
+                            var declarations = getDeclarations(declarationName);
+                            var lastDeclaration = ts.lastOrUndefined(declarations);
+                            // Check whether this declaration belongs to an "overload group".
+                            if (lastDeclaration && functionDeclaration.parent === lastDeclaration.parent && functionDeclaration.symbol === lastDeclaration.symbol) {
+                                // Overwrite the last declaration if it was an overload
+                                // and this one is an implementation.
+                                if (functionDeclaration.body && !lastDeclaration.body) {
+                                    declarations[declarations.length - 1] = functionDeclaration;
+                                }
+                            }
+                            else {
+                                declarations.push(functionDeclaration);
+                            }
+                            ts.forEachChild(node, visit);
+                        }
+                        break;
+                    case 221 /* ClassDeclaration */:
+                    case 192 /* ClassExpression */:
+                    case 222 /* InterfaceDeclaration */:
+                    case 223 /* TypeAliasDeclaration */:
+                    case 224 /* EnumDeclaration */:
+                    case 225 /* ModuleDeclaration */:
+                    case 229 /* ImportEqualsDeclaration */:
+                    case 238 /* ExportSpecifier */:
+                    case 234 /* ImportSpecifier */:
+                    case 229 /* ImportEqualsDeclaration */:
+                    case 231 /* ImportClause */:
+                    case 232 /* NamespaceImport */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 159 /* TypeLiteral */:
+                        addDeclaration(node);
+                        ts.forEachChild(node, visit);
+                        break;
+                    case 142 /* Parameter */:
+                        // Only consider parameter properties
+                        if (!(node.flags & 92 /* ParameterPropertyModifier */)) {
+                            break;
+                        }
+                    // fall through
+                    case 218 /* VariableDeclaration */:
+                    case 169 /* BindingElement */: {
+                        var decl = node;
+                        if (ts.isBindingPattern(decl.name)) {
+                            ts.forEachChild(decl.name, visit);
+                            break;
+                        }
+                        if (decl.initializer)
+                            visit(decl.initializer);
+                    }
+                    case 255 /* EnumMember */:
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                        addDeclaration(node);
+                        break;
+                    case 236 /* ExportDeclaration */:
+                        // Handle named exports case e.g.:
+                        //    export {a, b as B} from "mod";
+                        if (node.exportClause) {
+                            ts.forEach(node.exportClause.elements, visit);
+                        }
+                        break;
+                    case 230 /* ImportDeclaration */:
+                        var importClause = node.importClause;
+                        if (importClause) {
+                            // Handle default import case e.g.:
+                            //    import d from "mod";
+                            if (importClause.name) {
+                                addDeclaration(importClause);
+                            }
+                            // Handle named bindings in imports e.g.:
+                            //    import * as NS from "mod";
+                            //    import {a, b as B} from "mod";
+                            if (importClause.namedBindings) {
+                                if (importClause.namedBindings.kind === 232 /* NamespaceImport */) {
+                                    addDeclaration(importClause.namedBindings);
+                                }
+                                else {
+                                    ts.forEach(importClause.namedBindings.elements, visit);
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        ts.forEachChild(node, visit);
+                }
+            }
+        };
+        return SourceFileObject;
+    }(NodeObject));
+    var TextChange = (function () {
+        function TextChange() {
+        }
+        return TextChange;
+    }());
+    ts.TextChange = TextChange;
+    var HighlightSpanKind;
+    (function (HighlightSpanKind) {
+        HighlightSpanKind.none = "none";
+        HighlightSpanKind.definition = "definition";
+        HighlightSpanKind.reference = "reference";
+        HighlightSpanKind.writtenReference = "writtenReference";
+    })(HighlightSpanKind = ts.HighlightSpanKind || (ts.HighlightSpanKind = {}));
+    (function (IndentStyle) {
+        IndentStyle[IndentStyle["None"] = 0] = "None";
+        IndentStyle[IndentStyle["Block"] = 1] = "Block";
+        IndentStyle[IndentStyle["Smart"] = 2] = "Smart";
+    })(ts.IndentStyle || (ts.IndentStyle = {}));
+    var IndentStyle = ts.IndentStyle;
+    (function (SymbolDisplayPartKind) {
+        SymbolDisplayPartKind[SymbolDisplayPartKind["aliasName"] = 0] = "aliasName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["className"] = 1] = "className";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["enumName"] = 2] = "enumName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["fieldName"] = 3] = "fieldName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["interfaceName"] = 4] = "interfaceName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["keyword"] = 5] = "keyword";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["lineBreak"] = 6] = "lineBreak";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["numericLiteral"] = 7] = "numericLiteral";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["stringLiteral"] = 8] = "stringLiteral";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["localName"] = 9] = "localName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["methodName"] = 10] = "methodName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["moduleName"] = 11] = "moduleName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["operator"] = 12] = "operator";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["parameterName"] = 13] = "parameterName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["propertyName"] = 14] = "propertyName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["punctuation"] = 15] = "punctuation";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["space"] = 16] = "space";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["text"] = 17] = "text";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["typeParameterName"] = 18] = "typeParameterName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["enumMemberName"] = 19] = "enumMemberName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["functionName"] = 20] = "functionName";
+        SymbolDisplayPartKind[SymbolDisplayPartKind["regularExpressionLiteral"] = 21] = "regularExpressionLiteral";
+    })(ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {}));
+    var SymbolDisplayPartKind = ts.SymbolDisplayPartKind;
+    (function (OutputFileType) {
+        OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript";
+        OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap";
+        OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration";
+    })(ts.OutputFileType || (ts.OutputFileType = {}));
+    var OutputFileType = ts.OutputFileType;
+    (function (EndOfLineState) {
+        EndOfLineState[EndOfLineState["None"] = 0] = "None";
+        EndOfLineState[EndOfLineState["InMultiLineCommentTrivia"] = 1] = "InMultiLineCommentTrivia";
+        EndOfLineState[EndOfLineState["InSingleQuoteStringLiteral"] = 2] = "InSingleQuoteStringLiteral";
+        EndOfLineState[EndOfLineState["InDoubleQuoteStringLiteral"] = 3] = "InDoubleQuoteStringLiteral";
+        EndOfLineState[EndOfLineState["InTemplateHeadOrNoSubstitutionTemplate"] = 4] = "InTemplateHeadOrNoSubstitutionTemplate";
+        EndOfLineState[EndOfLineState["InTemplateMiddleOrTail"] = 5] = "InTemplateMiddleOrTail";
+        EndOfLineState[EndOfLineState["InTemplateSubstitutionPosition"] = 6] = "InTemplateSubstitutionPosition";
+    })(ts.EndOfLineState || (ts.EndOfLineState = {}));
+    var EndOfLineState = ts.EndOfLineState;
+    (function (TokenClass) {
+        TokenClass[TokenClass["Punctuation"] = 0] = "Punctuation";
+        TokenClass[TokenClass["Keyword"] = 1] = "Keyword";
+        TokenClass[TokenClass["Operator"] = 2] = "Operator";
+        TokenClass[TokenClass["Comment"] = 3] = "Comment";
+        TokenClass[TokenClass["Whitespace"] = 4] = "Whitespace";
+        TokenClass[TokenClass["Identifier"] = 5] = "Identifier";
+        TokenClass[TokenClass["NumberLiteral"] = 6] = "NumberLiteral";
+        TokenClass[TokenClass["StringLiteral"] = 7] = "StringLiteral";
+        TokenClass[TokenClass["RegExpLiteral"] = 8] = "RegExpLiteral";
+    })(ts.TokenClass || (ts.TokenClass = {}));
+    var TokenClass = ts.TokenClass;
+    // TODO: move these to enums
+    var ScriptElementKind;
+    (function (ScriptElementKind) {
+        ScriptElementKind.unknown = "";
+        ScriptElementKind.warning = "warning";
+        /** predefined type (void) or keyword (class) */
+        ScriptElementKind.keyword = "keyword";
+        /** top level script node */
+        ScriptElementKind.scriptElement = "script";
+        /** module foo {} */
+        ScriptElementKind.moduleElement = "module";
+        /** class X {} */
+        ScriptElementKind.classElement = "class";
+        /** var x = class X {} */
+        ScriptElementKind.localClassElement = "local class";
+        /** interface Y {} */
+        ScriptElementKind.interfaceElement = "interface";
+        /** type T = ... */
+        ScriptElementKind.typeElement = "type";
+        /** enum E */
+        ScriptElementKind.enumElement = "enum";
+        /**
+         * Inside module and script only
+         * const v = ..
+         */
+        ScriptElementKind.variableElement = "var";
+        /** Inside function */
+        ScriptElementKind.localVariableElement = "local var";
+        /**
+         * Inside module and script only
+         * function f() { }
+         */
+        ScriptElementKind.functionElement = "function";
+        /** Inside function */
+        ScriptElementKind.localFunctionElement = "local function";
+        /** class X { [public|private]* foo() {} } */
+        ScriptElementKind.memberFunctionElement = "method";
+        /** class X { [public|private]* [get|set] foo:number; } */
+        ScriptElementKind.memberGetAccessorElement = "getter";
+        ScriptElementKind.memberSetAccessorElement = "setter";
+        /**
+         * class X { [public|private]* foo:number; }
+         * interface Y { foo:number; }
+         */
+        ScriptElementKind.memberVariableElement = "property";
+        /** class X { constructor() { } } */
+        ScriptElementKind.constructorImplementationElement = "constructor";
+        /** interface Y { ():number; } */
+        ScriptElementKind.callSignatureElement = "call";
+        /** interface Y { []:number; } */
+        ScriptElementKind.indexSignatureElement = "index";
+        /** interface Y { new():Y; } */
+        ScriptElementKind.constructSignatureElement = "construct";
+        /** function foo(*Y*: string) */
+        ScriptElementKind.parameterElement = "parameter";
+        ScriptElementKind.typeParameterElement = "type parameter";
+        ScriptElementKind.primitiveType = "primitive type";
+        ScriptElementKind.label = "label";
+        ScriptElementKind.alias = "alias";
+        ScriptElementKind.constElement = "const";
+        ScriptElementKind.letElement = "let";
+    })(ScriptElementKind = ts.ScriptElementKind || (ts.ScriptElementKind = {}));
+    var ScriptElementKindModifier;
+    (function (ScriptElementKindModifier) {
+        ScriptElementKindModifier.none = "";
+        ScriptElementKindModifier.publicMemberModifier = "public";
+        ScriptElementKindModifier.privateMemberModifier = "private";
+        ScriptElementKindModifier.protectedMemberModifier = "protected";
+        ScriptElementKindModifier.exportedModifier = "export";
+        ScriptElementKindModifier.ambientModifier = "declare";
+        ScriptElementKindModifier.staticModifier = "static";
+        ScriptElementKindModifier.abstractModifier = "abstract";
+    })(ScriptElementKindModifier = ts.ScriptElementKindModifier || (ts.ScriptElementKindModifier = {}));
+    var ClassificationTypeNames = (function () {
+        function ClassificationTypeNames() {
+        }
+        ClassificationTypeNames.comment = "comment";
+        ClassificationTypeNames.identifier = "identifier";
+        ClassificationTypeNames.keyword = "keyword";
+        ClassificationTypeNames.numericLiteral = "number";
+        ClassificationTypeNames.operator = "operator";
+        ClassificationTypeNames.stringLiteral = "string";
+        ClassificationTypeNames.whiteSpace = "whitespace";
+        ClassificationTypeNames.text = "text";
+        ClassificationTypeNames.punctuation = "punctuation";
+        ClassificationTypeNames.className = "class name";
+        ClassificationTypeNames.enumName = "enum name";
+        ClassificationTypeNames.interfaceName = "interface name";
+        ClassificationTypeNames.moduleName = "module name";
+        ClassificationTypeNames.typeParameterName = "type parameter name";
+        ClassificationTypeNames.typeAliasName = "type alias name";
+        ClassificationTypeNames.parameterName = "parameter name";
+        ClassificationTypeNames.docCommentTagName = "doc comment tag name";
+        ClassificationTypeNames.jsxOpenTagName = "jsx open tag name";
+        ClassificationTypeNames.jsxCloseTagName = "jsx close tag name";
+        ClassificationTypeNames.jsxSelfClosingTagName = "jsx self closing tag name";
+        ClassificationTypeNames.jsxAttribute = "jsx attribute";
+        ClassificationTypeNames.jsxText = "jsx text";
+        ClassificationTypeNames.jsxAttributeStringLiteralValue = "jsx attribute string literal value";
+        return ClassificationTypeNames;
+    }());
+    ts.ClassificationTypeNames = ClassificationTypeNames;
+    (function (ClassificationType) {
+        ClassificationType[ClassificationType["comment"] = 1] = "comment";
+        ClassificationType[ClassificationType["identifier"] = 2] = "identifier";
+        ClassificationType[ClassificationType["keyword"] = 3] = "keyword";
+        ClassificationType[ClassificationType["numericLiteral"] = 4] = "numericLiteral";
+        ClassificationType[ClassificationType["operator"] = 5] = "operator";
+        ClassificationType[ClassificationType["stringLiteral"] = 6] = "stringLiteral";
+        ClassificationType[ClassificationType["regularExpressionLiteral"] = 7] = "regularExpressionLiteral";
+        ClassificationType[ClassificationType["whiteSpace"] = 8] = "whiteSpace";
+        ClassificationType[ClassificationType["text"] = 9] = "text";
+        ClassificationType[ClassificationType["punctuation"] = 10] = "punctuation";
+        ClassificationType[ClassificationType["className"] = 11] = "className";
+        ClassificationType[ClassificationType["enumName"] = 12] = "enumName";
+        ClassificationType[ClassificationType["interfaceName"] = 13] = "interfaceName";
+        ClassificationType[ClassificationType["moduleName"] = 14] = "moduleName";
+        ClassificationType[ClassificationType["typeParameterName"] = 15] = "typeParameterName";
+        ClassificationType[ClassificationType["typeAliasName"] = 16] = "typeAliasName";
+        ClassificationType[ClassificationType["parameterName"] = 17] = "parameterName";
+        ClassificationType[ClassificationType["docCommentTagName"] = 18] = "docCommentTagName";
+        ClassificationType[ClassificationType["jsxOpenTagName"] = 19] = "jsxOpenTagName";
+        ClassificationType[ClassificationType["jsxCloseTagName"] = 20] = "jsxCloseTagName";
+        ClassificationType[ClassificationType["jsxSelfClosingTagName"] = 21] = "jsxSelfClosingTagName";
+        ClassificationType[ClassificationType["jsxAttribute"] = 22] = "jsxAttribute";
+        ClassificationType[ClassificationType["jsxText"] = 23] = "jsxText";
+        ClassificationType[ClassificationType["jsxAttributeStringLiteralValue"] = 24] = "jsxAttributeStringLiteralValue";
+    })(ts.ClassificationType || (ts.ClassificationType = {}));
+    var ClassificationType = ts.ClassificationType;
+    function displayPartsToString(displayParts) {
+        if (displayParts) {
+            return ts.map(displayParts, function (displayPart) { return displayPart.text; }).join("");
+        }
+        return "";
+    }
+    ts.displayPartsToString = displayPartsToString;
+    function isLocalVariableOrFunction(symbol) {
+        if (symbol.parent) {
+            return false; // This is exported symbol
+        }
+        return ts.forEach(symbol.declarations, function (declaration) {
+            // Function expressions are local
+            if (declaration.kind === 179 /* FunctionExpression */) {
+                return true;
+            }
+            if (declaration.kind !== 218 /* VariableDeclaration */ && declaration.kind !== 220 /* FunctionDeclaration */) {
+                return false;
+            }
+            // If the parent is not sourceFile or module block it is local variable
+            for (var parent_16 = declaration.parent; !ts.isFunctionBlock(parent_16); parent_16 = parent_16.parent) {
+                // Reached source file or module block
+                if (parent_16.kind === 256 /* SourceFile */ || parent_16.kind === 226 /* ModuleBlock */) {
+                    return false;
+                }
+            }
+            // parent is in function block
+            return true;
+        });
+    }
+    function getDefaultCompilerOptions() {
+        // Always default to "ScriptTarget.ES5" for the language service
+        return {
+            target: 1 /* ES5 */,
+            jsx: 1 /* Preserve */
+        };
+    }
+    ts.getDefaultCompilerOptions = getDefaultCompilerOptions;
+    // Cache host information about scrip Should be refreshed
+    // at each language service public entry point, since we don't know when
+    // set of scripts handled by the host changes.
+    var HostCache = (function () {
+        function HostCache(host, getCanonicalFileName) {
+            this.host = host;
+            this.getCanonicalFileName = getCanonicalFileName;
+            // script id => script index
+            this.currentDirectory = host.getCurrentDirectory();
+            this.fileNameToEntry = ts.createFileMap();
+            // Initialize the list with the root file names
+            var rootFileNames = host.getScriptFileNames();
+            for (var _i = 0, rootFileNames_1 = rootFileNames; _i < rootFileNames_1.length; _i++) {
+                var fileName = rootFileNames_1[_i];
+                this.createEntry(fileName, ts.toPath(fileName, this.currentDirectory, getCanonicalFileName));
+            }
+            // store the compilation settings
+            this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
+        }
+        HostCache.prototype.compilationSettings = function () {
+            return this._compilationSettings;
+        };
+        HostCache.prototype.createEntry = function (fileName, path) {
+            var entry;
+            var scriptSnapshot = this.host.getScriptSnapshot(fileName);
+            if (scriptSnapshot) {
+                entry = {
+                    hostFileName: fileName,
+                    version: this.host.getScriptVersion(fileName),
+                    scriptSnapshot: scriptSnapshot,
+                    scriptKind: ts.getScriptKind(fileName, this.host)
+                };
+            }
+            this.fileNameToEntry.set(path, entry);
+            return entry;
+        };
+        HostCache.prototype.getEntry = function (path) {
+            return this.fileNameToEntry.get(path);
+        };
+        HostCache.prototype.contains = function (path) {
+            return this.fileNameToEntry.contains(path);
+        };
+        HostCache.prototype.getOrCreateEntry = function (fileName) {
+            var path = ts.toPath(fileName, this.currentDirectory, this.getCanonicalFileName);
+            return this.getOrCreateEntryByPath(fileName, path);
+        };
+        HostCache.prototype.getOrCreateEntryByPath = function (fileName, path) {
+            return this.contains(path)
+                ? this.getEntry(path)
+                : this.createEntry(fileName, path);
+        };
+        HostCache.prototype.getRootFileNames = function () {
+            var fileNames = [];
+            this.fileNameToEntry.forEachValue(function (path, value) {
+                if (value) {
+                    fileNames.push(value.hostFileName);
+                }
+            });
+            return fileNames;
+        };
+        HostCache.prototype.getVersion = function (path) {
+            var file = this.getEntry(path);
+            return file && file.version;
+        };
+        HostCache.prototype.getScriptSnapshot = function (path) {
+            var file = this.getEntry(path);
+            return file && file.scriptSnapshot;
+        };
+        return HostCache;
+    }());
+    var SyntaxTreeCache = (function () {
+        function SyntaxTreeCache(host) {
+            this.host = host;
+        }
+        SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) {
+            var scriptSnapshot = this.host.getScriptSnapshot(fileName);
+            if (!scriptSnapshot) {
+                // The host does not know about this file.
+                throw new Error("Could not find file: '" + fileName + "'.");
+            }
+            var scriptKind = ts.getScriptKind(fileName, this.host);
+            var version = this.host.getScriptVersion(fileName);
+            var sourceFile;
+            if (this.currentFileName !== fileName) {
+                // This is a new file, just parse it
+                sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2 /* Latest */, version, /*setNodeParents*/ true, scriptKind);
+            }
+            else if (this.currentFileVersion !== version) {
+                // This is the same file, just a newer version. Incrementally parse the file.
+                var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot);
+                sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange);
+            }
+            if (sourceFile) {
+                // All done, ensure state is up to date
+                this.currentFileVersion = version;
+                this.currentFileName = fileName;
+                this.currentFileScriptSnapshot = scriptSnapshot;
+                this.currentSourceFile = sourceFile;
+            }
+            return this.currentSourceFile;
+        };
+        return SyntaxTreeCache;
+    }());
+    function setSourceFileFields(sourceFile, scriptSnapshot, version) {
+        sourceFile.version = version;
+        sourceFile.scriptSnapshot = scriptSnapshot;
+    }
+    var commandLineOptionsStringToEnum;
+    /** JS users may pass in string values for enum compiler options (such as ModuleKind), so convert. */
+    function fixupCompilerOptions(options, diagnostics) {
+        // Lazily create this value to fix module loading errors.
+        commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || ts.filter(ts.optionDeclarations, function (o) {
+            return typeof o.type === "object" && !ts.forEachValue(o.type, function (v) { return typeof v !== "number"; });
+        });
+        options = ts.clone(options);
+        var _loop_3 = function(opt) {
+            if (!ts.hasProperty(options, opt.name)) {
+                return "continue";
+            }
+            var value = options[opt.name];
+            // Value should be a key of opt.type
+            if (typeof value === "string") {
+                // If value is not a string, this will fail
+                options[opt.name] = ts.parseCustomTypeOption(opt, value, diagnostics);
+            }
+            else {
+                if (!ts.forEachValue(opt.type, function (v) { return v === value; })) {
+                    // Supplied value isn't a valid enum value.
+                    diagnostics.push(ts.createCompilerDiagnosticForInvalidCustomType(opt));
+                }
+            }
+        };
+        for (var _i = 0, commandLineOptionsStringToEnum_1 = commandLineOptionsStringToEnum; _i < commandLineOptionsStringToEnum_1.length; _i++) {
+            var opt = commandLineOptionsStringToEnum_1[_i];
+            _loop_3(opt);
+        }
+        return options;
+    }
+    /*
+     * This function will compile source text from 'input' argument using specified compiler options.
+     * If not options are provided - it will use a set of default compiler options.
+     * Extra compiler options that will unconditionally be used by this function are:
+     * - isolatedModules = true
+     * - allowNonTsExtensions = true
+     * - noLib = true
+     * - noResolve = true
+     */
+    function transpileModule(input, transpileOptions) {
+        var diagnostics = [];
+        var options = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : getDefaultCompilerOptions();
+        options.isolatedModules = true;
+        // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
+        options.suppressOutputPathCheck = true;
+        // Filename can be non-ts file.
+        options.allowNonTsExtensions = true;
+        // We are not returning a sourceFile for lib file when asked by the program,
+        // so pass --noLib to avoid reporting a file not found error.
+        options.noLib = true;
+        // Clear out other settings that would not be used in transpiling this module
+        options.lib = undefined;
+        options.types = undefined;
+        options.noEmit = undefined;
+        options.noEmitOnError = undefined;
+        options.paths = undefined;
+        options.rootDirs = undefined;
+        options.declaration = undefined;
+        options.declarationDir = undefined;
+        options.out = undefined;
+        options.outFile = undefined;
+        // We are not doing a full typecheck, we are not resolving the whole context,
+        // so pass --noResolve to avoid reporting missing file errors.
+        options.noResolve = true;
+        // if jsx is specified then treat file as .tsx
+        var inputFileName = transpileOptions.fileName || (options.jsx ? "module.tsx" : "module.ts");
+        var sourceFile = ts.createSourceFile(inputFileName, input, options.target);
+        if (transpileOptions.moduleName) {
+            sourceFile.moduleName = transpileOptions.moduleName;
+        }
+        sourceFile.renamedDependencies = transpileOptions.renamedDependencies;
+        var newLine = ts.getNewLineCharacter(options);
+        // Output
+        var outputText;
+        var sourceMapText;
+        // Create a compilerHost object to allow the compiler to read and write files
+        var compilerHost = {
+            getSourceFile: function (fileName, target) { return fileName === ts.normalizePath(inputFileName) ? sourceFile : undefined; },
+            writeFile: function (name, text, writeByteOrderMark) {
+                if (ts.fileExtensionIs(name, ".map")) {
+                    ts.Debug.assert(sourceMapText === undefined, "Unexpected multiple source map outputs for the file '" + name + "'");
+                    sourceMapText = text;
+                }
+                else {
+                    ts.Debug.assert(outputText === undefined, "Unexpected multiple outputs for the file: '" + name + "'");
+                    outputText = text;
+                }
+            },
+            getDefaultLibFileName: function () { return "lib.d.ts"; },
+            useCaseSensitiveFileNames: function () { return false; },
+            getCanonicalFileName: function (fileName) { return fileName; },
+            getCurrentDirectory: function () { return ""; },
+            getNewLine: function () { return newLine; },
+            fileExists: function (fileName) { return fileName === inputFileName; },
+            readFile: function (fileName) { return ""; },
+            directoryExists: function (directoryExists) { return true; },
+            getDirectories: function (path) { return []; }
+        };
+        var program = ts.createProgram([inputFileName], options, compilerHost);
+        if (transpileOptions.reportDiagnostics) {
+            ts.addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile));
+            ts.addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics());
+        }
+        // Emit
+        program.emit();
+        ts.Debug.assert(outputText !== undefined, "Output generation failed");
+        return { outputText: outputText, diagnostics: diagnostics, sourceMapText: sourceMapText };
+    }
+    ts.transpileModule = transpileModule;
+    /*
+     * This is a shortcut function for transpileModule - it accepts transpileOptions as parameters and returns only outputText part of the result.
+     */
+    function transpile(input, compilerOptions, fileName, diagnostics, moduleName) {
+        var output = transpileModule(input, { compilerOptions: compilerOptions, fileName: fileName, reportDiagnostics: !!diagnostics, moduleName: moduleName });
+        // addRange correctly handles cases when wither 'from' or 'to' argument is missing
+        ts.addRange(diagnostics, output.diagnostics);
+        return output.outputText;
+    }
+    ts.transpile = transpile;
+    function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, setNodeParents, scriptKind) {
+        var text = scriptSnapshot.getText(0, scriptSnapshot.getLength());
+        var sourceFile = ts.createSourceFile(fileName, text, scriptTarget, setNodeParents, scriptKind);
+        setSourceFileFields(sourceFile, scriptSnapshot, version);
+        return sourceFile;
+    }
+    ts.createLanguageServiceSourceFile = createLanguageServiceSourceFile;
+    ts.disableIncrementalParsing = false;
+    function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks) {
+        // If we were given a text change range, and our version or open-ness changed, then
+        // incrementally parse this file.
+        if (textChangeRange) {
+            if (version !== sourceFile.version) {
+                // Once incremental parsing is ready, then just call into this function.
+                if (!ts.disableIncrementalParsing) {
+                    var newText = void 0;
+                    // grab the fragment from the beginning of the original text to the beginning of the span
+                    var prefix = textChangeRange.span.start !== 0
+                        ? sourceFile.text.substr(0, textChangeRange.span.start)
+                        : "";
+                    // grab the fragment from the end of the span till the end of the original text
+                    var suffix = ts.textSpanEnd(textChangeRange.span) !== sourceFile.text.length
+                        ? sourceFile.text.substr(ts.textSpanEnd(textChangeRange.span))
+                        : "";
+                    if (textChangeRange.newLength === 0) {
+                        // edit was a deletion - just combine prefix and suffix
+                        newText = prefix && suffix ? prefix + suffix : prefix || suffix;
+                    }
+                    else {
+                        // it was actual edit, fetch the fragment of new text that correspond to new span
+                        var changedText = scriptSnapshot.getText(textChangeRange.span.start, textChangeRange.span.start + textChangeRange.newLength);
+                        // combine prefix, changed text and suffix
+                        newText = prefix && suffix
+                            ? prefix + changedText + suffix
+                            : prefix
+                                ? (prefix + changedText)
+                                : (changedText + suffix);
+                    }
+                    var newSourceFile = ts.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
+                    setSourceFileFields(newSourceFile, scriptSnapshot, version);
+                    // after incremental parsing nameTable might not be up-to-date
+                    // drop it so it can be lazily recreated later
+                    newSourceFile.nameTable = undefined;
+                    // dispose all resources held by old script snapshot
+                    if (sourceFile !== newSourceFile && sourceFile.scriptSnapshot) {
+                        if (sourceFile.scriptSnapshot.dispose) {
+                            sourceFile.scriptSnapshot.dispose();
+                        }
+                        sourceFile.scriptSnapshot = undefined;
+                    }
+                    return newSourceFile;
+                }
+            }
+        }
+        // Otherwise, just create a new source file.
+        return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents*/ true, sourceFile.scriptKind);
+    }
+    ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile;
+    function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
+        // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
+        // for those settings.
+        var buckets = {};
+        var getCanonicalFileName = ts.createGetCanonicalFileName(!!useCaseSensitiveFileNames);
+        function getKeyForCompilationSettings(settings) {
+            return ("_" + settings.target + "|" + settings.module + "|" + settings.noResolve + "|" + settings.jsx + "|" + settings.allowJs + "|" + settings.baseUrl + "|" + JSON.stringify(settings.typeRoots) + "|" + JSON.stringify(settings.rootDirs) + "|" + JSON.stringify(settings.paths));
+        }
+        function getBucketForCompilationSettings(key, createIfMissing) {
+            var bucket = ts.lookUp(buckets, key);
+            if (!bucket && createIfMissing) {
+                buckets[key] = bucket = ts.createFileMap();
+            }
+            return bucket;
+        }
+        function reportStats() {
+            var bucketInfoArray = Object.keys(buckets).filter(function (name) { return name && name.charAt(0) === "_"; }).map(function (name) {
+                var entries = ts.lookUp(buckets, name);
+                var sourceFiles = [];
+                entries.forEachValue(function (key, entry) {
+                    sourceFiles.push({
+                        name: key,
+                        refCount: entry.languageServiceRefCount,
+                        references: entry.owners.slice(0)
+                    });
+                });
+                sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; });
+                return {
+                    bucket: name,
+                    sourceFiles: sourceFiles
+                };
+            });
+            return JSON.stringify(bucketInfoArray, undefined, 2);
+        }
+        function acquireDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var key = getKeyForCompilationSettings(compilationSettings);
+            return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+        function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind);
+        }
+        function updateDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var key = getKeyForCompilationSettings(compilationSettings);
+            return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+        function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+        }
+        function acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, acquiring, scriptKind) {
+            var bucket = getBucketForCompilationSettings(key, /*createIfMissing*/ true);
+            var entry = bucket.get(path);
+            if (!entry) {
+                ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
+                // Have never seen this file with these settings.  Create a new source file for it.
+                var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, /*setNodeParents*/ false, scriptKind);
+                entry = {
+                    sourceFile: sourceFile,
+                    languageServiceRefCount: 0,
+                    owners: []
+                };
+                bucket.set(path, entry);
+            }
+            else {
+                // We have an entry for this file.  However, it may be for a different version of
+                // the script snapshot.  If so, update it appropriately.  Otherwise, we can just
+                // return it as is.
+                if (entry.sourceFile.version !== version) {
+                    entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
+                }
+            }
+            // If we're acquiring, then this is the first time this LS is asking for this document.
+            // Increase our ref count so we know there's another LS using the document.  If we're
+            // not acquiring, then that means the LS is 'updating' the file instead, and that means
+            // it has already acquired the document previously.  As such, we do not need to increase
+            // the ref count.
+            if (acquiring) {
+                entry.languageServiceRefCount++;
+            }
+            return entry.sourceFile;
+        }
+        function releaseDocument(fileName, compilationSettings) {
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var key = getKeyForCompilationSettings(compilationSettings);
+            return releaseDocumentWithKey(path, key);
+        }
+        function releaseDocumentWithKey(path, key) {
+            var bucket = getBucketForCompilationSettings(key, /*createIfMissing*/ false);
+            ts.Debug.assert(bucket !== undefined);
+            var entry = bucket.get(path);
+            entry.languageServiceRefCount--;
+            ts.Debug.assert(entry.languageServiceRefCount >= 0);
+            if (entry.languageServiceRefCount === 0) {
+                bucket.remove(path);
+            }
+        }
+        return {
+            acquireDocument: acquireDocument,
+            acquireDocumentWithKey: acquireDocumentWithKey,
+            updateDocument: updateDocument,
+            updateDocumentWithKey: updateDocumentWithKey,
+            releaseDocument: releaseDocument,
+            releaseDocumentWithKey: releaseDocumentWithKey,
+            reportStats: reportStats,
+            getKeyForCompilationSettings: getKeyForCompilationSettings
+        };
+    }
+    ts.createDocumentRegistry = createDocumentRegistry;
+    function preProcessFile(sourceText, readImportFiles, detectJavaScriptImports) {
+        if (readImportFiles === void 0) { readImportFiles = true; }
+        if (detectJavaScriptImports === void 0) { detectJavaScriptImports = false; }
+        var referencedFiles = [];
+        var typeReferenceDirectives = [];
+        var importedFiles = [];
+        var ambientExternalModules;
+        var isNoDefaultLib = false;
+        var braceNesting = 0;
+        // assume that text represent an external module if it contains at least one top level import/export
+        // ambient modules that are found inside external modules are interpreted as module augmentations
+        var externalModule = false;
+        function nextToken() {
+            var token = scanner.scan();
+            if (token === 15 /* OpenBraceToken */) {
+                braceNesting++;
+            }
+            else if (token === 16 /* CloseBraceToken */) {
+                braceNesting--;
+            }
+            return token;
+        }
+        function processTripleSlashDirectives() {
+            var commentRanges = ts.getLeadingCommentRanges(sourceText, 0);
+            ts.forEach(commentRanges, function (commentRange) {
+                var comment = sourceText.substring(commentRange.pos, commentRange.end);
+                var referencePathMatchResult = ts.getFileReferenceFromReferencePath(comment, commentRange);
+                if (referencePathMatchResult) {
+                    isNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
+                    var fileReference = referencePathMatchResult.fileReference;
+                    if (fileReference) {
+                        var collection = referencePathMatchResult.isTypeReferenceDirective
+                            ? typeReferenceDirectives
+                            : referencedFiles;
+                        collection.push(fileReference);
+                    }
+                }
+            });
+        }
+        function getFileReference() {
+            var file = scanner.getTokenValue();
+            var pos = scanner.getTokenPos();
+            return {
+                fileName: file,
+                pos: pos,
+                end: pos + file.length
+            };
+        }
+        function recordAmbientExternalModule() {
+            if (!ambientExternalModules) {
+                ambientExternalModules = [];
+            }
+            ambientExternalModules.push({ ref: getFileReference(), depth: braceNesting });
+        }
+        function recordModuleName() {
+            importedFiles.push(getFileReference());
+            markAsExternalModuleIfTopLevel();
+        }
+        function markAsExternalModuleIfTopLevel() {
+            if (braceNesting === 0) {
+                externalModule = true;
+            }
+        }
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeDeclare() {
+            var token = scanner.getToken();
+            if (token === 122 /* DeclareKeyword */) {
+                // declare module "mod"
+                token = nextToken();
+                if (token === 125 /* ModuleKeyword */) {
+                    token = nextToken();
+                    if (token === 9 /* StringLiteral */) {
+                        recordAmbientExternalModule();
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeImport() {
+            var token = scanner.getToken();
+            if (token === 89 /* ImportKeyword */) {
+                token = nextToken();
+                if (token === 9 /* StringLiteral */) {
+                    // import "mod";
+                    recordModuleName();
+                    return true;
+                }
+                else {
+                    if (token === 69 /* Identifier */ || ts.isKeyword(token)) {
+                        token = nextToken();
+                        if (token === 136 /* FromKeyword */) {
+                            token = nextToken();
+                            if (token === 9 /* StringLiteral */) {
+                                // import d from "mod";
+                                recordModuleName();
+                                return true;
+                            }
+                        }
+                        else if (token === 56 /* EqualsToken */) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                        else if (token === 24 /* CommaToken */) {
+                            // consume comma and keep going
+                            token = nextToken();
+                        }
+                        else {
+                            // unknown syntax
+                            return true;
+                        }
+                    }
+                    if (token === 15 /* OpenBraceToken */) {
+                        token = nextToken();
+                        // consume "{ a as B, c, d as D}" clauses
+                        // make sure that it stops on EOF
+                        while (token !== 16 /* CloseBraceToken */ && token !== 1 /* EndOfFileToken */) {
+                            token = nextToken();
+                        }
+                        if (token === 16 /* CloseBraceToken */) {
+                            token = nextToken();
+                            if (token === 136 /* FromKeyword */) {
+                                token = nextToken();
+                                if (token === 9 /* StringLiteral */) {
+                                    // import {a as A} from "mod";
+                                    // import d, {a, b as B} from "mod"
+                                    recordModuleName();
+                                }
+                            }
+                        }
+                    }
+                    else if (token === 37 /* AsteriskToken */) {
+                        token = nextToken();
+                        if (token === 116 /* AsKeyword */) {
+                            token = nextToken();
+                            if (token === 69 /* Identifier */ || ts.isKeyword(token)) {
+                                token = nextToken();
+                                if (token === 136 /* FromKeyword */) {
+                                    token = nextToken();
+                                    if (token === 9 /* StringLiteral */) {
+                                        // import * as NS from "mod"
+                                        // import d, * as NS from "mod"
+                                        recordModuleName();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function tryConsumeExport() {
+            var token = scanner.getToken();
+            if (token === 82 /* ExportKeyword */) {
+                markAsExternalModuleIfTopLevel();
+                token = nextToken();
+                if (token === 15 /* OpenBraceToken */) {
+                    token = nextToken();
+                    // consume "{ a as B, c, d as D}" clauses
+                    // make sure it stops on EOF
+                    while (token !== 16 /* CloseBraceToken */ && token !== 1 /* EndOfFileToken */) {
+                        token = nextToken();
+                    }
+                    if (token === 16 /* CloseBraceToken */) {
+                        token = nextToken();
+                        if (token === 136 /* FromKeyword */) {
+                            token = nextToken();
+                            if (token === 9 /* StringLiteral */) {
+                                // export {a as A} from "mod";
+                                // export {a, b as B} from "mod"
+                                recordModuleName();
+                            }
+                        }
+                    }
+                }
+                else if (token === 37 /* AsteriskToken */) {
+                    token = nextToken();
+                    if (token === 136 /* FromKeyword */) {
+                        token = nextToken();
+                        if (token === 9 /* StringLiteral */) {
+                            // export * from "mod"
+                            recordModuleName();
+                        }
+                    }
+                }
+                else if (token === 89 /* ImportKeyword */) {
+                    token = nextToken();
+                    if (token === 69 /* Identifier */ || ts.isKeyword(token)) {
+                        token = nextToken();
+                        if (token === 56 /* EqualsToken */) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function tryConsumeRequireCall(skipCurrentToken) {
+            var token = skipCurrentToken ? nextToken() : scanner.getToken();
+            if (token === 129 /* RequireKeyword */) {
+                token = nextToken();
+                if (token === 17 /* OpenParenToken */) {
+                    token = nextToken();
+                    if (token === 9 /* StringLiteral */) {
+                        //  require("mod");
+                        recordModuleName();
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function tryConsumeDefine() {
+            var token = scanner.getToken();
+            if (token === 69 /* Identifier */ && scanner.getTokenValue() === "define") {
+                token = nextToken();
+                if (token !== 17 /* OpenParenToken */) {
+                    return true;
+                }
+                token = nextToken();
+                if (token === 9 /* StringLiteral */) {
+                    // looks like define ("modname", ... - skip string literal and comma
+                    token = nextToken();
+                    if (token === 24 /* CommaToken */) {
+                        token = nextToken();
+                    }
+                    else {
+                        // unexpected token
+                        return true;
+                    }
+                }
+                // should be start of dependency list
+                if (token !== 19 /* OpenBracketToken */) {
+                    return true;
+                }
+                // skip open bracket
+                token = nextToken();
+                var i = 0;
+                // scan until ']' or EOF
+                while (token !== 20 /* CloseBracketToken */ && token !== 1 /* EndOfFileToken */) {
+                    // record string literals as module names
+                    if (token === 9 /* StringLiteral */) {
+                        recordModuleName();
+                        i++;
+                    }
+                    token = nextToken();
+                }
+                return true;
+            }
+            return false;
+        }
+        function processImports() {
+            scanner.setText(sourceText);
+            nextToken();
+            // Look for:
+            //    import "mod";
+            //    import d from "mod"
+            //    import {a as A } from "mod";
+            //    import * as NS  from "mod"
+            //    import d, {a, b as B} from "mod"
+            //    import i = require("mod");
+            //
+            //    export * from "mod"
+            //    export {a as b} from "mod"
+            //    export import i = require("mod")
+            //    (for JavaScript files) require("mod")
+            while (true) {
+                if (scanner.getToken() === 1 /* EndOfFileToken */) {
+                    break;
+                }
+                // check if at least one of alternative have moved scanner forward
+                if (tryConsumeDeclare() ||
+                    tryConsumeImport() ||
+                    tryConsumeExport() ||
+                    (detectJavaScriptImports && (tryConsumeRequireCall(/*skipCurrentToken*/ false) || tryConsumeDefine()))) {
+                    continue;
+                }
+                else {
+                    nextToken();
+                }
+            }
+            scanner.setText(undefined);
+        }
+        if (readImportFiles) {
+            processImports();
+        }
+        processTripleSlashDirectives();
+        if (externalModule) {
+            // for external modules module all nested ambient modules are augmentations
+            if (ambientExternalModules) {
+                // move all detected ambient modules to imported files since they need to be resolved
+                for (var _i = 0, ambientExternalModules_1 = ambientExternalModules; _i < ambientExternalModules_1.length; _i++) {
+                    var decl = ambientExternalModules_1[_i];
+                    importedFiles.push(decl.ref);
+                }
+            }
+            return { referencedFiles: referencedFiles, typeReferenceDirectives: typeReferenceDirectives, importedFiles: importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: undefined };
+        }
+        else {
+            // for global scripts ambient modules still can have augmentations - look for ambient modules with depth > 0
+            var ambientModuleNames = void 0;
+            if (ambientExternalModules) {
+                for (var _a = 0, ambientExternalModules_2 = ambientExternalModules; _a < ambientExternalModules_2.length; _a++) {
+                    var decl = ambientExternalModules_2[_a];
+                    if (decl.depth === 0) {
+                        if (!ambientModuleNames) {
+                            ambientModuleNames = [];
+                        }
+                        ambientModuleNames.push(decl.ref.fileName);
+                    }
+                    else {
+                        importedFiles.push(decl.ref);
+                    }
+                }
+            }
+            return { referencedFiles: referencedFiles, typeReferenceDirectives: typeReferenceDirectives, importedFiles: importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: ambientModuleNames };
+        }
+    }
+    ts.preProcessFile = preProcessFile;
+    /// Helpers
+    function getTargetLabel(referenceNode, labelName) {
+        while (referenceNode) {
+            if (referenceNode.kind === 214 /* LabeledStatement */ && referenceNode.label.text === labelName) {
+                return referenceNode.label;
+            }
+            referenceNode = referenceNode.parent;
+        }
+        return undefined;
+    }
+    function isJumpStatementTarget(node) {
+        return node.kind === 69 /* Identifier */ &&
+            (node.parent.kind === 210 /* BreakStatement */ || node.parent.kind === 209 /* ContinueStatement */) &&
+            node.parent.label === node;
+    }
+    function isLabelOfLabeledStatement(node) {
+        return node.kind === 69 /* Identifier */ &&
+            node.parent.kind === 214 /* LabeledStatement */ &&
+            node.parent.label === node;
+    }
+    /**
+     * Whether or not a 'node' is preceded by a label of the given string.
+     * Note: 'node' cannot be a SourceFile.
+     */
+    function isLabeledBy(node, labelName) {
+        for (var owner = node.parent; owner.kind === 214 /* LabeledStatement */; owner = owner.parent) {
+            if (owner.label.text === labelName) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function isLabelName(node) {
+        return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node);
+    }
+    function isRightSideOfQualifiedName(node) {
+        return node.parent.kind === 139 /* QualifiedName */ && node.parent.right === node;
+    }
+    function isRightSideOfPropertyAccess(node) {
+        return node && node.parent && node.parent.kind === 172 /* PropertyAccessExpression */ && node.parent.name === node;
+    }
+    function isCallExpressionTarget(node) {
+        if (isRightSideOfPropertyAccess(node)) {
+            node = node.parent;
+        }
+        return node && node.parent && node.parent.kind === 174 /* CallExpression */ && node.parent.expression === node;
+    }
+    function isNewExpressionTarget(node) {
+        if (isRightSideOfPropertyAccess(node)) {
+            node = node.parent;
+        }
+        return node && node.parent && node.parent.kind === 175 /* NewExpression */ && node.parent.expression === node;
+    }
+    function isNameOfModuleDeclaration(node) {
+        return node.parent.kind === 225 /* ModuleDeclaration */ && node.parent.name === node;
+    }
+    function isNameOfFunctionDeclaration(node) {
+        return node.kind === 69 /* Identifier */ &&
+            ts.isFunctionLike(node.parent) && node.parent.name === node;
+    }
+    function isObjectLiteralPropertyDeclaration(node) {
+        switch (node.kind) {
+            case 253 /* PropertyAssignment */:
+            case 254 /* ShorthandPropertyAssignment */:
+            case 147 /* MethodDeclaration */:
+            case 149 /* GetAccessor */:
+            case 150 /* SetAccessor */:
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Returns the containing object literal property declaration given a possible name node, e.g. "a" in x = { "a": 1 }
+     */
+    function getContainingObjectLiteralElement(node) {
+        switch (node.kind) {
+            case 9 /* StringLiteral */:
+            case 8 /* NumericLiteral */:
+                if (node.parent.kind === 140 /* ComputedPropertyName */) {
+                    return isObjectLiteralPropertyDeclaration(node.parent.parent) ? node.parent.parent : undefined;
+                }
+            // intential fall through
+            case 69 /* Identifier */:
+                return isObjectLiteralPropertyDeclaration(node.parent) && node.parent.name === node ? node.parent : undefined;
+        }
+        return undefined;
+    }
+    function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) {
+        if (node.kind === 9 /* StringLiteral */ || node.kind === 8 /* NumericLiteral */) {
+            switch (node.parent.kind) {
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 253 /* PropertyAssignment */:
+                case 255 /* EnumMember */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 225 /* ModuleDeclaration */:
+                    return node.parent.name === node;
+                case 173 /* ElementAccessExpression */:
+                    return node.parent.argumentExpression === node;
+                case 140 /* ComputedPropertyName */:
+                    return true;
+            }
+        }
+        return false;
+    }
+    function isNameOfExternalModuleImportOrDeclaration(node) {
+        if (node.kind === 9 /* StringLiteral */) {
+            return isNameOfModuleDeclaration(node) ||
+                (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node);
+        }
+        return false;
+    }
+    /** Returns true if the position is within a comment */
+    function isInsideComment(sourceFile, token, position) {
+        // The position has to be: 1. in the leading trivia (before token.getStart()), and 2. within a comment
+        return position <= token.getStart(sourceFile) &&
+            (isInsideCommentRange(ts.getTrailingCommentRanges(sourceFile.text, token.getFullStart())) ||
+                isInsideCommentRange(ts.getLeadingCommentRanges(sourceFile.text, token.getFullStart())));
+        function isInsideCommentRange(comments) {
+            return ts.forEach(comments, function (comment) {
+                // either we are 1. completely inside the comment, or 2. at the end of the comment
+                if (comment.pos < position && position < comment.end) {
+                    return true;
+                }
+                else if (position === comment.end) {
+                    var text = sourceFile.text;
+                    var width = comment.end - comment.pos;
+                    // is single line comment or just /*
+                    if (width <= 2 || text.charCodeAt(comment.pos + 1) === 47 /* slash */) {
+                        return true;
+                    }
+                    else {
+                        // is unterminated multi-line comment
+                        return !(text.charCodeAt(comment.end - 1) === 47 /* slash */ &&
+                            text.charCodeAt(comment.end - 2) === 42 /* asterisk */);
+                    }
+                }
+                return false;
+            });
+        }
+    }
+    var SemanticMeaning;
+    (function (SemanticMeaning) {
+        SemanticMeaning[SemanticMeaning["None"] = 0] = "None";
+        SemanticMeaning[SemanticMeaning["Value"] = 1] = "Value";
+        SemanticMeaning[SemanticMeaning["Type"] = 2] = "Type";
+        SemanticMeaning[SemanticMeaning["Namespace"] = 4] = "Namespace";
+        SemanticMeaning[SemanticMeaning["All"] = 7] = "All";
+    })(SemanticMeaning || (SemanticMeaning = {}));
+    var BreakContinueSearchType;
+    (function (BreakContinueSearchType) {
+        BreakContinueSearchType[BreakContinueSearchType["None"] = 0] = "None";
+        BreakContinueSearchType[BreakContinueSearchType["Unlabeled"] = 1] = "Unlabeled";
+        BreakContinueSearchType[BreakContinueSearchType["Labeled"] = 2] = "Labeled";
+        BreakContinueSearchType[BreakContinueSearchType["All"] = 3] = "All";
+    })(BreakContinueSearchType || (BreakContinueSearchType = {}));
+    // A cache of completion entries for keywords, these do not change between sessions
+    var keywordCompletions = [];
+    for (var i = 70 /* FirstKeyword */; i <= 138 /* LastKeyword */; i++) {
+        keywordCompletions.push({
+            name: ts.tokenToString(i),
+            kind: ScriptElementKind.keyword,
+            kindModifiers: ScriptElementKindModifier.none,
+            sortText: "0"
+        });
+    }
+    /* @internal */ function getContainerNode(node) {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case 256 /* SourceFile */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 221 /* ClassDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 224 /* EnumDeclaration */:
+                case 225 /* ModuleDeclaration */:
+                    return node;
+            }
+        }
+    }
+    ts.getContainerNode = getContainerNode;
+    /* @internal */ function getNodeKind(node) {
+        switch (node.kind) {
+            case 225 /* ModuleDeclaration */: return ScriptElementKind.moduleElement;
+            case 221 /* ClassDeclaration */:
+            case 192 /* ClassExpression */:
+                return ScriptElementKind.classElement;
+            case 222 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement;
+            case 223 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement;
+            case 224 /* EnumDeclaration */: return ScriptElementKind.enumElement;
+            case 218 /* VariableDeclaration */:
+                return ts.isConst(node)
+                    ? ScriptElementKind.constElement
+                    : ts.isLet(node)
+                        ? ScriptElementKind.letElement
+                        : ScriptElementKind.variableElement;
+            case 220 /* FunctionDeclaration */:
+            case 179 /* FunctionExpression */:
+                return ScriptElementKind.functionElement;
+            case 149 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement;
+            case 150 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement;
+            case 147 /* MethodDeclaration */:
+            case 146 /* MethodSignature */:
+                return ScriptElementKind.memberFunctionElement;
+            case 145 /* PropertyDeclaration */:
+            case 144 /* PropertySignature */:
+                return ScriptElementKind.memberVariableElement;
+            case 153 /* IndexSignature */: return ScriptElementKind.indexSignatureElement;
+            case 152 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement;
+            case 151 /* CallSignature */: return ScriptElementKind.callSignatureElement;
+            case 148 /* Constructor */: return ScriptElementKind.constructorImplementationElement;
+            case 141 /* TypeParameter */: return ScriptElementKind.typeParameterElement;
+            case 255 /* EnumMember */: return ScriptElementKind.variableElement;
+            case 142 /* Parameter */: return (node.flags & 92 /* ParameterPropertyModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case 229 /* ImportEqualsDeclaration */:
+            case 234 /* ImportSpecifier */:
+            case 231 /* ImportClause */:
+            case 238 /* ExportSpecifier */:
+            case 232 /* NamespaceImport */:
+                return ScriptElementKind.alias;
+        }
+        return ScriptElementKind.unknown;
+    }
+    ts.getNodeKind = getNodeKind;
+    var CancellationTokenObject = (function () {
+        function CancellationTokenObject(cancellationToken) {
+            this.cancellationToken = cancellationToken;
+        }
+        CancellationTokenObject.prototype.isCancellationRequested = function () {
+            return this.cancellationToken && this.cancellationToken.isCancellationRequested();
+        };
+        CancellationTokenObject.prototype.throwIfCancellationRequested = function () {
+            if (this.isCancellationRequested()) {
+                throw new ts.OperationCanceledException();
+            }
+        };
+        return CancellationTokenObject;
+    }());
+    function createLanguageService(host, documentRegistry) {
+        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); }
+        var syntaxTreeCache = new SyntaxTreeCache(host);
+        var ruleProvider;
+        var program;
+        var lastProjectVersion;
+        var useCaseSensitivefileNames = false;
+        var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
+        var currentDirectory = host.getCurrentDirectory();
+        // Check if the localized messages json is set, otherwise query the host for it
+        if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
+            ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages();
+        }
+        function log(message) {
+            if (host.log) {
+                host.log(message);
+            }
+        }
+        var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitivefileNames);
+        function getValidSourceFile(fileName) {
+            var sourceFile = program.getSourceFile(fileName);
+            if (!sourceFile) {
+                throw new Error("Could not find file: '" + fileName + "'.");
+            }
+            return sourceFile;
+        }
+        function getRuleProvider(options) {
+            // Ensure rules are initialized and up to date wrt to formatting options
+            if (!ruleProvider) {
+                ruleProvider = new ts.formatting.RulesProvider();
+            }
+            ruleProvider.ensureUpToDate(options);
+            return ruleProvider;
+        }
+        function synchronizeHostData() {
+            // perform fast check if host supports it
+            if (host.getProjectVersion) {
+                var hostProjectVersion = host.getProjectVersion();
+                if (hostProjectVersion) {
+                    if (lastProjectVersion === hostProjectVersion) {
+                        return;
+                    }
+                    lastProjectVersion = hostProjectVersion;
+                }
+            }
+            // Get a fresh cache of the host information
+            var hostCache = new HostCache(host, getCanonicalFileName);
+            // If the program is already up-to-date, we can reuse it
+            if (programUpToDate()) {
+                return;
+            }
+            // IMPORTANT - It is critical from this moment onward that we do not check
+            // cancellation tokens.  We are about to mutate source files from a previous program
+            // instance.  If we cancel midway through, we may end up in an inconsistent state where
+            // the program points to old source files that have been invalidated because of
+            // incremental parsing.
+            var oldSettings = program && program.getCompilerOptions();
+            var newSettings = hostCache.compilationSettings();
+            var changesInCompilationSettingsAffectSyntax = oldSettings &&
+                (oldSettings.target !== newSettings.target ||
+                    oldSettings.module !== newSettings.module ||
+                    oldSettings.moduleResolution !== newSettings.moduleResolution ||
+                    oldSettings.noResolve !== newSettings.noResolve ||
+                    oldSettings.jsx !== newSettings.jsx ||
+                    oldSettings.allowJs !== newSettings.allowJs ||
+                    oldSettings.disableSizeLimit !== oldSettings.disableSizeLimit);
+            // Now create a new compiler
+            var compilerHost = {
+                getSourceFile: getOrCreateSourceFile,
+                getSourceFileByPath: getOrCreateSourceFileByPath,
+                getCancellationToken: function () { return cancellationToken; },
+                getCanonicalFileName: getCanonicalFileName,
+                useCaseSensitiveFileNames: function () { return useCaseSensitivefileNames; },
+                getNewLine: function () { return ts.getNewLineOrDefaultFromHost(host); },
+                getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
+                writeFile: function (fileName, data, writeByteOrderMark) { },
+                getCurrentDirectory: function () { return currentDirectory; },
+                fileExists: function (fileName) {
+                    // stub missing host functionality
+                    ts.Debug.assert(!host.resolveModuleNames || !host.resolveTypeReferenceDirectives);
+                    return hostCache.getOrCreateEntry(fileName) !== undefined;
+                },
+                readFile: function (fileName) {
+                    // stub missing host functionality
+                    var entry = hostCache.getOrCreateEntry(fileName);
+                    return entry && entry.scriptSnapshot.getText(0, entry.scriptSnapshot.getLength());
+                },
+                directoryExists: function (directoryName) {
+                    return ts.directoryProbablyExists(directoryName, host);
+                },
+                getDirectories: function (path) {
+                    return host.getDirectories ? host.getDirectories(path) : [];
+                }
+            };
+            if (host.trace) {
+                compilerHost.trace = function (message) { return host.trace(message); };
+            }
+            if (host.resolveModuleNames) {
+                compilerHost.resolveModuleNames = function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); };
+            }
+            if (host.resolveTypeReferenceDirectives) {
+                compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile) {
+                    return host.resolveTypeReferenceDirectives(typeReferenceDirectiveNames, containingFile);
+                };
+            }
+            var documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
+            var newProgram = ts.createProgram(hostCache.getRootFileNames(), newSettings, compilerHost, program);
+            // Release any files we have acquired in the old program but are
+            // not part of the new program.
+            if (program) {
+                var oldSourceFiles = program.getSourceFiles();
+                var oldSettingsKey = documentRegistry.getKeyForCompilationSettings(oldSettings);
+                for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) {
+                    var oldSourceFile = oldSourceFiles_1[_i];
+                    if (!newProgram.getSourceFile(oldSourceFile.fileName) || changesInCompilationSettingsAffectSyntax) {
+                        documentRegistry.releaseDocumentWithKey(oldSourceFile.path, oldSettingsKey);
+                    }
+                }
+            }
+            // hostCache is captured in the closure for 'getOrCreateSourceFile' but it should not be used past this point.
+            // It needs to be cleared to allow all collected snapshots to be released
+            hostCache = undefined;
+            program = newProgram;
+            // Make sure all the nodes in the program are both bound, and have their parent
+            // pointers set property.
+            program.getTypeChecker();
+            return;
+            function getOrCreateSourceFile(fileName) {
+                return getOrCreateSourceFileByPath(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName));
+            }
+            function getOrCreateSourceFileByPath(fileName, path) {
+                ts.Debug.assert(hostCache !== undefined);
+                // The program is asking for this file, check first if the host can locate it.
+                // If the host can not locate the file, then it does not exist. return undefined
+                // to the program to allow reporting of errors for missing files.
+                var hostFileInformation = hostCache.getOrCreateEntryByPath(fileName, path);
+                if (!hostFileInformation) {
+                    return undefined;
+                }
+                // Check if the language version has changed since we last created a program; if they are the same,
+                // it is safe to reuse the sourceFiles; if not, then the shape of the AST can change, and the oldSourceFile
+                // can not be reused. we have to dump all syntax trees and create new ones.
+                if (!changesInCompilationSettingsAffectSyntax) {
+                    // Check if the old program had this file already
+                    var oldSourceFile = program && program.getSourceFileByPath(path);
+                    if (oldSourceFile) {
+                        // We already had a source file for this file name.  Go to the registry to
+                        // ensure that we get the right up to date version of it.  We need this to
+                        // address the following race-condition.  Specifically, say we have the following:
+                        //
+                        //      LS1
+                        //          \
+                        //           DocumentRegistry
+                        //          /
+                        //      LS2
+                        //
+                        // Each LS has a reference to file 'foo.ts' at version 1.  LS2 then updates
+                        // it's version of 'foo.ts' to version 2.  This will cause LS2 and the
+                        // DocumentRegistry to have version 2 of the document.  HOwever, LS1 will
+                        // have version 1.  And *importantly* this source file will be *corrupt*.
+                        // The act of creating version 2 of the file irrevocably damages the version
+                        // 1 file.
+                        //
+                        // So, later when we call into LS1, we need to make sure that it doesn't use
+                        // it's source file any more, and instead defers to DocumentRegistry to get
+                        // either version 1, version 2 (or some other version) depending on what the
+                        // host says should be used.
+                        // We do not support the scenario where a host can modify a registered
+                        // file's script kind, i.e. in one project some file is treated as ".ts"
+                        // and in another as ".js"
+                        ts.Debug.assert(hostFileInformation.scriptKind === oldSourceFile.scriptKind, "Registered script kind (" + oldSourceFile.scriptKind + ") should match new script kind (" + hostFileInformation.scriptKind + ") for file: " + path);
+                        return documentRegistry.updateDocumentWithKey(fileName, path, newSettings, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+                    }
+                }
+                // Could not find this file in the old program, create a new SourceFile for it.
+                return documentRegistry.acquireDocumentWithKey(fileName, path, newSettings, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+            }
+            function sourceFileUpToDate(sourceFile) {
+                if (!sourceFile) {
+                    return false;
+                }
+                var path = sourceFile.path || ts.toPath(sourceFile.fileName, currentDirectory, getCanonicalFileName);
+                return sourceFile.version === hostCache.getVersion(path);
+            }
+            function programUpToDate() {
+                // If we haven't create a program yet, then it is not up-to-date
+                if (!program) {
+                    return false;
+                }
+                // If number of files in the program do not match, it is not up-to-date
+                var rootFileNames = hostCache.getRootFileNames();
+                if (program.getSourceFiles().length !== rootFileNames.length) {
+                    return false;
+                }
+                // If any file is not up-to-date, then the whole program is not up-to-date
+                for (var _i = 0, rootFileNames_2 = rootFileNames; _i < rootFileNames_2.length; _i++) {
+                    var fileName = rootFileNames_2[_i];
+                    if (!sourceFileUpToDate(program.getSourceFile(fileName))) {
+                        return false;
+                    }
+                }
+                // If the compilation settings do no match, then the program is not up-to-date
+                return ts.compareDataObjects(program.getCompilerOptions(), hostCache.compilationSettings());
+            }
+        }
+        function getProgram() {
+            synchronizeHostData();
+            return program;
+        }
+        function cleanupSemanticCache() {
+            // TODO: Should we jettison the program (or it's type checker) here?
+        }
+        function dispose() {
+            if (program) {
+                ts.forEach(program.getSourceFiles(), function (f) {
+                    return documentRegistry.releaseDocument(f.fileName, program.getCompilerOptions());
+                });
+            }
+        }
+        /// Diagnostics
+        function getSyntacticDiagnostics(fileName) {
+            synchronizeHostData();
+            return program.getSyntacticDiagnostics(getValidSourceFile(fileName), cancellationToken);
+        }
+        /**
+         * getSemanticDiagnostics return array of Diagnostics. If '-d' is not enabled, only report semantic errors
+         * If '-d' enabled, report both semantic and emitter errors
+         */
+        function getSemanticDiagnostics(fileName) {
+            synchronizeHostData();
+            var targetSourceFile = getValidSourceFile(fileName);
+            // Only perform the action per file regardless of '-out' flag as LanguageServiceHost is expected to call this function per file.
+            // Therefore only get diagnostics for given file.
+            var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile, cancellationToken);
+            if (!program.getCompilerOptions().declaration) {
+                return semanticDiagnostics;
+            }
+            // If '-d' is enabled, check for emitter error. One example of emitter error is export class implements non-export interface
+            var declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile, cancellationToken);
+            return ts.concatenate(semanticDiagnostics, declarationDiagnostics);
+        }
+        function getCompilerOptionsDiagnostics() {
+            synchronizeHostData();
+            return program.getOptionsDiagnostics(cancellationToken).concat(program.getGlobalDiagnostics(cancellationToken));
+        }
+        /**
+         * Get the name to be display in completion from a given symbol.
+         *
+         * @return undefined if the name is of external module otherwise a name with striped of any quote
+         */
+        function getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks, location) {
+            var displayName = ts.getDeclaredName(program.getTypeChecker(), symbol, location);
+            if (displayName) {
+                var firstCharCode = displayName.charCodeAt(0);
+                // First check of the displayName is not external module; if it is an external module, it is not valid entry
+                if ((symbol.flags & 1536 /* Namespace */) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) {
+                    // If the symbol is external module, don't show it in the completion list
+                    // (i.e declare module "http" { const x; } | // <= request completion here, "http" should not be there)
+                    return undefined;
+                }
+            }
+            return getCompletionEntryDisplayName(displayName, target, performCharacterChecks);
+        }
+        /**
+         * Get a displayName from a given for completion list, performing any necessary quotes stripping
+         * and checking whether the name is valid identifier name.
+         */
+        function getCompletionEntryDisplayName(name, target, performCharacterChecks) {
+            if (!name) {
+                return undefined;
+            }
+            name = ts.stripQuotes(name);
+            if (!name) {
+                return undefined;
+            }
+            // If the user entered name for the symbol was quoted, removing the quotes is not enough, as the name could be an
+            // invalid identifier name. We need to check if whatever was inside the quotes is actually a valid identifier name.
+            // e.g "b a" is valid quoted name but when we strip off the quotes, it is invalid.
+            // We, thus, need to check if whatever was inside the quotes is actually a valid identifier name.
+            if (performCharacterChecks) {
+                if (!ts.isIdentifier(name, target)) {
+                    return undefined;
+                }
+            }
+            return name;
+        }
+        function getCompletionData(fileName, position) {
+            var typeChecker = program.getTypeChecker();
+            var sourceFile = getValidSourceFile(fileName);
+            var isJavaScriptFile = ts.isSourceFileJavaScript(sourceFile);
+            var isJsDocTagName = false;
+            var start = new Date().getTime();
+            var currentToken = ts.getTokenAtPosition(sourceFile, position);
+            log("getCompletionData: Get current token: " + (new Date().getTime() - start));
+            start = new Date().getTime();
+            // Completion not allowed inside comments, bail out if this is the case
+            var insideComment = isInsideComment(sourceFile, currentToken, position);
+            log("getCompletionData: Is inside comment: " + (new Date().getTime() - start));
+            if (insideComment) {
+                // The current position is next to the '@' sign, when no tag name being provided yet.
+                // Provide a full list of tag names
+                if (ts.hasDocComment(sourceFile, position) && sourceFile.text.charCodeAt(position - 1) === 64 /* at */) {
+                    isJsDocTagName = true;
+                }
+                // Completion should work inside certain JsDoc tags. For example:
+                //     /** @type {number | string} */
+                // Completion should work in the brackets
+                var insideJsDocTagExpression = false;
+                var tag = ts.getJsDocTagAtPosition(sourceFile, position);
+                if (tag) {
+                    if (tag.tagName.pos <= position && position <= tag.tagName.end) {
+                        isJsDocTagName = true;
+                    }
+                    switch (tag.kind) {
+                        case 277 /* JSDocTypeTag */:
+                        case 275 /* JSDocParameterTag */:
+                        case 276 /* JSDocReturnTag */:
+                            var tagWithExpression = tag;
+                            if (tagWithExpression.typeExpression) {
+                                insideJsDocTagExpression = tagWithExpression.typeExpression.pos < position && position < tagWithExpression.typeExpression.end;
+                            }
+                            break;
+                    }
+                }
+                if (isJsDocTagName) {
+                    return { symbols: undefined, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, isJsDocTagName: isJsDocTagName };
+                }
+                if (!insideJsDocTagExpression) {
+                    // Proceed if the current position is in jsDoc tag expression; otherwise it is a normal
+                    // comment or the plain text part of a jsDoc comment, so no completion should be available
+                    log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment.");
+                    return undefined;
+                }
+            }
+            start = new Date().getTime();
+            var previousToken = ts.findPrecedingToken(position, sourceFile);
+            log("getCompletionData: Get previous token 1: " + (new Date().getTime() - start));
+            // The decision to provide completion depends on the contextToken, which is determined through the previousToken.
+            // Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file
+            var contextToken = previousToken;
+            // Check if the caret is at the end of an identifier; this is a partial identifier that we want to complete: e.g. a.toS|
+            // Skip this partial identifier and adjust the contextToken to the token that precedes it.
+            if (contextToken && position <= contextToken.end && ts.isWord(contextToken.kind)) {
+                var start_5 = new Date().getTime();
+                contextToken = ts.findPrecedingToken(contextToken.getFullStart(), sourceFile);
+                log("getCompletionData: Get previous token 2: " + (new Date().getTime() - start_5));
+            }
+            // Find the node where completion is requested on.
+            // Also determine whether we are trying to complete with members of that node
+            // or attributes of a JSX tag.
+            var node = currentToken;
+            var isRightOfDot = false;
+            var isRightOfOpenTag = false;
+            var isStartingCloseTag = false;
+            var location = ts.getTouchingPropertyName(sourceFile, position);
+            if (contextToken) {
+                // Bail out if this is a known invalid completion location
+                if (isCompletionListBlocker(contextToken)) {
+                    log("Returning an empty list because completion was requested in an invalid position.");
+                    return undefined;
+                }
+                var parent_17 = contextToken.parent, kind = contextToken.kind;
+                if (kind === 21 /* DotToken */) {
+                    if (parent_17.kind === 172 /* PropertyAccessExpression */) {
+                        node = contextToken.parent.expression;
+                        isRightOfDot = true;
+                    }
+                    else if (parent_17.kind === 139 /* QualifiedName */) {
+                        node = contextToken.parent.left;
+                        isRightOfDot = true;
+                    }
+                    else {
+                        // There is nothing that precedes the dot, so this likely just a stray character
+                        // or leading into a '...' token. Just bail out instead.
+                        return undefined;
+                    }
+                }
+                else if (sourceFile.languageVariant === 1 /* JSX */) {
+                    if (kind === 25 /* LessThanToken */) {
+                        isRightOfOpenTag = true;
+                        location = contextToken;
+                    }
+                    else if (kind === 39 /* SlashToken */ && contextToken.parent.kind === 245 /* JsxClosingElement */) {
+                        isStartingCloseTag = true;
+                        location = contextToken;
+                    }
+                }
+            }
+            var semanticStart = new Date().getTime();
+            var isMemberCompletion;
+            var isNewIdentifierLocation;
+            var symbols = [];
+            if (isRightOfDot) {
+                getTypeScriptMemberSymbols();
+            }
+            else if (isRightOfOpenTag) {
+                var tagSymbols = typeChecker.getJsxIntrinsicTagNames();
+                if (tryGetGlobalSymbols()) {
+                    symbols = tagSymbols.concat(symbols.filter(function (s) { return !!(s.flags & (107455 /* Value */ | 8388608 /* Alias */)); }));
+                }
+                else {
+                    symbols = tagSymbols;
+                }
+                isMemberCompletion = true;
+                isNewIdentifierLocation = false;
+            }
+            else if (isStartingCloseTag) {
+                var tagName = contextToken.parent.parent.openingElement.tagName;
+                var tagSymbol = typeChecker.getSymbolAtLocation(tagName);
+                if (!typeChecker.isUnknownSymbol(tagSymbol)) {
+                    symbols = [tagSymbol];
+                }
+                isMemberCompletion = true;
+                isNewIdentifierLocation = false;
+            }
+            else {
+                // For JavaScript or TypeScript, if we're not after a dot, then just try to get the
+                // global symbols in scope.  These results should be valid for either language as
+                // the set of symbols that can be referenced from this location.
+                if (!tryGetGlobalSymbols()) {
+                    return undefined;
+                }
+            }
+            log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart));
+            return { symbols: symbols, isMemberCompletion: isMemberCompletion, isNewIdentifierLocation: isNewIdentifierLocation, location: location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), isJsDocTagName: isJsDocTagName };
+            function getTypeScriptMemberSymbols() {
+                // Right of dot member completion list
+                isMemberCompletion = true;
+                isNewIdentifierLocation = false;
+                if (node.kind === 69 /* Identifier */ || node.kind === 139 /* QualifiedName */ || node.kind === 172 /* PropertyAccessExpression */) {
+                    var symbol = typeChecker.getSymbolAtLocation(node);
+                    // This is an alias, follow what it aliases
+                    if (symbol && symbol.flags & 8388608 /* Alias */) {
+                        symbol = typeChecker.getAliasedSymbol(symbol);
+                    }
+                    if (symbol && symbol.flags & 1952 /* HasExports */) {
+                        // Extract module or enum members
+                        var exportedSymbols = typeChecker.getExportsOfModule(symbol);
+                        ts.forEach(exportedSymbols, function (symbol) {
+                            if (typeChecker.isValidPropertyAccess((node.parent), symbol.name)) {
+                                symbols.push(symbol);
+                            }
+                        });
+                    }
+                }
+                var type = typeChecker.getTypeAtLocation(node);
+                addTypeProperties(type);
+            }
+            function addTypeProperties(type) {
+                if (type) {
+                    // Filter private properties
+                    for (var _i = 0, _a = type.getApparentProperties(); _i < _a.length; _i++) {
+                        var symbol = _a[_i];
+                        if (typeChecker.isValidPropertyAccess((node.parent), symbol.name)) {
+                            symbols.push(symbol);
+                        }
+                    }
+                    if (isJavaScriptFile && type.flags & 16384 /* Union */) {
+                        // In javascript files, for union types, we don't just get the members that
+                        // the individual types have in common, we also include all the members that
+                        // each individual type has.  This is because we're going to add all identifiers
+                        // anyways.  So we might as well elevate the members that were at least part
+                        // of the individual types to a higher status since we know what they are.
+                        var unionType = type;
+                        for (var _b = 0, _c = unionType.types; _b < _c.length; _b++) {
+                            var elementType = _c[_b];
+                            addTypeProperties(elementType);
+                        }
+                    }
+                }
+            }
+            function tryGetGlobalSymbols() {
+                var objectLikeContainer;
+                var namedImportsOrExports;
+                var jsxContainer;
+                if (objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken)) {
+                    return tryGetObjectLikeCompletionSymbols(objectLikeContainer);
+                }
+                if (namedImportsOrExports = tryGetNamedImportsOrExportsForCompletion(contextToken)) {
+                    // cursor is in an import clause
+                    // try to show exported member for imported module
+                    return tryGetImportOrExportClauseCompletionSymbols(namedImportsOrExports);
+                }
+                if (jsxContainer = tryGetContainingJsxElement(contextToken)) {
+                    var attrsType = void 0;
+                    if ((jsxContainer.kind === 242 /* JsxSelfClosingElement */) || (jsxContainer.kind === 243 /* JsxOpeningElement */)) {
+                        // Cursor is inside a JSX self-closing element or opening element
+                        attrsType = typeChecker.getJsxElementAttributesType(jsxContainer);
+                        if (attrsType) {
+                            symbols = filterJsxAttributes(typeChecker.getPropertiesOfType(attrsType), jsxContainer.attributes);
+                            isMemberCompletion = true;
+                            isNewIdentifierLocation = false;
+                            return true;
+                        }
+                    }
+                }
+                // Get all entities in the current scope.
+                isMemberCompletion = false;
+                isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken);
+                if (previousToken !== contextToken) {
+                    ts.Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'.");
+                }
+                // We need to find the node that will give us an appropriate scope to begin
+                // aggregating completion candidates. This is achieved in 'getScopeNode'
+                // by finding the first node that encompasses a position, accounting for whether a node
+                // is "complete" to decide whether a position belongs to the node.
+                //
+                // However, at the end of an identifier, we are interested in the scope of the identifier
+                // itself, but fall outside of the identifier. For instance:
+                //
+                //      xyz => x$
+                //
+                // the cursor is outside of both the 'x' and the arrow function 'xyz => x',
+                // so 'xyz' is not returned in our results.
+                //
+                // We define 'adjustedPosition' so that we may appropriately account for
+                // being at the end of an identifier. The intention is that if requesting completion
+                // at the end of an identifier, it should be effectively equivalent to requesting completion
+                // anywhere inside/at the beginning of the identifier. So in the previous case, the
+                // 'adjustedPosition' will work as if requesting completion in the following:
+                //
+                //      xyz => $x
+                //
+                // If previousToken !== contextToken, then
+                //   - 'contextToken' was adjusted to the token prior to 'previousToken'
+                //      because we were at the end of an identifier.
+                //   - 'previousToken' is defined.
+                var adjustedPosition = previousToken !== contextToken ?
+                    previousToken.getStart() :
+                    position;
+                var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
+                /// TODO filter meaning based on the current context
+                var symbolMeanings = 793056 /* Type */ | 107455 /* Value */ | 1536 /* Namespace */ | 8388608 /* Alias */;
+                symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings);
+                return true;
+            }
+            /**
+             * Finds the first node that "embraces" the position, so that one may
+             * accurately aggregate locals from the closest containing scope.
+             */
+            function getScopeNode(initialToken, position, sourceFile) {
+                var scope = initialToken;
+                while (scope && !ts.positionBelongsToNode(scope, position, sourceFile)) {
+                    scope = scope.parent;
+                }
+                return scope;
+            }
+            function isCompletionListBlocker(contextToken) {
+                var start = new Date().getTime();
+                var result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken) ||
+                    isSolelyIdentifierDefinitionLocation(contextToken) ||
+                    isDotOfNumericLiteral(contextToken) ||
+                    isInJsxText(contextToken);
+                log("getCompletionsAtPosition: isCompletionListBlocker: " + (new Date().getTime() - start));
+                return result;
+            }
+            function isInJsxText(contextToken) {
+                if (contextToken.kind === 244 /* JsxText */) {
+                    return true;
+                }
+                if (contextToken.kind === 27 /* GreaterThanToken */ && contextToken.parent) {
+                    if (contextToken.parent.kind === 243 /* JsxOpeningElement */) {
+                        return true;
+                    }
+                    if (contextToken.parent.kind === 245 /* JsxClosingElement */ || contextToken.parent.kind === 242 /* JsxSelfClosingElement */) {
+                        return contextToken.parent.parent && contextToken.parent.parent.kind === 241 /* JsxElement */;
+                    }
+                }
+                return false;
+            }
+            function isNewIdentifierDefinitionLocation(previousToken) {
+                if (previousToken) {
+                    var containingNodeKind = previousToken.parent.kind;
+                    switch (previousToken.kind) {
+                        case 24 /* CommaToken */:
+                            return containingNodeKind === 174 /* CallExpression */ // func( a, |
+                                || containingNodeKind === 148 /* Constructor */ // constructor( a, |   /* public, protected, private keywords are allowed here, so show completion */
+                                || containingNodeKind === 175 /* NewExpression */ // new C(a, |
+                                || containingNodeKind === 170 /* ArrayLiteralExpression */ // [a, |
+                                || containingNodeKind === 187 /* BinaryExpression */ // const x = (a, |
+                                || containingNodeKind === 156 /* FunctionType */; // var x: (s: string, list|
+                        case 17 /* OpenParenToken */:
+                            return containingNodeKind === 174 /* CallExpression */ // func( |
+                                || containingNodeKind === 148 /* Constructor */ // constructor( |
+                                || containingNodeKind === 175 /* NewExpression */ // new C(a|
+                                || containingNodeKind === 178 /* ParenthesizedExpression */ // const x = (a|
+                                || containingNodeKind === 164 /* ParenthesizedType */; // function F(pred: (a| /* this can become an arrow function, where 'a' is the argument */
+                        case 19 /* OpenBracketToken */:
+                            return containingNodeKind === 170 /* ArrayLiteralExpression */ // [ |
+                                || containingNodeKind === 153 /* IndexSignature */ // [ | : string ]
+                                || containingNodeKind === 140 /* ComputedPropertyName */; // [ |    /* this can become an index signature */
+                        case 125 /* ModuleKeyword */: // module |
+                        case 126 /* NamespaceKeyword */:
+                            return true;
+                        case 21 /* DotToken */:
+                            return containingNodeKind === 225 /* ModuleDeclaration */; // module A.|
+                        case 15 /* OpenBraceToken */:
+                            return containingNodeKind === 221 /* ClassDeclaration */; // class A{ |
+                        case 56 /* EqualsToken */:
+                            return containingNodeKind === 218 /* VariableDeclaration */ // const x = a|
+                                || containingNodeKind === 187 /* BinaryExpression */; // x = a|
+                        case 12 /* TemplateHead */:
+                            return containingNodeKind === 189 /* TemplateExpression */; // `aa ${|
+                        case 13 /* TemplateMiddle */:
+                            return containingNodeKind === 197 /* TemplateSpan */; // `aa ${10} dd ${|
+                        case 112 /* PublicKeyword */:
+                        case 110 /* PrivateKeyword */:
+                        case 111 /* ProtectedKeyword */:
+                            return containingNodeKind === 145 /* PropertyDeclaration */; // class A{ public |
+                    }
+                    // Previous token may have been a keyword that was converted to an identifier.
+                    switch (previousToken.getText()) {
+                        case "public":
+                        case "protected":
+                        case "private":
+                            return true;
+                    }
+                }
+                return false;
+            }
+            function isInStringOrRegularExpressionOrTemplateLiteral(contextToken) {
+                if (contextToken.kind === 9 /* StringLiteral */
+                    || contextToken.kind === 166 /* StringLiteralType */
+                    || contextToken.kind === 10 /* RegularExpressionLiteral */
+                    || ts.isTemplateLiteralKind(contextToken.kind)) {
+                    var start_6 = contextToken.getStart();
+                    var end = contextToken.getEnd();
+                    // To be "in" one of these literals, the position has to be:
+                    //   1. entirely within the token text.
+                    //   2. at the end position of an unterminated token.
+                    //   3. at the end of a regular expression (due to trailing flags like '/foo/g').
+                    if (start_6 < position && position < end) {
+                        return true;
+                    }
+                    if (position === end) {
+                        return !!contextToken.isUnterminated
+                            || contextToken.kind === 10 /* RegularExpressionLiteral */;
+                    }
+                }
+                return false;
+            }
+            /**
+             * Aggregates relevant symbols for completion in object literals and object binding patterns.
+             * Relevant symbols are stored in the captured 'symbols' variable.
+             *
+             * @returns true if 'symbols' was successfully populated; false otherwise.
+             */
+            function tryGetObjectLikeCompletionSymbols(objectLikeContainer) {
+                // We're looking up possible property names from contextual/inferred/declared type.
+                isMemberCompletion = true;
+                var typeForObject;
+                var existingMembers;
+                if (objectLikeContainer.kind === 171 /* ObjectLiteralExpression */) {
+                    // We are completing on contextual types, but may also include properties
+                    // other than those within the declared type.
+                    isNewIdentifierLocation = true;
+                    typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                    existingMembers = objectLikeContainer.properties;
+                }
+                else if (objectLikeContainer.kind === 167 /* ObjectBindingPattern */) {
+                    // We are *only* completing on properties from the type being destructured.
+                    isNewIdentifierLocation = false;
+                    var rootDeclaration = ts.getRootDeclaration(objectLikeContainer.parent);
+                    if (ts.isVariableLike(rootDeclaration)) {
+                        // We don't want to complete using the type acquired by the shape
+                        // of the binding pattern; we are only interested in types acquired
+                        // through type declaration or inference.
+                        // Also proceed if rootDeclaration is parameter and if its containing function expression\arrow function is contextually typed -
+                        // type of parameter will flow in from the contextual type of the function
+                        var canGetType = !!(rootDeclaration.initializer || rootDeclaration.type);
+                        if (!canGetType && rootDeclaration.kind === 142 /* Parameter */) {
+                            if (ts.isExpression(rootDeclaration.parent)) {
+                                canGetType = !!typeChecker.getContextualType(rootDeclaration.parent);
+                            }
+                            else if (rootDeclaration.parent.kind === 147 /* MethodDeclaration */ || rootDeclaration.parent.kind === 150 /* SetAccessor */) {
+                                canGetType = ts.isExpression(rootDeclaration.parent.parent) && !!typeChecker.getContextualType(rootDeclaration.parent.parent);
+                            }
+                        }
+                        if (canGetType) {
+                            typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer);
+                            existingMembers = objectLikeContainer.elements;
+                        }
+                    }
+                    else {
+                        ts.Debug.fail("Root declaration is not variable-like.");
+                    }
+                }
+                else {
+                    ts.Debug.fail("Expected object literal or binding pattern, got " + objectLikeContainer.kind);
+                }
+                if (!typeForObject) {
+                    return false;
+                }
+                var typeMembers = typeChecker.getPropertiesOfType(typeForObject);
+                if (typeMembers && typeMembers.length > 0) {
+                    // Add filtered items to the completion list
+                    symbols = filterObjectMembersList(typeMembers, existingMembers);
+                }
+                return true;
+            }
+            /**
+             * Aggregates relevant symbols for completion in import clauses and export clauses
+             * whose declarations have a module specifier; for instance, symbols will be aggregated for
+             *
+             *      import { | } from "moduleName";
+             *      export { a as foo, | } from "moduleName";
+             *
+             * but not for
+             *
+             *      export { | };
+             *
+             * Relevant symbols are stored in the captured 'symbols' variable.
+             *
+             * @returns true if 'symbols' was successfully populated; false otherwise.
+             */
+            function tryGetImportOrExportClauseCompletionSymbols(namedImportsOrExports) {
+                var declarationKind = namedImportsOrExports.kind === 233 /* NamedImports */ ?
+                    230 /* ImportDeclaration */ :
+                    236 /* ExportDeclaration */;
+                var importOrExportDeclaration = ts.getAncestor(namedImportsOrExports, declarationKind);
+                var moduleSpecifier = importOrExportDeclaration.moduleSpecifier;
+                if (!moduleSpecifier) {
+                    return false;
+                }
+                isMemberCompletion = true;
+                isNewIdentifierLocation = false;
+                var exports;
+                var moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(importOrExportDeclaration.moduleSpecifier);
+                if (moduleSpecifierSymbol) {
+                    exports = typeChecker.getExportsOfModule(moduleSpecifierSymbol);
+                }
+                symbols = exports ? filterNamedImportOrExportCompletionItems(exports, namedImportsOrExports.elements) : emptyArray;
+                return true;
+            }
+            /**
+             * Returns the immediate owning object literal or binding pattern of a context token,
+             * on the condition that one exists and that the context implies completion should be given.
+             */
+            function tryGetObjectLikeCompletionContainer(contextToken) {
+                if (contextToken) {
+                    switch (contextToken.kind) {
+                        case 15 /* OpenBraceToken */: // const x = { |
+                        case 24 /* CommaToken */:
+                            var parent_18 = contextToken.parent;
+                            if (parent_18 && (parent_18.kind === 171 /* ObjectLiteralExpression */ || parent_18.kind === 167 /* ObjectBindingPattern */)) {
+                                return parent_18;
+                            }
+                            break;
+                    }
+                }
+                return undefined;
+            }
+            /**
+             * Returns the containing list of named imports or exports of a context token,
+             * on the condition that one exists and that the context implies completion should be given.
+             */
+            function tryGetNamedImportsOrExportsForCompletion(contextToken) {
+                if (contextToken) {
+                    switch (contextToken.kind) {
+                        case 15 /* OpenBraceToken */: // import { |
+                        case 24 /* CommaToken */:
+                            switch (contextToken.parent.kind) {
+                                case 233 /* NamedImports */:
+                                case 237 /* NamedExports */:
+                                    return contextToken.parent;
+                            }
+                    }
+                }
+                return undefined;
+            }
+            function tryGetContainingJsxElement(contextToken) {
+                if (contextToken) {
+                    var parent_19 = contextToken.parent;
+                    switch (contextToken.kind) {
+                        case 26 /* LessThanSlashToken */:
+                        case 39 /* SlashToken */:
+                        case 69 /* Identifier */:
+                        case 246 /* JsxAttribute */:
+                        case 247 /* JsxSpreadAttribute */:
+                            if (parent_19 && (parent_19.kind === 242 /* JsxSelfClosingElement */ || parent_19.kind === 243 /* JsxOpeningElement */)) {
+                                return parent_19;
+                            }
+                            else if (parent_19.kind === 246 /* JsxAttribute */) {
+                                return parent_19.parent;
+                            }
+                            break;
+                        // The context token is the closing } or " of an attribute, which means
+                        // its parent is a JsxExpression, whose parent is a JsxAttribute,
+                        // whose parent is a JsxOpeningLikeElement
+                        case 9 /* StringLiteral */:
+                            if (parent_19 && ((parent_19.kind === 246 /* JsxAttribute */) || (parent_19.kind === 247 /* JsxSpreadAttribute */))) {
+                                return parent_19.parent;
+                            }
+                            break;
+                        case 16 /* CloseBraceToken */:
+                            if (parent_19 &&
+                                parent_19.kind === 248 /* JsxExpression */ &&
+                                parent_19.parent &&
+                                (parent_19.parent.kind === 246 /* JsxAttribute */)) {
+                                return parent_19.parent.parent;
+                            }
+                            if (parent_19 && parent_19.kind === 247 /* JsxSpreadAttribute */) {
+                                return parent_19.parent;
+                            }
+                            break;
+                    }
+                }
+                return undefined;
+            }
+            function isFunction(kind) {
+                switch (kind) {
+                    case 179 /* FunctionExpression */:
+                    case 180 /* ArrowFunction */:
+                    case 220 /* FunctionDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                    case 151 /* CallSignature */:
+                    case 152 /* ConstructSignature */:
+                    case 153 /* IndexSignature */:
+                        return true;
+                }
+                return false;
+            }
+            /**
+             * @returns true if we are certain that the currently edited location must define a new location; false otherwise.
+             */
+            function isSolelyIdentifierDefinitionLocation(contextToken) {
+                var containingNodeKind = contextToken.parent.kind;
+                switch (contextToken.kind) {
+                    case 24 /* CommaToken */:
+                        return containingNodeKind === 218 /* VariableDeclaration */ ||
+                            containingNodeKind === 219 /* VariableDeclarationList */ ||
+                            containingNodeKind === 200 /* VariableStatement */ ||
+                            containingNodeKind === 224 /* EnumDeclaration */ ||
+                            isFunction(containingNodeKind) ||
+                            containingNodeKind === 221 /* ClassDeclaration */ ||
+                            containingNodeKind === 192 /* ClassExpression */ ||
+                            containingNodeKind === 222 /* InterfaceDeclaration */ ||
+                            containingNodeKind === 168 /* ArrayBindingPattern */ ||
+                            containingNodeKind === 223 /* TypeAliasDeclaration */; // type Map, K, |
+                    case 21 /* DotToken */:
+                        return containingNodeKind === 168 /* ArrayBindingPattern */; // var [.|
+                    case 54 /* ColonToken */:
+                        return containingNodeKind === 169 /* BindingElement */; // var {x :html|
+                    case 19 /* OpenBracketToken */:
+                        return containingNodeKind === 168 /* ArrayBindingPattern */; // var [x|
+                    case 17 /* OpenParenToken */:
+                        return containingNodeKind === 252 /* CatchClause */ ||
+                            isFunction(containingNodeKind);
+                    case 15 /* OpenBraceToken */:
+                        return containingNodeKind === 224 /* EnumDeclaration */ ||
+                            containingNodeKind === 222 /* InterfaceDeclaration */ ||
+                            containingNodeKind === 159 /* TypeLiteral */; // const x : { |
+                    case 23 /* SemicolonToken */:
+                        return containingNodeKind === 144 /* PropertySignature */ &&
+                            contextToken.parent && contextToken.parent.parent &&
+                            (contextToken.parent.parent.kind === 222 /* InterfaceDeclaration */ ||
+                                contextToken.parent.parent.kind === 159 /* TypeLiteral */); // const x : { a; |
+                    case 25 /* LessThanToken */:
+                        return containingNodeKind === 221 /* ClassDeclaration */ ||
+                            containingNodeKind === 192 /* ClassExpression */ ||
+                            containingNodeKind === 222 /* InterfaceDeclaration */ ||
+                            containingNodeKind === 223 /* TypeAliasDeclaration */ ||
+                            isFunction(containingNodeKind);
+                    case 113 /* StaticKeyword */:
+                        return containingNodeKind === 145 /* PropertyDeclaration */;
+                    case 22 /* DotDotDotToken */:
+                        return containingNodeKind === 142 /* Parameter */ ||
+                            (contextToken.parent && contextToken.parent.parent &&
+                                contextToken.parent.parent.kind === 168 /* ArrayBindingPattern */); // var [...z|
+                    case 112 /* PublicKeyword */:
+                    case 110 /* PrivateKeyword */:
+                    case 111 /* ProtectedKeyword */:
+                        return containingNodeKind === 142 /* Parameter */;
+                    case 116 /* AsKeyword */:
+                        return containingNodeKind === 234 /* ImportSpecifier */ ||
+                            containingNodeKind === 238 /* ExportSpecifier */ ||
+                            containingNodeKind === 232 /* NamespaceImport */;
+                    case 73 /* ClassKeyword */:
+                    case 81 /* EnumKeyword */:
+                    case 107 /* InterfaceKeyword */:
+                    case 87 /* FunctionKeyword */:
+                    case 102 /* VarKeyword */:
+                    case 123 /* GetKeyword */:
+                    case 131 /* SetKeyword */:
+                    case 89 /* ImportKeyword */:
+                    case 108 /* LetKeyword */:
+                    case 74 /* ConstKeyword */:
+                    case 114 /* YieldKeyword */:
+                    case 134 /* TypeKeyword */:
+                        return true;
+                }
+                // Previous token may have been a keyword that was converted to an identifier.
+                switch (contextToken.getText()) {
+                    case "abstract":
+                    case "async":
+                    case "class":
+                    case "const":
+                    case "declare":
+                    case "enum":
+                    case "function":
+                    case "interface":
+                    case "let":
+                    case "private":
+                    case "protected":
+                    case "public":
+                    case "static":
+                    case "var":
+                    case "yield":
+                        return true;
+                }
+                return false;
+            }
+            function isDotOfNumericLiteral(contextToken) {
+                if (contextToken.kind === 8 /* NumericLiteral */) {
+                    var text = contextToken.getFullText();
+                    return text.charAt(text.length - 1) === ".";
+                }
+                return false;
+            }
+            /**
+             * Filters out completion suggestions for named imports or exports.
+             *
+             * @param exportsOfModule          The list of symbols which a module exposes.
+             * @param namedImportsOrExports    The list of existing import/export specifiers in the import/export clause.
+             *
+             * @returns Symbols to be suggested at an import/export clause, barring those whose named imports/exports
+             *          do not occur at the current position and have not otherwise been typed.
+             */
+            function filterNamedImportOrExportCompletionItems(exportsOfModule, namedImportsOrExports) {
+                var existingImportsOrExports = {};
+                for (var _i = 0, namedImportsOrExports_1 = namedImportsOrExports; _i < namedImportsOrExports_1.length; _i++) {
+                    var element = namedImportsOrExports_1[_i];
+                    // If this is the current item we are editing right now, do not filter it out
+                    if (element.getStart() <= position && position <= element.getEnd()) {
+                        continue;
+                    }
+                    var name_41 = element.propertyName || element.name;
+                    existingImportsOrExports[name_41.text] = true;
+                }
+                if (ts.isEmpty(existingImportsOrExports)) {
+                    return ts.filter(exportsOfModule, function (e) { return e.name !== "default"; });
+                }
+                return ts.filter(exportsOfModule, function (e) { return e.name !== "default" && !ts.lookUp(existingImportsOrExports, e.name); });
+            }
+            /**
+             * Filters out completion suggestions for named imports or exports.
+             *
+             * @returns Symbols to be suggested in an object binding pattern or object literal expression, barring those whose declarations
+             *          do not occur at the current position and have not otherwise been typed.
+             */
+            function filterObjectMembersList(contextualMemberSymbols, existingMembers) {
+                if (!existingMembers || existingMembers.length === 0) {
+                    return contextualMemberSymbols;
+                }
+                var existingMemberNames = {};
+                for (var _i = 0, existingMembers_1 = existingMembers; _i < existingMembers_1.length; _i++) {
+                    var m = existingMembers_1[_i];
+                    // Ignore omitted expressions for missing members
+                    if (m.kind !== 253 /* PropertyAssignment */ &&
+                        m.kind !== 254 /* ShorthandPropertyAssignment */ &&
+                        m.kind !== 169 /* BindingElement */ &&
+                        m.kind !== 147 /* MethodDeclaration */) {
+                        continue;
+                    }
+                    // If this is the current item we are editing right now, do not filter it out
+                    if (m.getStart() <= position && position <= m.getEnd()) {
+                        continue;
+                    }
+                    var existingName = void 0;
+                    if (m.kind === 169 /* BindingElement */ && m.propertyName) {
+                        // include only identifiers in completion list
+                        if (m.propertyName.kind === 69 /* Identifier */) {
+                            existingName = m.propertyName.text;
+                        }
+                    }
+                    else {
+                        // TODO(jfreeman): Account for computed property name
+                        // NOTE: if one only performs this step when m.name is an identifier,
+                        // things like '__proto__' are not filtered out.
+                        existingName = m.name.text;
+                    }
+                    existingMemberNames[existingName] = true;
+                }
+                return ts.filter(contextualMemberSymbols, function (m) { return !ts.lookUp(existingMemberNames, m.name); });
+            }
+            /**
+             * Filters out completion suggestions from 'symbols' according to existing JSX attributes.
+             *
+             * @returns Symbols to be suggested in a JSX element, barring those whose attributes
+             *          do not occur at the current position and have not otherwise been typed.
+             */
+            function filterJsxAttributes(symbols, attributes) {
+                var seenNames = {};
+                for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+                    var attr = attributes_1[_i];
+                    // If this is the current item we are editing right now, do not filter it out
+                    if (attr.getStart() <= position && position <= attr.getEnd()) {
+                        continue;
+                    }
+                    if (attr.kind === 246 /* JsxAttribute */) {
+                        seenNames[attr.name.text] = true;
+                    }
+                }
+                return ts.filter(symbols, function (a) { return !ts.lookUp(seenNames, a.name); });
+            }
+        }
+        function getCompletionsAtPosition(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            if (ts.isInString(sourceFile, position)) {
+                return getStringLiteralCompletionEntries(sourceFile, position);
+            }
+            var completionData = getCompletionData(fileName, position);
+            if (!completionData) {
+                return undefined;
+            }
+            var symbols = completionData.symbols, isMemberCompletion = completionData.isMemberCompletion, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, isJsDocTagName = completionData.isJsDocTagName;
+            if (isJsDocTagName) {
+                // If the current position is a jsDoc tag name, only tag names should be provided for completion
+                return { isMemberCompletion: false, isNewIdentifierLocation: false, entries: getAllJsDocCompletionEntries() };
+            }
+            var entries = [];
+            if (ts.isSourceFileJavaScript(sourceFile)) {
+                var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ false);
+                ts.addRange(entries, getJavaScriptCompletionEntries(sourceFile, location.pos, uniqueNames));
+            }
+            else {
+                if (!symbols || symbols.length === 0) {
+                    if (sourceFile.languageVariant === 1 /* JSX */ &&
+                        location.parent && location.parent.kind === 245 /* JsxClosingElement */) {
+                        // In the TypeScript JSX element, if such element is not defined. When users query for completion at closing tag,
+                        // instead of simply giving unknown value, the completion will return the tag-name of an associated opening-element.
+                        // For example:
+                        //     var x = <div> </ /*1*/>  completion list at "1" will contain "div" with type any
+                        var tagName = location.parent.parent.openingElement.tagName;
+                        entries.push({
+                            name: tagName.text,
+                            kind: undefined,
+                            kindModifiers: undefined,
+                            sortText: "0"
+                        });
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true);
+            }
+            // Add keywords if this is not a member completion list
+            if (!isMemberCompletion && !isJsDocTagName) {
+                ts.addRange(entries, keywordCompletions);
+            }
+            return { isMemberCompletion: isMemberCompletion, isNewIdentifierLocation: isNewIdentifierLocation, entries: entries };
+            function getJavaScriptCompletionEntries(sourceFile, position, uniqueNames) {
+                var entries = [];
+                var target = program.getCompilerOptions().target;
+                var nameTable = getNameTable(sourceFile);
+                for (var name_42 in nameTable) {
+                    // Skip identifiers produced only from the current location
+                    if (nameTable[name_42] === position) {
+                        continue;
+                    }
+                    if (!uniqueNames[name_42]) {
+                        uniqueNames[name_42] = name_42;
+                        var displayName = getCompletionEntryDisplayName(ts.unescapeIdentifier(name_42), target, /*performCharacterChecks*/ true);
+                        if (displayName) {
+                            var entry = {
+                                name: displayName,
+                                kind: ScriptElementKind.warning,
+                                kindModifiers: "",
+                                sortText: "1"
+                            };
+                            entries.push(entry);
+                        }
+                    }
+                }
+                return entries;
+            }
+            function getAllJsDocCompletionEntries() {
+                return jsDocCompletionEntries || (jsDocCompletionEntries = ts.map(jsDocTagNames, function (tagName) {
+                    return {
+                        name: tagName,
+                        kind: ScriptElementKind.keyword,
+                        kindModifiers: "",
+                        sortText: "0"
+                    };
+                }));
+            }
+            function createCompletionEntry(symbol, location, performCharacterChecks) {
+                // Try to get a valid display name for this symbol, if we could not find one, then ignore it.
+                // We would like to only show things that can be added after a dot, so for instance numeric properties can
+                // not be accessed with a dot (a.1 <- invalid)
+                var displayName = getCompletionEntryDisplayNameForSymbol(symbol, program.getCompilerOptions().target, performCharacterChecks, location);
+                if (!displayName) {
+                    return undefined;
+                }
+                // TODO(drosen): Right now we just permit *all* semantic meanings when calling
+                // 'getSymbolKind' which is permissible given that it is backwards compatible; but
+                // really we should consider passing the meaning for the node so that we don't report
+                // that a suggestion for a value is an interface.  We COULD also just do what
+                // 'getSymbolModifiers' does, which is to use the first declaration.
+                // Use a 'sortText' of 0' so that all symbol completion entries come before any other
+                // entries (like JavaScript identifier entries).
+                return {
+                    name: displayName,
+                    kind: getSymbolKind(symbol, location),
+                    kindModifiers: getSymbolModifiers(symbol),
+                    sortText: "0"
+                };
+            }
+            function getCompletionEntriesFromSymbols(symbols, entries, location, performCharacterChecks) {
+                var start = new Date().getTime();
+                var uniqueNames = {};
+                if (symbols) {
+                    for (var _i = 0, symbols_4 = symbols; _i < symbols_4.length; _i++) {
+                        var symbol = symbols_4[_i];
+                        var entry = createCompletionEntry(symbol, location, performCharacterChecks);
+                        if (entry) {
+                            var id = ts.escapeIdentifier(entry.name);
+                            if (!ts.lookUp(uniqueNames, id)) {
+                                entries.push(entry);
+                                uniqueNames[id] = id;
+                            }
+                        }
+                    }
+                }
+                log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (new Date().getTime() - start));
+                return uniqueNames;
+            }
+            function getStringLiteralCompletionEntries(sourceFile, position) {
+                var node = ts.findPrecedingToken(position, sourceFile);
+                if (!node || node.kind !== 9 /* StringLiteral */) {
+                    return undefined;
+                }
+                var argumentInfo = ts.SignatureHelp.getContainingArgumentInfo(node, position, sourceFile);
+                if (argumentInfo) {
+                    // Get string literal completions from specialized signatures of the target
+                    return getStringLiteralCompletionEntriesFromCallExpression(argumentInfo);
+                }
+                else if (ts.isElementAccessExpression(node.parent) && node.parent.argumentExpression === node) {
+                    // Get all names of properties on the expression
+                    return getStringLiteralCompletionEntriesFromElementAccess(node.parent);
+                }
+                else {
+                    // Otherwise, get the completions from the contextual type if one exists
+                    return getStringLiteralCompletionEntriesFromContextualType(node);
+                }
+            }
+            function getStringLiteralCompletionEntriesFromCallExpression(argumentInfo) {
+                var typeChecker = program.getTypeChecker();
+                var candidates = [];
+                var entries = [];
+                typeChecker.getResolvedSignature(argumentInfo.invocation, candidates);
+                for (var _i = 0, candidates_3 = candidates; _i < candidates_3.length; _i++) {
+                    var candidate = candidates_3[_i];
+                    if (candidate.parameters.length > argumentInfo.argumentIndex) {
+                        var parameter = candidate.parameters[argumentInfo.argumentIndex];
+                        addStringLiteralCompletionsFromType(typeChecker.getTypeAtLocation(parameter.valueDeclaration), entries);
+                    }
+                }
+                if (entries.length) {
+                    return { isMemberCompletion: false, isNewIdentifierLocation: true, entries: entries };
+                }
+                return undefined;
+            }
+            function getStringLiteralCompletionEntriesFromElementAccess(node) {
+                var typeChecker = program.getTypeChecker();
+                var type = typeChecker.getTypeAtLocation(node.expression);
+                var entries = [];
+                if (type) {
+                    getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, node, /*performCharacterChecks*/ false);
+                    if (entries.length) {
+                        return { isMemberCompletion: true, isNewIdentifierLocation: true, entries: entries };
+                    }
+                }
+                return undefined;
+            }
+            function getStringLiteralCompletionEntriesFromContextualType(node) {
+                var typeChecker = program.getTypeChecker();
+                var type = typeChecker.getContextualType(node);
+                if (type) {
+                    var entries_2 = [];
+                    addStringLiteralCompletionsFromType(type, entries_2);
+                    if (entries_2.length) {
+                        return { isMemberCompletion: false, isNewIdentifierLocation: false, entries: entries_2 };
+                    }
+                }
+                return undefined;
+            }
+            function addStringLiteralCompletionsFromType(type, result) {
+                if (!type) {
+                    return;
+                }
+                if (type.flags & 16384 /* Union */) {
+                    ts.forEach(type.types, function (t) { return addStringLiteralCompletionsFromType(t, result); });
+                }
+                else {
+                    if (type.flags & 256 /* StringLiteral */) {
+                        result.push({
+                            name: type.text,
+                            kindModifiers: ScriptElementKindModifier.none,
+                            kind: ScriptElementKind.variableElement,
+                            sortText: "0"
+                        });
+                    }
+                }
+            }
+        }
+        function getCompletionEntryDetails(fileName, position, entryName) {
+            synchronizeHostData();
+            // Compute all the completion symbols again.
+            var completionData = getCompletionData(fileName, position);
+            if (completionData) {
+                var symbols = completionData.symbols, location_2 = completionData.location;
+                // Find the symbol with the matching entry name.
+                var target_2 = program.getCompilerOptions().target;
+                // We don't need to perform character checks here because we're only comparing the
+                // name against 'entryName' (which is known to be good), not building a new
+                // completion entry.
+                var symbol = ts.forEach(symbols, function (s) { return getCompletionEntryDisplayNameForSymbol(s, target_2, /*performCharacterChecks*/ false, location_2) === entryName ? s : undefined; });
+                if (symbol) {
+                    var _a = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location_2, location_2, 7 /* All */), displayParts = _a.displayParts, documentation = _a.documentation, symbolKind = _a.symbolKind;
+                    return {
+                        name: entryName,
+                        kindModifiers: getSymbolModifiers(symbol),
+                        kind: symbolKind,
+                        displayParts: displayParts,
+                        documentation: documentation
+                    };
+                }
+            }
+            // Didn't find a symbol with this name.  See if we can find a keyword instead.
+            var keywordCompletion = ts.forEach(keywordCompletions, function (c) { return c.name === entryName; });
+            if (keywordCompletion) {
+                return {
+                    name: entryName,
+                    kind: ScriptElementKind.keyword,
+                    kindModifiers: ScriptElementKindModifier.none,
+                    displayParts: [ts.displayPart(entryName, SymbolDisplayPartKind.keyword)],
+                    documentation: undefined
+                };
+            }
+            return undefined;
+        }
+        // TODO(drosen): use contextual SemanticMeaning.
+        function getSymbolKind(symbol, location) {
+            var flags = symbol.getFlags();
+            if (flags & 32 /* Class */)
+                return ts.getDeclarationOfKind(symbol, 192 /* ClassExpression */) ?
+                    ScriptElementKind.localClassElement : ScriptElementKind.classElement;
+            if (flags & 384 /* Enum */)
+                return ScriptElementKind.enumElement;
+            if (flags & 524288 /* TypeAlias */)
+                return ScriptElementKind.typeElement;
+            if (flags & 64 /* Interface */)
+                return ScriptElementKind.interfaceElement;
+            if (flags & 262144 /* TypeParameter */)
+                return ScriptElementKind.typeParameterElement;
+            var result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, flags, location);
+            if (result === ScriptElementKind.unknown) {
+                if (flags & 262144 /* TypeParameter */)
+                    return ScriptElementKind.typeParameterElement;
+                if (flags & 8 /* EnumMember */)
+                    return ScriptElementKind.variableElement;
+                if (flags & 8388608 /* Alias */)
+                    return ScriptElementKind.alias;
+                if (flags & 1536 /* Module */)
+                    return ScriptElementKind.moduleElement;
+            }
+            return result;
+        }
+        function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, flags, location) {
+            var typeChecker = program.getTypeChecker();
+            if (typeChecker.isUndefinedSymbol(symbol)) {
+                return ScriptElementKind.variableElement;
+            }
+            if (typeChecker.isArgumentsSymbol(symbol)) {
+                return ScriptElementKind.localVariableElement;
+            }
+            if (location.kind === 97 /* ThisKeyword */ && ts.isExpression(location)) {
+                return ScriptElementKind.parameterElement;
+            }
+            if (flags & 3 /* Variable */) {
+                if (ts.isFirstDeclarationOfSymbolParameter(symbol)) {
+                    return ScriptElementKind.parameterElement;
+                }
+                else if (symbol.valueDeclaration && ts.isConst(symbol.valueDeclaration)) {
+                    return ScriptElementKind.constElement;
+                }
+                else if (ts.forEach(symbol.declarations, ts.isLet)) {
+                    return ScriptElementKind.letElement;
+                }
+                return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
+            }
+            if (flags & 16 /* Function */)
+                return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement;
+            if (flags & 32768 /* GetAccessor */)
+                return ScriptElementKind.memberGetAccessorElement;
+            if (flags & 65536 /* SetAccessor */)
+                return ScriptElementKind.memberSetAccessorElement;
+            if (flags & 8192 /* Method */)
+                return ScriptElementKind.memberFunctionElement;
+            if (flags & 16384 /* Constructor */)
+                return ScriptElementKind.constructorImplementationElement;
+            if (flags & 4 /* Property */) {
+                if (flags & 268435456 /* SyntheticProperty */) {
+                    // If union property is result of union of non method (property/accessors/variables), it is labeled as property
+                    var unionPropertyKind = ts.forEach(typeChecker.getRootSymbols(symbol), function (rootSymbol) {
+                        var rootSymbolFlags = rootSymbol.getFlags();
+                        if (rootSymbolFlags & (98308 /* PropertyOrAccessor */ | 3 /* Variable */)) {
+                            return ScriptElementKind.memberVariableElement;
+                        }
+                        ts.Debug.assert(!!(rootSymbolFlags & 8192 /* Method */));
+                    });
+                    if (!unionPropertyKind) {
+                        // If this was union of all methods,
+                        // make sure it has call signatures before we can label it as method
+                        var typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                        if (typeOfUnionProperty.getCallSignatures().length) {
+                            return ScriptElementKind.memberFunctionElement;
+                        }
+                        return ScriptElementKind.memberVariableElement;
+                    }
+                    return unionPropertyKind;
+                }
+                return ScriptElementKind.memberVariableElement;
+            }
+            return ScriptElementKind.unknown;
+        }
+        function getSymbolModifiers(symbol) {
+            return symbol && symbol.declarations && symbol.declarations.length > 0
+                ? ts.getNodeModifiers(symbol.declarations[0])
+                : ScriptElementKindModifier.none;
+        }
+        // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location
+        function getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, sourceFile, enclosingDeclaration, location, semanticMeaning) {
+            if (semanticMeaning === void 0) { semanticMeaning = getMeaningFromLocation(location); }
+            var typeChecker = program.getTypeChecker();
+            var displayParts = [];
+            var documentation;
+            var symbolFlags = symbol.flags;
+            var symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, location);
+            var hasAddedSymbolInfo;
+            var isThisExpression = location.kind === 97 /* ThisKeyword */ && ts.isExpression(location);
+            var type;
+            // Class at constructor site need to be shown as constructor apart from property,method, vars
+            if (symbolKind !== ScriptElementKind.unknown || symbolFlags & 32 /* Class */ || symbolFlags & 8388608 /* Alias */) {
+                // If it is accessor they are allowed only if location is at name of the accessor
+                if (symbolKind === ScriptElementKind.memberGetAccessorElement || symbolKind === ScriptElementKind.memberSetAccessorElement) {
+                    symbolKind = ScriptElementKind.memberVariableElement;
+                }
+                var signature = void 0;
+                type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                if (type) {
+                    if (location.parent && location.parent.kind === 172 /* PropertyAccessExpression */) {
+                        var right = location.parent.name;
+                        // Either the location is on the right of a property access, or on the left and the right is missing
+                        if (right === location || (right && right.getFullWidth() === 0)) {
+                            location = location.parent;
+                        }
+                    }
+                    // try get the call/construct signature from the type if it matches
+                    var callExpression = void 0;
+                    if (location.kind === 174 /* CallExpression */ || location.kind === 175 /* NewExpression */) {
+                        callExpression = location;
+                    }
+                    else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) {
+                        callExpression = location.parent;
+                    }
+                    if (callExpression) {
+                        var candidateSignatures = [];
+                        signature = typeChecker.getResolvedSignature(callExpression, candidateSignatures);
+                        if (!signature && candidateSignatures.length) {
+                            // Use the first candidate:
+                            signature = candidateSignatures[0];
+                        }
+                        var useConstructSignatures = callExpression.kind === 175 /* NewExpression */ || callExpression.expression.kind === 95 /* SuperKeyword */;
+                        var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
+                        if (!ts.contains(allSignatures, signature.target) && !ts.contains(allSignatures, signature)) {
+                            // Get the first signature if there is one -- allSignatures may contain
+                            // either the original signature or its target, so check for either
+                            signature = allSignatures.length ? allSignatures[0] : undefined;
+                        }
+                        if (signature) {
+                            if (useConstructSignatures && (symbolFlags & 32 /* Class */)) {
+                                // Constructor
+                                symbolKind = ScriptElementKind.constructorImplementationElement;
+                                addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                            }
+                            else if (symbolFlags & 8388608 /* Alias */) {
+                                symbolKind = ScriptElementKind.alias;
+                                pushTypePart(symbolKind);
+                                displayParts.push(ts.spacePart());
+                                if (useConstructSignatures) {
+                                    displayParts.push(ts.keywordPart(92 /* NewKeyword */));
+                                    displayParts.push(ts.spacePart());
+                                }
+                                addFullSymbolName(symbol);
+                            }
+                            else {
+                                addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                            }
+                            switch (symbolKind) {
+                                case ScriptElementKind.memberVariableElement:
+                                case ScriptElementKind.variableElement:
+                                case ScriptElementKind.constElement:
+                                case ScriptElementKind.letElement:
+                                case ScriptElementKind.parameterElement:
+                                case ScriptElementKind.localVariableElement:
+                                    // If it is call or construct signature of lambda's write type name
+                                    displayParts.push(ts.punctuationPart(54 /* ColonToken */));
+                                    displayParts.push(ts.spacePart());
+                                    if (useConstructSignatures) {
+                                        displayParts.push(ts.keywordPart(92 /* NewKeyword */));
+                                        displayParts.push(ts.spacePart());
+                                    }
+                                    if (!(type.flags & 65536 /* Anonymous */) && type.symbol) {
+                                        ts.addRange(displayParts, ts.symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, /*meaning*/ undefined, 1 /* WriteTypeParametersOrArguments */));
+                                    }
+                                    addSignatureDisplayParts(signature, allSignatures, 8 /* WriteArrowStyleSignature */);
+                                    break;
+                                default:
+                                    // Just signature
+                                    addSignatureDisplayParts(signature, allSignatures);
+                            }
+                            hasAddedSymbolInfo = true;
+                        }
+                    }
+                    else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304 /* Accessor */)) ||
+                        (location.kind === 121 /* ConstructorKeyword */ && location.parent.kind === 148 /* Constructor */)) {
+                        // get the signature from the declaration and write it
+                        var functionDeclaration = location.parent;
+                        var allSignatures = functionDeclaration.kind === 148 /* Constructor */ ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();
+                        if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {
+                            signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);
+                        }
+                        else {
+                            signature = allSignatures[0];
+                        }
+                        if (functionDeclaration.kind === 148 /* Constructor */) {
+                            // show (constructor) Type(...) signature
+                            symbolKind = ScriptElementKind.constructorImplementationElement;
+                            addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                        }
+                        else {
+                            // (function/method) symbol(..signature)
+                            addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 151 /* CallSignature */ &&
+                                !(type.symbol.flags & 2048 /* TypeLiteral */ || type.symbol.flags & 4096 /* ObjectLiteral */) ? type.symbol : symbol, symbolKind);
+                        }
+                        addSignatureDisplayParts(signature, allSignatures);
+                        hasAddedSymbolInfo = true;
+                    }
+                }
+            }
+            if (symbolFlags & 32 /* Class */ && !hasAddedSymbolInfo && !isThisExpression) {
+                if (ts.getDeclarationOfKind(symbol, 192 /* ClassExpression */)) {
+                    // Special case for class expressions because we would like to indicate that
+                    // the class name is local to the class body (similar to function expression)
+                    //      (local class) class <className>
+                    pushTypePart(ScriptElementKind.localClassElement);
+                }
+                else {
+                    // Class declaration has name which is not local.
+                    displayParts.push(ts.keywordPart(73 /* ClassKeyword */));
+                }
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+                writeTypeParametersOfSymbol(symbol, sourceFile);
+            }
+            if ((symbolFlags & 64 /* Interface */) && (semanticMeaning & 2 /* Type */)) {
+                addNewLineIfDisplayPartsExist();
+                displayParts.push(ts.keywordPart(107 /* InterfaceKeyword */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+                writeTypeParametersOfSymbol(symbol, sourceFile);
+            }
+            if (symbolFlags & 524288 /* TypeAlias */) {
+                addNewLineIfDisplayPartsExist();
+                displayParts.push(ts.keywordPart(134 /* TypeKeyword */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+                writeTypeParametersOfSymbol(symbol, sourceFile);
+                displayParts.push(ts.spacePart());
+                displayParts.push(ts.operatorPart(56 /* EqualsToken */));
+                displayParts.push(ts.spacePart());
+                ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration));
+            }
+            if (symbolFlags & 384 /* Enum */) {
+                addNewLineIfDisplayPartsExist();
+                if (ts.forEach(symbol.declarations, ts.isConstEnumDeclaration)) {
+                    displayParts.push(ts.keywordPart(74 /* ConstKeyword */));
+                    displayParts.push(ts.spacePart());
+                }
+                displayParts.push(ts.keywordPart(81 /* EnumKeyword */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+            }
+            if (symbolFlags & 1536 /* Module */) {
+                addNewLineIfDisplayPartsExist();
+                var declaration = ts.getDeclarationOfKind(symbol, 225 /* ModuleDeclaration */);
+                var isNamespace = declaration && declaration.name && declaration.name.kind === 69 /* Identifier */;
+                displayParts.push(ts.keywordPart(isNamespace ? 126 /* NamespaceKeyword */ : 125 /* ModuleKeyword */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+            }
+            if ((symbolFlags & 262144 /* TypeParameter */) && (semanticMeaning & 2 /* Type */)) {
+                addNewLineIfDisplayPartsExist();
+                displayParts.push(ts.punctuationPart(17 /* OpenParenToken */));
+                displayParts.push(ts.textPart("type parameter"));
+                displayParts.push(ts.punctuationPart(18 /* CloseParenToken */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+                displayParts.push(ts.spacePart());
+                displayParts.push(ts.keywordPart(90 /* InKeyword */));
+                displayParts.push(ts.spacePart());
+                if (symbol.parent) {
+                    // Class/Interface type parameter
+                    addFullSymbolName(symbol.parent, enclosingDeclaration);
+                    writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration);
+                }
+                else {
+                    // Method/function type parameter
+                    var declaration = ts.getDeclarationOfKind(symbol, 141 /* TypeParameter */);
+                    ts.Debug.assert(declaration !== undefined);
+                    declaration = declaration.parent;
+                    if (declaration) {
+                        if (ts.isFunctionLikeKind(declaration.kind)) {
+                            var signature = typeChecker.getSignatureFromDeclaration(declaration);
+                            if (declaration.kind === 152 /* ConstructSignature */) {
+                                displayParts.push(ts.keywordPart(92 /* NewKeyword */));
+                                displayParts.push(ts.spacePart());
+                            }
+                            else if (declaration.kind !== 151 /* CallSignature */ && declaration.name) {
+                                addFullSymbolName(declaration.symbol);
+                            }
+                            ts.addRange(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* WriteTypeArgumentsOfSignature */));
+                        }
+                        else {
+                            // Type alias type parameter
+                            // For example
+                            //      type list<T> = T[];  // Both T will go through same code path
+                            displayParts.push(ts.keywordPart(134 /* TypeKeyword */));
+                            displayParts.push(ts.spacePart());
+                            addFullSymbolName(declaration.symbol);
+                            writeTypeParametersOfSymbol(declaration.symbol, sourceFile);
+                        }
+                    }
+                }
+            }
+            if (symbolFlags & 8 /* EnumMember */) {
+                addPrefixForAnyFunctionOrVar(symbol, "enum member");
+                var declaration = symbol.declarations[0];
+                if (declaration.kind === 255 /* EnumMember */) {
+                    var constantValue = typeChecker.getConstantValue(declaration);
+                    if (constantValue !== undefined) {
+                        displayParts.push(ts.spacePart());
+                        displayParts.push(ts.operatorPart(56 /* EqualsToken */));
+                        displayParts.push(ts.spacePart());
+                        displayParts.push(ts.displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
+                    }
+                }
+            }
+            if (symbolFlags & 8388608 /* Alias */) {
+                addNewLineIfDisplayPartsExist();
+                displayParts.push(ts.keywordPart(89 /* ImportKeyword */));
+                displayParts.push(ts.spacePart());
+                addFullSymbolName(symbol);
+                ts.forEach(symbol.declarations, function (declaration) {
+                    if (declaration.kind === 229 /* ImportEqualsDeclaration */) {
+                        var importEqualsDeclaration = declaration;
+                        if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) {
+                            displayParts.push(ts.spacePart());
+                            displayParts.push(ts.operatorPart(56 /* EqualsToken */));
+                            displayParts.push(ts.spacePart());
+                            displayParts.push(ts.keywordPart(129 /* RequireKeyword */));
+                            displayParts.push(ts.punctuationPart(17 /* OpenParenToken */));
+                            displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral));
+                            displayParts.push(ts.punctuationPart(18 /* CloseParenToken */));
+                        }
+                        else {
+                            var internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference);
+                            if (internalAliasSymbol) {
+                                displayParts.push(ts.spacePart());
+                                displayParts.push(ts.operatorPart(56 /* EqualsToken */));
+                                displayParts.push(ts.spacePart());
+                                addFullSymbolName(internalAliasSymbol, enclosingDeclaration);
+                            }
+                        }
+                        return true;
+                    }
+                });
+            }
+            if (!hasAddedSymbolInfo) {
+                if (symbolKind !== ScriptElementKind.unknown) {
+                    if (type) {
+                        if (isThisExpression) {
+                            addNewLineIfDisplayPartsExist();
+                            displayParts.push(ts.keywordPart(97 /* ThisKeyword */));
+                        }
+                        else {
+                            addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                        }
+                        // For properties, variables and local vars: show the type
+                        if (symbolKind === ScriptElementKind.memberVariableElement ||
+                            symbolFlags & 3 /* Variable */ ||
+                            symbolKind === ScriptElementKind.localVariableElement ||
+                            isThisExpression) {
+                            displayParts.push(ts.punctuationPart(54 /* ColonToken */));
+                            displayParts.push(ts.spacePart());
+                            // If the type is type parameter, format it specially
+                            if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */) {
+                                var typeParameterParts = ts.mapToDisplayParts(function (writer) {
+                                    typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(type, writer, enclosingDeclaration);
+                                });
+                                ts.addRange(displayParts, typeParameterParts);
+                            }
+                            else {
+                                ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, type, enclosingDeclaration));
+                            }
+                        }
+                        else if (symbolFlags & 16 /* Function */ ||
+                            symbolFlags & 8192 /* Method */ ||
+                            symbolFlags & 16384 /* Constructor */ ||
+                            symbolFlags & 131072 /* Signature */ ||
+                            symbolFlags & 98304 /* Accessor */ ||
+                            symbolKind === ScriptElementKind.memberFunctionElement) {
+                            var allSignatures = type.getNonNullableType().getCallSignatures();
+                            addSignatureDisplayParts(allSignatures[0], allSignatures);
+                        }
+                    }
+                }
+                else {
+                    symbolKind = getSymbolKind(symbol, location);
+                }
+            }
+            if (!documentation) {
+                documentation = symbol.getDocumentationComment();
+            }
+            return { displayParts: displayParts, documentation: documentation, symbolKind: symbolKind };
+            function addNewLineIfDisplayPartsExist() {
+                if (displayParts.length) {
+                    displayParts.push(ts.lineBreakPart());
+                }
+            }
+            function addFullSymbolName(symbol, enclosingDeclaration) {
+                var fullSymbolDisplayParts = ts.symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, /*meaning*/ undefined, 1 /* WriteTypeParametersOrArguments */ | 2 /* UseOnlyExternalAliasing */);
+                ts.addRange(displayParts, fullSymbolDisplayParts);
+            }
+            function addPrefixForAnyFunctionOrVar(symbol, symbolKind) {
+                addNewLineIfDisplayPartsExist();
+                if (symbolKind) {
+                    pushTypePart(symbolKind);
+                    displayParts.push(ts.spacePart());
+                    addFullSymbolName(symbol);
+                }
+            }
+            function pushTypePart(symbolKind) {
+                switch (symbolKind) {
+                    case ScriptElementKind.variableElement:
+                    case ScriptElementKind.functionElement:
+                    case ScriptElementKind.letElement:
+                    case ScriptElementKind.constElement:
+                    case ScriptElementKind.constructorImplementationElement:
+                        displayParts.push(ts.textOrKeywordPart(symbolKind));
+                        return;
+                    default:
+                        displayParts.push(ts.punctuationPart(17 /* OpenParenToken */));
+                        displayParts.push(ts.textOrKeywordPart(symbolKind));
+                        displayParts.push(ts.punctuationPart(18 /* CloseParenToken */));
+                        return;
+                }
+            }
+            function addSignatureDisplayParts(signature, allSignatures, flags) {
+                ts.addRange(displayParts, ts.signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* WriteTypeArgumentsOfSignature */));
+                if (allSignatures.length > 1) {
+                    displayParts.push(ts.spacePart());
+                    displayParts.push(ts.punctuationPart(17 /* OpenParenToken */));
+                    displayParts.push(ts.operatorPart(35 /* PlusToken */));
+                    displayParts.push(ts.displayPart((allSignatures.length - 1).toString(), SymbolDisplayPartKind.numericLiteral));
+                    displayParts.push(ts.spacePart());
+                    displayParts.push(ts.textPart(allSignatures.length === 2 ? "overload" : "overloads"));
+                    displayParts.push(ts.punctuationPart(18 /* CloseParenToken */));
+                }
+                documentation = signature.getDocumentationComment();
+            }
+            function writeTypeParametersOfSymbol(symbol, enclosingDeclaration) {
+                var typeParameterParts = ts.mapToDisplayParts(function (writer) {
+                    typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration);
+                });
+                ts.addRange(displayParts, typeParameterParts);
+            }
+        }
+        function getQuickInfoAtPosition(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var node = ts.getTouchingPropertyName(sourceFile, position);
+            if (node === sourceFile) {
+                return undefined;
+            }
+            if (isLabelName(node)) {
+                return undefined;
+            }
+            var typeChecker = program.getTypeChecker();
+            var symbol = typeChecker.getSymbolAtLocation(node);
+            if (!symbol || typeChecker.isUnknownSymbol(symbol)) {
+                // Try getting just type at this position and show
+                switch (node.kind) {
+                    case 69 /* Identifier */:
+                    case 172 /* PropertyAccessExpression */:
+                    case 139 /* QualifiedName */:
+                    case 97 /* ThisKeyword */:
+                    case 165 /* ThisType */:
+                    case 95 /* SuperKeyword */:
+                        // For the identifiers/this/super etc get the type at position
+                        var type = typeChecker.getTypeAtLocation(node);
+                        if (type) {
+                            return {
+                                kind: ScriptElementKind.unknown,
+                                kindModifiers: ScriptElementKindModifier.none,
+                                textSpan: ts.createTextSpan(node.getStart(), node.getWidth()),
+                                displayParts: ts.typeToDisplayParts(typeChecker, type, getContainerNode(node)),
+                                documentation: type.symbol ? type.symbol.getDocumentationComment() : undefined
+                            };
+                        }
+                }
+                return undefined;
+            }
+            var displayPartsDocumentationsAndKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, sourceFile, getContainerNode(node), node);
+            return {
+                kind: displayPartsDocumentationsAndKind.symbolKind,
+                kindModifiers: getSymbolModifiers(symbol),
+                textSpan: ts.createTextSpan(node.getStart(), node.getWidth()),
+                displayParts: displayPartsDocumentationsAndKind.displayParts,
+                documentation: displayPartsDocumentationsAndKind.documentation
+            };
+        }
+        function createDefinitionInfo(node, symbolKind, symbolName, containerName) {
+            return {
+                fileName: node.getSourceFile().fileName,
+                textSpan: ts.createTextSpanFromBounds(node.getStart(), node.getEnd()),
+                kind: symbolKind,
+                name: symbolName,
+                containerKind: undefined,
+                containerName: containerName
+            };
+        }
+        function getDefinitionFromSymbol(symbol, node) {
+            var typeChecker = program.getTypeChecker();
+            var result = [];
+            var declarations = symbol.getDeclarations();
+            var symbolName = typeChecker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol
+            var symbolKind = getSymbolKind(symbol, node);
+            var containerSymbol = symbol.parent;
+            var containerName = containerSymbol ? typeChecker.symbolToString(containerSymbol, node) : "";
+            if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) &&
+                !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) {
+                // Just add all the declarations.
+                ts.forEach(declarations, function (declaration) {
+                    result.push(createDefinitionInfo(declaration, symbolKind, symbolName, containerName));
+                });
+            }
+            return result;
+            function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) {
+                // Applicable only if we are in a new expression, or we are on a constructor declaration
+                // and in either case the symbol has a construct signature definition, i.e. class
+                if (isNewExpressionTarget(location) || location.kind === 121 /* ConstructorKeyword */) {
+                    if (symbol.flags & 32 /* Class */) {
+                        // Find the first class-like declaration and try to get the construct signature.
+                        for (var _i = 0, _a = symbol.getDeclarations(); _i < _a.length; _i++) {
+                            var declaration = _a[_i];
+                            if (ts.isClassLike(declaration)) {
+                                return tryAddSignature(declaration.members, 
+                                /*selectConstructors*/ true, symbolKind, symbolName, containerName, result);
+                            }
+                        }
+                        ts.Debug.fail("Expected declaration to have at least one class-like declaration");
+                    }
+                }
+                return false;
+            }
+            function tryAddCallSignature(symbol, location, symbolKind, symbolName, containerName, result) {
+                if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) {
+                    return tryAddSignature(symbol.declarations, /*selectConstructors*/ false, symbolKind, symbolName, containerName, result);
+                }
+                return false;
+            }
+            function tryAddSignature(signatureDeclarations, selectConstructors, symbolKind, symbolName, containerName, result) {
+                var declarations = [];
+                var definition;
+                ts.forEach(signatureDeclarations, function (d) {
+                    if ((selectConstructors && d.kind === 148 /* Constructor */) ||
+                        (!selectConstructors && (d.kind === 220 /* FunctionDeclaration */ || d.kind === 147 /* MethodDeclaration */ || d.kind === 146 /* MethodSignature */))) {
+                        declarations.push(d);
+                        if (d.body)
+                            definition = d;
+                    }
+                });
+                if (definition) {
+                    result.push(createDefinitionInfo(definition, symbolKind, symbolName, containerName));
+                    return true;
+                }
+                else if (declarations.length) {
+                    result.push(createDefinitionInfo(ts.lastOrUndefined(declarations), symbolKind, symbolName, containerName));
+                    return true;
+                }
+                return false;
+            }
+        }
+        function findReferenceInPosition(refs, pos) {
+            for (var _i = 0, refs_1 = refs; _i < refs_1.length; _i++) {
+                var ref = refs_1[_i];
+                if (ref.pos <= pos && pos < ref.end) {
+                    return ref;
+                }
+            }
+            return undefined;
+        }
+        function getDefinitionInfoForFileReference(name, targetFileName) {
+            return {
+                fileName: targetFileName,
+                textSpan: ts.createTextSpanFromBounds(0, 0),
+                kind: ScriptElementKind.scriptElement,
+                name: name,
+                containerName: undefined,
+                containerKind: undefined
+            };
+        }
+        /// Goto definition
+        function getDefinitionAtPosition(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            /// Triple slash reference comments
+            var comment = findReferenceInPosition(sourceFile.referencedFiles, position);
+            if (comment) {
+                var referenceFile = ts.tryResolveScriptReference(program, sourceFile, comment);
+                if (referenceFile) {
+                    return [getDefinitionInfoForFileReference(comment.fileName, referenceFile.fileName)];
+                }
+                return undefined;
+            }
+            // Type reference directives
+            var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
+            if (typeReferenceDirective) {
+                var referenceFile = ts.lookUp(program.getResolvedTypeReferenceDirectives(), typeReferenceDirective.fileName);
+                if (referenceFile && referenceFile.resolvedFileName) {
+                    return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
+                }
+                return undefined;
+            }
+            var node = ts.getTouchingPropertyName(sourceFile, position);
+            if (node === sourceFile) {
+                return undefined;
+            }
+            // Labels
+            if (isJumpStatementTarget(node)) {
+                var labelName = node.text;
+                var label = getTargetLabel(node.parent, node.text);
+                return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, /*containerName*/ undefined)] : undefined;
+            }
+            var typeChecker = program.getTypeChecker();
+            var symbol = typeChecker.getSymbolAtLocation(node);
+            // Could not find a symbol e.g. node is string or number keyword,
+            // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
+            if (!symbol) {
+                return undefined;
+            }
+            // If this is an alias, and the request came at the declaration location
+            // get the aliased symbol instead. This allows for goto def on an import e.g.
+            //   import {A, B} from "mod";
+            // to jump to the implementation directly.
+            if (symbol.flags & 8388608 /* Alias */) {
+                var declaration = symbol.declarations[0];
+                // Go to the original declaration for cases:
+                //
+                //   (1) when the aliased symbol was declared in the location(parent).
+                //   (2) when the aliased symbol is originating from a named import.
+                //
+                if (node.kind === 69 /* Identifier */ &&
+                    (node.parent === declaration ||
+                        (declaration.kind === 234 /* ImportSpecifier */ && declaration.parent && declaration.parent.kind === 233 /* NamedImports */))) {
+                    symbol = typeChecker.getAliasedSymbol(symbol);
+                }
+            }
+            // Because name in short-hand property assignment has two different meanings: property name and property value,
+            // using go-to-definition at such position should go to the variable declaration of the property value rather than
+            // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
+            // is performed at the location of property access, we would like to go to definition of the property in the short-hand
+            // assignment. This case and others are handled by the following code.
+            if (node.parent.kind === 254 /* ShorthandPropertyAssignment */) {
+                var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
+                if (!shorthandSymbol) {
+                    return [];
+                }
+                var shorthandDeclarations = shorthandSymbol.getDeclarations();
+                var shorthandSymbolKind_1 = getSymbolKind(shorthandSymbol, node);
+                var shorthandSymbolName_1 = typeChecker.symbolToString(shorthandSymbol);
+                var shorthandContainerName_1 = typeChecker.symbolToString(symbol.parent, node);
+                return ts.map(shorthandDeclarations, function (declaration) { return createDefinitionInfo(declaration, shorthandSymbolKind_1, shorthandSymbolName_1, shorthandContainerName_1); });
+            }
+            return getDefinitionFromSymbol(symbol, node);
+        }
+        /// Goto type
+        function getTypeDefinitionAtPosition(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var node = ts.getTouchingPropertyName(sourceFile, position);
+            if (node === sourceFile) {
+                return undefined;
+            }
+            var typeChecker = program.getTypeChecker();
+            var symbol = typeChecker.getSymbolAtLocation(node);
+            if (!symbol) {
+                return undefined;
+            }
+            var type = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+            if (!type) {
+                return undefined;
+            }
+            if (type.flags & 16384 /* Union */) {
+                var result_3 = [];
+                ts.forEach(type.types, function (t) {
+                    if (t.symbol) {
+                        ts.addRange(/*to*/ result_3, /*from*/ getDefinitionFromSymbol(t.symbol, node));
+                    }
+                });
+                return result_3;
+            }
+            if (!type.symbol) {
+                return undefined;
+            }
+            return getDefinitionFromSymbol(type.symbol, node);
+        }
+        function getOccurrencesAtPosition(fileName, position) {
+            var results = getOccurrencesAtPositionCore(fileName, position);
+            if (results) {
+                var sourceFile_1 = getCanonicalFileName(ts.normalizeSlashes(fileName));
+                // Get occurrences only supports reporting occurrences for the file queried.  So
+                // filter down to that list.
+                results = ts.filter(results, function (r) { return getCanonicalFileName(ts.normalizeSlashes(r.fileName)) === sourceFile_1; });
+            }
+            return results;
+        }
+        function getDocumentHighlights(fileName, position, filesToSearch) {
+            synchronizeHostData();
+            var sourceFilesToSearch = ts.map(filesToSearch, function (f) { return program.getSourceFile(f); });
+            var sourceFile = getValidSourceFile(fileName);
+            var node = ts.getTouchingWord(sourceFile, position);
+            if (!node) {
+                return undefined;
+            }
+            return getSemanticDocumentHighlights(node) || getSyntacticDocumentHighlights(node);
+            function getHighlightSpanForNode(node) {
+                var start = node.getStart();
+                var end = node.getEnd();
+                return {
+                    fileName: sourceFile.fileName,
+                    textSpan: ts.createTextSpanFromBounds(start, end),
+                    kind: HighlightSpanKind.none
+                };
+            }
+            function getSemanticDocumentHighlights(node) {
+                if (node.kind === 69 /* Identifier */ ||
+                    node.kind === 97 /* ThisKeyword */ ||
+                    node.kind === 165 /* ThisType */ ||
+                    node.kind === 95 /* SuperKeyword */ ||
+                    node.kind === 9 /* StringLiteral */ ||
+                    isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+                    var referencedSymbols = getReferencedSymbolsForNode(node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false);
+                    return convertReferencedSymbols(referencedSymbols);
+                }
+                return undefined;
+                function convertReferencedSymbols(referencedSymbols) {
+                    if (!referencedSymbols) {
+                        return undefined;
+                    }
+                    var fileNameToDocumentHighlights = {};
+                    var result = [];
+                    for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                        var referencedSymbol = referencedSymbols_1[_i];
+                        for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                            var referenceEntry = _b[_a];
+                            var fileName_1 = referenceEntry.fileName;
+                            var documentHighlights = ts.getProperty(fileNameToDocumentHighlights, fileName_1);
+                            if (!documentHighlights) {
+                                documentHighlights = { fileName: fileName_1, highlightSpans: [] };
+                                fileNameToDocumentHighlights[fileName_1] = documentHighlights;
+                                result.push(documentHighlights);
+                            }
+                            documentHighlights.highlightSpans.push({
+                                textSpan: referenceEntry.textSpan,
+                                kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
+                            });
+                        }
+                    }
+                    return result;
+                }
+            }
+            function getSyntacticDocumentHighlights(node) {
+                var fileName = sourceFile.fileName;
+                var highlightSpans = getHighlightSpans(node);
+                if (!highlightSpans || highlightSpans.length === 0) {
+                    return undefined;
+                }
+                return [{ fileName: fileName, highlightSpans: highlightSpans }];
+                // returns true if 'node' is defined and has a matching 'kind'.
+                function hasKind(node, kind) {
+                    return node !== undefined && node.kind === kind;
+                }
+                // Null-propagating 'parent' function.
+                function parent(node) {
+                    return node && node.parent;
+                }
+                function getHighlightSpans(node) {
+                    if (node) {
+                        switch (node.kind) {
+                            case 88 /* IfKeyword */:
+                            case 80 /* ElseKeyword */:
+                                if (hasKind(node.parent, 203 /* IfStatement */)) {
+                                    return getIfElseOccurrences(node.parent);
+                                }
+                                break;
+                            case 94 /* ReturnKeyword */:
+                                if (hasKind(node.parent, 211 /* ReturnStatement */)) {
+                                    return getReturnOccurrences(node.parent);
+                                }
+                                break;
+                            case 98 /* ThrowKeyword */:
+                                if (hasKind(node.parent, 215 /* ThrowStatement */)) {
+                                    return getThrowOccurrences(node.parent);
+                                }
+                                break;
+                            case 72 /* CatchKeyword */:
+                                if (hasKind(parent(parent(node)), 216 /* TryStatement */)) {
+                                    return getTryCatchFinallyOccurrences(node.parent.parent);
+                                }
+                                break;
+                            case 100 /* TryKeyword */:
+                            case 85 /* FinallyKeyword */:
+                                if (hasKind(parent(node), 216 /* TryStatement */)) {
+                                    return getTryCatchFinallyOccurrences(node.parent);
+                                }
+                                break;
+                            case 96 /* SwitchKeyword */:
+                                if (hasKind(node.parent, 213 /* SwitchStatement */)) {
+                                    return getSwitchCaseDefaultOccurrences(node.parent);
+                                }
+                                break;
+                            case 71 /* CaseKeyword */:
+                            case 77 /* DefaultKeyword */:
+                                if (hasKind(parent(parent(parent(node))), 213 /* SwitchStatement */)) {
+                                    return getSwitchCaseDefaultOccurrences(node.parent.parent.parent);
+                                }
+                                break;
+                            case 70 /* BreakKeyword */:
+                            case 75 /* ContinueKeyword */:
+                                if (hasKind(node.parent, 210 /* BreakStatement */) || hasKind(node.parent, 209 /* ContinueStatement */)) {
+                                    return getBreakOrContinueStatementOccurrences(node.parent);
+                                }
+                                break;
+                            case 86 /* ForKeyword */:
+                                if (hasKind(node.parent, 206 /* ForStatement */) ||
+                                    hasKind(node.parent, 207 /* ForInStatement */) ||
+                                    hasKind(node.parent, 208 /* ForOfStatement */)) {
+                                    return getLoopBreakContinueOccurrences(node.parent);
+                                }
+                                break;
+                            case 104 /* WhileKeyword */:
+                            case 79 /* DoKeyword */:
+                                if (hasKind(node.parent, 205 /* WhileStatement */) || hasKind(node.parent, 204 /* DoStatement */)) {
+                                    return getLoopBreakContinueOccurrences(node.parent);
+                                }
+                                break;
+                            case 121 /* ConstructorKeyword */:
+                                if (hasKind(node.parent, 148 /* Constructor */)) {
+                                    return getConstructorOccurrences(node.parent);
+                                }
+                                break;
+                            case 123 /* GetKeyword */:
+                            case 131 /* SetKeyword */:
+                                if (hasKind(node.parent, 149 /* GetAccessor */) || hasKind(node.parent, 150 /* SetAccessor */)) {
+                                    return getGetAndSetOccurrences(node.parent);
+                                }
+                                break;
+                            default:
+                                if (ts.isModifierKind(node.kind) && node.parent &&
+                                    (ts.isDeclaration(node.parent) || node.parent.kind === 200 /* VariableStatement */)) {
+                                    return getModifierOccurrences(node.kind, node.parent);
+                                }
+                        }
+                    }
+                    return undefined;
+                }
+                /**
+                 * Aggregates all throw-statements within this node *without* crossing
+                 * into function boundaries and try-blocks with catch-clauses.
+                 */
+                function aggregateOwnedThrowStatements(node) {
+                    var statementAccumulator = [];
+                    aggregate(node);
+                    return statementAccumulator;
+                    function aggregate(node) {
+                        if (node.kind === 215 /* ThrowStatement */) {
+                            statementAccumulator.push(node);
+                        }
+                        else if (node.kind === 216 /* TryStatement */) {
+                            var tryStatement = node;
+                            if (tryStatement.catchClause) {
+                                aggregate(tryStatement.catchClause);
+                            }
+                            else {
+                                // Exceptions thrown within a try block lacking a catch clause
+                                // are "owned" in the current context.
+                                aggregate(tryStatement.tryBlock);
+                            }
+                            if (tryStatement.finallyBlock) {
+                                aggregate(tryStatement.finallyBlock);
+                            }
+                        }
+                        else if (!ts.isFunctionLike(node)) {
+                            ts.forEachChild(node, aggregate);
+                        }
+                    }
+                }
+                /**
+                 * For lack of a better name, this function takes a throw statement and returns the
+                 * nearest ancestor that is a try-block (whose try statement has a catch clause),
+                 * function-block, or source file.
+                 */
+                function getThrowStatementOwner(throwStatement) {
+                    var child = throwStatement;
+                    while (child.parent) {
+                        var parent_20 = child.parent;
+                        if (ts.isFunctionBlock(parent_20) || parent_20.kind === 256 /* SourceFile */) {
+                            return parent_20;
+                        }
+                        // A throw-statement is only owned by a try-statement if the try-statement has
+                        // a catch clause, and if the throw-statement occurs within the try block.
+                        if (parent_20.kind === 216 /* TryStatement */) {
+                            var tryStatement = parent_20;
+                            if (tryStatement.tryBlock === child && tryStatement.catchClause) {
+                                return child;
+                            }
+                        }
+                        child = parent_20;
+                    }
+                    return undefined;
+                }
+                function aggregateAllBreakAndContinueStatements(node) {
+                    var statementAccumulator = [];
+                    aggregate(node);
+                    return statementAccumulator;
+                    function aggregate(node) {
+                        if (node.kind === 210 /* BreakStatement */ || node.kind === 209 /* ContinueStatement */) {
+                            statementAccumulator.push(node);
+                        }
+                        else if (!ts.isFunctionLike(node)) {
+                            ts.forEachChild(node, aggregate);
+                        }
+                    }
+                }
+                function ownsBreakOrContinueStatement(owner, statement) {
+                    var actualOwner = getBreakOrContinueOwner(statement);
+                    return actualOwner && actualOwner === owner;
+                }
+                function getBreakOrContinueOwner(statement) {
+                    for (var node_1 = statement.parent; node_1; node_1 = node_1.parent) {
+                        switch (node_1.kind) {
+                            case 213 /* SwitchStatement */:
+                                if (statement.kind === 209 /* ContinueStatement */) {
+                                    continue;
+                                }
+                            // Fall through.
+                            case 206 /* ForStatement */:
+                            case 207 /* ForInStatement */:
+                            case 208 /* ForOfStatement */:
+                            case 205 /* WhileStatement */:
+                            case 204 /* DoStatement */:
+                                if (!statement.label || isLabeledBy(node_1, statement.label.text)) {
+                                    return node_1;
+                                }
+                                break;
+                            default:
+                                // Don't cross function boundaries.
+                                if (ts.isFunctionLike(node_1)) {
+                                    return undefined;
+                                }
+                                break;
+                        }
+                    }
+                    return undefined;
+                }
+                function getModifierOccurrences(modifier, declaration) {
+                    var container = declaration.parent;
+                    // Make sure we only highlight the keyword when it makes sense to do so.
+                    if (ts.isAccessibilityModifier(modifier)) {
+                        if (!(container.kind === 221 /* ClassDeclaration */ ||
+                            container.kind === 192 /* ClassExpression */ ||
+                            (declaration.kind === 142 /* Parameter */ && hasKind(container, 148 /* Constructor */)))) {
+                            return undefined;
+                        }
+                    }
+                    else if (modifier === 113 /* StaticKeyword */) {
+                        if (!(container.kind === 221 /* ClassDeclaration */ || container.kind === 192 /* ClassExpression */)) {
+                            return undefined;
+                        }
+                    }
+                    else if (modifier === 82 /* ExportKeyword */ || modifier === 122 /* DeclareKeyword */) {
+                        if (!(container.kind === 226 /* ModuleBlock */ || container.kind === 256 /* SourceFile */)) {
+                            return undefined;
+                        }
+                    }
+                    else if (modifier === 115 /* AbstractKeyword */) {
+                        if (!(container.kind === 221 /* ClassDeclaration */ || declaration.kind === 221 /* ClassDeclaration */)) {
+                            return undefined;
+                        }
+                    }
+                    else {
+                        // unsupported modifier
+                        return undefined;
+                    }
+                    var keywords = [];
+                    var modifierFlag = getFlagFromModifier(modifier);
+                    var nodes;
+                    switch (container.kind) {
+                        case 226 /* ModuleBlock */:
+                        case 256 /* SourceFile */:
+                            // Container is either a class declaration or the declaration is a classDeclaration
+                            if (modifierFlag & 128 /* Abstract */) {
+                                nodes = declaration.members.concat(declaration);
+                            }
+                            else {
+                                nodes = container.statements;
+                            }
+                            break;
+                        case 148 /* Constructor */:
+                            nodes = container.parameters.concat(container.parent.members);
+                            break;
+                        case 221 /* ClassDeclaration */:
+                        case 192 /* ClassExpression */:
+                            nodes = container.members;
+                            // If we're an accessibility modifier, we're in an instance member and should search
+                            // the constructor's parameter list for instance members as well.
+                            if (modifierFlag & 28 /* AccessibilityModifier */) {
+                                var constructor = ts.forEach(container.members, function (member) {
+                                    return member.kind === 148 /* Constructor */ && member;
+                                });
+                                if (constructor) {
+                                    nodes = nodes.concat(constructor.parameters);
+                                }
+                            }
+                            else if (modifierFlag & 128 /* Abstract */) {
+                                nodes = nodes.concat(container);
+                            }
+                            break;
+                        default:
+                            ts.Debug.fail("Invalid container kind.");
+                    }
+                    ts.forEach(nodes, function (node) {
+                        if (node.modifiers && node.flags & modifierFlag) {
+                            ts.forEach(node.modifiers, function (child) { return pushKeywordIf(keywords, child, modifier); });
+                        }
+                    });
+                    return ts.map(keywords, getHighlightSpanForNode);
+                    function getFlagFromModifier(modifier) {
+                        switch (modifier) {
+                            case 112 /* PublicKeyword */:
+                                return 4 /* Public */;
+                            case 110 /* PrivateKeyword */:
+                                return 8 /* Private */;
+                            case 111 /* ProtectedKeyword */:
+                                return 16 /* Protected */;
+                            case 113 /* StaticKeyword */:
+                                return 32 /* Static */;
+                            case 82 /* ExportKeyword */:
+                                return 1 /* Export */;
+                            case 122 /* DeclareKeyword */:
+                                return 2 /* Ambient */;
+                            case 115 /* AbstractKeyword */:
+                                return 128 /* Abstract */;
+                            default:
+                                ts.Debug.fail();
+                        }
+                    }
+                }
+                function pushKeywordIf(keywordList, token) {
+                    var expected = [];
+                    for (var _i = 2; _i < arguments.length; _i++) {
+                        expected[_i - 2] = arguments[_i];
+                    }
+                    if (token && ts.contains(expected, token.kind)) {
+                        keywordList.push(token);
+                        return true;
+                    }
+                    return false;
+                }
+                function getGetAndSetOccurrences(accessorDeclaration) {
+                    var keywords = [];
+                    tryPushAccessorKeyword(accessorDeclaration.symbol, 149 /* GetAccessor */);
+                    tryPushAccessorKeyword(accessorDeclaration.symbol, 150 /* SetAccessor */);
+                    return ts.map(keywords, getHighlightSpanForNode);
+                    function tryPushAccessorKeyword(accessorSymbol, accessorKind) {
+                        var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind);
+                        if (accessor) {
+                            ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 123 /* GetKeyword */, 131 /* SetKeyword */); });
+                        }
+                    }
+                }
+                function getConstructorOccurrences(constructorDeclaration) {
+                    var declarations = constructorDeclaration.symbol.getDeclarations();
+                    var keywords = [];
+                    ts.forEach(declarations, function (declaration) {
+                        ts.forEach(declaration.getChildren(), function (token) {
+                            return pushKeywordIf(keywords, token, 121 /* ConstructorKeyword */);
+                        });
+                    });
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getLoopBreakContinueOccurrences(loopNode) {
+                    var keywords = [];
+                    if (pushKeywordIf(keywords, loopNode.getFirstToken(), 86 /* ForKeyword */, 104 /* WhileKeyword */, 79 /* DoKeyword */)) {
+                        // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+                        if (loopNode.kind === 204 /* DoStatement */) {
+                            var loopTokens = loopNode.getChildren();
+                            for (var i = loopTokens.length - 1; i >= 0; i--) {
+                                if (pushKeywordIf(keywords, loopTokens[i], 104 /* WhileKeyword */)) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    var breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
+                    ts.forEach(breaksAndContinues, function (statement) {
+                        if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                            pushKeywordIf(keywords, statement.getFirstToken(), 70 /* BreakKeyword */, 75 /* ContinueKeyword */);
+                        }
+                    });
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getBreakOrContinueStatementOccurrences(breakOrContinueStatement) {
+                    var owner = getBreakOrContinueOwner(breakOrContinueStatement);
+                    if (owner) {
+                        switch (owner.kind) {
+                            case 206 /* ForStatement */:
+                            case 207 /* ForInStatement */:
+                            case 208 /* ForOfStatement */:
+                            case 204 /* DoStatement */:
+                            case 205 /* WhileStatement */:
+                                return getLoopBreakContinueOccurrences(owner);
+                            case 213 /* SwitchStatement */:
+                                return getSwitchCaseDefaultOccurrences(owner);
+                        }
+                    }
+                    return undefined;
+                }
+                function getSwitchCaseDefaultOccurrences(switchStatement) {
+                    var keywords = [];
+                    pushKeywordIf(keywords, switchStatement.getFirstToken(), 96 /* SwitchKeyword */);
+                    // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+                    ts.forEach(switchStatement.caseBlock.clauses, function (clause) {
+                        pushKeywordIf(keywords, clause.getFirstToken(), 71 /* CaseKeyword */, 77 /* DefaultKeyword */);
+                        var breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
+                        ts.forEach(breaksAndContinues, function (statement) {
+                            if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                                pushKeywordIf(keywords, statement.getFirstToken(), 70 /* BreakKeyword */);
+                            }
+                        });
+                    });
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getTryCatchFinallyOccurrences(tryStatement) {
+                    var keywords = [];
+                    pushKeywordIf(keywords, tryStatement.getFirstToken(), 100 /* TryKeyword */);
+                    if (tryStatement.catchClause) {
+                        pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 72 /* CatchKeyword */);
+                    }
+                    if (tryStatement.finallyBlock) {
+                        var finallyKeyword = ts.findChildOfKind(tryStatement, 85 /* FinallyKeyword */, sourceFile);
+                        pushKeywordIf(keywords, finallyKeyword, 85 /* FinallyKeyword */);
+                    }
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getThrowOccurrences(throwStatement) {
+                    var owner = getThrowStatementOwner(throwStatement);
+                    if (!owner) {
+                        return undefined;
+                    }
+                    var keywords = [];
+                    ts.forEach(aggregateOwnedThrowStatements(owner), function (throwStatement) {
+                        pushKeywordIf(keywords, throwStatement.getFirstToken(), 98 /* ThrowKeyword */);
+                    });
+                    // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+                    // ability to "jump out" of the function, and include occurrences for both.
+                    if (ts.isFunctionBlock(owner)) {
+                        ts.forEachReturnStatement(owner, function (returnStatement) {
+                            pushKeywordIf(keywords, returnStatement.getFirstToken(), 94 /* ReturnKeyword */);
+                        });
+                    }
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getReturnOccurrences(returnStatement) {
+                    var func = ts.getContainingFunction(returnStatement);
+                    // If we didn't find a containing function with a block body, bail out.
+                    if (!(func && hasKind(func.body, 199 /* Block */))) {
+                        return undefined;
+                    }
+                    var keywords = [];
+                    ts.forEachReturnStatement(func.body, function (returnStatement) {
+                        pushKeywordIf(keywords, returnStatement.getFirstToken(), 94 /* ReturnKeyword */);
+                    });
+                    // Include 'throw' statements that do not occur within a try block.
+                    ts.forEach(aggregateOwnedThrowStatements(func.body), function (throwStatement) {
+                        pushKeywordIf(keywords, throwStatement.getFirstToken(), 98 /* ThrowKeyword */);
+                    });
+                    return ts.map(keywords, getHighlightSpanForNode);
+                }
+                function getIfElseOccurrences(ifStatement) {
+                    var keywords = [];
+                    // Traverse upwards through all parent if-statements linked by their else-branches.
+                    while (hasKind(ifStatement.parent, 203 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) {
+                        ifStatement = ifStatement.parent;
+                    }
+                    // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+                    while (ifStatement) {
+                        var children = ifStatement.getChildren();
+                        pushKeywordIf(keywords, children[0], 88 /* IfKeyword */);
+                        // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+                        for (var i = children.length - 1; i >= 0; i--) {
+                            if (pushKeywordIf(keywords, children[i], 80 /* ElseKeyword */)) {
+                                break;
+                            }
+                        }
+                        if (!hasKind(ifStatement.elseStatement, 203 /* IfStatement */)) {
+                            break;
+                        }
+                        ifStatement = ifStatement.elseStatement;
+                    }
+                    var result = [];
+                    // We'd like to highlight else/ifs together if they are only separated by whitespace
+                    // (i.e. the keywords are separated by no comments, no newlines).
+                    for (var i = 0; i < keywords.length; i++) {
+                        if (keywords[i].kind === 80 /* ElseKeyword */ && i < keywords.length - 1) {
+                            var elseKeyword = keywords[i];
+                            var ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+                            var shouldCombindElseAndIf = true;
+                            // Avoid recalculating getStart() by iterating backwards.
+                            for (var j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
+                                if (!ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
+                                    shouldCombindElseAndIf = false;
+                                    break;
+                                }
+                            }
+                            if (shouldCombindElseAndIf) {
+                                result.push({
+                                    fileName: fileName,
+                                    textSpan: ts.createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                                    kind: HighlightSpanKind.reference
+                                });
+                                i++; // skip the next keyword
+                                continue;
+                            }
+                        }
+                        // Ordinary case: just highlight the keyword.
+                        result.push(getHighlightSpanForNode(keywords[i]));
+                    }
+                    return result;
+                }
+            }
+        }
+        /// References and Occurrences
+        function getOccurrencesAtPositionCore(fileName, position) {
+            synchronizeHostData();
+            return convertDocumentHighlights(getDocumentHighlights(fileName, position, [fileName]));
+            function convertDocumentHighlights(documentHighlights) {
+                if (!documentHighlights) {
+                    return undefined;
+                }
+                var result = [];
+                for (var _i = 0, documentHighlights_1 = documentHighlights; _i < documentHighlights_1.length; _i++) {
+                    var entry = documentHighlights_1[_i];
+                    for (var _a = 0, _b = entry.highlightSpans; _a < _b.length; _a++) {
+                        var highlightSpan = _b[_a];
+                        result.push({
+                            fileName: entry.fileName,
+                            textSpan: highlightSpan.textSpan,
+                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference,
+                            isDefinition: false
+                        });
+                    }
+                }
+                return result;
+            }
+        }
+        function convertReferences(referenceSymbols) {
+            if (!referenceSymbols) {
+                return undefined;
+            }
+            var referenceEntries = [];
+            for (var _i = 0, referenceSymbols_1 = referenceSymbols; _i < referenceSymbols_1.length; _i++) {
+                var referenceSymbol = referenceSymbols_1[_i];
+                ts.addRange(referenceEntries, referenceSymbol.references);
+            }
+            return referenceEntries;
+        }
+        function findRenameLocations(fileName, position, findInStrings, findInComments) {
+            var referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments);
+            return convertReferences(referencedSymbols);
+        }
+        function getReferencesAtPosition(fileName, position) {
+            var referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false);
+            return convertReferences(referencedSymbols);
+        }
+        function findReferences(fileName, position) {
+            var referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false);
+            // Only include referenced symbols that have a valid definition.
+            return ts.filter(referencedSymbols, function (rs) { return !!rs.definition; });
+        }
+        function findReferencedSymbols(fileName, position, findInStrings, findInComments) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var node = ts.getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
+            if (node === sourceFile) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case 8 /* NumericLiteral */:
+                    if (!isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+                        break;
+                    }
+                // Fallthrough
+                case 69 /* Identifier */:
+                case 97 /* ThisKeyword */:
+                // case SyntaxKind.SuperKeyword: TODO:GH#9268
+                case 9 /* StringLiteral */:
+                    return getReferencedSymbolsForNode(node, program.getSourceFiles(), findInStrings, findInComments);
+            }
+            return undefined;
+        }
+        function isThis(node) {
+            switch (node.kind) {
+                case 97 /* ThisKeyword */:
+                    // case SyntaxKind.ThisType: TODO: GH#9267
+                    return true;
+                case 69 /* Identifier */:
+                    // 'this' as a parameter
+                    return node.originalKeywordKind === 97 /* ThisKeyword */ && node.parent.kind === 142 /* Parameter */;
+                default:
+                    return false;
+            }
+        }
+        function getReferencedSymbolsForNode(node, sourceFiles, findInStrings, findInComments) {
+            var typeChecker = program.getTypeChecker();
+            // Labels
+            if (isLabelName(node)) {
+                if (isJumpStatementTarget(node)) {
+                    var labelDefinition = getTargetLabel(node.parent, node.text);
+                    // if we have a label definition, look within its statement for references, if not, then
+                    // the label is undefined and we have no results..
+                    return labelDefinition ? getLabelReferencesInNode(labelDefinition.parent, labelDefinition) : undefined;
+                }
+                else {
+                    // it is a label definition and not a target, search within the parent labeledStatement
+                    return getLabelReferencesInNode(node.parent, node);
+                }
+            }
+            if (isThis(node)) {
+                return getReferencesForThisKeyword(node, sourceFiles);
+            }
+            if (node.kind === 95 /* SuperKeyword */) {
+                return getReferencesForSuperKeyword(node);
+            }
+            var symbol = typeChecker.getSymbolAtLocation(node);
+            if (!symbol && node.kind === 9 /* StringLiteral */) {
+                return getReferencesForStringLiteral(node, sourceFiles);
+            }
+            // Could not find a symbol e.g. unknown identifier
+            if (!symbol) {
+                // Can't have references to something that we have no symbol for.
+                return undefined;
+            }
+            var declarations = symbol.declarations;
+            // The symbol was an internal symbol and does not have a declaration e.g. undefined symbol
+            if (!declarations || !declarations.length) {
+                return undefined;
+            }
+            var result;
+            // Compute the meaning from the location and the symbol it references
+            var searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
+            // Get the text to search for.
+            // Note: if this is an external module symbol, the name doesn't include quotes.
+            var declaredName = ts.stripQuotes(ts.getDeclaredName(typeChecker, symbol, node));
+            // Try to get the smallest valid scope that we can limit our search to;
+            // otherwise we'll need to search globally (i.e. include each file).
+            var scope = getSymbolScope(symbol);
+            // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
+            var symbolToIndex = [];
+            if (scope) {
+                result = [];
+                getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
+            }
+            else {
+                var internedName = getInternedName(symbol, node, declarations);
+                for (var _i = 0, sourceFiles_4 = sourceFiles; _i < sourceFiles_4.length; _i++) {
+                    var sourceFile = sourceFiles_4[_i];
+                    cancellationToken.throwIfCancellationRequested();
+                    var nameTable = getNameTable(sourceFile);
+                    if (ts.lookUp(nameTable, internedName) !== undefined) {
+                        result = result || [];
+                        getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
+                    }
+                }
+            }
+            return result;
+            function getDefinition(symbol) {
+                var info = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, node.getSourceFile(), getContainerNode(node), node);
+                var name = ts.map(info.displayParts, function (p) { return p.text; }).join("");
+                var declarations = symbol.declarations;
+                if (!declarations || declarations.length === 0) {
+                    return undefined;
+                }
+                return {
+                    containerKind: "",
+                    containerName: "",
+                    name: name,
+                    kind: info.symbolKind,
+                    fileName: declarations[0].getSourceFile().fileName,
+                    textSpan: ts.createTextSpan(declarations[0].getStart(), 0)
+                };
+            }
+            function getAliasSymbolForPropertyNameSymbol(symbol, location) {
+                if (symbol.flags & 8388608 /* Alias */) {
+                    // Default import get alias
+                    var defaultImport = ts.getDeclarationOfKind(symbol, 231 /* ImportClause */);
+                    if (defaultImport) {
+                        return typeChecker.getAliasedSymbol(symbol);
+                    }
+                    var importOrExportSpecifier = ts.forEach(symbol.declarations, function (declaration) { return (declaration.kind === 234 /* ImportSpecifier */ ||
+                        declaration.kind === 238 /* ExportSpecifier */) ? declaration : undefined; });
+                    if (importOrExportSpecifier &&
+                        // export { a }
+                        (!importOrExportSpecifier.propertyName ||
+                            // export {a as class } where a is location
+                            importOrExportSpecifier.propertyName === location)) {
+                        // If Import specifier -> get alias
+                        // else Export specifier -> get local target
+                        return importOrExportSpecifier.kind === 234 /* ImportSpecifier */ ?
+                            typeChecker.getAliasedSymbol(symbol) :
+                            typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier);
+                    }
+                }
+                return undefined;
+            }
+            function getPropertySymbolOfDestructuringAssignment(location) {
+                return ts.isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) &&
+                    typeChecker.getPropertySymbolOfDestructuringAssignment(location);
+            }
+            function isObjectBindingPatternElementWithoutPropertyName(symbol) {
+                var bindingElement = ts.getDeclarationOfKind(symbol, 169 /* BindingElement */);
+                return bindingElement &&
+                    bindingElement.parent.kind === 167 /* ObjectBindingPattern */ &&
+                    !bindingElement.propertyName;
+            }
+            function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol) {
+                if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
+                    var bindingElement = ts.getDeclarationOfKind(symbol, 169 /* BindingElement */);
+                    var typeOfPattern = typeChecker.getTypeAtLocation(bindingElement.parent);
+                    return typeOfPattern && typeChecker.getPropertyOfType(typeOfPattern, bindingElement.name.text);
+                }
+                return undefined;
+            }
+            function getInternedName(symbol, location, declarations) {
+                // If this is an export or import specifier it could have been renamed using the 'as' syntax.
+                // If so we want to search for whatever under the cursor.
+                if (ts.isImportOrExportSpecifierName(location)) {
+                    return location.getText();
+                }
+                // Try to get the local symbol if we're dealing with an 'export default'
+                // since that symbol has the "true" name.
+                var localExportDefaultSymbol = ts.getLocalSymbolForExportDefault(symbol);
+                symbol = localExportDefaultSymbol || symbol;
+                return ts.stripQuotes(symbol.name);
+            }
+            /**
+             * Determines the smallest scope in which a symbol may have named references.
+             * Note that not every construct has been accounted for. This function can
+             * probably be improved.
+             *
+             * @returns undefined if the scope cannot be determined, implying that
+             * a reference to a symbol can occur anywhere.
+             */
+            function getSymbolScope(symbol) {
+                // If this is the symbol of a named function expression or named class expression,
+                // then named references are limited to its own scope.
+                var valueDeclaration = symbol.valueDeclaration;
+                if (valueDeclaration && (valueDeclaration.kind === 179 /* FunctionExpression */ || valueDeclaration.kind === 192 /* ClassExpression */)) {
+                    return valueDeclaration;
+                }
+                // If this is private property or method, the scope is the containing class
+                if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) {
+                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 8 /* Private */) ? d : undefined; });
+                    if (privateDeclaration) {
+                        return ts.getAncestor(privateDeclaration, 221 /* ClassDeclaration */);
+                    }
+                }
+                // If the symbol is an import we would like to find it if we are looking for what it imports.
+                // So consider it visible outside its declaration scope.
+                if (symbol.flags & 8388608 /* Alias */) {
+                    return undefined;
+                }
+                // If symbol is of object binding pattern element without property name we would want to
+                // look for property too and that could be anywhere
+                if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
+                    return undefined;
+                }
+                // if this symbol is visible from its parent container, e.g. exported, then bail out
+                // if symbol correspond to the union property - bail out
+                if (symbol.parent || (symbol.flags & 268435456 /* SyntheticProperty */)) {
+                    return undefined;
+                }
+                var scope;
+                var declarations = symbol.getDeclarations();
+                if (declarations) {
+                    for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+                        var declaration = declarations_9[_i];
+                        var container = getContainerNode(declaration);
+                        if (!container) {
+                            return undefined;
+                        }
+                        if (scope && scope !== container) {
+                            // Different declarations have different containers, bail out
+                            return undefined;
+                        }
+                        if (container.kind === 256 /* SourceFile */ && !ts.isExternalModule(container)) {
+                            // This is a global variable and not an external module, any declaration defined
+                            // within this scope is visible outside the file
+                            return undefined;
+                        }
+                        // The search scope is the container node
+                        scope = container;
+                    }
+                }
+                return scope;
+            }
+            function getPossibleSymbolReferencePositions(sourceFile, symbolName, start, end) {
+                var positions = [];
+                /// TODO: Cache symbol existence for files to save text search
+                // Also, need to make this work for unicode escapes.
+                // Be resilient in the face of a symbol with no name or zero length name
+                if (!symbolName || !symbolName.length) {
+                    return positions;
+                }
+                var text = sourceFile.text;
+                var sourceLength = text.length;
+                var symbolNameLength = symbolName.length;
+                var position = text.indexOf(symbolName, start);
+                while (position >= 0) {
+                    cancellationToken.throwIfCancellationRequested();
+                    // If we are past the end, stop looking
+                    if (position > end)
+                        break;
+                    // We found a match.  Make sure it's not part of a larger word (i.e. the char
+                    // before and after it have to be a non-identifier char).
+                    var endPosition = position + symbolNameLength;
+                    if ((position === 0 || !ts.isIdentifierPart(text.charCodeAt(position - 1), 2 /* Latest */)) &&
+                        (endPosition === sourceLength || !ts.isIdentifierPart(text.charCodeAt(endPosition), 2 /* Latest */))) {
+                        // Found a real match.  Keep searching.
+                        positions.push(position);
+                    }
+                    position = text.indexOf(symbolName, position + symbolNameLength + 1);
+                }
+                return positions;
+            }
+            function getLabelReferencesInNode(container, targetLabel) {
+                var references = [];
+                var sourceFile = container.getSourceFile();
+                var labelName = targetLabel.text;
+                var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd());
+                ts.forEach(possiblePositions, function (position) {
+                    cancellationToken.throwIfCancellationRequested();
+                    var node = ts.getTouchingWord(sourceFile, position);
+                    if (!node || node.getWidth() !== labelName.length) {
+                        return;
+                    }
+                    // Only pick labels that are either the target label, or have a target that is the target label
+                    if (node === targetLabel ||
+                        (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) {
+                        references.push(getReferenceEntryFromNode(node));
+                    }
+                });
+                var definition = {
+                    containerKind: "",
+                    containerName: "",
+                    fileName: targetLabel.getSourceFile().fileName,
+                    kind: ScriptElementKind.label,
+                    name: labelName,
+                    textSpan: ts.createTextSpanFromBounds(targetLabel.getStart(), targetLabel.getEnd())
+                };
+                return [{ definition: definition, references: references }];
+            }
+            function isValidReferencePosition(node, searchSymbolName) {
+                if (node) {
+                    // Compare the length so we filter out strict superstrings of the symbol we are looking for
+                    switch (node.kind) {
+                        case 69 /* Identifier */:
+                            return node.getWidth() === searchSymbolName.length;
+                        case 9 /* StringLiteral */:
+                            if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+                                isNameOfExternalModuleImportOrDeclaration(node)) {
+                                // For string literals we have two additional chars for the quotes
+                                return node.getWidth() === searchSymbolName.length + 2;
+                            }
+                            break;
+                        case 8 /* NumericLiteral */:
+                            if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+                                return node.getWidth() === searchSymbolName.length;
+                            }
+                            break;
+                    }
+                }
+                return false;
+            }
+            /** Search within node "container" for references for a search value, where the search value is defined as a
+              * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning).
+              * searchLocation: a node where the search value
+              */
+            function getReferencesInNode(container, searchSymbol, searchText, searchLocation, searchMeaning, findInStrings, findInComments, result, symbolToIndex) {
+                var sourceFile = container.getSourceFile();
+                var tripleSlashDirectivePrefixRegex = /^\/\/\/\s*</;
+                var start = findInComments ? container.getFullStart() : container.getStart();
+                var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd());
+                if (possiblePositions.length) {
+                    // Build the set of symbols to search for, initially it has only the current symbol
+                    var searchSymbols_1 = populateSearchSymbolSet(searchSymbol, searchLocation);
+                    ts.forEach(possiblePositions, function (position) {
+                        cancellationToken.throwIfCancellationRequested();
+                        var referenceLocation = ts.getTouchingPropertyName(sourceFile, position);
+                        if (!isValidReferencePosition(referenceLocation, searchText)) {
+                            // This wasn't the start of a token.  Check to see if it might be a
+                            // match in a comment or string if that's what the caller is asking
+                            // for.
+                            if ((findInStrings && ts.isInString(sourceFile, position)) ||
+                                (findInComments && isInNonReferenceComment(sourceFile, position))) {
+                                // In the case where we're looking inside comments/strings, we don't have
+                                // an actual definition.  So just use 'undefined' here.  Features like
+                                // 'Rename' won't care (as they ignore the definitions), and features like
+                                // 'FindReferences' will just filter out these results.
+                                result.push({
+                                    definition: undefined,
+                                    references: [{
+                                            fileName: sourceFile.fileName,
+                                            textSpan: ts.createTextSpan(position, searchText.length),
+                                            isWriteAccess: false,
+                                            isDefinition: false
+                                        }]
+                                });
+                            }
+                            return;
+                        }
+                        if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
+                            return;
+                        }
+                        var referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation);
+                        if (referenceSymbol) {
+                            var referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
+                            var shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
+                            var relatedSymbol = getRelatedSymbol(searchSymbols_1, referenceSymbol, referenceLocation);
+                            if (relatedSymbol) {
+                                var referencedSymbol = getReferencedSymbol(relatedSymbol);
+                                referencedSymbol.references.push(getReferenceEntryFromNode(referenceLocation));
+                            }
+                            else if (!(referenceSymbol.flags & 67108864 /* Transient */) && searchSymbols_1.indexOf(shorthandValueSymbol) >= 0) {
+                                var referencedSymbol = getReferencedSymbol(shorthandValueSymbol);
+                                referencedSymbol.references.push(getReferenceEntryFromNode(referenceSymbolDeclaration.name));
+                            }
+                        }
+                    });
+                }
+                return;
+                function getReferencedSymbol(symbol) {
+                    var symbolId = ts.getSymbolId(symbol);
+                    var index = symbolToIndex[symbolId];
+                    if (index === undefined) {
+                        index = result.length;
+                        symbolToIndex[symbolId] = index;
+                        result.push({
+                            definition: getDefinition(symbol),
+                            references: []
+                        });
+                    }
+                    return result[index];
+                }
+                function isInNonReferenceComment(sourceFile, position) {
+                    return ts.isInCommentHelper(sourceFile, position, isNonReferenceComment);
+                    function isNonReferenceComment(c) {
+                        var commentText = sourceFile.text.substring(c.pos, c.end);
+                        return !tripleSlashDirectivePrefixRegex.test(commentText);
+                    }
+                }
+            }
+            function getReferencesForSuperKeyword(superKeyword) {
+                var searchSpaceNode = ts.getSuperContainer(superKeyword, /*stopOnFunctions*/ false);
+                if (!searchSpaceNode) {
+                    return undefined;
+                }
+                // Whether 'super' occurs in a static context within a class.
+                var staticFlag = 32 /* Static */;
+                switch (searchSpaceNode.kind) {
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                    case 148 /* Constructor */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        staticFlag &= searchSpaceNode.flags;
+                        searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
+                        break;
+                    default:
+                        return undefined;
+                }
+                var references = [];
+                var sourceFile = searchSpaceNode.getSourceFile();
+                var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd());
+                ts.forEach(possiblePositions, function (position) {
+                    cancellationToken.throwIfCancellationRequested();
+                    var node = ts.getTouchingWord(sourceFile, position);
+                    if (!node || node.kind !== 95 /* SuperKeyword */) {
+                        return;
+                    }
+                    var container = ts.getSuperContainer(node, /*stopOnFunctions*/ false);
+                    // If we have a 'super' container, we must have an enclosing class.
+                    // Now make sure the owning class is the same as the search-space
+                    // and has the same static qualifier as the original 'super's owner.
+                    if (container && (32 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
+                        references.push(getReferenceEntryFromNode(node));
+                    }
+                });
+                var definition = getDefinition(searchSpaceNode.symbol);
+                return [{ definition: definition, references: references }];
+            }
+            function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) {
+                var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
+                // Whether 'this' occurs in a static context within a class.
+                var staticFlag = 32 /* Static */;
+                switch (searchSpaceNode.kind) {
+                    case 147 /* MethodDeclaration */:
+                    case 146 /* MethodSignature */:
+                        if (ts.isObjectLiteralMethod(searchSpaceNode)) {
+                            break;
+                        }
+                    // fall through
+                    case 145 /* PropertyDeclaration */:
+                    case 144 /* PropertySignature */:
+                    case 148 /* Constructor */:
+                    case 149 /* GetAccessor */:
+                    case 150 /* SetAccessor */:
+                        staticFlag &= searchSpaceNode.flags;
+                        searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
+                        break;
+                    case 256 /* SourceFile */:
+                        if (ts.isExternalModule(searchSpaceNode)) {
+                            return undefined;
+                        }
+                    // Fall through
+                    case 220 /* FunctionDeclaration */:
+                    case 179 /* FunctionExpression */:
+                        break;
+                    // Computed properties in classes are not handled here because references to this are illegal,
+                    // so there is no point finding references to them.
+                    default:
+                        return undefined;
+                }
+                var references = [];
+                var possiblePositions;
+                if (searchSpaceNode.kind === 256 /* SourceFile */) {
+                    ts.forEach(sourceFiles, function (sourceFile) {
+                        possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd());
+                        getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references);
+                    });
+                }
+                else {
+                    var sourceFile = searchSpaceNode.getSourceFile();
+                    possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd());
+                    getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references);
+                }
+                return [{
+                        definition: {
+                            containerKind: "",
+                            containerName: "",
+                            fileName: node.getSourceFile().fileName,
+                            kind: ScriptElementKind.variableElement,
+                            name: "this",
+                            textSpan: ts.createTextSpanFromBounds(node.getStart(), node.getEnd())
+                        },
+                        references: references
+                    }];
+                function getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, result) {
+                    ts.forEach(possiblePositions, function (position) {
+                        cancellationToken.throwIfCancellationRequested();
+                        var node = ts.getTouchingWord(sourceFile, position);
+                        if (!node || !isThis(node)) {
+                            return;
+                        }
+                        var container = ts.getThisContainer(node, /* includeArrowFunctions */ false);
+                        switch (searchSpaceNode.kind) {
+                            case 179 /* FunctionExpression */:
+                            case 220 /* FunctionDeclaration */:
+                                if (searchSpaceNode.symbol === container.symbol) {
+                                    result.push(getReferenceEntryFromNode(node));
+                                }
+                                break;
+                            case 147 /* MethodDeclaration */:
+                            case 146 /* MethodSignature */:
+                                if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) {
+                                    result.push(getReferenceEntryFromNode(node));
+                                }
+                                break;
+                            case 192 /* ClassExpression */:
+                            case 221 /* ClassDeclaration */:
+                                // Make sure the container belongs to the same class
+                                // and has the appropriate static modifier from the original container.
+                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 32 /* Static */) === staticFlag) {
+                                    result.push(getReferenceEntryFromNode(node));
+                                }
+                                break;
+                            case 256 /* SourceFile */:
+                                if (container.kind === 256 /* SourceFile */ && !ts.isExternalModule(container)) {
+                                    result.push(getReferenceEntryFromNode(node));
+                                }
+                                break;
+                        }
+                    });
+                }
+            }
+            function getReferencesForStringLiteral(node, sourceFiles) {
+                var typeChecker = program.getTypeChecker();
+                var type = getStringLiteralTypeForNode(node, typeChecker);
+                if (!type) {
+                    // nothing to do here. moving on
+                    return undefined;
+                }
+                var references = [];
+                for (var _i = 0, sourceFiles_5 = sourceFiles; _i < sourceFiles_5.length; _i++) {
+                    var sourceFile = sourceFiles_5[_i];
+                    var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd());
+                    getReferencesForStringLiteralInFile(sourceFile, type, possiblePositions, references);
+                }
+                return [{
+                        definition: {
+                            containerKind: "",
+                            containerName: "",
+                            fileName: node.getSourceFile().fileName,
+                            kind: ScriptElementKind.variableElement,
+                            name: type.text,
+                            textSpan: ts.createTextSpanFromBounds(node.getStart(), node.getEnd())
+                        },
+                        references: references
+                    }];
+                function getReferencesForStringLiteralInFile(sourceFile, searchType, possiblePositions, references) {
+                    for (var _i = 0, possiblePositions_1 = possiblePositions; _i < possiblePositions_1.length; _i++) {
+                        var position = possiblePositions_1[_i];
+                        cancellationToken.throwIfCancellationRequested();
+                        var node_2 = ts.getTouchingWord(sourceFile, position);
+                        if (!node_2 || node_2.kind !== 9 /* StringLiteral */) {
+                            return;
+                        }
+                        var type_1 = getStringLiteralTypeForNode(node_2, typeChecker);
+                        if (type_1 === searchType) {
+                            references.push(getReferenceEntryFromNode(node_2));
+                        }
+                    }
+                }
+            }
+            function populateSearchSymbolSet(symbol, location) {
+                // The search set contains at least the current symbol
+                var result = [symbol];
+                // If the location is name of property symbol from object literal destructuring pattern
+                // Search the property symbol
+                //      for ( { property: p2 } of elems) { }
+                var containingObjectLiteralElement = getContainingObjectLiteralElement(location);
+                if (containingObjectLiteralElement && containingObjectLiteralElement.kind !== 254 /* ShorthandPropertyAssignment */) {
+                    var propertySymbol = getPropertySymbolOfDestructuringAssignment(location);
+                    if (propertySymbol) {
+                        result.push(propertySymbol);
+                    }
+                }
+                // If the symbol is an alias, add what it aliases to the list
+                //     import {a} from "mod";
+                //     export {a}
+                // If the symbol is an alias to default declaration, add what it aliases to the list
+                //     declare "mod" { export default class B { } }
+                //     import B from "mod";
+                //// For export specifiers, the exported name can be referring to a local symbol, e.g.:
+                ////     import {a} from "mod";
+                ////     export {a as somethingElse}
+                //// We want the *local* declaration of 'a' as declared in the import,
+                //// *not* as declared within "mod" (or farther)
+                var aliasSymbol = getAliasSymbolForPropertyNameSymbol(symbol, location);
+                if (aliasSymbol) {
+                    result = result.concat(populateSearchSymbolSet(aliasSymbol, location));
+                }
+                // If the location is in a context sensitive location (i.e. in an object literal) try
+                // to get a contextual type for it, and add the property symbol from the contextual
+                // type to the search set
+                if (containingObjectLiteralElement) {
+                    ts.forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement), function (contextualSymbol) {
+                        ts.addRange(result, typeChecker.getRootSymbols(contextualSymbol));
+                    });
+                    /* Because in short-hand property assignment, location has two meaning : property name and as value of the property
+                     * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of
+                     * property name and variable declaration of the identifier.
+                     * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service
+                     * should show both 'name' in 'obj' and 'name' in variable declaration
+                     *      const name = "Foo";
+                     *      const obj = { name };
+                     * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment
+                     * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration
+                     * will be included correctly.
+                     */
+                    var shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(location.parent);
+                    if (shorthandValueSymbol) {
+                        result.push(shorthandValueSymbol);
+                    }
+                }
+                // If the symbol.valueDeclaration is a property parameter declaration,
+                // we should include both parameter declaration symbol and property declaration symbol
+                // Parameter Declaration symbol is only visible within function scope, so the symbol is stored in constructor.locals.
+                // Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members
+                if (symbol.valueDeclaration && symbol.valueDeclaration.kind === 142 /* Parameter */ &&
+                    ts.isParameterPropertyDeclaration(symbol.valueDeclaration)) {
+                    result = result.concat(typeChecker.getSymbolsOfParameterPropertyDeclaration(symbol.valueDeclaration, symbol.name));
+                }
+                // If this is symbol of binding element without propertyName declaration in Object binding pattern
+                // Include the property in the search
+                var bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol);
+                if (bindingElementPropertySymbol) {
+                    result.push(bindingElementPropertySymbol);
+                }
+                // If this is a union property, add all the symbols from all its source symbols in all unioned types.
+                // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
+                ts.forEach(typeChecker.getRootSymbols(symbol), function (rootSymbol) {
+                    if (rootSymbol !== symbol) {
+                        result.push(rootSymbol);
+                    }
+                    // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
+                    if (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */)) {
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ {});
+                    }
+                });
+                return result;
+            }
+            /**
+             * Find symbol of the given property-name and add the symbol to the given result array
+             * @param symbol a symbol to start searching for the given propertyName
+             * @param propertyName a name of property to search for
+             * @param result an array of symbol of found property symbols
+             * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol.
+             *                                The value of previousIterationSymbol is undefined when the function is first called.
+             */
+            function getPropertySymbolsFromBaseTypes(symbol, propertyName, result, previousIterationSymbolsCache) {
+                if (!symbol) {
+                    return;
+                }
+                // If the current symbol is the same as the previous-iteration symbol, we can just return the symbol that has already been visited
+                // This is particularly important for the following cases, so that we do not infinitely visit the same symbol.
+                // For example:
+                //      interface C extends C {
+                //          /*findRef*/propName: string;
+                //      }
+                // The first time getPropertySymbolsFromBaseTypes is called when finding-all-references at propName,
+                // the symbol argument will be the symbol of an interface "C" and previousIterationSymbol is undefined,
+                // the function will add any found symbol of the property-name, then its sub-routine will call
+                // getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
+                // visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
+                if (ts.hasProperty(previousIterationSymbolsCache, symbol.name)) {
+                    return;
+                }
+                if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
+                    ts.forEach(symbol.getDeclarations(), function (declaration) {
+                        if (ts.isClassLike(declaration)) {
+                            getPropertySymbolFromTypeReference(ts.getClassExtendsHeritageClauseElement(declaration));
+                            ts.forEach(ts.getClassImplementsHeritageClauseElements(declaration), getPropertySymbolFromTypeReference);
+                        }
+                        else if (declaration.kind === 222 /* InterfaceDeclaration */) {
+                            ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference);
+                        }
+                    });
+                }
+                return;
+                function getPropertySymbolFromTypeReference(typeReference) {
+                    if (typeReference) {
+                        var type = typeChecker.getTypeAtLocation(typeReference);
+                        if (type) {
+                            var propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+                            if (propertySymbol) {
+                                result.push.apply(result, typeChecker.getRootSymbols(propertySymbol));
+                            }
+                            // Visit the typeReference as well to see if it directly or indirectly use that property
+                            previousIterationSymbolsCache[symbol.name] = symbol;
+                            getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache);
+                        }
+                    }
+                }
+            }
+            function getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation) {
+                if (searchSymbols.indexOf(referenceSymbol) >= 0) {
+                    return referenceSymbol;
+                }
+                // If the reference symbol is an alias, check if what it is aliasing is one of the search
+                // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness.
+                var aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation);
+                if (aliasSymbol) {
+                    return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation);
+                }
+                // If the reference location is in an object literal, try to get the contextual type for the
+                // object literal, lookup the property symbol in the contextual type, and use this symbol to
+                // compare to our searchSymbol
+                var containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
+                if (containingObjectLiteralElement) {
+                    var contextualSymbol = ts.forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement), function (contextualSymbol) {
+                        return ts.forEach(typeChecker.getRootSymbols(contextualSymbol), function (s) { return searchSymbols.indexOf(s) >= 0 ? s : undefined; });
+                    });
+                    if (contextualSymbol) {
+                        return contextualSymbol;
+                    }
+                    // If the reference location is the name of property from object literal destructuring pattern
+                    // Get the property symbol from the object literal's type and look if thats the search symbol
+                    // In below eg. get 'property' from type of elems iterating type
+                    //      for ( { property: p2 } of elems) { }
+                    var propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation);
+                    if (propertySymbol && searchSymbols.indexOf(propertySymbol) >= 0) {
+                        return propertySymbol;
+                    }
+                }
+                // If the reference location is the binding element and doesn't have property name
+                // then include the binding element in the related symbols
+                //      let { a } : { a };
+                var bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol);
+                if (bindingElementPropertySymbol && searchSymbols.indexOf(bindingElementPropertySymbol) >= 0) {
+                    return bindingElementPropertySymbol;
+                }
+                // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening)
+                // Or a union property, use its underlying unioned symbols
+                return ts.forEach(typeChecker.getRootSymbols(referenceSymbol), function (rootSymbol) {
+                    // if it is in the list, then we are done
+                    if (searchSymbols.indexOf(rootSymbol) >= 0) {
+                        return rootSymbol;
+                    }
+                    // Finally, try all properties with the same name in any type the containing type extended or implemented, and
+                    // see if any is in the list
+                    if (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */)) {
+                        var result_4 = [];
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result_4, /*previousIterationSymbolsCache*/ {});
+                        return ts.forEach(result_4, function (s) { return searchSymbols.indexOf(s) >= 0 ? s : undefined; });
+                    }
+                    return undefined;
+                });
+            }
+            function getNameFromObjectLiteralElement(node) {
+                if (node.name.kind === 140 /* ComputedPropertyName */) {
+                    var nameExpression = node.name.expression;
+                    // treat computed property names where expression is string/numeric literal as just string/numeric literal
+                    if (ts.isStringOrNumericLiteral(nameExpression.kind)) {
+                        return nameExpression.text;
+                    }
+                    return undefined;
+                }
+                return node.name.text;
+            }
+            function getPropertySymbolsFromContextualType(node) {
+                var objectLiteral = node.parent;
+                var contextualType = typeChecker.getContextualType(objectLiteral);
+                var name = getNameFromObjectLiteralElement(node);
+                if (name && contextualType) {
+                    var result_5 = [];
+                    var symbol_1 = contextualType.getProperty(name);
+                    if (symbol_1) {
+                        result_5.push(symbol_1);
+                    }
+                    if (contextualType.flags & 16384 /* Union */) {
+                        ts.forEach(contextualType.types, function (t) {
+                            var symbol = t.getProperty(name);
+                            if (symbol) {
+                                result_5.push(symbol);
+                            }
+                        });
+                    }
+                    return result_5;
+                }
+                return undefined;
+            }
+            /** Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations
+              * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class
+              * then we need to widen the search to include type positions as well.
+              * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated
+              * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module)
+              * do not intersect in any of the three spaces.
+              */
+            function getIntersectingMeaningFromDeclarations(meaning, declarations) {
+                if (declarations) {
+                    var lastIterationMeaning = void 0;
+                    do {
+                        // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module]
+                        // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module
+                        // intersects with the class in the value space.
+                        // To achieve that we will keep iterating until the result stabilizes.
+                        // Remember the last meaning
+                        lastIterationMeaning = meaning;
+                        for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) {
+                            var declaration = declarations_10[_i];
+                            var declarationMeaning = getMeaningFromDeclaration(declaration);
+                            if (declarationMeaning & meaning) {
+                                meaning |= declarationMeaning;
+                            }
+                        }
+                    } while (meaning !== lastIterationMeaning);
+                }
+                return meaning;
+            }
+        }
+        function getReferenceEntryFromNode(node) {
+            var start = node.getStart();
+            var end = node.getEnd();
+            if (node.kind === 9 /* StringLiteral */) {
+                start += 1;
+                end -= 1;
+            }
+            return {
+                fileName: node.getSourceFile().fileName,
+                textSpan: ts.createTextSpanFromBounds(start, end),
+                isWriteAccess: isWriteAccess(node),
+                isDefinition: ts.isDeclarationName(node) || ts.isLiteralComputedPropertyDeclarationName(node)
+            };
+        }
+        /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */
+        function isWriteAccess(node) {
+            if (node.kind === 69 /* Identifier */ && ts.isDeclarationName(node)) {
+                return true;
+            }
+            var parent = node.parent;
+            if (parent) {
+                if (parent.kind === 186 /* PostfixUnaryExpression */ || parent.kind === 185 /* PrefixUnaryExpression */) {
+                    return true;
+                }
+                else if (parent.kind === 187 /* BinaryExpression */ && parent.left === node) {
+                    var operator = parent.operatorToken.kind;
+                    return 56 /* FirstAssignment */ <= operator && operator <= 68 /* LastAssignment */;
+                }
+            }
+            return false;
+        }
+        /// NavigateTo
+        function getNavigateToItems(searchValue, maxResultCount) {
+            synchronizeHostData();
+            var checker = getProgram().getTypeChecker();
+            return ts.NavigateTo.getNavigateToItems(program, checker, cancellationToken, searchValue, maxResultCount);
+        }
+        function getEmitOutput(fileName) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var outputFiles = [];
+            function writeFile(fileName, data, writeByteOrderMark) {
+                outputFiles.push({
+                    name: fileName,
+                    writeByteOrderMark: writeByteOrderMark,
+                    text: data
+                });
+            }
+            var emitOutput = program.emit(sourceFile, writeFile, cancellationToken);
+            return {
+                outputFiles: outputFiles,
+                emitSkipped: emitOutput.emitSkipped
+            };
+        }
+        function getMeaningFromDeclaration(node) {
+            switch (node.kind) {
+                case 142 /* Parameter */:
+                case 218 /* VariableDeclaration */:
+                case 169 /* BindingElement */:
+                case 145 /* PropertyDeclaration */:
+                case 144 /* PropertySignature */:
+                case 253 /* PropertyAssignment */:
+                case 254 /* ShorthandPropertyAssignment */:
+                case 255 /* EnumMember */:
+                case 147 /* MethodDeclaration */:
+                case 146 /* MethodSignature */:
+                case 148 /* Constructor */:
+                case 149 /* GetAccessor */:
+                case 150 /* SetAccessor */:
+                case 220 /* FunctionDeclaration */:
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                case 252 /* CatchClause */:
+                    return 1 /* Value */;
+                case 141 /* TypeParameter */:
+                case 222 /* InterfaceDeclaration */:
+                case 223 /* TypeAliasDeclaration */:
+                case 159 /* TypeLiteral */:
+                    return 2 /* Type */;
+                case 221 /* ClassDeclaration */:
+                case 224 /* EnumDeclaration */:
+                    return 1 /* Value */ | 2 /* Type */;
+                case 225 /* ModuleDeclaration */:
+                    if (ts.isAmbientModule(node)) {
+                        return 4 /* Namespace */ | 1 /* Value */;
+                    }
+                    else if (ts.getModuleInstanceState(node) === 1 /* Instantiated */) {
+                        return 4 /* Namespace */ | 1 /* Value */;
+                    }
+                    else {
+                        return 4 /* Namespace */;
+                    }
+                case 233 /* NamedImports */:
+                case 234 /* ImportSpecifier */:
+                case 229 /* ImportEqualsDeclaration */:
+                case 230 /* ImportDeclaration */:
+                case 235 /* ExportAssignment */:
+                case 236 /* ExportDeclaration */:
+                    return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
+                // An external module can be a Value
+                case 256 /* SourceFile */:
+                    return 4 /* Namespace */ | 1 /* Value */;
+            }
+            return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
+        }
+        function isTypeReference(node) {
+            if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+                node = node.parent;
+            }
+            return node.parent.kind === 155 /* TypeReference */ ||
+                (node.parent.kind === 194 /* ExpressionWithTypeArguments */ && !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)) ||
+                (node.kind === 97 /* ThisKeyword */ && !ts.isExpression(node)) ||
+                node.kind === 165 /* ThisType */;
+        }
+        function isNamespaceReference(node) {
+            return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
+        }
+        function isPropertyAccessNamespaceReference(node) {
+            var root = node;
+            var isLastClause = true;
+            if (root.parent.kind === 172 /* PropertyAccessExpression */) {
+                while (root.parent && root.parent.kind === 172 /* PropertyAccessExpression */) {
+                    root = root.parent;
+                }
+                isLastClause = root.name === node;
+            }
+            if (!isLastClause && root.parent.kind === 194 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 251 /* HeritageClause */) {
+                var decl = root.parent.parent.parent;
+                return (decl.kind === 221 /* ClassDeclaration */ && root.parent.parent.token === 106 /* ImplementsKeyword */) ||
+                    (decl.kind === 222 /* InterfaceDeclaration */ && root.parent.parent.token === 83 /* ExtendsKeyword */);
+            }
+            return false;
+        }
+        function isQualifiedNameNamespaceReference(node) {
+            var root = node;
+            var isLastClause = true;
+            if (root.parent.kind === 139 /* QualifiedName */) {
+                while (root.parent && root.parent.kind === 139 /* QualifiedName */) {
+                    root = root.parent;
+                }
+                isLastClause = root.right === node;
+            }
+            return root.parent.kind === 155 /* TypeReference */ && !isLastClause;
+        }
+        function isInRightSideOfImport(node) {
+            while (node.parent.kind === 139 /* QualifiedName */) {
+                node = node.parent;
+            }
+            return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node;
+        }
+        function getMeaningFromRightHandSideOfImportEquals(node) {
+            ts.Debug.assert(node.kind === 69 /* Identifier */);
+            //     import a = |b|; // Namespace
+            //     import a = |b.c|; // Value, type, namespace
+            //     import a = |b.c|.d; // Namespace
+            if (node.parent.kind === 139 /* QualifiedName */ &&
+                node.parent.right === node &&
+                node.parent.parent.kind === 229 /* ImportEqualsDeclaration */) {
+                return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
+            }
+            return 4 /* Namespace */;
+        }
+        function getMeaningFromLocation(node) {
+            if (node.parent.kind === 235 /* ExportAssignment */) {
+                return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
+            }
+            else if (isInRightSideOfImport(node)) {
+                return getMeaningFromRightHandSideOfImportEquals(node);
+            }
+            else if (ts.isDeclarationName(node)) {
+                return getMeaningFromDeclaration(node.parent);
+            }
+            else if (isTypeReference(node)) {
+                return 2 /* Type */;
+            }
+            else if (isNamespaceReference(node)) {
+                return 4 /* Namespace */;
+            }
+            else {
+                return 1 /* Value */;
+            }
+        }
+        // Signature help
+        /**
+         * This is a semantic operation.
+         */
+        function getSignatureHelpItems(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            return ts.SignatureHelp.getSignatureHelpItems(program, sourceFile, position, cancellationToken);
+        }
+        /// Syntactic features
+        function getNonBoundSourceFile(fileName) {
+            return syntaxTreeCache.getCurrentSourceFile(fileName);
+        }
+        function getNameOrDottedNameSpan(fileName, startPos, endPos) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            // Get node at the location
+            var node = ts.getTouchingPropertyName(sourceFile, startPos);
+            if (node === sourceFile) {
+                return;
+            }
+            switch (node.kind) {
+                case 172 /* PropertyAccessExpression */:
+                case 139 /* QualifiedName */:
+                case 9 /* StringLiteral */:
+                case 166 /* StringLiteralType */:
+                case 84 /* FalseKeyword */:
+                case 99 /* TrueKeyword */:
+                case 93 /* NullKeyword */:
+                case 95 /* SuperKeyword */:
+                case 97 /* ThisKeyword */:
+                case 165 /* ThisType */:
+                case 69 /* Identifier */:
+                    break;
+                // Cant create the text span
+                default:
+                    return;
+            }
+            var nodeForStartPos = node;
+            while (true) {
+                if (isRightSideOfPropertyAccess(nodeForStartPos) || isRightSideOfQualifiedName(nodeForStartPos)) {
+                    // If on the span is in right side of the the property or qualified name, return the span from the qualified name pos to end of this node
+                    nodeForStartPos = nodeForStartPos.parent;
+                }
+                else if (isNameOfModuleDeclaration(nodeForStartPos)) {
+                    // If this is name of a module declarations, check if this is right side of dotted module name
+                    // If parent of the module declaration which is parent of this node is module declaration and its body is the module declaration that this node is name of
+                    // Then this name is name from dotted module
+                    if (nodeForStartPos.parent.parent.kind === 225 /* ModuleDeclaration */ &&
+                        nodeForStartPos.parent.parent.body === nodeForStartPos.parent) {
+                        // Use parent module declarations name for start pos
+                        nodeForStartPos = nodeForStartPos.parent.parent.name;
+                    }
+                    else {
+                        // We have to use this name for start pos
+                        break;
+                    }
+                }
+                else {
+                    // Is not a member expression so we have found the node for start pos
+                    break;
+                }
+            }
+            return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd());
+        }
+        function getBreakpointStatementAtPosition(fileName, position) {
+            // doesn't use compiler - no need to synchronize with host
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position);
+        }
+        function getNavigationBarItems(fileName) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            return ts.NavigationBar.getNavigationBarItems(sourceFile);
+        }
+        function getSemanticClassifications(fileName, span) {
+            return convertClassifications(getEncodedSemanticClassifications(fileName, span));
+        }
+        function checkForClassificationCancellation(kind) {
+            // We don't want to actually call back into our host on every node to find out if we've
+            // been canceled.  That would be an enormous amount of chattyness, along with the all
+            // the overhead of marshalling the data to/from the host.  So instead we pick a few
+            // reasonable node kinds to bother checking on.  These node kinds represent high level
+            // constructs that we would expect to see commonly, but just at a far less frequent
+            // interval.
+            //
+            // For example, in checker.ts (around 750k) we only have around 600 of these constructs.
+            // That means we're calling back into the host around every 1.2k of the file we process.
+            // Lib.d.ts has similar numbers.
+            switch (kind) {
+                case 225 /* ModuleDeclaration */:
+                case 221 /* ClassDeclaration */:
+                case 222 /* InterfaceDeclaration */:
+                case 220 /* FunctionDeclaration */:
+                    cancellationToken.throwIfCancellationRequested();
+            }
+        }
+        function getEncodedSemanticClassifications(fileName, span) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var typeChecker = program.getTypeChecker();
+            var result = [];
+            var classifiableNames = program.getClassifiableNames();
+            processNode(sourceFile);
+            return { spans: result, endOfLineState: 0 /* None */ };
+            function pushClassification(start, length, type) {
+                result.push(start);
+                result.push(length);
+                result.push(type);
+            }
+            function classifySymbol(symbol, meaningAtPosition) {
+                var flags = symbol.getFlags();
+                if ((flags & 788448 /* Classifiable */) === 0 /* None */) {
+                    return;
+                }
+                if (flags & 32 /* Class */) {
+                    return 11 /* className */;
+                }
+                else if (flags & 384 /* Enum */) {
+                    return 12 /* enumName */;
+                }
+                else if (flags & 524288 /* TypeAlias */) {
+                    return 16 /* typeAliasName */;
+                }
+                else if (meaningAtPosition & 2 /* Type */) {
+                    if (flags & 64 /* Interface */) {
+                        return 13 /* interfaceName */;
+                    }
+                    else if (flags & 262144 /* TypeParameter */) {
+                        return 15 /* typeParameterName */;
+                    }
+                }
+                else if (flags & 1536 /* Module */) {
+                    // Only classify a module as such if
+                    //  - It appears in a namespace context.
+                    //  - There exists a module declaration which actually impacts the value side.
+                    if (meaningAtPosition & 4 /* Namespace */ ||
+                        (meaningAtPosition & 1 /* Value */ && hasValueSideModule(symbol))) {
+                        return 14 /* moduleName */;
+                    }
+                }
+                return undefined;
+                /**
+                 * Returns true if there exists a module that introduces entities on the value side.
+                 */
+                function hasValueSideModule(symbol) {
+                    return ts.forEach(symbol.declarations, function (declaration) {
+                        return declaration.kind === 225 /* ModuleDeclaration */ &&
+                            ts.getModuleInstanceState(declaration) === 1 /* Instantiated */;
+                    });
+                }
+            }
+            function processNode(node) {
+                // Only walk into nodes that intersect the requested span.
+                if (node && ts.textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) {
+                    var kind = node.kind;
+                    checkForClassificationCancellation(kind);
+                    if (kind === 69 /* Identifier */ && !ts.nodeIsMissing(node)) {
+                        var identifier = node;
+                        // Only bother calling into the typechecker if this is an identifier that
+                        // could possibly resolve to a type name.  This makes classification run
+                        // in a third of the time it would normally take.
+                        if (classifiableNames[identifier.text]) {
+                            var symbol = typeChecker.getSymbolAtLocation(node);
+                            if (symbol) {
+                                var type = classifySymbol(symbol, getMeaningFromLocation(node));
+                                if (type) {
+                                    pushClassification(node.getStart(), node.getWidth(), type);
+                                }
+                            }
+                        }
+                    }
+                    ts.forEachChild(node, processNode);
+                }
+            }
+        }
+        function getClassificationTypeName(type) {
+            switch (type) {
+                case 1 /* comment */: return ClassificationTypeNames.comment;
+                case 2 /* identifier */: return ClassificationTypeNames.identifier;
+                case 3 /* keyword */: return ClassificationTypeNames.keyword;
+                case 4 /* numericLiteral */: return ClassificationTypeNames.numericLiteral;
+                case 5 /* operator */: return ClassificationTypeNames.operator;
+                case 6 /* stringLiteral */: return ClassificationTypeNames.stringLiteral;
+                case 8 /* whiteSpace */: return ClassificationTypeNames.whiteSpace;
+                case 9 /* text */: return ClassificationTypeNames.text;
+                case 10 /* punctuation */: return ClassificationTypeNames.punctuation;
+                case 11 /* className */: return ClassificationTypeNames.className;
+                case 12 /* enumName */: return ClassificationTypeNames.enumName;
+                case 13 /* interfaceName */: return ClassificationTypeNames.interfaceName;
+                case 14 /* moduleName */: return ClassificationTypeNames.moduleName;
+                case 15 /* typeParameterName */: return ClassificationTypeNames.typeParameterName;
+                case 16 /* typeAliasName */: return ClassificationTypeNames.typeAliasName;
+                case 17 /* parameterName */: return ClassificationTypeNames.parameterName;
+                case 18 /* docCommentTagName */: return ClassificationTypeNames.docCommentTagName;
+                case 19 /* jsxOpenTagName */: return ClassificationTypeNames.jsxOpenTagName;
+                case 20 /* jsxCloseTagName */: return ClassificationTypeNames.jsxCloseTagName;
+                case 21 /* jsxSelfClosingTagName */: return ClassificationTypeNames.jsxSelfClosingTagName;
+                case 22 /* jsxAttribute */: return ClassificationTypeNames.jsxAttribute;
+                case 23 /* jsxText */: return ClassificationTypeNames.jsxText;
+                case 24 /* jsxAttributeStringLiteralValue */: return ClassificationTypeNames.jsxAttributeStringLiteralValue;
+            }
+        }
+        function convertClassifications(classifications) {
+            ts.Debug.assert(classifications.spans.length % 3 === 0);
+            var dense = classifications.spans;
+            var result = [];
+            for (var i = 0, n = dense.length; i < n; i += 3) {
+                result.push({
+                    textSpan: ts.createTextSpan(dense[i], dense[i + 1]),
+                    classificationType: getClassificationTypeName(dense[i + 2])
+                });
+            }
+            return result;
+        }
+        function getSyntacticClassifications(fileName, span) {
+            return convertClassifications(getEncodedSyntacticClassifications(fileName, span));
+        }
+        function getEncodedSyntacticClassifications(fileName, span) {
+            // doesn't use compiler - no need to synchronize with host
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            var spanStart = span.start;
+            var spanLength = span.length;
+            // Make a scanner we can get trivia from.
+            var triviaScanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+            var mergeConflictScanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+            var result = [];
+            processElement(sourceFile);
+            return { spans: result, endOfLineState: 0 /* None */ };
+            function pushClassification(start, length, type) {
+                result.push(start);
+                result.push(length);
+                result.push(type);
+            }
+            function classifyLeadingTriviaAndGetTokenStart(token) {
+                triviaScanner.setTextPos(token.pos);
+                while (true) {
+                    var start = triviaScanner.getTextPos();
+                    // only bother scanning if we have something that could be trivia.
+                    if (!ts.couldStartTrivia(sourceFile.text, start)) {
+                        return start;
+                    }
+                    var kind = triviaScanner.scan();
+                    var end = triviaScanner.getTextPos();
+                    var width = end - start;
+                    // The moment we get something that isn't trivia, then stop processing.
+                    if (!ts.isTrivia(kind)) {
+                        return start;
+                    }
+                    // Don't bother with newlines/whitespace.
+                    if (kind === 4 /* NewLineTrivia */ || kind === 5 /* WhitespaceTrivia */) {
+                        continue;
+                    }
+                    // Only bother with the trivia if it at least intersects the span of interest.
+                    if (ts.isComment(kind)) {
+                        classifyComment(token, kind, start, width);
+                        // Classifying a comment might cause us to reuse the trivia scanner
+                        // (because of jsdoc comments).  So after we classify the comment make
+                        // sure we set the scanner position back to where it needs to be.
+                        triviaScanner.setTextPos(end);
+                        continue;
+                    }
+                    if (kind === 7 /* ConflictMarkerTrivia */) {
+                        var text = sourceFile.text;
+                        var ch = text.charCodeAt(start);
+                        // for the <<<<<<< and >>>>>>> markers, we just add them in as comments
+                        // in the classification stream.
+                        if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) {
+                            pushClassification(start, width, 1 /* comment */);
+                            continue;
+                        }
+                        // for the ======== add a comment for the first line, and then lex all
+                        // subsequent lines up until the end of the conflict marker.
+                        ts.Debug.assert(ch === 61 /* equals */);
+                        classifyDisabledMergeCode(text, start, end);
+                    }
+                }
+            }
+            function classifyComment(token, kind, start, width) {
+                if (kind === 3 /* MultiLineCommentTrivia */) {
+                    // See if this is a doc comment.  If so, we'll classify certain portions of it
+                    // specially.
+                    var docCommentAndDiagnostics = ts.parseIsolatedJSDocComment(sourceFile.text, start, width);
+                    if (docCommentAndDiagnostics && docCommentAndDiagnostics.jsDocComment) {
+                        docCommentAndDiagnostics.jsDocComment.parent = token;
+                        classifyJSDocComment(docCommentAndDiagnostics.jsDocComment);
+                        return;
+                    }
+                }
+                // Simple comment.  Just add as is.
+                pushCommentRange(start, width);
+            }
+            function pushCommentRange(start, width) {
+                pushClassification(start, width, 1 /* comment */);
+            }
+            function classifyJSDocComment(docComment) {
+                var pos = docComment.pos;
+                for (var _i = 0, _a = docComment.tags; _i < _a.length; _i++) {
+                    var tag = _a[_i];
+                    // As we walk through each tag, classify the portion of text from the end of
+                    // the last tag (or the start of the entire doc comment) as 'comment'.
+                    if (tag.pos !== pos) {
+                        pushCommentRange(pos, tag.pos - pos);
+                    }
+                    pushClassification(tag.atToken.pos, tag.atToken.end - tag.atToken.pos, 10 /* punctuation */);
+                    pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18 /* docCommentTagName */);
+                    pos = tag.tagName.end;
+                    switch (tag.kind) {
+                        case 275 /* JSDocParameterTag */:
+                            processJSDocParameterTag(tag);
+                            break;
+                        case 278 /* JSDocTemplateTag */:
+                            processJSDocTemplateTag(tag);
+                            break;
+                        case 277 /* JSDocTypeTag */:
+                            processElement(tag.typeExpression);
+                            break;
+                        case 276 /* JSDocReturnTag */:
+                            processElement(tag.typeExpression);
+                            break;
+                    }
+                    pos = tag.end;
+                }
+                if (pos !== docComment.end) {
+                    pushCommentRange(pos, docComment.end - pos);
+                }
+                return;
+                function processJSDocParameterTag(tag) {
+                    if (tag.preParameterName) {
+                        pushCommentRange(pos, tag.preParameterName.pos - pos);
+                        pushClassification(tag.preParameterName.pos, tag.preParameterName.end - tag.preParameterName.pos, 17 /* parameterName */);
+                        pos = tag.preParameterName.end;
+                    }
+                    if (tag.typeExpression) {
+                        pushCommentRange(pos, tag.typeExpression.pos - pos);
+                        processElement(tag.typeExpression);
+                        pos = tag.typeExpression.end;
+                    }
+                    if (tag.postParameterName) {
+                        pushCommentRange(pos, tag.postParameterName.pos - pos);
+                        pushClassification(tag.postParameterName.pos, tag.postParameterName.end - tag.postParameterName.pos, 17 /* parameterName */);
+                        pos = tag.postParameterName.end;
+                    }
+                }
+            }
+            function processJSDocTemplateTag(tag) {
+                for (var _i = 0, _a = tag.getChildren(); _i < _a.length; _i++) {
+                    var child = _a[_i];
+                    processElement(child);
+                }
+            }
+            function classifyDisabledMergeCode(text, start, end) {
+                // Classify the line that the ======= marker is on as a comment.  Then just lex
+                // all further tokens and add them to the result.
+                var i;
+                for (i = start; i < end; i++) {
+                    if (ts.isLineBreak(text.charCodeAt(i))) {
+                        break;
+                    }
+                }
+                pushClassification(start, i - start, 1 /* comment */);
+                mergeConflictScanner.setTextPos(i);
+                while (mergeConflictScanner.getTextPos() < end) {
+                    classifyDisabledCodeToken();
+                }
+            }
+            function classifyDisabledCodeToken() {
+                var start = mergeConflictScanner.getTextPos();
+                var tokenKind = mergeConflictScanner.scan();
+                var end = mergeConflictScanner.getTextPos();
+                var type = classifyTokenType(tokenKind);
+                if (type) {
+                    pushClassification(start, end - start, type);
+                }
+            }
+            /**
+             * Returns true if node should be treated as classified and no further processing is required.
+             * False will mean that node is not classified and traverse routine should recurse into node contents.
+             */
+            function tryClassifyNode(node) {
+                if (ts.nodeIsMissing(node)) {
+                    return true;
+                }
+                var classifiedElementName = tryClassifyJsxElementName(node);
+                if (!ts.isToken(node) && node.kind !== 244 /* JsxText */ && classifiedElementName === undefined) {
+                    return false;
+                }
+                var tokenStart = node.kind === 244 /* JsxText */ ? node.pos : classifyLeadingTriviaAndGetTokenStart(node);
+                var tokenWidth = node.end - tokenStart;
+                ts.Debug.assert(tokenWidth >= 0);
+                if (tokenWidth > 0) {
+                    var type = classifiedElementName || classifyTokenType(node.kind, node);
+                    if (type) {
+                        pushClassification(tokenStart, tokenWidth, type);
+                    }
+                }
+                return true;
+            }
+            function tryClassifyJsxElementName(token) {
+                switch (token.parent && token.parent.kind) {
+                    case 243 /* JsxOpeningElement */:
+                        if (token.parent.tagName === token) {
+                            return 19 /* jsxOpenTagName */;
+                        }
+                        break;
+                    case 245 /* JsxClosingElement */:
+                        if (token.parent.tagName === token) {
+                            return 20 /* jsxCloseTagName */;
+                        }
+                        break;
+                    case 242 /* JsxSelfClosingElement */:
+                        if (token.parent.tagName === token) {
+                            return 21 /* jsxSelfClosingTagName */;
+                        }
+                        break;
+                    case 246 /* JsxAttribute */:
+                        if (token.parent.name === token) {
+                            return 22 /* jsxAttribute */;
+                        }
+                        break;
+                }
+                return undefined;
+            }
+            // for accurate classification, the actual token should be passed in.  however, for
+            // cases like 'disabled merge code' classification, we just get the token kind and
+            // classify based on that instead.
+            function classifyTokenType(tokenKind, token) {
+                if (ts.isKeyword(tokenKind)) {
+                    return 3 /* keyword */;
+                }
+                // Special case < and >  If they appear in a generic context they are punctuation,
+                // not operators.
+                if (tokenKind === 25 /* LessThanToken */ || tokenKind === 27 /* GreaterThanToken */) {
+                    // If the node owning the token has a type argument list or type parameter list, then
+                    // we can effectively assume that a '<' and '>' belong to those lists.
+                    if (token && ts.getTypeArgumentOrTypeParameterList(token.parent)) {
+                        return 10 /* punctuation */;
+                    }
+                }
+                if (ts.isPunctuation(tokenKind)) {
+                    if (token) {
+                        if (tokenKind === 56 /* EqualsToken */) {
+                            // the '=' in a variable declaration is special cased here.
+                            if (token.parent.kind === 218 /* VariableDeclaration */ ||
+                                token.parent.kind === 145 /* PropertyDeclaration */ ||
+                                token.parent.kind === 142 /* Parameter */ ||
+                                token.parent.kind === 246 /* JsxAttribute */) {
+                                return 5 /* operator */;
+                            }
+                        }
+                        if (token.parent.kind === 187 /* BinaryExpression */ ||
+                            token.parent.kind === 185 /* PrefixUnaryExpression */ ||
+                            token.parent.kind === 186 /* PostfixUnaryExpression */ ||
+                            token.parent.kind === 188 /* ConditionalExpression */) {
+                            return 5 /* operator */;
+                        }
+                    }
+                    return 10 /* punctuation */;
+                }
+                else if (tokenKind === 8 /* NumericLiteral */) {
+                    return 4 /* numericLiteral */;
+                }
+                else if (tokenKind === 9 /* StringLiteral */ || tokenKind === 166 /* StringLiteralType */) {
+                    return token.parent.kind === 246 /* JsxAttribute */ ? 24 /* jsxAttributeStringLiteralValue */ : 6 /* stringLiteral */;
+                }
+                else if (tokenKind === 10 /* RegularExpressionLiteral */) {
+                    // TODO: we should get another classification type for these literals.
+                    return 6 /* stringLiteral */;
+                }
+                else if (ts.isTemplateLiteralKind(tokenKind)) {
+                    // TODO (drosen): we should *also* get another classification type for these literals.
+                    return 6 /* stringLiteral */;
+                }
+                else if (tokenKind === 244 /* JsxText */) {
+                    return 23 /* jsxText */;
+                }
+                else if (tokenKind === 69 /* Identifier */) {
+                    if (token) {
+                        switch (token.parent.kind) {
+                            case 221 /* ClassDeclaration */:
+                                if (token.parent.name === token) {
+                                    return 11 /* className */;
+                                }
+                                return;
+                            case 141 /* TypeParameter */:
+                                if (token.parent.name === token) {
+                                    return 15 /* typeParameterName */;
+                                }
+                                return;
+                            case 222 /* InterfaceDeclaration */:
+                                if (token.parent.name === token) {
+                                    return 13 /* interfaceName */;
+                                }
+                                return;
+                            case 224 /* EnumDeclaration */:
+                                if (token.parent.name === token) {
+                                    return 12 /* enumName */;
+                                }
+                                return;
+                            case 225 /* ModuleDeclaration */:
+                                if (token.parent.name === token) {
+                                    return 14 /* moduleName */;
+                                }
+                                return;
+                            case 142 /* Parameter */:
+                                if (token.parent.name === token) {
+                                    var isThis_1 = token.kind === 69 /* Identifier */ && token.originalKeywordKind === 97 /* ThisKeyword */;
+                                    return isThis_1 ? 3 /* keyword */ : 17 /* parameterName */;
+                                }
+                                return;
+                        }
+                    }
+                    return 2 /* identifier */;
+                }
+            }
+            function processElement(element) {
+                if (!element) {
+                    return;
+                }
+                // Ignore nodes that don't intersect the original span to classify.
+                if (ts.decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
+                    checkForClassificationCancellation(element.kind);
+                    var children = element.getChildren(sourceFile);
+                    for (var i = 0, n = children.length; i < n; i++) {
+                        var child = children[i];
+                        if (!tryClassifyNode(child)) {
+                            // Recurse into our child nodes.
+                            processElement(child);
+                        }
+                    }
+                }
+            }
+        }
+        function getOutliningSpans(fileName) {
+            // doesn't use compiler - no need to synchronize with host
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            return ts.OutliningElementsCollector.collectElements(sourceFile);
+        }
+        function getBraceMatchingAtPosition(fileName, position) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            var result = [];
+            var token = ts.getTouchingToken(sourceFile, position);
+            if (token.getStart(sourceFile) === position) {
+                var matchKind = getMatchingTokenKind(token);
+                // Ensure that there is a corresponding token to match ours.
+                if (matchKind) {
+                    var parentElement = token.parent;
+                    var childNodes = parentElement.getChildren(sourceFile);
+                    for (var _i = 0, childNodes_1 = childNodes; _i < childNodes_1.length; _i++) {
+                        var current = childNodes_1[_i];
+                        if (current.kind === matchKind) {
+                            var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile));
+                            var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile));
+                            // We want to order the braces when we return the result.
+                            if (range1.start < range2.start) {
+                                result.push(range1, range2);
+                            }
+                            else {
+                                result.push(range2, range1);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            return result;
+            function getMatchingTokenKind(token) {
+                switch (token.kind) {
+                    case 15 /* OpenBraceToken */: return 16 /* CloseBraceToken */;
+                    case 17 /* OpenParenToken */: return 18 /* CloseParenToken */;
+                    case 19 /* OpenBracketToken */: return 20 /* CloseBracketToken */;
+                    case 25 /* LessThanToken */: return 27 /* GreaterThanToken */;
+                    case 16 /* CloseBraceToken */: return 15 /* OpenBraceToken */;
+                    case 18 /* CloseParenToken */: return 17 /* OpenParenToken */;
+                    case 20 /* CloseBracketToken */: return 19 /* OpenBracketToken */;
+                    case 27 /* GreaterThanToken */: return 25 /* LessThanToken */;
+                }
+                return undefined;
+            }
+        }
+        function getIndentationAtPosition(fileName, position, editorOptions) {
+            var start = new Date().getTime();
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start));
+            start = new Date().getTime();
+            var result = ts.formatting.SmartIndenter.getIndentation(position, sourceFile, editorOptions);
+            log("getIndentationAtPosition: computeIndentation  : " + (new Date().getTime() - start));
+            return result;
+        }
+        function getFormattingEditsForRange(fileName, start, end, options) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(options), options);
+        }
+        function getFormattingEditsForDocument(fileName, options) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            return ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options);
+        }
+        function getFormattingEditsAfterKeystroke(fileName, position, key, options) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            if (key === "}") {
+                return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(options), options);
+            }
+            else if (key === ";") {
+                return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(options), options);
+            }
+            else if (key === "\n") {
+                return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(options), options);
+            }
+            return [];
+        }
+        /**
+         * Checks if position points to a valid position to add JSDoc comments, and if so,
+         * returns the appropriate template. Otherwise returns an empty string.
+         * Valid positions are
+         *      - outside of comments, statements, and expressions, and
+         *      - preceding a:
+         *          - function/constructor/method declaration
+         *          - class declarations
+         *          - variable statements
+         *          - namespace declarations
+         *
+         * Hosts should ideally check that:
+         * - The line is all whitespace up to 'position' before performing the insertion.
+         * - If the keystroke sequence "/\*\*" induced the call, we also check that the next
+         * non-whitespace character is '*', which (approximately) indicates whether we added
+         * the second '*' to complete an existing (JSDoc) comment.
+         * @param fileName The file in which to perform the check.
+         * @param position The (character-indexed) position in the file where the check should
+         * be performed.
+         */
+        function getDocCommentTemplateAtPosition(fileName, position) {
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            // Check if in a context where we don't want to perform any insertion
+            if (ts.isInString(sourceFile, position) || ts.isInComment(sourceFile, position) || ts.hasDocComment(sourceFile, position)) {
+                return undefined;
+            }
+            var tokenAtPos = ts.getTokenAtPosition(sourceFile, position);
+            var tokenStart = tokenAtPos.getStart();
+            if (!tokenAtPos || tokenStart < position) {
+                return undefined;
+            }
+            // TODO: add support for:
+            // - enums/enum members
+            // - interfaces
+            // - property declarations
+            // - potentially property assignments
+            var commentOwner;
+            findOwner: for (commentOwner = tokenAtPos; commentOwner; commentOwner = commentOwner.parent) {
+                switch (commentOwner.kind) {
+                    case 220 /* FunctionDeclaration */:
+                    case 147 /* MethodDeclaration */:
+                    case 148 /* Constructor */:
+                    case 221 /* ClassDeclaration */:
+                    case 200 /* VariableStatement */:
+                        break findOwner;
+                    case 256 /* SourceFile */:
+                        return undefined;
+                    case 225 /* ModuleDeclaration */:
+                        // If in walking up the tree, we hit a a nested namespace declaration,
+                        // then we must be somewhere within a dotted namespace name; however we don't
+                        // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'.
+                        if (commentOwner.parent.kind === 225 /* ModuleDeclaration */) {
+                            return undefined;
+                        }
+                        break findOwner;
+                }
+            }
+            if (!commentOwner || commentOwner.getStart() < position) {
+                return undefined;
+            }
+            var parameters = getParametersForJsDocOwningNode(commentOwner);
+            var posLineAndChar = sourceFile.getLineAndCharacterOfPosition(position);
+            var lineStart = sourceFile.getLineStarts()[posLineAndChar.line];
+            var indentationStr = sourceFile.text.substr(lineStart, posLineAndChar.character);
+            var newLine = ts.getNewLineOrDefaultFromHost(host);
+            var docParams = "";
+            for (var i = 0, numParams = parameters.length; i < numParams; i++) {
+                var currentName = parameters[i].name;
+                var paramName = currentName.kind === 69 /* Identifier */ ?
+                    currentName.text :
+                    "param" + i;
+                docParams += indentationStr + " * @param " + paramName + newLine;
+            }
+            // A doc comment consists of the following
+            // * The opening comment line
+            // * the first line (without a param) for the object's untagged info (this is also where the caret ends up)
+            // * the '@param'-tagged lines
+            // * TODO: other tags.
+            // * the closing comment line
+            // * if the caret was directly in front of the object, then we add an extra line and indentation.
+            var preamble = "/**" + newLine +
+                indentationStr + " * ";
+            var result = preamble + newLine +
+                docParams +
+                indentationStr + " */" +
+                (tokenStart === position ? newLine + indentationStr : "");
+            return { newText: result, caretOffset: preamble.length };
+        }
+        function isValidBraceCompletionAtPosition(fileName, position, openingBrace) {
+            // '<' is currently not supported, figuring out if we're in a Generic Type vs. a comparison is too
+            // expensive to do during typing scenarios
+            // i.e. whether we're dealing with:
+            //      var x = new foo<| ( with class foo<T>{} )
+            // or
+            //      var y = 3 <|
+            if (openingBrace === 60 /* lessThan */) {
+                return false;
+            }
+            var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            // Check if in a context where we don't want to perform any insertion
+            if (ts.isInString(sourceFile, position) || ts.isInComment(sourceFile, position)) {
+                return false;
+            }
+            if (ts.isInsideJsxElementOrAttribute(sourceFile, position)) {
+                return openingBrace === 123 /* openBrace */;
+            }
+            if (ts.isInTemplateString(sourceFile, position)) {
+                return false;
+            }
+            return true;
+        }
+        function getParametersForJsDocOwningNode(commentOwner) {
+            if (ts.isFunctionLike(commentOwner)) {
+                return commentOwner.parameters;
+            }
+            if (commentOwner.kind === 200 /* VariableStatement */) {
+                var varStatement = commentOwner;
+                var varDeclarations = varStatement.declarationList.declarations;
+                if (varDeclarations.length === 1 && varDeclarations[0].initializer) {
+                    return getParametersFromRightHandSideOfAssignment(varDeclarations[0].initializer);
+                }
+            }
+            return emptyArray;
+        }
+        /**
+         * Digs into an an initializer or RHS operand of an assignment operation
+         * to get the parameters of an apt signature corresponding to a
+         * function expression or a class expression.
+         *
+         * @param rightHandSide the expression which may contain an appropriate set of parameters
+         * @returns the parameters of a signature found on the RHS if one exists; otherwise 'emptyArray'.
+         */
+        function getParametersFromRightHandSideOfAssignment(rightHandSide) {
+            while (rightHandSide.kind === 178 /* ParenthesizedExpression */) {
+                rightHandSide = rightHandSide.expression;
+            }
+            switch (rightHandSide.kind) {
+                case 179 /* FunctionExpression */:
+                case 180 /* ArrowFunction */:
+                    return rightHandSide.parameters;
+                case 192 /* ClassExpression */:
+                    for (var _i = 0, _a = rightHandSide.members; _i < _a.length; _i++) {
+                        var member = _a[_i];
+                        if (member.kind === 148 /* Constructor */) {
+                            return member.parameters;
+                        }
+                    }
+                    break;
+            }
+            return emptyArray;
+        }
+        function getTodoComments(fileName, descriptors) {
+            // Note: while getting todo comments seems like a syntactic operation, we actually
+            // treat it as a semantic operation here.  This is because we expect our host to call
+            // this on every single file.  If we treat this syntactically, then that will cause
+            // us to populate and throw away the tree in our syntax tree cache for each file.  By
+            // treating this as a semantic operation, we can access any tree without throwing
+            // anything away.
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            cancellationToken.throwIfCancellationRequested();
+            var fileContents = sourceFile.text;
+            var result = [];
+            if (descriptors.length > 0) {
+                var regExp = getTodoCommentsRegExp();
+                var matchArray = void 0;
+                while (matchArray = regExp.exec(fileContents)) {
+                    cancellationToken.throwIfCancellationRequested();
+                    // If we got a match, here is what the match array will look like.  Say the source text is:
+                    //
+                    //      "    // hack   1"
+                    //
+                    // The result array with the regexp:    will be:
+                    //
+                    //      ["// hack   1", "// ", "hack   1", undefined, "hack"]
+                    //
+                    // Here are the relevant capture groups:
+                    //  0) The full match for the entire regexp.
+                    //  1) The preamble to the message portion.
+                    //  2) The message portion.
+                    //  3...N) The descriptor that was matched - by index.  'undefined' for each
+                    //         descriptor that didn't match.  an actual value if it did match.
+                    //
+                    //  i.e. 'undefined' in position 3 above means TODO(jason) didn't match.
+                    //       "hack"      in position 4 means HACK did match.
+                    var firstDescriptorCaptureIndex = 3;
+                    ts.Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
+                    var preamble = matchArray[1];
+                    var matchPosition = matchArray.index + preamble.length;
+                    // OK, we have found a match in the file.  This is only an acceptable match if
+                    // it is contained within a comment.
+                    var token = ts.getTokenAtPosition(sourceFile, matchPosition);
+                    if (!isInsideComment(sourceFile, token, matchPosition)) {
+                        continue;
+                    }
+                    var descriptor = undefined;
+                    for (var i = 0, n = descriptors.length; i < n; i++) {
+                        if (matchArray[i + firstDescriptorCaptureIndex]) {
+                            descriptor = descriptors[i];
+                        }
+                    }
+                    ts.Debug.assert(descriptor !== undefined);
+                    // We don't want to match something like 'TODOBY', so we make sure a non
+                    // letter/digit follows the match.
+                    if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
+                        continue;
+                    }
+                    var message = matchArray[2];
+                    result.push({
+                        descriptor: descriptor,
+                        message: message,
+                        position: matchPosition
+                    });
+                }
+            }
+            return result;
+            function escapeRegExp(str) {
+                return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+            }
+            function getTodoCommentsRegExp() {
+                // NOTE: ?:  means 'non-capture group'.  It allows us to have groups without having to
+                // filter them out later in the final result array.
+                // TODO comments can appear in one of the following forms:
+                //
+                //  1)      // TODO     or  /////////// TODO
+                //
+                //  2)      /* TODO     or  /********** TODO
+                //
+                //  3)      /*
+                //           *   TODO
+                //           */
+                //
+                // The following three regexps are used to match the start of the text up to the TODO
+                // comment portion.
+                var singleLineCommentStart = /(?:\/\/+\s*)/.source;
+                var multiLineCommentStart = /(?:\/\*+\s*)/.source;
+                var anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
+                // Match any of the above three TODO comment start regexps.
+                // Note that the outermost group *is* a capture group.  We want to capture the preamble
+                // so that we can determine the starting position of the TODO comment match.
+                var preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
+                // Takes the descriptors and forms a regexp that matches them as if they were literals.
+                // For example, if the descriptors are "TODO(jason)" and "HACK", then this will be:
+                //
+                //      (?:(TODO\(jason\))|(HACK))
+                //
+                // Note that the outermost group is *not* a capture group, but the innermost groups
+                // *are* capture groups.  By capturing the inner literals we can determine after
+                // matching which descriptor we are dealing with.
+                var literals = "(?:" + ts.map(descriptors, function (d) { return "(" + escapeRegExp(d.text) + ")"; }).join("|") + ")";
+                // After matching a descriptor literal, the following regexp matches the rest of the
+                // text up to the end of the line (or */).
+                var endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
+                var messageRemainder = /(?:.*?)/.source;
+                // This is the portion of the match we'll return as part of the TODO comment result. We
+                // match the literal portion up to the end of the line or end of comment.
+                var messagePortion = "(" + literals + messageRemainder + ")";
+                var regExpString = preamble + messagePortion + endOfLineOrEndOfComment;
+                // The final regexp will look like this:
+                // /((?:\/\/+\s*)|(?:\/\*+\s*)|(?:^(?:\s|\*)*))((?:(TODO\(jason\))|(HACK))(?:.*?))(?:$|\*\/)/gim
+                // The flags of the regexp are important here.
+                //  'g' is so that we are doing a global search and can find matches several times
+                //  in the input.
+                //
+                //  'i' is for case insensitivity (We do this to match C# TODO comment code).
+                //
+                //  'm' is so we can find matches in a multi-line input.
+                return new RegExp(regExpString, "gim");
+            }
+            function isLetterOrDigit(char) {
+                return (char >= 97 /* a */ && char <= 122 /* z */) ||
+                    (char >= 65 /* A */ && char <= 90 /* Z */) ||
+                    (char >= 48 /* _0 */ && char <= 57 /* _9 */);
+            }
+        }
+        function getStringLiteralTypeForNode(node, typeChecker) {
+            var searchNode = node.parent.kind === 166 /* StringLiteralType */ ? node.parent : node;
+            var type = typeChecker.getTypeAtLocation(searchNode);
+            if (type && type.flags & 256 /* StringLiteral */) {
+                return type;
+            }
+            return undefined;
+        }
+        function getRenameInfo(fileName, position) {
+            synchronizeHostData();
+            var sourceFile = getValidSourceFile(fileName);
+            var typeChecker = program.getTypeChecker();
+            var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings());
+            var canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
+            var node = ts.getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
+            if (node) {
+                if (node.kind === 69 /* Identifier */ ||
+                    node.kind === 9 /* StringLiteral */ ||
+                    isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+                    isThis(node)) {
+                    var symbol = typeChecker.getSymbolAtLocation(node);
+                    // Only allow a symbol to be renamed if it actually has at least one declaration.
+                    if (symbol) {
+                        var declarations = symbol.getDeclarations();
+                        if (declarations && declarations.length > 0) {
+                            // Disallow rename for elements that are defined in the standard TypeScript library.
+                            if (ts.forEach(declarations, isDefinedInLibraryFile)) {
+                                return getRenameInfoError(ts.getLocaleSpecificMessage(ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                            }
+                            var displayName = ts.stripQuotes(ts.getDeclaredName(typeChecker, symbol, node));
+                            var kind = getSymbolKind(symbol, node);
+                            if (kind) {
+                                return {
+                                    canRename: true,
+                                    kind: kind,
+                                    displayName: displayName,
+                                    localizedErrorMessage: undefined,
+                                    fullDisplayName: typeChecker.getFullyQualifiedName(symbol),
+                                    kindModifiers: getSymbolModifiers(symbol),
+                                    triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                                };
+                            }
+                        }
+                    }
+                    else if (node.kind === 9 /* StringLiteral */) {
+                        var type = getStringLiteralTypeForNode(node, typeChecker);
+                        if (type) {
+                            if (isDefinedInLibraryFile(node)) {
+                                return getRenameInfoError(ts.getLocaleSpecificMessage(ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                            }
+                            else {
+                                var displayName = ts.stripQuotes(type.text);
+                                return {
+                                    canRename: true,
+                                    kind: ScriptElementKind.variableElement,
+                                    displayName: displayName,
+                                    localizedErrorMessage: undefined,
+                                    fullDisplayName: displayName,
+                                    kindModifiers: ScriptElementKindModifier.none,
+                                    triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            return getRenameInfoError(ts.getLocaleSpecificMessage(ts.Diagnostics.You_cannot_rename_this_element));
+            function getRenameInfoError(localizedErrorMessage) {
+                return {
+                    canRename: false,
+                    localizedErrorMessage: localizedErrorMessage,
+                    displayName: undefined,
+                    fullDisplayName: undefined,
+                    kind: undefined,
+                    kindModifiers: undefined,
+                    triggerSpan: undefined
+                };
+            }
+            function isDefinedInLibraryFile(declaration) {
+                if (defaultLibFileName) {
+                    var sourceFile_2 = declaration.getSourceFile();
+                    var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName));
+                    if (canonicalName === canonicalDefaultLibName) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function createTriggerSpanForNode(node, sourceFile) {
+                var start = node.getStart(sourceFile);
+                var width = node.getWidth(sourceFile);
+                if (node.kind === 9 /* StringLiteral */) {
+                    // Exclude the quotes
+                    start += 1;
+                    width -= 2;
+                }
+                return ts.createTextSpan(start, width);
+            }
+        }
+        return {
+            dispose: dispose,
+            cleanupSemanticCache: cleanupSemanticCache,
+            getSyntacticDiagnostics: getSyntacticDiagnostics,
+            getSemanticDiagnostics: getSemanticDiagnostics,
+            getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics,
+            getSyntacticClassifications: getSyntacticClassifications,
+            getSemanticClassifications: getSemanticClassifications,
+            getEncodedSyntacticClassifications: getEncodedSyntacticClassifications,
+            getEncodedSemanticClassifications: getEncodedSemanticClassifications,
+            getCompletionsAtPosition: getCompletionsAtPosition,
+            getCompletionEntryDetails: getCompletionEntryDetails,
+            getSignatureHelpItems: getSignatureHelpItems,
+            getQuickInfoAtPosition: getQuickInfoAtPosition,
+            getDefinitionAtPosition: getDefinitionAtPosition,
+            getTypeDefinitionAtPosition: getTypeDefinitionAtPosition,
+            getReferencesAtPosition: getReferencesAtPosition,
+            findReferences: findReferences,
+            getOccurrencesAtPosition: getOccurrencesAtPosition,
+            getDocumentHighlights: getDocumentHighlights,
+            getNameOrDottedNameSpan: getNameOrDottedNameSpan,
+            getBreakpointStatementAtPosition: getBreakpointStatementAtPosition,
+            getNavigateToItems: getNavigateToItems,
+            getRenameInfo: getRenameInfo,
+            findRenameLocations: findRenameLocations,
+            getNavigationBarItems: getNavigationBarItems,
+            getOutliningSpans: getOutliningSpans,
+            getTodoComments: getTodoComments,
+            getBraceMatchingAtPosition: getBraceMatchingAtPosition,
+            getIndentationAtPosition: getIndentationAtPosition,
+            getFormattingEditsForRange: getFormattingEditsForRange,
+            getFormattingEditsForDocument: getFormattingEditsForDocument,
+            getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke,
+            getDocCommentTemplateAtPosition: getDocCommentTemplateAtPosition,
+            isValidBraceCompletionAtPosition: isValidBraceCompletionAtPosition,
+            getEmitOutput: getEmitOutput,
+            getNonBoundSourceFile: getNonBoundSourceFile,
+            getProgram: getProgram
+        };
+    }
+    ts.createLanguageService = createLanguageService;
+    /* @internal */
+    function getNameTable(sourceFile) {
+        if (!sourceFile.nameTable) {
+            initializeNameTable(sourceFile);
+        }
+        return sourceFile.nameTable;
+    }
+    ts.getNameTable = getNameTable;
+    function initializeNameTable(sourceFile) {
+        var nameTable = {};
+        walk(sourceFile);
+        sourceFile.nameTable = nameTable;
+        function walk(node) {
+            switch (node.kind) {
+                case 69 /* Identifier */:
+                    nameTable[node.text] = nameTable[node.text] === undefined ? node.pos : -1;
+                    break;
+                case 9 /* StringLiteral */:
+                case 8 /* NumericLiteral */:
+                    // We want to store any numbers/strings if they were a name that could be
+                    // related to a declaration.  So, if we have 'import x = require("something")'
+                    // then we want 'something' to be in the name table.  Similarly, if we have
+                    // "a['propname']" then we want to store "propname" in the name table.
+                    if (ts.isDeclarationName(node) ||
+                        node.parent.kind === 240 /* ExternalModuleReference */ ||
+                        isArgumentOfElementAccessExpression(node) ||
+                        ts.isLiteralComputedPropertyDeclarationName(node)) {
+                        nameTable[node.text] = nameTable[node.text] === undefined ? node.pos : -1;
+                    }
+                    break;
+                default:
+                    ts.forEachChild(node, walk);
+                    if (node.jsDocComments) {
+                        for (var _i = 0, _a = node.jsDocComments; _i < _a.length; _i++) {
+                            var jsDocComment = _a[_i];
+                            ts.forEachChild(jsDocComment, walk);
+                        }
+                    }
+            }
+        }
+    }
+    function isArgumentOfElementAccessExpression(node) {
+        return node &&
+            node.parent &&
+            node.parent.kind === 173 /* ElementAccessExpression */ &&
+            node.parent.argumentExpression === node;
+    }
+    /// Classifier
+    function createClassifier() {
+        var scanner = ts.createScanner(2 /* Latest */, /*skipTrivia*/ false);
+        /// We do not have a full parser support to know when we should parse a regex or not
+        /// If we consider every slash token to be a regex, we could be missing cases like "1/2/3", where
+        /// we have a series of divide operator. this list allows us to be more accurate by ruling out
+        /// locations where a regexp cannot exist.
+        var noRegexTable = [];
+        noRegexTable[69 /* Identifier */] = true;
+        noRegexTable[9 /* StringLiteral */] = true;
+        noRegexTable[8 /* NumericLiteral */] = true;
+        noRegexTable[10 /* RegularExpressionLiteral */] = true;
+        noRegexTable[97 /* ThisKeyword */] = true;
+        noRegexTable[41 /* PlusPlusToken */] = true;
+        noRegexTable[42 /* MinusMinusToken */] = true;
+        noRegexTable[18 /* CloseParenToken */] = true;
+        noRegexTable[20 /* CloseBracketToken */] = true;
+        noRegexTable[16 /* CloseBraceToken */] = true;
+        noRegexTable[99 /* TrueKeyword */] = true;
+        noRegexTable[84 /* FalseKeyword */] = true;
+        // Just a stack of TemplateHeads and OpenCurlyBraces, used to perform rudimentary (inexact)
+        // classification on template strings. Because of the context free nature of templates,
+        // the only precise way to classify a template portion would be by propagating the stack across
+        // lines, just as we do with the end-of-line state. However, this is a burden for implementers,
+        // and the behavior is entirely subsumed by the syntactic classifier anyway, so we instead
+        // flatten any nesting when the template stack is non-empty and encode it in the end-of-line state.
+        // Situations in which this fails are
+        //  1) When template strings are nested across different lines:
+        //          `hello ${ `world
+        //          ` }`
+        //
+        //     Where on the second line, you will get the closing of a template,
+        //     a closing curly, and a new template.
+        //
+        //  2) When substitution expressions have curly braces and the curly brace falls on the next line:
+        //          `hello ${ () => {
+        //          return "world" } } `
+        //
+        //     Where on the second line, you will get the 'return' keyword,
+        //     a string literal, and a template end consisting of '} } `'.
+        var templateStack = [];
+        /** Returns true if 'keyword2' can legally follow 'keyword1' in any language construct. */
+        function canFollow(keyword1, keyword2) {
+            if (ts.isAccessibilityModifier(keyword1)) {
+                if (keyword2 === 123 /* GetKeyword */ ||
+                    keyword2 === 131 /* SetKeyword */ ||
+                    keyword2 === 121 /* ConstructorKeyword */ ||
+                    keyword2 === 113 /* StaticKeyword */) {
+                    // Allow things like "public get", "public constructor" and "public static".
+                    // These are all legal.
+                    return true;
+                }
+                // Any other keyword following "public" is actually an identifier an not a real
+                // keyword.
+                return false;
+            }
+            // Assume any other keyword combination is legal.  This can be refined in the future
+            // if there are more cases we want the classifier to be better at.
+            return true;
+        }
+        function convertClassifications(classifications, text) {
+            var entries = [];
+            var dense = classifications.spans;
+            var lastEnd = 0;
+            for (var i = 0, n = dense.length; i < n; i += 3) {
+                var start = dense[i];
+                var length_3 = dense[i + 1];
+                var type = dense[i + 2];
+                // Make a whitespace entry between the last item and this one.
+                if (lastEnd >= 0) {
+                    var whitespaceLength_1 = start - lastEnd;
+                    if (whitespaceLength_1 > 0) {
+                        entries.push({ length: whitespaceLength_1, classification: TokenClass.Whitespace });
+                    }
+                }
+                entries.push({ length: length_3, classification: convertClassification(type) });
+                lastEnd = start + length_3;
+            }
+            var whitespaceLength = text.length - lastEnd;
+            if (whitespaceLength > 0) {
+                entries.push({ length: whitespaceLength, classification: TokenClass.Whitespace });
+            }
+            return { entries: entries, finalLexState: classifications.endOfLineState };
+        }
+        function convertClassification(type) {
+            switch (type) {
+                case 1 /* comment */: return TokenClass.Comment;
+                case 3 /* keyword */: return TokenClass.Keyword;
+                case 4 /* numericLiteral */: return TokenClass.NumberLiteral;
+                case 5 /* operator */: return TokenClass.Operator;
+                case 6 /* stringLiteral */: return TokenClass.StringLiteral;
+                case 8 /* whiteSpace */: return TokenClass.Whitespace;
+                case 10 /* punctuation */: return TokenClass.Punctuation;
+                case 2 /* identifier */:
+                case 11 /* className */:
+                case 12 /* enumName */:
+                case 13 /* interfaceName */:
+                case 14 /* moduleName */:
+                case 15 /* typeParameterName */:
+                case 16 /* typeAliasName */:
+                case 9 /* text */:
+                case 17 /* parameterName */:
+                default:
+                    return TokenClass.Identifier;
+            }
+        }
+        function getClassificationsForLine(text, lexState, syntacticClassifierAbsent) {
+            return convertClassifications(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text);
+        }
+        // If there is a syntactic classifier ('syntacticClassifierAbsent' is false),
+        // we will be more conservative in order to avoid conflicting with the syntactic classifier.
+        function getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent) {
+            var offset = 0;
+            var token = 0 /* Unknown */;
+            var lastNonTriviaToken = 0 /* Unknown */;
+            // Empty out the template stack for reuse.
+            while (templateStack.length > 0) {
+                templateStack.pop();
+            }
+            // If we're in a string literal, then prepend: "\
+            // (and a newline).  That way when we lex we'll think we're still in a string literal.
+            //
+            // If we're in a multiline comment, then prepend: /*
+            // (and a newline).  That way when we lex we'll think we're still in a multiline comment.
+            switch (lexState) {
+                case 3 /* InDoubleQuoteStringLiteral */:
+                    text = "\"\\\n" + text;
+                    offset = 3;
+                    break;
+                case 2 /* InSingleQuoteStringLiteral */:
+                    text = "'\\\n" + text;
+                    offset = 3;
+                    break;
+                case 1 /* InMultiLineCommentTrivia */:
+                    text = "/*\n" + text;
+                    offset = 3;
+                    break;
+                case 4 /* InTemplateHeadOrNoSubstitutionTemplate */:
+                    text = "`\n" + text;
+                    offset = 2;
+                    break;
+                case 5 /* InTemplateMiddleOrTail */:
+                    text = "}\n" + text;
+                    offset = 2;
+                // fallthrough
+                case 6 /* InTemplateSubstitutionPosition */:
+                    templateStack.push(12 /* TemplateHead */);
+                    break;
+            }
+            scanner.setText(text);
+            var result = {
+                endOfLineState: 0 /* None */,
+                spans: []
+            };
+            // We can run into an unfortunate interaction between the lexical and syntactic classifier
+            // when the user is typing something generic.  Consider the case where the user types:
+            //
+            //      Foo<number
+            //
+            // From the lexical classifier's perspective, 'number' is a keyword, and so the word will
+            // be classified as such.  However, from the syntactic classifier's tree-based perspective
+            // this is simply an expression with the identifier 'number' on the RHS of the less than
+            // token.  So the classification will go back to being an identifier.  The moment the user
+            // types again, number will become a keyword, then an identifier, etc. etc.
+            //
+            // To try to avoid this problem, we avoid classifying contextual keywords as keywords
+            // when the user is potentially typing something generic.  We just can't do a good enough
+            // job at the lexical level, and so well leave it up to the syntactic classifier to make
+            // the determination.
+            //
+            // In order to determine if the user is potentially typing something generic, we use a
+            // weak heuristic where we track < and > tokens.  It's a weak heuristic, but should
+            // work well enough in practice.
+            var angleBracketStack = 0;
+            do {
+                token = scanner.scan();
+                if (!ts.isTrivia(token)) {
+                    if ((token === 39 /* SlashToken */ || token === 61 /* SlashEqualsToken */) && !noRegexTable[lastNonTriviaToken]) {
+                        if (scanner.reScanSlashToken() === 10 /* RegularExpressionLiteral */) {
+                            token = 10 /* RegularExpressionLiteral */;
+                        }
+                    }
+                    else if (lastNonTriviaToken === 21 /* DotToken */ && isKeyword(token)) {
+                        token = 69 /* Identifier */;
+                    }
+                    else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) {
+                        // We have two keywords in a row.  Only treat the second as a keyword if
+                        // it's a sequence that could legally occur in the language.  Otherwise
+                        // treat it as an identifier.  This way, if someone writes "private var"
+                        // we recognize that 'var' is actually an identifier here.
+                        token = 69 /* Identifier */;
+                    }
+                    else if (lastNonTriviaToken === 69 /* Identifier */ &&
+                        token === 25 /* LessThanToken */) {
+                        // Could be the start of something generic.  Keep track of that by bumping
+                        // up the current count of generic contexts we may be in.
+                        angleBracketStack++;
+                    }
+                    else if (token === 27 /* GreaterThanToken */ && angleBracketStack > 0) {
+                        // If we think we're currently in something generic, then mark that that
+                        // generic entity is complete.
+                        angleBracketStack--;
+                    }
+                    else if (token === 117 /* AnyKeyword */ ||
+                        token === 132 /* StringKeyword */ ||
+                        token === 130 /* NumberKeyword */ ||
+                        token === 120 /* BooleanKeyword */ ||
+                        token === 133 /* SymbolKeyword */) {
+                        if (angleBracketStack > 0 && !syntacticClassifierAbsent) {
+                            // If it looks like we're could be in something generic, don't classify this
+                            // as a keyword.  We may just get overwritten by the syntactic classifier,
+                            // causing a noisy experience for the user.
+                            token = 69 /* Identifier */;
+                        }
+                    }
+                    else if (token === 12 /* TemplateHead */) {
+                        templateStack.push(token);
+                    }
+                    else if (token === 15 /* OpenBraceToken */) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            templateStack.push(token);
+                        }
+                    }
+                    else if (token === 16 /* CloseBraceToken */) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            var lastTemplateStackToken = ts.lastOrUndefined(templateStack);
+                            if (lastTemplateStackToken === 12 /* TemplateHead */) {
+                                token = scanner.reScanTemplateToken();
+                                // Only pop on a TemplateTail; a TemplateMiddle indicates there is more for us.
+                                if (token === 14 /* TemplateTail */) {
+                                    templateStack.pop();
+                                }
+                                else {
+                                    ts.Debug.assert(token === 13 /* TemplateMiddle */, "Should have been a template middle. Was " + token);
+                                }
+                            }
+                            else {
+                                ts.Debug.assert(lastTemplateStackToken === 15 /* OpenBraceToken */, "Should have been an open brace. Was: " + token);
+                                templateStack.pop();
+                            }
+                        }
+                    }
+                    lastNonTriviaToken = token;
+                }
+                processToken();
+            } while (token !== 1 /* EndOfFileToken */);
+            return result;
+            function processToken() {
+                var start = scanner.getTokenPos();
+                var end = scanner.getTextPos();
+                addResult(start, end, classFromKind(token));
+                if (end >= text.length) {
+                    if (token === 9 /* StringLiteral */ || token === 166 /* StringLiteralType */) {
+                        // Check to see if we finished up on a multiline string literal.
+                        var tokenText = scanner.getTokenText();
+                        if (scanner.isUnterminated()) {
+                            var lastCharIndex = tokenText.length - 1;
+                            var numBackslashes = 0;
+                            while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92 /* backslash */) {
+                                numBackslashes++;
+                            }
+                            // If we have an odd number of backslashes, then the multiline string is unclosed
+                            if (numBackslashes & 1) {
+                                var quoteChar = tokenText.charCodeAt(0);
+                                result.endOfLineState = quoteChar === 34 /* doubleQuote */
+                                    ? 3 /* InDoubleQuoteStringLiteral */
+                                    : 2 /* InSingleQuoteStringLiteral */;
+                            }
+                        }
+                    }
+                    else if (token === 3 /* MultiLineCommentTrivia */) {
+                        // Check to see if the multiline comment was unclosed.
+                        if (scanner.isUnterminated()) {
+                            result.endOfLineState = 1 /* InMultiLineCommentTrivia */;
+                        }
+                    }
+                    else if (ts.isTemplateLiteralKind(token)) {
+                        if (scanner.isUnterminated()) {
+                            if (token === 14 /* TemplateTail */) {
+                                result.endOfLineState = 5 /* InTemplateMiddleOrTail */;
+                            }
+                            else if (token === 11 /* NoSubstitutionTemplateLiteral */) {
+                                result.endOfLineState = 4 /* InTemplateHeadOrNoSubstitutionTemplate */;
+                            }
+                            else {
+                                ts.Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token);
+                            }
+                        }
+                    }
+                    else if (templateStack.length > 0 && ts.lastOrUndefined(templateStack) === 12 /* TemplateHead */) {
+                        result.endOfLineState = 6 /* InTemplateSubstitutionPosition */;
+                    }
+                }
+            }
+            function addResult(start, end, classification) {
+                if (classification === 8 /* whiteSpace */) {
+                    // Don't bother with whitespace classifications.  They're not needed.
+                    return;
+                }
+                if (start === 0 && offset > 0) {
+                    // We're classifying the first token, and this was a case where we prepended
+                    // text.  We should consider the start of this token to be at the start of
+                    // the original text.
+                    start += offset;
+                }
+                // All our tokens are in relation to the augmented text.  Move them back to be
+                // relative to the original text.
+                start -= offset;
+                end -= offset;
+                var length = end - start;
+                if (length > 0) {
+                    result.spans.push(start);
+                    result.spans.push(length);
+                    result.spans.push(classification);
+                }
+            }
+        }
+        function isBinaryExpressionOperatorToken(token) {
+            switch (token) {
+                case 37 /* AsteriskToken */:
+                case 39 /* SlashToken */:
+                case 40 /* PercentToken */:
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 43 /* LessThanLessThanToken */:
+                case 44 /* GreaterThanGreaterThanToken */:
+                case 45 /* GreaterThanGreaterThanGreaterThanToken */:
+                case 25 /* LessThanToken */:
+                case 27 /* GreaterThanToken */:
+                case 28 /* LessThanEqualsToken */:
+                case 29 /* GreaterThanEqualsToken */:
+                case 91 /* InstanceOfKeyword */:
+                case 90 /* InKeyword */:
+                case 116 /* AsKeyword */:
+                case 30 /* EqualsEqualsToken */:
+                case 31 /* ExclamationEqualsToken */:
+                case 32 /* EqualsEqualsEqualsToken */:
+                case 33 /* ExclamationEqualsEqualsToken */:
+                case 46 /* AmpersandToken */:
+                case 48 /* CaretToken */:
+                case 47 /* BarToken */:
+                case 51 /* AmpersandAmpersandToken */:
+                case 52 /* BarBarToken */:
+                case 67 /* BarEqualsToken */:
+                case 66 /* AmpersandEqualsToken */:
+                case 68 /* CaretEqualsToken */:
+                case 63 /* LessThanLessThanEqualsToken */:
+                case 64 /* GreaterThanGreaterThanEqualsToken */:
+                case 65 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
+                case 57 /* PlusEqualsToken */:
+                case 58 /* MinusEqualsToken */:
+                case 59 /* AsteriskEqualsToken */:
+                case 61 /* SlashEqualsToken */:
+                case 62 /* PercentEqualsToken */:
+                case 56 /* EqualsToken */:
+                case 24 /* CommaToken */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        function isPrefixUnaryExpressionOperatorToken(token) {
+            switch (token) {
+                case 35 /* PlusToken */:
+                case 36 /* MinusToken */:
+                case 50 /* TildeToken */:
+                case 49 /* ExclamationToken */:
+                case 41 /* PlusPlusToken */:
+                case 42 /* MinusMinusToken */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        function isKeyword(token) {
+            return token >= 70 /* FirstKeyword */ && token <= 138 /* LastKeyword */;
+        }
+        function classFromKind(token) {
+            if (isKeyword(token)) {
+                return 3 /* keyword */;
+            }
+            else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) {
+                return 5 /* operator */;
+            }
+            else if (token >= 15 /* FirstPunctuation */ && token <= 68 /* LastPunctuation */) {
+                return 10 /* punctuation */;
+            }
+            switch (token) {
+                case 8 /* NumericLiteral */:
+                    return 4 /* numericLiteral */;
+                case 9 /* StringLiteral */:
+                case 166 /* StringLiteralType */:
+                    return 6 /* stringLiteral */;
+                case 10 /* RegularExpressionLiteral */:
+                    return 7 /* regularExpressionLiteral */;
+                case 7 /* ConflictMarkerTrivia */:
+                case 3 /* MultiLineCommentTrivia */:
+                case 2 /* SingleLineCommentTrivia */:
+                    return 1 /* comment */;
+                case 5 /* WhitespaceTrivia */:
+                case 4 /* NewLineTrivia */:
+                    return 8 /* whiteSpace */;
+                case 69 /* Identifier */:
+                default:
+                    if (ts.isTemplateLiteralKind(token)) {
+                        return 6 /* stringLiteral */;
+                    }
+                    return 2 /* identifier */;
+            }
+        }
+        return {
+            getClassificationsForLine: getClassificationsForLine,
+            getEncodedLexicalClassifications: getEncodedLexicalClassifications
+        };
+    }
+    ts.createClassifier = createClassifier;
+    /**
+      * Get the path of the default library files (lib.d.ts) as distributed with the typescript
+      * node package.
+      * The functionality is not supported if the ts module is consumed outside of a node module.
+      */
+    function getDefaultLibFilePath(options) {
+        // Check __dirname is defined and that we are on a node.js system.
+        if (typeof __dirname !== "undefined") {
+            return __dirname + ts.directorySeparator + ts.getDefaultLibFileName(options);
+        }
+        throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. ");
+    }
+    ts.getDefaultLibFilePath = getDefaultLibFilePath;
+    function initializeServices() {
+        ts.objectAllocator = {
+            getNodeConstructor: function () { return NodeObject; },
+            getSourceFileConstructor: function () { return SourceFileObject; },
+            getSymbolConstructor: function () { return SymbolObject; },
+            getTypeConstructor: function () { return TypeObject; },
+            getSignatureConstructor: function () { return SignatureObject; }
+        };
+    }
+    initializeServices();
+})(ts || (ts = {}));
+// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
+// See LICENSE.txt in the project root for complete license information.
+/// <reference path='services.ts' />
+/* @internal */
+var ts;
+(function (ts) {
+    var BreakpointResolver;
+    (function (BreakpointResolver) {
+        /**
+         * Get the breakpoint span in given sourceFile
+         */
+        function spanInSourceFileAtLocation(sourceFile, position) {
+            // Cannot set breakpoint in dts file
+            if (sourceFile.isDeclarationFile) {
+                return undefined;
+            }
+            var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position);
+            var lineOfPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
+            if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart(sourceFile)).line > lineOfPosition) {
+                // Get previous token if the token is returned starts on new line
+                // eg: let x =10; |--- cursor is here
+                //     let y = 10;
+                // token at position will return let keyword on second line as the token but we would like to use
+                // token on same line if trailing trivia (comments or white spaces on same line) part of the last token on that line
+                tokenAtLocation = ts.findPrecedingToken(tokenAtLocation.pos, sourceFile);
+                // It's a blank line
+                if (!tokenAtLocation || sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getEnd()).line !== lineOfPosition) {
+                    return undefined;
+                }
+            }
+            // Cannot set breakpoint in ambient declarations
+            if (ts.isInAmbientContext(tokenAtLocation)) {
+                return undefined;
+            }
+            // Get the span in the node based on its syntax
+            return spanInNode(tokenAtLocation);
+            function textSpan(startNode, endNode) {
+                var start = startNode.decorators ?
+                    ts.skipTrivia(sourceFile.text, startNode.decorators.end) :
+                    startNode.getStart(sourceFile);
+                return ts.createTextSpanFromBounds(start, (endNode || startNode).getEnd());
+            }
+            function textSpanEndingAtNextToken(startNode, previousTokenToFindNextEndToken) {
+                return textSpan(startNode, ts.findNextToken(previousTokenToFindNextEndToken, previousTokenToFindNextEndToken.parent));
+            }
+            function spanInNodeIfStartsOnSameLine(node, otherwiseOnNode) {
+                if (node && lineOfPosition === sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line) {
+                    return spanInNode(node);
+                }
+                return spanInNode(otherwiseOnNode);
+            }
+            function spanInNodeArray(nodeArray) {
+                return ts.createTextSpanFromBounds(ts.skipTrivia(sourceFile.text, nodeArray.pos), nodeArray.end);
+            }
+            function spanInPreviousNode(node) {
+                return spanInNode(ts.findPrecedingToken(node.pos, sourceFile));
+            }
+            function spanInNextNode(node) {
+                return spanInNode(ts.findNextToken(node, node.parent));
+            }
+            function spanInNode(node) {
+                if (node) {
+                    switch (node.kind) {
+                        case 200 /* VariableStatement */:
+                            // Span on first variable declaration
+                            return spanInVariableDeclaration(node.declarationList.declarations[0]);
+                        case 218 /* VariableDeclaration */:
+                        case 145 /* PropertyDeclaration */:
+                        case 144 /* PropertySignature */:
+                            return spanInVariableDeclaration(node);
+                        case 142 /* Parameter */:
+                            return spanInParameterDeclaration(node);
+                        case 220 /* FunctionDeclaration */:
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                        case 149 /* GetAccessor */:
+                        case 150 /* SetAccessor */:
+                        case 148 /* Constructor */:
+                        case 179 /* FunctionExpression */:
+                        case 180 /* ArrowFunction */:
+                            return spanInFunctionDeclaration(node);
+                        case 199 /* Block */:
+                            if (ts.isFunctionBlock(node)) {
+                                return spanInFunctionBlock(node);
+                            }
+                        // Fall through
+                        case 226 /* ModuleBlock */:
+                            return spanInBlock(node);
+                        case 252 /* CatchClause */:
+                            return spanInBlock(node.block);
+                        case 202 /* ExpressionStatement */:
+                            // span on the expression
+                            return textSpan(node.expression);
+                        case 211 /* ReturnStatement */:
+                            // span on return keyword and expression if present
+                            return textSpan(node.getChildAt(0), node.expression);
+                        case 205 /* WhileStatement */:
+                            // Span on while(...)
+                            return textSpanEndingAtNextToken(node, node.expression);
+                        case 204 /* DoStatement */:
+                            // span in statement of the do statement
+                            return spanInNode(node.statement);
+                        case 217 /* DebuggerStatement */:
+                            // span on debugger keyword
+                            return textSpan(node.getChildAt(0));
+                        case 203 /* IfStatement */:
+                            // set on if(..) span
+                            return textSpanEndingAtNextToken(node, node.expression);
+                        case 214 /* LabeledStatement */:
+                            // span in statement
+                            return spanInNode(node.statement);
+                        case 210 /* BreakStatement */:
+                        case 209 /* ContinueStatement */:
+                            // On break or continue keyword and label if present
+                            return textSpan(node.getChildAt(0), node.label);
+                        case 206 /* ForStatement */:
+                            return spanInForStatement(node);
+                        case 207 /* ForInStatement */:
+                            // span of for (a in ...)
+                            return textSpanEndingAtNextToken(node, node.expression);
+                        case 208 /* ForOfStatement */:
+                            // span in initializer
+                            return spanInInitializerOfForLike(node);
+                        case 213 /* SwitchStatement */:
+                            // span on switch(...)
+                            return textSpanEndingAtNextToken(node, node.expression);
+                        case 249 /* CaseClause */:
+                        case 250 /* DefaultClause */:
+                            // span in first statement of the clause
+                            return spanInNode(node.statements[0]);
+                        case 216 /* TryStatement */:
+                            // span in try block
+                            return spanInBlock(node.tryBlock);
+                        case 215 /* ThrowStatement */:
+                            // span in throw ...
+                            return textSpan(node, node.expression);
+                        case 235 /* ExportAssignment */:
+                            // span on export = id
+                            return textSpan(node, node.expression);
+                        case 229 /* ImportEqualsDeclaration */:
+                            // import statement without including semicolon
+                            return textSpan(node, node.moduleReference);
+                        case 230 /* ImportDeclaration */:
+                            // import statement without including semicolon
+                            return textSpan(node, node.moduleSpecifier);
+                        case 236 /* ExportDeclaration */:
+                            // import statement without including semicolon
+                            return textSpan(node, node.moduleSpecifier);
+                        case 225 /* ModuleDeclaration */:
+                            // span on complete module if it is instantiated
+                            if (ts.getModuleInstanceState(node) !== 1 /* Instantiated */) {
+                                return undefined;
+                            }
+                        case 221 /* ClassDeclaration */:
+                        case 224 /* EnumDeclaration */:
+                        case 255 /* EnumMember */:
+                        case 169 /* BindingElement */:
+                            // span on complete node
+                            return textSpan(node);
+                        case 212 /* WithStatement */:
+                            // span in statement
+                            return spanInNode(node.statement);
+                        case 143 /* Decorator */:
+                            return spanInNodeArray(node.parent.decorators);
+                        case 167 /* ObjectBindingPattern */:
+                        case 168 /* ArrayBindingPattern */:
+                            return spanInBindingPattern(node);
+                        // No breakpoint in interface, type alias
+                        case 222 /* InterfaceDeclaration */:
+                        case 223 /* TypeAliasDeclaration */:
+                            return undefined;
+                        // Tokens:
+                        case 23 /* SemicolonToken */:
+                        case 1 /* EndOfFileToken */:
+                            return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile));
+                        case 24 /* CommaToken */:
+                            return spanInPreviousNode(node);
+                        case 15 /* OpenBraceToken */:
+                            return spanInOpenBraceToken(node);
+                        case 16 /* CloseBraceToken */:
+                            return spanInCloseBraceToken(node);
+                        case 20 /* CloseBracketToken */:
+                            return spanInCloseBracketToken(node);
+                        case 17 /* OpenParenToken */:
+                            return spanInOpenParenToken(node);
+                        case 18 /* CloseParenToken */:
+                            return spanInCloseParenToken(node);
+                        case 54 /* ColonToken */:
+                            return spanInColonToken(node);
+                        case 27 /* GreaterThanToken */:
+                        case 25 /* LessThanToken */:
+                            return spanInGreaterThanOrLessThanToken(node);
+                        // Keywords:
+                        case 104 /* WhileKeyword */:
+                            return spanInWhileKeyword(node);
+                        case 80 /* ElseKeyword */:
+                        case 72 /* CatchKeyword */:
+                        case 85 /* FinallyKeyword */:
+                            return spanInNextNode(node);
+                        case 138 /* OfKeyword */:
+                            return spanInOfKeyword(node);
+                        default:
+                            // Destructuring pattern in destructuring assignment
+                            // [a, b, c] of
+                            // [a, b, c] = expression
+                            if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node)) {
+                                return spanInArrayLiteralOrObjectLiteralDestructuringPattern(node);
+                            }
+                            // Set breakpoint on identifier element of destructuring pattern
+                            // a or ...c  or d: x from
+                            // [a, b, ...c] or { a, b } or { d: x } from destructuring pattern
+                            if ((node.kind === 69 /* Identifier */ ||
+                                node.kind == 191 /* SpreadElementExpression */ ||
+                                node.kind === 253 /* PropertyAssignment */ ||
+                                node.kind === 254 /* ShorthandPropertyAssignment */) &&
+                                ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
+                                return textSpan(node);
+                            }
+                            if (node.kind === 187 /* BinaryExpression */) {
+                                var binaryExpression = node;
+                                // Set breakpoint in destructuring pattern if its destructuring assignment
+                                // [a, b, c] or {a, b, c} of
+                                // [a, b, c] = expression or
+                                // {a, b, c} = expression
+                                if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.left)) {
+                                    return spanInArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.left);
+                                }
+                                if (binaryExpression.operatorToken.kind === 56 /* EqualsToken */ &&
+                                    ts.isArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.parent)) {
+                                    // Set breakpoint on assignment expression element of destructuring pattern
+                                    // a = expression of
+                                    // [a = expression, b, c] = someExpression or
+                                    // { a = expression, b, c } = someExpression
+                                    return textSpan(node);
+                                }
+                                if (binaryExpression.operatorToken.kind === 24 /* CommaToken */) {
+                                    return spanInNode(binaryExpression.left);
+                                }
+                            }
+                            if (ts.isExpression(node)) {
+                                switch (node.parent.kind) {
+                                    case 204 /* DoStatement */:
+                                        // Set span as if on while keyword
+                                        return spanInPreviousNode(node);
+                                    case 143 /* Decorator */:
+                                        // Set breakpoint on the decorator emit
+                                        return spanInNode(node.parent);
+                                    case 206 /* ForStatement */:
+                                    case 208 /* ForOfStatement */:
+                                        return textSpan(node);
+                                    case 187 /* BinaryExpression */:
+                                        if (node.parent.operatorToken.kind === 24 /* CommaToken */) {
+                                            // If this is a comma expression, the breakpoint is possible in this expression
+                                            return textSpan(node);
+                                        }
+                                        break;
+                                    case 180 /* ArrowFunction */:
+                                        if (node.parent.body === node) {
+                                            // If this is body of arrow function, it is allowed to have the breakpoint
+                                            return textSpan(node);
+                                        }
+                                        break;
+                                }
+                            }
+                            // If this is name of property assignment, set breakpoint in the initializer
+                            if (node.parent.kind === 253 /* PropertyAssignment */ &&
+                                node.parent.name === node &&
+                                !ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.parent)) {
+                                return spanInNode(node.parent.initializer);
+                            }
+                            // Breakpoint in type assertion goes to its operand
+                            if (node.parent.kind === 177 /* TypeAssertionExpression */ && node.parent.type === node) {
+                                return spanInNextNode(node.parent.type);
+                            }
+                            // return type of function go to previous token
+                            if (ts.isFunctionLike(node.parent) && node.parent.type === node) {
+                                return spanInPreviousNode(node);
+                            }
+                            // initializer of variable/parameter declaration go to previous node
+                            if ((node.parent.kind === 218 /* VariableDeclaration */ ||
+                                node.parent.kind === 142 /* Parameter */)) {
+                                var paramOrVarDecl = node.parent;
+                                if (paramOrVarDecl.initializer === node ||
+                                    paramOrVarDecl.type === node ||
+                                    ts.isAssignmentOperator(node.kind)) {
+                                    return spanInPreviousNode(node);
+                                }
+                            }
+                            if (node.parent.kind === 187 /* BinaryExpression */) {
+                                var binaryExpression = node.parent;
+                                if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.left) &&
+                                    (binaryExpression.right === node ||
+                                        binaryExpression.operatorToken === node)) {
+                                    // If initializer of destructuring assignment move to previous token
+                                    return spanInPreviousNode(node);
+                                }
+                            }
+                            // Default go to parent to set the breakpoint
+                            return spanInNode(node.parent);
+                    }
+                }
+                function textSpanFromVariableDeclaration(variableDeclaration) {
+                    var declarations = variableDeclaration.parent.declarations;
+                    if (declarations && declarations[0] === variableDeclaration) {
+                        // First declaration - include let keyword
+                        return textSpan(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration);
+                    }
+                    else {
+                        // Span only on this declaration
+                        return textSpan(variableDeclaration);
+                    }
+                }
+                function spanInVariableDeclaration(variableDeclaration) {
+                    // If declaration of for in statement, just set the span in parent
+                    if (variableDeclaration.parent.parent.kind === 207 /* ForInStatement */) {
+                        return spanInNode(variableDeclaration.parent.parent);
+                    }
+                    // If this is a destructuring pattern, set breakpoint in binding pattern
+                    if (ts.isBindingPattern(variableDeclaration.name)) {
+                        return spanInBindingPattern(variableDeclaration.name);
+                    }
+                    // Breakpoint is possible in variableDeclaration only if there is initialization
+                    // or its declaration from 'for of'
+                    if (variableDeclaration.initializer ||
+                        (variableDeclaration.flags & 1 /* Export */) ||
+                        variableDeclaration.parent.parent.kind === 208 /* ForOfStatement */) {
+                        return textSpanFromVariableDeclaration(variableDeclaration);
+                    }
+                    var declarations = variableDeclaration.parent.declarations;
+                    if (declarations && declarations[0] !== variableDeclaration) {
+                        // If we cannot set breakpoint on this declaration, set it on previous one
+                        // Because the variable declaration may be binding pattern and
+                        // we would like to set breakpoint in last binding element if that's the case,
+                        // use preceding token instead
+                        return spanInNode(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent));
+                    }
+                }
+                function canHaveSpanInParameterDeclaration(parameter) {
+                    // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier
+                    return !!parameter.initializer || parameter.dotDotDotToken !== undefined ||
+                        !!(parameter.flags & 4 /* Public */) || !!(parameter.flags & 8 /* Private */);
+                }
+                function spanInParameterDeclaration(parameter) {
+                    if (ts.isBindingPattern(parameter.name)) {
+                        // Set breakpoint in binding pattern
+                        return spanInBindingPattern(parameter.name);
+                    }
+                    else if (canHaveSpanInParameterDeclaration(parameter)) {
+                        return textSpan(parameter);
+                    }
+                    else {
+                        var functionDeclaration = parameter.parent;
+                        var indexOfParameter = ts.indexOf(functionDeclaration.parameters, parameter);
+                        if (indexOfParameter) {
+                            // Not a first parameter, go to previous parameter
+                            return spanInParameterDeclaration(functionDeclaration.parameters[indexOfParameter - 1]);
+                        }
+                        else {
+                            // Set breakpoint in the function declaration body
+                            return spanInNode(functionDeclaration.body);
+                        }
+                    }
+                }
+                function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
+                    return !!(functionDeclaration.flags & 1 /* Export */) ||
+                        (functionDeclaration.parent.kind === 221 /* ClassDeclaration */ && functionDeclaration.kind !== 148 /* Constructor */);
+                }
+                function spanInFunctionDeclaration(functionDeclaration) {
+                    // No breakpoints in the function signature
+                    if (!functionDeclaration.body) {
+                        return undefined;
+                    }
+                    if (canFunctionHaveSpanInWholeDeclaration(functionDeclaration)) {
+                        // Set the span on whole function declaration
+                        return textSpan(functionDeclaration);
+                    }
+                    // Set span in function body
+                    return spanInNode(functionDeclaration.body);
+                }
+                function spanInFunctionBlock(block) {
+                    var nodeForSpanInBlock = block.statements.length ? block.statements[0] : block.getLastToken();
+                    if (canFunctionHaveSpanInWholeDeclaration(block.parent)) {
+                        return spanInNodeIfStartsOnSameLine(block.parent, nodeForSpanInBlock);
+                    }
+                    return spanInNode(nodeForSpanInBlock);
+                }
+                function spanInBlock(block) {
+                    switch (block.parent.kind) {
+                        case 225 /* ModuleDeclaration */:
+                            if (ts.getModuleInstanceState(block.parent) !== 1 /* Instantiated */) {
+                                return undefined;
+                            }
+                        // Set on parent if on same line otherwise on first statement
+                        case 205 /* WhileStatement */:
+                        case 203 /* IfStatement */:
+                        case 207 /* ForInStatement */:
+                            return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]);
+                        // Set span on previous token if it starts on same line otherwise on the first statement of the block
+                        case 206 /* ForStatement */:
+                        case 208 /* ForOfStatement */:
+                            return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]);
+                    }
+                    // Default action is to set on first statement
+                    return spanInNode(block.statements[0]);
+                }
+                function spanInInitializerOfForLike(forLikeStatement) {
+                    if (forLikeStatement.initializer.kind === 219 /* VariableDeclarationList */) {
+                        // Declaration list - set breakpoint in first declaration
+                        var variableDeclarationList = forLikeStatement.initializer;
+                        if (variableDeclarationList.declarations.length > 0) {
+                            return spanInNode(variableDeclarationList.declarations[0]);
+                        }
+                    }
+                    else {
+                        // Expression - set breakpoint in it
+                        return spanInNode(forLikeStatement.initializer);
+                    }
+                }
+                function spanInForStatement(forStatement) {
+                    if (forStatement.initializer) {
+                        return spanInInitializerOfForLike(forStatement);
+                    }
+                    if (forStatement.condition) {
+                        return textSpan(forStatement.condition);
+                    }
+                    if (forStatement.incrementor) {
+                        return textSpan(forStatement.incrementor);
+                    }
+                }
+                function spanInBindingPattern(bindingPattern) {
+                    // Set breakpoint in first binding element
+                    var firstBindingElement = ts.forEach(bindingPattern.elements, function (element) { return element.kind !== 193 /* OmittedExpression */ ? element : undefined; });
+                    if (firstBindingElement) {
+                        return spanInNode(firstBindingElement);
+                    }
+                    // Empty binding pattern of binding element, set breakpoint on binding element
+                    if (bindingPattern.parent.kind === 169 /* BindingElement */) {
+                        return textSpan(bindingPattern.parent);
+                    }
+                    // Variable declaration is used as the span
+                    return textSpanFromVariableDeclaration(bindingPattern.parent);
+                }
+                function spanInArrayLiteralOrObjectLiteralDestructuringPattern(node) {
+                    ts.Debug.assert(node.kind !== 168 /* ArrayBindingPattern */ && node.kind !== 167 /* ObjectBindingPattern */);
+                    var elements = node.kind === 170 /* ArrayLiteralExpression */ ?
+                        node.elements :
+                        node.properties;
+                    var firstBindingElement = ts.forEach(elements, function (element) { return element.kind !== 193 /* OmittedExpression */ ? element : undefined; });
+                    if (firstBindingElement) {
+                        return spanInNode(firstBindingElement);
+                    }
+                    // Could be ArrayLiteral from destructuring assignment or
+                    // just nested element in another destructuring assignment
+                    // set breakpoint on assignment when parent is destructuring assignment
+                    // Otherwise set breakpoint for this element
+                    return textSpan(node.parent.kind === 187 /* BinaryExpression */ ? node.parent : node);
+                }
+                // Tokens:
+                function spanInOpenBraceToken(node) {
+                    switch (node.parent.kind) {
+                        case 224 /* EnumDeclaration */:
+                            var enumDeclaration = node.parent;
+                            return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile));
+                        case 221 /* ClassDeclaration */:
+                            var classDeclaration = node.parent;
+                            return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile));
+                        case 227 /* CaseBlock */:
+                            return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]);
+                    }
+                    // Default to parent node
+                    return spanInNode(node.parent);
+                }
+                function spanInCloseBraceToken(node) {
+                    switch (node.parent.kind) {
+                        case 226 /* ModuleBlock */:
+                            // If this is not an instantiated module block, no bp span
+                            if (ts.getModuleInstanceState(node.parent.parent) !== 1 /* Instantiated */) {
+                                return undefined;
+                            }
+                        case 224 /* EnumDeclaration */:
+                        case 221 /* ClassDeclaration */:
+                            // Span on close brace token
+                            return textSpan(node);
+                        case 199 /* Block */:
+                            if (ts.isFunctionBlock(node.parent)) {
+                                // Span on close brace token
+                                return textSpan(node);
+                            }
+                        // fall through
+                        case 252 /* CatchClause */:
+                            return spanInNode(ts.lastOrUndefined(node.parent.statements));
+                        case 227 /* CaseBlock */:
+                            // breakpoint in last statement of the last clause
+                            var caseBlock = node.parent;
+                            var lastClause = ts.lastOrUndefined(caseBlock.clauses);
+                            if (lastClause) {
+                                return spanInNode(ts.lastOrUndefined(lastClause.statements));
+                            }
+                            return undefined;
+                        case 167 /* ObjectBindingPattern */:
+                            // Breakpoint in last binding element or binding pattern if it contains no elements
+                            var bindingPattern = node.parent;
+                            return spanInNode(ts.lastOrUndefined(bindingPattern.elements) || bindingPattern);
+                        // Default to parent node
+                        default:
+                            if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
+                                // Breakpoint in last binding element or binding pattern if it contains no elements
+                                var objectLiteral = node.parent;
+                                return textSpan(ts.lastOrUndefined(objectLiteral.properties) || objectLiteral);
+                            }
+                            return spanInNode(node.parent);
+                    }
+                }
+                function spanInCloseBracketToken(node) {
+                    switch (node.parent.kind) {
+                        case 168 /* ArrayBindingPattern */:
+                            // Breakpoint in last binding element or binding pattern if it contains no elements
+                            var bindingPattern = node.parent;
+                            return textSpan(ts.lastOrUndefined(bindingPattern.elements) || bindingPattern);
+                        default:
+                            if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
+                                // Breakpoint in last binding element or binding pattern if it contains no elements
+                                var arrayLiteral = node.parent;
+                                return textSpan(ts.lastOrUndefined(arrayLiteral.elements) || arrayLiteral);
+                            }
+                            // Default to parent node
+                            return spanInNode(node.parent);
+                    }
+                }
+                function spanInOpenParenToken(node) {
+                    if (node.parent.kind === 204 /* DoStatement */ ||
+                        node.parent.kind === 174 /* CallExpression */ ||
+                        node.parent.kind === 175 /* NewExpression */) {
+                        return spanInPreviousNode(node);
+                    }
+                    if (node.parent.kind === 178 /* ParenthesizedExpression */) {
+                        return spanInNextNode(node);
+                    }
+                    // Default to parent node
+                    return spanInNode(node.parent);
+                }
+                function spanInCloseParenToken(node) {
+                    // Is this close paren token of parameter list, set span in previous token
+                    switch (node.parent.kind) {
+                        case 179 /* FunctionExpression */:
+                        case 220 /* FunctionDeclaration */:
+                        case 180 /* ArrowFunction */:
+                        case 147 /* MethodDeclaration */:
+                        case 146 /* MethodSignature */:
+                        case 149 /* GetAccessor */:
+                        case 150 /* SetAccessor */:
+                        case 148 /* Constructor */:
+                        case 205 /* WhileStatement */:
+                        case 204 /* DoStatement */:
+                        case 206 /* ForStatement */:
+                        case 208 /* ForOfStatement */:
+                        case 174 /* CallExpression */:
+                        case 175 /* NewExpression */:
+                        case 178 /* ParenthesizedExpression */:
+                            return spanInPreviousNode(node);
+                        // Default to parent node
+                        default:
+                            return spanInNode(node.parent);
+                    }
+                }
+                function spanInColonToken(node) {
+                    // Is this : specifying return annotation of the function declaration
+                    if (ts.isFunctionLike(node.parent) ||
+                        node.parent.kind === 253 /* PropertyAssignment */ ||
+                        node.parent.kind === 142 /* Parameter */) {
+                        return spanInPreviousNode(node);
+                    }
+                    return spanInNode(node.parent);
+                }
+                function spanInGreaterThanOrLessThanToken(node) {
+                    if (node.parent.kind === 177 /* TypeAssertionExpression */) {
+                        return spanInNextNode(node);
+                    }
+                    return spanInNode(node.parent);
+                }
+                function spanInWhileKeyword(node) {
+                    if (node.parent.kind === 204 /* DoStatement */) {
+                        // Set span on while expression
+                        return textSpanEndingAtNextToken(node, node.parent.expression);
+                    }
+                    // Default to parent node
+                    return spanInNode(node.parent);
+                }
+                function spanInOfKeyword(node) {
+                    if (node.parent.kind === 208 /* ForOfStatement */) {
+                        // Set using next token
+                        return spanInNextNode(node);
+                    }
+                    // Default to parent node
+                    return spanInNode(node.parent);
+                }
+            }
+        }
+        BreakpointResolver.spanInSourceFileAtLocation = spanInSourceFileAtLocation;
+    })(BreakpointResolver = ts.BreakpointResolver || (ts.BreakpointResolver = {}));
+})(ts || (ts = {}));
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+/// <reference path='services.ts' />
+/* @internal */
+var debugObjectHost = this;
+// We need to use 'null' to interface with the managed side.
+/* tslint:disable:no-null-keyword */
+/* tslint:disable:no-in-operator */
+/* @internal */
+var ts;
+(function (ts) {
+    function logInternalError(logger, err) {
+        if (logger) {
+            logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message);
+        }
+    }
+    var ScriptSnapshotShimAdapter = (function () {
+        function ScriptSnapshotShimAdapter(scriptSnapshotShim) {
+            this.scriptSnapshotShim = scriptSnapshotShim;
+        }
+        ScriptSnapshotShimAdapter.prototype.getText = function (start, end) {
+            return this.scriptSnapshotShim.getText(start, end);
+        };
+        ScriptSnapshotShimAdapter.prototype.getLength = function () {
+            return this.scriptSnapshotShim.getLength();
+        };
+        ScriptSnapshotShimAdapter.prototype.getChangeRange = function (oldSnapshot) {
+            var oldSnapshotShim = oldSnapshot;
+            var encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim);
+            // TODO: should this be '==='?
+            if (encoded == null) {
+                return null;
+            }
+            var decoded = JSON.parse(encoded);
+            return ts.createTextChangeRange(ts.createTextSpan(decoded.span.start, decoded.span.length), decoded.newLength);
+        };
+        ScriptSnapshotShimAdapter.prototype.dispose = function () {
+            // if scriptSnapshotShim is a COM object then property check becomes method call with no arguments
+            // 'in' does not have this effect
+            if ("dispose" in this.scriptSnapshotShim) {
+                this.scriptSnapshotShim.dispose();
+            }
+        };
+        return ScriptSnapshotShimAdapter;
+    }());
+    var LanguageServiceShimHostAdapter = (function () {
+        function LanguageServiceShimHostAdapter(shimHost) {
+            var _this = this;
+            this.shimHost = shimHost;
+            this.loggingEnabled = false;
+            this.tracingEnabled = false;
+            // if shimHost is a COM object then property check will become method call with no arguments.
+            // 'in' does not have this effect.
+            if ("getModuleResolutionsForFile" in this.shimHost) {
+                this.resolveModuleNames = function (moduleNames, containingFile) {
+                    var resolutionsInFile = JSON.parse(_this.shimHost.getModuleResolutionsForFile(containingFile));
+                    return ts.map(moduleNames, function (name) {
+                        var result = ts.lookUp(resolutionsInFile, name);
+                        return result ? { resolvedFileName: result } : undefined;
+                    });
+                };
+            }
+            if ("directoryExists" in this.shimHost) {
+                this.directoryExists = function (directoryName) { return _this.shimHost.directoryExists(directoryName); };
+            }
+            if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {
+                this.resolveTypeReferenceDirectives = function (typeDirectiveNames, containingFile) {
+                    var typeDirectivesForFile = JSON.parse(_this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile));
+                    return ts.map(typeDirectiveNames, function (name) { return ts.lookUp(typeDirectivesForFile, name); });
+                };
+            }
+        }
+        LanguageServiceShimHostAdapter.prototype.log = function (s) {
+            if (this.loggingEnabled) {
+                this.shimHost.log(s);
+            }
+        };
+        LanguageServiceShimHostAdapter.prototype.trace = function (s) {
+            if (this.tracingEnabled) {
+                this.shimHost.trace(s);
+            }
+        };
+        LanguageServiceShimHostAdapter.prototype.error = function (s) {
+            this.shimHost.error(s);
+        };
+        LanguageServiceShimHostAdapter.prototype.getProjectVersion = function () {
+            if (!this.shimHost.getProjectVersion) {
+                // shimmed host does not support getProjectVersion
+                return undefined;
+            }
+            return this.shimHost.getProjectVersion();
+        };
+        LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () {
+            return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;
+        };
+        LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () {
+            var settingsJson = this.shimHost.getCompilationSettings();
+            // TODO: should this be '==='?
+            if (settingsJson == null || settingsJson == "") {
+                throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
+            }
+            return JSON.parse(settingsJson);
+        };
+        LanguageServiceShimHostAdapter.prototype.getScriptFileNames = function () {
+            var encoded = this.shimHost.getScriptFileNames();
+            return this.files = JSON.parse(encoded);
+        };
+        LanguageServiceShimHostAdapter.prototype.getScriptSnapshot = function (fileName) {
+            var scriptSnapshot = this.shimHost.getScriptSnapshot(fileName);
+            return scriptSnapshot && new ScriptSnapshotShimAdapter(scriptSnapshot);
+        };
+        LanguageServiceShimHostAdapter.prototype.getScriptKind = function (fileName) {
+            if ("getScriptKind" in this.shimHost) {
+                return this.shimHost.getScriptKind(fileName);
+            }
+            else {
+                return 0 /* Unknown */;
+            }
+        };
+        LanguageServiceShimHostAdapter.prototype.getScriptVersion = function (fileName) {
+            return this.shimHost.getScriptVersion(fileName);
+        };
+        LanguageServiceShimHostAdapter.prototype.getLocalizedDiagnosticMessages = function () {
+            var diagnosticMessagesJson = this.shimHost.getLocalizedDiagnosticMessages();
+            if (diagnosticMessagesJson == null || diagnosticMessagesJson == "") {
+                return null;
+            }
+            try {
+                return JSON.parse(diagnosticMessagesJson);
+            }
+            catch (e) {
+                this.log(e.description || "diagnosticMessages.generated.json has invalid JSON format");
+                return null;
+            }
+        };
+        LanguageServiceShimHostAdapter.prototype.getCancellationToken = function () {
+            var hostCancellationToken = this.shimHost.getCancellationToken();
+            return new ThrottledCancellationToken(hostCancellationToken);
+        };
+        LanguageServiceShimHostAdapter.prototype.getCurrentDirectory = function () {
+            return this.shimHost.getCurrentDirectory();
+        };
+        LanguageServiceShimHostAdapter.prototype.getDirectories = function (path) {
+            return JSON.parse(this.shimHost.getDirectories(path));
+        };
+        LanguageServiceShimHostAdapter.prototype.getDefaultLibFileName = function (options) {
+            return this.shimHost.getDefaultLibFileName(JSON.stringify(options));
+        };
+        return LanguageServiceShimHostAdapter;
+    }());
+    ts.LanguageServiceShimHostAdapter = LanguageServiceShimHostAdapter;
+    /** A cancellation that throttles calls to the host */
+    var ThrottledCancellationToken = (function () {
+        function ThrottledCancellationToken(hostCancellationToken) {
+            this.hostCancellationToken = hostCancellationToken;
+            // Store when we last tried to cancel.  Checking cancellation can be expensive (as we have
+            // to marshall over to the host layer).  So we only bother actually checking once enough
+            // time has passed.
+            this.lastCancellationCheckTime = 0;
+        }
+        ThrottledCancellationToken.prototype.isCancellationRequested = function () {
+            var time = Date.now();
+            var duration = Math.abs(time - this.lastCancellationCheckTime);
+            if (duration > 10) {
+                // Check no more than once every 10 ms.
+                this.lastCancellationCheckTime = time;
+                return this.hostCancellationToken.isCancellationRequested();
+            }
+            return false;
+        };
+        return ThrottledCancellationToken;
+    }());
+    var CoreServicesShimHostAdapter = (function () {
+        function CoreServicesShimHostAdapter(shimHost) {
+            var _this = this;
+            this.shimHost = shimHost;
+            this.useCaseSensitiveFileNames = this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;
+            if ("directoryExists" in this.shimHost) {
+                this.directoryExists = function (directoryName) { return _this.shimHost.directoryExists(directoryName); };
+            }
+            if ("realpath" in this.shimHost) {
+                this.realpath = function (path) { return _this.shimHost.realpath(path); };
+            }
+        }
+        CoreServicesShimHostAdapter.prototype.readDirectory = function (rootDir, extensions, exclude, include, depth) {
+            // Wrap the API changes for 2.0 release. This try/catch
+            // should be removed once TypeScript 2.0 has shipped.
+            try {
+                var pattern = ts.getFileMatcherPatterns(rootDir, extensions, exclude, include, this.shimHost.useCaseSensitiveFileNames(), this.shimHost.getCurrentDirectory());
+                return JSON.parse(this.shimHost.readDirectory(rootDir, JSON.stringify(extensions), JSON.stringify(pattern.basePaths), pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern, depth));
+            }
+            catch (e) {
+                var results = [];
+                for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) {
+                    var extension = extensions_2[_i];
+                    for (var _a = 0, _b = this.readDirectoryFallback(rootDir, extension, exclude); _a < _b.length; _a++) {
+                        var file = _b[_a];
+                        if (!ts.contains(results, file)) {
+                            results.push(file);
+                        }
+                    }
+                }
+                return results;
+            }
+        };
+        CoreServicesShimHostAdapter.prototype.fileExists = function (fileName) {
+            return this.shimHost.fileExists(fileName);
+        };
+        CoreServicesShimHostAdapter.prototype.readFile = function (fileName) {
+            return this.shimHost.readFile(fileName);
+        };
+        CoreServicesShimHostAdapter.prototype.readDirectoryFallback = function (rootDir, extension, exclude) {
+            return JSON.parse(this.shimHost.readDirectory(rootDir, extension, JSON.stringify(exclude)));
+        };
+        return CoreServicesShimHostAdapter;
+    }());
+    ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter;
+    function simpleForwardCall(logger, actionDescription, action, logPerformance) {
+        var start;
+        if (logPerformance) {
+            logger.log(actionDescription);
+            start = Date.now();
+        }
+        var result = action();
+        if (logPerformance) {
+            var end = Date.now();
+            logger.log(actionDescription + " completed in " + (end - start) + " msec");
+            if (typeof result === "string") {
+                var str = result;
+                if (str.length > 128) {
+                    str = str.substring(0, 128) + "...";
+                }
+                logger.log("  result.length=" + str.length + ", result='" + JSON.stringify(str) + "'");
+            }
+        }
+        return result;
+    }
+    function forwardJSONCall(logger, actionDescription, action, logPerformance) {
+        return forwardCall(logger, actionDescription, /*returnJson*/ true, action, logPerformance);
+    }
+    function forwardCall(logger, actionDescription, returnJson, action, logPerformance) {
+        try {
+            var result = simpleForwardCall(logger, actionDescription, action, logPerformance);
+            return returnJson ? JSON.stringify({ result: result }) : result;
+        }
+        catch (err) {
+            if (err instanceof ts.OperationCanceledException) {
+                return JSON.stringify({ canceled: true });
+            }
+            logInternalError(logger, err);
+            err.description = actionDescription;
+            return JSON.stringify({ error: err });
+        }
+    }
+    var ShimBase = (function () {
+        function ShimBase(factory) {
+            this.factory = factory;
+            factory.registerShim(this);
+        }
+        ShimBase.prototype.dispose = function (dummy) {
+            this.factory.unregisterShim(this);
+        };
+        return ShimBase;
+    }());
+    function realizeDiagnostics(diagnostics, newLine) {
+        return diagnostics.map(function (d) { return realizeDiagnostic(d, newLine); });
+    }
+    ts.realizeDiagnostics = realizeDiagnostics;
+    function realizeDiagnostic(diagnostic, newLine) {
+        return {
+            message: ts.flattenDiagnosticMessageText(diagnostic.messageText, newLine),
+            start: diagnostic.start,
+            length: diagnostic.length,
+            /// TODO: no need for the tolowerCase call
+            category: ts.DiagnosticCategory[diagnostic.category].toLowerCase(),
+            code: diagnostic.code
+        };
+    }
+    var LanguageServiceShimObject = (function (_super) {
+        __extends(LanguageServiceShimObject, _super);
+        function LanguageServiceShimObject(factory, host, languageService) {
+            _super.call(this, factory);
+            this.host = host;
+            this.languageService = languageService;
+            this.logPerformance = false;
+            this.logger = this.host;
+        }
+        LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) {
+            return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance);
+        };
+        /// DISPOSE
+        /**
+         * Ensure (almost) deterministic release of internal Javascript resources when
+         * some external native objects holds onto us (e.g. Com/Interop).
+         */
+        LanguageServiceShimObject.prototype.dispose = function (dummy) {
+            this.logger.log("dispose()");
+            this.languageService.dispose();
+            this.languageService = null;
+            // force a GC
+            if (debugObjectHost && debugObjectHost.CollectGarbage) {
+                debugObjectHost.CollectGarbage();
+                this.logger.log("CollectGarbage()");
+            }
+            this.logger = null;
+            _super.prototype.dispose.call(this, dummy);
+        };
+        /// REFRESH
+        /**
+         * Update the list of scripts known to the compiler
+         */
+        LanguageServiceShimObject.prototype.refresh = function (throwOnError) {
+            this.forwardJSONCall("refresh(" + throwOnError + ")", function () { return null; });
+        };
+        LanguageServiceShimObject.prototype.cleanupSemanticCache = function () {
+            var _this = this;
+            this.forwardJSONCall("cleanupSemanticCache()", function () {
+                _this.languageService.cleanupSemanticCache();
+                return null;
+            });
+        };
+        LanguageServiceShimObject.prototype.realizeDiagnostics = function (diagnostics) {
+            var newLine = ts.getNewLineOrDefaultFromHost(this.host);
+            return ts.realizeDiagnostics(diagnostics, newLine);
+        };
+        LanguageServiceShimObject.prototype.getSyntacticClassifications = function (fileName, start, length) {
+            var _this = this;
+            return this.forwardJSONCall("getSyntacticClassifications('" + fileName + "', " + start + ", " + length + ")", function () { return _this.languageService.getSyntacticClassifications(fileName, ts.createTextSpan(start, length)); });
+        };
+        LanguageServiceShimObject.prototype.getSemanticClassifications = function (fileName, start, length) {
+            var _this = this;
+            return this.forwardJSONCall("getSemanticClassifications('" + fileName + "', " + start + ", " + length + ")", function () { return _this.languageService.getSemanticClassifications(fileName, ts.createTextSpan(start, length)); });
+        };
+        LanguageServiceShimObject.prototype.getEncodedSyntacticClassifications = function (fileName, start, length) {
+            var _this = this;
+            return this.forwardJSONCall("getEncodedSyntacticClassifications('" + fileName + "', " + start + ", " + length + ")", 
+            // directly serialize the spans out to a string.  This is much faster to decode
+            // on the managed side versus a full JSON array.
+            function () { return convertClassifications(_this.languageService.getEncodedSyntacticClassifications(fileName, ts.createTextSpan(start, length))); });
+        };
+        LanguageServiceShimObject.prototype.getEncodedSemanticClassifications = function (fileName, start, length) {
+            var _this = this;
+            return this.forwardJSONCall("getEncodedSemanticClassifications('" + fileName + "', " + start + ", " + length + ")", 
+            // directly serialize the spans out to a string.  This is much faster to decode
+            // on the managed side versus a full JSON array.
+            function () { return convertClassifications(_this.languageService.getEncodedSemanticClassifications(fileName, ts.createTextSpan(start, length))); });
+        };
+        LanguageServiceShimObject.prototype.getSyntacticDiagnostics = function (fileName) {
+            var _this = this;
+            return this.forwardJSONCall("getSyntacticDiagnostics('" + fileName + "')", function () {
+                var diagnostics = _this.languageService.getSyntacticDiagnostics(fileName);
+                return _this.realizeDiagnostics(diagnostics);
+            });
+        };
+        LanguageServiceShimObject.prototype.getSemanticDiagnostics = function (fileName) {
+            var _this = this;
+            return this.forwardJSONCall("getSemanticDiagnostics('" + fileName + "')", function () {
+                var diagnostics = _this.languageService.getSemanticDiagnostics(fileName);
+                return _this.realizeDiagnostics(diagnostics);
+            });
+        };
+        LanguageServiceShimObject.prototype.getCompilerOptionsDiagnostics = function () {
+            var _this = this;
+            return this.forwardJSONCall("getCompilerOptionsDiagnostics()", function () {
+                var diagnostics = _this.languageService.getCompilerOptionsDiagnostics();
+                return _this.realizeDiagnostics(diagnostics);
+            });
+        };
+        /// QUICKINFO
+        /**
+         * Computes a string representation of the type at the requested position
+         * in the active file.
+         */
+        LanguageServiceShimObject.prototype.getQuickInfoAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getQuickInfoAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getQuickInfoAtPosition(fileName, position); });
+        };
+        /// NAMEORDOTTEDNAMESPAN
+        /**
+         * Computes span information of the name or dotted name at the requested position
+         * in the active file.
+         */
+        LanguageServiceShimObject.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) {
+            var _this = this;
+            return this.forwardJSONCall("getNameOrDottedNameSpan('" + fileName + "', " + startPos + ", " + endPos + ")", function () { return _this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos); });
+        };
+        /**
+         * STATEMENTSPAN
+         * Computes span information of statement at the requested position in the active file.
+         */
+        LanguageServiceShimObject.prototype.getBreakpointStatementAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getBreakpointStatementAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getBreakpointStatementAtPosition(fileName, position); });
+        };
+        /// SIGNATUREHELP
+        LanguageServiceShimObject.prototype.getSignatureHelpItems = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getSignatureHelpItems('" + fileName + "', " + position + ")", function () { return _this.languageService.getSignatureHelpItems(fileName, position); });
+        };
+        /// GOTO DEFINITION
+        /**
+         * Computes the definition location and file for the symbol
+         * at the requested position.
+         */
+        LanguageServiceShimObject.prototype.getDefinitionAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getDefinitionAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getDefinitionAtPosition(fileName, position); });
+        };
+        /// GOTO Type
+        /**
+         * Computes the definition location of the type of the symbol
+         * at the requested position.
+         */
+        LanguageServiceShimObject.prototype.getTypeDefinitionAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getTypeDefinitionAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getTypeDefinitionAtPosition(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.getRenameInfo = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getRenameInfo('" + fileName + "', " + position + ")", function () { return _this.languageService.getRenameInfo(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.findRenameLocations = function (fileName, position, findInStrings, findInComments) {
+            var _this = this;
+            return this.forwardJSONCall("findRenameLocations('" + fileName + "', " + position + ", " + findInStrings + ", " + findInComments + ")", function () { return _this.languageService.findRenameLocations(fileName, position, findInStrings, findInComments); });
+        };
+        /// GET BRACE MATCHING
+        LanguageServiceShimObject.prototype.getBraceMatchingAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getBraceMatchingAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getBraceMatchingAtPosition(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.isValidBraceCompletionAtPosition = function (fileName, position, openingBrace) {
+            var _this = this;
+            return this.forwardJSONCall("isValidBraceCompletionAtPosition('" + fileName + "', " + position + ", " + openingBrace + ")", function () { return _this.languageService.isValidBraceCompletionAtPosition(fileName, position, openingBrace); });
+        };
+        /// GET SMART INDENT
+        LanguageServiceShimObject.prototype.getIndentationAtPosition = function (fileName, position, options /*Services.EditorOptions*/) {
+            var _this = this;
+            return this.forwardJSONCall("getIndentationAtPosition('" + fileName + "', " + position + ")", function () {
+                var localOptions = JSON.parse(options);
+                return _this.languageService.getIndentationAtPosition(fileName, position, localOptions);
+            });
+        };
+        /// GET REFERENCES
+        LanguageServiceShimObject.prototype.getReferencesAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getReferencesAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getReferencesAtPosition(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.findReferences = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("findReferences('" + fileName + "', " + position + ")", function () { return _this.languageService.findReferences(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.getOccurrencesAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getOccurrencesAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getOccurrencesAtPosition(fileName, position); });
+        };
+        LanguageServiceShimObject.prototype.getDocumentHighlights = function (fileName, position, filesToSearch) {
+            var _this = this;
+            return this.forwardJSONCall("getDocumentHighlights('" + fileName + "', " + position + ")", function () {
+                var results = _this.languageService.getDocumentHighlights(fileName, position, JSON.parse(filesToSearch));
+                // workaround for VS document highlighting issue - keep only items from the initial file
+                var normalizedName = ts.normalizeSlashes(fileName).toLowerCase();
+                return ts.filter(results, function (r) { return ts.normalizeSlashes(r.fileName).toLowerCase() === normalizedName; });
+            });
+        };
+        /// COMPLETION LISTS
+        /**
+         * Get a string based representation of the completions
+         * to provide at the given source position and providing a member completion
+         * list if requested.
+         */
+        LanguageServiceShimObject.prototype.getCompletionsAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getCompletionsAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getCompletionsAtPosition(fileName, position); });
+        };
+        /** Get a string based representation of a completion list entry details */
+        LanguageServiceShimObject.prototype.getCompletionEntryDetails = function (fileName, position, entryName) {
+            var _this = this;
+            return this.forwardJSONCall("getCompletionEntryDetails('" + fileName + "', " + position + ", '" + entryName + "')", function () { return _this.languageService.getCompletionEntryDetails(fileName, position, entryName); });
+        };
+        LanguageServiceShimObject.prototype.getFormattingEditsForRange = function (fileName, start, end, options /*Services.FormatCodeOptions*/) {
+            var _this = this;
+            return this.forwardJSONCall("getFormattingEditsForRange('" + fileName + "', " + start + ", " + end + ")", function () {
+                var localOptions = JSON.parse(options);
+                return _this.languageService.getFormattingEditsForRange(fileName, start, end, localOptions);
+            });
+        };
+        LanguageServiceShimObject.prototype.getFormattingEditsForDocument = function (fileName, options /*Services.FormatCodeOptions*/) {
+            var _this = this;
+            return this.forwardJSONCall("getFormattingEditsForDocument('" + fileName + "')", function () {
+                var localOptions = JSON.parse(options);
+                return _this.languageService.getFormattingEditsForDocument(fileName, localOptions);
+            });
+        };
+        LanguageServiceShimObject.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options /*Services.FormatCodeOptions*/) {
+            var _this = this;
+            return this.forwardJSONCall("getFormattingEditsAfterKeystroke('" + fileName + "', " + position + ", '" + key + "')", function () {
+                var localOptions = JSON.parse(options);
+                return _this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions);
+            });
+        };
+        LanguageServiceShimObject.prototype.getDocCommentTemplateAtPosition = function (fileName, position) {
+            var _this = this;
+            return this.forwardJSONCall("getDocCommentTemplateAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getDocCommentTemplateAtPosition(fileName, position); });
+        };
+        /// NAVIGATE TO
+        /** Return a list of symbols that are interesting to navigate to */
+        LanguageServiceShimObject.prototype.getNavigateToItems = function (searchValue, maxResultCount) {
+            var _this = this;
+            return this.forwardJSONCall("getNavigateToItems('" + searchValue + "', " + maxResultCount + ")", function () { return _this.languageService.getNavigateToItems(searchValue, maxResultCount); });
+        };
+        LanguageServiceShimObject.prototype.getNavigationBarItems = function (fileName) {
+            var _this = this;
+            return this.forwardJSONCall("getNavigationBarItems('" + fileName + "')", function () { return _this.languageService.getNavigationBarItems(fileName); });
+        };
+        LanguageServiceShimObject.prototype.getOutliningSpans = function (fileName) {
+            var _this = this;
+            return this.forwardJSONCall("getOutliningSpans('" + fileName + "')", function () { return _this.languageService.getOutliningSpans(fileName); });
+        };
+        LanguageServiceShimObject.prototype.getTodoComments = function (fileName, descriptors) {
+            var _this = this;
+            return this.forwardJSONCall("getTodoComments('" + fileName + "')", function () { return _this.languageService.getTodoComments(fileName, JSON.parse(descriptors)); });
+        };
+        /// Emit
+        LanguageServiceShimObject.prototype.getEmitOutput = function (fileName) {
+            var _this = this;
+            return this.forwardJSONCall("getEmitOutput('" + fileName + "')", function () { return _this.languageService.getEmitOutput(fileName); });
+        };
+        LanguageServiceShimObject.prototype.getEmitOutputObject = function (fileName) {
+            var _this = this;
+            return forwardCall(this.logger, "getEmitOutput('" + fileName + "')", 
+            /*returnJson*/ false, function () { return _this.languageService.getEmitOutput(fileName); }, this.logPerformance);
+        };
+        return LanguageServiceShimObject;
+    }(ShimBase));
+    function convertClassifications(classifications) {
+        return { spans: classifications.spans.join(","), endOfLineState: classifications.endOfLineState };
+    }
+    var ClassifierShimObject = (function (_super) {
+        __extends(ClassifierShimObject, _super);
+        function ClassifierShimObject(factory, logger) {
+            _super.call(this, factory);
+            this.logger = logger;
+            this.logPerformance = false;
+            this.classifier = ts.createClassifier();
+        }
+        ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) {
+            var _this = this;
+            return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance);
+        };
+        /// COLORIZATION
+        ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) {
+            var classification = this.classifier.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics);
+            var result = "";
+            for (var _i = 0, _a = classification.entries; _i < _a.length; _i++) {
+                var item = _a[_i];
+                result += item.length + "\n";
+                result += item.classification + "\n";
+            }
+            result += classification.finalLexState;
+            return result;
+        };
+        return ClassifierShimObject;
+    }(ShimBase));
+    var CoreServicesShimObject = (function (_super) {
+        __extends(CoreServicesShimObject, _super);
+        function CoreServicesShimObject(factory, logger, host) {
+            _super.call(this, factory);
+            this.logger = logger;
+            this.host = host;
+            this.logPerformance = false;
+        }
+        CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) {
+            return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance);
+        };
+        CoreServicesShimObject.prototype.resolveModuleName = function (fileName, moduleName, compilerOptionsJson) {
+            var _this = this;
+            return this.forwardJSONCall("resolveModuleName('" + fileName + "')", function () {
+                var compilerOptions = JSON.parse(compilerOptionsJson);
+                var result = ts.resolveModuleName(moduleName, ts.normalizeSlashes(fileName), compilerOptions, _this.host);
+                return {
+                    resolvedFileName: result.resolvedModule ? result.resolvedModule.resolvedFileName : undefined,
+                    failedLookupLocations: result.failedLookupLocations
+                };
+            });
+        };
+        CoreServicesShimObject.prototype.resolveTypeReferenceDirective = function (fileName, typeReferenceDirective, compilerOptionsJson) {
+            var _this = this;
+            return this.forwardJSONCall("resolveTypeReferenceDirective(" + fileName + ")", function () {
+                var compilerOptions = JSON.parse(compilerOptionsJson);
+                var result = ts.resolveTypeReferenceDirective(typeReferenceDirective, ts.normalizeSlashes(fileName), compilerOptions, _this.host);
+                return {
+                    resolvedFileName: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.resolvedFileName : undefined,
+                    primary: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.primary : true,
+                    failedLookupLocations: result.failedLookupLocations
+                };
+            });
+        };
+        CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) {
+            var _this = this;
+            return this.forwardJSONCall("getPreProcessedFileInfo('" + fileName + "')", function () {
+                // for now treat files as JavaScript
+                var result = ts.preProcessFile(sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength()), /* readImportFiles */ true, /* detectJavaScriptImports */ true);
+                return {
+                    referencedFiles: _this.convertFileReferences(result.referencedFiles),
+                    importedFiles: _this.convertFileReferences(result.importedFiles),
+                    ambientExternalModules: result.ambientExternalModules,
+                    isLibFile: result.isLibFile,
+                    typeReferenceDirectives: _this.convertFileReferences(result.typeReferenceDirectives)
+                };
+            });
+        };
+        CoreServicesShimObject.prototype.convertFileReferences = function (refs) {
+            if (!refs) {
+                return undefined;
+            }
+            var result = [];
+            for (var _i = 0, refs_2 = refs; _i < refs_2.length; _i++) {
+                var ref = refs_2[_i];
+                result.push({
+                    path: ts.normalizeSlashes(ref.fileName),
+                    position: ref.pos,
+                    length: ref.end - ref.pos
+                });
+            }
+            return result;
+        };
+        CoreServicesShimObject.prototype.getTSConfigFileInfo = function (fileName, sourceTextSnapshot) {
+            var _this = this;
+            return this.forwardJSONCall("getTSConfigFileInfo('" + fileName + "')", function () {
+                var text = sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength());
+                var result = ts.parseConfigFileTextToJson(fileName, text);
+                if (result.error) {
+                    return {
+                        options: {},
+                        typingOptions: {},
+                        files: [],
+                        raw: {},
+                        errors: [realizeDiagnostic(result.error, "\r\n")]
+                    };
+                }
+                var normalizedFileName = ts.normalizeSlashes(fileName);
+                var configFile = ts.parseJsonConfigFileContent(result.config, _this.host, ts.getDirectoryPath(normalizedFileName), /*existingOptions*/ {}, normalizedFileName);
+                return {
+                    options: configFile.options,
+                    typingOptions: configFile.typingOptions,
+                    files: configFile.fileNames,
+                    raw: configFile.raw,
+                    errors: realizeDiagnostics(configFile.errors, "\r\n")
+                };
+            });
+        };
+        CoreServicesShimObject.prototype.getDefaultCompilationSettings = function () {
+            return this.forwardJSONCall("getDefaultCompilationSettings()", function () { return ts.getDefaultCompilerOptions(); });
+        };
+        CoreServicesShimObject.prototype.discoverTypings = function (discoverTypingsJson) {
+            var _this = this;
+            var getCanonicalFileName = ts.createGetCanonicalFileName(/*useCaseSensitivefileNames:*/ false);
+            return this.forwardJSONCall("discoverTypings()", function () {
+                var info = JSON.parse(discoverTypingsJson);
+                return ts.JsTyping.discoverTypings(_this.host, info.fileNames, ts.toPath(info.projectRootPath, info.projectRootPath, getCanonicalFileName), ts.toPath(info.safeListPath, info.safeListPath, getCanonicalFileName), info.packageNameToTypingLocation, info.typingOptions, info.compilerOptions);
+            });
+        };
+        return CoreServicesShimObject;
+    }(ShimBase));
+    var TypeScriptServicesFactory = (function () {
+        function TypeScriptServicesFactory() {
+            this._shims = [];
+        }
+        /*
+         * Returns script API version.
+         */
+        TypeScriptServicesFactory.prototype.getServicesVersion = function () {
+            return ts.servicesVersion;
+        };
+        TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) {
+            try {
+                if (this.documentRegistry === undefined) {
+                    this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory());
+                }
+                var hostAdapter = new LanguageServiceShimHostAdapter(host);
+                var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry);
+                return new LanguageServiceShimObject(this, host, languageService);
+            }
+            catch (err) {
+                logInternalError(host, err);
+                throw err;
+            }
+        };
+        TypeScriptServicesFactory.prototype.createClassifierShim = function (logger) {
+            try {
+                return new ClassifierShimObject(this, logger);
+            }
+            catch (err) {
+                logInternalError(logger, err);
+                throw err;
+            }
+        };
+        TypeScriptServicesFactory.prototype.createCoreServicesShim = function (host) {
+            try {
+                var adapter = new CoreServicesShimHostAdapter(host);
+                return new CoreServicesShimObject(this, host, adapter);
+            }
+            catch (err) {
+                logInternalError(host, err);
+                throw err;
+            }
+        };
+        TypeScriptServicesFactory.prototype.close = function () {
+            // Forget all the registered shims
+            this._shims = [];
+            this.documentRegistry = undefined;
+        };
+        TypeScriptServicesFactory.prototype.registerShim = function (shim) {
+            this._shims.push(shim);
+        };
+        TypeScriptServicesFactory.prototype.unregisterShim = function (shim) {
+            for (var i = 0, n = this._shims.length; i < n; i++) {
+                if (this._shims[i] === shim) {
+                    delete this._shims[i];
+                    return;
+                }
+            }
+            throw new Error("Invalid operation");
+        };
+        return TypeScriptServicesFactory;
+    }());
+    ts.TypeScriptServicesFactory = TypeScriptServicesFactory;
+    if (typeof module !== "undefined" && module.exports) {
+        module.exports = ts;
+    }
+})(ts || (ts = {}));
+/* tslint:enable:no-in-operator */
+/* tslint:enable:no-null */
+/// TODO: this is used by VS, clean this up on both sides of the interface
+/* @internal */
+var TypeScript;
+(function (TypeScript) {
+    var Services;
+    (function (Services) {
+        Services.TypeScriptServicesFactory = ts.TypeScriptServicesFactory;
+    })(Services = TypeScript.Services || (TypeScript.Services = {}));
+})(TypeScript || (TypeScript = {}));
+/* tslint:disable:no-unused-variable */
+// 'toolsVersion' gets consumed by the managed side, so it's not unused.
+// TODO: it should be moved into a namespace though.
+/* @internal */
+var toolsVersion = "1.9";
+/* tslint:enable:no-unused-variable */
diff --git a/vendor/golang.org/x/tools/third_party/webcomponents/LICENSE b/vendor/golang.org/x/tools/third_party/webcomponents/LICENSE
new file mode 100644
index 0000000..e648283
--- /dev/null
+++ b/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
diff --git a/vendor/golang.org/x/tools/third_party/webcomponents/customelements.js b/vendor/golang.org/x/tools/third_party/webcomponents/customelements.js
new file mode 100644
index 0000000..931f6c2
--- /dev/null
+++ b/vendor/golang.org/x/tools/third_party/webcomponents/customelements.js
@@ -0,0 +1,1029 @@
+/**
+ * @license
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+// @version 0.7.22
+if (typeof WeakMap === "undefined") {
+  (function() {
+    var defineProperty = Object.defineProperty;
+    var counter = Date.now() % 1e9;
+    var WeakMap = function() {
+      this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
+    };
+    WeakMap.prototype = {
+      set: function(key, value) {
+        var entry = key[this.name];
+        if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
+          value: [ key, value ],
+          writable: true
+        });
+        return this;
+      },
+      get: function(key) {
+        var entry;
+        return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
+      },
+      "delete": function(key) {
+        var entry = key[this.name];
+        if (!entry || entry[0] !== key) return false;
+        entry[0] = entry[1] = undefined;
+        return true;
+      },
+      has: function(key) {
+        var entry = key[this.name];
+        if (!entry) return false;
+        return entry[0] === key;
+      }
+    };
+    window.WeakMap = WeakMap;
+  })();
+}
+
+(function(global) {
+  if (global.JsMutationObserver) {
+    return;
+  }
+  var registrationsTable = new WeakMap();
+  var setImmediate;
+  if (/Trident|Edge/.test(navigator.userAgent)) {
+    setImmediate = setTimeout;
+  } else if (window.setImmediate) {
+    setImmediate = window.setImmediate;
+  } else {
+    var setImmediateQueue = [];
+    var sentinel = String(Math.random());
+    window.addEventListener("message", function(e) {
+      if (e.data === sentinel) {
+        var queue = setImmediateQueue;
+        setImmediateQueue = [];
+        queue.forEach(function(func) {
+          func();
+        });
+      }
+    });
+    setImmediate = function(func) {
+      setImmediateQueue.push(func);
+      window.postMessage(sentinel, "*");
+    };
+  }
+  var isScheduled = false;
+  var scheduledObservers = [];
+  function scheduleCallback(observer) {
+    scheduledObservers.push(observer);
+    if (!isScheduled) {
+      isScheduled = true;
+      setImmediate(dispatchCallbacks);
+    }
+  }
+  function wrapIfNeeded(node) {
+    return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;
+  }
+  function dispatchCallbacks() {
+    isScheduled = false;
+    var observers = scheduledObservers;
+    scheduledObservers = [];
+    observers.sort(function(o1, o2) {
+      return o1.uid_ - o2.uid_;
+    });
+    var anyNonEmpty = false;
+    observers.forEach(function(observer) {
+      var queue = observer.takeRecords();
+      removeTransientObserversFor(observer);
+      if (queue.length) {
+        observer.callback_(queue, observer);
+        anyNonEmpty = true;
+      }
+    });
+    if (anyNonEmpty) dispatchCallbacks();
+  }
+  function removeTransientObserversFor(observer) {
+    observer.nodes_.forEach(function(node) {
+      var registrations = registrationsTable.get(node);
+      if (!registrations) return;
+      registrations.forEach(function(registration) {
+        if (registration.observer === observer) registration.removeTransientObservers();
+      });
+    });
+  }
+  function forEachAncestorAndObserverEnqueueRecord(target, callback) {
+    for (var node = target; node; node = node.parentNode) {
+      var registrations = registrationsTable.get(node);
+      if (registrations) {
+        for (var j = 0; j < registrations.length; j++) {
+          var registration = registrations[j];
+          var options = registration.options;
+          if (node !== target && !options.subtree) continue;
+          var record = callback(options);
+          if (record) registration.enqueue(record);
+        }
+      }
+    }
+  }
+  var uidCounter = 0;
+  function JsMutationObserver(callback) {
+    this.callback_ = callback;
+    this.nodes_ = [];
+    this.records_ = [];
+    this.uid_ = ++uidCounter;
+  }
+  JsMutationObserver.prototype = {
+    observe: function(target, options) {
+      target = wrapIfNeeded(target);
+      if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {
+        throw new SyntaxError();
+      }
+      var registrations = registrationsTable.get(target);
+      if (!registrations) registrationsTable.set(target, registrations = []);
+      var registration;
+      for (var i = 0; i < registrations.length; i++) {
+        if (registrations[i].observer === this) {
+          registration = registrations[i];
+          registration.removeListeners();
+          registration.options = options;
+          break;
+        }
+      }
+      if (!registration) {
+        registration = new Registration(this, target, options);
+        registrations.push(registration);
+        this.nodes_.push(target);
+      }
+      registration.addListeners();
+    },
+    disconnect: function() {
+      this.nodes_.forEach(function(node) {
+        var registrations = registrationsTable.get(node);
+        for (var i = 0; i < registrations.length; i++) {
+          var registration = registrations[i];
+          if (registration.observer === this) {
+            registration.removeListeners();
+            registrations.splice(i, 1);
+            break;
+          }
+        }
+      }, this);
+      this.records_ = [];
+    },
+    takeRecords: function() {
+      var copyOfRecords = this.records_;
+      this.records_ = [];
+      return copyOfRecords;
+    }
+  };
+  function MutationRecord(type, target) {
+    this.type = type;
+    this.target = target;
+    this.addedNodes = [];
+    this.removedNodes = [];
+    this.previousSibling = null;
+    this.nextSibling = null;
+    this.attributeName = null;
+    this.attributeNamespace = null;
+    this.oldValue = null;
+  }
+  function copyMutationRecord(original) {
+    var record = new MutationRecord(original.type, original.target);
+    record.addedNodes = original.addedNodes.slice();
+    record.removedNodes = original.removedNodes.slice();
+    record.previousSibling = original.previousSibling;
+    record.nextSibling = original.nextSibling;
+    record.attributeName = original.attributeName;
+    record.attributeNamespace = original.attributeNamespace;
+    record.oldValue = original.oldValue;
+    return record;
+  }
+  var currentRecord, recordWithOldValue;
+  function getRecord(type, target) {
+    return currentRecord = new MutationRecord(type, target);
+  }
+  function getRecordWithOldValue(oldValue) {
+    if (recordWithOldValue) return recordWithOldValue;
+    recordWithOldValue = copyMutationRecord(currentRecord);
+    recordWithOldValue.oldValue = oldValue;
+    return recordWithOldValue;
+  }
+  function clearRecords() {
+    currentRecord = recordWithOldValue = undefined;
+  }
+  function recordRepresentsCurrentMutation(record) {
+    return record === recordWithOldValue || record === currentRecord;
+  }
+  function selectRecord(lastRecord, newRecord) {
+    if (lastRecord === newRecord) return lastRecord;
+    if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;
+    return null;
+  }
+  function Registration(observer, target, options) {
+    this.observer = observer;
+    this.target = target;
+    this.options = options;
+    this.transientObservedNodes = [];
+  }
+  Registration.prototype = {
+    enqueue: function(record) {
+      var records = this.observer.records_;
+      var length = records.length;
+      if (records.length > 0) {
+        var lastRecord = records[length - 1];
+        var recordToReplaceLast = selectRecord(lastRecord, record);
+        if (recordToReplaceLast) {
+          records[length - 1] = recordToReplaceLast;
+          return;
+        }
+      } else {
+        scheduleCallback(this.observer);
+      }
+      records[length] = record;
+    },
+    addListeners: function() {
+      this.addListeners_(this.target);
+    },
+    addListeners_: function(node) {
+      var options = this.options;
+      if (options.attributes) node.addEventListener("DOMAttrModified", this, true);
+      if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);
+      if (options.childList) node.addEventListener("DOMNodeInserted", this, true);
+      if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);
+    },
+    removeListeners: function() {
+      this.removeListeners_(this.target);
+    },
+    removeListeners_: function(node) {
+      var options = this.options;
+      if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);
+      if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);
+      if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);
+      if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);
+    },
+    addTransientObserver: function(node) {
+      if (node === this.target) return;
+      this.addListeners_(node);
+      this.transientObservedNodes.push(node);
+      var registrations = registrationsTable.get(node);
+      if (!registrations) registrationsTable.set(node, registrations = []);
+      registrations.push(this);
+    },
+    removeTransientObservers: function() {
+      var transientObservedNodes = this.transientObservedNodes;
+      this.transientObservedNodes = [];
+      transientObservedNodes.forEach(function(node) {
+        this.removeListeners_(node);
+        var registrations = registrationsTable.get(node);
+        for (var i = 0; i < registrations.length; i++) {
+          if (registrations[i] === this) {
+            registrations.splice(i, 1);
+            break;
+          }
+        }
+      }, this);
+    },
+    handleEvent: function(e) {
+      e.stopImmediatePropagation();
+      switch (e.type) {
+       case "DOMAttrModified":
+        var name = e.attrName;
+        var namespace = e.relatedNode.namespaceURI;
+        var target = e.target;
+        var record = new getRecord("attributes", target);
+        record.attributeName = name;
+        record.attributeNamespace = namespace;
+        var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;
+        forEachAncestorAndObserverEnqueueRecord(target, function(options) {
+          if (!options.attributes) return;
+          if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {
+            return;
+          }
+          if (options.attributeOldValue) return getRecordWithOldValue(oldValue);
+          return record;
+        });
+        break;
+
+       case "DOMCharacterDataModified":
+        var target = e.target;
+        var record = getRecord("characterData", target);
+        var oldValue = e.prevValue;
+        forEachAncestorAndObserverEnqueueRecord(target, function(options) {
+          if (!options.characterData) return;
+          if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);
+          return record;
+        });
+        break;
+
+       case "DOMNodeRemoved":
+        this.addTransientObserver(e.target);
+
+       case "DOMNodeInserted":
+        var changedNode = e.target;
+        var addedNodes, removedNodes;
+        if (e.type === "DOMNodeInserted") {
+          addedNodes = [ changedNode ];
+          removedNodes = [];
+        } else {
+          addedNodes = [];
+          removedNodes = [ changedNode ];
+        }
+        var previousSibling = changedNode.previousSibling;
+        var nextSibling = changedNode.nextSibling;
+        var record = getRecord("childList", e.target.parentNode);
+        record.addedNodes = addedNodes;
+        record.removedNodes = removedNodes;
+        record.previousSibling = previousSibling;
+        record.nextSibling = nextSibling;
+        forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function(options) {
+          if (!options.childList) return;
+          return record;
+        });
+      }
+      clearRecords();
+    }
+  };
+  global.JsMutationObserver = JsMutationObserver;
+  if (!global.MutationObserver) {
+    global.MutationObserver = JsMutationObserver;
+    JsMutationObserver._isPolyfilled = true;
+  }
+})(self);
+
+(function(scope) {
+  "use strict";
+  if (!window.performance) {
+    var start = Date.now();
+    window.performance = {
+      now: function() {
+        return Date.now() - start;
+      }
+    };
+  }
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = function() {
+      var nativeRaf = window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;
+      return nativeRaf ? function(callback) {
+        return nativeRaf(function() {
+          callback(performance.now());
+        });
+      } : function(callback) {
+        return window.setTimeout(callback, 1e3 / 60);
+      };
+    }();
+  }
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = function() {
+      return window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || function(id) {
+        clearTimeout(id);
+      };
+    }();
+  }
+  var workingDefaultPrevented = function() {
+    var e = document.createEvent("Event");
+    e.initEvent("foo", true, true);
+    e.preventDefault();
+    return e.defaultPrevented;
+  }();
+  if (!workingDefaultPrevented) {
+    var origPreventDefault = Event.prototype.preventDefault;
+    Event.prototype.preventDefault = function() {
+      if (!this.cancelable) {
+        return;
+      }
+      origPreventDefault.call(this);
+      Object.defineProperty(this, "defaultPrevented", {
+        get: function() {
+          return true;
+        },
+        configurable: true
+      });
+    };
+  }
+  var isIE = /Trident/.test(navigator.userAgent);
+  if (!window.CustomEvent || isIE && typeof window.CustomEvent !== "function") {
+    window.CustomEvent = function(inType, params) {
+      params = params || {};
+      var e = document.createEvent("CustomEvent");
+      e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);
+      return e;
+    };
+    window.CustomEvent.prototype = window.Event.prototype;
+  }
+  if (!window.Event || isIE && typeof window.Event !== "function") {
+    var origEvent = window.Event;
+    window.Event = function(inType, params) {
+      params = params || {};
+      var e = document.createEvent("Event");
+      e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));
+      return e;
+    };
+    window.Event.prototype = origEvent.prototype;
+  }
+})(window.WebComponents);
+
+window.CustomElements = window.CustomElements || {
+  flags: {}
+};
+
+(function(scope) {
+  var flags = scope.flags;
+  var modules = [];
+  var addModule = function(module) {
+    modules.push(module);
+  };
+  var initializeModules = function() {
+    modules.forEach(function(module) {
+      module(scope);
+    });
+  };
+  scope.addModule = addModule;
+  scope.initializeModules = initializeModules;
+  scope.hasNative = Boolean(document.registerElement);
+  scope.isIE = /Trident/.test(navigator.userAgent);
+  scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || window.HTMLImports.useNative);
+})(window.CustomElements);
+
+window.CustomElements.addModule(function(scope) {
+  var IMPORT_LINK_TYPE = window.HTMLImports ? window.HTMLImports.IMPORT_LINK_TYPE : "none";
+  function forSubtree(node, cb) {
+    findAllElements(node, function(e) {
+      if (cb(e)) {
+        return true;
+      }
+      forRoots(e, cb);
+    });
+    forRoots(node, cb);
+  }
+  function findAllElements(node, find, data) {
+    var e = node.firstElementChild;
+    if (!e) {
+      e = node.firstChild;
+      while (e && e.nodeType !== Node.ELEMENT_NODE) {
+        e = e.nextSibling;
+      }
+    }
+    while (e) {
+      if (find(e, data) !== true) {
+        findAllElements(e, find, data);
+      }
+      e = e.nextElementSibling;
+    }
+    return null;
+  }
+  function forRoots(node, cb) {
+    var root = node.shadowRoot;
+    while (root) {
+      forSubtree(root, cb);
+      root = root.olderShadowRoot;
+    }
+  }
+  function forDocumentTree(doc, cb) {
+    _forDocumentTree(doc, cb, []);
+  }
+  function _forDocumentTree(doc, cb, processingDocuments) {
+    doc = window.wrap(doc);
+    if (processingDocuments.indexOf(doc) >= 0) {
+      return;
+    }
+    processingDocuments.push(doc);
+    var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]");
+    for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {
+      if (n.import) {
+        _forDocumentTree(n.import, cb, processingDocuments);
+      }
+    }
+    cb(doc);
+  }
+  scope.forDocumentTree = forDocumentTree;
+  scope.forSubtree = forSubtree;
+});
+
+window.CustomElements.addModule(function(scope) {
+  var flags = scope.flags;
+  var forSubtree = scope.forSubtree;
+  var forDocumentTree = scope.forDocumentTree;
+  function addedNode(node, isAttached) {
+    return added(node, isAttached) || addedSubtree(node, isAttached);
+  }
+  function added(node, isAttached) {
+    if (scope.upgrade(node, isAttached)) {
+      return true;
+    }
+    if (isAttached) {
+      attached(node);
+    }
+  }
+  function addedSubtree(node, isAttached) {
+    forSubtree(node, function(e) {
+      if (added(e, isAttached)) {
+        return true;
+      }
+    });
+  }
+  var hasThrottledAttached = window.MutationObserver._isPolyfilled && flags["throttle-attached"];
+  scope.hasPolyfillMutations = hasThrottledAttached;
+  scope.hasThrottledAttached = hasThrottledAttached;
+  var isPendingMutations = false;
+  var pendingMutations = [];
+  function deferMutation(fn) {
+    pendingMutations.push(fn);
+    if (!isPendingMutations) {
+      isPendingMutations = true;
+      setTimeout(takeMutations);
+    }
+  }
+  function takeMutations() {
+    isPendingMutations = false;
+    var $p = pendingMutations;
+    for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
+      p();
+    }
+    pendingMutations = [];
+  }
+  function attached(element) {
+    if (hasThrottledAttached) {
+      deferMutation(function() {
+        _attached(element);
+      });
+    } else {
+      _attached(element);
+    }
+  }
+  function _attached(element) {
+    if (element.__upgraded__ && !element.__attached) {
+      element.__attached = true;
+      if (element.attachedCallback) {
+        element.attachedCallback();
+      }
+    }
+  }
+  function detachedNode(node) {
+    detached(node);
+    forSubtree(node, function(e) {
+      detached(e);
+    });
+  }
+  function detached(element) {
+    if (hasThrottledAttached) {
+      deferMutation(function() {
+        _detached(element);
+      });
+    } else {
+      _detached(element);
+    }
+  }
+  function _detached(element) {
+    if (element.__upgraded__ && element.__attached) {
+      element.__attached = false;
+      if (element.detachedCallback) {
+        element.detachedCallback();
+      }
+    }
+  }
+  function inDocument(element) {
+    var p = element;
+    var doc = window.wrap(document);
+    while (p) {
+      if (p == doc) {
+        return true;
+      }
+      p = p.parentNode || p.nodeType === Node.DOCUMENT_FRAGMENT_NODE && p.host;
+    }
+  }
+  function watchShadow(node) {
+    if (node.shadowRoot && !node.shadowRoot.__watched) {
+      flags.dom && console.log("watching shadow-root for: ", node.localName);
+      var root = node.shadowRoot;
+      while (root) {
+        observe(root);
+        root = root.olderShadowRoot;
+      }
+    }
+  }
+  function handler(root, mutations) {
+    if (flags.dom) {
+      var mx = mutations[0];
+      if (mx && mx.type === "childList" && mx.addedNodes) {
+        if (mx.addedNodes) {
+          var d = mx.addedNodes[0];
+          while (d && d !== document && !d.host) {
+            d = d.parentNode;
+          }
+          var u = d && (d.URL || d._URL || d.host && d.host.localName) || "";
+          u = u.split("/?").shift().split("/").pop();
+        }
+      }
+      console.group("mutations (%d) [%s]", mutations.length, u || "");
+    }
+    var isAttached = inDocument(root);
+    mutations.forEach(function(mx) {
+      if (mx.type === "childList") {
+        forEach(mx.addedNodes, function(n) {
+          if (!n.localName) {
+            return;
+          }
+          addedNode(n, isAttached);
+        });
+        forEach(mx.removedNodes, function(n) {
+          if (!n.localName) {
+            return;
+          }
+          detachedNode(n);
+        });
+      }
+    });
+    flags.dom && console.groupEnd();
+  }
+  function takeRecords(node) {
+    node = window.wrap(node);
+    if (!node) {
+      node = window.wrap(document);
+    }
+    while (node.parentNode) {
+      node = node.parentNode;
+    }
+    var observer = node.__observer;
+    if (observer) {
+      handler(node, observer.takeRecords());
+      takeMutations();
+    }
+  }
+  var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
+  function observe(inRoot) {
+    if (inRoot.__observer) {
+      return;
+    }
+    var observer = new MutationObserver(handler.bind(this, inRoot));
+    observer.observe(inRoot, {
+      childList: true,
+      subtree: true
+    });
+    inRoot.__observer = observer;
+  }
+  function upgradeDocument(doc) {
+    doc = window.wrap(doc);
+    flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop());
+    var isMainDocument = doc === window.wrap(document);
+    addedNode(doc, isMainDocument);
+    observe(doc);
+    flags.dom && console.groupEnd();
+  }
+  function upgradeDocumentTree(doc) {
+    forDocumentTree(doc, upgradeDocument);
+  }
+  var originalCreateShadowRoot = Element.prototype.createShadowRoot;
+  if (originalCreateShadowRoot) {
+    Element.prototype.createShadowRoot = function() {
+      var root = originalCreateShadowRoot.call(this);
+      window.CustomElements.watchShadow(this);
+      return root;
+    };
+  }
+  scope.watchShadow = watchShadow;
+  scope.upgradeDocumentTree = upgradeDocumentTree;
+  scope.upgradeDocument = upgradeDocument;
+  scope.upgradeSubtree = addedSubtree;
+  scope.upgradeAll = addedNode;
+  scope.attached = attached;
+  scope.takeRecords = takeRecords;
+});
+
+window.CustomElements.addModule(function(scope) {
+  var flags = scope.flags;
+  function upgrade(node, isAttached) {
+    if (node.localName === "template") {
+      if (window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
+        HTMLTemplateElement.decorate(node);
+      }
+    }
+    if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {
+      var is = node.getAttribute("is");
+      var definition = scope.getRegisteredDefinition(node.localName) || scope.getRegisteredDefinition(is);
+      if (definition) {
+        if (is && definition.tag == node.localName || !is && !definition.extends) {
+          return upgradeWithDefinition(node, definition, isAttached);
+        }
+      }
+    }
+  }
+  function upgradeWithDefinition(element, definition, isAttached) {
+    flags.upgrade && console.group("upgrade:", element.localName);
+    if (definition.is) {
+      element.setAttribute("is", definition.is);
+    }
+    implementPrototype(element, definition);
+    element.__upgraded__ = true;
+    created(element);
+    if (isAttached) {
+      scope.attached(element);
+    }
+    scope.upgradeSubtree(element, isAttached);
+    flags.upgrade && console.groupEnd();
+    return element;
+  }
+  function implementPrototype(element, definition) {
+    if (Object.__proto__) {
+      element.__proto__ = definition.prototype;
+    } else {
+      customMixin(element, definition.prototype, definition.native);
+      element.__proto__ = definition.prototype;
+    }
+  }
+  function customMixin(inTarget, inSrc, inNative) {
+    var used = {};
+    var p = inSrc;
+    while (p !== inNative && p !== HTMLElement.prototype) {
+      var keys = Object.getOwnPropertyNames(p);
+      for (var i = 0, k; k = keys[i]; i++) {
+        if (!used[k]) {
+          Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));
+          used[k] = 1;
+        }
+      }
+      p = Object.getPrototypeOf(p);
+    }
+  }
+  function created(element) {
+    if (element.createdCallback) {
+      element.createdCallback();
+    }
+  }
+  scope.upgrade = upgrade;
+  scope.upgradeWithDefinition = upgradeWithDefinition;
+  scope.implementPrototype = implementPrototype;
+});
+
+window.CustomElements.addModule(function(scope) {
+  var isIE = scope.isIE;
+  var upgradeDocumentTree = scope.upgradeDocumentTree;
+  var upgradeAll = scope.upgradeAll;
+  var upgradeWithDefinition = scope.upgradeWithDefinition;
+  var implementPrototype = scope.implementPrototype;
+  var useNative = scope.useNative;
+  function register(name, options) {
+    var definition = options || {};
+    if (!name) {
+      throw new Error("document.registerElement: first argument `name` must not be empty");
+    }
+    if (name.indexOf("-") < 0) {
+      throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'.");
+    }
+    if (isReservedTag(name)) {
+      throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid.");
+    }
+    if (getRegisteredDefinition(name)) {
+      throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered");
+    }
+    if (!definition.prototype) {
+      definition.prototype = Object.create(HTMLElement.prototype);
+    }
+    definition.__name = name.toLowerCase();
+    if (definition.extends) {
+      definition.extends = definition.extends.toLowerCase();
+    }
+    definition.lifecycle = definition.lifecycle || {};
+    definition.ancestry = ancestry(definition.extends);
+    resolveTagName(definition);
+    resolvePrototypeChain(definition);
+    overrideAttributeApi(definition.prototype);
+    registerDefinition(definition.__name, definition);
+    definition.ctor = generateConstructor(definition);
+    definition.ctor.prototype = definition.prototype;
+    definition.prototype.constructor = definition.ctor;
+    if (scope.ready) {
+      upgradeDocumentTree(document);
+    }
+    return definition.ctor;
+  }
+  function overrideAttributeApi(prototype) {
+    if (prototype.setAttribute._polyfilled) {
+      return;
+    }
+    var setAttribute = prototype.setAttribute;
+    prototype.setAttribute = function(name, value) {
+      changeAttribute.call(this, name, value, setAttribute);
+    };
+    var removeAttribute = prototype.removeAttribute;
+    prototype.removeAttribute = function(name) {
+      changeAttribute.call(this, name, null, removeAttribute);
+    };
+    prototype.setAttribute._polyfilled = true;
+  }
+  function changeAttribute(name, value, operation) {
+    name = name.toLowerCase();
+    var oldValue = this.getAttribute(name);
+    operation.apply(this, arguments);
+    var newValue = this.getAttribute(name);
+    if (this.attributeChangedCallback && newValue !== oldValue) {
+      this.attributeChangedCallback(name, oldValue, newValue);
+    }
+  }
+  function isReservedTag(name) {
+    for (var i = 0; i < reservedTagList.length; i++) {
+      if (name === reservedTagList[i]) {
+        return true;
+      }
+    }
+  }
+  var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ];
+  function ancestry(extnds) {
+    var extendee = getRegisteredDefinition(extnds);
+    if (extendee) {
+      return ancestry(extendee.extends).concat([ extendee ]);
+    }
+    return [];
+  }
+  function resolveTagName(definition) {
+    var baseTag = definition.extends;
+    for (var i = 0, a; a = definition.ancestry[i]; i++) {
+      baseTag = a.is && a.tag;
+    }
+    definition.tag = baseTag || definition.__name;
+    if (baseTag) {
+      definition.is = definition.__name;
+    }
+  }
+  function resolvePrototypeChain(definition) {
+    if (!Object.__proto__) {
+      var nativePrototype = HTMLElement.prototype;
+      if (definition.is) {
+        var inst = document.createElement(definition.tag);
+        nativePrototype = Object.getPrototypeOf(inst);
+      }
+      var proto = definition.prototype, ancestor;
+      var foundPrototype = false;
+      while (proto) {
+        if (proto == nativePrototype) {
+          foundPrototype = true;
+        }
+        ancestor = Object.getPrototypeOf(proto);
+        if (ancestor) {
+          proto.__proto__ = ancestor;
+        }
+        proto = ancestor;
+      }
+      if (!foundPrototype) {
+        console.warn(definition.tag + " prototype not found in prototype chain for " + definition.is);
+      }
+      definition.native = nativePrototype;
+    }
+  }
+  function instantiate(definition) {
+    return upgradeWithDefinition(domCreateElement(definition.tag), definition);
+  }
+  var registry = {};
+  function getRegisteredDefinition(name) {
+    if (name) {
+      return registry[name.toLowerCase()];
+    }
+  }
+  function registerDefinition(name, definition) {
+    registry[name] = definition;
+  }
+  function generateConstructor(definition) {
+    return function() {
+      return instantiate(definition);
+    };
+  }
+  var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+  function createElementNS(namespace, tag, typeExtension) {
+    if (namespace === HTML_NAMESPACE) {
+      return createElement(tag, typeExtension);
+    } else {
+      return domCreateElementNS(namespace, tag);
+    }
+  }
+  function createElement(tag, typeExtension) {
+    if (tag) {
+      tag = tag.toLowerCase();
+    }
+    if (typeExtension) {
+      typeExtension = typeExtension.toLowerCase();
+    }
+    var definition = getRegisteredDefinition(typeExtension || tag);
+    if (definition) {
+      if (tag == definition.tag && typeExtension == definition.is) {
+        return new definition.ctor();
+      }
+      if (!typeExtension && !definition.is) {
+        return new definition.ctor();
+      }
+    }
+    var element;
+    if (typeExtension) {
+      element = createElement(tag);
+      element.setAttribute("is", typeExtension);
+      return element;
+    }
+    element = domCreateElement(tag);
+    if (tag.indexOf("-") >= 0) {
+      implementPrototype(element, HTMLElement);
+    }
+    return element;
+  }
+  var domCreateElement = document.createElement.bind(document);
+  var domCreateElementNS = document.createElementNS.bind(document);
+  var isInstance;
+  if (!Object.__proto__ && !useNative) {
+    isInstance = function(obj, ctor) {
+      if (obj instanceof ctor) {
+        return true;
+      }
+      var p = obj;
+      while (p) {
+        if (p === ctor.prototype) {
+          return true;
+        }
+        p = p.__proto__;
+      }
+      return false;
+    };
+  } else {
+    isInstance = function(obj, base) {
+      return obj instanceof base;
+    };
+  }
+  function wrapDomMethodToForceUpgrade(obj, methodName) {
+    var orig = obj[methodName];
+    obj[methodName] = function() {
+      var n = orig.apply(this, arguments);
+      upgradeAll(n);
+      return n;
+    };
+  }
+  wrapDomMethodToForceUpgrade(Node.prototype, "cloneNode");
+  wrapDomMethodToForceUpgrade(document, "importNode");
+  document.registerElement = register;
+  document.createElement = createElement;
+  document.createElementNS = createElementNS;
+  scope.registry = registry;
+  scope.instanceof = isInstance;
+  scope.reservedTagList = reservedTagList;
+  scope.getRegisteredDefinition = getRegisteredDefinition;
+  document.register = document.registerElement;
+});
+
+(function(scope) {
+  var useNative = scope.useNative;
+  var initializeModules = scope.initializeModules;
+  var isIE = scope.isIE;
+  if (useNative) {
+    var nop = function() {};
+    scope.watchShadow = nop;
+    scope.upgrade = nop;
+    scope.upgradeAll = nop;
+    scope.upgradeDocumentTree = nop;
+    scope.upgradeSubtree = nop;
+    scope.takeRecords = nop;
+    scope.instanceof = function(obj, base) {
+      return obj instanceof base;
+    };
+  } else {
+    initializeModules();
+  }
+  var upgradeDocumentTree = scope.upgradeDocumentTree;
+  var upgradeDocument = scope.upgradeDocument;
+  if (!window.wrap) {
+    if (window.ShadowDOMPolyfill) {
+      window.wrap = window.ShadowDOMPolyfill.wrapIfNeeded;
+      window.unwrap = window.ShadowDOMPolyfill.unwrapIfNeeded;
+    } else {
+      window.wrap = window.unwrap = function(node) {
+        return node;
+      };
+    }
+  }
+  if (window.HTMLImports) {
+    window.HTMLImports.__importsParsingHook = function(elt) {
+      if (elt.import) {
+        upgradeDocument(wrap(elt.import));
+      }
+    };
+  }
+  function bootstrap() {
+    upgradeDocumentTree(window.wrap(document));
+    window.CustomElements.ready = true;
+    var requestAnimationFrame = window.requestAnimationFrame || function(f) {
+      setTimeout(f, 16);
+    };
+    requestAnimationFrame(function() {
+      setTimeout(function() {
+        window.CustomElements.readyTime = Date.now();
+        if (window.HTMLImports) {
+          window.CustomElements.elapsed = window.CustomElements.readyTime - window.HTMLImports.readyTime;
+        }
+        document.dispatchEvent(new CustomEvent("WebComponentsReady", {
+          bubbles: true
+        }));
+      });
+    });
+  }
+  if (document.readyState === "complete" || scope.flags.eager) {
+    bootstrap();
+  } else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) {
+    bootstrap();
+  } else {
+    var loadEvent = window.HTMLImports && !window.HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded";
+    window.addEventListener(loadEvent, bootstrap);
+  }
+})(window.CustomElements);
\ No newline at end of file