TOOLS-1058 goconvey fails with gccgo

291 files changed, 29959 insertions, 4725 deletions

diff --git a/Godeps b/Godeps
index 18fde779e1e..12a7a1a7e61 100644
--- a/Godeps
+++ b/Godeps
@@ -1,7 +1,9 @@
 gopkg.in/mgo.v2                         e30de8ac9ae3b30df7065f766c71f88bba7d4e49
 gopkg.in/tomb.v2                        14b3d72120e8d10ea6e6b7f87f7175734b1faab8	github.com/go-tomb/tomb
+github.com/jtolds/gls                   8ddce2a84170772b95dd5d576c48d517b22cac63
 github.com/jacobsa/oglematchers         3ecefc49db07722beca986d9bb71ddd026b133f0
-github.com/smartystreets/goconvey       eb2e83c1df892d2c9ad5a3c85672da30be585dfd
+github.com/smartystreets/assertions     5de9043ec1a39cc97edc838ef7236538a55b30a4
+github.com/smartystreets/goconvey       995f5b2e021c69b8b028ba6d0b05c1dd500783db
 github.com/jessevdk/go-flags            5e118789801496c93ba210d34ef1f2ce5a9173bd
 github.com/3rf/mongo-lint               f6cf4f8a7d07167375b035d186a1e8b3ebf28aa3
 github.com/spacemonkeygo/openssl        4c6dbafa5ec35b3ffc6a1b1e1fe29c3eba2053ec	github.com/10gen/openssl
diff --git a/common/json/encode_test.go b/common/json/encode_test.go
index 6de6fb66c57..8226a3df71a 100644
--- a/common/json/encode_test.go
+++ b/common/json/encode_test.go
@@ -212,10 +212,10 @@ func TestRefValMarshal(t *testing.T) {
 	}
 }
 
-// C implements Marshaler and returns unescaped JSON.
-type C int
+// C1 implements Marshaler and returns unescaped JSON.
+type C1 int
 
-func (C) MarshalJSON() ([]byte, error) {
+func (C1) MarshalJSON() ([]byte, error) {
 	return []byte(`"<&>"`), nil
 }
 
@@ -227,14 +227,14 @@ func (CText) MarshalText() ([]byte, error) {
 }
 
 func TestMarshalerEscaping(t *testing.T) {
-	var c C
+	var c C1
 	want := `"\u003c\u0026\u003e"`
 	b, err := Marshal(c)
 	if err != nil {
-		t.Fatalf("Marshal(c): %v", err)
+		t.Fatalf("Marshal(c1): %v", err)
 	}
 	if got := string(b); got != want {
-		t.Errorf("Marshal(c) = %#q, want %#q", got, want)
+		t.Errorf("Marshal(c1) = %#q, want %#q", got, want)
 	}
 
 	var ct CText
diff --git a/common/json/new_test.go b/common/json/new_test.go
index 77c97b29a2e..3d91ed9dcfb 100644
--- a/common/json/new_test.go
+++ b/common/json/new_test.go
@@ -25,7 +25,7 @@ func TestNewKeyword(t *testing.T) {
 			So(jsonValue, ShouldResemble, BinData{1, "xyz"})
 		})
 
-		Convey("can be used with BinData constructor", func() {
+		Convey("can be used with Boolean constructor", func() {
 			var jsonMap map[string]interface{}
 
 			key := "key"
diff --git a/mongoimport/tsv_test.go b/mongoimport/tsv_test.go
index 89b3d6fe36c..b36a76925a6 100644
--- a/mongoimport/tsv_test.go
+++ b/mongoimport/tsv_test.go
@@ -12,7 +12,7 @@ import (
 func TestTSVStreamDocument(t *testing.T) {
 	testutil.VerifyTestType(t, testutil.UnitTestType)
 	Convey("With a TSV input reader", t, func() {
-		Convey("integer valued strings should be converted", func() {
+		Convey("integer valued strings should be converted tsv1", func() {
 			contents := "1\t2\t3e\n"
 			fields := []string{"a", "b", "c"}
 			expectedRead := bson.D{
@@ -26,7 +26,7 @@ func TestTSVStreamDocument(t *testing.T) {
 			So(<-docChan, ShouldResemble, expectedRead)
 		})
 
-		Convey("integer valued strings should be converted", func() {
+		Convey("integer valued strings should be converted tsv2", func() {
 			contents := "a\tb\t\"cccc,cccc\"\td\n"
 			fields := []string{"a", "b", "c"}
 			expectedRead := bson.D{
diff --git a/vendor/src/github.com/jtolds/gls/LICENSE b/vendor/src/github.com/jtolds/gls/LICENSE
new file mode 100644
index 00000000000..9b4a822d92c
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2013, Space Monkey, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/src/github.com/jtolds/gls/README.md b/vendor/src/github.com/jtolds/gls/README.md
new file mode 100644
index 00000000000..4ebb692fb18
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/README.md
@@ -0,0 +1,89 @@
+gls
+===
+
+Goroutine local storage
+
+### IMPORTANT NOTE ###
+
+It is my duty to point you to https://blog.golang.org/context, which is how 
+Google solves all of the problems you'd perhaps consider using this package
+for at scale. 
+
+One downside to Google's approach is that *all* of your functions must have
+a new first argument, but after clearing that hurdle everything else is much
+better.
+
+If you aren't interested in this warning, read on.
+
+### Huhwaht? Why? ###
+
+Every so often, a thread shows up on the
+[golang-nuts](https://groups.google.com/d/forum/golang-nuts) asking for some
+form of goroutine-local-storage, or some kind of goroutine id, or some kind of
+context. There are a few valid use cases for goroutine-local-storage, one of
+the most prominent being log line context. One poster was interested in being
+able to log an HTTP request context id in every log line in the same goroutine
+as the incoming HTTP request, without having to change every library and
+function call he was interested in logging.
+
+This would be pretty useful. Provided that you could get some kind of
+goroutine-local-storage, you could call
+[log.SetOutput](http://golang.org/pkg/log/#SetOutput) with your own logging
+writer that checks goroutine-local-storage for some context information and
+adds that context to your log lines.
+
+But alas, Andrew Gerrand's typically diplomatic answer to the question of
+goroutine-local variables was:
+
+> We wouldn't even be having this discussion if thread local storage wasn't
+> useful. But every feature comes at a cost, and in my opinion the cost of
+> threadlocals far outweighs their benefits. They're just not a good fit for
+> Go.
+
+So, yeah, that makes sense. That's a pretty good reason for why the language
+won't support a specific and (relatively) unuseful feature that requires some
+runtime changes, just for the sake of a little bit of log improvement.
+
+But does Go require runtime changes?
+
+### How it works ###
+
+Go has pretty fantastic introspective and reflective features, but one thing Go
+doesn't give you is any kind of access to the stack pointer, or frame pointer,
+or goroutine id, or anything contextual about your current stack. It gives you
+access to your list of callers, but only along with program counters, which are
+fixed at compile time.
+
+But it does give you the stack.
+
+So, we define 16 special functions and embed base-16 tags into the stack using
+the call order of those 16 functions. Then, we can read our tags back out of
+the stack looking at the callers list.
+
+We then use these tags as an index into a traditional map for implementing
+this library.
+
+### What are people saying? ###
+
+"Wow, that's horrifying."
+
+"This is the most terrible thing I have seen in a very long time."
+
+"Where is it getting a context from? Is this serializing all the requests? 
+What the heck is the client being bound to? What are these tags? Why does he 
+need callers? Oh god no. No no no."
+
+### Docs ###
+
+Please see the docs at http://godoc.org/github.com/jtolds/gls
+
+### Related ###
+
+If you're okay relying on the string format of the current runtime stacktrace 
+including a unique goroutine id (not guaranteed by the spec or anything, but 
+very unlikely to change within a Go release), you might be able to squeeze 
+out a bit more performance by using this similar library, inspired by some 
+code Brad Fitzpatrick wrote for debugging his HTTP/2 library: 
+https://github.com/tylerb/gls (in contrast, jtolds/gls doesn't require 
+any knowledge of the string format of the runtime stacktrace, which 
+probably adds unnecessary overhead).
diff --git a/vendor/src/github.com/jtolds/gls/context.go b/vendor/src/github.com/jtolds/gls/context.go
new file mode 100644
index 00000000000..90cfcf7db17
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/context.go
@@ -0,0 +1,144 @@
+// Package gls implements goroutine-local storage.
+package gls
+
+import (
+	"sync"
+)
+
+const (
+	maxCallers = 64
+)
+
+var (
+	stackTagPool   = &idPool{}
+	mgrRegistry    = make(map[*ContextManager]bool)
+	mgrRegistryMtx sync.RWMutex
+)
+
+// Values is simply a map of key types to value types. Used by SetValues to
+// set multiple values at once.
+type Values map[interface{}]interface{}
+
+// ContextManager is the main entrypoint for interacting with
+// Goroutine-local-storage. You can have multiple independent ContextManagers
+// at any given time. ContextManagers are usually declared globally for a given
+// class of context variables. You should use NewContextManager for
+// construction.
+type ContextManager struct {
+	mtx    sync.RWMutex
+	values map[uint]Values
+}
+
+// NewContextManager returns a brand new ContextManager. It also registers the
+// new ContextManager in the ContextManager registry which is used by the Go
+// method. ContextManagers are typically defined globally at package scope.
+func NewContextManager() *ContextManager {
+	mgr := &ContextManager{values: make(map[uint]Values)}
+	mgrRegistryMtx.Lock()
+	defer mgrRegistryMtx.Unlock()
+	mgrRegistry[mgr] = true
+	return mgr
+}
+
+// Unregister removes a ContextManager from the global registry, used by the
+// Go method. Only intended for use when you're completely done with a
+// ContextManager. Use of Unregister at all is rare.
+func (m *ContextManager) Unregister() {
+	mgrRegistryMtx.Lock()
+	defer mgrRegistryMtx.Unlock()
+	delete(mgrRegistry, m)
+}
+
+// SetValues takes a collection of values and a function to call for those
+// values to be set in. Anything further down the stack will have the set
+// values available through GetValue. SetValues will add new values or replace
+// existing values of the same key and will not mutate or change values for
+// previous stack frames.
+// SetValues is slow (makes a copy of all current and new values for the new
+// gls-context) in order to reduce the amount of lookups GetValue requires.
+func (m *ContextManager) SetValues(new_values Values, context_call func()) {
+	if len(new_values) == 0 {
+		context_call()
+		return
+	}
+
+	tags := readStackTags(1)
+
+	m.mtx.Lock()
+	values := new_values
+	for _, tag := range tags {
+		if existing_values, ok := m.values[tag]; ok {
+			// oh, we found existing values, let's make a copy
+			values = make(Values, len(existing_values)+len(new_values))
+			for key, val := range existing_values {
+				values[key] = val
+			}
+			for key, val := range new_values {
+				values[key] = val
+			}
+			break
+		}
+	}
+	new_tag := stackTagPool.Acquire()
+	m.values[new_tag] = values
+	m.mtx.Unlock()
+	defer func() {
+		m.mtx.Lock()
+		delete(m.values, new_tag)
+		m.mtx.Unlock()
+		stackTagPool.Release(new_tag)
+	}()
+
+	addStackTag(new_tag, context_call)
+}
+
+// GetValue will return a previously set value, provided that the value was set
+// by SetValues somewhere higher up the stack. If the value is not found, ok
+// will be false.
+func (m *ContextManager) GetValue(key interface{}) (value interface{}, ok bool) {
+
+	tags := readStackTags(1)
+	m.mtx.RLock()
+	defer m.mtx.RUnlock()
+	for _, tag := range tags {
+		if values, ok := m.values[tag]; ok {
+			value, ok := values[key]
+			return value, ok
+		}
+	}
+	return "", false
+}
+
+func (m *ContextManager) getValues() Values {
+	tags := readStackTags(2)
+	m.mtx.RLock()
+	defer m.mtx.RUnlock()
+	for _, tag := range tags {
+		if values, ok := m.values[tag]; ok {
+			return values
+		}
+	}
+	return nil
+}
+
+// Go preserves ContextManager values and Goroutine-local-storage across new
+// goroutine invocations. The Go method makes a copy of all existing values on
+// all registered context managers and makes sure they are still set after
+// kicking off the provided function in a new goroutine. If you don't use this
+// Go method instead of the standard 'go' keyword, you will lose values in
+// ContextManagers, as goroutines have brand new stacks.
+func Go(cb func()) {
+	mgrRegistryMtx.RLock()
+	defer mgrRegistryMtx.RUnlock()
+
+	for mgr, _ := range mgrRegistry {
+		values := mgr.getValues()
+		if len(values) > 0 {
+			mgr_copy := mgr
+			cb_copy := cb
+			cb = func() { mgr_copy.SetValues(values, cb_copy) }
+		}
+	}
+
+	go cb()
+}
diff --git a/vendor/src/github.com/jtolds/gls/context_test.go b/vendor/src/github.com/jtolds/gls/context_test.go
new file mode 100644
index 00000000000..ae5bde4aede
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/context_test.go
@@ -0,0 +1,139 @@
+package gls
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+)
+
+func TestContexts(t *testing.T) {
+	mgr1 := NewContextManager()
+	mgr2 := NewContextManager()
+
+	CheckVal := func(mgr *ContextManager, key, exp_val string) {
+		val, ok := mgr.GetValue(key)
+		if len(exp_val) == 0 {
+			if ok {
+				t.Fatalf("expected no value for key %s, got %s", key, val)
+			}
+			return
+		}
+		if !ok {
+			t.Fatalf("expected value %s for key %s, got no value",
+				exp_val, key)
+		}
+		if exp_val != val {
+			t.Fatalf("expected value %s for key %s, got %s", exp_val, key,
+				val)
+		}
+
+	}
+
+	Check := func(exp_m1v1, exp_m1v2, exp_m2v1, exp_m2v2 string) {
+		CheckVal(mgr1, "key1", exp_m1v1)
+		CheckVal(mgr1, "key2", exp_m1v2)
+		CheckVal(mgr2, "key1", exp_m2v1)
+		CheckVal(mgr2, "key2", exp_m2v2)
+	}
+
+	Check("", "", "", "")
+	mgr2.SetValues(Values{"key1": "val1c"}, func() {
+		Check("", "", "val1c", "")
+		mgr1.SetValues(Values{"key1": "val1a"}, func() {
+			Check("val1a", "", "val1c", "")
+			mgr1.SetValues(Values{"key2": "val1b"}, func() {
+				Check("val1a", "val1b", "val1c", "")
+				var wg sync.WaitGroup
+				wg.Add(2)
+				go func() {
+					defer wg.Done()
+					Check("", "", "", "")
+				}()
+				Go(func() {
+					defer wg.Done()
+					Check("val1a", "val1b", "val1c", "")
+				})
+				wg.Wait()
+			})
+		})
+	})
+}
+
+func ExampleContextManager_SetValues() {
+	var (
+		mgr            = NewContextManager()
+		request_id_key = GenSym()
+	)
+
+	MyLog := func() {
+		if request_id, ok := mgr.GetValue(request_id_key); ok {
+			fmt.Println("My request id is:", request_id)
+		} else {
+			fmt.Println("No request id found")
+		}
+	}
+
+	mgr.SetValues(Values{request_id_key: "12345"}, func() {
+		MyLog()
+	})
+	MyLog()
+
+	// Output: My request id is: 12345
+	// No request id found
+}
+
+func ExampleGo() {
+	var (
+		mgr            = NewContextManager()
+		request_id_key = GenSym()
+	)
+
+	MyLog := func() {
+		if request_id, ok := mgr.GetValue(request_id_key); ok {
+			fmt.Println("My request id is:", request_id)
+		} else {
+			fmt.Println("No request id found")
+		}
+	}
+
+	mgr.SetValues(Values{request_id_key: "12345"}, func() {
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			MyLog()
+		}()
+		wg.Wait()
+		wg.Add(1)
+		Go(func() {
+			defer wg.Done()
+			MyLog()
+		})
+		wg.Wait()
+	})
+
+	// Output: No request id found
+	// My request id is: 12345
+}
+
+func BenchmarkGetValue(b *testing.B) {
+	mgr := NewContextManager()
+	mgr.SetValues(Values{"test_key": "test_val"}, func() {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			val, ok := mgr.GetValue("test_key")
+			if !ok || val != "test_val" {
+				b.FailNow()
+			}
+		}
+	})
+}
+
+func BenchmarkSetValues(b *testing.B) {
+	mgr := NewContextManager()
+	for i := 0; i < b.N/2; i++ {
+		mgr.SetValues(Values{"test_key": "test_val"}, func() {
+			mgr.SetValues(Values{"test_key2": "test_val2"}, func() {})
+		})
+	}
+}
diff --git a/vendor/src/github.com/jtolds/gls/gen_sym.go b/vendor/src/github.com/jtolds/gls/gen_sym.go
new file mode 100644
index 00000000000..8d5fc24d4a4
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/gen_sym.go
@@ -0,0 +1,13 @@
+package gls
+
+var (
+	symPool = &idPool{}
+)
+
+// ContextKey is a throwaway value you can use as a key to a ContextManager
+type ContextKey struct{ id uint }
+
+// GenSym will return a brand new, never-before-used ContextKey
+func GenSym() ContextKey {
+	return ContextKey{id: symPool.Acquire()}
+}
diff --git a/vendor/src/github.com/jtolds/gls/id_pool.go b/vendor/src/github.com/jtolds/gls/id_pool.go
new file mode 100644
index 00000000000..b7974ae0026
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/id_pool.go
@@ -0,0 +1,34 @@
+package gls
+
+// though this could probably be better at keeping ids smaller, the goal of
+// this class is to keep a registry of the smallest unique integer ids
+// per-process possible
+
+import (
+	"sync"
+)
+
+type idPool struct {
+	mtx      sync.Mutex
+	released []uint
+	max_id   uint
+}
+
+func (p *idPool) Acquire() (id uint) {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	if len(p.released) > 0 {
+		id = p.released[len(p.released)-1]
+		p.released = p.released[:len(p.released)-1]
+		return id
+	}
+	id = p.max_id
+	p.max_id++
+	return id
+}
+
+func (p *idPool) Release(id uint) {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	p.released = append(p.released, id)
+}
diff --git a/vendor/src/github.com/jtolds/gls/stack_tags.go b/vendor/src/github.com/jtolds/gls/stack_tags.go
new file mode 100644
index 00000000000..9b8e39ba7c2
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/stack_tags.go
@@ -0,0 +1,43 @@
+package gls
+
+// so, basically, we're going to encode integer tags in base-16 on the stack
+
+const (
+	bitWidth = 4
+)
+
+func addStackTag(tag uint, context_call func()) {
+	if context_call == nil {
+		return
+	}
+	markS(tag, context_call)
+}
+
+func markS(tag uint, cb func()) { _m(tag, cb) }
+func mark0(tag uint, cb func()) { _m(tag, cb) }
+func mark1(tag uint, cb func()) { _m(tag, cb) }
+func mark2(tag uint, cb func()) { _m(tag, cb) }
+func mark3(tag uint, cb func()) { _m(tag, cb) }
+func mark4(tag uint, cb func()) { _m(tag, cb) }
+func mark5(tag uint, cb func()) { _m(tag, cb) }
+func mark6(tag uint, cb func()) { _m(tag, cb) }
+func mark7(tag uint, cb func()) { _m(tag, cb) }
+func mark8(tag uint, cb func()) { _m(tag, cb) }
+func mark9(tag uint, cb func()) { _m(tag, cb) }
+func markA(tag uint, cb func()) { _m(tag, cb) }
+func markB(tag uint, cb func()) { _m(tag, cb) }
+func markC(tag uint, cb func()) { _m(tag, cb) }
+func markD(tag uint, cb func()) { _m(tag, cb) }
+func markE(tag uint, cb func()) { _m(tag, cb) }
+func markF(tag uint, cb func()) { _m(tag, cb) }
+
+var pc_lookup = make(map[uintptr]int8, 17)
+var mark_lookup [16]func(uint, func())
+
+func _m(tag_remainder uint, cb func()) {
+	if tag_remainder == 0 {
+		cb()
+	} else {
+		mark_lookup[tag_remainder&0xf](tag_remainder>>bitWidth, cb)
+	}
+}
diff --git a/vendor/src/github.com/jtolds/gls/stack_tags_js.go b/vendor/src/github.com/jtolds/gls/stack_tags_js.go
new file mode 100644
index 00000000000..21d5595926b
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/stack_tags_js.go
@@ -0,0 +1,101 @@
+// +build js
+
+package gls
+
+// This file is used for GopherJS builds, which don't have normal runtime support
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/gopherjs/gopherjs/js"
+)
+
+var stackRE = regexp.MustCompile("\\s+at (\\S*) \\([^:]+:(\\d+):(\\d+)")
+
+func findPtr() uintptr {
+	jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n")
+	for i := 1; i < jsStack.Get("length").Int(); i++ {
+		item := jsStack.Index(i).String()
+		matches := stackRE.FindAllStringSubmatch(item, -1)
+		if matches == nil {
+			return 0
+		}
+		pkgPath := matches[0][1]
+		if strings.HasPrefix(pkgPath, "$packages.github.com/jtolds/gls.mark") {
+			line, _ := strconv.Atoi(matches[0][2])
+			char, _ := strconv.Atoi(matches[0][3])
+			x := (uintptr(line) << 16) | uintptr(char)
+			return x
+		}
+	}
+
+	return 0
+}
+
+func init() {
+	setEntries := func(f func(uint, func()), v int8) {
+		var ptr uintptr
+		f(0, func() {
+			ptr = findPtr()
+		})
+		pc_lookup[ptr] = v
+		if v >= 0 {
+			mark_lookup[v] = f
+		}
+	}
+	setEntries(markS, -0x1)
+	setEntries(mark0, 0x0)
+	setEntries(mark1, 0x1)
+	setEntries(mark2, 0x2)
+	setEntries(mark3, 0x3)
+	setEntries(mark4, 0x4)
+	setEntries(mark5, 0x5)
+	setEntries(mark6, 0x6)
+	setEntries(mark7, 0x7)
+	setEntries(mark8, 0x8)
+	setEntries(mark9, 0x9)
+	setEntries(markA, 0xa)
+	setEntries(markB, 0xb)
+	setEntries(markC, 0xc)
+	setEntries(markD, 0xd)
+	setEntries(markE, 0xe)
+	setEntries(markF, 0xf)
+}
+
+func currentStack(skip int) (stack []uintptr) {
+	jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n")
+	for i := skip + 2; i < jsStack.Get("length").Int(); i++ {
+		item := jsStack.Index(i).String()
+		matches := stackRE.FindAllStringSubmatch(item, -1)
+		if matches == nil {
+			return stack
+		}
+		line, _ := strconv.Atoi(matches[0][2])
+		char, _ := strconv.Atoi(matches[0][3])
+		x := (uintptr(line) << 16) | uintptr(char)&0xffff
+		stack = append(stack, x)
+	}
+
+	return stack
+}
+
+func readStackTags(skip int) (tags []uint) {
+	stack := currentStack(skip)
+	var current_tag uint
+	for _, pc := range stack {
+		val, ok := pc_lookup[pc]
+		if !ok {
+			continue
+		}
+		if val < 0 {
+			tags = append(tags, current_tag)
+			current_tag = 0
+			continue
+		}
+		current_tag <<= bitWidth
+		current_tag += uint(val)
+	}
+	return
+}
diff --git a/vendor/src/github.com/jtolds/gls/stack_tags_main.go b/vendor/src/github.com/jtolds/gls/stack_tags_main.go
new file mode 100644
index 00000000000..cb302b9ef63
--- /dev/null
+++ b/vendor/src/github.com/jtolds/gls/stack_tags_main.go
@@ -0,0 +1,61 @@
+// +build !js
+
+package gls
+
+// This file is used for standard Go builds, which have the expected runtime support
+
+import (
+	"reflect"
+	"runtime"
+)
+
+func init() {
+	setEntries := func(f func(uint, func()), v int8) {
+		pc_lookup[reflect.ValueOf(f).Pointer()] = v
+		if v >= 0 {
+			mark_lookup[v] = f
+		}
+	}
+	setEntries(markS, -0x1)
+	setEntries(mark0, 0x0)
+	setEntries(mark1, 0x1)
+	setEntries(mark2, 0x2)
+	setEntries(mark3, 0x3)
+	setEntries(mark4, 0x4)
+	setEntries(mark5, 0x5)
+	setEntries(mark6, 0x6)
+	setEntries(mark7, 0x7)
+	setEntries(mark8, 0x8)
+	setEntries(mark9, 0x9)
+	setEntries(markA, 0xa)
+	setEntries(markB, 0xb)
+	setEntries(markC, 0xc)
+	setEntries(markD, 0xd)
+	setEntries(markE, 0xe)
+	setEntries(markF, 0xf)
+}
+
+func currentStack(skip int) []uintptr {
+	stack := make([]uintptr, maxCallers)
+	return stack[:runtime.Callers(3+skip, stack)]
+}
+
+func readStackTags(skip int) (tags []uint) {
+	stack := currentStack(skip)
+	var current_tag uint
+	for _, pc := range stack {
+		pc = runtime.FuncForPC(pc).Entry()
+		val, ok := pc_lookup[pc]
+		if !ok {
+			continue
+		}
+		if val < 0 {
+			tags = append(tags, current_tag)
+			current_tag = 0
+			continue
+		}
+		current_tag <<= bitWidth
+		current_tag += uint(val)
+	}
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/.gitignore b/vendor/src/github.com/smartystreets/assertions/.gitignore
new file mode 100644
index 00000000000..6ad551742d3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/.gitignore
@@ -0,0 +1,3 @@
+.DS_Store
+Thumbs.db
+/.idea
diff --git a/vendor/src/github.com/smartystreets/assertions/.travis.yml b/vendor/src/github.com/smartystreets/assertions/.travis.yml
new file mode 100644
index 00000000000..44217c97335
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/.travis.yml
@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
+
+install:
+  - go get -t ./...
+
+script: go test -v
+
+sudo: false
diff --git a/vendor/src/github.com/smartystreets/assertions/LICENSE.md b/vendor/src/github.com/smartystreets/assertions/LICENSE.md
new file mode 100644
index 00000000000..48a3731c01a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/LICENSE.md
@@ -0,0 +1,23 @@
+Copyright (c) 2015 SmartyStreets, LLC
+
+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.
+
+NOTE: Various optional and subordinate components carry their own licensing
+requirements and restrictions.  Use of those components is subject to the terms
+and conditions outlined the respective license of each component.
diff --git a/vendor/src/github.com/smartystreets/assertions/README.md b/vendor/src/github.com/smartystreets/assertions/README.md
new file mode 100644
index 00000000000..19a66320e24
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/README.md
@@ -0,0 +1,554 @@
+# assertions
+--
+    import "github.com/smartystreets/assertions"
+
+Package assertions contains the implementations for all assertions which are
+referenced in goconvey's `convey` package
+(github.com/smartystreets/goconvey/convey) for use with the So(...) method. They
+can also be used in traditional Go test functions and even in applicaitons.
+
+## Usage
+
+#### func  GoConveyMode
+
+```go
+func GoConveyMode(yes bool)
+```
+GoConveyMode provides control over JSON serialization of failures. When using
+the assertions in this package from the convey package JSON results are very
+helpful and can be rendered in a DIFF view. In that case, this function will be
+called with a true value to enable the JSON serialization. By default, the
+assertions in this package will not serializer a JSON result, making standalone
+ussage more convenient.
+
+#### func  ShouldAlmostEqual
+
+```go
+func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldAlmostEqual makes sure that two parameters are close enough to being
+equal. The acceptable delta may be specified with a third argument, or a very
+small default delta will be used.
+
+#### func  ShouldBeBetween
+
+```go
+func ShouldBeBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBetween receives exactly three parameters: an actual value, a lower
+bound, and an upper bound. It ensures that the actual value is between both
+bounds (but not equal to either of them).
+
+#### func  ShouldBeBetweenOrEqual
+
+```go
+func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a
+lower bound, and an upper bound. It ensures that the actual value is between
+both bounds or equal to one of them.
+
+#### func  ShouldBeBlank
+
+```go
+func ShouldBeBlank(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal
+to "".
+
+#### func  ShouldBeChronological
+
+```go
+func ShouldBeChronological(actual interface{}, expected ...interface{}) string
+```
+ShouldBeChronological receives a []time.Time slice and asserts that the are in
+chronological order starting with the first time.Time as the earliest.
+
+#### func  ShouldBeEmpty
+
+```go
+func ShouldBeEmpty(actual interface{}, expected ...interface{}) string
+```
+ShouldBeEmpty receives a single parameter (actual) and determines whether or not
+calling len(actual) would return `0`. It obeys the rules specified by the len
+function for determining length: http://golang.org/pkg/builtin/#len
+
+#### func  ShouldBeFalse
+
+```go
+func ShouldBeFalse(actual interface{}, expected ...interface{}) string
+```
+ShouldBeFalse receives a single parameter and ensures that it is false.
+
+#### func  ShouldBeGreaterThan
+
+```go
+func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string
+```
+ShouldBeGreaterThan receives exactly two parameters and ensures that the first
+is greater than the second.
+
+#### func  ShouldBeGreaterThanOrEqualTo
+
+```go
+func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string
+```
+ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that
+the first is greater than or equal to the second.
+
+#### func  ShouldBeIn
+
+```go
+func ShouldBeIn(actual interface{}, expected ...interface{}) string
+```
+ShouldBeIn receives at least 2 parameters. The first is a proposed member of the
+collection that is passed in either as the second parameter, or of the
+collection that is comprised of all the remaining parameters. This assertion
+ensures that the proposed member is in the collection (using ShouldEqual).
+
+#### func  ShouldBeLessThan
+
+```go
+func ShouldBeLessThan(actual interface{}, expected ...interface{}) string
+```
+ShouldBeLessThan receives exactly two parameters and ensures that the first is
+less than the second.
+
+#### func  ShouldBeLessThanOrEqualTo
+
+```go
+func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string
+```
+ShouldBeLessThan receives exactly two parameters and ensures that the first is
+less than or equal to the second.
+
+#### func  ShouldBeNil
+
+```go
+func ShouldBeNil(actual interface{}, expected ...interface{}) string
+```
+ShouldBeNil receives a single parameter and ensures that it is nil.
+
+#### func  ShouldBeTrue
+
+```go
+func ShouldBeTrue(actual interface{}, expected ...interface{}) string
+```
+ShouldBeTrue receives a single parameter and ensures that it is true.
+
+#### func  ShouldBeZeroValue
+
+```go
+func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string
+```
+ShouldBeZeroValue receives a single parameter and ensures that it is the Go
+equivalent of the default value, or "zero" value.
+
+#### func  ShouldContain
+
+```go
+func ShouldContain(actual interface{}, expected ...interface{}) string
+```
+ShouldContain receives exactly two parameters. The first is a slice and the
+second is a proposed member. Membership is determined using ShouldEqual.
+
+#### func  ShouldContainKey
+
+```go
+func ShouldContainKey(actual interface{}, expected ...interface{}) string
+```
+ShouldContainKey receives exactly two parameters. The first is a map and the
+second is a proposed key. Keys are compared with a simple '=='.
+
+#### func  ShouldContainSubstring
+
+```go
+func ShouldContainSubstring(actual interface{}, expected ...interface{}) string
+```
+ShouldContainSubstring receives exactly 2 string parameters and ensures that the
+first contains the second as a substring.
+
+#### func  ShouldEndWith
+
+```go
+func ShouldEndWith(actual interface{}, expected ...interface{}) string
+```
+ShouldEndWith receives exactly 2 string parameters and ensures that the first
+ends with the second.
+
+#### func  ShouldEqual
+
+```go
+func ShouldEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldEqual receives exactly two parameters and does an equality check.
+
+#### func  ShouldEqualTrimSpace
+
+```go
+func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string
+```
+ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the
+first is equal to the second after removing all leading and trailing whitespace
+using strings.TrimSpace(first).
+
+#### func  ShouldEqualWithout
+
+```go
+func ShouldEqualWithout(actual interface{}, expected ...interface{}) string
+```
+ShouldEqualWithout receives exactly 3 string parameters and ensures that the
+first is equal to the second after removing all instances of the third from the
+first using strings.Replace(first, third, "", -1).
+
+#### func  ShouldHappenAfter
+
+```go
+func ShouldHappenAfter(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the
+first happens after the second.
+
+#### func  ShouldHappenBefore
+
+```go
+func ShouldHappenBefore(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the
+first happens before the second.
+
+#### func  ShouldHappenBetween
+
+```go
+func ShouldHappenBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the
+first happens between (not on) the second and third.
+
+#### func  ShouldHappenOnOrAfter
+
+```go
+func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that
+the first happens on or after the second.
+
+#### func  ShouldHappenOnOrBefore
+
+```go
+func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that
+the first happens on or before the second.
+
+#### func  ShouldHappenOnOrBetween
+
+```go
+func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that
+the first happens between or on the second and third.
+
+#### func  ShouldHappenWithin
+
+```go
+func ShouldHappenWithin(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
+arguments) and asserts that the first time.Time happens within or on the
+duration specified relative to the other time.Time.
+
+#### func  ShouldHaveLength
+
+```go
+func ShouldHaveLength(actual interface{}, expected ...interface{}) string
+```
+ShouldHaveLength receives a collection and a positive integer and asserts that
+the length of the collection is equal to the integer provided.
+
+#### func  ShouldHaveSameTypeAs
+
+```go
+func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string
+```
+ShouldHaveSameTypeAs receives exactly two parameters and compares their
+underlying types for equality.
+
+#### func  ShouldImplement
+
+```go
+func ShouldImplement(actual interface{}, expectedList ...interface{}) string
+```
+ShouldImplement receives exactly two parameters and ensures that the first
+implements the interface type of the second.
+
+#### func  ShouldNotAlmostEqual
+
+```go
+func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual
+
+#### func  ShouldNotBeBetween
+
+```go
+func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBetween receives exactly three parameters: an actual value, a lower
+bound, and an upper bound. It ensures that the actual value is NOT between both
+bounds.
+
+#### func  ShouldNotBeBetweenOrEqual
+
+```go
+func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a
+lower bound, and an upper bound. It ensures that the actual value is nopt
+between the bounds nor equal to either of them.
+
+#### func  ShouldNotBeBlank
+
+```go
+func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is
+equal to "".
+
+#### func  ShouldNotBeEmpty
+
+```go
+func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeEmpty receives a single parameter (actual) and determines whether or
+not calling len(actual) would return a value greater than zero. It obeys the
+rules specified by the `len` function for determining length:
+http://golang.org/pkg/builtin/#len
+
+#### func  ShouldNotBeIn
+
+```go
+func ShouldNotBeIn(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of
+the collection that is passed in either as the second parameter, or of the
+collection that is comprised of all the remaining parameters. This assertion
+ensures that the proposed member is NOT in the collection (using ShouldEqual).
+
+#### func  ShouldNotBeNil
+
+```go
+func ShouldNotBeNil(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeNil receives a single parameter and ensures that it is not nil.
+
+#### func  ShouldNotContain
+
+```go
+func ShouldNotContain(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContain receives exactly two parameters. The first is a slice and the
+second is a proposed member. Membership is determinied using ShouldEqual.
+
+#### func  ShouldNotContainKey
+
+```go
+func ShouldNotContainKey(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContainKey receives exactly two parameters. The first is a map and the
+second is a proposed absent key. Keys are compared with a simple '=='.
+
+#### func  ShouldNotContainSubstring
+
+```go
+func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContainSubstring receives exactly 2 string parameters and ensures that
+the first does NOT contain the second as a substring.
+
+#### func  ShouldNotEndWith
+
+```go
+func ShouldNotEndWith(actual interface{}, expected ...interface{}) string
+```
+ShouldEndWith receives exactly 2 string parameters and ensures that the first
+does not end with the second.
+
+#### func  ShouldNotEqual
+
+```go
+func ShouldNotEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotEqual receives exactly two parameters and does an inequality check.
+
+#### func  ShouldNotHappenOnOrBetween
+
+```go
+func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts
+that the first does NOT happen between or on the second or third.
+
+#### func  ShouldNotHappenWithin
+
+```go
+func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
+arguments) and asserts that the first time.Time does NOT happen within or on the
+duration specified relative to the other time.Time.
+
+#### func  ShouldNotHaveSameTypeAs
+
+```go
+func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHaveSameTypeAs receives exactly two parameters and compares their
+underlying types for inequality.
+
+#### func  ShouldNotImplement
+
+```go
+func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string
+```
+ShouldNotImplement receives exactly two parameters and ensures that the first
+does NOT implement the interface type of the second.
+
+#### func  ShouldNotPanic
+
+```go
+func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldNotPanic receives a void, niladic function and expects to execute the
+function without any panic.
+
+#### func  ShouldNotPanicWith
+
+```go
+func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldNotPanicWith receives a void, niladic function and expects to recover a
+panic whose content differs from the second argument.
+
+#### func  ShouldNotPointTo
+
+```go
+func ShouldNotPointTo(actual interface{}, expected ...interface{}) string
+```
+ShouldNotPointTo receives exactly two parameters and checks to see that they
+point to different addresess.
+
+#### func  ShouldNotResemble
+
+```go
+func ShouldNotResemble(actual interface{}, expected ...interface{}) string
+```
+ShouldNotResemble receives exactly two parameters and does an inverse deep equal
+check (see reflect.DeepEqual)
+
+#### func  ShouldNotStartWith
+
+```go
+func ShouldNotStartWith(actual interface{}, expected ...interface{}) string
+```
+ShouldNotStartWith receives exactly 2 string parameters and ensures that the
+first does not start with the second.
+
+#### func  ShouldPanic
+
+```go
+func ShouldPanic(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldPanic receives a void, niladic function and expects to recover a panic.
+
+#### func  ShouldPanicWith
+
+```go
+func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldPanicWith receives a void, niladic function and expects to recover a panic
+with the second argument as the content.
+
+#### func  ShouldPointTo
+
+```go
+func ShouldPointTo(actual interface{}, expected ...interface{}) string
+```
+ShouldPointTo receives exactly two parameters and checks to see that they point
+to the same address.
+
+#### func  ShouldResemble
+
+```go
+func ShouldResemble(actual interface{}, expected ...interface{}) string
+```
+ShouldResemble receives exactly two parameters and does a deep equal check (see
+reflect.DeepEqual)
+
+#### func  ShouldStartWith
+
+```go
+func ShouldStartWith(actual interface{}, expected ...interface{}) string
+```
+ShouldStartWith receives exactly 2 string parameters and ensures that the first
+starts with the second.
+
+#### func  So
+
+```go
+func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string)
+```
+So is a convenience function (as opposed to an inconvenience function?) for
+running assertions on arbitrary arguments in any context, be it for testing or
+even application logging. It allows you to perform assertion-like behavior (and
+get nicely formatted messages detailing discrepancies) but without the program
+blowing up or panicking. All that is required is to import this package and call
+`So` with one of the assertions exported by this package as the second
+parameter. The first return parameter is a boolean indicating if the assertion
+was true. The second return parameter is the well-formatted message showing why
+an assertion was incorrect, or blank if the assertion was correct.
+
+Example:
+
+    if ok, message := So(x, ShouldBeGreaterThan, y); !ok {
+         log.Println(message)
+    }
+
+#### type Assertion
+
+```go
+type Assertion struct {
+}
+```
+
+
+#### func  New
+
+```go
+func New(t testingT) *Assertion
+```
+New swallows the *testing.T struct and prints failed assertions using t.Error.
+Example: assertions.New(t).So(1, should.Equal, 1)
+
+#### func (*Assertion) Failed
+
+```go
+func (this *Assertion) Failed() bool
+```
+Failed reports whether any calls to So (on this Assertion instance) have failed.
+
+#### func (*Assertion) So
+
+```go
+func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool
+```
+So calls the standalone So function and additionally, calls t.Error in failure
+scenarios.
+
+#### type Serializer
+
+```go
+type Serializer interface {
+	// contains filtered or unexported methods
+}
+```
diff --git a/vendor/src/github.com/smartystreets/assertions/assertions.goconvey b/vendor/src/github.com/smartystreets/assertions/assertions.goconvey
new file mode 100644
index 00000000000..e76cf275d47
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/assertions.goconvey
@@ -0,0 +1,3 @@
+#ignore
+-timeout=1s
+-coverpkg=github.com/smartystreets/assertions,github.com/smartystreets/assertions/internal/oglematchers
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/collections.go b/vendor/src/github.com/smartystreets/assertions/collections.go
index 240aac4a5bf..de0f4426c3e 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/collections.go
+++ b/vendor/src/github.com/smartystreets/assertions/collections.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/jacobsa/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglematchers"
 )
 
 // ShouldContain receives exactly two parameters. The first is a slice and the
@@ -42,6 +42,61 @@ func ShouldNotContain(actual interface{}, expected ...interface{}) string {
 	return fmt.Sprintf(shouldNotHaveContained, typeName, expected[0])
 }
 
+// ShouldContainKey receives exactly two parameters. The first is a map and the
+// second is a proposed key. Keys are compared with a simple '=='.
+func ShouldContainKey(actual interface{}, expected ...interface{}) string {
+	if fail := need(1, expected); fail != success {
+		return fail
+	}
+
+	keys, isMap := mapKeys(actual)
+	if !isMap {
+		return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
+	}
+
+	if !keyFound(keys, expected[0]) {
+		return fmt.Sprintf(shouldHaveContainedKey, reflect.TypeOf(actual), expected)
+	}
+
+	return ""
+}
+
+// ShouldNotContainKey receives exactly two parameters. The first is a map and the
+// second is a proposed absent key. Keys are compared with a simple '=='.
+func ShouldNotContainKey(actual interface{}, expected ...interface{}) string {
+	if fail := need(1, expected); fail != success {
+		return fail
+	}
+
+	keys, isMap := mapKeys(actual)
+	if !isMap {
+		return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
+	}
+
+	if keyFound(keys, expected[0]) {
+		return fmt.Sprintf(shouldNotHaveContainedKey, reflect.TypeOf(actual), expected)
+	}
+
+	return ""
+}
+
+func mapKeys(m interface{}) ([]reflect.Value, bool) {
+	value := reflect.ValueOf(m)
+	if value.Kind() != reflect.Map {
+		return nil, false
+	}
+	return value.MapKeys(), true
+}
+func keyFound(keys []reflect.Value, expectedKey interface{}) bool {
+	found := false
+	for _, key := range keys {
+		if key.Interface() == expectedKey {
+			found = true
+		}
+	}
+	return found
+}
+
 // ShouldBeIn receives at least 2 parameters. The first is a proposed member of the collection
 // that is passed in either as the second parameter, or of the collection that is comprised
 // of all the remaining parameters. This assertion ensures that the proposed member is in
@@ -138,3 +193,58 @@ func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string {
 	}
 	return fmt.Sprintf(shouldNotHaveBeenEmpty, actual)
 }
+
+// ShouldHaveLength receives 2 parameters. The first is a collection to check
+// the length of, the second being the expected length. It obeys the rules
+// specified by the len function for determining length:
+// http://golang.org/pkg/builtin/#len
+func ShouldHaveLength(actual interface{}, expected ...interface{}) string {
+	if fail := need(1, expected); fail != success {
+		return fail
+	}
+
+	var expectedLen int64
+	lenValue := reflect.ValueOf(expected[0])
+	switch lenValue.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		expectedLen = lenValue.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		expectedLen = int64(lenValue.Uint())
+	default:
+		return fmt.Sprintf(shouldHaveBeenAValidInteger, reflect.TypeOf(expected[0]))
+	}
+
+	if expectedLen < 0 {
+		return fmt.Sprintf(shouldHaveBeenAValidLength, expected[0])
+	}
+
+	value := reflect.ValueOf(actual)
+	switch value.Kind() {
+	case reflect.Slice:
+		if int64(value.Len()) == expectedLen {
+			return success
+		}
+	case reflect.Chan:
+		if int64(value.Len()) == expectedLen {
+			return success
+		}
+	case reflect.Map:
+		if int64(value.Len()) == expectedLen {
+			return success
+		}
+	case reflect.String:
+		if int64(value.Len()) == expectedLen {
+			return success
+		}
+	case reflect.Ptr:
+		elem := value.Elem()
+		kind := elem.Kind()
+		if (kind == reflect.Slice || kind == reflect.Array) && int64(elem.Len()) == expectedLen {
+			return success
+		}
+	default:
+		return fmt.Sprintf(shouldHaveBeenAValidCollection, reflect.TypeOf(actual))
+	}
+
+	return fmt.Sprintf(shouldHaveHadLength, actual, expectedLen)
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/collections_test.go b/vendor/src/github.com/smartystreets/assertions/collections_test.go
index 25612bd7670..9433ef24bdc 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/collections_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/collections_test.go
@@ -6,6 +6,28 @@ import (
 	"time"
 )
 
+func TestShouldContainKey(t *testing.T) {
+	fail(t, so(map[int]int{}, ShouldContainKey), "This assertion requires exactly 1 comparison values (you provided 0).")
+	fail(t, so(map[int]int{}, ShouldContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
+
+	fail(t, so(Thing1{}, ShouldContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!")
+	fail(t, so(nil, ShouldContainKey, 1), "You must provide a valid map type (was <nil>)!")
+	fail(t, so(map[int]int{1: 41}, ShouldContainKey, 2), "Expected the map[int]int to contain the key: [2] (but it didn't)!")
+
+	pass(t, so(map[int]int{1: 41}, ShouldContainKey, 1))
+	pass(t, so(map[int]int{1: 41, 2: 42, 3: 43}, ShouldContainKey, 2))
+}
+
+func TestShouldNotContainKey(t *testing.T) {
+	fail(t, so(map[int]int{}, ShouldNotContainKey), "This assertion requires exactly 1 comparison values (you provided 0).")
+	fail(t, so(map[int]int{}, ShouldNotContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
+
+	fail(t, so(Thing1{}, ShouldNotContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!")
+	fail(t, so(nil, ShouldNotContainKey, 1), "You must provide a valid map type (was <nil>)!")
+	fail(t, so(map[int]int{1: 41}, ShouldNotContainKey, 1), "Expected the map[int]int NOT to contain the key: [1] (but it did)!")
+	pass(t, so(map[int]int{1: 41}, ShouldNotContainKey, 2))
+}
+
 func TestShouldContain(t *testing.T) {
 	fail(t, so([]int{}, ShouldContain), "This assertion requires exactly 1 comparison values (you provided 0).")
 	fail(t, so([]int{}, ShouldContain, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
@@ -32,25 +54,25 @@ func TestShouldNotContain(t *testing.T) {
 }
 
 func TestShouldBeIn(t *testing.T) {
-	fail(t, so(4, ShouldBeIn), shouldHaveProvidedCollectionMembers)
+	fail(t, so(4, ShouldBeIn), needNonEmptyCollection)
 
 	container := []int{1, 2, 3, 4}
 	pass(t, so(4, ShouldBeIn, container))
 	pass(t, so(4, ShouldBeIn, 1, 2, 3, 4))
 
-	fail(t, so(4, ShouldBeIn, 1, 2, 3), "Expected '4' to be in the container ([]interface {}, but it wasn't)!")
-	fail(t, so(4, ShouldBeIn, []int{1, 2, 3}), "Expected '4' to be in the container ([]int, but it wasn't)!")
+	fail(t, so(4, ShouldBeIn, 1, 2, 3), "Expected '4' to be in the container ([]interface {}), but it wasn't!")
+	fail(t, so(4, ShouldBeIn, []int{1, 2, 3}), "Expected '4' to be in the container ([]int), but it wasn't!")
 }
 
 func TestShouldNotBeIn(t *testing.T) {
-	fail(t, so(4, ShouldNotBeIn), shouldHaveProvidedCollectionMembers)
+	fail(t, so(4, ShouldNotBeIn), needNonEmptyCollection)
 
 	container := []int{1, 2, 3, 4}
 	pass(t, so(42, ShouldNotBeIn, container))
 	pass(t, so(42, ShouldNotBeIn, 1, 2, 3, 4))
 
-	fail(t, so(2, ShouldNotBeIn, 1, 2, 3), "Expected '2' NOT to be in the container ([]interface {}, but it was)!")
-	fail(t, so(2, ShouldNotBeIn, []int{1, 2, 3}), "Expected '2' NOT to be in the container ([]int, but it was)!")
+	fail(t, so(2, ShouldNotBeIn, 1, 2, 3), "Expected '2' NOT to be in the container ([]interface {}), but it was!")
+	fail(t, so(2, ShouldNotBeIn, []int{1, 2, 3}), "Expected '2' NOT to be in the container ([]int), but it was!")
 }
 
 func TestShouldBeEmpty(t *testing.T) {
@@ -101,3 +123,35 @@ func TestShouldNotBeEmpty(t *testing.T) {
 	time.Sleep(time.Millisecond)
 	pass(t, so(c, ShouldNotBeEmpty))
 }
+
+func TestShouldHaveLength(t *testing.T) {
+	fail(t, so(1, ShouldHaveLength, 2), "You must provide a valid container (was int)!")
+	fail(t, so(nil, ShouldHaveLength, 1), "You must provide a valid container (was <nil>)!")
+	fail(t, so("hi", ShouldHaveLength, float64(1.0)), "You must provide a valid integer (was float64)!")
+	fail(t, so([]string{}, ShouldHaveLength), "This assertion requires exactly 1 comparison values (you provided 0).")
+	fail(t, so([]string{}, ShouldHaveLength, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).")
+	fail(t, so([]string{}, ShouldHaveLength, -10), "You must provide a valid positive integer (was -10)!")
+
+	fail(t, so([]int{}, ShouldHaveLength, 1), "Expected [] to have length equal to '1', but it wasn't!")             // empty slice
+	fail(t, so([]interface{}{}, ShouldHaveLength, 1), "Expected [] to have length equal to '1', but it wasn't!")     // empty slice
+	fail(t, so(map[string]int{}, ShouldHaveLength, 1), "Expected map[] to have length equal to '1', but it wasn't!") // empty map
+	fail(t, so("", ShouldHaveLength, 1), "Expected  to have length equal to '1', but it wasn't!")                    // empty string
+	fail(t, so(&[]int{}, ShouldHaveLength, 1), "Expected &[] to have length equal to '1', but it wasn't!")           // pointer to empty slice
+	fail(t, so(&[0]int{}, ShouldHaveLength, 1), "Expected &[] to have length equal to '1', but it wasn't!")          // pointer to empty array
+	c := make(chan int, 0)                                                                                           // non-empty channel
+	fail(t, so(c, ShouldHaveLength, 1), fmt.Sprintf("Expected %+v to have length equal to '1', but it wasn't!", c))
+	c = make(chan int) // empty channel
+	fail(t, so(c, ShouldHaveLength, 1), fmt.Sprintf("Expected %+v to have length equal to '1', but it wasn't!", c))
+
+	pass(t, so([]int{1}, ShouldHaveLength, 1))                // non-empty slice
+	pass(t, so([]interface{}{1}, ShouldHaveLength, 1))        // non-empty slice
+	pass(t, so(map[string]int{"hi": 0}, ShouldHaveLength, 1)) // non-empty map
+	pass(t, so("hi", ShouldHaveLength, 2))                    // non-empty string
+	pass(t, so(&[]int{1}, ShouldHaveLength, 1))               // pointer to non-empty slice
+	pass(t, so(&[1]int{1}, ShouldHaveLength, 1))              // pointer to non-empty array
+	c = make(chan int, 1)
+	go func() { c <- 1 }()
+	time.Sleep(time.Millisecond)
+	pass(t, so(c, ShouldHaveLength, 1))
+
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/doc.go b/vendor/src/github.com/smartystreets/assertions/doc.go
new file mode 100644
index 00000000000..d3d116c418d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/doc.go
@@ -0,0 +1,99 @@
+// Package assertions contains the implementations for all assertions which
+// are referenced in goconvey's `convey` package
+// (github.com/smartystreets/goconvey/convey) for use with the So(...) method.
+// They can also be used in traditional Go test functions and even in
+// applicaitons.
+package assertions
+
+import (
+	"fmt"
+	"runtime"
+)
+
+// By default we use a no-op serializer. The actual Serializer provides a JSON
+// representation of failure results on selected assertions so the goconvey
+// web UI can display a convenient diff.
+var serializer Serializer = new(noopSerializer)
+
+// GoConveyMode provides control over JSON serialization of failures. When
+// using the assertions in this package from the convey package JSON results
+// are very helpful and can be rendered in a DIFF view. In that case, this function
+// will be called with a true value to enable the JSON serialization. By default,
+// the assertions in this package will not serializer a JSON result, making
+// standalone ussage more convenient.
+func GoConveyMode(yes bool) {
+	if yes {
+		serializer = newSerializer()
+	} else {
+		serializer = new(noopSerializer)
+	}
+}
+
+type testingT interface {
+	Error(args ...interface{})
+}
+
+type Assertion struct {
+	t      testingT
+	failed bool
+}
+
+// New swallows the *testing.T struct and prints failed assertions using t.Error.
+// Example: assertions.New(t).So(1, should.Equal, 1)
+func New(t testingT) *Assertion {
+	return &Assertion{t: t}
+}
+
+// Failed reports whether any calls to So (on this Assertion instance) have failed.
+func (this *Assertion) Failed() bool {
+	return this.failed
+}
+
+// So calls the standalone So function and additionally, calls t.Error in failure scenarios.
+func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool {
+	ok, result := So(actual, assert, expected...)
+	if !ok {
+		this.failed = true
+		_, file, line, _ := runtime.Caller(1)
+		this.t.Error(fmt.Sprintf("\n%s:%d\n%s", file, line, result))
+	}
+	return ok
+}
+
+// So is a convenience function (as opposed to an inconvenience function?)
+// for running assertions on arbitrary arguments in any context, be it for testing or even
+// application logging. It allows you to perform assertion-like behavior (and get nicely
+// formatted messages detailing discrepancies) but without the program blowing up or panicking.
+// All that is required is to import this package and call `So` with one of the assertions
+// exported by this package as the second parameter.
+// The first return parameter is a boolean indicating if the assertion was true. The second
+// return parameter is the well-formatted message showing why an assertion was incorrect, or
+// blank if the assertion was correct.
+//
+// Example:
+//
+//   if ok, message := So(x, ShouldBeGreaterThan, y); !ok {
+//        log.Println(message)
+//   }
+//
+func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string) {
+	if result := so(actual, assert, expected...); len(result) == 0 {
+		return true, result
+	} else {
+		return false, result
+	}
+}
+
+// so is like So, except that it only returns the string message, which is blank if the
+// assertion passed. Used to facilitate testing.
+func so(actual interface{}, assert func(interface{}, ...interface{}) string, expected ...interface{}) string {
+	return assert(actual, expected...)
+}
+
+// assertion is an alias for a function with a signature that the So()
+// function can handle. Any future or custom assertions should conform to this
+// method signature. The return value should be an empty string if the assertion
+// passes and a well-formed failure message if not.
+type assertion func(actual interface{}, expected ...interface{}) string
+
+////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/src/github.com/smartystreets/assertions/doc_test.go b/vendor/src/github.com/smartystreets/assertions/doc_test.go
new file mode 100644
index 00000000000..041faaffcb2
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/doc_test.go
@@ -0,0 +1,57 @@
+package assertions
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+)
+
+func TestPassingAssertion(t *testing.T) {
+	fake := &FakeT{buffer: new(bytes.Buffer)}
+	assertion := New(fake)
+	passed := assertion.So(1, ShouldEqual, 1)
+
+	if !passed {
+		t.Error("Assertion failed when it should have passed.")
+	}
+	if fake.buffer.Len() > 0 {
+		t.Error("Unexpected error message was printed.")
+	}
+}
+
+func TestFailingAssertion(t *testing.T) {
+	fake := &FakeT{buffer: new(bytes.Buffer)}
+	assertion := New(fake)
+	passed := assertion.So(1, ShouldEqual, 2)
+
+	if passed {
+		t.Error("Assertion passed when it should have failed.")
+	}
+	if fake.buffer.Len() == 0 {
+		t.Error("Expected error message not printed.")
+	}
+}
+
+func TestFailingGroupsOfAssertions(t *testing.T) {
+	fake := &FakeT{buffer: new(bytes.Buffer)}
+	assertion1 := New(fake)
+	assertion2 := New(fake)
+
+	assertion1.So(1, ShouldEqual, 2) // fail
+	assertion2.So(1, ShouldEqual, 1) // pass
+
+	if !assertion1.Failed() {
+		t.Error("Expected the first assertion to have been marked as failed.")
+	}
+	if assertion2.Failed() {
+		t.Error("Expected the second assertion to NOT have been marked as failed.")
+	}
+}
+
+type FakeT struct {
+	buffer *bytes.Buffer
+}
+
+func (this *FakeT) Error(args ...interface{}) {
+	fmt.Fprint(this.buffer, args...)
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/equality.go b/vendor/src/github.com/smartystreets/assertions/equality.go
index da893f82f97..95cd3473a1c 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/equality.go
+++ b/vendor/src/github.com/smartystreets/assertions/equality.go
@@ -7,7 +7,7 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/jacobsa/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglematchers"
 )
 
 // default acceptable delta for ShouldAlmostEqual
@@ -29,7 +29,14 @@ func shouldEqual(actual, expected interface{}) (message string) {
 	}()
 
 	if matchError := oglematchers.Equals(expected).Matches(actual); matchError != nil {
-		message = serializer.serialize(expected, actual, fmt.Sprintf(shouldHaveBeenEqual, expected, actual))
+		expectedSyntax := fmt.Sprintf("%v", expected)
+		actualSyntax := fmt.Sprintf("%v", actual)
+		if expectedSyntax == actualSyntax && reflect.TypeOf(expected) != reflect.TypeOf(actual) {
+			message = fmt.Sprintf(shouldHaveBeenEqualTypeMismatch, expected, expected, actual, actual)
+		} else {
+			message = fmt.Sprintf(shouldHaveBeenEqual, expected, actual)
+		}
+		message = serializer.serialize(expected, actual, message)
 		return
 	}
 
@@ -142,7 +149,15 @@ func ShouldResemble(actual interface{}, expected ...interface{}) string {
 	}
 
 	if matchError := oglematchers.DeepEquals(expected[0]).Matches(actual); matchError != nil {
-		return serializer.serialize(expected[0], actual, fmt.Sprintf(shouldHaveResembled, expected[0], actual))
+		expectedSyntax := fmt.Sprintf("%#v", expected[0])
+		actualSyntax := fmt.Sprintf("%#v", actual)
+		var message string
+		if expectedSyntax == actualSyntax {
+			message = fmt.Sprintf(shouldHaveResembledTypeMismatch, expected[0], expected[0], actual, actual)
+		} else {
+			message = fmt.Sprintf(shouldHaveResembled, expected[0], actual)
+		}
+		return serializer.serializeDetailed(expected[0], actual, message)
 	}
 
 	return success
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/equality_test.go b/vendor/src/github.com/smartystreets/assertions/equality_test.go
index a9acd711493..dde0c54940b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/equality_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/equality_test.go
@@ -15,6 +15,7 @@ func TestShouldEqual(t *testing.T) {
 
 	pass(t, so(1, ShouldEqual, 1))
 	fail(t, so(1, ShouldEqual, 2), "2|1|Expected: '2' Actual: '1' (Should be equal)")
+	fail(t, so(1, ShouldEqual, "1"), "1|1|Expected: '1' (string) Actual: '1' (int) (Should be equal, type mismatch)")
 
 	pass(t, so(true, ShouldEqual, true))
 	fail(t, so(true, ShouldEqual, false), "false|true|Expected: 'false' Actual: 'true' (Should be equal)")
@@ -37,6 +38,7 @@ func TestShouldNotEqual(t *testing.T) {
 	fail(t, so(1, ShouldNotEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
 
 	pass(t, so(1, ShouldNotEqual, 2))
+	pass(t, so(1, ShouldNotEqual, "1"))
 	fail(t, so(1, ShouldNotEqual, 1), "Expected '1' to NOT equal '1' (but it did)!")
 
 	pass(t, so(true, ShouldNotEqual, false))
@@ -103,7 +105,24 @@ func TestShouldResemble(t *testing.T) {
 	fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")
 
 	pass(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}))
-	fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"bye"}), "{bye}|{hi}|Expected: '{a:bye}' Actual: '{a:hi}' (Should resemble)!")
+	fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"bye"}), "{bye}|{hi}|Expected: 'assertions.Thing1{a:\"bye\"}' Actual: 'assertions.Thing1{a:\"hi\"}' (Should resemble)!")
+
+	var (
+		a []int
+		b []int = []int{}
+	)
+
+	fail(t, so(a, ShouldResemble, b), "[]|[]|Expected: '[]int{}' Actual: '[]int(nil)' (Should resemble)!")
+	fail(t, so(2, ShouldResemble, 1), "1|2|Expected: '1' Actual: '2' (Should resemble)!")
+
+	fail(t, so(StringStringMapAlias{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}),
+		"map[hi:bye]|map[hi:bye]|Expected: 'map[string]string{\"hi\":\"bye\"}' Actual: 'assertions.StringStringMapAlias{\"hi\":\"bye\"}' (Should resemble)!")
+	fail(t, so(StringSliceAlias{"hi", "bye"}, ShouldResemble, []string{"hi", "bye"}),
+		"[hi bye]|[hi bye]|Expected: '[]string{\"hi\", \"bye\"}' Actual: 'assertions.StringSliceAlias{\"hi\", \"bye\"}' (Should resemble)!")
+
+	// some types come out looking the same when represented with "%#v" so we show type mismatch info:
+	fail(t, so(StringAlias("hi"), ShouldResemble, "hi"), "hi|hi|Expected: '\"hi\"' (string) Actual: '\"hi\"' (assertions.StringAlias) (Should resemble, type mismatch)")
+	fail(t, so(IntAlias(42), ShouldResemble, 42), "42|42|Expected: '42' (int) Actual: '42' (assertions.IntAlias) (Should resemble, type mismatch)")
 }
 
 func TestShouldNotResemble(t *testing.T) {
@@ -111,7 +130,13 @@ func TestShouldNotResemble(t *testing.T) {
 	fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")
 
 	pass(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"bye"}))
-	fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}), "Expected '{a:hi}' to NOT resemble '{a:hi}' (but it did)!")
+	fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}),
+		"Expected 'assertions.Thing1{a:\"hi\"}' to NOT resemble 'assertions.Thing1{a:\"hi\"}' (but it did)!")
+
+	pass(t, so(map[string]string{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}))
+	pass(t, so(IntAlias(42), ShouldNotResemble, 42))
+
+	pass(t, so(StringSliceAlias{"hi", "bye"}, ShouldNotResemble, []string{"hi", "bye"}))
 }
 
 func TestShouldPointTo(t *testing.T) {
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/filter.go b/vendor/src/github.com/smartystreets/assertions/filter.go
index 872e58c5407..ee368a97ed7 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/filter.go
+++ b/vendor/src/github.com/smartystreets/assertions/filter.go
@@ -3,8 +3,9 @@ package assertions
 import "fmt"
 
 const (
-	success         = ""
-	needExactValues = "This assertion requires exactly %d comparison values (you provided %d)."
+	success                = ""
+	needExactValues        = "This assertion requires exactly %d comparison values (you provided %d)."
+	needNonEmptyCollection = "This assertion requires at least 1 comparison value (you provided 0)."
 )
 
 func need(needed int, expected []interface{}) string {
@@ -16,7 +17,7 @@ func need(needed int, expected []interface{}) string {
 
 func atLeast(minimum int, expected []interface{}) string {
 	if len(expected) < 1 {
-		return shouldHaveProvidedCollectionMembers
+		return needNonEmptyCollection
 	}
 	return success
 }
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/Makefile b/vendor/src/github.com/smartystreets/assertions/internal/Makefile
new file mode 100644
index 00000000000..714768027ba
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/Makefile
@@ -0,0 +1,21 @@
+# This Makefile pulls the latest oglematchers (with dependencies),
+# rewrites the imports to match this location,
+# and ensures that all the tests pass.
+
+go: clean clone rewrite test
+
+clean:
+	rm -rf ogle*
+	rm -rf reqtrace
+
+clone:
+	git clone https://github.com/jacobsa/ogletest.git && rm -rf ogletest/.git
+	git clone https://github.com/jacobsa/oglemock.git && rm -rf oglemock/.git
+	git clone https://github.com/jacobsa/oglematchers.git && rm -rf oglematchers/.git
+	git clone https://github.com/jacobsa/reqtrace.git && rm -rf reqtrace/.git
+
+rewrite:
+	grep -rl --exclude Makefile 'github.com/jacobsa' . | xargs sed -i '' 's#github.com/jacobsa#github.com/smartystreets/assertions/internal#g'
+
+test:
+	go test github.com/smartystreets/assertions/...
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.gitignore b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.gitignore
new file mode 100644
index 00000000000..dd8fc7468f4
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.gitignore
@@ -0,0 +1,5 @@
+*.6
+6.out
+_obj/
+_test/
+_testmain.go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.travis.yml b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.travis.yml
new file mode 100644
index 00000000000..b97211926e8
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.travis.yml
@@ -0,0 +1,4 @@
+# Cf. http://docs.travis-ci.com/user/getting-started/
+# Cf. http://docs.travis-ci.com/user/languages/go/
+
+language: go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/LICENSE b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/README.md b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/README.md
new file mode 100644
index 00000000000..215a2bb7a8b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/README.md
@@ -0,0 +1,58 @@
+[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers)
+
+`oglematchers` is a package for the Go programming language containing a set of
+matchers, useful in a testing or mocking framework, inspired by and mostly
+compatible with [Google Test][googletest] for C++ and
+[Google JS Test][google-js-test]. The package is used by the
+[ogletest][ogletest] testing framework and [oglemock][oglemock] mocking
+framework, which may be more directly useful to you, but can be generically used
+elsewhere as well.
+
+A "matcher" is simply an object with a `Matches` method defining a set of golang
+values matched by the matcher, and a `Description` method describing that set.
+For example, here are some matchers:
+
+```go
+// Numbers
+Equals(17.13)
+LessThan(19)
+
+// Strings
+Equals("taco")
+HasSubstr("burrito")
+MatchesRegex("t.*o")
+
+// Combining matchers
+AnyOf(LessThan(17), GreaterThan(19))
+```
+
+There are lots more; see [here][reference] for a reference. You can also add
+your own simply by implementing the `oglematchers.Matcher` interface.
+
+
+Installation
+------------
+
+First, make sure you have installed Go 1.0.2 or newer. See
+[here][golang-install] for instructions.
+
+Use the following command to install `oglematchers` and keep it up to date:
+
+    go get -u github.com/smartystreets/assertions/internal/oglematchers
+
+
+Documentation
+-------------
+
+See [here][reference] for documentation. Alternatively, you can install the
+package and then use `godoc`:
+
+    godoc github.com/smartystreets/assertions/internal/oglematchers
+
+
+[reference]: http://godoc.org/github.com/smartystreets/assertions/internal/oglematchers
+[golang-install]: http://golang.org/doc/install.html
+[googletest]: http://code.google.com/p/googletest/
+[google-js-test]: http://code.google.com/p/google-js-test/
+[ogletest]: http://github.com/smartystreets/assertions/internal/ogletest
+[oglemock]: http://github.com/smartystreets/assertions/internal/oglemock
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of.go
new file mode 100644
index 00000000000..d93a9740443
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of.go
@@ -0,0 +1,70 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"strings"
+)
+
+// AllOf accepts a set of matchers S and returns a matcher that follows the
+// algorithm below when considering a candidate c:
+//
+//  1. Return true if for every Matcher m in S, m matches c.
+//
+//  2. Otherwise, if there is a matcher m in S such that m returns a fatal
+//     error for c, return that matcher's error message.
+//
+//  3. Otherwise, return false with the error from some wrapped matcher.
+//
+// This is akin to a logical AND operation for matchers.
+func AllOf(matchers ...Matcher) Matcher {
+	return &allOfMatcher{matchers}
+}
+
+type allOfMatcher struct {
+	wrappedMatchers []Matcher
+}
+
+func (m *allOfMatcher) Description() string {
+	// Special case: the empty set.
+	if len(m.wrappedMatchers) == 0 {
+		return "is anything"
+	}
+
+	// Join the descriptions for the wrapped matchers.
+	wrappedDescs := make([]string, len(m.wrappedMatchers))
+	for i, wrappedMatcher := range m.wrappedMatchers {
+		wrappedDescs[i] = wrappedMatcher.Description()
+	}
+
+	return strings.Join(wrappedDescs, ", and ")
+}
+
+func (m *allOfMatcher) Matches(c interface{}) (err error) {
+	for _, wrappedMatcher := range m.wrappedMatchers {
+		if wrappedErr := wrappedMatcher.Matches(c); wrappedErr != nil {
+			err = wrappedErr
+
+			// If the error is fatal, return immediately with this error.
+			_, ok := wrappedErr.(*FatalError)
+			if ok {
+				return
+			}
+		}
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go
new file mode 100644
index 00000000000..0f9d198fcbe
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go
@@ -0,0 +1,110 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"errors"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type allOfFakeMatcher struct {
+	desc string
+	err  error
+}
+
+func (m *allOfFakeMatcher) Matches(c interface{}) error {
+	return m.err
+}
+
+func (m *allOfFakeMatcher) Description() string {
+	return m.desc
+}
+
+type AllOfTest struct {
+}
+
+func init() { RegisterTestSuite(&AllOfTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *AllOfTest) DescriptionWithEmptySet() {
+	m := AllOf()
+	ExpectEq("is anything", m.Description())
+}
+
+func (t *AllOfTest) DescriptionWithOneMatcher() {
+	m := AllOf(&allOfFakeMatcher{"taco", errors.New("")})
+	ExpectEq("taco", m.Description())
+}
+
+func (t *AllOfTest) DescriptionWithMultipleMatchers() {
+	m := AllOf(
+		&allOfFakeMatcher{"taco", errors.New("")},
+		&allOfFakeMatcher{"burrito", errors.New("")},
+		&allOfFakeMatcher{"enchilada", errors.New("")})
+
+	ExpectEq("taco, and burrito, and enchilada", m.Description())
+}
+
+func (t *AllOfTest) EmptySet() {
+	m := AllOf()
+	err := m.Matches(17)
+
+	ExpectEq(nil, err)
+}
+
+func (t *AllOfTest) OneMatcherReturnsFatalErrorAndSomeOthersFail() {
+	m := AllOf(
+		&allOfFakeMatcher{"", errors.New("")},
+		&allOfFakeMatcher{"", NewFatalError("taco")},
+		&allOfFakeMatcher{"", errors.New("")},
+		&allOfFakeMatcher{"", nil})
+
+	err := m.Matches(17)
+
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *AllOfTest) OneMatcherReturnsNonFatalAndOthersSayTrue() {
+	m := AllOf(
+		&allOfFakeMatcher{"", nil},
+		&allOfFakeMatcher{"", errors.New("taco")},
+		&allOfFakeMatcher{"", nil})
+
+	err := m.Matches(17)
+
+	ExpectFalse(isFatal(err))
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *AllOfTest) AllMatchersSayTrue() {
+	m := AllOf(
+		&allOfFakeMatcher{"", nil},
+		&allOfFakeMatcher{"", nil},
+		&allOfFakeMatcher{"", nil})
+
+	err := m.Matches(17)
+
+	ExpectEq(nil, err)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any.go
new file mode 100644
index 00000000000..f6991ec1020
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any.go
@@ -0,0 +1,32 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+// Any returns a matcher that matches any value.
+func Any() Matcher {
+	return &anyMatcher{}
+}
+
+type anyMatcher struct {
+}
+
+func (m *anyMatcher) Description() string {
+	return "is anything"
+}
+
+func (m *anyMatcher) Matches(c interface{}) error {
+	return nil
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of.go
new file mode 100644
index 00000000000..2918b51f21a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of.go
@@ -0,0 +1,94 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// AnyOf accepts a set of values S and returns a matcher that follows the
+// algorithm below when considering a candidate c:
+//
+//  1. If there exists a value m in S such that m implements the Matcher
+//     interface and m matches c, return true.
+//
+//  2. Otherwise, if there exists a value v in S such that v does not implement
+//     the Matcher interface and the matcher Equals(v) matches c, return true.
+//
+//  3. Otherwise, if there is a value m in S such that m implements the Matcher
+//     interface and m returns a fatal error for c, return that fatal error.
+//
+//  4. Otherwise, return false.
+//
+// This is akin to a logical OR operation for matchers, with non-matchers x
+// being treated as Equals(x).
+func AnyOf(vals ...interface{}) Matcher {
+	// Get ahold of a type variable for the Matcher interface.
+	var dummy *Matcher
+	matcherType := reflect.TypeOf(dummy).Elem()
+
+	// Create a matcher for each value, or use the value itself if it's already a
+	// matcher.
+	wrapped := make([]Matcher, len(vals))
+	for i, v := range vals {
+		t := reflect.TypeOf(v)
+		if t != nil && t.Implements(matcherType) {
+			wrapped[i] = v.(Matcher)
+		} else {
+			wrapped[i] = Equals(v)
+		}
+	}
+
+	return &anyOfMatcher{wrapped}
+}
+
+type anyOfMatcher struct {
+	wrapped []Matcher
+}
+
+func (m *anyOfMatcher) Description() string {
+	wrappedDescs := make([]string, len(m.wrapped))
+	for i, matcher := range m.wrapped {
+		wrappedDescs[i] = matcher.Description()
+	}
+
+	return fmt.Sprintf("or(%s)", strings.Join(wrappedDescs, ", "))
+}
+
+func (m *anyOfMatcher) Matches(c interface{}) (err error) {
+	err = errors.New("")
+
+	// Try each matcher in turn.
+	for _, matcher := range m.wrapped {
+		wrappedErr := matcher.Matches(c)
+
+		// Return immediately if there's a match.
+		if wrappedErr == nil {
+			err = nil
+			return
+		}
+
+		// Note the fatal error, if any.
+		if _, isFatal := wrappedErr.(*FatalError); isFatal {
+			err = wrappedErr
+		}
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go
new file mode 100644
index 00000000000..f0b5025406f
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go
@@ -0,0 +1,139 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"errors"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type fakeAnyOfMatcher struct {
+	desc string
+	err  error
+}
+
+func (m *fakeAnyOfMatcher) Matches(c interface{}) error {
+	return m.err
+}
+
+func (m *fakeAnyOfMatcher) Description() string {
+	return m.desc
+}
+
+type AnyOfTest struct {
+}
+
+func init() { RegisterTestSuite(&AnyOfTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *AnyOfTest) EmptySet() {
+	matcher := AnyOf()
+
+	err := matcher.Matches(0)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *AnyOfTest) OneTrue() {
+	matcher := AnyOf(
+		&fakeAnyOfMatcher{"", NewFatalError("foo")},
+		17,
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+		&fakeAnyOfMatcher{"", nil},
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+	)
+
+	err := matcher.Matches(0)
+	ExpectEq(nil, err)
+}
+
+func (t *AnyOfTest) OneEqual() {
+	matcher := AnyOf(
+		&fakeAnyOfMatcher{"", NewFatalError("foo")},
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+		13,
+		"taco",
+		19,
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+	)
+
+	err := matcher.Matches("taco")
+	ExpectEq(nil, err)
+}
+
+func (t *AnyOfTest) OneFatal() {
+	matcher := AnyOf(
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+		17,
+		&fakeAnyOfMatcher{"", NewFatalError("taco")},
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+	)
+
+	err := matcher.Matches(0)
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *AnyOfTest) OneNil() {
+	var err error
+	matcher := AnyOf(
+		13,
+		nil,
+		19,
+	)
+
+	// No match
+	err = matcher.Matches(14)
+	ExpectNe(nil, err)
+
+	// Match
+	err = matcher.Matches(nil)
+	ExpectEq(nil, err)
+}
+
+func (t *AnyOfTest) AllFalseAndNotEqual() {
+	matcher := AnyOf(
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+		17,
+		&fakeAnyOfMatcher{"", errors.New("foo")},
+		19,
+	)
+
+	err := matcher.Matches(0)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *AnyOfTest) DescriptionForEmptySet() {
+	matcher := AnyOf()
+	ExpectEq("or()", matcher.Description())
+}
+
+func (t *AnyOfTest) DescriptionForNonEmptySet() {
+	matcher := AnyOf(
+		&fakeAnyOfMatcher{"taco", nil},
+		"burrito",
+		&fakeAnyOfMatcher{"enchilada", nil},
+	)
+
+	ExpectEq("or(taco, burrito, enchilada)", matcher.Description())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_test.go
new file mode 100644
index 00000000000..410cc12825e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_test.go
@@ -0,0 +1,53 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type AnyTest struct {
+}
+
+func init() { RegisterTestSuite(&AnyTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *AnyTest) Description() {
+	m := Any()
+	ExpectEq("is anything", m.Description())
+}
+
+func (t *AnyTest) Matches() {
+	var err error
+	m := Any()
+
+	err = m.Matches(nil)
+	ExpectEq(nil, err)
+
+	err = m.Matches(17)
+	ExpectEq(nil, err)
+
+	err = m.Matches("taco")
+	ExpectEq(nil, err)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains.go
new file mode 100644
index 00000000000..2f326dbc5d6
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains.go
@@ -0,0 +1,61 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Return a matcher that matches arrays slices with at least one element that
+// matches the supplied argument. If the argument x is not itself a Matcher,
+// this is equivalent to Contains(Equals(x)).
+func Contains(x interface{}) Matcher {
+	var result containsMatcher
+	var ok bool
+
+	if result.elementMatcher, ok = x.(Matcher); !ok {
+		result.elementMatcher = Equals(x)
+	}
+
+	return &result
+}
+
+type containsMatcher struct {
+	elementMatcher Matcher
+}
+
+func (m *containsMatcher) Description() string {
+	return fmt.Sprintf("contains: %s", m.elementMatcher.Description())
+}
+
+func (m *containsMatcher) Matches(candidate interface{}) error {
+	// The candidate must be a slice or an array.
+	v := reflect.ValueOf(candidate)
+	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+		return NewFatalError("which is not a slice or array")
+	}
+
+	// Check each element.
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i)
+		if matchErr := m.elementMatcher.Matches(elem.Interface()); matchErr == nil {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go
new file mode 100644
index 00000000000..dfc981c1488
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go
@@ -0,0 +1,233 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type ContainsTest struct {}
+func init() { RegisterTestSuite(&ContainsTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *ContainsTest) WrongTypeCandidates() {
+	m := Contains("")
+	ExpectEq("contains: ", m.Description())
+
+	var err error
+
+	// Nil candidate
+	err = m.Matches(nil)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+
+	// String candidate
+	err = m.Matches("")
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+
+	// Map candidate
+	err = m.Matches(make(map[string]string))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+}
+
+func (t *ContainsTest) NilArgument() {
+	m := Contains(nil)
+	ExpectEq("contains: is nil", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Empty array of pointers
+	c = [...]*int{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Empty slice of pointers
+	c = []*int{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-empty array of integers
+	c = [...]int{17, 0, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-empty slice of integers
+	c = []int{17, 0, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching array of pointers
+	c = [...]*int{new(int), new(int)}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching slice of pointers
+	c = []*int{new(int), new(int)}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Matching array of pointers
+	c = [...]*int{new(int), nil, new(int)}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching slice of pointers
+	c = []*int{new(int), nil, new(int)}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching slice of pointers from matching array
+	someArray := [...]*int{new(int), nil, new(int)}
+	c = someArray[0:1]
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *ContainsTest) StringArgument() {
+	m := Contains("taco")
+	ExpectEq("contains: taco", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Non-matching array of strings
+	c = [...]string{"burrito", "enchilada"}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching slice of strings
+	c = []string{"burrito", "enchilada"}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Matching array of strings
+	c = [...]string{"burrito", "taco", "enchilada"}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching slice of strings
+	c = []string{"burrito", "taco", "enchilada"}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching slice of strings from matching array
+	someArray := [...]string{"burrito", "taco", "enchilada"}
+	c = someArray[0:1]
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *ContainsTest) IntegerArgument() {
+	m := Contains(int(17))
+	ExpectEq("contains: 17", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Non-matching array of integers
+	c = [...]int{13, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching slice of integers
+	c = []int{13, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Matching array of integers
+	c = [...]int{13, 17, 19}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching slice of integers
+	c = []int{13, 17, 19}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching slice of integers from matching array
+	someArray := [...]int{13, 17, 19}
+	c = someArray[0:1]
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching array of floats
+	c = [...]float32{13, 17.5, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching slice of floats
+	c = []float32{13, 17.5, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Matching array of floats
+	c = [...]float32{13, 17, 19}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching slice of floats
+	c = []float32{13, 17, 19}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+}
+
+func (t *ContainsTest) MatcherArgument() {
+	m := Contains(HasSubstr("ac"))
+	ExpectEq("contains: has substring \"ac\"", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Non-matching array of strings
+	c = [...]string{"burrito", "enchilada"}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Non-matching slice of strings
+	c = []string{"burrito", "enchilada"}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Matching array of strings
+	c = [...]string{"burrito", "taco", "enchilada"}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching slice of strings
+	c = []string{"burrito", "taco", "enchilada"}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching slice of strings from matching array
+	someArray := [...]string{"burrito", "taco", "enchilada"}
+	c = someArray[0:1]
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go
new file mode 100644
index 00000000000..1d91baef32e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go
@@ -0,0 +1,88 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+var byteSliceType reflect.Type = reflect.TypeOf([]byte{})
+
+// DeepEquals returns a matcher that matches based on 'deep equality', as
+// defined by the reflect package. This matcher requires that values have
+// identical types to x.
+func DeepEquals(x interface{}) Matcher {
+	return &deepEqualsMatcher{x}
+}
+
+type deepEqualsMatcher struct {
+	x interface{}
+}
+
+func (m *deepEqualsMatcher) Description() string {
+	xDesc := fmt.Sprintf("%v", m.x)
+	xValue := reflect.ValueOf(m.x)
+
+	// Special case: fmt.Sprintf presents nil slices as "[]", but
+	// reflect.DeepEqual makes a distinction between nil and empty slices. Make
+	// this less confusing.
+	if xValue.Kind() == reflect.Slice && xValue.IsNil() {
+		xDesc = "<nil slice>"
+	}
+
+	return fmt.Sprintf("deep equals: %s", xDesc)
+}
+
+func (m *deepEqualsMatcher) Matches(c interface{}) error {
+	// Make sure the types match.
+	ct := reflect.TypeOf(c)
+	xt := reflect.TypeOf(m.x)
+
+	if ct != xt {
+		return NewFatalError(fmt.Sprintf("which is of type %v", ct))
+	}
+
+	// Special case: handle byte slices more efficiently.
+	cValue := reflect.ValueOf(c)
+	xValue := reflect.ValueOf(m.x)
+
+	if ct == byteSliceType && !cValue.IsNil() && !xValue.IsNil() {
+		xBytes := m.x.([]byte)
+		cBytes := c.([]byte)
+
+		if bytes.Equal(cBytes, xBytes) {
+			return nil
+		}
+
+		return errors.New("")
+	}
+
+	// Defer to the reflect package.
+	if reflect.DeepEqual(m.x, c) {
+		return nil
+	}
+
+	// Special case: if the comparison failed because c is the nil slice, given
+	// an indication of this (since its value is printed as "[]").
+	if cValue.Kind() == reflect.Slice && cValue.IsNil() {
+		return errors.New("which is nil")
+	}
+
+	return errors.New("")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go
new file mode 100644
index 00000000000..a28113aaa6b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go
@@ -0,0 +1,343 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"bytes"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type DeepEqualsTest struct {}
+func init() { RegisterTestSuite(&DeepEqualsTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *DeepEqualsTest) WrongTypeCandidateWithScalarValue() {
+	var x int = 17
+	m := DeepEquals(x)
+
+	var err error
+
+	// Nil candidate.
+	err = m.Matches(nil)
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("<nil>")))
+
+	// Int alias candidate.
+	type intAlias int
+	err = m.Matches(intAlias(x))
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("intAlias")))
+
+	// String candidate.
+	err = m.Matches("taco")
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("string")))
+
+	// Byte slice candidate.
+	err = m.Matches([]byte{})
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint8")))
+
+	// Other slice candidate.
+	err = m.Matches([]uint16{})
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint16")))
+
+	// Unsigned int candidate.
+	err = m.Matches(uint(17))
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("uint")))
+}
+
+func (t *DeepEqualsTest) WrongTypeCandidateWithByteSliceValue() {
+	x := []byte{}
+	m := DeepEquals(x)
+
+	var err error
+
+	// Nil candidate.
+	err = m.Matches(nil)
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("<nil>")))
+
+	// String candidate.
+	err = m.Matches("taco")
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("string")))
+
+	// Slice candidate with wrong value type.
+	err = m.Matches([]uint16{})
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint16")))
+}
+
+func (t *DeepEqualsTest) WrongTypeCandidateWithOtherSliceValue() {
+	x := []uint16{}
+	m := DeepEquals(x)
+
+	var err error
+
+	// Nil candidate.
+	err = m.Matches(nil)
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("<nil>")))
+
+	// String candidate.
+	err = m.Matches("taco")
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("string")))
+
+	// Byte slice candidate with wrong value type.
+	err = m.Matches([]byte{})
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint8")))
+
+	// Other slice candidate with wrong value type.
+	err = m.Matches([]uint32{})
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint32")))
+}
+
+func (t *DeepEqualsTest) WrongTypeCandidateWithNilLiteralValue() {
+	m := DeepEquals(nil)
+
+	var err error
+
+	// String candidate.
+	err = m.Matches("taco")
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("string")))
+
+	// Nil byte slice candidate.
+	err = m.Matches([]byte(nil))
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint8")))
+
+	// Nil other slice candidate.
+	err = m.Matches([]uint16(nil))
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("type")))
+	ExpectThat(err, Error(HasSubstr("[]uint16")))
+}
+
+func (t *DeepEqualsTest) NilLiteralValue() {
+	m := DeepEquals(nil)
+	ExpectEq("deep equals: <nil>", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Nil literal candidate.
+	c = nil
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+}
+
+func (t *DeepEqualsTest) IntValue() {
+	m := DeepEquals(int(17))
+	ExpectEq("deep equals: 17", m.Description())
+
+	var c interface{}
+	var err error
+
+	// Matching int.
+	c = int(17)
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching int.
+	c = int(18)
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *DeepEqualsTest) ByteSliceValue() {
+	x := []byte{17, 19}
+	m := DeepEquals(x)
+	ExpectEq("deep equals: [17 19]", m.Description())
+
+	var c []byte
+	var err error
+
+	// Matching.
+	c = make([]byte, len(x))
+	AssertEq(len(x), copy(c, x))
+
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Nil slice.
+	c = []byte(nil)
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("which is nil")))
+
+	// Prefix.
+	AssertGt(len(x), 1)
+	c = make([]byte, len(x)-1)
+	AssertEq(len(x)-1, copy(c, x))
+
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Suffix.
+	c = make([]byte, len(x)+1)
+	AssertEq(len(x), copy(c, x))
+
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *DeepEqualsTest) OtherSliceValue() {
+	x := []uint16{17, 19}
+	m := DeepEquals(x)
+	ExpectEq("deep equals: [17 19]", m.Description())
+
+	var c []uint16
+	var err error
+
+	// Matching.
+	c = make([]uint16, len(x))
+	AssertEq(len(x), copy(c, x))
+
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Nil slice.
+	c = []uint16(nil)
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("which is nil")))
+
+	// Prefix.
+	AssertGt(len(x), 1)
+	c = make([]uint16, len(x)-1)
+	AssertEq(len(x)-1, copy(c, x))
+
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+
+	// Suffix.
+	c = make([]uint16, len(x)+1)
+	AssertEq(len(x), copy(c, x))
+
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *DeepEqualsTest) NilByteSliceValue() {
+	x := []byte(nil)
+	m := DeepEquals(x)
+	ExpectEq("deep equals: <nil slice>", m.Description())
+
+	var c []byte
+	var err error
+
+	// Nil slice.
+	c = []byte(nil)
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-nil slice.
+	c = []byte{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *DeepEqualsTest) NilOtherSliceValue() {
+	x := []uint16(nil)
+	m := DeepEquals(x)
+	ExpectEq("deep equals: <nil slice>", m.Description())
+
+	var c []uint16
+	var err error
+
+	// Nil slice.
+	c = []uint16(nil)
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-nil slice.
+	c = []uint16{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Benchmarks
+////////////////////////////////////////////////////////////////////////
+
+func benchmarkWithSize(b *testing.B, size int) {
+	b.StopTimer()
+	buf := bytes.Repeat([]byte{0x01}, size)
+	bufCopy := make([]byte, size)
+	copy(bufCopy, buf)
+
+	matcher := DeepEquals(buf)
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		matcher.Matches(bufCopy)
+	}
+
+	b.SetBytes(int64(size))
+}
+
+func BenchmarkShortByteSlice(b *testing.B) {
+	benchmarkWithSize(b, 256)
+}
+
+func BenchmarkLongByteSlice(b *testing.B) {
+	benchmarkWithSize(b, 1<<24)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go
new file mode 100644
index 00000000000..2941847c705
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go
@@ -0,0 +1,91 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Given a list of arguments M, ElementsAre returns a matcher that matches
+// arrays and slices A where all of the following hold:
+//
+//  *  A is the same length as M.
+//
+//  *  For each i < len(A) where M[i] is a matcher, A[i] matches M[i].
+//
+//  *  For each i < len(A) where M[i] is not a matcher, A[i] matches
+//     Equals(M[i]).
+//
+func ElementsAre(M ...interface{}) Matcher {
+	// Copy over matchers, or convert to Equals(x) for non-matcher x.
+	subMatchers := make([]Matcher, len(M))
+	for i, x := range M {
+		if matcher, ok := x.(Matcher); ok {
+			subMatchers[i] = matcher
+			continue
+		}
+
+		subMatchers[i] = Equals(x)
+	}
+
+	return &elementsAreMatcher{subMatchers}
+}
+
+type elementsAreMatcher struct {
+	subMatchers []Matcher
+}
+
+func (m *elementsAreMatcher) Description() string {
+	subDescs := make([]string, len(m.subMatchers))
+	for i, sm := range m.subMatchers {
+		subDescs[i] = sm.Description()
+	}
+
+	return fmt.Sprintf("elements are: [%s]", strings.Join(subDescs, ", "))
+}
+
+func (m *elementsAreMatcher) Matches(candidates interface{}) error {
+	// The candidate must be a slice or an array.
+	v := reflect.ValueOf(candidates)
+	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+		return NewFatalError("which is not a slice or array")
+	}
+
+	// The length must be correct.
+	if v.Len() != len(m.subMatchers) {
+		return errors.New(fmt.Sprintf("which is of length %d", v.Len()))
+	}
+
+	// Check each element.
+	for i, subMatcher := range m.subMatchers {
+		c := v.Index(i)
+		if matchErr := subMatcher.Matches(c.Interface()); matchErr != nil {
+			// Return an errors indicating which element doesn't match. If the
+			// matcher error was fatal, make this one fatal too.
+			err := errors.New(fmt.Sprintf("whose element %d doesn't match", i))
+			if _, isFatal := matchErr.(*FatalError); isFatal {
+				err = NewFatalError(err.Error())
+			}
+
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go
new file mode 100644
index 00000000000..172584fa140
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go
@@ -0,0 +1,208 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type ElementsAreTest struct {
+}
+
+func init()                     { RegisterTestSuite(&ElementsAreTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *ElementsAreTest) EmptySet() {
+	m := ElementsAre()
+	ExpectEq("elements are: []", m.Description())
+
+	var c []interface{}
+	var err error
+
+	// No candidates.
+	c = []interface{}{}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// One candidate.
+	c = []interface{}{17}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 1")))
+}
+
+func (t *ElementsAreTest) OneMatcher() {
+	m := ElementsAre(LessThan(17))
+	ExpectEq("elements are: [less than 17]", m.Description())
+
+	var c []interface{}
+	var err error
+
+	// No candidates.
+	c = []interface{}{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 0")))
+
+	// Matching candidate.
+	c = []interface{}{16}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching candidate.
+	c = []interface{}{19}
+	err = m.Matches(c)
+	ExpectNe(nil, err)
+
+	// Two candidates.
+	c = []interface{}{17, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 2")))
+}
+
+func (t *ElementsAreTest) OneValue() {
+	m := ElementsAre(17)
+	ExpectEq("elements are: [17]", m.Description())
+
+	var c []interface{}
+	var err error
+
+	// No candidates.
+	c = []interface{}{}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 0")))
+
+	// Matching int.
+	c = []interface{}{int(17)}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Matching float.
+	c = []interface{}{float32(17)}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// Non-matching candidate.
+	c = []interface{}{19}
+	err = m.Matches(c)
+	ExpectNe(nil, err)
+
+	// Two candidates.
+	c = []interface{}{17, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 2")))
+}
+
+func (t *ElementsAreTest) MultipleElements() {
+	m := ElementsAre("taco", LessThan(17))
+	ExpectEq("elements are: [taco, less than 17]", m.Description())
+
+	var c []interface{}
+	var err error
+
+	// One candidate.
+	c = []interface{}{17}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 1")))
+
+	// Both matching.
+	c = []interface{}{"taco", 16}
+	err = m.Matches(c)
+	ExpectEq(nil, err)
+
+	// First non-matching.
+	c = []interface{}{"burrito", 16}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("whose element 0 doesn't match")))
+
+	// Second non-matching.
+	c = []interface{}{"taco", 17}
+	err = m.Matches(c)
+	ExpectThat(err, Error(Equals("whose element 1 doesn't match")))
+
+	// Three candidates.
+	c = []interface{}{"taco", 17, 19}
+	err = m.Matches(c)
+	ExpectThat(err, Error(HasSubstr("length 3")))
+}
+
+func (t *ElementsAreTest) ArrayCandidates() {
+	m := ElementsAre("taco", LessThan(17))
+
+	var err error
+
+	// One candidate.
+	err = m.Matches([1]interface{}{"taco"})
+	ExpectThat(err, Error(HasSubstr("length 1")))
+
+	// Both matching.
+	err = m.Matches([2]interface{}{"taco", 16})
+	ExpectEq(nil, err)
+
+	// First non-matching.
+	err = m.Matches([2]interface{}{"burrito", 16})
+	ExpectThat(err, Error(Equals("whose element 0 doesn't match")))
+}
+
+func (t *ElementsAreTest) WrongTypeCandidate() {
+	m := ElementsAre("taco")
+
+	var err error
+
+	// String candidate.
+	err = m.Matches("taco")
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+
+	// Map candidate.
+	err = m.Matches(map[string]string{})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+
+	// Nil candidate.
+	err = m.Matches(nil)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("array")))
+	ExpectThat(err, Error(HasSubstr("slice")))
+}
+
+func (t *ElementsAreTest) PropagatesFatality() {
+	m := ElementsAre(LessThan(17))
+	ExpectEq("elements are: [less than 17]", m.Description())
+
+	var c []interface{}
+	var err error
+
+	// Non-fatal error.
+	c = []interface{}{19}
+	err = m.Matches(c)
+	AssertNe(nil, err)
+	ExpectFalse(isFatal(err))
+
+	// Fatal error.
+	c = []interface{}{"taco"}
+	err = m.Matches(c)
+	AssertNe(nil, err)
+	ExpectTrue(isFatal(err))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals.go
new file mode 100644
index 00000000000..a510707b3c7
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals.go
@@ -0,0 +1,541 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+)
+
+// Equals(x) returns a matcher that matches values v such that v and x are
+// equivalent. This includes the case when the comparison v == x using Go's
+// built-in comparison operator is legal (except for structs, which this
+// matcher does not support), but for convenience the following rules also
+// apply:
+//
+//  *  Type checking is done based on underlying types rather than actual
+//     types, so that e.g. two aliases for string can be compared:
+//
+//         type stringAlias1 string
+//         type stringAlias2 string
+//
+//         a := "taco"
+//         b := stringAlias1("taco")
+//         c := stringAlias2("taco")
+//
+//         ExpectTrue(a == b)  // Legal, passes
+//         ExpectTrue(b == c)  // Illegal, doesn't compile
+//
+//         ExpectThat(a, Equals(b))  // Passes
+//         ExpectThat(b, Equals(c))  // Passes
+//
+//  *  Values of numeric type are treated as if they were abstract numbers, and
+//     compared accordingly. Therefore Equals(17) will match int(17),
+//     int16(17), uint(17), float32(17), complex64(17), and so on.
+//
+// If you want a stricter matcher that contains no such cleverness, see
+// IdenticalTo instead.
+//
+// Arrays are supported by this matcher, but do not participate in the
+// exceptions above. Two arrays compared with this matcher must have identical
+// types, and their element type must itself be comparable according to Go's ==
+// operator.
+func Equals(x interface{}) Matcher {
+	v := reflect.ValueOf(x)
+
+	// This matcher doesn't support structs.
+	if v.Kind() == reflect.Struct {
+		panic(fmt.Sprintf("oglematchers.Equals: unsupported kind %v", v.Kind()))
+	}
+
+	// The == operator is not defined for non-nil slices.
+	if v.Kind() == reflect.Slice && v.Pointer() != uintptr(0) {
+		panic(fmt.Sprintf("oglematchers.Equals: non-nil slice"))
+	}
+
+	return &equalsMatcher{v}
+}
+
+type equalsMatcher struct {
+	expectedValue reflect.Value
+}
+
+////////////////////////////////////////////////////////////////////////
+// Numeric types
+////////////////////////////////////////////////////////////////////////
+
+func isSignedInteger(v reflect.Value) bool {
+	k := v.Kind()
+	return k >= reflect.Int && k <= reflect.Int64
+}
+
+func isUnsignedInteger(v reflect.Value) bool {
+	k := v.Kind()
+	return k >= reflect.Uint && k <= reflect.Uintptr
+}
+
+func isInteger(v reflect.Value) bool {
+	return isSignedInteger(v) || isUnsignedInteger(v)
+}
+
+func isFloat(v reflect.Value) bool {
+	k := v.Kind()
+	return k == reflect.Float32 || k == reflect.Float64
+}
+
+func isComplex(v reflect.Value) bool {
+	k := v.Kind()
+	return k == reflect.Complex64 || k == reflect.Complex128
+}
+
+func checkAgainstInt64(e int64, c reflect.Value) (err error) {
+	err = errors.New("")
+
+	switch {
+	case isSignedInteger(c):
+		if c.Int() == e {
+			err = nil
+		}
+
+	case isUnsignedInteger(c):
+		u := c.Uint()
+		if u <= math.MaxInt64 && int64(u) == e {
+			err = nil
+		}
+
+	// Turn around the various floating point types so that the checkAgainst*
+	// functions for them can deal with precision issues.
+	case isFloat(c), isComplex(c):
+		return Equals(c.Interface()).Matches(e)
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+func checkAgainstUint64(e uint64, c reflect.Value) (err error) {
+	err = errors.New("")
+
+	switch {
+	case isSignedInteger(c):
+		i := c.Int()
+		if i >= 0 && uint64(i) == e {
+			err = nil
+		}
+
+	case isUnsignedInteger(c):
+		if c.Uint() == e {
+			err = nil
+		}
+
+	// Turn around the various floating point types so that the checkAgainst*
+	// functions for them can deal with precision issues.
+	case isFloat(c), isComplex(c):
+		return Equals(c.Interface()).Matches(e)
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+func checkAgainstFloat32(e float32, c reflect.Value) (err error) {
+	err = errors.New("")
+
+	switch {
+	case isSignedInteger(c):
+		if float32(c.Int()) == e {
+			err = nil
+		}
+
+	case isUnsignedInteger(c):
+		if float32(c.Uint()) == e {
+			err = nil
+		}
+
+	case isFloat(c):
+		// Compare using float32 to avoid a false sense of precision; otherwise
+		// e.g. Equals(float32(0.1)) won't match float32(0.1).
+		if float32(c.Float()) == e {
+			err = nil
+		}
+
+	case isComplex(c):
+		comp := c.Complex()
+		rl := real(comp)
+		im := imag(comp)
+
+		// Compare using float32 to avoid a false sense of precision; otherwise
+		// e.g. Equals(float32(0.1)) won't match (0.1 + 0i).
+		if im == 0 && float32(rl) == e {
+			err = nil
+		}
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+func checkAgainstFloat64(e float64, c reflect.Value) (err error) {
+	err = errors.New("")
+
+	ck := c.Kind()
+
+	switch {
+	case isSignedInteger(c):
+		if float64(c.Int()) == e {
+			err = nil
+		}
+
+	case isUnsignedInteger(c):
+		if float64(c.Uint()) == e {
+			err = nil
+		}
+
+	// If the actual value is lower precision, turn the comparison around so we
+	// apply the low-precision rules. Otherwise, e.g. Equals(0.1) may not match
+	// float32(0.1).
+	case ck == reflect.Float32 || ck == reflect.Complex64:
+		return Equals(c.Interface()).Matches(e)
+
+		// Otherwise, compare with double precision.
+	case isFloat(c):
+		if c.Float() == e {
+			err = nil
+		}
+
+	case isComplex(c):
+		comp := c.Complex()
+		rl := real(comp)
+		im := imag(comp)
+
+		if im == 0 && rl == e {
+			err = nil
+		}
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+func checkAgainstComplex64(e complex64, c reflect.Value) (err error) {
+	err = errors.New("")
+	realPart := real(e)
+	imaginaryPart := imag(e)
+
+	switch {
+	case isInteger(c) || isFloat(c):
+		// If we have no imaginary part, then we should just compare against the
+		// real part. Otherwise, we can't be equal.
+		if imaginaryPart != 0 {
+			return
+		}
+
+		return checkAgainstFloat32(realPart, c)
+
+	case isComplex(c):
+		// Compare using complex64 to avoid a false sense of precision; otherwise
+		// e.g. Equals(0.1 + 0i) won't match float32(0.1).
+		if complex64(c.Complex()) == e {
+			err = nil
+		}
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+func checkAgainstComplex128(e complex128, c reflect.Value) (err error) {
+	err = errors.New("")
+	realPart := real(e)
+	imaginaryPart := imag(e)
+
+	switch {
+	case isInteger(c) || isFloat(c):
+		// If we have no imaginary part, then we should just compare against the
+		// real part. Otherwise, we can't be equal.
+		if imaginaryPart != 0 {
+			return
+		}
+
+		return checkAgainstFloat64(realPart, c)
+
+	case isComplex(c):
+		if c.Complex() == e {
+			err = nil
+		}
+
+	default:
+		err = NewFatalError("which is not numeric")
+	}
+
+	return
+}
+
+////////////////////////////////////////////////////////////////////////
+// Other types
+////////////////////////////////////////////////////////////////////////
+
+func checkAgainstBool(e bool, c reflect.Value) (err error) {
+	if c.Kind() != reflect.Bool {
+		err = NewFatalError("which is not a bool")
+		return
+	}
+
+	err = errors.New("")
+	if c.Bool() == e {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstChan(e reflect.Value, c reflect.Value) (err error) {
+	// Create a description of e's type, e.g. "chan int".
+	typeStr := fmt.Sprintf("%s %s", e.Type().ChanDir(), e.Type().Elem())
+
+	// Make sure c is a chan of the correct type.
+	if c.Kind() != reflect.Chan ||
+		c.Type().ChanDir() != e.Type().ChanDir() ||
+		c.Type().Elem() != e.Type().Elem() {
+		err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstFunc(e reflect.Value, c reflect.Value) (err error) {
+	// Make sure c is a function.
+	if c.Kind() != reflect.Func {
+		err = NewFatalError("which is not a function")
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstMap(e reflect.Value, c reflect.Value) (err error) {
+	// Make sure c is a map.
+	if c.Kind() != reflect.Map {
+		err = NewFatalError("which is not a map")
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstPtr(e reflect.Value, c reflect.Value) (err error) {
+	// Create a description of e's type, e.g. "*int".
+	typeStr := fmt.Sprintf("*%v", e.Type().Elem())
+
+	// Make sure c is a pointer of the correct type.
+	if c.Kind() != reflect.Ptr ||
+		c.Type().Elem() != e.Type().Elem() {
+		err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstSlice(e reflect.Value, c reflect.Value) (err error) {
+	// Create a description of e's type, e.g. "[]int".
+	typeStr := fmt.Sprintf("[]%v", e.Type().Elem())
+
+	// Make sure c is a slice of the correct type.
+	if c.Kind() != reflect.Slice ||
+		c.Type().Elem() != e.Type().Elem() {
+		err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstString(e reflect.Value, c reflect.Value) (err error) {
+	// Make sure c is a string.
+	if c.Kind() != reflect.String {
+		err = NewFatalError("which is not a string")
+		return
+	}
+
+	err = errors.New("")
+	if c.String() == e.String() {
+		err = nil
+	}
+	return
+}
+
+func checkAgainstArray(e reflect.Value, c reflect.Value) (err error) {
+	// Create a description of e's type, e.g. "[2]int".
+	typeStr := fmt.Sprintf("%v", e.Type())
+
+	// Make sure c is the correct type.
+	if c.Type() != e.Type() {
+		err = NewFatalError(fmt.Sprintf("which is not %s", typeStr))
+		return
+	}
+
+	// Check for equality.
+	if e.Interface() != c.Interface() {
+		err = errors.New("")
+		return
+	}
+
+	return
+}
+
+func checkAgainstUnsafePointer(e reflect.Value, c reflect.Value) (err error) {
+	// Make sure c is a pointer.
+	if c.Kind() != reflect.UnsafePointer {
+		err = NewFatalError("which is not a unsafe.Pointer")
+		return
+	}
+
+	err = errors.New("")
+	if c.Pointer() == e.Pointer() {
+		err = nil
+	}
+	return
+}
+
+func checkForNil(c reflect.Value) (err error) {
+	err = errors.New("")
+
+	// Make sure it is legal to call IsNil.
+	switch c.Kind() {
+	case reflect.Invalid:
+	case reflect.Chan:
+	case reflect.Func:
+	case reflect.Interface:
+	case reflect.Map:
+	case reflect.Ptr:
+	case reflect.Slice:
+
+	default:
+		err = NewFatalError("which cannot be compared to nil")
+		return
+	}
+
+	// Ask whether the value is nil. Handle a nil literal (kind Invalid)
+	// specially, since it's not legal to call IsNil there.
+	if c.Kind() == reflect.Invalid || c.IsNil() {
+		err = nil
+	}
+	return
+}
+
+////////////////////////////////////////////////////////////////////////
+// Public implementation
+////////////////////////////////////////////////////////////////////////
+
+func (m *equalsMatcher) Matches(candidate interface{}) error {
+	e := m.expectedValue
+	c := reflect.ValueOf(candidate)
+	ek := e.Kind()
+
+	switch {
+	case ek == reflect.Bool:
+		return checkAgainstBool(e.Bool(), c)
+
+	case isSignedInteger(e):
+		return checkAgainstInt64(e.Int(), c)
+
+	case isUnsignedInteger(e):
+		return checkAgainstUint64(e.Uint(), c)
+
+	case ek == reflect.Float32:
+		return checkAgainstFloat32(float32(e.Float()), c)
+
+	case ek == reflect.Float64:
+		return checkAgainstFloat64(e.Float(), c)
+
+	case ek == reflect.Complex64:
+		return checkAgainstComplex64(complex64(e.Complex()), c)
+
+	case ek == reflect.Complex128:
+		return checkAgainstComplex128(complex128(e.Complex()), c)
+
+	case ek == reflect.Chan:
+		return checkAgainstChan(e, c)
+
+	case ek == reflect.Func:
+		return checkAgainstFunc(e, c)
+
+	case ek == reflect.Map:
+		return checkAgainstMap(e, c)
+
+	case ek == reflect.Ptr:
+		return checkAgainstPtr(e, c)
+
+	case ek == reflect.Slice:
+		return checkAgainstSlice(e, c)
+
+	case ek == reflect.String:
+		return checkAgainstString(e, c)
+
+	case ek == reflect.Array:
+		return checkAgainstArray(e, c)
+
+	case ek == reflect.UnsafePointer:
+		return checkAgainstUnsafePointer(e, c)
+
+	case ek == reflect.Invalid:
+		return checkForNil(c)
+	}
+
+	panic(fmt.Sprintf("equalsMatcher.Matches: unexpected kind: %v", ek))
+}
+
+func (m *equalsMatcher) Description() string {
+	// Special case: handle nil.
+	if !m.expectedValue.IsValid() {
+		return "is nil"
+	}
+
+	return fmt.Sprintf("%v", m.expectedValue.Interface())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go
new file mode 100644
index 00000000000..6ac5df27329
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go
@@ -0,0 +1,3864 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	"math"
+	"unsafe"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+var someInt int = -17
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type EqualsTest struct {
+}
+
+func init() { RegisterTestSuite(&EqualsTest{}) }
+
+type equalsTestCase struct {
+	candidate      interface{}
+	expectedResult bool
+	shouldBeFatal  bool
+	expectedError  string
+}
+
+func (t *EqualsTest) checkTestCases(matcher Matcher, cases []equalsTestCase) {
+	for i, c := range cases {
+		err := matcher.Matches(c.candidate)
+		ExpectEq(
+			c.expectedResult,
+			(err == nil),
+			"Result for case %d: %v (Error: %v)", i, c, err)
+
+		if err == nil {
+			continue
+		}
+
+		_, isFatal := err.(*FatalError)
+		ExpectEq(c.shouldBeFatal, isFatal, "Fatality for case %d: %v", i, c)
+
+		ExpectThat(err, Error(Equals(c.expectedError)), "Case %d: %v", i, c)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// nil
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) EqualsNil() {
+	matcher := Equals(nil)
+	ExpectEq("is nil", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Legal types
+		equalsTestCase{nil, true, false, ""},
+		equalsTestCase{chan int(nil), true, false, ""},
+		equalsTestCase{(func())(nil), true, false, ""},
+		equalsTestCase{interface{}(nil), true, false, ""},
+		equalsTestCase{map[int]int(nil), true, false, ""},
+		equalsTestCase{(*int)(nil), true, false, ""},
+		equalsTestCase{[]int(nil), true, false, ""},
+
+		equalsTestCase{make(chan int), false, false, ""},
+		equalsTestCase{func() {}, false, false, ""},
+		equalsTestCase{map[int]int{}, false, false, ""},
+		equalsTestCase{&someInt, false, false, ""},
+		equalsTestCase{[]int{}, false, false, ""},
+
+		// Illegal types
+		equalsTestCase{17, false, true, "which cannot be compared to nil"},
+		equalsTestCase{int8(17), false, true, "which cannot be compared to nil"},
+		equalsTestCase{uintptr(17), false, true, "which cannot be compared to nil"},
+		equalsTestCase{[...]int{}, false, true, "which cannot be compared to nil"},
+		equalsTestCase{"taco", false, true, "which cannot be compared to nil"},
+		equalsTestCase{equalsTestCase{}, false, true, "which cannot be compared to nil"},
+		equalsTestCase{unsafe.Pointer(&someInt), false, true, "which cannot be compared to nil"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegerLiteral() {
+	// -2^30
+	matcher := Equals(-1073741824)
+	ExpectEq("-1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -1073741824.
+		equalsTestCase{-1073741824, true, false, ""},
+		equalsTestCase{-1073741824.0, true, false, ""},
+		equalsTestCase{-1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(-1073741824), true, false, ""},
+		equalsTestCase{int32(-1073741824), true, false, ""},
+		equalsTestCase{int64(-1073741824), true, false, ""},
+		equalsTestCase{float32(-1073741824), true, false, ""},
+		equalsTestCase{float64(-1073741824), true, false, ""},
+		equalsTestCase{complex64(-1073741824), true, false, ""},
+		equalsTestCase{complex128(-1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+		// Values that would be -1073741824 in two's complement.
+		equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-1073741823), false, false, ""},
+		equalsTestCase{int32(-1073741823), false, false, ""},
+		equalsTestCase{int64(-1073741823), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float64(-1073741824.1), false, false, ""},
+		equalsTestCase{float64(-1073741823.9), false, false, ""},
+		equalsTestCase{complex128(-1073741823), false, false, ""},
+		equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegerLiteral() {
+	// 2^30
+	matcher := Equals(1073741824)
+	ExpectEq("1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 1073741824.
+		equalsTestCase{1073741824, true, false, ""},
+		equalsTestCase{1073741824.0, true, false, ""},
+		equalsTestCase{1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(1073741824), true, false, ""},
+		equalsTestCase{uint(1073741824), true, false, ""},
+		equalsTestCase{int32(1073741824), true, false, ""},
+		equalsTestCase{int64(1073741824), true, false, ""},
+		equalsTestCase{uint32(1073741824), true, false, ""},
+		equalsTestCase{uint64(1073741824), true, false, ""},
+		equalsTestCase{uintptr(1073741824), true, false, ""},
+		equalsTestCase{float32(1073741824), true, false, ""},
+		equalsTestCase{float64(1073741824), true, false, ""},
+		equalsTestCase{complex64(1073741824), true, false, ""},
+		equalsTestCase{complex128(1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+		equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1073741823), false, false, ""},
+		equalsTestCase{int32(1073741823), false, false, ""},
+		equalsTestCase{int64(1073741823), false, false, ""},
+		equalsTestCase{float64(1073741824.1), false, false, ""},
+		equalsTestCase{float64(1073741823.9), false, false, ""},
+		equalsTestCase{complex128(1073741823), false, false, ""},
+		equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Floating point literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() {
+	// -2^30
+	matcher := Equals(-1073741824.0)
+	ExpectEq("-1.073741824e+09", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -1073741824.
+		equalsTestCase{-1073741824, true, false, ""},
+		equalsTestCase{-1073741824.0, true, false, ""},
+		equalsTestCase{-1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(-1073741824), true, false, ""},
+		equalsTestCase{int32(-1073741824), true, false, ""},
+		equalsTestCase{int64(-1073741824), true, false, ""},
+		equalsTestCase{float32(-1073741824), true, false, ""},
+		equalsTestCase{float64(-1073741824), true, false, ""},
+		equalsTestCase{complex64(-1073741824), true, false, ""},
+		equalsTestCase{complex128(-1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+		equalsTestCase{interface{}(float64(-1073741824)), true, false, ""},
+
+		// Values that would be -1073741824 in two's complement.
+		equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-1073741823), false, false, ""},
+		equalsTestCase{int32(-1073741823), false, false, ""},
+		equalsTestCase{int64(-1073741823), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float64(-1073741824.1), false, false, ""},
+		equalsTestCase{float64(-1073741823.9), false, false, ""},
+		equalsTestCase{complex128(-1073741823), false, false, ""},
+		equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() {
+	// 2^30
+	matcher := Equals(1073741824.0)
+	ExpectEq("1.073741824e+09", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 1073741824.
+		equalsTestCase{1073741824, true, false, ""},
+		equalsTestCase{1073741824.0, true, false, ""},
+		equalsTestCase{1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(1073741824), true, false, ""},
+		equalsTestCase{int32(1073741824), true, false, ""},
+		equalsTestCase{int64(1073741824), true, false, ""},
+		equalsTestCase{uint(1073741824), true, false, ""},
+		equalsTestCase{uint32(1073741824), true, false, ""},
+		equalsTestCase{uint64(1073741824), true, false, ""},
+		equalsTestCase{float32(1073741824), true, false, ""},
+		equalsTestCase{float64(1073741824), true, false, ""},
+		equalsTestCase{complex64(1073741824), true, false, ""},
+		equalsTestCase{complex128(1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+		equalsTestCase{interface{}(float64(1073741824)), true, false, ""},
+
+		// Values that would be 1073741824 in two's complement.
+		equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1073741823), false, false, ""},
+		equalsTestCase{int32(1073741823), false, false, ""},
+		equalsTestCase{int64(1073741823), false, false, ""},
+		equalsTestCase{uint(1073741823), false, false, ""},
+		equalsTestCase{uint32(1073741823), false, false, ""},
+		equalsTestCase{uint64(1073741823), false, false, ""},
+		equalsTestCase{float64(1073741824.1), false, false, ""},
+		equalsTestCase{float64(1073741823.9), false, false, ""},
+		equalsTestCase{complex128(1073741823), false, false, ""},
+		equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonIntegralFloatingPointLiteral() {
+	matcher := Equals(17.1)
+	ExpectEq("17.1", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 17.1.
+		equalsTestCase{17.1, true, false, ""},
+		equalsTestCase{17.1, true, false, ""},
+		equalsTestCase{17.1 + 0i, true, false, ""},
+		equalsTestCase{float32(17.1), true, false, ""},
+		equalsTestCase{float64(17.1), true, false, ""},
+		equalsTestCase{complex64(17.1), true, false, ""},
+		equalsTestCase{complex128(17.1), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{17, false, false, ""},
+		equalsTestCase{17.2, false, false, ""},
+		equalsTestCase{18, false, false, ""},
+		equalsTestCase{int(17), false, false, ""},
+		equalsTestCase{int(18), false, false, ""},
+		equalsTestCase{int32(17), false, false, ""},
+		equalsTestCase{int64(17), false, false, ""},
+		equalsTestCase{uint(17), false, false, ""},
+		equalsTestCase{uint32(17), false, false, ""},
+		equalsTestCase{uint64(17), false, false, ""},
+		equalsTestCase{uintptr(17), false, false, ""},
+		equalsTestCase{complex128(17.1 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// bool
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) False() {
+	matcher := Equals(false)
+	ExpectEq("false", matcher.Description())
+
+	cases := []equalsTestCase{
+		// bools
+		equalsTestCase{false, true, false, ""},
+		equalsTestCase{bool(false), true, false, ""},
+
+		equalsTestCase{true, false, false, ""},
+		equalsTestCase{bool(true), false, false, ""},
+
+		// Other types.
+		equalsTestCase{int(0), false, true, "which is not a bool"},
+		equalsTestCase{int8(0), false, true, "which is not a bool"},
+		equalsTestCase{int16(0), false, true, "which is not a bool"},
+		equalsTestCase{int32(0), false, true, "which is not a bool"},
+		equalsTestCase{int64(0), false, true, "which is not a bool"},
+		equalsTestCase{uint(0), false, true, "which is not a bool"},
+		equalsTestCase{uint8(0), false, true, "which is not a bool"},
+		equalsTestCase{uint16(0), false, true, "which is not a bool"},
+		equalsTestCase{uint32(0), false, true, "which is not a bool"},
+		equalsTestCase{uint64(0), false, true, "which is not a bool"},
+		equalsTestCase{uintptr(0), false, true, "which is not a bool"},
+		equalsTestCase{[...]int{}, false, true, "which is not a bool"},
+		equalsTestCase{make(chan int), false, true, "which is not a bool"},
+		equalsTestCase{func() {}, false, true, "which is not a bool"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a bool"},
+		equalsTestCase{&someInt, false, true, "which is not a bool"},
+		equalsTestCase{[]int{}, false, true, "which is not a bool"},
+		equalsTestCase{"taco", false, true, "which is not a bool"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) True() {
+	matcher := Equals(true)
+	ExpectEq("true", matcher.Description())
+
+	cases := []equalsTestCase{
+		// bools
+		equalsTestCase{true, true, false, ""},
+		equalsTestCase{bool(true), true, false, ""},
+
+		equalsTestCase{false, false, false, ""},
+		equalsTestCase{bool(false), false, false, ""},
+
+		// Other types.
+		equalsTestCase{int(1), false, true, "which is not a bool"},
+		equalsTestCase{int8(1), false, true, "which is not a bool"},
+		equalsTestCase{int16(1), false, true, "which is not a bool"},
+		equalsTestCase{int32(1), false, true, "which is not a bool"},
+		equalsTestCase{int64(1), false, true, "which is not a bool"},
+		equalsTestCase{uint(1), false, true, "which is not a bool"},
+		equalsTestCase{uint8(1), false, true, "which is not a bool"},
+		equalsTestCase{uint16(1), false, true, "which is not a bool"},
+		equalsTestCase{uint32(1), false, true, "which is not a bool"},
+		equalsTestCase{uint64(1), false, true, "which is not a bool"},
+		equalsTestCase{uintptr(1), false, true, "which is not a bool"},
+		equalsTestCase{[...]int{}, false, true, "which is not a bool"},
+		equalsTestCase{make(chan int), false, true, "which is not a bool"},
+		equalsTestCase{func() {}, false, true, "which is not a bool"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a bool"},
+		equalsTestCase{&someInt, false, true, "which is not a bool"},
+		equalsTestCase{[]int{}, false, true, "which is not a bool"},
+		equalsTestCase{"taco", false, true, "which is not a bool"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt() {
+	// -2^30
+	matcher := Equals(int(-1073741824))
+	ExpectEq("-1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -1073741824.
+		equalsTestCase{-1073741824, true, false, ""},
+		equalsTestCase{-1073741824.0, true, false, ""},
+		equalsTestCase{-1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(-1073741824), true, false, ""},
+		equalsTestCase{int32(-1073741824), true, false, ""},
+		equalsTestCase{int64(-1073741824), true, false, ""},
+		equalsTestCase{float32(-1073741824), true, false, ""},
+		equalsTestCase{float64(-1073741824), true, false, ""},
+		equalsTestCase{complex64(-1073741824), true, false, ""},
+		equalsTestCase{complex128(-1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+		// Values that would be -1073741824 in two's complement.
+		equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-1073741823), false, false, ""},
+		equalsTestCase{int32(-1073741823), false, false, ""},
+		equalsTestCase{int64(-1073741823), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float64(-1073741824.1), false, false, ""},
+		equalsTestCase{float64(-1073741823.9), false, false, ""},
+		equalsTestCase{complex128(-1073741823), false, false, ""},
+		equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt() {
+	// 2^30
+	matcher := Equals(int(1073741824))
+	ExpectEq("1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 1073741824.
+		equalsTestCase{1073741824, true, false, ""},
+		equalsTestCase{1073741824.0, true, false, ""},
+		equalsTestCase{1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(1073741824), true, false, ""},
+		equalsTestCase{uint(1073741824), true, false, ""},
+		equalsTestCase{int32(1073741824), true, false, ""},
+		equalsTestCase{int64(1073741824), true, false, ""},
+		equalsTestCase{uint32(1073741824), true, false, ""},
+		equalsTestCase{uint64(1073741824), true, false, ""},
+		equalsTestCase{uintptr(1073741824), true, false, ""},
+		equalsTestCase{float32(1073741824), true, false, ""},
+		equalsTestCase{float64(1073741824), true, false, ""},
+		equalsTestCase{complex64(1073741824), true, false, ""},
+		equalsTestCase{complex128(1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+		equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1073741823), false, false, ""},
+		equalsTestCase{int32(1073741823), false, false, ""},
+		equalsTestCase{int64(1073741823), false, false, ""},
+		equalsTestCase{float64(1073741824.1), false, false, ""},
+		equalsTestCase{float64(1073741823.9), false, false, ""},
+		equalsTestCase{complex128(1073741823), false, false, ""},
+		equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int8
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt8() {
+	matcher := Equals(int8(-17))
+	ExpectEq("-17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -17.
+		equalsTestCase{-17, true, false, ""},
+		equalsTestCase{-17.0, true, false, ""},
+		equalsTestCase{-17 + 0i, true, false, ""},
+		equalsTestCase{int(-17), true, false, ""},
+		equalsTestCase{int8(-17), true, false, ""},
+		equalsTestCase{int16(-17), true, false, ""},
+		equalsTestCase{int32(-17), true, false, ""},
+		equalsTestCase{int64(-17), true, false, ""},
+		equalsTestCase{float32(-17), true, false, ""},
+		equalsTestCase{float64(-17), true, false, ""},
+		equalsTestCase{complex64(-17), true, false, ""},
+		equalsTestCase{complex128(-17), true, false, ""},
+		equalsTestCase{interface{}(int(-17)), true, false, ""},
+
+		// Values that would be -17 in two's complement.
+		equalsTestCase{uint((1 << 32) - 17), false, false, ""},
+		equalsTestCase{uint8((1 << 8) - 17), false, false, ""},
+		equalsTestCase{uint16((1 << 16) - 17), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 17), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 17), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 17), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-16), false, false, ""},
+		equalsTestCase{int8(-16), false, false, ""},
+		equalsTestCase{int16(-16), false, false, ""},
+		equalsTestCase{int32(-16), false, false, ""},
+		equalsTestCase{int64(-16), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float32(-17.1), false, false, ""},
+		equalsTestCase{float32(-16.9), false, false, ""},
+		equalsTestCase{complex64(-16), false, false, ""},
+		equalsTestCase{complex64(-17 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{-17}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{-17}, false, true, "which is not numeric"},
+		equalsTestCase{"-17", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroInt8() {
+	matcher := Equals(int8(0))
+	ExpectEq("0", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 0.
+		equalsTestCase{0, true, false, ""},
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(int(0)), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1), false, false, ""},
+		equalsTestCase{int8(1), false, false, ""},
+		equalsTestCase{int16(1), false, false, ""},
+		equalsTestCase{int32(1), false, false, ""},
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{float32(-0.1), false, false, ""},
+		equalsTestCase{float32(0.1), false, false, ""},
+		equalsTestCase{complex64(1), false, false, ""},
+		equalsTestCase{complex64(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{0}, false, true, "which is not numeric"},
+		equalsTestCase{"0", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt8() {
+	matcher := Equals(int8(17))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 17.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(17), true, false, ""},
+		equalsTestCase{int8(17), true, false, ""},
+		equalsTestCase{int16(17), true, false, ""},
+		equalsTestCase{int32(17), true, false, ""},
+		equalsTestCase{int64(17), true, false, ""},
+		equalsTestCase{float32(17), true, false, ""},
+		equalsTestCase{float64(17), true, false, ""},
+		equalsTestCase{complex64(17), true, false, ""},
+		equalsTestCase{complex128(17), true, false, ""},
+		equalsTestCase{interface{}(int(17)), true, false, ""},
+		equalsTestCase{uint(17), true, false, ""},
+		equalsTestCase{uint8(17), true, false, ""},
+		equalsTestCase{uint16(17), true, false, ""},
+		equalsTestCase{uint32(17), true, false, ""},
+		equalsTestCase{uint64(17), true, false, ""},
+		equalsTestCase{uintptr(17), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(16), false, false, ""},
+		equalsTestCase{int8(16), false, false, ""},
+		equalsTestCase{int16(16), false, false, ""},
+		equalsTestCase{int32(16), false, false, ""},
+		equalsTestCase{int64(16), false, false, ""},
+		equalsTestCase{float32(16.9), false, false, ""},
+		equalsTestCase{float32(17.1), false, false, ""},
+		equalsTestCase{complex64(16), false, false, ""},
+		equalsTestCase{complex64(17 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{17}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{17}, false, true, "which is not numeric"},
+		equalsTestCase{"17", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int16
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt16() {
+	matcher := Equals(int16(-32766))
+	ExpectEq("-32766", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -32766.
+		equalsTestCase{-32766, true, false, ""},
+		equalsTestCase{-32766.0, true, false, ""},
+		equalsTestCase{-32766 + 0i, true, false, ""},
+		equalsTestCase{int(-32766), true, false, ""},
+		equalsTestCase{int16(-32766), true, false, ""},
+		equalsTestCase{int32(-32766), true, false, ""},
+		equalsTestCase{int64(-32766), true, false, ""},
+		equalsTestCase{float32(-32766), true, false, ""},
+		equalsTestCase{float64(-32766), true, false, ""},
+		equalsTestCase{complex64(-32766), true, false, ""},
+		equalsTestCase{complex128(-32766), true, false, ""},
+		equalsTestCase{interface{}(int(-32766)), true, false, ""},
+
+		// Values that would be -32766 in two's complement.
+		equalsTestCase{uint((1 << 32) - 32766), false, false, ""},
+		equalsTestCase{uint16((1 << 16) - 32766), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 32766), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 32766), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 32766), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-16), false, false, ""},
+		equalsTestCase{int8(-16), false, false, ""},
+		equalsTestCase{int16(-16), false, false, ""},
+		equalsTestCase{int32(-16), false, false, ""},
+		equalsTestCase{int64(-16), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float32(-32766.1), false, false, ""},
+		equalsTestCase{float32(-32765.9), false, false, ""},
+		equalsTestCase{complex64(-32766.1), false, false, ""},
+		equalsTestCase{complex64(-32766 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{-32766}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{-32766}, false, true, "which is not numeric"},
+		equalsTestCase{"-32766", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroInt16() {
+	matcher := Equals(int16(0))
+	ExpectEq("0", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 0.
+		equalsTestCase{0, true, false, ""},
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(int(0)), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1), false, false, ""},
+		equalsTestCase{int8(1), false, false, ""},
+		equalsTestCase{int16(1), false, false, ""},
+		equalsTestCase{int32(1), false, false, ""},
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{float32(-0.1), false, false, ""},
+		equalsTestCase{float32(0.1), false, false, ""},
+		equalsTestCase{complex64(1), false, false, ""},
+		equalsTestCase{complex64(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{0}, false, true, "which is not numeric"},
+		equalsTestCase{"0", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt16() {
+	matcher := Equals(int16(32765))
+	ExpectEq("32765", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32765.
+		equalsTestCase{32765, true, false, ""},
+		equalsTestCase{32765.0, true, false, ""},
+		equalsTestCase{32765 + 0i, true, false, ""},
+		equalsTestCase{int(32765), true, false, ""},
+		equalsTestCase{int16(32765), true, false, ""},
+		equalsTestCase{int32(32765), true, false, ""},
+		equalsTestCase{int64(32765), true, false, ""},
+		equalsTestCase{float32(32765), true, false, ""},
+		equalsTestCase{float64(32765), true, false, ""},
+		equalsTestCase{complex64(32765), true, false, ""},
+		equalsTestCase{complex128(32765), true, false, ""},
+		equalsTestCase{interface{}(int(32765)), true, false, ""},
+		equalsTestCase{uint(32765), true, false, ""},
+		equalsTestCase{uint16(32765), true, false, ""},
+		equalsTestCase{uint32(32765), true, false, ""},
+		equalsTestCase{uint64(32765), true, false, ""},
+		equalsTestCase{uintptr(32765), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(32764), false, false, ""},
+		equalsTestCase{int16(32764), false, false, ""},
+		equalsTestCase{int32(32764), false, false, ""},
+		equalsTestCase{int64(32764), false, false, ""},
+		equalsTestCase{float32(32764.9), false, false, ""},
+		equalsTestCase{float32(32765.1), false, false, ""},
+		equalsTestCase{complex64(32765.9), false, false, ""},
+		equalsTestCase{complex64(32765 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{32765}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{32765}, false, true, "which is not numeric"},
+		equalsTestCase{"32765", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt32() {
+	// -2^30
+	matcher := Equals(int32(-1073741824))
+	ExpectEq("-1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -1073741824.
+		equalsTestCase{-1073741824, true, false, ""},
+		equalsTestCase{-1073741824.0, true, false, ""},
+		equalsTestCase{-1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(-1073741824), true, false, ""},
+		equalsTestCase{int32(-1073741824), true, false, ""},
+		equalsTestCase{int64(-1073741824), true, false, ""},
+		equalsTestCase{float32(-1073741824), true, false, ""},
+		equalsTestCase{float64(-1073741824), true, false, ""},
+		equalsTestCase{complex64(-1073741824), true, false, ""},
+		equalsTestCase{complex128(-1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+		// Values that would be -1073741824 in two's complement.
+		equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+		equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int(-1073741823), false, false, ""},
+		equalsTestCase{int32(-1073741823), false, false, ""},
+		equalsTestCase{int64(-1073741823), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float64(-1073741824.1), false, false, ""},
+		equalsTestCase{float64(-1073741823.9), false, false, ""},
+		equalsTestCase{complex128(-1073741823), false, false, ""},
+		equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt32() {
+	// 2^30
+	matcher := Equals(int32(1073741824))
+	ExpectEq("1073741824", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 1073741824.
+		equalsTestCase{1073741824, true, false, ""},
+		equalsTestCase{1073741824.0, true, false, ""},
+		equalsTestCase{1073741824 + 0i, true, false, ""},
+		equalsTestCase{int(1073741824), true, false, ""},
+		equalsTestCase{uint(1073741824), true, false, ""},
+		equalsTestCase{int32(1073741824), true, false, ""},
+		equalsTestCase{int64(1073741824), true, false, ""},
+		equalsTestCase{uint32(1073741824), true, false, ""},
+		equalsTestCase{uint64(1073741824), true, false, ""},
+		equalsTestCase{uintptr(1073741824), true, false, ""},
+		equalsTestCase{float32(1073741824), true, false, ""},
+		equalsTestCase{float64(1073741824), true, false, ""},
+		equalsTestCase{complex64(1073741824), true, false, ""},
+		equalsTestCase{complex128(1073741824), true, false, ""},
+		equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+		equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(1073741823), false, false, ""},
+		equalsTestCase{int32(1073741823), false, false, ""},
+		equalsTestCase{int64(1073741823), false, false, ""},
+		equalsTestCase{float64(1073741824.1), false, false, ""},
+		equalsTestCase{float64(1073741823.9), false, false, ""},
+		equalsTestCase{complex128(1073741823), false, false, ""},
+		equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt64() {
+	// -2^40
+	matcher := Equals(int64(-1099511627776))
+	ExpectEq("-1099511627776", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -1099511627776.
+		equalsTestCase{-1099511627776.0, true, false, ""},
+		equalsTestCase{-1099511627776 + 0i, true, false, ""},
+		equalsTestCase{int64(-1099511627776), true, false, ""},
+		equalsTestCase{float32(-1099511627776), true, false, ""},
+		equalsTestCase{float64(-1099511627776), true, false, ""},
+		equalsTestCase{complex64(-1099511627776), true, false, ""},
+		equalsTestCase{complex128(-1099511627776), true, false, ""},
+		equalsTestCase{interface{}(int64(-1099511627776)), true, false, ""},
+
+		// Values that would be -1099511627776 in two's complement.
+		equalsTestCase{uint64((1 << 64) - 1099511627776), false, false, ""},
+
+		// Non-equal values of signed integer type.
+		equalsTestCase{int64(-1099511627775), false, false, ""},
+
+		// Non-equal values of other numeric types.
+		equalsTestCase{float64(-1099511627776.1), false, false, ""},
+		equalsTestCase{float64(-1099511627775.9), false, false, ""},
+		equalsTestCase{complex128(-1099511627775), false, false, ""},
+		equalsTestCase{complex128(-1099511627776 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt64() {
+	// 2^40
+	matcher := Equals(int64(1099511627776))
+	ExpectEq("1099511627776", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 1099511627776.
+		equalsTestCase{1099511627776.0, true, false, ""},
+		equalsTestCase{1099511627776 + 0i, true, false, ""},
+		equalsTestCase{int64(1099511627776), true, false, ""},
+		equalsTestCase{uint64(1099511627776), true, false, ""},
+		equalsTestCase{uintptr(1099511627776), true, false, ""},
+		equalsTestCase{float32(1099511627776), true, false, ""},
+		equalsTestCase{float64(1099511627776), true, false, ""},
+		equalsTestCase{complex64(1099511627776), true, false, ""},
+		equalsTestCase{complex128(1099511627776), true, false, ""},
+		equalsTestCase{interface{}(int64(1099511627776)), true, false, ""},
+		equalsTestCase{interface{}(uint64(1099511627776)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(1099511627775), false, false, ""},
+		equalsTestCase{uint64(1099511627775), false, false, ""},
+		equalsTestCase{float64(1099511627776.1), false, false, ""},
+		equalsTestCase{float64(1099511627775.9), false, false, ""},
+		equalsTestCase{complex128(1099511627775), false, false, ""},
+		equalsTestCase{complex128(1099511627776 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Int64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(int64(kTwoTo25 + 1))
+	ExpectEq("33554433", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Int64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := Equals(int64(kTwoTo54 + 1))
+	ExpectEq("18014398509481985", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint() {
+	const kExpected = 17
+	matcher := Equals(uint(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint() {
+	const kExpected = (1 << 16) + 17
+	matcher := Equals(uint(kExpected))
+	ExpectEq("65553", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{65553, true, false, ""},
+		equalsTestCase{65553.0, true, false, ""},
+		equalsTestCase{65553 + 0i, true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{int16(17), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(17), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) UintNotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(uint(kTwoTo25 + 1))
+	ExpectEq("33554433", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint8
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint8() {
+	const kExpected = 17
+	matcher := Equals(uint8(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint16
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint16() {
+	const kExpected = 17
+	matcher := Equals(uint16(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint16() {
+	const kExpected = (1 << 8) + 17
+	matcher := Equals(uint16(kExpected))
+	ExpectEq("273", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{273, true, false, ""},
+		equalsTestCase{273.0, true, false, ""},
+		equalsTestCase{273 + 0i, true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{int8(17), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(17), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint32() {
+	const kExpected = 17
+	matcher := Equals(uint32(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint32() {
+	const kExpected = (1 << 16) + 17
+	matcher := Equals(uint32(kExpected))
+	ExpectEq("65553", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{65553, true, false, ""},
+		equalsTestCase{65553.0, true, false, ""},
+		equalsTestCase{65553 + 0i, true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{int16(17), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(17), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint32NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(uint32(kTwoTo25 + 1))
+	ExpectEq("33554433", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint64() {
+	const kExpected = 17
+	matcher := Equals(uint64(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint64() {
+	const kExpected = (1 << 32) + 17
+	matcher := Equals(uint64(kExpected))
+	ExpectEq("4294967313", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{4294967313.0, true, false, ""},
+		equalsTestCase{4294967313 + 0i, true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{int(17), false, false, ""},
+		equalsTestCase{int32(17), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(17), false, false, ""},
+		equalsTestCase{uint32(17), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(uint64(kTwoTo25 + 1))
+	ExpectEq("33554433", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := Equals(uint64(kTwoTo54 + 1))
+	ExpectEq("18014398509481985", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uintptr
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUintptr() {
+	const kExpected = 17
+	matcher := Equals(uintptr(kExpected))
+	ExpectEq("17", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{17, true, false, ""},
+		equalsTestCase{17.0, true, false, ""},
+		equalsTestCase{17 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int8(kExpected), true, false, ""},
+		equalsTestCase{int16(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint8(kExpected), true, false, ""},
+		equalsTestCase{uint16(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{kExpected + 1, false, false, ""},
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int8(kExpected + 1), false, false, ""},
+		equalsTestCase{int16(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint8(kExpected + 1), false, false, ""},
+		equalsTestCase{uint16(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUintptr() {
+	const kExpected = (1 << 32) + 17
+	matcher := Equals(uintptr(kExpected))
+	ExpectEq("4294967313", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{4294967313.0, true, false, ""},
+		equalsTestCase{4294967313 + 0i, true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric types.
+		equalsTestCase{int(17), false, false, ""},
+		equalsTestCase{int32(17), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(17), false, false, ""},
+		equalsTestCase{uint32(17), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected + 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 1), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// float32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloat32() {
+	matcher := Equals(float32(-32769))
+	ExpectEq("-32769", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -32769.
+		equalsTestCase{-32769.0, true, false, ""},
+		equalsTestCase{-32769 + 0i, true, false, ""},
+		equalsTestCase{int32(-32769), true, false, ""},
+		equalsTestCase{int64(-32769), true, false, ""},
+		equalsTestCase{float32(-32769), true, false, ""},
+		equalsTestCase{float64(-32769), true, false, ""},
+		equalsTestCase{complex64(-32769), true, false, ""},
+		equalsTestCase{complex128(-32769), true, false, ""},
+		equalsTestCase{interface{}(float32(-32769)), true, false, ""},
+		equalsTestCase{interface{}(int64(-32769)), true, false, ""},
+
+		// Values that would be -32769 in two's complement.
+		equalsTestCase{uint64((1 << 64) - 32769), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) - 32769), false, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(-32770), false, false, ""},
+		equalsTestCase{float32(-32769.1), false, false, ""},
+		equalsTestCase{float32(-32768.9), false, false, ""},
+		equalsTestCase{float64(-32769.1), false, false, ""},
+		equalsTestCase{float64(-32768.9), false, false, ""},
+		equalsTestCase{complex128(-32768), false, false, ""},
+		equalsTestCase{complex128(-32769 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralFloat32() {
+	matcher := Equals(float32(-32769.1))
+	ExpectEq("-32769.1", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of -32769.1.
+		equalsTestCase{-32769.1, true, false, ""},
+		equalsTestCase{-32769.1 + 0i, true, false, ""},
+		equalsTestCase{float32(-32769.1), true, false, ""},
+		equalsTestCase{float64(-32769.1), true, false, ""},
+		equalsTestCase{complex64(-32769.1), true, false, ""},
+		equalsTestCase{complex128(-32769.1), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int32(-32769), false, false, ""},
+		equalsTestCase{int32(-32770), false, false, ""},
+		equalsTestCase{int64(-32769), false, false, ""},
+		equalsTestCase{int64(-32770), false, false, ""},
+		equalsTestCase{float32(-32769.2), false, false, ""},
+		equalsTestCase{float32(-32769.0), false, false, ""},
+		equalsTestCase{float64(-32769.2), false, false, ""},
+		equalsTestCase{complex128(-32769.1 + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeFloat32() {
+	const kExpected = -1 * (1 << 65)
+	matcher := Equals(float32(kExpected))
+	ExpectEq("-3.689349e+19", matcher.Description())
+
+	floatExpected := float32(kExpected)
+	castedInt := int64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroFloat32() {
+	matcher := Equals(float32(0))
+	ExpectEq("0", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of zero.
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{int64(-1), false, false, ""},
+		equalsTestCase{float32(1), false, false, ""},
+		equalsTestCase{float32(-1), false, false, ""},
+		equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloat32() {
+	matcher := Equals(float32(32769))
+	ExpectEq("32769", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32769.
+		equalsTestCase{32769.0, true, false, ""},
+		equalsTestCase{32769 + 0i, true, false, ""},
+		equalsTestCase{int(32769), true, false, ""},
+		equalsTestCase{int32(32769), true, false, ""},
+		equalsTestCase{int64(32769), true, false, ""},
+		equalsTestCase{uint(32769), true, false, ""},
+		equalsTestCase{uint32(32769), true, false, ""},
+		equalsTestCase{uint64(32769), true, false, ""},
+		equalsTestCase{uintptr(32769), true, false, ""},
+		equalsTestCase{float32(32769), true, false, ""},
+		equalsTestCase{float64(32769), true, false, ""},
+		equalsTestCase{complex64(32769), true, false, ""},
+		equalsTestCase{complex128(32769), true, false, ""},
+		equalsTestCase{interface{}(float32(32769)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(32770), false, false, ""},
+		equalsTestCase{uint64(32770), false, false, ""},
+		equalsTestCase{float32(32769.1), false, false, ""},
+		equalsTestCase{float32(32768.9), false, false, ""},
+		equalsTestCase{float64(32769.1), false, false, ""},
+		equalsTestCase{float64(32768.9), false, false, ""},
+		equalsTestCase{complex128(32768), false, false, ""},
+		equalsTestCase{complex128(32769 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralFloat32() {
+	matcher := Equals(float32(32769.1))
+	ExpectEq("32769.1", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32769.1.
+		equalsTestCase{32769.1, true, false, ""},
+		equalsTestCase{32769.1 + 0i, true, false, ""},
+		equalsTestCase{float32(32769.1), true, false, ""},
+		equalsTestCase{float64(32769.1), true, false, ""},
+		equalsTestCase{complex64(32769.1), true, false, ""},
+		equalsTestCase{complex128(32769.1), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int32(32769), false, false, ""},
+		equalsTestCase{int32(32770), false, false, ""},
+		equalsTestCase{uint64(32769), false, false, ""},
+		equalsTestCase{uint64(32770), false, false, ""},
+		equalsTestCase{float32(32769.2), false, false, ""},
+		equalsTestCase{float32(32769.0), false, false, ""},
+		equalsTestCase{float64(32769.2), false, false, ""},
+		equalsTestCase{complex128(32769.1 + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveFloat32() {
+	const kExpected = 1 << 65
+	matcher := Equals(float32(kExpected))
+	ExpectEq("3.689349e+19", matcher.Description())
+
+	floatExpected := float32(kExpected)
+	castedInt := uint64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{uint64(0), false, false, ""},
+		equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Float32AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(float32(kTwoTo25 + 1))
+	ExpectEq("3.3554432e+07", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// float64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloat64() {
+	const kExpected = -(1 << 50)
+	matcher := Equals(float64(kExpected))
+	ExpectEq("-1.125899906842624e+15", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{-1125899906842624.0, true, false, ""},
+		equalsTestCase{-1125899906842624.0 + 0i, true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Values that would be kExpected in two's complement.
+		equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralFloat64() {
+	const kTwoTo50 = 1 << 50
+	const kExpected = -kTwoTo50 - 0.25
+
+	matcher := Equals(float64(kExpected))
+	ExpectEq("-1.1258999068426242e+15", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(-kTwoTo50), false, false, ""},
+		equalsTestCase{int64(-kTwoTo50 - 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeFloat64() {
+	const kExpected = -1 * (1 << 65)
+	matcher := Equals(float64(kExpected))
+	ExpectEq("-3.6893488147419103e+19", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := int64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroFloat64() {
+	matcher := Equals(float64(0))
+	ExpectEq("0", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of zero.
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{int64(-1), false, false, ""},
+		equalsTestCase{float32(1), false, false, ""},
+		equalsTestCase{float32(-1), false, false, ""},
+		equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloat64() {
+	const kExpected = 1 << 50
+	matcher := Equals(float64(kExpected))
+	ExpectEq("1.125899906842624e+15", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32769.
+		equalsTestCase{1125899906842624.0, true, false, ""},
+		equalsTestCase{1125899906842624.0 + 0i, true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralFloat64() {
+	const kTwoTo50 = 1 << 50
+	const kExpected = kTwoTo50 + 0.25
+	matcher := Equals(float64(kExpected))
+	ExpectEq("1.1258999068426242e+15", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kTwoTo50), false, false, ""},
+		equalsTestCase{int64(kTwoTo50 - 1), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveFloat64() {
+	const kExpected = 1 << 65
+	matcher := Equals(float64(kExpected))
+	ExpectEq("3.6893488147419103e+19", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := uint64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{uint64(0), false, false, ""},
+		equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Float64AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := Equals(float64(kTwoTo54 + 1))
+	ExpectEq("1.8014398509481984e+16", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// complex64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralComplex64() {
+	const kExpected = -32769
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(-32769+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{-32769.0, true, false, ""},
+		equalsTestCase{-32769.0 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Values that would be kExpected in two's complement.
+		equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
+		equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralComplex64() {
+	const kTwoTo20 = 1 << 20
+	const kExpected = -kTwoTo20 - 0.25
+
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(-1.0485762e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(-kTwoTo20), false, false, ""},
+		equalsTestCase{int(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{int32(-kTwoTo20), false, false, ""},
+		equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{int64(-kTwoTo20), false, false, ""},
+		equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex64(kExpected - 0.75), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 0.75), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeComplex64() {
+	const kExpected = -1 * (1 << 65)
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(-3.689349e+19+0i)", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := int64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroComplex64() {
+	matcher := Equals(complex64(0))
+	ExpectEq("(0+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of zero.
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{int64(-1), false, false, ""},
+		equalsTestCase{float32(1), false, false, ""},
+		equalsTestCase{float32(-1), false, false, ""},
+		equalsTestCase{float64(1), false, false, ""},
+		equalsTestCase{float64(-1), false, false, ""},
+		equalsTestCase{complex64(0 + 2i), false, false, ""},
+		equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralComplex64() {
+	const kExpected = 1 << 20
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(1.048576e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32769.
+		equalsTestCase{1048576.0, true, false, ""},
+		equalsTestCase{1048576.0 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralComplex64() {
+	const kTwoTo20 = 1 << 20
+	const kExpected = kTwoTo20 + 0.25
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(1.0485762e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kTwoTo20), false, false, ""},
+		equalsTestCase{int64(kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{uint64(kTwoTo20), false, false, ""},
+		equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{float32(kExpected - 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveComplex64() {
+	const kExpected = 1 << 65
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(3.689349e+19+0i)", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := uint64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{uint64(0), false, false, ""},
+		equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex64AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := Equals(complex64(kTwoTo25 + 1))
+	ExpectEq("(3.3554432e+07+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{int64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+		// Single-precision floating point.
+		equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo25 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex64WithNonZeroImaginaryPart() {
+	const kRealPart = 17
+	const kImagPart = 0.25i
+	const kExpected = kRealPart + kImagPart
+	matcher := Equals(complex64(kExpected))
+	ExpectEq("(17+0.25i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kRealPart + kImagPart, true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(kRealPart), false, false, ""},
+		equalsTestCase{int8(kRealPart), false, false, ""},
+		equalsTestCase{int16(kRealPart), false, false, ""},
+		equalsTestCase{int32(kRealPart), false, false, ""},
+		equalsTestCase{int64(kRealPart), false, false, ""},
+		equalsTestCase{uint(kRealPart), false, false, ""},
+		equalsTestCase{uint8(kRealPart), false, false, ""},
+		equalsTestCase{uint16(kRealPart), false, false, ""},
+		equalsTestCase{uint32(kRealPart), false, false, ""},
+		equalsTestCase{uint64(kRealPart), false, false, ""},
+		equalsTestCase{float32(kRealPart), false, false, ""},
+		equalsTestCase{float64(kRealPart), false, false, ""},
+		equalsTestCase{complex64(kRealPart), false, false, ""},
+		equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""},
+		equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""},
+		equalsTestCase{complex128(kRealPart), false, false, ""},
+		equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""},
+		equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// complex128
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralComplex128() {
+	const kExpected = -32769
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(-32769+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{-32769.0, true, false, ""},
+		equalsTestCase{-32769.0 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Values that would be kExpected in two's complement.
+		equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
+		equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+		equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralComplex128() {
+	const kTwoTo20 = 1 << 20
+	const kExpected = -kTwoTo20 - 0.25
+
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(-1.04857625e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(-kTwoTo20), false, false, ""},
+		equalsTestCase{int(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{int32(-kTwoTo20), false, false, ""},
+		equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{int64(-kTwoTo20), false, false, ""},
+		equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex64(kExpected - 0.75), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 0.75), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeComplex128() {
+	const kExpected = -1 * (1 << 65)
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(-3.6893488147419103e+19+0i)", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := int64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroComplex128() {
+	matcher := Equals(complex128(0))
+	ExpectEq("(0+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of zero.
+		equalsTestCase{0.0, true, false, ""},
+		equalsTestCase{0 + 0i, true, false, ""},
+		equalsTestCase{int(0), true, false, ""},
+		equalsTestCase{int8(0), true, false, ""},
+		equalsTestCase{int16(0), true, false, ""},
+		equalsTestCase{int32(0), true, false, ""},
+		equalsTestCase{int64(0), true, false, ""},
+		equalsTestCase{uint(0), true, false, ""},
+		equalsTestCase{uint8(0), true, false, ""},
+		equalsTestCase{uint16(0), true, false, ""},
+		equalsTestCase{uint32(0), true, false, ""},
+		equalsTestCase{uint64(0), true, false, ""},
+		equalsTestCase{uintptr(0), true, false, ""},
+		equalsTestCase{float32(0), true, false, ""},
+		equalsTestCase{float64(0), true, false, ""},
+		equalsTestCase{complex64(0), true, false, ""},
+		equalsTestCase{complex128(0), true, false, ""},
+		equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(1), false, false, ""},
+		equalsTestCase{int64(-1), false, false, ""},
+		equalsTestCase{float32(1), false, false, ""},
+		equalsTestCase{float32(-1), false, false, ""},
+		equalsTestCase{float64(1), false, false, ""},
+		equalsTestCase{float64(-1), false, false, ""},
+		equalsTestCase{complex64(0 + 2i), false, false, ""},
+		equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralComplex128() {
+	const kExpected = 1 << 20
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(1.048576e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of 32769.
+		equalsTestCase{1048576.0, true, false, ""},
+		equalsTestCase{1048576.0 + 0i, true, false, ""},
+		equalsTestCase{int(kExpected), true, false, ""},
+		equalsTestCase{int32(kExpected), true, false, ""},
+		equalsTestCase{int64(kExpected), true, false, ""},
+		equalsTestCase{uint(kExpected), true, false, ""},
+		equalsTestCase{uint32(kExpected), true, false, ""},
+		equalsTestCase{uint64(kExpected), true, false, ""},
+		equalsTestCase{uintptr(kExpected), true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+		equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(kExpected + 1), false, false, ""},
+		equalsTestCase{int32(kExpected + 1), false, false, ""},
+		equalsTestCase{int64(kExpected + 1), false, false, ""},
+		equalsTestCase{uint(kExpected + 1), false, false, ""},
+		equalsTestCase{uint32(kExpected + 1), false, false, ""},
+		equalsTestCase{uint64(kExpected + 1), false, false, ""},
+		equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+		equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+		equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+		// Non-numeric types.
+		equalsTestCase{true, false, true, "which is not numeric"},
+		equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+		equalsTestCase{make(chan int), false, true, "which is not numeric"},
+		equalsTestCase{func() {}, false, true, "which is not numeric"},
+		equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+		equalsTestCase{&someInt, false, true, "which is not numeric"},
+		equalsTestCase{[]int{}, false, true, "which is not numeric"},
+		equalsTestCase{"taco", false, true, "which is not numeric"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralComplex128() {
+	const kTwoTo20 = 1 << 20
+	const kExpected = kTwoTo20 + 0.25
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(1.04857625e+06+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int64(kTwoTo20), false, false, ""},
+		equalsTestCase{int64(kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{uint64(kTwoTo20), false, false, ""},
+		equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""},
+		equalsTestCase{float32(kExpected - 1), false, false, ""},
+		equalsTestCase{float32(kExpected + 1), false, false, ""},
+		equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+		equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1), false, false, ""},
+		equalsTestCase{complex64(kExpected - 1i), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1), false, false, ""},
+		equalsTestCase{complex128(kExpected - 1i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveComplex128() {
+	const kExpected = 1 << 65
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(3.6893488147419103e+19+0i)", matcher.Description())
+
+	floatExpected := float64(kExpected)
+	castedInt := uint64(floatExpected)
+
+	cases := []equalsTestCase{
+		// Equal values of numeric type.
+		equalsTestCase{kExpected + 0i, true, false, ""},
+		equalsTestCase{float32(kExpected), true, false, ""},
+		equalsTestCase{float64(kExpected), true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{castedInt, false, false, ""},
+		equalsTestCase{int64(0), false, false, ""},
+		equalsTestCase{int64(math.MinInt64), false, false, ""},
+		equalsTestCase{int64(math.MaxInt64), false, false, ""},
+		equalsTestCase{uint64(0), false, false, ""},
+		equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+		equalsTestCase{float32(kExpected / 2), false, false, ""},
+		equalsTestCase{float64(kExpected / 2), false, false, ""},
+		equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex128AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := Equals(complex128(kTwoTo54 + 1))
+	ExpectEq("(1.8014398509481984e+16+0i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Integers.
+		equalsTestCase{int64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+		// Double-precision floating point.
+		equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+		equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+		equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+		equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex128WithNonZeroImaginaryPart() {
+	const kRealPart = 17
+	const kImagPart = 0.25i
+	const kExpected = kRealPart + kImagPart
+	matcher := Equals(complex128(kExpected))
+	ExpectEq("(17+0.25i)", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Various types of the expected value.
+		equalsTestCase{kExpected, true, false, ""},
+		equalsTestCase{kRealPart + kImagPart, true, false, ""},
+		equalsTestCase{complex64(kExpected), true, false, ""},
+		equalsTestCase{complex128(kExpected), true, false, ""},
+
+		// Non-equal values of numeric type.
+		equalsTestCase{int(kRealPart), false, false, ""},
+		equalsTestCase{int8(kRealPart), false, false, ""},
+		equalsTestCase{int16(kRealPart), false, false, ""},
+		equalsTestCase{int32(kRealPart), false, false, ""},
+		equalsTestCase{int64(kRealPart), false, false, ""},
+		equalsTestCase{uint(kRealPart), false, false, ""},
+		equalsTestCase{uint8(kRealPart), false, false, ""},
+		equalsTestCase{uint16(kRealPart), false, false, ""},
+		equalsTestCase{uint32(kRealPart), false, false, ""},
+		equalsTestCase{uint64(kRealPart), false, false, ""},
+		equalsTestCase{float32(kRealPart), false, false, ""},
+		equalsTestCase{float64(kRealPart), false, false, ""},
+		equalsTestCase{complex64(kRealPart), false, false, ""},
+		equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""},
+		equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""},
+		equalsTestCase{complex128(kRealPart), false, false, ""},
+		equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""},
+		equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Arrays
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) ArrayOfComparableType() {
+	expected := [3]uint{17, 19, 23}
+
+	matcher := Equals(expected)
+	ExpectEq("[17 19 23]", matcher.Description())
+
+	// To defeat constant de-duping by the compiler.
+	makeArray := func(i, j, k uint) [3]uint { return [3]uint{i, j, k} }
+
+	type arrayAlias [3]uint
+	type uintAlias uint
+
+	cases := []equalsTestCase{
+		// Correct types, equal.
+		equalsTestCase{expected, true, false, ""},
+		equalsTestCase{[3]uint{17, 19, 23}, true, false, ""},
+		equalsTestCase{makeArray(17, 19, 23), true, false, ""},
+
+		// Correct types, not equal.
+		equalsTestCase{[3]uint{0, 0, 0}, false, false, ""},
+		equalsTestCase{[3]uint{18, 19, 23}, false, false, ""},
+		equalsTestCase{[3]uint{17, 20, 23}, false, false, ""},
+		equalsTestCase{[3]uint{17, 19, 22}, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not [3]uint"},
+		equalsTestCase{bool(false), false, true, "which is not [3]uint"},
+		equalsTestCase{int(0), false, true, "which is not [3]uint"},
+		equalsTestCase{int8(0), false, true, "which is not [3]uint"},
+		equalsTestCase{int16(0), false, true, "which is not [3]uint"},
+		equalsTestCase{int32(0), false, true, "which is not [3]uint"},
+		equalsTestCase{int64(0), false, true, "which is not [3]uint"},
+		equalsTestCase{uint(0), false, true, "which is not [3]uint"},
+		equalsTestCase{uint8(0), false, true, "which is not [3]uint"},
+		equalsTestCase{uint16(0), false, true, "which is not [3]uint"},
+		equalsTestCase{uint32(0), false, true, "which is not [3]uint"},
+		equalsTestCase{uint64(0), false, true, "which is not [3]uint"},
+		equalsTestCase{true, false, true, "which is not [3]uint"},
+		equalsTestCase{[...]int{}, false, true, "which is not [3]uint"},
+		equalsTestCase{func() {}, false, true, "which is not [3]uint"},
+		equalsTestCase{map[int]int{}, false, true, "which is not [3]uint"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not [3]uint"},
+		equalsTestCase{[2]uint{17, 19}, false, true, "which is not [3]uint"},
+		equalsTestCase{[4]uint{17, 19, 23, 0}, false, true, "which is not [3]uint"},
+		equalsTestCase{arrayAlias{17, 19, 23}, false, true, "which is not [3]uint"},
+		equalsTestCase{[3]uintAlias{17, 19, 23}, false, true, "which is not [3]uint"},
+		equalsTestCase{[3]int32{17, 19, 23}, false, true, "which is not [3]uint"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ArrayOfNonComparableType() {
+	type nonComparableArray [2]map[string]string
+	f := func() {
+		ExpectEq(nonComparableArray{}, nonComparableArray{})
+	}
+
+	ExpectThat(f, Panics(MatchesRegexp("uncomparable.*nonComparableArray")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// chan
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilChan() {
+	var nilChan1 chan int
+	var nilChan2 chan int
+	var nilChan3 chan uint
+	var nonNilChan1 chan int = make(chan int)
+	var nonNilChan2 chan uint = make(chan uint)
+
+	matcher := Equals(nilChan1)
+	ExpectEq("<nil>", matcher.Description())
+
+	cases := []equalsTestCase{
+		// int channels
+		equalsTestCase{nilChan1, true, false, ""},
+		equalsTestCase{nilChan2, true, false, ""},
+		equalsTestCase{nonNilChan1, false, false, ""},
+
+		// uint channels
+		equalsTestCase{nilChan3, false, true, "which is not a chan int"},
+		equalsTestCase{nonNilChan2, false, true, "which is not a chan int"},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a chan int"},
+		equalsTestCase{bool(false), false, true, "which is not a chan int"},
+		equalsTestCase{int(0), false, true, "which is not a chan int"},
+		equalsTestCase{int8(0), false, true, "which is not a chan int"},
+		equalsTestCase{int16(0), false, true, "which is not a chan int"},
+		equalsTestCase{int32(0), false, true, "which is not a chan int"},
+		equalsTestCase{int64(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint8(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint16(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint32(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint64(0), false, true, "which is not a chan int"},
+		equalsTestCase{true, false, true, "which is not a chan int"},
+		equalsTestCase{[...]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{func() {}, false, true, "which is not a chan int"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{&someInt, false, true, "which is not a chan int"},
+		equalsTestCase{[]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{"taco", false, true, "which is not a chan int"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilChan() {
+	var nilChan1 chan int
+	var nilChan2 chan uint
+	var nonNilChan1 chan int = make(chan int)
+	var nonNilChan2 chan int = make(chan int)
+	var nonNilChan3 chan uint = make(chan uint)
+
+	matcher := Equals(nonNilChan1)
+	ExpectEq(fmt.Sprintf("%v", nonNilChan1), matcher.Description())
+
+	cases := []equalsTestCase{
+		// int channels
+		equalsTestCase{nonNilChan1, true, false, ""},
+		equalsTestCase{nonNilChan2, false, false, ""},
+		equalsTestCase{nilChan1, false, false, ""},
+
+		// uint channels
+		equalsTestCase{nilChan2, false, true, "which is not a chan int"},
+		equalsTestCase{nonNilChan3, false, true, "which is not a chan int"},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a chan int"},
+		equalsTestCase{bool(false), false, true, "which is not a chan int"},
+		equalsTestCase{int(0), false, true, "which is not a chan int"},
+		equalsTestCase{int8(0), false, true, "which is not a chan int"},
+		equalsTestCase{int16(0), false, true, "which is not a chan int"},
+		equalsTestCase{int32(0), false, true, "which is not a chan int"},
+		equalsTestCase{int64(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint8(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint16(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint32(0), false, true, "which is not a chan int"},
+		equalsTestCase{uint64(0), false, true, "which is not a chan int"},
+		equalsTestCase{true, false, true, "which is not a chan int"},
+		equalsTestCase{[...]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{func() {}, false, true, "which is not a chan int"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{&someInt, false, true, "which is not a chan int"},
+		equalsTestCase{[]int{}, false, true, "which is not a chan int"},
+		equalsTestCase{"taco", false, true, "which is not a chan int"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ChanDirection() {
+	var chan1 chan<- int
+	var chan2 <-chan int
+	var chan3 chan int
+
+	matcher := Equals(chan1)
+	ExpectEq(fmt.Sprintf("%v", chan1), matcher.Description())
+
+	cases := []equalsTestCase{
+		equalsTestCase{chan1, true, false, ""},
+		equalsTestCase{chan2, false, true, "which is not a chan<- int"},
+		equalsTestCase{chan3, false, true, "which is not a chan<- int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// func
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) Functions() {
+	func1 := func() {}
+	func2 := func() {}
+	func3 := func(x int) {}
+
+	matcher := Equals(func1)
+	ExpectEq(fmt.Sprintf("%v", func1), matcher.Description())
+
+	cases := []equalsTestCase{
+		// Functions.
+		equalsTestCase{func1, true, false, ""},
+		equalsTestCase{func2, false, false, ""},
+		equalsTestCase{func3, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a function"},
+		equalsTestCase{bool(false), false, true, "which is not a function"},
+		equalsTestCase{int(0), false, true, "which is not a function"},
+		equalsTestCase{int8(0), false, true, "which is not a function"},
+		equalsTestCase{int16(0), false, true, "which is not a function"},
+		equalsTestCase{int32(0), false, true, "which is not a function"},
+		equalsTestCase{int64(0), false, true, "which is not a function"},
+		equalsTestCase{uint(0), false, true, "which is not a function"},
+		equalsTestCase{uint8(0), false, true, "which is not a function"},
+		equalsTestCase{uint16(0), false, true, "which is not a function"},
+		equalsTestCase{uint32(0), false, true, "which is not a function"},
+		equalsTestCase{uint64(0), false, true, "which is not a function"},
+		equalsTestCase{true, false, true, "which is not a function"},
+		equalsTestCase{[...]int{}, false, true, "which is not a function"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a function"},
+		equalsTestCase{&someInt, false, true, "which is not a function"},
+		equalsTestCase{[]int{}, false, true, "which is not a function"},
+		equalsTestCase{"taco", false, true, "which is not a function"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a function"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// map
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilMap() {
+	var nilMap1 map[int]int
+	var nilMap2 map[int]int
+	var nilMap3 map[int]uint
+	var nonNilMap1 map[int]int = make(map[int]int)
+	var nonNilMap2 map[int]uint = make(map[int]uint)
+
+	matcher := Equals(nilMap1)
+	ExpectEq("map[]", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nilMap1, true, false, ""},
+		equalsTestCase{nilMap2, true, false, ""},
+		equalsTestCase{nilMap3, true, false, ""},
+		equalsTestCase{nonNilMap1, false, false, ""},
+		equalsTestCase{nonNilMap2, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a map"},
+		equalsTestCase{bool(false), false, true, "which is not a map"},
+		equalsTestCase{int(0), false, true, "which is not a map"},
+		equalsTestCase{int8(0), false, true, "which is not a map"},
+		equalsTestCase{int16(0), false, true, "which is not a map"},
+		equalsTestCase{int32(0), false, true, "which is not a map"},
+		equalsTestCase{int64(0), false, true, "which is not a map"},
+		equalsTestCase{uint(0), false, true, "which is not a map"},
+		equalsTestCase{uint8(0), false, true, "which is not a map"},
+		equalsTestCase{uint16(0), false, true, "which is not a map"},
+		equalsTestCase{uint32(0), false, true, "which is not a map"},
+		equalsTestCase{uint64(0), false, true, "which is not a map"},
+		equalsTestCase{true, false, true, "which is not a map"},
+		equalsTestCase{[...]int{}, false, true, "which is not a map"},
+		equalsTestCase{func() {}, false, true, "which is not a map"},
+		equalsTestCase{&someInt, false, true, "which is not a map"},
+		equalsTestCase{[]int{}, false, true, "which is not a map"},
+		equalsTestCase{"taco", false, true, "which is not a map"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a map"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilMap() {
+	var nilMap1 map[int]int
+	var nilMap2 map[int]uint
+	var nonNilMap1 map[int]int = make(map[int]int)
+	var nonNilMap2 map[int]int = make(map[int]int)
+	var nonNilMap3 map[int]uint = make(map[int]uint)
+
+	matcher := Equals(nonNilMap1)
+	ExpectEq("map[]", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nonNilMap1, true, false, ""},
+		equalsTestCase{nonNilMap2, false, false, ""},
+		equalsTestCase{nonNilMap3, false, false, ""},
+		equalsTestCase{nilMap1, false, false, ""},
+		equalsTestCase{nilMap2, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a map"},
+		equalsTestCase{bool(false), false, true, "which is not a map"},
+		equalsTestCase{int(0), false, true, "which is not a map"},
+		equalsTestCase{int8(0), false, true, "which is not a map"},
+		equalsTestCase{int16(0), false, true, "which is not a map"},
+		equalsTestCase{int32(0), false, true, "which is not a map"},
+		equalsTestCase{int64(0), false, true, "which is not a map"},
+		equalsTestCase{uint(0), false, true, "which is not a map"},
+		equalsTestCase{uint8(0), false, true, "which is not a map"},
+		equalsTestCase{uint16(0), false, true, "which is not a map"},
+		equalsTestCase{uint32(0), false, true, "which is not a map"},
+		equalsTestCase{uint64(0), false, true, "which is not a map"},
+		equalsTestCase{true, false, true, "which is not a map"},
+		equalsTestCase{[...]int{}, false, true, "which is not a map"},
+		equalsTestCase{func() {}, false, true, "which is not a map"},
+		equalsTestCase{&someInt, false, true, "which is not a map"},
+		equalsTestCase{[]int{}, false, true, "which is not a map"},
+		equalsTestCase{"taco", false, true, "which is not a map"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a map"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Pointers
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilPointer() {
+	var someInt int = 17
+	var someUint uint = 17
+
+	var nilInt1 *int
+	var nilInt2 *int
+	var nilUint *uint
+	var nonNilInt *int = &someInt
+	var nonNilUint *uint = &someUint
+
+	matcher := Equals(nilInt1)
+	ExpectEq("<nil>", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nilInt1, true, false, ""},
+		equalsTestCase{nilInt2, true, false, ""},
+		equalsTestCase{nonNilInt, false, false, ""},
+
+		// Incorrect type.
+		equalsTestCase{nilUint, false, true, "which is not a *int"},
+		equalsTestCase{nonNilUint, false, true, "which is not a *int"},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a *int"},
+		equalsTestCase{bool(false), false, true, "which is not a *int"},
+		equalsTestCase{int(0), false, true, "which is not a *int"},
+		equalsTestCase{int8(0), false, true, "which is not a *int"},
+		equalsTestCase{int16(0), false, true, "which is not a *int"},
+		equalsTestCase{int32(0), false, true, "which is not a *int"},
+		equalsTestCase{int64(0), false, true, "which is not a *int"},
+		equalsTestCase{uint(0), false, true, "which is not a *int"},
+		equalsTestCase{uint8(0), false, true, "which is not a *int"},
+		equalsTestCase{uint16(0), false, true, "which is not a *int"},
+		equalsTestCase{uint32(0), false, true, "which is not a *int"},
+		equalsTestCase{uint64(0), false, true, "which is not a *int"},
+		equalsTestCase{true, false, true, "which is not a *int"},
+		equalsTestCase{[...]int{}, false, true, "which is not a *int"},
+		equalsTestCase{func() {}, false, true, "which is not a *int"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a *int"},
+		equalsTestCase{[]int{}, false, true, "which is not a *int"},
+		equalsTestCase{"taco", false, true, "which is not a *int"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilPointer() {
+	var someInt int = 17
+	var someOtherInt int = 17
+	var someUint uint = 17
+
+	var nilInt *int
+	var nilUint *uint
+	var nonNilInt1 *int = &someInt
+	var nonNilInt2 *int = &someOtherInt
+	var nonNilUint *uint = &someUint
+
+	matcher := Equals(nonNilInt1)
+	ExpectEq(fmt.Sprintf("%v", nonNilInt1), matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nonNilInt1, true, false, ""},
+		equalsTestCase{nonNilInt2, false, false, ""},
+		equalsTestCase{nilInt, false, false, ""},
+
+		// Incorrect type.
+		equalsTestCase{nilUint, false, true, "which is not a *int"},
+		equalsTestCase{nonNilUint, false, true, "which is not a *int"},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a *int"},
+		equalsTestCase{bool(false), false, true, "which is not a *int"},
+		equalsTestCase{int(0), false, true, "which is not a *int"},
+		equalsTestCase{int8(0), false, true, "which is not a *int"},
+		equalsTestCase{int16(0), false, true, "which is not a *int"},
+		equalsTestCase{int32(0), false, true, "which is not a *int"},
+		equalsTestCase{int64(0), false, true, "which is not a *int"},
+		equalsTestCase{uint(0), false, true, "which is not a *int"},
+		equalsTestCase{uint8(0), false, true, "which is not a *int"},
+		equalsTestCase{uint16(0), false, true, "which is not a *int"},
+		equalsTestCase{uint32(0), false, true, "which is not a *int"},
+		equalsTestCase{uint64(0), false, true, "which is not a *int"},
+		equalsTestCase{true, false, true, "which is not a *int"},
+		equalsTestCase{[...]int{}, false, true, "which is not a *int"},
+		equalsTestCase{func() {}, false, true, "which is not a *int"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a *int"},
+		equalsTestCase{[]int{}, false, true, "which is not a *int"},
+		equalsTestCase{"taco", false, true, "which is not a *int"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Slices
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilSlice() {
+	var nilInt1 []int
+	var nilInt2 []int
+	var nilUint []uint
+
+	var nonNilInt []int = make([]int, 0)
+	var nonNilUint []uint = make([]uint, 0)
+
+	matcher := Equals(nilInt1)
+	ExpectEq("[]", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nilInt1, true, false, ""},
+		equalsTestCase{nilInt2, true, false, ""},
+		equalsTestCase{nonNilInt, false, false, ""},
+
+		// Incorrect type.
+		equalsTestCase{nilUint, false, true, "which is not a []int"},
+		equalsTestCase{nonNilUint, false, true, "which is not a []int"},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a []int"},
+		equalsTestCase{bool(false), false, true, "which is not a []int"},
+		equalsTestCase{int(0), false, true, "which is not a []int"},
+		equalsTestCase{int8(0), false, true, "which is not a []int"},
+		equalsTestCase{int16(0), false, true, "which is not a []int"},
+		equalsTestCase{int32(0), false, true, "which is not a []int"},
+		equalsTestCase{int64(0), false, true, "which is not a []int"},
+		equalsTestCase{uint(0), false, true, "which is not a []int"},
+		equalsTestCase{uint8(0), false, true, "which is not a []int"},
+		equalsTestCase{uint16(0), false, true, "which is not a []int"},
+		equalsTestCase{uint32(0), false, true, "which is not a []int"},
+		equalsTestCase{uint64(0), false, true, "which is not a []int"},
+		equalsTestCase{true, false, true, "which is not a []int"},
+		equalsTestCase{[...]int{}, false, true, "which is not a []int"},
+		equalsTestCase{func() {}, false, true, "which is not a []int"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a []int"},
+		equalsTestCase{"taco", false, true, "which is not a []int"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a []int"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilSlice() {
+	nonNil := make([]int, 0)
+	f := func() { Equals(nonNil) }
+	ExpectThat(f, Panics(HasSubstr("non-nil slice")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// string
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) String() {
+	partial := "taco"
+	expected := fmt.Sprintf("%s%d", partial, 1)
+
+	matcher := Equals(expected)
+	ExpectEq("taco1", matcher.Description())
+
+	type stringAlias string
+
+	cases := []equalsTestCase{
+		// Correct types.
+		equalsTestCase{"taco1", true, false, ""},
+		equalsTestCase{"taco" + "1", true, false, ""},
+		equalsTestCase{expected, true, false, ""},
+		equalsTestCase{stringAlias("taco1"), true, false, ""},
+
+		equalsTestCase{"", false, false, ""},
+		equalsTestCase{"taco", false, false, ""},
+		equalsTestCase{"taco1\x00", false, false, ""},
+		equalsTestCase{"taco2", false, false, ""},
+		equalsTestCase{stringAlias("taco2"), false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a string"},
+		equalsTestCase{bool(false), false, true, "which is not a string"},
+		equalsTestCase{int(0), false, true, "which is not a string"},
+		equalsTestCase{int8(0), false, true, "which is not a string"},
+		equalsTestCase{int16(0), false, true, "which is not a string"},
+		equalsTestCase{int32(0), false, true, "which is not a string"},
+		equalsTestCase{int64(0), false, true, "which is not a string"},
+		equalsTestCase{uint(0), false, true, "which is not a string"},
+		equalsTestCase{uint8(0), false, true, "which is not a string"},
+		equalsTestCase{uint16(0), false, true, "which is not a string"},
+		equalsTestCase{uint32(0), false, true, "which is not a string"},
+		equalsTestCase{uint64(0), false, true, "which is not a string"},
+		equalsTestCase{true, false, true, "which is not a string"},
+		equalsTestCase{[...]int{}, false, true, "which is not a string"},
+		equalsTestCase{func() {}, false, true, "which is not a string"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a string"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a string"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) StringAlias() {
+	type stringAlias string
+
+	matcher := Equals(stringAlias("taco"))
+	ExpectEq("taco", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct types.
+		equalsTestCase{stringAlias("taco"), true, false, ""},
+		equalsTestCase{"taco", true, false, ""},
+
+		equalsTestCase{"burrito", false, false, ""},
+		equalsTestCase{stringAlias("burrito"), false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a string"},
+		equalsTestCase{bool(false), false, true, "which is not a string"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// struct
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) Struct() {
+	type someStruct struct{ foo uint }
+	f := func() { Equals(someStruct{17}) }
+	ExpectThat(f, Panics(HasSubstr("unsupported kind struct")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// unsafe.Pointer
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilUnsafePointer() {
+	someInt := int(17)
+
+	var nilPtr1 unsafe.Pointer
+	var nilPtr2 unsafe.Pointer
+	var nonNilPtr unsafe.Pointer = unsafe.Pointer(&someInt)
+
+	matcher := Equals(nilPtr1)
+	ExpectEq("<nil>", matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nilPtr1, true, false, ""},
+		equalsTestCase{nilPtr2, true, false, ""},
+		equalsTestCase{nonNilPtr, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilUnsafePointer() {
+	someInt := int(17)
+	someOtherInt := int(17)
+
+	var nilPtr unsafe.Pointer
+	var nonNilPtr1 unsafe.Pointer = unsafe.Pointer(&someInt)
+	var nonNilPtr2 unsafe.Pointer = unsafe.Pointer(&someOtherInt)
+
+	matcher := Equals(nonNilPtr1)
+	ExpectEq(fmt.Sprintf("%v", nonNilPtr1), matcher.Description())
+
+	cases := []equalsTestCase{
+		// Correct type.
+		equalsTestCase{nonNilPtr1, true, false, ""},
+		equalsTestCase{nonNilPtr2, false, false, ""},
+		equalsTestCase{nilPtr, false, false, ""},
+
+		// Other types.
+		equalsTestCase{0, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"},
+		equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error.go
new file mode 100644
index 00000000000..8a078e36d86
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error.go
@@ -0,0 +1,51 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+// Error returns a matcher that matches non-nil values implementing the
+// built-in error interface for whom the return value of Error() matches the
+// supplied matcher.
+//
+// For example:
+//
+//     err := errors.New("taco burrito")
+//
+//     Error(Equals("taco burrito"))  // matches err
+//     Error(HasSubstr("taco"))       // matches err
+//     Error(HasSubstr("enchilada"))  // doesn't match err
+//
+func Error(m Matcher) Matcher {
+	return &errorMatcher{m}
+}
+
+type errorMatcher struct {
+	wrappedMatcher Matcher
+}
+
+func (m *errorMatcher) Description() string {
+	return "error " + m.wrappedMatcher.Description()
+}
+
+func (m *errorMatcher) Matches(c interface{}) error {
+	// Make sure that c is an error.
+	e, ok := c.(error)
+	if !ok {
+		return NewFatalError("which is not an error")
+	}
+
+	// Pass on the error text to the wrapped matcher.
+	return m.wrappedMatcher.Matches(e.Error())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error_test.go
new file mode 100644
index 00000000000..f92167cad1d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error_test.go
@@ -0,0 +1,92 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"errors"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type ErrorTest struct {
+	matcherCalled bool
+	suppliedCandidate interface{}
+	wrappedError error
+
+	matcher Matcher
+}
+
+func init() { RegisterTestSuite(&ErrorTest{}) }
+
+func (t *ErrorTest) SetUp(i *TestInfo) {
+	wrapped := &fakeMatcher{
+		func(c interface{}) error {
+			t.matcherCalled = true
+			t.suppliedCandidate = c
+			return t.wrappedError
+		},
+		"is foo",
+	}
+
+	t.matcher = Error(wrapped)
+}
+
+func isFatal(err error) bool {
+	_, isFatal := err.(*FatalError)
+	return isFatal
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *ErrorTest) Description() {
+	ExpectThat(t.matcher.Description(), Equals("error is foo"))
+}
+
+func (t *ErrorTest) CandidateIsNil() {
+	err := t.matcher.Matches(nil)
+
+	ExpectThat(t.matcherCalled, Equals(false))
+	ExpectThat(err.Error(), Equals("which is not an error"))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *ErrorTest) CandidateIsString() {
+	err := t.matcher.Matches("taco")
+
+	ExpectThat(t.matcherCalled, Equals(false))
+	ExpectThat(err.Error(), Equals("which is not an error"))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *ErrorTest) CallsWrappedMatcher() {
+	candidate := errors.New("taco")
+	t.matcher.Matches(candidate)
+
+	ExpectThat(t.matcherCalled, Equals(true))
+	ExpectThat(t.suppliedCandidate, Equals("taco"))
+}
+
+func (t *ErrorTest) ReturnsWrappedMatcherResult() {
+	t.wrappedError = errors.New("burrito")
+	err := t.matcher.Matches(errors.New(""))
+	ExpectThat(err, Equals(t.wrappedError))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go
new file mode 100644
index 00000000000..4b9d103a381
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go
@@ -0,0 +1,39 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// GreaterOrEqual returns a matcher that matches integer, floating point, or
+// strings values v such that v >= x. Comparison is not defined between numeric
+// and string types, but is defined between all integer and floating point
+// types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// GreaterOrEqual will panic.
+func GreaterOrEqual(x interface{}) Matcher {
+	desc := fmt.Sprintf("greater than or equal to %v", x)
+
+	// Special case: make it clear that strings are strings.
+	if reflect.TypeOf(x).Kind() == reflect.String {
+		desc = fmt.Sprintf("greater than or equal to \"%s\"", x)
+	}
+
+	return transformDescription(Not(LessThan(x)), desc)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go
new file mode 100644
index 00000000000..f5e29d1ce59
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go
@@ -0,0 +1,1101 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"math"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type GreaterOrEqualTest struct {
+}
+
+func init() { RegisterTestSuite(&GreaterOrEqualTest{}) }
+
+type geTestCase struct {
+	candidate      interface{}
+	expectedResult bool
+	shouldBeFatal  bool
+	expectedError  string
+}
+
+func (t *GreaterOrEqualTest) checkTestCases(matcher Matcher, cases []geTestCase) {
+	for i, c := range cases {
+		err := matcher.Matches(c.candidate)
+
+		ExpectThat(
+			(err == nil),
+			Equals(c.expectedResult),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		if err == nil {
+			continue
+		}
+
+		_, isFatal := err.(*FatalError)
+		ExpectEq(
+			c.shouldBeFatal,
+			isFatal,
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		ExpectThat(
+			err,
+			Error(Equals(c.expectedError)),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) IntegerCandidateBadTypes() {
+	matcher := GreaterOrEqual(int(-150))
+
+	cases := []geTestCase{
+		geTestCase{true, false, true, "which is not comparable"},
+		geTestCase{complex64(-151), false, true, "which is not comparable"},
+		geTestCase{complex128(-151), false, true, "which is not comparable"},
+		geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		geTestCase{make(chan int), false, true, "which is not comparable"},
+		geTestCase{func() {}, false, true, "which is not comparable"},
+		geTestCase{map[int]int{}, false, true, "which is not comparable"},
+		geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+		geTestCase{make([]int, 0), false, true, "which is not comparable"},
+		geTestCase{"-151", false, true, "which is not comparable"},
+		geTestCase{geTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) FloatCandidateBadTypes() {
+	matcher := GreaterOrEqual(float32(-150))
+
+	cases := []geTestCase{
+		geTestCase{true, false, true, "which is not comparable"},
+		geTestCase{complex64(-151), false, true, "which is not comparable"},
+		geTestCase{complex128(-151), false, true, "which is not comparable"},
+		geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		geTestCase{make(chan int), false, true, "which is not comparable"},
+		geTestCase{func() {}, false, true, "which is not comparable"},
+		geTestCase{map[int]int{}, false, true, "which is not comparable"},
+		geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+		geTestCase{make([]int, 0), false, true, "which is not comparable"},
+		geTestCase{"-151", false, true, "which is not comparable"},
+		geTestCase{geTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) StringCandidateBadTypes() {
+	matcher := GreaterOrEqual("17")
+
+	cases := []geTestCase{
+		geTestCase{true, false, true, "which is not comparable"},
+		geTestCase{int(0), false, true, "which is not comparable"},
+		geTestCase{int8(0), false, true, "which is not comparable"},
+		geTestCase{int16(0), false, true, "which is not comparable"},
+		geTestCase{int32(0), false, true, "which is not comparable"},
+		geTestCase{int64(0), false, true, "which is not comparable"},
+		geTestCase{uint(0), false, true, "which is not comparable"},
+		geTestCase{uint8(0), false, true, "which is not comparable"},
+		geTestCase{uint16(0), false, true, "which is not comparable"},
+		geTestCase{uint32(0), false, true, "which is not comparable"},
+		geTestCase{uint64(0), false, true, "which is not comparable"},
+		geTestCase{float32(0), false, true, "which is not comparable"},
+		geTestCase{float64(0), false, true, "which is not comparable"},
+		geTestCase{complex64(-151), false, true, "which is not comparable"},
+		geTestCase{complex128(-151), false, true, "which is not comparable"},
+		geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		geTestCase{make(chan int), false, true, "which is not comparable"},
+		geTestCase{func() {}, false, true, "which is not comparable"},
+		geTestCase{map[int]int{}, false, true, "which is not comparable"},
+		geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+		geTestCase{make([]int, 0), false, true, "which is not comparable"},
+		geTestCase{geTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) BadArgument() {
+	panicked := false
+
+	defer func() {
+		ExpectThat(panicked, Equals(true))
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	GreaterOrEqual(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) NegativeIntegerLiteral() {
+	matcher := GreaterOrEqual(-150)
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to -150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-(1 << 30), false, false, ""},
+		geTestCase{-151, false, false, ""},
+		geTestCase{-150, true, false, ""},
+		geTestCase{0, true, false, ""},
+		geTestCase{17, true, false, ""},
+
+		geTestCase{int(-(1 << 30)), false, false, ""},
+		geTestCase{int(-151), false, false, ""},
+		geTestCase{int(-150), true, false, ""},
+		geTestCase{int(0), true, false, ""},
+		geTestCase{int(17), true, false, ""},
+
+		geTestCase{int8(-127), true, false, ""},
+		geTestCase{int8(0), true, false, ""},
+		geTestCase{int8(17), true, false, ""},
+
+		geTestCase{int16(-(1 << 14)), false, false, ""},
+		geTestCase{int16(-151), false, false, ""},
+		geTestCase{int16(-150), true, false, ""},
+		geTestCase{int16(0), true, false, ""},
+		geTestCase{int16(17), true, false, ""},
+
+		geTestCase{int32(-(1 << 30)), false, false, ""},
+		geTestCase{int32(-151), false, false, ""},
+		geTestCase{int32(-150), true, false, ""},
+		geTestCase{int32(0), true, false, ""},
+		geTestCase{int32(17), true, false, ""},
+
+		geTestCase{int64(-(1 << 30)), false, false, ""},
+		geTestCase{int64(-151), false, false, ""},
+		geTestCase{int64(-150), true, false, ""},
+		geTestCase{int64(0), true, false, ""},
+		geTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint((1 << 32) - 151), true, false, ""},
+		geTestCase{uint(0), true, false, ""},
+		geTestCase{uint(17), true, false, ""},
+
+		geTestCase{uint8(0), true, false, ""},
+		geTestCase{uint8(17), true, false, ""},
+		geTestCase{uint8(253), true, false, ""},
+
+		geTestCase{uint16((1 << 16) - 151), true, false, ""},
+		geTestCase{uint16(0), true, false, ""},
+		geTestCase{uint16(17), true, false, ""},
+
+		geTestCase{uint32((1 << 32) - 151), true, false, ""},
+		geTestCase{uint32(0), true, false, ""},
+		geTestCase{uint32(17), true, false, ""},
+
+		geTestCase{uint64((1 << 64) - 151), true, false, ""},
+		geTestCase{uint64(0), true, false, ""},
+		geTestCase{uint64(17), true, false, ""},
+
+		geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+		geTestCase{uintptr(0), true, false, ""},
+		geTestCase{uintptr(17), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-(1 << 30)), false, false, ""},
+		geTestCase{float32(-151), false, false, ""},
+		geTestCase{float32(-150.1), false, false, ""},
+		geTestCase{float32(-150), true, false, ""},
+		geTestCase{float32(-149.9), true, false, ""},
+		geTestCase{float32(0), true, false, ""},
+		geTestCase{float32(17), true, false, ""},
+		geTestCase{float32(160), true, false, ""},
+
+		geTestCase{float64(-(1 << 30)), false, false, ""},
+		geTestCase{float64(-151), false, false, ""},
+		geTestCase{float64(-150.1), false, false, ""},
+		geTestCase{float64(-150), true, false, ""},
+		geTestCase{float64(-149.9), true, false, ""},
+		geTestCase{float64(0), true, false, ""},
+		geTestCase{float64(17), true, false, ""},
+		geTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) ZeroIntegerLiteral() {
+	matcher := GreaterOrEqual(0)
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 0"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-(1 << 30), false, false, ""},
+		geTestCase{-1, false, false, ""},
+		geTestCase{0, true, false, ""},
+		geTestCase{1, true, false, ""},
+		geTestCase{17, true, false, ""},
+		geTestCase{(1 << 30), true, false, ""},
+
+		geTestCase{int(-(1 << 30)), false, false, ""},
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(0), true, false, ""},
+		geTestCase{int(1), true, false, ""},
+		geTestCase{int(17), true, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(0), true, false, ""},
+		geTestCase{int8(1), true, false, ""},
+
+		geTestCase{int16(-(1 << 14)), false, false, ""},
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(0), true, false, ""},
+		geTestCase{int16(1), true, false, ""},
+		geTestCase{int16(17), true, false, ""},
+
+		geTestCase{int32(-(1 << 30)), false, false, ""},
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(0), true, false, ""},
+		geTestCase{int32(1), true, false, ""},
+		geTestCase{int32(17), true, false, ""},
+
+		geTestCase{int64(-(1 << 30)), false, false, ""},
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(0), true, false, ""},
+		geTestCase{int64(1), true, false, ""},
+		geTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint((1 << 32) - 1), true, false, ""},
+		geTestCase{uint(0), true, false, ""},
+		geTestCase{uint(17), true, false, ""},
+
+		geTestCase{uint8(0), true, false, ""},
+		geTestCase{uint8(17), true, false, ""},
+		geTestCase{uint8(253), true, false, ""},
+
+		geTestCase{uint16((1 << 16) - 1), true, false, ""},
+		geTestCase{uint16(0), true, false, ""},
+		geTestCase{uint16(17), true, false, ""},
+
+		geTestCase{uint32((1 << 32) - 1), true, false, ""},
+		geTestCase{uint32(0), true, false, ""},
+		geTestCase{uint32(17), true, false, ""},
+
+		geTestCase{uint64((1 << 64) - 1), true, false, ""},
+		geTestCase{uint64(0), true, false, ""},
+		geTestCase{uint64(17), true, false, ""},
+
+		geTestCase{uintptr((1 << 64) - 1), true, false, ""},
+		geTestCase{uintptr(0), true, false, ""},
+		geTestCase{uintptr(17), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-(1 << 30)), false, false, ""},
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(-0.1), false, false, ""},
+		geTestCase{float32(-0.0), true, false, ""},
+		geTestCase{float32(0), true, false, ""},
+		geTestCase{float32(0.1), true, false, ""},
+		geTestCase{float32(17), true, false, ""},
+		geTestCase{float32(160), true, false, ""},
+
+		geTestCase{float64(-(1 << 30)), false, false, ""},
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(-0.1), false, false, ""},
+		geTestCase{float64(-0), true, false, ""},
+		geTestCase{float64(0), true, false, ""},
+		geTestCase{float64(17), true, false, ""},
+		geTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) PositiveIntegerLiteral() {
+	matcher := GreaterOrEqual(150)
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{149, false, false, ""},
+		geTestCase{150, true, false, ""},
+		geTestCase{151, true, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(149), false, false, ""},
+		geTestCase{int(150), true, false, ""},
+		geTestCase{int(151), true, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(0), false, false, ""},
+		geTestCase{int8(17), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(149), false, false, ""},
+		geTestCase{int16(150), true, false, ""},
+		geTestCase{int16(151), true, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(149), false, false, ""},
+		geTestCase{int32(150), true, false, ""},
+		geTestCase{int32(151), true, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(149), false, false, ""},
+		geTestCase{int64(150), true, false, ""},
+		geTestCase{int64(151), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(149), false, false, ""},
+		geTestCase{uint(150), true, false, ""},
+		geTestCase{uint(151), true, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(127), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(149), false, false, ""},
+		geTestCase{uint16(150), true, false, ""},
+		geTestCase{uint16(151), true, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(149), false, false, ""},
+		geTestCase{uint32(150), true, false, ""},
+		geTestCase{uint32(151), true, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(149), false, false, ""},
+		geTestCase{uint64(150), true, false, ""},
+		geTestCase{uint64(151), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(149), false, false, ""},
+		geTestCase{uintptr(150), true, false, ""},
+		geTestCase{uintptr(151), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(149), false, false, ""},
+		geTestCase{float32(149.9), false, false, ""},
+		geTestCase{float32(150), true, false, ""},
+		geTestCase{float32(150.1), true, false, ""},
+		geTestCase{float32(151), true, false, ""},
+
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(149), false, false, ""},
+		geTestCase{float64(149.9), false, false, ""},
+		geTestCase{float64(150), true, false, ""},
+		geTestCase{float64(150.1), true, false, ""},
+		geTestCase{float64(151), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) NegativeFloatLiteral() {
+	matcher := GreaterOrEqual(-150.1)
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to -150.1"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-(1 << 30), false, false, ""},
+		geTestCase{-151, false, false, ""},
+		geTestCase{-150, true, false, ""},
+		geTestCase{0, true, false, ""},
+		geTestCase{17, true, false, ""},
+
+		geTestCase{int(-(1 << 30)), false, false, ""},
+		geTestCase{int(-151), false, false, ""},
+		geTestCase{int(-150), true, false, ""},
+		geTestCase{int(0), true, false, ""},
+		geTestCase{int(17), true, false, ""},
+
+		geTestCase{int8(-127), true, false, ""},
+		geTestCase{int8(0), true, false, ""},
+		geTestCase{int8(17), true, false, ""},
+
+		geTestCase{int16(-(1 << 14)), false, false, ""},
+		geTestCase{int16(-151), false, false, ""},
+		geTestCase{int16(-150), true, false, ""},
+		geTestCase{int16(0), true, false, ""},
+		geTestCase{int16(17), true, false, ""},
+
+		geTestCase{int32(-(1 << 30)), false, false, ""},
+		geTestCase{int32(-151), false, false, ""},
+		geTestCase{int32(-150), true, false, ""},
+		geTestCase{int32(0), true, false, ""},
+		geTestCase{int32(17), true, false, ""},
+
+		geTestCase{int64(-(1 << 30)), false, false, ""},
+		geTestCase{int64(-151), false, false, ""},
+		geTestCase{int64(-150), true, false, ""},
+		geTestCase{int64(0), true, false, ""},
+		geTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint((1 << 32) - 151), true, false, ""},
+		geTestCase{uint(0), true, false, ""},
+		geTestCase{uint(17), true, false, ""},
+
+		geTestCase{uint8(0), true, false, ""},
+		geTestCase{uint8(17), true, false, ""},
+		geTestCase{uint8(253), true, false, ""},
+
+		geTestCase{uint16((1 << 16) - 151), true, false, ""},
+		geTestCase{uint16(0), true, false, ""},
+		geTestCase{uint16(17), true, false, ""},
+
+		geTestCase{uint32((1 << 32) - 151), true, false, ""},
+		geTestCase{uint32(0), true, false, ""},
+		geTestCase{uint32(17), true, false, ""},
+
+		geTestCase{uint64((1 << 64) - 151), true, false, ""},
+		geTestCase{uint64(0), true, false, ""},
+		geTestCase{uint64(17), true, false, ""},
+
+		geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+		geTestCase{uintptr(0), true, false, ""},
+		geTestCase{uintptr(17), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-(1 << 30)), false, false, ""},
+		geTestCase{float32(-151), false, false, ""},
+		geTestCase{float32(-150.2), false, false, ""},
+		geTestCase{float32(-150.1), true, false, ""},
+		geTestCase{float32(-150), true, false, ""},
+		geTestCase{float32(0), true, false, ""},
+		geTestCase{float32(17), true, false, ""},
+		geTestCase{float32(160), true, false, ""},
+
+		geTestCase{float64(-(1 << 30)), false, false, ""},
+		geTestCase{float64(-151), false, false, ""},
+		geTestCase{float64(-150.2), false, false, ""},
+		geTestCase{float64(-150.1), true, false, ""},
+		geTestCase{float64(-150), true, false, ""},
+		geTestCase{float64(0), true, false, ""},
+		geTestCase{float64(17), true, false, ""},
+		geTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) PositiveFloatLiteral() {
+	matcher := GreaterOrEqual(149.9)
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 149.9"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{149, false, false, ""},
+		geTestCase{150, true, false, ""},
+		geTestCase{151, true, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(149), false, false, ""},
+		geTestCase{int(150), true, false, ""},
+		geTestCase{int(151), true, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(0), false, false, ""},
+		geTestCase{int8(17), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(149), false, false, ""},
+		geTestCase{int16(150), true, false, ""},
+		geTestCase{int16(151), true, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(149), false, false, ""},
+		geTestCase{int32(150), true, false, ""},
+		geTestCase{int32(151), true, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(149), false, false, ""},
+		geTestCase{int64(150), true, false, ""},
+		geTestCase{int64(151), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(149), false, false, ""},
+		geTestCase{uint(150), true, false, ""},
+		geTestCase{uint(151), true, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(127), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(149), false, false, ""},
+		geTestCase{uint16(150), true, false, ""},
+		geTestCase{uint16(151), true, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(149), false, false, ""},
+		geTestCase{uint32(150), true, false, ""},
+		geTestCase{uint32(151), true, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(149), false, false, ""},
+		geTestCase{uint64(150), true, false, ""},
+		geTestCase{uint64(151), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(149), false, false, ""},
+		geTestCase{uintptr(150), true, false, ""},
+		geTestCase{uintptr(151), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(149), false, false, ""},
+		geTestCase{float32(149.8), false, false, ""},
+		geTestCase{float32(149.9), true, false, ""},
+		geTestCase{float32(150), true, false, ""},
+		geTestCase{float32(151), true, false, ""},
+
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(149), false, false, ""},
+		geTestCase{float64(149.8), false, false, ""},
+		geTestCase{float64(149.9), true, false, ""},
+		geTestCase{float64(150), true, false, ""},
+		geTestCase{float64(151), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterOrEqual(int64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{kTwoTo25 + 0, false, false, ""},
+		geTestCase{kTwoTo25 + 1, true, false, ""},
+		geTestCase{kTwoTo25 + 2, true, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(0), false, false, ""},
+		geTestCase{int16(32767), false, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(255), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(65535), false, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		geTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterOrEqual(int64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{1 << 30, false, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(math.MaxInt32), false, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(0), false, false, ""},
+		geTestCase{int16(32767), false, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(math.MaxInt32), false, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		geTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(math.MaxUint32), false, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(255), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(65535), false, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(math.MaxUint32), false, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		geTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
+		// Floating point.
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterOrEqual(uint64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{kTwoTo25 + 0, false, false, ""},
+		geTestCase{kTwoTo25 + 1, true, false, ""},
+		geTestCase{kTwoTo25 + 2, true, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(0), false, false, ""},
+		geTestCase{int16(32767), false, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(255), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(65535), false, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		geTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterOrEqual(uint64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{-1, false, false, ""},
+		geTestCase{1 << 30, false, false, ""},
+
+		geTestCase{int(-1), false, false, ""},
+		geTestCase{int(math.MaxInt32), false, false, ""},
+
+		geTestCase{int8(-1), false, false, ""},
+		geTestCase{int8(127), false, false, ""},
+
+		geTestCase{int16(-1), false, false, ""},
+		geTestCase{int16(0), false, false, ""},
+		geTestCase{int16(32767), false, false, ""},
+
+		geTestCase{int32(-1), false, false, ""},
+		geTestCase{int32(math.MaxInt32), false, false, ""},
+
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		geTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint(0), false, false, ""},
+		geTestCase{uint(math.MaxUint32), false, false, ""},
+
+		geTestCase{uint8(0), false, false, ""},
+		geTestCase{uint8(255), false, false, ""},
+
+		geTestCase{uint16(0), false, false, ""},
+		geTestCase{uint16(65535), false, false, ""},
+
+		geTestCase{uint32(0), false, false, ""},
+		geTestCase{uint32(math.MaxUint32), false, false, ""},
+
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		geTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+		geTestCase{uintptr(0), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+		geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
+		// Floating point.
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Float32AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterOrEqual(float32(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 3.3554432e+07"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo25 - 2), false, false, ""},
+		geTestCase{int64(kTwoTo25 - 1), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+		geTestCase{int64(kTwoTo25 + 3), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+		geTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+		geTestCase{uint64(kTwoTo25 + 3), true, false, ""},
+
+		// Floating point.
+		geTestCase{float32(-1), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Float64AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterOrEqual(float64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to 1.8014398509481984e+16"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		// Signed integers.
+		geTestCase{int64(-1), false, false, ""},
+		geTestCase{int64(kTwoTo54 - 2), false, false, ""},
+		geTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+		geTestCase{int64(kTwoTo54 + 3), true, false, ""},
+
+		// Unsigned integers.
+		geTestCase{uint64(0), false, false, ""},
+		geTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+		geTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+		geTestCase{uint64(kTwoTo54 + 3), true, false, ""},
+
+		// Floating point.
+		geTestCase{float64(-1), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) EmptyString() {
+	matcher := GreaterOrEqual("")
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to \"\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		geTestCase{"", true, false, ""},
+		geTestCase{"\x00", true, false, ""},
+		geTestCase{"a", true, false, ""},
+		geTestCase{"foo", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) SingleNullByte() {
+	matcher := GreaterOrEqual("\x00")
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to \"\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		geTestCase{"", false, false, ""},
+		geTestCase{"\x00", true, false, ""},
+		geTestCase{"a", true, false, ""},
+		geTestCase{"foo", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) LongerString() {
+	matcher := GreaterOrEqual("foo\x00")
+	desc := matcher.Description()
+	expectedDesc := "greater than or equal to \"foo\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []geTestCase{
+		geTestCase{"", false, false, ""},
+		geTestCase{"\x00", false, false, ""},
+		geTestCase{"bar", false, false, ""},
+		geTestCase{"foo", false, false, ""},
+		geTestCase{"foo\x00", true, false, ""},
+		geTestCase{"fooa", true, false, ""},
+		geTestCase{"qux", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go
new file mode 100644
index 00000000000..3eef32178f8
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go
@@ -0,0 +1,39 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// GreaterThan returns a matcher that matches integer, floating point, or
+// strings values v such that v > x. Comparison is not defined between numeric
+// and string types, but is defined between all integer and floating point
+// types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// GreaterThan will panic.
+func GreaterThan(x interface{}) Matcher {
+	desc := fmt.Sprintf("greater than %v", x)
+
+	// Special case: make it clear that strings are strings.
+	if reflect.TypeOf(x).Kind() == reflect.String {
+		desc = fmt.Sprintf("greater than \"%s\"", x)
+	}
+
+	return transformDescription(Not(LessOrEqual(x)), desc)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go
new file mode 100644
index 00000000000..bf70fe56633
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go
@@ -0,0 +1,1077 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"math"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type GreaterThanTest struct {
+}
+
+func init() { RegisterTestSuite(&GreaterThanTest{}) }
+
+type gtTestCase struct {
+	candidate      interface{}
+	expectedResult bool
+	shouldBeFatal  bool
+	expectedError  string
+}
+
+func (t *GreaterThanTest) checkTestCases(matcher Matcher, cases []gtTestCase) {
+	for i, c := range cases {
+		err := matcher.Matches(c.candidate)
+
+		ExpectThat(
+			(err == nil),
+			Equals(c.expectedResult),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		if err == nil {
+			continue
+		}
+
+		_, isFatal := err.(*FatalError)
+		ExpectEq(
+			c.shouldBeFatal,
+			isFatal,
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		ExpectThat(
+			err,
+			Error(Equals(c.expectedError)),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) IntegerCandidateBadTypes() {
+	matcher := GreaterThan(int(-150))
+
+	cases := []gtTestCase{
+		gtTestCase{true, false, true, "which is not comparable"},
+		gtTestCase{complex64(-151), false, true, "which is not comparable"},
+		gtTestCase{complex128(-151), false, true, "which is not comparable"},
+		gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		gtTestCase{make(chan int), false, true, "which is not comparable"},
+		gtTestCase{func() {}, false, true, "which is not comparable"},
+		gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+		gtTestCase{&gtTestCase{}, false, true, "which is not comparable"},
+		gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+		gtTestCase{"-151", false, true, "which is not comparable"},
+		gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) FloatCandidateBadTypes() {
+	matcher := GreaterThan(float32(-150))
+
+	cases := []gtTestCase{
+		gtTestCase{true, false, true, "which is not comparable"},
+		gtTestCase{complex64(-151), false, true, "which is not comparable"},
+		gtTestCase{complex128(-151), false, true, "which is not comparable"},
+		gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		gtTestCase{make(chan int), false, true, "which is not comparable"},
+		gtTestCase{func() {}, false, true, "which is not comparable"},
+		gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+		gtTestCase{&gtTestCase{}, false, true, "which is not comparable"},
+		gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+		gtTestCase{"-151", false, true, "which is not comparable"},
+		gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) StringCandidateBadTypes() {
+	matcher := GreaterThan("17")
+
+	cases := []gtTestCase{
+		gtTestCase{true, false, true, "which is not comparable"},
+		gtTestCase{int(0), false, true, "which is not comparable"},
+		gtTestCase{int8(0), false, true, "which is not comparable"},
+		gtTestCase{int16(0), false, true, "which is not comparable"},
+		gtTestCase{int32(0), false, true, "which is not comparable"},
+		gtTestCase{int64(0), false, true, "which is not comparable"},
+		gtTestCase{uint(0), false, true, "which is not comparable"},
+		gtTestCase{uint8(0), false, true, "which is not comparable"},
+		gtTestCase{uint16(0), false, true, "which is not comparable"},
+		gtTestCase{uint32(0), false, true, "which is not comparable"},
+		gtTestCase{uint64(0), false, true, "which is not comparable"},
+		gtTestCase{float32(0), false, true, "which is not comparable"},
+		gtTestCase{float64(0), false, true, "which is not comparable"},
+		gtTestCase{complex64(-151), false, true, "which is not comparable"},
+		gtTestCase{complex128(-151), false, true, "which is not comparable"},
+		gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		gtTestCase{make(chan int), false, true, "which is not comparable"},
+		gtTestCase{func() {}, false, true, "which is not comparable"},
+		gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+		gtTestCase{&gtTestCase{}, false, true, "which is not comparable"},
+		gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+		gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) BadArgument() {
+	panicked := false
+
+	defer func() {
+		ExpectThat(panicked, Equals(true))
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	GreaterThan(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) NegativeIntegerLiteral() {
+	matcher := GreaterThan(-150)
+	desc := matcher.Description()
+	expectedDesc := "greater than -150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-(1 << 30), false, false, ""},
+		gtTestCase{-151, false, false, ""},
+		gtTestCase{-150, false, false, ""},
+		gtTestCase{-149, true, false, ""},
+		gtTestCase{0, true, false, ""},
+		gtTestCase{17, true, false, ""},
+
+		gtTestCase{int(-(1 << 30)), false, false, ""},
+		gtTestCase{int(-151), false, false, ""},
+		gtTestCase{int(-150), false, false, ""},
+		gtTestCase{int(-149), true, false, ""},
+		gtTestCase{int(0), true, false, ""},
+		gtTestCase{int(17), true, false, ""},
+
+		gtTestCase{int8(-127), true, false, ""},
+		gtTestCase{int8(0), true, false, ""},
+		gtTestCase{int8(17), true, false, ""},
+
+		gtTestCase{int16(-(1 << 14)), false, false, ""},
+		gtTestCase{int16(-151), false, false, ""},
+		gtTestCase{int16(-150), false, false, ""},
+		gtTestCase{int16(-149), true, false, ""},
+		gtTestCase{int16(0), true, false, ""},
+		gtTestCase{int16(17), true, false, ""},
+
+		gtTestCase{int32(-(1 << 30)), false, false, ""},
+		gtTestCase{int32(-151), false, false, ""},
+		gtTestCase{int32(-150), false, false, ""},
+		gtTestCase{int32(-149), true, false, ""},
+		gtTestCase{int32(0), true, false, ""},
+		gtTestCase{int32(17), true, false, ""},
+
+		gtTestCase{int64(-(1 << 30)), false, false, ""},
+		gtTestCase{int64(-151), false, false, ""},
+		gtTestCase{int64(-150), false, false, ""},
+		gtTestCase{int64(-149), true, false, ""},
+		gtTestCase{int64(0), true, false, ""},
+		gtTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint((1 << 32) - 151), true, false, ""},
+		gtTestCase{uint(0), true, false, ""},
+		gtTestCase{uint(17), true, false, ""},
+
+		gtTestCase{uint8(0), true, false, ""},
+		gtTestCase{uint8(17), true, false, ""},
+		gtTestCase{uint8(253), true, false, ""},
+
+		gtTestCase{uint16((1 << 16) - 151), true, false, ""},
+		gtTestCase{uint16(0), true, false, ""},
+		gtTestCase{uint16(17), true, false, ""},
+
+		gtTestCase{uint32((1 << 32) - 151), true, false, ""},
+		gtTestCase{uint32(0), true, false, ""},
+		gtTestCase{uint32(17), true, false, ""},
+
+		gtTestCase{uint64((1 << 64) - 151), true, false, ""},
+		gtTestCase{uint64(0), true, false, ""},
+		gtTestCase{uint64(17), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-(1 << 30)), false, false, ""},
+		gtTestCase{float32(-151), false, false, ""},
+		gtTestCase{float32(-150.1), false, false, ""},
+		gtTestCase{float32(-150), false, false, ""},
+		gtTestCase{float32(-149.9), true, false, ""},
+		gtTestCase{float32(0), true, false, ""},
+		gtTestCase{float32(17), true, false, ""},
+		gtTestCase{float32(160), true, false, ""},
+
+		gtTestCase{float64(-(1 << 30)), false, false, ""},
+		gtTestCase{float64(-151), false, false, ""},
+		gtTestCase{float64(-150.1), false, false, ""},
+		gtTestCase{float64(-150), false, false, ""},
+		gtTestCase{float64(-149.9), true, false, ""},
+		gtTestCase{float64(0), true, false, ""},
+		gtTestCase{float64(17), true, false, ""},
+		gtTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) ZeroIntegerLiteral() {
+	matcher := GreaterThan(0)
+	desc := matcher.Description()
+	expectedDesc := "greater than 0"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-(1 << 30), false, false, ""},
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{0, false, false, ""},
+		gtTestCase{1, true, false, ""},
+		gtTestCase{17, true, false, ""},
+		gtTestCase{(1 << 30), true, false, ""},
+
+		gtTestCase{int(-(1 << 30)), false, false, ""},
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(0), false, false, ""},
+		gtTestCase{int(1), true, false, ""},
+		gtTestCase{int(17), true, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(0), false, false, ""},
+		gtTestCase{int8(1), true, false, ""},
+
+		gtTestCase{int16(-(1 << 14)), false, false, ""},
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(0), false, false, ""},
+		gtTestCase{int16(1), true, false, ""},
+		gtTestCase{int16(17), true, false, ""},
+
+		gtTestCase{int32(-(1 << 30)), false, false, ""},
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(0), false, false, ""},
+		gtTestCase{int32(1), true, false, ""},
+		gtTestCase{int32(17), true, false, ""},
+
+		gtTestCase{int64(-(1 << 30)), false, false, ""},
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(0), false, false, ""},
+		gtTestCase{int64(1), true, false, ""},
+		gtTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint((1 << 32) - 1), true, false, ""},
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(1), true, false, ""},
+		gtTestCase{uint(17), true, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(1), true, false, ""},
+		gtTestCase{uint8(17), true, false, ""},
+		gtTestCase{uint8(253), true, false, ""},
+
+		gtTestCase{uint16((1 << 16) - 1), true, false, ""},
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(1), true, false, ""},
+		gtTestCase{uint16(17), true, false, ""},
+
+		gtTestCase{uint32((1 << 32) - 1), true, false, ""},
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(1), true, false, ""},
+		gtTestCase{uint32(17), true, false, ""},
+
+		gtTestCase{uint64((1 << 64) - 1), true, false, ""},
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(1), true, false, ""},
+		gtTestCase{uint64(17), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-(1 << 30)), false, false, ""},
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(-0.1), false, false, ""},
+		gtTestCase{float32(-0.0), false, false, ""},
+		gtTestCase{float32(0), false, false, ""},
+		gtTestCase{float32(0.1), true, false, ""},
+		gtTestCase{float32(17), true, false, ""},
+		gtTestCase{float32(160), true, false, ""},
+
+		gtTestCase{float64(-(1 << 30)), false, false, ""},
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(-0.1), false, false, ""},
+		gtTestCase{float64(-0), false, false, ""},
+		gtTestCase{float64(0), false, false, ""},
+		gtTestCase{float64(0.1), true, false, ""},
+		gtTestCase{float64(17), true, false, ""},
+		gtTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) PositiveIntegerLiteral() {
+	matcher := GreaterThan(150)
+	desc := matcher.Description()
+	expectedDesc := "greater than 150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{149, false, false, ""},
+		gtTestCase{150, false, false, ""},
+		gtTestCase{151, true, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(149), false, false, ""},
+		gtTestCase{int(150), false, false, ""},
+		gtTestCase{int(151), true, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(0), false, false, ""},
+		gtTestCase{int8(17), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(149), false, false, ""},
+		gtTestCase{int16(150), false, false, ""},
+		gtTestCase{int16(151), true, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(149), false, false, ""},
+		gtTestCase{int32(150), false, false, ""},
+		gtTestCase{int32(151), true, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(149), false, false, ""},
+		gtTestCase{int64(150), false, false, ""},
+		gtTestCase{int64(151), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(149), false, false, ""},
+		gtTestCase{uint(150), false, false, ""},
+		gtTestCase{uint(151), true, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(127), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(149), false, false, ""},
+		gtTestCase{uint16(150), false, false, ""},
+		gtTestCase{uint16(151), true, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(149), false, false, ""},
+		gtTestCase{uint32(150), false, false, ""},
+		gtTestCase{uint32(151), true, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(149), false, false, ""},
+		gtTestCase{uint64(150), false, false, ""},
+		gtTestCase{uint64(151), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(149), false, false, ""},
+		gtTestCase{float32(149.9), false, false, ""},
+		gtTestCase{float32(150), false, false, ""},
+		gtTestCase{float32(150.1), true, false, ""},
+		gtTestCase{float32(151), true, false, ""},
+
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(149), false, false, ""},
+		gtTestCase{float64(149.9), false, false, ""},
+		gtTestCase{float64(150), false, false, ""},
+		gtTestCase{float64(150.1), true, false, ""},
+		gtTestCase{float64(151), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) NegativeFloatLiteral() {
+	matcher := GreaterThan(-150.1)
+	desc := matcher.Description()
+	expectedDesc := "greater than -150.1"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-(1 << 30), false, false, ""},
+		gtTestCase{-151, false, false, ""},
+		gtTestCase{-150.1, false, false, ""},
+		gtTestCase{-150, true, false, ""},
+		gtTestCase{-149, true, false, ""},
+		gtTestCase{0, true, false, ""},
+		gtTestCase{17, true, false, ""},
+
+		gtTestCase{int(-(1 << 30)), false, false, ""},
+		gtTestCase{int(-151), false, false, ""},
+		gtTestCase{int(-150), true, false, ""},
+		gtTestCase{int(-149), true, false, ""},
+		gtTestCase{int(0), true, false, ""},
+		gtTestCase{int(17), true, false, ""},
+
+		gtTestCase{int8(-127), true, false, ""},
+		gtTestCase{int8(0), true, false, ""},
+		gtTestCase{int8(17), true, false, ""},
+
+		gtTestCase{int16(-(1 << 14)), false, false, ""},
+		gtTestCase{int16(-151), false, false, ""},
+		gtTestCase{int16(-150), true, false, ""},
+		gtTestCase{int16(-149), true, false, ""},
+		gtTestCase{int16(0), true, false, ""},
+		gtTestCase{int16(17), true, false, ""},
+
+		gtTestCase{int32(-(1 << 30)), false, false, ""},
+		gtTestCase{int32(-151), false, false, ""},
+		gtTestCase{int32(-150), true, false, ""},
+		gtTestCase{int32(-149), true, false, ""},
+		gtTestCase{int32(0), true, false, ""},
+		gtTestCase{int32(17), true, false, ""},
+
+		gtTestCase{int64(-(1 << 30)), false, false, ""},
+		gtTestCase{int64(-151), false, false, ""},
+		gtTestCase{int64(-150), true, false, ""},
+		gtTestCase{int64(-149), true, false, ""},
+		gtTestCase{int64(0), true, false, ""},
+		gtTestCase{int64(17), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint((1 << 32) - 151), true, false, ""},
+		gtTestCase{uint(0), true, false, ""},
+		gtTestCase{uint(17), true, false, ""},
+
+		gtTestCase{uint8(0), true, false, ""},
+		gtTestCase{uint8(17), true, false, ""},
+		gtTestCase{uint8(253), true, false, ""},
+
+		gtTestCase{uint16((1 << 16) - 151), true, false, ""},
+		gtTestCase{uint16(0), true, false, ""},
+		gtTestCase{uint16(17), true, false, ""},
+
+		gtTestCase{uint32((1 << 32) - 151), true, false, ""},
+		gtTestCase{uint32(0), true, false, ""},
+		gtTestCase{uint32(17), true, false, ""},
+
+		gtTestCase{uint64((1 << 64) - 151), true, false, ""},
+		gtTestCase{uint64(0), true, false, ""},
+		gtTestCase{uint64(17), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-(1 << 30)), false, false, ""},
+		gtTestCase{float32(-151), false, false, ""},
+		gtTestCase{float32(-150.2), false, false, ""},
+		gtTestCase{float32(-150.1), false, false, ""},
+		gtTestCase{float32(-150), true, false, ""},
+		gtTestCase{float32(0), true, false, ""},
+		gtTestCase{float32(17), true, false, ""},
+		gtTestCase{float32(160), true, false, ""},
+
+		gtTestCase{float64(-(1 << 30)), false, false, ""},
+		gtTestCase{float64(-151), false, false, ""},
+		gtTestCase{float64(-150.2), false, false, ""},
+		gtTestCase{float64(-150.1), false, false, ""},
+		gtTestCase{float64(-150), true, false, ""},
+		gtTestCase{float64(0), true, false, ""},
+		gtTestCase{float64(17), true, false, ""},
+		gtTestCase{float64(160), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) PositiveFloatLiteral() {
+	matcher := GreaterThan(149.9)
+	desc := matcher.Description()
+	expectedDesc := "greater than 149.9"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{149, false, false, ""},
+		gtTestCase{149.9, false, false, ""},
+		gtTestCase{150, true, false, ""},
+		gtTestCase{151, true, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(149), false, false, ""},
+		gtTestCase{int(150), true, false, ""},
+		gtTestCase{int(151), true, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(0), false, false, ""},
+		gtTestCase{int8(17), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(149), false, false, ""},
+		gtTestCase{int16(150), true, false, ""},
+		gtTestCase{int16(151), true, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(149), false, false, ""},
+		gtTestCase{int32(150), true, false, ""},
+		gtTestCase{int32(151), true, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(149), false, false, ""},
+		gtTestCase{int64(150), true, false, ""},
+		gtTestCase{int64(151), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(149), false, false, ""},
+		gtTestCase{uint(150), true, false, ""},
+		gtTestCase{uint(151), true, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(127), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(149), false, false, ""},
+		gtTestCase{uint16(150), true, false, ""},
+		gtTestCase{uint16(151), true, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(149), false, false, ""},
+		gtTestCase{uint32(150), true, false, ""},
+		gtTestCase{uint32(151), true, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(149), false, false, ""},
+		gtTestCase{uint64(150), true, false, ""},
+		gtTestCase{uint64(151), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(149), false, false, ""},
+		gtTestCase{float32(149.8), false, false, ""},
+		gtTestCase{float32(149.9), false, false, ""},
+		gtTestCase{float32(150), true, false, ""},
+		gtTestCase{float32(151), true, false, ""},
+
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(149), false, false, ""},
+		gtTestCase{float64(149.8), false, false, ""},
+		gtTestCase{float64(149.9), false, false, ""},
+		gtTestCase{float64(150), true, false, ""},
+		gtTestCase{float64(151), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) Int64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterThan(int64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{kTwoTo25 + 0, false, false, ""},
+		gtTestCase{kTwoTo25 + 1, false, false, ""},
+		gtTestCase{kTwoTo25 + 2, true, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(0), false, false, ""},
+		gtTestCase{int16(32767), false, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(255), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(65535), false, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Int64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterThan(int64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{1 << 30, false, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(math.MaxInt32), false, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(0), false, false, ""},
+		gtTestCase{int16(32767), false, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(math.MaxInt32), false, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(math.MaxUint32), false, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(255), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(65535), false, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(math.MaxUint32), false, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterThan(uint64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{kTwoTo25 + 0, false, false, ""},
+		gtTestCase{kTwoTo25 + 1, false, false, ""},
+		gtTestCase{kTwoTo25 + 2, true, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(0), false, false, ""},
+		gtTestCase{int16(32767), false, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(255), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(65535), false, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterThan(uint64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{-1, false, false, ""},
+		gtTestCase{1 << 30, false, false, ""},
+
+		gtTestCase{int(-1), false, false, ""},
+		gtTestCase{int(math.MaxInt32), false, false, ""},
+
+		gtTestCase{int8(-1), false, false, ""},
+		gtTestCase{int8(127), false, false, ""},
+
+		gtTestCase{int16(-1), false, false, ""},
+		gtTestCase{int16(0), false, false, ""},
+		gtTestCase{int16(32767), false, false, ""},
+
+		gtTestCase{int32(-1), false, false, ""},
+		gtTestCase{int32(math.MaxInt32), false, false, ""},
+
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint(0), false, false, ""},
+		gtTestCase{uint(math.MaxUint32), false, false, ""},
+
+		gtTestCase{uint8(0), false, false, ""},
+		gtTestCase{uint8(255), false, false, ""},
+
+		gtTestCase{uint16(0), false, false, ""},
+		gtTestCase{uint16(65535), false, false, ""},
+
+		gtTestCase{uint32(0), false, false, ""},
+		gtTestCase{uint32(math.MaxUint32), false, false, ""},
+
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Float32AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := GreaterThan(float32(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 3.3554432e+07"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{int64(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{int64(kTwoTo25 + 3), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{uint64(kTwoTo25 + 3), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float32(-1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Float64AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := GreaterThan(float64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "greater than 1.8014398509481984e+16"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		// Signed integers.
+		gtTestCase{int64(-1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 - 2), false, false, ""},
+		gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 2), false, false, ""},
+		gtTestCase{int64(kTwoTo54 + 3), true, false, ""},
+
+		// Unsigned integers.
+		gtTestCase{uint64(0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+		gtTestCase{uint64(kTwoTo54 + 3), true, false, ""},
+
+		// Floating point.
+		gtTestCase{float64(-1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) EmptyString() {
+	matcher := GreaterThan("")
+	desc := matcher.Description()
+	expectedDesc := "greater than \"\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		gtTestCase{"", false, false, ""},
+		gtTestCase{"\x00", true, false, ""},
+		gtTestCase{"a", true, false, ""},
+		gtTestCase{"foo", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) SingleNullByte() {
+	matcher := GreaterThan("\x00")
+	desc := matcher.Description()
+	expectedDesc := "greater than \"\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		gtTestCase{"", false, false, ""},
+		gtTestCase{"\x00", false, false, ""},
+		gtTestCase{"\x00\x00", true, false, ""},
+		gtTestCase{"a", true, false, ""},
+		gtTestCase{"foo", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) LongerString() {
+	matcher := GreaterThan("foo\x00")
+	desc := matcher.Description()
+	expectedDesc := "greater than \"foo\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []gtTestCase{
+		gtTestCase{"", false, false, ""},
+		gtTestCase{"\x00", false, false, ""},
+		gtTestCase{"bar", false, false, ""},
+		gtTestCase{"foo", false, false, ""},
+		gtTestCase{"foo\x00", false, false, ""},
+		gtTestCase{"foo\x00\x00", true, false, ""},
+		gtTestCase{"fooa", true, false, ""},
+		gtTestCase{"qux", true, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go
new file mode 100644
index 00000000000..3b286f73218
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go
@@ -0,0 +1,37 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// HasSameTypeAs returns a matcher that matches values with exactly the same
+// type as the supplied prototype.
+func HasSameTypeAs(p interface{}) Matcher {
+	expected := reflect.TypeOf(p)
+	pred := func(c interface{}) error {
+		actual := reflect.TypeOf(c)
+		if actual != expected {
+			return fmt.Errorf("which has type %v", actual)
+		}
+
+		return nil
+	}
+
+	return NewMatcher(pred, fmt.Sprintf("has type %v", expected))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go
new file mode 100644
index 00000000000..a4a3e308aa3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go
@@ -0,0 +1,181 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"io"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestHasSameTypeAs(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Boilerplate
+////////////////////////////////////////////////////////////////////////
+
+type HasSameTypeAsTest struct {
+}
+
+func init() { RegisterTestSuite(&HasSameTypeAsTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *HasSameTypeAsTest) CandidateIsLiteralNil() {
+	matcher := HasSameTypeAs(nil)
+	var err error
+
+	// Description
+	ExpectEq("has type <nil>", matcher.Description())
+
+	// Literal nil
+	err = matcher.Matches(nil)
+	ExpectEq(nil, err)
+
+	// nil in interface variable
+	var r io.Reader
+	err = matcher.Matches(r)
+	ExpectEq(nil, err)
+
+	// int
+	err = matcher.Matches(17)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type int")))
+
+	// string
+	err = matcher.Matches("")
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type string")))
+
+	// nil map
+	var m map[string]string
+	err = matcher.Matches(m)
+
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type map[string]string")))
+
+	// Non-nil map
+	m = make(map[string]string)
+	err = matcher.Matches(m)
+
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type map[string]string")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsNilMap() {
+	var m map[string]string
+	matcher := HasSameTypeAs(m)
+	var err error
+
+	// Description
+	ExpectEq("has type map[string]string", matcher.Description())
+
+	// nil map
+	m = nil
+	err = matcher.Matches(m)
+	ExpectEq(nil, err)
+
+	// Non-nil map
+	m = make(map[string]string)
+	err = matcher.Matches(m)
+	ExpectEq(nil, err)
+
+	// Literal nil
+	err = matcher.Matches(nil)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type <nil>")))
+
+	// int
+	err = matcher.Matches(17)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type int")))
+
+	// string
+	err = matcher.Matches("")
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type string")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsNilInInterfaceVariable() {
+	var r io.Reader
+	matcher := HasSameTypeAs(r)
+	var err error
+
+	// Description
+	ExpectEq("has type <nil>", matcher.Description())
+
+	// nil in interface variable
+	r = nil
+	err = matcher.Matches(r)
+	ExpectEq(nil, err)
+
+	// Literal nil
+	err = matcher.Matches(nil)
+	ExpectEq(nil, err)
+
+	// int
+	err = matcher.Matches(17)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type int")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsString() {
+	matcher := HasSameTypeAs("")
+	var err error
+
+	// Description
+	ExpectEq("has type string", matcher.Description())
+
+	// string
+	err = matcher.Matches("taco")
+	ExpectEq(nil, err)
+
+	// string alias
+	type Foo string
+	err = matcher.Matches(Foo("taco"))
+	ExpectThat(err, Error(MatchesRegexp("which has type .*Foo")))
+
+	// Literal nil
+	err = matcher.Matches(nil)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type <nil>")))
+
+	// int
+	err = matcher.Matches(17)
+	AssertNe(nil, err)
+	ExpectThat(err, Error(Equals("which has type int")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsStringAlias() {
+	type Foo string
+	matcher := HasSameTypeAs(Foo(""))
+	var err error
+
+	// Description
+	ExpectThat(matcher.Description(), MatchesRegexp("has type .*Foo"))
+
+	// string alias
+	err = matcher.Matches(Foo("taco"))
+	ExpectEq(nil, err)
+
+	// string
+	err = matcher.Matches("taco")
+	ExpectThat(err, Error(Equals("which has type string")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go
new file mode 100644
index 00000000000..bf5bd6ae6d3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go
@@ -0,0 +1,46 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// HasSubstr returns a matcher that matches strings containing s as a
+// substring.
+func HasSubstr(s string) Matcher {
+	return NewMatcher(
+		func(c interface{}) error { return hasSubstr(s, c) },
+		fmt.Sprintf("has substring \"%s\"", s))
+}
+
+func hasSubstr(needle string, c interface{}) error {
+	v := reflect.ValueOf(c)
+	if v.Kind() != reflect.String {
+		return NewFatalError("which is not a string")
+	}
+
+	// Perform the substring search.
+	haystack := v.String()
+	if strings.Contains(haystack, needle) {
+		return nil
+	}
+
+	return errors.New("")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go
new file mode 100644
index 00000000000..6fc913a2490
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go
@@ -0,0 +1,93 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type HasSubstrTest struct {
+
+}
+
+func init() { RegisterTestSuite(&HasSubstrTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *HasSubstrTest) Description() {
+	matcher := HasSubstr("taco")
+	ExpectThat(matcher.Description(), Equals("has substring \"taco\""))
+}
+
+func (t *HasSubstrTest) CandidateIsNil() {
+	matcher := HasSubstr("")
+	err := matcher.Matches(nil)
+
+	ExpectThat(err, Error(Equals("which is not a string")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *HasSubstrTest) CandidateIsInteger() {
+	matcher := HasSubstr("")
+	err := matcher.Matches(17)
+
+	ExpectThat(err, Error(Equals("which is not a string")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *HasSubstrTest) CandidateIsByteSlice() {
+	matcher := HasSubstr("")
+	err := matcher.Matches([]byte{17})
+
+	ExpectThat(err, Error(Equals("which is not a string")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *HasSubstrTest) CandidateDoesntHaveSubstring() {
+	matcher := HasSubstr("taco")
+	err := matcher.Matches("tac")
+
+	ExpectThat(err, Error(Equals("")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *HasSubstrTest) CandidateEqualsArg() {
+	matcher := HasSubstr("taco")
+	err := matcher.Matches("taco")
+
+	ExpectThat(err, Equals(nil))
+}
+
+func (t *HasSubstrTest) CandidateHasProperSubstring() {
+	matcher := HasSubstr("taco")
+	err := matcher.Matches("burritos and tacos")
+
+	ExpectThat(err, Equals(nil))
+}
+
+func (t *HasSubstrTest) EmptyStringIsAlwaysSubString() {
+	matcher := HasSubstr("")
+	err := matcher.Matches("asdf")
+
+	ExpectThat(err, Equals(nil))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go
new file mode 100644
index 00000000000..ae6460ed966
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go
@@ -0,0 +1,134 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Is the type comparable according to the definition here?
+//
+//     http://weekly.golang.org/doc/go_spec.html#Comparison_operators
+//
+func isComparable(t reflect.Type) bool {
+	switch t.Kind() {
+	case reflect.Array:
+		return isComparable(t.Elem())
+
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			if !isComparable(t.Field(i).Type) {
+				return false
+			}
+		}
+
+		return true
+
+	case reflect.Slice, reflect.Map, reflect.Func:
+		return false
+	}
+
+	return true
+}
+
+// Should the supplied type be allowed as an argument to IdenticalTo?
+func isLegalForIdenticalTo(t reflect.Type) (bool, error) {
+	// Allow the zero type.
+	if t == nil {
+		return true, nil
+	}
+
+	// Reference types are always okay; we compare pointers.
+	switch t.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+		return true, nil
+	}
+
+	// Reject other non-comparable types.
+	if !isComparable(t) {
+		return false, errors.New(fmt.Sprintf("%v is not comparable", t))
+	}
+
+	return true, nil
+}
+
+// IdenticalTo(x) returns a matcher that matches values v with type identical
+// to x such that:
+//
+//  1. If v and x are of a reference type (slice, map, function, channel), then
+//     they are either both nil or are references to the same object.
+//
+//  2. Otherwise, if v and x are not of a reference type but have a valid type,
+//     then v == x.
+//
+// If v and x are both the invalid type (which results from the predeclared nil
+// value, or from nil interface variables), then the matcher is satisfied.
+//
+// This function will panic if x is of a value type that is not comparable. For
+// example, x cannot be an array of functions.
+func IdenticalTo(x interface{}) Matcher {
+	t := reflect.TypeOf(x)
+
+	// Reject illegal arguments.
+	if ok, err := isLegalForIdenticalTo(t); !ok {
+		panic("IdenticalTo: " + err.Error())
+	}
+
+	return &identicalToMatcher{x}
+}
+
+type identicalToMatcher struct {
+	x interface{}
+}
+
+func (m *identicalToMatcher) Description() string {
+	t := reflect.TypeOf(m.x)
+	return fmt.Sprintf("identical to <%v> %v", t, m.x)
+}
+
+func (m *identicalToMatcher) Matches(c interface{}) error {
+	// Make sure the candidate's type is correct.
+	t := reflect.TypeOf(m.x)
+	if ct := reflect.TypeOf(c); t != ct {
+		return NewFatalError(fmt.Sprintf("which is of type %v", ct))
+	}
+
+	// Special case: two values of the invalid type are always identical.
+	if t == nil {
+		return nil
+	}
+
+	// Handle reference types.
+	switch t.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+		xv := reflect.ValueOf(m.x)
+		cv := reflect.ValueOf(c)
+		if xv.Pointer() == cv.Pointer() {
+			return nil
+		}
+
+		return errors.New("which is not an identical reference")
+	}
+
+	// Are the values equal?
+	if m.x == c {
+		return nil
+	}
+
+	return errors.New("")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go
new file mode 100644
index 00000000000..cc03b214ad6
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go
@@ -0,0 +1,849 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"fmt"
+	"io"
+	"unsafe"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type IdenticalToTest struct {
+}
+
+func init() { RegisterTestSuite(&IdenticalToTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *IdenticalToTest) TypesNotIdentical() {
+	var m Matcher
+	var err error
+
+	type intAlias int
+
+	// Type alias expected value
+	m = IdenticalTo(intAlias(17))
+	err = m.Matches(int(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int")))
+
+	// Type alias candidate
+	m = IdenticalTo(int(17))
+	err = m.Matches(intAlias(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.intAlias")))
+
+	// int and uint
+	m = IdenticalTo(int(17))
+	err = m.Matches(uint(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type uint")))
+}
+
+func (t *IdenticalToTest) PredeclaredNilIdentifier() {
+	var m Matcher
+	var err error
+
+	// Nil literal
+	m = IdenticalTo(nil)
+	err = m.Matches(nil)
+	ExpectEq(nil, err)
+
+	// Zero interface var (which is the same as above since IdenticalTo takes an
+	// interface{} as an arg)
+	var nilReader io.Reader
+	var nilWriter io.Writer
+
+	m = IdenticalTo(nilReader)
+	err = m.Matches(nilWriter)
+	ExpectEq(nil, err)
+
+	// Typed nil value.
+	m = IdenticalTo(nil)
+	err = m.Matches((chan int)(nil))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type chan int")))
+
+	// Non-nil value.
+	m = IdenticalTo(nil)
+	err = m.Matches("taco")
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type string")))
+}
+
+func (t *IdenticalToTest) Slices() {
+	var m Matcher
+	var err error
+
+	// Nil expected value
+	m = IdenticalTo(([]int)(nil))
+	ExpectEq("identical to <[]int> []", m.Description())
+
+	err = m.Matches(([]int)(nil))
+	ExpectEq(nil, err)
+
+	err = m.Matches([]int{})
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+
+	// Non-nil expected value
+	o1 := make([]int, 1)
+	o2 := make([]int, 1)
+	m = IdenticalTo(o1)
+	ExpectEq(fmt.Sprintf("identical to <[]int> %v", o1), m.Description())
+
+	err = m.Matches(o1)
+	ExpectEq(nil, err)
+
+	err = m.Matches(o2)
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+}
+
+func (t *IdenticalToTest) Maps() {
+	var m Matcher
+	var err error
+
+	// Nil expected value
+	m = IdenticalTo((map[int]int)(nil))
+	ExpectEq("identical to <map[int]int> map[]", m.Description())
+
+	err = m.Matches((map[int]int)(nil))
+	ExpectEq(nil, err)
+
+	err = m.Matches(map[int]int{})
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+
+	// Non-nil expected value
+	o1 := map[int]int{}
+	o2 := map[int]int{}
+	m = IdenticalTo(o1)
+	ExpectEq(fmt.Sprintf("identical to <map[int]int> %v", o1), m.Description())
+
+	err = m.Matches(o1)
+	ExpectEq(nil, err)
+
+	err = m.Matches(o2)
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+}
+
+func (t *IdenticalToTest) Functions() {
+	var m Matcher
+	var err error
+
+	// Nil expected value
+	m = IdenticalTo((func())(nil))
+	ExpectEq("identical to <func()> <nil>", m.Description())
+
+	err = m.Matches((func())(nil))
+	ExpectEq(nil, err)
+
+	err = m.Matches(func(){})
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+
+	// Non-nil expected value
+	o1 := func() {}
+	o2 := func() {}
+	m = IdenticalTo(o1)
+	ExpectEq(fmt.Sprintf("identical to <func()> %v", o1), m.Description())
+
+	err = m.Matches(o1)
+	ExpectEq(nil, err)
+
+	err = m.Matches(o2)
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+}
+
+func (t *IdenticalToTest) Channels() {
+	var m Matcher
+	var err error
+
+	// Nil expected value
+	m = IdenticalTo((chan int)(nil))
+	ExpectEq("identical to <chan int> <nil>", m.Description())
+
+	err = m.Matches((chan int)(nil))
+	ExpectEq(nil, err)
+
+	err = m.Matches(make(chan int))
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+
+	// Non-nil expected value
+	o1 := make(chan int)
+	o2 := make(chan int)
+	m = IdenticalTo(o1)
+	ExpectEq(fmt.Sprintf("identical to <chan int> %v", o1), m.Description())
+
+	err = m.Matches(o1)
+	ExpectEq(nil, err)
+
+	err = m.Matches(o2)
+	ExpectThat(err, Error(Equals("which is not an identical reference")))
+}
+
+func (t *IdenticalToTest) Bools() {
+	var m Matcher
+	var err error
+
+	// false
+	m = IdenticalTo(false)
+	ExpectEq("identical to <bool> false", m.Description())
+
+	err = m.Matches(false)
+	ExpectEq(nil, err)
+
+	err = m.Matches(true)
+	ExpectThat(err, Error(Equals("")))
+
+	// true
+	m = IdenticalTo(true)
+	ExpectEq("identical to <bool> true", m.Description())
+
+	err = m.Matches(false)
+	ExpectThat(err, Error(Equals("")))
+
+	err = m.Matches(true)
+	ExpectEq(nil, err)
+}
+
+func (t *IdenticalToTest) Ints() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(int(17))
+	ExpectEq("identical to <int> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(int(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType int
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Int8s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(int8(17))
+	ExpectEq("identical to <int8> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(int8(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType int8
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Int16s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(int16(17))
+	ExpectEq("identical to <int16> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(int16(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType int16
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Int32s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(int32(17))
+	ExpectEq("identical to <int32> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(int32(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType int32
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int16(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int16")))
+}
+
+func (t *IdenticalToTest) Int64s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(int64(17))
+	ExpectEq("identical to <int64> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(int64(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType int64
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uints() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uint(17))
+	ExpectEq("identical to <uint> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uint(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uint
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uint8s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uint8(17))
+	ExpectEq("identical to <uint8> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uint8(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uint8
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uint16s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uint16(17))
+	ExpectEq("identical to <uint16> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uint16(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uint16
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uint32s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uint32(17))
+	ExpectEq("identical to <uint32> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uint32(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uint32
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uint64s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uint64(17))
+	ExpectEq("identical to <uint64> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uint64(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uint64
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Uintptrs() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(uintptr(17))
+	ExpectEq("identical to <uintptr> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(uintptr(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType uintptr
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Float32s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(float32(17))
+	ExpectEq("identical to <float32> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(float32(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType float32
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Float64s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(float64(17))
+	ExpectEq("identical to <float64> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(float64(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType float64
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Complex64s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(complex64(17))
+	ExpectEq("identical to <complex64> (17+0i)", m.Description())
+
+	// Identical value
+	err = m.Matches(complex64(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType complex64
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) Complex128s() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo(complex128(17))
+	ExpectEq("identical to <complex128> (17+0i)", m.Description())
+
+	// Identical value
+	err = m.Matches(complex128(17))
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType complex128
+	err = m.Matches(myType(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) EmptyComparableArrays() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo([0]int{})
+	ExpectEq("identical to <[0]int> []", m.Description())
+
+	// Identical value
+	err = m.Matches([0]int{})
+	ExpectEq(nil, err)
+
+	// Length too long
+	err = m.Matches([1]int{17})
+	ExpectThat(err, Error(Equals("which is of type [1]int")))
+
+	// Element type alias
+	type myType int
+	err = m.Matches([0]myType{})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type [0]oglematchers_test.myType")))
+
+	// Completely wrong element type
+	err = m.Matches([0]int32{})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type [0]int32")))
+}
+
+func (t *IdenticalToTest) NonEmptyComparableArrays() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo([2]int{17, 19})
+	ExpectEq("identical to <[2]int> [17 19]", m.Description())
+
+	// Identical value
+	err = m.Matches([2]int{17, 19})
+	ExpectEq(nil, err)
+
+	// Length too short
+	err = m.Matches([1]int{17})
+	ExpectThat(err, Error(Equals("which is of type [1]int")))
+
+	// Length too long
+	err = m.Matches([3]int{17, 19, 23})
+	ExpectThat(err, Error(Equals("which is of type [3]int")))
+
+	// First element different
+	err = m.Matches([2]int{13, 19})
+	ExpectThat(err, Error(Equals("")))
+
+	// Second element different
+	err = m.Matches([2]int{17, 23})
+	ExpectThat(err, Error(Equals("")))
+
+	// Element type alias
+	type myType int
+	err = m.Matches([2]myType{17, 19})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type [2]oglematchers_test.myType")))
+
+	// Completely wrong element type
+	err = m.Matches([2]int32{17, 19})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type [2]int32")))
+}
+
+func (t *IdenticalToTest) NonEmptyArraysOfComparableArrays() {
+	var m Matcher
+	var err error
+
+	x := [2][2]int{
+		[2]int{17, 19},
+		[2]int{23, 29},
+	}
+	m = IdenticalTo(x)
+	ExpectEq("identical to <[2][2]int> [[17 19] [23 29]]", m.Description())
+
+	// Identical value
+	err = m.Matches([2][2]int{[2]int{17, 19}, [2]int{23, 29}})
+	ExpectEq(nil, err)
+
+	// Outer length too short
+	err = m.Matches([1][2]int{[2]int{17, 19}})
+	ExpectThat(err, Error(Equals("which is of type [1][2]int")))
+
+	// Inner length too short
+	err = m.Matches([2][1]int{[1]int{17}, [1]int{23}})
+	ExpectThat(err, Error(Equals("which is of type [2][1]int")))
+
+	// First element different
+	err = m.Matches([2][2]int{[2]int{13, 19}, [2]int{23, 29}})
+	ExpectThat(err, Error(Equals("")))
+
+	// Element type alias
+	type myType int
+	err = m.Matches([2][2]myType{[2]myType{17, 19}, [2]myType{23, 29}})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type [2][2]oglematchers_test.myType")))
+}
+
+func (t *IdenticalToTest) NonComparableArrays() {
+	x := [0]func(){}
+	f := func() { IdenticalTo(x) }
+	ExpectThat(f, Panics(HasSubstr("is not comparable")))
+}
+
+func (t *IdenticalToTest) ArraysOfNonComparableArrays() {
+	x := [0][0]func(){}
+	f := func() { IdenticalTo(x) }
+	ExpectThat(f, Panics(HasSubstr("is not comparable")))
+}
+
+func (t *IdenticalToTest) Strings() {
+	var m Matcher
+	var err error
+
+	m = IdenticalTo("taco")
+	ExpectEq("identical to <string> taco", m.Description())
+
+	// Identical value
+	err = m.Matches("ta" + "co")
+	ExpectEq(nil, err)
+
+	// Type alias
+	type myType string
+	err = m.Matches(myType("taco"))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) ComparableStructs() {
+	var m Matcher
+	var err error
+
+	type subStruct struct {
+		i int
+	}
+
+	type myStruct struct {
+		u uint
+		s subStruct
+	}
+
+	x := myStruct{17, subStruct{19}}
+	m = IdenticalTo(x)
+	ExpectEq("identical to <oglematchers_test.myStruct> {17 {19}}", m.Description())
+
+	// Identical value
+	err = m.Matches(myStruct{17, subStruct{19}})
+	ExpectEq(nil, err)
+
+	// Wrong outer field
+	err = m.Matches(myStruct{13, subStruct{19}})
+	ExpectThat(err, Error(Equals("")))
+
+	// Wrong inner field
+	err = m.Matches(myStruct{17, subStruct{23}})
+	ExpectThat(err, Error(Equals("")))
+
+	// Type alias
+	type myType myStruct
+	err = m.Matches(myType{17, subStruct{19}})
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) NonComparableStructs() {
+	type subStruct struct {
+		s []int
+	}
+
+	type myStruct struct {
+		u uint
+		s subStruct
+	}
+
+	x := myStruct{17, subStruct{[]int{19}}}
+	f := func() { IdenticalTo(x) }
+	ExpectThat(f, Panics(AllOf(HasSubstr("IdenticalTo"), HasSubstr("comparable"))))
+}
+
+func (t *IdenticalToTest) NilUnsafePointer() {
+	var m Matcher
+	var err error
+
+	x := unsafe.Pointer(nil)
+	m = IdenticalTo(x)
+	ExpectEq(fmt.Sprintf("identical to <unsafe.Pointer> %v", x), m.Description())
+
+	// Identical value
+	err = m.Matches(unsafe.Pointer(nil))
+	ExpectEq(nil, err)
+
+	// Wrong value
+	j := 17
+	err = m.Matches(unsafe.Pointer(&j))
+	ExpectThat(err, Error(Equals("")))
+
+	// Type alias
+	type myType unsafe.Pointer
+	err = m.Matches(myType(unsafe.Pointer(nil)))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) NonNilUnsafePointer() {
+	var m Matcher
+	var err error
+
+	i := 17
+	x := unsafe.Pointer(&i)
+	m = IdenticalTo(x)
+	ExpectEq(fmt.Sprintf("identical to <unsafe.Pointer> %v", x), m.Description())
+
+	// Identical value
+	err = m.Matches(unsafe.Pointer(&i))
+	ExpectEq(nil, err)
+
+	// Nil value
+	err = m.Matches(unsafe.Pointer(nil))
+	ExpectThat(err, Error(Equals("")))
+
+	// Wrong value
+	j := 17
+	err = m.Matches(unsafe.Pointer(&j))
+	ExpectThat(err, Error(Equals("")))
+
+	// Type alias
+	type myType unsafe.Pointer
+	err = m.Matches(myType(unsafe.Pointer(&i)))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
+
+func (t *IdenticalToTest) IntAlias() {
+	var m Matcher
+	var err error
+
+	type intAlias int
+
+	m = IdenticalTo(intAlias(17))
+	ExpectEq("identical to <oglematchers_test.intAlias> 17", m.Description())
+
+	// Identical value
+	err = m.Matches(intAlias(17))
+	ExpectEq(nil, err)
+
+	// Int
+	err = m.Matches(int(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int")))
+
+	// Completely wrong type
+	err = m.Matches(int32(17))
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("which is of type int32")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal.go
new file mode 100644
index 00000000000..8402cdeaf09
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal.go
@@ -0,0 +1,41 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// LessOrEqual returns a matcher that matches integer, floating point, or
+// strings values v such that v <= x. Comparison is not defined between numeric
+// and string types, but is defined between all integer and floating point
+// types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// LessOrEqual will panic.
+func LessOrEqual(x interface{}) Matcher {
+	desc := fmt.Sprintf("less than or equal to %v", x)
+
+	// Special case: make it clear that strings are strings.
+	if reflect.TypeOf(x).Kind() == reflect.String {
+		desc = fmt.Sprintf("less than or equal to \"%s\"", x)
+	}
+
+	// Put LessThan last so that its error messages will be used in the event of
+	// failure.
+	return transformDescription(AnyOf(Equals(x), LessThan(x)), desc)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal_test.go
new file mode 100644
index 00000000000..a1a2ae7d60e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_or_equal_test.go
@@ -0,0 +1,1077 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"math"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type LessOrEqualTest struct {
+}
+
+func init() { RegisterTestSuite(&LessOrEqualTest{}) }
+
+type leTestCase struct {
+	candidate      interface{}
+	expectedResult bool
+	shouldBeFatal  bool
+	expectedError  string
+}
+
+func (t *LessOrEqualTest) checkTestCases(matcher Matcher, cases []leTestCase) {
+	for i, c := range cases {
+		err := matcher.Matches(c.candidate)
+
+		ExpectThat(
+			(err == nil),
+			Equals(c.expectedResult),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		if err == nil {
+			continue
+		}
+
+		_, isFatal := err.(*FatalError)
+		ExpectEq(
+			c.shouldBeFatal,
+			isFatal,
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		ExpectThat(
+			err,
+			Error(Equals(c.expectedError)),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessOrEqualTest) IntegerCandidateBadTypes() {
+	matcher := LessOrEqual(int(-150))
+
+	cases := []leTestCase{
+		leTestCase{true, false, true, "which is not comparable"},
+		leTestCase{complex64(-151), false, true, "which is not comparable"},
+		leTestCase{complex128(-151), false, true, "which is not comparable"},
+		leTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		leTestCase{make(chan int), false, true, "which is not comparable"},
+		leTestCase{func() {}, false, true, "which is not comparable"},
+		leTestCase{map[int]int{}, false, true, "which is not comparable"},
+		leTestCase{&leTestCase{}, false, true, "which is not comparable"},
+		leTestCase{make([]int, 0), false, true, "which is not comparable"},
+		leTestCase{"-151", false, true, "which is not comparable"},
+		leTestCase{leTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) FloatCandidateBadTypes() {
+	matcher := LessOrEqual(float32(-150))
+
+	cases := []leTestCase{
+		leTestCase{true, false, true, "which is not comparable"},
+		leTestCase{complex64(-151), false, true, "which is not comparable"},
+		leTestCase{complex128(-151), false, true, "which is not comparable"},
+		leTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		leTestCase{make(chan int), false, true, "which is not comparable"},
+		leTestCase{func() {}, false, true, "which is not comparable"},
+		leTestCase{map[int]int{}, false, true, "which is not comparable"},
+		leTestCase{&leTestCase{}, false, true, "which is not comparable"},
+		leTestCase{make([]int, 0), false, true, "which is not comparable"},
+		leTestCase{"-151", false, true, "which is not comparable"},
+		leTestCase{leTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) StringCandidateBadTypes() {
+	matcher := LessOrEqual("17")
+
+	cases := []leTestCase{
+		leTestCase{true, false, true, "which is not comparable"},
+		leTestCase{int(0), false, true, "which is not comparable"},
+		leTestCase{int8(0), false, true, "which is not comparable"},
+		leTestCase{int16(0), false, true, "which is not comparable"},
+		leTestCase{int32(0), false, true, "which is not comparable"},
+		leTestCase{int64(0), false, true, "which is not comparable"},
+		leTestCase{uint(0), false, true, "which is not comparable"},
+		leTestCase{uint8(0), false, true, "which is not comparable"},
+		leTestCase{uint16(0), false, true, "which is not comparable"},
+		leTestCase{uint32(0), false, true, "which is not comparable"},
+		leTestCase{uint64(0), false, true, "which is not comparable"},
+		leTestCase{float32(0), false, true, "which is not comparable"},
+		leTestCase{float64(0), false, true, "which is not comparable"},
+		leTestCase{complex64(-151), false, true, "which is not comparable"},
+		leTestCase{complex128(-151), false, true, "which is not comparable"},
+		leTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		leTestCase{make(chan int), false, true, "which is not comparable"},
+		leTestCase{func() {}, false, true, "which is not comparable"},
+		leTestCase{map[int]int{}, false, true, "which is not comparable"},
+		leTestCase{&leTestCase{}, false, true, "which is not comparable"},
+		leTestCase{make([]int, 0), false, true, "which is not comparable"},
+		leTestCase{leTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) BadArgument() {
+	panicked := false
+
+	defer func() {
+		ExpectThat(panicked, Equals(true))
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	LessOrEqual(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessOrEqualTest) NegativeIntegerLiteral() {
+	matcher := LessOrEqual(-150)
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to -150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-(1 << 30), true, false, ""},
+		leTestCase{-151, true, false, ""},
+		leTestCase{-150, true, false, ""},
+		leTestCase{-149, false, false, ""},
+		leTestCase{0, false, false, ""},
+		leTestCase{17, false, false, ""},
+
+		leTestCase{int(-(1 << 30)), true, false, ""},
+		leTestCase{int(-151), true, false, ""},
+		leTestCase{int(-150), true, false, ""},
+		leTestCase{int(-149), false, false, ""},
+		leTestCase{int(0), false, false, ""},
+		leTestCase{int(17), false, false, ""},
+
+		leTestCase{int8(-127), false, false, ""},
+		leTestCase{int8(0), false, false, ""},
+		leTestCase{int8(17), false, false, ""},
+
+		leTestCase{int16(-(1 << 14)), true, false, ""},
+		leTestCase{int16(-151), true, false, ""},
+		leTestCase{int16(-150), true, false, ""},
+		leTestCase{int16(-149), false, false, ""},
+		leTestCase{int16(0), false, false, ""},
+		leTestCase{int16(17), false, false, ""},
+
+		leTestCase{int32(-(1 << 30)), true, false, ""},
+		leTestCase{int32(-151), true, false, ""},
+		leTestCase{int32(-150), true, false, ""},
+		leTestCase{int32(-149), false, false, ""},
+		leTestCase{int32(0), false, false, ""},
+		leTestCase{int32(17), false, false, ""},
+
+		leTestCase{int64(-(1 << 30)), true, false, ""},
+		leTestCase{int64(-151), true, false, ""},
+		leTestCase{int64(-150), true, false, ""},
+		leTestCase{int64(-149), false, false, ""},
+		leTestCase{int64(0), false, false, ""},
+		leTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint((1 << 32) - 151), false, false, ""},
+		leTestCase{uint(0), false, false, ""},
+		leTestCase{uint(17), false, false, ""},
+
+		leTestCase{uint8(0), false, false, ""},
+		leTestCase{uint8(17), false, false, ""},
+		leTestCase{uint8(253), false, false, ""},
+
+		leTestCase{uint16((1 << 16) - 151), false, false, ""},
+		leTestCase{uint16(0), false, false, ""},
+		leTestCase{uint16(17), false, false, ""},
+
+		leTestCase{uint32((1 << 32) - 151), false, false, ""},
+		leTestCase{uint32(0), false, false, ""},
+		leTestCase{uint32(17), false, false, ""},
+
+		leTestCase{uint64((1 << 64) - 151), false, false, ""},
+		leTestCase{uint64(0), false, false, ""},
+		leTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-(1 << 30)), true, false, ""},
+		leTestCase{float32(-151), true, false, ""},
+		leTestCase{float32(-150.1), true, false, ""},
+		leTestCase{float32(-150), true, false, ""},
+		leTestCase{float32(-149.9), false, false, ""},
+		leTestCase{float32(0), false, false, ""},
+		leTestCase{float32(17), false, false, ""},
+		leTestCase{float32(160), false, false, ""},
+
+		leTestCase{float64(-(1 << 30)), true, false, ""},
+		leTestCase{float64(-151), true, false, ""},
+		leTestCase{float64(-150.1), true, false, ""},
+		leTestCase{float64(-150), true, false, ""},
+		leTestCase{float64(-149.9), false, false, ""},
+		leTestCase{float64(0), false, false, ""},
+		leTestCase{float64(17), false, false, ""},
+		leTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) ZeroIntegerLiteral() {
+	matcher := LessOrEqual(0)
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 0"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-(1 << 30), true, false, ""},
+		leTestCase{-1, true, false, ""},
+		leTestCase{0, true, false, ""},
+		leTestCase{1, false, false, ""},
+		leTestCase{17, false, false, ""},
+		leTestCase{(1 << 30), false, false, ""},
+
+		leTestCase{int(-(1 << 30)), true, false, ""},
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(0), true, false, ""},
+		leTestCase{int(1), false, false, ""},
+		leTestCase{int(17), false, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(0), true, false, ""},
+		leTestCase{int8(1), false, false, ""},
+
+		leTestCase{int16(-(1 << 14)), true, false, ""},
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(0), true, false, ""},
+		leTestCase{int16(1), false, false, ""},
+		leTestCase{int16(17), false, false, ""},
+
+		leTestCase{int32(-(1 << 30)), true, false, ""},
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(0), true, false, ""},
+		leTestCase{int32(1), false, false, ""},
+		leTestCase{int32(17), false, false, ""},
+
+		leTestCase{int64(-(1 << 30)), true, false, ""},
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(0), true, false, ""},
+		leTestCase{int64(1), false, false, ""},
+		leTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint((1 << 32) - 1), false, false, ""},
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(1), false, false, ""},
+		leTestCase{uint(17), false, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(1), false, false, ""},
+		leTestCase{uint8(17), false, false, ""},
+		leTestCase{uint8(253), false, false, ""},
+
+		leTestCase{uint16((1 << 16) - 1), false, false, ""},
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(1), false, false, ""},
+		leTestCase{uint16(17), false, false, ""},
+
+		leTestCase{uint32((1 << 32) - 1), false, false, ""},
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(1), false, false, ""},
+		leTestCase{uint32(17), false, false, ""},
+
+		leTestCase{uint64((1 << 64) - 1), false, false, ""},
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(1), false, false, ""},
+		leTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-(1 << 30)), true, false, ""},
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(-0.1), true, false, ""},
+		leTestCase{float32(-0.0), true, false, ""},
+		leTestCase{float32(0), true, false, ""},
+		leTestCase{float32(0.1), false, false, ""},
+		leTestCase{float32(17), false, false, ""},
+		leTestCase{float32(160), false, false, ""},
+
+		leTestCase{float64(-(1 << 30)), true, false, ""},
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(-0.1), true, false, ""},
+		leTestCase{float64(-0), true, false, ""},
+		leTestCase{float64(0), true, false, ""},
+		leTestCase{float64(0.1), false, false, ""},
+		leTestCase{float64(17), false, false, ""},
+		leTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) PositiveIntegerLiteral() {
+	matcher := LessOrEqual(150)
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{149, true, false, ""},
+		leTestCase{150, true, false, ""},
+		leTestCase{151, false, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(149), true, false, ""},
+		leTestCase{int(150), true, false, ""},
+		leTestCase{int(151), false, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(0), true, false, ""},
+		leTestCase{int8(17), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(149), true, false, ""},
+		leTestCase{int16(150), true, false, ""},
+		leTestCase{int16(151), false, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(149), true, false, ""},
+		leTestCase{int32(150), true, false, ""},
+		leTestCase{int32(151), false, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(149), true, false, ""},
+		leTestCase{int64(150), true, false, ""},
+		leTestCase{int64(151), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(149), true, false, ""},
+		leTestCase{uint(150), true, false, ""},
+		leTestCase{uint(151), false, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(127), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(149), true, false, ""},
+		leTestCase{uint16(150), true, false, ""},
+		leTestCase{uint16(151), false, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(149), true, false, ""},
+		leTestCase{uint32(150), true, false, ""},
+		leTestCase{uint32(151), false, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(149), true, false, ""},
+		leTestCase{uint64(150), true, false, ""},
+		leTestCase{uint64(151), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(149), true, false, ""},
+		leTestCase{float32(149.9), true, false, ""},
+		leTestCase{float32(150), true, false, ""},
+		leTestCase{float32(150.1), false, false, ""},
+		leTestCase{float32(151), false, false, ""},
+
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(149), true, false, ""},
+		leTestCase{float64(149.9), true, false, ""},
+		leTestCase{float64(150), true, false, ""},
+		leTestCase{float64(150.1), false, false, ""},
+		leTestCase{float64(151), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessOrEqualTest) NegativeFloatLiteral() {
+	matcher := LessOrEqual(-150.1)
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to -150.1"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-(1 << 30), true, false, ""},
+		leTestCase{-151, true, false, ""},
+		leTestCase{-150.1, true, false, ""},
+		leTestCase{-150, false, false, ""},
+		leTestCase{-149, false, false, ""},
+		leTestCase{0, false, false, ""},
+		leTestCase{17, false, false, ""},
+
+		leTestCase{int(-(1 << 30)), true, false, ""},
+		leTestCase{int(-151), true, false, ""},
+		leTestCase{int(-150), false, false, ""},
+		leTestCase{int(-149), false, false, ""},
+		leTestCase{int(0), false, false, ""},
+		leTestCase{int(17), false, false, ""},
+
+		leTestCase{int8(-127), false, false, ""},
+		leTestCase{int8(0), false, false, ""},
+		leTestCase{int8(17), false, false, ""},
+
+		leTestCase{int16(-(1 << 14)), true, false, ""},
+		leTestCase{int16(-151), true, false, ""},
+		leTestCase{int16(-150), false, false, ""},
+		leTestCase{int16(-149), false, false, ""},
+		leTestCase{int16(0), false, false, ""},
+		leTestCase{int16(17), false, false, ""},
+
+		leTestCase{int32(-(1 << 30)), true, false, ""},
+		leTestCase{int32(-151), true, false, ""},
+		leTestCase{int32(-150), false, false, ""},
+		leTestCase{int32(-149), false, false, ""},
+		leTestCase{int32(0), false, false, ""},
+		leTestCase{int32(17), false, false, ""},
+
+		leTestCase{int64(-(1 << 30)), true, false, ""},
+		leTestCase{int64(-151), true, false, ""},
+		leTestCase{int64(-150), false, false, ""},
+		leTestCase{int64(-149), false, false, ""},
+		leTestCase{int64(0), false, false, ""},
+		leTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint((1 << 32) - 151), false, false, ""},
+		leTestCase{uint(0), false, false, ""},
+		leTestCase{uint(17), false, false, ""},
+
+		leTestCase{uint8(0), false, false, ""},
+		leTestCase{uint8(17), false, false, ""},
+		leTestCase{uint8(253), false, false, ""},
+
+		leTestCase{uint16((1 << 16) - 151), false, false, ""},
+		leTestCase{uint16(0), false, false, ""},
+		leTestCase{uint16(17), false, false, ""},
+
+		leTestCase{uint32((1 << 32) - 151), false, false, ""},
+		leTestCase{uint32(0), false, false, ""},
+		leTestCase{uint32(17), false, false, ""},
+
+		leTestCase{uint64((1 << 64) - 151), false, false, ""},
+		leTestCase{uint64(0), false, false, ""},
+		leTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-(1 << 30)), true, false, ""},
+		leTestCase{float32(-151), true, false, ""},
+		leTestCase{float32(-150.2), true, false, ""},
+		leTestCase{float32(-150.1), true, false, ""},
+		leTestCase{float32(-150), false, false, ""},
+		leTestCase{float32(0), false, false, ""},
+		leTestCase{float32(17), false, false, ""},
+		leTestCase{float32(160), false, false, ""},
+
+		leTestCase{float64(-(1 << 30)), true, false, ""},
+		leTestCase{float64(-151), true, false, ""},
+		leTestCase{float64(-150.2), true, false, ""},
+		leTestCase{float64(-150.1), true, false, ""},
+		leTestCase{float64(-150), false, false, ""},
+		leTestCase{float64(0), false, false, ""},
+		leTestCase{float64(17), false, false, ""},
+		leTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) PositiveFloatLiteral() {
+	matcher := LessOrEqual(149.9)
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 149.9"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{149, true, false, ""},
+		leTestCase{149.9, true, false, ""},
+		leTestCase{150, false, false, ""},
+		leTestCase{151, false, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(149), true, false, ""},
+		leTestCase{int(150), false, false, ""},
+		leTestCase{int(151), false, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(0), true, false, ""},
+		leTestCase{int8(17), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(149), true, false, ""},
+		leTestCase{int16(150), false, false, ""},
+		leTestCase{int16(151), false, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(149), true, false, ""},
+		leTestCase{int32(150), false, false, ""},
+		leTestCase{int32(151), false, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(149), true, false, ""},
+		leTestCase{int64(150), false, false, ""},
+		leTestCase{int64(151), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(149), true, false, ""},
+		leTestCase{uint(150), false, false, ""},
+		leTestCase{uint(151), false, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(127), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(149), true, false, ""},
+		leTestCase{uint16(150), false, false, ""},
+		leTestCase{uint16(151), false, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(149), true, false, ""},
+		leTestCase{uint32(150), false, false, ""},
+		leTestCase{uint32(151), false, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(149), true, false, ""},
+		leTestCase{uint64(150), false, false, ""},
+		leTestCase{uint64(151), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(149), true, false, ""},
+		leTestCase{float32(149.8), true, false, ""},
+		leTestCase{float32(149.9), true, false, ""},
+		leTestCase{float32(150), false, false, ""},
+		leTestCase{float32(151), false, false, ""},
+
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(149), true, false, ""},
+		leTestCase{float64(149.8), true, false, ""},
+		leTestCase{float64(149.9), true, false, ""},
+		leTestCase{float64(150), false, false, ""},
+		leTestCase{float64(151), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessOrEqual(int64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{kTwoTo25 + 0, true, false, ""},
+		leTestCase{kTwoTo25 + 1, true, false, ""},
+		leTestCase{kTwoTo25 + 2, false, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(0), true, false, ""},
+		leTestCase{int16(32767), true, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(255), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(65535), true, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		leTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessOrEqual(int64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{1 << 30, true, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(math.MaxInt32), true, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(0), true, false, ""},
+		leTestCase{int16(32767), true, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(math.MaxInt32), true, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(math.MaxUint32), true, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(255), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(65535), true, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(math.MaxUint32), true, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Floating point.
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessOrEqual(uint64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{kTwoTo25 + 0, true, false, ""},
+		leTestCase{kTwoTo25 + 1, true, false, ""},
+		leTestCase{kTwoTo25 + 2, false, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(0), true, false, ""},
+		leTestCase{int16(32767), true, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int32(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(255), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(65535), true, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint32(kTwoTo25 + 2), false, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		leTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessOrEqual(uint64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{-1, true, false, ""},
+		leTestCase{1 << 30, true, false, ""},
+
+		leTestCase{int(-1), true, false, ""},
+		leTestCase{int(math.MaxInt32), true, false, ""},
+
+		leTestCase{int8(-1), true, false, ""},
+		leTestCase{int8(127), true, false, ""},
+
+		leTestCase{int16(-1), true, false, ""},
+		leTestCase{int16(0), true, false, ""},
+		leTestCase{int16(32767), true, false, ""},
+
+		leTestCase{int32(-1), true, false, ""},
+		leTestCase{int32(math.MaxInt32), true, false, ""},
+
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint(0), true, false, ""},
+		leTestCase{uint(math.MaxUint32), true, false, ""},
+
+		leTestCase{uint8(0), true, false, ""},
+		leTestCase{uint8(255), true, false, ""},
+
+		leTestCase{uint16(0), true, false, ""},
+		leTestCase{uint16(65535), true, false, ""},
+
+		leTestCase{uint32(0), true, false, ""},
+		leTestCase{uint32(math.MaxUint32), true, false, ""},
+
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Floating point.
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) Float32AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessOrEqual(float32(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 3.3554432e+07"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo25 - 2), true, false, ""},
+		leTestCase{int64(kTwoTo25 - 1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 2), true, false, ""},
+		leTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 - 2), true, false, ""},
+		leTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+		leTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+		// Floating point.
+		leTestCase{float32(-1), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 2), true, false, ""},
+		leTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 2), true, false, ""},
+		leTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) Float64AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessOrEqual(float64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to 1.8014398509481984e+16"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		// Signed integers.
+		leTestCase{int64(-1), true, false, ""},
+		leTestCase{int64(kTwoTo54 - 2), true, false, ""},
+		leTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 2), true, false, ""},
+		leTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+		// Unsigned integers.
+		leTestCase{uint64(0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 - 2), true, false, ""},
+		leTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+		leTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+		// Floating point.
+		leTestCase{float64(-1), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 - 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 0), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 1), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 2), true, false, ""},
+		leTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessOrEqualTest) EmptyString() {
+	matcher := LessOrEqual("")
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to \"\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		leTestCase{"", true, false, ""},
+		leTestCase{"\x00", false, false, ""},
+		leTestCase{"a", false, false, ""},
+		leTestCase{"foo", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) SingleNullByte() {
+	matcher := LessOrEqual("\x00")
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to \"\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		leTestCase{"", true, false, ""},
+		leTestCase{"\x00", true, false, ""},
+		leTestCase{"\x00\x00", false, false, ""},
+		leTestCase{"a", false, false, ""},
+		leTestCase{"foo", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessOrEqualTest) LongerString() {
+	matcher := LessOrEqual("foo\x00")
+	desc := matcher.Description()
+	expectedDesc := "less than or equal to \"foo\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []leTestCase{
+		leTestCase{"", true, false, ""},
+		leTestCase{"\x00", true, false, ""},
+		leTestCase{"bar", true, false, ""},
+		leTestCase{"foo", true, false, ""},
+		leTestCase{"foo\x00", true, false, ""},
+		leTestCase{"foo\x00\x00", false, false, ""},
+		leTestCase{"fooa", false, false, ""},
+		leTestCase{"qux", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than.go
new file mode 100644
index 00000000000..8258e45d99d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than.go
@@ -0,0 +1,152 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+)
+
+// LessThan returns a matcher that matches integer, floating point, or strings
+// values v such that v < x. Comparison is not defined between numeric and
+// string types, but is defined between all integer and floating point types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// LessThan will panic.
+func LessThan(x interface{}) Matcher {
+	v := reflect.ValueOf(x)
+	kind := v.Kind()
+
+	switch {
+	case isInteger(v):
+	case isFloat(v):
+	case kind == reflect.String:
+
+	default:
+		panic(fmt.Sprintf("LessThan: unexpected kind %v", kind))
+	}
+
+	return &lessThanMatcher{v}
+}
+
+type lessThanMatcher struct {
+	limit reflect.Value
+}
+
+func (m *lessThanMatcher) Description() string {
+	// Special case: make it clear that strings are strings.
+	if m.limit.Kind() == reflect.String {
+		return fmt.Sprintf("less than \"%s\"", m.limit.String())
+	}
+
+	return fmt.Sprintf("less than %v", m.limit.Interface())
+}
+
+func compareIntegers(v1, v2 reflect.Value) (err error) {
+	err = errors.New("")
+
+	switch {
+	case isSignedInteger(v1) && isSignedInteger(v2):
+		if v1.Int() < v2.Int() {
+			err = nil
+		}
+		return
+
+	case isSignedInteger(v1) && isUnsignedInteger(v2):
+		if v1.Int() < 0 || uint64(v1.Int()) < v2.Uint() {
+			err = nil
+		}
+		return
+
+	case isUnsignedInteger(v1) && isSignedInteger(v2):
+		if v1.Uint() <= math.MaxInt64 && int64(v1.Uint()) < v2.Int() {
+			err = nil
+		}
+		return
+
+	case isUnsignedInteger(v1) && isUnsignedInteger(v2):
+		if v1.Uint() < v2.Uint() {
+			err = nil
+		}
+		return
+	}
+
+	panic(fmt.Sprintf("compareIntegers: %v %v", v1, v2))
+}
+
+func getFloat(v reflect.Value) float64 {
+	switch {
+	case isSignedInteger(v):
+		return float64(v.Int())
+
+	case isUnsignedInteger(v):
+		return float64(v.Uint())
+
+	case isFloat(v):
+		return v.Float()
+	}
+
+	panic(fmt.Sprintf("getFloat: %v", v))
+}
+
+func (m *lessThanMatcher) Matches(c interface{}) (err error) {
+	v1 := reflect.ValueOf(c)
+	v2 := m.limit
+
+	err = errors.New("")
+
+	// Handle strings as a special case.
+	if v1.Kind() == reflect.String && v2.Kind() == reflect.String {
+		if v1.String() < v2.String() {
+			err = nil
+		}
+		return
+	}
+
+	// If we get here, we require that we are dealing with integers or floats.
+	v1Legal := isInteger(v1) || isFloat(v1)
+	v2Legal := isInteger(v2) || isFloat(v2)
+	if !v1Legal || !v2Legal {
+		err = NewFatalError("which is not comparable")
+		return
+	}
+
+	// Handle the various comparison cases.
+	switch {
+	// Both integers
+	case isInteger(v1) && isInteger(v2):
+		return compareIntegers(v1, v2)
+
+	// At least one float32
+	case v1.Kind() == reflect.Float32 || v2.Kind() == reflect.Float32:
+		if float32(getFloat(v1)) < float32(getFloat(v2)) {
+			err = nil
+		}
+		return
+
+	// At least one float64
+	case v1.Kind() == reflect.Float64 || v2.Kind() == reflect.Float64:
+		if getFloat(v1) < getFloat(v2) {
+			err = nil
+		}
+		return
+	}
+
+	// We shouldn't get here.
+	panic(fmt.Sprintf("lessThanMatcher.Matches: Shouldn't get here: %v %v", v1, v2))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than_test.go
new file mode 100644
index 00000000000..59f5b7f56bd
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than_test.go
@@ -0,0 +1,1057 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"math"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type LessThanTest struct {
+}
+
+func init() { RegisterTestSuite(&LessThanTest{}) }
+
+type ltTestCase struct {
+	candidate      interface{}
+	expectedResult bool
+	shouldBeFatal  bool
+	expectedError  string
+}
+
+func (t *LessThanTest) checkTestCases(matcher Matcher, cases []ltTestCase) {
+	for i, c := range cases {
+		err := matcher.Matches(c.candidate)
+
+		ExpectThat(
+			(err == nil),
+			Equals(c.expectedResult),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		if err == nil {
+			continue
+		}
+
+		_, isFatal := err.(*FatalError)
+		ExpectEq(
+			c.shouldBeFatal,
+			isFatal,
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+
+		ExpectThat(
+			err,
+			Error(Equals(c.expectedError)),
+			"Case %d (candidate %v)",
+			i,
+			c.candidate)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessThanTest) IntegerCandidateBadTypes() {
+	matcher := LessThan(int(-150))
+
+	cases := []ltTestCase{
+		ltTestCase{true, false, true, "which is not comparable"},
+		ltTestCase{complex64(-151), false, true, "which is not comparable"},
+		ltTestCase{complex128(-151), false, true, "which is not comparable"},
+		ltTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		ltTestCase{make(chan int), false, true, "which is not comparable"},
+		ltTestCase{func() {}, false, true, "which is not comparable"},
+		ltTestCase{map[int]int{}, false, true, "which is not comparable"},
+		ltTestCase{&ltTestCase{}, false, true, "which is not comparable"},
+		ltTestCase{make([]int, 0), false, true, "which is not comparable"},
+		ltTestCase{"-151", false, true, "which is not comparable"},
+		ltTestCase{ltTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) FloatCandidateBadTypes() {
+	matcher := LessThan(float32(-150))
+
+	cases := []ltTestCase{
+		ltTestCase{true, false, true, "which is not comparable"},
+		ltTestCase{complex64(-151), false, true, "which is not comparable"},
+		ltTestCase{complex128(-151), false, true, "which is not comparable"},
+		ltTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		ltTestCase{make(chan int), false, true, "which is not comparable"},
+		ltTestCase{func() {}, false, true, "which is not comparable"},
+		ltTestCase{map[int]int{}, false, true, "which is not comparable"},
+		ltTestCase{&ltTestCase{}, false, true, "which is not comparable"},
+		ltTestCase{make([]int, 0), false, true, "which is not comparable"},
+		ltTestCase{"-151", false, true, "which is not comparable"},
+		ltTestCase{ltTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) StringCandidateBadTypes() {
+	matcher := LessThan("17")
+
+	cases := []ltTestCase{
+		ltTestCase{true, false, true, "which is not comparable"},
+		ltTestCase{int(0), false, true, "which is not comparable"},
+		ltTestCase{int8(0), false, true, "which is not comparable"},
+		ltTestCase{int16(0), false, true, "which is not comparable"},
+		ltTestCase{int32(0), false, true, "which is not comparable"},
+		ltTestCase{int64(0), false, true, "which is not comparable"},
+		ltTestCase{uint(0), false, true, "which is not comparable"},
+		ltTestCase{uint8(0), false, true, "which is not comparable"},
+		ltTestCase{uint16(0), false, true, "which is not comparable"},
+		ltTestCase{uint32(0), false, true, "which is not comparable"},
+		ltTestCase{uint64(0), false, true, "which is not comparable"},
+		ltTestCase{float32(0), false, true, "which is not comparable"},
+		ltTestCase{float64(0), false, true, "which is not comparable"},
+		ltTestCase{complex64(-151), false, true, "which is not comparable"},
+		ltTestCase{complex128(-151), false, true, "which is not comparable"},
+		ltTestCase{[...]int{-151}, false, true, "which is not comparable"},
+		ltTestCase{make(chan int), false, true, "which is not comparable"},
+		ltTestCase{func() {}, false, true, "which is not comparable"},
+		ltTestCase{map[int]int{}, false, true, "which is not comparable"},
+		ltTestCase{&ltTestCase{}, false, true, "which is not comparable"},
+		ltTestCase{make([]int, 0), false, true, "which is not comparable"},
+		ltTestCase{ltTestCase{}, false, true, "which is not comparable"},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) BadArgument() {
+	panicked := false
+
+	defer func() {
+		ExpectThat(panicked, Equals(true))
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	LessThan(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessThanTest) NegativeIntegerLiteral() {
+	matcher := LessThan(-150)
+	desc := matcher.Description()
+	expectedDesc := "less than -150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-(1 << 30), true, false, ""},
+		ltTestCase{-151, true, false, ""},
+		ltTestCase{-150, false, false, ""},
+		ltTestCase{0, false, false, ""},
+		ltTestCase{17, false, false, ""},
+
+		ltTestCase{int(-(1 << 30)), true, false, ""},
+		ltTestCase{int(-151), true, false, ""},
+		ltTestCase{int(-150), false, false, ""},
+		ltTestCase{int(0), false, false, ""},
+		ltTestCase{int(17), false, false, ""},
+
+		ltTestCase{int8(-127), false, false, ""},
+		ltTestCase{int8(0), false, false, ""},
+		ltTestCase{int8(17), false, false, ""},
+
+		ltTestCase{int16(-(1 << 14)), true, false, ""},
+		ltTestCase{int16(-151), true, false, ""},
+		ltTestCase{int16(-150), false, false, ""},
+		ltTestCase{int16(0), false, false, ""},
+		ltTestCase{int16(17), false, false, ""},
+
+		ltTestCase{int32(-(1 << 30)), true, false, ""},
+		ltTestCase{int32(-151), true, false, ""},
+		ltTestCase{int32(-150), false, false, ""},
+		ltTestCase{int32(0), false, false, ""},
+		ltTestCase{int32(17), false, false, ""},
+
+		ltTestCase{int64(-(1 << 30)), true, false, ""},
+		ltTestCase{int64(-151), true, false, ""},
+		ltTestCase{int64(-150), false, false, ""},
+		ltTestCase{int64(0), false, false, ""},
+		ltTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint((1 << 32) - 151), false, false, ""},
+		ltTestCase{uint(0), false, false, ""},
+		ltTestCase{uint(17), false, false, ""},
+
+		ltTestCase{uint8(0), false, false, ""},
+		ltTestCase{uint8(17), false, false, ""},
+		ltTestCase{uint8(253), false, false, ""},
+
+		ltTestCase{uint16((1 << 16) - 151), false, false, ""},
+		ltTestCase{uint16(0), false, false, ""},
+		ltTestCase{uint16(17), false, false, ""},
+
+		ltTestCase{uint32((1 << 32) - 151), false, false, ""},
+		ltTestCase{uint32(0), false, false, ""},
+		ltTestCase{uint32(17), false, false, ""},
+
+		ltTestCase{uint64((1 << 64) - 151), false, false, ""},
+		ltTestCase{uint64(0), false, false, ""},
+		ltTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-(1 << 30)), true, false, ""},
+		ltTestCase{float32(-151), true, false, ""},
+		ltTestCase{float32(-150.1), true, false, ""},
+		ltTestCase{float32(-150), false, false, ""},
+		ltTestCase{float32(-149.9), false, false, ""},
+		ltTestCase{float32(0), false, false, ""},
+		ltTestCase{float32(17), false, false, ""},
+		ltTestCase{float32(160), false, false, ""},
+
+		ltTestCase{float64(-(1 << 30)), true, false, ""},
+		ltTestCase{float64(-151), true, false, ""},
+		ltTestCase{float64(-150.1), true, false, ""},
+		ltTestCase{float64(-150), false, false, ""},
+		ltTestCase{float64(-149.9), false, false, ""},
+		ltTestCase{float64(0), false, false, ""},
+		ltTestCase{float64(17), false, false, ""},
+		ltTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) ZeroIntegerLiteral() {
+	matcher := LessThan(0)
+	desc := matcher.Description()
+	expectedDesc := "less than 0"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-(1 << 30), true, false, ""},
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{0, false, false, ""},
+		ltTestCase{1, false, false, ""},
+		ltTestCase{17, false, false, ""},
+		ltTestCase{(1 << 30), false, false, ""},
+
+		ltTestCase{int(-(1 << 30)), true, false, ""},
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(0), false, false, ""},
+		ltTestCase{int(1), false, false, ""},
+		ltTestCase{int(17), false, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(0), false, false, ""},
+		ltTestCase{int8(1), false, false, ""},
+
+		ltTestCase{int16(-(1 << 14)), true, false, ""},
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(0), false, false, ""},
+		ltTestCase{int16(1), false, false, ""},
+		ltTestCase{int16(17), false, false, ""},
+
+		ltTestCase{int32(-(1 << 30)), true, false, ""},
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(0), false, false, ""},
+		ltTestCase{int32(1), false, false, ""},
+		ltTestCase{int32(17), false, false, ""},
+
+		ltTestCase{int64(-(1 << 30)), true, false, ""},
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(0), false, false, ""},
+		ltTestCase{int64(1), false, false, ""},
+		ltTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint((1 << 32) - 1), false, false, ""},
+		ltTestCase{uint(0), false, false, ""},
+		ltTestCase{uint(17), false, false, ""},
+
+		ltTestCase{uint8(0), false, false, ""},
+		ltTestCase{uint8(17), false, false, ""},
+		ltTestCase{uint8(253), false, false, ""},
+
+		ltTestCase{uint16((1 << 16) - 1), false, false, ""},
+		ltTestCase{uint16(0), false, false, ""},
+		ltTestCase{uint16(17), false, false, ""},
+
+		ltTestCase{uint32((1 << 32) - 1), false, false, ""},
+		ltTestCase{uint32(0), false, false, ""},
+		ltTestCase{uint32(17), false, false, ""},
+
+		ltTestCase{uint64((1 << 64) - 1), false, false, ""},
+		ltTestCase{uint64(0), false, false, ""},
+		ltTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-(1 << 30)), true, false, ""},
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(-0.1), true, false, ""},
+		ltTestCase{float32(-0.0), false, false, ""},
+		ltTestCase{float32(0), false, false, ""},
+		ltTestCase{float32(0.1), false, false, ""},
+		ltTestCase{float32(17), false, false, ""},
+		ltTestCase{float32(160), false, false, ""},
+
+		ltTestCase{float64(-(1 << 30)), true, false, ""},
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(-0.1), true, false, ""},
+		ltTestCase{float64(-0), false, false, ""},
+		ltTestCase{float64(0), false, false, ""},
+		ltTestCase{float64(17), false, false, ""},
+		ltTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) PositiveIntegerLiteral() {
+	matcher := LessThan(150)
+	desc := matcher.Description()
+	expectedDesc := "less than 150"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{149, true, false, ""},
+		ltTestCase{150, false, false, ""},
+		ltTestCase{151, false, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(149), true, false, ""},
+		ltTestCase{int(150), false, false, ""},
+		ltTestCase{int(151), false, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(0), true, false, ""},
+		ltTestCase{int8(17), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(149), true, false, ""},
+		ltTestCase{int16(150), false, false, ""},
+		ltTestCase{int16(151), false, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(149), true, false, ""},
+		ltTestCase{int32(150), false, false, ""},
+		ltTestCase{int32(151), false, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(149), true, false, ""},
+		ltTestCase{int64(150), false, false, ""},
+		ltTestCase{int64(151), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(149), true, false, ""},
+		ltTestCase{uint(150), false, false, ""},
+		ltTestCase{uint(151), false, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(127), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(149), true, false, ""},
+		ltTestCase{uint16(150), false, false, ""},
+		ltTestCase{uint16(151), false, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(149), true, false, ""},
+		ltTestCase{uint32(150), false, false, ""},
+		ltTestCase{uint32(151), false, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(149), true, false, ""},
+		ltTestCase{uint64(150), false, false, ""},
+		ltTestCase{uint64(151), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(149), true, false, ""},
+		ltTestCase{float32(149.9), true, false, ""},
+		ltTestCase{float32(150), false, false, ""},
+		ltTestCase{float32(150.1), false, false, ""},
+		ltTestCase{float32(151), false, false, ""},
+
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(149), true, false, ""},
+		ltTestCase{float64(149.9), true, false, ""},
+		ltTestCase{float64(150), false, false, ""},
+		ltTestCase{float64(150.1), false, false, ""},
+		ltTestCase{float64(151), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessThanTest) NegativeFloatLiteral() {
+	matcher := LessThan(-150.1)
+	desc := matcher.Description()
+	expectedDesc := "less than -150.1"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-(1 << 30), true, false, ""},
+		ltTestCase{-151, true, false, ""},
+		ltTestCase{-150, false, false, ""},
+		ltTestCase{0, false, false, ""},
+		ltTestCase{17, false, false, ""},
+
+		ltTestCase{int(-(1 << 30)), true, false, ""},
+		ltTestCase{int(-151), true, false, ""},
+		ltTestCase{int(-150), false, false, ""},
+		ltTestCase{int(0), false, false, ""},
+		ltTestCase{int(17), false, false, ""},
+
+		ltTestCase{int8(-127), false, false, ""},
+		ltTestCase{int8(0), false, false, ""},
+		ltTestCase{int8(17), false, false, ""},
+
+		ltTestCase{int16(-(1 << 14)), true, false, ""},
+		ltTestCase{int16(-151), true, false, ""},
+		ltTestCase{int16(-150), false, false, ""},
+		ltTestCase{int16(0), false, false, ""},
+		ltTestCase{int16(17), false, false, ""},
+
+		ltTestCase{int32(-(1 << 30)), true, false, ""},
+		ltTestCase{int32(-151), true, false, ""},
+		ltTestCase{int32(-150), false, false, ""},
+		ltTestCase{int32(0), false, false, ""},
+		ltTestCase{int32(17), false, false, ""},
+
+		ltTestCase{int64(-(1 << 30)), true, false, ""},
+		ltTestCase{int64(-151), true, false, ""},
+		ltTestCase{int64(-150), false, false, ""},
+		ltTestCase{int64(0), false, false, ""},
+		ltTestCase{int64(17), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint((1 << 32) - 151), false, false, ""},
+		ltTestCase{uint(0), false, false, ""},
+		ltTestCase{uint(17), false, false, ""},
+
+		ltTestCase{uint8(0), false, false, ""},
+		ltTestCase{uint8(17), false, false, ""},
+		ltTestCase{uint8(253), false, false, ""},
+
+		ltTestCase{uint16((1 << 16) - 151), false, false, ""},
+		ltTestCase{uint16(0), false, false, ""},
+		ltTestCase{uint16(17), false, false, ""},
+
+		ltTestCase{uint32((1 << 32) - 151), false, false, ""},
+		ltTestCase{uint32(0), false, false, ""},
+		ltTestCase{uint32(17), false, false, ""},
+
+		ltTestCase{uint64((1 << 64) - 151), false, false, ""},
+		ltTestCase{uint64(0), false, false, ""},
+		ltTestCase{uint64(17), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-(1 << 30)), true, false, ""},
+		ltTestCase{float32(-151), true, false, ""},
+		ltTestCase{float32(-150.2), true, false, ""},
+		ltTestCase{float32(-150.1), false, false, ""},
+		ltTestCase{float32(-150), false, false, ""},
+		ltTestCase{float32(0), false, false, ""},
+		ltTestCase{float32(17), false, false, ""},
+		ltTestCase{float32(160), false, false, ""},
+
+		ltTestCase{float64(-(1 << 30)), true, false, ""},
+		ltTestCase{float64(-151), true, false, ""},
+		ltTestCase{float64(-150.2), true, false, ""},
+		ltTestCase{float64(-150.1), false, false, ""},
+		ltTestCase{float64(-150), false, false, ""},
+		ltTestCase{float64(0), false, false, ""},
+		ltTestCase{float64(17), false, false, ""},
+		ltTestCase{float64(160), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) PositiveFloatLiteral() {
+	matcher := LessThan(149.9)
+	desc := matcher.Description()
+	expectedDesc := "less than 149.9"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{149, true, false, ""},
+		ltTestCase{150, false, false, ""},
+		ltTestCase{151, false, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(149), true, false, ""},
+		ltTestCase{int(150), false, false, ""},
+		ltTestCase{int(151), false, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(0), true, false, ""},
+		ltTestCase{int8(17), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(149), true, false, ""},
+		ltTestCase{int16(150), false, false, ""},
+		ltTestCase{int16(151), false, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(149), true, false, ""},
+		ltTestCase{int32(150), false, false, ""},
+		ltTestCase{int32(151), false, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(149), true, false, ""},
+		ltTestCase{int64(150), false, false, ""},
+		ltTestCase{int64(151), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(149), true, false, ""},
+		ltTestCase{uint(150), false, false, ""},
+		ltTestCase{uint(151), false, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(127), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(149), true, false, ""},
+		ltTestCase{uint16(150), false, false, ""},
+		ltTestCase{uint16(151), false, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(149), true, false, ""},
+		ltTestCase{uint32(150), false, false, ""},
+		ltTestCase{uint32(151), false, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(149), true, false, ""},
+		ltTestCase{uint64(150), false, false, ""},
+		ltTestCase{uint64(151), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(149), true, false, ""},
+		ltTestCase{float32(149.8), true, false, ""},
+		ltTestCase{float32(149.9), false, false, ""},
+		ltTestCase{float32(150), false, false, ""},
+		ltTestCase{float32(151), false, false, ""},
+
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(149), true, false, ""},
+		ltTestCase{float64(149.8), true, false, ""},
+		ltTestCase{float64(149.9), false, false, ""},
+		ltTestCase{float64(150), false, false, ""},
+		ltTestCase{float64(151), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessThanTest) Int64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessThan(int64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{kTwoTo25 + 0, true, false, ""},
+		ltTestCase{kTwoTo25 + 1, false, false, ""},
+		ltTestCase{kTwoTo25 + 2, false, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(0), true, false, ""},
+		ltTestCase{int16(32767), true, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int32(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(255), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(65535), true, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		ltTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) Int64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessThan(int64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{1 << 30, true, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(math.MaxInt32), true, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(0), true, false, ""},
+		ltTestCase{int16(32767), true, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(math.MaxInt32), true, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		ltTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		ltTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(math.MaxUint32), true, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(255), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(65535), true, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(math.MaxUint32), true, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessThan(uint64(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 33554433"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{kTwoTo25 + 0, true, false, ""},
+		ltTestCase{kTwoTo25 + 1, false, false, ""},
+		ltTestCase{kTwoTo25 + 2, false, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(0), true, false, ""},
+		ltTestCase{int16(32767), true, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int32(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(255), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(65535), true, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint32(kTwoTo25 + 2), false, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 1), true, false, ""},
+		ltTestCase{float64(kTwoTo25 + 0), true, false, ""},
+		ltTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessThan(uint64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 18014398509481985"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{-1, true, false, ""},
+		ltTestCase{1 << 30, true, false, ""},
+
+		ltTestCase{int(-1), true, false, ""},
+		ltTestCase{int(math.MaxInt32), true, false, ""},
+
+		ltTestCase{int8(-1), true, false, ""},
+		ltTestCase{int8(127), true, false, ""},
+
+		ltTestCase{int16(-1), true, false, ""},
+		ltTestCase{int16(0), true, false, ""},
+		ltTestCase{int16(32767), true, false, ""},
+
+		ltTestCase{int32(-1), true, false, ""},
+		ltTestCase{int32(math.MaxInt32), true, false, ""},
+
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo54 - 1), true, false, ""},
+		ltTestCase{int64(kTwoTo54 + 0), true, false, ""},
+		ltTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint(0), true, false, ""},
+		ltTestCase{uint(math.MaxUint32), true, false, ""},
+
+		ltTestCase{uint8(0), true, false, ""},
+		ltTestCase{uint8(255), true, false, ""},
+
+		ltTestCase{uint16(0), true, false, ""},
+		ltTestCase{uint16(65535), true, false, ""},
+
+		ltTestCase{uint32(0), true, false, ""},
+		ltTestCase{uint32(math.MaxUint32), true, false, ""},
+
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) Float32AboveExactIntegerRange() {
+	// Single-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo25 = 1 << 25
+	matcher := LessThan(float32(kTwoTo25 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 3.3554432e+07"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{int64(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{uint64(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float32(-1), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float32(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo25 - 1), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 0), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo25 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) Float64AboveExactIntegerRange() {
+	// Double-precision floats don't have enough bits to represent the integers
+	// near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+	// and should be treated as equivalent when floats are in the mix.
+	const kTwoTo54 = 1 << 54
+	matcher := LessThan(float64(kTwoTo54 + 1))
+
+	desc := matcher.Description()
+	expectedDesc := "less than 1.8014398509481984e+16"
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		// Signed integers.
+		ltTestCase{int64(-1), true, false, ""},
+		ltTestCase{int64(kTwoTo54 - 2), true, false, ""},
+		ltTestCase{int64(kTwoTo54 - 1), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 0), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 2), false, false, ""},
+		ltTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+		// Unsigned integers.
+		ltTestCase{uint64(0), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 - 2), true, false, ""},
+		ltTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+		ltTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+		// Floating point.
+		ltTestCase{float64(-1), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 2), true, false, ""},
+		ltTestCase{float64(kTwoTo54 - 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 0), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 1), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 2), false, false, ""},
+		ltTestCase{float64(kTwoTo54 + 3), false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *LessThanTest) EmptyString() {
+	matcher := LessThan("")
+	desc := matcher.Description()
+	expectedDesc := "less than \"\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		ltTestCase{"", false, false, ""},
+		ltTestCase{"\x00", false, false, ""},
+		ltTestCase{"a", false, false, ""},
+		ltTestCase{"foo", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) SingleNullByte() {
+	matcher := LessThan("\x00")
+	desc := matcher.Description()
+	expectedDesc := "less than \"\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		ltTestCase{"", true, false, ""},
+		ltTestCase{"\x00", false, false, ""},
+		ltTestCase{"a", false, false, ""},
+		ltTestCase{"foo", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
+
+func (t *LessThanTest) LongerString() {
+	matcher := LessThan("foo\x00")
+	desc := matcher.Description()
+	expectedDesc := "less than \"foo\x00\""
+
+	ExpectThat(desc, Equals(expectedDesc))
+
+	cases := []ltTestCase{
+		ltTestCase{"", true, false, ""},
+		ltTestCase{"\x00", true, false, ""},
+		ltTestCase{"bar", true, false, ""},
+		ltTestCase{"foo", true, false, ""},
+		ltTestCase{"foo\x00", false, false, ""},
+		ltTestCase{"fooa", false, false, ""},
+		ltTestCase{"qux", false, false, ""},
+	}
+
+	t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matcher.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matcher.go
new file mode 100644
index 00000000000..78159a0727c
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matcher.go
@@ -0,0 +1,86 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package oglematchers provides a set of matchers useful in a testing or
+// mocking framework. These matchers are inspired by and mostly compatible with
+// Google Test for C++ and Google JS Test.
+//
+// This package is used by github.com/smartystreets/assertions/internal/ogletest and
+// github.com/smartystreets/assertions/internal/oglemock, which may be more directly useful if you're not
+// writing your own testing package or defining your own matchers.
+package oglematchers
+
+// A Matcher is some predicate implicitly defining a set of values that it
+// matches. For example, GreaterThan(17) matches all numeric values greater
+// than 17, and HasSubstr("taco") matches all strings with the substring
+// "taco".
+//
+// Matchers are typically exposed to tests via constructor functions like
+// HasSubstr. In order to implement such a function you can either define your
+// own matcher type or use NewMatcher.
+type Matcher interface {
+	// Check whether the supplied value belongs to the the set defined by the
+	// matcher. Return a non-nil error if and only if it does not.
+	//
+	// The error describes why the value doesn't match. The error text is a
+	// relative clause that is suitable for being placed after the value. For
+	// example, a predicate that matches strings with a particular substring may,
+	// when presented with a numerical value, return the following error text:
+	//
+	//     "which is not a string"
+	//
+	// Then the failure message may look like:
+	//
+	//     Expected: has substring "taco"
+	//     Actual:   17, which is not a string
+	//
+	// If the error is self-apparent based on the description of the matcher, the
+	// error text may be empty (but the error still non-nil). For example:
+	//
+	//     Expected: 17
+	//     Actual:   19
+	//
+	// If you are implementing a new matcher, see also the documentation on
+	// FatalError.
+	Matches(candidate interface{}) error
+
+	// Description returns a string describing the property that values matching
+	// this matcher have, as a verb phrase where the subject is the value. For
+	// example, "is greather than 17" or "has substring "taco"".
+	Description() string
+}
+
+// FatalError is an implementation of the error interface that may be returned
+// from matchers, indicating the error should be propagated. Returning a
+// *FatalError indicates that the matcher doesn't process values of the
+// supplied type, or otherwise doesn't know how to handle the value.
+//
+// For example, if GreaterThan(17) returned false for the value "taco" without
+// a fatal error, then Not(GreaterThan(17)) would return true. This is
+// technically correct, but is surprising and may mask failures where the wrong
+// sort of matcher is accidentally used. Instead, GreaterThan(17) can return a
+// fatal error, which will be propagated by Not().
+type FatalError struct {
+	errorText string
+}
+
+// NewFatalError creates a FatalError struct with the supplied error text.
+func NewFatalError(s string) *FatalError {
+	return &FatalError{s}
+}
+
+func (e *FatalError) Error() string {
+	return e.errorText
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp.go
new file mode 100644
index 00000000000..1ed63f30c4e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp.go
@@ -0,0 +1,69 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+)
+
+// MatchesRegexp returns a matcher that matches strings and byte slices whose
+// contents match the supplied regular expression. The semantics are those of
+// regexp.Match. In particular, that means the match is not implicitly anchored
+// to the ends of the string: MatchesRegexp("bar") will match "foo bar baz".
+func MatchesRegexp(pattern string) Matcher {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		panic("MatchesRegexp: " + err.Error())
+	}
+
+	return &matchesRegexpMatcher{re}
+}
+
+type matchesRegexpMatcher struct {
+	re *regexp.Regexp
+}
+
+func (m *matchesRegexpMatcher) Description() string {
+	return fmt.Sprintf("matches regexp \"%s\"", m.re.String())
+}
+
+func (m *matchesRegexpMatcher) Matches(c interface{}) (err error) {
+	v := reflect.ValueOf(c)
+	isString := v.Kind() == reflect.String
+	isByteSlice := v.Kind() == reflect.Slice && v.Elem().Kind() == reflect.Uint8
+
+	err = errors.New("")
+
+	switch {
+	case isString:
+		if m.re.MatchString(v.String()) {
+			err = nil
+		}
+
+	case isByteSlice:
+		if m.re.Match(v.Bytes()) {
+			err = nil
+		}
+
+	default:
+		err = NewFatalError("which is not a string or []byte")
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp_test.go
new file mode 100644
index 00000000000..031c6cb3eff
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matches_regexp_test.go
@@ -0,0 +1,92 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type MatchesRegexpTest struct {
+}
+
+func init() { RegisterTestSuite(&MatchesRegexpTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *MatchesRegexpTest) Description() {
+	m := MatchesRegexp("foo.*bar")
+	ExpectEq("matches regexp \"foo.*bar\"", m.Description())
+}
+
+func (t *MatchesRegexpTest) InvalidRegexp() {
+	ExpectThat(
+		func() { MatchesRegexp("(foo") },
+		Panics(HasSubstr("missing closing )")))
+}
+
+func (t *MatchesRegexpTest) CandidateIsNil() {
+	m := MatchesRegexp("")
+	err := m.Matches(nil)
+
+	ExpectThat(err, Error(Equals("which is not a string or []byte")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *MatchesRegexpTest) CandidateIsInteger() {
+	m := MatchesRegexp("")
+	err := m.Matches(17)
+
+	ExpectThat(err, Error(Equals("which is not a string or []byte")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *MatchesRegexpTest) NonMatchingCandidates() {
+	m := MatchesRegexp("fo[op]\\s+x")
+	var err error
+
+	err = m.Matches("fon x")
+	ExpectThat(err, Error(Equals("")))
+	ExpectFalse(isFatal(err))
+
+	err = m.Matches("fopx")
+	ExpectThat(err, Error(Equals("")))
+	ExpectFalse(isFatal(err))
+
+	err = m.Matches("fop   ")
+	ExpectThat(err, Error(Equals("")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *MatchesRegexpTest) MatchingCandidates() {
+	m := MatchesRegexp("fo[op]\\s+x")
+	var err error
+
+	err = m.Matches("foo x")
+	ExpectEq(nil, err)
+
+	err = m.Matches("fop     x")
+	ExpectEq(nil, err)
+
+	err = m.Matches("blah blah foo x blah blah")
+	ExpectEq(nil, err)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/new_matcher.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/new_matcher.go
new file mode 100644
index 00000000000..c9d8398ee63
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/new_matcher.go
@@ -0,0 +1,43 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+// Create a matcher with the given description and predicate function, which
+// will be invoked to handle calls to Matchers.
+//
+// Using this constructor may be a convenience over defining your own type that
+// implements Matcher if you do not need any logic in your Description method.
+func NewMatcher(
+	predicate func(interface{}) error,
+	description string) Matcher {
+	return &predicateMatcher{
+		predicate:   predicate,
+		description: description,
+	}
+}
+
+type predicateMatcher struct {
+	predicate   func(interface{}) error
+	description string
+}
+
+func (pm *predicateMatcher) Matches(c interface{}) error {
+	return pm.predicate(c)
+}
+
+func (pm *predicateMatcher) Description() string {
+	return pm.description
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not.go
new file mode 100644
index 00000000000..623789fe28a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not.go
@@ -0,0 +1,53 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Not returns a matcher that inverts the set of values matched by the wrapped
+// matcher. It does not transform the result for values for which the wrapped
+// matcher returns a fatal error.
+func Not(m Matcher) Matcher {
+	return &notMatcher{m}
+}
+
+type notMatcher struct {
+	wrapped Matcher
+}
+
+func (m *notMatcher) Matches(c interface{}) (err error) {
+	err = m.wrapped.Matches(c)
+
+	// Did the wrapped matcher say yes?
+	if err == nil {
+		return errors.New("")
+	}
+
+	// Did the wrapped matcher return a fatal error?
+	if _, isFatal := err.(*FatalError); isFatal {
+		return err
+	}
+
+	// The wrapped matcher returned a non-fatal error.
+	return nil
+}
+
+func (m *notMatcher) Description() string {
+	return fmt.Sprintf("not(%s)", m.wrapped.Description())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not_test.go
new file mode 100644
index 00000000000..9c65b85ef87
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not_test.go
@@ -0,0 +1,108 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"errors"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type fakeMatcher struct {
+	matchFunc   func(interface{}) error
+	description string
+}
+
+func (m *fakeMatcher) Matches(c interface{}) error {
+	return m.matchFunc(c)
+}
+
+func (m *fakeMatcher) Description() string {
+	return m.description
+}
+
+type NotTest struct {
+
+}
+
+func init()                     { RegisterTestSuite(&NotTest{}) }
+func TestOgletest(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *NotTest) CallsWrapped() {
+	var suppliedCandidate interface{}
+	matchFunc := func(c interface{}) error {
+		suppliedCandidate = c
+		return nil
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Not(wrapped)
+
+	matcher.Matches(17)
+	ExpectThat(suppliedCandidate, Equals(17))
+}
+
+func (t *NotTest) WrappedReturnsTrue() {
+	matchFunc := func(c interface{}) error {
+		return nil
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Not(wrapped)
+
+	err := matcher.Matches(0)
+	ExpectThat(err, Error(Equals("")))
+}
+
+func (t *NotTest) WrappedReturnsNonFatalError() {
+	matchFunc := func(c interface{}) error {
+		return errors.New("taco")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Not(wrapped)
+
+	err := matcher.Matches(0)
+	ExpectEq(nil, err)
+}
+
+func (t *NotTest) WrappedReturnsFatalError() {
+	matchFunc := func(c interface{}) error {
+		return NewFatalError("taco")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Not(wrapped)
+
+	err := matcher.Matches(0)
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *NotTest) Description() {
+	wrapped := &fakeMatcher{nil, "taco"}
+	matcher := Not(wrapped)
+
+	ExpectEq("not(taco)", matcher.Description())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics.go
new file mode 100644
index 00000000000..d2cfc97869b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics.go
@@ -0,0 +1,74 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Panics matches zero-arg functions which, when invoked, panic with an error
+// that matches the supplied matcher.
+//
+// NOTE(jacobsa): This matcher cannot detect the case where the function panics
+// using panic(nil), by design of the language. See here for more info:
+//
+//     http://goo.gl/9aIQL
+//
+func Panics(m Matcher) Matcher {
+	return &panicsMatcher{m}
+}
+
+type panicsMatcher struct {
+	wrappedMatcher Matcher
+}
+
+func (m *panicsMatcher) Description() string {
+	return "panics with: " + m.wrappedMatcher.Description()
+}
+
+func (m *panicsMatcher) Matches(c interface{}) (err error) {
+	// Make sure c is a zero-arg function.
+	v := reflect.ValueOf(c)
+	if v.Kind() != reflect.Func || v.Type().NumIn() != 0 {
+		err = NewFatalError("which is not a zero-arg function")
+		return
+	}
+
+	// Call the function and check its panic error.
+	defer func() {
+		if e := recover(); e != nil {
+			err = m.wrappedMatcher.Matches(e)
+
+			// Set a clearer error message if the matcher said no.
+			if err != nil {
+				wrappedClause := ""
+				if err.Error() != "" {
+					wrappedClause = ", " + err.Error()
+				}
+
+				err = errors.New(fmt.Sprintf("which panicked with: %v%s", e, wrappedClause))
+			}
+		}
+	}()
+
+	v.Call([]reflect.Value{})
+
+	// If we get here, the function didn't panic.
+	err = errors.New("which didn't panic")
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics_test.go
new file mode 100644
index 00000000000..fbb66bf31e2
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics_test.go
@@ -0,0 +1,141 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"errors"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type PanicsTest struct {
+	matcherCalled bool
+	suppliedCandidate interface{}
+	wrappedError error
+
+	matcher Matcher
+}
+
+func init() { RegisterTestSuite(&PanicsTest{}) }
+
+func (t *PanicsTest) SetUp(i *TestInfo) {
+	wrapped := &fakeMatcher{
+		func(c interface{}) error {
+			t.matcherCalled = true
+			t.suppliedCandidate = c
+			return t.wrappedError
+		},
+		"foo",
+	}
+
+	t.matcher = Panics(wrapped)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *PanicsTest) Description() {
+	ExpectThat(t.matcher.Description(), Equals("panics with: foo"))
+}
+
+func (t *PanicsTest) CandidateIsNil() {
+	err := t.matcher.Matches(nil)
+
+	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PanicsTest) CandidateIsString() {
+	err := t.matcher.Matches("taco")
+
+	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PanicsTest) CandidateTakesArgs() {
+	err := t.matcher.Matches(func(i int) string { return "" })
+
+	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PanicsTest) CallsFunction() {
+	callCount := 0
+	t.matcher.Matches(func() string {
+		callCount++
+		return ""
+	})
+
+	ExpectThat(callCount, Equals(1))
+}
+
+func (t *PanicsTest) FunctionDoesntPanic() {
+	err := t.matcher.Matches(func() {})
+
+	ExpectThat(err, Error(Equals("which didn't panic")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *PanicsTest) CallsWrappedMatcher() {
+	expectedErr := 17
+	t.wrappedError = errors.New("")
+	t.matcher.Matches(func() { panic(expectedErr) })
+
+	ExpectThat(t.suppliedCandidate, Equals(expectedErr))
+}
+
+func (t *PanicsTest) WrappedReturnsTrue() {
+	err := t.matcher.Matches(func() { panic("") })
+
+	ExpectEq(nil, err)
+}
+
+func (t *PanicsTest) WrappedReturnsFatalErrorWithoutText() {
+	t.wrappedError = NewFatalError("")
+	err := t.matcher.Matches(func() { panic(17) })
+
+	ExpectThat(err, Error(Equals("which panicked with: 17")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *PanicsTest) WrappedReturnsFatalErrorWithText() {
+	t.wrappedError = NewFatalError("which blah")
+	err := t.matcher.Matches(func() { panic(17) })
+
+	ExpectThat(err, Error(Equals("which panicked with: 17, which blah")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *PanicsTest) WrappedReturnsNonFatalErrorWithoutText() {
+	t.wrappedError = errors.New("")
+	err := t.matcher.Matches(func() { panic(17) })
+
+	ExpectThat(err, Error(Equals("which panicked with: 17")))
+	ExpectFalse(isFatal(err))
+}
+
+func (t *PanicsTest) WrappedReturnsNonFatalErrorWithText() {
+	t.wrappedError = errors.New("which blah")
+	err := t.matcher.Matches(func() { panic(17) })
+
+	ExpectThat(err, Error(Equals("which panicked with: 17, which blah")))
+	ExpectFalse(isFatal(err))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee.go
new file mode 100644
index 00000000000..c5383f2402f
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee.go
@@ -0,0 +1,65 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Return a matcher that matches non-nil pointers whose pointee matches the
+// wrapped matcher.
+func Pointee(m Matcher) Matcher {
+	return &pointeeMatcher{m}
+}
+
+type pointeeMatcher struct {
+	wrapped Matcher
+}
+
+func (m *pointeeMatcher) Matches(c interface{}) (err error) {
+	// Make sure the candidate is of the appropriate type.
+	cv := reflect.ValueOf(c)
+	if !cv.IsValid() || cv.Kind() != reflect.Ptr {
+		return NewFatalError("which is not a pointer")
+	}
+
+	// Make sure the candidate is non-nil.
+	if cv.IsNil() {
+		return NewFatalError("")
+	}
+
+	// Defer to the wrapped matcher. Fix up empty errors so that failure messages
+	// are more helpful than just printing a pointer for "Actual".
+	pointee := cv.Elem().Interface()
+	err = m.wrapped.Matches(pointee)
+	if err != nil && err.Error() == "" {
+		s := fmt.Sprintf("whose pointee is %v", pointee)
+
+		if _, ok := err.(*FatalError); ok {
+			err = NewFatalError(s)
+		} else {
+			err = errors.New(s)
+		}
+	}
+
+	return err
+}
+
+func (m *pointeeMatcher) Description() string {
+	return fmt.Sprintf("pointee(%s)", m.wrapped.Description())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee_test.go
new file mode 100644
index 00000000000..3bb72a702be
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee_test.go
@@ -0,0 +1,152 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"errors"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type PointeeTest struct {}
+func init()                     { RegisterTestSuite(&PointeeTest{}) }
+
+func TestPointee(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *PointeeTest) Description() {
+	wrapped := &fakeMatcher{nil, "taco"}
+	matcher := Pointee(wrapped)
+
+	ExpectEq("pointee(taco)", matcher.Description())
+}
+
+func (t *PointeeTest) CandidateIsNotAPointer() {
+	matcher := Pointee(HasSubstr(""))
+	err := matcher.Matches([]byte{})
+
+	ExpectThat(err, Error(Equals("which is not a pointer")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PointeeTest) CandidateIsANilLiteral() {
+	matcher := Pointee(HasSubstr(""))
+	err := matcher.Matches(nil)
+
+	ExpectThat(err, Error(Equals("which is not a pointer")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PointeeTest) CandidateIsANilPointer() {
+	matcher := Pointee(HasSubstr(""))
+	err := matcher.Matches((*int)(nil))
+
+	ExpectThat(err, Error(Equals("")))
+	ExpectTrue(isFatal(err))
+}
+
+func (t *PointeeTest) CallsWrapped() {
+	var suppliedCandidate interface{}
+	matchFunc := func(c interface{}) error {
+		suppliedCandidate = c
+		return nil
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	someSlice := []byte{}
+	matcher.Matches(&someSlice)
+	ExpectThat(suppliedCandidate, IdenticalTo(someSlice))
+}
+
+func (t *PointeeTest) WrappedReturnsOkay() {
+	matchFunc := func(c interface{}) error {
+		return nil
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	err := matcher.Matches(new(int))
+	ExpectEq(nil, err)
+}
+
+func (t *PointeeTest) WrappedReturnsNonFatalNonEmptyError() {
+	matchFunc := func(c interface{}) error {
+		return errors.New("taco")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	i := 17
+	err := matcher.Matches(&i)
+	ExpectFalse(isFatal(err))
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *PointeeTest) WrappedReturnsNonFatalEmptyError() {
+	matchFunc := func(c interface{}) error {
+		return errors.New("")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	i := 17
+	err := matcher.Matches(&i)
+	ExpectFalse(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("whose pointee")))
+	ExpectThat(err, Error(HasSubstr("17")))
+}
+
+func (t *PointeeTest) WrappedReturnsFatalNonEmptyError() {
+	matchFunc := func(c interface{}) error {
+		return NewFatalError("taco")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	i := 17
+	err := matcher.Matches(&i)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(Equals("taco")))
+}
+
+func (t *PointeeTest) WrappedReturnsFatalEmptyError() {
+	matchFunc := func(c interface{}) error {
+		return NewFatalError("")
+	}
+
+	wrapped := &fakeMatcher{matchFunc, ""}
+	matcher := Pointee(wrapped)
+
+	i := 17
+	err := matcher.Matches(&i)
+	ExpectTrue(isFatal(err))
+	ExpectThat(err, Error(HasSubstr("whose pointee")))
+	ExpectThat(err, Error(HasSubstr("17")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/transform_description.go b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/transform_description.go
new file mode 100644
index 00000000000..f79d0c03db1
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/transform_description.go
@@ -0,0 +1,36 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+// transformDescription returns a matcher that is equivalent to the supplied
+// one, except that it has the supplied description instead of the one attached
+// to the existing matcher.
+func transformDescription(m Matcher, newDesc string) Matcher {
+	return &transformDescriptionMatcher{newDesc, m}
+}
+
+type transformDescriptionMatcher struct {
+	desc string
+	wrappedMatcher Matcher
+}
+
+func (m *transformDescriptionMatcher) Description() string {
+	return m.desc
+}
+
+func (m *transformDescriptionMatcher) Matches(c interface{}) error {
+	return m.wrappedMatcher.Matches(c)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.gitignore b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.gitignore
new file mode 100644
index 00000000000..dd8fc7468f4
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.gitignore
@@ -0,0 +1,5 @@
+*.6
+6.out
+_obj/
+_test/
+_testmain.go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.travis.yml b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.travis.yml
new file mode 100644
index 00000000000..b97211926e8
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.travis.yml
@@ -0,0 +1,4 @@
+# Cf. http://docs.travis-ci.com/user/getting-started/
+# Cf. http://docs.travis-ci.com/user/languages/go/
+
+language: go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/LICENSE b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/README.md b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/README.md
new file mode 100644
index 00000000000..c5cb5c06b33
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/README.md
@@ -0,0 +1,103 @@
+[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/oglemock?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/oglemock)
+
+`oglemock` is a mocking framework for the Go programming language with the
+following features:
+
+ *  An extensive and extensible set of matchers for expressing call
+    expectations (provided by the [oglematchers][] package).
+
+ *  Clean, readable output that tells you exactly what you need to know.
+
+ *  Style and semantics similar to [Google Mock][googlemock] and
+    [Google JS Test][google-js-test].
+
+ *  Seamless integration with the [ogletest][] unit testing framework.
+
+It can be integrated into any testing framework (including Go's `testing`
+package), but out of the box support is built in to [ogletest][] and that is the
+easiest place to use it.
+
+
+Installation
+------------
+
+First, make sure you have installed Go 1.0.2 or newer. See
+[here][golang-install] for instructions.
+
+Use the following command to install `oglemock` and its dependencies, and to
+keep them up to date:
+
+    go get -u github.com/smartystreets/assertions/internal/oglemock
+    go get -u github.com/smartystreets/assertions/internal/oglemock/createmock
+
+Those commands will install the `oglemock` package itself, along with the
+`createmock` tool that is used to auto-generate mock types.
+
+
+Generating and using mock types
+-------------------------------
+
+Automatically generating a mock implementation of an interface is easy. If you
+want to mock interfaces `Bar` and `Baz` from package `foo`, simply run the
+following:
+
+    createmock foo Bar Baz
+
+That will print source code that can be saved to a file and used in your tests.
+For example, to create a `mock_io` package containing mock implementations of
+`io.Reader` and `io.Writer`:
+
+    mkdir mock_io
+    createmock io Reader Writer > mock_io/mock_io.go
+
+The new package will be named `mock_io`, and contain types called `MockReader`
+and `MockWriter`, which implement `io.Reader` and `io.Writer` respectively.
+
+For each generated mock type, there is a corresponding function for creating an
+instance of that type given a `Controller` object (see below). For example, to
+create a mock reader:
+
+```go
+someController := [...]  // See next section.
+someReader := mock_io.NewMockReader(someController, "Mock file reader")
+```
+
+The snippet above creates a mock `io.Reader` that reports failures to
+`someController`. The reader can subsequently have expectations set up and be
+passed to your code under test that uses an `io.Reader`.
+
+
+Getting ahold of a controller
+-----------------------------
+
+[oglemock.Controller][controller-ref] is used to create mock objects, and to set
+up and verify expectations for them. You can create one by calling
+`NewController` with an `ErrorReporter`, which is the basic type used to
+interface between `oglemock` and the testing framework within which it is being
+used.
+
+If you are using [ogletest][] you don't need to worry about any of this, since
+the `TestInfo` struct provided to your test's `SetUp` function already contains
+a working `Controller` that you can use to create mock object, and you can use
+the built-in `ExpectCall` function for setting expectations. (See the
+[ogletest documentation][ogletest-docs] for more info.) Otherwise, you will need
+to implement the simple [ErrorReporter interface][reporter-ref] for your test
+environment.
+
+
+Documentation
+-------------
+
+For thorough documentation, including information on how to set up expectations,
+see [here][oglemock-docs].
+
+
+[controller-ref]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock#Controller
+[reporter-ref]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock#ErrorReporter
+[golang-install]: http://golang.org/doc/install.html
+[google-js-test]: http://code.google.com/p/google-js-test/
+[googlemock]: http://code.google.com/p/googlemock/
+[oglematchers]: https://github.com/smartystreets/assertions/internal/oglematchers
+[oglemock-docs]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock
+[ogletest]: https://github.com/smartystreets/assertions/internal/ogletest
+[ogletest-docs]: http://godoc.org/github.com/smartystreets/assertions/internal/ogletest
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/action.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/action.go
new file mode 100644
index 00000000000..9fd40d81fe8
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/action.go
@@ -0,0 +1,36 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"reflect"
+)
+
+// Action represents an action to be taken in response to a call to a mock
+// method.
+type Action interface {
+	// Set the signature of the function with which this action is being used.
+	// This must be called before Invoke is called.
+	SetSignature(signature reflect.Type) error
+
+	// Invoke runs the specified action, given the arguments to the mock method.
+	// It returns zero or more values that may be treated as the return values of
+	// the method. If the action doesn't return any values, it may return the nil
+	// slice.
+	//
+	// You must call SetSignature before calling Invoke.
+	Invoke(methodArgs []interface{}) []interface{}
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller.go
new file mode 100644
index 00000000000..93a1d6239e1
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller.go
@@ -0,0 +1,480 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"math"
+	"reflect"
+	"sync"
+)
+
+// PartialExpecation is a function that should be called exactly once with
+// expected arguments or matchers in order to set up an expected method call.
+// See Controller.ExpectMethodCall below. It returns an expectation that can be
+// further modified (e.g. by calling WillOnce).
+//
+// If the arguments are of the wrong type, the function reports a fatal error
+// and returns nil.
+type PartialExpecation func(...interface{}) Expectation
+
+// Controller represents an object that implements the central logic of
+// oglemock: recording and verifying expectations, responding to mock method
+// calls, and so on.
+type Controller interface {
+	// ExpectCall expresses an expectation that the method of the given name
+	// should be called on the supplied mock object. It returns a function that
+	// should be called with the expected arguments, matchers for the arguments,
+	// or a mix of both.
+	//
+	// fileName and lineNumber should indicate the line on which the expectation
+	// was made, if known.
+	//
+	// For example:
+	//
+	//     mockWriter := [...]
+	//     controller.ExpectCall(mockWriter, "Write", "foo.go", 17)(ElementsAre(0x1))
+	//         .WillOnce(Return(1, nil))
+	//
+	// If the mock object doesn't have a method of the supplied name, the
+	// function reports a fatal error and returns nil.
+	ExpectCall(
+		o MockObject,
+		methodName string,
+		fileName string,
+		lineNumber int) PartialExpecation
+
+	// Finish causes the controller to check for any unsatisfied expectations,
+	// and report them as errors if they exist.
+	//
+	// The controller may panic if any of its methods (including this one) are
+	// called after Finish is called.
+	Finish()
+
+	// HandleMethodCall looks for a registered expectation matching the call of
+	// the given method on mock object o, invokes the appropriate action (if
+	// any), and returns the values returned by that action (if any).
+	//
+	// If the action returns nothing, the controller returns zero values. If
+	// there is no matching expectation, the controller reports an error and
+	// returns zero values.
+	//
+	// If the mock object doesn't have a method of the supplied name, the
+	// arguments are of the wrong type, or the action returns the wrong types,
+	// the function reports a fatal error.
+	//
+	// HandleMethodCall is exported for the sake of mock implementations, and
+	// should not be used directly.
+	HandleMethodCall(
+		o MockObject,
+		methodName string,
+		fileName string,
+		lineNumber int,
+		args []interface{}) []interface{}
+}
+
+// methodMap represents a map from method name to set of expectations for that
+// method.
+type methodMap map[string][]*InternalExpectation
+
+// objectMap represents a map from mock object ID to a methodMap for that object.
+type objectMap map[uintptr]methodMap
+
+// NewController sets up a fresh controller, without any expectations set, and
+// configures the controller to use the supplied error reporter.
+func NewController(reporter ErrorReporter) Controller {
+	return &controllerImpl{reporter, sync.RWMutex{}, objectMap{}}
+}
+
+type controllerImpl struct {
+	reporter ErrorReporter
+
+	mutex                sync.RWMutex
+	expectationsByObject objectMap // Protected by mutex
+}
+
+// Return the list of registered expectations for the named method of the
+// supplied object, or an empty slice if none have been registered. When this
+// method returns, it is guaranteed that c.expectationsByObject has an entry
+// for the object.
+//
+// c.mutex must be held for reading.
+func (c *controllerImpl) getExpectationsLocked(
+	o MockObject,
+	methodName string) []*InternalExpectation {
+	id := o.Oglemock_Id()
+
+	// Look up the mock object.
+	expectationsByMethod, ok := c.expectationsByObject[id]
+	if !ok {
+		expectationsByMethod = methodMap{}
+		c.expectationsByObject[id] = expectationsByMethod
+	}
+
+	result, ok := expectationsByMethod[methodName]
+	if !ok {
+		return []*InternalExpectation{}
+	}
+
+	return result
+}
+
+// Add an expectation to the list registered for the named method of the
+// supplied mock object.
+//
+// c.mutex must be held for writing.
+func (c *controllerImpl) addExpectationLocked(
+	o MockObject,
+	methodName string,
+	exp *InternalExpectation) {
+	// Get the existing list.
+	existing := c.getExpectationsLocked(o, methodName)
+
+	// Store a modified list.
+	id := o.Oglemock_Id()
+	c.expectationsByObject[id][methodName] = append(existing, exp)
+}
+
+func (c *controllerImpl) ExpectCall(
+	o MockObject,
+	methodName string,
+	fileName string,
+	lineNumber int) PartialExpecation {
+	// Find the signature for the requested method.
+	ov := reflect.ValueOf(o)
+	method := ov.MethodByName(methodName)
+	if method.Kind() == reflect.Invalid {
+		c.reporter.ReportFatalError(
+			fileName,
+			lineNumber,
+			errors.New("Unknown method: "+methodName))
+		return nil
+	}
+
+	partialAlreadyCalled := false // Protected by c.mutex
+	return func(args ...interface{}) Expectation {
+		c.mutex.Lock()
+		defer c.mutex.Unlock()
+
+		// This function should only be called once.
+		if partialAlreadyCalled {
+			c.reporter.ReportFatalError(
+				fileName,
+				lineNumber,
+				errors.New("Partial expectation called more than once."))
+			return nil
+		}
+
+		partialAlreadyCalled = true
+
+		// Make sure that the number of args is legal. Keep in mind that the
+		// method's type has an extra receiver arg.
+		if len(args) != method.Type().NumIn() {
+			c.reporter.ReportFatalError(
+				fileName,
+				lineNumber,
+				errors.New(
+					fmt.Sprintf(
+						"Expectation for %s given wrong number of arguments: "+
+							"expected %d, got %d.",
+						methodName,
+						method.Type().NumIn(),
+						len(args))))
+			return nil
+		}
+
+		// Create an expectation and insert it into the controller's map.
+		exp := InternalNewExpectation(
+			c.reporter,
+			method.Type(),
+			args,
+			fileName,
+			lineNumber)
+
+		c.addExpectationLocked(o, methodName, exp)
+
+		// Return the expectation to the user.
+		return exp
+	}
+}
+
+func (c *controllerImpl) Finish() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// Check whether the minimum cardinality for each registered expectation has
+	// been satisfied.
+	for _, expectationsByMethod := range c.expectationsByObject {
+		for methodName, expectations := range expectationsByMethod {
+			for _, exp := range expectations {
+				exp.mutex.Lock()
+				defer exp.mutex.Unlock()
+
+				minCardinality, _ := computeCardinalityLocked(exp)
+				if exp.NumMatches < minCardinality {
+					c.reporter.ReportError(
+						exp.FileName,
+						exp.LineNumber,
+						errors.New(
+							fmt.Sprintf(
+								"Unsatisfied expectation; expected %s to be called "+
+									"at least %d times; called %d times.",
+								methodName,
+								minCardinality,
+								exp.NumMatches)))
+				}
+			}
+		}
+	}
+}
+
+// expectationMatches checks the matchers for the expectation against the
+// supplied arguments.
+func expectationMatches(exp *InternalExpectation, args []interface{}) bool {
+	matchers := exp.ArgMatchers
+	if len(args) != len(matchers) {
+		panic("expectationMatches: len(args)")
+	}
+
+	// Check each matcher.
+	for i, matcher := range matchers {
+		if err := matcher.Matches(args[i]); err != nil {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Return the expectation that matches the supplied arguments. If there is more
+// than one such expectation, the one furthest along in the list for the method
+// is returned. If there is no such expectation, nil is returned.
+//
+// c.mutex must be held for reading.
+func (c *controllerImpl) chooseExpectationLocked(
+	o MockObject,
+	methodName string,
+	args []interface{}) *InternalExpectation {
+	// Do we have any expectations for this method?
+	expectations := c.getExpectationsLocked(o, methodName)
+	if len(expectations) == 0 {
+		return nil
+	}
+
+	for i := len(expectations) - 1; i >= 0; i-- {
+		if expectationMatches(expectations[i], args) {
+			return expectations[i]
+		}
+	}
+
+	return nil
+}
+
+// makeZeroReturnValues creates a []interface{} containing appropriate zero
+// values for returning from the supplied method type.
+func makeZeroReturnValues(signature reflect.Type) []interface{} {
+	result := make([]interface{}, signature.NumOut())
+
+	for i, _ := range result {
+		outType := signature.Out(i)
+		zeroVal := reflect.Zero(outType)
+		result[i] = zeroVal.Interface()
+	}
+
+	return result
+}
+
+// computeCardinality decides on the [min, max] range of the number of expected
+// matches for the supplied expectations, according to the rules documented in
+// expectation.go.
+//
+// exp.mutex must be held for reading.
+func computeCardinalityLocked(exp *InternalExpectation) (min, max uint) {
+	// Explicit cardinality.
+	if exp.ExpectedNumMatches >= 0 {
+		min = uint(exp.ExpectedNumMatches)
+		max = min
+		return
+	}
+
+	// Implicit count based on one-time actions.
+	if len(exp.OneTimeActions) != 0 {
+		min = uint(len(exp.OneTimeActions))
+		max = min
+
+		// If there is a fallback action, this is only a lower bound.
+		if exp.FallbackAction != nil {
+			max = math.MaxUint32
+		}
+
+		return
+	}
+
+	// Implicit lack of restriction based on a fallback action being configured.
+	if exp.FallbackAction != nil {
+		min = 0
+		max = math.MaxUint32
+		return
+	}
+
+	// Implicit cardinality of one.
+	min = 1
+	max = 1
+	return
+}
+
+// chooseAction returns the action that should be invoked for the i'th match to
+// the supplied expectation (counting from zero). If the implicit "return zero
+// values" action should be used, it returns nil.
+//
+// exp.mutex must be held for reading.
+func chooseActionLocked(i uint, exp *InternalExpectation) Action {
+	// Exhaust one-time actions first.
+	if i < uint(len(exp.OneTimeActions)) {
+		return exp.OneTimeActions[i]
+	}
+
+	// Fallback action (or nil if none is configured).
+	return exp.FallbackAction
+}
+
+// Find an action for the method call, updating expectation match state in the
+// process. Return either an action that should be invoked or a set of zero
+// values to return immediately.
+//
+// This is split out from HandleMethodCall in order to more easily avoid
+// invoking the action with locks held.
+func (c *controllerImpl) chooseActionAndUpdateExpectations(
+	o MockObject,
+	methodName string,
+	fileName string,
+	lineNumber int,
+	args []interface{},
+) (action Action, zeroVals []interface{}) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// Find the signature for the requested method.
+	ov := reflect.ValueOf(o)
+	method := ov.MethodByName(methodName)
+	if method.Kind() == reflect.Invalid {
+		c.reporter.ReportFatalError(
+			fileName,
+			lineNumber,
+			errors.New("Unknown method: "+methodName),
+		)
+
+		// Should never get here in real code.
+		log.Println("ReportFatalError unexpectedly returned.")
+		return
+	}
+
+	// HACK(jacobsa): Make sure we got the correct number of arguments. This will
+	// need to be refined when issue #5 (variadic methods) is handled.
+	if len(args) != method.Type().NumIn() {
+		c.reporter.ReportFatalError(
+			fileName,
+			lineNumber,
+			errors.New(
+				fmt.Sprintf(
+					"Wrong number of arguments: expected %d; got %d",
+					method.Type().NumIn(),
+					len(args),
+				),
+			),
+		)
+
+		// Should never get here in real code.
+		log.Println("ReportFatalError unexpectedly returned.")
+		return
+	}
+
+	// Find an expectation matching this call.
+	expectation := c.chooseExpectationLocked(o, methodName, args)
+	if expectation == nil {
+		c.reporter.ReportError(
+			fileName,
+			lineNumber,
+			errors.New(
+				fmt.Sprintf("Unexpected call to %s with args: %v", methodName, args),
+			),
+		)
+
+		zeroVals = makeZeroReturnValues(method.Type())
+		return
+	}
+
+	expectation.mutex.Lock()
+	defer expectation.mutex.Unlock()
+
+	// Increase the number of matches recorded, and check whether we're over the
+	// number expected.
+	expectation.NumMatches++
+	_, maxCardinality := computeCardinalityLocked(expectation)
+	if expectation.NumMatches > maxCardinality {
+		c.reporter.ReportError(
+			expectation.FileName,
+			expectation.LineNumber,
+			errors.New(
+				fmt.Sprintf(
+					"Unexpected call to %s: "+
+						"expected to be called at most %d times; called %d times.",
+					methodName,
+					maxCardinality,
+					expectation.NumMatches,
+				),
+			),
+		)
+
+		zeroVals = makeZeroReturnValues(method.Type())
+		return
+	}
+
+	// Choose an action to invoke. If there is none, just return zero values.
+	action = chooseActionLocked(expectation.NumMatches-1, expectation)
+	if action == nil {
+		zeroVals = makeZeroReturnValues(method.Type())
+		return
+	}
+
+	// Let the action take over.
+	return
+}
+
+func (c *controllerImpl) HandleMethodCall(
+	o MockObject,
+	methodName string,
+	fileName string,
+	lineNumber int,
+	args []interface{},
+) []interface{} {
+	// Figure out whether to invoke an action or return zero values.
+	action, zeroVals := c.chooseActionAndUpdateExpectations(
+		o,
+		methodName,
+		fileName,
+		lineNumber,
+		args,
+	)
+
+	if action != nil {
+		return action.Invoke(args)
+	}
+
+	return zeroVals
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller_test.go
new file mode 100644
index 00000000000..0ff5e5c41bb
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller_test.go
@@ -0,0 +1,1249 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"reflect"
+)
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+type errorReport struct {
+	fileName   string
+	lineNumber int
+	err        error
+}
+
+type fakeErrorReporter struct {
+	errors      []errorReport
+	fatalErrors []errorReport
+}
+
+func (r *fakeErrorReporter) ReportError(fileName string, lineNumber int, err error) {
+	report := errorReport{fileName, lineNumber, err}
+	r.errors = append(r.errors, report)
+}
+
+func (r *fakeErrorReporter) ReportFatalError(fileName string, lineNumber int, err error) {
+	report := errorReport{fileName, lineNumber, err}
+	r.fatalErrors = append(r.fatalErrors, report)
+}
+
+type trivialMockObject struct {
+	id   uintptr
+	desc string
+}
+
+func (o *trivialMockObject) Oglemock_Id() uintptr {
+	return o.id
+}
+
+func (o *trivialMockObject) Oglemock_Description() string {
+	return o.desc
+}
+
+// Method being mocked
+func (o *trivialMockObject) StringToInt(s string) int {
+	return 0
+}
+
+// Method being mocked
+func (o *trivialMockObject) TwoIntsToString(i, j int) string {
+	return ""
+}
+
+type ControllerTest struct {
+	reporter   fakeErrorReporter
+	controller Controller
+
+	mock1 MockObject
+	mock2 MockObject
+}
+
+func (t *ControllerTest) SetUp(c *TestInfo) {
+	t.reporter.errors = make([]errorReport, 0)
+	t.reporter.fatalErrors = make([]errorReport, 0)
+	t.controller = NewController(&t.reporter)
+
+	t.mock1 = &trivialMockObject{17, "taco"}
+	t.mock2 = &trivialMockObject{19, "burrito"}
+}
+
+func init() { RegisterTestSuite(&ControllerTest{}) }
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *ControllerTest) FinishWithoutAnyEvents() {
+	t.controller.Finish()
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) HandleCallForUnknownObject() {
+	p := []byte{255}
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"taco.go",
+		112,
+		[]interface{}{p})
+
+	// The error should be reported immediately.
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("taco.go", t.reporter.errors[0].fileName)
+	ExpectEq(112, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("[255]")))
+
+	// Finish should change nothing.
+	t.controller.Finish()
+
+	ExpectEq(1, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ExpectCallForUnknownMethod() {
+	ExpectEq(
+		nil,
+		t.controller.ExpectCall(t.mock1, "Frobnicate", "burrito.go", 117))
+
+	// A fatal error should be reported immediately.
+	AssertEq(0, len(t.reporter.errors))
+	AssertEq(1, len(t.reporter.fatalErrors))
+
+	report := t.reporter.fatalErrors[0]
+	ExpectEq("burrito.go", report.fileName)
+	ExpectEq(117, report.lineNumber)
+	ExpectThat(report.err, Error(HasSubstr("Unknown method")))
+	ExpectThat(report.err, Error(HasSubstr("Frobnicate")))
+}
+
+func (t *ControllerTest) PartialExpectationGivenWrongNumberOfArgs() {
+	ExpectEq(
+		nil,
+		t.controller.ExpectCall(t.mock1, "TwoIntsToString", "burrito.go", 117)(
+			17, 19, 23))
+
+	// A fatal error should be reported immediately.
+	AssertEq(0, len(t.reporter.errors))
+	AssertEq(1, len(t.reporter.fatalErrors))
+
+	report := t.reporter.fatalErrors[0]
+	ExpectEq("burrito.go", report.fileName)
+	ExpectEq(117, report.lineNumber)
+	ExpectThat(report.err, Error(HasSubstr("TwoIntsToString")))
+	ExpectThat(report.err, Error(HasSubstr("arguments")))
+	ExpectThat(report.err, Error(HasSubstr("expected 2")))
+	ExpectThat(report.err, Error(HasSubstr("got 3")))
+}
+
+func (t *ControllerTest) PartialExpectationCalledTwice() {
+	partial := t.controller.ExpectCall(t.mock1, "StringToInt", "burrito.go", 117)
+	AssertNe(nil, partial("taco"))
+	ExpectEq(nil, partial("taco"))
+
+	// A fatal error should be reported immediately.
+	AssertEq(0, len(t.reporter.errors))
+	AssertEq(1, len(t.reporter.fatalErrors))
+
+	report := t.reporter.fatalErrors[0]
+	ExpectEq("burrito.go", report.fileName)
+	ExpectEq(117, report.lineNumber)
+	ExpectThat(report.err, Error(HasSubstr("called more than once")))
+}
+
+func (t *ControllerTest) HandleMethodCallForUnknownMethod() {
+	ExpectEq(
+		nil,
+		t.controller.HandleMethodCall(
+			t.mock1,
+			"Frobnicate",
+			"burrito.go",
+			117,
+			[]interface{}{}))
+
+	// A fatal error should be reported immediately.
+	AssertEq(0, len(t.reporter.errors))
+	AssertEq(1, len(t.reporter.fatalErrors))
+
+	report := t.reporter.fatalErrors[0]
+	ExpectEq("burrito.go", report.fileName)
+	ExpectEq(117, report.lineNumber)
+	ExpectThat(report.err, Error(HasSubstr("Unknown method")))
+	ExpectThat(report.err, Error(HasSubstr("Frobnicate")))
+}
+
+func (t *ControllerTest) HandleMethodCallGivenWrongNumberOfArgs() {
+	t.controller.ExpectCall(t.mock1, "TwoIntsToString", "", 0)(17, 19)
+
+	ExpectEq(
+		nil,
+		t.controller.HandleMethodCall(
+			t.mock1,
+			"TwoIntsToString",
+			"burrito.go",
+			117,
+			[]interface{}{17, 19, 23}))
+
+	// A fatal error should be reported immediately.
+	AssertEq(0, len(t.reporter.errors))
+	AssertEq(1, len(t.reporter.fatalErrors))
+
+	report := t.reporter.fatalErrors[0]
+	ExpectEq("burrito.go", report.fileName)
+	ExpectEq(117, report.lineNumber)
+	ExpectThat(report.err, Error(HasSubstr("arguments")))
+	ExpectThat(report.err, Error(HasSubstr("expected 2")))
+	ExpectThat(report.err, Error(HasSubstr("got 3")))
+}
+
+func (t *ControllerTest) ExpectThenNonMatchingCall() {
+	// Expectation -- set up a fallback action to make it optional.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"TwoIntsToString",
+		"burrito.go",
+		117)
+
+	exp := partial(LessThan(10), Equals(2))
+	exp.WillRepeatedly(Return(""))
+
+	// Call
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"TwoIntsToString",
+		"taco.go",
+		112,
+		[]interface{}{8, 1})
+
+	// The error should be reported immediately.
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("taco.go", t.reporter.errors[0].fileName)
+	ExpectEq(112, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("TwoIntsToString")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("[8 1]")))
+
+	// Finish should change nothing.
+	t.controller.Finish()
+
+	ExpectEq(1, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ExplicitCardinalityNotSatisfied() {
+	// Expectation -- set up an explicit cardinality of three.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.Times(3)
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should not yet be reported.
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+
+	// Finish should cause the error to be reported.
+	t.controller.Finish()
+
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times")))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionCountNotSatisfied() {
+	// Expectation -- add three one-time actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+	exp.WillOnce(Return(2))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should not yet be reported.
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+
+	// Finish should cause the error to be reported.
+	t.controller.Finish()
+
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times")))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionLowerBoundNotSatisfied() {
+	// Expectation -- add three one-time actions and a fallback.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+	exp.WillOnce(Return(2))
+	exp.WillRepeatedly(Return(3))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should not yet be reported.
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+
+	// Finish should cause the error to be reported.
+	t.controller.Finish()
+
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times")))
+}
+
+func (t *ControllerTest) ImplicitCardinalityOfOneNotSatisfied() {
+	// Expectation -- add no actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	partial(HasSubstr(""))
+
+	// Don't call.
+
+	// The error should not yet be reported.
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+
+	// Finish should cause the error to be reported.
+	t.controller.Finish()
+
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 1 time")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 0 times")))
+}
+
+func (t *ControllerTest) ExplicitCardinalityOverrun() {
+	// Expectation -- call times(2).
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.Times(2)
+
+	// Call three times.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should be reported immediately.
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 2 times")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 3 times")))
+
+	// Finish should change nothing.
+	t.controller.Finish()
+
+	ExpectEq(1, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionCountOverrun() {
+	// Expectation -- add a one-time action.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should be reported immediately.
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 1 time")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times")))
+
+	// Finish should change nothing.
+	t.controller.Finish()
+
+	ExpectEq(1, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitCardinalityOfOneOverrun() {
+	// Expectation -- don't add any actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	partial(HasSubstr(""))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// The error should be reported immediately.
+	AssertEq(1, len(t.reporter.errors))
+	AssertEq(0, len(t.reporter.fatalErrors))
+
+	ExpectEq("burrito.go", t.reporter.errors[0].fileName)
+	ExpectEq(117, t.reporter.errors[0].lineNumber)
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 1 time")))
+	ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times")))
+
+	// Finish should change nothing.
+	t.controller.Finish()
+
+	ExpectEq(1, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ExplicitCardinalitySatisfied() {
+	// Expectation -- set up an explicit cardinality of two.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.Times(2)
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionCountSatisfied() {
+	// Expectation -- set up two one-time actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionLowerBoundJustSatisfied() {
+	// Expectation -- set up two one-time actions and a fallback.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+	exp.WillRepeatedly(Return(2))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitOneTimeActionLowerBoundMoreThanSatisfied() {
+	// Expectation -- set up two one-time actions and a fallback.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+	exp.WillRepeatedly(Return(2))
+
+	// Call four times.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) FallbackActionConfiguredWithZeroCalls() {
+	// Expectation -- set up a fallback action.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(0))
+
+	// Don't call.
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) FallbackActionConfiguredWithMultipleCalls() {
+	// Expectation -- set up a fallback action.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(0))
+
+	// Call twice.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) ImplicitCardinalityOfOneSatisfied() {
+	// Expectation -- don't add actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	partial(HasSubstr(""))
+
+	// Call once.
+	t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	// There should be no errors.
+	t.controller.Finish()
+
+	ExpectEq(0, len(t.reporter.errors))
+	ExpectEq(0, len(t.reporter.fatalErrors))
+}
+
+func (t *ControllerTest) InvokesOneTimeActions() {
+	var res []interface{}
+
+	// Expectation -- set up two one-time actions.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	suppliedArg := ""
+	expectedReturn := 17
+
+	f := func(s string) int {
+		suppliedArg = s
+		return expectedReturn
+	}
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Invoke(f))
+	exp.WillOnce(Return(1))
+
+	AssertThat(t.reporter.fatalErrors, ElementsAre())
+
+	// Call 0
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{"taco"})
+
+	ExpectEq("taco", suppliedArg)
+	ExpectThat(res, ElementsAre(IdenticalTo(expectedReturn)))
+
+	// Call 1
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(1))
+}
+
+func (t *ControllerTest) InvokesFallbackActionAfterOneTimeActions() {
+	var res []interface{}
+
+	// Expectation -- set up two one-time actions and a fallback.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(0))
+	exp.WillOnce(Return(1))
+	exp.WillRepeatedly(Return(2))
+
+	// Call 0
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(0))
+
+	// Call 1
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(1))
+
+	// Call 2
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(2))
+
+	// Call 3
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(2))
+}
+
+func (t *ControllerTest) InvokesFallbackActionWithoutOneTimeActions() {
+	var res []interface{}
+
+	// Expectation -- set up only a fallback action.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(2))
+
+	// Call 0
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(2))
+
+	// Call 1
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(2))
+
+	// Call 2
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(2))
+}
+
+func (t *ControllerTest) ImplicitActionReturnsZeroInts() {
+	var res []interface{}
+
+	// Expectation -- set up a cardinality of two.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.Times(2)
+
+	// Call 0
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(reflect.TypeOf(res[0]), Equals(reflect.TypeOf(int(0))))
+	ExpectThat(res[0], Equals(0))
+
+	// Call 1
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(reflect.TypeOf(res[0]), Equals(reflect.TypeOf(int(0))))
+	ExpectThat(res[0], Equals(0))
+}
+
+func (t *ControllerTest) ImplicitActionReturnsEmptyStrings() {
+	var res []interface{}
+
+	// Expectation -- set up a cardinality of two.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"TwoIntsToString",
+		"burrito.go",
+		117)
+
+	exp := partial(LessThan(100), LessThan(100))
+	exp.Times(2)
+
+	// Call 0
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"TwoIntsToString",
+		"",
+		0,
+		[]interface{}{0, 0})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(""))
+
+	// Call 1
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"TwoIntsToString",
+		"",
+		0,
+		[]interface{}{0, 0})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(""))
+}
+
+func (t *ControllerTest) ExpectationsAreMatchedLastToFirst() {
+	var res []interface{}
+
+	// General expectation
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(17))
+
+	// More specific expectation
+	partial = t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp = partial(Equals("taco"))
+	exp.WillRepeatedly(Return(19))
+
+	// Call -- the second expectation should match.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{"taco"})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(19))
+
+	// Call -- the first expectation should match because the second doesn't.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{"burrito"})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(17))
+}
+
+func (t *ControllerTest) ExpectationsAreSegregatedByMockObject() {
+	var res []interface{}
+
+	// Expectation for mock1 -- return 17.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(17))
+
+	// Expectation for mock2 -- return 19.
+	partial = t.controller.ExpectCall(
+		t.mock2,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp = partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(19))
+
+	// Call mock1.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(17))
+
+	// Call mock2.
+	res = t.controller.HandleMethodCall(
+		t.mock2,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(19))
+}
+
+func (t *ControllerTest) ExpectationsAreSegregatedByMethodName() {
+	var res []interface{}
+
+	// Expectation for StringToInt
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillRepeatedly(Return(17))
+
+	// Expectation for TwoIntsToString
+	partial = t.controller.ExpectCall(
+		t.mock1,
+		"TwoIntsToString",
+		"burrito.go",
+		117)
+
+	exp = partial(1, 2)
+	exp.WillRepeatedly(Return("taco"))
+
+	// Call StringToInt.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals(17))
+
+	// Call TwoIntsToString.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"TwoIntsToString",
+		"",
+		0,
+		[]interface{}{1, 2})
+
+	ExpectThat(len(res), Equals(1))
+	ExpectThat(res[0], Equals("taco"))
+}
+
+func (t *ControllerTest) ActionCallsAgainMatchingDifferentExpectation() {
+	var res []interface{}
+
+	// Expectation for StringToInt
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.WillOnce(Return(17))
+
+	// Expectation for TwoIntsToString -- pretend we call StringToInt.
+	partial = t.controller.ExpectCall(
+		t.mock1,
+		"TwoIntsToString",
+		"burrito.go",
+		117)
+
+	exp = partial(1, 2)
+	exp.WillOnce(Invoke(func(int, int) string {
+		t.controller.HandleMethodCall(
+			t.mock1,
+			"StringToInt",
+			"taco.go",
+			112,
+			[]interface{}{""})
+
+		return "queso"
+	}))
+
+	// Call TwoIntsToString.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"TwoIntsToString",
+		"",
+		0,
+		[]interface{}{1, 2})
+
+	AssertThat(res, ElementsAre("queso"))
+
+	// Finish. Everything should be satisfied.
+	t.controller.Finish()
+
+	ExpectThat(t.reporter.errors, ElementsAre())
+	ExpectThat(t.reporter.fatalErrors, ElementsAre())
+}
+
+func (t *ControllerTest) ActionCallsAgainMatchingSameExpectation() {
+	var res []interface{}
+
+	// Expectation for StringToInt -- should be called twice. The first time it
+	// should call itself.
+	partial := t.controller.ExpectCall(
+		t.mock1,
+		"StringToInt",
+		"burrito.go",
+		117)
+
+	exp := partial(HasSubstr(""))
+	exp.Times(2)
+	exp.WillOnce(Invoke(func(string) int {
+		subCallRes := t.controller.HandleMethodCall(
+			t.mock1,
+			"StringToInt",
+			"taco.go",
+			112,
+			[]interface{}{""})
+
+		return subCallRes[0].(int) + 19
+	}))
+
+	exp.WillOnce(Return(17))
+
+	// Call.
+	res = t.controller.HandleMethodCall(
+		t.mock1,
+		"StringToInt",
+		"",
+		0,
+		[]interface{}{""})
+
+	AssertThat(res, ElementsAre(17+19))
+
+	// Finish. Everything should be satisfied.
+	t.controller.Finish()
+
+	ExpectThat(t.reporter.errors, ElementsAre())
+	ExpectThat(t.reporter.fatalErrors, ElementsAre())
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock.go
new file mode 100644
index 00000000000..b9243a7d55c
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock.go
@@ -0,0 +1,226 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// 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.
+
+// createmock is used to generate source code for mock versions of interfaces
+// from installed packages.
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"regexp"
+	"text/template"
+
+	// Ensure that the generate package, which is used by the generated code, is
+	// installed by goinstall.
+	_ "github.com/smartystreets/assertions/internal/oglemock/generate"
+)
+
+// A template for generated code that is used to print the result.
+const tmplStr = `
+{{$inputPkg := .InputPkg}}
+{{$outputPkg := .OutputPkg}}
+
+package main
+
+import (
+	{{range $identifier, $import := .Imports}}
+		{{$identifier}} "{{$import}}"
+	{{end}}
+)
+
+func getTypeForPtr(ptr interface{}) reflect.Type {
+	return reflect.TypeOf(ptr).Elem()
+}
+
+func main() {
+	// Reduce noise in logging output.
+	log.SetFlags(0)
+
+	interfaces := []reflect.Type{
+		{{range $typeName := .TypeNames}}
+			getTypeForPtr((*{{base $inputPkg}}.{{$typeName}})(nil)),
+		{{end}}
+	}
+
+	err := generate.GenerateMockSource(os.Stdout, "{{$outputPkg}}", interfaces)
+	if err != nil {
+		log.Fatalf("Error generating mock source: %v", err)
+	}
+}
+`
+
+// A map from import identifier to package to use that identifier for,
+// containing elements for each import needed by the generated code.
+type importMap map[string]string
+
+type tmplArg struct {
+	InputPkg  string
+	OutputPkg string
+
+	// Imports needed by the generated code.
+	Imports importMap
+
+	// Types to be mocked, relative to their package's name.
+	TypeNames []string
+}
+
+var unknownPackageRegexp = regexp.MustCompile(
+	`tool\.go:\d+:\d+: cannot find package "([^"]+)"`)
+
+var undefinedInterfaceRegexp = regexp.MustCompile(`tool\.go:\d+: undefined: [\pL_0-9]+\.([\pL_0-9]+)`)
+
+// Does the 'go build' output indicate that a package wasn't found? If so,
+// return the name of the package.
+func findUnknownPackage(output []byte) *string {
+	if match := unknownPackageRegexp.FindSubmatch(output); match != nil {
+		res := string(match[1])
+		return &res
+	}
+
+	return nil
+}
+
+// Does the 'go build' output indicate that an interface wasn't found? If so,
+// return the name of the interface.
+func findUndefinedInterface(output []byte) *string {
+	if match := undefinedInterfaceRegexp.FindSubmatch(output); match != nil {
+		res := string(match[1])
+		return &res
+	}
+
+	return nil
+}
+
+// Split out from main so that deferred calls are executed even in the event of
+// an error.
+func run() error {
+	// Reduce noise in logging output.
+	log.SetFlags(0)
+
+	// Check the command-line arguments.
+	flag.Parse()
+
+	cmdLineArgs := flag.Args()
+	if len(cmdLineArgs) < 2 {
+		return errors.New("Usage: createmock [package] [interface ...]")
+	}
+
+	// Create a temporary directory inside of $GOPATH to hold generated code.
+	buildPkg, err := build.Import("github.com/smartystreets/assertions/internal/oglemock", "", build.FindOnly)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Couldn't find oglemock in $GOPATH: %v", err))
+	}
+
+	tmpDir, err := ioutil.TempDir(buildPkg.SrcRoot, "tmp-createmock-")
+	if err != nil {
+		return errors.New(fmt.Sprintf("Creating temp dir: %v", err))
+	}
+
+	defer os.RemoveAll(tmpDir)
+
+	// Create a file to hold generated code.
+	codeFile, err := os.Create(path.Join(tmpDir, "tool.go"))
+	if err != nil {
+		return errors.New(fmt.Sprintf("Couldn't create a file to hold code: %v", err))
+	}
+
+	// Create an appropriate path for the built binary.
+	binaryPath := path.Join(tmpDir, "tool")
+
+	// Create an appropriate template argument.
+	var arg tmplArg
+	arg.InputPkg = cmdLineArgs[0]
+	arg.OutputPkg = "mock_" + path.Base(arg.InputPkg)
+	arg.TypeNames = cmdLineArgs[1:]
+
+	arg.Imports = make(importMap)
+	arg.Imports[path.Base(arg.InputPkg)] = arg.InputPkg
+	arg.Imports["generate"] = "github.com/smartystreets/assertions/internal/oglemock/generate"
+	arg.Imports["log"] = "log"
+	arg.Imports["os"] = "os"
+	arg.Imports["reflect"] = "reflect"
+
+	// Execute the template to generate code that will itself generate the mock
+	// code. Write the code to the temp file.
+	tmpl := template.Must(
+		template.New("code").Funcs(
+			template.FuncMap{
+				"base": path.Base,
+			}).Parse(tmplStr))
+	if err := tmpl.Execute(codeFile, arg); err != nil {
+		return errors.New(fmt.Sprintf("Error executing template: %v", err))
+	}
+
+	codeFile.Close()
+
+	// Attempt to build the code.
+	cmd := exec.Command("go", "build", "-o", binaryPath)
+	cmd.Dir = tmpDir
+	buildOutput, err := cmd.CombinedOutput()
+
+	if err != nil {
+		// Did the compilation fail due to the user-specified package not being found?
+		if pkg := findUnknownPackage(buildOutput); pkg != nil && *pkg == arg.InputPkg {
+			return errors.New(fmt.Sprintf("Unknown package: %s", *pkg))
+		}
+
+		// Did the compilation fail due to an unknown interface?
+		if in := findUndefinedInterface(buildOutput); in != nil {
+			return errors.New(fmt.Sprintf("Unknown interface: %s", *in))
+		}
+
+		// Otherwise return a generic error.
+		return errors.New(fmt.Sprintf(
+			"%s\n\nError building generated code:\n\n"+
+				"    %v\n\nPlease report this oglemock bug.",
+			buildOutput,
+			err))
+	}
+
+	// Run the binary.
+	cmd = exec.Command(binaryPath)
+	binaryOutput, err := cmd.CombinedOutput()
+
+	if err != nil {
+		return errors.New(fmt.Sprintf(
+			"%s\n\nError running generated code:\n\n"+
+				"    %v\n\n Please report this oglemock bug.",
+			binaryOutput,
+			err))
+	}
+
+	// Copy its output.
+	_, err = os.Stdout.Write(binaryOutput)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Error copying binary output: %v", err))
+	}
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock_test.go
new file mode 100644
index 00000000000..cb1bb08153d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/createmock_test.go
@@ -0,0 +1,215 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"syscall"
+	"testing"
+)
+
+var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.")
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+var tempDir string
+var createmockPath string
+
+type CreateMockTest struct {
+}
+
+func TestOgletest(t *testing.T) { RunTests(t) }
+func init()                     { RegisterTestSuite(&CreateMockTest{}) }
+
+func (t *CreateMockTest) SetUpTestSuite() {
+	// Create a temporary file to hold the built createmock binary.
+	tempDir, err := ioutil.TempDir("", "createmock-")
+	if err != nil {
+		panic("Creating temporary directory: " + err.Error())
+	}
+
+	createmockPath = path.Join(tempDir, "createmock")
+
+	// Build the createmock tool so that it can be used in the tests below.
+	cmd := exec.Command("go", "build", "-o", createmockPath, "github.com/smartystreets/assertions/internal/oglemock/createmock")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		panic(fmt.Sprintf("Error building createmock: %v\n\n%s", err, output))
+	}
+}
+
+func (t *CreateMockTest) TearDownTestSuite() {
+	// Delete the createmock binary we built above.
+	os.RemoveAll(tempDir)
+	tempDir = ""
+	createmockPath = ""
+}
+
+func (t *CreateMockTest) runGoldenTest(
+	caseName string,
+	expectedReturnCode int,
+	createmockArgs ...string) {
+	// Run createmock.
+	cmd := exec.Command(createmockPath, createmockArgs...)
+	output, err := cmd.CombinedOutput()
+
+	// Make sure the process actually exited.
+	exitError, ok := err.(*exec.ExitError)
+	if err != nil && (!ok || !exitError.Exited()) {
+		panic("exec.Command.CombinedOutput: " + err.Error())
+	}
+
+	// Extract a return code.
+	var actualReturnCode int
+	if exitError != nil {
+		actualReturnCode = exitError.Sys().(syscall.WaitStatus).ExitStatus()
+	}
+
+	// Make sure the return code is correct.
+	ExpectEq(expectedReturnCode, actualReturnCode)
+
+	// Read the golden file.
+	goldenPath := path.Join("test_cases", "golden."+caseName)
+	goldenData := readFileOrDie(goldenPath)
+
+	// Compare the two.
+	identical := (string(output) == string(goldenData))
+	ExpectTrue(identical, "Output doesn't match for case '%s'.", caseName)
+
+	// Write out a new golden file if requested.
+	if !identical && *dumpNew {
+		writeContentsToFileOrDie(output, goldenPath)
+	}
+}
+
+// Ensure that when createmock is run with the supplied args, it produces
+// output that can be compiled.
+func (t *CreateMockTest) runCompilationTest(createmockArgs ...string) {
+	// Create a temporary directory inside of $GOPATH to hold generated code.
+	buildPkg, err := build.Import("github.com/smartystreets/assertions/internal/oglemock", "", build.FindOnly)
+	AssertEq(nil, err)
+
+	tmpDir, err := ioutil.TempDir(buildPkg.SrcRoot, "tmp-createmock_test-")
+	AssertEq(nil, err)
+	defer os.RemoveAll(tmpDir)
+
+	// Create a file to hold the mock code.
+	codeFile, err := os.Create(path.Join(tmpDir, "mock.go"))
+	AssertEq(nil, err)
+
+	// Run createmock and save its output to the file created above.
+	stdErrBuf := new(bytes.Buffer)
+
+	cmd := exec.Command(createmockPath, createmockArgs...)
+	cmd.Stdout = codeFile
+	cmd.Stderr = stdErrBuf
+
+	err = cmd.Run()
+	AssertEq(nil, err, "createmock stderr output:\n\n%s", stdErrBuf.String())
+	codeFile.Close()
+
+	// Run 'go build' in the directory and make sure it exits with return code
+	// zero.
+	cmd = exec.Command("go", "build")
+	cmd.Dir = tmpDir
+	output, err := cmd.CombinedOutput()
+
+	ExpectEq(nil, err, "go build output:\n\n%s", output)
+}
+
+func writeContentsToFileOrDie(contents []byte, path string) {
+	if err := ioutil.WriteFile(path, contents, 0600); err != nil {
+		panic("ioutil.WriteFile: " + err.Error())
+	}
+}
+
+func readFileOrDie(path string) []byte {
+	contents, err := ioutil.ReadFile(path)
+	if err != nil {
+		panic("ioutil.ReadFile: " + err.Error())
+	}
+
+	return contents
+}
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *CreateMockTest) NoPackage() {
+	t.runGoldenTest(
+		"no_package",
+		1)
+}
+
+func (t *CreateMockTest) NoInterfaces() {
+	t.runGoldenTest(
+		"no_interfaces",
+		1,
+		"io")
+}
+
+func (t *CreateMockTest) UnknownPackage() {
+	t.runGoldenTest(
+		"unknown_package",
+		1,
+		"foo/bar",
+		"Reader")
+}
+
+func (t *CreateMockTest) UnknownInterface() {
+	t.runGoldenTest(
+		"unknown_interface",
+		1,
+		"io",
+		"Frobnicator")
+}
+
+func (t *CreateMockTest) IoReaderAndWriter() {
+	t.runCompilationTest(
+		"io",
+		"Reader",
+		"Writer")
+}
+
+func (t *CreateMockTest) OsFileInfo() {
+	// Note that os is also used by the code that createmock generates; there
+	// should be no conflict.
+	t.runCompilationTest(
+		"os",
+		"FileInfo")
+}
+
+func (t *CreateMockTest) ComplicatedSamplePackage() {
+	t.runCompilationTest(
+		"github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg",
+		"ComplicatedThing")
+}
+
+func (t *CreateMockTest) RenamedSamplePackage() {
+	t.runCompilationTest(
+		"github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg",
+		"SomeInterface")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_interfaces b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_interfaces
new file mode 100644
index 00000000000..b70535fae6b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_interfaces
@@ -0,0 +1 @@
+Usage: createmock [package] [interface ...]
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_package b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_package
new file mode 100644
index 00000000000..b70535fae6b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.no_package
@@ -0,0 +1 @@
+Usage: createmock [package] [interface ...]
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_interface b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_interface
new file mode 100644
index 00000000000..c32950a1790
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_interface
@@ -0,0 +1 @@
+Unknown interface: Frobnicator
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_package b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_package
new file mode 100644
index 00000000000..d07e915d2cf
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/test_cases/golden.unknown_package
@@ -0,0 +1 @@
+Unknown package: foo/bar
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all.go
new file mode 100644
index 00000000000..c0cd3ffbd69
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all.go
@@ -0,0 +1,53 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Create an Action that invokes the supplied actions one after another. The
+// return values from the final action are used; others are ignored.
+func DoAll(first Action, others ...Action) Action {
+	return &doAll{
+		wrapped: append([]Action{first}, others...),
+	}
+}
+
+type doAll struct {
+	wrapped []Action
+}
+
+func (a *doAll) SetSignature(signature reflect.Type) (err error) {
+	for i, w := range a.wrapped {
+		err = w.SetSignature(signature)
+		if err != nil {
+			err = fmt.Errorf("Action %v: %v", i, err)
+			return
+		}
+	}
+
+	return
+}
+
+func (a *doAll) Invoke(methodArgs []interface{}) (rets []interface{}) {
+	for _, w := range a.wrapped {
+		rets = w.Invoke(methodArgs)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all_test.go
new file mode 100644
index 00000000000..f835b66c7c5
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all_test.go
@@ -0,0 +1,90 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	"reflect"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestDoAll(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////
+// Boilerplate
+////////////////////////////////////////////////////////////
+
+type DoAllTest struct {
+}
+
+func init() { RegisterTestSuite(&DoAllTest{}) }
+
+////////////////////////////////////////////////////////////
+// Test functions
+////////////////////////////////////////////////////////////
+
+func (t *DoAllTest) FirstActionDoesntLikeSignature() {
+	f := func(a int, b string) {}
+
+	a0 := oglemock.Invoke(func() {})
+	a1 := oglemock.Invoke(f)
+	a2 := oglemock.Return()
+
+	err := oglemock.DoAll(a0, a1, a2).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("Action 0")))
+	ExpectThat(err, Error(HasSubstr("func()")))
+}
+
+func (t *DoAllTest) LastActionDoesntLikeSignature() {
+	f := func(a int, b string) {}
+
+	a0 := oglemock.Invoke(f)
+	a1 := oglemock.Invoke(f)
+	a2 := oglemock.Return(17)
+
+	err := oglemock.DoAll(a0, a1, a2).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("Action 2")))
+	ExpectThat(err, Error(HasSubstr("1 vals; expected 0")))
+}
+
+func (t *DoAllTest) SingleAction() {
+	f := func(a int) string { return "" }
+	a0 := oglemock.Return("taco")
+
+	action := oglemock.DoAll(a0)
+	AssertEq(nil, action.SetSignature(reflect.TypeOf(f)))
+
+	rets := action.Invoke([]interface{}{17})
+	ExpectThat(rets, ElementsAre("taco"))
+}
+
+func (t *DoAllTest) MultipleActions() {
+	f := func(a int) string { return "" }
+
+	var saved int
+	a0 := oglemock.SaveArg(0, &saved)
+	a1 := oglemock.Return("taco")
+
+	action := oglemock.DoAll(a0, a1)
+	AssertEq(nil, action.SetSignature(reflect.TypeOf(f)))
+
+	rets := action.Invoke([]interface{}{17})
+	ExpectEq(17, saved)
+	ExpectThat(rets, ElementsAre("taco"))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/error_reporter.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/error_reporter.go
new file mode 100644
index 00000000000..0c3a65ee187
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/error_reporter.go
@@ -0,0 +1,29 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+// ErrorReporter is an interface that wraps methods for reporting errors that
+// should cause test failures.
+type ErrorReporter interface {
+	// Report that some failure (e.g. an unsatisfied expectation) occurred. If
+	// known, fileName and lineNumber should contain information about where it
+	// occurred. The test may continue if the test framework supports it.
+	ReportError(fileName string, lineNumber int, err error)
+
+	// Like ReportError, but the test should be halted immediately. It is assumed
+	// that this method does not return.
+	ReportFatalError(fileName string, lineNumber int, err error)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/expectation.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/expectation.go
new file mode 100644
index 00000000000..d18bfb8bce9
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/expectation.go
@@ -0,0 +1,59 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+// Expectation is an expectation for zero or more calls to a mock method with
+// particular arguments or sets of arguments.
+type Expectation interface {
+	// Times expresses that a matching method call should happen exactly N times.
+	// Times must not be called more than once, and must not be called after
+	// WillOnce or WillRepeatedly.
+	//
+	// The full rules for the cardinality of an expectation are as follows:
+	//
+	//  1. If an explicit cardinality is set with Times(N), then anything other
+	//     than exactly N matching calls will cause a test failure.
+	//
+	//  2. Otherwise, if there are any one-time actions set up, then it is
+	//     expected there will be at least that many matching calls. If there is
+	//     not also a fallback action, then it is expected that there will be
+	//     exactly that many.
+	//
+	//  3. Otherwise, if there is a fallback action configured, any number of
+	//     matching calls (including zero) is allowed.
+	//
+	//  4. Otherwise, the implicit cardinality is one.
+	//
+	Times(n uint) Expectation
+
+	// WillOnce configures a "one-time action". WillOnce can be called zero or
+	// more times, but must be called after any call to Times and before any call
+	// to WillRepeatedly.
+	//
+	// When matching method calls are made on the mock object, one-time actions
+	// are invoked one per matching call in the order that they were set up until
+	// they are exhausted. Afterward the fallback action, if any, will be used.
+	WillOnce(a Action) Expectation
+
+	// WillRepeatedly configures a "fallback action". WillRepeatedly can be
+	// called zero or one times, and must not be called before Times or WillOnce.
+	//
+	// Once all one-time actions are exhausted (see above), the fallback action
+	// will be invoked for any further method calls. If WillRepeatedly is not
+	// called, the fallback action is implicitly an action that returns zero
+	// values for the method's return values.
+	WillRepeatedly(a Action) Expectation
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate.go
new file mode 100644
index 00000000000..387367ed730
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate.go
@@ -0,0 +1,329 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package generate implements code generation for mock classes. This is an
+// implementation detail of the createmock command, which you probably want to
+// use directly instead.
+package generate
+
+import (
+	"bytes"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"io"
+	"reflect"
+	"regexp"
+	"text/template"
+)
+
+const tmplStr = `
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package {{.Pkg}}
+
+import (
+	{{range $identifier, $import := .Imports}}{{$identifier}} "{{$import}}"
+	{{end}}
+)
+
+{{range .Interfaces}}
+	{{$interfaceName := printf "Mock%s" .Name}}
+	{{$structName := printf "mock%s" .Name}}
+
+	type {{$interfaceName}} interface {
+		{{getTypeString .}}
+		oglemock.MockObject
+	}
+
+	type {{$structName}} struct {
+		controller oglemock.Controller
+		description string
+	}
+	
+	func New{{printf "Mock%s" .Name}}(
+		c oglemock.Controller,
+		desc string) {{$interfaceName}} {
+	  return &{{$structName}}{
+			controller: c,
+			description: desc,
+		}
+	}
+	
+	func (m *{{$structName}}) Oglemock_Id() uintptr {
+		return uintptr(unsafe.Pointer(m))
+	}
+	
+	func (m *{{$structName}}) Oglemock_Description() string {
+		return m.description
+	}
+
+	{{range getMethods .}}
+	  {{$funcType := .Type}}
+	  {{$inputTypes := getInputs $funcType}}
+	  {{$outputTypes := getOutputs $funcType}}
+
+		func (m *{{$structName}}) {{.Name}}({{range $i, $type := $inputTypes}}p{{$i}} {{getInputTypeString $i $funcType}}, {{end}}) ({{range $i, $type := $outputTypes}}o{{$i}} {{getTypeString $type}}, {{end}}) {
+			// Get a file name and line number for the caller.
+			_, file, line, _ := runtime.Caller(1)
+
+			// Hand the call off to the controller, which does most of the work.
+			retVals := m.controller.HandleMethodCall(
+				m,
+				"{{.Name}}",
+				file,
+				line,
+				[]interface{}{ {{range $i, $type := $inputTypes}}p{{$i}}, {{end}} })
+
+			if len(retVals) != {{len $outputTypes}} {
+				panic(fmt.Sprintf("{{$structName}}.{{.Name}}: invalid return values: %v", retVals))
+			}
+
+			{{range $i, $type := $outputTypes}}
+				// o{{$i}} {{getTypeString $type}}
+				if retVals[{{$i}}] != nil {
+					o{{$i}} = retVals[{{$i}}].({{getTypeString $type}})
+				}
+			{{end}}
+
+			return
+		}
+	{{end}}
+{{end}}
+`
+
+type tmplArg struct {
+	// The package of the generated code.
+	Pkg string
+
+	// Imports needed by the interfaces.
+	Imports importMap
+
+	// The set of interfaces to mock.
+	Interfaces []reflect.Type
+}
+
+var tmpl *template.Template
+
+func init() {
+	extraFuncs := make(template.FuncMap)
+	extraFuncs["getMethods"] = getMethods
+	extraFuncs["getInputs"] = getInputs
+	extraFuncs["getOutputs"] = getOutputs
+	extraFuncs["getInputTypeString"] = getInputTypeString
+	extraFuncs["getTypeString"] = getTypeString
+
+	tmpl = template.New("code")
+	tmpl.Funcs(extraFuncs)
+	tmpl.Parse(tmplStr)
+}
+
+func getInputTypeString(i int, ft reflect.Type) string {
+	numInputs := ft.NumIn()
+	if i == numInputs-1 && ft.IsVariadic() {
+		return "..." + getTypeString(ft.In(i).Elem())
+	}
+
+	return getTypeString(ft.In(i))
+}
+
+func getTypeString(t reflect.Type) string {
+	return t.String()
+}
+
+func getMethods(it reflect.Type) []reflect.Method {
+	numMethods := it.NumMethod()
+	methods := make([]reflect.Method, numMethods)
+
+	for i := 0; i < numMethods; i++ {
+		methods[i] = it.Method(i)
+	}
+
+	return methods
+}
+
+func getInputs(ft reflect.Type) []reflect.Type {
+	numIn := ft.NumIn()
+	inputs := make([]reflect.Type, numIn)
+
+	for i := 0; i < numIn; i++ {
+		inputs[i] = ft.In(i)
+	}
+
+	return inputs
+}
+
+func getOutputs(ft reflect.Type) []reflect.Type {
+	numOut := ft.NumOut()
+	outputs := make([]reflect.Type, numOut)
+
+	for i := 0; i < numOut; i++ {
+		outputs[i] = ft.Out(i)
+	}
+
+	return outputs
+}
+
+// A map from import identifier to package to use that identifier for,
+// containing elements for each import needed by a set of mocked interfaces.
+type importMap map[string]string
+
+var typePackageIdentifierRegexp = regexp.MustCompile(`^([\pL_0-9]+)\.[\pL_0-9]+$`)
+
+// Add an import for the supplied type, without recursing.
+func addImportForType(imports importMap, t reflect.Type) {
+	// If there is no package path, this is a built-in type and we don't need an
+	// import.
+	pkgPath := t.PkgPath()
+	if pkgPath == "" {
+		return
+	}
+
+	// Work around a bug in Go:
+	//
+	//     http://code.google.com/p/go/issues/detail?id=2660
+	//
+	var errorPtr *error
+	if t == reflect.TypeOf(errorPtr).Elem() {
+		return
+	}
+
+	// Use the identifier that's part of the type's string representation as the
+	// import identifier. This means that we'll do the right thing for package
+	// "foo/bar" with declaration "package baz".
+	match := typePackageIdentifierRegexp.FindStringSubmatch(t.String())
+	if match == nil {
+		return
+	}
+
+	imports[match[1]] = pkgPath
+}
+
+// Add all necessary imports for the type, recursing as appropriate.
+func addImportsForType(imports importMap, t reflect.Type) {
+	// Add any import needed for the type itself.
+	addImportForType(imports, t)
+
+	// Handle special cases where recursion is needed.
+	switch t.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Ptr, reflect.Slice:
+		addImportsForType(imports, t.Elem())
+
+	case reflect.Func:
+		// Input parameters.
+		for i := 0; i < t.NumIn(); i++ {
+			addImportsForType(imports, t.In(i))
+		}
+
+		// Return values.
+		for i := 0; i < t.NumOut(); i++ {
+			addImportsForType(imports, t.Out(i))
+		}
+
+	case reflect.Map:
+		addImportsForType(imports, t.Key())
+		addImportsForType(imports, t.Elem())
+	}
+}
+
+// Add imports for each of the methods of the interface, but not the interface
+// itself.
+func addImportsForInterfaceMethods(imports importMap, it reflect.Type) {
+	// Handle each method.
+	for i := 0; i < it.NumMethod(); i++ {
+		m := it.Method(i)
+		addImportsForType(imports, m.Type)
+	}
+}
+
+// Given a set of interfaces, return a map from import identifier to package to
+// use that identifier for, containing elements for each import needed by the
+// mock versions of those interfaces.
+func getImports(interfaces []reflect.Type) importMap {
+	imports := make(importMap)
+	for _, it := range interfaces {
+		addImportForType(imports, it)
+		addImportsForInterfaceMethods(imports, it)
+	}
+
+	// Make sure there are imports for other types used by the generated code
+	// itself.
+	imports["fmt"] = "fmt"
+	imports["oglemock"] = "github.com/smartystreets/assertions/internal/oglemock"
+	imports["runtime"] = "runtime"
+	imports["unsafe"] = "unsafe"
+
+	return imports
+}
+
+// Given a set of interfaces to mock, write out source code for a package named
+// `pkg` that contains mock implementations of those interfaces.
+func GenerateMockSource(w io.Writer, pkg string, interfaces []reflect.Type) error {
+	// Sanity-check arguments.
+	if pkg == "" {
+		return errors.New("Package name must be non-empty.")
+	}
+
+	if len(interfaces) == 0 {
+		return errors.New("List of interfaces must be non-empty.")
+	}
+
+	// Make sure each type is indeed an interface.
+	for _, it := range interfaces {
+		if it.Kind() != reflect.Interface {
+			return errors.New("Invalid type: " + it.String())
+		}
+	}
+
+	// Create an appropriate template arg, then execute the template. Write the
+	// raw output into a buffer.
+	var arg tmplArg
+	arg.Pkg = pkg
+	arg.Imports = getImports(interfaces)
+	arg.Interfaces = interfaces
+
+	buf := new(bytes.Buffer)
+	if err := tmpl.Execute(buf, arg); err != nil {
+		return err
+	}
+
+	// Parse the output.
+	fset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fset, pkg+".go", buf, parser.ParseComments)
+	if err != nil {
+		return errors.New("Error parsing generated code: " + err.Error())
+	}
+
+	// Sort the import lines in the AST in the same way that gofmt does.
+	ast.SortImports(fset, astFile)
+
+	// Pretty-print the AST, using the same options that gofmt does by default.
+	cfg := &printer.Config{
+		Mode:     printer.UseSpaces | printer.TabIndent,
+		Tabwidth: 8,
+	}
+
+	if err = cfg.Fprint(w, fset, astFile); err != nil {
+		return errors.New("Error pretty printing: " + err.Error())
+	}
+
+	return nil
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate_test.go
new file mode 100644
index 00000000000..2cdd1b4cfd6
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/generate_test.go
@@ -0,0 +1,153 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generate_test
+
+import (
+	"bytes"
+	"flag"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock/generate"
+	"github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg"
+	"github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"image"
+	"io"
+	"io/ioutil"
+	"path"
+	"reflect"
+	"testing"
+)
+
+var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.")
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+type GenerateTest struct {
+}
+
+func TestOgletest(t *testing.T) { RunTests(t) }
+func init()                     { RegisterTestSuite(&GenerateTest{}) }
+
+func (t *GenerateTest) runGoldenTest(
+	caseName string,
+	nilPtrs ...interface{}) {
+	// Make a slice of interface types to give to GenerateMockSource.
+	interfaces := make([]reflect.Type, len(nilPtrs))
+	for i, ptr := range nilPtrs {
+		interfaces[i] = reflect.TypeOf(ptr).Elem()
+	}
+
+	// Create the mock source.
+	buf := new(bytes.Buffer)
+	err := generate.GenerateMockSource(buf, "some_pkg", interfaces)
+	AssertEq(nil, err, "Error from GenerateMockSource: %v", err)
+
+	// Read the golden file.
+	goldenPath := path.Join("test_cases", "golden."+caseName+".go")
+	goldenData := readFileOrDie(goldenPath)
+
+	// Compare the two.
+	identical := (buf.String() == string(goldenData))
+	ExpectTrue(identical, "Output doesn't match for case '%s'.", caseName)
+
+	// Write out a new golden file if requested.
+	if !identical && *dumpNew {
+		writeContentsToFileOrDie(buf.Bytes(), goldenPath)
+	}
+}
+
+func writeContentsToFileOrDie(contents []byte, path string) {
+	if err := ioutil.WriteFile(path, contents, 0600); err != nil {
+		panic("ioutil.WriteFile: " + err.Error())
+	}
+}
+
+func readFileOrDie(path string) []byte {
+	contents, err := ioutil.ReadFile(path)
+	if err != nil {
+		panic("ioutil.ReadFile: " + err.Error())
+	}
+
+	return contents
+}
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *GenerateTest) EmptyPackageName() {
+	err := generate.GenerateMockSource(
+		new(bytes.Buffer),
+		"",
+		[]reflect.Type{
+			reflect.TypeOf((*io.Reader)(nil)).Elem(),
+		})
+
+	ExpectThat(err, Error(HasSubstr("Package name")))
+	ExpectThat(err, Error(HasSubstr("non-empty")))
+}
+
+func (t *GenerateTest) EmptySetOfInterfaces() {
+	err := generate.GenerateMockSource(
+		new(bytes.Buffer),
+		"foo",
+		[]reflect.Type{})
+
+	ExpectThat(err, Error(HasSubstr("interfaces")))
+	ExpectThat(err, Error(HasSubstr("non-empty")))
+}
+
+func (t *GenerateTest) NonInterfaceType() {
+	err := generate.GenerateMockSource(
+		new(bytes.Buffer),
+		"foo",
+		[]reflect.Type{
+			reflect.TypeOf((*io.Reader)(nil)).Elem(),
+			reflect.TypeOf(17),
+			reflect.TypeOf((*io.Writer)(nil)).Elem(),
+		})
+
+	ExpectThat(err, Error(HasSubstr("Invalid type")))
+}
+
+func (t *GenerateTest) IoReaderAndWriter() {
+	// Mock io.Reader and io.Writer.
+	t.runGoldenTest(
+		"io_reader_writer",
+		(*io.Reader)(nil),
+		(*io.Writer)(nil))
+}
+
+func (t *GenerateTest) Image() {
+	t.runGoldenTest(
+		"image",
+		(*image.Image)(nil),
+		(*image.PalettedImage)(nil))
+}
+
+func (t *GenerateTest) ComplicatedPackage() {
+	t.runGoldenTest(
+		"complicated_pkg",
+		(*complicated_pkg.ComplicatedThing)(nil))
+}
+
+func (t *GenerateTest) RenamedPackage() {
+	t.runGoldenTest(
+		"renamed_pkg",
+		(*tony.SomeInterface)(nil))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg/complicated_pkg.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg/complicated_pkg.go
new file mode 100644
index 00000000000..08844fe5594
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg/complicated_pkg.go
@@ -0,0 +1,40 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package complicated_pkg contains an interface with lots of interesting
+// cases, for use in integration testing.
+package complicated_pkg
+
+import (
+	"github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg"
+	"image"
+	"io"
+	"net"
+)
+
+type Byte uint8
+
+type ComplicatedThing interface {
+	Channels(a chan chan<- <-chan net.Conn) chan int
+	Pointers(a *int, b *net.Conn, c **io.Reader) (*int, error)
+	Functions(a func(int, image.Image) int) func(string, int) net.Conn
+	Maps(a map[string]*int) (map[int]*string, error)
+	Arrays(a [3]string) ([3]int, error)
+	Slices(a []string) ([]int, error)
+	NamedScalarType(a Byte) ([]Byte, error)
+	EmptyInterface(a interface{}) (interface{}, error)
+	RenamedPackage(a tony.SomeUint8Alias)
+	Variadic(a int, b ...net.Conn) int
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.complicated_pkg.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.complicated_pkg.go
new file mode 100644
index 00000000000..c8c9f7992b2
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.complicated_pkg.go
@@ -0,0 +1,311 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package some_pkg
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	complicated_pkg "github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/complicated_pkg"
+	tony "github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg"
+	image "image"
+	io "io"
+	net "net"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockComplicatedThing interface {
+	complicated_pkg.ComplicatedThing
+	oglemock.MockObject
+}
+
+type mockComplicatedThing struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockComplicatedThing(
+	c oglemock.Controller,
+	desc string) MockComplicatedThing {
+	return &mockComplicatedThing{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockComplicatedThing) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockComplicatedThing) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockComplicatedThing) Arrays(p0 [3]string) (o0 [3]int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Arrays",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.Arrays: invalid return values: %v", retVals))
+	}
+
+	// o0 [3]int
+	if retVals[0] != nil {
+		o0 = retVals[0].([3]int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Channels(p0 chan chan<- <-chan net.Conn) (o0 chan int) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Channels",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockComplicatedThing.Channels: invalid return values: %v", retVals))
+	}
+
+	// o0 chan int
+	if retVals[0] != nil {
+		o0 = retVals[0].(chan int)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) EmptyInterface(p0 interface{}) (o0 interface{}, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"EmptyInterface",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.EmptyInterface: invalid return values: %v", retVals))
+	}
+
+	// o0 interface {}
+	if retVals[0] != nil {
+		o0 = retVals[0].(interface{})
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Functions(p0 func(int, image.Image) int) (o0 func(string, int) net.Conn) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Functions",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockComplicatedThing.Functions: invalid return values: %v", retVals))
+	}
+
+	// o0 func(string, int) net.Conn
+	if retVals[0] != nil {
+		o0 = retVals[0].(func(string, int) net.Conn)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Maps(p0 map[string]*int) (o0 map[int]*string, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Maps",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.Maps: invalid return values: %v", retVals))
+	}
+
+	// o0 map[int]*string
+	if retVals[0] != nil {
+		o0 = retVals[0].(map[int]*string)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) NamedScalarType(p0 complicated_pkg.Byte) (o0 []complicated_pkg.Byte, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"NamedScalarType",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.NamedScalarType: invalid return values: %v", retVals))
+	}
+
+	// o0 []complicated_pkg.Byte
+	if retVals[0] != nil {
+		o0 = retVals[0].([]complicated_pkg.Byte)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Pointers(p0 *int, p1 *net.Conn, p2 **io.Reader) (o0 *int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Pointers",
+		file,
+		line,
+		[]interface{}{p0, p1, p2})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.Pointers: invalid return values: %v", retVals))
+	}
+
+	// o0 *int
+	if retVals[0] != nil {
+		o0 = retVals[0].(*int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) RenamedPackage(p0 tony.SomeUint8Alias) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"RenamedPackage",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 0 {
+		panic(fmt.Sprintf("mockComplicatedThing.RenamedPackage: invalid return values: %v", retVals))
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Slices(p0 []string) (o0 []int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Slices",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockComplicatedThing.Slices: invalid return values: %v", retVals))
+	}
+
+	// o0 []int
+	if retVals[0] != nil {
+		o0 = retVals[0].([]int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+func (m *mockComplicatedThing) Variadic(p0 int, p1 ...net.Conn) (o0 int) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Variadic",
+		file,
+		line,
+		[]interface{}{p0, p1})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockComplicatedThing.Variadic: invalid return values: %v", retVals))
+	}
+
+	// o0 int
+	if retVals[0] != nil {
+		o0 = retVals[0].(int)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.image.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.image.go
new file mode 100644
index 00000000000..957186d0c52
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.image.go
@@ -0,0 +1,238 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package some_pkg
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	image "image"
+	color "image/color"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockImage interface {
+	image.Image
+	oglemock.MockObject
+}
+
+type mockImage struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockImage(
+	c oglemock.Controller,
+	desc string) MockImage {
+	return &mockImage{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockImage) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockImage) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockImage) At(p0 int, p1 int) (o0 color.Color) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"At",
+		file,
+		line,
+		[]interface{}{p0, p1})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.At: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Color
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Color)
+	}
+
+	return
+}
+
+func (m *mockImage) Bounds() (o0 image.Rectangle) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Bounds",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.Bounds: invalid return values: %v", retVals))
+	}
+
+	// o0 image.Rectangle
+	if retVals[0] != nil {
+		o0 = retVals[0].(image.Rectangle)
+	}
+
+	return
+}
+
+func (m *mockImage) ColorModel() (o0 color.Model) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"ColorModel",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.ColorModel: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Model
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Model)
+	}
+
+	return
+}
+
+type MockPalettedImage interface {
+	image.PalettedImage
+	oglemock.MockObject
+}
+
+type mockPalettedImage struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockPalettedImage(
+	c oglemock.Controller,
+	desc string) MockPalettedImage {
+	return &mockPalettedImage{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockPalettedImage) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockPalettedImage) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockPalettedImage) At(p0 int, p1 int) (o0 color.Color) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"At",
+		file,
+		line,
+		[]interface{}{p0, p1})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockPalettedImage.At: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Color
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Color)
+	}
+
+	return
+}
+
+func (m *mockPalettedImage) Bounds() (o0 image.Rectangle) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Bounds",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockPalettedImage.Bounds: invalid return values: %v", retVals))
+	}
+
+	// o0 image.Rectangle
+	if retVals[0] != nil {
+		o0 = retVals[0].(image.Rectangle)
+	}
+
+	return
+}
+
+func (m *mockPalettedImage) ColorIndexAt(p0 int, p1 int) (o0 uint8) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"ColorIndexAt",
+		file,
+		line,
+		[]interface{}{p0, p1})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockPalettedImage.ColorIndexAt: invalid return values: %v", retVals))
+	}
+
+	// o0 uint8
+	if retVals[0] != nil {
+		o0 = retVals[0].(uint8)
+	}
+
+	return
+}
+
+func (m *mockPalettedImage) ColorModel() (o0 color.Model) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"ColorModel",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockPalettedImage.ColorModel: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Model
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Model)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.io_reader_writer.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.io_reader_writer.go
new file mode 100644
index 00000000000..59cba861877
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.io_reader_writer.go
@@ -0,0 +1,127 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package some_pkg
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	io "io"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockReader interface {
+	io.Reader
+	oglemock.MockObject
+}
+
+type mockReader struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockReader(
+	c oglemock.Controller,
+	desc string) MockReader {
+	return &mockReader{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockReader) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockReader) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockReader) Read(p0 []uint8) (o0 int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Read",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockReader.Read: invalid return values: %v", retVals))
+	}
+
+	// o0 int
+	if retVals[0] != nil {
+		o0 = retVals[0].(int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
+
+type MockWriter interface {
+	io.Writer
+	oglemock.MockObject
+}
+
+type mockWriter struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockWriter(
+	c oglemock.Controller,
+	desc string) MockWriter {
+	return &mockWriter{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockWriter) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockWriter) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockWriter) Write(p0 []uint8) (o0 int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Write",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockWriter.Write: invalid return values: %v", retVals))
+	}
+
+	// o0 int
+	if retVals[0] != nil {
+		o0 = retVals[0].(int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.renamed_pkg.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.renamed_pkg.go
new file mode 100644
index 00000000000..9b4158faf6c
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/golden.renamed_pkg.go
@@ -0,0 +1,66 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package some_pkg
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	tony "github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockSomeInterface interface {
+	tony.SomeInterface
+	oglemock.MockObject
+}
+
+type mockSomeInterface struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockSomeInterface(
+	c oglemock.Controller,
+	desc string) MockSomeInterface {
+	return &mockSomeInterface{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockSomeInterface) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockSomeInterface) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockSomeInterface) DoFoo(p0 int) (o0 int) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"DoFoo",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockSomeInterface.DoFoo: invalid return values: %v", retVals))
+	}
+
+	// o0 int
+	if retVals[0] != nil {
+		o0 = retVals[0].(int)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg/renamed_pkg.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg/renamed_pkg.go
new file mode 100644
index 00000000000..1461cd6960d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/test_cases/renamed_pkg/renamed_pkg.go
@@ -0,0 +1,24 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// 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.
+
+// A package that calls itself something different than its package path would
+// have you believe.
+package tony
+
+type SomeUint8Alias uint8
+
+type SomeInterface interface {
+	DoFoo(a int) int
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/integration_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/integration_test.go
new file mode 100644
index 00000000000..e72f0cbb13b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/integration_test.go
@@ -0,0 +1,129 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	"errors"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	"github.com/smartystreets/assertions/internal/oglemock/sample/mock_io"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"path"
+	"runtime"
+)
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+func getLineNumber() int {
+	_, _, line, _ := runtime.Caller(1)
+	return line
+}
+
+type IntegrationTest struct {
+	reporter   fakeErrorReporter
+	controller oglemock.Controller
+
+	reader mock_io.MockReader
+}
+
+func init() { RegisterTestSuite(&IntegrationTest{}) }
+
+func (t *IntegrationTest) SetUp(c *TestInfo) {
+	t.reporter.errors = make([]errorReport, 0)
+	t.reporter.fatalErrors = make([]errorReport, 0)
+	t.controller = oglemock.NewController(&t.reporter)
+
+	t.reader = mock_io.NewMockReader(t.controller, "")
+}
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *IntegrationTest) UnexpectedCall() {
+	t.reader.Read([]uint8{1, 2, 3})
+	expectedLine := getLineNumber() - 1
+
+	// An error should have been reported.
+	AssertEq(1, len(t.reporter.errors), "%v", t.reporter.errors)
+	AssertEq(0, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors)
+
+	r := t.reporter.errors[0]
+	ExpectEq("integration_test.go", path.Base(r.fileName))
+	ExpectEq(expectedLine, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Unexpected")))
+	ExpectThat(r.err, Error(HasSubstr("Read")))
+	ExpectThat(r.err, Error(HasSubstr("[1 2 3]")))
+}
+
+func (t *IntegrationTest) ZeroValues() {
+	// Make an unexpected call.
+	n, err := t.reader.Read([]uint8{})
+
+	// Check the return values.
+	ExpectEq(0, n)
+	ExpectEq(nil, err)
+}
+
+func (t *IntegrationTest) ExpectedCalls() {
+	// Expectations
+	t.controller.ExpectCall(t.reader, "Read", "", 112)(nil).
+		WillOnce(oglemock.Return(17, nil)).
+		WillOnce(oglemock.Return(19, nil))
+
+	t.controller.ExpectCall(t.reader, "Read", "", 112)(Not(Equals(nil))).
+		WillOnce(oglemock.Return(23, errors.New("taco")))
+
+	// Calls
+	var n int
+	var err error
+
+	n, err = t.reader.Read(nil)
+	ExpectEq(17, n)
+	ExpectEq(nil, err)
+
+	n, err = t.reader.Read([]byte{})
+	ExpectEq(23, n)
+	ExpectThat(err, Error(Equals("taco")))
+
+	n, err = t.reader.Read(nil)
+	ExpectEq(19, n)
+	ExpectEq(nil, err)
+
+	// Errors
+	AssertEq(0, len(t.reporter.errors), "%v", t.reporter.errors)
+	AssertEq(0, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors)
+}
+
+func (t *IntegrationTest) WrongTypeForReturn() {
+	t.controller.ExpectCall(t.reader, "Read", "foo.go", 112)(nil).
+		WillOnce(oglemock.Return(0, errors.New(""))).
+		WillOnce(oglemock.Return("taco", errors.New("")))
+
+	// Errors
+	AssertEq(0, len(t.reporter.errors), "%v", t.reporter.errors)
+	AssertEq(1, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors)
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("foo.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Return")))
+	ExpectThat(r.err, Error(HasSubstr("arg 0")))
+	ExpectThat(r.err, Error(HasSubstr("int")))
+	ExpectThat(r.err, Error(HasSubstr("string")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation.go
new file mode 100644
index 00000000000..8fa8aeafa42
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation.go
@@ -0,0 +1,180 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"errors"
+	"fmt"
+	"github.com/smartystreets/assertions/internal/oglematchers"
+	"reflect"
+	"sync"
+)
+
+// InternalExpectation is exported for purposes of testing only. You should not
+// touch it.
+//
+// InternalExpectation represents an expectation for zero or more calls to a
+// mock method, and a set of actions to be taken when those calls are received.
+type InternalExpectation struct {
+	// The signature of the method to which this expectation is bound, for
+	// checking action types.
+	methodSignature reflect.Type
+
+	// An error reporter to use for reporting errors in the way that expectations
+	// are set.
+	errorReporter ErrorReporter
+
+	// A mutex protecting mutable fields of the struct.
+	mutex sync.Mutex
+
+	// Matchers that the arguments to the mock method must satisfy in order to
+	// match this expectation.
+	ArgMatchers []oglematchers.Matcher
+
+	// The name of the file in which this expectation was expressed.
+	FileName string
+
+	// The line number at which this expectation was expressed.
+	LineNumber int
+
+	// The number of times this expectation should be matched, as explicitly
+	// listed by the user. If there was no explicit number expressed, this is -1.
+	ExpectedNumMatches int
+
+	// Actions to be taken for the first N calls, one per call in order, where N
+	// is the length of this slice.
+	OneTimeActions []Action
+
+	// An action to be taken when the one-time actions have expired, or nil if
+	// there is no such action.
+	FallbackAction Action
+
+	// The number of times this expectation has been matched so far.
+	NumMatches uint
+}
+
+// InternalNewExpectation is exported for purposes of testing only. You should
+// not touch it.
+func InternalNewExpectation(
+	reporter ErrorReporter,
+	methodSignature reflect.Type,
+	args []interface{},
+	fileName string,
+	lineNumber int) *InternalExpectation {
+	result := &InternalExpectation{}
+
+	// Store fields that can be stored directly.
+	result.methodSignature = methodSignature
+	result.errorReporter = reporter
+	result.FileName = fileName
+	result.LineNumber = lineNumber
+
+	// Set up defaults.
+	result.ExpectedNumMatches = -1
+	result.OneTimeActions = make([]Action, 0)
+
+	// Set up the ArgMatchers slice, using Equals(x) for each x that is not a
+	// matcher itself.
+	result.ArgMatchers = make([]oglematchers.Matcher, len(args))
+	for i, x := range args {
+		if matcher, ok := x.(oglematchers.Matcher); ok {
+			result.ArgMatchers[i] = matcher
+		} else {
+			result.ArgMatchers[i] = oglematchers.Equals(x)
+		}
+	}
+
+	return result
+}
+
+func (e *InternalExpectation) Times(n uint) Expectation {
+	e.mutex.Lock()
+	defer e.mutex.Unlock()
+
+	// It is illegal to call this more than once.
+	if e.ExpectedNumMatches != -1 {
+		e.reportFatalError("Times called more than once.")
+		return nil
+	}
+
+	// It is illegal to call this after any actions are configured.
+	if len(e.OneTimeActions) != 0 {
+		e.reportFatalError("Times called after WillOnce.")
+		return nil
+	}
+
+	if e.FallbackAction != nil {
+		e.reportFatalError("Times called after WillRepeatedly.")
+		return nil
+	}
+
+	// Make sure the number is reasonable (and will fit in an int).
+	if n > 1000 {
+		e.reportFatalError("Expectation.Times: N must be at most 1000")
+		return nil
+	}
+
+	e.ExpectedNumMatches = int(n)
+	return e
+}
+
+func (e *InternalExpectation) WillOnce(a Action) Expectation {
+	e.mutex.Lock()
+	defer e.mutex.Unlock()
+
+	// It is illegal to call this after WillRepeatedly.
+	if e.FallbackAction != nil {
+		e.reportFatalError("WillOnce called after WillRepeatedly.")
+		return nil
+	}
+
+	// Tell the action about the method's signature.
+	if err := a.SetSignature(e.methodSignature); err != nil {
+		e.reportFatalError(fmt.Sprintf("WillOnce given invalid action: %v", err))
+		return nil
+	}
+
+	// Store the action.
+	e.OneTimeActions = append(e.OneTimeActions, a)
+
+	return e
+}
+
+func (e *InternalExpectation) WillRepeatedly(a Action) Expectation {
+	e.mutex.Lock()
+	defer e.mutex.Unlock()
+
+	// It is illegal to call this twice.
+	if e.FallbackAction != nil {
+		e.reportFatalError("WillRepeatedly called more than once.")
+		return nil
+	}
+
+	// Tell the action about the method's signature.
+	if err := a.SetSignature(e.methodSignature); err != nil {
+		e.reportFatalError(fmt.Sprintf("WillRepeatedly given invalid action: %v", err))
+		return nil
+	}
+
+	// Store the action.
+	e.FallbackAction = a
+
+	return e
+}
+
+func (e *InternalExpectation) reportFatalError(errorText string) {
+	e.errorReporter.ReportFatalError(e.FileName, e.LineNumber, errors.New(errorText))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation_test.go
new file mode 100644
index 00000000000..977fe1ac3f7
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/internal_expectation_test.go
@@ -0,0 +1,265 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"reflect"
+)
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+var emptyReturnSig reflect.Type = reflect.TypeOf(func(i int) {})
+var float64ReturnSig reflect.Type = reflect.TypeOf(func(i int) float64 { return 17.0 })
+
+type InternalExpectationTest struct {
+	reporter fakeErrorReporter
+}
+
+func init() { RegisterTestSuite(&InternalExpectationTest{}) }
+
+func (t *InternalExpectationTest) SetUp(c *TestInfo) {
+	t.reporter.errors = make([]errorReport, 0)
+	t.reporter.fatalErrors = make([]errorReport, 0)
+}
+
+func (t *InternalExpectationTest) makeExpectation(
+	sig reflect.Type,
+	args []interface{},
+	fileName string,
+	lineNumber int) *InternalExpectation {
+	return InternalNewExpectation(&t.reporter, sig, args, fileName, lineNumber)
+}
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *InternalExpectationTest) StoresFileNameAndLineNumber() {
+	args := []interface{}{}
+	exp := t.makeExpectation(emptyReturnSig, args, "taco", 17)
+
+	ExpectThat(exp.FileName, Equals("taco"))
+	ExpectThat(exp.LineNumber, Equals(17))
+}
+
+func (t *InternalExpectationTest) NoArgs() {
+	args := []interface{}{}
+	exp := t.makeExpectation(emptyReturnSig, args, "", 0)
+
+	ExpectThat(len(exp.ArgMatchers), Equals(0))
+}
+
+func (t *InternalExpectationTest) MixOfMatchersAndNonMatchers() {
+	args := []interface{}{Equals(17), 19, Equals(23)}
+	exp := t.makeExpectation(emptyReturnSig, args, "", 0)
+
+	// Matcher args
+	ExpectThat(len(exp.ArgMatchers), Equals(3))
+	ExpectThat(exp.ArgMatchers[0], Equals(args[0]))
+	ExpectThat(exp.ArgMatchers[2], Equals(args[2]))
+
+	// Non-matcher arg
+	var err error
+	matcher1 := exp.ArgMatchers[1]
+
+	err = matcher1.Matches(17)
+	ExpectNe(nil, err)
+
+	err = matcher1.Matches(19)
+	ExpectEq(nil, err)
+
+	err = matcher1.Matches(23)
+	ExpectNe(nil, err)
+}
+
+func (t *InternalExpectationTest) NoTimes() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0)
+
+	ExpectThat(exp.ExpectedNumMatches, Equals(-1))
+}
+
+func (t *InternalExpectationTest) TimesN() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0)
+	exp.Times(17)
+
+	ExpectThat(exp.ExpectedNumMatches, Equals(17))
+}
+
+func (t *InternalExpectationTest) NoActions() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0)
+
+	ExpectThat(len(exp.OneTimeActions), Equals(0))
+	ExpectThat(exp.FallbackAction, Equals(nil))
+}
+
+func (t *InternalExpectationTest) WillOnce() {
+	action0 := Return(17.0)
+	action1 := Return(19.0)
+
+	exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0)
+	exp.WillOnce(action0).WillOnce(action1)
+
+	ExpectThat(len(exp.OneTimeActions), Equals(2))
+	ExpectThat(exp.OneTimeActions[0], Equals(action0))
+	ExpectThat(exp.OneTimeActions[1], Equals(action1))
+}
+
+func (t *InternalExpectationTest) WillRepeatedly() {
+	action := Return(17.0)
+
+	exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0)
+	exp.WillRepeatedly(action)
+
+	ExpectThat(exp.FallbackAction, Equals(action))
+}
+
+func (t *InternalExpectationTest) BothKindsOfAction() {
+	action0 := Return(17.0)
+	action1 := Return(19.0)
+	action2 := Return(23.0)
+
+	exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0)
+	exp.WillOnce(action0).WillOnce(action1).WillRepeatedly(action2)
+
+	ExpectThat(len(exp.OneTimeActions), Equals(2))
+	ExpectThat(exp.OneTimeActions[0], Equals(action0))
+	ExpectThat(exp.OneTimeActions[1], Equals(action1))
+	ExpectThat(exp.FallbackAction, Equals(action2))
+}
+
+func (t *InternalExpectationTest) TimesCalledWithHugeNumber() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.Times(1 << 30)
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Times")))
+	ExpectThat(r.err, Error(HasSubstr("N must be at most 1000")))
+}
+
+func (t *InternalExpectationTest) TimesCalledTwice() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.Times(17)
+	exp.Times(17)
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Times")))
+	ExpectThat(r.err, Error(HasSubstr("more than once")))
+}
+
+func (t *InternalExpectationTest) TimesCalledAfterWillOnce() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillOnce(Return())
+	exp.Times(17)
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Times")))
+	ExpectThat(r.err, Error(HasSubstr("after WillOnce")))
+}
+
+func (t *InternalExpectationTest) TimesCalledAfterWillRepeatedly() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillRepeatedly(Return())
+	exp.Times(17)
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("Times")))
+	ExpectThat(r.err, Error(HasSubstr("after WillRepeatedly")))
+}
+
+func (t *InternalExpectationTest) WillOnceCalledAfterWillRepeatedly() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillRepeatedly(Return())
+	exp.WillOnce(Return())
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("WillOnce")))
+	ExpectThat(r.err, Error(HasSubstr("after WillRepeatedly")))
+}
+
+func (t *InternalExpectationTest) OneTimeActionRejectsSignature() {
+	exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillOnce(Return("taco"))
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("arg 0")))
+	ExpectThat(r.err, Error(HasSubstr("expected float64")))
+	ExpectThat(r.err, Error(HasSubstr("given string")))
+}
+
+func (t *InternalExpectationTest) WillRepeatedlyCalledTwice() {
+	exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillRepeatedly(Return())
+	exp.WillRepeatedly(Return())
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("WillRepeatedly")))
+	ExpectThat(r.err, Error(HasSubstr("once")))
+}
+
+func (t *InternalExpectationTest) FallbackActionRejectsSignature() {
+	exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "taco.go", 112)
+	exp.WillRepeatedly(Return("taco"))
+
+	AssertEq(1, len(t.reporter.fatalErrors))
+	AssertEq(0, len(t.reporter.errors))
+
+	r := t.reporter.fatalErrors[0]
+	ExpectEq("taco.go", r.fileName)
+	ExpectEq(112, r.lineNumber)
+	ExpectThat(r.err, Error(HasSubstr("arg 0")))
+	ExpectThat(r.err, Error(HasSubstr("expected float64")))
+	ExpectThat(r.err, Error(HasSubstr("given string")))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke.go
new file mode 100644
index 00000000000..07630cbbb7e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke.go
@@ -0,0 +1,73 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Create an Action that invokes the supplied function, returning whatever it
+// returns. The signature of the function must match that of the mocked method
+// exactly.
+func Invoke(f interface{}) Action {
+	// Make sure f is a function.
+	fv := reflect.ValueOf(f)
+	fk := fv.Kind()
+
+	if fk != reflect.Func {
+		desc := "<nil>"
+		if fk != reflect.Invalid {
+			desc = fv.Type().String()
+		}
+
+		panic(fmt.Sprintf("Invoke: expected function, got %s", desc))
+	}
+
+	return &invokeAction{fv}
+}
+
+type invokeAction struct {
+	f reflect.Value
+}
+
+func (a *invokeAction) SetSignature(signature reflect.Type) error {
+	// The signature must match exactly.
+	ft := a.f.Type()
+	if ft != signature {
+		return errors.New(fmt.Sprintf("Invoke: expected %v, got %v", signature, ft))
+	}
+
+	return nil
+}
+
+func (a *invokeAction) Invoke(vals []interface{}) []interface{} {
+	// Create a slice of args for the function.
+	in := make([]reflect.Value, len(vals))
+	for i, x := range vals {
+		in[i] = reflect.ValueOf(x)
+	}
+
+	// Call the function and return its return values.
+	out := a.f.Call(in)
+	result := make([]interface{}, len(out))
+	for i, v := range out {
+		result[i] = v.Interface()
+	}
+
+	return result
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke_test.go
new file mode 100644
index 00000000000..9e1478ba8cc
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke_test.go
@@ -0,0 +1,110 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"reflect"
+)
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+type InvokeTest struct {
+}
+
+func init() { RegisterTestSuite(&InvokeTest{}) }
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *InvokeTest) ArgumentIsNil() {
+	f := func() { oglemock.Invoke(nil) }
+	ExpectThat(f, Panics(MatchesRegexp("Invoke.*function.*<nil>")))
+}
+
+func (t *InvokeTest) ArgumentIsInt() {
+	f := func() { oglemock.Invoke(17) }
+	ExpectThat(f, Panics(MatchesRegexp("Invoke.*function.*int")))
+}
+
+func (t *InvokeTest) FunctionHasOneWrongInputType() {
+	f := func(a int, b int32, c string) {}
+	g := func(a int, b int, c string) {}
+
+	err := oglemock.Invoke(f).SetSignature(reflect.TypeOf(g))
+	ExpectThat(err, Error(HasSubstr("func(int, int32, string)")))
+	ExpectThat(err, Error(HasSubstr("func(int, int, string)")))
+}
+
+func (t *InvokeTest) FunctionHasOneWrongOutputType() {
+	f := func() (int32, string) { return 0, "" }
+	g := func() (int, string) { return 0, "" }
+
+	err := oglemock.Invoke(f).SetSignature(reflect.TypeOf(g))
+	ExpectThat(err, Error(HasSubstr("func() (int32, string)")))
+	ExpectThat(err, Error(HasSubstr("func() (int, string)")))
+}
+
+func (t *InvokeTest) CallsFunction() {
+	var actualArg0, actualArg1 interface{}
+
+	f := func(a uintptr, b int8) {
+		actualArg0 = a
+		actualArg1 = b
+	}
+
+	a := oglemock.Invoke(f)
+
+	// Set signature.
+	AssertEq(nil, a.SetSignature(reflect.TypeOf(f)))
+
+	// Call the action.
+	expectedArg0 := uintptr(17)
+	expectedArg1 := int8(-7)
+
+	a.Invoke([]interface{}{expectedArg0, expectedArg1})
+
+	ExpectThat(actualArg0, IdenticalTo(expectedArg0))
+	ExpectThat(actualArg1, IdenticalTo(expectedArg1))
+}
+
+func (t *InvokeTest) ReturnsFunctionResult() {
+	expectedReturn0 := int16(3)
+	expectedReturn1 := "taco"
+
+	f := func() (int16, string) {
+		return expectedReturn0, expectedReturn1
+	}
+
+	a := oglemock.Invoke(f)
+
+	// Set signature.
+	AssertEq(nil, a.SetSignature(reflect.TypeOf(f)))
+
+	// Call the action.
+	res := a.Invoke([]interface{}{})
+
+	ExpectThat(
+		res,
+		ElementsAre(
+			IdenticalTo(expectedReturn0),
+			IdenticalTo(expectedReturn1)))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/mock_object.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/mock_object.go
new file mode 100644
index 00000000000..de995efc667
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/mock_object.go
@@ -0,0 +1,30 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+// MockObject is an interface that mock object implementations must conform to
+// in order to register expectations with and hand off calls to a
+// MockController. Users should not interact with this interface directly.
+type MockObject interface {
+	// Oglemock_Id returns an identifier for the mock object that is guaranteed
+	// to be unique within the process at least until the mock object is garbage
+	// collected.
+	Oglemock_Id() uintptr
+
+	// Oglemock_Description returns a description of the mock object that may be
+	// helpful in test failure messages.
+	Oglemock_Description() string
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return.go
new file mode 100644
index 00000000000..c66d248f44a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return.go
@@ -0,0 +1,251 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+)
+
+var intType = reflect.TypeOf(int(0))
+var float64Type = reflect.TypeOf(float64(0))
+var complex128Type = reflect.TypeOf(complex128(0))
+
+// Return creates an Action that returns the values passed to Return as
+// arguments, after suitable legal type conversions. The following rules apply.
+// Given an argument x to Return and a corresponding type T in the method's
+// signature, at least one of the following must hold:
+//
+//  *  x is assignable to T. (See "Assignability" in the language spec.) Note
+//     that this in particular applies that x may be a type that implements an
+//     interface T. It also implies that the nil literal can be used if T is a
+//     pointer, function, interface, slice, channel, or map type.
+//
+//  *  T is any numeric type, and x is an int that is in-range for that type.
+//     This facilities using raw integer constants: Return(17).
+//
+//  *  T is a floating-point or complex number type, and x is a float64.  This
+//     facilities using raw floating-point constants: Return(17.5).
+//
+//  *  T is a complex number type, and x is a complex128. This facilities using
+//     raw complex constants: Return(17+2i).
+//
+func Return(vals ...interface{}) Action {
+	return &returnAction{vals, nil}
+}
+
+type returnAction struct {
+	returnVals []interface{}
+	signature  reflect.Type
+}
+
+func (a *returnAction) Invoke(vals []interface{}) []interface{} {
+	if a.signature == nil {
+		panic("You must first call SetSignature with a valid signature.")
+	}
+
+	res, err := a.buildInvokeResult(a.signature)
+	if err != nil {
+		panic(err)
+	}
+
+	return res
+}
+
+func (a *returnAction) SetSignature(signature reflect.Type) error {
+	if _, err := a.buildInvokeResult(signature); err != nil {
+		return err
+	}
+
+	a.signature = signature
+	return nil
+}
+
+// A version of Invoke that does error checking, used by both public methods.
+func (a *returnAction) buildInvokeResult(
+	sig reflect.Type) (res []interface{}, err error) {
+	// Check the length of the return value.
+	numOut := sig.NumOut()
+	numVals := len(a.returnVals)
+
+	if numOut != numVals {
+		err = errors.New(
+			fmt.Sprintf("Return given %d vals; expected %d.", numVals, numOut))
+		return
+	}
+
+	// Attempt to coerce each return value.
+	res = make([]interface{}, numOut)
+
+	for i, val := range a.returnVals {
+		resType := sig.Out(i)
+		res[i], err = a.coerce(val, resType)
+
+		if err != nil {
+			res = nil
+			err = errors.New(fmt.Sprintf("Return: arg %d: %v", i, err))
+			return
+		}
+	}
+
+	return
+}
+
+func (a *returnAction) coerce(x interface{}, t reflect.Type) (interface{}, error) {
+	xv := reflect.ValueOf(x)
+	rv := reflect.New(t).Elem()
+
+	// Special case: the language spec says that the predeclared identifier nil
+	// is assignable to pointers, functions, interface, slices, channels, and map
+	// types. However, reflect.ValueOf(nil) returns an invalid value that will
+	// not cooperate below. So handle invalid values here, assuming that they
+	// resulted from Return(nil).
+	if !xv.IsValid() {
+		switch t.Kind() {
+		case reflect.Ptr, reflect.Func, reflect.Interface, reflect.Chan, reflect.Slice, reflect.Map, reflect.UnsafePointer:
+			return rv.Interface(), nil
+		}
+
+		return nil, errors.New(fmt.Sprintf("expected %v, given <nil>", t))
+	}
+
+	// If x is assignable to type t, let the reflect package do the heavy
+	// lifting.
+	if reflect.TypeOf(x).AssignableTo(t) {
+		rv.Set(xv)
+		return rv.Interface(), nil
+	}
+
+	// Handle numeric types as described in the documentation on Return.
+	switch {
+	case xv.Type() == intType && a.isNumeric(t):
+		return a.coerceInt(xv.Int(), t)
+
+	case xv.Type() == float64Type && (a.isFloatingPoint(t) || a.isComplex(t)):
+		return a.coerceFloat(xv.Float(), t)
+
+	case xv.Type() == complex128Type && a.isComplex(t):
+		return a.coerceComplex(xv.Complex(), t)
+	}
+
+	// The value wasn't of a legal type.
+	return nil, errors.New(fmt.Sprintf("expected %v, given %v", t, xv.Type()))
+}
+
+func (a *returnAction) isNumeric(t reflect.Type) bool {
+	return (t.Kind() >= reflect.Int && t.Kind() <= reflect.Uint64) ||
+		a.isFloatingPoint(t) ||
+		a.isComplex(t)
+}
+
+func (a *returnAction) isFloatingPoint(t reflect.Type) bool {
+	return t.Kind() == reflect.Float32 || t.Kind() == reflect.Float64
+}
+
+func (a *returnAction) isComplex(t reflect.Type) bool {
+	return t.Kind() == reflect.Complex64 || t.Kind() == reflect.Complex128
+}
+
+func (a *returnAction) coerceInt(x int64, t reflect.Type) (interface{}, error) {
+	k := t.Kind()
+
+	// Floating point and complex numbers: promote appropriately.
+	if a.isFloatingPoint(t) || a.isComplex(t) {
+		return a.coerceFloat(float64(x), t)
+	}
+
+	// Integers: range check.
+	var min, max int64
+	unsigned := false
+
+	switch k {
+	case reflect.Int8:
+		min = math.MinInt8
+		max = math.MaxInt8
+
+	case reflect.Int16:
+		min = math.MinInt16
+		max = math.MaxInt16
+
+	case reflect.Int32:
+		min = math.MinInt32
+		max = math.MaxInt32
+
+	case reflect.Int64:
+		min = math.MinInt64
+		max = math.MaxInt64
+
+	case reflect.Uint:
+		unsigned = true
+		min = 0
+		max = math.MaxUint32
+
+	case reflect.Uint8:
+		unsigned = true
+		min = 0
+		max = math.MaxUint8
+
+	case reflect.Uint16:
+		unsigned = true
+		min = 0
+		max = math.MaxUint16
+
+	case reflect.Uint32:
+		unsigned = true
+		min = 0
+		max = math.MaxUint32
+
+	case reflect.Uint64:
+		unsigned = true
+		min = 0
+		max = math.MaxInt64
+
+	default:
+		panic(fmt.Sprintf("Unexpected type: %v", t))
+	}
+
+	if x < min || x > max {
+		return nil, errors.New("int value out of range")
+	}
+
+	rv := reflect.New(t).Elem()
+	if unsigned {
+		rv.SetUint(uint64(x))
+	} else {
+		rv.SetInt(x)
+	}
+
+	return rv.Interface(), nil
+}
+
+func (a *returnAction) coerceFloat(x float64, t reflect.Type) (interface{}, error) {
+	// Promote complex numbers.
+	if a.isComplex(t) {
+		return a.coerceComplex(complex(x, 0), t)
+	}
+
+	rv := reflect.New(t).Elem()
+	rv.SetFloat(x)
+	return rv.Interface(), nil
+}
+
+func (a *returnAction) coerceComplex(x complex128, t reflect.Type) (interface{}, error) {
+	rv := reflect.New(t).Elem()
+	rv.SetComplex(x)
+	return rv.Interface(), nil
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return_test.go
new file mode 100644
index 00000000000..f1794bd764a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return_test.go
@@ -0,0 +1,978 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	"bytes"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"io"
+	"math"
+	"reflect"
+	"testing"
+	"unsafe"
+)
+
+////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////
+
+var someInt int = 17
+
+type ReturnTest struct {
+}
+
+func init()                     { RegisterTestSuite(&ReturnTest{}) }
+func TestOgletest(t *testing.T) { RunTests(t) }
+
+type returnTestCase struct {
+	suppliedVal                        interface{}
+	expectedVal                        interface{}
+	expectedSetSignatureErrorSubstring string
+}
+
+func (t *ReturnTest) runTestCases(signature reflect.Type, cases []returnTestCase) {
+	for i, c := range cases {
+		a := oglemock.Return(c.suppliedVal)
+
+		// SetSignature
+		err := a.SetSignature(signature)
+		if c.expectedSetSignatureErrorSubstring == "" {
+			ExpectEq(nil, err, "Test case %d: %v", i, c)
+
+			if err != nil {
+				continue
+			}
+		} else {
+			ExpectThat(err, Error(HasSubstr(c.expectedSetSignatureErrorSubstring)),
+				"Test case %d: %v", i, c)
+			continue
+		}
+
+		// Invoke
+		res := a.Invoke([]interface{}{})
+		AssertThat(res, ElementsAre(Any()))
+		ExpectThat(res[0], IdenticalTo(c.expectedVal), "Test case %d: %v", i, c)
+	}
+}
+
+////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////
+
+func (t *ReturnTest) SetSignatureNotCalled() {
+	a := oglemock.Return()
+	f := func() { a.Invoke([]interface{}{}) }
+	ExpectThat(f, Panics(MatchesRegexp("first call SetSignature")))
+}
+
+func (t *ReturnTest) NoReturnValues() {
+	sig := reflect.TypeOf(func() {})
+	var a oglemock.Action
+	var err error
+	var vals []interface{}
+
+	// No values.
+	a = oglemock.Return()
+	err = a.SetSignature(sig)
+	AssertEq(nil, err)
+
+	vals = a.Invoke([]interface{}{})
+	ExpectThat(vals, ElementsAre())
+
+	// One value.
+	a = oglemock.Return(17)
+	err = a.SetSignature(sig)
+	ExpectThat(err, Error(HasSubstr("given 1 val")))
+	ExpectThat(err, Error(HasSubstr("expected 0")))
+
+	// Two values.
+	a = oglemock.Return(17, 19)
+	err = a.SetSignature(sig)
+	ExpectThat(err, Error(HasSubstr("given 2 vals")))
+	ExpectThat(err, Error(HasSubstr("expected 0")))
+}
+
+func (t *ReturnTest) MultipleReturnValues() {
+	sig := reflect.TypeOf(func() (int, string) { return 0, "" })
+	var a oglemock.Action
+	var err error
+	var vals []interface{}
+
+	// No values.
+	a = oglemock.Return()
+	err = a.SetSignature(sig)
+	ExpectThat(err, Error(HasSubstr("given 0 vals")))
+	ExpectThat(err, Error(HasSubstr("expected 2")))
+
+	// One value.
+	a = oglemock.Return(17)
+	err = a.SetSignature(sig)
+	ExpectThat(err, Error(HasSubstr("given 1 val")))
+	ExpectThat(err, Error(HasSubstr("expected 2")))
+
+	// Two values.
+	a = oglemock.Return(17, "taco")
+	err = a.SetSignature(sig)
+	AssertEq(nil, err)
+
+	vals = a.Invoke([]interface{}{})
+	ExpectThat(vals, ElementsAre(IdenticalTo(int(17)), "taco"))
+}
+
+func (t *ReturnTest) Bool() {
+	sig := reflect.TypeOf(func() bool { return false })
+	cases := []returnTestCase{
+		// Identical types.
+		{bool(true), bool(true), ""},
+		{bool(false), bool(false), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Int() {
+	sig := reflect.TypeOf(func() int { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{int(math.MinInt32), int(math.MinInt32), ""},
+		{int(math.MaxInt32), int(math.MaxInt32), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Int8() {
+	sig := reflect.TypeOf(func() int8 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{int8(math.MinInt8), int8(math.MinInt8), ""},
+		{int8(math.MaxInt8), int8(math.MaxInt8), ""},
+
+		// In-range ints.
+		{int(math.MinInt8), int8(math.MinInt8), ""},
+		{int(math.MaxInt8), int8(math.MaxInt8), ""},
+
+		// Out of range ints.
+		{int(math.MinInt8 - 1), nil, "out of range"},
+		{int(math.MaxInt8 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Int16() {
+	sig := reflect.TypeOf(func() int16 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{int16(math.MinInt16), int16(math.MinInt16), ""},
+		{int16(math.MaxInt16), int16(math.MaxInt16), ""},
+
+		// In-range ints.
+		{int(math.MinInt16), int16(math.MinInt16), ""},
+		{int(math.MaxInt16), int16(math.MaxInt16), ""},
+
+		// Out of range ints.
+		{int(math.MinInt16 - 1), nil, "out of range"},
+		{int(math.MaxInt16 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int8(1), nil, "given int8"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Int32() {
+	sig := reflect.TypeOf(func() int32 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{int32(math.MinInt32), int32(math.MinInt32), ""},
+		{int32(math.MaxInt32), int32(math.MaxInt32), ""},
+
+		// Aliased version of type.
+		{rune(17), int32(17), ""},
+
+		// In-range ints.
+		{int(math.MinInt32), int32(math.MinInt32), ""},
+		{int(math.MaxInt32), int32(math.MaxInt32), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Rune() {
+	sig := reflect.TypeOf(func() rune { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{rune(math.MinInt32), rune(math.MinInt32), ""},
+		{rune(math.MaxInt32), rune(math.MaxInt32), ""},
+
+		// Aliased version of type.
+		{int32(17), rune(17), ""},
+
+		// In-range ints.
+		{int(math.MinInt32), rune(math.MinInt32), ""},
+		{int(math.MaxInt32), rune(math.MaxInt32), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Int64() {
+	sig := reflect.TypeOf(func() int64 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{int64(math.MinInt64), int64(math.MinInt64), ""},
+		{int64(math.MaxInt64), int64(math.MaxInt64), ""},
+
+		// In-range ints.
+		{int(math.MinInt32), int64(math.MinInt32), ""},
+		{int(math.MaxInt32), int64(math.MaxInt32), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uint() {
+	sig := reflect.TypeOf(func() uint { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uint(0), uint(0), ""},
+		{uint(math.MaxUint32), uint(math.MaxUint32), ""},
+
+		// In-range ints.
+		{int(0), uint(0), ""},
+		{int(math.MaxInt32), uint(math.MaxInt32), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uint8() {
+	sig := reflect.TypeOf(func() uint8 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uint8(0), uint8(0), ""},
+		{uint8(math.MaxUint8), uint8(math.MaxUint8), ""},
+
+		// Aliased version of type.
+		{byte(17), uint8(17), ""},
+
+		// In-range ints.
+		{int(0), uint8(0), ""},
+		{int(math.MaxUint8), uint8(math.MaxUint8), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+		{int(math.MaxUint8 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Byte() {
+	sig := reflect.TypeOf(func() byte { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{byte(0), byte(0), ""},
+		{byte(math.MaxUint8), byte(math.MaxUint8), ""},
+
+		// Aliased version of type.
+		{uint8(17), byte(17), ""},
+
+		// In-range ints.
+		{int(0), byte(0), ""},
+		{int(math.MaxUint8), byte(math.MaxUint8), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+		{int(math.MaxUint8 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uint16() {
+	sig := reflect.TypeOf(func() uint16 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uint16(0), uint16(0), ""},
+		{uint16(math.MaxUint16), uint16(math.MaxUint16), ""},
+
+		// In-range ints.
+		{int(0), uint16(0), ""},
+		{int(math.MaxUint16), uint16(math.MaxUint16), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+		{int(math.MaxUint16 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uint32() {
+	sig := reflect.TypeOf(func() uint32 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uint32(0), uint32(0), ""},
+		{uint32(math.MaxUint32), uint32(math.MaxUint32), ""},
+
+		// In-range ints.
+		{int(0), uint32(0), ""},
+		{int(math.MaxInt32), uint32(math.MaxInt32), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uint64() {
+	sig := reflect.TypeOf(func() uint64 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uint64(0), uint64(0), ""},
+		{uint64(math.MaxUint64), uint64(math.MaxUint64), ""},
+
+		// In-range ints.
+		{int(0), uint64(0), ""},
+		{int(math.MaxInt32), uint64(math.MaxInt32), ""},
+
+		// Out of range ints.
+		{int(-1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Uintptr() {
+	sig := reflect.TypeOf(func() uintptr { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{uintptr(17), uintptr(17), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Float32() {
+	sig := reflect.TypeOf(func() float32 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{float32(-17.5), float32(-17.5), ""},
+		{float32(17.5), float32(17.5), ""},
+
+		// In-range ints.
+		{int(-17), float32(-17), ""},
+		{int(17), float32(17), ""},
+
+		// Float64s
+		{float64(-17.5), float32(-17.5), ""},
+		{float64(17.5), float32(17.5), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Float64() {
+	sig := reflect.TypeOf(func() float64 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{float64(-17.5), float64(-17.5), ""},
+		{float64(17.5), float64(17.5), ""},
+
+		// In-range ints.
+		{int(-17), float64(-17), ""},
+		{int(17), float64(17), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float32(1), nil, "given float32"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Complex64() {
+	sig := reflect.TypeOf(func() complex64 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{complex64(-17.5 - 1i), complex64(-17.5 - 1i), ""},
+		{complex64(17.5 + 1i), complex64(17.5 + 1i), ""},
+
+		// In-range ints.
+		{int(-17), complex64(-17), ""},
+		{int(17), complex64(17), ""},
+
+		// Float64s
+		{float64(-17.5), complex64(-17.5), ""},
+		{float64(17.5), complex64(17.5), ""},
+
+		// Complex128s
+		{complex128(-17.5 - 1i), complex64(-17.5 - 1i), ""},
+		{complex128(17.5 + 1i), complex64(17.5 + 1i), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float32(1), nil, "given float32"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Complex128() {
+	sig := reflect.TypeOf(func() complex128 { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{complex128(-17.5 - 1i), complex128(-17.5 - 1i), ""},
+		{complex128(17.5 + 1i), complex128(17.5 + 1i), ""},
+
+		// In-range ints.
+		{int(-17), complex128(-17), ""},
+		{int(17), complex128(17), ""},
+
+		// Float64s
+		{float64(-17.5), complex128(-17.5), ""},
+		{float64(17.5), complex128(17.5), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float32(1), nil, "given float32"},
+		{complex64(1), nil, "given complex64"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) ArrayOfInt() {
+	type namedElemType int
+
+	sig := reflect.TypeOf(func() [2]int { return [2]int{0, 0} })
+	cases := []returnTestCase{
+		// Identical types.
+		{[2]int{19, 23}, [2]int{19, 23}, ""},
+
+		// Wrong length.
+		{[1]int{17}, nil, "given [1]int"},
+
+		// Wrong element types.
+		{[2]namedElemType{19, 23}, nil, "given [2]oglemock_test.namedElemType"},
+		{[2]string{"", ""}, nil, "given [2]string"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) ChanOfInt() {
+	type namedElemType int
+	someChan := make(chan int)
+
+	sig := reflect.TypeOf(func() chan int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someChan, someChan, ""},
+
+		// Nil values.
+		{(interface{})(nil), (chan int)(nil), ""},
+		{(chan int)(nil), (chan int)(nil), ""},
+
+		// Wrong element types.
+		{make(chan string), nil, "given chan string"},
+		{make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"},
+
+		// Wrong direction
+		{(<-chan int)(someChan), nil, "given <-chan int"},
+		{(chan<- int)(someChan), nil, "given chan<- int"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) SendChanOfInt() {
+	type namedElemType int
+
+	someChan := make(chan<- int)
+	someBidirectionalChannel := make(chan int)
+
+	sig := reflect.TypeOf(func() chan<- int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someChan, someChan, ""},
+
+		// Nil values.
+		{(interface{})(nil), (chan<- int)(nil), ""},
+		{(chan int)(nil), (chan<- int)(nil), ""},
+
+		// Bidirectional channel
+		{someBidirectionalChannel, (chan<- int)(someBidirectionalChannel), ""},
+
+		// Wrong direction
+		{(<-chan int)(someBidirectionalChannel), nil, "given <-chan int"},
+
+		// Wrong element types.
+		{make(chan string), nil, "given chan string"},
+		{make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) RecvChanOfInt() {
+	type namedElemType int
+
+	someChan := make(<-chan int)
+	someBidirectionalChannel := make(chan int)
+
+	sig := reflect.TypeOf(func() <-chan int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someChan, someChan, ""},
+
+		// Nil values.
+		{(interface{})(nil), (<-chan int)(nil), ""},
+		{(chan int)(nil), (<-chan int)(nil), ""},
+
+		// Bidirectional channel
+		{someBidirectionalChannel, (<-chan int)(someBidirectionalChannel), ""},
+
+		// Wrong direction
+		{(chan<- int)(someBidirectionalChannel), nil, "given chan<- int"},
+
+		// Wrong element types.
+		{make(chan string), nil, "given chan string"},
+		{make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Func() {
+	someFunc := func(string) int { return 0 }
+
+	sig := reflect.TypeOf(func() func(string) int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someFunc, someFunc, ""},
+
+		// Nil values.
+		{(interface{})(nil), (func(string) int)(nil), ""},
+		{(func(string) int)(nil), (func(string) int)(nil), ""},
+
+		// Wrong parameter and return types.
+		{func(int) int { return 0 }, nil, "given func(int) int"},
+		{func(string) string { return "" }, nil, "given func(string) string"},
+
+		// Wrong types.
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{(chan int)(nil), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Interface() {
+	sig := reflect.TypeOf(func() io.Reader { return nil })
+
+	someBuffer := new(bytes.Buffer)
+
+	cases := []returnTestCase{
+		// Type that implements interface.
+		{someBuffer, someBuffer, ""},
+
+		// Nil value.
+		{(interface{})(nil), (interface{})(nil), ""},
+
+		// Non-implementing types.
+		{(chan int)(nil), nil, "given chan int"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) MapFromStringToInt() {
+	type namedElemType string
+
+	someMap := make(map[string]int)
+
+	sig := reflect.TypeOf(func() map[string]int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someMap, someMap, ""},
+
+		// Nil values.
+		{(interface{})(nil), (map[string]int)(nil), ""},
+		{(map[string]int)(nil), (map[string]int)(nil), ""},
+
+		// Wrong element types.
+		{make(map[int]int), nil, "given map[int]int"},
+		{make(map[namedElemType]int), nil, "given map[oglemock_test.namedElemType]int"},
+		{make(map[string]string), nil, "given map[string]string"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) PointerToString() {
+	type namedElemType string
+
+	someStr := ""
+
+	sig := reflect.TypeOf(func() *string { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{(*string)(&someStr), (*string)(&someStr), ""},
+
+		// Nil values.
+		{(interface{})(nil), (*string)(nil), ""},
+		{(*string)(nil), (*string)(nil), ""},
+
+		// Wrong element types.
+		{&someInt, nil, "given *int"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{unsafe.Pointer(&someStr), nil, "given unsafe.Pointer"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) SliceOfInts() {
+	type namedElemType int
+
+	someSlice := make([]int, 1)
+
+	sig := reflect.TypeOf(func() []int { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{someSlice, someSlice, ""},
+
+		// Nil values.
+		{(interface{})(nil), ([]int)(nil), ""},
+		{([]int)(nil), ([]int)(nil), ""},
+
+		// Wrong element types.
+		{make([]string, 1), nil, "given []string"},
+		{make([]namedElemType, 1), nil, "given []oglemock_test.namedElemType"},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) String() {
+	sig := reflect.TypeOf(func() string { return "" })
+	cases := []returnTestCase{
+		// Identical types.
+		{string(""), string(""), ""},
+		{string("taco"), string("taco"), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) Struct() {
+	type myStruct struct {
+		a int
+	}
+
+	type otherStruct struct{}
+
+	sig := reflect.TypeOf(func() myStruct { return myStruct{0} })
+	cases := []returnTestCase{
+		// Identical types.
+		{myStruct{17}, myStruct{17}, ""},
+
+		// Wrong field types.
+		{otherStruct{}, nil, "given oglemock_test.otherStruct"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) UnsafePointer() {
+	someStr := ""
+
+	sig := reflect.TypeOf(func() unsafe.Pointer { return nil })
+	cases := []returnTestCase{
+		// Identical types.
+		{unsafe.Pointer(&someStr), unsafe.Pointer(&someStr), ""},
+
+		// Nil values.
+		{(interface{})(nil), unsafe.Pointer(nil), ""},
+		{unsafe.Pointer(nil), unsafe.Pointer(nil), ""},
+
+		// Wrong types.
+		{(func())(nil), nil, "given func()"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{(*string)(&someStr), nil, "given *string"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) UserDefinedNumericType() {
+	type myType int16
+
+	sig := reflect.TypeOf(func() myType { return 0 })
+	cases := []returnTestCase{
+		// Identical types.
+		{myType(math.MinInt16), myType(math.MinInt16), ""},
+		{myType(math.MaxInt16), myType(math.MaxInt16), ""},
+
+		// In-range ints.
+		{int(math.MinInt16), myType(math.MinInt16), ""},
+		{int(math.MaxInt16), myType(math.MaxInt16), ""},
+
+		// Out of range ints.
+		{int(math.MinInt16 - 1), nil, "out of range"},
+		{int(math.MaxInt16 + 1), nil, "out of range"},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int16(1), nil, "given int16"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
+
+func (t *ReturnTest) UserDefinedNonNumericType() {
+	type myType string
+
+	sig := reflect.TypeOf(func() myType { return "" })
+	cases := []returnTestCase{
+		// Identical types.
+		{myType("taco"), myType("taco"), ""},
+
+		// Wrong types.
+		{nil, nil, "given <nil>"},
+		{int(1), nil, "given int"},
+		{float64(1), nil, "given float64"},
+		{complex128(1), nil, "given complex128"},
+		{string(""), nil, "given string"},
+		{&someInt, nil, "given *int"},
+		{make(chan int), nil, "given chan int"},
+	}
+
+	t.runTestCases(sig, cases)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/README.markdown b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/README.markdown
new file mode 100644
index 00000000000..60d5d2cb1ab
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/README.markdown
@@ -0,0 +1,6 @@
+This directory contains sample code generated with the `createmock` command. For
+example, the file `mock_io.go` can be regenerated with:
+
+    createmock io Reader > sample/mock_io/mock_io.go
+
+The files are also used by `integration_test.go`.
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/mock_io/mock_io.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/mock_io/mock_io.go
new file mode 100644
index 00000000000..76e8f00056d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/mock_io/mock_io.go
@@ -0,0 +1,71 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package mock_io
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	io "io"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockReader interface {
+	io.Reader
+	oglemock.MockObject
+}
+
+type mockReader struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockReader(
+	c oglemock.Controller,
+	desc string) MockReader {
+	return &mockReader{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockReader) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockReader) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockReader) Read(p0 []uint8) (o0 int, o1 error) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Read",
+		file,
+		line,
+		[]interface{}{p0})
+
+	if len(retVals) != 2 {
+		panic(fmt.Sprintf("mockReader.Read: invalid return values: %v", retVals))
+	}
+
+	// o0 int
+	if retVals[0] != nil {
+		o0 = retVals[0].(int)
+	}
+
+	// o1 error
+	if retVals[1] != nil {
+		o1 = retVals[1].(error)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg.go
new file mode 100644
index 00000000000..27cfcf6193b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg.go
@@ -0,0 +1,83 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Create an Action that saves the argument at the given zero-based index to
+// the supplied destination, which must be a pointer to a type that is
+// assignable from the argument type.
+func SaveArg(index int, dst interface{}) Action {
+	return &saveArg{
+		index:      index,
+		dstPointer: dst,
+	}
+}
+
+type saveArg struct {
+	index      int
+	dstPointer interface{}
+
+	// Set by SetSignature.
+	dstValue reflect.Value
+}
+
+func (a *saveArg) SetSignature(signature reflect.Type) (err error) {
+	// Extract the source type.
+	if a.index >= signature.NumIn() {
+		err = fmt.Errorf(
+			"Out of range argument index %v for function type %v",
+			a.index,
+			signature)
+		return
+	}
+
+	srcType := signature.In(a.index)
+
+	// The destination must be a pointer.
+	v := reflect.ValueOf(a.dstPointer)
+	if v.Kind() != reflect.Ptr {
+		err = fmt.Errorf("Destination is %v, not a pointer", v.Kind())
+		return
+	}
+
+	// Dereference the pointer.
+	if v.IsNil() {
+		err = fmt.Errorf("Destination pointer must be non-nil")
+		return
+	}
+
+	a.dstValue = v.Elem()
+
+	// The destination must be assignable from the source.
+	if !srcType.AssignableTo(a.dstValue.Type()) {
+		err = fmt.Errorf(
+			"%v is not assignable to %v",
+			srcType,
+			a.dstValue.Type())
+		return
+	}
+
+	return
+}
+
+func (a *saveArg) Invoke(methodArgs []interface{}) (rets []interface{}) {
+	a.dstValue.Set(reflect.ValueOf(methodArgs[a.index]))
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg_test.go b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg_test.go
new file mode 100644
index 00000000000..4051907e0dd
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg_test.go
@@ -0,0 +1,132 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglemock_test
+
+import (
+	"io"
+	"os"
+	"reflect"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestSaveArg(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////
+// Boilerplate
+////////////////////////////////////////////////////////////
+
+type SaveArgTest struct {
+}
+
+func init() { RegisterTestSuite(&SaveArgTest{}) }
+
+////////////////////////////////////////////////////////////
+// Test functions
+////////////////////////////////////////////////////////////
+
+func (t *SaveArgTest) FunctionHasNoArguments() {
+	const index = 0
+	var dst int
+	f := func() (int, string) { return 0, "" }
+
+	err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("index 0")))
+	ExpectThat(err, Error(HasSubstr("Out of range")))
+	ExpectThat(err, Error(HasSubstr("func() (int, string)")))
+}
+
+func (t *SaveArgTest) ArgumentIndexOutOfRange() {
+	const index = 2
+	var dst int
+	f := func(a int, b int) {}
+
+	err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("index 2")))
+	ExpectThat(err, Error(HasSubstr("Out of range")))
+	ExpectThat(err, Error(HasSubstr("func(int, int)")))
+}
+
+func (t *SaveArgTest) DestinationIsLiteralNil() {
+	const index = 0
+	f := func(a int, b int) {}
+
+	err := oglemock.SaveArg(index, nil).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("not a pointer")))
+}
+
+func (t *SaveArgTest) DestinationIsNotAPointer() {
+	const index = 0
+	f := func(a int, b int) {}
+
+	err := oglemock.SaveArg(index, uint(17)).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("pointer")))
+	ExpectThat(err, Error(HasSubstr("uint")))
+}
+
+func (t *SaveArgTest) DestinationIsNilPointer() {
+	const index = 1
+	var dst *int
+	f := func(a int, b int) {}
+
+	err := oglemock.SaveArg(index, dst).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("pointer")))
+	ExpectThat(err, Error(HasSubstr("non-nil")))
+}
+
+func (t *SaveArgTest) DestinationNotAssignableFromSource() {
+	const index = 1
+	var dst int
+	f := func(a int, b string) {}
+
+	err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f))
+	ExpectThat(err, Error(HasSubstr("int")))
+	ExpectThat(err, Error(HasSubstr("assignable")))
+	ExpectThat(err, Error(HasSubstr("string")))
+}
+
+func (t *SaveArgTest) ExactTypeMatch() {
+	const index = 1
+	var dst int
+	f := func(a int, b int) {}
+
+	action := oglemock.SaveArg(index, &dst)
+	AssertEq(nil, action.SetSignature(reflect.TypeOf(f)))
+
+	var a int = 17
+	var b int = 19
+	_ = action.Invoke([]interface{}{a, b})
+
+	ExpectEq(19, dst)
+}
+
+func (t *SaveArgTest) AssignableTypeMatch() {
+	const index = 1
+	var dst io.Reader
+	f := func(a int, b *os.File) {}
+
+	action := oglemock.SaveArg(index, &dst)
+	AssertEq(nil, action.SetSignature(reflect.TypeOf(f)))
+
+	var a int = 17
+	var b *os.File = os.Stdout
+	_ = action.Invoke([]interface{}{a, b})
+
+	ExpectEq(os.Stdout, dst)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.gitignore b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.gitignore
new file mode 100644
index 00000000000..dd8fc7468f4
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.gitignore
@@ -0,0 +1,5 @@
+*.6
+6.out
+_obj/
+_test/
+_testmain.go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.travis.yml b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.travis.yml
new file mode 100644
index 00000000000..b97211926e8
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.travis.yml
@@ -0,0 +1,4 @@
+# Cf. http://docs.travis-ci.com/user/getting-started/
+# Cf. http://docs.travis-ci.com/user/languages/go/
+
+language: go
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/LICENSE b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/README.md b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/README.md
new file mode 100644
index 00000000000..8e54862082b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/README.md
@@ -0,0 +1,151 @@
+[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/ogletest?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/ogletest)
+
+`ogletest` is a unit testing framework for Go with the following features:
+
+ *  An extensive and extensible set of matchers for expressing expectations.
+ *  Automatic failure messages; no need to say `t.Errorf("Expected %v, got
+    %v"...)`.
+ *  Clean, readable output that tells you exactly what you need to know.
+ *  Built-in support for mocking through the [oglemock][] package.
+ *  Style and semantics similar to [Google Test][googletest] and
+    [Google JS Test][google-js-test].
+
+It integrates with Go's built-in `testing` package, so it works with the
+`go test` command, and even with other types of test within your package. Unlike
+the `testing` package which offers only basic capabilities for signalling
+failures, it offers ways to express expectations and get nice failure messages
+automatically.
+
+
+Installation
+------------
+
+First, make sure you have installed Go 1.0.2 or newer. See
+[here][golang-install] for instructions.
+
+Use the following command to install `ogletest` and its dependencies, and to
+keep them up to date:
+
+    go get -u github.com/smartystreets/assertions/internal/ogletest
+
+
+Documentation
+-------------
+
+See [here][reference] for package documentation containing an exhaustive list of
+exported symbols. Alternatively, you can install the package and then use
+`godoc`:
+
+    godoc github.com/smartystreets/assertions/internal/ogletest
+
+An important part of `ogletest` is its use of matchers provided by the
+[oglematchers][matcher-reference] package. See that package's documentation
+for information on the built-in matchers available, and check out the
+`oglematchers.Matcher` interface if you want to define your own.
+
+
+Example
+-------
+
+Let's say you have a function in your package `people` with the following
+signature:
+
+```go
+// GetRandomPerson returns the name and phone number of Tony, Dennis, or Scott.
+func GetRandomPerson() (name, phone string) {
+  [...]
+}
+```
+
+A silly function, but it will do for an example. You can write a couple of tests
+for it as follows:
+
+```go
+package people
+
+import (
+  "github.com/smartystreets/assertions/internal/oglematchers"
+  "github.com/smartystreets/assertions/internal/ogletest"
+  "testing"
+)
+
+// Give ogletest a chance to run your tests when invoked by 'go test'.
+func TestOgletest(t *testing.T) { ogletest.RunTests(t) }
+
+// Create a test suite, which groups together logically related test methods
+// (defined below). You can share common setup and teardown code here; see the
+// package docs for more info.
+type PeopleTest struct {}
+func init() { ogletest.RegisterTestSuite(&PeopleTest{}) }
+
+func (t *PeopleTest) ReturnsCorrectNames() {
+  // Call the function a few times, and make sure it never strays from the set
+  // of expected names.
+  for i := 0; i < 25; i++ {
+    name, _ := GetRandomPerson()
+    ogletest.ExpectThat(name, oglematchers.AnyOf("Tony", "Dennis", "Scott"))
+  }
+}
+
+func (t *PeopleTest) FormatsPhoneNumbersCorrectly() {
+  // Call the function a few times, and make sure it returns phone numbers in a
+  // standard US format.
+  for i := 0; i < 25; i++ {
+    _, phone := GetRandomPerson()
+    ogletest.ExpectThat(phone, oglematchers.MatchesRegexp(`^\(\d{3}\) \d{3}-\d{4}$`))
+}
+```
+
+Note that test control functions (`RunTests`, `ExpectThat`, and so on) are part
+of the `ogletest` package, whereas built-in matchers (`AnyOf`, `MatchesRegexp`,
+and more) are part of the [oglematchers][matcher-reference] library. You can of
+course use dot imports so that you don't need to prefix each function with its
+package name:
+
+```go
+import (
+  . "github.com/smartystreets/assertions/internal/oglematchers"
+  . "github.com/smartystreets/assertions/internal/ogletest"
+)
+```
+
+If you save the test in a file whose name ends in `_test.go`, you can run your
+tests by simply invoking the following in your package directory:
+
+    go test
+
+Here's what the failure output of ogletest looks like, if your function's
+implementation is bad.
+
+    [----------] Running tests from PeopleTest
+    [ RUN      ] PeopleTest.FormatsPhoneNumbersCorrectly
+    people_test.go:32:
+    Expected: matches regexp "^\(\d{3}\) \d{3}-\d{4}$"
+    Actual:   +1 800 555 5555
+    
+    [  FAILED  ] PeopleTest.FormatsPhoneNumbersCorrectly
+    [ RUN      ] PeopleTest.ReturnsCorrectNames
+    people_test.go:23:
+    Expected: or(Tony, Dennis, Scott)
+    Actual:   Bart
+    
+    [  FAILED  ] PeopleTest.ReturnsCorrectNames
+    [----------] Finished with tests from PeopleTest
+
+And if the test passes:
+
+    [----------] Running tests from PeopleTest
+    [ RUN      ] PeopleTest.FormatsPhoneNumbersCorrectly
+    [       OK ] PeopleTest.FormatsPhoneNumbersCorrectly
+    [ RUN      ] PeopleTest.ReturnsCorrectNames
+    [       OK ] PeopleTest.ReturnsCorrectNames
+    [----------] Finished with tests from PeopleTest
+
+
+[reference]: http://godoc.org/github.com/smartystreets/assertions/internal/ogletest
+[matcher-reference]: http://godoc.org/github.com/smartystreets/assertions/internal/oglematchers
+[golang-install]: http://golang.org/doc/install.html
+[googletest]: http://code.google.com/p/googletest/
+[google-js-test]: http://code.google.com/p/google-js-test/
+[howtowrite]: http://golang.org/doc/code.html
+[oglemock]: https://github.com/smartystreets/assertions/internal/oglemock
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_aliases.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_aliases.go
new file mode 100644
index 00000000000..70fa25c327a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_aliases.go
@@ -0,0 +1,70 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+// AssertEq(e, a) is equivalent to AssertThat(a, oglematchers.Equals(e)).
+func AssertEq(expected, actual interface{}, errorParts ...interface{}) {
+	assertThat(
+		actual,
+		oglematchers.Equals(expected),
+		1,
+		errorParts)
+}
+
+// AssertNe(e, a) is equivalent to
+// AssertThat(a, oglematchers.Not(oglematchers.Equals(e))).
+func AssertNe(expected, actual interface{}, errorParts ...interface{}) {
+	assertThat(
+		actual,
+		oglematchers.Not(oglematchers.Equals(expected)),
+		1,
+		errorParts)
+}
+
+// AssertLt(x, y) is equivalent to AssertThat(x, oglematchers.LessThan(y)).
+func AssertLt(x, y interface{}, errorParts ...interface{}) {
+	assertThat(x, oglematchers.LessThan(y), 1, errorParts)
+}
+
+// AssertLe(x, y) is equivalent to AssertThat(x, oglematchers.LessOrEqual(y)).
+func AssertLe(x, y interface{}, errorParts ...interface{}) {
+	assertThat(x, oglematchers.LessOrEqual(y), 1, errorParts)
+}
+
+// AssertGt(x, y) is equivalent to AssertThat(x, oglematchers.GreaterThan(y)).
+func AssertGt(x, y interface{}, errorParts ...interface{}) {
+	assertThat(x, oglematchers.GreaterThan(y), 1, errorParts)
+}
+
+// AssertGe(x, y) is equivalent to
+// AssertThat(x, oglematchers.GreaterOrEqual(y)).
+func AssertGe(x, y interface{}, errorParts ...interface{}) {
+	assertThat(x, oglematchers.GreaterOrEqual(y), 1, errorParts)
+}
+
+// AssertTrue(b) is equivalent to AssertThat(b, oglematchers.Equals(true)).
+func AssertTrue(b interface{}, errorParts ...interface{}) {
+	assertThat(b, oglematchers.Equals(true), 1, errorParts)
+}
+
+// AssertFalse(b) is equivalent to AssertThat(b, oglematchers.Equals(false)).
+func AssertFalse(b interface{}, errorParts ...interface{}) {
+	assertThat(b, oglematchers.Equals(false), 1, errorParts)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_that.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_that.go
new file mode 100644
index 00000000000..65c8fbce052
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_that.go
@@ -0,0 +1,46 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+func assertThat(
+	x interface{},
+	m oglematchers.Matcher,
+	depth int,
+	errorParts []interface{}) {
+	passed := expectThat(x, m, depth+1, errorParts)
+	if !passed {
+		AbortTest()
+	}
+}
+
+// AssertThat is identical to ExpectThat, except that in the event of failure
+// it halts the currently running test immediately. It is thus useful for
+// things like bounds checking:
+//
+//     someSlice := [...]
+//     AssertEq(1, len(someSlice))  // Protects next line from panicking.
+//     ExpectEq("taco", someSlice[0])
+//
+func AssertThat(
+	x interface{},
+	m oglematchers.Matcher,
+	errorParts ...interface{}) {
+	assertThat(x, m, 1, errorParts)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/doc.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/doc.go
new file mode 100644
index 00000000000..bf6507fae4d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/doc.go
@@ -0,0 +1,51 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package ogletest provides a framework for writing expressive unit tests. It
+// integrates with the builtin testing package, so it works with the gotest
+// command. Unlike the testing package which offers only basic capabilities for
+// signalling failures, it offers ways to express expectations and get nice
+// failure messages automatically.
+//
+// For example:
+//
+//     ////////////////////////////////////////////////////////////////////////
+//     // testing package test
+//     ////////////////////////////////////////////////////////////////////////
+//
+//     someStr, err := ComputeSomeString()
+//     if err != nil {
+//       t.Errorf("ComputeSomeString: expected nil error, got %v", err)
+//     }
+//
+//     !strings.Contains(someStr, "foo") {
+//       t.Errorf("ComputeSomeString: expected substring foo, got %v", someStr)
+//     }
+//
+//     ////////////////////////////////////////////////////////////////////////
+//     // ogletest test
+//     ////////////////////////////////////////////////////////////////////////
+//
+//     someStr, err := ComputeSomeString()
+//     ExpectEq(nil, err)
+//     ExpectThat(someStr, HasSubstr("foo")
+//
+// Failure messages require no work from the user, and look like the following:
+//
+//     foo_test.go:103:
+//     Expected: has substring "foo"
+//     Actual:   "bar baz"
+//
+package ogletest
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_aliases.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_aliases.go
new file mode 100644
index 00000000000..5bc1dc120a7
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_aliases.go
@@ -0,0 +1,64 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import "github.com/smartystreets/assertions/internal/oglematchers"
+
+// ExpectEq(e, a) is equivalent to ExpectThat(a, oglematchers.Equals(e)).
+func ExpectEq(expected, actual interface{}, errorParts ...interface{}) {
+	expectThat(actual, oglematchers.Equals(expected), 1, errorParts)
+}
+
+// ExpectNe(e, a) is equivalent to
+// ExpectThat(a, oglematchers.Not(oglematchers.Equals(e))).
+func ExpectNe(expected, actual interface{}, errorParts ...interface{}) {
+	expectThat(
+		actual,
+		oglematchers.Not(oglematchers.Equals(expected)),
+		1,
+		errorParts)
+}
+
+// ExpectLt(x, y) is equivalent to ExpectThat(x, oglematchers.LessThan(y)).
+func ExpectLt(x, y interface{}, errorParts ...interface{}) {
+	expectThat(x, oglematchers.LessThan(y), 1, errorParts)
+}
+
+// ExpectLe(x, y) is equivalent to ExpectThat(x, oglematchers.LessOrEqual(y)).
+func ExpectLe(x, y interface{}, errorParts ...interface{}) {
+	expectThat(x, oglematchers.LessOrEqual(y), 1, errorParts)
+}
+
+// ExpectGt(x, y) is equivalent to ExpectThat(x, oglematchers.GreaterThan(y)).
+func ExpectGt(x, y interface{}, errorParts ...interface{}) {
+	expectThat(x, oglematchers.GreaterThan(y), 1, errorParts)
+}
+
+// ExpectGe(x, y) is equivalent to
+// ExpectThat(x, oglematchers.GreaterOrEqual(y)).
+func ExpectGe(x, y interface{}, errorParts ...interface{}) {
+	expectThat(x, oglematchers.GreaterOrEqual(y), 1, errorParts)
+}
+
+// ExpectTrue(b) is equivalent to ExpectThat(b, oglematchers.Equals(true)).
+func ExpectTrue(b interface{}, errorParts ...interface{}) {
+	expectThat(b, oglematchers.Equals(true), 1, errorParts)
+}
+
+// ExpectFalse(b) is equivalent to ExpectThat(b, oglematchers.Equals(false)).
+func ExpectFalse(b interface{}, errorParts ...interface{}) {
+	expectThat(b, oglematchers.Equals(false), 1, errorParts)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_call.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_call.go
new file mode 100644
index 00000000000..b8bf542a8bc
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_call.go
@@ -0,0 +1,59 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"github.com/smartystreets/assertions/internal/oglemock"
+	"runtime"
+)
+
+// ExpectCall expresses an expectation that the method of the given name
+// should be called on the supplied mock object. It returns a function that
+// should be called with the expected arguments, matchers for the arguments,
+// or a mix of both.
+//
+// For example:
+//
+//     mockWriter := [...]
+//     ogletest.ExpectCall(mockWriter, "Write")(oglematchers.ElementsAre(0x1))
+//         .WillOnce(oglemock.Return(1, nil))
+//
+// This is a shortcut for calling i.MockController.ExpectCall, where i is the
+// TestInfo struct for the currently-running test. Unlike that direct approach,
+// this function automatically sets the correct file name and line number for
+// the expectation.
+func ExpectCall(o oglemock.MockObject, method string) oglemock.PartialExpecation {
+	// Get information about the call site.
+	_, file, lineNumber, ok := runtime.Caller(1)
+	if !ok {
+		panic("ExpectCall: runtime.Caller")
+	}
+
+	// Grab the current test info.
+	info := currentlyRunningTest
+	if info == nil {
+		panic("ExpectCall: no test info.")
+	}
+
+	// Grab the mock controller.
+	controller := currentlyRunningTest.MockController
+	if controller == nil {
+		panic("ExpectCall: no mock controller.")
+	}
+
+	// Report the expectation.
+	return controller.ExpectCall(o, method, file, lineNumber)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that.go
new file mode 100644
index 00000000000..69fc669785d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that.go
@@ -0,0 +1,100 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"fmt"
+	"path"
+	"reflect"
+	"runtime"
+
+	"github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+// ExpectThat confirms that the supplied matcher matches the value x, adding a
+// failure record to the currently running test if it does not. If additional
+// parameters are supplied, the first will be used as a format string for the
+// later ones, and the user-supplied error message will be added to the test
+// output in the event of a failure.
+//
+// For example:
+//
+//     ExpectThat(userName, Equals("jacobsa"))
+//     ExpectThat(users[i], Equals("jacobsa"), "while processing user %d", i)
+//
+func ExpectThat(
+	x interface{},
+	m oglematchers.Matcher,
+	errorParts ...interface{}) {
+	expectThat(x, m, 1, errorParts)
+}
+
+// The generalized form of ExpectThat. depth is the distance on the stack
+// between the caller's frame and the user's frame. Returns passed iff the
+// match succeeded.
+func expectThat(
+	x interface{},
+	m oglematchers.Matcher,
+	depth int,
+	errorParts []interface{}) (passed bool) {
+	// Check whether the value matches. If it does, we are finished.
+	matcherErr := m.Matches(x)
+	if matcherErr == nil {
+		passed = true
+		return
+	}
+
+	var r FailureRecord
+
+	// Get information about the call site.
+	var ok bool
+	if _, r.FileName, r.LineNumber, ok = runtime.Caller(depth + 1); !ok {
+		panic("expectThat: runtime.Caller")
+	}
+
+	r.FileName = path.Base(r.FileName)
+
+	// Create an appropriate failure message. Make sure that the expected and
+	// actual values align properly.
+	relativeClause := ""
+	if matcherErr.Error() != "" {
+		relativeClause = fmt.Sprintf(", %s", matcherErr.Error())
+	}
+
+	r.Error = fmt.Sprintf(
+		"Expected: %s\nActual:   %v%s",
+		m.Description(),
+		x,
+		relativeClause)
+
+	// Add the user error, if any.
+	if len(errorParts) != 0 {
+		v := reflect.ValueOf(errorParts[0])
+		if v.Kind() != reflect.String {
+			panic(fmt.Sprintf("ExpectThat: invalid format string type %v", v.Kind()))
+		}
+
+		r.Error = fmt.Sprintf(
+			"%s\n%s",
+			r.Error,
+			fmt.Sprintf(v.String(), errorParts[1:]...))
+	}
+
+	// Report the failure.
+	AddFailureRecord(r)
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that_test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that_test.go
new file mode 100644
index 00000000000..e3e37236700
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that_test.go
@@ -0,0 +1,168 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"errors"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+// Set up a new test state with empty fields.
+func setUpCurrentTest() {
+	currentlyRunningTest = newTestInfo()
+}
+
+type fakeExpectThatMatcher struct {
+	desc string
+	err  error
+}
+
+func (m *fakeExpectThatMatcher) Matches(c interface{}) error {
+	return m.err
+}
+
+func (m *fakeExpectThatMatcher) Description() string {
+	return m.desc
+}
+
+func assertEqInt(t *testing.T, e, c int) {
+	if e != c {
+		t.Fatalf("Expected %d, got %d", e, c)
+	}
+}
+
+func expectEqInt(t *testing.T, e, c int) {
+	if e != c {
+		t.Errorf("Expected %v, got %v", e, c)
+	}
+}
+
+func expectEqStr(t *testing.T, e, c string) {
+	if e != c {
+		t.Errorf("Expected %s, got %s", e, c)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func TestNoCurrentTest(t *testing.T) {
+	panicked := false
+
+	defer func() {
+		if !panicked {
+			t.Errorf("Expected panic; got none.")
+		}
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	currentlyRunningTest = nil
+	ExpectThat(17, Equals(19))
+}
+
+func TestNoFailure(t *testing.T) {
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"", nil}
+	ExpectThat(17, matcher)
+
+	assertEqInt(t, 0, len(currentlyRunningTest.failureRecords))
+}
+
+func TestInvalidFormatString(t *testing.T) {
+	panicked := false
+
+	defer func() {
+		if !panicked {
+			t.Errorf("Expected panic; got none.")
+		}
+	}()
+
+	defer func() {
+		if r := recover(); r != nil {
+			panicked = true
+		}
+	}()
+
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"", errors.New("")}
+	ExpectThat(17, matcher, 19, "blah")
+}
+
+func TestNoMatchWithoutErrorText(t *testing.T) {
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"taco", errors.New("")}
+	ExpectThat(17, matcher)
+
+	assertEqInt(t, 1, len(currentlyRunningTest.failureRecords))
+
+	record := currentlyRunningTest.failureRecords[0]
+	expectEqStr(t, "expect_that_test.go", record.FileName)
+	expectEqInt(t, 119, record.LineNumber)
+	expectEqStr(t, "Expected: taco\nActual:   17", record.Error)
+}
+
+func TestNoMatchWithErrorTExt(t *testing.T) {
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"taco", errors.New("which is foo")}
+	ExpectThat(17, matcher)
+
+	assertEqInt(t, 1, len(currentlyRunningTest.failureRecords))
+	record := currentlyRunningTest.failureRecords[0]
+
+	expectEqStr(
+		t,
+		"Expected: taco\nActual:   17, which is foo",
+		record.Error)
+}
+
+func TestFailureWithUserMessage(t *testing.T) {
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"taco", errors.New("")}
+	ExpectThat(17, matcher, "Asd: %d %s", 19, "taco")
+
+	assertEqInt(t, 1, len(currentlyRunningTest.failureRecords))
+	record := currentlyRunningTest.failureRecords[0]
+
+	expectEqStr(t, "Expected: taco\nActual:   17\nAsd: 19 taco", record.Error)
+}
+
+func TestAdditionalFailure(t *testing.T) {
+	setUpCurrentTest()
+	matcher := &fakeExpectThatMatcher{"", errors.New("")}
+
+	// Fail twice.
+	ExpectThat(17, matcher, "taco")
+	ExpectThat(19, matcher, "burrito")
+
+	assertEqInt(t, 2, len(currentlyRunningTest.failureRecords))
+	record1 := currentlyRunningTest.failureRecords[0]
+	record2 := currentlyRunningTest.failureRecords[1]
+
+	expectEqStr(t, "Expected: \nActual:   17\ntaco", record1.Error)
+	expectEqStr(t, "Expected: \nActual:   19\nburrito", record2.Error)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/failure.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/failure.go
new file mode 100644
index 00000000000..95be2cf4502
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/failure.go
@@ -0,0 +1,90 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"fmt"
+	"path"
+	"runtime"
+)
+
+// FailureRecord represents a single failed expectation or assertion for a
+// test. Most users don't want to interact with these directly; they are
+// generated implicitly using ExpectThat, AssertThat, ExpectLt, etc.
+type FailureRecord struct {
+	// The file name within which the expectation failed, e.g. "foo_test.go".
+	FileName string
+
+	// The line number at which the expectation failed.
+	LineNumber int
+
+	// The error associated with the file:line pair above. For example, the
+	// following expectation:
+	//
+	//     ExpectEq(17, "taco")"
+	//
+	// May cause this error:
+	//
+	//     Expected: 17
+	//     Actual:   "taco", which is not numeric
+	//
+	Error string
+}
+
+// Record a failure for the currently running test (and continue running it).
+// Most users will want to use ExpectThat, ExpectEq, etc. instead of this
+// function. Those that do want to report arbitrary errors will probably be
+// satisfied with AddFailure, which is easier to use.
+func AddFailureRecord(r FailureRecord) {
+	currentlyRunningTest.mu.Lock()
+	defer currentlyRunningTest.mu.Unlock()
+
+	currentlyRunningTest.failureRecords = append(
+		currentlyRunningTest.failureRecords,
+		r)
+}
+
+// Call AddFailureRecord with a record whose file name and line number come
+// from the caller of this function, and whose error string is created by
+// calling fmt.Sprintf using the arguments to this function.
+func AddFailure(format string, a ...interface{}) {
+	r := FailureRecord{
+		Error: fmt.Sprintf(format, a...),
+	}
+
+	// Get information about the call site.
+	var ok bool
+	if _, r.FileName, r.LineNumber, ok = runtime.Caller(1); !ok {
+		panic("Can't find caller")
+	}
+
+	r.FileName = path.Base(r.FileName)
+
+	AddFailureRecord(r)
+}
+
+// A sentinel type that is used in a conspiracy between AbortTest and runTests.
+// If runTests sees an abortError as the value given to a panic() call, it will
+// avoid printing the panic error.
+type abortError struct {
+}
+
+// Immediately stop executing the running test, causing it to fail with the
+// failures previously recorded. Behavior is undefined if no failures have been
+// recorded.
+func AbortTest() {
+	panic(abortError{})
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/integration_test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/integration_test.go
new file mode 100644
index 00000000000..ec45184e326
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/integration_test.go
@@ -0,0 +1,265 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest_test
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"regexp"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+const ogletestPkg = "github.com/smartystreets/assertions/internal/ogletest"
+
+var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.")
+var objDir string
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+// Install the possibly locally-modified copy of ogletest, so that these
+// integration tests run using the package currently being worked on by the
+// programmer. Also install other dependencies needed by the test cases, so
+// that `go test` complaining about non-up-to-date packages doesn't make it
+// into the golden files.
+func installLocalPackages() error {
+	cmd := exec.Command(
+		"go",
+		"install",
+		ogletestPkg,
+		"github.com/smartystreets/assertions/internal/oglemock",
+		"github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image")
+
+	output, err := cmd.CombinedOutput()
+
+	if err != nil {
+		return errors.New(fmt.Sprintf("%v:\n%s", err, output))
+	}
+
+	return nil
+}
+
+// getCaseNames looks for integration test cases as files in the test_cases
+// directory.
+func getCaseNames() ([]string, error) {
+	// Open the test cases directory.
+	dir, err := os.Open("test_cases")
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Opening dir: %v", err))
+	}
+
+	// Get a list of the names in the directory.
+	names, err := dir.Readdirnames(0)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Readdirnames: %v", err))
+	}
+
+	// Filter the names.
+	result := make([]string, len(names))
+	resultLen := 0
+	for _, name := range names {
+		// Skip golden files and hidden files.
+		if strings.HasPrefix(name, "golden.") || strings.HasPrefix(name, ".") {
+			continue
+		}
+
+		// Check for the right format.
+		if !strings.HasSuffix(name, ".test.go") {
+			continue
+		}
+
+		// Store the name minus the extension.
+		result[resultLen] = name[:len(name)-8]
+		resultLen++
+	}
+
+	return result[:resultLen], nil
+}
+
+func writeContentsToFileOrDie(contents []byte, path string) {
+	if err := ioutil.WriteFile(path, contents, 0600); err != nil {
+		panic("ioutil.WriteFile: " + err.Error())
+	}
+}
+
+func readFileOrDie(path string) []byte {
+	contents, err := ioutil.ReadFile(path)
+	if err != nil {
+		panic("ioutil.ReadFile: " + err.Error())
+	}
+
+	return contents
+}
+
+// cleanOutput transforms the supplied output so that it no longer contains
+// information that changes from run to run, making the golden tests less
+// flaky.
+func cleanOutput(o []byte, testPkg string) []byte {
+	// Replace references to the last component of the test package name, which
+	// contains a unique number.
+	o = []byte(strings.Replace(string(o), path.Base(testPkg), "somepkg", -1))
+
+	// Replace things that look like line numbers and process counters in stack
+	// traces.
+	stackFrameRe := regexp.MustCompile(`\t\S+\.(c|go):\d+`)
+	o = stackFrameRe.ReplaceAll(o, []byte("\tsome_file.txt:0"))
+
+	// Replace full paths in failure messages with fake paths.
+	pathRe := regexp.MustCompile(`/\S+/(\w+\.(?:go|s):\d+)`)
+	o = pathRe.ReplaceAll(o, []byte("/some/path/$1"))
+
+	// Replace unstable timings in gotest fail messages.
+	timingRe1 := regexp.MustCompile(`--- FAIL: .* \(\d\.\d{2}s\)`)
+	o = timingRe1.ReplaceAll(o, []byte("--- FAIL: TestSomething (1.23s)"))
+
+	timingRe2 := regexp.MustCompile(`FAIL.*somepkg\s*\d\.\d{2,}s`)
+	o = timingRe2.ReplaceAll(o, []byte("FAIL somepkg 1.234s"))
+
+	timingRe3 := regexp.MustCompile(`ok.*somepkg\s*\d\.\d{2,}s`)
+	o = timingRe3.ReplaceAll(o, []byte("ok somepkg 1.234s"))
+
+	timingRe4 := regexp.MustCompile(`SlowTest \([0-9.]+ms\)`)
+	o = timingRe4.ReplaceAll(o, []byte("SlowTest (1234ms)"))
+
+	return o
+}
+
+// Create a temporary package directory somewhere that 'go test' can find, and
+// return the directory and package name.
+func createTempPackageDir(caseName string) (dir, pkg string) {
+	// Figure out where the local source code for ogletest is.
+	buildPkg, err := build.Import(ogletestPkg, "", build.FindOnly)
+	if err != nil {
+		panic("Finding ogletest tree: " + err.Error())
+	}
+
+	// Create a temporary directory underneath this.
+	ogletestPkgDir := buildPkg.Dir
+	prefix := fmt.Sprintf("tmp-%s-", caseName)
+
+	dir, err = ioutil.TempDir(ogletestPkgDir, prefix)
+	if err != nil {
+		panic("ioutil.TempDir: " + err.Error())
+	}
+
+	pkg = path.Join("github.com/smartystreets/assertions/internal/ogletest", dir[len(ogletestPkgDir):])
+	return
+}
+
+// runTestCase runs the case with the supplied name (e.g. "passing"), and
+// returns its output and exit code.
+func runTestCase(name string) ([]byte, int, error) {
+	// Create a temporary directory for the test files.
+	testDir, testPkg := createTempPackageDir(name)
+	defer os.RemoveAll(testDir)
+
+	// Create the test source file.
+	sourceFile := name + ".test.go"
+	testContents := readFileOrDie(path.Join("test_cases", sourceFile))
+	writeContentsToFileOrDie(testContents, path.Join(testDir, name+"_test.go"))
+
+	// Invoke 'go test'. Use the package directory as working dir instead of
+	// giving the package name as an argument so that 'go test' prints passing
+	// test output. Special case: pass a test filter to the filtered case.
+	cmd := exec.Command("go", "test")
+	if name == "filtered" {
+		cmd.Args = append(cmd.Args, "--ogletest.run=Test(Bar|Baz)")
+	}
+
+	cmd.Dir = testDir
+	output, err := cmd.CombinedOutput()
+
+	// Clean up the process's output.
+	output = cleanOutput(output, testPkg)
+
+	// Did the process exist with zero code?
+	if err == nil {
+		return output, 0, nil
+	}
+
+	// Make sure the process actually exited.
+	exitError, ok := err.(*exec.ExitError)
+	if !ok || !exitError.Exited() {
+		return nil, 0, errors.New("exec.Command.Output: " + err.Error())
+	}
+
+	return output, exitError.Sys().(syscall.WaitStatus).ExitStatus(), nil
+}
+
+// checkGolden file checks the supplied actual output for the named test case
+// against the golden file for that case. If requested by the user, it rewrites
+// the golden file on failure.
+func checkAgainstGoldenFile(caseName string, output []byte) bool {
+	goldenFile := path.Join("test_cases", "golden."+caseName+"_test")
+	goldenContents := readFileOrDie(goldenFile)
+
+	result := string(output) == string(goldenContents)
+	if !result && *dumpNew {
+		writeContentsToFileOrDie(output, goldenFile)
+	}
+
+	return result
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func TestGoldenFiles(t *testing.T) {
+	// Ensure the local package is installed. This will prevent the test cases
+	// from using the installed version, which may be out of date.
+	err := installLocalPackages()
+	if err != nil {
+		t.Fatalf("Error installing local ogletest: %v", err)
+	}
+
+	// We expect there to be at least one case.
+	caseNames, err := getCaseNames()
+	if err != nil || len(caseNames) == 0 {
+		t.Fatalf("Error getting cases: %v", err)
+	}
+
+	// Run each test case.
+	for _, caseName := range caseNames {
+		// Run the test case.
+		output, exitCode, err := runTestCase(caseName)
+		if err != nil {
+			t.Fatalf("Running test case %s: %v", caseName, err)
+		}
+
+		// Check the status code. We assume all test cases fail except for the
+		// passing one.
+		shouldPass := (caseName == "passing" || caseName == "no_cases")
+		didPass := exitCode == 0
+		if shouldPass != didPass {
+			t.Errorf("Bad exit code for test case %s: %d", caseName, exitCode)
+		}
+
+		// Check the output against the golden file.
+		if !checkAgainstGoldenFile(caseName, output) {
+			t.Errorf("Output for test case %s doesn't match golden file.", caseName)
+		}
+	}
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register.go
new file mode 100644
index 00000000000..756f2aa9ad9
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register.go
@@ -0,0 +1,86 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+// The input to ogletest.Register. Most users will want to use
+// ogletest.RegisterTestSuite.
+//
+// A test suite is the basic unit of registration in ogletest. It consists of
+// zero or more named test functions which will be run in sequence, along with
+// optional setup and tear-down functions.
+type TestSuite struct {
+	// The name of the overall suite, e.g. "MyPackageTest".
+	Name string
+
+	// If non-nil, a function that will be run exactly once, before any of the
+	// test functions are run.
+	SetUp func()
+
+	// The test functions comprising this suite.
+	TestFunctions []TestFunction
+
+	// If non-nil, a function that will be run exactly once, after all of the
+	// test functions have run.
+	TearDown func()
+}
+
+type TestFunction struct {
+	// The name of this test function, relative to the suite in which it resides.
+	// If the name is "TweaksFrobnicator", then the function might be presented
+	// in the ogletest UI as "FooTest.TweaksFrobnicator".
+	Name string
+
+	// If non-nil, a function that is run before Run, passed a pointer to a
+	// struct containing information about the test run.
+	SetUp func(*TestInfo)
+
+	// The function to invoke for the test body. Must be non-nil. Will not be run
+	// if SetUp panics.
+	Run func()
+
+	// If non-nil, a function that is run after Run.
+	TearDown func()
+}
+
+// Register a test suite for execution by RunTests.
+//
+// This is the most general registration mechanism. Most users will want
+// RegisterTestSuite, which is a wrapper around this function that requires
+// less boilerplate.
+//
+// Panics on invalid input.
+func Register(suite TestSuite) {
+	// Make sure the suite is legal.
+	if suite.Name == "" {
+		panic("Test suites must have names.")
+	}
+
+	for _, tf := range suite.TestFunctions {
+		if tf.Name == "" {
+			panic("Test functions must have names.")
+		}
+
+		if tf.Run == nil {
+			panic("Test functions must have non-nil run fields.")
+		}
+	}
+
+	// Save the suite for later.
+	registeredSuites = append(registeredSuites, suite)
+}
+
+// The list of test suites previously registered.
+var registeredSuites []TestSuite
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register_test_suite.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register_test_suite.go
new file mode 100644
index 00000000000..7303dfa8a6e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register_test_suite.go
@@ -0,0 +1,193 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/smartystreets/assertions/internal/ogletest/srcutil"
+)
+
+// Test suites that implement this interface have special meaning to
+// RegisterTestSuite.
+type SetUpTestSuiteInterface interface {
+	// This method will be called exactly once, before the first test method is
+	// run. The receiver of this method will be a zero value of the test suite
+	// type, and is not shared with any other methods. Use this method to set up
+	// any necessary global state shared by all of the test methods.
+	SetUpTestSuite()
+}
+
+// Test suites that implement this interface have special meaning to
+// RegisterTestSuite.
+type TearDownTestSuiteInterface interface {
+	// This method will be called exactly once, after the last test method is
+	// run. The receiver of this method will be a zero value of the test suite
+	// type, and is not shared with any other methods. Use this method to clean
+	// up after any necessary global state shared by all of the test methods.
+	TearDownTestSuite()
+}
+
+// Test suites that implement this interface have special meaning to
+// Register.
+type SetUpInterface interface {
+	// This method is called before each test method is invoked, with the same
+	// receiver as that test method. At the time this method is invoked, the
+	// receiver is a zero value for the test suite type. Use this method for
+	// common setup code that works on data not shared across tests.
+	SetUp(*TestInfo)
+}
+
+// Test suites that implement this interface have special meaning to
+// Register.
+type TearDownInterface interface {
+	// This method is called after each test method is invoked, with the same
+	// receiver as that test method. Use this method for common cleanup code that
+	// works on data not shared across tests.
+	TearDown()
+}
+
+// RegisterTestSuite tells ogletest about a test suite containing tests that it
+// should run. Any exported method on the type pointed to by the supplied
+// prototype value will be treated as test methods, with the exception of the
+// methods defined by the following interfaces, which when present are treated
+// as described in the documentation for those interfaces:
+//
+//  *  SetUpTestSuiteInterface
+//  *  SetUpInterface
+//  *  TearDownInterface
+//  *  TearDownTestSuiteInterface
+//
+// Each test method is invoked on a different receiver, which is initially a
+// zero value of the test suite type.
+//
+// Example:
+//
+//     // Some value that is needed by the tests but is expensive to compute.
+//     var someExpensiveThing uint
+//
+//     type FooTest struct {
+//       // Path to a temporary file used by the tests. Each test gets a
+//       // different temporary file.
+//       tempFile string
+//     }
+//     func init() { ogletest.RegisterTestSuite(&FooTest{}) }
+//
+//     func (t *FooTest) SetUpTestSuite() {
+//       someExpensiveThing = ComputeSomeExpensiveThing()
+//     }
+//
+//     func (t *FooTest) SetUp(ti *ogletest.TestInfo) {
+//       t.tempFile = CreateTempFile()
+//     }
+//
+//     func (t *FooTest) TearDown() {
+//       DeleteTempFile(t.tempFile)
+//     }
+//
+//     func (t *FooTest) FrobinicatorIsSuccessfullyTweaked() {
+//       res := DoSomethingWithExpensiveThing(someExpensiveThing, t.tempFile)
+//       ExpectThat(res, Equals(true))
+//     }
+//
+func RegisterTestSuite(p interface{}) {
+	if p == nil {
+		panic("RegisterTestSuite called with nil suite.")
+	}
+
+	val := reflect.ValueOf(p)
+	typ := val.Type()
+	var zeroInstance reflect.Value
+
+	// We will transform to a TestSuite struct.
+	suite := TestSuite{}
+	suite.Name = typ.Elem().Name()
+
+	zeroInstance = reflect.New(typ.Elem())
+	if i, ok := zeroInstance.Interface().(SetUpTestSuiteInterface); ok {
+		suite.SetUp = func() { i.SetUpTestSuite() }
+	}
+
+	zeroInstance = reflect.New(typ.Elem())
+	if i, ok := zeroInstance.Interface().(TearDownTestSuiteInterface); ok {
+		suite.TearDown = func() { i.TearDownTestSuite() }
+	}
+
+	// Transform a list of test methods for the suite, filtering them to just the
+	// ones that we don't need to skip.
+	for _, method := range filterMethods(suite.Name, srcutil.GetMethodsInSourceOrder(typ)) {
+		var tf TestFunction
+		tf.Name = method.Name
+
+		// Create an instance to be operated on by all of the TestFunction's
+		// internal functions.
+		instance := reflect.New(typ.Elem())
+
+		// Bind the functions to the instance.
+		if i, ok := instance.Interface().(SetUpInterface); ok {
+			tf.SetUp = func(ti *TestInfo) { i.SetUp(ti) }
+		}
+
+		methodCopy := method
+		tf.Run = func() { runTestMethod(instance, methodCopy) }
+
+		if i, ok := instance.Interface().(TearDownInterface); ok {
+			tf.TearDown = func() { i.TearDown() }
+		}
+
+		// Save the TestFunction.
+		suite.TestFunctions = append(suite.TestFunctions, tf)
+	}
+
+	// Register the suite.
+	Register(suite)
+}
+
+func runTestMethod(suite reflect.Value, method reflect.Method) {
+	if method.Func.Type().NumIn() != 1 {
+		panic(fmt.Sprintf(
+			"%s: expected 1 args, actually %d.",
+			method.Name,
+			method.Func.Type().NumIn()))
+	}
+
+	method.Func.Call([]reflect.Value{suite})
+}
+
+func filterMethods(suiteName string, in []reflect.Method) (out []reflect.Method) {
+	for _, m := range in {
+		// Skip set up, tear down, and unexported methods.
+		if isSpecialMethod(m.Name) || !isExportedMethod(m.Name) {
+			continue
+		}
+
+		out = append(out, m)
+	}
+
+	return
+}
+
+func isSpecialMethod(name string) bool {
+	return (name == "SetUpTestSuite") ||
+		(name == "TearDownTestSuite") ||
+		(name == "SetUp") ||
+		(name == "TearDown")
+}
+
+func isExportedMethod(name string) bool {
+	return len(name) > 0 && name[0] >= 'A' && name[0] <= 'Z'
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/run_tests.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/run_tests.go
new file mode 100644
index 00000000000..003aeb019de
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/run_tests.go
@@ -0,0 +1,354 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"path"
+	"regexp"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/assertions/internal/reqtrace"
+)
+
+var fTestFilter = flag.String(
+	"ogletest.run",
+	"",
+	"Regexp for matching tests to run.")
+
+var fStopEarly = flag.Bool(
+	"ogletest.stop_early",
+	false,
+	"If true, stop after the first failure.")
+
+// runTestsOnce protects RunTests from executing multiple times.
+var runTestsOnce sync.Once
+
+func isAbortError(x interface{}) bool {
+	_, ok := x.(abortError)
+	return ok
+}
+
+// Run a single test function, returning a slice of failure records.
+func runTestFunction(tf TestFunction) (failures []FailureRecord) {
+	// Set up a clean slate for this test. Make sure to reset it after everything
+	// below is finished, so we don't accidentally use it elsewhere.
+	currentlyRunningTest = newTestInfo()
+	defer func() {
+		currentlyRunningTest = nil
+	}()
+
+	ti := currentlyRunningTest
+
+	// Start a trace.
+	var reportOutcome reqtrace.ReportFunc
+	ti.Ctx, reportOutcome = reqtrace.Trace(ti.Ctx, tf.Name)
+
+	// Run the SetUp function, if any, paying attention to whether it panics.
+	setUpPanicked := false
+	if tf.SetUp != nil {
+		setUpPanicked = runWithProtection(func() { tf.SetUp(ti) })
+	}
+
+	// Run the test function itself, but only if the SetUp function didn't panic.
+	// (This includes AssertThat errors.)
+	if !setUpPanicked {
+		runWithProtection(tf.Run)
+	}
+
+	// Run the TearDown function, if any.
+	if tf.TearDown != nil {
+		runWithProtection(tf.TearDown)
+	}
+
+	// Tell the mock controller for the tests to report any errors it's sitting
+	// on.
+	ti.MockController.Finish()
+
+	// Report the outcome to reqtrace.
+	if len(ti.failureRecords) == 0 {
+		reportOutcome(nil)
+	} else {
+		reportOutcome(fmt.Errorf("%v failure records", len(ti.failureRecords)))
+	}
+
+	return ti.failureRecords
+}
+
+// Run everything registered with Register (including via the wrapper
+// RegisterTestSuite).
+//
+// Failures are communicated to the supplied testing.T object. This is the
+// bridge between ogletest and the testing package (and `go test`); you should
+// ensure that it's called at least once by creating a test function compatible
+// with `go test` and calling it there.
+//
+// For example:
+//
+//     import (
+//       "github.com/smartystreets/assertions/internal/ogletest"
+//       "testing"
+//     )
+//
+//     func TestOgletest(t *testing.T) {
+//       ogletest.RunTests(t)
+//     }
+//
+func RunTests(t *testing.T) {
+	runTestsOnce.Do(func() { runTestsInternal(t) })
+}
+
+// Signalling between RunTests and StopRunningTests.
+var gStopRunning uint64
+
+// Request that RunTests stop what it's doing. After the currently running test
+// is finished, including tear-down, the program will exit with an error code.
+func StopRunningTests() {
+	atomic.StoreUint64(&gStopRunning, 1)
+}
+
+// runTestsInternal does the real work of RunTests, which simply wraps it in a
+// sync.Once.
+func runTestsInternal(t *testing.T) {
+	// Process each registered suite.
+	for _, suite := range registeredSuites {
+		// Stop now if we've already seen a failure and we've been told to stop
+		// early.
+		if t.Failed() && *fStopEarly {
+			break
+		}
+
+		// Print a banner.
+		fmt.Printf("[----------] Running tests from %s\n", suite.Name)
+
+		// Run the SetUp function, if any.
+		if suite.SetUp != nil {
+			suite.SetUp()
+		}
+
+		// Run each test function that the user has not told us to skip.
+		stoppedEarly := false
+		for _, tf := range filterTestFunctions(suite) {
+			// Did the user request that we stop running tests? If so, skip the rest
+			// of this suite (and exit after tearing it down).
+			if atomic.LoadUint64(&gStopRunning) != 0 {
+				stoppedEarly = true
+				break
+			}
+
+			// Print a banner for the start of this test function.
+			fmt.Printf("[ RUN      ] %s.%s\n", suite.Name, tf.Name)
+
+			// Run the test function.
+			startTime := time.Now()
+			failures := runTestFunction(tf)
+			runDuration := time.Since(startTime)
+
+			// Print any failures, and mark the test as having failed if there are any.
+			for _, record := range failures {
+				t.Fail()
+				fmt.Printf(
+					"%s:%d:\n%s\n\n",
+					record.FileName,
+					record.LineNumber,
+					record.Error)
+			}
+
+			// Print a banner for the end of the test.
+			bannerMessage := "[       OK ]"
+			if len(failures) != 0 {
+				bannerMessage = "[  FAILED  ]"
+			}
+
+			// Print a summary of the time taken, if long enough.
+			var timeMessage string
+			if runDuration >= 25*time.Millisecond {
+				timeMessage = fmt.Sprintf(" (%s)", runDuration.String())
+			}
+
+			fmt.Printf(
+				"%s %s.%s%s\n",
+				bannerMessage,
+				suite.Name,
+				tf.Name,
+				timeMessage)
+
+			// Stop running tests from this suite if we've been told to stop early
+			// and this test failed.
+			if t.Failed() && *fStopEarly {
+				break
+			}
+		}
+
+		// Run the suite's TearDown function, if any.
+		if suite.TearDown != nil {
+			suite.TearDown()
+		}
+
+		// Were we told to exit early?
+		if stoppedEarly {
+			fmt.Println("Exiting early due to user request.")
+			os.Exit(1)
+		}
+
+		fmt.Printf("[----------] Finished with tests from %s\n", suite.Name)
+	}
+}
+
+// Return true iff the supplied program counter appears to lie within panic().
+func isPanic(pc uintptr) bool {
+	f := runtime.FuncForPC(pc)
+	if f == nil {
+		return false
+	}
+
+	return f.Name() == "runtime.gopanic" || f.Name() == "runtime.sigpanic"
+}
+
+// Find the deepest stack frame containing something that appears to be a
+// panic. Return the 'skip' value that a caller to this function would need
+// to supply to runtime.Caller for that frame, or a negative number if not found.
+func findPanic() int {
+	localSkip := -1
+	for i := 0; ; i++ {
+		// Stop if we've passed the base of the stack.
+		pc, _, _, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+
+		// Is this a panic?
+		if isPanic(pc) {
+			localSkip = i
+		}
+	}
+
+	return localSkip - 1
+}
+
+// Attempt to find the file base name and line number for the ultimate source
+// of a panic, on the panicking stack. Return a human-readable sentinel if
+// unsuccessful.
+func findPanicFileLine() (string, int) {
+	panicSkip := findPanic()
+	if panicSkip < 0 {
+		return "(unknown)", 0
+	}
+
+	// Find the trigger of the panic.
+	_, file, line, ok := runtime.Caller(panicSkip + 1)
+	if !ok {
+		return "(unknown)", 0
+	}
+
+	return path.Base(file), line
+}
+
+// Run the supplied function, catching panics (including AssertThat errors) and
+// reporting them to the currently-running test as appropriate. Return true iff
+// the function panicked.
+func runWithProtection(f func()) (panicked bool) {
+	defer func() {
+		// If the test didn't panic, we're done.
+		r := recover()
+		if r == nil {
+			return
+		}
+
+		panicked = true
+
+		// We modify the currently running test below.
+		currentlyRunningTest.mu.Lock()
+		defer currentlyRunningTest.mu.Unlock()
+
+		// If the function panicked (and the panic was not due to an AssertThat
+		// failure), add a failure for the panic.
+		if !isAbortError(r) {
+			var panicRecord FailureRecord
+			panicRecord.FileName, panicRecord.LineNumber = findPanicFileLine()
+			panicRecord.Error = fmt.Sprintf(
+				"panic: %v\n\n%s", r, formatPanicStack())
+
+			currentlyRunningTest.failureRecords = append(
+				currentlyRunningTest.failureRecords,
+				panicRecord)
+		}
+	}()
+
+	f()
+	return
+}
+
+func formatPanicStack() string {
+	buf := new(bytes.Buffer)
+
+	// Find the panic. If successful, we'll skip to below it. Otherwise, we'll
+	// format everything.
+	var initialSkip int
+	if panicSkip := findPanic(); panicSkip >= 0 {
+		initialSkip = panicSkip + 1
+	}
+
+	for i := initialSkip; ; i++ {
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+
+		// Choose a function name to display.
+		funcName := "(unknown)"
+		if f := runtime.FuncForPC(pc); f != nil {
+			funcName = f.Name()
+		}
+
+		// Stop if we've gotten as far as the test runner code.
+		if funcName == "github.com/smartystreets/assertions/internal/ogletest.runTestMethod" ||
+			funcName == "github.com/smartystreets/assertions/internal/ogletest.runWithProtection" {
+			break
+		}
+
+		// Add an entry for this frame.
+		fmt.Fprintf(buf, "%s\n\t%s:%d\n", funcName, file, line)
+	}
+
+	return buf.String()
+}
+
+// Filter test functions according to the user-supplied filter flag.
+func filterTestFunctions(suite TestSuite) (out []TestFunction) {
+	re, err := regexp.Compile(*fTestFilter)
+	if err != nil {
+		panic("Invalid value for --ogletest.run: " + err.Error())
+	}
+
+	for _, tf := range suite.TestFunctions {
+		fullName := fmt.Sprintf("%s.%s", suite.Name, tf.Name)
+		if !re.MatchString(fullName) {
+			continue
+		}
+
+		out = append(out, tf)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/docs.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/docs.go
new file mode 100644
index 00000000000..d9b9bc8e5fe
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/docs.go
@@ -0,0 +1,5 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+
+// Functions for working with source code.
+package srcutil
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods.go
new file mode 100644
index 00000000000..a8c5828ea3a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods.go
@@ -0,0 +1,65 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package srcutil
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"sort"
+)
+
+func getLine(m reflect.Method) int {
+	pc := m.Func.Pointer()
+
+	f := runtime.FuncForPC(pc)
+	if f == nil {
+		panic(fmt.Sprintf("Couldn't get runtime func for method (pc=%d): %v", pc, m))
+	}
+
+	_, line := f.FileLine(pc)
+	return line
+}
+
+type sortableMethodSet []reflect.Method
+
+func (s sortableMethodSet) Len() int {
+	return len(s)
+}
+
+func (s sortableMethodSet) Less(i, j int) bool {
+	return getLine(s[i]) < getLine(s[j])
+}
+
+func (s sortableMethodSet) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+// Given a type t, return all of the methods of t sorted such that source file
+// order is preserved. Order across files is undefined. Order within lines is
+// undefined.
+func GetMethodsInSourceOrder(t reflect.Type) []reflect.Method {
+	// Build the list of methods.
+	methods := sortableMethodSet{}
+	for i := 0; i < t.NumMethod(); i++ {
+		methods = append(methods, t.Method(i))
+	}
+
+	// Sort it.
+	sort.Sort(methods)
+
+	return methods
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods_test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods_test.go
new file mode 100644
index 00000000000..95c07fd4697
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/methods_test.go
@@ -0,0 +1,107 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package srcutil_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"github.com/smartystreets/assertions/internal/ogletest/srcutil"
+)
+
+func TestRegisterMethodsTest(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type MethodsTest struct {
+}
+
+func init() { RegisterTestSuite(&MethodsTest{}) }
+
+type OneMethodType int
+
+func (x OneMethodType) Foo() {}
+
+type MultipleMethodsType int
+
+func (x MultipleMethodsType) Foo() {}
+func (x MultipleMethodsType) Bar() {}
+func (x MultipleMethodsType) Baz() {}
+
+type methodNameMatcher struct {
+	expected string
+}
+
+func (m *methodNameMatcher) Description() string {
+	return fmt.Sprintf("method named %s", m.expected)
+}
+
+func (m *methodNameMatcher) Matches(x interface{}) error {
+	method, ok := x.(reflect.Method)
+	if !ok {
+		panic("Invalid argument.")
+	}
+
+	if method.Name != m.expected {
+		return fmt.Errorf("whose name is %s", method.Name)
+	}
+
+	return nil
+}
+
+func NameIs(name string) Matcher {
+	return &methodNameMatcher{name}
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *MethodsTest) NoMethods() {
+	type foo int
+
+	methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(foo(17)))
+	ExpectThat(methods, ElementsAre())
+}
+
+func (t *MethodsTest) OneMethod() {
+	methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(OneMethodType(17)))
+	ExpectThat(
+		methods,
+		ElementsAre(
+			NameIs("Foo"),
+		))
+}
+
+func (t *MethodsTest) MultipleMethods() {
+	methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(MultipleMethodsType(17)))
+	ExpectThat(
+		methods,
+		ElementsAre(
+			NameIs("Foo"),
+			NameIs("Bar"),
+			NameIs("Baz"),
+		))
+
+	ExpectEq("Foo", methods[0].Name)
+	ExpectEq("Bar", methods[1].Name)
+	ExpectEq("Baz", methods[2].Name)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/failing.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/failing.test.go
new file mode 100644
index 00000000000..17c50e19487
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/failing.test.go
@@ -0,0 +1,252 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestFailingTest(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Usual failures
+////////////////////////////////////////////////////////////////////////
+
+type FailingTest struct {
+}
+
+var _ TearDownInterface = &FailingTest{}
+var _ TearDownTestSuiteInterface = &FailingTest{}
+
+func init() { RegisterTestSuite(&FailingTest{}) }
+
+func (t *FailingTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *FailingTest) TearDownTestSuite() {
+	fmt.Println("TearDownTestSuite running.")
+}
+
+func (t *FailingTest) PassingMethod() {
+}
+
+func (t *FailingTest) Equals() {
+	ExpectThat(17, Equals(17.5))
+	ExpectThat(17, Equals("taco"))
+}
+
+func (t *FailingTest) LessThan() {
+	ExpectThat(18, LessThan(17))
+	ExpectThat(18, LessThan("taco"))
+}
+
+func (t *FailingTest) HasSubstr() {
+	ExpectThat("taco", HasSubstr("ac"))
+	ExpectThat(17, HasSubstr("ac"))
+}
+
+func (t *FailingTest) ExpectWithUserErrorMessages() {
+	ExpectThat(17, Equals(19), "foo bar: %d", 112)
+	ExpectEq(17, 17.5, "foo bar: %d", 112)
+	ExpectLe(17, 16.9, "foo bar: %d", 112)
+	ExpectLt(17, 16.9, "foo bar: %d", 112)
+	ExpectGe(17, 17.1, "foo bar: %d", 112)
+	ExpectGt(17, "taco", "foo bar: %d", 112)
+	ExpectNe(17, 17.0, "foo bar: %d", 112)
+	ExpectFalse(true, "foo bar: %d", 112)
+	ExpectTrue(false, "foo bar: %d", 112)
+}
+
+func (t *FailingTest) AssertWithUserErrorMessages() {
+	AssertThat(17, Equals(19), "foo bar: %d", 112)
+}
+
+func (t *FailingTest) ExpectationAliases() {
+	ExpectEq(17, 17.5)
+	ExpectEq("taco", 17.5)
+
+	ExpectLe(17, 16.9)
+	ExpectLt(17, 16.9)
+	ExpectLt(17, "taco")
+
+	ExpectGe(17, 17.1)
+	ExpectGt(17, 17.1)
+	ExpectGt(17, "taco")
+
+	ExpectNe(17, 17.0)
+	ExpectNe(17, "taco")
+
+	ExpectFalse(true)
+	ExpectFalse("taco")
+
+	ExpectTrue(false)
+	ExpectTrue("taco")
+}
+
+func (t *FailingTest) AssertThatFailure() {
+	AssertThat(17, Equals(19))
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertEqFailure() {
+	AssertEq(19, 17)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertNeFailure() {
+	AssertNe(19, 19)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertLeFailure() {
+	AssertLe(19, 17)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertLtFailure() {
+	AssertLt(19, 17)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertGeFailure() {
+	AssertGe(17, 19)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertGtFailure() {
+	AssertGt(17, 19)
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertTrueFailure() {
+	AssertTrue("taco")
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AssertFalseFailure() {
+	AssertFalse("taco")
+	panic("Shouldn't get here.")
+}
+
+func (t *FailingTest) AddFailureRecord() {
+	r := FailureRecord{
+		FileName:   "foo.go",
+		LineNumber: 17,
+		Error:      "taco\nburrito",
+	}
+
+	AddFailureRecord(r)
+}
+
+func (t *FailingTest) AddFailure() {
+	AddFailure("taco")
+	AddFailure("burrito: %d", 17)
+}
+
+func (t *FailingTest) AddFailureThenAbortTest() {
+	AddFailure("enchilada")
+	AbortTest()
+	fmt.Println("Shouldn't get here.")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Expectation failure during SetUp
+////////////////////////////////////////////////////////////////////////
+
+type ExpectFailDuringSetUpTest struct {
+}
+
+func init() { RegisterTestSuite(&ExpectFailDuringSetUpTest{}) }
+
+func (t *ExpectFailDuringSetUpTest) SetUp(i *TestInfo) {
+	ExpectFalse(true)
+}
+
+func (t *ExpectFailDuringSetUpTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *ExpectFailDuringSetUpTest) PassingMethod() {
+	fmt.Println("Method running.")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Assertion failure during SetUp
+////////////////////////////////////////////////////////////////////////
+
+type AssertFailDuringSetUpTest struct {
+}
+
+func init() { RegisterTestSuite(&AssertFailDuringSetUpTest{}) }
+
+func (t *AssertFailDuringSetUpTest) SetUp(i *TestInfo) {
+	AssertFalse(true)
+}
+
+func (t *AssertFailDuringSetUpTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *AssertFailDuringSetUpTest) PassingMethod() {
+	fmt.Println("Method running.")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Expectation failure during TearDown
+////////////////////////////////////////////////////////////////////////
+
+type ExpectFailDuringTearDownTest struct {
+}
+
+func init() { RegisterTestSuite(&ExpectFailDuringTearDownTest{}) }
+
+func (t *ExpectFailDuringTearDownTest) SetUp(i *TestInfo) {
+	fmt.Println("SetUp running.")
+}
+
+func (t *ExpectFailDuringTearDownTest) TearDown() {
+	ExpectFalse(true)
+}
+
+func (t *ExpectFailDuringTearDownTest) PassingMethod() {
+	fmt.Println("Method running.")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Assertion failure during TearDown
+////////////////////////////////////////////////////////////////////////
+
+type AssertFailDuringTearDownTest struct {
+}
+
+func init() { RegisterTestSuite(&AssertFailDuringTearDownTest{}) }
+
+func (t *AssertFailDuringTearDownTest) SetUp(i *TestInfo) {
+	fmt.Println("SetUp running.")
+}
+
+func (t *AssertFailDuringTearDownTest) TearDown() {
+	AssertFalse(true)
+}
+
+func (t *AssertFailDuringTearDownTest) PassingMethod() {
+	fmt.Println("Method running.")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/filtered.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/filtered.test.go
new file mode 100644
index 00000000000..e559c5f926c
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/filtered.test.go
@@ -0,0 +1,79 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+func TestFiltered(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Partially filtered out
+////////////////////////////////////////////////////////////////////////
+
+type PartiallyFilteredTest struct {
+}
+
+func init() { RegisterTestSuite(&PartiallyFilteredTest{}) }
+
+func (t *PartiallyFilteredTest) PassingTestFoo() {
+	ExpectThat(19, Equals(19))
+}
+
+func (t *PartiallyFilteredTest) PassingTestBar() {
+	ExpectThat(17, Equals(17))
+}
+
+func (t *PartiallyFilteredTest) PartiallyFilteredTestFoo() {
+	ExpectThat(18, LessThan(17))
+}
+
+func (t *PartiallyFilteredTest) PartiallyFilteredTestBar() {
+	ExpectThat("taco", HasSubstr("blah"))
+}
+
+func (t *PartiallyFilteredTest) PartiallyFilteredTestBaz() {
+	ExpectThat(18, LessThan(17))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Completely filtered out
+////////////////////////////////////////////////////////////////////////
+
+type CompletelyFilteredTest struct {
+}
+
+func init() { RegisterTestSuite(&CompletelyFilteredTest{}) }
+
+func (t *CompletelyFilteredTest) SetUpTestSuite() {
+	fmt.Println("SetUpTestSuite run!")
+}
+
+func (t *CompletelyFilteredTest) TearDownTestSuite() {
+	fmt.Println("TearDownTestSuite run!")
+}
+
+func (t *PartiallyFilteredTest) SomePassingTest() {
+	ExpectThat(19, Equals(19))
+}
+
+func (t *PartiallyFilteredTest) SomeFailingTest() {
+	ExpectThat(19, Equals(17))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.failing_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.failing_test
new file mode 100644
index 00000000000..f0cd76af500
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.failing_test
@@ -0,0 +1,278 @@
+[----------] Running tests from FailingTest
+[ RUN      ] FailingTest.PassingMethod
+TearDown running.
+[       OK ] FailingTest.PassingMethod
+[ RUN      ] FailingTest.Equals
+TearDown running.
+failing_test.go:52:
+Expected: 17.5
+Actual:   17
+
+failing_test.go:53:
+Expected: taco
+Actual:   17, which is not a string
+
+[  FAILED  ] FailingTest.Equals
+[ RUN      ] FailingTest.LessThan
+TearDown running.
+failing_test.go:57:
+Expected: less than 17
+Actual:   18
+
+failing_test.go:58:
+Expected: less than "taco"
+Actual:   18, which is not comparable
+
+[  FAILED  ] FailingTest.LessThan
+[ RUN      ] FailingTest.HasSubstr
+TearDown running.
+failing_test.go:63:
+Expected: has substring "ac"
+Actual:   17, which is not a string
+
+[  FAILED  ] FailingTest.HasSubstr
+[ RUN      ] FailingTest.ExpectWithUserErrorMessages
+TearDown running.
+failing_test.go:67:
+Expected: 19
+Actual:   17
+foo bar: 112
+
+failing_test.go:68:
+Expected: 17
+Actual:   17.5
+foo bar: 112
+
+failing_test.go:69:
+Expected: less than or equal to 16.9
+Actual:   17
+foo bar: 112
+
+failing_test.go:70:
+Expected: less than 16.9
+Actual:   17
+foo bar: 112
+
+failing_test.go:71:
+Expected: greater than or equal to 17.1
+Actual:   17
+foo bar: 112
+
+failing_test.go:72:
+Expected: greater than "taco"
+Actual:   17, which is not comparable
+foo bar: 112
+
+failing_test.go:73:
+Expected: not(17)
+Actual:   17
+foo bar: 112
+
+failing_test.go:74:
+Expected: false
+Actual:   true
+foo bar: 112
+
+failing_test.go:75:
+Expected: true
+Actual:   false
+foo bar: 112
+
+[  FAILED  ] FailingTest.ExpectWithUserErrorMessages
+[ RUN      ] FailingTest.AssertWithUserErrorMessages
+TearDown running.
+failing_test.go:79:
+Expected: 19
+Actual:   17
+foo bar: 112
+
+[  FAILED  ] FailingTest.AssertWithUserErrorMessages
+[ RUN      ] FailingTest.ExpectationAliases
+TearDown running.
+failing_test.go:83:
+Expected: 17
+Actual:   17.5
+
+failing_test.go:84:
+Expected: taco
+Actual:   17.5, which is not a string
+
+failing_test.go:86:
+Expected: less than or equal to 16.9
+Actual:   17
+
+failing_test.go:87:
+Expected: less than 16.9
+Actual:   17
+
+failing_test.go:88:
+Expected: less than "taco"
+Actual:   17, which is not comparable
+
+failing_test.go:90:
+Expected: greater than or equal to 17.1
+Actual:   17
+
+failing_test.go:91:
+Expected: greater than 17.1
+Actual:   17
+
+failing_test.go:92:
+Expected: greater than "taco"
+Actual:   17, which is not comparable
+
+failing_test.go:94:
+Expected: not(17)
+Actual:   17
+
+failing_test.go:95:
+Expected: not(17)
+Actual:   taco, which is not numeric
+
+failing_test.go:97:
+Expected: false
+Actual:   true
+
+failing_test.go:98:
+Expected: false
+Actual:   taco, which is not a bool
+
+failing_test.go:100:
+Expected: true
+Actual:   false
+
+failing_test.go:101:
+Expected: true
+Actual:   taco, which is not a bool
+
+[  FAILED  ] FailingTest.ExpectationAliases
+[ RUN      ] FailingTest.AssertThatFailure
+TearDown running.
+failing_test.go:105:
+Expected: 19
+Actual:   17
+
+[  FAILED  ] FailingTest.AssertThatFailure
+[ RUN      ] FailingTest.AssertEqFailure
+TearDown running.
+failing_test.go:110:
+Expected: 19
+Actual:   17
+
+[  FAILED  ] FailingTest.AssertEqFailure
+[ RUN      ] FailingTest.AssertNeFailure
+TearDown running.
+failing_test.go:115:
+Expected: not(19)
+Actual:   19
+
+[  FAILED  ] FailingTest.AssertNeFailure
+[ RUN      ] FailingTest.AssertLeFailure
+TearDown running.
+failing_test.go:120:
+Expected: less than or equal to 17
+Actual:   19
+
+[  FAILED  ] FailingTest.AssertLeFailure
+[ RUN      ] FailingTest.AssertLtFailure
+TearDown running.
+failing_test.go:125:
+Expected: less than 17
+Actual:   19
+
+[  FAILED  ] FailingTest.AssertLtFailure
+[ RUN      ] FailingTest.AssertGeFailure
+TearDown running.
+failing_test.go:130:
+Expected: greater than or equal to 19
+Actual:   17
+
+[  FAILED  ] FailingTest.AssertGeFailure
+[ RUN      ] FailingTest.AssertGtFailure
+TearDown running.
+failing_test.go:135:
+Expected: greater than 19
+Actual:   17
+
+[  FAILED  ] FailingTest.AssertGtFailure
+[ RUN      ] FailingTest.AssertTrueFailure
+TearDown running.
+failing_test.go:140:
+Expected: true
+Actual:   taco, which is not a bool
+
+[  FAILED  ] FailingTest.AssertTrueFailure
+[ RUN      ] FailingTest.AssertFalseFailure
+TearDown running.
+failing_test.go:145:
+Expected: false
+Actual:   taco, which is not a bool
+
+[  FAILED  ] FailingTest.AssertFalseFailure
+[ RUN      ] FailingTest.AddFailureRecord
+TearDown running.
+foo.go:17:
+taco
+burrito
+
+[  FAILED  ] FailingTest.AddFailureRecord
+[ RUN      ] FailingTest.AddFailure
+TearDown running.
+failing_test.go:160:
+taco
+
+failing_test.go:161:
+burrito: 17
+
+[  FAILED  ] FailingTest.AddFailure
+[ RUN      ] FailingTest.AddFailureThenAbortTest
+TearDown running.
+failing_test.go:165:
+enchilada
+
+[  FAILED  ] FailingTest.AddFailureThenAbortTest
+TearDownTestSuite running.
+[----------] Finished with tests from FailingTest
+[----------] Running tests from ExpectFailDuringSetUpTest
+[ RUN      ] ExpectFailDuringSetUpTest.PassingMethod
+Method running.
+TearDown running.
+failing_test.go:180:
+Expected: false
+Actual:   true
+
+[  FAILED  ] ExpectFailDuringSetUpTest.PassingMethod
+[----------] Finished with tests from ExpectFailDuringSetUpTest
+[----------] Running tests from AssertFailDuringSetUpTest
+[ RUN      ] AssertFailDuringSetUpTest.PassingMethod
+TearDown running.
+failing_test.go:201:
+Expected: false
+Actual:   true
+
+[  FAILED  ] AssertFailDuringSetUpTest.PassingMethod
+[----------] Finished with tests from AssertFailDuringSetUpTest
+[----------] Running tests from ExpectFailDuringTearDownTest
+[ RUN      ] ExpectFailDuringTearDownTest.PassingMethod
+SetUp running.
+Method running.
+failing_test.go:226:
+Expected: false
+Actual:   true
+
+[  FAILED  ] ExpectFailDuringTearDownTest.PassingMethod
+[----------] Finished with tests from ExpectFailDuringTearDownTest
+[----------] Running tests from AssertFailDuringTearDownTest
+[ RUN      ] AssertFailDuringTearDownTest.PassingMethod
+SetUp running.
+Method running.
+failing_test.go:247:
+Expected: false
+Actual:   true
+
+[  FAILED  ] AssertFailDuringTearDownTest.PassingMethod
+[----------] Finished with tests from AssertFailDuringTearDownTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.filtered_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.filtered_test
new file mode 100644
index 00000000000..39fa697140c
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.filtered_test
@@ -0,0 +1,24 @@
+[----------] Running tests from PartiallyFilteredTest
+[ RUN      ] PartiallyFilteredTest.PassingTestBar
+[       OK ] PartiallyFilteredTest.PassingTestBar
+[ RUN      ] PartiallyFilteredTest.PartiallyFilteredTestBar
+filtered_test.go:49:
+Expected: has substring "blah"
+Actual:   taco
+
+[  FAILED  ] PartiallyFilteredTest.PartiallyFilteredTestBar
+[ RUN      ] PartiallyFilteredTest.PartiallyFilteredTestBaz
+filtered_test.go:53:
+Expected: less than 17
+Actual:   18
+
+[  FAILED  ] PartiallyFilteredTest.PartiallyFilteredTestBaz
+[----------] Finished with tests from PartiallyFilteredTest
+[----------] Running tests from CompletelyFilteredTest
+SetUpTestSuite run!
+TearDownTestSuite run!
+[----------] Finished with tests from CompletelyFilteredTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.mock_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.mock_test
new file mode 100644
index 00000000000..4ca29791de7
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.mock_test
@@ -0,0 +1,25 @@
+[----------] Running tests from MockTest
+[ RUN      ] MockTest.ExpectationSatisfied
+[       OK ] MockTest.ExpectationSatisfied
+[ RUN      ] MockTest.MockExpectationNotSatisfied
+/some/path/mock_test.go:56:
+Unsatisfied expectation; expected At to be called at least 1 times; called 0 times.
+
+[  FAILED  ] MockTest.MockExpectationNotSatisfied
+[ RUN      ] MockTest.ExpectCallForUnknownMethod
+/some/path/mock_test.go:61:
+Unknown method: FooBar
+
+[  FAILED  ] MockTest.ExpectCallForUnknownMethod
+[ RUN      ] MockTest.UnexpectedCall
+/some/path/mock_test.go:65:
+Unexpected call to At with args: [11 23]
+
+[  FAILED  ] MockTest.UnexpectedCall
+[ RUN      ] MockTest.InvokeFunction
+[       OK ] MockTest.InvokeFunction
+[----------] Finished with tests from MockTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.no_cases_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.no_cases_test
new file mode 100644
index 00000000000..8631385581d
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.no_cases_test
@@ -0,0 +1,6 @@
+[----------] Running tests from NoCasesTest
+SetUpTestSuite run!
+TearDownTestSuite run!
+[----------] Finished with tests from NoCasesTest
+PASS
+ok somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.panicking_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.panicking_test
new file mode 100644
index 00000000000..32eac65f7ba
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.panicking_test
@@ -0,0 +1,90 @@
+[----------] Running tests from PanickingTest
+[ RUN      ] PanickingTest.ExplicitPanic
+TearDown running.
+panicking_test.go:47:
+panic: Panic in ExplicitPanic
+
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).ExplicitPanic
+	some_file.txt:0
+runtime.call16
+	/some/path/asm_amd64.s:401
+reflect.Value.call
+	some_file.txt:0
+reflect.Value.Call
+	some_file.txt:0
+
+
+[  FAILED  ] PanickingTest.ExplicitPanic
+[ RUN      ] PanickingTest.ExplicitPanicInHelperFunction
+TearDown running.
+panicking_test.go:34:
+panic: Panic in someFuncThatPanics
+
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.someFuncThatPanics
+	some_file.txt:0
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).ExplicitPanicInHelperFunction
+	some_file.txt:0
+runtime.call16
+	/some/path/asm_amd64.s:401
+reflect.Value.call
+	some_file.txt:0
+reflect.Value.Call
+	some_file.txt:0
+
+
+[  FAILED  ] PanickingTest.ExplicitPanicInHelperFunction
+[ RUN      ] PanickingTest.NilPointerDerefence
+TearDown running.
+panicking_test.go:56:
+panic: runtime error: invalid memory address or nil pointer dereference
+
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).NilPointerDerefence
+	some_file.txt:0
+runtime.call16
+	/some/path/asm_amd64.s:401
+reflect.Value.call
+	some_file.txt:0
+reflect.Value.Call
+	some_file.txt:0
+
+
+[  FAILED  ] PanickingTest.NilPointerDerefence
+[ RUN      ] PanickingTest.ZzzSomeOtherTest
+TearDown running.
+[       OK ] PanickingTest.ZzzSomeOtherTest
+[----------] Finished with tests from PanickingTest
+[----------] Running tests from SetUpPanicTest
+[ RUN      ] SetUpPanicTest.SomeTestCase
+SetUp about to panic.
+TearDown running.
+panicking_test.go:74:
+panic: Panic in SetUp
+
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*SetUpPanicTest).SetUp
+	some_file.txt:0
+github.com/smartystreets/assertions/internal/ogletest.func·003
+	some_file.txt:0
+github.com/smartystreets/assertions/internal/ogletest.func·007
+	some_file.txt:0
+
+
+[  FAILED  ] SetUpPanicTest.SomeTestCase
+[----------] Finished with tests from SetUpPanicTest
+[----------] Running tests from TearDownPanicTest
+[ RUN      ] TearDownPanicTest.SomeTestCase
+TearDown about to panic.
+panicking_test.go:95:
+panic: Panic in TearDown
+
+github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*TearDownPanicTest).TearDown
+	some_file.txt:0
+github.com/smartystreets/assertions/internal/ogletest.func·005
+	some_file.txt:0
+
+
+[  FAILED  ] TearDownPanicTest.SomeTestCase
+[----------] Finished with tests from TearDownPanicTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.passing_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.passing_test
new file mode 100644
index 00000000000..031128842ac
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.passing_test
@@ -0,0 +1,22 @@
+[----------] Running tests from PassingTest
+[ RUN      ] PassingTest.EmptyTestMethod
+[       OK ] PassingTest.EmptyTestMethod
+[ RUN      ] PassingTest.SuccessfullMatches
+[       OK ] PassingTest.SuccessfullMatches
+[ RUN      ] PassingTest.ExpectAliases
+[       OK ] PassingTest.ExpectAliases
+[ RUN      ] PassingTest.AssertAliases
+[       OK ] PassingTest.AssertAliases
+[ RUN      ] PassingTest.SlowTest
+[       OK ] PassingTest.SlowTest (1234ms)
+[----------] Finished with tests from PassingTest
+[----------] Running tests from PassingTestWithHelpers
+SetUpTestSuite ran.
+[ RUN      ] PassingTestWithHelpers.EmptyTestMethod
+SetUp ran.
+TearDown ran.
+[       OK ] PassingTestWithHelpers.EmptyTestMethod
+TearDownTestSuite ran.
+[----------] Finished with tests from PassingTestWithHelpers
+PASS
+ok somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.run_twice_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.run_twice_test
new file mode 100644
index 00000000000..0749f916454
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.run_twice_test
@@ -0,0 +1,14 @@
+[----------] Running tests from RunTwiceTest
+[ RUN      ] RunTwiceTest.PassingMethod
+[       OK ] RunTwiceTest.PassingMethod
+[ RUN      ] RunTwiceTest.FailingMethod
+run_twice_test.go:46:
+Expected: 17.5
+Actual:   17
+
+[  FAILED  ] RunTwiceTest.FailingMethod
+[----------] Finished with tests from RunTwiceTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.stop_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.stop_test
new file mode 100644
index 00000000000..e7d42c79337
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.stop_test
@@ -0,0 +1,13 @@
+[----------] Running tests from StopTest
+[ RUN      ] StopTest.First
+TearDown running.
+[       OK ] StopTest.First
+[ RUN      ] StopTest.Second
+About to call StopRunningTests.
+Called StopRunningTests.
+TearDown running.
+[       OK ] StopTest.Second
+TearDownTestSuite running.
+Exiting early due to user request.
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.unexported_test b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.unexported_test
new file mode 100644
index 00000000000..6221e65ea9a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/golden.unexported_test
@@ -0,0 +1,12 @@
+[----------] Running tests from UnexportedTest
+[ RUN      ] UnexportedTest.SomeTest
+unexported_test.go:42:
+Expected: 4
+Actual:   3
+
+[  FAILED  ] UnexportedTest.SomeTest
+[----------] Finished with tests from UnexportedTest
+--- FAIL: TestSomething (1.23s)
+FAIL
+exit status 1
+FAIL somepkg 1.234s
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock.test.go
new file mode 100644
index 00000000000..8e0fca9cc01
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock.test.go
@@ -0,0 +1,82 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglemock"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image"
+	"image/color"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type MockTest struct {
+	controller oglemock.Controller
+	image      mock_image.MockImage
+}
+
+func init()                     { RegisterTestSuite(&MockTest{}) }
+func TestMockTest(t *testing.T) { RunTests(t) }
+
+func (t *MockTest) SetUp(i *TestInfo) {
+	t.controller = i.MockController
+	t.image = mock_image.NewMockImage(t.controller, "some mock image")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *MockTest) ExpectationSatisfied() {
+	ExpectCall(t.image, "At")(11, GreaterThan(19)).
+		WillOnce(oglemock.Return(color.Gray{0}))
+
+	ExpectThat(t.image.At(11, 23), IdenticalTo(color.Gray{0}))
+}
+
+func (t *MockTest) MockExpectationNotSatisfied() {
+	ExpectCall(t.image, "At")(11, GreaterThan(19)).
+		WillOnce(oglemock.Return(color.Gray{0}))
+}
+
+func (t *MockTest) ExpectCallForUnknownMethod() {
+	ExpectCall(t.image, "FooBar")(11)
+}
+
+func (t *MockTest) UnexpectedCall() {
+	t.image.At(11, 23)
+}
+
+func (t *MockTest) InvokeFunction() {
+	var suppliedX, suppliedY int
+	f := func(x, y int) color.Color {
+		suppliedX = x
+		suppliedY = y
+		return color.Gray{17}
+	}
+
+	ExpectCall(t.image, "At")(Any(), Any()).
+		WillOnce(oglemock.Invoke(f))
+
+	ExpectThat(t.image.At(-1, 12), IdenticalTo(color.Gray{17}))
+	ExpectEq(-1, suppliedX)
+	ExpectEq(12, suppliedY)
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image/mock_image.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image/mock_image.go
new file mode 100644
index 00000000000..a8d55bc4808
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image/mock_image.go
@@ -0,0 +1,115 @@
+// This file was auto-generated using createmock. See the following page for
+// more information:
+//
+//     https://github.com/smartystreets/assertions/internal/oglemock
+//
+
+package mock_image
+
+import (
+	fmt "fmt"
+	oglemock "github.com/smartystreets/assertions/internal/oglemock"
+	image "image"
+	color "image/color"
+	runtime "runtime"
+	unsafe "unsafe"
+)
+
+type MockImage interface {
+	image.Image
+	oglemock.MockObject
+}
+
+type mockImage struct {
+	controller  oglemock.Controller
+	description string
+}
+
+func NewMockImage(
+	c oglemock.Controller,
+	desc string) MockImage {
+	return &mockImage{
+		controller:  c,
+		description: desc,
+	}
+}
+
+func (m *mockImage) Oglemock_Id() uintptr {
+	return uintptr(unsafe.Pointer(m))
+}
+
+func (m *mockImage) Oglemock_Description() string {
+	return m.description
+}
+
+func (m *mockImage) At(p0 int, p1 int) (o0 color.Color) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"At",
+		file,
+		line,
+		[]interface{}{p0, p1})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.At: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Color
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Color)
+	}
+
+	return
+}
+
+func (m *mockImage) Bounds() (o0 image.Rectangle) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"Bounds",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.Bounds: invalid return values: %v", retVals))
+	}
+
+	// o0 image.Rectangle
+	if retVals[0] != nil {
+		o0 = retVals[0].(image.Rectangle)
+	}
+
+	return
+}
+
+func (m *mockImage) ColorModel() (o0 color.Model) {
+	// Get a file name and line number for the caller.
+	_, file, line, _ := runtime.Caller(1)
+
+	// Hand the call off to the controller, which does most of the work.
+	retVals := m.controller.HandleMethodCall(
+		m,
+		"ColorModel",
+		file,
+		line,
+		[]interface{}{})
+
+	if len(retVals) != 1 {
+		panic(fmt.Sprintf("mockImage.ColorModel: invalid return values: %v", retVals))
+	}
+
+	// o0 color.Model
+	if retVals[0] != nil {
+		o0 = retVals[0].(color.Model)
+	}
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/no_cases.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/no_cases.test.go
new file mode 100644
index 00000000000..ad204e053e5
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/no_cases.test.go
@@ -0,0 +1,41 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+func TestNoCases(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type NoCasesTest struct {
+}
+
+func init() { RegisterTestSuite(&NoCasesTest{}) }
+
+func (t *NoCasesTest) SetUpTestSuite() {
+	fmt.Println("SetUpTestSuite run!")
+}
+
+func (t *NoCasesTest) TearDownTestSuite() {
+	fmt.Println("TearDownTestSuite run!")
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/panicking.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/panicking.test.go
new file mode 100644
index 00000000000..59d1fe3bae0
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/panicking.test.go
@@ -0,0 +1,99 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	"log"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestPanickingTest(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// PanickingTest
+////////////////////////////////////////////////////////////////////////
+
+func someFuncThatPanics() {
+	panic("Panic in someFuncThatPanics")
+}
+
+type PanickingTest struct {
+}
+
+func init() { RegisterTestSuite(&PanickingTest{}) }
+
+func (t *PanickingTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *PanickingTest) ExplicitPanic() {
+	panic("Panic in ExplicitPanic")
+}
+
+func (t *PanickingTest) ExplicitPanicInHelperFunction() {
+	someFuncThatPanics()
+}
+
+func (t *PanickingTest) NilPointerDerefence() {
+	var p *int
+	log.Println(*p)
+}
+
+func (t *PanickingTest) ZzzSomeOtherTest() {
+	ExpectThat(17, Equals(17.0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// SetUpPanicTest
+////////////////////////////////////////////////////////////////////////
+
+type SetUpPanicTest struct {
+}
+
+func init() { RegisterTestSuite(&SetUpPanicTest{}) }
+
+func (t *SetUpPanicTest) SetUp(ti *TestInfo) {
+	fmt.Println("SetUp about to panic.")
+	panic("Panic in SetUp")
+}
+
+func (t *SetUpPanicTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *SetUpPanicTest) SomeTestCase() {
+}
+
+////////////////////////////////////////////////////////////////////////
+// TearDownPanicTest
+////////////////////////////////////////////////////////////////////////
+
+type TearDownPanicTest struct {
+}
+
+func init() { RegisterTestSuite(&TearDownPanicTest{}) }
+
+func (t *TearDownPanicTest) TearDown() {
+	fmt.Println("TearDown about to panic.")
+	panic("Panic in TearDown")
+}
+
+func (t *TearDownPanicTest) SomeTestCase() {
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/passing.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/passing.test.go
new file mode 100644
index 00000000000..01d8e63446e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/passing.test.go
@@ -0,0 +1,120 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestPassingTest(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// PassingTest
+////////////////////////////////////////////////////////////////////////
+
+type PassingTest struct {
+}
+
+func init() { RegisterTestSuite(&PassingTest{}) }
+
+func (t *PassingTest) EmptyTestMethod() {
+}
+
+func (t *PassingTest) SuccessfullMatches() {
+	ExpectThat(17, Equals(17.0))
+	ExpectThat(16.9, LessThan(17))
+	ExpectThat("taco", HasSubstr("ac"))
+
+	AssertThat(17, Equals(17.0))
+	AssertThat(16.9, LessThan(17))
+	AssertThat("taco", HasSubstr("ac"))
+}
+
+func (t *PassingTest) ExpectAliases() {
+	ExpectEq(17, 17.0)
+
+	ExpectLe(17, 17.0)
+	ExpectLe(17, 18.0)
+	ExpectLt(17, 18.0)
+
+	ExpectGe(17, 17.0)
+	ExpectGe(17, 16.0)
+	ExpectGt(17, 16.0)
+
+	ExpectNe(17, 18.0)
+
+	ExpectTrue(true)
+	ExpectFalse(false)
+}
+
+func (t *PassingTest) AssertAliases() {
+	AssertEq(17, 17.0)
+
+	AssertLe(17, 17.0)
+	AssertLe(17, 18.0)
+	AssertLt(17, 18.0)
+
+	AssertGe(17, 17.0)
+	AssertGe(17, 16.0)
+	AssertGt(17, 16.0)
+
+	AssertNe(17, 18.0)
+
+	AssertTrue(true)
+	AssertFalse(false)
+}
+
+func (t *PassingTest) SlowTest() {
+	time.Sleep(37 * time.Millisecond)
+}
+
+////////////////////////////////////////////////////////////////////////
+// PassingTestWithHelpers
+////////////////////////////////////////////////////////////////////////
+
+type PassingTestWithHelpers struct {
+}
+
+var _ SetUpTestSuiteInterface = &PassingTestWithHelpers{}
+var _ SetUpInterface = &PassingTestWithHelpers{}
+var _ TearDownInterface = &PassingTestWithHelpers{}
+var _ TearDownTestSuiteInterface = &PassingTestWithHelpers{}
+
+func init() { RegisterTestSuite(&PassingTestWithHelpers{}) }
+
+func (t *PassingTestWithHelpers) SetUpTestSuite() {
+	fmt.Println("SetUpTestSuite ran.")
+}
+
+func (t *PassingTestWithHelpers) SetUp(ti *TestInfo) {
+	fmt.Println("SetUp ran.")
+}
+
+func (t *PassingTestWithHelpers) TearDown() {
+	fmt.Println("TearDown ran.")
+}
+
+func (t *PassingTestWithHelpers) TearDownTestSuite() {
+	fmt.Println("TearDownTestSuite ran.")
+}
+
+func (t *PassingTestWithHelpers) EmptyTestMethod() {
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/run_twice.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/run_twice.test.go
new file mode 100644
index 00000000000..a3a36c17525
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/run_twice.test.go
@@ -0,0 +1,47 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type RunTwiceTest struct {
+}
+
+func init() { RegisterTestSuite(&RunTwiceTest{}) }
+
+// Set up two helpers that call RunTests. The test should still only be run
+// once.
+func TestOgletest(t *testing.T)  { RunTests(t) }
+func TestOgletest2(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *RunTwiceTest) PassingMethod() {
+}
+
+func (t *RunTwiceTest) FailingMethod() {
+	ExpectThat(17, Equals(17.5))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/stop.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/stop.test.go
new file mode 100644
index 00000000000..a008c081e91
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/stop.test.go
@@ -0,0 +1,61 @@
+// Copyright 2015 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestStop(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Boilerplate
+////////////////////////////////////////////////////////////////////////
+
+type StopTest struct {
+}
+
+var _ TearDownInterface = &StopTest{}
+var _ TearDownTestSuiteInterface = &StopTest{}
+
+func init() { RegisterTestSuite(&StopTest{}) }
+
+func (t *StopTest) TearDown() {
+	fmt.Println("TearDown running.")
+}
+
+func (t *StopTest) TearDownTestSuite() {
+	fmt.Println("TearDownTestSuite running.")
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *StopTest) First() {
+}
+
+func (t *StopTest) Second() {
+	fmt.Println("About to call StopRunningTests.")
+	StopRunningTests()
+	fmt.Println("Called StopRunningTests.")
+}
+
+func (t *StopTest) Third() {
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/unexported.test.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/unexported.test.go
new file mode 100644
index 00000000000..a425e78d404
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/unexported.test.go
@@ -0,0 +1,43 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers_test
+
+import (
+	. "github.com/smartystreets/assertions/internal/oglematchers"
+	. "github.com/smartystreets/assertions/internal/ogletest"
+	"testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type UnexportedTest struct {
+}
+
+func init()                           { RegisterTestSuite(&UnexportedTest{}) }
+func TestUnexportedTest(t *testing.T) { RunTests(t) }
+
+func (t *UnexportedTest) someUnexportedMethod() {
+}
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *UnexportedTest) SomeTest() {
+	ExpectThat(3, Equals(4))
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_info.go b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_info.go
new file mode 100644
index 00000000000..3ae12526bc2
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_info.go
@@ -0,0 +1,91 @@
+// Copyright 2011 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ogletest
+
+import (
+	"sync"
+
+	"golang.org/x/net/context"
+
+	"github.com/smartystreets/assertions/internal/oglemock"
+)
+
+// TestInfo represents information about a currently running or previously-run
+// test.
+type TestInfo struct {
+	// A mock controller that is set up to report errors to the ogletest test
+	// runner. This can be used for setting up mock expectations and handling
+	// mock calls. The Finish method should not be run by the user; ogletest will
+	// do that automatically after the test's TearDown method is run.
+	//
+	// Note that this feature is still experimental, and is subject to change.
+	MockController oglemock.Controller
+
+	// A context that can be used by tests for long-running operations. In
+	// particular, this enables conveniently tracing the execution of a test
+	// function with reqtrace.
+	Ctx context.Context
+
+	// A mutex protecting shared state.
+	mu sync.RWMutex
+
+	// A set of failure records that the test has produced.
+	//
+	// GUARDED_BY(mu)
+	failureRecords []FailureRecord
+}
+
+// currentlyRunningTest is the state for the currently running test, if any.
+var currentlyRunningTest *TestInfo
+
+// newTestInfo creates a valid but empty TestInfo struct.
+func newTestInfo() (info *TestInfo) {
+	info = &TestInfo{}
+	info.MockController = oglemock.NewController(&testInfoErrorReporter{info})
+	info.Ctx = context.Background()
+
+	return
+}
+
+// testInfoErrorReporter is an oglemock.ErrorReporter that writes failure
+// records into a test info struct.
+type testInfoErrorReporter struct {
+	testInfo *TestInfo
+}
+
+func (r *testInfoErrorReporter) ReportError(
+	fileName string,
+	lineNumber int,
+	err error) {
+	r.testInfo.mu.Lock()
+	defer r.testInfo.mu.Unlock()
+
+	record := FailureRecord{
+		FileName:   fileName,
+		LineNumber: lineNumber,
+		Error:      err.Error(),
+	}
+
+	r.testInfo.failureRecords = append(r.testInfo.failureRecords, record)
+}
+
+func (r *testInfoErrorReporter) ReportFatalError(
+	fileName string,
+	lineNumber int,
+	err error) {
+	r.ReportError(fileName, lineNumber, err)
+	AbortTest()
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/.gitignore b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/.gitignore
new file mode 100644
index 00000000000..daf913b1b34
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/.gitignore
@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/LICENSE b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/LICENSE
new file mode 100644
index 00000000000..8f71f43fee3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/LICENSE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/README.md b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/README.md
new file mode 100644
index 00000000000..4392452b5b1
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/README.md
@@ -0,0 +1,53 @@
+[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/reqtrace?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/reqtrace)
+
+reqtrace is a package for simple request tracing. It requires nothing of its
+user except:
+
+ *  They must use [golang.org/x/net/context][context].
+ *  They must add a single line to each function they want to be visible in
+    traces.
+
+[context]: http://godoc.org/golang.org/x/net/context
+
+In particular, reqtrace is console-based and doesn't require an HTTP server.
+
+**Warning**: This package is still barebones and in its early days. I reserve
+the right to make backwards-incompatible changes to its API. But if it's useful
+to you in your current form, have at it.
+
+## Use
+
+Call reqtrace.Trace anywhere you want to start a new root trace. (This is
+probably where you create your root context.) This returns a new context that
+you should pass to child operations, and a reporting function that you must use
+to inform reqtrace when the trace is complete.
+
+For example:
+
+```Go
+func HandleRequest(r *someRequest) (err error) {
+  ctx, report := reqtrace.Trace(context.Background(), "HandleRequest")
+  defer func() { report(err) }()
+
+  // Do two things for this request.
+  DoSomething(ctx, r)
+  DoSomethingElse(ctx, r)
+}
+```
+
+Within other functions that you want to show up in the trace, you
+reqtrace.StartSpan (or its more convenient sibling reqtrace.StartSpanWithError):
+
+```Go
+func DoSomething(ctx context.Context, r *someRequest) (err error) {
+  defer reqtrace.StartSpanWithError(&ctx, &err, "DoSomething")()
+
+  // Process the request somehow using ctx. If downstream code also annotes
+  // using reqtrace, reqtrace will know that its spans are descendants of
+  // this one.
+  CallAnotherLibrary(ctx, r.Param)
+}
+```
+
+When `--reqtrace.enable` is set, the completion of a trace will cause helpful
+ASCII art to be spit out.
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/reqtrace.go b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/reqtrace.go
new file mode 100644
index 00000000000..853c024244f
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/reqtrace.go
@@ -0,0 +1,132 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package reqtrace contains a very simple request tracing framework.
+package reqtrace
+
+import (
+	"flag"
+
+	"golang.org/x/net/context"
+)
+
+type contextKey int
+
+var fEnabled = flag.Bool("reqtrace.enable", false, "Collect and print traces.")
+
+// The key used to associate a *traceState with a context.
+const traceStateKey contextKey = 0
+
+// A function that must be called exactly once to report the outcome of an
+// operation represented by a span.
+type ReportFunc func(error)
+
+// Return false only if traces are disabled, i.e. Trace will never cause a
+// trace to be initiated.
+//
+// REQUIRES: flag.Parsed()
+func Enabled() (enabled bool) {
+	enabled = *fEnabled
+	return
+}
+
+// Begin a span within the current trace. Return a new context that should be
+// used for operations that logically occur within the span, and a report
+// function that must be called with the outcome of the logical operation
+// represented by the span.
+//
+// If no trace is active, no span will be created but ctx and report will still
+// be valid.
+func StartSpan(
+	parent context.Context,
+	desc string) (ctx context.Context, report ReportFunc) {
+	// Look for the trace state.
+	val := parent.Value(traceStateKey)
+	if val == nil {
+		// Nothing to do.
+		ctx = parent
+		report = func(err error) {}
+		return
+	}
+
+	ts := val.(*traceState)
+
+	// Set up the report function.
+	report = ts.CreateSpan(desc)
+
+	// For now we don't do anything interesting with the context. In the future,
+	// we may use it to record span hierarchy.
+	ctx = parent
+
+	return
+}
+
+// A wrapper around StartSpan that can be more convenient to use when the
+// lifetime of a span matches the lifetime of a function. Intended to be used
+// in a defer statement within a function using a named error return parameter.
+//
+// Equivalent to calling StartSpan with *ctx, replacing *ctx with the resulting
+// new context, then setting f to a function that will invoke the report
+// function with the contents of *error at the time that it is called.
+//
+// Example:
+//
+//     func DoSomething(ctx context.Context) (err error) {
+//       defer reqtrace.StartSpanWithError(&ctx, &err, "DoSomething")()
+//       [...]
+//     }
+//
+func StartSpanWithError(
+	ctx *context.Context,
+	err *error,
+	desc string) (f func()) {
+	var report ReportFunc
+	*ctx, report = StartSpan(*ctx, desc)
+	f = func() { report(*err) }
+	return
+}
+
+// Like StartSpan, but begins a root span for a new trace if no trace is active
+// in the supplied context and tracing is enabled for the process.
+func Trace(
+	parent context.Context,
+	desc string) (ctx context.Context, report ReportFunc) {
+	// If tracing is disabled, this is a no-op.
+	if !*fEnabled {
+		ctx = parent
+		report = func(err error) {}
+		return
+	}
+
+	// Is this context already being traced? If so, simply add a span.
+	if parent.Value(traceStateKey) != nil {
+		ctx, report = StartSpan(parent, desc)
+		return
+	}
+
+	// Set up a new trace state.
+	ts := new(traceState)
+	baseReport := ts.CreateSpan(desc)
+
+	// Log when finished.
+	report = func(err error) {
+		baseReport(err)
+		ts.Log()
+	}
+
+	// Set up the context.
+	ctx = context.WithValue(parent, traceStateKey, ts)
+
+	return
+}
diff --git a/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/trace_state.go b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/trace_state.go
new file mode 100644
index 00000000000..614ef90d892
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/trace_state.go
@@ -0,0 +1,175 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package reqtrace
+
+import (
+	"log"
+	"math"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+const logFlags = 0
+
+var gLogger = log.New(os.Stderr, "reqtrace: ", logFlags)
+
+type span struct {
+	// Fixed at creation.
+	desc  string
+	start time.Time
+
+	// Updated by report functions.
+	finished bool
+	end      time.Time
+	err      error
+}
+
+// All of the state for a particular trace root. The zero value is usable.
+type traceState struct {
+	mu sync.Mutex
+
+	// The list of spans associated with this state. Append-only.
+	//
+	// GUARDED_BY(mu)
+	spans []*span
+}
+
+func (ts *traceState) report(spanIndex int, err error) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+
+	s := ts.spans[spanIndex]
+	s.finished = true
+	s.end = time.Now()
+	s.err = err
+}
+
+// Associate a new span with the trace. Return a function that will report its
+// completion.
+func (ts *traceState) CreateSpan(desc string) (report ReportFunc) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+
+	index := len(ts.spans)
+	ts.spans = append(ts.spans, &span{desc: desc, start: time.Now()})
+
+	report = func(err error) { ts.report(index, err) }
+	return
+}
+
+func round(x float64) float64 {
+	if x < 0 {
+		return math.Ceil(x - 0.5)
+	}
+
+	return math.Floor(x + 0.5)
+}
+
+// Log information about the spans in this trace.
+func (ts *traceState) Log() {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	gLogger.Println()
+
+	// Special case: we require at least one span.
+	if len(ts.spans) == 0 {
+		return
+	}
+
+	// Print a banner for this trace.
+	const bannerHalfLength = 45
+
+	gLogger.Println()
+	gLogger.Printf(
+		"%s %s %s",
+		strings.Repeat("=", bannerHalfLength),
+		ts.spans[0].desc,
+		strings.Repeat("=", bannerHalfLength))
+	gLogger.Printf("Start time: %v", ts.spans[0].start.Format(time.RFC3339Nano))
+	gLogger.Println()
+
+	// Find the minimum start time and maximum end time of all durations.
+	var minStart time.Time
+	var maxEnd time.Time
+	for _, s := range ts.spans {
+		if !s.finished {
+			continue
+		}
+
+		if minStart.IsZero() || s.start.Before(minStart) {
+			minStart = s.start
+		}
+
+		if maxEnd.Before(s.end) {
+			maxEnd = s.end
+		}
+	}
+
+	// Bail out if something weird happened.
+	//
+	// TODO(jacobsa): Be more graceful.
+	totalDuration := maxEnd.Sub(minStart)
+	if minStart.IsZero() || maxEnd.IsZero() || totalDuration <= 0 {
+		gLogger.Println("(Weird trace)")
+		return
+	}
+
+	// Calculate the number of nanoseconds elapsed, as a floating point number.
+	totalNs := float64(totalDuration / time.Nanosecond)
+
+	// Log each span with some ASCII art showing its length relative to the
+	// total.
+	const totalNumCols float64 = 120
+	for _, s := range ts.spans {
+		if !s.finished {
+			gLogger.Printf("(Unfinished: %s)", s.desc)
+			gLogger.Println()
+			continue
+		}
+
+		// Calculate the duration of the span, and its width relative to the
+		// longest span.
+		d := s.end.Sub(s.start)
+		if d <= 0 {
+			gLogger.Println("(Weird duration)")
+			gLogger.Println()
+			continue
+		}
+
+		durationRatio := float64(d/time.Nanosecond) / totalNs
+
+		// We will offset the label and banner proportional to the time since the
+		// start of the earliest span.
+		offsetRatio := float64(s.start.Sub(minStart)/time.Nanosecond) / totalNs
+		offsetChars := int(round(offsetRatio * totalNumCols))
+		offsetStr := strings.Repeat(" ", offsetChars)
+
+		// Print the description and duration.
+		gLogger.Printf("%s%v", offsetStr, s.desc)
+		gLogger.Printf("%s%v", offsetStr, d)
+
+		// Print a banner showing the duration graphically.
+		bannerChars := int(round(durationRatio * totalNumCols))
+		var dashes string
+		if bannerChars > 2 {
+			dashes = strings.Repeat("-", bannerChars-2)
+		}
+
+		gLogger.Printf("%s|%s|", offsetStr, dashes)
+		gLogger.Println()
+	}
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/messages.go b/vendor/src/github.com/smartystreets/assertions/messages.go
index 655fdadec82..318854546b1 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/messages.go
+++ b/vendor/src/github.com/smartystreets/assertions/messages.go
@@ -1,21 +1,23 @@
 package assertions
 
 const ( // equality
-	shouldHaveBeenEqual          = "Expected: '%v'\nActual:   '%v'\n(Should be equal)"
-	shouldNotHaveBeenEqual       = "Expected     '%v'\nto NOT equal '%v'\n(but it did)!"
-	shouldHaveBeenAlmostEqual    = "Expected '%v' to almost equal '%v' (but it didn't)!"
-	shouldHaveNotBeenAlmostEqual = "Expected '%v' to NOT almost equal '%v' (but it did)!"
-	shouldHaveResembled          = "Expected: '%+v'\nActual:   '%+v'\n(Should resemble)!"
-	shouldNotHaveResembled       = "Expected        '%+v'\nto NOT resemble '%+v'\n(but it did)!"
-	shouldBePointers             = "Both arguments should be pointers "
-	shouldHaveBeenNonNilPointer  = shouldBePointers + "(the %s was %s)!"
-	shouldHavePointedTo          = "Expected '%+v' (address: '%v') and '%+v' (address: '%v') to be the same address (but their weren't)!"
-	shouldNotHavePointedTo       = "Expected '%+v' and '%+v' to be different references (but they matched: '%v')!"
-	shouldHaveBeenNil            = "Expected: nil\nActual:   '%v'"
-	shouldNotHaveBeenNil         = "Expected '%+v' to NOT be nil (but it was)!"
-	shouldHaveBeenTrue           = "Expected: true\nActual:   %v"
-	shouldHaveBeenFalse          = "Expected: false\nActual:   %v"
-	shouldHaveBeenZeroValue      = "'%+v' should have been the zero value" //"Expected: (zero value)\nActual:   %v"
+	shouldHaveBeenEqual             = "Expected: '%v'\nActual:   '%v'\n(Should be equal)"
+	shouldNotHaveBeenEqual          = "Expected     '%v'\nto NOT equal '%v'\n(but it did)!"
+	shouldHaveBeenEqualTypeMismatch = "Expected: '%v' (%T)\nActual:   '%v' (%T)\n(Should be equal, type mismatch)"
+	shouldHaveBeenAlmostEqual       = "Expected '%v' to almost equal '%v' (but it didn't)!"
+	shouldHaveNotBeenAlmostEqual    = "Expected '%v' to NOT almost equal '%v' (but it did)!"
+	shouldHaveResembled             = "Expected: '%#v'\nActual:   '%#v'\n(Should resemble)!"
+	shouldHaveResembledTypeMismatch = "Expected: '%#v' (%T)\nActual:   '%#v' (%T)\n(Should resemble, type mismatch)"
+	shouldNotHaveResembled          = "Expected        '%#v'\nto NOT resemble '%#v'\n(but it did)!"
+	shouldBePointers                = "Both arguments should be pointers "
+	shouldHaveBeenNonNilPointer     = shouldBePointers + "(the %s was %s)!"
+	shouldHavePointedTo             = "Expected '%+v' (address: '%v') and '%+v' (address: '%v') to be the same address (but their weren't)!"
+	shouldNotHavePointedTo          = "Expected '%+v' and '%+v' to be different references (but they matched: '%v')!"
+	shouldHaveBeenNil               = "Expected: nil\nActual:   '%v'"
+	shouldNotHaveBeenNil            = "Expected '%+v' to NOT be nil (but it was)!"
+	shouldHaveBeenTrue              = "Expected: true\nActual:   %v"
+	shouldHaveBeenFalse             = "Expected: false\nActual:   %v"
+	shouldHaveBeenZeroValue         = "'%+v' should have been the zero value" //"Expected: (zero value)\nActual:   %v"
 )
 
 const ( // quantity comparisons
@@ -31,14 +33,19 @@ const ( // quantity comparisons
 )
 
 const ( // collections
-	shouldHaveContained                 = "Expected the container (%v) to contain: '%v' (but it didn't)!"
-	shouldNotHaveContained              = "Expected the container (%v) NOT to contain: '%v' (but it did)!"
-	shouldHaveBeenIn                    = "Expected '%v' to be in the container (%v, but it wasn't)!"
-	shouldNotHaveBeenIn                 = "Expected '%v' NOT to be in the container (%v, but it was)!"
-	shouldHaveBeenAValidCollection      = "You must provide a valid container (was %v)!"
-	shouldHaveProvidedCollectionMembers = "This assertion requires at least 1 comparison value (you provided 0)."
-	shouldHaveBeenEmpty                 = "Expected %+v to be empty (but it wasn't)!"
-	shouldNotHaveBeenEmpty              = "Expected %+v to NOT be empty (but it was)!"
+	shouldHaveContained            = "Expected the container (%v) to contain: '%v' (but it didn't)!"
+	shouldNotHaveContained         = "Expected the container (%v) NOT to contain: '%v' (but it did)!"
+	shouldHaveContainedKey         = "Expected the %v to contain the key: %v (but it didn't)!"
+	shouldNotHaveContainedKey      = "Expected the %v NOT to contain the key: %v (but it did)!"
+	shouldHaveBeenIn               = "Expected '%v' to be in the container (%v), but it wasn't!"
+	shouldNotHaveBeenIn            = "Expected '%v' NOT to be in the container (%v), but it was!"
+	shouldHaveBeenAValidCollection = "You must provide a valid container (was %v)!"
+	shouldHaveBeenAValidMap        = "You must provide a valid map type (was %v)!"
+	shouldHaveBeenEmpty            = "Expected %+v to be empty (but it wasn't)!"
+	shouldNotHaveBeenEmpty         = "Expected %+v to NOT be empty (but it was)!"
+	shouldHaveBeenAValidInteger    = "You must provide a valid integer (was %v)!"
+	shouldHaveBeenAValidLength     = "You must provide a valid positive integer (was %v)!"
+	shouldHaveHadLength            = "Expected %+v to have length equal to '%v', but it wasn't!"
 )
 
 const ( // strings
@@ -46,10 +53,11 @@ const ( // strings
 	shouldNotHaveStartedWith        = "Expected          '%v'\nNOT to start with '%v'\n(but it did)!"
 	shouldHaveEndedWith             = "Expected    '%v'\nto end with '%v'\n(but it didn't)!"
 	shouldNotHaveEndedWith          = "Expected        '%v'\nNOT to end with '%v'\n(but it did)!"
+	shouldAllBeStrings              = "All arguments to this assertion must be strings (you provided: %v)."
 	shouldBothBeStrings             = "Both arguments to this assertion must be strings (you provided %v and %v)."
 	shouldBeString                  = "The argument to this assertion must be a string (you provided %v)."
 	shouldHaveContainedSubstring    = "Expected '%s' to contain substring '%s' (but it didn't)!"
-	shouldNotHaveContainedSubstring = "Expected '%s' NOT to contain substring '%s' (but it didn't)!"
+	shouldNotHaveContainedSubstring = "Expected '%s' NOT to contain substring '%s' (but it did)!"
 	shouldHaveBeenBlank             = "Expected '%s' to be blank (but it wasn't)!"
 	shouldNotHaveBeenBlank          = "Expected value to NOT be blank (but it was)!"
 )
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/panic.go b/vendor/src/github.com/smartystreets/assertions/panic.go
index 7e75db1784b..7e75db1784b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/panic.go
+++ b/vendor/src/github.com/smartystreets/assertions/panic.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/panic_test.go b/vendor/src/github.com/smartystreets/assertions/panic_test.go
index 15eafac4fbb..15eafac4fbb 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/panic_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/panic_test.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/quantity.go b/vendor/src/github.com/smartystreets/assertions/quantity.go
index 19e697bf3ce..80789f0cc71 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/quantity.go
+++ b/vendor/src/github.com/smartystreets/assertions/quantity.go
@@ -3,7 +3,7 @@ package assertions
 import (
 	"fmt"
 
-	"github.com/jacobsa/oglematchers"
+	"github.com/smartystreets/assertions/internal/oglematchers"
 )
 
 // ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second.
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/quantity_test.go b/vendor/src/github.com/smartystreets/assertions/quantity_test.go
index 7546e7250a8..7546e7250a8 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/quantity_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/quantity_test.go
diff --git a/vendor/src/github.com/smartystreets/assertions/serializer.go b/vendor/src/github.com/smartystreets/assertions/serializer.go
new file mode 100644
index 00000000000..7908606fff7
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/serializer.go
@@ -0,0 +1,67 @@
+package assertions
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type Serializer interface {
+	serialize(expected, actual interface{}, message string) string
+	serializeDetailed(expected, actual interface{}, message string) string
+}
+
+type failureSerializer struct{}
+
+func (self *failureSerializer) serializeDetailed(expected, actual interface{}, message string) string {
+	view := self.format(expected, actual, message, "%#v")
+	serialized, err := json.Marshal(view)
+	if err != nil {
+		return message
+	}
+	return string(serialized)
+}
+
+func (self *failureSerializer) serialize(expected, actual interface{}, message string) string {
+	view := self.format(expected, actual, message, "%+v")
+	serialized, err := json.Marshal(view)
+	if err != nil {
+		return message
+	}
+	return string(serialized)
+}
+
+func (self *failureSerializer) format(expected, actual interface{}, message string, format string) FailureView {
+	return FailureView{
+		Message:  message,
+		Expected: fmt.Sprintf(format, expected),
+		Actual:   fmt.Sprintf(format, actual),
+	}
+}
+
+func newSerializer() *failureSerializer {
+	return &failureSerializer{}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// This struct is also declared in github.com/smartystreets/goconvey/convey/reporting.
+// The json struct tags should be equal in both declarations.
+type FailureView struct {
+	Message  string `json:"Message"`
+	Expected string `json:"Expected"`
+	Actual   string `json:"Actual"`
+}
+
+///////////////////////////////////////////////////////
+
+// noopSerializer just gives back the original message. This is useful when we are using
+// the assertions from a context other than the web UI, that requires the JSON structure
+// provided by the failureSerializer.
+type noopSerializer struct{}
+
+func (self *noopSerializer) serialize(expected, actual interface{}, message string) string {
+	return message
+}
+func (self *noopSerializer) serializeDetailed(expected, actual interface{}, message string) string {
+	return message
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/serializer_test.go b/vendor/src/github.com/smartystreets/assertions/serializer_test.go
index ba6a36e1f42..597b40ac183 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/serializer_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/serializer_test.go
@@ -4,8 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"testing"
-
-	"github.com/smartystreets/goconvey/convey/reporting"
 )
 
 func TestSerializerCreatesSerializedVersionOfAssertionResult(t *testing.T) {
@@ -16,7 +14,7 @@ func TestSerializerCreatesSerializedVersionOfAssertionResult(t *testing.T) {
 
 	actualResult := serializer.serialize(thing1, thing2, message)
 
-	expectedResult, _ := json.Marshal(reporting.FailureView{
+	expectedResult, _ := json.Marshal(FailureView{
 		Message:  message,
 		Expected: fmt.Sprintf("%+v", thing1),
 		Actual:   fmt.Sprintf("%+v", thing2),
@@ -25,4 +23,14 @@ func TestSerializerCreatesSerializedVersionOfAssertionResult(t *testing.T) {
 	if actualResult != string(expectedResult) {
 		t.Errorf("\nExpected: %s\nActual:   %s", string(expectedResult), actualResult)
 	}
+
+	actualResult = serializer.serializeDetailed(thing1, thing2, message)
+	expectedResult, _ = json.Marshal(FailureView{
+		Message:  message,
+		Expected: fmt.Sprintf("%#v", thing1),
+		Actual:   fmt.Sprintf("%#v", thing2),
+	})
+	if actualResult != string(expectedResult) {
+		t.Errorf("\nExpected: %s\nActual:   %s", string(expectedResult), actualResult)
+	}
 }
diff --git a/vendor/src/github.com/smartystreets/assertions/should/should.go b/vendor/src/github.com/smartystreets/assertions/should/should.go
new file mode 100644
index 00000000000..596e43b8f8b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/assertions/should/should.go
@@ -0,0 +1,73 @@
+// package should is simply a rewording of the assertion
+// functions in the assertions package.
+package should
+
+import "github.com/smartystreets/assertions"
+
+var (
+	Equal          = assertions.ShouldEqual
+	NotEqual       = assertions.ShouldNotEqual
+	AlmostEqual    = assertions.ShouldAlmostEqual
+	NotAlmostEqual = assertions.ShouldNotAlmostEqual
+	Resemble       = assertions.ShouldResemble
+	NotResemble    = assertions.ShouldNotResemble
+	PointTo        = assertions.ShouldPointTo
+	NotPointTo     = assertions.ShouldNotPointTo
+	BeNil          = assertions.ShouldBeNil
+	NotBeNil       = assertions.ShouldNotBeNil
+	BeTrue         = assertions.ShouldBeTrue
+	BeFalse        = assertions.ShouldBeFalse
+	BeZeroValue    = assertions.ShouldBeZeroValue
+
+	BeGreaterThan          = assertions.ShouldBeGreaterThan
+	BeGreaterThanOrEqualTo = assertions.ShouldBeGreaterThanOrEqualTo
+	BeLessThan             = assertions.ShouldBeLessThan
+	BeLessThanOrEqualTo    = assertions.ShouldBeLessThanOrEqualTo
+	BeBetween              = assertions.ShouldBeBetween
+	NotBeBetween           = assertions.ShouldNotBeBetween
+	BeBetweenOrEqual       = assertions.ShouldBeBetweenOrEqual
+	NotBeBetweenOrEqual    = assertions.ShouldNotBeBetweenOrEqual
+
+	Contain       = assertions.ShouldContain
+	NotContain    = assertions.ShouldNotContain
+	ContainKey    = assertions.ShouldContainKey
+	NotContainKey = assertions.ShouldNotContainKey
+	BeIn          = assertions.ShouldBeIn
+	NotBeIn       = assertions.ShouldNotBeIn
+	BeEmpty       = assertions.ShouldBeEmpty
+	NotBeEmpty    = assertions.ShouldNotBeEmpty
+	HaveLength    = assertions.ShouldHaveLength
+
+	StartWith           = assertions.ShouldStartWith
+	NotStartWith        = assertions.ShouldNotStartWith
+	EndWith             = assertions.ShouldEndWith
+	NotEndWith          = assertions.ShouldNotEndWith
+	BeBlank             = assertions.ShouldBeBlank
+	NotBeBlank          = assertions.ShouldNotBeBlank
+	ContainSubstring    = assertions.ShouldContainSubstring
+	NotContainSubstring = assertions.ShouldNotContainSubstring
+
+	EqualWithout   = assertions.ShouldEqualWithout
+	EqualTrimSpace = assertions.ShouldEqualTrimSpace
+
+	Panic        = assertions.ShouldPanic
+	NotPanic     = assertions.ShouldNotPanic
+	PanicWith    = assertions.ShouldPanicWith
+	NotPanicWith = assertions.ShouldNotPanicWith
+
+	HaveSameTypeAs    = assertions.ShouldHaveSameTypeAs
+	NotHaveSameTypeAs = assertions.ShouldNotHaveSameTypeAs
+	Implement         = assertions.ShouldImplement
+	NotImplement      = assertions.ShouldNotImplement
+
+	HappenBefore         = assertions.ShouldHappenBefore
+	HappenOnOrBefore     = assertions.ShouldHappenOnOrBefore
+	HappenAfter          = assertions.ShouldHappenAfter
+	HappenOnOrAfter      = assertions.ShouldHappenOnOrAfter
+	HappenBetween        = assertions.ShouldHappenBetween
+	HappenOnOrBetween    = assertions.ShouldHappenOnOrBetween
+	NotHappenOnOrBetween = assertions.ShouldNotHappenOnOrBetween
+	HappenWithin         = assertions.ShouldHappenWithin
+	NotHappenWithin      = assertions.ShouldNotHappenWithin
+	BeChronological      = assertions.ShouldBeChronological
+)
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/strings.go b/vendor/src/github.com/smartystreets/assertions/strings.go
index 1b887b1191e..dbc3f04790e 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/strings.go
+++ b/vendor/src/github.com/smartystreets/assertions/strings.go
@@ -181,3 +181,47 @@ func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string {
 	}
 	return success
 }
+
+// ShouldEqualWithout receives exactly 3 string parameters and ensures that the first is equal to the second
+// after removing all instances of the third from the first using strings.Replace(first, third, "", -1).
+func ShouldEqualWithout(actual interface{}, expected ...interface{}) string {
+	if fail := need(2, expected); fail != success {
+		return fail
+	}
+	actualString, ok1 := actual.(string)
+	expectedString, ok2 := expected[0].(string)
+	replace, ok3 := expected[1].(string)
+
+	if !ok1 || !ok2 || !ok3 {
+		return fmt.Sprintf(shouldAllBeStrings, []reflect.Type{
+			reflect.TypeOf(actual),
+			reflect.TypeOf(expected[0]),
+			reflect.TypeOf(expected[1]),
+		})
+	}
+
+	replaced := strings.Replace(actualString, replace, "", -1)
+	if replaced == expectedString {
+		return ""
+	}
+
+	return fmt.Sprintf("Expected '%s' to equal '%s' but without any '%s' (but it didn't).", actualString, expectedString, replace)
+}
+
+// ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the first is equal to the second
+// after removing all leading and trailing whitespace using strings.TrimSpace(first).
+func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string {
+	if fail := need(1, expected); fail != success {
+		return fail
+	}
+
+	actualString, valueIsString := actual.(string)
+	_, value2IsString := expected[0].(string)
+
+	if !valueIsString || !value2IsString {
+		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
+	}
+
+	actualString = strings.TrimSpace(actualString)
+	return ShouldEqual(actualString, expected[0])
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/strings_test.go b/vendor/src/github.com/smartystreets/assertions/strings_test.go
index eec9440ed0a..ad8d0c88585 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/strings_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/strings_test.go
@@ -80,7 +80,7 @@ func TestShouldNotContainSubstring(t *testing.T) {
 	fail(t, so(123, ShouldNotContainSubstring, 23), "Both arguments to this assertion must be strings (you provided int and int).")
 
 	pass(t, so("qwer", ShouldNotContainSubstring, "sd"))
-	fail(t, so("asdf", ShouldNotContainSubstring, "sd"), "Expected 'asdf' NOT to contain substring 'sd' (but it didn't)!")
+	fail(t, so("asdf", ShouldNotContainSubstring, "sd"), "Expected 'asdf' NOT to contain substring 'sd' (but it did)!")
 }
 
 func TestShouldBeBlank(t *testing.T) {
@@ -100,3 +100,19 @@ func TestShouldNotBeBlank(t *testing.T) {
 	fail(t, so("", ShouldNotBeBlank), "Expected value to NOT be blank (but it was)!")
 	pass(t, so("asdf", ShouldNotBeBlank))
 }
+
+func TestShouldEqualWithout(t *testing.T) {
+	fail(t, so("", ShouldEqualWithout, ""), "This assertion requires exactly 2 comparison values (you provided 1).")
+	fail(t, so(1, ShouldEqualWithout, 2, 3), "All arguments to this assertion must be strings (you provided: [int int int]).")
+
+	fail(t, so("asdf", ShouldEqualWithout, "qwer", "q"), "Expected 'asdf' to equal 'qwer' but without any 'q' (but it didn't).")
+	pass(t, so("asdf", ShouldEqualWithout, "df", "as"))
+}
+
+func TestShouldEqualTrimSpace(t *testing.T) {
+	fail(t, so(" asdf ", ShouldEqualTrimSpace), "This assertion requires exactly 1 comparison values (you provided 0).")
+	fail(t, so(1, ShouldEqualTrimSpace, 2), "Both arguments to this assertion must be strings (you provided int and int).")
+
+	fail(t, so("asdf", ShouldEqualTrimSpace, "qwer"), "qwer|asdf|Expected: 'qwer' Actual: 'asdf' (Should be equal)")
+	pass(t, so(" asdf\t\n", ShouldEqualTrimSpace, "asdf"))
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/time.go b/vendor/src/github.com/smartystreets/assertions/time.go
index 7e05026143f..7e05026143f 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/time.go
+++ b/vendor/src/github.com/smartystreets/assertions/time.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/time_test.go b/vendor/src/github.com/smartystreets/assertions/time_test.go
index f9dda8f8f34..f9dda8f8f34 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/time_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/time_test.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/type.go b/vendor/src/github.com/smartystreets/assertions/type.go
index 3fc00f68cd0..3fc00f68cd0 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/type.go
+++ b/vendor/src/github.com/smartystreets/assertions/type.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/type_test.go b/vendor/src/github.com/smartystreets/assertions/type_test.go
index 4b8d1984670..4b8d1984670 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/type_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/type_test.go
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/utilities_for_test.go b/vendor/src/github.com/smartystreets/assertions/utilities_for_test.go
index 7acfdc5ae93..7243ebcb937 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/utilities_for_test.go
+++ b/vendor/src/github.com/smartystreets/assertions/utilities_for_test.go
@@ -38,10 +38,6 @@ func format(message string) string {
 	return message
 }
 
-func so(actual interface{}, assert func(interface{}, ...interface{}) string, expected ...interface{}) string {
-	return assert(actual, expected...)
-}
-
 type Thing1 struct {
 	a string
 }
@@ -57,6 +53,11 @@ type Thing struct{}
 
 func (self *Thing) Hi() {}
 
+type IntAlias int
+type StringAlias string
+type StringSliceAlias []string
+type StringStringMapAlias map[string]string
+
 /******** FakeSerialzier ********/
 
 type fakeSerializer struct{}
@@ -65,6 +66,10 @@ func (self *fakeSerializer) serialize(expected, actual interface{}, message stri
 	return fmt.Sprintf("%v|%v|%s", expected, actual, message)
 }
 
+func (self *fakeSerializer) serializeDetailed(expected, actual interface{}, message string) string {
+	return fmt.Sprintf("%v|%v|%s", expected, actual, message)
+}
+
 func newFakeSerializer() *fakeSerializer {
 	return new(fakeSerializer)
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/.gitignore b/vendor/src/github.com/smartystreets/goconvey/.gitignore
index 9e0d999d129..c9205c5335a 100644
--- a/vendor/src/github.com/smartystreets/goconvey/.gitignore
+++ b/vendor/src/github.com/smartystreets/goconvey/.gitignore
@@ -1,4 +1,5 @@
 .DS_Store
 Thumbs.db
 examples/output.json
-web/client/reports/
\ No newline at end of file
+web/client/reports/
+/.idea
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/.travis.yml b/vendor/src/github.com/smartystreets/goconvey/.travis.yml
index ff2c9a3e373..a5124b0491b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/.travis.yml
+++ b/vendor/src/github.com/smartystreets/goconvey/.travis.yml
@@ -1,9 +1,14 @@
 language: go
 
 go:
-  - 1.1
   - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
 
 install:
-  - go get github.com/jacobsa/ogletest
-  - go get github.com/jacobsa/oglematchers
+  - go get -t ./...
+
+script: go test -short -v ./...
+
+sudo: false
diff --git a/vendor/src/github.com/smartystreets/goconvey/CONTRIBUTING.md b/vendor/src/github.com/smartystreets/goconvey/CONTRIBUTING.md
new file mode 100644
index 00000000000..9c9053b83ad
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/CONTRIBUTING.md
@@ -0,0 +1,22 @@
+# Subject: GoConvey maintainers wanted
+
+We'd like to open the project up to additional maintainers who want to move the project forward in a meaningful way.
+
+We've spent significant time at SmartyStreets building GoConvey and it has perfectly met (and exceeded) all of our initial design specifications. We've used it to great effect. Being so well-matched to our development workflows at SmartyStreets, we haven't had a need to hack on it lately. This had been frustrating to many in the community who have ideas for the project and would like to see new features released (and some old bugs fixed). The release of Go 1.5 and the new vendoring experiment has been a source of confusion and hassle for those who have already upgraded and find that GoConvey needs to be brought up to speed.
+
+Comment below if you're interested. Preference will be given to those that have already contributed to the project. Checkout the issues listing if you need some ideas for contributing.
+
+GoConvey is a popular 2-pronged, open-source github project (1,600+ stargazers, 100+ forks):
+
+- A package you import in your test code that allows you to write BDD-style tests.
+- An executable that runs a local web server which displays auto-updating test results in a web browser.
+
+----
+
+- http://goconvey.co/
+- https://github.com/smartystreets/goconvey
+- https://github.com/smartystreets/goconvey/wiki
+
+_I should mention that the [assertions package](https://github.com/smartystreets/assertions) imported by the convey package is used by other projects at SmartyStreets and so we will be continuing to maintain that project internally._
+
+We hope to hear from you soon. Thanks!
diff --git a/vendor/src/github.com/smartystreets/goconvey/LICENSE.md b/vendor/src/github.com/smartystreets/goconvey/LICENSE.md
index 486fe9273ca..5bc993c93c9 100644
--- a/vendor/src/github.com/smartystreets/goconvey/LICENSE.md
+++ b/vendor/src/github.com/smartystreets/goconvey/LICENSE.md
@@ -1,21 +1,21 @@
-Copyright (c) 2013 SmartyStreets, LLC
+Copyright (c) 2014 SmartyStreets, LLC
 
-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 
+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 
+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 
+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.
 
 NOTE: Various optional and subordinate components carry their own licensing
diff --git a/vendor/src/github.com/smartystreets/goconvey/README.md b/vendor/src/github.com/smartystreets/goconvey/README.md
index 334293f5db5..a07ce5a6eb2 100644
--- a/vendor/src/github.com/smartystreets/goconvey/README.md
+++ b/vendor/src/github.com/smartystreets/goconvey/README.md
@@ -1,10 +1,11 @@
-GoConvey is awesome Go testing 
+GoConvey is awesome Go testing
 ==============================
 
-[![Build Status](https://travis-ci.org/smartystreets/goconvey.png)](https://travis-ci.org/smartystreets/goconvey) [![GoDoc](https://godoc.org/github.com/smartystreets/goconvey?status.png)](http://godoc.org/github.com/smartystreets/goconvey)
+[![Build Status](https://travis-ci.org/smartystreets/goconvey.png)](https://travis-ci.org/smartystreets/goconvey)
+[![GoDoc](https://godoc.org/github.com/smartystreets/goconvey?status.svg)](http://godoc.org/github.com/smartystreets/goconvey)
 
 
-Welcome to GoConvey, a yummy Go testing tool for gophers. Works with `go test`. Use it in the terminal or browser according your viewing pleasure. **[View full feature tour.](http://goconvey.co)**
+Welcome to GoConvey, a yummy Go testing tool for gophers. Works with `go test`. Use it in the terminal or browser according to your viewing pleasure. **[View full feature tour.](http://goconvey.co)**
 
 **Features:**
 
@@ -17,6 +18,9 @@ Welcome to GoConvey, a yummy Go testing tool for gophers. Works with `go test`.
 - Desktop notifications (optional)
 - Immediately open problem lines in [Sublime Text](http://www.sublimetext.com) ([some assembly required](https://github.com/asuth/subl-handler))
 
+
+You can ask questions about how to use GoConvey on [StackOverflow](http://stackoverflow.com/questions/ask?tags=goconvey,go&title=GoConvey%3A%20). Use the tags `go` and `goconvey`.
+
 **Menu:**
 
 - [Installation](#installation)
@@ -31,17 +35,7 @@ Welcome to GoConvey, a yummy Go testing tool for gophers. Works with `go test`.
 Installation
 ------------
 
-#### Go Version 1.2+
-
-	$ go get -t github.com/smartystreets/goconvey
-
-The `-t` flag above ensures that all test dependencies for goconvey are downloaded.
-
-#### Go - Before Version 1.2
-
-    $ go get github.com/smartystreets/goconvey
-    $ go get github.com/jacobsa/oglematchers
-
+	$ go get github.com/smartystreets/goconvey
 
 [Quick start](https://github.com/smartystreets/goconvey/wiki#get-going-in-25-seconds)
 -----------
@@ -49,6 +43,13 @@ The `-t` flag above ensures that all test dependencies for goconvey are download
 Make a test, for example:
 
 ```go
+package package_name
+
+import (
+    "testing"
+    . "github.com/smartystreets/goconvey/convey"
+)
+
 func TestSpec(t *testing.T) {
 
 	// Only pass t into top-level Convey calls
@@ -73,11 +74,20 @@ Start up the GoConvey web server at your project's path:
 
 	$ $GOPATH/bin/goconvey
 
-Then open your browser to:
+Then watch the test results display in your browser at:
 
 	http://localhost:8080
 
-There you have it. As long as GoConvey is running, test results will automatically update in your browser window. The design is responsive, so you can squish the browser real tight if you need to put it beside your code.
+
+If the browser doesn't open automatically, please click [http://localhost:8080](http://localhost:8080) to open manually.
+
+There you have it.
+![](http://d79i1fxsrar4t.cloudfront.net/goconvey.co/gc-1-dark.png)
+As long as GoConvey is running, test results will automatically update in your browser window.
+
+![](http://d79i1fxsrar4t.cloudfront.net/goconvey.co/gc-5-dark.png)
+The design is responsive, so you can squish the browser real tight if you need to put it beside your code.
+
 
 The [web UI](https://github.com/smartystreets/goconvey/wiki/Web-UI) supports traditional Go tests, so use it even if you're not using GoConvey tests.
 
@@ -94,43 +104,23 @@ Or if you want the output to include the story:
     $ go test -v
 
 
-
-
-
 [Documentation](https://github.com/smartystreets/goconvey/wiki)
+
 -----------
 
-Check out the 
+Check out the
 
 - [GoConvey wiki](https://github.com/smartystreets/goconvey/wiki),
 - [![GoDoc](https://godoc.org/github.com/smartystreets/goconvey?status.png)](http://godoc.org/github.com/smartystreets/goconvey)
 - and the *_test.go files scattered throughout this project.
 
-
-
-
-
 [Screenshots](http://goconvey.co)
+
 -----------
 
 For web UI and terminal screenshots, check out [the full feature tour](http://goconvey.co).
 
 
-
-Contributions
--------------
-
-You can get started on the [guidelines page](https://github.com/smartystreets/goconvey/wiki/For-Contributors) found in our wiki.
-
-
-
-
-Contributors (Thanks!)
 ----------------------
 
-We appreciate everyone's contributions to the project! Please see the [contributor graphs](https://github.com/smartystreets/goconvey/graphs/contributors) provided by GitHub for all the credits.
-
-GoConvey is brought to you by [SmartyStreets](https://github.com/smartystreets); in particular:
-
- - [Michael Whatcott](https://github.com/mdwhatcott)
- - [Matt Holt](https://github.com/mholt)
+GoConvey is brought to you by [SmartyStreets](https://github.com/smartystreets) and [several contributors](https://github.com/smartystreets/goconvey/graphs/contributors) (Thanks!).
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions.go b/vendor/src/github.com/smartystreets/goconvey/convey/assertions.go
index ee5433e3b88..1e87b826dff 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/assertions.go
@@ -1,6 +1,6 @@
 package convey
 
-import "github.com/smartystreets/goconvey/convey/assertions"
+import "github.com/smartystreets/assertions"
 
 var (
 	ShouldEqual          = assertions.ShouldEqual
@@ -23,13 +23,18 @@ var (
 	ShouldBeLessThanOrEqualTo    = assertions.ShouldBeLessThanOrEqualTo
 	ShouldBeBetween              = assertions.ShouldBeBetween
 	ShouldNotBeBetween           = assertions.ShouldNotBeBetween
+	ShouldBeBetweenOrEqual       = assertions.ShouldBeBetweenOrEqual
+	ShouldNotBeBetweenOrEqual    = assertions.ShouldNotBeBetweenOrEqual
 
-	ShouldContain    = assertions.ShouldContain
-	ShouldNotContain = assertions.ShouldNotContain
-	ShouldBeIn       = assertions.ShouldBeIn
-	ShouldNotBeIn    = assertions.ShouldNotBeIn
-	ShouldBeEmpty    = assertions.ShouldBeEmpty
-	ShouldNotBeEmpty = assertions.ShouldNotBeEmpty
+	ShouldContain       = assertions.ShouldContain
+	ShouldNotContain    = assertions.ShouldNotContain
+	ShouldContainKey    = assertions.ShouldContainKey
+	ShouldNotContainKey = assertions.ShouldNotContainKey
+	ShouldBeIn          = assertions.ShouldBeIn
+	ShouldNotBeIn       = assertions.ShouldNotBeIn
+	ShouldBeEmpty       = assertions.ShouldBeEmpty
+	ShouldNotBeEmpty    = assertions.ShouldNotBeEmpty
+	ShouldHaveLength    = assertions.ShouldHaveLength
 
 	ShouldStartWith           = assertions.ShouldStartWith
 	ShouldNotStartWith        = assertions.ShouldNotStartWith
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/doc.go b/vendor/src/github.com/smartystreets/goconvey/convey/assertions/doc.go
deleted file mode 100644
index fe52b0853b5..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/doc.go
+++ /dev/null
@@ -1,3 +0,0 @@
-// Package assertions contains the implementations for all assertions which
-// are referenced in the convey package for use with the So(...) method.
-package assertions
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/init.go b/vendor/src/github.com/smartystreets/goconvey/convey/assertions/init.go
deleted file mode 100644
index 5efdf3f0f4d..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/init.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package assertions
-
-var serializer Serializer
-
-func init() {
-	serializer = newSerializer()
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/serializer.go b/vendor/src/github.com/smartystreets/goconvey/convey/assertions/serializer.go
deleted file mode 100644
index 81b66ce11cf..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/assertions/serializer.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package assertions
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/smartystreets/goconvey/convey/reporting"
-)
-
-type Serializer interface {
-	serialize(expected, actual interface{}, message string) string
-}
-
-type failureSerializer struct{}
-
-func (self *failureSerializer) serialize(expected, actual interface{}, message string) string {
-	view := reporting.FailureView{
-		Message:  message,
-		Expected: fmt.Sprintf("%+v", expected),
-		Actual:   fmt.Sprintf("%+v", actual),
-	}
-	serialized, err := json.Marshal(view)
-	if err != nil {
-		return message
-	}
-	return string(serialized)
-}
-
-func newSerializer() *failureSerializer {
-	return &failureSerializer{}
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/context.go b/vendor/src/github.com/smartystreets/goconvey/convey/context.go
index 9fea2897f14..2c75c2d7b1b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/context.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/context.go
@@ -1,152 +1,272 @@
-// Oh the stack trace scanning!
-// The density of comments in this file is evidence that
-// the code doesn't exactly explain itself. Tread with care...
 package convey
 
 import (
-	"errors"
 	"fmt"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
+
+	"github.com/jtolds/gls"
+	"github.com/smartystreets/goconvey/convey/reporting"
 )
 
-// suiteContext magically handles all coordination of reporter, runners as they handle calls
-// to Convey, So, and the like. It does this via runtime call stack inspection, making sure
-// that each test function has its own runner, and routes all live registrations
-// to the appropriate runner.
-type suiteContext struct {
-	lock    sync.Mutex
-	runners map[string]*runner // key: testName;
+type conveyErr struct {
+	fmt    string
+	params []interface{}
+}
 
-	// stores a correlation to the actual runner for outside-of-stack scenaios
-	locations map[string]string // key: file:line; value: testName (key to runners)
+func (e *conveyErr) Error() string {
+	return fmt.Sprintf(e.fmt, e.params...)
 }
 
-func (self *suiteContext) Run(entry *registration) {
-	if self.current() != nil {
-		panic(extraGoTest)
-	}
+func conveyPanic(fmt string, params ...interface{}) {
+	panic(&conveyErr{fmt, params})
+}
 
-	reporter := buildReporter()
-	runner := newRunner()
-	runner.UpgradeReporter(reporter)
+const (
+	missingGoTest = `Top-level calls to Convey(...) need a reference to the *testing.T.
+		Hint: Convey("description here", t, func() { /* notice that the second argument was the *testing.T (t)! */ }) `
+	extraGoTest    = `Only the top-level call to Convey(...) needs a reference to the *testing.T.`
+	noStackContext = "Convey operation made without context on goroutine stack.\n" +
+		"Hint: Perhaps you meant to use `Convey(..., func(c C){...})` ?"
+	differentConveySituations = "Different set of Convey statements on subsequent pass!\nDid not expect %#v."
+	multipleIdenticalConvey   = "Multiple convey suites with identical names: %#v"
+)
 
-	testName, location, _ := suiteAnchor()
+const (
+	failureHalt = "___FAILURE_HALT___"
 
-	self.lock.Lock()
-	self.locations[location] = testName
-	self.runners[testName] = runner
-	self.lock.Unlock()
+	nodeKey = "node"
+)
 
-	runner.Begin(entry)
-	runner.Run()
+///////////////////////////////// Stack Context /////////////////////////////////
 
-	self.lock.Lock()
-	delete(self.locations, location)
-	delete(self.runners, testName)
-	self.lock.Unlock()
+func getCurrentContext() *context {
+	ctx, ok := ctxMgr.GetValue(nodeKey)
+	if ok {
+		return ctx.(*context)
+	}
+	return nil
 }
 
-func (self *suiteContext) Current() *runner {
-	if runner := self.current(); runner != nil {
-		return runner
+func mustGetCurrentContext() *context {
+	ctx := getCurrentContext()
+	if ctx == nil {
+		conveyPanic(noStackContext)
 	}
-	panic(missingGoTest)
+	return ctx
 }
-func (self *suiteContext) current() *runner {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-	testName, _, err := suiteAnchor()
 
-	if err != nil {
-		testName = correlate(self.locations)
-	}
+//////////////////////////////////// Context ////////////////////////////////////
 
-	return self.runners[testName]
-}
+// context magically handles all coordination of Convey's and So assertions.
+//
+// It is tracked on the stack as goroutine-local-storage with the gls package,
+// or explicitly if the user decides to call convey like:
+//
+//   Convey(..., func(c C) {
+//     c.So(...)
+//   })
+//
+// This implements the `C` interface.
+type context struct {
+	reporter reporting.Reporter
+
+	children map[string]*context
+
+	resets []func()
 
-func newSuiteContext() *suiteContext {
-	self := new(suiteContext)
-	self.locations = make(map[string]string)
-	self.runners = make(map[string]*runner)
-	return self
+	executedOnce   bool
+	expectChildRun *bool
+	complete       bool
+
+	focus       bool
+	failureMode FailureMode
 }
 
-//////////////////// Helper Functions ///////////////////////
+// rootConvey is the main entry point to a test suite. This is called when
+// there's no context in the stack already, and items must contain a `t` object,
+// or this panics.
+func rootConvey(items ...interface{}) {
+	entry := discover(items)
 
-// suiteAnchor returns the enclosing test function name (including package) and the
-// file:line combination of the top-level Convey. It does this by traversing the
-// call stack in reverse, looking for the go testing harnass call ("testing.tRunner")
-// and then grabs the very next entry.
-func suiteAnchor() (testName, location string, err error) {
-	callers := runtime.Callers(0, callStack)
+	if entry.Test == nil {
+		conveyPanic(missingGoTest)
+	}
 
-	for y := callers; y > 0; y-- {
-		callerId, file, conveyLine, found := runtime.Caller(y)
-		if !found {
-			continue
-		}
+	expectChildRun := true
+	ctx := &context{
+		reporter: buildReporter(),
 
-		if name := runtime.FuncForPC(callerId).Name(); name != goTestHarness {
-			continue
+		children: make(map[string]*context),
+
+		expectChildRun: &expectChildRun,
+
+		focus:       entry.Focus,
+		failureMode: defaultFailureMode.combine(entry.FailMode),
+	}
+	ctxMgr.SetValues(gls.Values{nodeKey: ctx}, func() {
+		ctx.reporter.BeginStory(reporting.NewStoryReport(entry.Test))
+		defer ctx.reporter.EndStory()
+
+		for ctx.shouldVisit() {
+			ctx.conveyInner(entry.Situation, entry.Func)
+			expectChildRun = true
 		}
+	})
+}
+
+//////////////////////////////////// Methods ////////////////////////////////////
 
-		callerId, file, conveyLine, _ = runtime.Caller(y - 1)
-		testName = runtime.FuncForPC(callerId).Name()
-		location = fmt.Sprintf("%s:%d", file, conveyLine)
+func (ctx *context) SkipConvey(items ...interface{}) {
+	ctx.Convey(items, skipConvey)
+}
+
+func (ctx *context) FocusConvey(items ...interface{}) {
+	ctx.Convey(items, focusConvey)
+}
+
+func (ctx *context) Convey(items ...interface{}) {
+	entry := discover(items)
+
+	// we're a branch, or leaf (on the wind)
+	if entry.Test != nil {
+		conveyPanic(extraGoTest)
+	}
+	if ctx.focus && !entry.Focus {
 		return
 	}
-	return "", "", errors.New("Can't resolve test method name! Are you calling Convey() from a `*_test.go` file and a `Test*` method (because you should be)?")
-}
-
-// correlate links the current stack with the appropriate
-// top-level Convey by comparing line numbers in its own stack trace
-// with the registered file:line combo. It's come to this.
-func correlate(locations map[string]string) (testName string) {
-	file, line := resolveTestFileAndLine()
-	closest := -1
-	for location, registeredTestName := range locations {
-		parts := strings.Split(location, ":")
-		locationFile := parts[0]
-		if locationFile != file {
-			continue
-		}
 
-		locationLine, err := strconv.Atoi(parts[1])
-		if err != nil || locationLine < line {
-			continue
+	var inner_ctx *context
+	if ctx.executedOnce {
+		var ok bool
+		inner_ctx, ok = ctx.children[entry.Situation]
+		if !ok {
+			conveyPanic(differentConveySituations, entry.Situation)
 		}
+	} else {
+		if _, ok := ctx.children[entry.Situation]; ok {
+			conveyPanic(multipleIdenticalConvey, entry.Situation)
+		}
+		inner_ctx = &context{
+			reporter: ctx.reporter,
+
+			children: make(map[string]*context),
 
-		if closest == -1 || locationLine < closest {
-			closest = locationLine
-			testName = registeredTestName
+			expectChildRun: ctx.expectChildRun,
+
+			focus:       entry.Focus,
+			failureMode: ctx.failureMode.combine(entry.FailMode),
 		}
+		ctx.children[entry.Situation] = inner_ctx
+	}
+
+	if inner_ctx.shouldVisit() {
+		ctxMgr.SetValues(gls.Values{nodeKey: inner_ctx}, func() {
+			inner_ctx.conveyInner(entry.Situation, entry.Func)
+		})
+	}
+}
+
+func (ctx *context) SkipSo(stuff ...interface{}) {
+	ctx.assertionReport(reporting.NewSkipReport())
+}
+
+func (ctx *context) So(actual interface{}, assert assertion, expected ...interface{}) {
+	if result := assert(actual, expected...); result == assertionSuccess {
+		ctx.assertionReport(reporting.NewSuccessReport())
+	} else {
+		ctx.assertionReport(reporting.NewFailureReport(result))
 	}
-	return
 }
 
-// resolveTestFileAndLine is used as a last-ditch effort to correlate an
-// assertion with the right executor and runner.
-func resolveTestFileAndLine() (file string, line int) {
-	callers := runtime.Callers(0, callStack)
-	var found bool
+func (ctx *context) Reset(action func()) {
+	/* TODO: Failure mode configuration */
+	ctx.resets = append(ctx.resets, action)
+}
 
-	for y := callers; y > 0; y-- {
-		_, file, line, found = runtime.Caller(y)
-		if !found {
-			continue
+func (ctx *context) Print(items ...interface{}) (int, error) {
+	fmt.Fprint(ctx.reporter, items...)
+	return fmt.Print(items...)
+}
+
+func (ctx *context) Println(items ...interface{}) (int, error) {
+	fmt.Fprintln(ctx.reporter, items...)
+	return fmt.Println(items...)
+}
+
+func (ctx *context) Printf(format string, items ...interface{}) (int, error) {
+	fmt.Fprintf(ctx.reporter, format, items...)
+	return fmt.Printf(format, items...)
+}
+
+//////////////////////////////////// Private ////////////////////////////////////
+
+// shouldVisit returns true iff we should traverse down into a Convey. Note
+// that just because we don't traverse a Convey this time, doesn't mean that
+// we may not traverse it on a subsequent pass.
+func (c *context) shouldVisit() bool {
+	return !c.complete && *c.expectChildRun
+}
+
+// conveyInner is the function which actually executes the user's anonymous test
+// function body. At this point, Convey or RootConvey has decided that this
+// function should actually run.
+func (ctx *context) conveyInner(situation string, f func(C)) {
+	// Record/Reset state for next time.
+	defer func() {
+		ctx.executedOnce = true
+
+		// This is only needed at the leaves, but there's no harm in also setting it
+		// when returning from branch Convey's
+		*ctx.expectChildRun = false
+	}()
+
+	// Set up+tear down our scope for the reporter
+	ctx.reporter.Enter(reporting.NewScopeReport(situation))
+	defer ctx.reporter.Exit()
+
+	// Recover from any panics in f, and assign the `complete` status for this
+	// node of the tree.
+	defer func() {
+		ctx.complete = true
+		if problem := recover(); problem != nil {
+			if problem, ok := problem.(*conveyErr); ok {
+				panic(problem)
+			}
+			if problem != failureHalt {
+				ctx.reporter.Report(reporting.NewErrorReport(problem))
+			}
+		} else {
+			for _, child := range ctx.children {
+				if !child.complete {
+					ctx.complete = false
+					return
+				}
+			}
 		}
+	}()
 
-		if strings.HasSuffix(file, "_test.go") {
-			return
+	// Resets are registered as the `f` function executes, so nil them here.
+	// All resets are run in registration order (FIFO).
+	ctx.resets = []func(){}
+	defer func() {
+		for _, r := range ctx.resets {
+			// panics handled by the previous defer
+			r()
 		}
+	}()
+
+	if f == nil {
+		// if f is nil, this was either a Convey(..., nil), or a SkipConvey
+		ctx.reporter.Report(reporting.NewSkipReport())
+	} else {
+		f(ctx)
 	}
-	return "", 0
 }
 
-const maxStackDepth = 100               // This had better be enough...
-const goTestHarness = "testing.tRunner" // I hope this doesn't change...
-
-var callStack []uintptr = make([]uintptr, maxStackDepth, maxStackDepth)
+// assertionReport is a helper for So and SkipSo which makes the report and
+// then possibly panics, depending on the current context's failureMode.
+func (ctx *context) assertionReport(r *reporting.AssertionResult) {
+	ctx.reporter.Report(r)
+	if r.Failure != "" && ctx.failureMode == FailureHalts {
+		panic(failureHalt)
+	}
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/convey.goconvey b/vendor/src/github.com/smartystreets/goconvey/convey/convey.goconvey
new file mode 100644
index 00000000000..a2d9327dc91
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/convey.goconvey
@@ -0,0 +1,4 @@
+#ignore
+-timeout=1s
+#-covermode=count
+#-coverpkg=github.com/smartystreets/goconvey/convey,github.com/smartystreets/goconvey/convey/gotest,github.com/smartystreets/goconvey/convey/reporting
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/discovery.go b/vendor/src/github.com/smartystreets/goconvey/convey/discovery.go
index 4696c998404..eb8d4cb2cee 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/discovery.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/discovery.go
@@ -1,54 +1,100 @@
 package convey
 
-func discover(items []interface{}) *registration {
-	ensureEnough(items)
+type actionSpecifier uint8
 
-	name := parseName(items)
-	test := parseGoTest(items)
-	action := parseAction(items, test)
+const (
+	noSpecifier actionSpecifier = iota
+	skipConvey
+	focusConvey
+)
 
-	return newRegistration(name, action, test)
+type suite struct {
+	Situation string
+	Test      t
+	Focus     bool
+	Func      func(C) // nil means skipped
+	FailMode  FailureMode
 }
-func ensureEnough(items []interface{}) {
-	if len(items) < 2 {
-		panic(parseError)
+
+func newSuite(situation string, failureMode FailureMode, f func(C), test t, specifier actionSpecifier) *suite {
+	ret := &suite{
+		Situation: situation,
+		Test:      test,
+		Func:      f,
+		FailMode:  failureMode,
+	}
+	switch specifier {
+	case skipConvey:
+		ret.Func = nil
+	case focusConvey:
+		ret.Focus = true
 	}
+	return ret
 }
-func parseName(items []interface{}) string {
-	if name, parsed := items[0].(string); parsed {
-		return name
+
+func discover(items []interface{}) *suite {
+	name, items := parseName(items)
+	test, items := parseGoTest(items)
+	failure, items := parseFailureMode(items)
+	action, items := parseAction(items)
+	specifier, items := parseSpecifier(items)
+
+	if len(items) != 0 {
+		conveyPanic(parseError)
 	}
-	panic(parseError)
+
+	return newSuite(name, failure, action, test, specifier)
 }
-func parseGoTest(items []interface{}) t {
-	if test, parsed := items[1].(t); parsed {
-		return test
+func item(items []interface{}) interface{} {
+	if len(items) == 0 {
+		conveyPanic(parseError)
 	}
-	return nil
+	return items[0]
 }
-func parseAction(items []interface{}, test t) *action {
-	var index = 1
-	var failure = FailureInherits
-	if test != nil {
-		index = 2
+func parseName(items []interface{}) (string, []interface{}) {
+	if name, parsed := item(items).(string); parsed {
+		return name, items[1:]
 	}
-
-	if mode, parsed := items[index].(FailureMode); parsed {
-		failure = mode
-		index += 1
+	conveyPanic(parseError)
+	panic("never get here")
+}
+func parseGoTest(items []interface{}) (t, []interface{}) {
+	if test, parsed := item(items).(t); parsed {
+		return test, items[1:]
 	}
-
-	if action, parsed := items[index].(func()); parsed {
-		return newAction(action, failure)
+	return nil, items
+}
+func parseFailureMode(items []interface{}) (FailureMode, []interface{}) {
+	if mode, parsed := item(items).(FailureMode); parsed {
+		return mode, items[1:]
+	}
+	return FailureInherits, items
+}
+func parseAction(items []interface{}) (func(C), []interface{}) {
+	switch x := item(items).(type) {
+	case nil:
+		return nil, items[1:]
+	case func(C):
+		return x, items[1:]
+	case func():
+		return func(C) { x() }, items[1:]
+	}
+	conveyPanic(parseError)
+	panic("never get here")
+}
+func parseSpecifier(items []interface{}) (actionSpecifier, []interface{}) {
+	if len(items) == 0 {
+		return noSpecifier, items
 	}
-	if items[index] == nil {
-		return newSkippedAction(skipReport, failure)
+	if spec, ok := items[0].(actionSpecifier); ok {
+		return spec, items[1:]
 	}
-	panic(parseError)
+	conveyPanic(parseError)
+	panic("never get here")
 }
 
 // This interface allows us to pass the *testing.T struct
-// throughout the internals of this tool without ever
+// throughout the internals of this package without ever
 // having to import the "testing" package.
 type t interface {
 	Fail()
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/doc.go b/vendor/src/github.com/smartystreets/goconvey/convey/doc.go
index 7b860a8ab17..2562ce4c284 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/doc.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/doc.go
@@ -3,53 +3,66 @@
 // packages from this project as they serve internal purposes.
 package convey
 
-import (
-	"fmt"
+import "github.com/smartystreets/goconvey/convey/reporting"
 
-	"github.com/smartystreets/goconvey/convey/reporting"
-)
+////////////////////////////////// suite //////////////////////////////////
 
-// FailureMode is a type which determines how the So() blocks should fail
-// if their assertion fails. See constants further down for acceptable values
-type FailureMode string
+// C is the Convey context which you can optionally obtain in your action
+// by calling Convey like:
+//
+//   Convey(..., func(c C) {
+//     ...
+//   })
+//
+// See the documentation on Convey for more details.
+//
+// All methods in this context behave identically to the global functions of the
+// same name in this package.
+type C interface {
+	Convey(items ...interface{})
+	SkipConvey(items ...interface{})
+	FocusConvey(items ...interface{})
 
-const (
-	// FailureContinues is a failure mode which prevents failing
-	// So()-assertions from halting Convey-block execution, instead
-	// allowing the test to continue past failing So()-assertions.
-	FailureContinues FailureMode = "continue"
-	// FailureInherits is the default setting for failure-mode, it will
-	// default to the failure-mode of the parent block.
-	// The top-level Convey()-block has the default of FailureHalts.
-	FailureInherits FailureMode = "inherits"
-	// FailureHalts is the default setting for a top-level Convey()-block
-	// and will cause all failing So()-assertions to halt further execution
-	// in that test-arm and continue on to the next arm.
-	FailureHalts FailureMode = "halt"
-)
+	So(actual interface{}, assert assertion, expected ...interface{})
+	SkipSo(stuff ...interface{})
+
+	Reset(action func())
+
+	Println(items ...interface{}) (int, error)
+	Print(items ...interface{}) (int, error)
+	Printf(format string, items ...interface{}) (int, error)
+}
 
-// Convey is the method intended for use when declaring the scopes
-// of a specification. Each scope has a description and a func()
-// which may contain other calls to Convey(), Reset() or Should-style
-// assertions. Convey calls can be nested as far as you see fit.
+// Convey is the method intended for use when declaring the scopes of
+// a specification. Each scope has a description and a func() which may contain
+// other calls to Convey(), Reset() or Should-style assertions. Convey calls can
+// be nested as far as you see fit.
 //
 // IMPORTANT NOTE: The top-level Convey() within a Test method
 // must conform to the following signature:
 //
 //     Convey(description string, t *testing.T, action func())
 //
-// All other calls should like like this (no need to pass in *testing.T):
+// All other calls should look like this (no need to pass in *testing.T):
 //
 //     Convey(description string, action func())
 //
-// Don't worry, the goconvey will panic if you get it wrong so you can fix it.
+// Don't worry, goconvey will panic if you get it wrong so you can fix it.
+//
+// Additionally, you may explicitly obtain access to the Convey context by doing:
+//
+//     Convey(description string, action func(c C))
 //
-// All Convey()-blocks also take an optional parameter of FailureMode which
-// sets how goconvey should treat failures for So()-assertions in the block and
+// You may need to do this if you want to pass the context through to a
+// goroutine, or to close over the context in a handler to a library which
+// calls your handler in a goroutine (httptest comes to mind).
+//
+// All Convey()-blocks also accept an optional parameter of FailureMode which sets
+// how goconvey should treat failures for So()-assertions in the block and
 // nested blocks. See the constants in this file for the available options.
 //
 // By default it will inherit from its parent block and the top-level blocks
-// start with setting of FailureHalts.
+// default to the FailureHalts setting.
 //
 // This parameter is inserted before the block itself:
 //
@@ -58,17 +71,18 @@ const (
 //
 // See the examples package for, well, examples.
 func Convey(items ...interface{}) {
-	entry := discover(items)
-	register(entry)
+	if ctx := getCurrentContext(); ctx == nil {
+		rootConvey(items...)
+	} else {
+		ctx.Convey(items...)
+	}
 }
 
 // SkipConvey is analagous to Convey except that the scope is not executed
 // (which means that child scopes defined within this scope are not run either).
 // The reporter will be notified that this step was skipped.
 func SkipConvey(items ...interface{}) {
-	entry := discover(items)
-	entry.action = newSkippedAction(skipReport, entry.action.failureMode)
-	register(entry)
+	Convey(append(items, skipConvey)...)
 }
 
 // FocusConvey is has the inverse effect of SkipConvey. If the top-level
@@ -79,76 +93,126 @@ func SkipConvey(items ...interface{}) {
 // without swaths of `SkipConvey` calls, just a targeted chain of calls
 // to FocusConvey.
 func FocusConvey(items ...interface{}) {
-	entry := discover(items)
-	entry.Focus = true
-	register(entry)
-}
-
-func register(entry *registration) {
-	if entry.IsTopLevel() {
-		suites.Run(entry)
-	} else {
-		suites.Current().Register(entry)
-	}
-}
-
-func skipReport() {
-	suites.Current().Report(reporting.NewSkipReport())
+	Convey(append(items, focusConvey)...)
 }
 
 // Reset registers a cleanup function to be run after each Convey()
 // in the same scope. See the examples package for a simple use case.
 func Reset(action func()) {
-	/* TODO: Failure mode configuration */
-	suites.Current().RegisterReset(newAction(action, FailureInherits))
+	mustGetCurrentContext().Reset(action)
 }
 
+/////////////////////////////////// Assertions ///////////////////////////////////
+
+// assertion is an alias for a function with a signature that the convey.So()
+// method can handle. Any future or custom assertions should conform to this
+// method signature. The return value should be an empty string if the assertion
+// passes and a well-formed failure message if not.
+type assertion func(actual interface{}, expected ...interface{}) string
+
+const assertionSuccess = ""
+
 // So is the means by which assertions are made against the system under test.
 // The majority of exported names in the assertions package begin with the word
 // 'Should' and describe how the first argument (actual) should compare with any
 // of the final (expected) arguments. How many final arguments are accepted
 // depends on the particular assertion that is passed in as the assert argument.
 // See the examples package for use cases and the assertions package for
-// documentation on specific assertion methods.
+// documentation on specific assertion methods. A failing assertion will
+// cause t.Fail() to be invoked--you should never call this method (or other
+// failure-inducing methods) in your test code. Leave that to GoConvey.
 func So(actual interface{}, assert assertion, expected ...interface{}) {
-	if result := assert(actual, expected...); result == assertionSuccess {
-		suites.Current().Report(reporting.NewSuccessReport())
-	} else {
-		suites.Current().Report(reporting.NewFailureReport(result))
-	}
+	mustGetCurrentContext().So(actual, assert, expected...)
 }
 
 // SkipSo is analagous to So except that the assertion that would have been passed
 // to So is not executed and the reporter is notified that the assertion was skipped.
 func SkipSo(stuff ...interface{}) {
-	skipReport()
+	mustGetCurrentContext().SkipSo()
+}
+
+// FailureMode is a type which determines how the So() blocks should fail
+// if their assertion fails. See constants further down for acceptable values
+type FailureMode string
+
+const (
+
+	// FailureContinues is a failure mode which prevents failing
+	// So()-assertions from halting Convey-block execution, instead
+	// allowing the test to continue past failing So()-assertions.
+	FailureContinues FailureMode = "continue"
+
+	// FailureHalts is the default setting for a top-level Convey()-block
+	// and will cause all failing So()-assertions to halt further execution
+	// in that test-arm and continue on to the next arm.
+	FailureHalts FailureMode = "halt"
+
+	// FailureInherits is the default setting for failure-mode, it will
+	// default to the failure-mode of the parent block. You should never
+	// need to specify this mode in your tests..
+	FailureInherits FailureMode = "inherits"
+)
+
+func (f FailureMode) combine(other FailureMode) FailureMode {
+	if other == FailureInherits {
+		return f
+	}
+	return other
 }
 
+var defaultFailureMode FailureMode = FailureHalts
+
+// SetDefaultFailureMode allows you to specify the default failure mode
+// for all Convey blocks. It is meant to be used in an init function to
+// allow the default mode to be changdd across all tests for an entire packgae
+// but it can be used anywhere.
+func SetDefaultFailureMode(mode FailureMode) {
+	if mode == FailureContinues || mode == FailureHalts {
+		defaultFailureMode = mode
+	} else {
+		panic("You may only use the constants named 'FailureContinues' and 'FailureHalts' as default failure modes.")
+	}
+}
+
+//////////////////////////////////// Print functions ////////////////////////////////////
+
 // Print is analogous to fmt.Print (and it even calls fmt.Print). It ensures that
 // output is aligned with the corresponding scopes in the web UI.
 func Print(items ...interface{}) (written int, err error) {
-	fmt.Fprint(suites.Current(), items...)
-	return fmt.Print(items...)
+	return mustGetCurrentContext().Print(items...)
 }
 
 // Print is analogous to fmt.Println (and it even calls fmt.Println). It ensures that
 // output is aligned with the corresponding scopes in the web UI.
 func Println(items ...interface{}) (written int, err error) {
-	fmt.Fprintln(suites.Current(), items...)
-	return fmt.Println(items...)
+	return mustGetCurrentContext().Println(items...)
 }
 
 // Print is analogous to fmt.Printf (and it even calls fmt.Printf). It ensures that
 // output is aligned with the corresponding scopes in the web UI.
 func Printf(format string, items ...interface{}) (written int, err error) {
-	fmt.Fprintf(suites.Current(), format, items...)
-	return fmt.Printf(format, items...)
+	return mustGetCurrentContext().Printf(format, items...)
 }
 
-// assertion is an alias for a function with a signature that the convey.So()
-// method can handle. Any future or custom assertions should conform to this
-// method signature. The return value should be an empty string if the assertion
-// passes and a well-formed failure message if not.
-type assertion func(actual interface{}, expected ...interface{}) string
+///////////////////////////////////////////////////////////////////////////////
 
-const assertionSuccess = ""
+// SuppressConsoleStatistics prevents automatic printing of console statistics.
+// Calling PrintConsoleStatistics explicitly will force printing of statistics.
+func SuppressConsoleStatistics() {
+	reporting.SuppressConsoleStatistics()
+}
+
+// ConsoleStatistics may be called at any time to print assertion statistics.
+// Generally, the best place to do this would be in a TestMain function,
+// after all tests have been run. Something like this:
+//
+// func TestMain(m *testing.M) {
+//     convey.SuppressConsoleStatistics()
+//     result := m.Run()
+//     convey.PrintConsoleStatistics()
+//     os.Exit(result)
+// }
+//
+func PrintConsoleStatistics() {
+	reporting.PrintConsoleStatistics()
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/gotest/doc_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/gotest/doc_test.go
new file mode 100644
index 00000000000..1b6406be99b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/gotest/doc_test.go
@@ -0,0 +1 @@
+package gotest
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/gotest/utils.go b/vendor/src/github.com/smartystreets/goconvey/convey/gotest/utils.go
index b370f1e4cd0..3a5c848a445 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/gotest/utils.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/gotest/utils.go
@@ -4,26 +4,17 @@
 package gotest
 
 import (
-	"fmt"
 	"runtime"
 	"strings"
 )
 
-func FormatExternalFileAndLine() string {
-	file, line, _ := ResolveExternalCaller()
-	if line == -1 {
-		return "<unknown caller!>" // panic?
-	}
-	return fmt.Sprintf("%s:%d", file, line)
-}
-
 func ResolveExternalCaller() (file string, line int, name string) {
 	var caller_id uintptr
 	callers := runtime.Callers(0, callStack)
 
 	for x := 0; x < callers; x++ {
 		caller_id, file, line, _ = runtime.Caller(x)
-		if strings.HasSuffix(file, "_test.go") {
+		if strings.HasSuffix(file, "_test.go") || strings.HasSuffix(file, "_tests.go") {
 			name = runtime.FuncForPC(caller_id).Name()
 			return
 		}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/init.go b/vendor/src/github.com/smartystreets/goconvey/convey/init.go
index 9d9783e9b7d..732b72142e0 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/init.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/init.go
@@ -4,13 +4,17 @@ import (
 	"flag"
 	"os"
 
+	"github.com/jtolds/gls"
+	"github.com/smartystreets/assertions"
 	"github.com/smartystreets/goconvey/convey/reporting"
 )
 
 func init() {
+	assertions.GoConveyMode(true)
+
 	declareFlags()
 
-	suites = newSuiteContext()
+	ctxMgr = gls.NewContextManager()
 }
 
 func declareFlags() {
@@ -30,14 +34,19 @@ func noStoryFlagProvided() bool {
 }
 
 func buildReporter() reporting.Reporter {
+	selectReporter := os.Getenv("GOCONVEY_REPORTER")
+
 	switch {
 	case testReporter != nil:
 		return testReporter
-	case json:
+	case json || selectReporter == "json":
 		return reporting.BuildJsonReporter()
-	case silent:
+	case silent || selectReporter == "silent":
 		return reporting.BuildSilentReporter()
-	case story:
+	case selectReporter == "dot":
+		// Story is turned on when verbose is set, so we need to check for dot reporter first.
+		return reporting.BuildDotReporter()
+	case story || selectReporter == "story":
 		return reporting.BuildStoryReporter()
 	default:
 		return reporting.BuildDotReporter()
@@ -45,7 +54,7 @@ func buildReporter() reporting.Reporter {
 }
 
 var (
-	suites *suiteContext
+	ctxMgr *gls.ContextManager
 
 	// only set by internal tests
 	testReporter reporting.Reporter
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/isolated_execution_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/isolated_execution_test.go
index 5926fcf237c..7e22b3caa53 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/isolated_execution_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/isolated_execution_test.go
@@ -1,9 +1,9 @@
 package convey
 
 import (
-	"time"
 	"strconv"
 	"testing"
+	"time"
 )
 
 func TestSingleScope(t *testing.T) {
@@ -92,6 +92,28 @@ func TestSingleScopeWithConveyAndNestedReset(t *testing.T) {
 	expectEqual(t, "1a", output)
 }
 
+func TestPanicingReset(t *testing.T) {
+	output := prepare()
+
+	Convey("1", t, func() {
+		output += "1"
+
+		Reset(func() {
+			panic("nooo")
+		})
+
+		Convey("runs since the reset hasn't yet", func() {
+			output += "a"
+		})
+
+		Convey("but this doesnt", func() {
+			output += "nope"
+		})
+	})
+
+	expectEqual(t, "1a", output)
+}
+
 func TestSingleScopeWithMultipleRegistrationsAndReset(t *testing.T) {
 	output := prepare()
 
@@ -154,14 +176,24 @@ func Test_Panic_AtHigherLevelScopePreventsChildScopesFromRunning(t *testing.T) {
 	output := prepare()
 
 	Convey("This step panics", t, func() {
-		Convey("this should NOT be executed", func() {
+		Convey("this happens, because the panic didn't happen yet", func() {
 			output += "1"
 		})
 
+		output += "a"
+
+		Convey("this should NOT be executed", func() {
+			output += "2"
+		})
+
+		output += "b"
+
 		panic("Hi")
+
+		output += "nope"
 	})
 
-	expectEqual(t, "", output)
+	expectEqual(t, "1ab", output)
 }
 
 func Test_Panic_InChildScopeDoes_NOT_PreventExecutionOfSiblingScopes(t *testing.T) {
@@ -721,6 +753,21 @@ func TestMultipleInvocationInheritance2(t *testing.T) {
 	expectEqual(t, "A1 A2 A3 B1 B2 A1 A2 A3 C1 C2 C3 ", output)
 }
 
+func TestSetDefaultFailureMode(t *testing.T) {
+	output := prepare()
+
+	SetDefaultFailureMode(FailureContinues) // the default is normally FailureHalts
+	defer SetDefaultFailureMode(FailureHalts)
+
+	Convey("A", t, func() {
+		output += "A1 "
+		So(true, ShouldBeFalse)
+		output += "A2 "
+	})
+
+	expectEqual(t, "A1 A2 ", output)
+}
+
 func prepare() string {
 	testReporter = newNilReporter()
 	return ""
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/nilReporter.go b/vendor/src/github.com/smartystreets/goconvey/convey/nilReporter.go
new file mode 100644
index 00000000000..777b2a51228
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/nilReporter.go
@@ -0,0 +1,15 @@
+package convey
+
+import (
+	"github.com/smartystreets/goconvey/convey/reporting"
+)
+
+type nilReporter struct{}
+
+func (self *nilReporter) BeginStory(story *reporting.StoryReport)  {}
+func (self *nilReporter) Enter(scope *reporting.ScopeReport)       {}
+func (self *nilReporter) Report(report *reporting.AssertionResult) {}
+func (self *nilReporter) Exit()                                    {}
+func (self *nilReporter) EndStory()                                {}
+func (self *nilReporter) Write(p []byte) (int, error)              { return len(p), nil }
+func newNilReporter() *nilReporter                                 { return &nilReporter{} }
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/registration.go b/vendor/src/github.com/smartystreets/goconvey/convey/registration.go
deleted file mode 100644
index 40c2e3ea1dc..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/registration.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package convey
-
-import (
-	"reflect"
-	"runtime"
-
-	"github.com/smartystreets/goconvey/convey/gotest"
-)
-
-type registration struct {
-	Situation string
-	action    *action
-	Test      t
-	File      string
-	Line      int
-	Focus     bool
-}
-
-func (self *registration) IsTopLevel() bool {
-	return self.Test != nil
-}
-
-func newRegistration(situation string, action *action, test t) *registration {
-	file, line, _ := gotest.ResolveExternalCaller()
-	self := new(registration)
-	self.Situation = situation
-	self.action = action
-	self.Test = test
-	self.File = file
-	self.Line = line
-	return self
-}
-
-////////////////////////// action ///////////////////////
-
-type action struct {
-	wrapped     func()
-	name        string
-	failureMode FailureMode
-}
-
-func (self *action) Invoke() {
-	self.wrapped()
-}
-
-func newAction(wrapped func(), mode FailureMode) *action {
-	self := new(action)
-	self.name = functionName(wrapped)
-	self.wrapped = wrapped
-	self.failureMode = mode
-	return self
-}
-
-func newSkippedAction(wrapped func(), mode FailureMode) *action {
-	self := new(action)
-
-	// The choice to use the filename and line number as the action name
-	// reflects the need for something unique but also that corresponds
-	// in a determinist way to the action itself.
-	self.name = gotest.FormatExternalFileAndLine()
-	self.wrapped = wrapped
-	self.failureMode = mode
-	return self
-}
-
-///////////////////////// helpers //////////////////////////////
-
-func functionName(action func()) string {
-	return runtime.FuncForPC(functionId(action)).Name()
-}
-
-func functionId(action func()) uintptr {
-	return reflect.ValueOf(action).Pointer()
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest_test.go
index e15d619ae27..fda189458e5 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest_test.go
@@ -47,7 +47,7 @@ func TestReporterIsResetAtTheEndOfTheStory(t *testing.T) {
 
 func TestReporterNoopMethods(t *testing.T) {
 	reporter := NewGoTestReporter()
-	reporter.Enter(NewScopeReport("title", "name"))
+	reporter.Enter(NewScopeReport("title"))
 	reporter.Exit()
 }
 
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/init.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/init.go
index ea7a4be075f..430cf73d53c 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/init.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/init.go
@@ -43,7 +43,7 @@ func BuildSilentReporter() Reporter {
 	out := NewPrinter(NewConsole())
 	return NewReporters(
 		NewGoTestReporter(),
-		NewProblemReporter(out))
+		NewSilentProblemReporter(out))
 }
 
 var (
@@ -69,6 +69,9 @@ var (
 
 var consoleStatistics = NewStatisticsReporter(NewPrinter(NewConsole()))
 
+func SuppressConsoleStatistics() { consoleStatistics.Suppress() }
+func PrintConsoleStatistics()    { consoleStatistics.PrintSummary() }
+
 // QuiteMode disables all console output symbols. This is only meant to be used
 // for tests that are internal to goconvey where the output is distracting or
 // otherwise not needed in the test output.
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/json.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/json.go
index 38c350450e5..f8526979f85 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/json.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/json.go
@@ -10,26 +10,26 @@ import (
 )
 
 type JsonReporter struct {
-	out     *Printer
-	current *ScopeResult
-	index   map[string]*ScopeResult
-	scopes  []*ScopeResult
-	depth   int
+	out        *Printer
+	currentKey []string
+	current    *ScopeResult
+	index      map[string]*ScopeResult
+	scopes     []*ScopeResult
 }
 
+func (self *JsonReporter) depth() int { return len(self.currentKey) }
+
 func (self *JsonReporter) BeginStory(story *StoryReport) {}
 
 func (self *JsonReporter) Enter(scope *ScopeReport) {
-	if _, found := self.index[scope.ID]; !found {
-		self.registerScope(scope)
+	self.currentKey = append(self.currentKey, scope.Title)
+	ID := strings.Join(self.currentKey, "|")
+	if _, found := self.index[ID]; !found {
+		next := newScopeResult(scope.Title, self.depth(), scope.File, scope.Line)
+		self.scopes = append(self.scopes, next)
+		self.index[ID] = next
 	}
-	self.depth++
-	self.current = self.index[scope.ID]
-}
-func (self *JsonReporter) registerScope(scope *ScopeReport) {
-	next := newScopeResult(scope.Title, self.depth, scope.File, scope.Line)
-	self.scopes = append(self.scopes, next)
-	self.index[scope.ID] = next
+	self.current = self.index[ID]
 }
 
 func (self *JsonReporter) Report(report *AssertionResult) {
@@ -37,7 +37,7 @@ func (self *JsonReporter) Report(report *AssertionResult) {
 }
 
 func (self *JsonReporter) Exit() {
-	self.depth--
+	self.currentKey = self.currentKey[:len(self.currentKey)-1]
 }
 
 func (self *JsonReporter) EndStory() {
@@ -61,7 +61,7 @@ func (self *JsonReporter) report() {
 func (self *JsonReporter) reset() {
 	self.scopes = []*ScopeResult{}
 	self.index = map[string]*ScopeResult{}
-	self.depth = 0
+	self.currentKey = nil
 }
 
 func (self *JsonReporter) Write(content []byte) (written int, err error) {
@@ -76,8 +76,8 @@ func NewJsonReporter(out *Printer) *JsonReporter {
 	return self
 }
 
-const OpenJson = ">>>>>"  // "⌦"
-const CloseJson = "<<<<<" // "⌫"
+const OpenJson = ">->->OPEN-JSON->->->"   // "⌦"
+const CloseJson = "<-<-<-CLOSE-JSON<-<-<" // "⌫"
 const jsonMarshalFailure = `
 
 GOCONVEY_JSON_MARSHALL_FAILURE: There was an error when attempting to convert test results to JSON.
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems.go
index c610ba88693..9ae493ac3b7 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems.go
@@ -3,6 +3,7 @@ package reporting
 import "fmt"
 
 type problem struct {
+	silent   bool
 	out      *Printer
 	errors   []*AssertionResult
 	failures []*AssertionResult
@@ -28,9 +29,13 @@ func (self *problem) EndStory() {
 	self.prepareForNextStory()
 }
 func (self *problem) show(display func(), color string) {
-	fmt.Print(color)
+	if !self.silent {
+		fmt.Print(color)
+	}
 	display()
-	fmt.Print(resetColor)
+	if !self.silent {
+		fmt.Print(resetColor)
+	}
 	self.out.Dedent()
 }
 func (self *problem) showErrors() {
@@ -62,6 +67,13 @@ func NewProblemReporter(out *Printer) *problem {
 	self.prepareForNextStory()
 	return self
 }
+
+func NewSilentProblemReporter(out *Printer) *problem {
+	self := NewProblemReporter(out)
+	self.silent = true
+	return self
+}
+
 func (self *problem) prepareForNextStory() {
 	self.errors = []*AssertionResult{}
 	self.failures = []*AssertionResult{}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems_test.go
index 34b8c2c4049..92f0ca35cca 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems_test.go
@@ -31,7 +31,12 @@ func TestReporterPrintsFailuresAndErrorsAtTheEndOfTheStory(t *testing.T) {
 	if !strings.Contains(result, "Failures:\n") {
 		t.Errorf("Expected failures, found none.")
 	}
-	problemCount := strings.Count(result, "*")
+
+	// Each stack trace looks like: `* /path/to/file.go`, so look for `* `.
+	// With go 1.4+ there is a line in some stack traces that looks like this:
+	//   `testing.(*M).Run(0x2082d60a0, 0x25b7c0)`
+	// So we can't just look for "*" anymore.
+	problemCount := strings.Count(result, "* ")
 	if problemCount != 2 {
 		t.Errorf("Expected one failure and one error (total of 2 '*' characters). Got %d", problemCount)
 	}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter_test.go
index 2d5f1ab8c55..4e5caf63b2b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter_test.go
@@ -14,7 +14,7 @@ func TestEachNestedReporterReceivesTheCallFromTheContainingReporter(t *testing.T
 	assertTrue(t, fake1.begun)
 	assertTrue(t, fake2.begun)
 
-	reporter.Enter(NewScopeReport("scope", "hi"))
+	reporter.Enter(NewScopeReport("scope"))
 	assertTrue(t, fake1.entered)
 	assertTrue(t, fake2.entered)
 
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporting.goconvey b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporting.goconvey
new file mode 100644
index 00000000000..79982854b53
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporting.goconvey
@@ -0,0 +1,2 @@
+#ignore
+-timeout=1s
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reports.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reports.go
index 63e1829d139..712e6ade625 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reports.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reports.go
@@ -13,16 +13,14 @@ import (
 
 type ScopeReport struct {
 	Title string
-	ID    string
 	File  string
 	Line  int
 }
 
-func NewScopeReport(title, name string) *ScopeReport {
+func NewScopeReport(title string) *ScopeReport {
 	file, line, _ := gotest.ResolveExternalCaller()
 	self := new(ScopeReport)
 	self.Title = title
-	self.ID = fmt.Sprintf("%s|%s", title, name)
 	self.File = file
 	self.Line = line
 	return self
@@ -78,10 +76,12 @@ func removePackagePath(name string) string {
 
 /////////////////// FailureView ////////////////////////
 
+// This struct is also declared in github.com/smartystreets/assertions.
+// The json struct tags should be equal in both declarations.
 type FailureView struct {
-	Message  string
-	Expected string
-	Actual   string
+	Message  string `json:"Message"`
+	Expected string `json:"Expected"`
+	Actual   string `json:"Actual"`
 }
 
 ////////////////////AssertionResult //////////////////////
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/statistics.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/statistics.go
index e015031c3a3..28e1d2071d4 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/statistics.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/statistics.go
@@ -23,13 +23,23 @@ func (self *statistics) Report(report *AssertionResult) {
 func (self *statistics) Exit() {}
 
 func (self *statistics) EndStory() {
+	if !self.suppressed {
+		self.PrintSummary()
+	}
+}
+
+func (self *statistics) Suppress() {
+	self.suppressed = true
+}
+
+func (self *statistics) PrintSummary() {
 	self.reportAssertions()
 	self.reportSkippedSections()
 	self.completeReport()
 }
 func (self *statistics) reportAssertions() {
 	self.decideColor()
-	self.out.Print("\n%d %s thus far", self.total, plural("assertion", self.total))
+	self.out.Print("\n%d total %s", self.total, plural("assertion", self.total))
 }
 func (self *statistics) decideColor() {
 	if self.failing && !self.erroring {
@@ -44,7 +54,6 @@ func (self *statistics) reportSkippedSections() {
 	if self.skipped > 0 {
 		fmt.Print(yellowColor)
 		self.out.Print(" (one or more sections skipped)")
-		self.skipped = 0
 	}
 }
 func (self *statistics) completeReport() {
@@ -64,11 +73,12 @@ func NewStatisticsReporter(out *Printer) *statistics {
 }
 
 type statistics struct {
-	out      *Printer
-	total    int
-	failing  bool
-	erroring bool
-	skipped  int
+	out        *Printer
+	total      int
+	failing    bool
+	erroring   bool
+	skipped    int
+	suppressed bool
 }
 
 func plural(word string, count int) string {
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/story.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/story.go
index 42584c0e19f..9e73c971f8f 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting/story.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting/story.go
@@ -7,11 +7,15 @@
 
 package reporting
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 type story struct {
 	out        *Printer
 	titlesById map[string]string
+	currentKey []string
 }
 
 func (self *story) BeginStory(story *StoryReport) {}
@@ -19,11 +23,14 @@ func (self *story) BeginStory(story *StoryReport) {}
 func (self *story) Enter(scope *ScopeReport) {
 	self.out.Indent()
 
-	if _, found := self.titlesById[scope.ID]; !found {
+	self.currentKey = append(self.currentKey, scope.Title)
+	ID := strings.Join(self.currentKey, "|")
+
+	if _, found := self.titlesById[ID]; !found {
 		self.out.Println("")
 		self.out.Print(scope.Title)
 		self.out.Insert(" ")
-		self.titlesById[scope.ID] = scope.Title
+		self.titlesById[ID] = scope.Title
 	}
 }
 
@@ -46,6 +53,7 @@ func (self *story) Report(report *AssertionResult) {
 
 func (self *story) Exit() {
 	self.out.Dedent()
+	self.currentKey = self.currentKey[:len(self.currentKey)-1]
 }
 
 func (self *story) EndStory() {
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/reporting_hooks_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/reporting_hooks_test.go
index 33ab3e46e28..69125c3cf44 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/reporting_hooks_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/reporting_hooks_test.go
@@ -188,12 +188,40 @@ func TestIterativeConveysReported(t *testing.T) {
 	expectEqual(t, "Begin|A|0|Success|Exit|Exit|A|1|Success|Exit|Exit|A|2|Success|Exit|Exit|End", myReporter.wholeStory())
 }
 
-func TestEmbeddedAssertionReported(t *testing.T) {
+func TestNestedIterativeConveysReported(t *testing.T) {
 	myReporter, test := setupFakeReporter()
 
 	Convey("A", test, func() {
+		for x := 0; x < 3; x++ {
+			Convey(strconv.Itoa(x), func() {
+				for y := 0; y < 3; y++ {
+					Convey("< "+strconv.Itoa(y), func() {
+						So(x, ShouldBeLessThan, y)
+					})
+				}
+			})
+		}
+	})
+
+	expectEqual(t, ("Begin|" +
+		"A|0|< 0|Failure|Exit|Exit|Exit|" +
+		"A|0|< 1|Success|Exit|Exit|Exit|" +
+		"A|0|< 2|Success|Exit|Exit|Exit|" +
+		"A|1|< 0|Failure|Exit|Exit|Exit|" +
+		"A|1|< 1|Failure|Exit|Exit|Exit|" +
+		"A|1|< 2|Success|Exit|Exit|Exit|" +
+		"A|2|< 0|Failure|Exit|Exit|Exit|" +
+		"A|2|< 1|Failure|Exit|Exit|Exit|" +
+		"A|2|< 2|Failure|Exit|Exit|Exit|" +
+		"End"), myReporter.wholeStory())
+}
+
+func TestEmbeddedAssertionReported(t *testing.T) {
+	myReporter, test := setupFakeReporter()
+
+	Convey("A", test, func(c C) {
 		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			So(r.FormValue("msg"), ShouldEqual, "ping")
+			c.So(r.FormValue("msg"), ShouldEqual, "ping")
 		}))
 		http.DefaultClient.Get(ts.URL + "?msg=ping")
 	})
@@ -201,6 +229,25 @@ func TestEmbeddedAssertionReported(t *testing.T) {
 	expectEqual(t, "Begin|A|Success|Exit|End", myReporter.wholeStory())
 }
 
+func TestEmbeddedContextHelperReported(t *testing.T) {
+	myReporter, test := setupFakeReporter()
+
+	helper := func(c C) http.HandlerFunc {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			c.Convey("Embedded", func() {
+				So(r.FormValue("msg"), ShouldEqual, "ping")
+			})
+		})
+	}
+
+	Convey("A", test, func(c C) {
+		ts := httptest.NewServer(helper(c))
+		http.DefaultClient.Get(ts.URL + "?msg=ping")
+	})
+
+	expectEqual(t, "Begin|A|Embedded|Success|Exit|Exit|End", myReporter.wholeStory())
+}
+
 func expectEqual(t *testing.T, expected interface{}, actual interface{}) {
 	if expected != actual {
 		_, file, line, _ := runtime.Caller(1)
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/runner.go b/vendor/src/github.com/smartystreets/goconvey/convey/runner.go
deleted file mode 100644
index fbc7d5d59c4..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/runner.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package convey
-
-import (
-	"fmt"
-
-	"github.com/smartystreets/goconvey/convey/gotest"
-	"github.com/smartystreets/goconvey/convey/reporting"
-)
-
-type runner struct {
-	top         *scope
-	active      *scope
-	reporter    reporting.Reporter
-	failureMode FailureMode
-
-	awaitingNewStory bool
-	focus            bool
-}
-
-func (self *runner) Begin(entry *registration) {
-	self.active = self.top
-	self.focus = entry.Focus
-
-	self.ensureStoryCanBegin()
-	self.reporter.BeginStory(reporting.NewStoryReport(entry.Test))
-	self.Register(entry)
-}
-func (self *runner) ensureStoryCanBegin() {
-	if self.awaitingNewStory {
-		self.awaitingNewStory = false
-	} else {
-		panic(fmt.Sprintf("%s (See %s)", extraGoTest, gotest.FormatExternalFileAndLine()))
-	}
-}
-
-func (self *runner) Register(entry *registration) {
-	if self.focus && !entry.Focus {
-		return
-	}
-
-	self.ensureStoryAlreadyStarted()
-
-	child := newScope(entry, self.reporter)
-	self.active.adopt(child)
-}
-
-func (self *runner) ensureStoryAlreadyStarted() {
-	if self.awaitingNewStory {
-		panic(missingGoTest)
-	}
-}
-
-func (self *runner) RegisterReset(action *action) {
-	self.active.registerReset(action)
-}
-
-func (self *runner) Run() {
-	self.active = self.top
-	self.failureMode = FailureHalts
-
-	for !self.top.visited() {
-		self.top.visit(self)
-	}
-
-	self.reporter.EndStory()
-	self.awaitingNewStory = true
-}
-
-func newRunner() *runner {
-	self := new(runner)
-
-	self.reporter = newNilReporter()
-	self.top = newScope(newRegistration(topLevel, newAction(func() {}, FailureInherits), nil), self.reporter)
-	self.active = self.top
-	self.awaitingNewStory = true
-
-	return self
-}
-
-func (self *runner) UpgradeReporter(reporter reporting.Reporter) {
-	self.reporter = reporter
-}
-
-func (self *runner) Report(result *reporting.AssertionResult) {
-	self.reporter.Report(result)
-	if result.Failure != "" && self.failureMode == FailureHalts {
-		panic(failureHalt)
-	}
-}
-
-func (self *runner) Write(content []byte) (written int, err error) {
-	return self.reporter.Write(content)
-}
-
-func last(group []string) string {
-	return group[len(group)-1]
-}
-
-const topLevel = "TOP"
-const missingGoTest = `Top-level calls to Convey(...) need a reference to the *testing.T. 
-    Hint: Convey("description here", t, func() { /* notice that the second argument was the *testing.T (t)! */ }) `
-const extraGoTest = `Only the top-level call to Convey(...) needs a reference to the *testing.T.`
-const failureHalt = "___FAILURE_HALT___"
-
-//////////////////////// nilReporter /////////////////////////////
-
-type nilReporter struct{}
-
-func (self *nilReporter) BeginStory(story *reporting.StoryReport)  {}
-func (self *nilReporter) Enter(scope *reporting.ScopeReport)       {}
-func (self *nilReporter) Report(report *reporting.AssertionResult) {}
-func (self *nilReporter) Exit()                                    {}
-func (self *nilReporter) EndStory()                                {}
-func (self *nilReporter) Write(p []byte) (int, error)              { return len(p), nil }
-func newNilReporter() *nilReporter                                 { return new(nilReporter) }
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/scope.go b/vendor/src/github.com/smartystreets/goconvey/convey/scope.go
deleted file mode 100644
index 24b4e14fc5d..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/convey/scope.go
+++ /dev/null
@@ -1,121 +0,0 @@
-package convey
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/smartystreets/goconvey/convey/reporting"
-)
-
-type scope struct {
-	name       string
-	title      string
-	action     *action
-	children   map[string]*scope
-	birthOrder []*scope
-	child      int
-	resets     map[string]*action
-	panicked   bool
-	reporter   reporting.Reporter
-	report     *reporting.ScopeReport
-}
-
-func (parent *scope) adopt(child *scope) {
-	i := parent.getChildIndex(child)
-
-	if i == -1 {
-		parent.children[child.name] = child
-		parent.birthOrder = append(parent.birthOrder, child)
-	} else {
-		/* We need to replace the action to retain the closed over variables from
-		   the specific invocation of the parent scope, enabling the enclosing
-		   parent scope to serve as a set-up for the child scope */
-		parent.birthOrder[i].action = child.action
-	}
-}
-
-func (parent *scope) getChildIndex(child *scope) int {
-	for i, ordered := range parent.birthOrder {
-		if ordered.name == child.name && ordered.title == child.title {
-			return i
-		}
-	}
-
-	return -1
-}
-
-func (self *scope) registerReset(action *action) {
-	self.resets[action.name] = action
-}
-
-func (self *scope) visited() bool {
-	return self.panicked || self.child >= len(self.birthOrder)
-}
-
-func (parent *scope) visit(runner *runner) {
-	runner.active = parent
-	defer parent.exit()
-
-	// Set and reset failure mode
-	oldFailure := runner.failureMode
-	if parent.action.failureMode != FailureInherits {
-		runner.failureMode = parent.action.failureMode
-	}
-	defer func() {
-		runner.failureMode = oldFailure
-	}()
-
-	parent.enter()
-	parent.action.Invoke()
-	parent.visitChildren(runner)
-}
-func (parent *scope) enter() {
-	parent.reporter.Enter(parent.report)
-}
-func (parent *scope) visitChildren(runner *runner) {
-	if len(parent.birthOrder) == 0 {
-		parent.cleanup()
-	} else {
-		parent.visitChild(runner)
-	}
-}
-func (parent *scope) visitChild(runner *runner) {
-	child := parent.birthOrder[parent.child]
-	child.visit(runner)
-
-	parent.cleanup()
-
-	if child.visited() {
-		parent.child++
-	}
-}
-func (parent *scope) cleanup() {
-	for _, reset := range parent.resets {
-		reset.Invoke()
-	}
-}
-func (parent *scope) exit() {
-	if problem := recover(); problem != nil {
-		if strings.HasPrefix(fmt.Sprintf("%v", problem), extraGoTest) {
-			panic(problem)
-		}
-		if problem != failureHalt {
-			parent.reporter.Report(reporting.NewErrorReport(problem))
-		}
-		parent.panicked = true
-	}
-	parent.reporter.Exit()
-}
-
-func newScope(entry *registration, reporter reporting.Reporter) *scope {
-	self := new(scope)
-	self.reporter = reporter
-	self.name = entry.action.name
-	self.title = entry.Situation
-	self.action = entry.action
-	self.children = make(map[string]*scope)
-	self.birthOrder = []*scope{}
-	self.resets = make(map[string]*action)
-	self.report = reporting.NewScopeReport(self.title, self.name)
-	return self
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/convey/story_conventions_test.go b/vendor/src/github.com/smartystreets/goconvey/convey/story_conventions_test.go
index 251694ef2f4..84832c78d5b 100644
--- a/vendor/src/github.com/smartystreets/goconvey/convey/story_conventions_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/convey/story_conventions_test.go
@@ -1,31 +1,37 @@
 package convey
 
 import (
-	"fmt"
-	"strings"
+	"reflect"
 	"testing"
 )
 
+func expectPanic(t *testing.T, f string) interface{} {
+	r := recover()
+	if r != nil {
+		if cp, ok := r.(*conveyErr); ok {
+			if cp.fmt != f {
+				t.Error("Incorrect panic message.")
+			}
+		} else {
+			t.Errorf("Incorrect panic type. %s", reflect.TypeOf(r))
+		}
+	} else {
+		t.Error("Expected panic but none occured")
+	}
+	return r
+}
+
 func TestMissingTopLevelGoTestReferenceCausesPanic(t *testing.T) {
 	output := map[string]bool{}
 
 	defer expectEqual(t, false, output["good"])
-	defer requireGoTestReference(t)
+	defer expectPanic(t, missingGoTest)
 
 	Convey("Hi", func() {
 		output["bad"] = true // this shouldn't happen
 	})
 }
 
-func requireGoTestReference(t *testing.T) {
-	err := recover()
-	if err == nil {
-		t.Error("We should have recovered a panic here (because of a missing *testing.T reference)!")
-	} else {
-		expectEqual(t, missingGoTest, err)
-	}
-}
-
 func TestMissingTopLevelGoTestReferenceAfterGoodExample(t *testing.T) {
 	output := map[string]bool{}
 
@@ -33,7 +39,7 @@ func TestMissingTopLevelGoTestReferenceAfterGoodExample(t *testing.T) {
 		expectEqual(t, true, output["good"])
 		expectEqual(t, false, output["bad"])
 	}()
-	defer requireGoTestReference(t)
+	defer expectPanic(t, missingGoTest)
 
 	Convey("Good example", t, func() {
 		output["good"] = true
@@ -47,17 +53,8 @@ func TestMissingTopLevelGoTestReferenceAfterGoodExample(t *testing.T) {
 func TestExtraReferencePanics(t *testing.T) {
 	output := map[string]bool{}
 
-	defer func() {
-		err := recover()
-		if err == nil {
-			t.Error("We should have recovered a panic here (because of an extra *testing.T reference)!")
-		} else if !strings.HasPrefix(fmt.Sprintf("%v", err), extraGoTest) {
-			t.Error("Should have panicked with the 'extra go test' error!")
-		}
-		if output["bad"] {
-			t.Error("We should NOT have run the bad example!")
-		}
-	}()
+	defer expectEqual(t, false, output["bad"])
+	defer expectPanic(t, extraGoTest)
 
 	Convey("Good example", t, func() {
 		Convey("Bad example - passing in *testing.T a second time!", t, func() {
@@ -67,45 +64,112 @@ func TestExtraReferencePanics(t *testing.T) {
 }
 
 func TestParseRegistrationMissingRequiredElements(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "You must provide a name (string), then a *testing.T (if in outermost scope), an optional FailureMode, and then an action (func())." {
-				t.Errorf("Incorrect panic message.")
-			}
-		}
-	}()
+	defer expectPanic(t, parseError)
 
 	Convey()
-
-	t.Errorf("goTest should have panicked in Convey(...) and then recovered in the defer func().")
 }
 
 func TestParseRegistration_MissingNameString(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != parseError {
-				t.Errorf("Incorrect panic message.")
-			}
-		}
-	}()
+	defer expectPanic(t, parseError)
+
+	Convey(func() {})
+}
 
-	action := func() {}
+func TestParseRegistration_MissingActionFunc(t *testing.T) {
+	defer expectPanic(t, parseError)
 
-	Convey(action)
+	Convey("Hi there", 12345)
+}
 
-	t.Errorf("goTest should have panicked in Convey(...) and then recovered in the defer func().")
+func TestFailureModeNoContext(t *testing.T) {
+	Convey("Foo", t, func() {
+		done := make(chan int, 1)
+		go func() {
+			defer func() { done <- 1 }()
+			defer expectPanic(t, noStackContext)
+			So(len("I have no context"), ShouldBeGreaterThan, 0)
+		}()
+		<-done
+	})
 }
 
-func TestParseRegistration_MissingActionFunc(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != parseError {
-				t.Errorf("Incorrect panic message: '%s'", r)
-			}
+func TestFailureModeDuplicateSuite(t *testing.T) {
+	Convey("cool", t, func() {
+		defer expectPanic(t, multipleIdenticalConvey)
+
+		Convey("dup", nil)
+		Convey("dup", nil)
+	})
+}
+
+func TestFailureModeIndeterminentSuiteNames(t *testing.T) {
+	defer expectPanic(t, differentConveySituations)
+
+	name := "bob"
+	Convey("cool", t, func() {
+		for i := 0; i < 3; i++ {
+			Convey(name, func() {})
+			name += "bob"
 		}
-	}()
+	})
+}
 
-	Convey("Hi there", 12345)
+func TestFailureModeNestedIndeterminentSuiteNames(t *testing.T) {
+	defer expectPanic(t, differentConveySituations)
+
+	name := "bob"
+	Convey("cool", t, func() {
+		Convey("inner", func() {
+			for i := 0; i < 3; i++ {
+				Convey(name, func() {})
+				name += "bob"
+			}
+		})
+	})
+}
+
+func TestFailureModeParameterButMissing(t *testing.T) {
+	defer expectPanic(t, parseError)
+
+	prepare()
+
+	Convey("Foobar", t, FailureHalts)
+}
+
+func TestFailureModeParameterWithAction(t *testing.T) {
+	prepare()
+
+	Convey("Foobar", t, FailureHalts, func() {})
+}
+
+func TestExtraConveyParameters(t *testing.T) {
+	defer expectPanic(t, parseError)
+
+	prepare()
+
+	Convey("Foobar", t, FailureHalts, func() {}, "This is not supposed to be here")
+}
+
+func TestExtraConveyParameters2(t *testing.T) {
+	defer expectPanic(t, parseError)
+
+	prepare()
+
+	Convey("Foobar", t, func() {}, "This is not supposed to be here")
+}
+
+func TestExtraConveyParameters3(t *testing.T) {
+	defer expectPanic(t, parseError)
+
+	output := prepare()
+
+	Convey("A", t, func() {
+		output += "A "
+
+		Convey("B", func() {
+			output += "B "
+		}, "This is not supposed to be here")
+	})
 
-	t.Errorf("goTest should have panicked in Convey(...) and then recovered in the defer func().")
+	expectEqual(t, "A ", output)
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/dependencies.go b/vendor/src/github.com/smartystreets/goconvey/dependencies.go
new file mode 100644
index 00000000000..0839e27fdf2
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/dependencies.go
@@ -0,0 +1,4 @@
+package main
+
+import _ "github.com/jtolds/gls"
+import _ "github.com/smartystreets/assertions"
diff --git a/vendor/src/github.com/smartystreets/goconvey/deps_test.go b/vendor/src/github.com/smartystreets/goconvey/deps_test.go
deleted file mode 100644
index 0a9838e4e35..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/deps_test.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// The purpose of this file is to make sure the dependencies are pulled in when
-// `go get -t` is invoked for the first time. Because it is in a *_test.go file
-// it prevents all of the flags from dependencies from leaking into the goconvey
-// binary.
-
-package main
-
-import (
-	_ "github.com/jacobsa/oglematchers"
-	_ "github.com/jacobsa/ogletest"
-)
diff --git a/vendor/src/github.com/smartystreets/goconvey/doc_test.go b/vendor/src/github.com/smartystreets/goconvey/doc_test.go
new file mode 100644
index 00000000000..06ab7d0f9a3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/doc_test.go
@@ -0,0 +1 @@
+package main
diff --git a/vendor/src/github.com/smartystreets/goconvey/examples/assertion_examples_test.go b/vendor/src/github.com/smartystreets/goconvey/examples/assertion_examples_test.go
index a163e093c25..a933292a2e7 100644
--- a/vendor/src/github.com/smartystreets/goconvey/examples/assertion_examples_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/examples/assertion_examples_test.go
@@ -9,8 +9,11 @@ import (
 	. "github.com/smartystreets/goconvey/convey"
 )
 
-func TestAssertions(t *testing.T) {
-	Convey("Equality assertions should be accessible", t, FailureContinues, func() {
+func TestAssertionsAreAvailableFromConveyPackage(t *testing.T) {
+	SetDefaultFailureMode(FailureContinues)
+	defer SetDefaultFailureMode(FailureHalts)
+
+	Convey("Equality assertions should be accessible", t, func() {
 		thing1a := thing{a: "asdf"}
 		thing1b := thing{a: "asdf"}
 		thing2 := thing{a: "qwer"}
@@ -30,25 +33,30 @@ func TestAssertions(t *testing.T) {
 		So(0, ShouldBeZeroValue)
 	})
 
-	Convey("Numeric comparison assertions should be accessible", t, FailureContinues, func() {
+	Convey("Numeric comparison assertions should be accessible", t, func() {
 		So(1, ShouldBeGreaterThan, 0)
 		So(1, ShouldBeGreaterThanOrEqualTo, 1)
 		So(1, ShouldBeLessThan, 2)
 		So(1, ShouldBeLessThanOrEqualTo, 1)
 		So(1, ShouldBeBetween, 0, 2)
 		So(1, ShouldNotBeBetween, 2, 4)
+		So(1, ShouldBeBetweenOrEqual, 1, 2)
+		So(1, ShouldNotBeBetweenOrEqual, 2, 4)
 	})
 
-	Convey("Container assertions should be accessible", t, FailureContinues, func() {
+	Convey("Container assertions should be accessible", t, func() {
 		So([]int{1, 2, 3}, ShouldContain, 2)
 		So([]int{1, 2, 3}, ShouldNotContain, 4)
+		So(map[int]int{1: 1, 2: 2, 3: 3}, ShouldContainKey, 2)
+		So(map[int]int{1: 1, 2: 2, 3: 3}, ShouldNotContainKey, 4)
 		So(1, ShouldBeIn, []int{1, 2, 3})
 		So(4, ShouldNotBeIn, []int{1, 2, 3})
 		So([]int{}, ShouldBeEmpty)
 		So([]int{1}, ShouldNotBeEmpty)
+		So([]int{1, 2}, ShouldHaveLength, 2)
 	})
 
-	Convey("String assertions should be accessible", t, FailureContinues, func() {
+	Convey("String assertions should be accessible", t, func() {
 		So("asdf", ShouldStartWith, "a")
 		So("asdf", ShouldNotStartWith, "z")
 		So("asdf", ShouldEndWith, "df")
@@ -59,14 +67,14 @@ func TestAssertions(t *testing.T) {
 		So("asdf", ShouldNotContainSubstring, "af")
 	})
 
-	Convey("Panic recovery assertions should be accessible", t, FailureContinues, func() {
+	Convey("Panic recovery assertions should be accessible", t, func() {
 		So(panics, ShouldPanic)
 		So(func() {}, ShouldNotPanic)
 		So(panics, ShouldPanicWith, "Goofy Gophers!")
 		So(panics, ShouldNotPanicWith, "Guileless Gophers!")
 	})
 
-	Convey("Type-checking assertions should be accessible", t, FailureContinues, func() {
+	Convey("Type-checking assertions should be accessible", t, func() {
 
 		// NOTE: Values or pointers may be checked.  If a value is passed,
 		// it will be cast as a pointer to the value to avoid cases where
@@ -85,7 +93,7 @@ func TestAssertions(t *testing.T) {
 		So("string", ShouldNotImplement, (*io.Reader)(nil))
 	})
 
-	Convey("Time assertions should be accessible", t, FailureContinues, func() {
+	Convey("Time assertions should be accessible", t, func() {
 		january1, _ := time.Parse(timeLayout, "2013-01-01 00:00")
 		january2, _ := time.Parse(timeLayout, "2013-01-02 00:00")
 		january3, _ := time.Parse(timeLayout, "2013-01-03 00:00")
diff --git a/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game.go b/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game.go
index 1b3639d1c92..547bf93d1c3 100644
--- a/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game.go
+++ b/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game.go
@@ -1,21 +1,25 @@
 package examples
 
+// Game contains the state of a bowling game.
 type Game struct {
 	rolls   []int
 	current int
 }
 
+// NewGame allocates and starts a new game of bowling.
 func NewGame() *Game {
 	game := new(Game)
 	game.rolls = make([]int, maxThrowsPerGame)
 	return game
 }
 
+// Roll rolls the ball and knocks down the number of pins specified by pins.
 func (self *Game) Roll(pins int) {
 	self.rolls[self.current] = pins
 	self.current++
 }
 
+// Score calculates and returns the player's current score.
 func (self *Game) Score() (sum int) {
 	for throw, frame := 0, 0; frame < framesPerGame; frame++ {
 		if self.isStrike(throw) {
@@ -32,26 +36,40 @@ func (self *Game) Score() (sum int) {
 	return sum
 }
 
+// isStrike determines if a given throw is a strike or not. A strike is knocking
+// down all pins in one throw.
 func (self *Game) isStrike(throw int) bool {
 	return self.rolls[throw] == allPins
 }
+
+// strikeBonusFor calculates and returns the strike bonus for a throw.
 func (self *Game) strikeBonusFor(throw int) int {
 	return allPins + self.framePointsAt(throw+1)
 }
 
+// isSpare determines if a given frame is a spare or not. A spare is knocking
+// down all pins in one frame with two throws.
 func (self *Game) isSpare(throw int) bool {
 	return self.framePointsAt(throw) == allPins
 }
+
+// spareBonusFor calculates and returns the spare bonus for a throw.
 func (self *Game) spareBonusFor(throw int) int {
 	return allPins + self.rolls[throw+2]
 }
 
+// framePointsAt computes and returns the score in a frame specified by throw.
 func (self *Game) framePointsAt(throw int) int {
 	return self.rolls[throw] + self.rolls[throw+1]
 }
 
 const (
+	// allPins is the number of pins allocated per fresh throw.
 	allPins          = 10
+	
+	// framesPerGame is the number of frames per bowling game.
 	framesPerGame    = 10
+	
+	// maxThrowsPerGame is the maximum number of throws possible in a single game.
 	maxThrowsPerGame = 21
 )
diff --git a/vendor/src/github.com/smartystreets/goconvey/examples/examples.goconvey b/vendor/src/github.com/smartystreets/goconvey/examples/examples.goconvey
new file mode 100644
index 00000000000..b5c805fbf4e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/examples/examples.goconvey
@@ -0,0 +1,12 @@
+// Uncomment the next line to disable the package when running the GoConvey UI:
+//IGNORE
+
+// Uncomment the next line to limit testing to the specified test function name pattern:
+//-run=TestAssertionsAreAvailableFromConveyPackage
+
+// Uncomment the next line to limit testing to those tests that don't bail when testing.Short() is true:
+//-short
+
+// include any additional `go test` flags or application-specific flags below:
+
+-timeout=1s
diff --git a/vendor/src/github.com/smartystreets/goconvey/examples/simple_example_test.go b/vendor/src/github.com/smartystreets/goconvey/examples/simple_example_test.go
index 917c6362329..dadfd8136a3 100644
--- a/vendor/src/github.com/smartystreets/goconvey/examples/simple_example_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/examples/simple_example_test.go
@@ -7,6 +7,8 @@ import (
 )
 
 func TestIntegerManipulation(t *testing.T) {
+	t.Parallel()
+
 	Convey("Given a starting integer value", t, func() {
 		x := 42
 
diff --git a/vendor/src/github.com/smartystreets/goconvey/goconvey.go b/vendor/src/github.com/smartystreets/goconvey/goconvey.go
index 9243b37f00f..4d5fc0ef6d5 100644
--- a/vendor/src/github.com/smartystreets/goconvey/goconvey.go
+++ b/vendor/src/github.com/smartystreets/goconvey/goconvey.go
@@ -2,7 +2,6 @@
 // to .go files within the working directory (and all nested go packages).
 // Navigating to the configured host and port in a web browser will display the
 // latest results of running `go test` in each go package.
-
 package main
 
 import (
@@ -11,17 +10,21 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"time"
 
+	"go/build"
+
 	"github.com/smartystreets/goconvey/web/server/api"
 	"github.com/smartystreets/goconvey/web/server/contract"
-	executor "github.com/smartystreets/goconvey/web/server/executor"
-	parser "github.com/smartystreets/goconvey/web/server/parser"
+	"github.com/smartystreets/goconvey/web/server/executor"
+	"github.com/smartystreets/goconvey/web/server/messaging"
+	"github.com/smartystreets/goconvey/web/server/parser"
 	"github.com/smartystreets/goconvey/web/server/system"
-	watch "github.com/smartystreets/goconvey/web/server/watcher"
+	"github.com/smartystreets/goconvey/web/server/watch"
 )
 
 func init() {
@@ -36,7 +39,10 @@ func flags() {
 	flag.StringVar(&gobin, "gobin", "go", "The path to the 'go' binary (default: search on the PATH).")
 	flag.BoolVar(&cover, "cover", true, "Enable package-level coverage statistics. Requires Go 1.2+ and the go cover tool. (default: true)")
 	flag.IntVar(&depth, "depth", -1, "The directory scanning depth. If -1, scan infinitely deep directory structures. 0: scan working directory. 1+: Scan into nested directories, limited to value. (default: -1)")
-	flag.BoolVar(&short, "short", false, "Configures the `testing.Short()` function to return `true`, allowing you to call `t.Skip()` on long-running tests.")
+	flag.StringVar(&timeout, "timeout", "0", "The test execution timeout if none is specified in the *.goconvey file (default is '0', which is the same as not providing this option).")
+	flag.StringVar(&watchedSuffixes, "watchedSuffixes", ".go", "A comma separated list of file suffixes to watch for modifications (default: .go).")
+	flag.StringVar(&excludedDirs, "excludedDirs", "vendor,node_modules", "A comma separated list of directories that will be excluded from being watched")
+	flag.StringVar(&workDir, "workDir", "", "set goconvey working directory (default current directory)")
 
 	log.SetOutput(os.Stdout)
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
@@ -50,16 +56,101 @@ func folders() {
 
 func main() {
 	flag.Parse()
+	log.Printf(initialConfiguration, host, port, nap, cover)
 
-	log.Printf(initialConfiguration, host, port, nap, cover, short)
+	working := getWorkDir()
+	cover = coverageEnabled(cover, reports)
+	shell := system.NewShell(gobin, reports, cover, timeout)
 
-	monitor, server := wireup()
+	watcherInput := make(chan messaging.WatcherCommand)
+	watcherOutput := make(chan messaging.Folders)
+	excludedDirItems := strings.Split(excludedDirs, `,`)
+	watcher := watch.NewWatcher(working, depth, nap, watcherInput, watcherOutput, watchedSuffixes, excludedDirItems)
 
-	go monitor.ScanForever()
+	parser := parser.NewParser(parser.ParsePackageResults)
+	tester := executor.NewConcurrentTester(shell)
+	tester.SetBatchSize(packages)
 
+	longpollChan := make(chan chan string)
+	executor := executor.NewExecutor(tester, parser, longpollChan)
+	server := api.NewHTTPServer(working, watcherInput, executor, longpollChan)
+	go runTestOnUpdates(watcherOutput, executor, server)
+	go watcher.Listen()
+	go launchBrowser(host, port)
 	serveHTTP(server)
 }
 
+func browserCmd() (string, bool) {
+	browser := map[string]string{
+		"darwin": "open",
+		"linux":  "xdg-open",
+		"win32":  "start",
+	}
+	cmd, ok := browser[runtime.GOOS]
+	return cmd, ok
+}
+
+func launchBrowser(host string, port int) {
+	browser, ok := browserCmd()
+	if !ok {
+		log.Printf("Skipped launching browser for this OS: %s", runtime.GOOS)
+		return
+	}
+
+	log.Printf("Launching browser on %s:%d", host, port)
+	url := fmt.Sprintf("http://%s:%d", host, port)
+	cmd := exec.Command(browser, url)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Println(err)
+	}
+	log.Println(string(output))
+}
+
+func runTestOnUpdates(queue chan messaging.Folders, executor contract.Executor, server contract.Server) {
+	for update := range queue {
+		log.Println("Received request from watcher to execute tests...")
+		packages := extractPackages(update)
+		output := executor.ExecuteTests(packages)
+		root := extractRoot(update, packages)
+		server.ReceiveUpdate(root, output)
+	}
+}
+
+func extractPackages(folderList messaging.Folders) []*contract.Package {
+	packageList := []*contract.Package{}
+	for _, folder := range folderList {
+		hasImportCycle := testFilesImportTheirOwnPackage(folder.Path)
+		packageList = append(packageList, contract.NewPackage(folder, hasImportCycle))
+	}
+	return packageList
+}
+
+func extractRoot(folderList messaging.Folders, packageList []*contract.Package) string {
+	path := packageList[0].Path
+	folder := folderList[path]
+	return folder.Root
+}
+
+// This method exists because of a bug in the go cover tool that
+// causes an infinite loop when you try to run `go test -cover`
+// on a package that has an import cycle defined in one of it's
+// test files. Yuck.
+func testFilesImportTheirOwnPackage(packagePath string) bool {
+	meta, err := build.ImportDir(packagePath, build.AllowBinary)
+	if err != nil {
+		return false
+	}
+
+	for _, dependency := range meta.TestImports {
+		if dependency == meta.ImportPath {
+			return true
+		}
+	}
+	return false
+}
+
 func serveHTTP(server contract.Server) {
 	serveStaticResources()
 	serveAjaxMethods(server)
@@ -83,45 +174,16 @@ func serveAjaxMethods(server contract.Server) {
 
 func activateServer() {
 	log.Printf("Serving HTTP at: http://%s:%d\n", host, port)
-	err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
-	if err != nil {
-		fmt.Println(err)
-	}
-}
-
-func wireup() (*contract.Monitor, contract.Server) {
-	log.Println("Constructing components...")
-	working, err := os.Getwd()
+	err := http.ListenAndServe(fmt.Sprintf("%s:%d", host, port), nil)
 	if err != nil {
-		log.Fatal(err)
+		log.Println(err)
 	}
-
-	shellExecutor := system.NewCommandExecutor()
-	cover = coverageEnabled(cover, reports, shellExecutor)
-
-	depthLimit := system.NewDepthLimit(system.NewFileSystem(), depth)
-	shell := system.NewShell(shellExecutor, gobin, short, cover, reports)
-
-	watcher := watch.NewWatcher(depthLimit, shell)
-	watcher.Adjust(working)
-
-	parser := parser.NewParser(parser.ParsePackageResults)
-	tester := executor.NewConcurrentTester(shell)
-	tester.SetBatchSize(packages)
-
-	longpollChan, pauseUpdate := make(chan chan string), make(chan bool, 1)
-	executor := executor.NewExecutor(tester, parser, longpollChan)
-	server := api.NewHTTPServer(watcher, executor, longpollChan, pauseUpdate)
-	scanner := watch.NewScanner(depthLimit, watcher)
-	monitor := contract.NewMonitor(scanner, watcher, executor, server, pauseUpdate, sleeper)
-
-	return monitor, server
 }
 
-func coverageEnabled(cover bool, reports string, shell system.Executor) bool {
+func coverageEnabled(cover bool, reports string) bool {
 	return (cover &&
 		goVersion_1_2_orGreater() &&
-		coverToolInstalled(shell) &&
+		coverToolInstalled() &&
 		ensureReportDirectoryExists(reports))
 }
 func goVersion_1_2_orGreater() bool {
@@ -134,13 +196,10 @@ func goVersion_1_2_orGreater() bool {
 	}
 	return true
 }
-func coverToolInstalled(shell system.Executor) bool {
-	working, err := os.Getwd()
-	if err != nil {
-		working = "."
-	}
-	output, _ := shell.Execute(working, "go", "tool", "cover")
-	installed := strings.Contains(output, "Usage of 'go tool cover':")
+func coverToolInstalled() bool {
+	working := getWorkDir()
+	command := system.NewCommand(working, "go", "tool", "cover").Execute()
+	installed := strings.Contains(command.Output, "Usage of 'go tool cover':")
 	if !installed {
 		log.Print(coverToolMissing)
 		return false
@@ -148,7 +207,11 @@ func coverToolInstalled(shell system.Executor) bool {
 	return true
 }
 func ensureReportDirectoryExists(reports string) bool {
-	if exists(reports) {
+	result, err := exists(reports)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if result {
 		return true
 	}
 
@@ -159,40 +222,59 @@ func ensureReportDirectoryExists(reports string) bool {
 	log.Printf(reportDirectoryUnavailable, reports)
 	return false
 }
-func exists(path string) bool {
+func exists(path string) (bool, error) {
 	_, err := os.Stat(path)
 	if err == nil {
-		return true
+		return true, nil
 	}
 	if os.IsNotExist(err) {
-		return false
+		return false, nil
 	}
-	return false
+	return false, err
 }
-
-func sleeper() {
-	time.Sleep(nap)
+func getWorkDir() string {
+	working := ""
+	var err error
+	if workDir != "" {
+		working = workDir
+	} else {
+		working, err = os.Getwd()
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	result, err := exists(working)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !result {
+		log.Fatalf("Path:%s does not exists", working)
+	}
+	return working
 }
 
 var (
-	port     int
-	host     string
-	gobin    string
-	nap      time.Duration
-	packages int
-	cover    bool
-	depth    int
-	short    bool
+	port            int
+	host            string
+	gobin           string
+	nap             time.Duration
+	packages        int
+	cover           bool
+	depth           int
+	timeout         string
+	watchedSuffixes string
+	excludedDirs    string
 
 	static  string
 	reports string
 
 	quarterSecond = time.Millisecond * 250
+	workDir       string
 )
 
 const (
-	initialConfiguration       = "Initial configuration: [host: %s] [port: %d] [poll: %v] [cover: %v] [short: %v]\n"
+	initialConfiguration       = "Initial configuration: [host: %s] [port: %d] [poll: %v] [cover: %v]\n"
 	pleaseUpgradeGoVersion     = "Go version is less that 1.2 (%s), please upgrade to the latest stable version to enable coverage reporting.\n"
-	coverToolMissing           = "Go cover tool is not installed or not accessible: `go get code.google.com/p/go.tools/cmd/cover`\n"
+	coverToolMissing           = "Go cover tool is not installed or not accessible: for Go < 1.5 run`go get golang.org/x/tools/cmd/cover`\n For >= Go 1.5 run `go install $GOROOT/src/cmd/cover`\n"
 	reportDirectoryUnavailable = "Could not find or create the coverage report directory (at: '%s'). You probably won't see any coverage statistics...\n"
 )
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/index.html b/vendor/src/github.com/smartystreets/goconvey/web/client/index.html
index 11836e18aaf..6895c7c4936 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/index.html
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/index.html
@@ -2,6 +2,7 @@
 <html>
 	<head>
 		<title>GoConvey</title>
+		<meta name="apple-mobile-web-app-capable" content="yes">
 		<link rel="stylesheet" href="/resources/css/font-awesome.min.css">
 		<link rel="stylesheet" href="/resources/css/tipsy.css">
 		<link rel="stylesheet" href="/resources/css/common.css">
@@ -9,12 +10,12 @@
 		<link rel="shortcut icon" class="favicon" href="/favicon.ico" type="image/vnd.microsoft.icon">
 		<script src="/resources/js/lib/markup.min.js"></script>
 		<script src="/resources/js/lib/moment.min.js"></script>
+		<script src="/resources/js/lib/ansispan.js"></script>
 		<script src="/resources/js/lib/diff-match-patch.min.js"></script>
 		<script src="/resources/js/lib/jquery-2_1_0.min.js"></script>
 		<script src="/resources/js/lib/jquery-ui-1_10_3-custom.min.js"></script>
 		<script src="/resources/js/lib/jquery.pretty-text-diff.min.js"></script>
 		<script src="/resources/js/lib/jquery.tipsy.min.js"></script>
-		<script src="/resources/js/lib/jquery.waypoints.sticky.min.js"></script>
 
 		<!-- Script ordering is important -->
 		<script src="/resources/js/poller.js"></script>
@@ -45,7 +46,7 @@
 					<ul class="float-right" id="control-buttons">
 						<li class="fa fa-pause" id="play-pause" title="Play/pause tests"></li>
 						<li class="fa fa-refresh" id="run-tests" title="Run tests"></li>
-						<li class="fa fa-clock-o" id="show-history" title="Test history"></li>
+						<li class="fa fa-history" id="show-history" title="Test history"></li>
 						<li class="fa fa-bell-o" id="toggle-notif" title="Toggle notifications"></li>
 						<li class="fa fa-cog" id="show-settings" title="Settings"></li>
 						<li class="fa fa-pencil-square-o" id="show-gen" title="Composer"></li>
@@ -74,7 +75,7 @@
 						</div>
 						<div class="setting">
 							<div class="setting-meta">
-								Default View
+								Default
 							</div>
 							<div class="setting-val">
 								<ol class="enum" id="pkg-expand-collapse">
@@ -94,6 +95,17 @@
 								</ol>
 							</div>
 						</div>
+						<div class="setting">
+							<div class="setting-meta">
+								Effects
+							</div>
+							<div class="setting-val">
+								<ol class="enum" id="ui-effects">
+									<li data-ui-effects="true">Cinematic</li>
+									<li data-ui-effects="false">Off</li>
+								</ol>
+							</div>
+						</div>
 					</div>
 				</div>
 
@@ -139,6 +151,23 @@
 
 
 
+				<div class="toggler" data-toggle="ignored">
+					Ignored
+				</div>
+				<div class="togglable" id="ignored"><!-- Populated by Javascript --></div>
+				<script id="tpl-ignored" type="text/template">
+					<div class="templated">
+						<div class="rtl pkg-list">
+						{{.}}
+							<div>
+								<a class="fa fa-level-down" href="#pkg-{{_id}}" style="padding: 0 5px;"></a>{{PackageName|boldPkgName}}
+							</div>
+						{{/.}}
+						</div>
+					</div>
+				</script>
+
+
 				<div class="toggler" data-toggle="notestfn">
 					No Test Functions
 				</div>
@@ -206,7 +235,7 @@
 						{{.}}
 						<div class="buildfail">
 							<div class="buildfail-pkg"><i class="fa fa-wrench"></i>&nbsp; {{PackageName|boldPkgName}}</div>
-							<div class="buildfail-output">{{BuildOutput|showhtml}}</div>
+							<div class="buildfail-output">{{BuildOutput|htmlSafe|ansiColours}}</div>
 						</div>
 						{{/.}}
 					</div>
@@ -223,19 +252,25 @@
 						{{.}}
 						<div class="panic">
 							<div class="panic-pkg">
-								<i class="fa fa-exclamation"></i>&nbsp; {{_pkg|boldPkgName}}
+								<i class="fa fa-bomb"></i>&nbsp; {{_pkg|boldPkgName}}
 							</div>
 						<div class="panic-details">
 							<div class="panic-story">
-							<div class="panic-file">{{if File|notempty}}{{File|relativePath|boldPkgName}}:{{Line}}{{else}}{{TestName}}{{/if}}</div>
-						{{if _path|notempty}}
-							{{_path}}
-								<div{{if Depth|more>-1}} class="depth-{{Depth}}"{{/if}}>{{Title}}</div>
-							{{/_path}}
-						{{/if}}
-								{{if StackTrace|notempty}}<div class="depth-{{_maxDepth}} panic-summary">{{Error}}</div>{{/if}}
+							<div class="panic-file">
+								{{if File|notempty}}
+								<a href="goconvey://open/?url=file://{{File|url}}&line={{Line}}">{{File|relativePath}}{{if Line|more>0}}:{{Line}}{{/if}}&nbsp; <i class="fa fa-external-link"></i></a>
+								{{else}}
+								<b>{{TestName}}</b>
+								{{/if}}
+						</div>
+					{{if _path|notempty}}
+						{{_path}}
+							<div class="story-links{{if Depth|more>-1}} depth-{{Depth}}{{/if}}"><a href="#test-{{_id}}">{{Title}}</a></div>
+						{{/_path}}
+					{{/if}}
+							{{if StackTrace|notempty}}<div class="depth-{{_maxDepth}} panic-summary">{{Error}}</div>{{/if}}
 							</div>
-							<div class="panic-output">{{if StackTrace|empty}}{{Error|showhtml}}{{else}}{{StackTrace|showhtml}}{{/if}}</div>
+							<div class="panic-output">{{if StackTrace|empty}}{{Error|htmlSafe|ansiColours}}{{else}}{{StackTrace|htmlSafe|ansiColours}}{{/if}}</div>
 						</div>
 						{{/.}}
 					</div>
@@ -252,26 +287,32 @@
 					<div class="templated">
 						{{.}}
 						<div class="failure">
-							<div class="failure-pkg"><i class="fa fa-chain-broken"></i>&nbsp; {{_pkg|boldPkgName}}</div>
+							<div class="failure-pkg"><i class="fa fa-file-code-o"></i>&nbsp; {{_pkg|boldPkgName}}</div>
 							<div class="failure-details">
 								<div class="failure-story">
-									<div class="failure-file"><a href="javascript:">{{if File|notempty}}{{File|relativePath|boldPkgName}}{{else}}{{TestName}}{{/if}}</b></a>&nbsp; &nbsp; &middot; &nbsp; &nbsp;{{if Line|more>0}}<a href="goconvey://open/?url=file://{{File|url}}&line={{Line}}"><i class="fa fa-share"></i> Line {{Line}}</a>{{/if}}</div>
+									<div class="failure-file">
+										{{if File|notempty}}
+										<a href="goconvey://open/?url=file://{{File|url}}&line={{Line}}">{{File|relativePath}}{{if Line|more>0}}:{{Line}}{{/if}}&nbsp; <i class="fa fa-external-link"></i></a>
+										{{else}}
+										<b class="test-name-link"><a href="#test-{{_id}}">{{TestName}}</a></b>
+										{{/if}}
+									</div>
 							{{if _path|notempty}}
 								{{_path}}
-									<div{{if Depth|more>-1}} class="depth-{{Depth}}"{{/if}}>{{Title}}</div>
+									<div class="story-links{{if Depth|more>-1}} depth-{{Depth}}{{/if}}"><a href="#test-{{_id}}">{{Title}}</a></div>
 								{{/_path}}
 							{{/if}}
 								</div>
-								<div class="failure-output">{{if Failure|notempty}}{{Failure|showhtml}}{{else}}{{if Message|notempty}}{{Message|showhtml}}{{else}}{{StackTrace|showhtml}}{{/if}}{{/if}}</div>
+								<div class="failure-output">{{if Failure|notempty}}{{Failure|htmlSafe|ansiColours}}{{else}}{{if Message|notempty}}{{Message|htmlSafe|ansiColours}}{{else}}{{StackTrace|htmlSafe|ansiColours}}{{/if}}{{/if}}</div>
 								{{if .|needsDiff}}
 								<table class="diffviewer">
 									<tr>
 										<td class="exp">Expected</td>
-										<td class="original">{{Expected|showhtml}}</td>
+										<td class="original">{{Expected|htmlSafe|ansiColours}}</td>
 									</tr>
 									<tr>
 										<td class="act">Actual</td>
-										<td class="changed">{{Actual|showhtml}}</td>
+										<td class="changed">{{Actual|htmlSafe|ansiColours}}</td>
 									</tr>
 									<tr>
 										<td>Diff</td>
@@ -315,11 +356,15 @@
 								{{if _skipped|more>0}}<span class="story-pkg-skip-count">&nbsp; <span class="statusicon skip"><b>S</b></span> {{_skipped}}</span>{{/if}}
 							</td>
 							<td class="story-pkg-watch-td">
+								{{if Outcome|equals>disabled}}
+								<span class="fa fa-lg fa-eye-slash disabled" title="Disabled"></span>
+								{{else}}
 								<a class="fa fa-lg ignore {{if Outcome|notequals>ignored}}fa-eye unwatch{{else}}fa-eye-slash watch clr-red{{/if}}" href="javascript:" title="Toggle ignore" data-pkg="{{PackageName}}"></a>
+								{{/if}}
 							</td>
 						</tr>
 						{{TestResults}}
-						<tr class="story-line {{if _status.class}}{{_status.class}}{{else}}skip{{/if}} test-{{_id}} pkg-{{_pkgid}}">
+						<tr id="test-{{_id}}" class="story-line {{if _status.class}}{{_status.class}}{{else}}skip{{/if}} test-{{_id}} pkg-{{_pkgid}}">
 							<td class="story-line-status"></td>
 							<td class="story-line-summary-container">
 								
@@ -332,8 +377,8 @@
 
 							</td>
 							<td colspan="3" class="depth-0 story-line-desc">
-								<b>{{TestName|htmlSafe}}</b>
-								{{if Message}}<div class="message">{{Message|htmlSafe}}</div>{{/if}}
+								<b>{{TestName|htmlSafe|ansiColours}}</b>
+								{{if Message}}<div class="message">{{Message|htmlSafe|ansiColours}}</div>{{/if}}
 							</td>
 						</tr>
 
@@ -351,25 +396,29 @@
 
 								</td>
 								<td colspan="3" class="depth-{{Depth}} story-line-desc">
-									{{Title|showhtml}}
-									{{if Output}}<div class="message">{{Output|htmlSafe}}</div>{{/if}}
+									{{Title|htmlSafe|ansiColours}}
+									{{if Output}}<div class="message">{{Output|htmlSafe|ansiColours}}</div>{{/if}}
 									{{if _failed}}
 										{{Assertions}}
+											{{if _failed}}
 											<div class="failure">
 												<div class="failure-details">
-													<div class="failure-output">{{if Failure|notempty}}{{Failure|showhtml}}{{else}}{{if Message|notempty}}{{Message|showhtml}}{{else}}
-															{{StackTrace|showhtml}}{{/if}}{{/if}}</div>
+													<div class="failure-output">{{if Failure|notempty}}{{Failure|htmlSafe|ansiColours}}{{else}}{{if Message|notempty}}{{Message|htmlSafe|ansiColours}}{{else}}
+															{{StackTrace|htmlSafe|ansiColours}}{{/if}}{{/if}}</div>
 												</div>
 											</div>
+											{{/if}}
 										{{/Assertions}}
 									{{/if}}
 									{{if _panicked}}
 										{{Assertions}}
+											{{if _panicked}}
 											<div class="panic">
 												<div class="panic-details">
-													<div class="panic-output">{{if Panic|notempty}}{{Panic|showhtml}}{{else}}{{if Message|notempty}}{{Message|showhtml}}{{else}}{{StackTrace|showhtml}}{{/if}}{{/if}}</div>
+													<div class="panic-output">{{if Panic|notempty}}{{Panic|htmlSafe|ansiColours}}{{else}}{{if Message|notempty}}{{Message|htmlSafe|ansiColours}}{{else}}{{StackTrace|htmlSafe|ansiColours}}{{/if}}{{/if}}</div>
 												</div>
 											</div>
+											{{/if}}
 										{{/Assertions}}
 									{{/if}}
 								</td>
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/common.css b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/common.css
index a607f0deb56..7aa56d1f668 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/common.css
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/common.css
@@ -13,10 +13,6 @@ html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abb
 	font-family: 'Oswald';
 	src: local("Oswald"), url("../fonts/Oswald/Oswald-Regular.ttf");
 }
-@font-face {
-	font-family: 'Share Tech Mono';
-	src: local("Share Tech Mono"), url("../fonts/Share_Tech_Mono/ShareTechMono-Regular.ttf");
-}
 
 ::selection {
 	background: #87AFBC;
@@ -217,6 +213,10 @@ footer .server-down {
 	margin-right: 5%;
 }
 
+.settings .setting:first-child {
+	margin-left: 5%;
+}
+
 .settings .setting .setting-meta {
 	text-align: right;
 	padding-right: 1em;
@@ -270,7 +270,7 @@ footer .server-down {
 }
 
 .history .item .summary {
-	font: 14px/1.5em 'Share Tech Mono', 'Monaco', 'Menlo', 'Courier New', monospace;
+	font: 14px/1.5em 'Monaco', 'Menlo', 'Courier New', monospace;
 }
 
 .history .item.selected {
@@ -362,7 +362,7 @@ footer .server-down {
 
 .pkg-cover-name,
 .pkg-list {
-	font-family: 'Menlo', 'Share Tech Mono', monospace;
+	font-family: 'Menlo', monospace;
 	font-size: 10px;
 	padding-right: 2%;
 	white-space: nowrap;
@@ -381,10 +381,9 @@ footer .server-down {
 	padding: 10px;
 	font-size: 12px;
 	line-height: 1.25em;
-	max-height: 150px;
 	overflow-y: auto;
 	white-space: pre-wrap;
-	font-family: 'Menlo', 'Share Tech Mono', monospace;
+	font-family: 'Menlo', monospace;
 }
 
 .panic-story,
@@ -418,6 +417,12 @@ footer .server-down {
 	font-size: 14px;
 }
 
+.diffviewer .original,
+.diffviewer .changed,
+.diffviewer .diff {
+	white-space: pre-wrap;
+}
+
 .diffviewer tr:first-child td {
 	border-top-width: 1px;
 	border-top-style: solid;
@@ -498,7 +503,7 @@ footer .server-down {
 }
 
 .story-line-desc .message {
-	font-family: 'Menlo', 'Share Tech Mono', monospace;
+	font-family: 'Menlo', monospace;
 	white-space: pre-wrap;
 }
 
@@ -954,4 +959,4 @@ footer .server-down .notice-message {
 
 #coverage:hover .pkg-cover {
 	-webkit-transform: rotateX(180deg);
-}*/
\ No newline at end of file
+}*/
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/font-awesome.min.css b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/font-awesome.min.css
index 9ec4d0395b4..40403f53189 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/font-awesome.min.css
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/font-awesome.min.css
@@ -1,5 +1,5 @@
 /*!
- *  Font Awesome 4.0.3 by @davegandy - http://fontawesome.io - @fontawesome
+ *  Font Awesome 4.1.0 by @davegandy - http://fontawesome.io - @fontawesome
  *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
  */
- @font-face{font-family:'FontAwesome';src:url('../fonts/FontAwesome/fontawesome-webfont.eot?v=4.0.3');src:url('../fonts/FontAwesome/fontawesome-webfont.eot?#iefix&v=4.0.3') format('embedded-opentype'),url('../fonts/FontAwesome/fontawesome-webfont.woff?v=4.0.3') format('woff'),url('../fonts/FontAwesome/fontawesome-webfont.ttf?v=4.0.3') format('truetype'),url('../fonts/FontAwesome/fontawesome-webfont.svg?v=4.0.3#fontawesomeregular') format('svg');font-weight:normal;font-style:normal}.fa{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.3333333333333333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.2857142857142858em;text-align:center}.fa-ul{padding-left:0;margin-left:2.142857142857143em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.142857142857143em;width:2.142857142857143em;top:.14285714285714285em;text-align:center}.fa-li.fa-lg{left:-1.8571428571428572em}.fa-border{padding:.2em .25em .15em;border:solid .08em #eee;border-radius:.1em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:spin 2s infinite linear;-moz-animation:spin 2s infinite linear;-o-animation:spin 2s infinite linear;animation:spin 2s infinite linear}@-moz-keyframes spin{0%{-moz-transform:rotate(0deg)}100%{-moz-transform:rotate(359deg)}}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg)}}@-o-keyframes spin{0%{-o-transform:rotate(0deg)}100%{-o-transform:rotate(359deg)}}@-ms-keyframes spin{0%{-ms-transform:rotate(0deg)}100%{-ms-transform:rotate(359deg)}}@keyframes spin{0%{transform:rotate(0deg)}100%{transform:rotate(359deg)}}.fa-rotate-90{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=1);-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2);-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=3);-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=0,mirror=1);-webkit-transform:scale(-1,1);-moz-transform:scale(-1,1);-ms-transform:scale(-1,1);-o-transform:scale(-1,1);transform:scale(-1,1)}.fa-flip-vertical{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2,mirror=1);-webkit-transform:scale(1,-1);-moz-transform:scale(1,-1);-ms-transform:scale(1,-1);-o-transform:scale(1,-1);transform:scale(1,-1)}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:"\f000"}.fa-music:before{content:"\f001"}.fa-search:before{content:"\f002"}.fa-envelope-o:before{content:"\f003"}.fa-heart:before{content:"\f004"}.fa-star:before{content:"\f005"}.fa-star-o:before{content:"\f006"}.fa-user:before{content:"\f007"}.fa-film:before{content:"\f008"}.fa-th-large:before{content:"\f009"}.fa-th:before{content:"\f00a"}.fa-th-list:before{content:"\f00b"}.fa-check:before{content:"\f00c"}.fa-times:before{content:"\f00d"}.fa-search-plus:before{content:"\f00e"}.fa-search-minus:before{content:"\f010"}.fa-power-off:before{content:"\f011"}.fa-signal:before{content:"\f012"}.fa-gear:before,.fa-cog:before{content:"\f013"}.fa-trash-o:before{content:"\f014"}.fa-home:before{content:"\f015"}.fa-file-o:before{content:"\f016"}.fa-clock-o:before{content:"\f017"}.fa-road:before{content:"\f018"}.fa-download:before{content:"\f019"}.fa-arrow-circle-o-down:before{content:"\f01a"}.fa-arrow-circle-o-up:before{content:"\f01b"}.fa-inbox:before{content:"\f01c"}.fa-play-circle-o:before{content:"\f01d"}.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}.fa-refresh:before{content:"\f021"}.fa-list-alt:before{content:"\f022"}.fa-lock:before{content:"\f023"}.fa-flag:before{content:"\f024"}.fa-headphones:before{content:"\f025"}.fa-volume-off:before{content:"\f026"}.fa-volume-down:before{content:"\f027"}.fa-volume-up:before{content:"\f028"}.fa-qrcode:before{content:"\f029"}.fa-barcode:before{content:"\f02a"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-book:before{content:"\f02d"}.fa-bookmark:before{content:"\f02e"}.fa-print:before{content:"\f02f"}.fa-camera:before{content:"\f030"}.fa-font:before{content:"\f031"}.fa-bold:before{content:"\f032"}.fa-italic:before{content:"\f033"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-align-left:before{content:"\f036"}.fa-align-center:before{content:"\f037"}.fa-align-right:before{content:"\f038"}.fa-align-justify:before{content:"\f039"}.fa-list:before{content:"\f03a"}.fa-dedent:before,.fa-outdent:before{content:"\f03b"}.fa-indent:before{content:"\f03c"}.fa-video-camera:before{content:"\f03d"}.fa-picture-o:before{content:"\f03e"}.fa-pencil:before{content:"\f040"}.fa-map-marker:before{content:"\f041"}.fa-adjust:before{content:"\f042"}.fa-tint:before{content:"\f043"}.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}.fa-share-square-o:before{content:"\f045"}.fa-check-square-o:before{content:"\f046"}.fa-arrows:before{content:"\f047"}.fa-step-backward:before{content:"\f048"}.fa-fast-backward:before{content:"\f049"}.fa-backward:before{content:"\f04a"}.fa-play:before{content:"\f04b"}.fa-pause:before{content:"\f04c"}.fa-stop:before{content:"\f04d"}.fa-forward:before{content:"\f04e"}.fa-fast-forward:before{content:"\f050"}.fa-step-forward:before{content:"\f051"}.fa-eject:before{content:"\f052"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-plus-circle:before{content:"\f055"}.fa-minus-circle:before{content:"\f056"}.fa-times-circle:before{content:"\f057"}.fa-check-circle:before{content:"\f058"}.fa-question-circle:before{content:"\f059"}.fa-info-circle:before{content:"\f05a"}.fa-crosshairs:before{content:"\f05b"}.fa-times-circle-o:before{content:"\f05c"}.fa-check-circle-o:before{content:"\f05d"}.fa-ban:before{content:"\f05e"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrow-down:before{content:"\f063"}.fa-mail-forward:before,.fa-share:before{content:"\f064"}.fa-expand:before{content:"\f065"}.fa-compress:before{content:"\f066"}.fa-plus:before{content:"\f067"}.fa-minus:before{content:"\f068"}.fa-asterisk:before{content:"\f069"}.fa-exclamation-circle:before{content:"\f06a"}.fa-gift:before{content:"\f06b"}.fa-leaf:before{content:"\f06c"}.fa-fire:before{content:"\f06d"}.fa-eye:before{content:"\f06e"}.fa-eye-slash:before{content:"\f070"}.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}.fa-plane:before{content:"\f072"}.fa-calendar:before{content:"\f073"}.fa-random:before{content:"\f074"}.fa-comment:before{content:"\f075"}.fa-magnet:before{content:"\f076"}.fa-chevron-up:before{content:"\f077"}.fa-chevron-down:before{content:"\f078"}.fa-retweet:before{content:"\f079"}.fa-shopping-cart:before{content:"\f07a"}.fa-folder:before{content:"\f07b"}.fa-folder-open:before{content:"\f07c"}.fa-arrows-v:before{content:"\f07d"}.fa-arrows-h:before{content:"\f07e"}.fa-bar-chart-o:before{content:"\f080"}.fa-twitter-square:before{content:"\f081"}.fa-facebook-square:before{content:"\f082"}.fa-camera-retro:before{content:"\f083"}.fa-key:before{content:"\f084"}.fa-gears:before,.fa-cogs:before{content:"\f085"}.fa-comments:before{content:"\f086"}.fa-thumbs-o-up:before{content:"\f087"}.fa-thumbs-o-down:before{content:"\f088"}.fa-star-half:before{content:"\f089"}.fa-heart-o:before{content:"\f08a"}.fa-sign-out:before{content:"\f08b"}.fa-linkedin-square:before{content:"\f08c"}.fa-thumb-tack:before{content:"\f08d"}.fa-external-link:before{content:"\f08e"}.fa-sign-in:before{content:"\f090"}.fa-trophy:before{content:"\f091"}.fa-github-square:before{content:"\f092"}.fa-upload:before{content:"\f093"}.fa-lemon-o:before{content:"\f094"}.fa-phone:before{content:"\f095"}.fa-square-o:before{content:"\f096"}.fa-bookmark-o:before{content:"\f097"}.fa-phone-square:before{content:"\f098"}.fa-twitter:before{content:"\f099"}.fa-facebook:before{content:"\f09a"}.fa-github:before{content:"\f09b"}.fa-unlock:before{content:"\f09c"}.fa-credit-card:before{content:"\f09d"}.fa-rss:before{content:"\f09e"}.fa-hdd-o:before{content:"\f0a0"}.fa-bullhorn:before{content:"\f0a1"}.fa-bell:before{content:"\f0f3"}.fa-certificate:before{content:"\f0a3"}.fa-hand-o-right:before{content:"\f0a4"}.fa-hand-o-left:before{content:"\f0a5"}.fa-hand-o-up:before{content:"\f0a6"}.fa-hand-o-down:before{content:"\f0a7"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-globe:before{content:"\f0ac"}.fa-wrench:before{content:"\f0ad"}.fa-tasks:before{content:"\f0ae"}.fa-filter:before{content:"\f0b0"}.fa-briefcase:before{content:"\f0b1"}.fa-arrows-alt:before{content:"\f0b2"}.fa-group:before,.fa-users:before{content:"\f0c0"}.fa-chain:before,.fa-link:before{content:"\f0c1"}.fa-cloud:before{content:"\f0c2"}.fa-flask:before{content:"\f0c3"}.fa-cut:before,.fa-scissors:before{content:"\f0c4"}.fa-copy:before,.fa-files-o:before{content:"\f0c5"}.fa-paperclip:before{content:"\f0c6"}.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}.fa-square:before{content:"\f0c8"}.fa-bars:before{content:"\f0c9"}.fa-list-ul:before{content:"\f0ca"}.fa-list-ol:before{content:"\f0cb"}.fa-strikethrough:before{content:"\f0cc"}.fa-underline:before{content:"\f0cd"}.fa-table:before{content:"\f0ce"}.fa-magic:before{content:"\f0d0"}.fa-truck:before{content:"\f0d1"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-square:before{content:"\f0d3"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-plus:before{content:"\f0d5"}.fa-money:before{content:"\f0d6"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-columns:before{content:"\f0db"}.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}.fa-sort-down:before,.fa-sort-asc:before{content:"\f0dd"}.fa-sort-up:before,.fa-sort-desc:before{content:"\f0de"}.fa-envelope:before{content:"\f0e0"}.fa-linkedin:before{content:"\f0e1"}.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}.fa-legal:before,.fa-gavel:before{content:"\f0e3"}.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}.fa-comment-o:before{content:"\f0e5"}.fa-comments-o:before{content:"\f0e6"}.fa-flash:before,.fa-bolt:before{content:"\f0e7"}.fa-sitemap:before{content:"\f0e8"}.fa-umbrella:before{content:"\f0e9"}.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}.fa-lightbulb-o:before{content:"\f0eb"}.fa-exchange:before{content:"\f0ec"}.fa-cloud-download:before{content:"\f0ed"}.fa-cloud-upload:before{content:"\f0ee"}.fa-user-md:before{content:"\f0f0"}.fa-stethoscope:before{content:"\f0f1"}.fa-suitcase:before{content:"\f0f2"}.fa-bell-o:before{content:"\f0a2"}.fa-coffee:before{content:"\f0f4"}.fa-cutlery:before{content:"\f0f5"}.fa-file-text-o:before{content:"\f0f6"}.fa-building-o:before{content:"\f0f7"}.fa-hospital-o:before{content:"\f0f8"}.fa-ambulance:before{content:"\f0f9"}.fa-medkit:before{content:"\f0fa"}.fa-fighter-jet:before{content:"\f0fb"}.fa-beer:before{content:"\f0fc"}.fa-h-square:before{content:"\f0fd"}.fa-plus-square:before{content:"\f0fe"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angle-down:before{content:"\f107"}.fa-desktop:before{content:"\f108"}.fa-laptop:before{content:"\f109"}.fa-tablet:before{content:"\f10a"}.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}.fa-circle-o:before{content:"\f10c"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-spinner:before{content:"\f110"}.fa-circle:before{content:"\f111"}.fa-mail-reply:before,.fa-reply:before{content:"\f112"}.fa-github-alt:before{content:"\f113"}.fa-folder-o:before{content:"\f114"}.fa-folder-open-o:before{content:"\f115"}.fa-smile-o:before{content:"\f118"}.fa-frown-o:before{content:"\f119"}.fa-meh-o:before{content:"\f11a"}.fa-gamepad:before{content:"\f11b"}.fa-keyboard-o:before{content:"\f11c"}.fa-flag-o:before{content:"\f11d"}.fa-flag-checkered:before{content:"\f11e"}.fa-terminal:before{content:"\f120"}.fa-code:before{content:"\f121"}.fa-reply-all:before{content:"\f122"}.fa-mail-reply-all:before{content:"\f122"}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}.fa-location-arrow:before{content:"\f124"}.fa-crop:before{content:"\f125"}.fa-code-fork:before{content:"\f126"}.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}.fa-question:before{content:"\f128"}.fa-info:before{content:"\f129"}.fa-exclamation:before{content:"\f12a"}.fa-superscript:before{content:"\f12b"}.fa-subscript:before{content:"\f12c"}.fa-eraser:before{content:"\f12d"}.fa-puzzle-piece:before{content:"\f12e"}.fa-microphone:before{content:"\f130"}.fa-microphone-slash:before{content:"\f131"}.fa-shield:before{content:"\f132"}.fa-calendar-o:before{content:"\f133"}.fa-fire-extinguisher:before{content:"\f134"}.fa-rocket:before{content:"\f135"}.fa-maxcdn:before{content:"\f136"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-html5:before{content:"\f13b"}.fa-css3:before{content:"\f13c"}.fa-anchor:before{content:"\f13d"}.fa-unlock-alt:before{content:"\f13e"}.fa-bullseye:before{content:"\f140"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-rss-square:before{content:"\f143"}.fa-play-circle:before{content:"\f144"}.fa-ticket:before{content:"\f145"}.fa-minus-square:before{content:"\f146"}.fa-minus-square-o:before{content:"\f147"}.fa-level-up:before{content:"\f148"}.fa-level-down:before{content:"\f149"}.fa-check-square:before{content:"\f14a"}.fa-pencil-square:before{content:"\f14b"}.fa-external-link-square:before{content:"\f14c"}.fa-share-square:before{content:"\f14d"}.fa-compass:before{content:"\f14e"}.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}.fa-euro:before,.fa-eur:before{content:"\f153"}.fa-gbp:before{content:"\f154"}.fa-dollar:before,.fa-usd:before{content:"\f155"}.fa-rupee:before,.fa-inr:before{content:"\f156"}.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}.fa-won:before,.fa-krw:before{content:"\f159"}.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}.fa-file:before{content:"\f15b"}.fa-file-text:before{content:"\f15c"}.fa-sort-alpha-asc:before{content:"\f15d"}.fa-sort-alpha-desc:before{content:"\f15e"}.fa-sort-amount-asc:before{content:"\f160"}.fa-sort-amount-desc:before{content:"\f161"}.fa-sort-numeric-asc:before{content:"\f162"}.fa-sort-numeric-desc:before{content:"\f163"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbs-down:before{content:"\f165"}.fa-youtube-square:before{content:"\f166"}.fa-youtube:before{content:"\f167"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-youtube-play:before{content:"\f16a"}.fa-dropbox:before{content:"\f16b"}.fa-stack-overflow:before{content:"\f16c"}.fa-instagram:before{content:"\f16d"}.fa-flickr:before{content:"\f16e"}.fa-adn:before{content:"\f170"}.fa-bitbucket:before{content:"\f171"}.fa-bitbucket-square:before{content:"\f172"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-long-arrow-down:before{content:"\f175"}.fa-long-arrow-up:before{content:"\f176"}.fa-long-arrow-left:before{content:"\f177"}.fa-long-arrow-right:before{content:"\f178"}.fa-apple:before{content:"\f179"}.fa-windows:before{content:"\f17a"}.fa-android:before{content:"\f17b"}.fa-linux:before{content:"\f17c"}.fa-dribbble:before{content:"\f17d"}.fa-skype:before{content:"\f17e"}.fa-foursquare:before{content:"\f180"}.fa-trello:before{content:"\f181"}.fa-female:before{content:"\f182"}.fa-male:before{content:"\f183"}.fa-gittip:before{content:"\f184"}.fa-sun-o:before{content:"\f185"}.fa-moon-o:before{content:"\f186"}.fa-archive:before{content:"\f187"}.fa-bug:before{content:"\f188"}.fa-vk:before{content:"\f189"}.fa-weibo:before{content:"\f18a"}.fa-renren:before{content:"\f18b"}.fa-pagelines:before{content:"\f18c"}.fa-stack-exchange:before{content:"\f18d"}.fa-arrow-circle-o-right:before{content:"\f18e"}.fa-arrow-circle-o-left:before{content:"\f190"}.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}.fa-dot-circle-o:before{content:"\f192"}.fa-wheelchair:before{content:"\f193"}.fa-vimeo-square:before{content:"\f194"}.fa-turkish-lira:before,.fa-try:before{content:"\f195"}.fa-plus-square-o:before{content:"\f196"}
\ No newline at end of file
+ @font-face{font-family:'FontAwesome';src:url('../fonts/FontAwesome/fontawesome-webfont.eot?v=4.1.0');src:url('../fonts/FontAwesome/fontawesome-webfont.eot?#iefix&v=4.1.0') format('embedded-opentype'),url('../fonts/FontAwesome/fontawesome-webfont.woff?v=4.1.0') format('woff'),url('../fonts/FontAwesome/fontawesome-webfont.ttf?v=4.1.0') format('truetype'),url('../fonts/FontAwesome/fontawesome-webfont.svg?v=4.1.0#fontawesomeregular') format('svg');font-weight:normal;font-style:normal}.fa{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14285714em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14285714em;width:2.14285714em;top:.14285714em;text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em;border:solid .08em #eee;border-radius:.1em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:spin 2s infinite linear;-moz-animation:spin 2s infinite linear;-o-animation:spin 2s infinite linear;animation:spin 2s infinite linear}@-moz-keyframes spin{0%{-moz-transform:rotate(0deg)}100%{-moz-transform:rotate(359deg)}}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg)}}@-o-keyframes spin{0%{-o-transform:rotate(0deg)}100%{-o-transform:rotate(359deg)}}@keyframes spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=1);-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2);-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=3);-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);-webkit-transform:scale(-1, 1);-moz-transform:scale(-1, 1);-ms-transform:scale(-1, 1);-o-transform:scale(-1, 1);transform:scale(-1, 1)}.fa-flip-vertical{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);-webkit-transform:scale(1, -1);-moz-transform:scale(1, -1);-ms-transform:scale(1, -1);-o-transform:scale(1, -1);transform:scale(1, -1)}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:"\f000"}.fa-music:before{content:"\f001"}.fa-search:before{content:"\f002"}.fa-envelope-o:before{content:"\f003"}.fa-heart:before{content:"\f004"}.fa-star:before{content:"\f005"}.fa-star-o:before{content:"\f006"}.fa-user:before{content:"\f007"}.fa-film:before{content:"\f008"}.fa-th-large:before{content:"\f009"}.fa-th:before{content:"\f00a"}.fa-th-list:before{content:"\f00b"}.fa-check:before{content:"\f00c"}.fa-times:before{content:"\f00d"}.fa-search-plus:before{content:"\f00e"}.fa-search-minus:before{content:"\f010"}.fa-power-off:before{content:"\f011"}.fa-signal:before{content:"\f012"}.fa-gear:before,.fa-cog:before{content:"\f013"}.fa-trash-o:before{content:"\f014"}.fa-home:before{content:"\f015"}.fa-file-o:before{content:"\f016"}.fa-clock-o:before{content:"\f017"}.fa-road:before{content:"\f018"}.fa-download:before{content:"\f019"}.fa-arrow-circle-o-down:before{content:"\f01a"}.fa-arrow-circle-o-up:before{content:"\f01b"}.fa-inbox:before{content:"\f01c"}.fa-play-circle-o:before{content:"\f01d"}.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}.fa-refresh:before{content:"\f021"}.fa-list-alt:before{content:"\f022"}.fa-lock:before{content:"\f023"}.fa-flag:before{content:"\f024"}.fa-headphones:before{content:"\f025"}.fa-volume-off:before{content:"\f026"}.fa-volume-down:before{content:"\f027"}.fa-volume-up:before{content:"\f028"}.fa-qrcode:before{content:"\f029"}.fa-barcode:before{content:"\f02a"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-book:before{content:"\f02d"}.fa-bookmark:before{content:"\f02e"}.fa-print:before{content:"\f02f"}.fa-camera:before{content:"\f030"}.fa-font:before{content:"\f031"}.fa-bold:before{content:"\f032"}.fa-italic:before{content:"\f033"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-align-left:before{content:"\f036"}.fa-align-center:before{content:"\f037"}.fa-align-right:before{content:"\f038"}.fa-align-justify:before{content:"\f039"}.fa-list:before{content:"\f03a"}.fa-dedent:before,.fa-outdent:before{content:"\f03b"}.fa-indent:before{content:"\f03c"}.fa-video-camera:before{content:"\f03d"}.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"}.fa-pencil:before{content:"\f040"}.fa-map-marker:before{content:"\f041"}.fa-adjust:before{content:"\f042"}.fa-tint:before{content:"\f043"}.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}.fa-share-square-o:before{content:"\f045"}.fa-check-square-o:before{content:"\f046"}.fa-arrows:before{content:"\f047"}.fa-step-backward:before{content:"\f048"}.fa-fast-backward:before{content:"\f049"}.fa-backward:before{content:"\f04a"}.fa-play:before{content:"\f04b"}.fa-pause:before{content:"\f04c"}.fa-stop:before{content:"\f04d"}.fa-forward:before{content:"\f04e"}.fa-fast-forward:before{content:"\f050"}.fa-step-forward:before{content:"\f051"}.fa-eject:before{content:"\f052"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-plus-circle:before{content:"\f055"}.fa-minus-circle:before{content:"\f056"}.fa-times-circle:before{content:"\f057"}.fa-check-circle:before{content:"\f058"}.fa-question-circle:before{content:"\f059"}.fa-info-circle:before{content:"\f05a"}.fa-crosshairs:before{content:"\f05b"}.fa-times-circle-o:before{content:"\f05c"}.fa-check-circle-o:before{content:"\f05d"}.fa-ban:before{content:"\f05e"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrow-down:before{content:"\f063"}.fa-mail-forward:before,.fa-share:before{content:"\f064"}.fa-expand:before{content:"\f065"}.fa-compress:before{content:"\f066"}.fa-plus:before{content:"\f067"}.fa-minus:before{content:"\f068"}.fa-asterisk:before{content:"\f069"}.fa-exclamation-circle:before{content:"\f06a"}.fa-gift:before{content:"\f06b"}.fa-leaf:before{content:"\f06c"}.fa-fire:before{content:"\f06d"}.fa-eye:before{content:"\f06e"}.fa-eye-slash:before{content:"\f070"}.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}.fa-plane:before{content:"\f072"}.fa-calendar:before{content:"\f073"}.fa-random:before{content:"\f074"}.fa-comment:before{content:"\f075"}.fa-magnet:before{content:"\f076"}.fa-chevron-up:before{content:"\f077"}.fa-chevron-down:before{content:"\f078"}.fa-retweet:before{content:"\f079"}.fa-shopping-cart:before{content:"\f07a"}.fa-folder:before{content:"\f07b"}.fa-folder-open:before{content:"\f07c"}.fa-arrows-v:before{content:"\f07d"}.fa-arrows-h:before{content:"\f07e"}.fa-bar-chart-o:before{content:"\f080"}.fa-twitter-square:before{content:"\f081"}.fa-facebook-square:before{content:"\f082"}.fa-camera-retro:before{content:"\f083"}.fa-key:before{content:"\f084"}.fa-gears:before,.fa-cogs:before{content:"\f085"}.fa-comments:before{content:"\f086"}.fa-thumbs-o-up:before{content:"\f087"}.fa-thumbs-o-down:before{content:"\f088"}.fa-star-half:before{content:"\f089"}.fa-heart-o:before{content:"\f08a"}.fa-sign-out:before{content:"\f08b"}.fa-linkedin-square:before{content:"\f08c"}.fa-thumb-tack:before{content:"\f08d"}.fa-external-link:before{content:"\f08e"}.fa-sign-in:before{content:"\f090"}.fa-trophy:before{content:"\f091"}.fa-github-square:before{content:"\f092"}.fa-upload:before{content:"\f093"}.fa-lemon-o:before{content:"\f094"}.fa-phone:before{content:"\f095"}.fa-square-o:before{content:"\f096"}.fa-bookmark-o:before{content:"\f097"}.fa-phone-square:before{content:"\f098"}.fa-twitter:before{content:"\f099"}.fa-facebook:before{content:"\f09a"}.fa-github:before{content:"\f09b"}.fa-unlock:before{content:"\f09c"}.fa-credit-card:before{content:"\f09d"}.fa-rss:before{content:"\f09e"}.fa-hdd-o:before{content:"\f0a0"}.fa-bullhorn:before{content:"\f0a1"}.fa-bell:before{content:"\f0f3"}.fa-certificate:before{content:"\f0a3"}.fa-hand-o-right:before{content:"\f0a4"}.fa-hand-o-left:before{content:"\f0a5"}.fa-hand-o-up:before{content:"\f0a6"}.fa-hand-o-down:before{content:"\f0a7"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-globe:before{content:"\f0ac"}.fa-wrench:before{content:"\f0ad"}.fa-tasks:before{content:"\f0ae"}.fa-filter:before{content:"\f0b0"}.fa-briefcase:before{content:"\f0b1"}.fa-arrows-alt:before{content:"\f0b2"}.fa-group:before,.fa-users:before{content:"\f0c0"}.fa-chain:before,.fa-link:before{content:"\f0c1"}.fa-cloud:before{content:"\f0c2"}.fa-flask:before{content:"\f0c3"}.fa-cut:before,.fa-scissors:before{content:"\f0c4"}.fa-copy:before,.fa-files-o:before{content:"\f0c5"}.fa-paperclip:before{content:"\f0c6"}.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}.fa-square:before{content:"\f0c8"}.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"}.fa-list-ul:before{content:"\f0ca"}.fa-list-ol:before{content:"\f0cb"}.fa-strikethrough:before{content:"\f0cc"}.fa-underline:before{content:"\f0cd"}.fa-table:before{content:"\f0ce"}.fa-magic:before{content:"\f0d0"}.fa-truck:before{content:"\f0d1"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-square:before{content:"\f0d3"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-plus:before{content:"\f0d5"}.fa-money:before{content:"\f0d6"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-columns:before{content:"\f0db"}.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"}.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"}.fa-envelope:before{content:"\f0e0"}.fa-linkedin:before{content:"\f0e1"}.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}.fa-legal:before,.fa-gavel:before{content:"\f0e3"}.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}.fa-comment-o:before{content:"\f0e5"}.fa-comments-o:before{content:"\f0e6"}.fa-flash:before,.fa-bolt:before{content:"\f0e7"}.fa-sitemap:before{content:"\f0e8"}.fa-umbrella:before{content:"\f0e9"}.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}.fa-lightbulb-o:before{content:"\f0eb"}.fa-exchange:before{content:"\f0ec"}.fa-cloud-download:before{content:"\f0ed"}.fa-cloud-upload:before{content:"\f0ee"}.fa-user-md:before{content:"\f0f0"}.fa-stethoscope:before{content:"\f0f1"}.fa-suitcase:before{content:"\f0f2"}.fa-bell-o:before{content:"\f0a2"}.fa-coffee:before{content:"\f0f4"}.fa-cutlery:before{content:"\f0f5"}.fa-file-text-o:before{content:"\f0f6"}.fa-building-o:before{content:"\f0f7"}.fa-hospital-o:before{content:"\f0f8"}.fa-ambulance:before{content:"\f0f9"}.fa-medkit:before{content:"\f0fa"}.fa-fighter-jet:before{content:"\f0fb"}.fa-beer:before{content:"\f0fc"}.fa-h-square:before{content:"\f0fd"}.fa-plus-square:before{content:"\f0fe"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angle-down:before{content:"\f107"}.fa-desktop:before{content:"\f108"}.fa-laptop:before{content:"\f109"}.fa-tablet:before{content:"\f10a"}.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}.fa-circle-o:before{content:"\f10c"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-spinner:before{content:"\f110"}.fa-circle:before{content:"\f111"}.fa-mail-reply:before,.fa-reply:before{content:"\f112"}.fa-github-alt:before{content:"\f113"}.fa-folder-o:before{content:"\f114"}.fa-folder-open-o:before{content:"\f115"}.fa-smile-o:before{content:"\f118"}.fa-frown-o:before{content:"\f119"}.fa-meh-o:before{content:"\f11a"}.fa-gamepad:before{content:"\f11b"}.fa-keyboard-o:before{content:"\f11c"}.fa-flag-o:before{content:"\f11d"}.fa-flag-checkered:before{content:"\f11e"}.fa-terminal:before{content:"\f120"}.fa-code:before{content:"\f121"}.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}.fa-location-arrow:before{content:"\f124"}.fa-crop:before{content:"\f125"}.fa-code-fork:before{content:"\f126"}.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}.fa-question:before{content:"\f128"}.fa-info:before{content:"\f129"}.fa-exclamation:before{content:"\f12a"}.fa-superscript:before{content:"\f12b"}.fa-subscript:before{content:"\f12c"}.fa-eraser:before{content:"\f12d"}.fa-puzzle-piece:before{content:"\f12e"}.fa-microphone:before{content:"\f130"}.fa-microphone-slash:before{content:"\f131"}.fa-shield:before{content:"\f132"}.fa-calendar-o:before{content:"\f133"}.fa-fire-extinguisher:before{content:"\f134"}.fa-rocket:before{content:"\f135"}.fa-maxcdn:before{content:"\f136"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-html5:before{content:"\f13b"}.fa-css3:before{content:"\f13c"}.fa-anchor:before{content:"\f13d"}.fa-unlock-alt:before{content:"\f13e"}.fa-bullseye:before{content:"\f140"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-rss-square:before{content:"\f143"}.fa-play-circle:before{content:"\f144"}.fa-ticket:before{content:"\f145"}.fa-minus-square:before{content:"\f146"}.fa-minus-square-o:before{content:"\f147"}.fa-level-up:before{content:"\f148"}.fa-level-down:before{content:"\f149"}.fa-check-square:before{content:"\f14a"}.fa-pencil-square:before{content:"\f14b"}.fa-external-link-square:before{content:"\f14c"}.fa-share-square:before{content:"\f14d"}.fa-compass:before{content:"\f14e"}.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}.fa-euro:before,.fa-eur:before{content:"\f153"}.fa-gbp:before{content:"\f154"}.fa-dollar:before,.fa-usd:before{content:"\f155"}.fa-rupee:before,.fa-inr:before{content:"\f156"}.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}.fa-won:before,.fa-krw:before{content:"\f159"}.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}.fa-file:before{content:"\f15b"}.fa-file-text:before{content:"\f15c"}.fa-sort-alpha-asc:before{content:"\f15d"}.fa-sort-alpha-desc:before{content:"\f15e"}.fa-sort-amount-asc:before{content:"\f160"}.fa-sort-amount-desc:before{content:"\f161"}.fa-sort-numeric-asc:before{content:"\f162"}.fa-sort-numeric-desc:before{content:"\f163"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbs-down:before{content:"\f165"}.fa-youtube-square:before{content:"\f166"}.fa-youtube:before{content:"\f167"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-youtube-play:before{content:"\f16a"}.fa-dropbox:before{content:"\f16b"}.fa-stack-overflow:before{content:"\f16c"}.fa-instagram:before{content:"\f16d"}.fa-flickr:before{content:"\f16e"}.fa-adn:before{content:"\f170"}.fa-bitbucket:before{content:"\f171"}.fa-bitbucket-square:before{content:"\f172"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-long-arrow-down:before{content:"\f175"}.fa-long-arrow-up:before{content:"\f176"}.fa-long-arrow-left:before{content:"\f177"}.fa-long-arrow-right:before{content:"\f178"}.fa-apple:before{content:"\f179"}.fa-windows:before{content:"\f17a"}.fa-android:before{content:"\f17b"}.fa-linux:before{content:"\f17c"}.fa-dribbble:before{content:"\f17d"}.fa-skype:before{content:"\f17e"}.fa-foursquare:before{content:"\f180"}.fa-trello:before{content:"\f181"}.fa-female:before{content:"\f182"}.fa-male:before{content:"\f183"}.fa-gittip:before{content:"\f184"}.fa-sun-o:before{content:"\f185"}.fa-moon-o:before{content:"\f186"}.fa-archive:before{content:"\f187"}.fa-bug:before{content:"\f188"}.fa-vk:before{content:"\f189"}.fa-weibo:before{content:"\f18a"}.fa-renren:before{content:"\f18b"}.fa-pagelines:before{content:"\f18c"}.fa-stack-exchange:before{content:"\f18d"}.fa-arrow-circle-o-right:before{content:"\f18e"}.fa-arrow-circle-o-left:before{content:"\f190"}.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}.fa-dot-circle-o:before{content:"\f192"}.fa-wheelchair:before{content:"\f193"}.fa-vimeo-square:before{content:"\f194"}.fa-turkish-lira:before,.fa-try:before{content:"\f195"}.fa-plus-square-o:before{content:"\f196"}.fa-space-shuttle:before{content:"\f197"}.fa-slack:before{content:"\f198"}.fa-envelope-square:before{content:"\f199"}.fa-wordpress:before{content:"\f19a"}.fa-openid:before{content:"\f19b"}.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"}.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"}.fa-yahoo:before{content:"\f19e"}.fa-google:before{content:"\f1a0"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-square:before{content:"\f1a2"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-stumbleupon:before{content:"\f1a4"}.fa-delicious:before{content:"\f1a5"}.fa-digg:before{content:"\f1a6"}.fa-pied-piper-square:before,.fa-pied-piper:before{content:"\f1a7"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-drupal:before{content:"\f1a9"}.fa-joomla:before{content:"\f1aa"}.fa-language:before{content:"\f1ab"}.fa-fax:before{content:"\f1ac"}.fa-building:before{content:"\f1ad"}.fa-child:before{content:"\f1ae"}.fa-paw:before{content:"\f1b0"}.fa-spoon:before{content:"\f1b1"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-recycle:before{content:"\f1b8"}.fa-automobile:before,.fa-car:before{content:"\f1b9"}.fa-cab:before,.fa-taxi:before{content:"\f1ba"}.fa-tree:before{content:"\f1bb"}.fa-spotify:before{content:"\f1bc"}.fa-deviantart:before{content:"\f1bd"}.fa-soundcloud:before{content:"\f1be"}.fa-database:before{content:"\f1c0"}.fa-file-pdf-o:before{content:"\f1c1"}.fa-file-word-o:before{content:"\f1c2"}.fa-file-excel-o:before{content:"\f1c3"}.fa-file-powerpoint-o:before{content:"\f1c4"}.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"}.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"}.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"}.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"}.fa-file-code-o:before{content:"\f1c9"}.fa-vine:before{content:"\f1ca"}.fa-codepen:before{content:"\f1cb"}.fa-jsfiddle:before{content:"\f1cc"}.fa-life-bouy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"}.fa-circle-o-notch:before{content:"\f1ce"}.fa-ra:before,.fa-rebel:before{content:"\f1d0"}.fa-ge:before,.fa-empire:before{content:"\f1d1"}.fa-git-square:before{content:"\f1d2"}.fa-git:before{content:"\f1d3"}.fa-hacker-news:before{content:"\f1d4"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-qq:before{content:"\f1d6"}.fa-wechat:before,.fa-weixin:before{content:"\f1d7"}.fa-send:before,.fa-paper-plane:before{content:"\f1d8"}.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"}.fa-history:before{content:"\f1da"}.fa-circle-thin:before{content:"\f1db"}.fa-header:before{content:"\f1dc"}.fa-paragraph:before{content:"\f1dd"}.fa-sliders:before{content:"\f1de"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-bomb:before{content:"\f1e2"}
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark-bigtext.css b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark-bigtext.css
new file mode 100644
index 00000000000..38d71340208
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark-bigtext.css
@@ -0,0 +1,400 @@
+/* This is a fork of the dark.css theme. The only changes from dark.css are near the very end. */
+
+::-webkit-scrollbar {
+	width: 10px;
+	height: 10px;
+}
+
+::-webkit-scrollbar-corner {
+	background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+	background-color: rgba(255, 255, 255, .35);
+	border-radius: 10px;
+}
+
+body {
+	color: #D0D0D0;
+	background: fixed #040607;
+	background: fixed -moz-linear-gradient(top, hsl(200,27%,2%) 0%, hsl(203,29%,26%) 100%);
+	background: fixed -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(200,27%,2%)), color-stop(100%,hsl(203,29%,26%)));
+	background: fixed -webkit-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%);
+	background: fixed -o-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%);
+	background: fixed -ms-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%);
+	background: fixed linear-gradient(to bottom, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#040607', endColorstr='#2f4756',GradientType=0 );
+}
+
+a,
+.toggle-all-pkg {
+	color: #247D9E;
+}
+
+a:hover,
+.toggle-all-pkg:hover {
+	color: #33B5E5;
+}
+
+input[type=text] {
+	border-bottom-color: #33B5E5;
+	color: #BBB;
+}
+
+::-webkit-input-placeholder {
+	color: #555;
+}
+:-moz-placeholder {
+	color: #555;
+}
+::-moz-placeholder {
+	color: #555;
+}
+:-ms-input-placeholder {
+	color: #555;
+}
+
+.overall {
+	/*
+		Using box-shadow here is not very performant but allows us
+		to animate the change of the background color much more easily.
+		This box-shadow is an ALTERNATIVE, not supplement, to using gradients
+		in this case.
+	*/
+	box-shadow: inset 0 150px 100px -110px rgba(0, 0, 0, .5);
+}
+
+.overall.ok {
+	background: #688E00;
+}
+
+.overall.fail {
+	background: #DB8700;
+}
+
+.overall.panic {
+	background: #A80000;
+}
+
+.overall.buildfail {
+	background: #A4A8AA;
+}
+
+.overall .status {
+	color: #EEE;
+}
+
+.server-down {
+	background: rgba(255, 45, 45, 0.55);
+	color: #FFF;
+}
+
+.toggler {
+	background: #132535;
+}
+
+.toggler:hover {
+	background: #1C374F;
+}
+
+.controls {
+	border-bottom: 1px solid #33B5E5;
+}
+
+.controls li {
+	color: #2A5A84;
+}
+
+.controls li:hover {
+	background: #132535;
+	color: #33B5E5;
+}
+
+.sel {
+	background: #33B5E5 !important;
+	color: #FFF !important;
+}
+
+.pkg-cover-name {
+	text-shadow: 1px 1px 0px #000;
+}
+
+.pkg-cover-name b, 
+.story-pkg-name b {
+	color: #FFF;
+	font-weight: bold;
+}
+
+.pkg-cover:hover,
+.pkg-cover:hover b {
+	color: #FFF;
+}
+
+.expandable {
+	border-top-color: #33B5E5;
+}
+
+.expandable {
+	background: rgba(0, 0, 0, .2);
+}
+
+.history .item.ok {
+	background: #3f5400;
+	background: -moz-linear-gradient(top, hsl(75,100%,16%) 0%, hsl(76,100%,28%) 100%);
+	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(75,100%,16%)), color-stop(100%,hsl(76,100%,28%)));
+	background: -webkit-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%);
+	background: -o-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%);
+	background: -ms-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%);
+	background: linear-gradient(to bottom, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#3f5400', endColorstr='#698f00',GradientType=0 );
+}
+
+.history .item.fail {
+	background: #7f4e00;
+	background: -moz-linear-gradient(top, hsl(37,100%,25%) 0%, hsl(37,100%,43%) 100%);
+	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(37,100%,25%)), color-stop(100%,hsl(37,100%,43%)));
+	background: -webkit-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%);
+	background: -o-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%);
+	background: -ms-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%);
+	background: linear-gradient(to bottom, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#7f4e00', endColorstr='#db8700',GradientType=0 );
+}
+
+.history .item.panic {
+	background: #660000;
+	background: -moz-linear-gradient(top, hsl(0,100%,20%) 0%, hsl(0,100%,33%) 100%);
+	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(0,100%,20%)), color-stop(100%,hsl(0,100%,33%)));
+	background: -webkit-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%);
+	background: -o-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%);
+	background: -ms-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%);
+	background: linear-gradient(to bottom, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#660000', endColorstr='#a80000',GradientType=0 );
+}
+
+.history .item.buildfail {
+	background: #282f33;
+	background: -moz-linear-gradient(top, hsl(202,12%,18%) 0%, hsl(208,5%,48%) 100%);
+	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(202,12%,18%)), color-stop(100%,hsl(208,5%,48%)));
+	background: -webkit-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%);
+	background: -o-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%);
+	background: -ms-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%);
+	background: linear-gradient(to bottom, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#282f33', endColorstr='#757c82',GradientType=0 );
+}
+
+.enum {
+	border-color: #2B597F;
+}
+
+.enum > li {
+	border-left-color: #2B597F;
+}
+
+.enum > li:hover {
+	background: rgba(55, 114, 163, .25);
+}
+
+.group {
+	background: -moz-linear-gradient(top, rgba(16,59,71,0) 0%, rgba(16,59,71,1) 100%);
+	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(16,59,71,0)), color-stop(100%,rgba(16,59,71,1)));
+	background: -webkit-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%);
+	background: -o-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%);
+	background: -ms-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%);
+	background: linear-gradient(to top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%);
+	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#00103b47', endColorstr='#103b47',GradientType=0 );
+}
+
+.stats {
+	color: #FFF;
+}
+
+.error {
+	color: #F58888 !important;
+	background: rgba(255, 45, 45, 0.35) !important;
+}
+
+.spin-slowly,
+.spin-once {
+	color: #33B5E5 !important;
+}
+
+.frame .col,
+footer {
+	border-color: #33B5E5;
+}
+
+footer {
+	background: rgba(0, 0, 0, .5);
+}
+
+footer .recording .fa {
+	color: #CC0000;
+}
+
+footer .replay .fa {
+	color: #33B5E5;
+}
+
+footer .paused .fa {
+	color: #AAA;
+}
+
+footer .recording.replay .fa {
+	color: #33B5E5;
+}
+
+
+
+.buildfail-pkg {
+	background: rgba(255, 255, 255, .1);
+}
+.buildfail-output {
+	background: rgba(255, 255, 255, .2);
+}
+
+
+
+.panic-pkg {
+	background: rgba(255, 0, 0, .3);
+}
+.panic-story {
+	padding: 10px;
+	background: rgba(255, 0, 0, .1);
+}
+.panic-story a,
+.panic-summary {
+	color: #E94A4A;
+}
+.panic-output {
+	color: #FF8181;
+}
+
+
+
+.failure-pkg {
+	background: rgba(255, 153, 0, .42);
+}
+.failure-story {
+	padding: 10px;
+	background: rgba(255, 153, 0, .1);
+}
+.failure-story a {
+	color: #FFB518;
+}
+.failure-output {
+	color: #FFBD47;
+}
+.failure-file {
+	color: #FFF;
+}
+
+
+.diffviewer td {
+	border-color: rgba(0, 0, 0, .3);
+}
+
+/* prettyTextDiff expected/deleted colors */
+.diffviewer .exp,
+.diff del {
+	background: rgba(131, 252, 131, 0.22);
+}
+
+/* prettyTextDiff actual/inserted colors */
+.diffviewer .act,
+.diff ins {
+	background: rgba(255, 52, 52, 0.33);
+}
+
+
+
+.story-links a,
+.test-name-link a {
+	color: inherit;
+}
+
+
+
+.story-pkg {
+	background: rgba(0, 0, 0, .4);
+}
+
+.story-pkg:hover {
+	background: rgba(255, 255, 255, .05);
+}
+
+.story-line + .story-line {
+	border-top: 1px dashed rgba(255, 255, 255, .08);
+}
+
+.story-line-desc .message {
+	color: #999;
+}
+
+.story-line-summary-container {
+	border-right: 1px dashed #333;
+}
+
+.story-line.ok .story-line-status { background: #008000; }
+.story-line.ok:hover, .story-line.ok.story-line-sel { background: rgba(0, 128, 0, .1); }
+
+.story-line.fail .story-line-status { background: #EA9C4D; }
+.story-line.fail:hover, .story-line.fail.story-line-sel { background: rgba(234, 156, 77, .1); }
+
+.story-line.panic .story-line-status { background: #FF3232; }
+.story-line.panic:hover, .story-line.panic.story-line-sel { background: rgba(255, 50, 50, .1); }
+
+.story-line.skip .story-line-status { background: #AAA; }
+.story-line.skip:hover, .story-line.skip.story-line-sel { background: rgba(255, 255, 255, .1); }
+
+.statusicon.ok { color: #76C13C; }
+.statusicon.fail, .fail-clr { color: #EA9C4D; }
+.statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; }
+.statusicon.skip, .skip-clr { color: #888; }
+
+
+.log .timestamp {
+	color: #999;
+}
+
+
+.clr-red {
+	color: #FF2222;
+}
+
+
+.tipsy-inner {
+	background-color: #FAFAFA;
+	color: #222;
+}
+
+.tipsy-arrow {
+	border: 8px dashed #FAFAFA;
+}
+
+.tipsy-arrow-n,
+.tipsy-arrow-s,
+.tipsy-arrow-e,
+.tipsy-arrow-w,
+{
+	border-color: #FAFAFA;
+}
+
+/***************************************************************/
+/*************************** Tweaks ****************************/
+/***************************************************************/
+
+
+/* More space for stories */
+div#col-3 { display: none; } /* hides the log */
+div#col-2 { width: 85%; }    /* fill it in with stories */
+
+/* Bigger Text */
+.story-line       { font-size: 16px; }
+.story-line b     { font-size: 20px; }
+td.story-pkg-name { font-size: 24px; }
+
+/* Smaller Header */
+div.overall      { padding: 10px 0 0px; }
+.overall .status { font-size: 36px; }
+
+/***************************************************************/
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark.css b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark.css
index b4fd0349d56..132e19dbf1d 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark.css
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/dark.css
@@ -305,6 +305,11 @@ footer .recording.replay .fa {
 
 
 
+.story-links a,
+.test-name-link a {
+	color: inherit;
+}
+
 
 
 .story-pkg {
@@ -344,6 +349,8 @@ footer .recording.replay .fa {
 .statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; }
 .statusicon.skip, .skip-clr { color: #888; }
 
+.ansi-green { color: #76C13C; }
+.ansi-yellow   { color: #EA9C4D; }
 
 .log .timestamp {
 	color: #999;
@@ -370,4 +377,4 @@ footer .recording.replay .fa {
 .tipsy-arrow-w,
 {
 	border-color: #FAFAFA;
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/light.css b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/light.css
index 5de1bb5712a..decfc7f4135 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/light.css
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/light.css
@@ -249,7 +249,10 @@ footer .paused .fa {
 
 
 
-
+.story-links a,
+.test-name-link a {
+	color: inherit;
+}
 
 
 
@@ -294,7 +297,8 @@ footer .paused .fa {
 .statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; }
 .statusicon.skip, .skip-clr { color: #AAA; }
 
-
+.ansi-green { color: #76C13C; }
+.ansi-yellow   { color: #EA9C4D; }
 
 .log .timestamp {
 	color: #999;
@@ -321,4 +325,4 @@ a.clr-red {
 .tipsy-arrow-w,
 {
 	border-color: #000;
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/FontAwesome.otf b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/FontAwesome.otf
index 8b0f54e47e1..3461e3fce6a 100644..100755
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/FontAwesome.otf
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/FontAwesome.otf
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.eot b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.eot
index 7c79c6a6bc9..6cfd5660956 100755
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.eot
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.eot
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.svg b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.svg
index 45fdf338301..a9f84695031 100755
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.svg
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.svg
@@ -14,10 +14,11 @@
 <glyph unicode="&#xae;" horiz-adv-x="1792" />
 <glyph unicode="&#xb4;" horiz-adv-x="1792" />
 <glyph unicode="&#xc6;" horiz-adv-x="1792" />
+<glyph unicode="&#xd8;" horiz-adv-x="1792" />
 <glyph unicode="&#x2000;" horiz-adv-x="768" />
-<glyph unicode="&#x2001;" />
+<glyph unicode="&#x2001;" horiz-adv-x="1537" />
 <glyph unicode="&#x2002;" horiz-adv-x="768" />
-<glyph unicode="&#x2003;" />
+<glyph unicode="&#x2003;" horiz-adv-x="1537" />
 <glyph unicode="&#x2004;" horiz-adv-x="512" />
 <glyph unicode="&#x2005;" horiz-adv-x="384" />
 <glyph unicode="&#x2006;" horiz-adv-x="256" />
@@ -30,385 +31,474 @@
 <glyph unicode="&#x2122;" horiz-adv-x="1792" />
 <glyph unicode="&#x221e;" horiz-adv-x="1792" />
 <glyph unicode="&#x2260;" horiz-adv-x="1792" />
-<glyph unicode="&#xe000;" horiz-adv-x="500" d="M0 0z" />
-<glyph unicode="&#xf000;" horiz-adv-x="1792" d="M1699 1350q0 -35 -43 -78l-632 -632v-768h320q26 0 45 -19t19 -45t-19 -45t-45 -19h-896q-26 0 -45 19t-19 45t19 45t45 19h320v768l-632 632q-43 43 -43 78q0 23 18 36.5t38 17.5t43 4h1408q23 0 43 -4t38 -17.5t18 -36.5z" />
-<glyph unicode="&#xf001;" d="M1536 1312v-1120q0 -50 -34 -89t-86 -60.5t-103.5 -32t-96.5 -10.5t-96.5 10.5t-103.5 32t-86 60.5t-34 89t34 89t86 60.5t103.5 32t96.5 10.5q105 0 192 -39v537l-768 -237v-709q0 -50 -34 -89t-86 -60.5t-103.5 -32t-96.5 -10.5t-96.5 10.5t-103.5 32t-86 60.5t-34 89 t34 89t86 60.5t103.5 32t96.5 10.5q105 0 192 -39v967q0 31 19 56.5t49 35.5l832 256q12 4 28 4q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf002;" horiz-adv-x="1664" d="M1152 704q0 185 -131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5t131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5zM1664 -128q0 -52 -38 -90t-90 -38q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5 t55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90z" />
-<glyph unicode="&#xf003;" horiz-adv-x="1792" d="M1664 32v768q-32 -36 -69 -66q-268 -206 -426 -338q-51 -43 -83 -67t-86.5 -48.5t-102.5 -24.5h-1h-1q-48 0 -102.5 24.5t-86.5 48.5t-83 67q-158 132 -426 338q-37 30 -69 66v-768q0 -13 9.5 -22.5t22.5 -9.5h1472q13 0 22.5 9.5t9.5 22.5zM1664 1083v11v13.5t-0.5 13 t-3 12.5t-5.5 9t-9 7.5t-14 2.5h-1472q-13 0 -22.5 -9.5t-9.5 -22.5q0 -168 147 -284q193 -152 401 -317q6 -5 35 -29.5t46 -37.5t44.5 -31.5t50.5 -27.5t43 -9h1h1q20 0 43 9t50.5 27.5t44.5 31.5t46 37.5t35 29.5q208 165 401 317q54 43 100.5 115.5t46.5 131.5z M1792 1120v-1088q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113v1088q0 66 47 113t113 47h1472q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf004;" horiz-adv-x="1792" d="M896 -128q-26 0 -44 18l-624 602q-10 8 -27.5 26t-55.5 65.5t-68 97.5t-53.5 121t-23.5 138q0 220 127 344t351 124q62 0 126.5 -21.5t120 -58t95.5 -68.5t76 -68q36 36 76 68t95.5 68.5t120 58t126.5 21.5q224 0 351 -124t127 -344q0 -221 -229 -450l-623 -600 q-18 -18 -44 -18z" />
-<glyph unicode="&#xf005;" horiz-adv-x="1664" d="M1664 889q0 -22 -26 -48l-363 -354l86 -500q1 -7 1 -20q0 -21 -10.5 -35.5t-30.5 -14.5q-19 0 -40 12l-449 236l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500l-364 354q-25 27 -25 48q0 37 56 46l502 73l225 455q19 41 49 41t49 -41l225 -455 l502 -73q56 -9 56 -46z" />
-<glyph unicode="&#xf006;" horiz-adv-x="1664" d="M1137 532l306 297l-422 62l-189 382l-189 -382l-422 -62l306 -297l-73 -421l378 199l377 -199zM1664 889q0 -22 -26 -48l-363 -354l86 -500q1 -7 1 -20q0 -50 -41 -50q-19 0 -40 12l-449 236l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500 l-364 354q-25 27 -25 48q0 37 56 46l502 73l225 455q19 41 49 41t49 -41l225 -455l502 -73q56 -9 56 -46z" />
-<glyph unicode="&#xf007;" horiz-adv-x="1408" d="M1408 131q0 -120 -73 -189.5t-194 -69.5h-874q-121 0 -194 69.5t-73 189.5q0 53 3.5 103.5t14 109t26.5 108.5t43 97.5t62 81t85.5 53.5t111.5 20q9 0 42 -21.5t74.5 -48t108 -48t133.5 -21.5t133.5 21.5t108 48t74.5 48t42 21.5q61 0 111.5 -20t85.5 -53.5t62 -81 t43 -97.5t26.5 -108.5t14 -109t3.5 -103.5zM1088 1024q0 -159 -112.5 -271.5t-271.5 -112.5t-271.5 112.5t-112.5 271.5t112.5 271.5t271.5 112.5t271.5 -112.5t112.5 -271.5z" />
-<glyph unicode="&#xf008;" horiz-adv-x="1920" d="M384 -64v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM384 320v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM384 704v128q0 26 -19 45t-45 19h-128 q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1408 -64v512q0 26 -19 45t-45 19h-768q-26 0 -45 -19t-19 -45v-512q0 -26 19 -45t45 -19h768q26 0 45 19t19 45zM384 1088v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45 t45 -19h128q26 0 45 19t19 45zM1792 -64v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1408 704v512q0 26 -19 45t-45 19h-768q-26 0 -45 -19t-19 -45v-512q0 -26 19 -45t45 -19h768q26 0 45 19t19 45zM1792 320v128 q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1792 704v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1792 1088v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19 t-19 -45v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1920 1248v-1344q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113v1344q0 66 47 113t113 47h1600q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf009;" horiz-adv-x="1664" d="M768 512v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90zM768 1280v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90zM1664 512v-384q0 -52 -38 -90t-90 -38 h-512q-52 0 -90 38t-38 90v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90zM1664 1280v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90z" />
-<glyph unicode="&#xf00a;" horiz-adv-x="1792" d="M512 288v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM512 800v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1152 288v-192q0 -40 -28 -68t-68 -28h-320 q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM512 1312v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1152 800v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28 h320q40 0 68 -28t28 -68zM1792 288v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1152 1312v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1792 800v-192 q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1792 1312v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf00b;" horiz-adv-x="1792" d="M512 288v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM512 800v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1792 288v-192q0 -40 -28 -68t-68 -28h-960 q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h960q40 0 68 -28t28 -68zM512 1312v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68zM1792 800v-192q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v192q0 40 28 68t68 28 h960q40 0 68 -28t28 -68zM1792 1312v-192q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h960q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf00c;" horiz-adv-x="1792" d="M1671 970q0 -40 -28 -68l-724 -724l-136 -136q-28 -28 -68 -28t-68 28l-136 136l-362 362q-28 28 -28 68t28 68l136 136q28 28 68 28t68 -28l294 -295l656 657q28 28 68 28t68 -28l136 -136q28 -28 28 -68z" />
-<glyph unicode="&#xf00d;" horiz-adv-x="1408" d="M1298 214q0 -40 -28 -68l-136 -136q-28 -28 -68 -28t-68 28l-294 294l-294 -294q-28 -28 -68 -28t-68 28l-136 136q-28 28 -28 68t28 68l294 294l-294 294q-28 28 -28 68t28 68l136 136q28 28 68 28t68 -28l294 -294l294 294q28 28 68 28t68 -28l136 -136q28 -28 28 -68 t-28 -68l-294 -294l294 -294q28 -28 28 -68z" />
-<glyph unicode="&#xf00e;" horiz-adv-x="1664" d="M1024 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-224v-224q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v224h-224q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h224v224q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-224h224 q13 0 22.5 -9.5t9.5 -22.5zM1152 704q0 185 -131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5t131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5zM1664 -128q0 -53 -37.5 -90.5t-90.5 -37.5q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5 t-225 150t-150 225t-55.5 273.5t55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90z" />
-<glyph unicode="&#xf010;" horiz-adv-x="1664" d="M1024 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-576q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h576q13 0 22.5 -9.5t9.5 -22.5zM1152 704q0 185 -131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5t131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5z M1664 -128q0 -53 -37.5 -90.5t-90.5 -37.5q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5t55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90z " />
-<glyph unicode="&#xf011;" d="M1536 640q0 -156 -61 -298t-164 -245t-245 -164t-298 -61t-298 61t-245 164t-164 245t-61 298q0 182 80.5 343t226.5 270q43 32 95.5 25t83.5 -50q32 -42 24.5 -94.5t-49.5 -84.5q-98 -74 -151.5 -181t-53.5 -228q0 -104 40.5 -198.5t109.5 -163.5t163.5 -109.5 t198.5 -40.5t198.5 40.5t163.5 109.5t109.5 163.5t40.5 198.5q0 121 -53.5 228t-151.5 181q-42 32 -49.5 84.5t24.5 94.5q31 43 84 50t95 -25q146 -109 226.5 -270t80.5 -343zM896 1408v-640q0 -52 -38 -90t-90 -38t-90 38t-38 90v640q0 52 38 90t90 38t90 -38t38 -90z" />
-<glyph unicode="&#xf012;" horiz-adv-x="1792" d="M256 96v-192q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h192q14 0 23 -9t9 -23zM640 224v-320q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v320q0 14 9 23t23 9h192q14 0 23 -9t9 -23zM1024 480v-576q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23 v576q0 14 9 23t23 9h192q14 0 23 -9t9 -23zM1408 864v-960q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v960q0 14 9 23t23 9h192q14 0 23 -9t9 -23zM1792 1376v-1472q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v1472q0 14 9 23t23 9h192q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf013;" d="M1024 640q0 106 -75 181t-181 75t-181 -75t-75 -181t75 -181t181 -75t181 75t75 181zM1536 749v-222q0 -12 -8 -23t-20 -13l-185 -28q-19 -54 -39 -91q35 -50 107 -138q10 -12 10 -25t-9 -23q-27 -37 -99 -108t-94 -71q-12 0 -26 9l-138 108q-44 -23 -91 -38 q-16 -136 -29 -186q-7 -28 -36 -28h-222q-14 0 -24.5 8.5t-11.5 21.5l-28 184q-49 16 -90 37l-141 -107q-10 -9 -25 -9q-14 0 -25 11q-126 114 -165 168q-7 10 -7 23q0 12 8 23q15 21 51 66.5t54 70.5q-27 50 -41 99l-183 27q-13 2 -21 12.5t-8 23.5v222q0 12 8 23t19 13 l186 28q14 46 39 92q-40 57 -107 138q-10 12 -10 24q0 10 9 23q26 36 98.5 107.5t94.5 71.5q13 0 26 -10l138 -107q44 23 91 38q16 136 29 186q7 28 36 28h222q14 0 24.5 -8.5t11.5 -21.5l28 -184q49 -16 90 -37l142 107q9 9 24 9q13 0 25 -10q129 -119 165 -170q7 -8 7 -22 q0 -12 -8 -23q-15 -21 -51 -66.5t-54 -70.5q26 -50 41 -98l183 -28q13 -2 21 -12.5t8 -23.5z" />
-<glyph unicode="&#xf014;" horiz-adv-x="1408" d="M512 800v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23zM768 800v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23zM1024 800v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v576 q0 14 9 23t23 9h64q14 0 23 -9t9 -23zM1152 76v948h-896v-948q0 -22 7 -40.5t14.5 -27t10.5 -8.5h832q3 0 10.5 8.5t14.5 27t7 40.5zM480 1152h448l-48 117q-7 9 -17 11h-317q-10 -2 -17 -11zM1408 1120v-64q0 -14 -9 -23t-23 -9h-96v-948q0 -83 -47 -143.5t-113 -60.5h-832 q-66 0 -113 58.5t-47 141.5v952h-96q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h309l70 167q15 37 54 63t79 26h320q40 0 79 -26t54 -63l70 -167h309q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf015;" horiz-adv-x="1664" d="M1408 544v-480q0 -26 -19 -45t-45 -19h-384v384h-256v-384h-384q-26 0 -45 19t-19 45v480q0 1 0.5 3t0.5 3l575 474l575 -474q1 -2 1 -6zM1631 613l-62 -74q-8 -9 -21 -11h-3q-13 0 -21 7l-692 577l-692 -577q-12 -8 -24 -7q-13 2 -21 11l-62 74q-8 10 -7 23.5t11 21.5 l719 599q32 26 76 26t76 -26l244 -204v195q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-408l219 -182q10 -8 11 -21.5t-7 -23.5z" />
-<glyph unicode="&#xf016;" horiz-adv-x="1280" d="M128 0h1024v768h-416q-40 0 -68 28t-28 68v416h-512v-1280zM768 896h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376zM1280 864v-896q0 -40 -28 -68t-68 -28h-1088q-40 0 -68 28t-28 68v1344q0 40 28 68t68 28h640q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88z " />
-<glyph unicode="&#xf017;" d="M896 992v-448q0 -14 -9 -23t-23 -9h-320q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h224v352q0 14 9 23t23 9h64q14 0 23 -9t9 -23zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf018;" horiz-adv-x="1920" d="M1111 540v4l-24 320q-1 13 -11 22.5t-23 9.5h-186q-13 0 -23 -9.5t-11 -22.5l-24 -320v-4q-1 -12 8 -20t21 -8h244q12 0 21 8t8 20zM1870 73q0 -73 -46 -73h-704q13 0 22 9.5t8 22.5l-20 256q-1 13 -11 22.5t-23 9.5h-272q-13 0 -23 -9.5t-11 -22.5l-20 -256 q-1 -13 8 -22.5t22 -9.5h-704q-46 0 -46 73q0 54 26 116l417 1044q8 19 26 33t38 14h339q-13 0 -23 -9.5t-11 -22.5l-15 -192q-1 -14 8 -23t22 -9h166q13 0 22 9t8 23l-15 192q-1 13 -11 22.5t-23 9.5h339q20 0 38 -14t26 -33l417 -1044q26 -62 26 -116z" />
-<glyph unicode="&#xf019;" horiz-adv-x="1664" d="M1280 192q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1536 192q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1664 416v-320q0 -40 -28 -68t-68 -28h-1472q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h465l135 -136 q58 -56 136 -56t136 56l136 136h464q40 0 68 -28t28 -68zM1339 985q17 -41 -14 -70l-448 -448q-18 -19 -45 -19t-45 19l-448 448q-31 29 -14 70q17 39 59 39h256v448q0 26 19 45t45 19h256q26 0 45 -19t19 -45v-448h256q42 0 59 -39z" />
-<glyph unicode="&#xf01a;" d="M1120 608q0 -12 -10 -24l-319 -319q-11 -9 -23 -9t-23 9l-320 320q-15 16 -7 35q8 20 30 20h192v352q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-352h192q14 0 23 -9t9 -23zM768 1184q-148 0 -273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273 t-73 273t-198 198t-273 73zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf01b;" d="M1118 660q-8 -20 -30 -20h-192v-352q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v352h-192q-14 0 -23 9t-9 23q0 12 10 24l319 319q11 9 23 9t23 -9l320 -320q15 -16 7 -35zM768 1184q-148 0 -273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198 t73 273t-73 273t-198 198t-273 73zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf01c;" d="M1023 576h316q-1 3 -2.5 8t-2.5 8l-212 496h-708l-212 -496q-1 -2 -2.5 -8t-2.5 -8h316l95 -192h320zM1536 546v-482q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45v482q0 62 25 123l238 552q10 25 36.5 42t52.5 17h832q26 0 52.5 -17t36.5 -42l238 -552 q25 -61 25 -123z" />
-<glyph unicode="&#xf01d;" d="M1184 640q0 -37 -32 -55l-544 -320q-15 -9 -32 -9q-16 0 -32 8q-32 19 -32 56v640q0 37 32 56q33 18 64 -1l544 -320q32 -18 32 -55zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf01e;" d="M1536 1280v-448q0 -26 -19 -45t-45 -19h-448q-42 0 -59 40q-17 39 14 69l138 138q-148 137 -349 137q-104 0 -198.5 -40.5t-163.5 -109.5t-109.5 -163.5t-40.5 -198.5t40.5 -198.5t109.5 -163.5t163.5 -109.5t198.5 -40.5q119 0 225 52t179 147q7 10 23 12q14 0 25 -9 l137 -138q9 -8 9.5 -20.5t-7.5 -22.5q-109 -132 -264 -204.5t-327 -72.5q-156 0 -298 61t-245 164t-164 245t-61 298t61 298t164 245t245 164t298 61q147 0 284.5 -55.5t244.5 -156.5l130 129q29 31 70 14q39 -17 39 -59z" />
-<glyph unicode="&#xf021;" d="M1511 480q0 -5 -1 -7q-64 -268 -268 -434.5t-478 -166.5q-146 0 -282.5 55t-243.5 157l-129 -129q-19 -19 -45 -19t-45 19t-19 45v448q0 26 19 45t45 19h448q26 0 45 -19t19 -45t-19 -45l-137 -137q71 -66 161 -102t187 -36q134 0 250 65t186 179q11 17 53 117 q8 23 30 23h192q13 0 22.5 -9.5t9.5 -22.5zM1536 1280v-448q0 -26 -19 -45t-45 -19h-448q-26 0 -45 19t-19 45t19 45l138 138q-148 137 -349 137q-134 0 -250 -65t-186 -179q-11 -17 -53 -117q-8 -23 -30 -23h-199q-13 0 -22.5 9.5t-9.5 22.5v7q65 268 270 434.5t480 166.5 q146 0 284 -55.5t245 -156.5l130 129q19 19 45 19t45 -19t19 -45z" />
-<glyph unicode="&#xf022;" horiz-adv-x="1792" d="M384 352v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 608v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M384 864v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM1536 352v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5t9.5 -22.5z M1536 608v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5t9.5 -22.5zM1536 864v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5 t9.5 -22.5zM1664 160v832q0 13 -9.5 22.5t-22.5 9.5h-1472q-13 0 -22.5 -9.5t-9.5 -22.5v-832q0 -13 9.5 -22.5t22.5 -9.5h1472q13 0 22.5 9.5t9.5 22.5zM1792 1248v-1088q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113v1088q0 66 47 113t113 47h1472q66 0 113 -47 t47 -113z" />
-<glyph unicode="&#xf023;" horiz-adv-x="1152" d="M320 768h512v192q0 106 -75 181t-181 75t-181 -75t-75 -181v-192zM1152 672v-576q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v576q0 40 28 68t68 28h32v192q0 184 132 316t316 132t316 -132t132 -316v-192h32q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf024;" horiz-adv-x="1792" d="M320 1280q0 -72 -64 -110v-1266q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v1266q-64 38 -64 110q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1792 1216v-763q0 -25 -12.5 -38.5t-39.5 -27.5q-215 -116 -369 -116q-61 0 -123.5 22t-108.5 48 t-115.5 48t-142.5 22q-192 0 -464 -146q-17 -9 -33 -9q-26 0 -45 19t-19 45v742q0 32 31 55q21 14 79 43q236 120 421 120q107 0 200 -29t219 -88q38 -19 88 -19q54 0 117.5 21t110 47t88 47t54.5 21q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf025;" horiz-adv-x="1664" d="M1664 650q0 -166 -60 -314l-20 -49l-185 -33q-22 -83 -90.5 -136.5t-156.5 -53.5v-32q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-32q71 0 130 -35.5t93 -95.5l68 12q29 95 29 193q0 148 -88 279t-236.5 209t-315.5 78 t-315.5 -78t-236.5 -209t-88 -279q0 -98 29 -193l68 -12q34 60 93 95.5t130 35.5v32q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v32q-88 0 -156.5 53.5t-90.5 136.5l-185 33l-20 49q-60 148 -60 314q0 151 67 291t179 242.5 t266 163.5t320 61t320 -61t266 -163.5t179 -242.5t67 -291z" />
-<glyph unicode="&#xf026;" horiz-adv-x="768" d="M768 1184v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45z" />
-<glyph unicode="&#xf027;" horiz-adv-x="1152" d="M768 1184v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45zM1152 640q0 -76 -42.5 -141.5t-112.5 -93.5q-10 -5 -25 -5q-26 0 -45 18.5t-19 45.5q0 21 12 35.5t29 25t34 23t29 35.5 t12 57t-12 57t-29 35.5t-34 23t-29 25t-12 35.5q0 27 19 45.5t45 18.5q15 0 25 -5q70 -27 112.5 -93t42.5 -142z" />
-<glyph unicode="&#xf028;" horiz-adv-x="1664" d="M768 1184v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45zM1152 640q0 -76 -42.5 -141.5t-112.5 -93.5q-10 -5 -25 -5q-26 0 -45 18.5t-19 45.5q0 21 12 35.5t29 25t34 23t29 35.5 t12 57t-12 57t-29 35.5t-34 23t-29 25t-12 35.5q0 27 19 45.5t45 18.5q15 0 25 -5q70 -27 112.5 -93t42.5 -142zM1408 640q0 -153 -85 -282.5t-225 -188.5q-13 -5 -25 -5q-27 0 -46 19t-19 45q0 39 39 59q56 29 76 44q74 54 115.5 135.5t41.5 173.5t-41.5 173.5 t-115.5 135.5q-20 15 -76 44q-39 20 -39 59q0 26 19 45t45 19q13 0 26 -5q140 -59 225 -188.5t85 -282.5zM1664 640q0 -230 -127 -422.5t-338 -283.5q-13 -5 -26 -5q-26 0 -45 19t-19 45q0 36 39 59q7 4 22.5 10.5t22.5 10.5q46 25 82 51q123 91 192 227t69 289t-69 289 t-192 227q-36 26 -82 51q-7 4 -22.5 10.5t-22.5 10.5q-39 23 -39 59q0 26 19 45t45 19q13 0 26 -5q211 -91 338 -283.5t127 -422.5z" />
-<glyph unicode="&#xf029;" horiz-adv-x="1408" d="M384 384v-128h-128v128h128zM384 1152v-128h-128v128h128zM1152 1152v-128h-128v128h128zM128 129h384v383h-384v-383zM128 896h384v384h-384v-384zM896 896h384v384h-384v-384zM640 640v-640h-640v640h640zM1152 128v-128h-128v128h128zM1408 128v-128h-128v128h128z M1408 640v-384h-384v128h-128v-384h-128v640h384v-128h128v128h128zM640 1408v-640h-640v640h640zM1408 1408v-640h-640v640h640z" />
-<glyph unicode="&#xf02a;" horiz-adv-x="1792" d="M63 0h-63v1408h63v-1408zM126 1h-32v1407h32v-1407zM220 1h-31v1407h31v-1407zM377 1h-31v1407h31v-1407zM534 1h-62v1407h62v-1407zM660 1h-31v1407h31v-1407zM723 1h-31v1407h31v-1407zM786 1h-31v1407h31v-1407zM943 1h-63v1407h63v-1407zM1100 1h-63v1407h63v-1407z M1226 1h-63v1407h63v-1407zM1352 1h-63v1407h63v-1407zM1446 1h-63v1407h63v-1407zM1635 1h-94v1407h94v-1407zM1698 1h-32v1407h32v-1407zM1792 0h-63v1408h63v-1408z" />
-<glyph unicode="&#xf02b;" d="M448 1088q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1515 512q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-53 0 -90 37l-715 716q-38 37 -64.5 101t-26.5 117v416q0 52 38 90t90 38h416q53 0 117 -26.5t102 -64.5 l715 -714q37 -39 37 -91z" />
-<glyph unicode="&#xf02c;" horiz-adv-x="1920" d="M448 1088q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1515 512q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-53 0 -90 37l-715 716q-38 37 -64.5 101t-26.5 117v416q0 52 38 90t90 38h416q53 0 117 -26.5t102 -64.5 l715 -714q37 -39 37 -91zM1899 512q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-36 0 -59 14t-53 45l470 470q37 37 37 90q0 52 -37 91l-715 714q-38 38 -102 64.5t-117 26.5h224q53 0 117 -26.5t102 -64.5l715 -714q37 -39 37 -91z" />
-<glyph unicode="&#xf02d;" horiz-adv-x="1664" d="M1639 1058q40 -57 18 -129l-275 -906q-19 -64 -76.5 -107.5t-122.5 -43.5h-923q-77 0 -148.5 53.5t-99.5 131.5q-24 67 -2 127q0 4 3 27t4 37q1 8 -3 21.5t-3 19.5q2 11 8 21t16.5 23.5t16.5 23.5q23 38 45 91.5t30 91.5q3 10 0.5 30t-0.5 28q3 11 17 28t17 23 q21 36 42 92t25 90q1 9 -2.5 32t0.5 28q4 13 22 30.5t22 22.5q19 26 42.5 84.5t27.5 96.5q1 8 -3 25.5t-2 26.5q2 8 9 18t18 23t17 21q8 12 16.5 30.5t15 35t16 36t19.5 32t26.5 23.5t36 11.5t47.5 -5.5l-1 -3q38 9 51 9h761q74 0 114 -56t18 -130l-274 -906 q-36 -119 -71.5 -153.5t-128.5 -34.5h-869q-27 0 -38 -15q-11 -16 -1 -43q24 -70 144 -70h923q29 0 56 15.5t35 41.5l300 987q7 22 5 57q38 -15 59 -43zM575 1056q-4 -13 2 -22.5t20 -9.5h608q13 0 25.5 9.5t16.5 22.5l21 64q4 13 -2 22.5t-20 9.5h-608q-13 0 -25.5 -9.5 t-16.5 -22.5zM492 800q-4 -13 2 -22.5t20 -9.5h608q13 0 25.5 9.5t16.5 22.5l21 64q4 13 -2 22.5t-20 9.5h-608q-13 0 -25.5 -9.5t-16.5 -22.5z" />
-<glyph unicode="&#xf02e;" horiz-adv-x="1280" d="M1164 1408q23 0 44 -9q33 -13 52.5 -41t19.5 -62v-1289q0 -34 -19.5 -62t-52.5 -41q-19 -8 -44 -8q-48 0 -83 32l-441 424l-441 -424q-36 -33 -83 -33q-23 0 -44 9q-33 13 -52.5 41t-19.5 62v1289q0 34 19.5 62t52.5 41q21 9 44 9h1048z" />
-<glyph unicode="&#xf02f;" horiz-adv-x="1664" d="M384 0h896v256h-896v-256zM384 640h896v384h-160q-40 0 -68 28t-28 68v160h-640v-640zM1536 576q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1664 576v-416q0 -13 -9.5 -22.5t-22.5 -9.5h-224v-160q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68 v160h-224q-13 0 -22.5 9.5t-9.5 22.5v416q0 79 56.5 135.5t135.5 56.5h64v544q0 40 28 68t68 28h672q40 0 88 -20t76 -48l152 -152q28 -28 48 -76t20 -88v-256h64q79 0 135.5 -56.5t56.5 -135.5z" />
-<glyph unicode="&#xf030;" horiz-adv-x="1920" d="M960 864q119 0 203.5 -84.5t84.5 -203.5t-84.5 -203.5t-203.5 -84.5t-203.5 84.5t-84.5 203.5t84.5 203.5t203.5 84.5zM1664 1280q106 0 181 -75t75 -181v-896q0 -106 -75 -181t-181 -75h-1408q-106 0 -181 75t-75 181v896q0 106 75 181t181 75h224l51 136 q19 49 69.5 84.5t103.5 35.5h512q53 0 103.5 -35.5t69.5 -84.5l51 -136h224zM960 128q185 0 316.5 131.5t131.5 316.5t-131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5t131.5 -316.5t316.5 -131.5z" />
-<glyph unicode="&#xf031;" horiz-adv-x="1664" d="M725 977l-170 -450q73 -1 153.5 -2t119 -1.5t52.5 -0.5l29 2q-32 95 -92 241q-53 132 -92 211zM21 -128h-21l2 79q22 7 80 18q89 16 110 31q20 16 48 68l237 616l280 724h75h53l11 -21l205 -480q103 -242 124 -297q39 -102 96 -235q26 -58 65 -164q24 -67 65 -149 q22 -49 35 -57q22 -19 69 -23q47 -6 103 -27q6 -39 6 -57q0 -14 -1 -26q-80 0 -192 8q-93 8 -189 8q-79 0 -135 -2l-200 -11l-58 -2q0 45 4 78l131 28q56 13 68 23q12 12 12 27t-6 32l-47 114l-92 228l-450 2q-29 -65 -104 -274q-23 -64 -23 -84q0 -31 17 -43 q26 -21 103 -32q3 0 13.5 -2t30 -5t40.5 -6q1 -28 1 -58q0 -17 -2 -27q-66 0 -349 20l-48 -8q-81 -14 -167 -14z" />
-<glyph unicode="&#xf032;" horiz-adv-x="1408" d="M555 15q76 -32 140 -32q131 0 216 41t122 113q38 70 38 181q0 114 -41 180q-58 94 -141 126q-80 32 -247 32q-74 0 -101 -10v-144l-1 -173l3 -270q0 -15 12 -44zM541 761q43 -7 109 -7q175 0 264 65t89 224q0 112 -85 187q-84 75 -255 75q-52 0 -130 -13q0 -44 2 -77 q7 -122 6 -279l-1 -98q0 -43 1 -77zM0 -128l2 94q45 9 68 12q77 12 123 31q17 27 21 51q9 66 9 194l-2 497q-5 256 -9 404q-1 87 -11 109q-1 4 -12 12q-18 12 -69 15q-30 2 -114 13l-4 83l260 6l380 13l45 1q5 0 14 0.5t14 0.5q1 0 21.5 -0.5t40.5 -0.5h74q88 0 191 -27 q43 -13 96 -39q57 -29 102 -76q44 -47 65 -104t21 -122q0 -70 -32 -128t-95 -105q-26 -20 -150 -77q177 -41 267 -146q92 -106 92 -236q0 -76 -29 -161q-21 -62 -71 -117q-66 -72 -140 -108q-73 -36 -203 -60q-82 -15 -198 -11l-197 4q-84 2 -298 -11q-33 -3 -272 -11z" />
-<glyph unicode="&#xf033;" horiz-adv-x="1024" d="M0 -126l17 85q4 1 77 20q76 19 116 39q29 37 41 101l27 139l56 268l12 64q8 44 17 84.5t16 67t12.5 46.5t9 30.5t3.5 11.5l29 157l16 63l22 135l8 50v38q-41 22 -144 28q-28 2 -38 4l19 103l317 -14q39 -2 73 -2q66 0 214 9q33 2 68 4.5t36 2.5q-2 -19 -6 -38 q-7 -29 -13 -51q-55 -19 -109 -31q-64 -16 -101 -31q-12 -31 -24 -88q-9 -44 -13 -82q-44 -199 -66 -306l-61 -311l-38 -158l-43 -235l-12 -45q-2 -7 1 -27q64 -15 119 -21q36 -5 66 -10q-1 -29 -7 -58q-7 -31 -9 -41q-18 0 -23 -1q-24 -2 -42 -2q-9 0 -28 3q-19 4 -145 17 l-198 2q-41 1 -174 -11q-74 -7 -98 -9z" />
-<glyph unicode="&#xf034;" horiz-adv-x="1792" d="M81 1407l54 -27q20 -5 211 -5h130l19 3l115 1l215 -1h293l34 -2q14 -1 28 7t21 16l7 8l42 1q15 0 28 -1v-104.5t1 -131.5l1 -100l-1 -58q0 -32 -4 -51q-39 -15 -68 -18q-25 43 -54 128q-8 24 -15.5 62.5t-11.5 65.5t-6 29q-13 15 -27 19q-7 2 -42.5 2t-103.5 -1t-111 -1 q-34 0 -67 -5q-10 -97 -8 -136l1 -152v-332l3 -359l-1 -147q-1 -46 11 -85q49 -25 89 -32q2 0 18 -5t44 -13t43 -12q30 -8 50 -18q5 -45 5 -50q0 -10 -3 -29q-14 -1 -34 -1q-110 0 -187 10q-72 8 -238 8q-88 0 -233 -14q-48 -4 -70 -4q-2 22 -2 26l-1 26v9q21 33 79 49 q139 38 159 50q9 21 12 56q8 192 6 433l-5 428q-1 62 -0.5 118.5t0.5 102.5t-2 57t-6 15q-6 5 -14 6q-38 6 -148 6q-43 0 -100 -13.5t-73 -24.5q-13 -9 -22 -33t-22 -75t-24 -84q-6 -19 -19.5 -32t-20.5 -13q-44 27 -56 44v297v86zM1744 128q33 0 42 -18.5t-11 -44.5 l-126 -162q-20 -26 -49 -26t-49 26l-126 162q-20 26 -11 44.5t42 18.5h80v1024h-80q-33 0 -42 18.5t11 44.5l126 162q20 26 49 26t49 -26l126 -162q20 -26 11 -44.5t-42 -18.5h-80v-1024h80z" />
-<glyph unicode="&#xf035;" d="M81 1407l54 -27q20 -5 211 -5h130l19 3l115 1l446 -1h318l34 -2q14 -1 28 7t21 16l7 8l42 1q15 0 28 -1v-104.5t1 -131.5l1 -100l-1 -58q0 -32 -4 -51q-39 -15 -68 -18q-25 43 -54 128q-8 24 -15.5 62.5t-11.5 65.5t-6 29q-13 15 -27 19q-7 2 -58.5 2t-138.5 -1t-128 -1 q-94 0 -127 -5q-10 -97 -8 -136l1 -152v52l3 -359l-1 -147q-1 -46 11 -85q49 -25 89 -32q2 0 18 -5t44 -13t43 -12q30 -8 50 -18q5 -45 5 -50q0 -10 -3 -29q-14 -1 -34 -1q-110 0 -187 10q-72 8 -238 8q-82 0 -233 -13q-45 -5 -70 -5q-2 22 -2 26l-1 26v9q21 33 79 49 q139 38 159 50q9 21 12 56q6 137 6 433l-5 44q0 265 -2 278q-2 11 -6 15q-6 5 -14 6q-38 6 -148 6q-50 0 -168.5 -14t-132.5 -24q-13 -9 -22 -33t-22 -75t-24 -84q-6 -19 -19.5 -32t-20.5 -13q-44 27 -56 44v297v86zM1505 113q26 -20 26 -49t-26 -49l-162 -126 q-26 -20 -44.5 -11t-18.5 42v80h-1024v-80q0 -33 -18.5 -42t-44.5 11l-162 126q-26 20 -26 49t26 49l162 126q26 20 44.5 11t18.5 -42v-80h1024v80q0 33 18.5 42t44.5 -11z" />
-<glyph unicode="&#xf036;" horiz-adv-x="1792" d="M1792 192v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1408 576v-128q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1280q26 0 45 -19t19 -45zM1664 960v-128q0 -26 -19 -45 t-45 -19h-1536q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1536q26 0 45 -19t19 -45zM1280 1344v-128q0 -26 -19 -45t-45 -19h-1152q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1152q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf037;" horiz-adv-x="1792" d="M1792 192v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1408 576v-128q0 -26 -19 -45t-45 -19h-896q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h896q26 0 45 -19t19 -45zM1664 960v-128q0 -26 -19 -45t-45 -19 h-1408q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45zM1280 1344v-128q0 -26 -19 -45t-45 -19h-640q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h640q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf038;" horiz-adv-x="1792" d="M1792 192v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 576v-128q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1280q26 0 45 -19t19 -45zM1792 960v-128q0 -26 -19 -45 t-45 -19h-1536q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1536q26 0 45 -19t19 -45zM1792 1344v-128q0 -26 -19 -45t-45 -19h-1152q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1152q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf039;" horiz-adv-x="1792" d="M1792 192v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 576v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 960v-128q0 -26 -19 -45 t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 1344v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf03a;" horiz-adv-x="1792" d="M256 224v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5zM256 608v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5 t9.5 -22.5zM256 992v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5zM1792 224v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1344 q13 0 22.5 -9.5t9.5 -22.5zM256 1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5zM1792 608v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5 t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5zM1792 992v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5zM1792 1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v192 q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5z" />
-<glyph unicode="&#xf03b;" horiz-adv-x="1792" d="M384 992v-576q0 -13 -9.5 -22.5t-22.5 -9.5q-14 0 -23 9l-288 288q-9 9 -9 23t9 23l288 288q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5zM1792 224v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5 t9.5 -22.5zM1792 608v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5zM1792 992v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1088 q13 0 22.5 -9.5t9.5 -22.5zM1792 1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5z" />
-<glyph unicode="&#xf03c;" horiz-adv-x="1792" d="M352 704q0 -14 -9 -23l-288 -288q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v576q0 13 9.5 22.5t22.5 9.5q14 0 23 -9l288 -288q9 -9 9 -23zM1792 224v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5 t9.5 -22.5zM1792 608v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5zM1792 992v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1088 q13 0 22.5 -9.5t9.5 -22.5zM1792 1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5z" />
-<glyph unicode="&#xf03d;" horiz-adv-x="1792" d="M1792 1184v-1088q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-403 403v-166q0 -119 -84.5 -203.5t-203.5 -84.5h-704q-119 0 -203.5 84.5t-84.5 203.5v704q0 119 84.5 203.5t203.5 84.5h704q119 0 203.5 -84.5t84.5 -203.5v-165l403 402q18 19 45 19q12 0 25 -5 q39 -17 39 -59z" />
-<glyph unicode="&#xf03e;" horiz-adv-x="1920" d="M640 960q0 -80 -56 -136t-136 -56t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM1664 576v-448h-1408v192l320 320l160 -160l512 512zM1760 1280h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-1216q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5v1216 q0 13 -9.5 22.5t-22.5 9.5zM1920 1248v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113v1216q0 66 47 113t113 47h1600q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf040;" d="M363 0l91 91l-235 235l-91 -91v-107h128v-128h107zM886 928q0 22 -22 22q-10 0 -17 -7l-542 -542q-7 -7 -7 -17q0 -22 22 -22q10 0 17 7l542 542q7 7 7 17zM832 1120l416 -416l-832 -832h-416v416zM1515 1024q0 -53 -37 -90l-166 -166l-416 416l166 165q36 38 90 38 q53 0 91 -38l235 -234q37 -39 37 -91z" />
-<glyph unicode="&#xf041;" horiz-adv-x="1024" d="M768 896q0 106 -75 181t-181 75t-181 -75t-75 -181t75 -181t181 -75t181 75t75 181zM1024 896q0 -109 -33 -179l-364 -774q-16 -33 -47.5 -52t-67.5 -19t-67.5 19t-46.5 52l-365 774q-33 70 -33 179q0 212 150 362t362 150t362 -150t150 -362z" />
-<glyph unicode="&#xf042;" d="M768 96v1088q-148 0 -273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf043;" horiz-adv-x="1024" d="M512 384q0 36 -20 69q-1 1 -15.5 22.5t-25.5 38t-25 44t-21 50.5q-4 16 -21 16t-21 -16q-7 -23 -21 -50.5t-25 -44t-25.5 -38t-15.5 -22.5q-20 -33 -20 -69q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1024 512q0 -212 -150 -362t-362 -150t-362 150t-150 362 q0 145 81 275q6 9 62.5 90.5t101 151t99.5 178t83 201.5q9 30 34 47t51 17t51.5 -17t33.5 -47q28 -93 83 -201.5t99.5 -178t101 -151t62.5 -90.5q81 -127 81 -275z" />
-<glyph unicode="&#xf044;" horiz-adv-x="1792" d="M888 352l116 116l-152 152l-116 -116v-56h96v-96h56zM1328 1072q-16 16 -33 -1l-350 -350q-17 -17 -1 -33t33 1l350 350q17 17 1 33zM1408 478v-190q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h832 q63 0 117 -25q15 -7 18 -23q3 -17 -9 -29l-49 -49q-14 -14 -32 -8q-23 6 -45 6h-832q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v126q0 13 9 22l64 64q15 15 35 7t20 -29zM1312 1216l288 -288l-672 -672h-288v288zM1756 1084l-92 -92 l-288 288l92 92q28 28 68 28t68 -28l152 -152q28 -28 28 -68t-28 -68z" />
-<glyph unicode="&#xf045;" horiz-adv-x="1664" d="M1408 547v-259q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h255v0q13 0 22.5 -9.5t9.5 -22.5q0 -27 -26 -32q-77 -26 -133 -60q-10 -4 -16 -4h-112q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832 q66 0 113 47t47 113v214q0 19 18 29q28 13 54 37q16 16 35 8q21 -9 21 -29zM1645 1043l-384 -384q-18 -19 -45 -19q-12 0 -25 5q-39 17 -39 59v192h-160q-323 0 -438 -131q-119 -137 -74 -473q3 -23 -20 -34q-8 -2 -12 -2q-16 0 -26 13q-10 14 -21 31t-39.5 68.5t-49.5 99.5 t-38.5 114t-17.5 122q0 49 3.5 91t14 90t28 88t47 81.5t68.5 74t94.5 61.5t124.5 48.5t159.5 30.5t196.5 11h160v192q0 42 39 59q13 5 25 5q26 0 45 -19l384 -384q19 -19 19 -45t-19 -45z" />
-<glyph unicode="&#xf046;" horiz-adv-x="1664" d="M1408 606v-318q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h832q63 0 117 -25q15 -7 18 -23q3 -17 -9 -29l-49 -49q-10 -10 -23 -10q-3 0 -9 2q-23 6 -45 6h-832q-66 0 -113 -47t-47 -113v-832 q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v254q0 13 9 22l64 64q10 10 23 10q6 0 12 -3q20 -8 20 -29zM1639 1095l-814 -814q-24 -24 -57 -24t-57 24l-430 430q-24 24 -24 57t24 57l110 110q24 24 57 24t57 -24l263 -263l647 647q24 24 57 24t57 -24l110 -110 q24 -24 24 -57t-24 -57z" />
-<glyph unicode="&#xf047;" horiz-adv-x="1792" d="M1792 640q0 -26 -19 -45l-256 -256q-19 -19 -45 -19t-45 19t-19 45v128h-384v-384h128q26 0 45 -19t19 -45t-19 -45l-256 -256q-19 -19 -45 -19t-45 19l-256 256q-19 19 -19 45t19 45t45 19h128v384h-384v-128q0 -26 -19 -45t-45 -19t-45 19l-256 256q-19 19 -19 45 t19 45l256 256q19 19 45 19t45 -19t19 -45v-128h384v384h-128q-26 0 -45 19t-19 45t19 45l256 256q19 19 45 19t45 -19l256 -256q19 -19 19 -45t-19 -45t-45 -19h-128v-384h384v128q0 26 19 45t45 19t45 -19l256 -256q19 -19 19 -45z" />
-<glyph unicode="&#xf048;" horiz-adv-x="1024" d="M979 1395q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-678q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-678q4 11 13 19z" />
-<glyph unicode="&#xf049;" horiz-adv-x="1792" d="M1747 1395q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-710q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-678q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-678q4 11 13 19l710 710 q19 19 32 13t13 -32v-710q4 11 13 19z" />
-<glyph unicode="&#xf04a;" horiz-adv-x="1664" d="M1619 1395q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-8 9 -13 19v-710q0 -26 -13 -32t-32 13l-710 710q-19 19 -19 45t19 45l710 710q19 19 32 13t13 -32v-710q5 11 13 19z" />
-<glyph unicode="&#xf04b;" horiz-adv-x="1408" d="M1384 609l-1328 -738q-23 -13 -39.5 -3t-16.5 36v1472q0 26 16.5 36t39.5 -3l1328 -738q23 -13 23 -31t-23 -31z" />
-<glyph unicode="&#xf04c;" d="M1536 1344v-1408q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h512q26 0 45 -19t19 -45zM640 1344v-1408q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h512q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf04d;" d="M1536 1344v-1408q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h1408q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf04e;" horiz-adv-x="1664" d="M45 -115q-19 -19 -32 -13t-13 32v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v710q0 26 13 32t32 -13l710 -710q19 -19 19 -45t-19 -45l-710 -710q-19 -19 -32 -13t-13 32v710q-5 -10 -13 -19z" />
-<glyph unicode="&#xf050;" horiz-adv-x="1792" d="M45 -115q-19 -19 -32 -13t-13 32v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v710q0 26 13 32t32 -13l710 -710q8 -8 13 -19v678q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v678q-5 -10 -13 -19l-710 -710 q-19 -19 -32 -13t-13 32v710q-5 -10 -13 -19z" />
-<glyph unicode="&#xf051;" horiz-adv-x="1024" d="M45 -115q-19 -19 -32 -13t-13 32v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v678q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v678q-5 -10 -13 -19z" />
-<glyph unicode="&#xf052;" horiz-adv-x="1538" d="M14 557l710 710q19 19 45 19t45 -19l710 -710q19 -19 13 -32t-32 -13h-1472q-26 0 -32 13t13 32zM1473 0h-1408q-26 0 -45 19t-19 45v256q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19z" />
-<glyph unicode="&#xf053;" horiz-adv-x="1152" d="M742 -37l-652 651q-37 37 -37 90.5t37 90.5l652 651q37 37 90.5 37t90.5 -37l75 -75q37 -37 37 -90.5t-37 -90.5l-486 -486l486 -485q37 -38 37 -91t-37 -90l-75 -75q-37 -37 -90.5 -37t-90.5 37z" />
-<glyph unicode="&#xf054;" horiz-adv-x="1152" d="M1099 704q0 -52 -37 -91l-652 -651q-37 -37 -90 -37t-90 37l-76 75q-37 39 -37 91q0 53 37 90l486 486l-486 485q-37 39 -37 91q0 53 37 90l76 75q36 38 90 38t90 -38l652 -651q37 -37 37 -90z" />
-<glyph unicode="&#xf055;" d="M1216 576v128q0 26 -19 45t-45 19h-256v256q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-256h-256q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h256v-256q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v256h256q26 0 45 19t19 45zM1536 640q0 -209 -103 -385.5 t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf056;" d="M1216 576v128q0 26 -19 45t-45 19h-768q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h768q26 0 45 19t19 45zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5 t103 -385.5z" />
-<glyph unicode="&#xf057;" d="M1149 414q0 26 -19 45l-181 181l181 181q19 19 19 45q0 27 -19 46l-90 90q-19 19 -46 19q-26 0 -45 -19l-181 -181l-181 181q-19 19 -45 19q-27 0 -46 -19l-90 -90q-19 -19 -19 -46q0 -26 19 -45l181 -181l-181 -181q-19 -19 -19 -45q0 -27 19 -46l90 -90q19 -19 46 -19 q26 0 45 19l181 181l181 -181q19 -19 45 -19q27 0 46 19l90 90q19 19 19 46zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf058;" d="M1284 802q0 28 -18 46l-91 90q-19 19 -45 19t-45 -19l-408 -407l-226 226q-19 19 -45 19t-45 -19l-91 -90q-18 -18 -18 -46q0 -27 18 -45l362 -362q19 -19 45 -19q27 0 46 19l543 543q18 18 18 45zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103 t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf059;" d="M896 160v192q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h192q14 0 23 9t9 23zM1152 832q0 88 -55.5 163t-138.5 116t-170 41q-243 0 -371 -213q-15 -24 8 -42l132 -100q7 -6 19 -6q16 0 25 12q53 68 86 92q34 24 86 24q48 0 85.5 -26t37.5 -59 q0 -38 -20 -61t-68 -45q-63 -28 -115.5 -86.5t-52.5 -125.5v-36q0 -14 9 -23t23 -9h192q14 0 23 9t9 23q0 19 21.5 49.5t54.5 49.5q32 18 49 28.5t46 35t44.5 48t28 60.5t12.5 81zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5 t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf05a;" d="M1024 160v160q0 14 -9 23t-23 9h-96v512q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-160q0 -14 9 -23t23 -9h96v-320h-96q-14 0 -23 -9t-9 -23v-160q0 -14 9 -23t23 -9h448q14 0 23 9t9 23zM896 1056v160q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-160q0 -14 9 -23 t23 -9h192q14 0 23 9t9 23zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf05b;" d="M1197 512h-109q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h109q-32 108 -112.5 188.5t-188.5 112.5v-109q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v109q-108 -32 -188.5 -112.5t-112.5 -188.5h109q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-109 q32 -108 112.5 -188.5t188.5 -112.5v109q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-109q108 32 188.5 112.5t112.5 188.5zM1536 704v-128q0 -26 -19 -45t-45 -19h-143q-37 -161 -154.5 -278.5t-278.5 -154.5v-143q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v143 q-161 37 -278.5 154.5t-154.5 278.5h-143q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h143q37 161 154.5 278.5t278.5 154.5v143q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-143q161 -37 278.5 -154.5t154.5 -278.5h143q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf05c;" d="M1097 457l-146 -146q-10 -10 -23 -10t-23 10l-137 137l-137 -137q-10 -10 -23 -10t-23 10l-146 146q-10 10 -10 23t10 23l137 137l-137 137q-10 10 -10 23t10 23l146 146q10 10 23 10t23 -10l137 -137l137 137q10 10 23 10t23 -10l146 -146q10 -10 10 -23t-10 -23 l-137 -137l137 -137q10 -10 10 -23t-10 -23zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5 t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf05d;" d="M1171 723l-422 -422q-19 -19 -45 -19t-45 19l-294 294q-19 19 -19 45t19 45l102 102q19 19 45 19t45 -19l147 -147l275 275q19 19 45 19t45 -19l102 -102q19 -19 19 -45t-19 -45zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198t-73 -273t73 -273t198 -198 t273 -73t273 73t198 198t73 273zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf05e;" d="M1312 643q0 161 -87 295l-754 -753q137 -89 297 -89q111 0 211.5 43.5t173.5 116.5t116 174.5t43 212.5zM313 344l755 754q-135 91 -300 91q-148 0 -273 -73t-198 -199t-73 -274q0 -162 89 -299zM1536 643q0 -157 -61 -300t-163.5 -246t-245 -164t-298.5 -61t-298.5 61 t-245 164t-163.5 246t-61 300t61 299.5t163.5 245.5t245 164t298.5 61t298.5 -61t245 -164t163.5 -245.5t61 -299.5z" />
-<glyph unicode="&#xf060;" d="M1536 640v-128q0 -53 -32.5 -90.5t-84.5 -37.5h-704l293 -294q38 -36 38 -90t-38 -90l-75 -76q-37 -37 -90 -37q-52 0 -91 37l-651 652q-37 37 -37 90q0 52 37 91l651 650q38 38 91 38q52 0 90 -38l75 -74q38 -38 38 -91t-38 -91l-293 -293h704q52 0 84.5 -37.5 t32.5 -90.5z" />
-<glyph unicode="&#xf061;" d="M1472 576q0 -54 -37 -91l-651 -651q-39 -37 -91 -37q-51 0 -90 37l-75 75q-38 38 -38 91t38 91l293 293h-704q-52 0 -84.5 37.5t-32.5 90.5v128q0 53 32.5 90.5t84.5 37.5h704l-293 294q-38 36 -38 90t38 90l75 75q38 38 90 38q53 0 91 -38l651 -651q37 -35 37 -90z" />
-<glyph unicode="&#xf062;" horiz-adv-x="1664" d="M1611 565q0 -51 -37 -90l-75 -75q-38 -38 -91 -38q-54 0 -90 38l-294 293v-704q0 -52 -37.5 -84.5t-90.5 -32.5h-128q-53 0 -90.5 32.5t-37.5 84.5v704l-294 -293q-36 -38 -90 -38t-90 38l-75 75q-38 38 -38 90q0 53 38 91l651 651q35 37 90 37q54 0 91 -37l651 -651 q37 -39 37 -91z" />
-<glyph unicode="&#xf063;" horiz-adv-x="1664" d="M1611 704q0 -53 -37 -90l-651 -652q-39 -37 -91 -37q-53 0 -90 37l-651 652q-38 36 -38 90q0 53 38 91l74 75q39 37 91 37q53 0 90 -37l294 -294v704q0 52 38 90t90 38h128q52 0 90 -38t38 -90v-704l294 294q37 37 90 37q52 0 91 -37l75 -75q37 -39 37 -91z" />
-<glyph unicode="&#xf064;" horiz-adv-x="1792" d="M1792 896q0 -26 -19 -45l-512 -512q-19 -19 -45 -19t-45 19t-19 45v256h-224q-98 0 -175.5 -6t-154 -21.5t-133 -42.5t-105.5 -69.5t-80 -101t-48.5 -138.5t-17.5 -181q0 -55 5 -123q0 -6 2.5 -23.5t2.5 -26.5q0 -15 -8.5 -25t-23.5 -10q-16 0 -28 17q-7 9 -13 22 t-13.5 30t-10.5 24q-127 285 -127 451q0 199 53 333q162 403 875 403h224v256q0 26 19 45t45 19t45 -19l512 -512q19 -19 19 -45z" />
-<glyph unicode="&#xf065;" d="M755 480q0 -13 -10 -23l-332 -332l144 -144q19 -19 19 -45t-19 -45t-45 -19h-448q-26 0 -45 19t-19 45v448q0 26 19 45t45 19t45 -19l144 -144l332 332q10 10 23 10t23 -10l114 -114q10 -10 10 -23zM1536 1344v-448q0 -26 -19 -45t-45 -19t-45 19l-144 144l-332 -332 q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23t10 23l332 332l-144 144q-19 19 -19 45t19 45t45 19h448q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf066;" d="M768 576v-448q0 -26 -19 -45t-45 -19t-45 19l-144 144l-332 -332q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23t10 23l332 332l-144 144q-19 19 -19 45t19 45t45 19h448q26 0 45 -19t19 -45zM1523 1248q0 -13 -10 -23l-332 -332l144 -144q19 -19 19 -45t-19 -45 t-45 -19h-448q-26 0 -45 19t-19 45v448q0 26 19 45t45 19t45 -19l144 -144l332 332q10 10 23 10t23 -10l114 -114q10 -10 10 -23z" />
-<glyph unicode="&#xf067;" horiz-adv-x="1408" d="M1408 800v-192q0 -40 -28 -68t-68 -28h-416v-416q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v416h-416q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h416v416q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-416h416q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf068;" horiz-adv-x="1408" d="M1408 800v-192q0 -40 -28 -68t-68 -28h-1216q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h1216q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf069;" horiz-adv-x="1664" d="M1482 486q46 -26 59.5 -77.5t-12.5 -97.5l-64 -110q-26 -46 -77.5 -59.5t-97.5 12.5l-266 153v-307q0 -52 -38 -90t-90 -38h-128q-52 0 -90 38t-38 90v307l-266 -153q-46 -26 -97.5 -12.5t-77.5 59.5l-64 110q-26 46 -12.5 97.5t59.5 77.5l266 154l-266 154 q-46 26 -59.5 77.5t12.5 97.5l64 110q26 46 77.5 59.5t97.5 -12.5l266 -153v307q0 52 38 90t90 38h128q52 0 90 -38t38 -90v-307l266 153q46 26 97.5 12.5t77.5 -59.5l64 -110q26 -46 12.5 -97.5t-59.5 -77.5l-266 -154z" />
-<glyph unicode="&#xf06a;" d="M768 1408q209 0 385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103zM896 161v190q0 14 -9 23.5t-22 9.5h-192q-13 0 -23 -10t-10 -23v-190q0 -13 10 -23t23 -10h192 q13 0 22 9.5t9 23.5zM894 505l18 621q0 12 -10 18q-10 8 -24 8h-220q-14 0 -24 -8q-10 -6 -10 -18l17 -621q0 -10 10 -17.5t24 -7.5h185q14 0 23.5 7.5t10.5 17.5z" />
-<glyph unicode="&#xf06b;" d="M928 180v56v468v192h-320v-192v-468v-56q0 -25 18 -38.5t46 -13.5h192q28 0 46 13.5t18 38.5zM472 1024h195l-126 161q-26 31 -69 31q-40 0 -68 -28t-28 -68t28 -68t68 -28zM1160 1120q0 40 -28 68t-68 28q-43 0 -69 -31l-125 -161h194q40 0 68 28t28 68zM1536 864v-320 q0 -14 -9 -23t-23 -9h-96v-416q0 -40 -28 -68t-68 -28h-1088q-40 0 -68 28t-28 68v416h-96q-14 0 -23 9t-9 23v320q0 14 9 23t23 9h440q-93 0 -158.5 65.5t-65.5 158.5t65.5 158.5t158.5 65.5q107 0 168 -77l128 -165l128 165q61 77 168 77q93 0 158.5 -65.5t65.5 -158.5 t-65.5 -158.5t-158.5 -65.5h440q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf06c;" horiz-adv-x="1792" d="M1280 832q0 26 -19 45t-45 19q-172 0 -318 -49.5t-259.5 -134t-235.5 -219.5q-19 -21 -19 -45q0 -26 19 -45t45 -19q24 0 45 19q27 24 74 71t67 66q137 124 268.5 176t313.5 52q26 0 45 19t19 45zM1792 1030q0 -95 -20 -193q-46 -224 -184.5 -383t-357.5 -268 q-214 -108 -438 -108q-148 0 -286 47q-15 5 -88 42t-96 37q-16 0 -39.5 -32t-45 -70t-52.5 -70t-60 -32q-30 0 -51 11t-31 24t-27 42q-2 4 -6 11t-5.5 10t-3 9.5t-1.5 13.5q0 35 31 73.5t68 65.5t68 56t31 48q0 4 -14 38t-16 44q-9 51 -9 104q0 115 43.5 220t119 184.5 t170.5 139t204 95.5q55 18 145 25.5t179.5 9t178.5 6t163.5 24t113.5 56.5l29.5 29.5t29.5 28t27 20t36.5 16t43.5 4.5q39 0 70.5 -46t47.5 -112t24 -124t8 -96z" />
-<glyph unicode="&#xf06d;" horiz-adv-x="1408" d="M1408 -160v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5zM1152 896q0 -78 -24.5 -144t-64 -112.5t-87.5 -88t-96 -77.5t-87.5 -72t-64 -81.5t-24.5 -96.5q0 -96 67 -224l-4 1l1 -1 q-90 41 -160 83t-138.5 100t-113.5 122.5t-72.5 150.5t-27.5 184q0 78 24.5 144t64 112.5t87.5 88t96 77.5t87.5 72t64 81.5t24.5 96.5q0 94 -66 224l3 -1l-1 1q90 -41 160 -83t138.5 -100t113.5 -122.5t72.5 -150.5t27.5 -184z" />
-<glyph unicode="&#xf06e;" horiz-adv-x="1792" d="M1664 576q-152 236 -381 353q61 -104 61 -225q0 -185 -131.5 -316.5t-316.5 -131.5t-316.5 131.5t-131.5 316.5q0 121 61 225q-229 -117 -381 -353q133 -205 333.5 -326.5t434.5 -121.5t434.5 121.5t333.5 326.5zM944 960q0 20 -14 34t-34 14q-125 0 -214.5 -89.5 t-89.5 -214.5q0 -20 14 -34t34 -14t34 14t14 34q0 86 61 147t147 61q20 0 34 14t14 34zM1792 576q0 -34 -20 -69q-140 -230 -376.5 -368.5t-499.5 -138.5t-499.5 139t-376.5 368q-20 35 -20 69t20 69q140 229 376.5 368t499.5 139t499.5 -139t376.5 -368q20 -35 20 -69z" />
-<glyph unicode="&#xf070;" horiz-adv-x="1792" d="M555 201l78 141q-87 63 -136 159t-49 203q0 121 61 225q-229 -117 -381 -353q167 -258 427 -375zM944 960q0 20 -14 34t-34 14q-125 0 -214.5 -89.5t-89.5 -214.5q0 -20 14 -34t34 -14t34 14t14 34q0 86 61 147t147 61q20 0 34 14t14 34zM1307 1151q0 -7 -1 -9 q-105 -188 -315 -566t-316 -567l-49 -89q-10 -16 -28 -16q-12 0 -134 70q-16 10 -16 28q0 12 44 87q-143 65 -263.5 173t-208.5 245q-20 31 -20 69t20 69q153 235 380 371t496 136q89 0 180 -17l54 97q10 16 28 16q5 0 18 -6t31 -15.5t33 -18.5t31.5 -18.5t19.5 -11.5 q16 -10 16 -27zM1344 704q0 -139 -79 -253.5t-209 -164.5l280 502q8 -45 8 -84zM1792 576q0 -35 -20 -69q-39 -64 -109 -145q-150 -172 -347.5 -267t-419.5 -95l74 132q212 18 392.5 137t301.5 307q-115 179 -282 294l63 112q95 -64 182.5 -153t144.5 -184q20 -34 20 -69z " />
-<glyph unicode="&#xf071;" horiz-adv-x="1792" d="M1024 161v190q0 14 -9.5 23.5t-22.5 9.5h-192q-13 0 -22.5 -9.5t-9.5 -23.5v-190q0 -14 9.5 -23.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 23.5zM1022 535l18 459q0 12 -10 19q-13 11 -24 11h-220q-11 0 -24 -11q-10 -7 -10 -21l17 -457q0 -10 10 -16.5t24 -6.5h185 q14 0 23.5 6.5t10.5 16.5zM1008 1469l768 -1408q35 -63 -2 -126q-17 -29 -46.5 -46t-63.5 -17h-1536q-34 0 -63.5 17t-46.5 46q-37 63 -2 126l768 1408q17 31 47 49t65 18t65 -18t47 -49z" />
-<glyph unicode="&#xf072;" horiz-adv-x="1408" d="M1376 1376q44 -52 12 -148t-108 -172l-161 -161l160 -696q5 -19 -12 -33l-128 -96q-7 -6 -19 -6q-4 0 -7 1q-15 3 -21 16l-279 508l-259 -259l53 -194q5 -17 -8 -31l-96 -96q-9 -9 -23 -9h-2q-15 2 -24 13l-189 252l-252 189q-11 7 -13 23q-1 13 9 25l96 97q9 9 23 9 q6 0 8 -1l194 -53l259 259l-508 279q-14 8 -17 24q-2 16 9 27l128 128q14 13 30 8l665 -159l160 160q76 76 172 108t148 -12z" />
-<glyph unicode="&#xf073;" horiz-adv-x="1664" d="M128 -128h288v288h-288v-288zM480 -128h320v288h-320v-288zM128 224h288v320h-288v-320zM480 224h320v320h-320v-320zM128 608h288v288h-288v-288zM864 -128h320v288h-320v-288zM480 608h320v288h-320v-288zM1248 -128h288v288h-288v-288zM864 224h320v320h-320v-320z M512 1088v288q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-288q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5zM1248 224h288v320h-288v-320zM864 608h320v288h-320v-288zM1248 608h288v288h-288v-288zM1280 1088v288q0 13 -9.5 22.5t-22.5 9.5h-64 q-13 0 -22.5 -9.5t-9.5 -22.5v-288q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5zM1664 1152v-1280q0 -52 -38 -90t-90 -38h-1408q-52 0 -90 38t-38 90v1280q0 52 38 90t90 38h128v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h384v96q0 66 47 113t113 47 h64q66 0 113 -47t47 -113v-96h128q52 0 90 -38t38 -90z" />
-<glyph unicode="&#xf074;" horiz-adv-x="1792" d="M666 1055q-60 -92 -137 -273q-22 45 -37 72.5t-40.5 63.5t-51 56.5t-63 35t-81.5 14.5h-224q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h224q250 0 410 -225zM1792 256q0 -14 -9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192q-32 0 -85 -0.5t-81 -1t-73 1 t-71 5t-64 10.5t-63 18.5t-58 28.5t-59 40t-55 53.5t-56 69.5q59 93 136 273q22 -45 37 -72.5t40.5 -63.5t51 -56.5t63 -35t81.5 -14.5h256v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23zM1792 1152q0 -14 -9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5 v192h-256q-48 0 -87 -15t-69 -45t-51 -61.5t-45 -77.5q-32 -62 -78 -171q-29 -66 -49.5 -111t-54 -105t-64 -100t-74 -83t-90 -68.5t-106.5 -42t-128 -16.5h-224q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h224q48 0 87 15t69 45t51 61.5t45 77.5q32 62 78 171q29 66 49.5 111 t54 105t64 100t74 83t90 68.5t106.5 42t128 16.5h256v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23z" />
-<glyph unicode="&#xf075;" horiz-adv-x="1792" d="M1792 640q0 -174 -120 -321.5t-326 -233t-450 -85.5q-70 0 -145 8q-198 -175 -460 -242q-49 -14 -114 -22q-17 -2 -30.5 9t-17.5 29v1q-3 4 -0.5 12t2 10t4.5 9.5l6 9t7 8.5t8 9q7 8 31 34.5t34.5 38t31 39.5t32.5 51t27 59t26 76q-157 89 -247.5 220t-90.5 281 q0 130 71 248.5t191 204.5t286 136.5t348 50.5q244 0 450 -85.5t326 -233t120 -321.5z" />
-<glyph unicode="&#xf076;" d="M1536 704v-128q0 -201 -98.5 -362t-274 -251.5t-395.5 -90.5t-395.5 90.5t-274 251.5t-98.5 362v128q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-128q0 -52 23.5 -90t53.5 -57t71 -30t64 -13t44 -2t44 2t64 13t71 30t53.5 57t23.5 90v128q0 26 19 45t45 19h384 q26 0 45 -19t19 -45zM512 1344v-384q0 -26 -19 -45t-45 -19h-384q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h384q26 0 45 -19t19 -45zM1536 1344v-384q0 -26 -19 -45t-45 -19h-384q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h384q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf077;" horiz-adv-x="1664" d="M1611 320q0 -53 -37 -90l-75 -75q-38 -38 -91 -38q-54 0 -90 38l-486 485l-486 -485q-36 -38 -90 -38t-90 38l-75 75q-38 36 -38 90q0 53 38 91l651 651q37 37 90 37q52 0 91 -37l650 -651q38 -38 38 -91z" />
-<glyph unicode="&#xf078;" horiz-adv-x="1664" d="M1611 832q0 -53 -37 -90l-651 -651q-38 -38 -91 -38q-54 0 -90 38l-651 651q-38 36 -38 90q0 53 38 91l74 75q39 37 91 37q53 0 90 -37l486 -486l486 486q37 37 90 37q52 0 91 -37l75 -75q37 -39 37 -91z" />
-<glyph unicode="&#xf079;" horiz-adv-x="1920" d="M1280 32q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-8 0 -13.5 2t-9 7t-5.5 8t-3 11.5t-1 11.5v13v11v160v416h-192q-26 0 -45 19t-19 45q0 24 15 41l320 384q19 22 49 22t49 -22l320 -384q15 -17 15 -41q0 -26 -19 -45t-45 -19h-192v-384h576q16 0 25 -11l160 -192q7 -11 7 -21 zM1920 448q0 -24 -15 -41l-320 -384q-20 -23 -49 -23t-49 23l-320 384q-15 17 -15 41q0 26 19 45t45 19h192v384h-576q-16 0 -25 12l-160 192q-7 9 -7 20q0 13 9.5 22.5t22.5 9.5h960q8 0 13.5 -2t9 -7t5.5 -8t3 -11.5t1 -11.5v-13v-11v-160v-416h192q26 0 45 -19t19 -45z " />
-<glyph unicode="&#xf07a;" horiz-adv-x="1664" d="M640 0q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1536 0q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1664 1088v-512q0 -24 -16 -42.5t-41 -21.5 l-1044 -122q1 -7 4.5 -21.5t6 -26.5t2.5 -22q0 -16 -24 -64h920q26 0 45 -19t19 -45t-19 -45t-45 -19h-1024q-26 0 -45 19t-19 45q0 14 11 39.5t29.5 59.5t20.5 38l-177 823h-204q-26 0 -45 19t-19 45t19 45t45 19h256q16 0 28.5 -6.5t20 -15.5t13 -24.5t7.5 -26.5 t5.5 -29.5t4.5 -25.5h1201q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf07b;" horiz-adv-x="1664" d="M1664 928v-704q0 -92 -66 -158t-158 -66h-1216q-92 0 -158 66t-66 158v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h672q92 0 158 -66t66 -158z" />
-<glyph unicode="&#xf07c;" horiz-adv-x="1920" d="M1879 584q0 -31 -31 -66l-336 -396q-43 -51 -120.5 -86.5t-143.5 -35.5h-1088q-34 0 -60.5 13t-26.5 43q0 31 31 66l336 396q43 51 120.5 86.5t143.5 35.5h1088q34 0 60.5 -13t26.5 -43zM1536 928v-160h-832q-94 0 -197 -47.5t-164 -119.5l-337 -396l-5 -6q0 4 -0.5 12.5 t-0.5 12.5v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h544q92 0 158 -66t66 -158z" />
-<glyph unicode="&#xf07d;" horiz-adv-x="768" d="M704 1216q0 -26 -19 -45t-45 -19h-128v-1024h128q26 0 45 -19t19 -45t-19 -45l-256 -256q-19 -19 -45 -19t-45 19l-256 256q-19 19 -19 45t19 45t45 19h128v1024h-128q-26 0 -45 19t-19 45t19 45l256 256q19 19 45 19t45 -19l256 -256q19 -19 19 -45z" />
-<glyph unicode="&#xf07e;" horiz-adv-x="1792" d="M1792 640q0 -26 -19 -45l-256 -256q-19 -19 -45 -19t-45 19t-19 45v128h-1024v-128q0 -26 -19 -45t-45 -19t-45 19l-256 256q-19 19 -19 45t19 45l256 256q19 19 45 19t45 -19t19 -45v-128h1024v128q0 26 19 45t45 19t45 -19l256 -256q19 -19 19 -45z" />
-<glyph unicode="&#xf080;" horiz-adv-x="1920" d="M512 512v-384h-256v384h256zM896 1024v-896h-256v896h256zM1280 768v-640h-256v640h256zM1664 1152v-1024h-256v1024h256zM1792 32v1216q0 13 -9.5 22.5t-22.5 9.5h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-1216q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5z M1920 1248v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113v1216q0 66 47 113t113 47h1600q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf081;" d="M1280 926q-56 -25 -121 -34q68 40 93 117q-65 -38 -134 -51q-61 66 -153 66q-87 0 -148.5 -61.5t-61.5 -148.5q0 -29 5 -48q-129 7 -242 65t-192 155q-29 -50 -29 -106q0 -114 91 -175q-47 1 -100 26v-2q0 -75 50 -133.5t123 -72.5q-29 -8 -51 -8q-13 0 -39 4 q21 -63 74.5 -104t121.5 -42q-116 -90 -261 -90q-26 0 -50 3q148 -94 322 -94q112 0 210 35.5t168 95t120.5 137t75 162t24.5 168.5q0 18 -1 27q63 45 105 109zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5 t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf082;" d="M1307 618l23 219h-198v109q0 49 15.5 68.5t71.5 19.5h110v219h-175q-152 0 -218 -72t-66 -213v-131h-131v-219h131v-635h262v635h175zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960 q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf083;" horiz-adv-x="1792" d="M928 704q0 14 -9 23t-23 9q-66 0 -113 -47t-47 -113q0 -14 9 -23t23 -9t23 9t9 23q0 40 28 68t68 28q14 0 23 9t9 23zM1152 574q0 -106 -75 -181t-181 -75t-181 75t-75 181t75 181t181 75t181 -75t75 -181zM128 0h1536v128h-1536v-128zM1280 574q0 159 -112.5 271.5 t-271.5 112.5t-271.5 -112.5t-112.5 -271.5t112.5 -271.5t271.5 -112.5t271.5 112.5t112.5 271.5zM256 1216h384v128h-384v-128zM128 1024h1536v118v138h-828l-64 -128h-644v-128zM1792 1280v-1280q0 -53 -37.5 -90.5t-90.5 -37.5h-1536q-53 0 -90.5 37.5t-37.5 90.5v1280 q0 53 37.5 90.5t90.5 37.5h1536q53 0 90.5 -37.5t37.5 -90.5z" />
-<glyph unicode="&#xf084;" horiz-adv-x="1792" d="M832 1024q0 80 -56 136t-136 56t-136 -56t-56 -136q0 -42 19 -83q-41 19 -83 19q-80 0 -136 -56t-56 -136t56 -136t136 -56t136 56t56 136q0 42 -19 83q41 -19 83 -19q80 0 136 56t56 136zM1683 320q0 -17 -49 -66t-66 -49q-9 0 -28.5 16t-36.5 33t-38.5 40t-24.5 26 l-96 -96l220 -220q28 -28 28 -68q0 -42 -39 -81t-81 -39q-40 0 -68 28l-671 671q-176 -131 -365 -131q-163 0 -265.5 102.5t-102.5 265.5q0 160 95 313t248 248t313 95q163 0 265.5 -102.5t102.5 -265.5q0 -189 -131 -365l355 -355l96 96q-3 3 -26 24.5t-40 38.5t-33 36.5 t-16 28.5q0 17 49 66t66 49q13 0 23 -10q6 -6 46 -44.5t82 -79.5t86.5 -86t73 -78t28.5 -41z" />
-<glyph unicode="&#xf085;" horiz-adv-x="1920" d="M896 640q0 106 -75 181t-181 75t-181 -75t-75 -181t75 -181t181 -75t181 75t75 181zM1664 128q0 52 -38 90t-90 38t-90 -38t-38 -90q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1664 1152q0 52 -38 90t-90 38t-90 -38t-38 -90q0 -53 37.5 -90.5t90.5 -37.5 t90.5 37.5t37.5 90.5zM1280 731v-185q0 -10 -7 -19.5t-16 -10.5l-155 -24q-11 -35 -32 -76q34 -48 90 -115q7 -10 7 -20q0 -12 -7 -19q-23 -30 -82.5 -89.5t-78.5 -59.5q-11 0 -21 7l-115 90q-37 -19 -77 -31q-11 -108 -23 -155q-7 -24 -30 -24h-186q-11 0 -20 7.5t-10 17.5 l-23 153q-34 10 -75 31l-118 -89q-7 -7 -20 -7q-11 0 -21 8q-144 133 -144 160q0 9 7 19q10 14 41 53t47 61q-23 44 -35 82l-152 24q-10 1 -17 9.5t-7 19.5v185q0 10 7 19.5t16 10.5l155 24q11 35 32 76q-34 48 -90 115q-7 11 -7 20q0 12 7 20q22 30 82 89t79 59q11 0 21 -7 l115 -90q34 18 77 32q11 108 23 154q7 24 30 24h186q11 0 20 -7.5t10 -17.5l23 -153q34 -10 75 -31l118 89q8 7 20 7q11 0 21 -8q144 -133 144 -160q0 -9 -7 -19q-12 -16 -42 -54t-45 -60q23 -48 34 -82l152 -23q10 -2 17 -10.5t7 -19.5zM1920 198v-140q0 -16 -149 -31 q-12 -27 -30 -52q51 -113 51 -138q0 -4 -4 -7q-122 -71 -124 -71q-8 0 -46 47t-52 68q-20 -2 -30 -2t-30 2q-14 -21 -52 -68t-46 -47q-2 0 -124 71q-4 3 -4 7q0 25 51 138q-18 25 -30 52q-149 15 -149 31v140q0 16 149 31q13 29 30 52q-51 113 -51 138q0 4 4 7q4 2 35 20 t59 34t30 16q8 0 46 -46.5t52 -67.5q20 2 30 2t30 -2q51 71 92 112l6 2q4 0 124 -70q4 -3 4 -7q0 -25 -51 -138q17 -23 30 -52q149 -15 149 -31zM1920 1222v-140q0 -16 -149 -31q-12 -27 -30 -52q51 -113 51 -138q0 -4 -4 -7q-122 -71 -124 -71q-8 0 -46 47t-52 68 q-20 -2 -30 -2t-30 2q-14 -21 -52 -68t-46 -47q-2 0 -124 71q-4 3 -4 7q0 25 51 138q-18 25 -30 52q-149 15 -149 31v140q0 16 149 31q13 29 30 52q-51 113 -51 138q0 4 4 7q4 2 35 20t59 34t30 16q8 0 46 -46.5t52 -67.5q20 2 30 2t30 -2q51 71 92 112l6 2q4 0 124 -70 q4 -3 4 -7q0 -25 -51 -138q17 -23 30 -52q149 -15 149 -31z" />
-<glyph unicode="&#xf086;" horiz-adv-x="1792" d="M1408 768q0 -139 -94 -257t-256.5 -186.5t-353.5 -68.5q-86 0 -176 16q-124 -88 -278 -128q-36 -9 -86 -16h-3q-11 0 -20.5 8t-11.5 21q-1 3 -1 6.5t0.5 6.5t2 6l2.5 5t3.5 5.5t4 5t4.5 5t4 4.5q5 6 23 25t26 29.5t22.5 29t25 38.5t20.5 44q-124 72 -195 177t-71 224 q0 139 94 257t256.5 186.5t353.5 68.5t353.5 -68.5t256.5 -186.5t94 -257zM1792 512q0 -120 -71 -224.5t-195 -176.5q10 -24 20.5 -44t25 -38.5t22.5 -29t26 -29.5t23 -25q1 -1 4 -4.5t4.5 -5t4 -5t3.5 -5.5l2.5 -5t2 -6t0.5 -6.5t-1 -6.5q-3 -14 -13 -22t-22 -7 q-50 7 -86 16q-154 40 -278 128q-90 -16 -176 -16q-271 0 -472 132q58 -4 88 -4q161 0 309 45t264 129q125 92 192 212t67 254q0 77 -23 152q129 -71 204 -178t75 -230z" />
-<glyph unicode="&#xf087;" d="M256 192q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1408 768q0 51 -39 89.5t-89 38.5h-352q0 58 48 159.5t48 160.5q0 98 -32 145t-128 47q-26 -26 -38 -85t-30.5 -125.5t-59.5 -109.5q-22 -23 -77 -91q-4 -5 -23 -30t-31.5 -41t-34.5 -42.5 t-40 -44t-38.5 -35.5t-40 -27t-35.5 -9h-32v-640h32q13 0 31.5 -3t33 -6.5t38 -11t35 -11.5t35.5 -12.5t29 -10.5q211 -73 342 -73h121q192 0 192 167q0 26 -5 56q30 16 47.5 52.5t17.5 73.5t-18 69q53 50 53 119q0 25 -10 55.5t-25 47.5q32 1 53.5 47t21.5 81zM1536 769 q0 -89 -49 -163q9 -33 9 -69q0 -77 -38 -144q3 -21 3 -43q0 -101 -60 -178q1 -139 -85 -219.5t-227 -80.5h-36h-93q-96 0 -189.5 22.5t-216.5 65.5q-116 40 -138 40h-288q-53 0 -90.5 37.5t-37.5 90.5v640q0 53 37.5 90.5t90.5 37.5h274q36 24 137 155q58 75 107 128 q24 25 35.5 85.5t30.5 126.5t62 108q39 37 90 37q84 0 151 -32.5t102 -101.5t35 -186q0 -93 -48 -192h176q104 0 180 -76t76 -179z" />
-<glyph unicode="&#xf088;" d="M256 1088q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1408 512q0 35 -21.5 81t-53.5 47q15 17 25 47.5t10 55.5q0 69 -53 119q18 32 18 69t-17.5 73.5t-47.5 52.5q5 30 5 56q0 85 -49 126t-136 41h-128q-131 0 -342 -73q-5 -2 -29 -10.5 t-35.5 -12.5t-35 -11.5t-38 -11t-33 -6.5t-31.5 -3h-32v-640h32q16 0 35.5 -9t40 -27t38.5 -35.5t40 -44t34.5 -42.5t31.5 -41t23 -30q55 -68 77 -91q41 -43 59.5 -109.5t30.5 -125.5t38 -85q96 0 128 47t32 145q0 59 -48 160.5t-48 159.5h352q50 0 89 38.5t39 89.5z M1536 511q0 -103 -76 -179t-180 -76h-176q48 -99 48 -192q0 -118 -35 -186q-35 -69 -102 -101.5t-151 -32.5q-51 0 -90 37q-34 33 -54 82t-25.5 90.5t-17.5 84.5t-31 64q-48 50 -107 127q-101 131 -137 155h-274q-53 0 -90.5 37.5t-37.5 90.5v640q0 53 37.5 90.5t90.5 37.5 h288q22 0 138 40q128 44 223 66t200 22h112q140 0 226.5 -79t85.5 -216v-5q60 -77 60 -178q0 -22 -3 -43q38 -67 38 -144q0 -36 -9 -69q49 -74 49 -163z" />
-<glyph unicode="&#xf089;" horiz-adv-x="896" d="M832 1504v-1339l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500l-364 354q-25 27 -25 48q0 37 56 46l502 73l225 455q19 41 49 41z" />
-<glyph unicode="&#xf08a;" horiz-adv-x="1792" d="M1664 940q0 81 -21.5 143t-55 98.5t-81.5 59.5t-94 31t-98 8t-112 -25.5t-110.5 -64t-86.5 -72t-60 -61.5q-18 -22 -49 -22t-49 22q-24 28 -60 61.5t-86.5 72t-110.5 64t-112 25.5t-98 -8t-94 -31t-81.5 -59.5t-55 -98.5t-21.5 -143q0 -168 187 -355l581 -560l580 559 q188 188 188 356zM1792 940q0 -221 -229 -450l-623 -600q-18 -18 -44 -18t-44 18l-624 602q-10 8 -27.5 26t-55.5 65.5t-68 97.5t-53.5 121t-23.5 138q0 220 127 344t351 124q62 0 126.5 -21.5t120 -58t95.5 -68.5t76 -68q36 36 76 68t95.5 68.5t120 58t126.5 21.5 q224 0 351 -124t127 -344z" />
-<glyph unicode="&#xf08b;" horiz-adv-x="1664" d="M640 96q0 -4 1 -20t0.5 -26.5t-3 -23.5t-10 -19.5t-20.5 -6.5h-320q-119 0 -203.5 84.5t-84.5 203.5v704q0 119 84.5 203.5t203.5 84.5h320q13 0 22.5 -9.5t9.5 -22.5q0 -4 1 -20t0.5 -26.5t-3 -23.5t-10 -19.5t-20.5 -6.5h-320q-66 0 -113 -47t-47 -113v-704 q0 -66 47 -113t113 -47h288h11h13t11.5 -1t11.5 -3t8 -5.5t7 -9t2 -13.5zM1568 640q0 -26 -19 -45l-544 -544q-19 -19 -45 -19t-45 19t-19 45v288h-448q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h448v288q0 26 19 45t45 19t45 -19l544 -544q19 -19 19 -45z" />
-<glyph unicode="&#xf08c;" d="M237 122h231v694h-231v-694zM483 1030q-1 52 -36 86t-93 34t-94.5 -34t-36.5 -86q0 -51 35.5 -85.5t92.5 -34.5h1q59 0 95 34.5t36 85.5zM1068 122h231v398q0 154 -73 233t-193 79q-136 0 -209 -117h2v101h-231q3 -66 0 -694h231v388q0 38 7 56q15 35 45 59.5t74 24.5 q116 0 116 -157v-371zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf08d;" horiz-adv-x="1152" d="M480 672v448q0 14 -9 23t-23 9t-23 -9t-9 -23v-448q0 -14 9 -23t23 -9t23 9t9 23zM1152 320q0 -26 -19 -45t-45 -19h-429l-51 -483q-2 -12 -10.5 -20.5t-20.5 -8.5h-1q-27 0 -32 27l-76 485h-404q-26 0 -45 19t-19 45q0 123 78.5 221.5t177.5 98.5v512q-52 0 -90 38 t-38 90t38 90t90 38h640q52 0 90 -38t38 -90t-38 -90t-90 -38v-512q99 0 177.5 -98.5t78.5 -221.5z" />
-<glyph unicode="&#xf08e;" horiz-adv-x="1792" d="M1408 608v-320q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h704q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-704q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v320 q0 14 9 23t23 9h64q14 0 23 -9t9 -23zM1792 1472v-512q0 -26 -19 -45t-45 -19t-45 19l-176 176l-652 -652q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23t10 23l652 652l-176 176q-19 19 -19 45t19 45t45 19h512q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf090;" d="M1184 640q0 -26 -19 -45l-544 -544q-19 -19 -45 -19t-45 19t-19 45v288h-448q-26 0 -45 19t-19 45v384q0 26 19 45t45 19h448v288q0 26 19 45t45 19t45 -19l544 -544q19 -19 19 -45zM1536 992v-704q0 -119 -84.5 -203.5t-203.5 -84.5h-320q-13 0 -22.5 9.5t-9.5 22.5 q0 4 -1 20t-0.5 26.5t3 23.5t10 19.5t20.5 6.5h320q66 0 113 47t47 113v704q0 66 -47 113t-113 47h-288h-11h-13t-11.5 1t-11.5 3t-8 5.5t-7 9t-2 13.5q0 4 -1 20t-0.5 26.5t3 23.5t10 19.5t20.5 6.5h320q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf091;" horiz-adv-x="1664" d="M458 653q-74 162 -74 371h-256v-96q0 -78 94.5 -162t235.5 -113zM1536 928v96h-256q0 -209 -74 -371q141 29 235.5 113t94.5 162zM1664 1056v-128q0 -71 -41.5 -143t-112 -130t-173 -97.5t-215.5 -44.5q-42 -54 -95 -95q-38 -34 -52.5 -72.5t-14.5 -89.5q0 -54 30.5 -91 t97.5 -37q75 0 133.5 -45.5t58.5 -114.5v-64q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23v64q0 69 58.5 114.5t133.5 45.5q67 0 97.5 37t30.5 91q0 51 -14.5 89.5t-52.5 72.5q-53 41 -95 95q-113 5 -215.5 44.5t-173 97.5t-112 130t-41.5 143v128q0 40 28 68t68 28h288v96 q0 66 47 113t113 47h576q66 0 113 -47t47 -113v-96h288q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf092;" d="M394 184q-8 -9 -20 3q-13 11 -4 19q8 9 20 -3q12 -11 4 -19zM352 245q9 -12 0 -19q-8 -6 -17 7t0 18q9 7 17 -6zM291 305q-5 -7 -13 -2q-10 5 -7 12q3 5 13 2q10 -5 7 -12zM322 271q-6 -7 -16 3q-9 11 -2 16q6 6 16 -3q9 -11 2 -16zM451 159q-4 -12 -19 -6q-17 4 -13 15 t19 7q16 -5 13 -16zM514 154q0 -11 -16 -11q-17 -2 -17 11q0 11 16 11q17 2 17 -11zM572 164q2 -10 -14 -14t-18 8t14 15q16 2 18 -9zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-224q-16 0 -24.5 1t-19.5 5t-16 14.5t-5 27.5v239q0 97 -52 142q57 6 102.5 18t94 39 t81 66.5t53 105t20.5 150.5q0 121 -79 206q37 91 -8 204q-28 9 -81 -11t-92 -44l-38 -24q-93 26 -192 26t-192 -26q-16 11 -42.5 27t-83.5 38.5t-86 13.5q-44 -113 -7 -204q-79 -85 -79 -206q0 -85 20.5 -150t52.5 -105t80.5 -67t94 -39t102.5 -18q-40 -36 -49 -103 q-21 -10 -45 -15t-57 -5t-65.5 21.5t-55.5 62.5q-19 32 -48.5 52t-49.5 24l-20 3q-21 0 -29 -4.5t-5 -11.5t9 -14t13 -12l7 -5q22 -10 43.5 -38t31.5 -51l10 -23q13 -38 44 -61.5t67 -30t69.5 -7t55.5 3.5l23 4q0 -38 0.5 -103t0.5 -68q0 -22 -11 -33.5t-22 -13t-33 -1.5 h-224q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf093;" horiz-adv-x="1664" d="M1280 64q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1536 64q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1664 288v-320q0 -40 -28 -68t-68 -28h-1472q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h427q21 -56 70.5 -92 t110.5 -36h256q61 0 110.5 36t70.5 92h427q40 0 68 -28t28 -68zM1339 936q-17 -40 -59 -40h-256v-448q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45v448h-256q-42 0 -59 40q-17 39 14 69l448 448q18 19 45 19t45 -19l448 -448q31 -30 14 -69z" />
-<glyph unicode="&#xf094;" d="M1407 710q0 44 -7 113.5t-18 96.5q-12 30 -17 44t-9 36.5t-4 48.5q0 23 5 68.5t5 67.5q0 37 -10 55q-4 1 -13 1q-19 0 -58 -4.5t-59 -4.5q-60 0 -176 24t-175 24q-43 0 -94.5 -11.5t-85 -23.5t-89.5 -34q-137 -54 -202 -103q-96 -73 -159.5 -189.5t-88 -236t-24.5 -248.5 q0 -40 12.5 -120t12.5 -121q0 -23 -11 -66.5t-11 -65.5t12 -36.5t34 -14.5q24 0 72.5 11t73.5 11q57 0 169.5 -15.5t169.5 -15.5q181 0 284 36q129 45 235.5 152.5t166 245.5t59.5 275zM1535 712q0 -165 -70 -327.5t-196 -288t-281 -180.5q-124 -44 -326 -44 q-57 0 -170 14.5t-169 14.5q-24 0 -72.5 -14.5t-73.5 -14.5q-73 0 -123.5 55.5t-50.5 128.5q0 24 11 68t11 67q0 40 -12.5 120.5t-12.5 121.5q0 111 18 217.5t54.5 209.5t100.5 194t150 156q78 59 232 120q194 78 316 78q60 0 175.5 -24t173.5 -24q19 0 57 5t58 5 q81 0 118 -50.5t37 -134.5q0 -23 -5 -68t-5 -68q0 -10 1 -18.5t3 -17t4 -13.5t6.5 -16t6.5 -17q16 -40 25 -118.5t9 -136.5z" />
-<glyph unicode="&#xf095;" horiz-adv-x="1408" d="M1408 296q0 -27 -10 -70.5t-21 -68.5q-21 -50 -122 -106q-94 -51 -186 -51q-27 0 -52.5 3.5t-57.5 12.5t-47.5 14.5t-55.5 20.5t-49 18q-98 35 -175 83q-128 79 -264.5 215.5t-215.5 264.5q-48 77 -83 175q-3 9 -18 49t-20.5 55.5t-14.5 47.5t-12.5 57.5t-3.5 52.5 q0 92 51 186q56 101 106 122q25 11 68.5 21t70.5 10q14 0 21 -3q18 -6 53 -76q11 -19 30 -54t35 -63.5t31 -53.5q3 -4 17.5 -25t21.5 -35.5t7 -28.5q0 -20 -28.5 -50t-62 -55t-62 -53t-28.5 -46q0 -9 5 -22.5t8.5 -20.5t14 -24t11.5 -19q76 -137 174 -235t235 -174 q2 -1 19 -11.5t24 -14t20.5 -8.5t22.5 -5q18 0 46 28.5t53 62t55 62t50 28.5q14 0 28.5 -7t35.5 -21.5t25 -17.5q25 -15 53.5 -31t63.5 -35t54 -30q70 -35 76 -53q3 -7 3 -21z" />
-<glyph unicode="&#xf096;" horiz-adv-x="1408" d="M1120 1280h-832q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v832q0 66 -47 113t-113 47zM1408 1120v-832q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h832 q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf097;" horiz-adv-x="1280" d="M1152 1280h-1024v-1242l423 406l89 85l89 -85l423 -406v1242zM1164 1408q23 0 44 -9q33 -13 52.5 -41t19.5 -62v-1289q0 -34 -19.5 -62t-52.5 -41q-19 -8 -44 -8q-48 0 -83 32l-441 424l-441 -424q-36 -33 -83 -33q-23 0 -44 9q-33 13 -52.5 41t-19.5 62v1289 q0 34 19.5 62t52.5 41q21 9 44 9h1048z" />
-<glyph unicode="&#xf098;" d="M1280 343q0 11 -2 16q-3 8 -38.5 29.5t-88.5 49.5l-53 29q-5 3 -19 13t-25 15t-21 5q-18 0 -47 -32.5t-57 -65.5t-44 -33q-7 0 -16.5 3.5t-15.5 6.5t-17 9.5t-14 8.5q-99 55 -170.5 126.5t-126.5 170.5q-2 3 -8.5 14t-9.5 17t-6.5 15.5t-3.5 16.5q0 13 20.5 33.5t45 38.5 t45 39.5t20.5 36.5q0 10 -5 21t-15 25t-13 19q-3 6 -15 28.5t-25 45.5t-26.5 47.5t-25 40.5t-16.5 18t-16 2q-48 0 -101 -22q-46 -21 -80 -94.5t-34 -130.5q0 -16 2.5 -34t5 -30.5t9 -33t10 -29.5t12.5 -33t11 -30q60 -164 216.5 -320.5t320.5 -216.5q6 -2 30 -11t33 -12.5 t29.5 -10t33 -9t30.5 -5t34 -2.5q57 0 130.5 34t94.5 80q22 53 22 101zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf099;" horiz-adv-x="1664" d="M1620 1128q-67 -98 -162 -167q1 -14 1 -42q0 -130 -38 -259.5t-115.5 -248.5t-184.5 -210.5t-258 -146t-323 -54.5q-271 0 -496 145q35 -4 78 -4q225 0 401 138q-105 2 -188 64.5t-114 159.5q33 -5 61 -5q43 0 85 11q-112 23 -185.5 111.5t-73.5 205.5v4q68 -38 146 -41 q-66 44 -105 115t-39 154q0 88 44 163q121 -149 294.5 -238.5t371.5 -99.5q-8 38 -8 74q0 134 94.5 228.5t228.5 94.5q140 0 236 -102q109 21 205 78q-37 -115 -142 -178q93 10 186 50z" />
-<glyph unicode="&#xf09a;" horiz-adv-x="768" d="M511 980h257l-30 -284h-227v-824h-341v824h-170v284h170v171q0 182 86 275.5t283 93.5h227v-284h-142q-39 0 -62.5 -6.5t-34 -23.5t-13.5 -34.5t-3 -49.5v-142z" />
-<glyph unicode="&#xf09b;" d="M1536 640q0 -251 -146.5 -451.5t-378.5 -277.5q-27 -5 -39.5 7t-12.5 30v211q0 97 -52 142q57 6 102.5 18t94 39t81 66.5t53 105t20.5 150.5q0 121 -79 206q37 91 -8 204q-28 9 -81 -11t-92 -44l-38 -24q-93 26 -192 26t-192 -26q-16 11 -42.5 27t-83.5 38.5t-86 13.5 q-44 -113 -7 -204q-79 -85 -79 -206q0 -85 20.5 -150t52.5 -105t80.5 -67t94 -39t102.5 -18q-40 -36 -49 -103q-21 -10 -45 -15t-57 -5t-65.5 21.5t-55.5 62.5q-19 32 -48.5 52t-49.5 24l-20 3q-21 0 -29 -4.5t-5 -11.5t9 -14t13 -12l7 -5q22 -10 43.5 -38t31.5 -51l10 -23 q13 -38 44 -61.5t67 -30t69.5 -7t55.5 3.5l23 4q0 -38 0.5 -89t0.5 -54q0 -18 -13 -30t-40 -7q-232 77 -378.5 277.5t-146.5 451.5q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf09c;" horiz-adv-x="1664" d="M1664 960v-256q0 -26 -19 -45t-45 -19h-64q-26 0 -45 19t-19 45v256q0 106 -75 181t-181 75t-181 -75t-75 -181v-192h96q40 0 68 -28t28 -68v-576q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v576q0 40 28 68t68 28h672v192q0 185 131.5 316.5t316.5 131.5 t316.5 -131.5t131.5 -316.5z" />
-<glyph unicode="&#xf09d;" horiz-adv-x="1920" d="M1760 1408q66 0 113 -47t47 -113v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113v1216q0 66 47 113t113 47h1600zM160 1280q-13 0 -22.5 -9.5t-9.5 -22.5v-224h1664v224q0 13 -9.5 22.5t-22.5 9.5h-1600zM1760 0q13 0 22.5 9.5t9.5 22.5v608h-1664v-608 q0 -13 9.5 -22.5t22.5 -9.5h1600zM256 128v128h256v-128h-256zM640 128v128h384v-128h-384z" />
-<glyph unicode="&#xf09e;" horiz-adv-x="1408" d="M384 192q0 -80 -56 -136t-136 -56t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM896 69q2 -28 -17 -48q-18 -21 -47 -21h-135q-25 0 -43 16.5t-20 41.5q-22 229 -184.5 391.5t-391.5 184.5q-25 2 -41.5 20t-16.5 43v135q0 29 21 47q17 17 43 17h5q160 -13 306 -80.5 t259 -181.5q114 -113 181.5 -259t80.5 -306zM1408 67q2 -27 -18 -47q-18 -20 -46 -20h-143q-26 0 -44.5 17.5t-19.5 42.5q-12 215 -101 408.5t-231.5 336t-336 231.5t-408.5 102q-25 1 -42.5 19.5t-17.5 43.5v143q0 28 20 46q18 18 44 18h3q262 -13 501.5 -120t425.5 -294 q187 -186 294 -425.5t120 -501.5z" />
-<glyph unicode="&#xf0a0;" d="M1040 320q0 -33 -23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5t23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5zM1296 320q0 -33 -23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5t23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5zM1408 160v320q0 13 -9.5 22.5t-22.5 9.5 h-1216q-13 0 -22.5 -9.5t-9.5 -22.5v-320q0 -13 9.5 -22.5t22.5 -9.5h1216q13 0 22.5 9.5t9.5 22.5zM178 640h1180l-157 482q-4 13 -16 21.5t-26 8.5h-782q-14 0 -26 -8.5t-16 -21.5zM1536 480v-320q0 -66 -47 -113t-113 -47h-1216q-66 0 -113 47t-47 113v320q0 25 16 75 l197 606q17 53 63 86t101 33h782q55 0 101 -33t63 -86l197 -606q16 -50 16 -75z" />
-<glyph unicode="&#xf0a1;" horiz-adv-x="1792" d="M1664 896q53 0 90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5v-384q0 -52 -38 -90t-90 -38q-417 347 -812 380q-58 -19 -91 -66t-31 -100.5t40 -92.5q-20 -33 -23 -65.5t6 -58t33.5 -55t48 -50t61.5 -50.5q-29 -58 -111.5 -83t-168.5 -11.5t-132 55.5q-7 23 -29.5 87.5 t-32 94.5t-23 89t-15 101t3.5 98.5t22 110.5h-122q-66 0 -113 47t-47 113v192q0 66 47 113t113 47h480q435 0 896 384q52 0 90 -38t38 -90v-384zM1536 292v954q-394 -302 -768 -343v-270q377 -42 768 -341z" />
-<glyph unicode="&#xf0a2;" horiz-adv-x="1664" d="M848 -160q0 16 -16 16q-59 0 -101.5 42.5t-42.5 101.5q0 16 -16 16t-16 -16q0 -73 51.5 -124.5t124.5 -51.5q16 0 16 16zM183 128h1298q-164 181 -246.5 411.5t-82.5 484.5q0 256 -320 256t-320 -256q0 -254 -82.5 -484.5t-246.5 -411.5zM1664 128q0 -52 -38 -90t-90 -38 h-448q0 -106 -75 -181t-181 -75t-181 75t-75 181h-448q-52 0 -90 38t-38 90q190 161 287 397.5t97 498.5q0 165 96 262t264 117q-8 18 -8 37q0 40 28 68t68 28t68 -28t28 -68q0 -19 -8 -37q168 -20 264 -117t96 -262q0 -262 97 -498.5t287 -397.5z" />
-<glyph unicode="&#xf0a3;" d="M1376 640l138 -135q30 -28 20 -70q-12 -41 -52 -51l-188 -48l53 -186q12 -41 -19 -70q-29 -31 -70 -19l-186 53l-48 -188q-10 -40 -51 -52q-12 -2 -19 -2q-31 0 -51 22l-135 138l-135 -138q-28 -30 -70 -20q-41 11 -51 52l-48 188l-186 -53q-41 -12 -70 19q-31 29 -19 70 l53 186l-188 48q-40 10 -52 51q-10 42 20 70l138 135l-138 135q-30 28 -20 70q12 41 52 51l188 48l-53 186q-12 41 19 70q29 31 70 19l186 -53l48 188q10 41 51 51q41 12 70 -19l135 -139l135 139q29 30 70 19q41 -10 51 -51l48 -188l186 53q41 12 70 -19q31 -29 19 -70 l-53 -186l188 -48q40 -10 52 -51q10 -42 -20 -70z" />
-<glyph unicode="&#xf0a4;" horiz-adv-x="1792" d="M256 192q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1664 768q0 51 -39 89.5t-89 38.5h-576q0 20 15 48.5t33 55t33 68t15 84.5q0 67 -44.5 97.5t-115.5 30.5q-24 0 -90 -139q-24 -44 -37 -65q-40 -64 -112 -145q-71 -81 -101 -106 q-69 -57 -140 -57h-32v-640h32q72 0 167 -32t193.5 -64t179.5 -32q189 0 189 167q0 26 -5 56q30 16 47.5 52.5t17.5 73.5t-18 69q53 50 53 119q0 25 -10 55.5t-25 47.5h331q52 0 90 38t38 90zM1792 769q0 -105 -75.5 -181t-180.5 -76h-169q-4 -62 -37 -119q3 -21 3 -43 q0 -101 -60 -178q1 -139 -85 -219.5t-227 -80.5q-133 0 -322 69q-164 59 -223 59h-288q-53 0 -90.5 37.5t-37.5 90.5v640q0 53 37.5 90.5t90.5 37.5h288q10 0 21.5 4.5t23.5 14t22.5 18t24 22.5t20.5 21.5t19 21.5t14 17q65 74 100 129q13 21 33 62t37 72t40.5 63t55 49.5 t69.5 17.5q125 0 206.5 -67t81.5 -189q0 -68 -22 -128h374q104 0 180 -76t76 -179z" />
-<glyph unicode="&#xf0a5;" horiz-adv-x="1792" d="M1376 128h32v640h-32q-35 0 -67.5 12t-62.5 37t-50 46t-49 54q-2 3 -3.5 4.5t-4 4.5t-4.5 5q-72 81 -112 145q-14 22 -38 68q-1 3 -10.5 22.5t-18.5 36t-20 35.5t-21.5 30.5t-18.5 11.5q-71 0 -115.5 -30.5t-44.5 -97.5q0 -43 15 -84.5t33 -68t33 -55t15 -48.5h-576 q-50 0 -89 -38.5t-39 -89.5q0 -52 38 -90t90 -38h331q-15 -17 -25 -47.5t-10 -55.5q0 -69 53 -119q-18 -32 -18 -69t17.5 -73.5t47.5 -52.5q-4 -24 -4 -56q0 -85 48.5 -126t135.5 -41q84 0 183 32t194 64t167 32zM1664 192q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45 t45 -19t45 19t19 45zM1792 768v-640q0 -53 -37.5 -90.5t-90.5 -37.5h-288q-59 0 -223 -59q-190 -69 -317 -69q-142 0 -230 77.5t-87 217.5l1 5q-61 76 -61 178q0 22 3 43q-33 57 -37 119h-169q-105 0 -180.5 76t-75.5 181q0 103 76 179t180 76h374q-22 60 -22 128 q0 122 81.5 189t206.5 67q38 0 69.5 -17.5t55 -49.5t40.5 -63t37 -72t33 -62q35 -55 100 -129q2 -3 14 -17t19 -21.5t20.5 -21.5t24 -22.5t22.5 -18t23.5 -14t21.5 -4.5h288q53 0 90.5 -37.5t37.5 -90.5z" />
-<glyph unicode="&#xf0a6;" d="M1280 -64q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1408 700q0 189 -167 189q-26 0 -56 -5q-16 30 -52.5 47.5t-73.5 17.5t-69 -18q-50 53 -119 53q-25 0 -55.5 -10t-47.5 -25v331q0 52 -38 90t-90 38q-51 0 -89.5 -39t-38.5 -89v-576 q-20 0 -48.5 15t-55 33t-68 33t-84.5 15q-67 0 -97.5 -44.5t-30.5 -115.5q0 -24 139 -90q44 -24 65 -37q64 -40 145 -112q81 -71 106 -101q57 -69 57 -140v-32h640v32q0 72 32 167t64 193.5t32 179.5zM1536 705q0 -133 -69 -322q-59 -164 -59 -223v-288q0 -53 -37.5 -90.5 t-90.5 -37.5h-640q-53 0 -90.5 37.5t-37.5 90.5v288q0 10 -4.5 21.5t-14 23.5t-18 22.5t-22.5 24t-21.5 20.5t-21.5 19t-17 14q-74 65 -129 100q-21 13 -62 33t-72 37t-63 40.5t-49.5 55t-17.5 69.5q0 125 67 206.5t189 81.5q68 0 128 -22v374q0 104 76 180t179 76 q105 0 181 -75.5t76 -180.5v-169q62 -4 119 -37q21 3 43 3q101 0 178 -60q139 1 219.5 -85t80.5 -227z" />
-<glyph unicode="&#xf0a7;" d="M1408 576q0 84 -32 183t-64 194t-32 167v32h-640v-32q0 -35 -12 -67.5t-37 -62.5t-46 -50t-54 -49q-9 -8 -14 -12q-81 -72 -145 -112q-22 -14 -68 -38q-3 -1 -22.5 -10.5t-36 -18.5t-35.5 -20t-30.5 -21.5t-11.5 -18.5q0 -71 30.5 -115.5t97.5 -44.5q43 0 84.5 15t68 33 t55 33t48.5 15v-576q0 -50 38.5 -89t89.5 -39q52 0 90 38t38 90v331q46 -35 103 -35q69 0 119 53q32 -18 69 -18t73.5 17.5t52.5 47.5q24 -4 56 -4q85 0 126 48.5t41 135.5zM1280 1344q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1536 580 q0 -142 -77.5 -230t-217.5 -87l-5 1q-76 -61 -178 -61q-22 0 -43 3q-54 -30 -119 -37v-169q0 -105 -76 -180.5t-181 -75.5q-103 0 -179 76t-76 180v374q-54 -22 -128 -22q-121 0 -188.5 81.5t-67.5 206.5q0 38 17.5 69.5t49.5 55t63 40.5t72 37t62 33q55 35 129 100 q3 2 17 14t21.5 19t21.5 20.5t22.5 24t18 22.5t14 23.5t4.5 21.5v288q0 53 37.5 90.5t90.5 37.5h640q53 0 90.5 -37.5t37.5 -90.5v-288q0 -59 59 -223q69 -190 69 -317z" />
-<glyph unicode="&#xf0a8;" d="M1280 576v128q0 26 -19 45t-45 19h-502l189 189q19 19 19 45t-19 45l-91 91q-18 18 -45 18t-45 -18l-362 -362l-91 -91q-18 -18 -18 -45t18 -45l91 -91l362 -362q18 -18 45 -18t45 18l91 91q18 18 18 45t-18 45l-189 189h502q26 0 45 19t19 45zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf0a9;" d="M1285 640q0 27 -18 45l-91 91l-362 362q-18 18 -45 18t-45 -18l-91 -91q-18 -18 -18 -45t18 -45l189 -189h-502q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h502l-189 -189q-19 -19 -19 -45t19 -45l91 -91q18 -18 45 -18t45 18l362 362l91 91q18 18 18 45zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf0aa;" d="M1284 641q0 27 -18 45l-362 362l-91 91q-18 18 -45 18t-45 -18l-91 -91l-362 -362q-18 -18 -18 -45t18 -45l91 -91q18 -18 45 -18t45 18l189 189v-502q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v502l189 -189q19 -19 45 -19t45 19l91 91q18 18 18 45zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf0ab;" d="M1284 639q0 27 -18 45l-91 91q-18 18 -45 18t-45 -18l-189 -189v502q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-502l-189 189q-19 19 -45 19t-45 -19l-91 -91q-18 -18 -18 -45t18 -45l362 -362l91 -91q18 -18 45 -18t45 18l91 91l362 362q18 18 18 45zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf0ac;" d="M768 1408q209 0 385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103zM1042 887q-2 -1 -9.5 -9.5t-13.5 -9.5q2 0 4.5 5t5 11t3.5 7q6 7 22 15q14 6 52 12q34 8 51 -11 q-2 2 9.5 13t14.5 12q3 2 15 4.5t15 7.5l2 22q-12 -1 -17.5 7t-6.5 21q0 -2 -6 -8q0 7 -4.5 8t-11.5 -1t-9 -1q-10 3 -15 7.5t-8 16.5t-4 15q-2 5 -9.5 10.5t-9.5 10.5q-1 2 -2.5 5.5t-3 6.5t-4 5.5t-5.5 2.5t-7 -5t-7.5 -10t-4.5 -5q-3 2 -6 1.5t-4.5 -1t-4.5 -3t-5 -3.5 q-3 -2 -8.5 -3t-8.5 -2q15 5 -1 11q-10 4 -16 3q9 4 7.5 12t-8.5 14h5q-1 4 -8.5 8.5t-17.5 8.5t-13 6q-8 5 -34 9.5t-33 0.5q-5 -6 -4.5 -10.5t4 -14t3.5 -12.5q1 -6 -5.5 -13t-6.5 -12q0 -7 14 -15.5t10 -21.5q-3 -8 -16 -16t-16 -12q-5 -8 -1.5 -18.5t10.5 -16.5 q2 -2 1.5 -4t-3.5 -4.5t-5.5 -4t-6.5 -3.5l-3 -2q-11 -5 -20.5 6t-13.5 26q-7 25 -16 30q-23 8 -29 -1q-5 13 -41 26q-25 9 -58 4q6 1 0 15q-7 15 -19 12q3 6 4 17.5t1 13.5q3 13 12 23q1 1 7 8.5t9.5 13.5t0.5 6q35 -4 50 11q5 5 11.5 17t10.5 17q9 6 14 5.5t14.5 -5.5 t14.5 -5q14 -1 15.5 11t-7.5 20q12 -1 3 17q-5 7 -8 9q-12 4 -27 -5q-8 -4 2 -8q-1 1 -9.5 -10.5t-16.5 -17.5t-16 5q-1 1 -5.5 13.5t-9.5 13.5q-8 0 -16 -15q3 8 -11 15t-24 8q19 12 -8 27q-7 4 -20.5 5t-19.5 -4q-5 -7 -5.5 -11.5t5 -8t10.5 -5.5t11.5 -4t8.5 -3 q14 -10 8 -14q-2 -1 -8.5 -3.5t-11.5 -4.5t-6 -4q-3 -4 0 -14t-2 -14q-5 5 -9 17.5t-7 16.5q7 -9 -25 -6l-10 1q-4 0 -16 -2t-20.5 -1t-13.5 8q-4 8 0 20q1 4 4 2q-4 3 -11 9.5t-10 8.5q-46 -15 -94 -41q6 -1 12 1q5 2 13 6.5t10 5.5q34 14 42 7l5 5q14 -16 20 -25 q-7 4 -30 1q-20 -6 -22 -12q7 -12 5 -18q-4 3 -11.5 10t-14.5 11t-15 5q-16 0 -22 -1q-146 -80 -235 -222q7 -7 12 -8q4 -1 5 -9t2.5 -11t11.5 3q9 -8 3 -19q1 1 44 -27q19 -17 21 -21q3 -11 -10 -18q-1 2 -9 9t-9 4q-3 -5 0.5 -18.5t10.5 -12.5q-7 0 -9.5 -16t-2.5 -35.5 t-1 -23.5l2 -1q-3 -12 5.5 -34.5t21.5 -19.5q-13 -3 20 -43q6 -8 8 -9q3 -2 12 -7.5t15 -10t10 -10.5q4 -5 10 -22.5t14 -23.5q-2 -6 9.5 -20t10.5 -23q-1 0 -2.5 -1t-2.5 -1q3 -7 15.5 -14t15.5 -13q1 -3 2 -10t3 -11t8 -2q2 20 -24 62q-15 25 -17 29q-3 5 -5.5 15.5 t-4.5 14.5q2 0 6 -1.5t8.5 -3.5t7.5 -4t2 -3q-3 -7 2 -17.5t12 -18.5t17 -19t12 -13q6 -6 14 -19.5t0 -13.5q9 0 20 -10t17 -20q5 -8 8 -26t5 -24q2 -7 8.5 -13.5t12.5 -9.5l16 -8t13 -7q5 -2 18.5 -10.5t21.5 -11.5q10 -4 16 -4t14.5 2.5t13.5 3.5q15 2 29 -15t21 -21 q36 -19 55 -11q-2 -1 0.5 -7.5t8 -15.5t9 -14.5t5.5 -8.5q5 -6 18 -15t18 -15q6 4 7 9q-3 -8 7 -20t18 -10q14 3 14 32q-31 -15 -49 18q0 1 -2.5 5.5t-4 8.5t-2.5 8.5t0 7.5t5 3q9 0 10 3.5t-2 12.5t-4 13q-1 8 -11 20t-12 15q-5 -9 -16 -8t-16 9q0 -1 -1.5 -5.5t-1.5 -6.5 q-13 0 -15 1q1 3 2.5 17.5t3.5 22.5q1 4 5.5 12t7.5 14.5t4 12.5t-4.5 9.5t-17.5 2.5q-19 -1 -26 -20q-1 -3 -3 -10.5t-5 -11.5t-9 -7q-7 -3 -24 -2t-24 5q-13 8 -22.5 29t-9.5 37q0 10 2.5 26.5t3 25t-5.5 24.5q3 2 9 9.5t10 10.5q2 1 4.5 1.5t4.5 0t4 1.5t3 6q-1 1 -4 3 q-3 3 -4 3q7 -3 28.5 1.5t27.5 -1.5q15 -11 22 2q0 1 -2.5 9.5t-0.5 13.5q5 -27 29 -9q3 -3 15.5 -5t17.5 -5q3 -2 7 -5.5t5.5 -4.5t5 0.5t8.5 6.5q10 -14 12 -24q11 -40 19 -44q7 -3 11 -2t4.5 9.5t0 14t-1.5 12.5l-1 8v18l-1 8q-15 3 -18.5 12t1.5 18.5t15 18.5q1 1 8 3.5 t15.5 6.5t12.5 8q21 19 15 35q7 0 11 9q-1 0 -5 3t-7.5 5t-4.5 2q9 5 2 16q5 3 7.5 11t7.5 10q9 -12 21 -2q7 8 1 16q5 7 20.5 10.5t18.5 9.5q7 -2 8 2t1 12t3 12q4 5 15 9t13 5l17 11q3 4 0 4q18 -2 31 11q10 11 -6 20q3 6 -3 9.5t-15 5.5q3 1 11.5 0.5t10.5 1.5 q15 10 -7 16q-17 5 -43 -12zM879 10q206 36 351 189q-3 3 -12.5 4.5t-12.5 3.5q-18 7 -24 8q1 7 -2.5 13t-8 9t-12.5 8t-11 7q-2 2 -7 6t-7 5.5t-7.5 4.5t-8.5 2t-10 -1l-3 -1q-3 -1 -5.5 -2.5t-5.5 -3t-4 -3t0 -2.5q-21 17 -36 22q-5 1 -11 5.5t-10.5 7t-10 1.5t-11.5 -7 q-5 -5 -6 -15t-2 -13q-7 5 0 17.5t2 18.5q-3 6 -10.5 4.5t-12 -4.5t-11.5 -8.5t-9 -6.5t-8.5 -5.5t-8.5 -7.5q-3 -4 -6 -12t-5 -11q-2 4 -11.5 6.5t-9.5 5.5q2 -10 4 -35t5 -38q7 -31 -12 -48q-27 -25 -29 -40q-4 -22 12 -26q0 -7 -8 -20.5t-7 -21.5q0 -6 2 -16z" />
-<glyph unicode="&#xf0ad;" horiz-adv-x="1664" d="M384 64q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1028 484l-682 -682q-37 -37 -90 -37q-52 0 -91 37l-106 108q-38 36 -38 90q0 53 38 91l681 681q39 -98 114.5 -173.5t173.5 -114.5zM1662 919q0 -39 -23 -106q-47 -134 -164.5 -217.5 t-258.5 -83.5q-185 0 -316.5 131.5t-131.5 316.5t131.5 316.5t316.5 131.5q58 0 121.5 -16.5t107.5 -46.5q16 -11 16 -28t-16 -28l-293 -169v-224l193 -107q5 3 79 48.5t135.5 81t70.5 35.5q15 0 23.5 -10t8.5 -25z" />
-<glyph unicode="&#xf0ae;" horiz-adv-x="1792" d="M1024 128h640v128h-640v-128zM640 640h1024v128h-1024v-128zM1280 1152h384v128h-384v-128zM1792 320v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v256q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 832v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19 t-19 45v256q0 26 19 45t45 19h1664q26 0 45 -19t19 -45zM1792 1344v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45v256q0 26 19 45t45 19h1664q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0b0;" horiz-adv-x="1408" d="M1403 1241q17 -41 -14 -70l-493 -493v-742q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-256 256q-19 19 -19 45v486l-493 493q-31 29 -14 70q17 39 59 39h1280q42 0 59 -39z" />
-<glyph unicode="&#xf0b1;" horiz-adv-x="1792" d="M640 1280h512v128h-512v-128zM1792 640v-480q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113v480h672v-160q0 -26 19 -45t45 -19h320q26 0 45 19t19 45v160h672zM1024 640v-128h-256v128h256zM1792 1120v-384h-1792v384q0 66 47 113t113 47h352v160q0 40 28 68 t68 28h576q40 0 68 -28t28 -68v-160h352q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf0b2;" d="M1283 995l-355 -355l355 -355l144 144q29 31 70 14q39 -17 39 -59v-448q0 -26 -19 -45t-45 -19h-448q-42 0 -59 40q-17 39 14 69l144 144l-355 355l-355 -355l144 -144q31 -30 14 -69q-17 -40 -59 -40h-448q-26 0 -45 19t-19 45v448q0 42 40 59q39 17 69 -14l144 -144 l355 355l-355 355l-144 -144q-19 -19 -45 -19q-12 0 -24 5q-40 17 -40 59v448q0 26 19 45t45 19h448q42 0 59 -40q17 -39 -14 -69l-144 -144l355 -355l355 355l-144 144q-31 30 -14 69q17 40 59 40h448q26 0 45 -19t19 -45v-448q0 -42 -39 -59q-13 -5 -25 -5q-26 0 -45 19z " />
-<glyph unicode="&#xf0c0;" horiz-adv-x="1920" d="M593 640q-162 -5 -265 -128h-134q-82 0 -138 40.5t-56 118.5q0 353 124 353q6 0 43.5 -21t97.5 -42.5t119 -21.5q67 0 133 23q-5 -37 -5 -66q0 -139 81 -256zM1664 3q0 -120 -73 -189.5t-194 -69.5h-874q-121 0 -194 69.5t-73 189.5q0 53 3.5 103.5t14 109t26.5 108.5 t43 97.5t62 81t85.5 53.5t111.5 20q10 0 43 -21.5t73 -48t107 -48t135 -21.5t135 21.5t107 48t73 48t43 21.5q61 0 111.5 -20t85.5 -53.5t62 -81t43 -97.5t26.5 -108.5t14 -109t3.5 -103.5zM640 1280q0 -106 -75 -181t-181 -75t-181 75t-75 181t75 181t181 75t181 -75 t75 -181zM1344 896q0 -159 -112.5 -271.5t-271.5 -112.5t-271.5 112.5t-112.5 271.5t112.5 271.5t271.5 112.5t271.5 -112.5t112.5 -271.5zM1920 671q0 -78 -56 -118.5t-138 -40.5h-134q-103 123 -265 128q81 117 81 256q0 29 -5 66q66 -23 133 -23q59 0 119 21.5t97.5 42.5 t43.5 21q124 0 124 -353zM1792 1280q0 -106 -75 -181t-181 -75t-181 75t-75 181t75 181t181 75t181 -75t75 -181z" />
-<glyph unicode="&#xf0c1;" horiz-adv-x="1664" d="M1456 320q0 40 -28 68l-208 208q-28 28 -68 28q-42 0 -72 -32q3 -3 19 -18.5t21.5 -21.5t15 -19t13 -25.5t3.5 -27.5q0 -40 -28 -68t-68 -28q-15 0 -27.5 3.5t-25.5 13t-19 15t-21.5 21.5t-18.5 19q-33 -31 -33 -73q0 -40 28 -68l206 -207q27 -27 68 -27q40 0 68 26 l147 146q28 28 28 67zM753 1025q0 40 -28 68l-206 207q-28 28 -68 28q-39 0 -68 -27l-147 -146q-28 -28 -28 -67q0 -40 28 -68l208 -208q27 -27 68 -27q42 0 72 31q-3 3 -19 18.5t-21.5 21.5t-15 19t-13 25.5t-3.5 27.5q0 40 28 68t68 28q15 0 27.5 -3.5t25.5 -13t19 -15 t21.5 -21.5t18.5 -19q33 31 33 73zM1648 320q0 -120 -85 -203l-147 -146q-83 -83 -203 -83q-121 0 -204 85l-206 207q-83 83 -83 203q0 123 88 209l-88 88q-86 -88 -208 -88q-120 0 -204 84l-208 208q-84 84 -84 204t85 203l147 146q83 83 203 83q121 0 204 -85l206 -207 q83 -83 83 -203q0 -123 -88 -209l88 -88q86 88 208 88q120 0 204 -84l208 -208q84 -84 84 -204z" />
-<glyph unicode="&#xf0c2;" horiz-adv-x="1920" d="M1920 384q0 -159 -112.5 -271.5t-271.5 -112.5h-1088q-185 0 -316.5 131.5t-131.5 316.5q0 132 71 241.5t187 163.5q-2 28 -2 43q0 212 150 362t362 150q158 0 286.5 -88t187.5 -230q70 62 166 62q106 0 181 -75t75 -181q0 -75 -41 -138q129 -30 213 -134.5t84 -239.5z " />
-<glyph unicode="&#xf0c3;" horiz-adv-x="1664" d="M1527 88q56 -89 21.5 -152.5t-140.5 -63.5h-1152q-106 0 -140.5 63.5t21.5 152.5l503 793v399h-64q-26 0 -45 19t-19 45t19 45t45 19h512q26 0 45 -19t19 -45t-19 -45t-45 -19h-64v-399zM748 813l-272 -429h712l-272 429l-20 31v37v399h-128v-399v-37z" />
-<glyph unicode="&#xf0c4;" horiz-adv-x="1792" d="M960 640q26 0 45 -19t19 -45t-19 -45t-45 -19t-45 19t-19 45t19 45t45 19zM1260 576l507 -398q28 -20 25 -56q-5 -35 -35 -51l-128 -64q-13 -7 -29 -7q-17 0 -31 8l-690 387l-110 -66q-8 -4 -12 -5q14 -49 10 -97q-7 -77 -56 -147.5t-132 -123.5q-132 -84 -277 -84 q-136 0 -222 78q-90 84 -79 207q7 76 56 147t131 124q132 84 278 84q83 0 151 -31q9 13 22 22l122 73l-122 73q-13 9 -22 22q-68 -31 -151 -31q-146 0 -278 84q-82 53 -131 124t-56 147q-5 59 15.5 113t63.5 93q85 79 222 79q145 0 277 -84q83 -52 132 -123t56 -148 q4 -48 -10 -97q4 -1 12 -5l110 -66l690 387q14 8 31 8q16 0 29 -7l128 -64q30 -16 35 -51q3 -36 -25 -56zM579 836q46 42 21 108t-106 117q-92 59 -192 59q-74 0 -113 -36q-46 -42 -21 -108t106 -117q92 -59 192 -59q74 0 113 36zM494 91q81 51 106 117t-21 108 q-39 36 -113 36q-100 0 -192 -59q-81 -51 -106 -117t21 -108q39 -36 113 -36q100 0 192 59zM672 704l96 -58v11q0 36 33 56l14 8l-79 47l-26 -26q-3 -3 -10 -11t-12 -12q-2 -2 -4 -3.5t-3 -2.5zM896 480l96 -32l736 576l-128 64l-768 -431v-113l-160 -96l9 -8q2 -2 7 -6 q4 -4 11 -12t11 -12l26 -26zM1600 64l128 64l-520 408l-177 -138q-2 -3 -13 -7z" />
-<glyph unicode="&#xf0c5;" horiz-adv-x="1792" d="M1696 1152q40 0 68 -28t28 -68v-1216q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v288h-544q-40 0 -68 28t-28 68v672q0 40 20 88t48 76l408 408q28 28 76 48t88 20h416q40 0 68 -28t28 -68v-328q68 40 128 40h416zM1152 939l-299 -299h299v299zM512 1323l-299 -299 h299v299zM708 676l316 316v416h-384v-416q0 -40 -28 -68t-68 -28h-416v-640h512v256q0 40 20 88t48 76zM1664 -128v1152h-384v-416q0 -40 -28 -68t-68 -28h-416v-640h896z" />
-<glyph unicode="&#xf0c6;" horiz-adv-x="1408" d="M1404 151q0 -117 -79 -196t-196 -79q-135 0 -235 100l-777 776q-113 115 -113 271q0 159 110 270t269 111q158 0 273 -113l605 -606q10 -10 10 -22q0 -16 -30.5 -46.5t-46.5 -30.5q-13 0 -23 10l-606 607q-79 77 -181 77q-106 0 -179 -75t-73 -181q0 -105 76 -181 l776 -777q63 -63 145 -63q64 0 106 42t42 106q0 82 -63 145l-581 581q-26 24 -60 24q-29 0 -48 -19t-19 -48q0 -32 25 -59l410 -410q10 -10 10 -22q0 -16 -31 -47t-47 -31q-12 0 -22 10l-410 410q-63 61 -63 149q0 82 57 139t139 57q88 0 149 -63l581 -581q100 -98 100 -235 z" />
-<glyph unicode="&#xf0c7;" d="M384 0h768v384h-768v-384zM1280 0h128v896q0 14 -10 38.5t-20 34.5l-281 281q-10 10 -34 20t-39 10v-416q0 -40 -28 -68t-68 -28h-576q-40 0 -68 28t-28 68v416h-128v-1280h128v416q0 40 28 68t68 28h832q40 0 68 -28t28 -68v-416zM896 928v320q0 13 -9.5 22.5t-22.5 9.5 h-192q-13 0 -22.5 -9.5t-9.5 -22.5v-320q0 -13 9.5 -22.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 22.5zM1536 896v-928q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68v1344q0 40 28 68t68 28h928q40 0 88 -20t76 -48l280 -280q28 -28 48 -76t20 -88z" />
-<glyph unicode="&#xf0c8;" d="M1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf0c9;" d="M1536 192v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45zM1536 704v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45zM1536 1216v-128q0 -26 -19 -45 t-45 -19h-1408q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0ca;" horiz-adv-x="1792" d="M384 128q0 -80 -56 -136t-136 -56t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM384 640q0 -80 -56 -136t-136 -56t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM1792 224v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5 t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5zM384 1152q0 -80 -56 -136t-136 -56t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM1792 736v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5z M1792 1248v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5z" />
-<glyph unicode="&#xf0cb;" horiz-adv-x="1792" d="M381 -84q0 -80 -54.5 -126t-135.5 -46q-106 0 -172 66l57 88q49 -45 106 -45q29 0 50.5 14.5t21.5 42.5q0 64 -105 56l-26 56q8 10 32.5 43.5t42.5 54t37 38.5v1q-16 0 -48.5 -1t-48.5 -1v-53h-106v152h333v-88l-95 -115q51 -12 81 -49t30 -88zM383 543v-159h-362 q-6 36 -6 54q0 51 23.5 93t56.5 68t66 47.5t56.5 43.5t23.5 45q0 25 -14.5 38.5t-39.5 13.5q-46 0 -81 -58l-85 59q24 51 71.5 79.5t105.5 28.5q73 0 123 -41.5t50 -112.5q0 -50 -34 -91.5t-75 -64.5t-75.5 -50.5t-35.5 -52.5h127v60h105zM1792 224v-192q0 -13 -9.5 -22.5 t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5v192q0 14 9 23t23 9h1216q13 0 22.5 -9.5t9.5 -22.5zM384 1123v-99h-335v99h107q0 41 0.5 122t0.5 121v12h-2q-8 -17 -50 -54l-71 76l136 127h106v-404h108zM1792 736v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5 t-9.5 22.5v192q0 14 9 23t23 9h1216q13 0 22.5 -9.5t9.5 -22.5zM1792 1248v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5z" />
-<glyph unicode="&#xf0cc;" horiz-adv-x="1792" d="M1760 640q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-1728q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h1728zM483 704q-28 35 -51 80q-48 97 -48 188q0 181 134 309q133 127 393 127q50 0 167 -19q66 -12 177 -48q10 -38 21 -118q14 -123 14 -183q0 -18 -5 -45l-12 -3l-84 6 l-14 2q-50 149 -103 205q-88 91 -210 91q-114 0 -182 -59q-67 -58 -67 -146q0 -73 66 -140t279 -129q69 -20 173 -66q58 -28 95 -52h-743zM990 448h411q7 -39 7 -92q0 -111 -41 -212q-23 -55 -71 -104q-37 -35 -109 -81q-80 -48 -153 -66q-80 -21 -203 -21q-114 0 -195 23 l-140 40q-57 16 -72 28q-8 8 -8 22v13q0 108 -2 156q-1 30 0 68l2 37v44l102 2q15 -34 30 -71t22.5 -56t12.5 -27q35 -57 80 -94q43 -36 105 -57q59 -22 132 -22q64 0 139 27q77 26 122 86q47 61 47 129q0 84 -81 157q-34 29 -137 71z" />
-<glyph unicode="&#xf0cd;" d="M48 1313q-37 2 -45 4l-3 88q13 1 40 1q60 0 112 -4q132 -7 166 -7q86 0 168 3q116 4 146 5q56 0 86 2l-1 -14l2 -64v-9q-60 -9 -124 -9q-60 0 -79 -25q-13 -14 -13 -132q0 -13 0.5 -32.5t0.5 -25.5l1 -229l14 -280q6 -124 51 -202q35 -59 96 -92q88 -47 177 -47 q104 0 191 28q56 18 99 51q48 36 65 64q36 56 53 114q21 73 21 229q0 79 -3.5 128t-11 122.5t-13.5 159.5l-4 59q-5 67 -24 88q-34 35 -77 34l-100 -2l-14 3l2 86h84l205 -10q76 -3 196 10l18 -2q6 -38 6 -51q0 -7 -4 -31q-45 -12 -84 -13q-73 -11 -79 -17q-15 -15 -15 -41 q0 -7 1.5 -27t1.5 -31q8 -19 22 -396q6 -195 -15 -304q-15 -76 -41 -122q-38 -65 -112 -123q-75 -57 -182 -89q-109 -33 -255 -33q-167 0 -284 46q-119 47 -179 122q-61 76 -83 195q-16 80 -16 237v333q0 188 -17 213q-25 36 -147 39zM1536 -96v64q0 14 -9 23t-23 9h-1472 q-14 0 -23 -9t-9 -23v-64q0 -14 9 -23t23 -9h1472q14 0 23 9t9 23z" />
-<glyph unicode="&#xf0ce;" horiz-adv-x="1664" d="M512 160v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM512 544v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1024 160v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23 v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM512 928v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1024 544v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1536 160v192 q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1024 928v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1536 544v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192 q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1536 928v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23zM1664 1248v-1088q0 -66 -47 -113t-113 -47h-1344q-66 0 -113 47t-47 113v1088q0 66 47 113t113 47h1344q66 0 113 -47t47 -113 z" />
-<glyph unicode="&#xf0d0;" horiz-adv-x="1664" d="M1190 955l293 293l-107 107l-293 -293zM1637 1248q0 -27 -18 -45l-1286 -1286q-18 -18 -45 -18t-45 18l-198 198q-18 18 -18 45t18 45l1286 1286q18 18 45 18t45 -18l198 -198q18 -18 18 -45zM286 1438l98 -30l-98 -30l-30 -98l-30 98l-98 30l98 30l30 98zM636 1276 l196 -60l-196 -60l-60 -196l-60 196l-196 60l196 60l60 196zM1566 798l98 -30l-98 -30l-30 -98l-30 98l-98 30l98 30l30 98zM926 1438l98 -30l-98 -30l-30 -98l-30 98l-98 30l98 30l30 98z" />
-<glyph unicode="&#xf0d1;" horiz-adv-x="1792" d="M640 128q0 52 -38 90t-90 38t-90 -38t-38 -90t38 -90t90 -38t90 38t38 90zM256 640h384v256h-158q-13 0 -22 -9l-195 -195q-9 -9 -9 -22v-30zM1536 128q0 52 -38 90t-90 38t-90 -38t-38 -90t38 -90t90 -38t90 38t38 90zM1792 1216v-1024q0 -15 -4 -26.5t-13.5 -18.5 t-16.5 -11.5t-23.5 -6t-22.5 -2t-25.5 0t-22.5 0.5q0 -106 -75 -181t-181 -75t-181 75t-75 181h-384q0 -106 -75 -181t-181 -75t-181 75t-75 181h-64q-3 0 -22.5 -0.5t-25.5 0t-22.5 2t-23.5 6t-16.5 11.5t-13.5 18.5t-4 26.5q0 26 19 45t45 19v320q0 8 -0.5 35t0 38 t2.5 34.5t6.5 37t14 30.5t22.5 30l198 198q19 19 50.5 32t58.5 13h160v192q0 26 19 45t45 19h1024q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0d2;" d="M1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103q-111 0 -218 32q59 93 78 164q9 34 54 211q20 -39 73 -67.5t114 -28.5q121 0 216 68.5t147 188.5t52 270q0 114 -59.5 214t-172.5 163t-255 63q-105 0 -196 -29t-154.5 -77t-109 -110.5t-67 -129.5t-21.5 -134 q0 -104 40 -183t117 -111q30 -12 38 20q2 7 8 31t8 30q6 23 -11 43q-51 61 -51 151q0 151 104.5 259.5t273.5 108.5q151 0 235.5 -82t84.5 -213q0 -170 -68.5 -289t-175.5 -119q-61 0 -98 43.5t-23 104.5q8 35 26.5 93.5t30 103t11.5 75.5q0 50 -27 83t-77 33 q-62 0 -105 -57t-43 -142q0 -73 25 -122l-99 -418q-17 -70 -13 -177q-206 91 -333 281t-127 423q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf0d3;" d="M1248 1408q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-725q85 122 108 210q9 34 53 209q21 -39 73.5 -67t112.5 -28q181 0 295.5 147.5t114.5 373.5q0 84 -35 162.5t-96.5 139t-152.5 97t-197 36.5q-104 0 -194.5 -28.5t-153 -76.5 t-107.5 -109.5t-66.5 -128t-21.5 -132.5q0 -102 39.5 -180t116.5 -110q13 -5 23.5 0t14.5 19q10 44 15 61q6 23 -11 42q-50 62 -50 150q0 150 103.5 256.5t270.5 106.5q149 0 232.5 -81t83.5 -210q0 -168 -67.5 -286t-173.5 -118q-60 0 -97 43.5t-23 103.5q8 34 26.5 92.5 t29.5 102t11 74.5q0 49 -26.5 81.5t-75.5 32.5q-61 0 -103.5 -56.5t-42.5 -139.5q0 -72 24 -121l-98 -414q-24 -100 -7 -254h-183q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960z" />
-<glyph unicode="&#xf0d4;" d="M678 -57q0 -38 -10 -71h-380q-95 0 -171.5 56.5t-103.5 147.5q24 45 69 77.5t100 49.5t107 24t107 7q32 0 49 -2q6 -4 30.5 -21t33 -23t31 -23t32 -25.5t27.5 -25.5t26.5 -29.5t21 -30.5t17.5 -34.5t9.5 -36t4.5 -40.5zM385 294q-234 -7 -385 -85v433q103 -118 273 -118 q32 0 70 5q-21 -61 -21 -86q0 -67 63 -149zM558 805q0 -100 -43.5 -160.5t-140.5 -60.5q-51 0 -97 26t-78 67.5t-56 93.5t-35.5 104t-11.5 99q0 96 51.5 165t144.5 69q66 0 119 -41t84 -104t47 -130t16 -128zM1536 896v-736q0 -119 -84.5 -203.5t-203.5 -84.5h-468 q39 73 39 157q0 66 -22 122.5t-55.5 93t-72 71t-72 59.5t-55.5 54.5t-22 59.5q0 36 23 68t56 61.5t65.5 64.5t55.5 93t23 131t-26.5 145.5t-75.5 118.5q-6 6 -14 11t-12.5 7.5t-10 9.5t-10.5 17h135l135 64h-437q-138 0 -244.5 -38.5t-182.5 -133.5q0 126 81 213t207 87h960 q119 0 203.5 -84.5t84.5 -203.5v-96h-256v256h-128v-256h-256v-128h256v-256h128v256h256z" />
-<glyph unicode="&#xf0d5;" horiz-adv-x="1664" d="M876 71q0 21 -4.5 40.5t-9.5 36t-17.5 34.5t-21 30.5t-26.5 29.5t-27.5 25.5t-32 25.5t-31 23t-33 23t-30.5 21q-17 2 -50 2q-54 0 -106 -7t-108 -25t-98 -46t-69 -75t-27 -107q0 -68 35.5 -121.5t93 -84t120.5 -45.5t127 -15q59 0 112.5 12.5t100.5 39t74.5 73.5 t27.5 110zM756 933q0 60 -16.5 127.5t-47 130.5t-84 104t-119.5 41q-93 0 -144 -69t-51 -165q0 -47 11.5 -99t35.5 -104t56 -93.5t78 -67.5t97 -26q97 0 140.5 60.5t43.5 160.5zM625 1408h437l-135 -79h-135q71 -45 110 -126t39 -169q0 -74 -23 -131.5t-56 -92.5t-66 -64.5 t-56 -61t-23 -67.5q0 -26 16.5 -51t43 -48t58.5 -48t64 -55.5t58.5 -66t43 -85t16.5 -106.5q0 -160 -140 -282q-152 -131 -420 -131q-59 0 -119.5 10t-122 33.5t-108.5 58t-77 89t-30 121.5q0 61 37 135q32 64 96 110.5t145 71t155 36t150 13.5q-64 83 -64 149q0 12 2 23.5 t5 19.5t8 21.5t7 21.5q-40 -5 -70 -5q-149 0 -255.5 98t-106.5 246q0 140 95 250.5t234 141.5q94 20 187 20zM1664 1152v-128h-256v-256h-128v256h-256v128h256v256h128v-256h256z" />
-<glyph unicode="&#xf0d6;" horiz-adv-x="1920" d="M768 384h384v96h-128v448h-114l-148 -137l77 -80q42 37 55 57h2v-288h-128v-96zM1280 640q0 -70 -21 -142t-59.5 -134t-101.5 -101t-138 -39t-138 39t-101.5 101t-59.5 134t-21 142t21 142t59.5 134t101.5 101t138 39t138 -39t101.5 -101t59.5 -134t21 -142zM1792 384 v512q-106 0 -181 75t-75 181h-1152q0 -106 -75 -181t-181 -75v-512q106 0 181 -75t75 -181h1152q0 106 75 181t181 75zM1920 1216v-1152q0 -26 -19 -45t-45 -19h-1792q-26 0 -45 19t-19 45v1152q0 26 19 45t45 19h1792q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0d7;" horiz-adv-x="1024" d="M1024 832q0 -26 -19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45t19 45t45 19h896q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0d8;" horiz-adv-x="1024" d="M1024 320q0 -26 -19 -45t-45 -19h-896q-26 0 -45 19t-19 45t19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45z" />
-<glyph unicode="&#xf0d9;" horiz-adv-x="640" d="M640 1088v-896q0 -26 -19 -45t-45 -19t-45 19l-448 448q-19 19 -19 45t19 45l448 448q19 19 45 19t45 -19t19 -45z" />
-<glyph unicode="&#xf0da;" horiz-adv-x="640" d="M576 640q0 -26 -19 -45l-448 -448q-19 -19 -45 -19t-45 19t-19 45v896q0 26 19 45t45 19t45 -19l448 -448q19 -19 19 -45z" />
-<glyph unicode="&#xf0db;" horiz-adv-x="1664" d="M160 0h608v1152h-640v-1120q0 -13 9.5 -22.5t22.5 -9.5zM1536 32v1120h-640v-1152h608q13 0 22.5 9.5t9.5 22.5zM1664 1248v-1216q0 -66 -47 -113t-113 -47h-1344q-66 0 -113 47t-47 113v1216q0 66 47 113t113 47h1344q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf0dc;" horiz-adv-x="1024" d="M1024 448q0 -26 -19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45t19 45t45 19h896q26 0 45 -19t19 -45zM1024 832q0 -26 -19 -45t-45 -19h-896q-26 0 -45 19t-19 45t19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45z" />
-<glyph unicode="&#xf0dd;" horiz-adv-x="1024" d="M1024 448q0 -26 -19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45t19 45t45 19h896q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0de;" horiz-adv-x="1024" d="M1024 832q0 -26 -19 -45t-45 -19h-896q-26 0 -45 19t-19 45t19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45z" />
-<glyph unicode="&#xf0e0;" horiz-adv-x="1792" d="M1792 826v-794q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113v794q44 -49 101 -87q362 -246 497 -345q57 -42 92.5 -65.5t94.5 -48t110 -24.5h1h1q51 0 110 24.5t94.5 48t92.5 65.5q170 123 498 345q57 39 100 87zM1792 1120q0 -79 -49 -151t-122 -123 q-376 -261 -468 -325q-10 -7 -42.5 -30.5t-54 -38t-52 -32.5t-57.5 -27t-50 -9h-1h-1q-23 0 -50 9t-57.5 27t-52 32.5t-54 38t-42.5 30.5q-91 64 -262 182.5t-205 142.5q-62 42 -117 115.5t-55 136.5q0 78 41.5 130t118.5 52h1472q65 0 112.5 -47t47.5 -113z" />
-<glyph unicode="&#xf0e1;" d="M349 911v-991h-330v991h330zM370 1217q1 -73 -50.5 -122t-135.5 -49h-2q-82 0 -132 49t-50 122q0 74 51.5 122.5t134.5 48.5t133 -48.5t51 -122.5zM1536 488v-568h-329v530q0 105 -40.5 164.5t-126.5 59.5q-63 0 -105.5 -34.5t-63.5 -85.5q-11 -30 -11 -81v-553h-329 q2 399 2 647t-1 296l-1 48h329v-144h-2q20 32 41 56t56.5 52t87 43.5t114.5 15.5q171 0 275 -113.5t104 -332.5z" />
-<glyph unicode="&#xf0e2;" d="M1536 640q0 -156 -61 -298t-164 -245t-245 -164t-298 -61q-172 0 -327 72.5t-264 204.5q-7 10 -6.5 22.5t8.5 20.5l137 138q10 9 25 9q16 -2 23 -12q73 -95 179 -147t225 -52q104 0 198.5 40.5t163.5 109.5t109.5 163.5t40.5 198.5t-40.5 198.5t-109.5 163.5 t-163.5 109.5t-198.5 40.5q-98 0 -188 -35.5t-160 -101.5l137 -138q31 -30 14 -69q-17 -40 -59 -40h-448q-26 0 -45 19t-19 45v448q0 42 40 59q39 17 69 -14l130 -129q107 101 244.5 156.5t284.5 55.5q156 0 298 -61t245 -164t164 -245t61 -298z" />
-<glyph unicode="&#xf0e3;" horiz-adv-x="1792" d="M1771 0q0 -53 -37 -90l-107 -108q-39 -37 -91 -37q-53 0 -90 37l-363 364q-38 36 -38 90q0 53 43 96l-256 256l-126 -126q-14 -14 -34 -14t-34 14q2 -2 12.5 -12t12.5 -13t10 -11.5t10 -13.5t6 -13.5t5.5 -16.5t1.5 -18q0 -38 -28 -68q-3 -3 -16.5 -18t-19 -20.5 t-18.5 -16.5t-22 -15.5t-22 -9t-26 -4.5q-40 0 -68 28l-408 408q-28 28 -28 68q0 13 4.5 26t9 22t15.5 22t16.5 18.5t20.5 19t18 16.5q30 28 68 28q10 0 18 -1.5t16.5 -5.5t13.5 -6t13.5 -10t11.5 -10t13 -12.5t12 -12.5q-14 14 -14 34t14 34l348 348q14 14 34 14t34 -14 q-2 2 -12.5 12t-12.5 13t-10 11.5t-10 13.5t-6 13.5t-5.5 16.5t-1.5 18q0 38 28 68q3 3 16.5 18t19 20.5t18.5 16.5t22 15.5t22 9t26 4.5q40 0 68 -28l408 -408q28 -28 28 -68q0 -13 -4.5 -26t-9 -22t-15.5 -22t-16.5 -18.5t-20.5 -19t-18 -16.5q-30 -28 -68 -28 q-10 0 -18 1.5t-16.5 5.5t-13.5 6t-13.5 10t-11.5 10t-13 12.5t-12 12.5q14 -14 14 -34t-14 -34l-126 -126l256 -256q43 43 96 43q52 0 91 -37l363 -363q37 -39 37 -91z" />
-<glyph unicode="&#xf0e4;" horiz-adv-x="1792" d="M384 384q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM576 832q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1004 351l101 382q6 26 -7.5 48.5t-38.5 29.5 t-48 -6.5t-30 -39.5l-101 -382q-60 -5 -107 -43.5t-63 -98.5q-20 -77 20 -146t117 -89t146 20t89 117q16 60 -6 117t-72 91zM1664 384q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1024 1024q0 53 -37.5 90.5 t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1472 832q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1792 384q0 -261 -141 -483q-19 -29 -54 -29h-1402q-35 0 -54 29 q-141 221 -141 483q0 182 71 348t191 286t286 191t348 71t348 -71t286 -191t191 -286t71 -348z" />
-<glyph unicode="&#xf0e5;" horiz-adv-x="1792" d="M896 1152q-204 0 -381.5 -69.5t-282 -187.5t-104.5 -255q0 -112 71.5 -213.5t201.5 -175.5l87 -50l-27 -96q-24 -91 -70 -172q152 63 275 171l43 38l57 -6q69 -8 130 -8q204 0 381.5 69.5t282 187.5t104.5 255t-104.5 255t-282 187.5t-381.5 69.5zM1792 640 q0 -174 -120 -321.5t-326 -233t-450 -85.5q-70 0 -145 8q-198 -175 -460 -242q-49 -14 -114 -22h-5q-15 0 -27 10.5t-16 27.5v1q-3 4 -0.5 12t2 10t4.5 9.5l6 9t7 8.5t8 9q7 8 31 34.5t34.5 38t31 39.5t32.5 51t27 59t26 76q-157 89 -247.5 220t-90.5 281q0 174 120 321.5 t326 233t450 85.5t450 -85.5t326 -233t120 -321.5z" />
-<glyph unicode="&#xf0e6;" horiz-adv-x="1792" d="M704 1152q-153 0 -286 -52t-211.5 -141t-78.5 -191q0 -82 53 -158t149 -132l97 -56l-35 -84q34 20 62 39l44 31l53 -10q78 -14 153 -14q153 0 286 52t211.5 141t78.5 191t-78.5 191t-211.5 141t-286 52zM704 1280q191 0 353.5 -68.5t256.5 -186.5t94 -257t-94 -257 t-256.5 -186.5t-353.5 -68.5q-86 0 -176 16q-124 -88 -278 -128q-36 -9 -86 -16h-3q-11 0 -20.5 8t-11.5 21q-1 3 -1 6.5t0.5 6.5t2 6l2.5 5t3.5 5.5t4 5t4.5 5t4 4.5q5 6 23 25t26 29.5t22.5 29t25 38.5t20.5 44q-124 72 -195 177t-71 224q0 139 94 257t256.5 186.5 t353.5 68.5zM1526 111q10 -24 20.5 -44t25 -38.5t22.5 -29t26 -29.5t23 -25q1 -1 4 -4.5t4.5 -5t4 -5t3.5 -5.5l2.5 -5t2 -6t0.5 -6.5t-1 -6.5q-3 -14 -13 -22t-22 -7q-50 7 -86 16q-154 40 -278 128q-90 -16 -176 -16q-271 0 -472 132q58 -4 88 -4q161 0 309 45t264 129 q125 92 192 212t67 254q0 77 -23 152q129 -71 204 -178t75 -230q0 -120 -71 -224.5t-195 -176.5z" />
-<glyph unicode="&#xf0e7;" horiz-adv-x="896" d="M885 970q18 -20 7 -44l-540 -1157q-13 -25 -42 -25q-4 0 -14 2q-17 5 -25.5 19t-4.5 30l197 808l-406 -101q-4 -1 -12 -1q-18 0 -31 11q-18 15 -13 39l201 825q4 14 16 23t28 9h328q19 0 32 -12.5t13 -29.5q0 -8 -5 -18l-171 -463l396 98q8 2 12 2q19 0 34 -15z" />
-<glyph unicode="&#xf0e8;" horiz-adv-x="1792" d="M1792 288v-320q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h96v192h-512v-192h96q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h96v192h-512v-192h96q40 0 68 -28t28 -68v-320 q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h96v192q0 52 38 90t90 38h512v192h-96q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-96v-192h512q52 0 90 -38t38 -90v-192h96q40 0 68 -28t28 -68 z" />
-<glyph unicode="&#xf0e9;" horiz-adv-x="1664" d="M896 708v-580q0 -104 -76 -180t-180 -76t-180 76t-76 180q0 26 19 45t45 19t45 -19t19 -45q0 -50 39 -89t89 -39t89 39t39 89v580q33 11 64 11t64 -11zM1664 681q0 -13 -9.5 -22.5t-22.5 -9.5q-11 0 -23 10q-49 46 -93 69t-102 23q-68 0 -128 -37t-103 -97 q-7 -10 -17.5 -28t-14.5 -24q-11 -17 -28 -17q-18 0 -29 17q-4 6 -14.5 24t-17.5 28q-43 60 -102.5 97t-127.5 37t-127.5 -37t-102.5 -97q-7 -10 -17.5 -28t-14.5 -24q-11 -17 -29 -17q-17 0 -28 17q-4 6 -14.5 24t-17.5 28q-43 60 -103 97t-128 37q-58 0 -102 -23t-93 -69 q-12 -10 -23 -10q-13 0 -22.5 9.5t-9.5 22.5q0 5 1 7q45 183 172.5 319.5t298 204.5t360.5 68q140 0 274.5 -40t246.5 -113.5t194.5 -187t115.5 -251.5q1 -2 1 -7zM896 1408v-98q-42 2 -64 2t-64 -2v98q0 26 19 45t45 19t45 -19t19 -45z" />
-<glyph unicode="&#xf0ea;" horiz-adv-x="1792" d="M768 -128h896v640h-416q-40 0 -68 28t-28 68v416h-384v-1152zM1024 1312v64q0 13 -9.5 22.5t-22.5 9.5h-704q-13 0 -22.5 -9.5t-9.5 -22.5v-64q0 -13 9.5 -22.5t22.5 -9.5h704q13 0 22.5 9.5t9.5 22.5zM1280 640h299l-299 299v-299zM1792 512v-672q0 -40 -28 -68t-68 -28 h-960q-40 0 -68 28t-28 68v160h-544q-40 0 -68 28t-28 68v1344q0 40 28 68t68 28h1088q40 0 68 -28t28 -68v-328q21 -13 36 -28l408 -408q28 -28 48 -76t20 -88z" />
-<glyph unicode="&#xf0eb;" horiz-adv-x="1024" d="M736 960q0 -13 -9.5 -22.5t-22.5 -9.5t-22.5 9.5t-9.5 22.5q0 46 -54 71t-106 25q-13 0 -22.5 9.5t-9.5 22.5t9.5 22.5t22.5 9.5q50 0 99.5 -16t87 -54t37.5 -90zM896 960q0 72 -34.5 134t-90 101.5t-123 62t-136.5 22.5t-136.5 -22.5t-123 -62t-90 -101.5t-34.5 -134 q0 -101 68 -180q10 -11 30.5 -33t30.5 -33q128 -153 141 -298h228q13 145 141 298q10 11 30.5 33t30.5 33q68 79 68 180zM1024 960q0 -155 -103 -268q-45 -49 -74.5 -87t-59.5 -95.5t-34 -107.5q47 -28 47 -82q0 -37 -25 -64q25 -27 25 -64q0 -52 -45 -81q13 -23 13 -47 q0 -46 -31.5 -71t-77.5 -25q-20 -44 -60 -70t-87 -26t-87 26t-60 70q-46 0 -77.5 25t-31.5 71q0 24 13 47q-45 29 -45 81q0 37 25 64q-25 27 -25 64q0 54 47 82q-4 50 -34 107.5t-59.5 95.5t-74.5 87q-103 113 -103 268q0 99 44.5 184.5t117 142t164 89t186.5 32.5 t186.5 -32.5t164 -89t117 -142t44.5 -184.5z" />
-<glyph unicode="&#xf0ec;" horiz-adv-x="1792" d="M1792 352v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5q-12 0 -24 10l-319 320q-9 9 -9 22q0 14 9 23l320 320q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5v-192h1376q13 0 22.5 -9.5t9.5 -22.5zM1792 896q0 -14 -9 -23l-320 -320q-9 -9 -23 -9 q-13 0 -22.5 9.5t-9.5 22.5v192h-1376q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h1376v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23z" />
-<glyph unicode="&#xf0ed;" horiz-adv-x="1920" d="M1280 608q0 14 -9 23t-23 9h-224v352q0 13 -9.5 22.5t-22.5 9.5h-192q-13 0 -22.5 -9.5t-9.5 -22.5v-352h-224q-13 0 -22.5 -9.5t-9.5 -22.5q0 -14 9 -23l352 -352q9 -9 23 -9t23 9l351 351q10 12 10 24zM1920 384q0 -159 -112.5 -271.5t-271.5 -112.5h-1088 q-185 0 -316.5 131.5t-131.5 316.5q0 130 70 240t188 165q-2 30 -2 43q0 212 150 362t362 150q156 0 285.5 -87t188.5 -231q71 62 166 62q106 0 181 -75t75 -181q0 -76 -41 -138q130 -31 213.5 -135.5t83.5 -238.5z" />
-<glyph unicode="&#xf0ee;" horiz-adv-x="1920" d="M1280 672q0 14 -9 23l-352 352q-9 9 -23 9t-23 -9l-351 -351q-10 -12 -10 -24q0 -14 9 -23t23 -9h224v-352q0 -13 9.5 -22.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 22.5v352h224q13 0 22.5 9.5t9.5 22.5zM1920 384q0 -159 -112.5 -271.5t-271.5 -112.5h-1088 q-185 0 -316.5 131.5t-131.5 316.5q0 130 70 240t188 165q-2 30 -2 43q0 212 150 362t362 150q156 0 285.5 -87t188.5 -231q71 62 166 62q106 0 181 -75t75 -181q0 -76 -41 -138q130 -31 213.5 -135.5t83.5 -238.5z" />
-<glyph unicode="&#xf0f0;" horiz-adv-x="1408" d="M384 192q0 -26 -19 -45t-45 -19t-45 19t-19 45t19 45t45 19t45 -19t19 -45zM1408 131q0 -121 -73 -190t-194 -69h-874q-121 0 -194 69t-73 190q0 68 5.5 131t24 138t47.5 132.5t81 103t120 60.5q-22 -52 -22 -120v-203q-58 -20 -93 -70t-35 -111q0 -80 56 -136t136 -56 t136 56t56 136q0 61 -35.5 111t-92.5 70v203q0 62 25 93q132 -104 295 -104t295 104q25 -31 25 -93v-64q-106 0 -181 -75t-75 -181v-89q-32 -29 -32 -71q0 -40 28 -68t68 -28t68 28t28 68q0 42 -32 71v89q0 52 38 90t90 38t90 -38t38 -90v-89q-32 -29 -32 -71q0 -40 28 -68 t68 -28t68 28t28 68q0 42 -32 71v89q0 68 -34.5 127.5t-93.5 93.5q0 10 0.5 42.5t0 48t-2.5 41.5t-7 47t-13 40q68 -15 120 -60.5t81 -103t47.5 -132.5t24 -138t5.5 -131zM1088 1024q0 -159 -112.5 -271.5t-271.5 -112.5t-271.5 112.5t-112.5 271.5t112.5 271.5t271.5 112.5 t271.5 -112.5t112.5 -271.5z" />
-<glyph unicode="&#xf0f1;" horiz-adv-x="1408" d="M1280 832q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1408 832q0 -62 -35.5 -111t-92.5 -70v-395q0 -159 -131.5 -271.5t-316.5 -112.5t-316.5 112.5t-131.5 271.5v132q-164 20 -274 128t-110 252v512q0 26 19 45t45 19q6 0 16 -2q17 30 47 48 t65 18q53 0 90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5q-33 0 -64 18v-402q0 -106 94 -181t226 -75t226 75t94 181v402q-31 -18 -64 -18q-53 0 -90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5q35 0 65 -18t47 -48q10 2 16 2q26 0 45 -19t19 -45v-512q0 -144 -110 -252 t-274 -128v-132q0 -106 94 -181t226 -75t226 75t94 181v395q-57 21 -92.5 70t-35.5 111q0 80 56 136t136 56t136 -56t56 -136z" />
-<glyph unicode="&#xf0f2;" horiz-adv-x="1792" d="M640 1152h512v128h-512v-128zM288 1152v-1280h-64q-92 0 -158 66t-66 158v832q0 92 66 158t158 66h64zM1408 1152v-1280h-1024v1280h128v160q0 40 28 68t68 28h576q40 0 68 -28t28 -68v-160h128zM1792 928v-832q0 -92 -66 -158t-158 -66h-64v1280h64q92 0 158 -66 t66 -158z" />
-<glyph unicode="&#xf0f3;" horiz-adv-x="1664" d="M848 -160q0 16 -16 16q-59 0 -101.5 42.5t-42.5 101.5q0 16 -16 16t-16 -16q0 -73 51.5 -124.5t124.5 -51.5q16 0 16 16zM1664 128q0 -52 -38 -90t-90 -38h-448q0 -106 -75 -181t-181 -75t-181 75t-75 181h-448q-52 0 -90 38t-38 90q190 161 287 397.5t97 498.5 q0 165 96 262t264 117q-8 18 -8 37q0 40 28 68t68 28t68 -28t28 -68q0 -19 -8 -37q168 -20 264 -117t96 -262q0 -262 97 -498.5t287 -397.5z" />
-<glyph unicode="&#xf0f4;" horiz-adv-x="1920" d="M1664 896q0 80 -56 136t-136 56h-64v-384h64q80 0 136 56t56 136zM0 128h1792q0 -106 -75 -181t-181 -75h-1280q-106 0 -181 75t-75 181zM1856 896q0 -159 -112.5 -271.5t-271.5 -112.5h-64v-32q0 -92 -66 -158t-158 -66h-704q-92 0 -158 66t-66 158v736q0 26 19 45 t45 19h1152q159 0 271.5 -112.5t112.5 -271.5z" />
-<glyph unicode="&#xf0f5;" horiz-adv-x="1408" d="M640 1472v-640q0 -61 -35.5 -111t-92.5 -70v-779q0 -52 -38 -90t-90 -38h-128q-52 0 -90 38t-38 90v779q-57 20 -92.5 70t-35.5 111v640q0 26 19 45t45 19t45 -19t19 -45v-416q0 -26 19 -45t45 -19t45 19t19 45v416q0 26 19 45t45 19t45 -19t19 -45v-416q0 -26 19 -45 t45 -19t45 19t19 45v416q0 26 19 45t45 19t45 -19t19 -45zM1408 1472v-1600q0 -52 -38 -90t-90 -38h-128q-52 0 -90 38t-38 90v512h-224q-13 0 -22.5 9.5t-9.5 22.5v800q0 132 94 226t226 94h256q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0f6;" horiz-adv-x="1280" d="M1024 352v-64q0 -14 -9 -23t-23 -9h-704q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h704q14 0 23 -9t9 -23zM1024 608v-64q0 -14 -9 -23t-23 -9h-704q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h704q14 0 23 -9t9 -23zM128 0h1024v768h-416q-40 0 -68 28t-28 68v416h-512v-1280z M768 896h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376zM1280 864v-896q0 -40 -28 -68t-68 -28h-1088q-40 0 -68 28t-28 68v1344q0 40 28 68t68 28h640q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88z" />
-<glyph unicode="&#xf0f7;" horiz-adv-x="1408" d="M384 224v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M1152 224v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM896 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 992v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M1152 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM896 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 992v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 1248v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M1152 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM896 992v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 1248v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM1152 992v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M896 1248v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM1152 1248v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M896 -128h384v1536h-1152v-1536h384v224q0 13 9.5 22.5t22.5 9.5h320q13 0 22.5 -9.5t9.5 -22.5v-224zM1408 1472v-1664q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45v1664q0 26 19 45t45 19h1280q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0f8;" horiz-adv-x="1408" d="M384 224v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM384 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M1152 224v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM896 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M640 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM1152 480v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M896 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5zM1152 736v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5z M896 -128h384v1152h-256v-32q0 -40 -28 -68t-68 -28h-448q-40 0 -68 28t-28 68v32h-256v-1152h384v224q0 13 9.5 22.5t22.5 9.5h320q13 0 22.5 -9.5t9.5 -22.5v-224zM896 1056v320q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-96h-128v96q0 13 -9.5 22.5 t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-320q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5v96h128v-96q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5zM1408 1088v-1280q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45v1280q0 26 19 45t45 19h320 v288q0 40 28 68t68 28h448q40 0 68 -28t28 -68v-288h320q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0f9;" horiz-adv-x="1920" d="M640 128q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM256 640h384v256h-158q-14 -2 -22 -9l-195 -195q-7 -12 -9 -22v-30zM1536 128q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5 t90.5 37.5t37.5 90.5zM1664 800v192q0 14 -9 23t-23 9h-224v224q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-224h-224q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h224v-224q0 -14 9 -23t23 -9h192q14 0 23 9t9 23v224h224q14 0 23 9t9 23zM1920 1344v-1152 q0 -26 -19 -45t-45 -19h-192q0 -106 -75 -181t-181 -75t-181 75t-75 181h-384q0 -106 -75 -181t-181 -75t-181 75t-75 181h-128q-26 0 -45 19t-19 45t19 45t45 19v416q0 26 13 58t32 51l198 198q19 19 51 32t58 13h160v320q0 26 19 45t45 19h1152q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf0fa;" horiz-adv-x="1792" d="M1280 416v192q0 14 -9 23t-23 9h-224v224q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-224h-224q-14 0 -23 -9t-9 -23v-192q0 -14 9 -23t23 -9h224v-224q0 -14 9 -23t23 -9h192q14 0 23 9t9 23v224h224q14 0 23 9t9 23zM640 1152h512v128h-512v-128zM256 1152v-1280h-32 q-92 0 -158 66t-66 158v832q0 92 66 158t158 66h32zM1440 1152v-1280h-1088v1280h160v160q0 40 28 68t68 28h576q40 0 68 -28t28 -68v-160h160zM1792 928v-832q0 -92 -66 -158t-158 -66h-32v1280h32q92 0 158 -66t66 -158z" />
-<glyph unicode="&#xf0fb;" horiz-adv-x="1920" d="M1920 576q-1 -32 -288 -96l-352 -32l-224 -64h-64l-293 -352h69q26 0 45 -4.5t19 -11.5t-19 -11.5t-45 -4.5h-96h-160h-64v32h64v416h-160l-192 -224h-96l-32 32v192h32v32h128v8l-192 24v128l192 24v8h-128v32h-32v192l32 32h96l192 -224h160v416h-64v32h64h160h96 q26 0 45 -4.5t19 -11.5t-19 -11.5t-45 -4.5h-69l293 -352h64l224 -64l352 -32q261 -58 287 -93z" />
-<glyph unicode="&#xf0fc;" horiz-adv-x="1664" d="M640 640v384h-256v-256q0 -53 37.5 -90.5t90.5 -37.5h128zM1664 192v-192h-1152v192l128 192h-128q-159 0 -271.5 112.5t-112.5 271.5v320l-64 64l32 128h480l32 128h960l32 -192l-64 -32v-800z" />
-<glyph unicode="&#xf0fd;" d="M1280 192v896q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-320h-512v320q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-896q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v320h512v-320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45zM1536 1120v-960 q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf0fe;" d="M1280 576v128q0 26 -19 45t-45 19h-320v320q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-320h-320q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h320v-320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v320h320q26 0 45 19t19 45zM1536 1120v-960 q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf100;" horiz-adv-x="1024" d="M627 160q0 -13 -10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23zM1011 160q0 -13 -10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23 t10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23z" />
-<glyph unicode="&#xf101;" horiz-adv-x="1024" d="M595 576q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23zM979 576q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23 l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23z" />
-<glyph unicode="&#xf102;" horiz-adv-x="1152" d="M1075 224q0 -13 -10 -23l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23zM1075 608q0 -13 -10 -23l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393 q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23z" />
-<glyph unicode="&#xf103;" horiz-adv-x="1152" d="M1075 672q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10l50 -50q10 -10 10 -23zM1075 1056q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23 t10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10l50 -50q10 -10 10 -23z" />
-<glyph unicode="&#xf104;" horiz-adv-x="640" d="M627 992q0 -13 -10 -23l-393 -393l393 -393q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23z" />
-<glyph unicode="&#xf105;" horiz-adv-x="640" d="M595 576q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23z" />
-<glyph unicode="&#xf106;" horiz-adv-x="1152" d="M1075 352q0 -13 -10 -23l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23z" />
-<glyph unicode="&#xf107;" horiz-adv-x="1152" d="M1075 800q0 -13 -10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10l50 -50q10 -10 10 -23z" />
-<glyph unicode="&#xf108;" horiz-adv-x="1920" d="M1792 544v832q0 13 -9.5 22.5t-22.5 9.5h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-832q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5zM1920 1376v-1088q0 -66 -47 -113t-113 -47h-544q0 -37 16 -77.5t32 -71t16 -43.5q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19 t-19 45q0 14 16 44t32 70t16 78h-544q-66 0 -113 47t-47 113v1088q0 66 47 113t113 47h1600q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf109;" horiz-adv-x="1920" d="M416 256q-66 0 -113 47t-47 113v704q0 66 47 113t113 47h1088q66 0 113 -47t47 -113v-704q0 -66 -47 -113t-113 -47h-1088zM384 1120v-704q0 -13 9.5 -22.5t22.5 -9.5h1088q13 0 22.5 9.5t9.5 22.5v704q0 13 -9.5 22.5t-22.5 9.5h-1088q-13 0 -22.5 -9.5t-9.5 -22.5z M1760 192h160v-96q0 -40 -47 -68t-113 -28h-1600q-66 0 -113 28t-47 68v96h160h1600zM1040 96q16 0 16 16t-16 16h-160q-16 0 -16 -16t16 -16h160z" />
-<glyph unicode="&#xf10a;" horiz-adv-x="1152" d="M640 128q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1024 288v960q0 13 -9.5 22.5t-22.5 9.5h-832q-13 0 -22.5 -9.5t-9.5 -22.5v-960q0 -13 9.5 -22.5t22.5 -9.5h832q13 0 22.5 9.5t9.5 22.5zM1152 1248v-1088q0 -66 -47 -113t-113 -47h-832 q-66 0 -113 47t-47 113v1088q0 66 47 113t113 47h832q66 0 113 -47t47 -113z" />
-<glyph unicode="&#xf10b;" horiz-adv-x="768" d="M464 128q0 33 -23.5 56.5t-56.5 23.5t-56.5 -23.5t-23.5 -56.5t23.5 -56.5t56.5 -23.5t56.5 23.5t23.5 56.5zM672 288v704q0 13 -9.5 22.5t-22.5 9.5h-512q-13 0 -22.5 -9.5t-9.5 -22.5v-704q0 -13 9.5 -22.5t22.5 -9.5h512q13 0 22.5 9.5t9.5 22.5zM480 1136 q0 16 -16 16h-160q-16 0 -16 -16t16 -16h160q16 0 16 16zM768 1152v-1024q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90v1024q0 52 38 90t90 38h512q52 0 90 -38t38 -90z" />
-<glyph unicode="&#xf10c;" d="M768 1184q-148 0 -273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103 t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf10d;" horiz-adv-x="1664" d="M768 576v-384q0 -80 -56 -136t-136 -56h-384q-80 0 -136 56t-56 136v704q0 104 40.5 198.5t109.5 163.5t163.5 109.5t198.5 40.5h64q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-64q-106 0 -181 -75t-75 -181v-32q0 -40 28 -68t68 -28h224q80 0 136 -56t56 -136z M1664 576v-384q0 -80 -56 -136t-136 -56h-384q-80 0 -136 56t-56 136v704q0 104 40.5 198.5t109.5 163.5t163.5 109.5t198.5 40.5h64q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-64q-106 0 -181 -75t-75 -181v-32q0 -40 28 -68t68 -28h224q80 0 136 -56t56 -136z" />
-<glyph unicode="&#xf10e;" horiz-adv-x="1664" d="M768 1216v-704q0 -104 -40.5 -198.5t-109.5 -163.5t-163.5 -109.5t-198.5 -40.5h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h64q106 0 181 75t75 181v32q0 40 -28 68t-68 28h-224q-80 0 -136 56t-56 136v384q0 80 56 136t136 56h384q80 0 136 -56t56 -136zM1664 1216 v-704q0 -104 -40.5 -198.5t-109.5 -163.5t-163.5 -109.5t-198.5 -40.5h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h64q106 0 181 75t75 181v32q0 40 -28 68t-68 28h-224q-80 0 -136 56t-56 136v384q0 80 56 136t136 56h384q80 0 136 -56t56 -136z" />
-<glyph unicode="&#xf110;" horiz-adv-x="1568" d="M496 192q0 -60 -42.5 -102t-101.5 -42q-60 0 -102 42t-42 102t42 102t102 42q59 0 101.5 -42t42.5 -102zM928 0q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM320 640q0 -66 -47 -113t-113 -47t-113 47t-47 113 t47 113t113 47t113 -47t47 -113zM1360 192q0 -46 -33 -79t-79 -33t-79 33t-33 79t33 79t79 33t79 -33t33 -79zM528 1088q0 -73 -51.5 -124.5t-124.5 -51.5t-124.5 51.5t-51.5 124.5t51.5 124.5t124.5 51.5t124.5 -51.5t51.5 -124.5zM992 1280q0 -80 -56 -136t-136 -56 t-136 56t-56 136t56 136t136 56t136 -56t56 -136zM1536 640q0 -40 -28 -68t-68 -28t-68 28t-28 68t28 68t68 28t68 -28t28 -68zM1328 1088q0 -33 -23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5t23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5z" />
-<glyph unicode="&#xf111;" d="M1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf112;" horiz-adv-x="1792" d="M1792 416q0 -166 -127 -451q-3 -7 -10.5 -24t-13.5 -30t-13 -22q-12 -17 -28 -17q-15 0 -23.5 10t-8.5 25q0 9 2.5 26.5t2.5 23.5q5 68 5 123q0 101 -17.5 181t-48.5 138.5t-80 101t-105.5 69.5t-133 42.5t-154 21.5t-175.5 6h-224v-256q0 -26 -19 -45t-45 -19t-45 19 l-512 512q-19 19 -19 45t19 45l512 512q19 19 45 19t45 -19t19 -45v-256h224q713 0 875 -403q53 -134 53 -333z" />
-<glyph unicode="&#xf113;" horiz-adv-x="1664" d="M640 320q0 -40 -12.5 -82t-43 -76t-72.5 -34t-72.5 34t-43 76t-12.5 82t12.5 82t43 76t72.5 34t72.5 -34t43 -76t12.5 -82zM1280 320q0 -40 -12.5 -82t-43 -76t-72.5 -34t-72.5 34t-43 76t-12.5 82t12.5 82t43 76t72.5 34t72.5 -34t43 -76t12.5 -82zM1440 320 q0 120 -69 204t-187 84q-41 0 -195 -21q-71 -11 -157 -11t-157 11q-152 21 -195 21q-118 0 -187 -84t-69 -204q0 -88 32 -153.5t81 -103t122 -60t140 -29.5t149 -7h168q82 0 149 7t140 29.5t122 60t81 103t32 153.5zM1664 496q0 -207 -61 -331q-38 -77 -105.5 -133t-141 -86 t-170 -47.5t-171.5 -22t-167 -4.5q-78 0 -142 3t-147.5 12.5t-152.5 30t-137 51.5t-121 81t-86 115q-62 123 -62 331q0 237 136 396q-27 82 -27 170q0 116 51 218q108 0 190 -39.5t189 -123.5q147 35 309 35q148 0 280 -32q105 82 187 121t189 39q51 -102 51 -218 q0 -87 -27 -168q136 -160 136 -398z" />
-<glyph unicode="&#xf114;" horiz-adv-x="1664" d="M1536 224v704q0 40 -28 68t-68 28h-704q-40 0 -68 28t-28 68v64q0 40 -28 68t-68 28h-320q-40 0 -68 -28t-28 -68v-960q0 -40 28 -68t68 -28h1216q40 0 68 28t28 68zM1664 928v-704q0 -92 -66 -158t-158 -66h-1216q-92 0 -158 66t-66 158v960q0 92 66 158t158 66h320 q92 0 158 -66t66 -158v-32h672q92 0 158 -66t66 -158z" />
-<glyph unicode="&#xf115;" horiz-adv-x="1920" d="M1781 605q0 35 -53 35h-1088q-40 0 -85.5 -21.5t-71.5 -52.5l-294 -363q-18 -24 -18 -40q0 -35 53 -35h1088q40 0 86 22t71 53l294 363q18 22 18 39zM640 768h768v160q0 40 -28 68t-68 28h-576q-40 0 -68 28t-28 68v64q0 40 -28 68t-68 28h-320q-40 0 -68 -28t-28 -68 v-853l256 315q44 53 116 87.5t140 34.5zM1909 605q0 -62 -46 -120l-295 -363q-43 -53 -116 -87.5t-140 -34.5h-1088q-92 0 -158 66t-66 158v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h544q92 0 158 -66t66 -158v-160h192q54 0 99 -24.5t67 -70.5q15 -32 15 -68z " />
+<glyph unicode="&#x25fc;" horiz-adv-x="500" d="M0 0z" />
+<glyph unicode="&#xf000;" horiz-adv-x="1792" d="M93 1350q0 23 18 36.5t38 17.5t43 4h1408q23 0 43 -4t38 -17.5t18 -36.5q0 -35 -43 -78l-632 -632v-768h320q26 0 45 -19t19 -45t-19 -45t-45 -19h-896q-26 0 -45 19t-19 45t19 45t45 19h320v768l-632 632q-43 43 -43 78z" />
+<glyph unicode="&#xf001;" d="M0 -64q0 50 34 89t86 60.5t103.5 32t96.5 10.5q105 0 192 -39v967q0 31 19 56.5t49 35.5l832 256q12 4 28 4q40 0 68 -28t28 -68v-1120q0 -50 -34 -89t-86 -60.5t-103.5 -32t-96.5 -10.5t-96.5 10.5t-103.5 32t-86 60.5t-34 89t34 89t86 60.5t103.5 32t96.5 10.5 q105 0 192 -39v537l-768 -237v-709q0 -50 -34 -89t-86 -60.5t-103.5 -32t-96.5 -10.5t-96.5 10.5t-103.5 32t-86 60.5t-34 89z" />
+<glyph unicode="&#xf002;" horiz-adv-x="1664" d="M0 704q0 143 55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90q0 -52 -38 -90t-90 -38q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5z M256 704q0 -185 131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5t-131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5z" />
+<glyph unicode="&#xf003;" horiz-adv-x="1792" d="M0 32v1088q0 66 47 113t113 47h1472q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113zM128 32q0 -13 9.5 -22.5t22.5 -9.5h1472q13 0 22.5 9.5t9.5 22.5v768q-32 -36 -69 -66q-268 -206 -426 -338q-51 -43 -83 -67t-86.5 -48.5 t-102.5 -24.5h-1h-1q-48 0 -102.5 24.5t-86.5 48.5t-83 67q-158 132 -426 338q-37 30 -69 66v-768zM128 1120q0 -168 147 -284q193 -152 401 -317q6 -5 35 -29.5t46 -37.5t44.5 -31.5t50.5 -27.5t43 -9h1h1q20 0 43 9t50.5 27.5t44.5 31.5t46 37.5t35 29.5q208 165 401 317 q54 43 100.5 115.5t46.5 131.5v11v13.5t-0.5 13t-3 12.5t-5.5 9t-9 7.5t-14 2.5h-1472q-13 0 -22.5 -9.5t-9.5 -22.5z" />
+<glyph unicode="&#xf004;" horiz-adv-x="1792" d="M0 940q0 220 127 344t351 124q62 0 126.5 -21.5t120 -58t95.5 -68.5t76 -68q36 36 76 68t95.5 68.5t120 58t126.5 21.5q224 0 351 -124t127 -344q0 -221 -229 -450l-623 -600q-18 -18 -44 -18t-44 18l-624 602q-10 8 -27.5 26t-55.5 65.5t-68 97.5t-53.5 121t-23.5 138z " />
+<glyph unicode="&#xf005;" horiz-adv-x="1664" d="M0 889q0 37 56 46l502 73l225 455q19 41 49 41t49 -41l225 -455l502 -73q56 -9 56 -46q0 -22 -26 -48l-363 -354l86 -500q1 -7 1 -20q0 -21 -10.5 -35.5t-30.5 -14.5q-19 0 -40 12l-449 236l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500 l-364 354q-25 27 -25 48z" />
+<glyph unicode="&#xf006;" horiz-adv-x="1664" d="M0 889q0 37 56 46l502 73l225 455q19 41 49 41t49 -41l225 -455l502 -73q56 -9 56 -46q0 -22 -26 -48l-363 -354l86 -500q1 -7 1 -20q0 -50 -41 -50q-19 0 -40 12l-449 236l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500l-364 354 q-25 27 -25 48zM221 829l306 -297l-73 -421l378 199l377 -199l-72 421l306 297l-422 62l-189 382l-189 -382z" />
+<glyph unicode="&#xf007;" horiz-adv-x="1408" d="M0 131q0 53 3.5 103.5t14 109t26.5 108.5t43 97.5t62 81t85.5 53.5t111.5 20q9 0 42 -21.5t74.5 -48t108 -48t133.5 -21.5t133.5 21.5t108 48t74.5 48t42 21.5q61 0 111.5 -20t85.5 -53.5t62 -81t43 -97.5t26.5 -108.5t14 -109t3.5 -103.5q0 -120 -73 -189.5t-194 -69.5 h-874q-121 0 -194 69.5t-73 189.5zM320 1024q0 159 112.5 271.5t271.5 112.5t271.5 -112.5t112.5 -271.5t-112.5 -271.5t-271.5 -112.5t-271.5 112.5t-112.5 271.5z" />
+<glyph unicode="&#xf008;" horiz-adv-x="1920" d="M0 -96v1344q0 66 47 113t113 47h1600q66 0 113 -47t47 -113v-1344q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113zM128 64v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45zM128 320q0 -26 19 -45t45 -19h128 q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128zM128 704q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128zM128 1088q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19 h-128q-26 0 -45 -19t-19 -45v-128zM512 -64q0 -26 19 -45t45 -19h768q26 0 45 19t19 45v512q0 26 -19 45t-45 19h-768q-26 0 -45 -19t-19 -45v-512zM512 704q0 -26 19 -45t45 -19h768q26 0 45 19t19 45v512q0 26 -19 45t-45 19h-768q-26 0 -45 -19t-19 -45v-512zM1536 64 v-128q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45zM1536 320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128zM1536 704q0 -26 19 -45t45 -19h128q26 0 45 19t19 45 v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128zM1536 1088q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-128z" />
+<glyph unicode="&#xf009;" horiz-adv-x="1664" d="M0 128v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90zM0 896v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90zM896 128v384q0 52 38 90t90 38h512q52 0 90 -38 t38 -90v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90zM896 896v384q0 52 38 90t90 38h512q52 0 90 -38t38 -90v-384q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90z" />
+<glyph unicode="&#xf00a;" horiz-adv-x="1792" d="M0 96v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM0 608v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM0 1120v192q0 40 28 68t68 28h320q40 0 68 -28 t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM640 96v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM640 608v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320 q-40 0 -68 28t-28 68zM640 1120v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM1280 96v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM1280 608v192 q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM1280 1120v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf00b;" horiz-adv-x="1792" d="M0 96v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM0 608v192q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM0 1120v192q0 40 28 68t68 28h320q40 0 68 -28 t28 -68v-192q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM640 96v192q0 40 28 68t68 28h960q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68zM640 608v192q0 40 28 68t68 28h960q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-960 q-40 0 -68 28t-28 68zM640 1120v192q0 40 28 68t68 28h960q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf00c;" horiz-adv-x="1792" d="M121 608q0 40 28 68l136 136q28 28 68 28t68 -28l294 -295l656 657q28 28 68 28t68 -28l136 -136q28 -28 28 -68t-28 -68l-724 -724l-136 -136q-28 -28 -68 -28t-68 28l-136 136l-362 362q-28 28 -28 68z" />
+<glyph unicode="&#xf00d;" horiz-adv-x="1408" d="M110 214q0 40 28 68l294 294l-294 294q-28 28 -28 68t28 68l136 136q28 28 68 28t68 -28l294 -294l294 294q28 28 68 28t68 -28l136 -136q28 -28 28 -68t-28 -68l-294 -294l294 -294q28 -28 28 -68t-28 -68l-136 -136q-28 -28 -68 -28t-68 28l-294 294l-294 -294 q-28 -28 -68 -28t-68 28l-136 136q-28 28 -28 68z" />
+<glyph unicode="&#xf00e;" horiz-adv-x="1664" d="M0 704q0 143 55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90t-37.5 -90.5t-90.5 -37.5q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5z M256 704q0 -185 131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5t-131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5zM384 672v64q0 13 9.5 22.5t22.5 9.5h224v224q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-224h224q13 0 22.5 -9.5t9.5 -22.5v-64 q0 -13 -9.5 -22.5t-22.5 -9.5h-224v-224q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v224h-224q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf010;" horiz-adv-x="1664" d="M0 704q0 143 55.5 273.5t150 225t225 150t273.5 55.5t273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -220 -124 -399l343 -343q37 -37 37 -90t-37.5 -90.5t-90.5 -37.5q-54 0 -90 38l-343 342q-179 -124 -399 -124q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5z M256 704q0 -185 131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5t-131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5zM384 672v64q0 13 9.5 22.5t22.5 9.5h576q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-576q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf011;" d="M0 640q0 182 80.5 343t226.5 270q43 32 95.5 25t83.5 -50q32 -42 24.5 -94.5t-49.5 -84.5q-98 -74 -151.5 -181t-53.5 -228q0 -104 40.5 -198.5t109.5 -163.5t163.5 -109.5t198.5 -40.5t198.5 40.5t163.5 109.5t109.5 163.5t40.5 198.5q0 121 -53.5 228t-151.5 181 q-42 32 -49.5 84.5t24.5 94.5q31 43 84 50t95 -25q146 -109 226.5 -270t80.5 -343q0 -156 -61 -298t-164 -245t-245 -164t-298 -61t-298 61t-245 164t-164 245t-61 298zM640 768v640q0 52 38 90t90 38t90 -38t38 -90v-640q0 -52 -38 -90t-90 -38t-90 38t-38 90z" />
+<glyph unicode="&#xf012;" horiz-adv-x="1792" d="M0 -96v192q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM384 -96v320q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-320q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM768 -96v576q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-576 q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM1152 -96v960q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-960q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM1536 -96v1472q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1472q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf013;" d="M0 531v222q0 12 8 23t19 13l186 28q14 46 39 92q-40 57 -107 138q-10 12 -10 24q0 10 9 23q26 36 98.5 107.5t94.5 71.5q13 0 26 -10l138 -107q44 23 91 38q16 136 29 186q7 28 36 28h222q14 0 24.5 -8.5t11.5 -21.5l28 -184q49 -16 90 -37l142 107q9 9 24 9q13 0 25 -10 q129 -119 165 -170q7 -8 7 -22q0 -12 -8 -23q-15 -21 -51 -66.5t-54 -70.5q26 -50 41 -98l183 -28q13 -2 21 -12.5t8 -23.5v-222q0 -12 -8 -23t-20 -13l-185 -28q-19 -54 -39 -91q35 -50 107 -138q10 -12 10 -25t-9 -23q-27 -37 -99 -108t-94 -71q-12 0 -26 9l-138 108 q-44 -23 -91 -38q-16 -136 -29 -186q-7 -28 -36 -28h-222q-14 0 -24.5 8.5t-11.5 21.5l-28 184q-49 16 -90 37l-141 -107q-10 -9 -25 -9q-14 0 -25 11q-126 114 -165 168q-7 10 -7 23q0 12 8 23q15 21 51 66.5t54 70.5q-27 50 -41 99l-183 27q-13 2 -21 12.5t-8 23.5z M512 640q0 -106 75 -181t181 -75t181 75t75 181t-75 181t-181 75t-181 -75t-75 -181z" />
+<glyph unicode="&#xf014;" horiz-adv-x="1408" d="M0 1056v64q0 14 9 23t23 9h309l70 167q15 37 54 63t79 26h320q40 0 79 -26t54 -63l70 -167h309q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-96v-948q0 -83 -47 -143.5t-113 -60.5h-832q-66 0 -113 58.5t-47 141.5v952h-96q-14 0 -23 9t-9 23zM256 76q0 -22 7 -40.5 t14.5 -27t10.5 -8.5h832q3 0 10.5 8.5t14.5 27t7 40.5v948h-896v-948zM384 224v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23zM480 1152h448l-48 117q-7 9 -17 11h-317q-10 -2 -17 -11zM640 224v576q0 14 9 23t23 9h64 q14 0 23 -9t9 -23v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23zM896 224v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf015;" horiz-adv-x="1664" d="M26 636.5q1 13.5 11 21.5l719 599q32 26 76 26t76 -26l244 -204v195q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-408l219 -182q10 -8 11 -21.5t-7 -23.5l-62 -74q-8 -9 -21 -11h-3q-13 0 -21 7l-692 577l-692 -577q-12 -8 -24 -7q-13 2 -21 11l-62 74q-8 10 -7 23.5zM256 64 v480q0 1 0.5 3t0.5 3l575 474l575 -474q1 -2 1 -6v-480q0 -26 -19 -45t-45 -19h-384v384h-256v-384h-384q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf016;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22 v-376z" />
+<glyph unicode="&#xf017;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM512 544v64q0 14 9 23t23 9h224v352q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-448q0 -14 -9 -23t-23 -9h-320q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf018;" horiz-adv-x="1920" d="M50 73q0 54 26 116l417 1044q8 19 26 33t38 14h339q-13 0 -23 -9.5t-11 -22.5l-15 -192q-1 -14 8 -23t22 -9h166q13 0 22 9t8 23l-15 192q-1 13 -11 22.5t-23 9.5h339q20 0 38 -14t26 -33l417 -1044q26 -62 26 -116q0 -73 -46 -73h-704q13 0 22 9.5t8 22.5l-20 256 q-1 13 -11 22.5t-23 9.5h-272q-13 0 -23 -9.5t-11 -22.5l-20 -256q-1 -13 8 -22.5t22 -9.5h-704q-46 0 -46 73zM809 540q-1 -12 8 -20t21 -8h244q12 0 21 8t8 20v4l-24 320q-1 13 -11 22.5t-23 9.5h-186q-13 0 -23 -9.5t-11 -22.5l-24 -320v-4z" />
+<glyph unicode="&#xf019;" horiz-adv-x="1664" d="M0 96v320q0 40 28 68t68 28h465l135 -136q58 -56 136 -56t136 56l136 136h464q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-1472q-40 0 -68 28t-28 68zM325 985q17 39 59 39h256v448q0 26 19 45t45 19h256q26 0 45 -19t19 -45v-448h256q42 0 59 -39q17 -41 -14 -70 l-448 -448q-18 -19 -45 -19t-45 19l-448 448q-31 29 -14 70zM1152 192q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM1408 192q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf01a;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM418 620q8 20 30 20h192v352q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-352h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-11 -9 -23 -9t-23 9l-320 320q-15 16 -7 35z" />
+<glyph unicode="&#xf01b;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM416 672q0 12 10 24l319 319q11 9 23 9t23 -9l320 -320q15 -16 7 -35q-8 -20 -30 -20h-192v-352q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v352h-192q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf01c;" d="M0 64v482q0 62 25 123l238 552q10 25 36.5 42t52.5 17h832q26 0 52.5 -17t36.5 -42l238 -552q25 -61 25 -123v-482q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM197 576h316l95 -192h320l95 192h316q-1 3 -2.5 8t-2.5 8l-212 496h-708l-212 -496q-1 -2 -2.5 -8 t-2.5 -8z" />
+<glyph unicode="&#xf01d;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM512 320v640q0 37 32 56q33 18 64 -1l544 -320q32 -18 32 -55t-32 -55l-544 -320q-15 -9 -32 -9q-16 0 -32 8q-32 19 -32 56z" />
+<glyph unicode="&#xf01e;" d="M0 640q0 156 61 298t164 245t245 164t298 61q147 0 284.5 -55.5t244.5 -156.5l130 129q29 31 70 14q39 -17 39 -59v-448q0 -26 -19 -45t-45 -19h-448q-42 0 -59 40q-17 39 14 69l138 138q-148 137 -349 137q-104 0 -198.5 -40.5t-163.5 -109.5t-109.5 -163.5 t-40.5 -198.5t40.5 -198.5t109.5 -163.5t163.5 -109.5t198.5 -40.5q119 0 225 52t179 147q7 10 23 12q14 0 25 -9l137 -138q9 -8 9.5 -20.5t-7.5 -22.5q-109 -132 -264 -204.5t-327 -72.5q-156 0 -298 61t-245 164t-164 245t-61 298z" />
+<glyph unicode="&#xf021;" d="M0 0v448q0 26 19 45t45 19h448q26 0 45 -19t19 -45t-19 -45l-137 -137q71 -66 161 -102t187 -36q134 0 250 65t186 179q11 17 53 117q8 23 30 23h192q13 0 22.5 -9.5t9.5 -22.5q0 -5 -1 -7q-64 -268 -268 -434.5t-478 -166.5q-146 0 -282.5 55t-243.5 157l-129 -129 q-19 -19 -45 -19t-45 19t-19 45zM18 800v7q65 268 270 434.5t480 166.5q146 0 284 -55.5t245 -156.5l130 129q19 19 45 19t45 -19t19 -45v-448q0 -26 -19 -45t-45 -19h-448q-26 0 -45 19t-19 45t19 45l138 138q-148 137 -349 137q-134 0 -250 -65t-186 -179 q-11 -17 -53 -117q-8 -23 -30 -23h-199q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf022;" horiz-adv-x="1792" d="M0 160v1088q0 66 47 113t113 47h1472q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113zM128 160q0 -13 9.5 -22.5t22.5 -9.5h1472q13 0 22.5 9.5t9.5 22.5v832q0 13 -9.5 22.5t-22.5 9.5h-1472q-13 0 -22.5 -9.5t-9.5 -22.5v-832z M256 288v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 544v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5z M256 800v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 288v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5z M512 544v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5zM512 800v64q0 13 9.5 22.5t22.5 9.5h960q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-13 0 -22.5 9.5t-9.5 22.5z " />
+<glyph unicode="&#xf023;" horiz-adv-x="1152" d="M0 96v576q0 40 28 68t68 28h32v192q0 184 132 316t316 132t316 -132t132 -316v-192h32q40 0 68 -28t28 -68v-576q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68zM320 768h512v192q0 106 -75 181t-181 75t-181 -75t-75 -181v-192z" />
+<glyph unicode="&#xf024;" horiz-adv-x="1792" d="M64 1280q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5q0 -72 -64 -110v-1266q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5v1266q-64 38 -64 110zM320 320v742q0 32 31 55q21 14 79 43q236 120 421 120q107 0 200 -29t219 -88q38 -19 88 -19 q54 0 117.5 21t110 47t88 47t54.5 21q26 0 45 -19t19 -45v-763q0 -25 -12.5 -38.5t-39.5 -27.5q-215 -116 -369 -116q-61 0 -123.5 22t-108.5 48t-115.5 48t-142.5 22q-192 0 -464 -146q-17 -9 -33 -9q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf025;" horiz-adv-x="1664" d="M0 650q0 151 67 291t179 242.5t266 163.5t320 61t320 -61t266 -163.5t179 -242.5t67 -291q0 -166 -60 -314l-20 -49l-185 -33q-22 -83 -90.5 -136.5t-156.5 -53.5v-32q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v576q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-32 q71 0 130 -35.5t93 -95.5l68 12q29 95 29 193q0 148 -88 279t-236.5 209t-315.5 78t-315.5 -78t-236.5 -209t-88 -279q0 -98 29 -193l68 -12q34 60 93 95.5t130 35.5v32q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-576q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v32 q-88 0 -156.5 53.5t-90.5 136.5l-185 33l-20 49q-60 148 -60 314z" />
+<glyph unicode="&#xf026;" horiz-adv-x="768" d="M0 448v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf027;" horiz-adv-x="1152" d="M0 448v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45zM908 464q0 21 12 35.5t29 25t34 23t29 35.5t12 57t-12 57t-29 35.5t-34 23t-29 25t-12 35.5q0 27 19 45.5t45 18.5 q15 0 25 -5q70 -27 112.5 -93t42.5 -142t-42.5 -141.5t-112.5 -93.5q-10 -5 -25 -5q-26 0 -45 18.5t-19 45.5z" />
+<glyph unicode="&#xf028;" horiz-adv-x="1664" d="M0 448v384q0 26 19 45t45 19h262l333 333q19 19 45 19t45 -19t19 -45v-1088q0 -26 -19 -45t-45 -19t-45 19l-333 333h-262q-26 0 -45 19t-19 45zM908 464q0 21 12 35.5t29 25t34 23t29 35.5t12 57t-12 57t-29 35.5t-34 23t-29 25t-12 35.5q0 27 19 45.5t45 18.5 q15 0 25 -5q70 -27 112.5 -93t42.5 -142t-42.5 -141.5t-112.5 -93.5q-10 -5 -25 -5q-26 0 -45 18.5t-19 45.5zM1008 228q0 39 39 59q56 29 76 44q74 54 115.5 135.5t41.5 173.5t-41.5 173.5t-115.5 135.5q-20 15 -76 44q-39 20 -39 59q0 26 19 45t45 19q13 0 26 -5 q140 -59 225 -188.5t85 -282.5t-85 -282.5t-225 -188.5q-13 -5 -25 -5q-27 0 -46 19t-19 45zM1109 -7q0 36 39 59q7 4 22.5 10.5t22.5 10.5q46 25 82 51q123 91 192 227t69 289t-69 289t-192 227q-36 26 -82 51q-7 4 -22.5 10.5t-22.5 10.5q-39 23 -39 59q0 26 19 45t45 19 q13 0 26 -5q211 -91 338 -283.5t127 -422.5t-127 -422.5t-338 -283.5q-13 -5 -26 -5q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf029;" horiz-adv-x="1408" d="M0 0v640h640v-640h-640zM0 768v640h640v-640h-640zM128 129h384v383h-384v-383zM128 896h384v384h-384v-384zM256 256v128h128v-128h-128zM256 1024v128h128v-128h-128zM768 0v640h384v-128h128v128h128v-384h-384v128h-128v-384h-128zM768 768v640h640v-640h-640z M896 896h384v384h-384v-384zM1024 0v128h128v-128h-128zM1024 1024v128h128v-128h-128zM1280 0v128h128v-128h-128z" />
+<glyph unicode="&#xf02a;" horiz-adv-x="1792" d="M0 0v1408h63v-1408h-63zM94 1v1407h32v-1407h-32zM189 1v1407h31v-1407h-31zM346 1v1407h31v-1407h-31zM472 1v1407h62v-1407h-62zM629 1v1407h31v-1407h-31zM692 1v1407h31v-1407h-31zM755 1v1407h31v-1407h-31zM880 1v1407h63v-1407h-63zM1037 1v1407h63v-1407h-63z M1163 1v1407h63v-1407h-63zM1289 1v1407h63v-1407h-63zM1383 1v1407h63v-1407h-63zM1541 1v1407h94v-1407h-94zM1666 1v1407h32v-1407h-32zM1729 0v1408h63v-1408h-63z" />
+<glyph unicode="&#xf02b;" d="M0 864v416q0 52 38 90t90 38h416q53 0 117 -26.5t102 -64.5l715 -714q37 -39 37 -91q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-53 0 -90 37l-715 716q-38 37 -64.5 101t-26.5 117zM192 1088q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5 t-90.5 -37.5t-37.5 -90.5z" />
+<glyph unicode="&#xf02c;" horiz-adv-x="1920" d="M0 864v416q0 52 38 90t90 38h416q53 0 117 -26.5t102 -64.5l715 -714q37 -39 37 -91q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-53 0 -90 37l-715 716q-38 37 -64.5 101t-26.5 117zM192 1088q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5 t-90.5 -37.5t-37.5 -90.5zM704 1408h224q53 0 117 -26.5t102 -64.5l715 -714q37 -39 37 -91q0 -53 -37 -90l-491 -492q-39 -37 -91 -37q-36 0 -59 14t-53 45l470 470q37 37 37 90q0 52 -37 91l-715 714q-38 38 -102 64.5t-117 26.5z" />
+<glyph unicode="&#xf02d;" horiz-adv-x="1664" d="M10 184q0 4 3 27t4 37q1 8 -3 21.5t-3 19.5q2 11 8 21t16.5 23.5t16.5 23.5q23 38 45 91.5t30 91.5q3 10 0.5 30t-0.5 28q3 11 17 28t17 23q21 36 42 92t25 90q1 9 -2.5 32t0.5 28q4 13 22 30.5t22 22.5q19 26 42.5 84.5t27.5 96.5q1 8 -3 25.5t-2 26.5q2 8 9 18t18 23 t17 21q8 12 16.5 30.5t15 35t16 36t19.5 32t26.5 23.5t36 11.5t47.5 -5.5l-1 -3q38 9 51 9h761q74 0 114 -56t18 -130l-274 -906q-36 -119 -71.5 -153.5t-128.5 -34.5h-869q-27 0 -38 -15q-11 -16 -1 -43q24 -70 144 -70h923q29 0 56 15.5t35 41.5l300 987q7 22 5 57 q38 -15 59 -43q40 -57 18 -129l-275 -906q-19 -64 -76.5 -107.5t-122.5 -43.5h-923q-77 0 -148.5 53.5t-99.5 131.5q-24 67 -2 127zM492 800q-4 -13 2 -22.5t20 -9.5h608q13 0 25.5 9.5t16.5 22.5l21 64q4 13 -2 22.5t-20 9.5h-608q-13 0 -25.5 -9.5t-16.5 -22.5zM575 1056 q-4 -13 2 -22.5t20 -9.5h608q13 0 25.5 9.5t16.5 22.5l21 64q4 13 -2 22.5t-20 9.5h-608q-13 0 -25.5 -9.5t-16.5 -22.5z" />
+<glyph unicode="&#xf02e;" horiz-adv-x="1280" d="M0 7v1289q0 34 19.5 62t52.5 41q21 9 44 9h1048q23 0 44 -9q33 -13 52.5 -41t19.5 -62v-1289q0 -34 -19.5 -62t-52.5 -41q-19 -8 -44 -8q-48 0 -83 32l-441 424l-441 -424q-36 -33 -83 -33q-23 0 -44 9q-33 13 -52.5 41t-19.5 62z" />
+<glyph unicode="&#xf02f;" horiz-adv-x="1664" d="M0 160v416q0 79 56.5 135.5t135.5 56.5h64v544q0 40 28 68t68 28h672q40 0 88 -20t76 -48l152 -152q28 -28 48 -76t20 -88v-256h64q79 0 135.5 -56.5t56.5 -135.5v-416q0 -13 -9.5 -22.5t-22.5 -9.5h-224v-160q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v160h-224 q-13 0 -22.5 9.5t-9.5 22.5zM384 0h896v256h-896v-256zM384 640h896v384h-160q-40 0 -68 28t-28 68v160h-640v-640zM1408 576q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf030;" horiz-adv-x="1920" d="M0 128v896q0 106 75 181t181 75h224l51 136q19 49 69.5 84.5t103.5 35.5h512q53 0 103.5 -35.5t69.5 -84.5l51 -136h224q106 0 181 -75t75 -181v-896q0 -106 -75 -181t-181 -75h-1408q-106 0 -181 75t-75 181zM512 576q0 -185 131.5 -316.5t316.5 -131.5t316.5 131.5 t131.5 316.5t-131.5 316.5t-316.5 131.5t-316.5 -131.5t-131.5 -316.5zM672 576q0 119 84.5 203.5t203.5 84.5t203.5 -84.5t84.5 -203.5t-84.5 -203.5t-203.5 -84.5t-203.5 84.5t-84.5 203.5z" />
+<glyph unicode="&#xf031;" horiz-adv-x="1664" d="M0 -128l2 79q23 7 56 12.5t57 10.5t49.5 14.5t44.5 29t31 50.5l237 616l280 724h75h53q8 -14 11 -21l205 -480q33 -78 106 -257.5t114 -274.5q15 -34 58 -144.5t72 -168.5q20 -45 35 -57q19 -15 88 -29.5t84 -20.5q6 -38 6 -57q0 -4 -0.5 -13t-0.5 -13q-63 0 -190 8 t-191 8q-76 0 -215 -7t-178 -8q0 43 4 78l131 28q1 0 12.5 2.5t15.5 3.5t14.5 4.5t15 6.5t11 8t9 11t2.5 14q0 16 -31 96.5t-72 177.5t-42 100l-450 2q-26 -58 -76.5 -195.5t-50.5 -162.5q0 -22 14 -37.5t43.5 -24.5t48.5 -13.5t57 -8.5t41 -4q1 -19 1 -58q0 -9 -2 -27 q-58 0 -174.5 10t-174.5 10q-8 0 -26.5 -4t-21.5 -4q-80 -14 -188 -14zM555 527q33 0 136.5 -2t160.5 -2q19 0 57 2q-87 253 -184 452z" />
+<glyph unicode="&#xf032;" horiz-adv-x="1408" d="M0 -128l2 94q15 4 85 16t106 27q7 12 12.5 27t8.5 33.5t5.5 32.5t3 37.5t0.5 34v35.5v30q0 982 -22 1025q-4 8 -22 14.5t-44.5 11t-49.5 7t-48.5 4.5t-30.5 3l-4 83q98 2 340 11.5t373 9.5q23 0 68.5 -0.5t67.5 -0.5q70 0 136.5 -13t128.5 -42t108 -71t74 -104.5 t28 -137.5q0 -52 -16.5 -95.5t-39 -72t-64.5 -57.5t-73 -45t-84 -40q154 -35 256.5 -134t102.5 -248q0 -100 -35 -179.5t-93.5 -130.5t-138 -85.5t-163.5 -48.5t-176 -14q-44 0 -132 3t-132 3q-106 0 -307 -11t-231 -12zM533 1292q0 -50 4 -151t4 -152q0 -27 -0.5 -80 t-0.5 -79q0 -46 1 -69q42 -7 109 -7q82 0 143 13t110 44.5t74.5 89.5t25.5 142q0 70 -29 122.5t-79 82t-108 43.5t-124 14q-50 0 -130 -13zM538.5 165q0.5 -37 4.5 -83.5t12 -66.5q74 -32 140 -32q376 0 376 335q0 114 -41 180q-27 44 -61.5 74t-67.5 46.5t-80.5 25 t-84 10.5t-94.5 2q-73 0 -101 -10q0 -53 -0.5 -159t-0.5 -158q0 -8 -1 -67.5t-0.5 -96.5z" />
+<glyph unicode="&#xf033;" horiz-adv-x="1024" d="M0 -126l17 85q6 2 81.5 21.5t111.5 37.5q28 35 41 101q1 7 62 289t114 543.5t52 296.5v25q-24 13 -54.5 18.5t-69.5 8t-58 5.5l19 103q33 -2 120 -6.5t149.5 -7t120.5 -2.5q48 0 98.5 2.5t121 7t98.5 6.5q-5 -39 -19 -89q-30 -10 -101.5 -28.5t-108.5 -33.5 q-8 -19 -14 -42.5t-9 -40t-7.5 -45.5t-6.5 -42q-27 -148 -87.5 -419.5t-77.5 -355.5q-2 -9 -13 -58t-20 -90t-16 -83.5t-6 -57.5l1 -18q17 -4 185 -31q-3 -44 -16 -99q-11 0 -32.5 -1.5t-32.5 -1.5q-29 0 -87 10t-86 10q-138 2 -206 2q-51 0 -143 -9t-121 -11z" />
+<glyph unicode="&#xf034;" horiz-adv-x="1792" d="M0 1023v383l81 1l54 -27q12 -5 211 -5q44 0 132 2t132 2q36 0 107.5 -0.5t107.5 -0.5h293q6 0 21 -0.5t20.5 0t16 3t17.5 9t15 17.5l42 1q4 0 14 -0.5t14 -0.5q2 -112 2 -336q0 -80 -5 -109q-39 -14 -68 -18q-25 44 -54 128q-3 9 -11 48t-14.5 73.5t-7.5 35.5 q-6 8 -12 12.5t-15.5 6t-13 2.5t-18 0.5t-16.5 -0.5q-17 0 -66.5 0.5t-74.5 0.5t-64 -2t-71 -6q-9 -81 -8 -136q0 -94 2 -388t2 -455q0 -16 -2.5 -71.5t0 -91.5t12.5 -69q40 -21 124 -42.5t120 -37.5q5 -40 5 -50q0 -14 -3 -29l-34 -1q-76 -2 -218 8t-207 10q-50 0 -151 -9 t-152 -9q-3 51 -3 52v9q17 27 61.5 43t98.5 29t78 27q19 42 19 383q0 101 -3 303t-3 303v117q0 2 0.5 15.5t0.5 25t-1 25.5t-3 24t-5 14q-11 12 -162 12q-33 0 -93 -12t-80 -26q-19 -13 -34 -72.5t-31.5 -111t-42.5 -53.5q-42 26 -56 44zM1414 109.5q9 18.5 42 18.5h80v1024 h-80q-33 0 -42 18.5t11 44.5l126 162q20 26 49 26t49 -26l126 -162q20 -26 11 -44.5t-42 -18.5h-80v-1024h80q33 0 42 -18.5t-11 -44.5l-126 -162q-20 -26 -49 -26t-49 26l-126 162q-20 26 -11 44.5z" />
+<glyph unicode="&#xf035;" d="M0 1023v383l81 1l54 -27q12 -5 211 -5q44 0 132 2t132 2q70 0 246.5 1t304.5 0.5t247 -4.5q33 -1 56 31l42 1q4 0 14 -0.5t14 -0.5q2 -112 2 -336q0 -80 -5 -109q-39 -14 -68 -18q-25 44 -54 128q-3 9 -11 47.5t-15 73.5t-7 36q-10 13 -27 19q-5 2 -66 2q-30 0 -93 1 t-103 1t-94 -2t-96 -7q-9 -81 -8 -136l1 -152v52q0 -55 1 -154t1.5 -180t0.5 -153q0 -16 -2.5 -71.5t0 -91.5t12.5 -69q40 -21 124 -42.5t120 -37.5q5 -40 5 -50q0 -14 -3 -29l-34 -1q-76 -2 -218 8t-207 10q-50 0 -151 -9t-152 -9q-3 51 -3 52v9q17 27 61.5 43t98.5 29 t78 27q7 16 11.5 74t6 145.5t1.5 155t-0.5 153.5t-0.5 89q0 7 -2.5 21.5t-2.5 22.5q0 7 0.5 44t1 73t0 76.5t-3 67.5t-6.5 32q-11 12 -162 12q-41 0 -163 -13.5t-138 -24.5q-19 -12 -34 -71.5t-31.5 -111.5t-42.5 -54q-42 26 -56 44zM5 -64q0 28 26 49q4 3 36 30t59.5 49 t57.5 41.5t42 19.5q13 0 20.5 -10.5t10 -28.5t2.5 -33.5t-1.5 -33t-1.5 -19.5h1024q0 2 -1.5 19.5t-1.5 33t2.5 33.5t10 28.5t20.5 10.5q12 0 42 -19.5t57.5 -41.5t59.5 -49t36 -30q26 -21 26 -49t-26 -49q-4 -3 -36 -30t-59.5 -49t-57.5 -41.5t-42 -19.5q-13 0 -20.5 10.5 t-10 28.5t-2.5 33.5t1.5 33t1.5 19.5h-1024q0 -2 1.5 -19.5t1.5 -33t-2.5 -33.5t-10 -28.5t-20.5 -10.5q-12 0 -42 19.5t-57.5 41.5t-59.5 49t-36 30q-26 21 -26 49z" />
+<glyph unicode="&#xf036;" horiz-adv-x="1792" d="M0 64v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 448v128q0 26 19 45t45 19h1280q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45zM0 832v128q0 26 19 45t45 19h1536 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1536q-26 0 -45 19t-19 45zM0 1216v128q0 26 19 45t45 19h1152q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1152q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf037;" horiz-adv-x="1792" d="M0 64v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM128 832v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM384 448v128q0 26 19 45t45 19h896 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-896q-26 0 -45 19t-19 45zM512 1216v128q0 26 19 45t45 19h640q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-640q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf038;" horiz-adv-x="1792" d="M0 64v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM128 832v128q0 26 19 45t45 19h1536q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1536q-26 0 -45 19t-19 45zM384 448v128q0 26 19 45t45 19h1280 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45zM512 1216v128q0 26 19 45t45 19h1152q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1152q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf039;" horiz-adv-x="1792" d="M0 64v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 448v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 832v128q0 26 19 45t45 19h1664 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 1216v128q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf03a;" horiz-adv-x="1792" d="M0 32v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5zM0 416v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5 t-9.5 22.5zM0 800v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192q-13 0 -22.5 9.5t-9.5 22.5zM0 1184v192q0 13 9.5 22.5t22.5 9.5h192q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-192 q-13 0 -22.5 9.5t-9.5 22.5zM384 32v192q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5zM384 416v192q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5 t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5zM384 800v192q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5zM384 1184v192q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5v-192 q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf03b;" horiz-adv-x="1792" d="M0 32v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5zM0 1184v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5 t-9.5 22.5zM32 704q0 14 9 23l288 288q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5v-576q0 -13 -9.5 -22.5t-22.5 -9.5q-14 0 -23 9l-288 288q-9 9 -9 23zM640 416v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088 q-13 0 -22.5 9.5t-9.5 22.5zM640 800v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf03c;" horiz-adv-x="1792" d="M0 32v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5zM0 416v576q0 13 9.5 22.5t22.5 9.5q14 0 23 -9l288 -288q9 -9 9 -23t-9 -23l-288 -288q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5z M0 1184v192q0 13 9.5 22.5t22.5 9.5h1728q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1728q-13 0 -22.5 9.5t-9.5 22.5zM640 416v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5 t-9.5 22.5zM640 800v192q0 13 9.5 22.5t22.5 9.5h1088q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1088q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf03d;" horiz-adv-x="1792" d="M0 288v704q0 119 84.5 203.5t203.5 84.5h704q119 0 203.5 -84.5t84.5 -203.5v-165l403 402q18 19 45 19q12 0 25 -5q39 -17 39 -59v-1088q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-403 403v-166q0 -119 -84.5 -203.5t-203.5 -84.5h-704q-119 0 -203.5 84.5 t-84.5 203.5z" />
+<glyph unicode="&#xf03e;" horiz-adv-x="1920" d="M0 32v1216q0 66 47 113t113 47h1600q66 0 113 -47t47 -113v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113zM128 32q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5v1216q0 13 -9.5 22.5t-22.5 9.5h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-1216z M256 128v192l320 320l160 -160l512 512l416 -416v-448h-1408zM256 960q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136z" />
+<glyph unicode="&#xf040;" d="M0 -128v416l832 832l416 -416l-832 -832h-416zM128 128h128v-128h107l91 91l-235 235l-91 -91v-107zM298 384q0 -22 22 -22q10 0 17 7l542 542q7 7 7 17q0 22 -22 22q-10 0 -17 -7l-542 -542q-7 -7 -7 -17zM896 1184l166 165q36 38 90 38q53 0 91 -38l235 -234 q37 -39 37 -91q0 -53 -37 -90l-166 -166z" />
+<glyph unicode="&#xf041;" horiz-adv-x="1024" d="M0 896q0 212 150 362t362 150t362 -150t150 -362q0 -109 -33 -179l-364 -774q-16 -33 -47.5 -52t-67.5 -19t-67.5 19t-46.5 52l-365 774q-33 70 -33 179zM256 896q0 -106 75 -181t181 -75t181 75t75 181t-75 181t-181 75t-181 -75t-75 -181z" />
+<glyph unicode="&#xf042;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73v1088q-148 0 -273 -73t-198 -198t-73 -273z" />
+<glyph unicode="&#xf043;" horiz-adv-x="1024" d="M0 512q0 145 81 275q6 9 62.5 90.5t101 151t99.5 178t83 201.5q9 30 34 47t51 17t51.5 -17t33.5 -47q28 -93 83 -201.5t99.5 -178t101 -151t62.5 -90.5q81 -127 81 -275q0 -212 -150 -362t-362 -150t-362 150t-150 362zM256 384q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5 t37.5 90.5q0 36 -20 69q-1 1 -15.5 22.5t-25.5 38t-25 44t-21 50.5q-4 16 -21 16t-21 -16q-7 -23 -21 -50.5t-25 -44t-25.5 -38t-15.5 -22.5q-20 -33 -20 -69z" />
+<glyph unicode="&#xf044;" horiz-adv-x="1792" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h832q63 0 117 -25q15 -7 18 -23q3 -17 -9 -29l-49 -49q-14 -14 -32 -8q-23 6 -45 6h-832q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v126q0 13 9 22l64 64q15 15 35 7t20 -29v-190 q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM640 256v288l672 672l288 -288l-672 -672h-288zM736 448h96v-96h56l116 116l-152 152l-116 -116v-56zM944 688q16 -16 33 1l350 350q17 17 1 33t-33 -1l-350 -350q-17 -17 -1 -33zM1376 1280l92 92 q28 28 68 28t68 -28l152 -152q28 -28 28 -68t-28 -68l-92 -92z" />
+<glyph unicode="&#xf045;" horiz-adv-x="1664" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h255q13 0 22.5 -9.5t9.5 -22.5q0 -27 -26 -32q-77 -26 -133 -60q-10 -4 -16 -4h-112q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v214q0 19 18 29q28 13 54 37q16 16 35 8q21 -9 21 -29v-259 q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM256 704q0 49 3.5 91t14 90t28 88t47 81.5t68.5 74t94.5 61.5t124.5 48.5t159.5 30.5t196.5 11h160v192q0 42 39 59q13 5 25 5q26 0 45 -19l384 -384q19 -19 19 -45t-19 -45l-384 -384 q-18 -19 -45 -19q-12 0 -25 5q-39 17 -39 59v192h-160q-323 0 -438 -131q-119 -137 -74 -473q3 -23 -20 -34q-8 -2 -12 -2q-16 0 -26 13q-10 14 -21 31t-39.5 68.5t-49.5 99.5t-38.5 114t-17.5 122z" />
+<glyph unicode="&#xf046;" horiz-adv-x="1664" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h832q63 0 117 -25q15 -7 18 -23q3 -17 -9 -29l-49 -49q-10 -10 -23 -10q-3 0 -9 2q-23 6 -45 6h-832q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v254q0 13 9 22l64 64q10 10 23 10q6 0 12 -3 q20 -8 20 -29v-318q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM257 768q0 33 24 57l110 110q24 24 57 24t57 -24l263 -263l647 647q24 24 57 24t57 -24l110 -110q24 -24 24 -57t-24 -57l-814 -814q-24 -24 -57 -24t-57 24l-430 430 q-24 24 -24 57z" />
+<glyph unicode="&#xf047;" horiz-adv-x="1792" d="M0 640q0 26 19 45l256 256q19 19 45 19t45 -19t19 -45v-128h384v384h-128q-26 0 -45 19t-19 45t19 45l256 256q19 19 45 19t45 -19l256 -256q19 -19 19 -45t-19 -45t-45 -19h-128v-384h384v128q0 26 19 45t45 19t45 -19l256 -256q19 -19 19 -45t-19 -45l-256 -256 q-19 -19 -45 -19t-45 19t-19 45v128h-384v-384h128q26 0 45 -19t19 -45t-19 -45l-256 -256q-19 -19 -45 -19t-45 19l-256 256q-19 19 -19 45t19 45t45 19h128v384h-384v-128q0 -26 -19 -45t-45 -19t-45 19l-256 256q-19 19 -19 45z" />
+<glyph unicode="&#xf048;" horiz-adv-x="1024" d="M0 -64v1408q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-678q4 11 13 19l710 710q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-678q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf049;" horiz-adv-x="1792" d="M0 -64v1408q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-678q4 11 13 19l710 710q19 19 32 13t13 -32v-710q4 11 13 19l710 710q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-710q0 -26 -13 -32t-32 13l-710 710q-9 9 -13 19v-678q0 -26 -19 -45 t-45 -19h-128q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf04a;" horiz-adv-x="1664" d="M122 640q0 26 19 45l710 710q19 19 32 13t13 -32v-710q5 11 13 19l710 710q19 19 32 13t13 -32v-1472q0 -26 -13 -32t-32 13l-710 710q-8 9 -13 19v-710q0 -26 -13 -32t-32 13l-710 710q-19 19 -19 45z" />
+<glyph unicode="&#xf04b;" horiz-adv-x="1408" d="M0 -96v1472q0 26 16.5 36t39.5 -3l1328 -738q23 -13 23 -31t-23 -31l-1328 -738q-23 -13 -39.5 -3t-16.5 36z" />
+<glyph unicode="&#xf04c;" d="M0 -64v1408q0 26 19 45t45 19h512q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45zM896 -64v1408q0 26 19 45t45 19h512q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf04d;" d="M0 -64v1408q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf04e;" horiz-adv-x="1664" d="M0 -96v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v710q0 26 13 32t32 -13l710 -710q19 -19 19 -45t-19 -45l-710 -710q-19 -19 -32 -13t-13 32v710q-5 -10 -13 -19l-710 -710q-19 -19 -32 -13t-13 32z" />
+<glyph unicode="&#xf050;" horiz-adv-x="1792" d="M0 -96v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v710q0 26 13 32t32 -13l710 -710q8 -8 13 -19v678q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v678q-5 -10 -13 -19l-710 -710q-19 -19 -32 -13t-13 32v710 q-5 -10 -13 -19l-710 -710q-19 -19 -32 -13t-13 32z" />
+<glyph unicode="&#xf051;" horiz-adv-x="1024" d="M0 -96v1472q0 26 13 32t32 -13l710 -710q8 -8 13 -19v678q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v678q-5 -10 -13 -19l-710 -710q-19 -19 -32 -13t-13 32z" />
+<glyph unicode="&#xf052;" horiz-adv-x="1538" d="M1 64v256q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM1 525q-6 13 13 32l710 710q19 19 45 19t45 -19l710 -710q19 -19 13 -32t-32 -13h-1472q-26 0 -32 13z" />
+<glyph unicode="&#xf053;" horiz-adv-x="1280" d="M154 704q0 26 19 45l742 742q19 19 45 19t45 -19l166 -166q19 -19 19 -45t-19 -45l-531 -531l531 -531q19 -19 19 -45t-19 -45l-166 -166q-19 -19 -45 -19t-45 19l-742 742q-19 19 -19 45z" />
+<glyph unicode="&#xf054;" horiz-adv-x="1280" d="M90 128q0 26 19 45l531 531l-531 531q-19 19 -19 45t19 45l166 166q19 19 45 19t45 -19l742 -742q19 -19 19 -45t-19 -45l-742 -742q-19 -19 -45 -19t-45 19l-166 166q-19 19 -19 45z" />
+<glyph unicode="&#xf055;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM320 576q0 -26 19 -45t45 -19h256v-256q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v256h256q26 0 45 19 t19 45v128q0 26 -19 45t-45 19h-256v256q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-256h-256q-26 0 -45 -19t-19 -45v-128z" />
+<glyph unicode="&#xf056;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM320 576q0 -26 19 -45t45 -19h768q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-768q-26 0 -45 -19 t-19 -45v-128z" />
+<glyph unicode="&#xf057;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM387 414q0 -27 19 -46l90 -90q19 -19 46 -19q26 0 45 19l181 181l181 -181q19 -19 45 -19q27 0 46 19 l90 90q19 19 19 46q0 26 -19 45l-181 181l181 181q19 19 19 45q0 27 -19 46l-90 90q-19 19 -46 19q-26 0 -45 -19l-181 -181l-181 181q-19 19 -45 19q-27 0 -46 -19l-90 -90q-19 -19 -19 -46q0 -26 19 -45l181 -181l-181 -181q-19 -19 -19 -45z" />
+<glyph unicode="&#xf058;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM252 621q0 -27 18 -45l362 -362q19 -19 45 -19q27 0 46 19l543 543q18 18 18 45q0 28 -18 46l-91 90 q-19 19 -45 19t-45 -19l-408 -407l-226 226q-19 19 -45 19t-45 -19l-91 -90q-18 -18 -18 -46z" />
+<glyph unicode="&#xf059;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM417 939q-15 -24 8 -42l132 -100q7 -6 19 -6q16 0 25 12q53 68 86 92q34 24 86 24q48 0 85.5 -26 t37.5 -59q0 -38 -20 -61t-68 -45q-63 -28 -115.5 -86.5t-52.5 -125.5v-36q0 -14 9 -23t23 -9h192q14 0 23 9t9 23q0 19 21.5 49.5t54.5 49.5q32 18 49 28.5t46 35t44.5 48t28 60.5t12.5 81q0 88 -55.5 163t-138.5 116t-170 41q-243 0 -371 -213zM640 160q0 -14 9 -23t23 -9 h192q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-192z" />
+<glyph unicode="&#xf05a;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM512 160q0 -14 9 -23t23 -9h448q14 0 23 9t9 23v160q0 14 -9 23t-23 9h-96v512q0 14 -9 23t-23 9h-320 q-14 0 -23 -9t-9 -23v-160q0 -14 9 -23t23 -9h96v-320h-96q-14 0 -23 -9t-9 -23v-160zM640 1056q0 -14 9 -23t23 -9h192q14 0 23 9t9 23v160q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-160z" />
+<glyph unicode="&#xf05b;" d="M0 576v128q0 26 19 45t45 19h143q37 161 154.5 278.5t278.5 154.5v143q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-143q161 -37 278.5 -154.5t154.5 -278.5h143q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-143q-37 -161 -154.5 -278.5t-278.5 -154.5v-143 q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v143q-161 37 -278.5 154.5t-154.5 278.5h-143q-26 0 -45 19t-19 45zM339 512q32 -108 112.5 -188.5t188.5 -112.5v109q0 26 19 45t45 19h128q26 0 45 -19t19 -45v-109q108 32 188.5 112.5t112.5 188.5h-109q-26 0 -45 19 t-19 45v128q0 26 19 45t45 19h109q-32 108 -112.5 188.5t-188.5 112.5v-109q0 -26 -19 -45t-45 -19h-128q-26 0 -45 19t-19 45v109q-108 -32 -188.5 -112.5t-112.5 -188.5h109q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-109z" />
+<glyph unicode="&#xf05c;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM429 480q0 13 10 23l137 137l-137 137q-10 10 -10 23t10 23l146 146q10 10 23 10t23 -10l137 -137l137 137q10 10 23 10t23 -10l146 -146q10 -10 10 -23t-10 -23l-137 -137l137 -137q10 -10 10 -23t-10 -23l-146 -146q-10 -10 -23 -10t-23 10l-137 137 l-137 -137q-10 -10 -23 -10t-23 10l-146 146q-10 10 -10 23z" />
+<glyph unicode="&#xf05d;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM346 640q0 26 19 45l102 102q19 19 45 19t45 -19l147 -147l275 275q19 19 45 19t45 -19l102 -102q19 -19 19 -45t-19 -45l-422 -422q-19 -19 -45 -19t-45 19l-294 294q-19 19 -19 45z" />
+<glyph unicode="&#xf05e;" d="M0 643q0 157 61 299.5t163.5 245.5t245 164t298.5 61t298.5 -61t245 -164t163.5 -245.5t61 -299.5t-61 -300t-163.5 -246t-245 -164t-298.5 -61t-298.5 61t-245 164t-163.5 246t-61 300zM224 643q0 -162 89 -299l755 754q-135 91 -300 91q-148 0 -273 -73t-198 -199 t-73 -274zM471 185q137 -89 297 -89q111 0 211.5 43.5t173.5 116.5t116 174.5t43 212.5q0 161 -87 295z" />
+<glyph unicode="&#xf060;" d="M64 576q0 52 37 91l651 650q38 38 91 38q52 0 90 -38l75 -74q38 -38 38 -91t-38 -91l-293 -293h704q52 0 84.5 -37.5t32.5 -90.5v-128q0 -53 -32.5 -90.5t-84.5 -37.5h-704l293 -294q38 -36 38 -90t-38 -90l-75 -76q-37 -37 -90 -37q-52 0 -91 37l-651 652q-37 37 -37 90 z" />
+<glyph unicode="&#xf061;" d="M0 512v128q0 53 32.5 90.5t84.5 37.5h704l-293 294q-38 36 -38 90t38 90l75 75q38 38 90 38q53 0 91 -38l651 -651q37 -35 37 -90q0 -54 -37 -91l-651 -651q-39 -37 -91 -37q-51 0 -90 37l-75 75q-38 38 -38 91t38 91l293 293h-704q-52 0 -84.5 37.5t-32.5 90.5z" />
+<glyph unicode="&#xf062;" horiz-adv-x="1664" d="M53 565q0 53 38 91l651 651q35 37 90 37q54 0 91 -37l651 -651q37 -39 37 -91q0 -51 -37 -90l-75 -75q-38 -38 -91 -38q-54 0 -90 38l-294 293v-704q0 -52 -37.5 -84.5t-90.5 -32.5h-128q-53 0 -90.5 32.5t-37.5 84.5v704l-294 -293q-36 -38 -90 -38t-90 38l-75 75 q-38 38 -38 90z" />
+<glyph unicode="&#xf063;" horiz-adv-x="1664" d="M53 704q0 53 38 91l74 75q39 37 91 37q53 0 90 -37l294 -294v704q0 52 38 90t90 38h128q52 0 90 -38t38 -90v-704l294 294q37 37 90 37q52 0 91 -37l75 -75q37 -39 37 -91q0 -53 -37 -90l-651 -652q-39 -37 -91 -37q-53 0 -90 37l-651 652q-38 36 -38 90z" />
+<glyph unicode="&#xf064;" horiz-adv-x="1792" d="M0 416q0 199 53 333q162 403 875 403h224v256q0 26 19 45t45 19t45 -19l512 -512q19 -19 19 -45t-19 -45l-512 -512q-19 -19 -45 -19t-45 19t-19 45v256h-224q-98 0 -175.5 -6t-154 -21.5t-133 -42.5t-105.5 -69.5t-80 -101t-48.5 -138.5t-17.5 -181q0 -55 5 -123 q0 -6 2.5 -23.5t2.5 -26.5q0 -15 -8.5 -25t-23.5 -10q-16 0 -28 17q-7 9 -13 22t-13.5 30t-10.5 24q-127 285 -127 451z" />
+<glyph unicode="&#xf065;" d="M0 -64v448q0 26 19 45t45 19t45 -19l144 -144l332 332q10 10 23 10t23 -10l114 -114q10 -10 10 -23t-10 -23l-332 -332l144 -144q19 -19 19 -45t-19 -45t-45 -19h-448q-26 0 -45 19t-19 45zM781 800q0 13 10 23l332 332l-144 144q-19 19 -19 45t19 45t45 19h448 q26 0 45 -19t19 -45v-448q0 -26 -19 -45t-45 -19t-45 19l-144 144l-332 -332q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23z" />
+<glyph unicode="&#xf066;" d="M13 32q0 13 10 23l332 332l-144 144q-19 19 -19 45t19 45t45 19h448q26 0 45 -19t19 -45v-448q0 -26 -19 -45t-45 -19t-45 19l-144 144l-332 -332q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23zM768 704v448q0 26 19 45t45 19t45 -19l144 -144l332 332q10 10 23 10 t23 -10l114 -114q10 -10 10 -23t-10 -23l-332 -332l144 -144q19 -19 19 -45t-19 -45t-45 -19h-448q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf067;" horiz-adv-x="1408" d="M0 608v192q0 40 28 68t68 28h416v416q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-416h416q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-416v-416q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v416h-416q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf068;" horiz-adv-x="1408" d="M0 608v192q0 40 28 68t68 28h1216q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-1216q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf069;" horiz-adv-x="1664" d="M122.5 408.5q13.5 51.5 59.5 77.5l266 154l-266 154q-46 26 -59.5 77.5t12.5 97.5l64 110q26 46 77.5 59.5t97.5 -12.5l266 -153v307q0 52 38 90t90 38h128q52 0 90 -38t38 -90v-307l266 153q46 26 97.5 12.5t77.5 -59.5l64 -110q26 -46 12.5 -97.5t-59.5 -77.5 l-266 -154l266 -154q46 -26 59.5 -77.5t-12.5 -97.5l-64 -110q-26 -46 -77.5 -59.5t-97.5 12.5l-266 153v-307q0 -52 -38 -90t-90 -38h-128q-52 0 -90 38t-38 90v307l-266 -153q-46 -26 -97.5 -12.5t-77.5 59.5l-64 110q-26 46 -12.5 97.5z" />
+<glyph unicode="&#xf06a;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM624 1126l17 -621q0 -10 10 -17.5t24 -7.5h185q14 0 23.5 7.5t10.5 17.5l18 621q0 12 -10 18 q-10 8 -24 8h-220q-14 0 -24 -8q-10 -6 -10 -18zM640 161q0 -13 10 -23t23 -10h192q13 0 22 9.5t9 23.5v190q0 14 -9 23.5t-22 9.5h-192q-13 0 -23 -10t-10 -23v-190z" />
+<glyph unicode="&#xf06b;" d="M0 544v320q0 14 9 23t23 9h440q-93 0 -158.5 65.5t-65.5 158.5t65.5 158.5t158.5 65.5q107 0 168 -77l128 -165l128 165q61 77 168 77q93 0 158.5 -65.5t65.5 -158.5t-65.5 -158.5t-158.5 -65.5h440q14 0 23 -9t9 -23v-320q0 -14 -9 -23t-23 -9h-96v-416q0 -40 -28 -68 t-68 -28h-1088q-40 0 -68 28t-28 68v416h-96q-14 0 -23 9t-9 23zM376 1120q0 -40 28 -68t68 -28h195l-126 161q-26 31 -69 31q-40 0 -68 -28t-28 -68zM608 180q0 -25 18 -38.5t46 -13.5h192q28 0 46 13.5t18 38.5v56v468v192h-320v-192v-468v-56zM870 1024h194q40 0 68 28 t28 68t-28 68t-68 28q-43 0 -69 -31z" />
+<glyph unicode="&#xf06c;" horiz-adv-x="1792" d="M0 121q0 35 31 73.5t68 65.5t68 56t31 48q0 4 -14 38t-16 44q-9 51 -9 104q0 115 43.5 220t119 184.5t170.5 139t204 95.5q55 18 145 25.5t179.5 9t178.5 6t163.5 24t113.5 56.5l29.5 29.5t29.5 28t27 20t36.5 16t43.5 4.5q39 0 70.5 -46t47.5 -112t24 -124t8 -96 q0 -95 -20 -193q-46 -224 -184.5 -383t-357.5 -268q-214 -108 -438 -108q-148 0 -286 47q-15 5 -88 42t-96 37q-16 0 -39.5 -32t-45 -70t-52.5 -70t-60 -32q-30 0 -51 11t-31 24t-27 42q-2 4 -6 11t-5.5 10t-3 9.5t-1.5 13.5zM384 448q0 -26 19 -45t45 -19q24 0 45 19 q27 24 74 71t67 66q137 124 268.5 176t313.5 52q26 0 45 19t19 45t-19 45t-45 19q-172 0 -318 -49.5t-259.5 -134t-235.5 -219.5q-19 -21 -19 -45z" />
+<glyph unicode="&#xf06d;" horiz-adv-x="1408" d="M0 -160q0 13 9.5 22.5t22.5 9.5h1344q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-1344q-13 0 -22.5 9.5t-9.5 22.5v64zM256 640q0 78 24.5 144t64 112.5t87.5 88t96 77.5t87.5 72t64 81.5t24.5 96.5q0 94 -66 224l3 -1l-1 1q90 -41 160 -83t138.5 -100 t113.5 -122.5t72.5 -150.5t27.5 -184q0 -78 -24.5 -144t-64 -112.5t-87.5 -88t-96 -77.5t-87.5 -72t-64 -81.5t-24.5 -96.5q0 -96 67 -224l-4 1l1 -1q-90 41 -160 83t-138.5 100t-113.5 122.5t-72.5 150.5t-27.5 184z" />
+<glyph unicode="&#xf06e;" horiz-adv-x="1792" d="M0 576q0 34 20 69q140 229 376.5 368t499.5 139t499.5 -139t376.5 -368q20 -35 20 -69t-20 -69q-140 -230 -376.5 -368.5t-499.5 -138.5t-499.5 139t-376.5 368q-20 35 -20 69zM128 576q133 -205 333.5 -326.5t434.5 -121.5t434.5 121.5t333.5 326.5q-152 236 -381 353 q61 -104 61 -225q0 -185 -131.5 -316.5t-316.5 -131.5t-316.5 131.5t-131.5 316.5q0 121 61 225q-229 -117 -381 -353zM592 704q0 -20 14 -34t34 -14t34 14t14 34q0 86 61 147t147 61q20 0 34 14t14 34t-14 34t-34 14q-125 0 -214.5 -89.5t-89.5 -214.5z" />
+<glyph unicode="&#xf070;" horiz-adv-x="1792" d="M0 576q0 38 20 69q153 235 380 371t496 136q89 0 180 -17l54 97q10 16 28 16q5 0 18 -6t31 -15.5t33 -18.5t31.5 -18.5t19.5 -11.5q16 -10 16 -27q0 -7 -1 -9q-105 -188 -315 -566t-316 -567l-49 -89q-10 -16 -28 -16q-12 0 -134 70q-16 10 -16 28q0 12 44 87 q-143 65 -263.5 173t-208.5 245q-20 31 -20 69zM128 576q167 -258 427 -375l78 141q-87 63 -136 159t-49 203q0 121 61 225q-229 -117 -381 -353zM592 704q0 -20 14 -34t34 -14t34 14t14 34q0 86 61 147t147 61q20 0 34 14t14 34t-14 34t-34 14q-125 0 -214.5 -89.5 t-89.5 -214.5zM896 0l74 132q212 18 392.5 137t301.5 307q-115 179 -282 294l63 112q95 -64 182.5 -153t144.5 -184q20 -34 20 -69t-20 -69q-39 -64 -109 -145q-150 -172 -347.5 -267t-419.5 -95zM1056 286l280 502q8 -45 8 -84q0 -139 -79 -253.5t-209 -164.5z" />
+<glyph unicode="&#xf071;" horiz-adv-x="1792" d="M16 61l768 1408q17 31 47 49t65 18t65 -18t47 -49l768 -1408q35 -63 -2 -126q-17 -29 -46.5 -46t-63.5 -17h-1536q-34 0 -63.5 17t-46.5 46q-37 63 -2 126zM752 992l17 -457q0 -10 10 -16.5t24 -6.5h185q14 0 23.5 6.5t10.5 16.5l18 459q0 12 -10 19q-13 11 -24 11h-220 q-11 0 -24 -11q-10 -7 -10 -21zM768 161q0 -14 9.5 -23.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 23.5v190q0 14 -9.5 23.5t-22.5 9.5h-192q-13 0 -22.5 -9.5t-9.5 -23.5v-190z" />
+<glyph unicode="&#xf072;" horiz-adv-x="1408" d="M0 477q-1 13 9 25l96 97q9 9 23 9q6 0 8 -1l194 -53l259 259l-508 279q-14 8 -17 24q-2 16 9 27l128 128q14 13 30 8l665 -159l160 160q76 76 172 108t148 -12q44 -52 12 -148t-108 -172l-161 -161l160 -696q5 -19 -12 -33l-128 -96q-7 -6 -19 -6q-4 0 -7 1q-15 3 -21 16 l-279 508l-259 -259l53 -194q5 -17 -8 -31l-96 -96q-9 -9 -23 -9h-2q-15 2 -24 13l-189 252l-252 189q-11 7 -13 23z" />
+<glyph unicode="&#xf073;" horiz-adv-x="1664" d="M0 -128v1280q0 52 38 90t90 38h128v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h384v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h128q52 0 90 -38t38 -90v-1280q0 -52 -38 -90t-90 -38h-1408q-52 0 -90 38t-38 90zM128 -128h288v288h-288v-288zM128 224 h288v320h-288v-320zM128 608h288v288h-288v-288zM384 1088q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5v288q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-288zM480 -128h320v288h-320v-288zM480 224h320v320h-320v-320zM480 608h320v288h-320 v-288zM864 -128h320v288h-320v-288zM864 224h320v320h-320v-320zM864 608h320v288h-320v-288zM1152 1088q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5v288q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-288zM1248 -128h288v288h-288v-288z M1248 224h288v320h-288v-320zM1248 608h288v288h-288v-288z" />
+<glyph unicode="&#xf074;" horiz-adv-x="1792" d="M0 160v192q0 14 9 23t23 9h224q48 0 87 15t69 45t51 61.5t45 77.5q32 62 78 171q29 66 49.5 111t54 105t64 100t74 83t90 68.5t106.5 42t128 16.5h256v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23t-9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192 h-256q-48 0 -87 -15t-69 -45t-51 -61.5t-45 -77.5q-32 -62 -78 -171q-29 -66 -49.5 -111t-54 -105t-64 -100t-74 -83t-90 -68.5t-106.5 -42t-128 -16.5h-224q-14 0 -23 9t-9 23zM0 1056v192q0 14 9 23t23 9h224q250 0 410 -225q-60 -92 -137 -273q-22 45 -37 72.5 t-40.5 63.5t-51 56.5t-63 35t-81.5 14.5h-224q-14 0 -23 9t-9 23zM743 353q59 93 136 273q22 -45 37 -72.5t40.5 -63.5t51 -56.5t63 -35t81.5 -14.5h256v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23t-9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192 q-32 0 -85 -0.5t-81 -1t-73 1t-71 5t-64 10.5t-63 18.5t-58 28.5t-59 40t-55 53.5t-56 69.5z" />
+<glyph unicode="&#xf075;" horiz-adv-x="1792" d="M0 640q0 130 71 248.5t191 204.5t286 136.5t348 50.5q244 0 450 -85.5t326 -233t120 -321.5t-120 -321.5t-326 -233t-450 -85.5q-70 0 -145 8q-198 -175 -460 -242q-49 -14 -114 -22q-17 -2 -30.5 9t-17.5 29v1q-3 4 -0.5 12t2 10t4.5 9.5l6 9t7 8.5t8 9q7 8 31 34.5 t34.5 38t31 39.5t32.5 51t27 59t26 76q-157 89 -247.5 220t-90.5 281z" />
+<glyph unicode="&#xf076;" d="M0 576v128q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-128q0 -52 23.5 -90t53.5 -57t71 -30t64 -13t44 -2t44 2t64 13t71 30t53.5 57t23.5 90v128q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-128q0 -201 -98.5 -362t-274 -251.5t-395.5 -90.5t-395.5 90.5t-274 251.5 t-98.5 362zM0 960v384q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-384q0 -26 -19 -45t-45 -19h-384q-26 0 -45 19t-19 45zM1024 960v384q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-384q0 -26 -19 -45t-45 -19h-384q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf077;" horiz-adv-x="1792" d="M90 250.5q0 26.5 19 45.5l742 741q19 19 45 19t45 -19l742 -741q19 -19 19 -45.5t-19 -45.5l-166 -165q-19 -19 -45 -19t-45 19l-531 531l-531 -531q-19 -19 -45 -19t-45 19l-166 165q-19 19 -19 45.5z" />
+<glyph unicode="&#xf078;" horiz-adv-x="1792" d="M90 773.5q0 26.5 19 45.5l166 165q19 19 45 19t45 -19l531 -531l531 531q19 19 45 19t45 -19l166 -165q19 -19 19 -45.5t-19 -45.5l-742 -741q-19 -19 -45 -19t-45 19l-742 741q-19 19 -19 45.5z" />
+<glyph unicode="&#xf079;" horiz-adv-x="1920" d="M0 704q0 24 15 41l320 384q19 22 49 22t49 -22l320 -384q15 -17 15 -41q0 -26 -19 -45t-45 -19h-192v-384h576q16 0 25 -11l160 -192q7 -11 7 -21q0 -13 -9.5 -22.5t-22.5 -9.5h-960q-8 0 -13.5 2t-9 7t-5.5 8t-3 11.5t-1 11.5v13v11v160v416h-192q-26 0 -45 19t-19 45z M640 1120q0 13 9.5 22.5t22.5 9.5h960q8 0 13.5 -2t9 -7t5.5 -8t3 -11.5t1 -11.5v-13v-11v-160v-416h192q26 0 45 -19t19 -45q0 -24 -15 -41l-320 -384q-20 -23 -49 -23t-49 23l-320 384q-15 17 -15 41q0 26 19 45t45 19h192v384h-576q-16 0 -25 12l-160 192q-7 9 -7 20z " />
+<glyph unicode="&#xf07a;" horiz-adv-x="1664" d="M0 1216q0 26 19 45t45 19h256q16 0 28.5 -6.5t20 -15.5t13 -24.5t7.5 -26.5t5.5 -29.5t4.5 -25.5h1201q26 0 45 -19t19 -45v-512q0 -24 -16 -42.5t-41 -21.5l-1044 -122q1 -7 4.5 -21.5t6 -26.5t2.5 -22q0 -16 -24 -64h920q26 0 45 -19t19 -45t-19 -45t-45 -19h-1024 q-26 0 -45 19t-19 45q0 14 11 39.5t29.5 59.5t20.5 38l-177 823h-204q-26 0 -45 19t-19 45zM384 0q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5zM1280 0q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5 t-90.5 -37.5t-90.5 37.5t-37.5 90.5z" />
+<glyph unicode="&#xf07b;" horiz-adv-x="1664" d="M0 224v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h672q92 0 158 -66t66 -158v-704q0 -92 -66 -158t-158 -66h-1216q-92 0 -158 66t-66 158z" />
+<glyph unicode="&#xf07c;" horiz-adv-x="1920" d="M0 224v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h544q92 0 158 -66t66 -158v-160h-832q-94 0 -197 -47.5t-164 -119.5l-337 -396l-5 -6q0 4 -0.5 12.5t-0.5 12.5zM73 56q0 31 31 66l336 396q43 51 120.5 86.5t143.5 35.5h1088q34 0 60.5 -13t26.5 -43 q0 -31 -31 -66l-336 -396q-43 -51 -120.5 -86.5t-143.5 -35.5h-1088q-34 0 -60.5 13t-26.5 43z" />
+<glyph unicode="&#xf07d;" horiz-adv-x="768" d="M64 64q0 26 19 45t45 19h128v1024h-128q-26 0 -45 19t-19 45t19 45l256 256q19 19 45 19t45 -19l256 -256q19 -19 19 -45t-19 -45t-45 -19h-128v-1024h128q26 0 45 -19t19 -45t-19 -45l-256 -256q-19 -19 -45 -19t-45 19l-256 256q-19 19 -19 45z" />
+<glyph unicode="&#xf07e;" horiz-adv-x="1792" d="M0 640q0 26 19 45l256 256q19 19 45 19t45 -19t19 -45v-128h1024v128q0 26 19 45t45 19t45 -19l256 -256q19 -19 19 -45t-19 -45l-256 -256q-19 -19 -45 -19t-45 19t-19 45v128h-1024v-128q0 -26 -19 -45t-45 -19t-45 19l-256 256q-19 19 -19 45z" />
+<glyph unicode="&#xf080;" horiz-adv-x="1920" d="M0 32v1216q0 66 47 113t113 47h1600q66 0 113 -47t47 -113v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113zM128 32q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5v1216q0 13 -9.5 22.5t-22.5 9.5h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-1216z M256 128v384h256v-384h-256zM640 128v896h256v-896h-256zM1024 128v640h256v-640h-256zM1408 128v1024h256v-1024h-256z" />
+<glyph unicode="&#xf081;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 286q148 -94 322 -94q112 0 210 35.5t168 95t120.5 137t75 162t24.5 168.5q0 18 -1 27q63 45 105 109 q-56 -25 -121 -34q68 40 93 117q-65 -38 -134 -51q-61 66 -153 66q-87 0 -148.5 -61.5t-61.5 -148.5q0 -29 5 -48q-129 7 -242 65t-192 155q-29 -50 -29 -106q0 -114 91 -175q-47 1 -100 26v-2q0 -75 50 -133.5t123 -72.5q-29 -8 -51 -8q-13 0 -39 4q21 -63 74.5 -104 t121.5 -42q-116 -90 -261 -90q-26 0 -50 3z" />
+<glyph unicode="&#xf082;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-192v608h203l30 224h-233v143q0 54 28 83t96 29l132 1v207q-96 9 -180 9q-136 0 -218 -80.5t-82 -225.5v-166h-224v-224h224v-608h-544 q-119 0 -203.5 84.5t-84.5 203.5z" />
+<glyph unicode="&#xf083;" horiz-adv-x="1792" d="M0 0v1280q0 53 37.5 90.5t90.5 37.5h1536q53 0 90.5 -37.5t37.5 -90.5v-1280q0 -53 -37.5 -90.5t-90.5 -37.5h-1536q-53 0 -90.5 37.5t-37.5 90.5zM128 0h1536v128h-1536v-128zM128 1024h1536v118v138h-828l-64 -128h-644v-128zM256 1216h384v128h-384v-128zM512 574 q0 -159 112.5 -271.5t271.5 -112.5t271.5 112.5t112.5 271.5t-112.5 271.5t-271.5 112.5t-271.5 -112.5t-112.5 -271.5zM640 574q0 106 75 181t181 75t181 -75t75 -181t-75 -181t-181 -75t-181 75t-75 181zM736 576q0 -14 9 -23t23 -9t23 9t9 23q0 40 28 68t68 28q14 0 23 9 t9 23t-9 23t-23 9q-66 0 -113 -47t-47 -113z" />
+<glyph unicode="&#xf084;" horiz-adv-x="1792" d="M0 752q0 160 95 313t248 248t313 95q163 0 265.5 -102.5t102.5 -265.5q0 -189 -131 -365l355 -355l96 96q-3 3 -26 24.5t-40 38.5t-33 36.5t-16 28.5q0 17 49 66t66 49q13 0 23 -10q6 -6 46 -44.5t82 -79.5t86.5 -86t73 -78t28.5 -41q0 -17 -49 -66t-66 -49 q-9 0 -28.5 16t-36.5 33t-38.5 40t-24.5 26l-96 -96l220 -220q28 -28 28 -68q0 -42 -39 -81t-81 -39q-40 0 -68 28l-671 671q-176 -131 -365 -131q-163 0 -265.5 102.5t-102.5 265.5zM192 768q0 -80 56 -136t136 -56t136 56t56 136q0 42 -19 83q41 -19 83 -19q80 0 136 56 t56 136t-56 136t-136 56t-136 -56t-56 -136q0 -42 19 -83q-41 19 -83 19q-80 0 -136 -56t-56 -136z" />
+<glyph unicode="&#xf085;" horiz-adv-x="1920" d="M0 549v185q0 10 7 19.5t16 10.5l155 24q11 35 32 76q-34 48 -90 115q-7 11 -7 20q0 12 7 20q22 30 82 89t79 59q11 0 21 -7l115 -90q34 18 77 32q11 108 23 154q7 24 30 24h186q11 0 20 -7.5t10 -17.5l23 -153q34 -10 75 -31l118 89q8 7 20 7q11 0 21 -8 q144 -133 144 -160q0 -9 -7 -19q-12 -16 -42 -54t-45 -60q23 -48 34 -82l152 -23q10 -2 17 -10.5t7 -19.5v-185q0 -10 -7 -19.5t-16 -10.5l-155 -24q-11 -35 -32 -76q34 -48 90 -115q7 -10 7 -20q0 -12 -7 -19q-23 -30 -82.5 -89.5t-78.5 -59.5q-11 0 -21 7l-115 90 q-37 -19 -77 -31q-11 -108 -23 -155q-7 -24 -30 -24h-186q-11 0 -20 7.5t-10 17.5l-23 153q-34 10 -75 31l-118 -89q-7 -7 -20 -7q-11 0 -21 8q-144 133 -144 160q0 9 7 19q10 14 41 53t47 61q-23 44 -35 82l-152 24q-10 1 -17 9.5t-7 19.5zM384 640q0 -106 75 -181t181 -75 t181 75t75 181t-75 181t-181 75t-181 -75t-75 -181zM1152 58v140q0 16 149 31q13 29 30 52q-51 113 -51 138q0 4 4 7q4 2 35 20t59 34t30 16q8 0 46 -46.5t52 -67.5q20 2 30 2t30 -2q51 71 92 112l6 2q4 0 124 -70q4 -3 4 -7q0 -25 -51 -138q17 -23 30 -52q149 -15 149 -31 v-140q0 -16 -149 -31q-12 -27 -30 -52q51 -113 51 -138q0 -4 -4 -7q-122 -71 -124 -71q-8 0 -46 47t-52 68q-20 -2 -30 -2t-30 2q-14 -21 -52 -68t-46 -47q-2 0 -124 71q-4 3 -4 7q0 25 51 138q-18 25 -30 52q-149 15 -149 31zM1152 1082v140q0 16 149 31q13 29 30 52 q-51 113 -51 138q0 4 4 7q4 2 35 20t59 34t30 16q8 0 46 -46.5t52 -67.5q20 2 30 2t30 -2q51 71 92 112l6 2q4 0 124 -70q4 -3 4 -7q0 -25 -51 -138q17 -23 30 -52q149 -15 149 -31v-140q0 -16 -149 -31q-12 -27 -30 -52q51 -113 51 -138q0 -4 -4 -7q-122 -71 -124 -71 q-8 0 -46 47t-52 68q-20 -2 -30 -2t-30 2q-14 -21 -52 -68t-46 -47q-2 0 -124 71q-4 3 -4 7q0 25 51 138q-18 25 -30 52q-149 15 -149 31zM1408 128q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5q0 52 -38 90t-90 38t-90 -38t-38 -90zM1408 1152q0 -53 37.5 -90.5 t90.5 -37.5t90.5 37.5t37.5 90.5q0 52 -38 90t-90 38t-90 -38t-38 -90z" />
+<glyph unicode="&#xf086;" horiz-adv-x="1792" d="M0 768q0 139 94 257t256.5 186.5t353.5 68.5t353.5 -68.5t256.5 -186.5t94 -257t-94 -257t-256.5 -186.5t-353.5 -68.5q-86 0 -176 16q-124 -88 -278 -128q-36 -9 -86 -16h-3q-11 0 -20.5 8t-11.5 21q-1 3 -1 6.5t0.5 6.5t2 6l2.5 5t3.5 5.5t4 5t4.5 5t4 4.5q5 6 23 25 t26 29.5t22.5 29t25 38.5t20.5 44q-124 72 -195 177t-71 224zM616 132q58 -4 88 -4q161 0 309 45t264 129q125 92 192 212t67 254q0 77 -23 152q129 -71 204 -178t75 -230q0 -120 -71 -224.5t-195 -176.5q10 -24 20.5 -44t25 -38.5t22.5 -29t26 -29.5t23 -25q1 -1 4 -4.5 t4.5 -5t4 -5t3.5 -5.5l2.5 -5t2 -6t0.5 -6.5t-1 -6.5q-3 -14 -13 -22t-22 -7q-50 7 -86 16q-154 40 -278 128q-90 -16 -176 -16q-271 0 -472 132z" />
+<glyph unicode="&#xf087;" d="M0 128v640q0 53 37.5 90.5t90.5 37.5h274q36 24 137 155q58 75 107 128q24 25 35.5 85.5t30.5 126.5t62 108q39 37 90 37q84 0 151 -32.5t102 -101.5t35 -186q0 -93 -48 -192h176q104 0 180 -76t76 -179q0 -89 -49 -163q9 -33 9 -69q0 -77 -38 -144q3 -21 3 -43 q0 -101 -60 -178q1 -139 -85 -219.5t-227 -80.5h-36h-93q-96 0 -189.5 22.5t-216.5 65.5q-116 40 -138 40h-288q-53 0 -90.5 37.5t-37.5 90.5zM128 192q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM384 128h32q13 0 31.5 -3t33 -6.5t38 -11t35 -11.5 t35.5 -12.5t29 -10.5q211 -73 342 -73h121q192 0 192 167q0 26 -5 56q30 16 47.5 52.5t17.5 73.5t-18 69q53 50 53 119q0 25 -10 55.5t-25 47.5q32 1 53.5 47t21.5 81q0 51 -39 89.5t-89 38.5h-352q0 58 48 159.5t48 160.5q0 98 -32 145t-128 47q-26 -26 -38 -85 t-30.5 -125.5t-59.5 -109.5q-22 -23 -77 -91q-4 -5 -23 -30t-31.5 -41t-34.5 -42.5t-40 -44t-38.5 -35.5t-40 -27t-35.5 -9h-32v-640z" />
+<glyph unicode="&#xf088;" d="M0 512v640q0 53 37.5 90.5t90.5 37.5h288q22 0 138 40q128 44 223 66t200 22h112q140 0 226.5 -79t85.5 -216v-5q60 -77 60 -178q0 -22 -3 -43q38 -67 38 -144q0 -36 -9 -69q49 -74 49 -163q0 -103 -76 -179t-180 -76h-176q48 -99 48 -192q0 -118 -35 -186 q-35 -69 -102 -101.5t-151 -32.5q-51 0 -90 37q-34 33 -54 82t-25.5 90.5t-17.5 84.5t-31 64q-48 50 -107 127q-101 131 -137 155h-274q-53 0 -90.5 37.5t-37.5 90.5zM128 1088q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM384 512h32q16 0 35.5 -9 t40 -27t38.5 -35.5t40 -44t34.5 -42.5t31.5 -41t23 -30q55 -68 77 -91q41 -43 59.5 -109.5t30.5 -125.5t38 -85q96 0 128 47t32 145q0 59 -48 160.5t-48 159.5h352q50 0 89 38.5t39 89.5q0 35 -21.5 81t-53.5 47q15 17 25 47.5t10 55.5q0 69 -53 119q18 32 18 69t-17.5 73.5 t-47.5 52.5q5 30 5 56q0 85 -49 126t-136 41h-128q-131 0 -342 -73q-5 -2 -29 -10.5t-35.5 -12.5t-35 -11.5t-38 -11t-33 -6.5t-31.5 -3h-32v-640z" />
+<glyph unicode="&#xf089;" horiz-adv-x="896" d="M0 889q0 37 56 46l502 73l225 455q19 41 49 41v-1339l-449 -236q-22 -12 -40 -12q-21 0 -31.5 14.5t-10.5 35.5q0 6 2 20l86 500l-364 354q-25 27 -25 48z" />
+<glyph unicode="&#xf08a;" horiz-adv-x="1792" d="M0 940q0 220 127 344t351 124q62 0 126.5 -21.5t120 -58t95.5 -68.5t76 -68q36 36 76 68t95.5 68.5t120 58t126.5 21.5q224 0 351 -124t127 -344q0 -221 -229 -450l-623 -600q-18 -18 -44 -18t-44 18l-624 602q-10 8 -27.5 26t-55.5 65.5t-68 97.5t-53.5 121t-23.5 138z M128 940q0 -168 187 -355l581 -560l580 559q188 188 188 356q0 81 -21.5 143t-55 98.5t-81.5 59.5t-94 31t-98 8t-112 -25.5t-110.5 -64t-86.5 -72t-60 -61.5q-18 -22 -49 -22t-49 22q-24 28 -60 61.5t-86.5 72t-110.5 64t-112 25.5t-98 -8t-94 -31t-81.5 -59.5t-55 -98.5 t-21.5 -143z" />
+<glyph unicode="&#xf08b;" horiz-adv-x="1664" d="M0 288v704q0 119 84.5 203.5t203.5 84.5h320q13 0 22.5 -9.5t9.5 -22.5q0 -4 1 -20t0.5 -26.5t-3 -23.5t-10 -19.5t-20.5 -6.5h-320q-66 0 -113 -47t-47 -113v-704q0 -66 47 -113t113 -47h288h11h13t11.5 -1t11.5 -3t8 -5.5t7 -9t2 -13.5q0 -4 1 -20t0.5 -26.5t-3 -23.5 t-10 -19.5t-20.5 -6.5h-320q-119 0 -203.5 84.5t-84.5 203.5zM384 448v384q0 26 19 45t45 19h448v288q0 26 19 45t45 19t45 -19l544 -544q19 -19 19 -45t-19 -45l-544 -544q-19 -19 -45 -19t-45 19t-19 45v288h-448q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf08c;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM223 1030q0 -51 35.5 -85.5t92.5 -34.5h1q59 0 95 34.5t36 85.5q-1 52 -36 86t-93 34t-94.5 -34t-36.5 -86z M237 122h231v694h-231v-694zM595 122h231v388q0 38 7 56q15 35 45 59.5t74 24.5q116 0 116 -157v-371h231v398q0 154 -73 233t-193 79q-136 0 -209 -117h2v101h-231q3 -66 0 -694z" />
+<glyph unicode="&#xf08d;" horiz-adv-x="1152" d="M0 320q0 123 78.5 221.5t177.5 98.5v512q-52 0 -90 38t-38 90t38 90t90 38h640q52 0 90 -38t38 -90t-38 -90t-90 -38v-512q99 0 177.5 -98.5t78.5 -221.5q0 -26 -19 -45t-45 -19h-429l-51 -483q-2 -12 -10.5 -20.5t-20.5 -8.5h-1q-27 0 -32 27l-76 485h-404q-26 0 -45 19 t-19 45zM416 672q0 -14 9 -23t23 -9t23 9t9 23v448q0 14 -9 23t-23 9t-23 -9t-9 -23v-448z" />
+<glyph unicode="&#xf08e;" horiz-adv-x="1792" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h704q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-704q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v320q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-320q0 -119 -84.5 -203.5t-203.5 -84.5h-832 q-119 0 -203.5 84.5t-84.5 203.5zM685 576q0 13 10 23l652 652l-176 176q-19 19 -19 45t19 45t45 19h512q26 0 45 -19t19 -45v-512q0 -26 -19 -45t-45 -19t-45 19l-176 176l-652 -652q-10 -10 -23 -10t-23 10l-114 114q-10 10 -10 23z" />
+<glyph unicode="&#xf090;" d="M0 448v384q0 26 19 45t45 19h448v288q0 26 19 45t45 19t45 -19l544 -544q19 -19 19 -45t-19 -45l-544 -544q-19 -19 -45 -19t-45 19t-19 45v288h-448q-26 0 -45 19t-19 45zM894.5 78.5q0.5 10.5 3 23.5t10 19.5t20.5 6.5h320q66 0 113 47t47 113v704q0 66 -47 113 t-113 47h-288h-11h-13t-11.5 1t-11.5 3t-8 5.5t-7 9t-2 13.5q0 4 -1 20t-0.5 26.5t3 23.5t10 19.5t20.5 6.5h320q119 0 203.5 -84.5t84.5 -203.5v-704q0 -119 -84.5 -203.5t-203.5 -84.5h-320q-13 0 -22.5 9.5t-9.5 22.5q0 4 -1 20t-0.5 26.5z" />
+<glyph unicode="&#xf091;" horiz-adv-x="1664" d="M0 928v128q0 40 28 68t68 28h288v96q0 66 47 113t113 47h576q66 0 113 -47t47 -113v-96h288q40 0 68 -28t28 -68v-128q0 -71 -41.5 -143t-112 -130t-173 -97.5t-215.5 -44.5q-42 -54 -95 -95q-38 -34 -52.5 -72.5t-14.5 -89.5q0 -54 30.5 -91t97.5 -37q75 0 133.5 -45.5 t58.5 -114.5v-64q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23v64q0 69 58.5 114.5t133.5 45.5q67 0 97.5 37t30.5 91q0 51 -14.5 89.5t-52.5 72.5q-53 41 -95 95q-113 5 -215.5 44.5t-173 97.5t-112 130t-41.5 143zM128 928q0 -78 94.5 -162t235.5 -113q-74 162 -74 371 h-256v-96zM1206 653q141 29 235.5 113t94.5 162v96h-256q0 -209 -74 -371z" />
+<glyph unicode="&#xf092;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-224q-16 0 -24.5 1t-19.5 5t-16 14.5t-5 27.5v239q0 97 -52 142q57 6 102.5 18t94 39t81 66.5t53 105t20.5 150.5q0 121 -79 206q37 91 -8 204 q-28 9 -81 -11t-92 -44l-38 -24q-93 26 -192 26t-192 -26q-16 11 -42.5 27t-83.5 38.5t-86 13.5q-44 -113 -7 -204q-79 -85 -79 -206q0 -85 20.5 -150t52.5 -105t80.5 -67t94 -39t102.5 -18q-40 -36 -49 -103q-21 -10 -45 -15t-57 -5t-65.5 21.5t-55.5 62.5q-19 32 -48.5 52 t-49.5 24l-20 3q-21 0 -29 -4.5t-5 -11.5t9 -14t13 -12l7 -5q22 -10 43.5 -38t31.5 -51l10 -23q13 -38 44 -61.5t67 -30t69.5 -7t55.5 3.5l23 4q0 -38 0.5 -103t0.5 -68q0 -22 -11 -33.5t-22 -13t-33 -1.5h-224q-119 0 -203.5 84.5t-84.5 203.5zM271 315q3 5 13 2 q10 -5 7 -12q-5 -7 -13 -2q-10 5 -7 12zM304 290q6 6 16 -3q9 -11 2 -16q-6 -7 -16 3q-9 11 -2 16zM335 233q-9 13 0 18q9 7 17 -6q9 -12 0 -19q-8 -6 -17 7zM370 206q8 9 20 -3q12 -11 4 -19q-8 -9 -20 3q-13 11 -4 19zM419 168q4 11 19 7q16 -5 13 -16q-4 -12 -19 -6 q-17 4 -13 15zM481 154q0 11 16 11q17 2 17 -11q0 -11 -16 -11q-17 -2 -17 11zM540 158q-2 12 14 15q16 2 18 -9q2 -10 -14 -14t-18 8z" />
+<glyph unicode="&#xf093;" horiz-adv-x="1664" d="M0 -32v320q0 40 28 68t68 28h427q21 -56 70.5 -92t110.5 -36h256q61 0 110.5 36t70.5 92h427q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-1472q-40 0 -68 28t-28 68zM325 936q-17 39 14 69l448 448q18 19 45 19t45 -19l448 -448q31 -30 14 -69q-17 -40 -59 -40 h-256v-448q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45v448h-256q-42 0 -59 40zM1152 64q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM1408 64q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf094;" d="M0 433q0 111 18 217.5t54.5 209.5t100.5 194t150 156q78 59 232 120q194 78 316 78q60 0 175.5 -24t173.5 -24q19 0 57 5t58 5q81 0 118 -50.5t37 -134.5q0 -23 -5 -68t-5 -68q0 -10 1 -18.5t3 -17t4 -13.5t6.5 -16t6.5 -17q16 -40 25 -118.5t9 -136.5q0 -165 -70 -327.5 t-196 -288t-281 -180.5q-124 -44 -326 -44q-57 0 -170 14.5t-169 14.5q-24 0 -72.5 -14.5t-73.5 -14.5q-73 0 -123.5 55.5t-50.5 128.5q0 24 11 68t11 67q0 40 -12.5 120.5t-12.5 121.5zM128 434q0 -40 12.5 -120t12.5 -121q0 -23 -11 -66.5t-11 -65.5t12 -36.5t34 -14.5 q24 0 72.5 11t73.5 11q57 0 169.5 -15.5t169.5 -15.5q181 0 284 36q129 45 235.5 152.5t166 245.5t59.5 275q0 44 -7 113.5t-18 96.5q-12 30 -17 44t-9 36.5t-4 48.5q0 23 5 68.5t5 67.5q0 37 -10 55q-4 1 -13 1q-19 0 -58 -4.5t-59 -4.5q-60 0 -176 24t-175 24 q-43 0 -94.5 -11.5t-85 -23.5t-89.5 -34q-137 -54 -202 -103q-96 -73 -159.5 -189.5t-88 -236t-24.5 -248.5z" />
+<glyph unicode="&#xf095;" horiz-adv-x="1408" d="M0 1069q0 92 51 186q56 101 106 122q25 11 68.5 21t70.5 10q14 0 21 -3q18 -6 53 -76q11 -19 30 -54t35 -63.5t31 -53.5q3 -4 17.5 -25t21.5 -35.5t7 -28.5q0 -20 -28.5 -50t-62 -55t-62 -53t-28.5 -46q0 -9 5 -22.5t8.5 -20.5t14 -24t11.5 -19q76 -137 174 -235 t235 -174q2 -1 19 -11.5t24 -14t20.5 -8.5t22.5 -5q18 0 46 28.5t53 62t55 62t50 28.5q14 0 28.5 -7t35.5 -21.5t25 -17.5q25 -15 53.5 -31t63.5 -35t54 -30q70 -35 76 -53q3 -7 3 -21q0 -27 -10 -70.5t-21 -68.5q-21 -50 -122 -106q-94 -51 -186 -51q-27 0 -52.5 3.5 t-57.5 12.5t-47.5 14.5t-55.5 20.5t-49 18q-98 35 -175 83q-128 79 -264.5 215.5t-215.5 264.5q-48 77 -83 175q-3 9 -18 49t-20.5 55.5t-14.5 47.5t-12.5 57.5t-3.5 52.5z" />
+<glyph unicode="&#xf096;" horiz-adv-x="1408" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h832q119 0 203.5 -84.5t84.5 -203.5v-832q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM128 288q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v832q0 66 -47 113t-113 47h-832q-66 0 -113 -47 t-47 -113v-832z" />
+<glyph unicode="&#xf097;" horiz-adv-x="1280" d="M0 7v1289q0 34 19.5 62t52.5 41q21 9 44 9h1048q23 0 44 -9q33 -13 52.5 -41t19.5 -62v-1289q0 -34 -19.5 -62t-52.5 -41q-19 -8 -44 -8q-48 0 -83 32l-441 424l-441 -424q-36 -33 -83 -33q-23 0 -44 9q-33 13 -52.5 41t-19.5 62zM128 38l423 406l89 85l89 -85l423 -406 v1242h-1024v-1242z" />
+<glyph unicode="&#xf098;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 905q0 -16 2.5 -34t5 -30.5t9 -33t10 -29.5t12.5 -33t11 -30q60 -164 216.5 -320.5t320.5 -216.5 q6 -2 30 -11t33 -12.5t29.5 -10t33 -9t30.5 -5t34 -2.5q57 0 130.5 34t94.5 80q22 53 22 101q0 11 -2 16q-3 8 -38.5 29.5t-88.5 49.5l-53 29q-5 3 -19 13t-25 15t-21 5q-18 0 -47 -32.5t-57 -65.5t-44 -33q-7 0 -16.5 3.5t-15.5 6.5t-17 9.5t-14 8.5q-99 55 -170.5 126.5 t-126.5 170.5q-2 3 -8.5 14t-9.5 17t-6.5 15.5t-3.5 16.5q0 13 20.5 33.5t45 38.5t45 39.5t20.5 36.5q0 10 -5 21t-15 25t-13 19q-3 6 -15 28.5t-25 45.5t-26.5 47.5t-25 40.5t-16.5 18t-16 2q-48 0 -101 -22q-46 -21 -80 -94.5t-34 -130.5z" />
+<glyph unicode="&#xf099;" horiz-adv-x="1664" d="M44 145q35 -4 78 -4q225 0 401 138q-105 2 -188 64.5t-114 159.5q33 -5 61 -5q43 0 85 11q-112 23 -185.5 111.5t-73.5 205.5v4q68 -38 146 -41q-66 44 -105 115t-39 154q0 88 44 163q121 -149 294.5 -238.5t371.5 -99.5q-8 38 -8 74q0 134 94.5 228.5t228.5 94.5 q140 0 236 -102q109 21 205 78q-37 -115 -142 -178q93 10 186 50q-67 -98 -162 -167q1 -14 1 -42q0 -130 -38 -259.5t-115.5 -248.5t-184.5 -210.5t-258 -146t-323 -54.5q-271 0 -496 145z" />
+<glyph unicode="&#xf09a;" horiz-adv-x="1024" d="M95 631v296h255v218q0 186 104 288.5t277 102.5q147 0 228 -12v-264h-157q-86 0 -116 -36t-30 -108v-189h293l-39 -296h-254v-759h-306v759h-255z" />
+<glyph unicode="&#xf09b;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5q0 -251 -146.5 -451.5t-378.5 -277.5q-27 -5 -39.5 7t-12.5 30v211q0 97 -52 142q57 6 102.5 18t94 39t81 66.5t53 105t20.5 150.5q0 121 -79 206q37 91 -8 204q-28 9 -81 -11t-92 -44 l-38 -24q-93 26 -192 26t-192 -26q-16 11 -42.5 27t-83.5 38.5t-86 13.5q-44 -113 -7 -204q-79 -85 -79 -206q0 -85 20.5 -150t52.5 -105t80.5 -67t94 -39t102.5 -18q-40 -36 -49 -103q-21 -10 -45 -15t-57 -5t-65.5 21.5t-55.5 62.5q-19 32 -48.5 52t-49.5 24l-20 3 q-21 0 -29 -4.5t-5 -11.5t9 -14t13 -12l7 -5q22 -10 43.5 -38t31.5 -51l10 -23q13 -38 44 -61.5t67 -30t69.5 -7t55.5 3.5l23 4q0 -38 0.5 -89t0.5 -54q0 -18 -13 -30t-40 -7q-232 77 -378.5 277.5t-146.5 451.5z" />
+<glyph unicode="&#xf09c;" horiz-adv-x="1664" d="M0 96v576q0 40 28 68t68 28h672v192q0 185 131.5 316.5t316.5 131.5t316.5 -131.5t131.5 -316.5v-256q0 -26 -19 -45t-45 -19h-64q-26 0 -45 19t-19 45v256q0 106 -75 181t-181 75t-181 -75t-75 -181v-192h96q40 0 68 -28t28 -68v-576q0 -40 -28 -68t-68 -28h-960 q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf09d;" horiz-adv-x="1920" d="M0 32v1216q0 66 47 113t113 47h1600q66 0 113 -47t47 -113v-1216q0 -66 -47 -113t-113 -47h-1600q-66 0 -113 47t-47 113zM128 32q0 -13 9.5 -22.5t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5v608h-1664v-608zM128 1024h1664v224q0 13 -9.5 22.5t-22.5 9.5h-1600 q-13 0 -22.5 -9.5t-9.5 -22.5v-224zM256 128v128h256v-128h-256zM640 128v128h384v-128h-384z" />
+<glyph unicode="&#xf09e;" horiz-adv-x="1408" d="M0 192q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM0 697v135q0 29 21 47q17 17 43 17h5q160 -13 306 -80.5t259 -181.5q114 -113 181.5 -259t80.5 -306q2 -28 -17 -48q-18 -21 -47 -21h-135q-25 0 -43 16.5t-20 41.5q-22 229 -184.5 391.5 t-391.5 184.5q-25 2 -41.5 20t-16.5 43zM0 1201v143q0 28 20 46q18 18 44 18h3q262 -13 501.5 -120t425.5 -294q187 -186 294 -425.5t120 -501.5q2 -27 -18 -47q-18 -20 -46 -20h-143q-26 0 -44.5 17.5t-19.5 42.5q-12 215 -101 408.5t-231.5 336t-336 231.5t-408.5 102 q-25 1 -42.5 19.5t-17.5 43.5z" />
+<glyph unicode="&#xf0a0;" d="M0 160v320q0 25 16 75l197 606q17 53 63 86t101 33h782q55 0 101 -33t63 -86l197 -606q16 -50 16 -75v-320q0 -66 -47 -113t-113 -47h-1216q-66 0 -113 47t-47 113zM128 160q0 -13 9.5 -22.5t22.5 -9.5h1216q13 0 22.5 9.5t9.5 22.5v320q0 13 -9.5 22.5t-22.5 9.5h-1216 q-13 0 -22.5 -9.5t-9.5 -22.5v-320zM178 640h1180l-157 482q-4 13 -16 21.5t-26 8.5h-782q-14 0 -26 -8.5t-16 -21.5zM880 320q0 33 23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5t-23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5zM1136 320q0 33 23.5 56.5t56.5 23.5 t56.5 -23.5t23.5 -56.5t-23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5z" />
+<glyph unicode="&#xf0a1;" horiz-adv-x="1792" d="M0 672v192q0 66 47 113t113 47h480q435 0 896 384q52 0 90 -38t38 -90v-384q53 0 90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5v-384q0 -52 -38 -90t-90 -38q-417 347 -812 380q-58 -19 -91 -66t-31 -100.5t40 -92.5q-20 -33 -23 -65.5t6 -58t33.5 -55t48 -50 t61.5 -50.5q-29 -58 -111.5 -83t-168.5 -11.5t-132 55.5q-7 23 -29.5 87.5t-32 94.5t-23 89t-15 101t3.5 98.5t22 110.5h-122q-66 0 -113 47t-47 113zM768 633q377 -42 768 -341v954q-394 -302 -768 -343v-270z" />
+<glyph unicode="&#xf0a2;" horiz-adv-x="1664" d="M0 128q190 161 287 397.5t97 498.5q0 165 96 262t264 117q-8 18 -8 37q0 40 28 68t68 28t68 -28t28 -68q0 -19 -8 -37q168 -20 264 -117t96 -262q0 -262 97 -498.5t287 -397.5q0 -52 -38 -90t-90 -38h-448q0 -106 -75 -181t-181 -75t-181 75t-75 181h-448q-52 0 -90 38 t-38 90zM183 128h1298q-164 181 -246.5 411.5t-82.5 484.5q0 256 -320 256t-320 -256q0 -254 -82.5 -484.5t-246.5 -411.5zM656 0q0 -73 51.5 -124.5t124.5 -51.5q16 0 16 16t-16 16q-59 0 -101.5 42.5t-42.5 101.5q0 16 -16 16t-16 -16z" />
+<glyph unicode="&#xf0a3;" d="M2 435q-10 42 20 70l138 135l-138 135q-30 28 -20 70q12 41 52 51l188 48l-53 186q-12 41 19 70q29 31 70 19l186 -53l48 188q10 41 51 51q41 12 70 -19l135 -139l135 139q29 30 70 19q41 -10 51 -51l48 -188l186 53q41 12 70 -19q31 -29 19 -70l-53 -186l188 -48 q40 -10 52 -51q10 -42 -20 -70l-138 -135l138 -135q30 -28 20 -70q-12 -41 -52 -51l-188 -48l53 -186q12 -41 -19 -70q-29 -31 -70 -19l-186 53l-48 -188q-10 -40 -51 -52q-12 -2 -19 -2q-31 0 -51 22l-135 138l-135 -138q-28 -30 -70 -20q-41 11 -51 52l-48 188l-186 -53 q-41 -12 -70 19q-31 29 -19 70l53 186l-188 48q-40 10 -52 51z" />
+<glyph unicode="&#xf0a4;" horiz-adv-x="1792" d="M0 128v640q0 53 37.5 90.5t90.5 37.5h288q10 0 21.5 4.5t23.5 14t22.5 18t24 22.5t20.5 21.5t19 21.5t14 17q65 74 100 129q13 21 33 62t37 72t40.5 63t55 49.5t69.5 17.5q125 0 206.5 -67t81.5 -189q0 -68 -22 -128h374q104 0 180 -76t76 -179q0 -105 -75.5 -181 t-180.5 -76h-169q-4 -62 -37 -119q3 -21 3 -43q0 -101 -60 -178q1 -139 -85 -219.5t-227 -80.5q-133 0 -322 69q-164 59 -223 59h-288q-53 0 -90.5 37.5t-37.5 90.5zM128 192q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM384 128h32q72 0 167 -32 t193.5 -64t179.5 -32q189 0 189 167q0 26 -5 56q30 16 47.5 52.5t17.5 73.5t-18 69q53 50 53 119q0 25 -10 55.5t-25 47.5h331q52 0 90 38t38 90q0 51 -39 89.5t-89 38.5h-576q0 20 15 48.5t33 55t33 68t15 84.5q0 67 -44.5 97.5t-115.5 30.5q-24 0 -90 -139 q-24 -44 -37 -65q-40 -64 -112 -145q-71 -81 -101 -106q-69 -57 -140 -57h-32v-640z" />
+<glyph unicode="&#xf0a5;" horiz-adv-x="1792" d="M0 769q0 103 76 179t180 76h374q-22 60 -22 128q0 122 81.5 189t206.5 67q38 0 69.5 -17.5t55 -49.5t40.5 -63t37 -72t33 -62q35 -55 100 -129q2 -3 14 -17t19 -21.5t20.5 -21.5t24 -22.5t22.5 -18t23.5 -14t21.5 -4.5h288q53 0 90.5 -37.5t37.5 -90.5v-640 q0 -53 -37.5 -90.5t-90.5 -37.5h-288q-59 0 -223 -59q-190 -69 -317 -69q-142 0 -230 77.5t-87 217.5l1 5q-61 76 -61 178q0 22 3 43q-33 57 -37 119h-169q-105 0 -180.5 76t-75.5 181zM128 768q0 -52 38 -90t90 -38h331q-15 -17 -25 -47.5t-10 -55.5q0 -69 53 -119 q-18 -32 -18 -69t17.5 -73.5t47.5 -52.5q-4 -24 -4 -56q0 -85 48.5 -126t135.5 -41q84 0 183 32t194 64t167 32h32v640h-32q-35 0 -67.5 12t-62.5 37t-50 46t-49 54q-2 3 -3.5 4.5t-4 4.5t-4.5 5q-72 81 -112 145q-14 22 -38 68q-1 3 -10.5 22.5t-18.5 36t-20 35.5 t-21.5 30.5t-18.5 11.5q-71 0 -115.5 -30.5t-44.5 -97.5q0 -43 15 -84.5t33 -68t33 -55t15 -48.5h-576q-50 0 -89 -38.5t-39 -89.5zM1536 192q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf0a6;" d="M0 640q0 125 67 206.5t189 81.5q68 0 128 -22v374q0 104 76 180t179 76q105 0 181 -75.5t76 -180.5v-169q62 -4 119 -37q21 3 43 3q101 0 178 -60q139 1 219.5 -85t80.5 -227q0 -133 -69 -322q-59 -164 -59 -223v-288q0 -53 -37.5 -90.5t-90.5 -37.5h-640 q-53 0 -90.5 37.5t-37.5 90.5v288q0 10 -4.5 21.5t-14 23.5t-18 22.5t-22.5 24t-21.5 20.5t-21.5 19t-17 14q-74 65 -129 100q-21 13 -62 33t-72 37t-63 40.5t-49.5 55t-17.5 69.5zM128 640q0 -24 139 -90q44 -24 65 -37q64 -40 145 -112q81 -71 106 -101q57 -69 57 -140 v-32h640v32q0 72 32 167t64 193.5t32 179.5q0 189 -167 189q-26 0 -56 -5q-16 30 -52.5 47.5t-73.5 17.5t-69 -18q-50 53 -119 53q-25 0 -55.5 -10t-47.5 -25v331q0 52 -38 90t-90 38q-51 0 -89.5 -39t-38.5 -89v-576q-20 0 -48.5 15t-55 33t-68 33t-84.5 15 q-67 0 -97.5 -44.5t-30.5 -115.5zM1152 -64q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf0a7;" d="M0 640q0 38 17.5 69.5t49.5 55t63 40.5t72 37t62 33q55 35 129 100q3 2 17 14t21.5 19t21.5 20.5t22.5 24t18 22.5t14 23.5t4.5 21.5v288q0 53 37.5 90.5t90.5 37.5h640q53 0 90.5 -37.5t37.5 -90.5v-288q0 -59 59 -223q69 -190 69 -317q0 -142 -77.5 -230t-217.5 -87 l-5 1q-76 -61 -178 -61q-22 0 -43 3q-54 -30 -119 -37v-169q0 -105 -76 -180.5t-181 -75.5q-103 0 -179 76t-76 180v374q-54 -22 -128 -22q-121 0 -188.5 81.5t-67.5 206.5zM128 640q0 -71 30.5 -115.5t97.5 -44.5q43 0 84.5 15t68 33t55 33t48.5 15v-576q0 -50 38.5 -89 t89.5 -39q52 0 90 38t38 90v331q46 -35 103 -35q69 0 119 53q32 -18 69 -18t73.5 17.5t52.5 47.5q24 -4 56 -4q85 0 126 48.5t41 135.5q0 84 -32 183t-64 194t-32 167v32h-640v-32q0 -35 -12 -67.5t-37 -62.5t-46 -50t-54 -49q-9 -8 -14 -12q-81 -72 -145 -112 q-22 -14 -68 -38q-3 -1 -22.5 -10.5t-36 -18.5t-35.5 -20t-30.5 -21.5t-11.5 -18.5zM1152 1344q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf0a8;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM251 640q0 -27 18 -45l91 -91l362 -362q18 -18 45 -18t45 18l91 91q18 18 18 45t-18 45l-189 189h502 q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-502l189 189q19 19 19 45t-19 45l-91 91q-18 18 -45 18t-45 -18l-362 -362l-91 -91q-18 -18 -18 -45z" />
+<glyph unicode="&#xf0a9;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM256 576q0 -26 19 -45t45 -19h502l-189 -189q-19 -19 -19 -45t19 -45l91 -91q18 -18 45 -18t45 18 l362 362l91 91q18 18 18 45t-18 45l-91 91l-362 362q-18 18 -45 18t-45 -18l-91 -91q-18 -18 -18 -45t18 -45l189 -189h-502q-26 0 -45 -19t-19 -45v-128z" />
+<glyph unicode="&#xf0aa;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM252 641q0 -27 18 -45l91 -91q18 -18 45 -18t45 18l189 189v-502q0 -26 19 -45t45 -19h128q26 0 45 19 t19 45v502l189 -189q19 -19 45 -19t45 19l91 91q18 18 18 45t-18 45l-362 362l-91 91q-18 18 -45 18t-45 -18l-91 -91l-362 -362q-18 -18 -18 -45z" />
+<glyph unicode="&#xf0ab;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM252 639q0 -27 18 -45l362 -362l91 -91q18 -18 45 -18t45 18l91 91l362 362q18 18 18 45t-18 45l-91 91 q-18 18 -45 18t-45 -18l-189 -189v502q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-502l-189 189q-19 19 -45 19t-45 -19l-91 -91q-18 -18 -18 -45z" />
+<glyph unicode="&#xf0ac;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM226 979q7 -7 12 -8q4 -1 5 -9t2.5 -11t11.5 3q9 -8 3 -19q1 1 44 -27q19 -17 21 -21q3 -11 -10 -18 q-1 2 -9 9t-9 4q-3 -5 0.5 -18.5t10.5 -12.5q-7 0 -9.5 -16t-2.5 -35.5t-1 -23.5l2 -1q-3 -12 5.5 -34.5t21.5 -19.5q-13 -3 20 -43q6 -8 8 -9q3 -2 12 -7.5t15 -10t10 -10.5q4 -5 10 -22.5t14 -23.5q-2 -6 9.5 -20t10.5 -23q-1 0 -2.5 -1t-2.5 -1q3 -7 15.5 -14t15.5 -13 q1 -3 2 -10t3 -11t8 -2q2 20 -24 62q-15 25 -17 29q-3 5 -5.5 15.5t-4.5 14.5q2 0 6 -1.5t8.5 -3.5t7.5 -4t2 -3q-3 -7 2 -17.5t12 -18.5t17 -19t12 -13q6 -6 14 -19.5t0 -13.5q9 0 20 -10t17 -20q5 -8 8 -26t5 -24q2 -7 8.5 -13.5t12.5 -9.5l16 -8t13 -7q5 -2 18.5 -10.5 t21.5 -11.5q10 -4 16 -4t14.5 2.5t13.5 3.5q15 2 29 -15t21 -21q36 -19 55 -11q-2 -1 0.5 -7.5t8 -15.5t9 -14.5t5.5 -8.5q5 -6 18 -15t18 -15q6 4 7 9q-3 -8 7 -20t18 -10q14 3 14 32q-31 -15 -49 18q0 1 -2.5 5.5t-4 8.5t-2.5 8.5t0 7.5t5 3q9 0 10 3.5t-2 12.5t-4 13 q-1 8 -11 20t-12 15q-5 -9 -16 -8t-16 9q0 -1 -1.5 -5.5t-1.5 -6.5q-13 0 -15 1q1 3 2.5 17.5t3.5 22.5q1 4 5.5 12t7.5 14.5t4 12.5t-4.5 9.5t-17.5 2.5q-19 -1 -26 -20q-1 -3 -3 -10.5t-5 -11.5t-9 -7q-7 -3 -24 -2t-24 5q-13 8 -22.5 29t-9.5 37q0 10 2.5 26.5t3 25 t-5.5 24.5q3 2 9 9.5t10 10.5q2 1 4.5 1.5t4.5 0t4 1.5t3 6q-1 1 -4 3q-3 3 -4 3q7 -3 28.5 1.5t27.5 -1.5q15 -11 22 2q0 1 -2.5 9.5t-0.5 13.5q5 -27 29 -9q3 -3 15.5 -5t17.5 -5q3 -2 7 -5.5t5.5 -4.5t5 0.5t8.5 6.5q10 -14 12 -24q11 -40 19 -44q7 -3 11 -2t4.5 9.5 t0 14t-1.5 12.5l-1 8v18l-1 8q-15 3 -18.5 12t1.5 18.5t15 18.5q1 1 8 3.5t15.5 6.5t12.5 8q21 19 15 35q7 0 11 9q-1 0 -5 3t-7.5 5t-4.5 2q9 5 2 16q5 3 7.5 11t7.5 10q9 -12 21 -2q7 8 1 16q5 7 20.5 10.5t18.5 9.5q7 -2 8 2t1 12t3 12q4 5 15 9t13 5l17 11q3 4 0 4 q18 -2 31 11q10 11 -6 20q3 6 -3 9.5t-15 5.5q3 1 11.5 0.5t10.5 1.5q15 10 -7 16q-17 5 -43 -12q-2 -1 -9.5 -9.5t-13.5 -9.5q2 0 4.5 5t5 11t3.5 7q6 7 22 15q14 6 52 12q34 8 51 -11q-2 2 9.5 13t14.5 12q3 2 15 4.5t15 7.5l2 22q-12 -1 -17.5 7t-6.5 21q0 -2 -6 -8 q0 7 -4.5 8t-11.5 -1t-9 -1q-10 3 -15 7.5t-8 16.5t-4 15q-2 5 -9.5 10.5t-9.5 10.5q-1 2 -2.5 5.5t-3 6.5t-4 5.5t-5.5 2.5t-7 -5t-7.5 -10t-4.5 -5q-3 2 -6 1.5t-4.5 -1t-4.5 -3t-5 -3.5q-3 -2 -8.5 -3t-8.5 -2q15 5 -1 11q-10 4 -16 3q9 4 7.5 12t-8.5 14h5 q-1 4 -8.5 8.5t-17.5 8.5t-13 6q-8 5 -34 9.5t-33 0.5q-5 -6 -4.5 -10.5t4 -14t3.5 -12.5q1 -6 -5.5 -13t-6.5 -12q0 -7 14 -15.5t10 -21.5q-3 -8 -16 -16t-16 -12q-5 -8 -1.5 -18.5t10.5 -16.5q2 -2 1.5 -4t-3.5 -4.5t-5.5 -4t-6.5 -3.5l-3 -2q-11 -5 -20.5 6t-13.5 26 q-7 25 -16 30q-23 8 -29 -1q-5 13 -41 26q-25 9 -58 4q6 1 0 15q-7 15 -19 12q3 6 4 17.5t1 13.5q3 13 12 23q1 1 7 8.5t9.5 13.5t0.5 6q35 -4 50 11q5 5 11.5 17t10.5 17q9 6 14 5.5t14.5 -5.5t14.5 -5q14 -1 15.5 11t-7.5 20q12 -1 3 17q-5 7 -8 9q-12 4 -27 -5 q-8 -4 2 -8q-1 1 -9.5 -10.5t-16.5 -17.5t-16 5q-1 1 -5.5 13.5t-9.5 13.5q-8 0 -16 -15q3 8 -11 15t-24 8q19 12 -8 27q-7 4 -20.5 5t-19.5 -4q-5 -7 -5.5 -11.5t5 -8t10.5 -5.5t11.5 -4t8.5 -3q14 -10 8 -14q-2 -1 -8.5 -3.5t-11.5 -4.5t-6 -4q-3 -4 0 -14t-2 -14 q-5 5 -9 17.5t-7 16.5q7 -9 -25 -6l-10 1q-4 0 -16 -2t-20.5 -1t-13.5 8q-4 8 0 20q1 4 4 2q-4 3 -11 9.5t-10 8.5q-46 -15 -94 -41q6 -1 12 1q5 2 13 6.5t10 5.5q34 14 42 7l5 5q14 -16 20 -25q-7 4 -30 1q-20 -6 -22 -12q7 -12 5 -18q-4 3 -11.5 10t-14.5 11t-15 5 q-16 0 -22 -1q-146 -80 -235 -222zM877 26q0 -6 2 -16q206 36 351 189q-3 3 -12.5 4.5t-12.5 3.5q-18 7 -24 8q1 7 -2.5 13t-8 9t-12.5 8t-11 7q-2 2 -7 6t-7 5.5t-7.5 4.5t-8.5 2t-10 -1l-3 -1q-3 -1 -5.5 -2.5t-5.5 -3t-4 -3t0 -2.5q-21 17 -36 22q-5 1 -11 5.5t-10.5 7 t-10 1.5t-11.5 -7q-5 -5 -6 -15t-2 -13q-7 5 0 17.5t2 18.5q-3 6 -10.5 4.5t-12 -4.5t-11.5 -8.5t-9 -6.5t-8.5 -5.5t-8.5 -7.5q-3 -4 -6 -12t-5 -11q-2 4 -11.5 6.5t-9.5 5.5q2 -10 4 -35t5 -38q7 -31 -12 -48q-27 -25 -29 -40q-4 -22 12 -26q0 -7 -8 -20.5t-7 -21.5z" />
+<glyph unicode="&#xf0ad;" horiz-adv-x="1664" d="M21 0q0 53 38 91l681 681q39 -98 114.5 -173.5t173.5 -114.5l-682 -682q-37 -37 -90 -37q-52 0 -91 37l-106 108q-38 36 -38 90zM256 64q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45zM768 960q0 185 131.5 316.5t316.5 131.5q58 0 121.5 -16.5 t107.5 -46.5q16 -11 16 -28t-16 -28l-293 -169v-224l193 -107q5 3 79 48.5t135.5 81t70.5 35.5q15 0 23.5 -10t8.5 -25q0 -39 -23 -106q-47 -134 -164.5 -217.5t-258.5 -83.5q-185 0 -316.5 131.5t-131.5 316.5z" />
+<glyph unicode="&#xf0ae;" horiz-adv-x="1792" d="M0 64v256q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 576v256q0 26 19 45t45 19h1664q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM0 1088v256q0 26 19 45t45 19h1664 q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19h-1664q-26 0 -45 19t-19 45zM640 640h1024v128h-1024v-128zM1024 128h640v128h-640v-128zM1280 1152h384v128h-384v-128z" />
+<glyph unicode="&#xf0b0;" horiz-adv-x="1408" d="M5 1241q17 39 59 39h1280q42 0 59 -39q17 -41 -14 -70l-493 -493v-742q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-256 256q-19 19 -19 45v486l-493 493q-31 29 -14 70z" />
+<glyph unicode="&#xf0b1;" horiz-adv-x="1792" d="M0 160v480h672v-160q0 -26 19 -45t45 -19h320q26 0 45 19t19 45v160h672v-480q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113zM0 736v384q0 66 47 113t113 47h352v160q0 40 28 68t68 28h576q40 0 68 -28t28 -68v-160h352q66 0 113 -47t47 -113v-384h-1792z M640 1280h512v128h-512v-128zM768 512v128h256v-128h-256z" />
+<glyph unicode="&#xf0b2;" d="M0 -64v448q0 42 40 59q39 17 69 -14l144 -144l355 355l-355 355l-144 -144q-19 -19 -45 -19q-12 0 -24 5q-40 17 -40 59v448q0 26 19 45t45 19h448q42 0 59 -40q17 -39 -14 -69l-144 -144l355 -355l355 355l-144 144q-31 30 -14 69q17 40 59 40h448q26 0 45 -19t19 -45 v-448q0 -42 -39 -59q-13 -5 -25 -5q-26 0 -45 19l-144 144l-355 -355l355 -355l144 144q29 31 70 14q39 -17 39 -59v-448q0 -26 -19 -45t-45 -19h-448q-42 0 -59 40q-17 39 14 69l144 144l-355 355l-355 -355l144 -144q31 -30 14 -69q-17 -40 -59 -40h-448q-26 0 -45 19 t-19 45z" />
+<glyph unicode="&#xf0c0;" horiz-adv-x="1920" d="M0 671q0 353 124 353q6 0 43.5 -21t97.5 -42.5t119 -21.5q67 0 133 23q-5 -37 -5 -66q0 -139 81 -256q-162 -5 -265 -128h-134q-82 0 -138 40.5t-56 118.5zM128 1280q0 106 75 181t181 75t181 -75t75 -181t-75 -181t-181 -75t-181 75t-75 181zM256 3q0 53 3.5 103.5 t14 109t26.5 108.5t43 97.5t62 81t85.5 53.5t111.5 20q10 0 43 -21.5t73 -48t107 -48t135 -21.5t135 21.5t107 48t73 48t43 21.5q61 0 111.5 -20t85.5 -53.5t62 -81t43 -97.5t26.5 -108.5t14 -109t3.5 -103.5q0 -120 -73 -189.5t-194 -69.5h-874q-121 0 -194 69.5t-73 189.5 zM576 896q0 159 112.5 271.5t271.5 112.5t271.5 -112.5t112.5 -271.5t-112.5 -271.5t-271.5 -112.5t-271.5 112.5t-112.5 271.5zM1280 1280q0 106 75 181t181 75t181 -75t75 -181t-75 -181t-181 -75t-181 75t-75 181zM1327 640q81 117 81 256q0 29 -5 66q66 -23 133 -23 q59 0 119 21.5t97.5 42.5t43.5 21q124 0 124 -353q0 -78 -56 -118.5t-138 -40.5h-134q-103 123 -265 128z" />
+<glyph unicode="&#xf0c1;" horiz-adv-x="1664" d="M16 1088q0 120 85 203l147 146q83 83 203 83q121 0 204 -85l206 -207q83 -83 83 -203q0 -123 -88 -209l88 -88q86 88 208 88q120 0 204 -84l208 -208q84 -84 84 -204t-85 -203l-147 -146q-83 -83 -203 -83q-121 0 -204 85l-206 207q-83 83 -83 203q0 123 88 209l-88 88 q-86 -88 -208 -88q-120 0 -204 84l-208 208q-84 84 -84 204zM208 1088q0 -40 28 -68l208 -208q27 -27 68 -27q42 0 72 31q-3 3 -19 18.5t-21.5 21.5t-15 19t-13 25.5t-3.5 27.5q0 40 28 68t68 28q15 0 27.5 -3.5t25.5 -13t19 -15t21.5 -21.5t18.5 -19q33 31 33 73 q0 40 -28 68l-206 207q-28 28 -68 28q-39 0 -68 -27l-147 -146q-28 -28 -28 -67zM911 383q0 -40 28 -68l206 -207q27 -27 68 -27q40 0 68 26l147 146q28 28 28 67q0 40 -28 68l-208 208q-28 28 -68 28q-42 0 -72 -32q3 -3 19 -18.5t21.5 -21.5t15 -19t13 -25.5t3.5 -27.5 q0 -40 -28 -68t-68 -28q-15 0 -27.5 3.5t-25.5 13t-19 15t-21.5 21.5t-18.5 19q-33 -31 -33 -73z" />
+<glyph unicode="&#xf0c2;" horiz-adv-x="1920" d="M0 448q0 132 71 241.5t187 163.5q-2 28 -2 43q0 212 150 362t362 150q158 0 286.5 -88t187.5 -230q70 62 166 62q106 0 181 -75t75 -181q0 -75 -41 -138q129 -30 213 -134.5t84 -239.5q0 -159 -112.5 -271.5t-271.5 -112.5h-1088q-185 0 -316.5 131.5t-131.5 316.5z" />
+<glyph unicode="&#xf0c3;" horiz-adv-x="1664" d="M115.5 -64.5q-34.5 63.5 21.5 152.5l503 793v399h-64q-26 0 -45 19t-19 45t19 45t45 19h512q26 0 45 -19t19 -45t-19 -45t-45 -19h-64v-399l503 -793q56 -89 21.5 -152.5t-140.5 -63.5h-1152q-106 0 -140.5 63.5zM476 384h712l-272 429l-20 31v37v399h-128v-399v-37 l-20 -31z" />
+<glyph unicode="&#xf0c4;" horiz-adv-x="1792" d="M1 157q7 76 56 147t131 124q132 84 278 84q83 0 151 -31q9 13 22 22l122 73l-122 73q-13 9 -22 22q-68 -31 -151 -31q-146 0 -278 84q-82 53 -131 124t-56 147q-5 59 15.5 113t63.5 93q85 79 222 79q145 0 277 -84q83 -52 132 -123t56 -148q4 -48 -10 -97q4 -1 12 -5 l110 -66l690 387q14 8 31 8q16 0 29 -7l128 -64q30 -16 35 -51q3 -36 -25 -56l-507 -398l507 -398q28 -20 25 -56q-5 -35 -35 -51l-128 -64q-13 -7 -29 -7q-17 0 -31 8l-690 387l-110 -66q-8 -4 -12 -5q14 -49 10 -97q-7 -77 -56 -147.5t-132 -123.5q-132 -84 -277 -84 q-136 0 -222 78q-90 84 -79 207zM168 176q-25 -66 21 -108q39 -36 113 -36q100 0 192 59q81 51 106 117t-21 108q-39 36 -113 36q-100 0 -192 -59q-81 -51 -106 -117zM168 976q25 -66 106 -117q92 -59 192 -59q74 0 113 36q46 42 21 108t-106 117q-92 59 -192 59 q-74 0 -113 -36q-46 -42 -21 -108zM672 448l9 -8q2 -2 7 -6q4 -4 11 -12t11 -12l26 -26l160 96l96 -32l736 576l-128 64l-768 -431v-113zM672 704l96 -58v11q0 36 33 56l14 8l-79 47l-26 -26q-3 -3 -10 -11t-12 -12q-2 -2 -4 -3.5t-3 -2.5zM896 576q0 26 19 45t45 19t45 -19 t19 -45t-19 -45t-45 -19t-45 19t-19 45zM1018 391l582 -327l128 64l-520 408l-177 -138q-2 -3 -13 -7z" />
+<glyph unicode="&#xf0c5;" horiz-adv-x="1792" d="M0 224v672q0 40 20 88t48 76l408 408q28 28 76 48t88 20h416q40 0 68 -28t28 -68v-328q68 40 128 40h416q40 0 68 -28t28 -68v-1216q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v288h-544q-40 0 -68 28t-28 68zM128 256h512v256q0 40 20 88t48 76l316 316v416h-384 v-416q0 -40 -28 -68t-68 -28h-416v-640zM213 1024h299v299zM768 -128h896v1152h-384v-416q0 -40 -28 -68t-68 -28h-416v-640zM853 640h299v299z" />
+<glyph unicode="&#xf0c6;" horiz-adv-x="1408" d="M4 1023q0 159 110 270t269 111q158 0 273 -113l605 -606q10 -10 10 -22q0 -16 -30.5 -46.5t-46.5 -30.5q-13 0 -23 10l-606 607q-79 77 -181 77q-106 0 -179 -75t-73 -181q0 -105 76 -181l776 -777q63 -63 145 -63q64 0 106 42t42 106q0 82 -63 145l-581 581 q-26 24 -60 24q-29 0 -48 -19t-19 -48q0 -32 25 -59l410 -410q10 -10 10 -22q0 -16 -31 -47t-47 -31q-12 0 -22 10l-410 410q-63 61 -63 149q0 82 57 139t139 57q88 0 149 -63l581 -581q100 -98 100 -235q0 -117 -79 -196t-196 -79q-135 0 -235 100l-777 776 q-113 115 -113 271z" />
+<glyph unicode="&#xf0c7;" d="M0 -32v1344q0 40 28 68t68 28h928q40 0 88 -20t76 -48l280 -280q28 -28 48 -76t20 -88v-928q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 0h128v416q0 40 28 68t68 28h832q40 0 68 -28t28 -68v-416h128v896q0 14 -10 38.5t-20 34.5l-281 281q-10 10 -34 20 t-39 10v-416q0 -40 -28 -68t-68 -28h-576q-40 0 -68 28t-28 68v416h-128v-1280zM384 0h768v384h-768v-384zM640 928q0 -13 9.5 -22.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 22.5v320q0 13 -9.5 22.5t-22.5 9.5h-192q-13 0 -22.5 -9.5t-9.5 -22.5v-320z" />
+<glyph unicode="&#xf0c8;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5z" />
+<glyph unicode="&#xf0c9;" d="M0 64v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM0 576v128q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM0 1088v128q0 26 19 45t45 19h1408 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf0ca;" horiz-adv-x="1792" d="M0 128q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM0 640q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM0 1152q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM512 32v192 q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5zM512 544v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5z M512 1056v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0cb;" horiz-adv-x="1792" d="M15 438q0 51 23.5 93t56.5 68t66 47.5t56.5 43.5t23.5 45q0 25 -14.5 38.5t-39.5 13.5q-46 0 -81 -58l-85 59q24 51 71.5 79.5t105.5 28.5q73 0 123 -41.5t50 -112.5q0 -50 -34 -91.5t-75 -64.5t-75.5 -50.5t-35.5 -52.5h127v60h105v-159h-362q-6 36 -6 54zM19 -190 l57 88q49 -45 106 -45q29 0 50.5 14.5t21.5 42.5q0 64 -105 56l-26 56q8 10 32.5 43.5t42.5 54t37 38.5v1q-16 0 -48.5 -1t-48.5 -1v-53h-106v152h333v-88l-95 -115q51 -12 81 -49t30 -88q0 -80 -54.5 -126t-135.5 -46q-106 0 -172 66zM34 1400l136 127h106v-404h108v-99 h-335v99h107q0 41 0.5 122t0.5 121v12h-2q-8 -17 -50 -54zM512 32v192q0 14 9 23t23 9h1216q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5zM512 544v192q0 14 9 23t23 9h1216q13 0 22.5 -9.5t9.5 -22.5v-192 q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5zM512 1056v192q0 13 9.5 22.5t22.5 9.5h1216q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1216q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0cc;" horiz-adv-x="1792" d="M0 544v64q0 14 9 23t23 9h1728q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-1728q-14 0 -23 9t-9 23zM384 972q0 181 134 309q133 127 393 127q50 0 167 -19q66 -12 177 -48q10 -38 21 -118q14 -123 14 -183q0 -18 -5 -45l-12 -3l-84 6l-14 2q-50 149 -103 205 q-88 91 -210 91q-114 0 -182 -59q-67 -58 -67 -146q0 -73 66 -140t279 -129q69 -20 173 -66q58 -28 95 -52h-743q-28 35 -51 80q-48 97 -48 188zM414 154q-1 30 0 68l2 37v44l102 2q15 -34 30 -71t22.5 -56t12.5 -27q35 -57 80 -94q43 -36 105 -57q59 -22 132 -22 q64 0 139 27q77 26 122 86q47 61 47 129q0 84 -81 157q-34 29 -137 71h411q7 -39 7 -92q0 -111 -41 -212q-23 -55 -71 -104q-37 -35 -109 -81q-80 -48 -153 -66q-80 -21 -203 -21q-114 0 -195 23l-140 40q-57 16 -72 28q-8 8 -8 22v13q0 108 -2 156z" />
+<glyph unicode="&#xf0cd;" d="M0 -32v-64q0 -14 9 -23t23 -9h1472q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-1472q-14 0 -23 -9t-9 -23zM0 1405q13 1 40 1q60 0 112 -4q132 -7 166 -7q86 0 168 3q116 4 146 5q56 0 86 2l-1 -14l2 -64v-9q-60 -9 -124 -9q-60 0 -79 -25q-13 -14 -13 -132q0 -13 0.5 -32.5 t0.5 -25.5l1 -229l14 -280q6 -124 51 -202q35 -59 96 -92q88 -47 177 -47q104 0 191 28q56 18 99 51q48 36 65 64q36 56 53 114q21 73 21 229q0 79 -3.5 128t-11 122.5t-13.5 159.5l-4 59q-5 67 -24 88q-34 35 -77 34l-100 -2l-14 3l2 86h84l205 -10q76 -3 196 10l18 -2 q6 -38 6 -51q0 -7 -4 -31q-45 -12 -84 -13q-73 -11 -79 -17q-15 -15 -15 -41q0 -7 1.5 -27t1.5 -31q8 -19 22 -396q6 -195 -15 -304q-15 -76 -41 -122q-38 -65 -112 -123q-75 -57 -182 -89q-109 -33 -255 -33q-167 0 -284 46q-119 47 -179 122q-61 76 -83 195 q-16 80 -16 237v333q0 188 -17 213q-25 36 -147 39q-37 2 -45 4z" />
+<glyph unicode="&#xf0ce;" horiz-adv-x="1664" d="M0 160v1088q0 66 47 113t113 47h1344q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-1344q-66 0 -113 47t-47 113zM128 160q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM128 544q0 -14 9 -23t23 -9h320 q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM128 928q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM640 160q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9 t-9 -23v-192zM640 544q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM640 928q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM1152 160q0 -14 9 -23t23 -9h320q14 0 23 9t9 23 v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM1152 544q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192zM1152 928q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23v-192z" />
+<glyph unicode="&#xf0d0;" horiz-adv-x="1664" d="M27 160q0 27 18 45l1286 1286q18 18 45 18t45 -18l198 -198q18 -18 18 -45t-18 -45l-1286 -1286q-18 -18 -45 -18t-45 18l-198 198q-18 18 -18 45zM128 1408l98 30l30 98l30 -98l98 -30l-98 -30l-30 -98l-30 98zM320 1216l196 60l60 196l60 -196l196 -60l-196 -60 l-60 -196l-60 196zM768 1408l98 30l30 98l30 -98l98 -30l-98 -30l-30 -98l-30 98zM1083 1062l107 -107l293 293l-107 107zM1408 768l98 30l30 98l30 -98l98 -30l-98 -30l-30 -98l-30 98z" />
+<glyph unicode="&#xf0d1;" horiz-adv-x="1792" d="M64 192q0 26 19 45t45 19v320q0 8 -0.5 35t0 38t2.5 34.5t6.5 37t14 30.5t22.5 30l198 198q19 19 50.5 32t58.5 13h160v192q0 26 19 45t45 19h1024q26 0 45 -19t19 -45v-1024q0 -15 -4 -26.5t-13.5 -18.5t-16.5 -11.5t-23.5 -6t-22.5 -2t-25.5 0t-22.5 0.5 q0 -106 -75 -181t-181 -75t-181 75t-75 181h-384q0 -106 -75 -181t-181 -75t-181 75t-75 181h-64q-3 0 -22.5 -0.5t-25.5 0t-22.5 2t-23.5 6t-16.5 11.5t-13.5 18.5t-4 26.5zM256 640h384v256h-158q-13 0 -22 -9l-195 -195q-9 -9 -9 -22v-30zM384 128q0 -52 38 -90t90 -38 t90 38t38 90t-38 90t-90 38t-90 -38t-38 -90zM1280 128q0 -52 38 -90t90 -38t90 38t38 90t-38 90t-90 38t-90 -38t-38 -90z" />
+<glyph unicode="&#xf0d2;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103q-111 0 -218 32q59 93 78 164q9 34 54 211q20 -39 73 -67.5t114 -28.5q121 0 216 68.5t147 188.5t52 270q0 114 -59.5 214t-172.5 163t-255 63 q-105 0 -196 -29t-154.5 -77t-109 -110.5t-67 -129.5t-21.5 -134q0 -104 40 -183t117 -111q30 -12 38 20q2 7 8 31t8 30q6 23 -11 43q-51 61 -51 151q0 151 104.5 259.5t273.5 108.5q151 0 235.5 -82t84.5 -213q0 -170 -68.5 -289t-175.5 -119q-61 0 -98 43.5t-23 104.5 q8 35 26.5 93.5t30 103t11.5 75.5q0 50 -27 83t-77 33q-62 0 -105 -57t-43 -142q0 -73 25 -122l-99 -418q-17 -70 -13 -177q-206 91 -333 281t-127 423z" />
+<glyph unicode="&#xf0d3;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-725q85 122 108 210q9 34 53 209q21 -39 73.5 -67t112.5 -28q181 0 295.5 147.5t114.5 373.5q0 84 -35 162.5t-96.5 139t-152.5 97t-197 36.5 q-104 0 -194.5 -28.5t-153 -76.5t-107.5 -109.5t-66.5 -128t-21.5 -132.5q0 -102 39.5 -180t116.5 -110q13 -5 23.5 0t14.5 19q10 44 15 61q6 23 -11 42q-50 62 -50 150q0 150 103.5 256.5t270.5 106.5q149 0 232.5 -81t83.5 -210q0 -168 -67.5 -286t-173.5 -118 q-60 0 -97 43.5t-23 103.5q8 34 26.5 92.5t29.5 102t11 74.5q0 49 -26.5 81.5t-75.5 32.5q-61 0 -103.5 -56.5t-42.5 -139.5q0 -72 24 -121l-98 -414q-24 -100 -7 -254h-183q-119 0 -203.5 84.5t-84.5 203.5z" />
+<glyph unicode="&#xf0d4;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM276 309q0 -43 18.5 -77.5t48.5 -56.5t69 -37t77.5 -21t76.5 -6q60 0 120.5 15.5t113.5 46t86 82.5t33 117 q0 49 -20 89.5t-49 66.5t-58 47.5t-49 44t-20 44.5t15.5 42.5t37.5 39.5t44 42t37.5 59.5t15.5 82.5q0 60 -22.5 99.5t-72.5 90.5h83l88 64h-265q-85 0 -161 -32t-127.5 -98t-51.5 -153q0 -93 64.5 -154.5t158.5 -61.5q22 0 43 3q-13 -29 -13 -54q0 -44 40 -94 q-175 -12 -257 -63q-47 -29 -75.5 -73t-28.5 -95zM395 338q0 46 25 80t65.5 51.5t82 25t84.5 7.5q20 0 31 -2q2 -1 23 -16.5t26 -19t23 -18t24.5 -22t19 -22.5t17 -26t9 -26.5t4.5 -31.5q0 -76 -58.5 -112.5t-139.5 -36.5q-41 0 -80.5 9.5t-75.5 28.5t-58 53t-22 78z M462 969q0 61 32 104t92 43q53 0 93.5 -45t58 -101t17.5 -107q0 -60 -33 -99.5t-92 -39.5q-53 0 -93 42.5t-57.5 96.5t-17.5 106zM960 672h128v-160h64v160h128v64h-128v128h-64v-128h-128v-64z" />
+<glyph unicode="&#xf0d5;" horiz-adv-x="1664" d="M32 182q0 81 44.5 150t118.5 115q131 82 404 100q-32 42 -47.5 74t-15.5 73q0 36 21 85q-46 -4 -68 -4q-148 0 -249.5 96.5t-101.5 244.5q0 82 36 159t99 131q77 66 182.5 98t217.5 32h418l-138 -88h-131q74 -63 112 -133t38 -160q0 -72 -24.5 -129.5t-59 -93t-69.5 -65 t-59.5 -61.5t-24.5 -66q0 -36 32 -70.5t77.5 -68t90.5 -73.5t77 -104t32 -142q0 -90 -48 -173q-72 -122 -211 -179.5t-298 -57.5q-132 0 -246.5 41.5t-171.5 137.5q-37 60 -37 131zM218 228q0 -70 35 -123.5t91.5 -83t119 -44t127.5 -14.5q58 0 111.5 13t99 39t73 73 t27.5 109q0 25 -7 49t-14.5 42t-27 41.5t-29.5 35t-38.5 34.5t-36.5 29t-41.5 30t-36.5 26q-16 2 -48 2q-53 0 -105 -7t-107.5 -25t-97 -46t-68.5 -74.5t-27 -105.5zM324 1222q0 -46 10 -97.5t31.5 -103t52 -92.5t75 -67t96.5 -26q38 0 78 16.5t66 43.5q53 57 53 159 q0 58 -17 125t-48.5 129.5t-84.5 103.5t-117 41q-42 0 -82.5 -19.5t-65.5 -52.5q-47 -59 -47 -160zM1084 731v108h212v217h105v-217h213v-108h-213v-219h-105v219h-212z" />
+<glyph unicode="&#xf0d6;" horiz-adv-x="1920" d="M0 64v1152q0 26 19 45t45 19h1792q26 0 45 -19t19 -45v-1152q0 -26 -19 -45t-45 -19h-1792q-26 0 -45 19t-19 45zM128 384q106 0 181 -75t75 -181h1152q0 106 75 181t181 75v512q-106 0 -181 75t-75 181h-1152q0 -106 -75 -181t-181 -75v-512zM640 640q0 70 21 142 t59.5 134t101.5 101t138 39t138 -39t101.5 -101t59.5 -134t21 -142t-21 -142t-59.5 -134t-101.5 -101t-138 -39t-138 39t-101.5 101t-59.5 134t-21 142zM762 791l77 -80q42 37 55 57h2v-288h-128v-96h384v96h-128v448h-114z" />
+<glyph unicode="&#xf0d7;" horiz-adv-x="1024" d="M0 832q0 26 19 45t45 19h896q26 0 45 -19t19 -45t-19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45z" />
+<glyph unicode="&#xf0d8;" horiz-adv-x="1024" d="M0 320q0 26 19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45t-19 -45t-45 -19h-896q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf0d9;" horiz-adv-x="640" d="M64 640q0 26 19 45l448 448q19 19 45 19t45 -19t19 -45v-896q0 -26 -19 -45t-45 -19t-45 19l-448 448q-19 19 -19 45z" />
+<glyph unicode="&#xf0da;" horiz-adv-x="640" d="M0 192v896q0 26 19 45t45 19t45 -19l448 -448q19 -19 19 -45t-19 -45l-448 -448q-19 -19 -45 -19t-45 19t-19 45z" />
+<glyph unicode="&#xf0db;" horiz-adv-x="1664" d="M0 32v1216q0 66 47 113t113 47h1344q66 0 113 -47t47 -113v-1216q0 -66 -47 -113t-113 -47h-1344q-66 0 -113 47t-47 113zM128 32q0 -13 9.5 -22.5t22.5 -9.5h608v1152h-640v-1120zM896 0h608q13 0 22.5 9.5t9.5 22.5v1120h-640v-1152z" />
+<glyph unicode="&#xf0dc;" horiz-adv-x="1024" d="M0 448q0 26 19 45t45 19h896q26 0 45 -19t19 -45t-19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45zM0 832q0 26 19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45t-19 -45t-45 -19h-896q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf0dd;" horiz-adv-x="1024" d="M0 448q0 26 19 45t45 19h896q26 0 45 -19t19 -45t-19 -45l-448 -448q-19 -19 -45 -19t-45 19l-448 448q-19 19 -19 45z" />
+<glyph unicode="&#xf0de;" horiz-adv-x="1024" d="M0 832q0 26 19 45l448 448q19 19 45 19t45 -19l448 -448q19 -19 19 -45t-19 -45t-45 -19h-896q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf0e0;" horiz-adv-x="1792" d="M0 32v794q44 -49 101 -87q362 -246 497 -345q57 -42 92.5 -65.5t94.5 -48t110 -24.5h1h1q51 0 110 24.5t94.5 48t92.5 65.5q170 123 498 345q57 39 100 87v-794q0 -66 -47 -113t-113 -47h-1472q-66 0 -113 47t-47 113zM0 1098q0 78 41.5 130t118.5 52h1472 q65 0 112.5 -47t47.5 -113q0 -79 -49 -151t-122 -123q-376 -261 -468 -325q-10 -7 -42.5 -30.5t-54 -38t-52 -32.5t-57.5 -27t-50 -9h-1h-1q-23 0 -50 9t-57.5 27t-52 32.5t-54 38t-42.5 30.5q-91 64 -262 182.5t-205 142.5q-62 42 -117 115.5t-55 136.5z" />
+<glyph unicode="&#xf0e1;" d="M0 1217q0 74 51.5 122.5t134.5 48.5t133 -48.5t51 -122.5q1 -73 -50.5 -122t-135.5 -49h-2q-82 0 -132 49t-50 122zM19 -80v991h330v-991h-330zM531 -80q2 399 2 647t-1 296l-1 48h329v-144h-2q20 32 41 56t56.5 52t87 43.5t114.5 15.5q171 0 275 -113.5t104 -332.5v-568 h-329v530q0 105 -40.5 164.5t-126.5 59.5q-63 0 -105.5 -34.5t-63.5 -85.5q-11 -30 -11 -81v-553h-329z" />
+<glyph unicode="&#xf0e2;" d="M0 832v448q0 42 40 59q39 17 69 -14l130 -129q107 101 244.5 156.5t284.5 55.5q156 0 298 -61t245 -164t164 -245t61 -298t-61 -298t-164 -245t-245 -164t-298 -61q-172 0 -327 72.5t-264 204.5q-7 10 -6.5 22.5t8.5 20.5l137 138q10 9 25 9q16 -2 23 -12 q73 -95 179 -147t225 -52q104 0 198.5 40.5t163.5 109.5t109.5 163.5t40.5 198.5t-40.5 198.5t-109.5 163.5t-163.5 109.5t-198.5 40.5q-98 0 -188 -35.5t-160 -101.5l137 -138q31 -30 14 -69q-17 -40 -59 -40h-448q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf0e3;" horiz-adv-x="1792" d="M40 736q0 13 4.5 26t9 22t15.5 22t16.5 18.5t20.5 19t18 16.5q30 28 68 28q10 0 18 -1.5t16.5 -5.5t13.5 -6t13.5 -10t11.5 -10t13 -12.5t12 -12.5q-14 14 -14 34t14 34l348 348q14 14 34 14t34 -14q-2 2 -12.5 12t-12.5 13t-10 11.5t-10 13.5t-6 13.5t-5.5 16.5t-1.5 18 q0 38 28 68q3 3 16.5 18t19 20.5t18.5 16.5t22 15.5t22 9t26 4.5q40 0 68 -28l408 -408q28 -28 28 -68q0 -13 -4.5 -26t-9 -22t-15.5 -22t-16.5 -18.5t-20.5 -19t-18 -16.5q-30 -28 -68 -28q-10 0 -18 1.5t-16.5 5.5t-13.5 6t-13.5 10t-11.5 10t-13 12.5t-12 12.5 q14 -14 14 -34t-14 -34l-126 -126l256 -256q43 43 96 43q52 0 91 -37l363 -363q37 -39 37 -91q0 -53 -37 -90l-107 -108q-39 -37 -91 -37q-53 0 -90 37l-363 364q-38 36 -38 90q0 53 43 96l-256 256l-126 -126q-14 -14 -34 -14t-34 14q2 -2 12.5 -12t12.5 -13t10 -11.5 t10 -13.5t6 -13.5t5.5 -16.5t1.5 -18q0 -38 -28 -68q-3 -3 -16.5 -18t-19 -20.5t-18.5 -16.5t-22 -15.5t-22 -9t-26 -4.5q-40 0 -68 28l-408 408q-28 28 -28 68z" />
+<glyph unicode="&#xf0e4;" horiz-adv-x="1792" d="M0 384q0 182 71 348t191 286t286 191t348 71t348 -71t286 -191t191 -286t71 -348q0 -261 -141 -483q-19 -29 -54 -29h-1402q-35 0 -54 29q-141 221 -141 483zM128 384q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5z M320 832q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5zM710 241q-20 -77 20 -146t117 -89t146 20t89 117q16 60 -6 117t-72 91l101 382q6 26 -7.5 48.5t-38.5 29.5t-48 -6.5t-30 -39.5l-101 -382q-60 -5 -107 -43.5 t-63 -98.5zM768 1024q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5zM1216 832q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5zM1408 384q0 -53 37.5 -90.5 t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5z" />
+<glyph unicode="&#xf0e5;" horiz-adv-x="1792" d="M0 640q0 174 120 321.5t326 233t450 85.5t450 -85.5t326 -233t120 -321.5t-120 -321.5t-326 -233t-450 -85.5q-70 0 -145 8q-198 -175 -460 -242q-49 -14 -114 -22h-5q-15 0 -27 10.5t-16 27.5v1q-3 4 -0.5 12t2 10t4.5 9.5l6 9t7 8.5t8 9q7 8 31 34.5t34.5 38t31 39.5 t32.5 51t27 59t26 76q-157 89 -247.5 220t-90.5 281zM128 640q0 -112 71.5 -213.5t201.5 -175.5l87 -50l-27 -96q-24 -91 -70 -172q152 63 275 171l43 38l57 -6q69 -8 130 -8q204 0 381.5 69.5t282 187.5t104.5 255t-104.5 255t-282 187.5t-381.5 69.5t-381.5 -69.5 t-282 -187.5t-104.5 -255z" />
+<glyph unicode="&#xf0e6;" horiz-adv-x="1792" d="M0 768q0 139 94 257t256.5 186.5t353.5 68.5t353.5 -68.5t256.5 -186.5t94 -257t-94 -257t-256.5 -186.5t-353.5 -68.5q-86 0 -176 16q-124 -88 -278 -128q-36 -9 -86 -16h-3q-11 0 -20.5 8t-11.5 21q-1 3 -1 6.5t0.5 6.5t2 6l2.5 5t3.5 5.5t4 5t4.5 5t4 4.5q5 6 23 25 t26 29.5t22.5 29t25 38.5t20.5 44q-124 72 -195 177t-71 224zM128 768q0 -82 53 -158t149 -132l97 -56l-35 -84q34 20 62 39l44 31l53 -10q78 -14 153 -14q153 0 286 52t211.5 141t78.5 191t-78.5 191t-211.5 141t-286 52t-286 -52t-211.5 -141t-78.5 -191zM616 132 q58 -4 88 -4q161 0 309 45t264 129q125 92 192 212t67 254q0 77 -23 152q129 -71 204 -178t75 -230q0 -120 -71 -224.5t-195 -176.5q10 -24 20.5 -44t25 -38.5t22.5 -29t26 -29.5t23 -25q1 -1 4 -4.5t4.5 -5t4 -5t3.5 -5.5l2.5 -5t2 -6t0.5 -6.5t-1 -6.5q-3 -14 -13 -22 t-22 -7q-50 7 -86 16q-154 40 -278 128q-90 -16 -176 -16q-271 0 -472 132z" />
+<glyph unicode="&#xf0e7;" horiz-adv-x="896" d="M1 551l201 825q4 14 16 23t28 9h328q19 0 32 -12.5t13 -29.5q0 -8 -5 -18l-171 -463l396 98q8 2 12 2q19 0 34 -15q18 -20 7 -44l-540 -1157q-13 -25 -42 -25q-4 0 -14 2q-17 5 -25.5 19t-4.5 30l197 808l-406 -101q-4 -1 -12 -1q-18 0 -31 11q-18 15 -13 39z" />
+<glyph unicode="&#xf0e8;" horiz-adv-x="1792" d="M0 -32v320q0 40 28 68t68 28h96v192q0 52 38 90t90 38h512v192h-96q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-96v-192h512q52 0 90 -38t38 -90v-192h96q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-320 q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h96v192h-512v-192h96q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68v320q0 40 28 68t68 28h96v192h-512v-192h96q40 0 68 -28t28 -68v-320q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf0e9;" horiz-adv-x="1664" d="M0 681q0 5 1 7q45 183 172.5 319.5t298 204.5t360.5 68q140 0 274.5 -40t246.5 -113.5t194.5 -187t115.5 -251.5q1 -2 1 -7q0 -13 -9.5 -22.5t-22.5 -9.5q-11 0 -23 10q-49 46 -93 69t-102 23q-68 0 -128 -37t-103 -97q-7 -10 -17.5 -28t-14.5 -24q-11 -17 -28 -17 q-18 0 -29 17q-4 6 -14.5 24t-17.5 28q-43 60 -102.5 97t-127.5 37t-127.5 -37t-102.5 -97q-7 -10 -17.5 -28t-14.5 -24q-11 -17 -29 -17q-17 0 -28 17q-4 6 -14.5 24t-17.5 28q-43 60 -103 97t-128 37q-58 0 -102 -23t-93 -69q-12 -10 -23 -10q-13 0 -22.5 9.5t-9.5 22.5z M384 128q0 26 19 45t45 19t45 -19t19 -45q0 -50 39 -89t89 -39t89 39t39 89v580q33 11 64 11t64 -11v-580q0 -104 -76 -180t-180 -76t-180 76t-76 180zM768 1310v98q0 26 19 45t45 19t45 -19t19 -45v-98q-42 2 -64 2t-64 -2z" />
+<glyph unicode="&#xf0ea;" horiz-adv-x="1792" d="M0 96v1344q0 40 28 68t68 28h1088q40 0 68 -28t28 -68v-328q21 -13 36 -28l408 -408q28 -28 48 -76t20 -88v-672q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v160h-544q-40 0 -68 28t-28 68zM256 1312q0 -13 9.5 -22.5t22.5 -9.5h704q13 0 22.5 9.5t9.5 22.5v64 q0 13 -9.5 22.5t-22.5 9.5h-704q-13 0 -22.5 -9.5t-9.5 -22.5v-64zM768 -128h896v640h-416q-40 0 -68 28t-28 68v416h-384v-1152zM1280 640h299l-299 299v-299z" />
+<glyph unicode="&#xf0eb;" horiz-adv-x="1024" d="M0 960q0 99 44.5 184.5t117 142t164 89t186.5 32.5t186.5 -32.5t164 -89t117 -142t44.5 -184.5q0 -155 -103 -268q-45 -49 -74.5 -87t-59.5 -95.5t-34 -107.5q47 -28 47 -82q0 -37 -25 -64q25 -27 25 -64q0 -52 -45 -81q13 -23 13 -47q0 -46 -31.5 -71t-77.5 -25 q-20 -44 -60 -70t-87 -26t-87 26t-60 70q-46 0 -77.5 25t-31.5 71q0 24 13 47q-45 29 -45 81q0 37 25 64q-25 27 -25 64q0 54 47 82q-4 50 -34 107.5t-59.5 95.5t-74.5 87q-103 113 -103 268zM128 960q0 -101 68 -180q10 -11 30.5 -33t30.5 -33q128 -153 141 -298h228 q13 145 141 298q10 11 30.5 33t30.5 33q68 79 68 180q0 72 -34.5 134t-90 101.5t-123 62t-136.5 22.5t-136.5 -22.5t-123 -62t-90 -101.5t-34.5 -134zM480 1088q0 13 9.5 22.5t22.5 9.5q50 0 99.5 -16t87 -54t37.5 -90q0 -13 -9.5 -22.5t-22.5 -9.5t-22.5 9.5t-9.5 22.5 q0 46 -54 71t-106 25q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0ec;" horiz-adv-x="1792" d="M0 256q0 14 9 23l320 320q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5v-192h1376q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-1376v-192q0 -13 -9.5 -22.5t-22.5 -9.5q-12 0 -24 10l-319 320q-9 9 -9 22zM0 800v192q0 13 9.5 22.5t22.5 9.5h1376v192q0 14 9 23 t23 9q12 0 24 -10l319 -319q9 -9 9 -23t-9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192h-1376q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0ed;" horiz-adv-x="1920" d="M0 448q0 130 70 240t188 165q-2 30 -2 43q0 212 150 362t362 150q156 0 285.5 -87t188.5 -231q71 62 166 62q106 0 181 -75t75 -181q0 -76 -41 -138q130 -31 213.5 -135.5t83.5 -238.5q0 -159 -112.5 -271.5t-271.5 -112.5h-1088q-185 0 -316.5 131.5t-131.5 316.5z M512 608q0 -14 9 -23l352 -352q9 -9 23 -9t23 9l351 351q10 12 10 24q0 14 -9 23t-23 9h-224v352q0 13 -9.5 22.5t-22.5 9.5h-192q-13 0 -22.5 -9.5t-9.5 -22.5v-352h-224q-13 0 -22.5 -9.5t-9.5 -22.5z" />
+<glyph unicode="&#xf0ee;" horiz-adv-x="1920" d="M0 448q0 130 70 240t188 165q-2 30 -2 43q0 212 150 362t362 150q156 0 285.5 -87t188.5 -231q71 62 166 62q106 0 181 -75t75 -181q0 -76 -41 -138q130 -31 213.5 -135.5t83.5 -238.5q0 -159 -112.5 -271.5t-271.5 -112.5h-1088q-185 0 -316.5 131.5t-131.5 316.5z M512 672q0 -14 9 -23t23 -9h224v-352q0 -13 9.5 -22.5t22.5 -9.5h192q13 0 22.5 9.5t9.5 22.5v352h224q13 0 22.5 9.5t9.5 22.5q0 14 -9 23l-352 352q-9 9 -23 9t-23 -9l-351 -351q-10 -12 -10 -24z" />
+<glyph unicode="&#xf0f0;" horiz-adv-x="1408" d="M0 131q0 68 5.5 131t24 138t47.5 132.5t81 103t120 60.5q-22 -52 -22 -120v-203q-58 -20 -93 -70t-35 -111q0 -80 56 -136t136 -56t136 56t56 136q0 61 -35.5 111t-92.5 70v203q0 62 25 93q132 -104 295 -104t295 104q25 -31 25 -93v-64q-106 0 -181 -75t-75 -181v-89 q-32 -29 -32 -71q0 -40 28 -68t68 -28t68 28t28 68q0 42 -32 71v89q0 52 38 90t90 38t90 -38t38 -90v-89q-32 -29 -32 -71q0 -40 28 -68t68 -28t68 28t28 68q0 42 -32 71v89q0 68 -34.5 127.5t-93.5 93.5q0 10 0.5 42.5t0 48t-2.5 41.5t-7 47t-13 40q68 -15 120 -60.5 t81 -103t47.5 -132.5t24 -138t5.5 -131q0 -121 -73 -190t-194 -69h-874q-121 0 -194 69t-73 190zM256 192q0 26 19 45t45 19t45 -19t19 -45t-19 -45t-45 -19t-45 19t-19 45zM320 1024q0 159 112.5 271.5t271.5 112.5t271.5 -112.5t112.5 -271.5t-112.5 -271.5t-271.5 -112.5 t-271.5 112.5t-112.5 271.5z" />
+<glyph unicode="&#xf0f1;" horiz-adv-x="1408" d="M0 768v512q0 26 19 45t45 19q6 0 16 -2q17 30 47 48t65 18q53 0 90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5q-33 0 -64 18v-402q0 -106 94 -181t226 -75t226 75t94 181v402q-31 -18 -64 -18q-53 0 -90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5q35 0 65 -18t47 -48 q10 2 16 2q26 0 45 -19t19 -45v-512q0 -144 -110 -252t-274 -128v-132q0 -106 94 -181t226 -75t226 75t94 181v395q-57 21 -92.5 70t-35.5 111q0 80 56 136t136 56t136 -56t56 -136q0 -62 -35.5 -111t-92.5 -70v-395q0 -159 -131.5 -271.5t-316.5 -112.5t-316.5 112.5 t-131.5 271.5v132q-164 20 -274 128t-110 252zM1152 832q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf0f2;" horiz-adv-x="1792" d="M0 96v832q0 92 66 158t158 66h64v-1280h-64q-92 0 -158 66t-66 158zM384 -128v1280h128v160q0 40 28 68t68 28h576q40 0 68 -28t28 -68v-160h128v-1280h-1024zM640 1152h512v128h-512v-128zM1504 -128v1280h64q92 0 158 -66t66 -158v-832q0 -92 -66 -158t-158 -66h-64z " />
+<glyph unicode="&#xf0f3;" horiz-adv-x="1664" d="M0 128q190 161 287 397.5t97 498.5q0 165 96 262t264 117q-8 18 -8 37q0 40 28 68t68 28t68 -28t28 -68q0 -19 -8 -37q168 -20 264 -117t96 -262q0 -262 97 -498.5t287 -397.5q0 -52 -38 -90t-90 -38h-448q0 -106 -75 -181t-181 -75t-181 75t-75 181h-448q-52 0 -90 38 t-38 90zM656 0q0 -73 51.5 -124.5t124.5 -51.5q16 0 16 16t-16 16q-59 0 -101.5 42.5t-42.5 101.5q0 16 -16 16t-16 -16z" />
+<glyph unicode="&#xf0f4;" horiz-adv-x="1920" d="M0 128h1792q0 -106 -75 -181t-181 -75h-1280q-106 0 -181 75t-75 181zM256 480v736q0 26 19 45t45 19h1152q159 0 271.5 -112.5t112.5 -271.5t-112.5 -271.5t-271.5 -112.5h-64v-32q0 -92 -66 -158t-158 -66h-704q-92 0 -158 66t-66 158zM1408 704h64q80 0 136 56t56 136 t-56 136t-136 56h-64v-384z" />
+<glyph unicode="&#xf0f5;" horiz-adv-x="1408" d="M0 832v640q0 26 19 45t45 19t45 -19t19 -45v-416q0 -26 19 -45t45 -19t45 19t19 45v416q0 26 19 45t45 19t45 -19t19 -45v-416q0 -26 19 -45t45 -19t45 19t19 45v416q0 26 19 45t45 19t45 -19t19 -45v-640q0 -61 -35.5 -111t-92.5 -70v-779q0 -52 -38 -90t-90 -38h-128 q-52 0 -90 38t-38 90v779q-57 20 -92.5 70t-35.5 111zM768 416v800q0 132 94 226t226 94h256q26 0 45 -19t19 -45v-1600q0 -52 -38 -90t-90 -38h-128q-52 0 -90 38t-38 90v512h-224q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0f6;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM384 160v64q0 14 9 23t23 9h704q14 0 23 -9t9 -23v-64 q0 -14 -9 -23t-23 -9h-704q-14 0 -23 9t-9 23zM384 416v64q0 14 9 23t23 9h704q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-704q-14 0 -23 9t-9 23zM384 672v64q0 14 9 23t23 9h704q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-704q-14 0 -23 9t-9 23zM1024 1024h376 q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf0f7;" horiz-adv-x="1408" d="M0 -192v1664q0 26 19 45t45 19h1280q26 0 45 -19t19 -45v-1664q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45zM128 -128h384v224q0 13 9.5 22.5t22.5 9.5h320q13 0 22.5 -9.5t9.5 -22.5v-224h384v1536h-1152v-1536zM256 160v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 672v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 928v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 1184v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 672v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 928v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 1184v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM768 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM768 672v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM768 928v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM768 1184v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 160v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 416v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 672v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 928v64q0 13 9.5 22.5t22.5 9.5h64 q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 1184v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0f8;" horiz-adv-x="1408" d="M0 -192v1280q0 26 19 45t45 19h320v288q0 40 28 68t68 28h448q40 0 68 -28t28 -68v-288h320q26 0 45 -19t19 -45v-1280q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45zM128 -128h384v224q0 13 9.5 22.5t22.5 9.5h320q13 0 22.5 -9.5t9.5 -22.5v-224h384v1152h-256 v-32q0 -40 -28 -68t-68 -28h-448q-40 0 -68 28t-28 68v32h-256v-1152zM256 160v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5 v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM256 672v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64 q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 672v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM512 1056q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5v96h128 v-96q0 -13 9.5 -22.5t22.5 -9.5h64q13 0 22.5 9.5t9.5 22.5v320q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-96h-128v96q0 13 -9.5 22.5t-22.5 9.5h-64q-13 0 -22.5 -9.5t-9.5 -22.5v-320zM768 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5 v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM768 672v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 160v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5 v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 416v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5zM1024 672v64q0 13 9.5 22.5t22.5 9.5h64q13 0 22.5 -9.5t9.5 -22.5 v-64q0 -13 -9.5 -22.5t-22.5 -9.5h-64q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf0f9;" horiz-adv-x="1920" d="M64 192q0 26 19 45t45 19v416q0 26 13 58t32 51l198 198q19 19 51 32t58 13h160v320q0 26 19 45t45 19h1152q26 0 45 -19t19 -45v-1152q0 -26 -19 -45t-45 -19h-192q0 -106 -75 -181t-181 -75t-181 75t-75 181h-384q0 -106 -75 -181t-181 -75t-181 75t-75 181h-128 q-26 0 -45 19t-19 45zM256 640h384v256h-158q-14 -2 -22 -9l-195 -195q-7 -12 -9 -22v-30zM384 128q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5zM896 800q0 -14 9 -23t23 -9h224v-224q0 -14 9 -23t23 -9h192 q14 0 23 9t9 23v224h224q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-224v224q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-224h-224q-14 0 -23 -9t-9 -23v-192zM1280 128q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5z" />
+<glyph unicode="&#xf0fa;" horiz-adv-x="1792" d="M0 96v832q0 92 66 158t158 66h32v-1280h-32q-92 0 -158 66t-66 158zM352 -128v1280h160v160q0 40 28 68t68 28h576q40 0 68 -28t28 -68v-160h160v-1280h-1088zM512 416q0 -14 9 -23t23 -9h224v-224q0 -14 9 -23t23 -9h192q14 0 23 9t9 23v224h224q14 0 23 9t9 23v192 q0 14 -9 23t-23 9h-224v224q0 14 -9 23t-23 9h-192q-14 0 -23 -9t-9 -23v-224h-224q-14 0 -23 -9t-9 -23v-192zM640 1152h512v128h-512v-128zM1536 -128v1280h32q92 0 158 -66t66 -158v-832q0 -92 -66 -158t-158 -66h-32z" />
+<glyph unicode="&#xf0fb;" horiz-adv-x="1920" d="M0 512v128l192 24v8h-128v32h-32v192l32 32h96l192 -224h160v416h-64v32h64h160h96q26 0 45 -4.5t19 -11.5t-19 -11.5t-45 -4.5h-69l293 -352h64l224 -64l352 -32q261 -58 287 -93l1 -3q-1 -32 -288 -96l-352 -32l-224 -64h-64l-293 -352h69q26 0 45 -4.5t19 -11.5 t-19 -11.5t-45 -4.5h-96h-160h-64v32h64v416h-160l-192 -224h-96l-32 32v192h32v32h128v8z" />
+<glyph unicode="&#xf0fc;" horiz-adv-x="1664" d="M64 1152l32 128h480l32 128h960l32 -192l-64 -32v-800l128 -192v-192h-1152v192l128 192h-128q-159 0 -271.5 112.5t-112.5 271.5v320zM384 768q0 -53 37.5 -90.5t90.5 -37.5h128v384h-256v-256z" />
+<glyph unicode="&#xf0fd;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 192q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v320h512v-320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45 v896q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-320h-512v320q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-896z" />
+<glyph unicode="&#xf0fe;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 576q0 -26 19 -45t45 -19h320v-320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v320h320q26 0 45 19t19 45 v128q0 26 -19 45t-45 19h-320v320q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-320h-320q-26 0 -45 -19t-19 -45v-128z" />
+<glyph unicode="&#xf100;" horiz-adv-x="1024" d="M45 576q0 13 10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23zM429 576q0 13 10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23 l-393 -393l393 -393q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23z" />
+<glyph unicode="&#xf101;" horiz-adv-x="1024" d="M13 160q0 13 10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23zM397 160q0 13 10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10 l466 -466q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23z" />
+<glyph unicode="&#xf102;" horiz-adv-x="1152" d="M77 224q0 13 10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23zM77 608q0 13 10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23 l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23z" />
+<glyph unicode="&#xf103;" horiz-adv-x="1152" d="M77 672q0 13 10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23zM77 1056q0 13 10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10 l50 -50q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23z" />
+<glyph unicode="&#xf104;" horiz-adv-x="640" d="M45 576q0 13 10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23z" />
+<glyph unicode="&#xf105;" horiz-adv-x="640" d="M13 160q0 13 10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23z" />
+<glyph unicode="&#xf106;" horiz-adv-x="1152" d="M77 352q0 13 10 23l466 466q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-393 393l-393 -393q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23z" />
+<glyph unicode="&#xf107;" horiz-adv-x="1152" d="M77 800q0 13 10 23l50 50q10 10 23 10t23 -10l393 -393l393 393q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23z" />
+<glyph unicode="&#xf108;" horiz-adv-x="1920" d="M0 288v1088q0 66 47 113t113 47h1600q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-544q0 -37 16 -77.5t32 -71t16 -43.5q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45q0 14 16 44t32 70t16 78h-544q-66 0 -113 47t-47 113zM128 544q0 -13 9.5 -22.5 t22.5 -9.5h1600q13 0 22.5 9.5t9.5 22.5v832q0 13 -9.5 22.5t-22.5 9.5h-1600q-13 0 -22.5 -9.5t-9.5 -22.5v-832z" />
+<glyph unicode="&#xf109;" horiz-adv-x="1920" d="M0 96v96h160h1600h160v-96q0 -40 -47 -68t-113 -28h-1600q-66 0 -113 28t-47 68zM256 416v704q0 66 47 113t113 47h1088q66 0 113 -47t47 -113v-704q0 -66 -47 -113t-113 -47h-1088q-66 0 -113 47t-47 113zM384 416q0 -13 9.5 -22.5t22.5 -9.5h1088q13 0 22.5 9.5 t9.5 22.5v704q0 13 -9.5 22.5t-22.5 9.5h-1088q-13 0 -22.5 -9.5t-9.5 -22.5v-704zM864 112q0 -16 16 -16h160q16 0 16 16t-16 16h-160q-16 0 -16 -16z" />
+<glyph unicode="&#xf10a;" horiz-adv-x="1152" d="M0 160v1088q0 66 47 113t113 47h832q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-832q-66 0 -113 47t-47 113zM128 288q0 -13 9.5 -22.5t22.5 -9.5h832q13 0 22.5 9.5t9.5 22.5v960q0 13 -9.5 22.5t-22.5 9.5h-832q-13 0 -22.5 -9.5t-9.5 -22.5v-960zM512 128 q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf10b;" horiz-adv-x="768" d="M0 128v1024q0 52 38 90t90 38h512q52 0 90 -38t38 -90v-1024q0 -52 -38 -90t-90 -38h-512q-52 0 -90 38t-38 90zM96 288q0 -13 9.5 -22.5t22.5 -9.5h512q13 0 22.5 9.5t9.5 22.5v704q0 13 -9.5 22.5t-22.5 9.5h-512q-13 0 -22.5 -9.5t-9.5 -22.5v-704zM288 1136 q0 -16 16 -16h160q16 0 16 16t-16 16h-160q-16 0 -16 -16zM304 128q0 -33 23.5 -56.5t56.5 -23.5t56.5 23.5t23.5 56.5t-23.5 56.5t-56.5 23.5t-56.5 -23.5t-23.5 -56.5z" />
+<glyph unicode="&#xf10c;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273z" />
+<glyph unicode="&#xf10d;" horiz-adv-x="1664" d="M0 192v704q0 104 40.5 198.5t109.5 163.5t163.5 109.5t198.5 40.5h64q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-64q-106 0 -181 -75t-75 -181v-32q0 -40 28 -68t68 -28h224q80 0 136 -56t56 -136v-384q0 -80 -56 -136t-136 -56h-384q-80 0 -136 56t-56 136z M896 192v704q0 104 40.5 198.5t109.5 163.5t163.5 109.5t198.5 40.5h64q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-64q-106 0 -181 -75t-75 -181v-32q0 -40 28 -68t68 -28h224q80 0 136 -56t56 -136v-384q0 -80 -56 -136t-136 -56h-384q-80 0 -136 56t-56 136z" />
+<glyph unicode="&#xf10e;" horiz-adv-x="1664" d="M0 832v384q0 80 56 136t136 56h384q80 0 136 -56t56 -136v-704q0 -104 -40.5 -198.5t-109.5 -163.5t-163.5 -109.5t-198.5 -40.5h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h64q106 0 181 75t75 181v32q0 40 -28 68t-68 28h-224q-80 0 -136 56t-56 136zM896 832v384 q0 80 56 136t136 56h384q80 0 136 -56t56 -136v-704q0 -104 -40.5 -198.5t-109.5 -163.5t-163.5 -109.5t-198.5 -40.5h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h64q106 0 181 75t75 181v32q0 40 -28 68t-68 28h-224q-80 0 -136 56t-56 136z" />
+<glyph unicode="&#xf110;" horiz-adv-x="1568" d="M0 640q0 66 47 113t113 47t113 -47t47 -113t-47 -113t-113 -47t-113 47t-47 113zM176 1088q0 73 51.5 124.5t124.5 51.5t124.5 -51.5t51.5 -124.5t-51.5 -124.5t-124.5 -51.5t-124.5 51.5t-51.5 124.5zM208 192q0 60 42 102t102 42q59 0 101.5 -42t42.5 -102t-42.5 -102 t-101.5 -42q-60 0 -102 42t-42 102zM608 1280q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM672 0q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5zM1136 192q0 46 33 79t79 33t79 -33t33 -79 t-33 -79t-79 -33t-79 33t-33 79zM1168 1088q0 33 23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5t-23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5zM1344 640q0 40 28 68t68 28t68 -28t28 -68t-28 -68t-68 -28t-68 28t-28 68z" />
+<glyph unicode="&#xf111;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5z" />
+<glyph unicode="&#xf112;" horiz-adv-x="1792" d="M0 896q0 26 19 45l512 512q19 19 45 19t45 -19t19 -45v-256h224q713 0 875 -403q53 -134 53 -333q0 -166 -127 -451q-3 -7 -10.5 -24t-13.5 -30t-13 -22q-12 -17 -28 -17q-15 0 -23.5 10t-8.5 25q0 9 2.5 26.5t2.5 23.5q5 68 5 123q0 101 -17.5 181t-48.5 138.5t-80 101 t-105.5 69.5t-133 42.5t-154 21.5t-175.5 6h-224v-256q0 -26 -19 -45t-45 -19t-45 19l-512 512q-19 19 -19 45z" />
+<glyph unicode="&#xf113;" horiz-adv-x="1664" d="M0 496q0 237 136 396q-27 82 -27 170q0 116 51 218q108 0 190 -39.5t189 -123.5q147 35 309 35q148 0 280 -32q105 82 187 121t189 39q51 -102 51 -218q0 -87 -27 -168q136 -160 136 -398q0 -207 -61 -331q-38 -77 -105.5 -133t-141 -86t-170 -47.5t-171.5 -22t-167 -4.5 q-78 0 -142 3t-147.5 12.5t-152.5 30t-137 51.5t-121 81t-86 115q-62 123 -62 331zM224 320q0 -88 32 -153.5t81 -103t122 -60t140 -29.5t149 -7h168q82 0 149 7t140 29.5t122 60t81 103t32 153.5q0 120 -69 204t-187 84q-41 0 -195 -21q-71 -11 -157 -11t-157 11 q-152 21 -195 21q-118 0 -187 -84t-69 -204zM384 320q0 40 12.5 82t43 76t72.5 34t72.5 -34t43 -76t12.5 -82t-12.5 -82t-43 -76t-72.5 -34t-72.5 34t-43 76t-12.5 82zM1024 320q0 40 12.5 82t43 76t72.5 34t72.5 -34t43 -76t12.5 -82t-12.5 -82t-43 -76t-72.5 -34t-72.5 34 t-43 76t-12.5 82z" />
+<glyph unicode="&#xf114;" horiz-adv-x="1664" d="M0 224v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h672q92 0 158 -66t66 -158v-704q0 -92 -66 -158t-158 -66h-1216q-92 0 -158 66t-66 158zM128 224q0 -40 28 -68t68 -28h1216q40 0 68 28t28 68v704q0 40 -28 68t-68 28h-704q-40 0 -68 28t-28 68v64 q0 40 -28 68t-68 28h-320q-40 0 -68 -28t-28 -68v-960z" />
+<glyph unicode="&#xf115;" horiz-adv-x="1920" d="M0 224v960q0 92 66 158t158 66h320q92 0 158 -66t66 -158v-32h544q92 0 158 -66t66 -158v-160h192q54 0 99 -24.5t67 -70.5q15 -32 15 -68q0 -62 -46 -120l-295 -363q-43 -53 -116 -87.5t-140 -34.5h-1088q-92 0 -158 66t-66 158zM128 331l256 315q44 53 116 87.5 t140 34.5h768v160q0 40 -28 68t-68 28h-576q-40 0 -68 28t-28 68v64q0 40 -28 68t-68 28h-320q-40 0 -68 -28t-28 -68v-853zM171 163q0 -35 53 -35h1088q40 0 86 22t71 53l294 363q18 22 18 39q0 35 -53 35h-1088q-40 0 -85.5 -21.5t-71.5 -52.5l-294 -363q-18 -24 -18 -40z " />
 <glyph unicode="&#xf116;" horiz-adv-x="1792" />
 <glyph unicode="&#xf117;" horiz-adv-x="1792" />
-<glyph unicode="&#xf118;" d="M1134 461q-37 -121 -138 -195t-228 -74t-228 74t-138 195q-8 25 4 48.5t38 31.5q25 8 48.5 -4t31.5 -38q25 -80 92.5 -129.5t151.5 -49.5t151.5 49.5t92.5 129.5q8 26 32 38t49 4t37 -31.5t4 -48.5zM640 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5 t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1152 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1408 640q0 130 -51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5 t51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf119;" d="M1134 307q8 -25 -4 -48.5t-37 -31.5t-49 4t-32 38q-25 80 -92.5 129.5t-151.5 49.5t-151.5 -49.5t-92.5 -129.5q-8 -26 -31.5 -38t-48.5 -4q-26 8 -38 31.5t-4 48.5q37 121 138 195t228 74t228 -74t138 -195zM640 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5 t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1152 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1408 640q0 130 -51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204 t-51 -248.5t51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf11a;" d="M1152 448q0 -26 -19 -45t-45 -19h-640q-26 0 -45 19t-19 45t19 45t45 19h640q26 0 45 -19t19 -45zM640 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1152 896q0 -53 -37.5 -90.5t-90.5 -37.5t-90.5 37.5 t-37.5 90.5t37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1408 640q0 130 -51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5t51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf11b;" horiz-adv-x="1920" d="M832 448v128q0 14 -9 23t-23 9h-192v192q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-192h-192q-14 0 -23 -9t-9 -23v-128q0 -14 9 -23t23 -9h192v-192q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v192h192q14 0 23 9t9 23zM1408 384q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5 t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1664 640q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM1920 512q0 -212 -150 -362t-362 -150q-192 0 -338 128h-220q-146 -128 -338 -128q-212 0 -362 150 t-150 362t150 362t362 150h896q212 0 362 -150t150 -362z" />
-<glyph unicode="&#xf11c;" horiz-adv-x="1920" d="M384 368v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM512 624v-96q0 -16 -16 -16h-224q-16 0 -16 16v96q0 16 16 16h224q16 0 16 -16zM384 880v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1408 368v-96q0 -16 -16 -16 h-864q-16 0 -16 16v96q0 16 16 16h864q16 0 16 -16zM768 624v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM640 880v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1024 624v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16 h96q16 0 16 -16zM896 880v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1280 624v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1664 368v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1152 880v-96 q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1408 880v-96q0 -16 -16 -16h-96q-16 0 -16 16v96q0 16 16 16h96q16 0 16 -16zM1664 880v-352q0 -16 -16 -16h-224q-16 0 -16 16v96q0 16 16 16h112v240q0 16 16 16h96q16 0 16 -16zM1792 128v896h-1664v-896 h1664zM1920 1024v-896q0 -53 -37.5 -90.5t-90.5 -37.5h-1664q-53 0 -90.5 37.5t-37.5 90.5v896q0 53 37.5 90.5t90.5 37.5h1664q53 0 90.5 -37.5t37.5 -90.5z" />
-<glyph unicode="&#xf11d;" horiz-adv-x="1792" d="M1664 491v616q-169 -91 -306 -91q-82 0 -145 32q-100 49 -184 76.5t-178 27.5q-173 0 -403 -127v-599q245 113 433 113q55 0 103.5 -7.5t98 -26t77 -31t82.5 -39.5l28 -14q44 -22 101 -22q120 0 293 92zM320 1280q0 -35 -17.5 -64t-46.5 -46v-1266q0 -14 -9 -23t-23 -9 h-64q-14 0 -23 9t-9 23v1266q-29 17 -46.5 46t-17.5 64q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1792 1216v-763q0 -39 -35 -57q-10 -5 -17 -9q-218 -116 -369 -116q-88 0 -158 35l-28 14q-64 33 -99 48t-91 29t-114 14q-102 0 -235.5 -44t-228.5 -102 q-15 -9 -33 -9q-16 0 -32 8q-32 19 -32 56v742q0 35 31 55q35 21 78.5 42.5t114 52t152.5 49.5t155 19q112 0 209 -31t209 -86q38 -19 89 -19q122 0 310 112q22 12 31 17q31 16 62 -2q31 -20 31 -55z" />
-<glyph unicode="&#xf11e;" horiz-adv-x="1792" d="M832 536v192q-181 -16 -384 -117v-185q205 96 384 110zM832 954v197q-172 -8 -384 -126v-189q215 111 384 118zM1664 491v184q-235 -116 -384 -71v224q-20 6 -39 15q-5 3 -33 17t-34.5 17t-31.5 15t-34.5 15.5t-32.5 13t-36 12.5t-35 8.5t-39.5 7.5t-39.5 4t-44 2 q-23 0 -49 -3v-222h19q102 0 192.5 -29t197.5 -82q19 -9 39 -15v-188q42 -17 91 -17q120 0 293 92zM1664 918v189q-169 -91 -306 -91q-45 0 -78 8v-196q148 -42 384 90zM320 1280q0 -35 -17.5 -64t-46.5 -46v-1266q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v1266 q-29 17 -46.5 46t-17.5 64q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5zM1792 1216v-763q0 -39 -35 -57q-10 -5 -17 -9q-218 -116 -369 -116q-88 0 -158 35l-28 14q-64 33 -99 48t-91 29t-114 14q-102 0 -235.5 -44t-228.5 -102q-15 -9 -33 -9q-16 0 -32 8 q-32 19 -32 56v742q0 35 31 55q35 21 78.5 42.5t114 52t152.5 49.5t155 19q112 0 209 -31t209 -86q38 -19 89 -19q122 0 310 112q22 12 31 17q31 16 62 -2q31 -20 31 -55z" />
-<glyph unicode="&#xf120;" horiz-adv-x="1664" d="M585 553l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23zM1664 96v-64q0 -14 -9 -23t-23 -9h-960q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h960q14 0 23 -9 t9 -23z" />
-<glyph unicode="&#xf121;" horiz-adv-x="1920" d="M617 137l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23t10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23t-10 -23zM1208 1204l-373 -1291q-4 -13 -15.5 -19.5t-23.5 -2.5l-62 17q-13 4 -19.5 15.5t-2.5 24.5 l373 1291q4 13 15.5 19.5t23.5 2.5l62 -17q13 -4 19.5 -15.5t2.5 -24.5zM1865 553l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23t10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23z" />
-<glyph unicode="&#xf122;" horiz-adv-x="1792" d="M640 454v-70q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-512 512q-19 19 -19 45t19 45l512 512q29 31 70 14q39 -17 39 -59v-69l-397 -398q-19 -19 -19 -45t19 -45zM1792 416q0 -58 -17 -133.5t-38.5 -138t-48 -125t-40.5 -90.5l-20 -40q-8 -17 -28 -17q-6 0 -9 1 q-25 8 -23 34q43 400 -106 565q-64 71 -170.5 110.5t-267.5 52.5v-251q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-512 512q-19 19 -19 45t19 45l512 512q29 31 70 14q39 -17 39 -59v-262q411 -28 599 -221q169 -173 169 -509z" />
-<glyph unicode="&#xf123;" horiz-adv-x="1664" d="M1186 579l257 250l-356 52l-66 10l-30 60l-159 322v-963l59 -31l318 -168l-60 355l-12 66zM1638 841l-363 -354l86 -500q5 -33 -6 -51.5t-34 -18.5q-17 0 -40 12l-449 236l-449 -236q-23 -12 -40 -12q-23 0 -34 18.5t-6 51.5l86 500l-364 354q-32 32 -23 59.5t54 34.5 l502 73l225 455q20 41 49 41q28 0 49 -41l225 -455l502 -73q45 -7 54 -34.5t-24 -59.5z" />
-<glyph unicode="&#xf124;" horiz-adv-x="1408" d="M1401 1187l-640 -1280q-17 -35 -57 -35q-5 0 -15 2q-22 5 -35.5 22.5t-13.5 39.5v576h-576q-22 0 -39.5 13.5t-22.5 35.5t4 42t29 30l1280 640q13 7 29 7q27 0 45 -19q15 -14 18.5 -34.5t-6.5 -39.5z" />
-<glyph unicode="&#xf125;" horiz-adv-x="1664" d="M557 256h595v595zM512 301l595 595h-595v-595zM1664 224v-192q0 -14 -9 -23t-23 -9h-224v-224q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v224h-864q-14 0 -23 9t-9 23v864h-224q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h224v224q0 14 9 23t23 9h192q14 0 23 -9t9 -23 v-224h851l246 247q10 9 23 9t23 -9q9 -10 9 -23t-9 -23l-247 -246v-851h224q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf126;" horiz-adv-x="1024" d="M288 64q0 40 -28 68t-68 28t-68 -28t-28 -68t28 -68t68 -28t68 28t28 68zM288 1216q0 40 -28 68t-68 28t-68 -28t-28 -68t28 -68t68 -28t68 28t28 68zM928 1088q0 40 -28 68t-68 28t-68 -28t-28 -68t28 -68t68 -28t68 28t28 68zM1024 1088q0 -52 -26 -96.5t-70 -69.5 q-2 -287 -226 -414q-68 -38 -203 -81q-128 -40 -169.5 -71t-41.5 -100v-26q44 -25 70 -69.5t26 -96.5q0 -80 -56 -136t-136 -56t-136 56t-56 136q0 52 26 96.5t70 69.5v820q-44 25 -70 69.5t-26 96.5q0 80 56 136t136 56t136 -56t56 -136q0 -52 -26 -96.5t-70 -69.5v-497 q54 26 154 57q55 17 87.5 29.5t70.5 31t59 39.5t40.5 51t28 69.5t8.5 91.5q-44 25 -70 69.5t-26 96.5q0 80 56 136t136 56t136 -56t56 -136z" />
-<glyph unicode="&#xf127;" horiz-adv-x="1664" d="M439 265l-256 -256q-10 -9 -23 -9q-12 0 -23 9q-9 10 -9 23t9 23l256 256q10 9 23 9t23 -9q9 -10 9 -23t-9 -23zM608 224v-320q0 -14 -9 -23t-23 -9t-23 9t-9 23v320q0 14 9 23t23 9t23 -9t9 -23zM384 448q0 -14 -9 -23t-23 -9h-320q-14 0 -23 9t-9 23t9 23t23 9h320 q14 0 23 -9t9 -23zM1648 320q0 -120 -85 -203l-147 -146q-83 -83 -203 -83q-121 0 -204 85l-334 335q-21 21 -42 56l239 18l273 -274q27 -27 68 -27.5t68 26.5l147 146q28 28 28 67q0 40 -28 68l-274 275l18 239q35 -21 56 -42l336 -336q84 -86 84 -204zM1031 1044l-239 -18 l-273 274q-28 28 -68 28q-39 0 -68 -27l-147 -146q-28 -28 -28 -67q0 -40 28 -68l274 -274l-18 -240q-35 21 -56 42l-336 336q-84 86 -84 204q0 120 85 203l147 146q83 83 203 83q121 0 204 -85l334 -335q21 -21 42 -56zM1664 960q0 -14 -9 -23t-23 -9h-320q-14 0 -23 9 t-9 23t9 23t23 9h320q14 0 23 -9t9 -23zM1120 1504v-320q0 -14 -9 -23t-23 -9t-23 9t-9 23v320q0 14 9 23t23 9t23 -9t9 -23zM1527 1353l-256 -256q-11 -9 -23 -9t-23 9q-9 10 -9 23t9 23l256 256q10 9 23 9t23 -9q9 -10 9 -23t-9 -23z" />
-<glyph unicode="&#xf128;" horiz-adv-x="1024" d="M704 280v-240q0 -16 -12 -28t-28 -12h-240q-16 0 -28 12t-12 28v240q0 16 12 28t28 12h240q16 0 28 -12t12 -28zM1020 880q0 -54 -15.5 -101t-35 -76.5t-55 -59.5t-57.5 -43.5t-61 -35.5q-41 -23 -68.5 -65t-27.5 -67q0 -17 -12 -32.5t-28 -15.5h-240q-15 0 -25.5 18.5 t-10.5 37.5v45q0 83 65 156.5t143 108.5q59 27 84 56t25 76q0 42 -46.5 74t-107.5 32q-65 0 -108 -29q-35 -25 -107 -115q-13 -16 -31 -16q-12 0 -25 8l-164 125q-13 10 -15.5 25t5.5 28q160 266 464 266q80 0 161 -31t146 -83t106 -127.5t41 -158.5z" />
-<glyph unicode="&#xf129;" horiz-adv-x="640" d="M640 192v-128q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h64v384h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-576h64q26 0 45 -19t19 -45zM512 1344v-192q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45v192 q0 26 19 45t45 19h256q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf12a;" horiz-adv-x="640" d="M512 288v-224q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45v224q0 26 19 45t45 19h256q26 0 45 -19t19 -45zM542 1344l-28 -768q-1 -26 -20.5 -45t-45.5 -19h-256q-26 0 -45.5 19t-20.5 45l-28 768q-1 26 17.5 45t44.5 19h320q26 0 44.5 -19t17.5 -45z" />
-<glyph unicode="&#xf12b;" d="M897 167v-167h-248l-159 252l-24 42q-8 9 -11 21h-3l-9 -21q-10 -20 -25 -44l-155 -250h-258v167h128l197 291l-185 272h-137v168h276l139 -228q2 -4 23 -42q8 -9 11 -21h3q3 9 11 21l25 42l140 228h257v-168h-125l-184 -267l204 -296h109zM1534 846v-206h-514l-3 27 q-4 28 -4 46q0 64 26 117t65 86.5t84 65t84 54.5t65 54t26 64q0 38 -29.5 62.5t-70.5 24.5q-51 0 -97 -39q-14 -11 -36 -38l-105 92q26 37 63 66q83 65 188 65q110 0 178 -59.5t68 -158.5q0 -56 -24.5 -103t-62 -76.5t-81.5 -58.5t-82 -50.5t-65.5 -51.5t-30.5 -63h232v80 h126z" />
-<glyph unicode="&#xf12c;" d="M897 167v-167h-248l-159 252l-24 42q-8 9 -11 21h-3l-9 -21q-10 -20 -25 -44l-155 -250h-258v167h128l197 291l-185 272h-137v168h276l139 -228q2 -4 23 -42q8 -9 11 -21h3q3 9 11 21l25 42l140 228h257v-168h-125l-184 -267l204 -296h109zM1536 -50v-206h-514l-4 27 q-3 45 -3 46q0 64 26 117t65 86.5t84 65t84 54.5t65 54t26 64q0 38 -29.5 62.5t-70.5 24.5q-51 0 -97 -39q-14 -11 -36 -38l-105 92q26 37 63 66q80 65 188 65q110 0 178 -59.5t68 -158.5q0 -66 -34.5 -118.5t-84 -86t-99.5 -62.5t-87 -63t-41 -73h232v80h126z" />
-<glyph unicode="&#xf12d;" horiz-adv-x="1920" d="M896 128l336 384h-768l-336 -384h768zM1909 1205q15 -34 9.5 -71.5t-30.5 -65.5l-896 -1024q-38 -44 -96 -44h-768q-38 0 -69.5 20.5t-47.5 54.5q-15 34 -9.5 71.5t30.5 65.5l896 1024q38 44 96 44h768q38 0 69.5 -20.5t47.5 -54.5z" />
-<glyph unicode="&#xf12e;" horiz-adv-x="1664" d="M1664 438q0 -81 -44.5 -135t-123.5 -54q-41 0 -77.5 17.5t-59 38t-56.5 38t-71 17.5q-110 0 -110 -124q0 -39 16 -115t15 -115v-5q-22 0 -33 -1q-34 -3 -97.5 -11.5t-115.5 -13.5t-98 -5q-61 0 -103 26.5t-42 83.5q0 37 17.5 71t38 56.5t38 59t17.5 77.5q0 79 -54 123.5 t-135 44.5q-84 0 -143 -45.5t-59 -127.5q0 -43 15 -83t33.5 -64.5t33.5 -53t15 -50.5q0 -45 -46 -89q-37 -35 -117 -35q-95 0 -245 24q-9 2 -27.5 4t-27.5 4l-13 2q-1 0 -3 1q-2 0 -2 1v1024q2 -1 17.5 -3.5t34 -5t21.5 -3.5q150 -24 245 -24q80 0 117 35q46 44 46 89 q0 22 -15 50.5t-33.5 53t-33.5 64.5t-15 83q0 82 59 127.5t144 45.5q80 0 134 -44.5t54 -123.5q0 -41 -17.5 -77.5t-38 -59t-38 -56.5t-17.5 -71q0 -57 42 -83.5t103 -26.5q64 0 180 15t163 17v-2q-1 -2 -3.5 -17.5t-5 -34t-3.5 -21.5q-24 -150 -24 -245q0 -80 35 -117 q44 -46 89 -46q22 0 50.5 15t53 33.5t64.5 33.5t83 15q82 0 127.5 -59t45.5 -143z" />
-<glyph unicode="&#xf130;" horiz-adv-x="1152" d="M1152 832v-128q0 -221 -147.5 -384.5t-364.5 -187.5v-132h256q26 0 45 -19t19 -45t-19 -45t-45 -19h-640q-26 0 -45 19t-19 45t19 45t45 19h256v132q-217 24 -364.5 187.5t-147.5 384.5v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -185 131.5 -316.5t316.5 -131.5 t316.5 131.5t131.5 316.5v128q0 26 19 45t45 19t45 -19t19 -45zM896 1216v-512q0 -132 -94 -226t-226 -94t-226 94t-94 226v512q0 132 94 226t226 94t226 -94t94 -226z" />
-<glyph unicode="&#xf131;" horiz-adv-x="1408" d="M271 591l-101 -101q-42 103 -42 214v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -53 15 -113zM1385 1193l-361 -361v-128q0 -132 -94 -226t-226 -94q-55 0 -109 19l-96 -96q97 -51 205 -51q185 0 316.5 131.5t131.5 316.5v128q0 26 19 45t45 19t45 -19t19 -45v-128 q0 -221 -147.5 -384.5t-364.5 -187.5v-132h256q26 0 45 -19t19 -45t-19 -45t-45 -19h-640q-26 0 -45 19t-19 45t19 45t45 19h256v132q-125 13 -235 81l-254 -254q-10 -10 -23 -10t-23 10l-82 82q-10 10 -10 23t10 23l1234 1234q10 10 23 10t23 -10l82 -82q10 -10 10 -23 t-10 -23zM1005 1325l-621 -621v512q0 132 94 226t226 94q102 0 184.5 -59t116.5 -152z" />
-<glyph unicode="&#xf132;" horiz-adv-x="1280" d="M1088 576v640h-448v-1137q119 63 213 137q235 184 235 360zM1280 1344v-768q0 -86 -33.5 -170.5t-83 -150t-118 -127.5t-126.5 -103t-121 -77.5t-89.5 -49.5t-42.5 -20q-12 -6 -26 -6t-26 6q-16 7 -42.5 20t-89.5 49.5t-121 77.5t-126.5 103t-118 127.5t-83 150 t-33.5 170.5v768q0 26 19 45t45 19h1152q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf133;" horiz-adv-x="1664" d="M128 -128h1408v1024h-1408v-1024zM512 1088v288q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-288q0 -14 9 -23t23 -9h64q14 0 23 9t9 23zM1280 1088v288q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-288q0 -14 9 -23t23 -9h64q14 0 23 9t9 23zM1664 1152v-1280 q0 -52 -38 -90t-90 -38h-1408q-52 0 -90 38t-38 90v1280q0 52 38 90t90 38h128v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h384v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h128q52 0 90 -38t38 -90z" />
-<glyph unicode="&#xf134;" horiz-adv-x="1408" d="M512 1344q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1408 1376v-320q0 -16 -12 -25q-8 -7 -20 -7q-4 0 -7 1l-448 96q-11 2 -18 11t-7 20h-256v-102q111 -23 183.5 -111t72.5 -203v-800q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45v800 q0 106 62.5 190.5t161.5 114.5v111h-32q-59 0 -115 -23.5t-91.5 -53t-66 -66.5t-40.5 -53.5t-14 -24.5q-17 -35 -57 -35q-16 0 -29 7q-23 12 -31.5 37t3.5 49q5 10 14.5 26t37.5 53.5t60.5 70t85 67t108.5 52.5q-25 42 -25 86q0 66 47 113t113 47t113 -47t47 -113 q0 -33 -14 -64h302q0 11 7 20t18 11l448 96q3 1 7 1q12 0 20 -7q12 -9 12 -25z" />
-<glyph unicode="&#xf135;" horiz-adv-x="1664" d="M1440 1088q0 40 -28 68t-68 28t-68 -28t-28 -68t28 -68t68 -28t68 28t28 68zM1664 1376q0 -249 -75.5 -430.5t-253.5 -360.5q-81 -80 -195 -176l-20 -379q-2 -16 -16 -26l-384 -224q-7 -4 -16 -4q-12 0 -23 9l-64 64q-13 14 -8 32l85 276l-281 281l-276 -85q-3 -1 -9 -1 q-14 0 -23 9l-64 64q-17 19 -5 39l224 384q10 14 26 16l379 20q96 114 176 195q188 187 358 258t431 71q14 0 24 -9.5t10 -22.5z" />
-<glyph unicode="&#xf136;" horiz-adv-x="1792" d="M1745 763l-164 -763h-334l178 832q13 56 -15 88q-27 33 -83 33h-169l-204 -953h-334l204 953h-286l-204 -953h-334l204 953l-153 327h1276q101 0 189.5 -40.5t147.5 -113.5q60 -73 81 -168.5t0 -194.5z" />
-<glyph unicode="&#xf137;" d="M909 141l102 102q19 19 19 45t-19 45l-307 307l307 307q19 19 19 45t-19 45l-102 102q-19 19 -45 19t-45 -19l-454 -454q-19 -19 -19 -45t19 -45l454 -454q19 -19 45 -19t45 19zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5 t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf138;" d="M717 141l454 454q19 19 19 45t-19 45l-454 454q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45t19 -45l307 -307l-307 -307q-19 -19 -19 -45t19 -45l102 -102q19 -19 45 -19t45 19zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5 t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf139;" d="M1165 397l102 102q19 19 19 45t-19 45l-454 454q-19 19 -45 19t-45 -19l-454 -454q-19 -19 -19 -45t19 -45l102 -102q19 -19 45 -19t45 19l307 307l307 -307q19 -19 45 -19t45 19zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5 t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf13a;" d="M813 237l454 454q19 19 19 45t-19 45l-102 102q-19 19 -45 19t-45 -19l-307 -307l-307 307q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45t19 -45l454 -454q19 -19 45 -19t45 19zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5 t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf13b;" horiz-adv-x="1408" d="M1130 939l16 175h-884l47 -534h612l-22 -228l-197 -53l-196 53l-13 140h-175l22 -278l362 -100h4v1l359 99l50 544h-644l-15 181h674zM0 1408h1408l-128 -1438l-578 -162l-574 162z" />
-<glyph unicode="&#xf13c;" horiz-adv-x="1792" d="M275 1408h1505l-266 -1333l-804 -267l-698 267l71 356h297l-29 -147l422 -161l486 161l68 339h-1208l58 297h1209l38 191h-1208z" />
-<glyph unicode="&#xf13d;" horiz-adv-x="1792" d="M960 1280q0 26 -19 45t-45 19t-45 -19t-19 -45t19 -45t45 -19t45 19t19 45zM1792 352v-352q0 -22 -20 -30q-8 -2 -12 -2q-13 0 -23 9l-93 93q-119 -143 -318.5 -226.5t-429.5 -83.5t-429.5 83.5t-318.5 226.5l-93 -93q-9 -9 -23 -9q-4 0 -12 2q-20 8 -20 30v352 q0 14 9 23t23 9h352q22 0 30 -20q8 -19 -7 -35l-100 -100q67 -91 189.5 -153.5t271.5 -82.5v647h-192q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h192v163q-58 34 -93 92.5t-35 128.5q0 106 75 181t181 75t181 -75t75 -181q0 -70 -35 -128.5t-93 -92.5v-163h192q26 0 45 -19 t19 -45v-128q0 -26 -19 -45t-45 -19h-192v-647q149 20 271.5 82.5t189.5 153.5l-100 100q-15 16 -7 35q8 20 30 20h352q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf13e;" horiz-adv-x="1152" d="M1056 768q40 0 68 -28t28 -68v-576q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28t-28 68v576q0 40 28 68t68 28h32v320q0 185 131.5 316.5t316.5 131.5t316.5 -131.5t131.5 -316.5q0 -26 -19 -45t-45 -19h-64q-26 0 -45 19t-19 45q0 106 -75 181t-181 75t-181 -75t-75 -181 v-320h736z" />
-<glyph unicode="&#xf140;" d="M1024 640q0 -106 -75 -181t-181 -75t-181 75t-75 181t75 181t181 75t181 -75t75 -181zM1152 640q0 159 -112.5 271.5t-271.5 112.5t-271.5 -112.5t-112.5 -271.5t112.5 -271.5t271.5 -112.5t271.5 112.5t112.5 271.5zM1280 640q0 -212 -150 -362t-362 -150t-362 150 t-150 362t150 362t362 150t362 -150t150 -362zM1408 640q0 130 -51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5t51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5zM1536 640 q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf141;" horiz-adv-x="1408" d="M384 800v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68zM896 800v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68zM1408 800v-192q0 -40 -28 -68t-68 -28h-192 q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf142;" horiz-adv-x="384" d="M384 288v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68zM384 800v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68zM384 1312v-192q0 -40 -28 -68t-68 -28h-192 q-40 0 -68 28t-28 68v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68z" />
-<glyph unicode="&#xf143;" d="M512 256q0 53 -37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5t37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5zM863 162q-13 232 -177 396t-396 177q-14 1 -24 -9t-10 -23v-128q0 -13 8.5 -22t21.5 -10q154 -11 264 -121t121 -264q1 -13 10 -21.5t22 -8.5h128q13 0 23 10 t9 24zM1247 161q-5 154 -56 297.5t-139.5 260t-205 205t-260 139.5t-297.5 56q-14 1 -23 -9q-10 -10 -10 -23v-128q0 -13 9 -22t22 -10q204 -7 378 -111.5t278.5 -278.5t111.5 -378q1 -13 10 -22t22 -9h128q13 0 23 10q11 9 9 23zM1536 1120v-960q0 -119 -84.5 -203.5 t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf144;" d="M768 1408q209 0 385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103zM1152 585q32 18 32 55t-32 55l-544 320q-31 19 -64 1q-32 -19 -32 -56v-640q0 -37 32 -56 q16 -8 32 -8q17 0 32 9z" />
-<glyph unicode="&#xf145;" horiz-adv-x="1792" d="M1024 1084l316 -316l-572 -572l-316 316zM813 105l618 618q19 19 19 45t-19 45l-362 362q-18 18 -45 18t-45 -18l-618 -618q-19 -19 -19 -45t19 -45l362 -362q18 -18 45 -18t45 18zM1702 742l-907 -908q-37 -37 -90.5 -37t-90.5 37l-126 126q56 56 56 136t-56 136 t-136 56t-136 -56l-125 126q-37 37 -37 90.5t37 90.5l907 906q37 37 90.5 37t90.5 -37l125 -125q-56 -56 -56 -136t56 -136t136 -56t136 56l126 -125q37 -37 37 -90.5t-37 -90.5z" />
-<glyph unicode="&#xf146;" d="M1280 576v128q0 26 -19 45t-45 19h-896q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h896q26 0 45 19t19 45zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5 t84.5 -203.5z" />
-<glyph unicode="&#xf147;" horiz-adv-x="1408" d="M1152 736v-64q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h832q14 0 23 -9t9 -23zM1280 288v832q0 66 -47 113t-113 47h-832q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113zM1408 1120v-832q0 -119 -84.5 -203.5 t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h832q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf148;" horiz-adv-x="1024" d="M1018 933q-18 -37 -58 -37h-192v-864q0 -14 -9 -23t-23 -9h-704q-21 0 -29 18q-8 20 4 35l160 192q9 11 25 11h320v640h-192q-40 0 -58 37q-17 37 9 68l320 384q18 22 49 22t49 -22l320 -384q27 -32 9 -68z" />
-<glyph unicode="&#xf149;" horiz-adv-x="1024" d="M32 1280h704q13 0 22.5 -9.5t9.5 -23.5v-863h192q40 0 58 -37t-9 -69l-320 -384q-18 -22 -49 -22t-49 22l-320 384q-26 31 -9 69q18 37 58 37h192v640h-320q-14 0 -25 11l-160 192q-13 14 -4 34q9 19 29 19z" />
-<glyph unicode="&#xf14a;" d="M685 237l614 614q19 19 19 45t-19 45l-102 102q-19 19 -45 19t-45 -19l-467 -467l-211 211q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45t19 -45l358 -358q19 -19 45 -19t45 19zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5 t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf14b;" d="M404 428l152 -152l-52 -52h-56v96h-96v56zM818 818q14 -13 -3 -30l-291 -291q-17 -17 -30 -3q-14 13 3 30l291 291q17 17 30 3zM544 128l544 544l-288 288l-544 -544v-288h288zM1152 736l92 92q28 28 28 68t-28 68l-152 152q-28 28 -68 28t-68 -28l-92 -92zM1536 1120 v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf14c;" d="M1280 608v480q0 26 -19 45t-45 19h-480q-42 0 -59 -39q-17 -41 14 -70l144 -144l-534 -534q-19 -19 -19 -45t19 -45l102 -102q19 -19 45 -19t45 19l534 534l144 -144q18 -19 45 -19q12 0 25 5q39 17 39 59zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960 q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf14d;" d="M1005 435l352 352q19 19 19 45t-19 45l-352 352q-30 31 -69 14q-40 -17 -40 -59v-160q-119 0 -216 -19.5t-162.5 -51t-114 -79t-76.5 -95.5t-44.5 -109t-21.5 -111.5t-5 -110.5q0 -181 167 -404q10 -12 25 -12q7 0 13 3q22 9 19 33q-44 354 62 473q46 52 130 75.5 t224 23.5v-160q0 -42 40 -59q12 -5 24 -5q26 0 45 19zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf14e;" d="M640 448l256 128l-256 128v-256zM1024 1039v-542l-512 -256v542zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103 t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf150;" d="M1145 861q18 -35 -5 -66l-320 -448q-19 -27 -52 -27t-52 27l-320 448q-23 31 -5 66q17 35 57 35h640q40 0 57 -35zM1280 160v960q0 13 -9.5 22.5t-22.5 9.5h-960q-13 0 -22.5 -9.5t-9.5 -22.5v-960q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5zM1536 1120 v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf151;" d="M1145 419q-17 -35 -57 -35h-640q-40 0 -57 35q-18 35 5 66l320 448q19 27 52 27t52 -27l320 -448q23 -31 5 -66zM1280 160v960q0 13 -9.5 22.5t-22.5 9.5h-960q-13 0 -22.5 -9.5t-9.5 -22.5v-960q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5zM1536 1120v-960 q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf152;" d="M1088 640q0 -33 -27 -52l-448 -320q-31 -23 -66 -5q-35 17 -35 57v640q0 40 35 57q35 18 66 -5l448 -320q27 -19 27 -52zM1280 160v960q0 14 -9 23t-23 9h-960q-14 0 -23 -9t-9 -23v-960q0 -14 9 -23t23 -9h960q14 0 23 9t9 23zM1536 1120v-960q0 -119 -84.5 -203.5 t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf153;" horiz-adv-x="1024" d="M976 229l35 -159q3 -12 -3 -22.5t-17 -14.5l-5 -1q-4 -2 -10.5 -3.5t-16 -4.5t-21.5 -5.5t-25.5 -5t-30 -5t-33.5 -4.5t-36.5 -3t-38.5 -1q-234 0 -409 130.5t-238 351.5h-95q-13 0 -22.5 9.5t-9.5 22.5v113q0 13 9.5 22.5t22.5 9.5h66q-2 57 1 105h-67q-14 0 -23 9 t-9 23v114q0 14 9 23t23 9h98q67 210 243.5 338t400.5 128q102 0 194 -23q11 -3 20 -15q6 -11 3 -24l-43 -159q-3 -13 -14 -19.5t-24 -2.5l-4 1q-4 1 -11.5 2.5l-17.5 3.5t-22.5 3.5t-26 3t-29 2.5t-29.5 1q-126 0 -226 -64t-150 -176h468q16 0 25 -12q10 -12 7 -26 l-24 -114q-5 -26 -32 -26h-488q-3 -37 0 -105h459q15 0 25 -12q9 -12 6 -27l-24 -112q-2 -11 -11 -18.5t-20 -7.5h-387q48 -117 149.5 -185.5t228.5 -68.5q18 0 36 1.5t33.5 3.5t29.5 4.5t24.5 5t18.5 4.5l12 3l5 2q13 5 26 -2q12 -7 15 -21z" />
-<glyph unicode="&#xf154;" horiz-adv-x="1024" d="M1020 399v-367q0 -14 -9 -23t-23 -9h-956q-14 0 -23 9t-9 23v150q0 13 9.5 22.5t22.5 9.5h97v383h-95q-14 0 -23 9.5t-9 22.5v131q0 14 9 23t23 9h95v223q0 171 123.5 282t314.5 111q185 0 335 -125q9 -8 10 -20.5t-7 -22.5l-103 -127q-9 -11 -22 -12q-13 -2 -23 7 q-5 5 -26 19t-69 32t-93 18q-85 0 -137 -47t-52 -123v-215h305q13 0 22.5 -9t9.5 -23v-131q0 -13 -9.5 -22.5t-22.5 -9.5h-305v-379h414v181q0 13 9 22.5t23 9.5h162q14 0 23 -9.5t9 -22.5z" />
-<glyph unicode="&#xf155;" horiz-adv-x="1024" d="M978 351q0 -153 -99.5 -263.5t-258.5 -136.5v-175q0 -14 -9 -23t-23 -9h-135q-13 0 -22.5 9.5t-9.5 22.5v175q-66 9 -127.5 31t-101.5 44.5t-74 48t-46.5 37.5t-17.5 18q-17 21 -2 41l103 135q7 10 23 12q15 2 24 -9l2 -2q113 -99 243 -125q37 -8 74 -8q81 0 142.5 43 t61.5 122q0 28 -15 53t-33.5 42t-58.5 37.5t-66 32t-80 32.5q-39 16 -61.5 25t-61.5 26.5t-62.5 31t-56.5 35.5t-53.5 42.5t-43.5 49t-35.5 58t-21 66.5t-8.5 78q0 138 98 242t255 134v180q0 13 9.5 22.5t22.5 9.5h135q14 0 23 -9t9 -23v-176q57 -6 110.5 -23t87 -33.5 t63.5 -37.5t39 -29t15 -14q17 -18 5 -38l-81 -146q-8 -15 -23 -16q-14 -3 -27 7q-3 3 -14.5 12t-39 26.5t-58.5 32t-74.5 26t-85.5 11.5q-95 0 -155 -43t-60 -111q0 -26 8.5 -48t29.5 -41.5t39.5 -33t56 -31t60.5 -27t70 -27.5q53 -20 81 -31.5t76 -35t75.5 -42.5t62 -50 t53 -63.5t31.5 -76.5t13 -94z" />
-<glyph unicode="&#xf156;" horiz-adv-x="898" d="M898 1066v-102q0 -14 -9 -23t-23 -9h-168q-23 -144 -129 -234t-276 -110q167 -178 459 -536q14 -16 4 -34q-8 -18 -29 -18h-195q-16 0 -25 12q-306 367 -498 571q-9 9 -9 22v127q0 13 9.5 22.5t22.5 9.5h112q132 0 212.5 43t102.5 125h-427q-14 0 -23 9t-9 23v102 q0 14 9 23t23 9h413q-57 113 -268 113h-145q-13 0 -22.5 9.5t-9.5 22.5v133q0 14 9 23t23 9h832q14 0 23 -9t9 -23v-102q0 -14 -9 -23t-23 -9h-233q47 -61 64 -144h171q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf157;" horiz-adv-x="1027" d="M603 0h-172q-13 0 -22.5 9t-9.5 23v330h-288q-13 0 -22.5 9t-9.5 23v103q0 13 9.5 22.5t22.5 9.5h288v85h-288q-13 0 -22.5 9t-9.5 23v104q0 13 9.5 22.5t22.5 9.5h214l-321 578q-8 16 0 32q10 16 28 16h194q19 0 29 -18l215 -425q19 -38 56 -125q10 24 30.5 68t27.5 61 l191 420q8 19 29 19h191q17 0 27 -16q9 -14 1 -31l-313 -579h215q13 0 22.5 -9.5t9.5 -22.5v-104q0 -14 -9.5 -23t-22.5 -9h-290v-85h290q13 0 22.5 -9.5t9.5 -22.5v-103q0 -14 -9.5 -23t-22.5 -9h-290v-330q0 -13 -9.5 -22.5t-22.5 -9.5z" />
-<glyph unicode="&#xf158;" horiz-adv-x="1280" d="M1043 971q0 100 -65 162t-171 62h-320v-448h320q106 0 171 62t65 162zM1280 971q0 -193 -126.5 -315t-326.5 -122h-340v-118h505q14 0 23 -9t9 -23v-128q0 -14 -9 -23t-23 -9h-505v-192q0 -14 -9.5 -23t-22.5 -9h-167q-14 0 -23 9t-9 23v192h-224q-14 0 -23 9t-9 23v128 q0 14 9 23t23 9h224v118h-224q-14 0 -23 9t-9 23v149q0 13 9 22.5t23 9.5h224v629q0 14 9 23t23 9h539q200 0 326.5 -122t126.5 -315z" />
-<glyph unicode="&#xf159;" horiz-adv-x="1792" d="M514 341l81 299h-159l75 -300q1 -1 1 -3t1 -3q0 1 0.5 3.5t0.5 3.5zM630 768l35 128h-292l32 -128h225zM822 768h139l-35 128h-70zM1271 340l78 300h-162l81 -299q0 -1 0.5 -3.5t1.5 -3.5q0 1 0.5 3t0.5 3zM1382 768l33 128h-297l34 -128h230zM1792 736v-64q0 -14 -9 -23 t-23 -9h-213l-164 -616q-7 -24 -31 -24h-159q-24 0 -31 24l-166 616h-209l-167 -616q-7 -24 -31 -24h-159q-11 0 -19.5 7t-10.5 17l-160 616h-208q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h175l-33 128h-142q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h109l-89 344q-5 15 5 28 q10 12 26 12h137q26 0 31 -24l90 -360h359l97 360q7 24 31 24h126q24 0 31 -24l98 -360h365l93 360q5 24 31 24h137q16 0 26 -12q10 -13 5 -28l-91 -344h111q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-145l-34 -128h179q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf15a;" horiz-adv-x="1280" d="M1167 896q18 -182 -131 -258q117 -28 175 -103t45 -214q-7 -71 -32.5 -125t-64.5 -89t-97 -58.5t-121.5 -34.5t-145.5 -15v-255h-154v251q-80 0 -122 1v-252h-154v255q-18 0 -54 0.5t-55 0.5h-200l31 183h111q50 0 58 51v402h16q-6 1 -16 1v287q-13 68 -89 68h-111v164 l212 -1q64 0 97 1v252h154v-247q82 2 122 2v245h154v-252q79 -7 140 -22.5t113 -45t82.5 -78t36.5 -114.5zM952 351q0 36 -15 64t-37 46t-57.5 30.5t-65.5 18.5t-74 9t-69 3t-64.5 -1t-47.5 -1v-338q8 0 37 -0.5t48 -0.5t53 1.5t58.5 4t57 8.5t55.5 14t47.5 21t39.5 30 t24.5 40t9.5 51zM881 827q0 33 -12.5 58.5t-30.5 42t-48 28t-55 16.5t-61.5 8t-58 2.5t-54 -1t-39.5 -0.5v-307q5 0 34.5 -0.5t46.5 0t50 2t55 5.5t51.5 11t48.5 18.5t37 27t27 38.5t9 51z" />
-<glyph unicode="&#xf15b;" horiz-adv-x="1280" d="M1280 768v-800q0 -40 -28 -68t-68 -28h-1088q-40 0 -68 28t-28 68v1344q0 40 28 68t68 28h544v-544q0 -40 28 -68t68 -28h544zM1277 896h-509v509q82 -15 132 -65l312 -312q50 -50 65 -132z" />
-<glyph unicode="&#xf15c;" horiz-adv-x="1280" d="M1024 160v64q0 14 -9 23t-23 9h-704q-14 0 -23 -9t-9 -23v-64q0 -14 9 -23t23 -9h704q14 0 23 9t9 23zM1024 416v64q0 14 -9 23t-23 9h-704q-14 0 -23 -9t-9 -23v-64q0 -14 9 -23t23 -9h704q14 0 23 9t9 23zM1280 768v-800q0 -40 -28 -68t-68 -28h-1088q-40 0 -68 28 t-28 68v1344q0 40 28 68t68 28h544v-544q0 -40 28 -68t68 -28h544zM1277 896h-509v509q82 -15 132 -65l312 -312q50 -50 65 -132z" />
-<glyph unicode="&#xf15d;" horiz-adv-x="1664" d="M1191 1128h177l-72 218l-12 47q-2 16 -2 20h-4l-3 -20q0 -1 -3.5 -18t-7.5 -29zM736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23zM1572 -23 v-233h-584v90l369 529q12 18 21 27l11 9v3q-2 0 -6.5 -0.5t-7.5 -0.5q-12 -3 -30 -3h-232v-115h-120v229h567v-89l-369 -530q-6 -8 -21 -26l-11 -11v-2l14 2q9 2 30 2h248v119h121zM1661 874v-106h-288v106h75l-47 144h-243l-47 -144h75v-106h-287v106h70l230 662h162 l230 -662h70z" />
-<glyph unicode="&#xf15e;" horiz-adv-x="1664" d="M1191 104h177l-72 218l-12 47q-2 16 -2 20h-4l-3 -20q0 -1 -3.5 -18t-7.5 -29zM736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23zM1661 -150 v-106h-288v106h75l-47 144h-243l-47 -144h75v-106h-287v106h70l230 662h162l230 -662h70zM1572 1001v-233h-584v90l369 529q12 18 21 27l11 9v3q-2 0 -6.5 -0.5t-7.5 -0.5q-12 -3 -30 -3h-232v-115h-120v229h567v-89l-369 -530q-6 -8 -21 -26l-11 -10v-3l14 3q9 1 30 1h248 v119h121z" />
-<glyph unicode="&#xf160;" horiz-adv-x="1792" d="M736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23zM1792 -32v-192q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h832 q14 0 23 -9t9 -23zM1600 480v-192q0 -14 -9 -23t-23 -9h-640q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h640q14 0 23 -9t9 -23zM1408 992v-192q0 -14 -9 -23t-23 -9h-448q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h448q14 0 23 -9t9 -23zM1216 1504v-192q0 -14 -9 -23t-23 -9h-256 q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h256q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf161;" horiz-adv-x="1792" d="M1216 -32v-192q0 -14 -9 -23t-23 -9h-256q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h256q14 0 23 -9t9 -23zM736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192 q14 0 23 -9t9 -23zM1408 480v-192q0 -14 -9 -23t-23 -9h-448q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h448q14 0 23 -9t9 -23zM1600 992v-192q0 -14 -9 -23t-23 -9h-640q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h640q14 0 23 -9t9 -23zM1792 1504v-192q0 -14 -9 -23t-23 -9h-832 q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h832q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf162;" d="M1346 223q0 63 -44 116t-103 53q-52 0 -83 -37t-31 -94t36.5 -95t104.5 -38q50 0 85 27t35 68zM736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23 zM1486 165q0 -62 -13 -121.5t-41 -114t-68 -95.5t-98.5 -65.5t-127.5 -24.5q-62 0 -108 16q-24 8 -42 15l39 113q15 -7 31 -11q37 -13 75 -13q84 0 134.5 58.5t66.5 145.5h-2q-21 -23 -61.5 -37t-84.5 -14q-106 0 -173 71.5t-67 172.5q0 105 72 178t181 73q123 0 205 -94.5 t82 -252.5zM1456 882v-114h-469v114h167v432q0 7 0.5 19t0.5 17v16h-2l-7 -12q-8 -13 -26 -31l-62 -58l-82 86l192 185h123v-654h165z" />
-<glyph unicode="&#xf163;" d="M1346 1247q0 63 -44 116t-103 53q-52 0 -83 -37t-31 -94t36.5 -95t104.5 -38q50 0 85 27t35 68zM736 96q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9 t9 -23zM1456 -142v-114h-469v114h167v432q0 7 0.5 19t0.5 17v16h-2l-7 -12q-8 -13 -26 -31l-62 -58l-82 86l192 185h123v-654h165zM1486 1189q0 -62 -13 -121.5t-41 -114t-68 -95.5t-98.5 -65.5t-127.5 -24.5q-62 0 -108 16q-24 8 -42 15l39 113q15 -7 31 -11q37 -13 75 -13 q84 0 134.5 58.5t66.5 145.5h-2q-21 -23 -61.5 -37t-84.5 -14q-106 0 -173 71.5t-67 172.5q0 105 72 178t181 73q123 0 205 -94.5t82 -252.5z" />
-<glyph unicode="&#xf164;" horiz-adv-x="1664" d="M256 192q0 26 -19 45t-45 19q-27 0 -45.5 -19t-18.5 -45q0 -27 18.5 -45.5t45.5 -18.5q26 0 45 18.5t19 45.5zM416 704v-640q0 -26 -19 -45t-45 -19h-288q-26 0 -45 19t-19 45v640q0 26 19 45t45 19h288q26 0 45 -19t19 -45zM1600 704q0 -86 -55 -149q15 -44 15 -76 q3 -76 -43 -137q17 -56 0 -117q-15 -57 -54 -94q9 -112 -49 -181q-64 -76 -197 -78h-36h-76h-17q-66 0 -144 15.5t-121.5 29t-120.5 39.5q-123 43 -158 44q-26 1 -45 19.5t-19 44.5v641q0 25 18 43.5t43 20.5q24 2 76 59t101 121q68 87 101 120q18 18 31 48t17.5 48.5 t13.5 60.5q7 39 12.5 61t19.5 52t34 50q19 19 45 19q46 0 82.5 -10.5t60 -26t40 -40.5t24 -45t12 -50t5 -45t0.5 -39q0 -38 -9.5 -76t-19 -60t-27.5 -56q-3 -6 -10 -18t-11 -22t-8 -24h277q78 0 135 -57t57 -135z" />
-<glyph unicode="&#xf165;" horiz-adv-x="1664" d="M256 960q0 -26 -19 -45t-45 -19q-27 0 -45.5 19t-18.5 45q0 27 18.5 45.5t45.5 18.5q26 0 45 -18.5t19 -45.5zM416 448v640q0 26 -19 45t-45 19h-288q-26 0 -45 -19t-19 -45v-640q0 -26 19 -45t45 -19h288q26 0 45 19t19 45zM1545 597q55 -61 55 -149q-1 -78 -57.5 -135 t-134.5 -57h-277q4 -14 8 -24t11 -22t10 -18q18 -37 27 -57t19 -58.5t10 -76.5q0 -24 -0.5 -39t-5 -45t-12 -50t-24 -45t-40 -40.5t-60 -26t-82.5 -10.5q-26 0 -45 19q-20 20 -34 50t-19.5 52t-12.5 61q-9 42 -13.5 60.5t-17.5 48.5t-31 48q-33 33 -101 120q-49 64 -101 121 t-76 59q-25 2 -43 20.5t-18 43.5v641q0 26 19 44.5t45 19.5q35 1 158 44q77 26 120.5 39.5t121.5 29t144 15.5h17h76h36q133 -2 197 -78q58 -69 49 -181q39 -37 54 -94q17 -61 0 -117q46 -61 43 -137q0 -32 -15 -76z" />
-<glyph unicode="&#xf166;" d="M919 233v157q0 50 -29 50q-17 0 -33 -16v-224q16 -16 33 -16q29 0 29 49zM1103 355h66v34q0 51 -33 51t-33 -51v-34zM532 621v-70h-80v-423h-74v423h-78v70h232zM733 495v-367h-67v40q-39 -45 -76 -45q-33 0 -42 28q-6 16 -6 54v290h66v-270q0 -24 1 -26q1 -15 15 -15 q20 0 42 31v280h67zM985 384v-146q0 -52 -7 -73q-12 -42 -53 -42q-35 0 -68 41v-36h-67v493h67v-161q32 40 68 40q41 0 53 -42q7 -21 7 -74zM1236 255v-9q0 -29 -2 -43q-3 -22 -15 -40q-27 -40 -80 -40q-52 0 -81 38q-21 27 -21 86v129q0 59 20 86q29 38 80 38t78 -38 q21 -28 21 -86v-76h-133v-65q0 -51 34 -51q24 0 30 26q0 1 0.5 7t0.5 16.5v21.5h68zM785 1079v-156q0 -51 -32 -51t-32 51v156q0 52 32 52t32 -52zM1318 366q0 177 -19 260q-10 44 -43 73.5t-76 34.5q-136 15 -412 15q-275 0 -411 -15q-44 -5 -76.5 -34.5t-42.5 -73.5 q-20 -87 -20 -260q0 -176 20 -260q10 -43 42.5 -73t75.5 -35q137 -15 412 -15t412 15q43 5 75.5 35t42.5 73q20 84 20 260zM563 1017l90 296h-75l-51 -195l-53 195h-78l24 -69t23 -69q35 -103 46 -158v-201h74v201zM852 936v130q0 58 -21 87q-29 38 -78 38q-51 0 -78 -38 q-21 -29 -21 -87v-130q0 -58 21 -87q27 -38 78 -38q49 0 78 38q21 27 21 87zM1033 816h67v370h-67v-283q-22 -31 -42 -31q-15 0 -16 16q-1 2 -1 26v272h-67v-293q0 -37 6 -55q11 -27 43 -27q36 0 77 45v-40zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960 q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf167;" d="M971 292v-211q0 -67 -39 -67q-23 0 -45 22v301q22 22 45 22q39 0 39 -67zM1309 291v-46h-90v46q0 68 45 68t45 -68zM343 509h107v94h-312v-94h105v-569h100v569zM631 -60h89v494h-89v-378q-30 -42 -57 -42q-18 0 -21 21q-1 3 -1 35v364h-89v-391q0 -49 8 -73 q12 -37 58 -37q48 0 102 61v-54zM1060 88v197q0 73 -9 99q-17 56 -71 56q-50 0 -93 -54v217h-89v-663h89v48q45 -55 93 -55q54 0 71 55q9 27 9 100zM1398 98v13h-91q0 -51 -2 -61q-7 -36 -40 -36q-46 0 -46 69v87h179v103q0 79 -27 116q-39 51 -106 51q-68 0 -107 -51 q-28 -37 -28 -116v-173q0 -79 29 -116q39 -51 108 -51q72 0 108 53q18 27 21 54q2 9 2 58zM790 1011v210q0 69 -43 69t-43 -69v-210q0 -70 43 -70t43 70zM1509 260q0 -234 -26 -350q-14 -59 -58 -99t-102 -46q-184 -21 -555 -21t-555 21q-58 6 -102.5 46t-57.5 99 q-26 112 -26 350q0 234 26 350q14 59 58 99t103 47q183 20 554 20t555 -20q58 -7 102.5 -47t57.5 -99q26 -112 26 -350zM511 1536h102l-121 -399v-271h-100v271q-14 74 -61 212q-37 103 -65 187h106l71 -263zM881 1203v-175q0 -81 -28 -118q-37 -51 -106 -51q-67 0 -105 51 q-28 38 -28 118v175q0 80 28 117q38 51 105 51q69 0 106 -51q28 -37 28 -117zM1216 1365v-499h-91v55q-53 -62 -103 -62q-46 0 -59 37q-8 24 -8 75v394h91v-367q0 -33 1 -35q3 -22 21 -22q27 0 57 43v381h91z" />
-<glyph unicode="&#xf168;" horiz-adv-x="1408" d="M597 869q-10 -18 -257 -456q-27 -46 -65 -46h-239q-21 0 -31 17t0 36l253 448q1 0 0 1l-161 279q-12 22 -1 37q9 15 32 15h239q40 0 66 -45zM1403 1511q11 -16 0 -37l-528 -934v-1l336 -615q11 -20 1 -37q-10 -15 -32 -15h-239q-42 0 -66 45l-339 622q18 32 531 942 q25 45 64 45h241q22 0 31 -15z" />
-<glyph unicode="&#xf169;" d="M685 771q0 1 -126 222q-21 34 -52 34h-184q-18 0 -26 -11q-7 -12 1 -29l125 -216v-1l-196 -346q-9 -14 0 -28q8 -13 24 -13h185q31 0 50 36zM1309 1268q-7 12 -24 12h-187q-30 0 -49 -35l-411 -729q1 -2 262 -481q20 -35 52 -35h184q18 0 25 12q8 13 -1 28l-260 476v1 l409 723q8 16 0 28zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf16a;" horiz-adv-x="1792" d="M1280 640q0 37 -30 54l-512 320q-31 20 -65 2q-33 -18 -33 -56v-640q0 -38 33 -56q16 -8 31 -8q20 0 34 10l512 320q30 17 30 54zM1792 640q0 -96 -1 -150t-8.5 -136.5t-22.5 -147.5q-16 -73 -69 -123t-124 -58q-222 -25 -671 -25t-671 25q-71 8 -124.5 58t-69.5 123 q-14 65 -21.5 147.5t-8.5 136.5t-1 150t1 150t8.5 136.5t22.5 147.5q16 73 69 123t124 58q222 25 671 25t671 -25q71 -8 124.5 -58t69.5 -123q14 -65 21.5 -147.5t8.5 -136.5t1 -150z" />
-<glyph unicode="&#xf16b;" horiz-adv-x="1792" d="M402 829l494 -305l-342 -285l-490 319zM1388 274v-108l-490 -293v-1l-1 1l-1 -1v1l-489 293v108l147 -96l342 284v2l1 -1l1 1v-2l343 -284zM554 1418l342 -285l-494 -304l-338 270zM1390 829l338 -271l-489 -319l-343 285zM1239 1418l489 -319l-338 -270l-494 304z" />
-<glyph unicode="&#xf16c;" horiz-adv-x="1408" d="M928 135v-151l-707 -1v151zM1169 481v-701l-1 -35v-1h-1132l-35 1h-1v736h121v-618h928v618h120zM241 393l704 -65l-13 -150l-705 65zM309 709l683 -183l-39 -146l-683 183zM472 1058l609 -360l-77 -130l-609 360zM832 1389l398 -585l-124 -85l-399 584zM1285 1536 l121 -697l-149 -26l-121 697z" />
-<glyph unicode="&#xf16d;" d="M1362 110v648h-135q20 -63 20 -131q0 -126 -64 -232.5t-174 -168.5t-240 -62q-197 0 -337 135.5t-140 327.5q0 68 20 131h-141v-648q0 -26 17.5 -43.5t43.5 -17.5h1069q25 0 43 17.5t18 43.5zM1078 643q0 124 -90.5 211.5t-218.5 87.5q-127 0 -217.5 -87.5t-90.5 -211.5 t90.5 -211.5t217.5 -87.5q128 0 218.5 87.5t90.5 211.5zM1362 1003v165q0 28 -20 48.5t-49 20.5h-174q-29 0 -49 -20.5t-20 -48.5v-165q0 -29 20 -49t49 -20h174q29 0 49 20t20 49zM1536 1211v-1142q0 -81 -58 -139t-139 -58h-1142q-81 0 -139 58t-58 139v1142q0 81 58 139 t139 58h1142q81 0 139 -58t58 -139z" />
-<glyph unicode="&#xf16e;" d="M1248 1408q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960zM698 640q0 88 -62 150t-150 62t-150 -62t-62 -150t62 -150t150 -62t150 62t62 150zM1262 640q0 88 -62 150 t-150 62t-150 -62t-62 -150t62 -150t150 -62t150 62t62 150z" />
-<glyph unicode="&#xf170;" d="M768 914l201 -306h-402zM1133 384h94l-459 691l-459 -691h94l104 160h522zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf171;" horiz-adv-x="1408" d="M815 677q8 -63 -50.5 -101t-111.5 -6q-39 17 -53.5 58t-0.5 82t52 58q36 18 72.5 12t64 -35.5t27.5 -67.5zM926 698q-14 107 -113 164t-197 13q-63 -28 -100.5 -88.5t-34.5 -129.5q4 -91 77.5 -155t165.5 -56q91 8 152 84t50 168zM1165 1240q-20 27 -56 44.5t-58 22 t-71 12.5q-291 47 -566 -2q-43 -7 -66 -12t-55 -22t-50 -43q30 -28 76 -45.5t73.5 -22t87.5 -11.5q228 -29 448 -1q63 8 89.5 12t72.5 21.5t75 46.5zM1222 205q-8 -26 -15.5 -76.5t-14 -84t-28.5 -70t-58 -56.5q-86 -48 -189.5 -71.5t-202 -22t-201.5 18.5q-46 8 -81.5 18 t-76.5 27t-73 43.5t-52 61.5q-25 96 -57 292l6 16l18 9q223 -148 506.5 -148t507.5 148q21 -6 24 -23t-5 -45t-8 -37zM1403 1166q-26 -167 -111 -655q-5 -30 -27 -56t-43.5 -40t-54.5 -31q-252 -126 -610 -88q-248 27 -394 139q-15 12 -25.5 26.5t-17 35t-9 34t-6 39.5 t-5.5 35q-9 50 -26.5 150t-28 161.5t-23.5 147.5t-22 158q3 26 17.5 48.5t31.5 37.5t45 30t46 22.5t48 18.5q125 46 313 64q379 37 676 -50q155 -46 215 -122q16 -20 16.5 -51t-5.5 -54z" />
-<glyph unicode="&#xf172;" d="M848 666q0 43 -41 66t-77 1q-43 -20 -42.5 -72.5t43.5 -70.5q39 -23 81 4t36 72zM928 682q8 -66 -36 -121t-110 -61t-119 40t-56 113q-2 49 25.5 93t72.5 64q70 31 141.5 -10t81.5 -118zM1100 1073q-20 -21 -53.5 -34t-53 -16t-63.5 -8q-155 -20 -324 0q-44 6 -63 9.5 t-52.5 16t-54.5 32.5q13 19 36 31t40 15.5t47 8.5q198 35 408 1q33 -5 51 -8.5t43 -16t39 -31.5zM1142 327q0 7 5.5 26.5t3 32t-17.5 16.5q-161 -106 -365 -106t-366 106l-12 -6l-5 -12q26 -154 41 -210q47 -81 204 -108q249 -46 428 53q34 19 49 51.5t22.5 85.5t12.5 71z M1272 1020q9 53 -8 75q-43 55 -155 88q-216 63 -487 36q-132 -12 -226 -46q-38 -15 -59.5 -25t-47 -34t-29.5 -54q8 -68 19 -138t29 -171t24 -137q1 -5 5 -31t7 -36t12 -27t22 -28q105 -80 284 -100q259 -28 440 63q24 13 39.5 23t31 29t19.5 40q48 267 80 473zM1536 1120 v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf173;" horiz-adv-x="1024" d="M390 1408h219v-388h364v-241h-364v-394q0 -136 14 -172q13 -37 52 -60q50 -31 117 -31q117 0 232 76v-242q-102 -48 -178 -65q-77 -19 -173 -19q-105 0 -186 27q-78 25 -138 75q-58 51 -79 105q-22 54 -22 161v539h-170v217q91 30 155 84q64 55 103 132q39 78 54 196z " />
-<glyph unicode="&#xf174;" d="M1123 127v181q-88 -56 -174 -56q-51 0 -88 23q-29 17 -39 45q-11 30 -11 129v295h274v181h-274v291h-164q-11 -90 -40 -147t-78 -99q-48 -40 -116 -63v-163h127v-404q0 -78 17 -121q17 -42 59 -78q43 -37 104 -57q62 -20 140 -20q67 0 129 14q57 13 134 49zM1536 1120 v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf175;" horiz-adv-x="768" d="M765 237q8 -19 -5 -35l-350 -384q-10 -10 -23 -10q-14 0 -24 10l-355 384q-13 16 -5 35q9 19 29 19h224v1248q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1248h224q21 0 29 -19z" />
-<glyph unicode="&#xf176;" horiz-adv-x="768" d="M765 1043q-9 -19 -29 -19h-224v-1248q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v1248h-224q-21 0 -29 19t5 35l350 384q10 10 23 10q14 0 24 -10l355 -384q13 -16 5 -35z" />
-<glyph unicode="&#xf177;" horiz-adv-x="1792" d="M1792 736v-192q0 -14 -9 -23t-23 -9h-1248v-224q0 -21 -19 -29t-35 5l-384 350q-10 10 -10 23q0 14 10 24l384 354q16 14 35 6q19 -9 19 -29v-224h1248q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf178;" horiz-adv-x="1792" d="M1728 643q0 -14 -10 -24l-384 -354q-16 -14 -35 -6q-19 9 -19 29v224h-1248q-14 0 -23 9t-9 23v192q0 14 9 23t23 9h1248v224q0 21 19 29t35 -5l384 -350q10 -10 10 -23z" />
-<glyph unicode="&#xf179;" horiz-adv-x="1408" d="M1393 321q-39 -125 -123 -250q-129 -196 -257 -196q-49 0 -140 32q-86 32 -151 32q-61 0 -142 -33q-81 -34 -132 -34q-152 0 -301 259q-147 261 -147 503q0 228 113 374q112 144 284 144q72 0 177 -30q104 -30 138 -30q45 0 143 34q102 34 173 34q119 0 213 -65 q52 -36 104 -100q-79 -67 -114 -118q-65 -94 -65 -207q0 -124 69 -223t158 -126zM1017 1494q0 -61 -29 -136q-30 -75 -93 -138q-54 -54 -108 -72q-37 -11 -104 -17q3 149 78 257q74 107 250 148q1 -3 2.5 -11t2.5 -11q0 -4 0.5 -10t0.5 -10z" />
-<glyph unicode="&#xf17a;" horiz-adv-x="1664" d="M682 530v-651l-682 94v557h682zM682 1273v-659h-682v565zM1664 530v-786l-907 125v661h907zM1664 1408v-794h-907v669z" />
-<glyph unicode="&#xf17b;" horiz-adv-x="1408" d="M493 1053q16 0 27.5 11.5t11.5 27.5t-11.5 27.5t-27.5 11.5t-27 -11.5t-11 -27.5t11 -27.5t27 -11.5zM915 1053q16 0 27 11.5t11 27.5t-11 27.5t-27 11.5t-27.5 -11.5t-11.5 -27.5t11.5 -27.5t27.5 -11.5zM103 869q42 0 72 -30t30 -72v-430q0 -43 -29.5 -73t-72.5 -30 t-73 30t-30 73v430q0 42 30 72t73 30zM1163 850v-666q0 -46 -32 -78t-77 -32h-75v-227q0 -43 -30 -73t-73 -30t-73 30t-30 73v227h-138v-227q0 -43 -30 -73t-73 -30q-42 0 -72 30t-30 73l-1 227h-74q-46 0 -78 32t-32 78v666h918zM931 1255q107 -55 171 -153.5t64 -215.5 h-925q0 117 64 215.5t172 153.5l-71 131q-7 13 5 20q13 6 20 -6l72 -132q95 42 201 42t201 -42l72 132q7 12 20 6q12 -7 5 -20zM1408 767v-430q0 -43 -30 -73t-73 -30q-42 0 -72 30t-30 73v430q0 43 30 72.5t72 29.5q43 0 73 -29.5t30 -72.5z" />
-<glyph unicode="&#xf17c;" d="M663 1125q-11 -1 -15.5 -10.5t-8.5 -9.5q-5 -1 -5 5q0 12 19 15h10zM750 1111q-4 -1 -11.5 6.5t-17.5 4.5q24 11 32 -2q3 -6 -3 -9zM399 684q-4 1 -6 -3t-4.5 -12.5t-5.5 -13.5t-10 -13q-7 -10 -1 -12q4 -1 12.5 7t12.5 18q1 3 2 7t2 6t1.5 4.5t0.5 4v3t-1 2.5t-3 2z M1254 325q0 18 -55 42q4 15 7.5 27.5t5 26t3 21.5t0.5 22.5t-1 19.5t-3.5 22t-4 20.5t-5 25t-5.5 26.5q-10 48 -47 103t-72 75q24 -20 57 -83q87 -162 54 -278q-11 -40 -50 -42q-31 -4 -38.5 18.5t-8 83.5t-11.5 107q-9 39 -19.5 69t-19.5 45.5t-15.5 24.5t-13 15t-7.5 7 q-14 62 -31 103t-29.5 56t-23.5 33t-15 40q-4 21 6 53.5t4.5 49.5t-44.5 25q-15 3 -44.5 18t-35.5 16q-8 1 -11 26t8 51t36 27q37 3 51 -30t4 -58q-11 -19 -2 -26.5t30 -0.5q13 4 13 36v37q-5 30 -13.5 50t-21 30.5t-23.5 15t-27 7.5q-107 -8 -89 -134q0 -15 -1 -15 q-9 9 -29.5 10.5t-33 -0.5t-15.5 5q1 57 -16 90t-45 34q-27 1 -41.5 -27.5t-16.5 -59.5q-1 -15 3.5 -37t13 -37.5t15.5 -13.5q10 3 16 14q4 9 -7 8q-7 0 -15.5 14.5t-9.5 33.5q-1 22 9 37t34 14q17 0 27 -21t9.5 -39t-1.5 -22q-22 -15 -31 -29q-8 -12 -27.5 -23.5 t-20.5 -12.5q-13 -14 -15.5 -27t7.5 -18q14 -8 25 -19.5t16 -19t18.5 -13t35.5 -6.5q47 -2 102 15q2 1 23 7t34.5 10.5t29.5 13t21 17.5q9 14 20 8q5 -3 6.5 -8.5t-3 -12t-16.5 -9.5q-20 -6 -56.5 -21.5t-45.5 -19.5q-44 -19 -70 -23q-25 -5 -79 2q-10 2 -9 -2t17 -19 q25 -23 67 -22q17 1 36 7t36 14t33.5 17.5t30 17t24.5 12t17.5 2.5t8.5 -11q0 -2 -1 -4.5t-4 -5t-6 -4.5t-8.5 -5t-9 -4.5t-10 -5t-9.5 -4.5q-28 -14 -67.5 -44t-66.5 -43t-49 -1q-21 11 -63 73q-22 31 -25 22q-1 -3 -1 -10q0 -25 -15 -56.5t-29.5 -55.5t-21 -58t11.5 -63 q-23 -6 -62.5 -90t-47.5 -141q-2 -18 -1.5 -69t-5.5 -59q-8 -24 -29 -3q-32 31 -36 94q-2 28 4 56q4 19 -1 18l-4 -5q-36 -65 10 -166q5 -12 25 -28t24 -20q20 -23 104 -90.5t93 -76.5q16 -15 17.5 -38t-14 -43t-45.5 -23q8 -15 29 -44.5t28 -54t7 -70.5q46 24 7 92 q-4 8 -10.5 16t-9.5 12t-2 6q3 5 13 9.5t20 -2.5q46 -52 166 -36q133 15 177 87q23 38 34 30q12 -6 10 -52q-1 -25 -23 -92q-9 -23 -6 -37.5t24 -15.5q3 19 14.5 77t13.5 90q2 21 -6.5 73.5t-7.5 97t23 70.5q15 18 51 18q1 37 34.5 53t72.5 10.5t60 -22.5zM626 1152 q3 17 -2.5 30t-11.5 15q-9 2 -9 -7q2 -5 5 -6q10 0 7 -15q-3 -20 8 -20q3 0 3 3zM1045 955q-2 8 -6.5 11.5t-13 5t-14.5 5.5q-5 3 -9.5 8t-7 8t-5.5 6.5t-4 4t-4 -1.5q-14 -16 7 -43.5t39 -31.5q9 -1 14.5 8t3.5 20zM867 1168q0 11 -5 19.5t-11 12.5t-9 3q-14 -1 -7 -7l4 -2 q14 -4 18 -31q0 -3 8 2zM921 1401q0 2 -2.5 5t-9 7t-9.5 6q-15 15 -24 15q-9 -1 -11.5 -7.5t-1 -13t-0.5 -12.5q-1 -4 -6 -10.5t-6 -9t3 -8.5q4 -3 8 0t11 9t15 9q1 1 9 1t15 2t9 7zM1486 60q20 -12 31 -24.5t12 -24t-2.5 -22.5t-15.5 -22t-23.5 -19.5t-30 -18.5 t-31.5 -16.5t-32 -15.5t-27 -13q-38 -19 -85.5 -56t-75.5 -64q-17 -16 -68 -19.5t-89 14.5q-18 9 -29.5 23.5t-16.5 25.5t-22 19.5t-47 9.5q-44 1 -130 1q-19 0 -57 -1.5t-58 -2.5q-44 -1 -79.5 -15t-53.5 -30t-43.5 -28.5t-53.5 -11.5q-29 1 -111 31t-146 43q-19 4 -51 9.5 t-50 9t-39.5 9.5t-33.5 14.5t-17 19.5q-10 23 7 66.5t18 54.5q1 16 -4 40t-10 42.5t-4.5 36.5t10.5 27q14 12 57 14t60 12q30 18 42 35t12 51q21 -73 -32 -106q-32 -20 -83 -15q-34 3 -43 -10q-13 -15 5 -57q2 -6 8 -18t8.5 -18t4.5 -17t1 -22q0 -15 -17 -49t-14 -48 q3 -17 37 -26q20 -6 84.5 -18.5t99.5 -20.5q24 -6 74 -22t82.5 -23t55.5 -4q43 6 64.5 28t23 48t-7.5 58.5t-19 52t-20 36.5q-121 190 -169 242q-68 74 -113 40q-11 -9 -15 15q-3 16 -2 38q1 29 10 52t24 47t22 42q8 21 26.5 72t29.5 78t30 61t39 54q110 143 124 195 q-12 112 -16 310q-2 90 24 151.5t106 104.5q39 21 104 21q53 1 106 -13.5t89 -41.5q57 -42 91.5 -121.5t29.5 -147.5q-5 -95 30 -214q34 -113 133 -218q55 -59 99.5 -163t59.5 -191q8 -49 5 -84.5t-12 -55.5t-20 -22q-10 -2 -23.5 -19t-27 -35.5t-40.5 -33.5t-61 -14 q-18 1 -31.5 5t-22.5 13.5t-13.5 15.5t-11.5 20.5t-9 19.5q-22 37 -41 30t-28 -49t7 -97q20 -70 1 -195q-10 -65 18 -100.5t73 -33t85 35.5q59 49 89.5 66.5t103.5 42.5q53 18 77 36.5t18.5 34.5t-25 28.5t-51.5 23.5q-33 11 -49.5 48t-15 72.5t15.5 47.5q1 -31 8 -56.5 t14.5 -40.5t20.5 -28.5t21 -19t21.5 -13t16.5 -9.5z" />
-<glyph unicode="&#xf17d;" d="M1024 36q-42 241 -140 498h-2l-2 -1q-16 -6 -43 -16.5t-101 -49t-137 -82t-131 -114.5t-103 -148l-15 11q184 -150 418 -150q132 0 256 52zM839 643q-21 49 -53 111q-311 -93 -673 -93q-1 -7 -1 -21q0 -124 44 -236.5t124 -201.5q50 89 123.5 166.5t142.5 124.5t130.5 81 t99.5 48l37 13q4 1 13 3.5t13 4.5zM732 855q-120 213 -244 378q-138 -65 -234 -186t-128 -272q302 0 606 80zM1416 536q-210 60 -409 29q87 -239 128 -469q111 75 185 189.5t96 250.5zM611 1277q-1 0 -2 -1q1 1 2 1zM1201 1132q-185 164 -433 164q-76 0 -155 -19 q131 -170 246 -382q69 26 130 60.5t96.5 61.5t65.5 57t37.5 40.5zM1424 647q-3 232 -149 410l-1 -1q-9 -12 -19 -24.5t-43.5 -44.5t-71 -60.5t-100 -65t-131.5 -64.5q25 -53 44 -95q2 -6 6.5 -17.5t7.5 -16.5q36 5 74.5 7t73.5 2t69 -1.5t64 -4t56.5 -5.5t48 -6.5t36.5 -6 t25 -4.5zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf17e;" d="M1173 473q0 50 -19.5 91.5t-48.5 68.5t-73 49t-82.5 34t-87.5 23l-104 24q-30 7 -44 10.5t-35 11.5t-30 16t-16.5 21t-7.5 30q0 77 144 77q43 0 77 -12t54 -28.5t38 -33.5t40 -29t48 -12q47 0 75.5 32t28.5 77q0 55 -56 99.5t-142 67.5t-182 23q-68 0 -132 -15.5 t-119.5 -47t-89 -87t-33.5 -128.5q0 -61 19 -106.5t56 -75.5t80 -48.5t103 -32.5l146 -36q90 -22 112 -36q32 -20 32 -60q0 -39 -40 -64.5t-105 -25.5q-51 0 -91.5 16t-65 38.5t-45.5 45t-46 38.5t-54 16q-50 0 -75.5 -30t-25.5 -75q0 -92 122 -157.5t291 -65.5 q73 0 140 18.5t122.5 53.5t88.5 93.5t33 131.5zM1536 256q0 -159 -112.5 -271.5t-271.5 -112.5q-130 0 -234 80q-77 -16 -150 -16q-143 0 -273.5 55.5t-225 150t-150 225t-55.5 273.5q0 73 16 150q-80 104 -80 234q0 159 112.5 271.5t271.5 112.5q130 0 234 -80 q77 16 150 16q143 0 273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -73 -16 -150q80 -104 80 -234z" />
-<glyph unicode="&#xf180;" horiz-adv-x="1664" d="M1483 512l-587 -587q-52 -53 -127.5 -53t-128.5 53l-587 587q-53 53 -53 128t53 128l587 587q53 53 128 53t128 -53l265 -265l-398 -399l-188 188q-42 42 -99 42q-59 0 -100 -41l-120 -121q-42 -40 -42 -99q0 -58 42 -100l406 -408q30 -28 67 -37l6 -4h28q60 0 99 41 l619 619l2 -3q53 -53 53 -128t-53 -128zM1406 1138l120 -120q14 -15 14 -36t-14 -36l-730 -730q-17 -15 -37 -15v0q-4 0 -6 1q-18 2 -30 14l-407 408q-14 15 -14 36t14 35l121 120q13 15 35 15t36 -15l252 -252l574 575q15 15 36 15t36 -15z" />
-<glyph unicode="&#xf181;" d="M704 192v1024q0 14 -9 23t-23 9h-480q-14 0 -23 -9t-9 -23v-1024q0 -14 9 -23t23 -9h480q14 0 23 9t9 23zM1376 576v640q0 14 -9 23t-23 9h-480q-14 0 -23 -9t-9 -23v-640q0 -14 9 -23t23 -9h480q14 0 23 9t9 23zM1536 1344v-1408q0 -26 -19 -45t-45 -19h-1408 q-26 0 -45 19t-19 45v1408q0 26 19 45t45 19h1408q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf182;" horiz-adv-x="1280" d="M1280 480q0 -40 -28 -68t-68 -28q-51 0 -80 43l-227 341h-45v-132l247 -411q9 -15 9 -33q0 -26 -19 -45t-45 -19h-192v-272q0 -46 -33 -79t-79 -33h-160q-46 0 -79 33t-33 79v272h-192q-26 0 -45 19t-19 45q0 18 9 33l247 411v132h-45l-227 -341q-29 -43 -80 -43 q-40 0 -68 28t-28 68q0 29 16 53l256 384q73 107 176 107h384q103 0 176 -107l256 -384q16 -24 16 -53zM864 1280q0 -93 -65.5 -158.5t-158.5 -65.5t-158.5 65.5t-65.5 158.5t65.5 158.5t158.5 65.5t158.5 -65.5t65.5 -158.5z" />
-<glyph unicode="&#xf183;" horiz-adv-x="1024" d="M1024 832v-416q0 -40 -28 -68t-68 -28t-68 28t-28 68v352h-64v-912q0 -46 -33 -79t-79 -33t-79 33t-33 79v464h-64v-464q0 -46 -33 -79t-79 -33t-79 33t-33 79v912h-64v-352q0 -40 -28 -68t-68 -28t-68 28t-28 68v416q0 80 56 136t136 56h640q80 0 136 -56t56 -136z M736 1280q0 -93 -65.5 -158.5t-158.5 -65.5t-158.5 65.5t-65.5 158.5t65.5 158.5t158.5 65.5t158.5 -65.5t65.5 -158.5z" />
-<glyph unicode="&#xf184;" d="M773 234l350 473q16 22 24.5 59t-6 85t-61.5 79q-40 26 -83 25.5t-73.5 -17.5t-54.5 -45q-36 -40 -96 -40q-59 0 -95 40q-24 28 -54.5 45t-73.5 17.5t-84 -25.5q-46 -31 -60.5 -79t-6 -85t24.5 -59zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103 t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf185;" horiz-adv-x="1792" d="M1472 640q0 117 -45.5 223.5t-123 184t-184 123t-223.5 45.5t-223.5 -45.5t-184 -123t-123 -184t-45.5 -223.5t45.5 -223.5t123 -184t184 -123t223.5 -45.5t223.5 45.5t184 123t123 184t45.5 223.5zM1748 363q-4 -15 -20 -20l-292 -96v-306q0 -16 -13 -26q-15 -10 -29 -4 l-292 94l-180 -248q-10 -13 -26 -13t-26 13l-180 248l-292 -94q-14 -6 -29 4q-13 10 -13 26v306l-292 96q-16 5 -20 20q-5 17 4 29l180 248l-180 248q-9 13 -4 29q4 15 20 20l292 96v306q0 16 13 26q15 10 29 4l292 -94l180 248q9 12 26 12t26 -12l180 -248l292 94 q14 6 29 -4q13 -10 13 -26v-306l292 -96q16 -5 20 -20q5 -16 -4 -29l-180 -248l180 -248q9 -12 4 -29z" />
-<glyph unicode="&#xf186;" d="M1262 233q-54 -9 -110 -9q-182 0 -337 90t-245 245t-90 337q0 192 104 357q-201 -60 -328.5 -229t-127.5 -384q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51q144 0 273.5 61.5t220.5 171.5zM1465 318q-94 -203 -283.5 -324.5t-413.5 -121.5q-156 0 -298 61 t-245 164t-164 245t-61 298q0 153 57.5 292.5t156 241.5t235.5 164.5t290 68.5q44 2 61 -39q18 -41 -15 -72q-86 -78 -131.5 -181.5t-45.5 -218.5q0 -148 73 -273t198 -198t273 -73q118 0 228 51q41 18 72 -13q14 -14 17.5 -34t-4.5 -38z" />
-<glyph unicode="&#xf187;" horiz-adv-x="1792" d="M1088 704q0 26 -19 45t-45 19h-256q-26 0 -45 -19t-19 -45t19 -45t45 -19h256q26 0 45 19t19 45zM1664 896v-960q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45v960q0 26 19 45t45 19h1408q26 0 45 -19t19 -45zM1728 1344v-256q0 -26 -19 -45t-45 -19h-1536 q-26 0 -45 19t-19 45v256q0 26 19 45t45 19h1536q26 0 45 -19t19 -45z" />
-<glyph unicode="&#xf188;" horiz-adv-x="1664" d="M1632 576q0 -26 -19 -45t-45 -19h-224q0 -171 -67 -290l208 -209q19 -19 19 -45t-19 -45q-18 -19 -45 -19t-45 19l-198 197q-5 -5 -15 -13t-42 -28.5t-65 -36.5t-82 -29t-97 -13v896h-128v-896q-51 0 -101.5 13.5t-87 33t-66 39t-43.5 32.5l-15 14l-183 -207 q-20 -21 -48 -21q-24 0 -43 16q-19 18 -20.5 44.5t15.5 46.5l202 227q-58 114 -58 274h-224q-26 0 -45 19t-19 45t19 45t45 19h224v294l-173 173q-19 19 -19 45t19 45t45 19t45 -19l173 -173h844l173 173q19 19 45 19t45 -19t19 -45t-19 -45l-173 -173v-294h224q26 0 45 -19 t19 -45zM1152 1152h-640q0 133 93.5 226.5t226.5 93.5t226.5 -93.5t93.5 -226.5z" />
-<glyph unicode="&#xf189;" horiz-adv-x="1920" d="M1917 1016q23 -64 -150 -294q-24 -32 -65 -85q-78 -100 -90 -131q-17 -41 14 -81q17 -21 81 -82h1l1 -1l1 -1l2 -2q141 -131 191 -221q3 -5 6.5 -12.5t7 -26.5t-0.5 -34t-25 -27.5t-59 -12.5l-256 -4q-24 -5 -56 5t-52 22l-20 12q-30 21 -70 64t-68.5 77.5t-61 58 t-56.5 15.5q-3 -1 -8 -3.5t-17 -14.5t-21.5 -29.5t-17 -52t-6.5 -77.5q0 -15 -3.5 -27.5t-7.5 -18.5l-4 -5q-18 -19 -53 -22h-115q-71 -4 -146 16.5t-131.5 53t-103 66t-70.5 57.5l-25 24q-10 10 -27.5 30t-71.5 91t-106 151t-122.5 211t-130.5 272q-6 16 -6 27t3 16l4 6 q15 19 57 19l274 2q12 -2 23 -6.5t16 -8.5l5 -3q16 -11 24 -32q20 -50 46 -103.5t41 -81.5l16 -29q29 -60 56 -104t48.5 -68.5t41.5 -38.5t34 -14t27 5q2 1 5 5t12 22t13.5 47t9.5 81t0 125q-2 40 -9 73t-14 46l-6 12q-25 34 -85 43q-13 2 5 24q17 19 38 30q53 26 239 24 q82 -1 135 -13q20 -5 33.5 -13.5t20.5 -24t10.5 -32t3.5 -45.5t-1 -55t-2.5 -70.5t-1.5 -82.5q0 -11 -1 -42t-0.5 -48t3.5 -40.5t11.5 -39t22.5 -24.5q8 -2 17 -4t26 11t38 34.5t52 67t68 107.5q60 104 107 225q4 10 10 17.5t11 10.5l4 3l5 2.5t13 3t20 0.5l288 2 q39 5 64 -2.5t31 -16.5z" />
-<glyph unicode="&#xf18a;" horiz-adv-x="1792" d="M675 252q21 34 11 69t-45 50q-34 14 -73 1t-60 -46q-22 -34 -13 -68.5t43 -50.5t74.5 -2.5t62.5 47.5zM769 373q8 13 3.5 26.5t-17.5 18.5q-14 5 -28.5 -0.5t-21.5 -18.5q-17 -31 13 -45q14 -5 29 0.5t22 18.5zM943 266q-45 -102 -158 -150t-224 -12 q-107 34 -147.5 126.5t6.5 187.5q47 93 151.5 139t210.5 19q111 -29 158.5 -119.5t2.5 -190.5zM1255 426q-9 96 -89 170t-208.5 109t-274.5 21q-223 -23 -369.5 -141.5t-132.5 -264.5q9 -96 89 -170t208.5 -109t274.5 -21q223 23 369.5 141.5t132.5 264.5zM1563 422 q0 -68 -37 -139.5t-109 -137t-168.5 -117.5t-226 -83t-270.5 -31t-275 33.5t-240.5 93t-171.5 151t-65 199.5q0 115 69.5 245t197.5 258q169 169 341.5 236t246.5 -7q65 -64 20 -209q-4 -14 -1 -20t10 -7t14.5 0.5t13.5 3.5l6 2q139 59 246 59t153 -61q45 -63 0 -178 q-2 -13 -4.5 -20t4.5 -12.5t12 -7.5t17 -6q57 -18 103 -47t80 -81.5t34 -116.5zM1489 1046q42 -47 54.5 -108.5t-6.5 -117.5q-8 -23 -29.5 -34t-44.5 -4q-23 8 -34 29.5t-4 44.5q20 63 -24 111t-107 35q-24 -5 -45 8t-25 37q-5 24 8 44.5t37 25.5q60 13 119 -5.5t101 -65.5z M1670 1209q87 -96 112.5 -222.5t-13.5 -241.5q-9 -27 -34 -40t-52 -4t-40 34t-5 52q28 82 10 172t-80 158q-62 69 -148 95.5t-173 8.5q-28 -6 -52 9.5t-30 43.5t9.5 51.5t43.5 29.5q123 26 244 -11.5t208 -134.5z" />
-<glyph unicode="&#xf18b;" d="M1133 -34q-171 -94 -368 -94q-196 0 -367 94q138 87 235.5 211t131.5 268q35 -144 132.5 -268t235.5 -211zM638 1394v-485q0 -252 -126.5 -459.5t-330.5 -306.5q-181 215 -181 495q0 187 83.5 349.5t229.5 269.5t325 137zM1536 638q0 -280 -181 -495 q-204 99 -330.5 306.5t-126.5 459.5v485q179 -30 325 -137t229.5 -269.5t83.5 -349.5z" />
-<glyph unicode="&#xf18c;" horiz-adv-x="1408" d="M1402 433q-32 -80 -76 -138t-91 -88.5t-99 -46.5t-101.5 -14.5t-96.5 8.5t-86.5 22t-69.5 27.5t-46 22.5l-17 10q-113 -228 -289.5 -359.5t-384.5 -132.5q-19 0 -32 13t-13 32t13 31.5t32 12.5q173 1 322.5 107.5t251.5 294.5q-36 -14 -72 -23t-83 -13t-91 2.5t-93 28.5 t-92 59t-84.5 100t-74.5 146q114 47 214 57t167.5 -7.5t124.5 -56.5t88.5 -77t56.5 -82q53 131 79 291q-7 -1 -18 -2.5t-46.5 -2.5t-69.5 0.5t-81.5 10t-88.5 23t-84 42.5t-75 65t-54.5 94.5t-28.5 127.5q70 28 133.5 36.5t112.5 -1t92 -30t73.5 -50t56 -61t42 -63t27.5 -56 t16 -39.5l4 -16q12 122 12 195q-8 6 -21.5 16t-49 44.5t-63.5 71.5t-54 93t-33 112.5t12 127t70 138.5q73 -25 127.5 -61.5t84.5 -76.5t48 -85t20.5 -89t-0.5 -85.5t-13 -76.5t-19 -62t-17 -42l-7 -15q1 -5 1 -50.5t-1 -71.5q3 7 10 18.5t30.5 43t50.5 58t71 55.5t91.5 44.5 t112 14.5t132.5 -24q-2 -78 -21.5 -141.5t-50 -104.5t-69.5 -71.5t-81.5 -45.5t-84.5 -24t-80 -9.5t-67.5 1t-46.5 4.5l-17 3q-23 -147 -73 -283q6 7 18 18.5t49.5 41t77.5 52.5t99.5 42t117.5 20t129 -23.5t137 -77.5z" />
-<glyph unicode="&#xf18d;" horiz-adv-x="1280" d="M1259 283v-66q0 -85 -57.5 -144.5t-138.5 -59.5h-57l-260 -269v269h-529q-81 0 -138.5 59.5t-57.5 144.5v66h1238zM1259 609v-255h-1238v255h1238zM1259 937v-255h-1238v255h1238zM1259 1077v-67h-1238v67q0 84 57.5 143.5t138.5 59.5h846q81 0 138.5 -59.5t57.5 -143.5z " />
-<glyph unicode="&#xf18e;" d="M1152 640q0 -14 -9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192h-352q-13 0 -22.5 9.5t-9.5 22.5v192q0 13 9.5 22.5t22.5 9.5h352v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198 t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf190;" d="M1152 736v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-352v-192q0 -14 -9 -23t-23 -9q-12 0 -24 10l-319 319q-9 9 -9 23t9 23l320 320q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5v-192h352q13 0 22.5 -9.5t9.5 -22.5zM1312 640q0 148 -73 273t-198 198t-273 73t-273 -73t-198 -198 t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273zM1536 640q0 -209 -103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf191;" d="M1024 960v-640q0 -26 -19 -45t-45 -19q-20 0 -37 12l-448 320q-27 19 -27 52t27 52l448 320q17 12 37 12q26 0 45 -19t19 -45zM1280 160v960q0 13 -9.5 22.5t-22.5 9.5h-960q-13 0 -22.5 -9.5t-9.5 -22.5v-960q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5z M1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf192;" d="M1024 640q0 -106 -75 -181t-181 -75t-181 75t-75 181t75 181t181 75t181 -75t75 -181zM768 1184q-148 0 -273 -73t-198 -198t-73 -273t73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73zM1536 640q0 -209 -103 -385.5t-279.5 -279.5 t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5t103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5z" />
-<glyph unicode="&#xf193;" horiz-adv-x="1664" d="M1023 349l102 -204q-58 -179 -210 -290t-339 -111q-156 0 -288.5 77.5t-210 210t-77.5 288.5q0 181 104.5 330t274.5 211l17 -131q-122 -54 -195 -165.5t-73 -244.5q0 -185 131.5 -316.5t316.5 -131.5q126 0 232.5 65t165 175.5t49.5 236.5zM1571 249l58 -114l-256 -128 q-13 -7 -29 -7q-40 0 -57 35l-239 477h-472q-24 0 -42.5 16.5t-21.5 40.5l-96 779q-2 16 6 42q14 51 57 82.5t97 31.5q66 0 113 -47t47 -113q0 -69 -52 -117.5t-120 -41.5l37 -289h423v-128h-407l16 -128h455q40 0 57 -35l228 -455z" />
-<glyph unicode="&#xf194;" d="M1254 899q16 85 -21 132q-52 65 -187 45q-17 -3 -41 -12.5t-57.5 -30.5t-64.5 -48.5t-59.5 -70t-44.5 -91.5q80 7 113.5 -16t26.5 -99q-5 -52 -52 -143q-43 -78 -71 -99q-44 -32 -87 14q-23 24 -37.5 64.5t-19 73t-10 84t-8.5 71.5q-23 129 -34 164q-12 37 -35.5 69 t-50.5 40q-57 16 -127 -25q-54 -32 -136.5 -106t-122.5 -102v-7q16 -8 25.5 -26t21.5 -20q21 -3 54.5 8.5t58 10.5t41.5 -30q11 -18 18.5 -38.5t15 -48t12.5 -40.5q17 -46 53 -187q36 -146 57 -197q42 -99 103 -125q43 -12 85 -1.5t76 31.5q131 77 250 237 q104 139 172.5 292.5t82.5 226.5zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf195;" horiz-adv-x="1152" d="M1152 704q0 -191 -94.5 -353t-256.5 -256.5t-353 -94.5h-160q-14 0 -23 9t-9 23v611l-215 -66q-3 -1 -9 -1q-10 0 -19 6q-13 10 -13 26v128q0 23 23 31l233 71v93l-215 -66q-3 -1 -9 -1q-10 0 -19 6q-13 10 -13 26v128q0 23 23 31l233 71v250q0 14 9 23t23 9h160 q14 0 23 -9t9 -23v-181l375 116q15 5 28 -5t13 -26v-128q0 -23 -23 -31l-393 -121v-93l375 116q15 5 28 -5t13 -26v-128q0 -23 -23 -31l-393 -121v-487q188 13 318 151t130 328q0 14 9 23t23 9h160q14 0 23 -9t9 -23z" />
-<glyph unicode="&#xf196;" horiz-adv-x="1408" d="M1152 736v-64q0 -14 -9 -23t-23 -9h-352v-352q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v352h-352q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h352v352q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-352h352q14 0 23 -9t9 -23zM1280 288v832q0 66 -47 113t-113 47h-832 q-66 0 -113 -47t-47 -113v-832q0 -66 47 -113t113 -47h832q66 0 113 47t47 113zM1408 1120v-832q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5v832q0 119 84.5 203.5t203.5 84.5h832q119 0 203.5 -84.5t84.5 -203.5z" />
-<glyph unicode="&#xf197;" horiz-adv-x="1792" />
-<glyph unicode="&#xf198;" horiz-adv-x="1792" />
-<glyph unicode="&#xf199;" horiz-adv-x="1792" />
-<glyph unicode="&#xf19a;" horiz-adv-x="1792" />
-<glyph unicode="&#xf19b;" horiz-adv-x="1792" />
-<glyph unicode="&#xf19c;" horiz-adv-x="1792" />
-<glyph unicode="&#xf19d;" horiz-adv-x="1792" />
-<glyph unicode="&#xf19e;" horiz-adv-x="1792" />
+<glyph unicode="&#xf118;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5 t-51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5zM384 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5zM402 461q-8 25 4 48.5t38 31.5q25 8 48.5 -4t31.5 -38 q25 -80 92.5 -129.5t151.5 -49.5t151.5 49.5t92.5 129.5q8 26 32 38t49 4t37 -31.5t4 -48.5q-37 -121 -138 -195t-228 -74t-228 74t-138 195zM896 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5z" />
+<glyph unicode="&#xf119;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5 t-51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5zM384 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5zM402 307q37 121 138 195t228 74t228 -74t138 -195q8 -25 -4 -48.5 t-37 -31.5t-49 4t-32 38q-25 80 -92.5 129.5t-151.5 49.5t-151.5 -49.5t-92.5 -129.5q-8 -26 -31.5 -38t-48.5 -4q-26 8 -38 31.5t-4 48.5zM896 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5z" />
+<glyph unicode="&#xf11a;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5 t-51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5zM384 448q0 26 19 45t45 19h640q26 0 45 -19t19 -45t-19 -45t-45 -19h-640q-26 0 -45 19t-19 45zM384 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5 t-90.5 -37.5t-90.5 37.5t-37.5 90.5zM896 896q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5t-37.5 -90.5t-90.5 -37.5t-90.5 37.5t-37.5 90.5z" />
+<glyph unicode="&#xf11b;" horiz-adv-x="1920" d="M0 512q0 212 150 362t362 150h896q212 0 362 -150t150 -362t-150 -362t-362 -150q-192 0 -338 128h-220q-146 -128 -338 -128q-212 0 -362 150t-150 362zM192 448q0 -14 9 -23t23 -9h192v-192q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v192h192q14 0 23 9t9 23v128 q0 14 -9 23t-23 9h-192v192q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-192h-192q-14 0 -23 -9t-9 -23v-128zM1152 384q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5zM1408 640q0 -53 37.5 -90.5t90.5 -37.5 t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5z" />
+<glyph unicode="&#xf11c;" horiz-adv-x="1920" d="M0 128v896q0 53 37.5 90.5t90.5 37.5h1664q53 0 90.5 -37.5t37.5 -90.5v-896q0 -53 -37.5 -90.5t-90.5 -37.5h-1664q-53 0 -90.5 37.5t-37.5 90.5zM128 128h1664v896h-1664v-896zM256 272v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM256 528v96 q0 16 16 16h224q16 0 16 -16v-96q0 -16 -16 -16h-224q-16 0 -16 16zM256 784v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM512 272v96q0 16 16 16h864q16 0 16 -16v-96q0 -16 -16 -16h-864q-16 0 -16 16zM512 784v96q0 16 16 16h96q16 0 16 -16v-96 q0 -16 -16 -16h-96q-16 0 -16 16zM640 528v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM768 784v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM896 528v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16z M1024 784v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM1152 528v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM1280 784v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16zM1408 528v96q0 16 16 16h112v240 q0 16 16 16h96q16 0 16 -16v-352q0 -16 -16 -16h-224q-16 0 -16 16zM1536 272v96q0 16 16 16h96q16 0 16 -16v-96q0 -16 -16 -16h-96q-16 0 -16 16z" />
+<glyph unicode="&#xf11d;" horiz-adv-x="1792" d="M64 1280q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5q0 -35 -17.5 -64t-46.5 -46v-1266q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v1266q-29 17 -46.5 46t-17.5 64zM320 320v742q0 35 31 55q35 21 78.5 42.5t114 52t152.5 49.5t155 19q112 0 209 -31t209 -86 q38 -19 89 -19q122 0 310 112q22 12 31 17q31 16 62 -2q31 -20 31 -55v-763q0 -39 -35 -57q-10 -5 -17 -9q-218 -116 -369 -116q-88 0 -158 35l-28 14q-64 33 -99 48t-91 29t-114 14q-102 0 -235.5 -44t-228.5 -102q-15 -9 -33 -9q-16 0 -32 8q-32 19 -32 56zM448 426 q245 113 433 113q55 0 103.5 -7.5t98 -26t77 -31t82.5 -39.5l28 -14q44 -22 101 -22q120 0 293 92v616q-169 -91 -306 -91q-82 0 -145 32q-100 49 -184 76.5t-178 27.5q-173 0 -403 -127v-599z" />
+<glyph unicode="&#xf11e;" horiz-adv-x="1792" d="M64 1280q0 53 37.5 90.5t90.5 37.5t90.5 -37.5t37.5 -90.5q0 -35 -17.5 -64t-46.5 -46v-1266q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v1266q-29 17 -46.5 46t-17.5 64zM320 320v742q0 35 31 55q35 21 78.5 42.5t114 52t152.5 49.5t155 19q112 0 209 -31t209 -86 q38 -19 89 -19q122 0 310 112q22 12 31 17q31 16 62 -2q31 -20 31 -55v-763q0 -39 -35 -57q-10 -5 -17 -9q-218 -116 -369 -116q-88 0 -158 35l-28 14q-64 33 -99 48t-91 29t-114 14q-102 0 -235.5 -44t-228.5 -102q-15 -9 -33 -9q-16 0 -32 8q-32 19 -32 56zM448 426 q205 96 384 110v192q-181 -16 -384 -117v-185zM448 836q215 111 384 118v197q-172 -8 -384 -126v-189zM832 730h19q102 0 192.5 -29t197.5 -82q19 -9 39 -15v-188q42 -17 91 -17q120 0 293 92v184q-235 -116 -384 -71v224q-20 6 -39 15q-5 3 -33 17t-34.5 17t-31.5 15 t-34.5 15.5t-32.5 13t-36 12.5t-35 8.5t-39.5 7.5t-39.5 4t-44 2q-23 0 -49 -3v-222zM1280 828q148 -42 384 90v189q-169 -91 -306 -91q-45 0 -78 8v-196z" />
+<glyph unicode="&#xf120;" horiz-adv-x="1664" d="M13 160q0 13 10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23zM640 32v64q0 14 9 23t23 9h960q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-960 q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf121;" horiz-adv-x="1920" d="M45 576q0 13 10 23l466 466q10 10 23 10t23 -10l50 -50q10 -10 10 -23t-10 -23l-393 -393l393 -393q10 -10 10 -23t-10 -23l-50 -50q-10 -10 -23 -10t-23 10l-466 466q-10 10 -10 23zM712 -52l373 1291q4 13 15.5 19.5t23.5 2.5l62 -17q13 -4 19.5 -15.5t2.5 -24.5 l-373 -1291q-4 -13 -15.5 -19.5t-23.5 -2.5l-62 17q-13 4 -19.5 15.5t-2.5 24.5zM1293 160q0 13 10 23l393 393l-393 393q-10 10 -10 23t10 23l50 50q10 10 23 10t23 -10l466 -466q10 -10 10 -23t-10 -23l-466 -466q-10 -10 -23 -10t-23 10l-50 50q-10 10 -10 23z" />
+<glyph unicode="&#xf122;" horiz-adv-x="1792" d="M0 896q0 26 19 45l512 512q29 31 70 14q39 -17 39 -59v-69l-397 -398q-19 -19 -19 -45t19 -45l397 -397v-70q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-512 512q-19 19 -19 45zM384 896q0 26 19 45l512 512q29 31 70 14q39 -17 39 -59v-262q411 -28 599 -221 q169 -173 169 -509q0 -58 -17 -133.5t-38.5 -138t-48 -125t-40.5 -90.5l-20 -40q-8 -17 -28 -17q-6 0 -9 1q-25 8 -23 34q43 400 -106 565q-64 71 -170.5 110.5t-267.5 52.5v-251q0 -42 -39 -59q-13 -5 -25 -5q-27 0 -45 19l-512 512q-19 19 -19 45z" />
+<glyph unicode="&#xf123;" horiz-adv-x="1664" d="M2 900.5q9 27.5 54 34.5l502 73l225 455q20 41 49 41q28 0 49 -41l225 -455l502 -73q45 -7 54 -34.5t-24 -59.5l-363 -354l86 -500q5 -33 -6 -51.5t-34 -18.5q-17 0 -40 12l-449 236l-449 -236q-23 -12 -40 -12q-23 0 -34 18.5t-6 51.5l86 500l-364 354q-32 32 -23 59.5z M832 310l59 -31l318 -168l-60 355l-12 66l49 47l257 250l-356 52l-66 10l-30 60l-159 322v-963z" />
+<glyph unicode="&#xf124;" horiz-adv-x="1408" d="M2 561q-5 22 4 42t29 30l1280 640q13 7 29 7q27 0 45 -19q15 -14 18.5 -34.5t-6.5 -39.5l-640 -1280q-17 -35 -57 -35q-5 0 -15 2q-22 5 -35.5 22.5t-13.5 39.5v576h-576q-22 0 -39.5 13.5t-22.5 35.5z" />
+<glyph unicode="&#xf125;" horiz-adv-x="1664" d="M0 928v192q0 14 9 23t23 9h224v224q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-224h851l246 247q10 9 23 9t23 -9q9 -10 9 -23t-9 -23l-247 -246v-851h224q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-224v-224q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v224h-864 q-14 0 -23 9t-9 23v864h-224q-14 0 -23 9t-9 23zM512 301l595 595h-595v-595zM557 256h595v595z" />
+<glyph unicode="&#xf126;" horiz-adv-x="1024" d="M0 64q0 52 26 96.5t70 69.5v820q-44 25 -70 69.5t-26 96.5q0 80 56 136t136 56t136 -56t56 -136q0 -52 -26 -96.5t-70 -69.5v-497q54 26 154 57q55 17 87.5 29.5t70.5 31t59 39.5t40.5 51t28 69.5t8.5 91.5q-44 25 -70 69.5t-26 96.5q0 80 56 136t136 56t136 -56t56 -136 q0 -52 -26 -96.5t-70 -69.5q-2 -287 -226 -414q-68 -38 -203 -81q-128 -40 -169.5 -71t-41.5 -100v-26q44 -25 70 -69.5t26 -96.5q0 -80 -56 -136t-136 -56t-136 56t-56 136zM96 64q0 -40 28 -68t68 -28t68 28t28 68t-28 68t-68 28t-68 -28t-28 -68zM96 1216q0 -40 28 -68 t68 -28t68 28t28 68t-28 68t-68 28t-68 -28t-28 -68zM736 1088q0 -40 28 -68t68 -28t68 28t28 68t-28 68t-68 28t-68 -28t-28 -68z" />
+<glyph unicode="&#xf127;" horiz-adv-x="1664" d="M0 448q0 14 9 23t23 9h320q14 0 23 -9t9 -23t-9 -23t-23 -9h-320q-14 0 -23 9t-9 23zM16 1088q0 120 85 203l147 146q83 83 203 83q121 0 204 -85l334 -335q21 -21 42 -56l-239 -18l-273 274q-28 28 -68 28q-39 0 -68 -27l-147 -146q-28 -28 -28 -67q0 -40 28 -68 l274 -274l-18 -240q-35 21 -56 42l-336 336q-84 86 -84 204zM128 32q0 13 9 23l256 256q10 9 23 9t23 -9q9 -10 9 -23t-9 -23l-256 -256q-10 -9 -23 -9q-12 0 -23 9q-9 10 -9 23zM544 -96v320q0 14 9 23t23 9t23 -9t9 -23v-320q0 -14 -9 -23t-23 -9t-23 9t-9 23zM633 364 l239 18l273 -274q27 -27 68 -27.5t68 26.5l147 146q28 28 28 67q0 40 -28 68l-274 275l18 239q35 -21 56 -42l336 -336q84 -86 84 -204q0 -120 -85 -203l-147 -146q-83 -83 -203 -83q-121 0 -204 85l-334 335q-21 21 -42 56zM1056 1184v320q0 14 9 23t23 9t23 -9t9 -23v-320 q0 -14 -9 -23t-23 -9t-23 9t-9 23zM1216 1120q0 13 9 23l256 256q10 9 23 9t23 -9q9 -10 9 -23t-9 -23l-256 -256q-11 -9 -23 -9t-23 9q-9 10 -9 23zM1280 960q0 14 9 23t23 9h320q14 0 23 -9t9 -23t-9 -23t-23 -9h-320q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf128;" horiz-adv-x="1024" d="M96.5 986q-2.5 15 5.5 28q160 266 464 266q80 0 161 -31t146 -83t106 -127.5t41 -158.5q0 -54 -15.5 -101t-35 -76.5t-55 -59.5t-57.5 -43.5t-61 -35.5q-41 -23 -68.5 -65t-27.5 -67q0 -17 -12 -32.5t-28 -15.5h-240q-15 0 -25.5 18.5t-10.5 37.5v45q0 83 65 156.5 t143 108.5q59 27 84 56t25 76q0 42 -46.5 74t-107.5 32q-65 0 -108 -29q-35 -25 -107 -115q-13 -16 -31 -16q-12 0 -25 8l-164 125q-13 10 -15.5 25zM384 40v240q0 16 12 28t28 12h240q16 0 28 -12t12 -28v-240q0 -16 -12 -28t-28 -12h-240q-16 0 -28 12t-12 28z" />
+<glyph unicode="&#xf129;" horiz-adv-x="640" d="M0 64v128q0 26 19 45t45 19h64v384h-64q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h384q26 0 45 -19t19 -45v-576h64q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45zM128 1152v192q0 26 19 45t45 19h256q26 0 45 -19t19 -45v-192 q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf12a;" horiz-adv-x="640" d="M98 1344q-1 26 17.5 45t44.5 19h320q26 0 44.5 -19t17.5 -45l-28 -768q-1 -26 -20.5 -45t-45.5 -19h-256q-26 0 -45.5 19t-20.5 45zM128 64v224q0 26 19 45t45 19h256q26 0 45 -19t19 -45v-224q0 -26 -19 -45t-45 -19h-256q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf12b;" d="M5 0v167h128l197 291l-185 272h-137v168h276l139 -228q2 -4 23 -42q8 -9 11 -21h3q3 9 11 21l25 42l140 228h257v-168h-125l-184 -267l204 -296h109v-167h-248l-159 252l-24 42q-8 9 -11 21h-3l-9 -21q-10 -20 -25 -44l-155 -250h-258zM1013 713q0 64 26 117t65 86.5 t84 65t84 54.5t65 54t26 64q0 38 -29.5 62.5t-70.5 24.5q-51 0 -97 -39q-14 -11 -36 -38l-105 92q26 37 63 66q83 65 188 65q110 0 178 -59.5t68 -158.5q0 -56 -24.5 -103t-62 -76.5t-81.5 -58.5t-82 -50.5t-65.5 -51.5t-30.5 -63h232v80h126v-206h-514l-3 27q-4 28 -4 46z " />
+<glyph unicode="&#xf12c;" d="M5 0v167h128l197 291l-185 272h-137v168h276l139 -228q2 -4 23 -42q8 -9 11 -21h3q3 9 11 21l25 42l140 228h257v-168h-125l-184 -267l204 -296h109v-167h-248l-159 252l-24 42q-8 9 -11 21h-3l-9 -21q-10 -20 -25 -44l-155 -250h-258zM1015 -183q0 64 26 117t65 86.5 t84 65t84 54.5t65 54t26 64q0 38 -29.5 62.5t-70.5 24.5q-51 0 -97 -39q-14 -11 -36 -38l-105 92q26 37 63 66q80 65 188 65q110 0 178 -59.5t68 -158.5q0 -66 -34.5 -118.5t-84 -86t-99.5 -62.5t-87 -63t-41 -73h232v80h126v-206h-514l-4 27q-3 45 -3 46z" />
+<glyph unicode="&#xf12d;" horiz-adv-x="1920" d="M1.5 146.5q5.5 37.5 30.5 65.5l896 1024q38 44 96 44h768q38 0 69.5 -20.5t47.5 -54.5q15 -34 9.5 -71.5t-30.5 -65.5l-896 -1024q-38 -44 -96 -44h-768q-38 0 -69.5 20.5t-47.5 54.5q-15 34 -9.5 71.5zM128 128h768l336 384h-768z" />
+<glyph unicode="&#xf12e;" horiz-adv-x="1664" d="M0 0v1024q2 -1 17.5 -3.5t34 -5t21.5 -3.5q150 -24 245 -24q80 0 117 35q46 44 46 89q0 22 -15 50.5t-33.5 53t-33.5 64.5t-15 83q0 82 59 127.5t144 45.5q80 0 134 -44.5t54 -123.5q0 -41 -17.5 -77.5t-38 -59t-38 -56.5t-17.5 -71q0 -57 42 -83.5t103 -26.5 q64 0 180 15t163 17v-2q-1 -2 -3.5 -17.5t-5 -34t-3.5 -21.5q-24 -150 -24 -245q0 -80 35 -117q44 -46 89 -46q22 0 50.5 15t53 33.5t64.5 33.5t83 15q82 0 127.5 -59t45.5 -143q0 -81 -44.5 -135t-123.5 -54q-41 0 -77.5 17.5t-59 38t-56.5 38t-71 17.5q-110 0 -110 -124 q0 -39 16 -115t15 -115v-5q-22 0 -33 -1q-34 -3 -97.5 -11.5t-115.5 -13.5t-98 -5q-61 0 -103 26.5t-42 83.5q0 37 17.5 71t38 56.5t38 59t17.5 77.5q0 79 -54 123.5t-135 44.5q-84 0 -143 -45.5t-59 -127.5q0 -43 15 -83t33.5 -64.5t33.5 -53t15 -50.5q0 -45 -46 -89 q-37 -35 -117 -35q-95 0 -245 24q-9 2 -27.5 4t-27.5 4l-13 2q-1 0 -3 1q-2 0 -2 1z" />
+<glyph unicode="&#xf130;" horiz-adv-x="1152" d="M0 704v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -185 131.5 -316.5t316.5 -131.5t316.5 131.5t131.5 316.5v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -221 -147.5 -384.5t-364.5 -187.5v-132h256q26 0 45 -19t19 -45t-19 -45t-45 -19h-640q-26 0 -45 19t-19 45 t19 45t45 19h256v132q-217 24 -364.5 187.5t-147.5 384.5zM256 704v512q0 132 94 226t226 94t226 -94t94 -226v-512q0 -132 -94 -226t-226 -94t-226 94t-94 226z" />
+<glyph unicode="&#xf131;" horiz-adv-x="1408" d="M13 64q0 13 10 23l1234 1234q10 10 23 10t23 -10l82 -82q10 -10 10 -23t-10 -23l-361 -361v-128q0 -132 -94 -226t-226 -94q-55 0 -109 19l-96 -96q97 -51 205 -51q185 0 316.5 131.5t131.5 316.5v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -221 -147.5 -384.5 t-364.5 -187.5v-132h256q26 0 45 -19t19 -45t-19 -45t-45 -19h-640q-26 0 -45 19t-19 45t19 45t45 19h256v132q-125 13 -235 81l-254 -254q-10 -10 -23 -10t-23 10l-82 82q-10 10 -10 23zM128 704v128q0 26 19 45t45 19t45 -19t19 -45v-128q0 -53 15 -113l-101 -101 q-42 103 -42 214zM384 704v512q0 132 94 226t226 94q102 0 184.5 -59t116.5 -152z" />
+<glyph unicode="&#xf132;" horiz-adv-x="1280" d="M0 576v768q0 26 19 45t45 19h1152q26 0 45 -19t19 -45v-768q0 -86 -33.5 -170.5t-83 -150t-118 -127.5t-126.5 -103t-121 -77.5t-89.5 -49.5t-42.5 -20q-12 -6 -26 -6t-26 6q-16 7 -42.5 20t-89.5 49.5t-121 77.5t-126.5 103t-118 127.5t-83 150t-33.5 170.5zM640 79 q119 63 213 137q235 184 235 360v640h-448v-1137z" />
+<glyph unicode="&#xf133;" horiz-adv-x="1664" d="M0 -128v1280q0 52 38 90t90 38h128v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h384v96q0 66 47 113t113 47h64q66 0 113 -47t47 -113v-96h128q52 0 90 -38t38 -90v-1280q0 -52 -38 -90t-90 -38h-1408q-52 0 -90 38t-38 90zM128 -128h1408v1024h-1408v-1024z M384 1088q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v288q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-288zM1152 1088q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v288q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-288z" />
+<glyph unicode="&#xf134;" horiz-adv-x="1408" d="M3.5 940q-8.5 25 3.5 49q5 10 14.5 26t37.5 53.5t60.5 70t85 67t108.5 52.5q-25 42 -25 86q0 66 47 113t113 47t113 -47t47 -113q0 -33 -14 -64h302q0 11 7 20t18 11l448 96q3 1 7 1q12 0 20 -7q12 -9 12 -25v-320q0 -16 -12 -25q-8 -7 -20 -7q-4 0 -7 1l-448 96 q-11 2 -18 11t-7 20h-256v-102q111 -23 183.5 -111t72.5 -203v-800q0 -26 -19 -45t-45 -19h-512q-26 0 -45 19t-19 45v800q0 106 62.5 190.5t161.5 114.5v111h-32q-59 0 -115 -23.5t-91.5 -53t-66 -66.5t-40.5 -53.5t-14 -24.5q-17 -35 -57 -35q-16 0 -29 7q-23 12 -31.5 37 zM384 1344q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf135;" horiz-adv-x="1664" d="M36 464l224 384q10 14 26 16l379 20q96 114 176 195q188 187 358 258t431 71q14 0 24 -9.5t10 -22.5q0 -249 -75.5 -430.5t-253.5 -360.5q-81 -80 -195 -176l-20 -379q-2 -16 -16 -26l-384 -224q-7 -4 -16 -4q-12 0 -23 9l-64 64q-13 14 -8 32l85 276l-281 281l-276 -85 q-3 -1 -9 -1q-14 0 -23 9l-64 64q-17 19 -5 39zM1248 1088q0 -40 28 -68t68 -28t68 28t28 68t-28 68t-68 28t-68 -28t-28 -68z" />
+<glyph unicode="&#xf136;" horiz-adv-x="1792" d="M0 0l204 953l-153 327h1276q101 0 189.5 -40.5t147.5 -113.5q60 -73 81 -168.5t0 -194.5l-164 -763h-334l178 832q13 56 -15 88q-27 33 -83 33h-169l-204 -953h-334l204 953h-286l-204 -953h-334z" />
+<glyph unicode="&#xf137;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM346 640q0 -26 19 -45l454 -454q19 -19 45 -19t45 19l102 102q19 19 19 45t-19 45l-307 307l307 307 q19 19 19 45t-19 45l-102 102q-19 19 -45 19t-45 -19l-454 -454q-19 -19 -19 -45z" />
+<glyph unicode="&#xf138;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM506 288q0 -26 19 -45l102 -102q19 -19 45 -19t45 19l454 454q19 19 19 45t-19 45l-454 454 q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45t19 -45l307 -307l-307 -307q-19 -19 -19 -45z" />
+<glyph unicode="&#xf139;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM250 544q0 -26 19 -45l102 -102q19 -19 45 -19t45 19l307 307l307 -307q19 -19 45 -19t45 19l102 102 q19 19 19 45t-19 45l-454 454q-19 19 -45 19t-45 -19l-454 -454q-19 -19 -19 -45z" />
+<glyph unicode="&#xf13a;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM250 736q0 -26 19 -45l454 -454q19 -19 45 -19t45 19l454 454q19 19 19 45t-19 45l-102 102 q-19 19 -45 19t-45 -19l-307 -307l-307 307q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45z" />
+<glyph unicode="&#xf13b;" horiz-adv-x="1408" d="M0 1408h1408l-128 -1438l-578 -162l-574 162zM262 1114l47 -534h612l-22 -228l-197 -53l-196 53l-13 140h-175l22 -278l362 -100h4v1l359 99l50 544h-644l-15 181h674l16 175h-884z" />
+<glyph unicode="&#xf13c;" horiz-adv-x="1792" d="M12 75l71 356h297l-29 -147l422 -161l486 161l68 339h-1208l58 297h1209l38 191h-1208l59 297h1505l-266 -1333l-804 -267z" />
+<glyph unicode="&#xf13d;" horiz-adv-x="1792" d="M0 0v352q0 14 9 23t23 9h352q22 0 30 -20q8 -19 -7 -35l-100 -100q67 -91 189.5 -153.5t271.5 -82.5v647h-192q-26 0 -45 19t-19 45v128q0 26 19 45t45 19h192v163q-58 34 -93 92.5t-35 128.5q0 106 75 181t181 75t181 -75t75 -181q0 -70 -35 -128.5t-93 -92.5v-163h192 q26 0 45 -19t19 -45v-128q0 -26 -19 -45t-45 -19h-192v-647q149 20 271.5 82.5t189.5 153.5l-100 100q-15 16 -7 35q8 20 30 20h352q14 0 23 -9t9 -23v-352q0 -22 -20 -30q-8 -2 -12 -2q-13 0 -23 9l-93 93q-119 -143 -318.5 -226.5t-429.5 -83.5t-429.5 83.5t-318.5 226.5 l-93 -93q-9 -9 -23 -9q-4 0 -12 2q-20 8 -20 30zM832 1280q0 -26 19 -45t45 -19t45 19t19 45t-19 45t-45 19t-45 -19t-19 -45z" />
+<glyph unicode="&#xf13e;" horiz-adv-x="1152" d="M0 96v576q0 40 28 68t68 28h32v320q0 185 131.5 316.5t316.5 131.5t316.5 -131.5t131.5 -316.5q0 -26 -19 -45t-45 -19h-64q-26 0 -45 19t-19 45q0 106 -75 181t-181 75t-181 -75t-75 -181v-320h736q40 0 68 -28t28 -68v-576q0 -40 -28 -68t-68 -28h-960q-40 0 -68 28 t-28 68z" />
+<glyph unicode="&#xf140;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5 t-51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5zM256 640q0 212 150 362t362 150t362 -150t150 -362t-150 -362t-362 -150t-362 150t-150 362zM384 640q0 -159 112.5 -271.5t271.5 -112.5t271.5 112.5t112.5 271.5t-112.5 271.5 t-271.5 112.5t-271.5 -112.5t-112.5 -271.5zM512 640q0 106 75 181t181 75t181 -75t75 -181t-75 -181t-181 -75t-181 75t-75 181z" />
+<glyph unicode="&#xf141;" horiz-adv-x="1408" d="M0 608v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68zM512 608v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68zM1024 608v192q0 40 28 68t68 28h192 q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf142;" horiz-adv-x="384" d="M0 96v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68zM0 608v192q0 40 28 68t68 28h192q40 0 68 -28t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68zM0 1120v192q0 40 28 68t68 28h192q40 0 68 -28 t28 -68v-192q0 -40 -28 -68t-68 -28h-192q-40 0 -68 28t-28 68z" />
+<glyph unicode="&#xf143;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 256q0 -53 37.5 -90.5t90.5 -37.5t90.5 37.5t37.5 90.5t-37.5 90.5t-90.5 37.5t-90.5 -37.5t-37.5 -90.5z M256 575q0 -13 8.5 -22t21.5 -10q154 -11 264 -121t121 -264q1 -13 10 -21.5t22 -8.5h128q13 0 23 10t9 24q-13 232 -177 396t-396 177q-14 1 -24 -9t-10 -23v-128zM256 959q0 -13 9 -22t22 -10q204 -7 378 -111.5t278.5 -278.5t111.5 -378q1 -13 10 -22t22 -9h128 q13 0 23 10q11 9 9 23q-5 154 -56 297.5t-139.5 260t-205 205t-260 139.5t-297.5 56q-14 1 -23 -9q-10 -10 -10 -23v-128z" />
+<glyph unicode="&#xf144;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM512 320q0 -37 32 -56q16 -8 32 -8q17 0 32 9l544 320q32 18 32 55t-32 55l-544 320q-31 19 -64 1 q-32 -19 -32 -56v-640z" />
+<glyph unicode="&#xf145;" horiz-adv-x="1792" d="M54 448.5q0 53.5 37 90.5l907 906q37 37 90.5 37t90.5 -37l125 -125q-56 -56 -56 -136t56 -136t136 -56t136 56l126 -125q37 -37 37 -90.5t-37 -90.5l-907 -908q-37 -37 -90.5 -37t-90.5 37l-126 126q56 56 56 136t-56 136t-136 56t-136 -56l-125 126q-37 37 -37 90.5z M342 512q0 -26 19 -45l362 -362q18 -18 45 -18t45 18l618 618q19 19 19 45t-19 45l-362 362q-18 18 -45 18t-45 -18l-618 -618q-19 -19 -19 -45zM452 512l572 572l316 -316l-572 -572z" />
+<glyph unicode="&#xf146;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 576q0 -26 19 -45t45 -19h896q26 0 45 19t19 45v128q0 26 -19 45t-45 19h-896q-26 0 -45 -19t-19 -45v-128 z" />
+<glyph unicode="&#xf147;" horiz-adv-x="1408" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h832q119 0 203.5 -84.5t84.5 -203.5v-832q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM128 288q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v832q0 66 -47 113t-113 47h-832q-66 0 -113 -47 t-47 -113v-832zM256 672v64q0 14 9 23t23 9h832q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf148;" horiz-adv-x="1024" d="M3 18q-8 20 4 35l160 192q9 11 25 11h320v640h-192q-40 0 -58 37q-17 37 9 68l320 384q18 22 49 22t49 -22l320 -384q27 -32 9 -68q-18 -37 -58 -37h-192v-864q0 -14 -9 -23t-23 -9h-704q-21 0 -29 18z" />
+<glyph unicode="&#xf149;" horiz-adv-x="1024" d="M3 1261q9 19 29 19h704q13 0 22.5 -9.5t9.5 -23.5v-863h192q40 0 58 -37t-9 -69l-320 -384q-18 -22 -49 -22t-49 22l-320 384q-26 31 -9 69q18 37 58 37h192v640h-320q-14 0 -25 11l-160 192q-13 14 -4 34z" />
+<glyph unicode="&#xf14a;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM218 640q0 -26 19 -45l358 -358q19 -19 45 -19t45 19l614 614q19 19 19 45t-19 45l-102 102q-19 19 -45 19 t-45 -19l-467 -467l-211 211q-19 19 -45 19t-45 -19l-102 -102q-19 -19 -19 -45z" />
+<glyph unicode="&#xf14b;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 128h288l544 544l-288 288l-544 -544v-288zM352 320v56l52 52l152 -152l-52 -52h-56v96h-96zM494 494 q-14 13 3 30l291 291q17 17 30 3q14 -13 -3 -30l-291 -291q-17 -17 -30 -3zM864 1024l288 -288l92 92q28 28 28 68t-28 68l-152 152q-28 28 -68 28t-68 -28z" />
+<glyph unicode="&#xf14c;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM282 320q0 -26 19 -45l102 -102q19 -19 45 -19t45 19l534 534l144 -144q18 -19 45 -19q12 0 25 5q39 17 39 59 v480q0 26 -19 45t-45 19h-480q-42 0 -59 -39q-17 -41 14 -70l144 -144l-534 -534q-19 -19 -19 -45z" />
+<glyph unicode="&#xf14d;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 448q0 -181 167 -404q10 -12 25 -12q7 0 13 3q22 9 19 33q-44 354 62 473q46 52 130 75.5t224 23.5v-160 q0 -42 40 -59q12 -5 24 -5q26 0 45 19l352 352q19 19 19 45t-19 45l-352 352q-30 31 -69 14q-40 -17 -40 -59v-160q-119 0 -216 -19.5t-162.5 -51t-114 -79t-76.5 -95.5t-44.5 -109t-21.5 -111.5t-5 -110.5z" />
+<glyph unicode="&#xf14e;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM512 241v542l512 256v-542zM640 448l256 128l-256 128v-256z" />
+<glyph unicode="&#xf150;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 160q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5v960q0 13 -9.5 22.5t-22.5 9.5h-960 q-13 0 -22.5 -9.5t-9.5 -22.5v-960zM391 861q17 35 57 35h640q40 0 57 -35q18 -35 -5 -66l-320 -448q-19 -27 -52 -27t-52 27l-320 448q-23 31 -5 66z" />
+<glyph unicode="&#xf151;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 160q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5v960q0 13 -9.5 22.5t-22.5 9.5h-960 q-13 0 -22.5 -9.5t-9.5 -22.5v-960zM391 419q-18 35 5 66l320 448q19 27 52 27t52 -27l320 -448q23 -31 5 -66q-17 -35 -57 -35h-640q-40 0 -57 35z" />
+<glyph unicode="&#xf152;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 160q0 -14 9 -23t23 -9h960q14 0 23 9t9 23v960q0 14 -9 23t-23 9h-960q-14 0 -23 -9t-9 -23v-960z M512 320v640q0 40 35 57q35 18 66 -5l448 -320q27 -19 27 -52t-27 -52l-448 -320q-31 -23 -66 -5q-35 17 -35 57z" />
+<glyph unicode="&#xf153;" horiz-adv-x="1024" d="M0 514v113q0 13 9.5 22.5t22.5 9.5h66q-2 57 1 105h-67q-14 0 -23 9t-9 23v114q0 14 9 23t23 9h98q67 210 243.5 338t400.5 128q102 0 194 -23q11 -3 20 -15q6 -11 3 -24l-43 -159q-3 -13 -14 -19.5t-24 -2.5l-4 1q-4 1 -11.5 2.5l-17.5 3.5t-22.5 3.5t-26 3t-29 2.5 t-29.5 1q-126 0 -226 -64t-150 -176h468q16 0 25 -12q10 -12 7 -26l-24 -114q-5 -26 -32 -26h-488q-3 -37 0 -105h459q15 0 25 -12q9 -12 6 -27l-24 -112q-2 -11 -11 -18.5t-20 -7.5h-387q48 -117 149.5 -185.5t228.5 -68.5q18 0 36 1.5t33.5 3.5t29.5 4.5t24.5 5t18.5 4.5 l12 3l5 2q13 5 26 -2q12 -7 15 -21l35 -159q3 -12 -3 -22.5t-17 -14.5l-5 -1q-4 -2 -10.5 -3.5t-16 -4.5t-21.5 -5.5t-25.5 -5t-30 -5t-33.5 -4.5t-36.5 -3t-38.5 -1q-234 0 -409 130.5t-238 351.5h-95q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf154;" horiz-adv-x="1024" d="M0 32v150q0 13 9.5 22.5t22.5 9.5h97v383h-95q-14 0 -23 9.5t-9 22.5v131q0 14 9 23t23 9h95v223q0 171 123.5 282t314.5 111q185 0 335 -125q9 -8 10 -20.5t-7 -22.5l-103 -127q-9 -11 -22 -12q-13 -2 -23 7q-5 5 -26 19t-69 32t-93 18q-85 0 -137 -47t-52 -123v-215 h305q13 0 22.5 -9t9.5 -23v-131q0 -13 -9.5 -22.5t-22.5 -9.5h-305v-379h414v181q0 13 9 22.5t23 9.5h162q14 0 23 -9.5t9 -22.5v-367q0 -14 -9 -23t-23 -9h-956q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf155;" horiz-adv-x="1024" d="M52 171l103 135q7 10 23 12q15 2 24 -9l2 -2q113 -99 243 -125q37 -8 74 -8q81 0 142.5 43t61.5 122q0 28 -15 53t-33.5 42t-58.5 37.5t-66 32t-80 32.5q-39 16 -61.5 25t-61.5 26.5t-62.5 31t-56.5 35.5t-53.5 42.5t-43.5 49t-35.5 58t-21 66.5t-8.5 78q0 138 98 242 t255 134v180q0 13 9.5 22.5t22.5 9.5h135q14 0 23 -9t9 -23v-176q57 -6 110.5 -23t87 -33.5t63.5 -37.5t39 -29t15 -14q17 -18 5 -38l-81 -146q-8 -15 -23 -16q-14 -3 -27 7q-3 3 -14.5 12t-39 26.5t-58.5 32t-74.5 26t-85.5 11.5q-95 0 -155 -43t-60 -111q0 -26 8.5 -48 t29.5 -41.5t39.5 -33t56 -31t60.5 -27t70 -27.5q53 -20 81 -31.5t76 -35t75.5 -42.5t62 -50t53 -63.5t31.5 -76.5t13 -94q0 -153 -99.5 -263.5t-258.5 -136.5v-175q0 -14 -9 -23t-23 -9h-135q-13 0 -22.5 9.5t-9.5 22.5v175q-66 9 -127.5 31t-101.5 44.5t-74 48t-46.5 37.5 t-17.5 18q-17 21 -2 41z" />
+<glyph unicode="&#xf156;" horiz-adv-x="898" d="M0 605v127q0 13 9.5 22.5t22.5 9.5h112q132 0 212.5 43t102.5 125h-427q-14 0 -23 9t-9 23v102q0 14 9 23t23 9h413q-57 113 -268 113h-145q-13 0 -22.5 9.5t-9.5 22.5v133q0 14 9 23t23 9h832q14 0 23 -9t9 -23v-102q0 -14 -9 -23t-23 -9h-233q47 -61 64 -144h171 q14 0 23 -9t9 -23v-102q0 -14 -9 -23t-23 -9h-168q-23 -144 -129 -234t-276 -110q167 -178 459 -536q14 -16 4 -34q-8 -18 -29 -18h-195q-16 0 -25 12q-306 367 -498 571q-9 9 -9 22z" />
+<glyph unicode="&#xf157;" horiz-adv-x="1027" d="M4 1360q-8 16 0 32q10 16 28 16h194q19 0 29 -18l215 -425q19 -38 56 -125q10 24 30.5 68t27.5 61l191 420q8 19 29 19h191q17 0 27 -16q9 -14 1 -31l-313 -579h215q13 0 22.5 -9.5t9.5 -22.5v-104q0 -14 -9.5 -23t-22.5 -9h-290v-85h290q13 0 22.5 -9.5t9.5 -22.5v-103 q0 -14 -9.5 -23t-22.5 -9h-290v-330q0 -13 -9.5 -22.5t-22.5 -9.5h-172q-13 0 -22.5 9t-9.5 23v330h-288q-13 0 -22.5 9t-9.5 23v103q0 13 9.5 22.5t22.5 9.5h288v85h-288q-13 0 -22.5 9t-9.5 23v104q0 13 9.5 22.5t22.5 9.5h214z" />
+<glyph unicode="&#xf158;" horiz-adv-x="1280" d="M0 256v128q0 14 9 23t23 9h224v118h-224q-14 0 -23 9t-9 23v149q0 13 9 22.5t23 9.5h224v629q0 14 9 23t23 9h539q200 0 326.5 -122t126.5 -315t-126.5 -315t-326.5 -122h-340v-118h505q14 0 23 -9t9 -23v-128q0 -14 -9 -23t-23 -9h-505v-192q0 -14 -9.5 -23t-22.5 -9 h-167q-14 0 -23 9t-9 23v192h-224q-14 0 -23 9t-9 23zM487 747h320q106 0 171 62t65 162t-65 162t-171 62h-320v-448z" />
+<glyph unicode="&#xf159;" horiz-adv-x="1792" d="M0 672v64q0 14 9 23t23 9h175l-33 128h-142q-14 0 -23 9t-9 23v64q0 14 9 23t23 9h109l-89 344q-5 15 5 28q10 12 26 12h137q26 0 31 -24l90 -360h359l97 360q7 24 31 24h126q24 0 31 -24l98 -360h365l93 360q5 24 31 24h137q16 0 26 -12q10 -13 5 -28l-91 -344h111 q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-145l-34 -128h179q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-213l-164 -616q-7 -24 -31 -24h-159q-24 0 -31 24l-166 616h-209l-167 -616q-7 -24 -31 -24h-159q-11 0 -19.5 7t-10.5 17l-160 616h-208q-14 0 -23 9t-9 23z M373 896l32 -128h225l35 128h-292zM436 640l75 -300q1 -1 1 -3t1 -3q0 1 0.5 3.5t0.5 3.5l81 299h-159zM822 768h139l-35 128h-70zM1118 896l34 -128h230l33 128h-297zM1187 640l81 -299q0 -1 0.5 -3.5t1.5 -3.5q0 1 0.5 3t0.5 3l78 300h-162z" />
+<glyph unicode="&#xf15a;" horiz-adv-x="1280" d="M56 0l31 183h111q50 0 58 51v402h16q-6 1 -16 1v287q-13 68 -89 68h-111v164l212 -1q64 0 97 1v252h154v-247q82 2 122 2v245h154v-252q79 -7 140 -22.5t113 -45t82.5 -78t36.5 -114.5q18 -182 -131 -258q117 -28 175 -103t45 -214q-7 -71 -32.5 -125t-64.5 -89 t-97 -58.5t-121.5 -34.5t-145.5 -15v-255h-154v251q-80 0 -122 1v-252h-154v255q-18 0 -54 0.5t-55 0.5h-200zM522 182q8 0 37 -0.5t48 -0.5t53 1.5t58.5 4t57 8.5t55.5 14t47.5 21t39.5 30t24.5 40t9.5 51q0 36 -15 64t-37 46t-57.5 30.5t-65.5 18.5t-74 9t-69 3t-64.5 -1 t-47.5 -1v-338zM522 674q5 0 34.5 -0.5t46.5 0t50 2t55 5.5t51.5 11t48.5 18.5t37 27t27 38.5t9 51q0 33 -12.5 58.5t-30.5 42t-48 28t-55 16.5t-61.5 8t-58 2.5t-54 -1t-39.5 -0.5v-307z" />
+<glyph unicode="&#xf15b;" d="M0 -160v1600q0 40 28 68t68 28h800v-544q0 -40 28 -68t68 -28h544v-1056q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM1024 1024v472q22 -14 36 -28l408 -408q14 -14 28 -36h-472z" />
+<glyph unicode="&#xf15c;" d="M0 -160v1600q0 40 28 68t68 28h800v-544q0 -40 28 -68t68 -28h544v-1056q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM384 160q0 -14 9 -23t23 -9h704q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-704q-14 0 -23 -9t-9 -23v-64zM384 416q0 -14 9 -23t23 -9h704 q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-704q-14 0 -23 -9t-9 -23v-64zM384 672q0 -14 9 -23t23 -9h704q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-704q-14 0 -23 -9t-9 -23v-64zM1024 1024v472q22 -14 36 -28l408 -408q14 -14 28 -36h-472z" />
+<glyph unicode="&#xf15d;" horiz-adv-x="1664" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM899 768v106h70l230 662h162l230 -662h70v-106h-288v106h75l-47 144h-243l-47 -144h75v-106 h-287zM988 -166l369 529q12 18 21 27l11 9v3q-2 0 -6.5 -0.5t-7.5 -0.5q-12 -3 -30 -3h-232v-115h-120v229h567v-89l-369 -530q-6 -8 -21 -26l-11 -11v-2l14 2q9 2 30 2h248v119h121v-233h-584v90zM1191 1128h177l-72 218l-12 47q-2 16 -2 20h-4l-3 -20q0 -1 -3.5 -18 t-7.5 -29z" />
+<glyph unicode="&#xf15e;" horiz-adv-x="1664" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM899 -150h70l230 662h162l230 -662h70v-106h-288v106h75l-47 144h-243l-47 -144h75v-106h-287 v106zM988 768v90l369 529q12 18 21 27l11 9v3q-2 0 -6.5 -0.5t-7.5 -0.5q-12 -3 -30 -3h-232v-115h-120v229h567v-89l-369 -530q-6 -8 -21 -26l-11 -10v-3l14 3q9 1 30 1h248v119h121v-233h-584zM1191 104h177l-72 218l-12 47q-2 16 -2 20h-4l-3 -20q0 -1 -3.5 -18t-7.5 -29 z" />
+<glyph unicode="&#xf160;" horiz-adv-x="1792" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM896 -32q0 14 9 23t23 9h832q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9 t-9 23v192zM896 288v192q0 14 9 23t23 9h640q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-640q-14 0 -23 9t-9 23zM896 800v192q0 14 9 23t23 9h448q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-448q-14 0 -23 9t-9 23zM896 1312v192q0 14 9 23t23 9h256q14 0 23 -9t9 -23 v-192q0 -14 -9 -23t-23 -9h-256q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf161;" horiz-adv-x="1792" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM896 -32q0 14 9 23t23 9h256q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-256q-14 0 -23 9 t-9 23v192zM896 288v192q0 14 9 23t23 9h448q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-448q-14 0 -23 9t-9 23zM896 800v192q0 14 9 23t23 9h640q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-640q-14 0 -23 9t-9 23zM896 1312v192q0 14 9 23t23 9h832q14 0 23 -9t9 -23 v-192q0 -14 -9 -23t-23 -9h-832q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf162;" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM946 261q0 105 72 178t181 73q123 0 205 -94.5t82 -252.5q0 -62 -13 -121.5t-41 -114 t-68 -95.5t-98.5 -65.5t-127.5 -24.5q-62 0 -108 16q-24 8 -42 15l39 113q15 -7 31 -11q37 -13 75 -13q84 0 134.5 58.5t66.5 145.5h-2q-21 -23 -61.5 -37t-84.5 -14q-106 0 -173 71.5t-67 172.5zM976 1351l192 185h123v-654h165v-114h-469v114h167v432q0 7 0.5 19t0.5 17 v16h-2l-7 -12q-8 -13 -26 -31l-62 -58zM1085 261q0 -57 36.5 -95t104.5 -38q50 0 85 27t35 68q0 63 -44 116t-103 53q-52 0 -83 -37t-31 -94z" />
+<glyph unicode="&#xf163;" d="M34 108q8 20 30 20h192v1376q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1376h192q14 0 23 -9t9 -23q0 -12 -10 -24l-319 -319q-10 -9 -23 -9q-12 0 -23 9l-320 320q-15 16 -7 35zM946 1285q0 105 72 178t181 73q123 0 205 -94.5t82 -252.5q0 -62 -13 -121.5t-41 -114 t-68 -95.5t-98.5 -65.5t-127.5 -24.5q-62 0 -108 16q-24 8 -42 15l39 113q15 -7 31 -11q37 -13 75 -13q84 0 134.5 58.5t66.5 145.5h-2q-21 -23 -61.5 -37t-84.5 -14q-106 0 -173 71.5t-67 172.5zM976 327l192 185h123v-654h165v-114h-469v114h167v432q0 7 0.5 19t0.5 17v16 h-2l-7 -12q-8 -13 -26 -31l-62 -58zM1085 1285q0 -57 36.5 -95t104.5 -38q50 0 85 27t35 68q0 63 -44 116t-103 53q-52 0 -83 -37t-31 -94z" />
+<glyph unicode="&#xf164;" horiz-adv-x="1664" d="M0 64v640q0 26 19 45t45 19h288q26 0 45 -19t19 -45v-640q0 -26 -19 -45t-45 -19h-288q-26 0 -45 19t-19 45zM128 192q0 -27 18.5 -45.5t45.5 -18.5q26 0 45 18.5t19 45.5q0 26 -19 45t-45 19q-27 0 -45.5 -19t-18.5 -45zM480 64v641q0 25 18 43.5t43 20.5q24 2 76 59 t101 121q68 87 101 120q18 18 31 48t17.5 48.5t13.5 60.5q7 39 12.5 61t19.5 52t34 50q19 19 45 19q46 0 82.5 -10.5t60 -26t40 -40.5t24 -45t12 -50t5 -45t0.5 -39q0 -38 -9.5 -76t-19 -60t-27.5 -56q-3 -6 -10 -18t-11 -22t-8 -24h277q78 0 135 -57t57 -135 q0 -86 -55 -149q15 -44 15 -76q3 -76 -43 -137q17 -56 0 -117q-15 -57 -54 -94q9 -112 -49 -181q-64 -76 -197 -78h-36h-76h-17q-66 0 -144 15.5t-121.5 29t-120.5 39.5q-123 43 -158 44q-26 1 -45 19.5t-19 44.5z" />
+<glyph unicode="&#xf165;" horiz-adv-x="1664" d="M0 448q0 -26 19 -45t45 -19h288q26 0 45 19t19 45v640q0 26 -19 45t-45 19h-288q-26 0 -45 -19t-19 -45v-640zM128 960q0 27 18.5 45.5t45.5 18.5q26 0 45 -18.5t19 -45.5q0 -26 -19 -45t-45 -19q-27 0 -45.5 19t-18.5 45zM480 447v641q0 26 19 44.5t45 19.5q35 1 158 44 q77 26 120.5 39.5t121.5 29t144 15.5h17h76h36q133 -2 197 -78q58 -69 49 -181q39 -37 54 -94q17 -61 0 -117q46 -61 43 -137q0 -32 -15 -76q55 -61 55 -149q-1 -78 -57.5 -135t-134.5 -57h-277q4 -14 8 -24t11 -22t10 -18q18 -37 27 -57t19 -58.5t10 -76.5q0 -24 -0.5 -39 t-5 -45t-12 -50t-24 -45t-40 -40.5t-60 -26t-82.5 -10.5q-26 0 -45 19q-20 20 -34 50t-19.5 52t-12.5 61q-9 42 -13.5 60.5t-17.5 48.5t-31 48q-33 33 -101 120q-49 64 -101 121t-76 59q-25 2 -43 20.5t-18 43.5z" />
+<glyph unicode="&#xf166;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM218 366q0 -176 20 -260q10 -43 42.5 -73t75.5 -35q137 -15 412 -15t412 15q43 5 75.5 35t42.5 73 q20 84 20 260q0 177 -19 260q-10 44 -43 73.5t-76 34.5q-136 15 -412 15q-275 0 -411 -15q-44 -5 -76.5 -34.5t-42.5 -73.5q-20 -87 -20 -260zM300 551v70h232v-70h-80v-423h-74v423h-78zM396 1313l24 -69t23 -69q35 -103 46 -158v-201h74v201l90 296h-75l-51 -195l-53 195 h-78zM542 205v290h66v-270q0 -24 1 -26q1 -15 15 -15q20 0 42 31v280h67v-367h-67v40q-39 -45 -76 -45q-33 0 -42 28q-6 16 -6 54zM654 936q0 -58 21 -87q27 -38 78 -38q49 0 78 38q21 27 21 87v130q0 58 -21 87q-29 38 -78 38q-51 0 -78 -38q-21 -29 -21 -87v-130zM721 923 v156q0 52 32 52t32 -52v-156q0 -51 -32 -51t-32 51zM790 128v493h67v-161q32 40 68 40q41 0 53 -42q7 -21 7 -74v-146q0 -52 -7 -73q-12 -42 -53 -42q-35 0 -68 41v-36h-67zM857 200q16 -16 33 -16q29 0 29 49v157q0 50 -29 50q-17 0 -33 -16v-224zM907 893q0 -37 6 -55 q11 -27 43 -27q36 0 77 45v-40h67v370h-67v-283q-22 -31 -42 -31q-15 0 -16 16q-1 2 -1 26v272h-67v-293zM1037 247v129q0 59 20 86q29 38 80 38t78 -38q21 -28 21 -86v-76h-133v-65q0 -51 34 -51q24 0 30 26q0 1 0.5 7t0.5 16.5v21.5h68v-9q0 -29 -2 -43q-3 -22 -15 -40 q-27 -40 -80 -40q-52 0 -81 38q-21 27 -21 86zM1103 355h66v34q0 51 -33 51t-33 -51v-34z" />
+<glyph unicode="&#xf167;" d="M27 260q0 234 26 350q14 59 58 99t103 47q183 20 554 20t555 -20q58 -7 102.5 -47t57.5 -99q26 -112 26 -350q0 -234 -26 -350q-14 -59 -58 -99t-102 -46q-184 -21 -555 -21t-555 21q-58 6 -102.5 46t-57.5 99q-26 112 -26 350zM138 509h105v-569h100v569h107v94h-312 v-94zM266 1536h106l71 -263l68 263h102l-121 -399v-271h-100v271q-14 74 -61 212q-37 103 -65 187zM463 43q0 -49 8 -73q12 -37 58 -37q48 0 102 61v-54h89v494h-89v-378q-30 -42 -57 -42q-18 0 -21 21q-1 3 -1 35v364h-89v-391zM614 1028v175q0 80 28 117q38 51 105 51 q69 0 106 -51q28 -37 28 -117v-175q0 -81 -28 -118q-37 -51 -106 -51q-67 0 -105 51q-28 38 -28 118zM704 1011q0 -70 43 -70t43 70v210q0 69 -43 69t-43 -69v-210zM798 -60h89v48q45 -55 93 -55q54 0 71 55q9 27 9 100v197q0 73 -9 99q-17 56 -71 56q-50 0 -93 -54v217h-89 v-663zM887 36v301q22 22 45 22q39 0 39 -67v-211q0 -67 -39 -67q-23 0 -45 22zM955 971v394h91v-367q0 -33 1 -35q3 -22 21 -22q27 0 57 43v381h91v-499h-91v55q-53 -62 -103 -62q-46 0 -59 37q-8 24 -8 75zM1130 100q0 -79 29 -116q39 -51 108 -51q72 0 108 53q18 27 21 54 q2 9 2 58v13h-91q0 -51 -2 -61q-7 -36 -40 -36q-46 0 -46 69v87h179v103q0 79 -27 116q-39 51 -106 51q-68 0 -107 -51q-28 -37 -28 -116v-173zM1219 245v46q0 68 45 68t45 -68v-46h-90z" />
+<glyph unicode="&#xf168;" horiz-adv-x="1408" d="M5 384q-10 17 0 36l253 448q1 0 0 1l-161 279q-12 22 -1 37q9 15 32 15h239q40 0 66 -45l164 -286q-10 -18 -257 -456q-27 -46 -65 -46h-239q-21 0 -31 17zM536 539q18 32 531 942q25 45 64 45h241q22 0 31 -15q11 -16 0 -37l-528 -934v-1l336 -615q11 -20 1 -37 q-10 -15 -32 -15h-239q-42 0 -66 45z" />
+<glyph unicode="&#xf169;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM227 396q8 -13 24 -13h185q31 0 50 36l199 352q0 1 -126 222q-21 34 -52 34h-184q-18 0 -26 -11q-7 -12 1 -29 l125 -216v-1l-196 -346q-9 -14 0 -28zM638 516q1 -2 262 -481q20 -35 52 -35h184q18 0 25 12q8 13 -1 28l-260 476v1l409 723q8 16 0 28q-7 12 -24 12h-187q-30 0 -49 -35z" />
+<glyph unicode="&#xf16a;" horiz-adv-x="1792" d="M0 640q0 96 1 150t8.5 136.5t22.5 147.5q16 73 69 123t124 58q222 25 671 25t671 -25q71 -8 124.5 -58t69.5 -123q14 -65 21.5 -147.5t8.5 -136.5t1 -150t-1 -150t-8.5 -136.5t-22.5 -147.5q-16 -73 -69 -123t-124 -58q-222 -25 -671 -25t-671 25q-71 8 -124.5 58 t-69.5 123q-14 65 -21.5 147.5t-8.5 136.5t-1 150zM640 320q0 -38 33 -56q16 -8 31 -8q20 0 34 10l512 320q30 17 30 54t-30 54l-512 320q-31 20 -65 2q-33 -18 -33 -56v-640z" />
+<glyph unicode="&#xf16b;" horiz-adv-x="1792" d="M64 558l338 271l494 -305l-342 -285zM64 1099l490 319l342 -285l-494 -304zM407 166v108l147 -96l342 284v2l1 -1l1 1v-2l343 -284l147 96v-108l-490 -293v-1l-1 1l-1 -1v1zM896 524l494 305l338 -271l-489 -319zM896 1133l343 285l489 -319l-338 -270z" />
+<glyph unicode="&#xf16c;" horiz-adv-x="1408" d="M0 -255v736h121v-618h928v618h120v-701l-1 -35v-1h-1132l-35 1h-1zM221 -17v151l707 1v-151zM227 243l14 150l704 -65l-13 -150zM270 563l39 146l683 -183l-39 -146zM395 928l77 130l609 -360l-77 -130zM707 1303l125 86l398 -585l-124 -85zM1136 1510l149 26l121 -697 l-149 -26z" />
+<glyph unicode="&#xf16d;" d="M0 69v1142q0 81 58 139t139 58h1142q81 0 139 -58t58 -139v-1142q0 -81 -58 -139t-139 -58h-1142q-81 0 -139 58t-58 139zM171 110q0 -26 17.5 -43.5t43.5 -17.5h1069q25 0 43 17.5t18 43.5v648h-135q20 -63 20 -131q0 -126 -64 -232.5t-174 -168.5t-240 -62 q-197 0 -337 135.5t-140 327.5q0 68 20 131h-141v-648zM461 643q0 -124 90.5 -211.5t217.5 -87.5q128 0 218.5 87.5t90.5 211.5t-90.5 211.5t-218.5 87.5q-127 0 -217.5 -87.5t-90.5 -211.5zM1050 1003q0 -29 20 -49t49 -20h174q29 0 49 20t20 49v165q0 28 -20 48.5 t-49 20.5h-174q-29 0 -49 -20.5t-20 -48.5v-165z" />
+<glyph unicode="&#xf16e;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM274 640q0 -88 62 -150t150 -62t150 62t62 150t-62 150t-150 62t-150 -62t-62 -150zM838 640q0 -88 62 -150 t150 -62t150 62t62 150t-62 150t-150 62t-150 -62t-62 -150z" />
+<glyph unicode="&#xf170;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM309 384h94l104 160h522l104 -160h94l-459 691zM567 608l201 306l201 -306h-402z" />
+<glyph unicode="&#xf171;" horiz-adv-x="1408" d="M0 1222q3 26 17.5 48.5t31.5 37.5t45 30t46 22.5t48 18.5q125 46 313 64q379 37 676 -50q155 -46 215 -122q16 -20 16.5 -51t-5.5 -54q-26 -167 -111 -655q-5 -30 -27 -56t-43.5 -40t-54.5 -31q-252 -126 -610 -88q-248 27 -394 139q-15 12 -25.5 26.5t-17 35t-9 34 t-6 39.5t-5.5 35q-9 50 -26.5 150t-28 161.5t-23.5 147.5t-22 158zM173 285l6 16l18 9q223 -148 506.5 -148t507.5 148q21 -6 24 -23t-5 -45t-8 -37q-8 -26 -15.5 -76.5t-14 -84t-28.5 -70t-58 -56.5q-86 -48 -189.5 -71.5t-202 -22t-201.5 18.5q-46 8 -81.5 18t-76.5 27 t-73 43.5t-52 61.5q-25 96 -57 292zM243 1240q30 -28 76 -45.5t73.5 -22t87.5 -11.5q228 -29 448 -1q63 8 89.5 12t72.5 21.5t75 46.5q-20 27 -56 44.5t-58 22t-71 12.5q-291 47 -566 -2q-43 -7 -66 -12t-55 -22t-50 -43zM481 657q4 -91 77.5 -155t165.5 -56q91 8 152 84 t50 168q-14 107 -113 164t-197 13q-63 -28 -100.5 -88.5t-34.5 -129.5zM599 710q14 41 52 58q36 18 72.5 12t64 -35.5t27.5 -67.5q8 -63 -50.5 -101t-111.5 -6q-39 17 -53.5 58t-0.5 82z" />
+<glyph unicode="&#xf172;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM260 1060q8 -68 19 -138t29 -171t24 -137q1 -5 5 -31t7 -36t12 -27t22 -28q105 -80 284 -100q259 -28 440 63 q24 13 39.5 23t31 29t19.5 40q48 267 80 473q9 53 -8 75q-43 55 -155 88q-216 63 -487 36q-132 -12 -226 -46q-38 -15 -59.5 -25t-47 -34t-29.5 -54zM385 384q26 -154 41 -210q47 -81 204 -108q249 -46 428 53q34 19 49 51.5t22.5 85.5t12.5 71q0 7 5.5 26.5t3 32 t-17.5 16.5q-161 -106 -365 -106t-366 106l-12 -6zM436 1073q13 19 36 31t40 15.5t47 8.5q198 35 408 1q33 -5 51 -8.5t43 -16t39 -31.5q-20 -21 -53.5 -34t-53 -16t-63.5 -8q-155 -20 -324 0q-44 6 -63 9.5t-52.5 16t-54.5 32.5zM607 653q-2 49 25.5 93t72.5 64 q70 31 141.5 -10t81.5 -118q8 -66 -36 -121t-110 -61t-119 40t-56 113zM687.5 660.5q0.5 -52.5 43.5 -70.5q39 -23 81 4t36 72q0 43 -41 66t-77 1q-43 -20 -42.5 -72.5z" />
+<glyph unicode="&#xf173;" horiz-adv-x="1024" d="M78 779v217q91 30 155 84q64 55 103 132q39 78 54 196h219v-388h364v-241h-364v-394q0 -136 14 -172q13 -37 52 -60q50 -31 117 -31q117 0 232 76v-242q-102 -48 -178 -65q-77 -19 -173 -19q-105 0 -186 27q-78 25 -138 75q-58 51 -79 105q-22 54 -22 161v539h-170z" />
+<glyph unicode="&#xf174;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM413 744h127v-404q0 -78 17 -121q17 -42 59 -78q43 -37 104 -57q62 -20 140 -20q67 0 129 14q57 13 134 49v181 q-88 -56 -174 -56q-51 0 -88 23q-29 17 -39 45q-11 30 -11 129v295h274v181h-274v291h-164q-11 -90 -40 -147t-78 -99q-48 -40 -116 -63v-163z" />
+<glyph unicode="&#xf175;" horiz-adv-x="768" d="M3 237q9 19 29 19h224v1248q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-1248h224q21 0 29 -19t-5 -35l-350 -384q-10 -10 -23 -10q-14 0 -24 10l-355 384q-13 16 -5 35z" />
+<glyph unicode="&#xf176;" horiz-adv-x="768" d="M3 1043q-8 19 5 35l350 384q10 10 23 10q14 0 24 -10l355 -384q13 -16 5 -35q-9 -19 -29 -19h-224v-1248q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v1248h-224q-21 0 -29 19z" />
+<glyph unicode="&#xf177;" horiz-adv-x="1792" d="M64 637q0 14 10 24l384 354q16 14 35 6q19 -9 19 -29v-224h1248q14 0 23 -9t9 -23v-192q0 -14 -9 -23t-23 -9h-1248v-224q0 -21 -19 -29t-35 5l-384 350q-10 10 -10 23z" />
+<glyph unicode="&#xf178;" horiz-adv-x="1792" d="M0 544v192q0 14 9 23t23 9h1248v224q0 21 19 29t35 -5l384 -350q10 -10 10 -23q0 -14 -10 -24l-384 -354q-16 -14 -35 -6q-19 9 -19 29v224h-1248q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf179;" horiz-adv-x="1408" d="M0 634q0 228 113 374q112 144 284 144q72 0 177 -30q104 -30 138 -30q45 0 143 34q102 34 173 34q119 0 213 -65q52 -36 104 -100q-79 -67 -114 -118q-65 -94 -65 -207q0 -124 69 -223t158 -126q-39 -125 -123 -250q-129 -196 -257 -196q-49 0 -140 32q-86 32 -151 32 q-61 0 -142 -33q-81 -34 -132 -34q-152 0 -301 259q-147 261 -147 503zM683 1131q3 149 78 257q74 107 250 148q1 -3 2.5 -11t2.5 -11q0 -4 0.5 -10t0.5 -10q0 -61 -29 -136q-30 -75 -93 -138q-54 -54 -108 -72q-37 -11 -104 -17z" />
+<glyph unicode="&#xf17a;" horiz-adv-x="1664" d="M0 -27v557h682v-651zM0 614v565l682 94v-659h-682zM757 -131v661h907v-786zM757 614v669l907 125v-794h-907z" />
+<glyph unicode="&#xf17b;" horiz-adv-x="1408" d="M0 337v430q0 42 30 72t73 30q42 0 72 -30t30 -72v-430q0 -43 -29.5 -73t-72.5 -30t-73 30t-30 73zM241 886q0 117 64 215.5t172 153.5l-71 131q-7 13 5 20q13 6 20 -6l72 -132q95 42 201 42t201 -42l72 132q7 12 20 6q12 -7 5 -20l-71 -131q107 -55 171 -153.5t64 -215.5 h-925zM245 184v666h918v-666q0 -46 -32 -78t-77 -32h-75v-227q0 -43 -30 -73t-73 -30t-73 30t-30 73v227h-138v-227q0 -43 -30 -73t-73 -30q-42 0 -72 30t-30 73l-1 227h-74q-46 0 -78 32t-32 78zM455 1092q0 -16 11 -27.5t27 -11.5t27.5 11.5t11.5 27.5t-11.5 27.5 t-27.5 11.5t-27 -11.5t-11 -27.5zM876 1092q0 -16 11.5 -27.5t27.5 -11.5t27 11.5t11 27.5t-11 27.5t-27 11.5t-27.5 -11.5t-11.5 -27.5zM1203 337v430q0 43 30 72.5t72 29.5q43 0 73 -29.5t30 -72.5v-430q0 -43 -30 -73t-73 -30q-42 0 -72 30t-30 73z" />
+<glyph unicode="&#xf17c;" d="M11 -115q-10 23 7 66.5t18 54.5q1 16 -4 40t-10 42.5t-4.5 36.5t10.5 27q14 12 57 14t60 12q30 18 42 35t12 51q21 -73 -32 -106q-32 -20 -83 -15q-34 3 -43 -10q-13 -15 5 -57q2 -6 8 -18t8.5 -18t4.5 -17t1 -22q0 -15 -17 -49t-14 -48q3 -17 37 -26q20 -6 84.5 -18.5 t99.5 -20.5q24 -6 74 -22t82.5 -23t55.5 -4q43 6 64.5 28t23 48t-7.5 58.5t-19 52t-20 36.5q-121 190 -169 242q-68 74 -113 40q-11 -9 -15 15q-3 16 -2 38q1 29 10 52t24 47t22 42q8 21 26.5 72t29.5 78t30 61t39 54q110 143 124 195q-12 112 -16 310q-2 90 24 151.5 t106 104.5q39 21 104 21q53 1 106 -13.5t89 -41.5q57 -42 91.5 -121.5t29.5 -147.5q-5 -95 30 -214q34 -113 133 -218q55 -59 99.5 -163t59.5 -191q8 -49 5 -84.5t-12 -55.5t-20 -22q-10 -2 -23.5 -19t-27 -35.5t-40.5 -33.5t-61 -14q-18 1 -31.5 5t-22.5 13.5t-13.5 15.5 t-11.5 20.5t-9 19.5q-22 37 -41 30t-28 -49t7 -97q20 -70 1 -195q-10 -65 18 -100.5t73 -33t85 35.5q59 49 89.5 66.5t103.5 42.5q53 18 77 36.5t18.5 34.5t-25 28.5t-51.5 23.5q-33 11 -49.5 48t-15 72.5t15.5 47.5q1 -31 8 -56.5t14.5 -40.5t20.5 -28.5t21 -19t21.5 -13 t16.5 -9.5q20 -12 31 -24.5t12 -24t-2.5 -22.5t-15.5 -22t-23.5 -19.5t-30 -18.5t-31.5 -16.5t-32 -15.5t-27 -13q-38 -19 -85.5 -56t-75.5 -64q-17 -16 -68 -19.5t-89 14.5q-18 9 -29.5 23.5t-16.5 25.5t-22 19.5t-47 9.5q-44 1 -130 1q-19 0 -57 -1.5t-58 -2.5 q-44 -1 -79.5 -15t-53.5 -30t-43.5 -28.5t-53.5 -11.5q-29 1 -111 31t-146 43q-19 4 -51 9.5t-50 9t-39.5 9.5t-33.5 14.5t-17 19.5zM321 495q-36 -65 10 -166q5 -12 25 -28t24 -20q20 -23 104 -90.5t93 -76.5q16 -15 17.5 -38t-14 -43t-45.5 -23q8 -15 29 -44.5t28 -54 t7 -70.5q46 24 7 92q-4 8 -10.5 16t-9.5 12t-2 6q3 5 13 9.5t20 -2.5q46 -52 166 -36q133 15 177 87q23 38 34 30q12 -6 10 -52q-1 -25 -23 -92q-9 -23 -6 -37.5t24 -15.5q3 19 14.5 77t13.5 90q2 21 -6.5 73.5t-7.5 97t23 70.5q15 18 51 18q1 37 34.5 53t72.5 10.5 t60 -22.5q0 18 -55 42q4 15 7.5 27.5t5 26t3 21.5t0.5 22.5t-1 19.5t-3.5 22t-4 20.5t-5 25t-5.5 26.5q-10 48 -47 103t-72 75q24 -20 57 -83q87 -162 54 -278q-11 -40 -50 -42q-31 -4 -38.5 18.5t-8 83.5t-11.5 107q-9 39 -19.5 69t-19.5 45.5t-15.5 24.5t-13 15t-7.5 7 q-14 62 -31 103t-29.5 56t-23.5 33t-15 40q-4 21 6 53.5t4.5 49.5t-44.5 25q-15 3 -44.5 18t-35.5 16q-8 1 -11 26t8 51t36 27q37 3 51 -30t4 -58q-11 -19 -2 -26.5t30 -0.5q13 4 13 36v37q-5 30 -13.5 50t-21 30.5t-23.5 15t-27 7.5q-107 -8 -89 -134q0 -15 -1 -15 q-9 9 -29.5 10.5t-33 -0.5t-15.5 5q1 57 -16 90t-45 34q-27 1 -41.5 -27.5t-16.5 -59.5q-1 -15 3.5 -37t13 -37.5t15.5 -13.5q10 3 16 14q4 9 -7 8q-7 0 -15.5 14.5t-9.5 33.5q-1 22 9 37t34 14q17 0 27 -21t9.5 -39t-1.5 -22q-22 -15 -31 -29q-8 -12 -27.5 -23.5 t-20.5 -12.5q-13 -14 -15.5 -27t7.5 -18q14 -8 25 -19.5t16 -19t18.5 -13t35.5 -6.5q47 -2 102 15q2 1 23 7t34.5 10.5t29.5 13t21 17.5q9 14 20 8q5 -3 6.5 -8.5t-3 -12t-16.5 -9.5q-20 -6 -56.5 -21.5t-45.5 -19.5q-44 -19 -70 -23q-25 -5 -79 2q-10 2 -9 -2t17 -19 q25 -23 67 -22q17 1 36 7t36 14t33.5 17.5t30 17t24.5 12t17.5 2.5t8.5 -11q0 -2 -1 -4.5t-4 -5t-6 -4.5t-8.5 -5t-9 -4.5t-10 -5t-9.5 -4.5q-28 -14 -67.5 -44t-66.5 -43t-49 -1q-21 11 -63 73q-22 31 -25 22q-1 -3 -1 -10q0 -25 -15 -56.5t-29.5 -55.5t-21 -58t11.5 -63 q-23 -6 -62.5 -90t-47.5 -141q-2 -18 -1.5 -69t-5.5 -59q-8 -24 -29 -3q-32 31 -36 94q-2 28 4 56q4 19 -1 18zM372 630q4 -1 12.5 7t12.5 18q1 3 2 7t2 6t1.5 4.5t0.5 4v3t-1 2.5t-3 2q-4 1 -6 -3t-4.5 -12.5t-5.5 -13.5t-10 -13q-7 -10 -1 -12zM603 1190q2 -5 5 -6 q10 0 7 -15q-3 -20 8 -20q3 0 3 3q3 17 -2.5 30t-11.5 15q-9 2 -9 -7zM634 1110q0 12 19 15h10q-11 -1 -15.5 -10.5t-8.5 -9.5q-5 -1 -5 5zM721 1122q24 11 32 -2q3 -6 -3 -9q-4 -1 -11.5 6.5t-17.5 4.5zM835 1196l4 -2q14 -4 18 -31q0 -3 8 2l2 3q0 11 -5 19.5t-11 12.5 t-9 3q-14 -1 -7 -7zM851 1381.5q-1 -2.5 3 -8.5q4 -3 8 0t11 9t15 9q1 1 9 1t15 2t9 7q0 2 -2.5 5t-9 7t-9.5 6q-15 15 -24 15q-9 -1 -11.5 -7.5t-1 -13t-0.5 -12.5q-1 -4 -6 -10.5t-6 -9zM981 1002q-14 -16 7 -43.5t39 -31.5q9 -1 14.5 8t3.5 20q-2 8 -6.5 11.5t-13 5 t-14.5 5.5q-5 3 -9.5 8t-7 8t-5.5 6.5t-4 4t-4 -1.5z" />
+<glyph unicode="&#xf17d;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM112 640q0 -124 44 -236.5t124 -201.5q50 89 123.5 166.5t142.5 124.5t130.5 81t99.5 48l37 13 q4 1 13 3.5t13 4.5q-21 49 -53 111q-311 -93 -673 -93q-1 -7 -1 -21zM126 775q302 0 606 80q-120 213 -244 378q-138 -65 -234 -186t-128 -272zM350 134q184 -150 418 -150q132 0 256 52q-42 241 -140 498h-2l-2 -1q-16 -6 -43 -16.5t-101 -49t-137 -82t-131 -114.5 t-103 -148zM609 1276q1 1 2 1q-1 0 -2 -1zM613 1277q131 -170 246 -382q69 26 130 60.5t96.5 61.5t65.5 57t37.5 40.5l12.5 17.5q-185 164 -433 164q-76 0 -155 -19zM909 797q25 -53 44 -95q2 -6 6.5 -17.5t7.5 -16.5q36 5 74.5 7t73.5 2t69 -1.5t64 -4t56.5 -5.5t48 -6.5 t36.5 -6t25 -4.5l10 -2q-3 232 -149 410l-1 -1q-9 -12 -19 -24.5t-43.5 -44.5t-71 -60.5t-100 -65t-131.5 -64.5zM1007 565q87 -239 128 -469q111 75 185 189.5t96 250.5q-210 60 -409 29z" />
+<glyph unicode="&#xf17e;" d="M0 1024q0 159 112.5 271.5t271.5 112.5q130 0 234 -80q77 16 150 16q143 0 273.5 -55.5t225 -150t150 -225t55.5 -273.5q0 -73 -16 -150q80 -104 80 -234q0 -159 -112.5 -271.5t-271.5 -112.5q-130 0 -234 80q-77 -16 -150 -16q-143 0 -273.5 55.5t-225 150t-150 225 t-55.5 273.5q0 73 16 150q-80 104 -80 234zM376 399q0 -92 122 -157.5t291 -65.5q73 0 140 18.5t122.5 53.5t88.5 93.5t33 131.5q0 50 -19.5 91.5t-48.5 68.5t-73 49t-82.5 34t-87.5 23l-104 24q-30 7 -44 10.5t-35 11.5t-30 16t-16.5 21t-7.5 30q0 77 144 77q43 0 77 -12 t54 -28.5t38 -33.5t40 -29t48 -12q47 0 75.5 32t28.5 77q0 55 -56 99.5t-142 67.5t-182 23q-68 0 -132 -15.5t-119.5 -47t-89 -87t-33.5 -128.5q0 -61 19 -106.5t56 -75.5t80 -48.5t103 -32.5l146 -36q90 -22 112 -36q32 -20 32 -60q0 -39 -40 -64.5t-105 -25.5 q-51 0 -91.5 16t-65 38.5t-45.5 45t-46 38.5t-54 16q-50 0 -75.5 -30t-25.5 -75z" />
+<glyph unicode="&#xf180;" horiz-adv-x="1664" d="M0 640q0 75 53 128l587 587q53 53 128 53t128 -53l265 -265l-398 -399l-188 188q-42 42 -99 42q-59 0 -100 -41l-120 -121q-42 -40 -42 -99q0 -58 42 -100l406 -408q30 -28 67 -37l6 -4h28q60 0 99 41l619 619l2 -3q53 -53 53 -128t-53 -128l-587 -587 q-52 -53 -127.5 -53t-128.5 53l-587 587q-53 53 -53 128zM302 660q0 21 14 35l121 120q13 15 35 15t36 -15l252 -252l574 575q15 15 36 15t36 -15l120 -120q14 -15 14 -36t-14 -36l-730 -730q-17 -15 -37 -15q-4 0 -6 1q-18 2 -30 14l-407 408q-14 15 -14 36z" />
+<glyph unicode="&#xf181;" d="M0 -64v1408q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-1408q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM160 192q0 -14 9 -23t23 -9h480q14 0 23 9t9 23v1024q0 14 -9 23t-23 9h-480q-14 0 -23 -9t-9 -23v-1024zM832 576q0 -14 9 -23t23 -9h480q14 0 23 9t9 23 v640q0 14 -9 23t-23 9h-480q-14 0 -23 -9t-9 -23v-640z" />
+<glyph unicode="&#xf182;" horiz-adv-x="1280" d="M0 480q0 29 16 53l256 384q73 107 176 107h384q103 0 176 -107l256 -384q16 -24 16 -53q0 -40 -28 -68t-68 -28q-51 0 -80 43l-227 341h-45v-132l247 -411q9 -15 9 -33q0 -26 -19 -45t-45 -19h-192v-272q0 -46 -33 -79t-79 -33h-160q-46 0 -79 33t-33 79v272h-192 q-26 0 -45 19t-19 45q0 18 9 33l247 411v132h-45l-227 -341q-29 -43 -80 -43q-40 0 -68 28t-28 68zM416 1280q0 93 65.5 158.5t158.5 65.5t158.5 -65.5t65.5 -158.5t-65.5 -158.5t-158.5 -65.5t-158.5 65.5t-65.5 158.5z" />
+<glyph unicode="&#xf183;" horiz-adv-x="1024" d="M0 416v416q0 80 56 136t136 56h640q80 0 136 -56t56 -136v-416q0 -40 -28 -68t-68 -28t-68 28t-28 68v352h-64v-912q0 -46 -33 -79t-79 -33t-79 33t-33 79v464h-64v-464q0 -46 -33 -79t-79 -33t-79 33t-33 79v912h-64v-352q0 -40 -28 -68t-68 -28t-68 28t-28 68z M288 1280q0 93 65.5 158.5t158.5 65.5t158.5 -65.5t65.5 -158.5t-65.5 -158.5t-158.5 -65.5t-158.5 65.5t-65.5 158.5z" />
+<glyph unicode="&#xf184;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM399.5 766q8.5 -37 24.5 -59l349 -473l350 473q16 22 24.5 59t-6 85t-61.5 79q-40 26 -83 25.5 t-73.5 -17.5t-54.5 -45q-36 -40 -96 -40q-59 0 -95 40q-24 28 -54.5 45t-73.5 17.5t-84 -25.5q-46 -31 -60.5 -79t-6 -85z" />
+<glyph unicode="&#xf185;" horiz-adv-x="1792" d="M44 363q-5 17 4 29l180 248l-180 248q-9 13 -4 29q4 15 20 20l292 96v306q0 16 13 26q15 10 29 4l292 -94l180 248q9 12 26 12t26 -12l180 -248l292 94q14 6 29 -4q13 -10 13 -26v-306l292 -96q16 -5 20 -20q5 -16 -4 -29l-180 -248l180 -248q9 -12 4 -29q-4 -15 -20 -20 l-292 -96v-306q0 -16 -13 -26q-15 -10 -29 -4l-292 94l-180 -248q-10 -13 -26 -13t-26 13l-180 248l-292 -94q-14 -6 -29 4q-13 10 -13 26v306l-292 96q-16 5 -20 20zM320 640q0 -117 45.5 -223.5t123 -184t184 -123t223.5 -45.5t223.5 45.5t184 123t123 184t45.5 223.5 t-45.5 223.5t-123 184t-184 123t-223.5 45.5t-223.5 -45.5t-184 -123t-123 -184t-45.5 -223.5z" />
+<glyph unicode="&#xf186;" d="M0 640q0 153 57.5 292.5t156 241.5t235.5 164.5t290 68.5q44 2 61 -39q18 -41 -15 -72q-86 -78 -131.5 -181.5t-45.5 -218.5q0 -148 73 -273t198 -198t273 -73q118 0 228 51q41 18 72 -13q14 -14 17.5 -34t-4.5 -38q-94 -203 -283.5 -324.5t-413.5 -121.5q-156 0 -298 61 t-245 164t-164 245t-61 298zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51q144 0 273.5 61.5t220.5 171.5q-54 -9 -110 -9q-182 0 -337 90t-245 245t-90 337q0 192 104 357q-201 -60 -328.5 -229t-127.5 -384z" />
+<glyph unicode="&#xf187;" horiz-adv-x="1792" d="M64 1088v256q0 26 19 45t45 19h1536q26 0 45 -19t19 -45v-256q0 -26 -19 -45t-45 -19h-1536q-26 0 -45 19t-19 45zM128 -64v960q0 26 19 45t45 19h1408q26 0 45 -19t19 -45v-960q0 -26 -19 -45t-45 -19h-1408q-26 0 -45 19t-19 45zM704 704q0 -26 19 -45t45 -19h256 q26 0 45 19t19 45t-19 45t-45 19h-256q-26 0 -45 -19t-19 -45z" />
+<glyph unicode="&#xf188;" horiz-adv-x="1664" d="M32 576q0 26 19 45t45 19h224v294l-173 173q-19 19 -19 45t19 45t45 19t45 -19l173 -173h844l173 173q19 19 45 19t45 -19t19 -45t-19 -45l-173 -173v-294h224q26 0 45 -19t19 -45t-19 -45t-45 -19h-224q0 -171 -67 -290l208 -209q19 -19 19 -45t-19 -45q-18 -19 -45 -19 t-45 19l-198 197q-5 -5 -15 -13t-42 -28.5t-65 -36.5t-82 -29t-97 -13v896h-128v-896q-51 0 -101.5 13.5t-87 33t-66 39t-43.5 32.5l-15 14l-183 -207q-20 -21 -48 -21q-24 0 -43 16q-19 18 -20.5 44.5t15.5 46.5l202 227q-58 114 -58 274h-224q-26 0 -45 19t-19 45z M512 1152q0 133 93.5 226.5t226.5 93.5t226.5 -93.5t93.5 -226.5h-640z" />
+<glyph unicode="&#xf189;" horiz-adv-x="1920" d="M-1 1004q0 11 3 16l4 6q15 19 57 19l274 2q12 -2 23 -6.5t16 -8.5l5 -3q16 -11 24 -32q20 -50 46 -103.5t41 -81.5l16 -29q29 -60 56 -104t48.5 -68.5t41.5 -38.5t34 -14t27 5q2 1 5 5t12 22t13.5 47t9.5 81t0 125q-2 40 -9 73t-14 46l-6 12q-25 34 -85 43q-13 2 5 24 q17 19 38 30q53 26 239 24q82 -1 135 -13q20 -5 33.5 -13.5t20.5 -24t10.5 -32t3.5 -45.5t-1 -55t-2.5 -70.5t-1.5 -82.5q0 -11 -1 -42t-0.5 -48t3.5 -40.5t11.5 -39t22.5 -24.5q8 -2 17 -4t26 11t38 34.5t52 67t68 107.5q60 104 107 225q4 10 10 17.5t11 10.5l4 3l5 2.5 t13 3t20 0.5l288 2q39 5 64 -2.5t31 -16.5l6 -10q23 -64 -150 -294q-24 -32 -65 -85q-78 -100 -90 -131q-17 -41 14 -81q17 -21 81 -82h1l1 -1l1 -1l2 -2q141 -131 191 -221q3 -5 6.5 -12.5t7 -26.5t-0.5 -34t-25 -27.5t-59 -12.5l-256 -4q-24 -5 -56 5t-52 22l-20 12 q-30 21 -70 64t-68.5 77.5t-61 58t-56.5 15.5q-3 -1 -8 -3.5t-17 -14.5t-21.5 -29.5t-17 -52t-6.5 -77.5q0 -15 -3.5 -27.5t-7.5 -18.5l-4 -5q-18 -19 -53 -22h-115q-71 -4 -146 16.5t-131.5 53t-103 66t-70.5 57.5l-25 24q-10 10 -27.5 30t-71.5 91t-106 151t-122.5 211 t-130.5 272q-6 16 -6 27z" />
+<glyph unicode="&#xf18a;" horiz-adv-x="1792" d="M0 391q0 115 69.5 245t197.5 258q169 169 341.5 236t246.5 -7q65 -64 20 -209q-4 -14 -1 -20t10 -7t14.5 0.5t13.5 3.5l6 2q139 59 246 59t153 -61q45 -63 0 -178q-2 -13 -4.5 -20t4.5 -12.5t12 -7.5t17 -6q57 -18 103 -47t80 -81.5t34 -116.5q0 -68 -37 -139.5 t-109 -137t-168.5 -117.5t-226 -83t-270.5 -31t-275 33.5t-240.5 93t-171.5 151t-65 199.5zM181 320q9 -96 89 -170t208.5 -109t274.5 -21q223 23 369.5 141.5t132.5 264.5q-9 96 -89 170t-208.5 109t-274.5 21q-223 -23 -369.5 -141.5t-132.5 -264.5zM413.5 230.5 q-40.5 92.5 6.5 187.5q47 93 151.5 139t210.5 19q111 -29 158.5 -119.5t2.5 -190.5q-45 -102 -158 -150t-224 -12q-107 34 -147.5 126.5zM495 257.5q9 -34.5 43 -50.5t74.5 -2.5t62.5 47.5q21 34 11 69t-45 50q-34 14 -73 1t-60 -46q-22 -34 -13 -68.5zM705 399 q-17 -31 13 -45q14 -5 29 0.5t22 18.5q8 13 3.5 26.5t-17.5 18.5q-14 5 -28.5 -0.5t-21.5 -18.5zM1165 1274q-6 28 9.5 51.5t43.5 29.5q123 26 244 -11.5t208 -134.5q87 -96 112.5 -222.5t-13.5 -241.5q-9 -27 -34 -40t-52 -4t-40 34t-5 52q28 82 10 172t-80 158 q-62 69 -148 95.5t-173 8.5q-28 -6 -52 9.5t-30 43.5zM1224 1047q-5 24 8 44.5t37 25.5q60 13 119 -5.5t101 -65.5t54.5 -108.5t-6.5 -117.5q-8 -23 -29.5 -34t-44.5 -4q-23 8 -34 29.5t-4 44.5q20 63 -24 111t-107 35q-24 -5 -45 8t-25 37z" />
+<glyph unicode="&#xf18b;" d="M0 638q0 187 83.5 349.5t229.5 269.5t325 137v-485q0 -252 -126.5 -459.5t-330.5 -306.5q-181 215 -181 495zM398 -34q138 87 235.5 211t131.5 268q35 -144 132.5 -268t235.5 -211q-171 -94 -368 -94q-196 0 -367 94zM898 909v485q179 -30 325 -137t229.5 -269.5 t83.5 -349.5q0 -280 -181 -495q-204 99 -330.5 306.5t-126.5 459.5z" />
+<glyph unicode="&#xf18c;" horiz-adv-x="1408" d="M0 -211q0 19 13 31.5t32 12.5q173 1 322.5 107.5t251.5 294.5q-36 -14 -72 -23t-83 -13t-91 2.5t-93 28.5t-92 59t-84.5 100t-74.5 146q114 47 214 57t167.5 -7.5t124.5 -56.5t88.5 -77t56.5 -82q53 131 79 291q-7 -1 -18 -2.5t-46.5 -2.5t-69.5 0.5t-81.5 10t-88.5 23 t-84 42.5t-75 65t-54.5 94.5t-28.5 127.5q70 28 133.5 36.5t112.5 -1t92 -30t73.5 -50t56 -61t42 -63t27.5 -56t16 -39.5l4 -16q12 122 12 195q-8 6 -21.5 16t-49 44.5t-63.5 71.5t-54 93t-33 112.5t12 127t70 138.5q73 -25 127.5 -61.5t84.5 -76.5t48 -85t20.5 -89 t-0.5 -85.5t-13 -76.5t-19 -62t-17 -42l-7 -15q1 -5 1 -50.5t-1 -71.5q3 7 10 18.5t30.5 43t50.5 58t71 55.5t91.5 44.5t112 14.5t132.5 -24q-2 -78 -21.5 -141.5t-50 -104.5t-69.5 -71.5t-81.5 -45.5t-84.5 -24t-80 -9.5t-67.5 1t-46.5 4.5l-17 3q-23 -147 -73 -283 q6 7 18 18.5t49.5 41t77.5 52.5t99.5 42t117.5 20t129 -23.5t137 -77.5q-32 -80 -76 -138t-91 -88.5t-99 -46.5t-101.5 -14.5t-96.5 8.5t-86.5 22t-69.5 27.5t-46 22.5l-17 10q-113 -228 -289.5 -359.5t-384.5 -132.5q-19 0 -32 13t-13 32z" />
+<glyph unicode="&#xf18d;" horiz-adv-x="1280" d="M21 217v66h1238v-66q0 -85 -57.5 -144.5t-138.5 -59.5h-57l-260 -269v269h-529q-81 0 -138.5 59.5t-57.5 144.5zM21 354v255h1238v-255h-1238zM21 682v255h1238v-255h-1238zM21 1010v67q0 84 57.5 143.5t138.5 59.5h846q81 0 138.5 -59.5t57.5 -143.5v-67h-1238z" />
+<glyph unicode="&#xf18e;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM384 544v192q0 13 9.5 22.5t22.5 9.5h352v192q0 14 9 23t23 9q12 0 24 -10l319 -319q9 -9 9 -23t-9 -23l-320 -320q-9 -9 -23 -9q-13 0 -22.5 9.5t-9.5 22.5v192h-352q-13 0 -22.5 9.5t-9.5 22.5z" />
+<glyph unicode="&#xf190;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM384 640q0 14 9 23l320 320q9 9 23 9q13 0 22.5 -9.5t9.5 -22.5v-192h352q13 0 22.5 -9.5t9.5 -22.5v-192q0 -13 -9.5 -22.5t-22.5 -9.5h-352v-192q0 -14 -9 -23t-23 -9q-12 0 -24 10l-319 319q-9 9 -9 23z" />
+<glyph unicode="&#xf191;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 160q0 -13 9.5 -22.5t22.5 -9.5h960q13 0 22.5 9.5t9.5 22.5v960q0 13 -9.5 22.5t-22.5 9.5h-960 q-13 0 -22.5 -9.5t-9.5 -22.5v-960zM448 640q0 33 27 52l448 320q17 12 37 12q26 0 45 -19t19 -45v-640q0 -26 -19 -45t-45 -19q-20 0 -37 12l-448 320q-27 19 -27 52z" />
+<glyph unicode="&#xf192;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM224 640q0 -148 73 -273t198 -198t273 -73t273 73t198 198t73 273t-73 273t-198 198t-273 73t-273 -73 t-198 -198t-73 -273zM512 640q0 106 75 181t181 75t181 -75t75 -181t-75 -181t-181 -75t-181 75t-75 181z" />
+<glyph unicode="&#xf193;" horiz-adv-x="1664" d="M0 320q0 181 104.5 330t274.5 211l17 -131q-122 -54 -195 -165.5t-73 -244.5q0 -185 131.5 -316.5t316.5 -131.5q126 0 232.5 65t165 175.5t49.5 236.5l102 -204q-58 -179 -210 -290t-339 -111q-156 0 -288.5 77.5t-210 210t-77.5 288.5zM416 1348q-2 16 6 42 q14 51 57 82.5t97 31.5q66 0 113 -47t47 -113q0 -69 -52 -117.5t-120 -41.5l37 -289h423v-128h-407l16 -128h455q40 0 57 -35l228 -455l198 99l58 -114l-256 -128q-13 -7 -29 -7q-40 0 -57 35l-239 477h-472q-24 0 -42.5 16.5t-21.5 40.5z" />
+<glyph unicode="&#xf194;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM128 806q16 -8 25.5 -26t21.5 -20q21 -3 54.5 8.5t58 10.5t41.5 -30q11 -18 18.5 -38.5t15 -48t12.5 -40.5 q17 -46 53 -187q36 -146 57 -197q42 -99 103 -125q43 -12 85 -1.5t76 31.5q131 77 250 237q104 139 172.5 292.5t82.5 226.5q16 85 -21 132q-52 65 -187 45q-17 -3 -41 -12.5t-57.5 -30.5t-64.5 -48.5t-59.5 -70t-44.5 -91.5q80 7 113.5 -16t26.5 -99q-5 -52 -52 -143 q-43 -78 -71 -99q-44 -32 -87 14q-23 24 -37.5 64.5t-19 73t-10 84t-8.5 71.5q-23 129 -34 164q-12 37 -35.5 69t-50.5 40q-57 16 -127 -25q-54 -32 -136.5 -106t-122.5 -102v-7z" />
+<glyph unicode="&#xf195;" horiz-adv-x="1152" d="M0 608v128q0 23 23 31l233 71v93l-215 -66q-3 -1 -9 -1q-10 0 -19 6q-13 10 -13 26v128q0 23 23 31l233 71v250q0 14 9 23t23 9h160q14 0 23 -9t9 -23v-181l375 116q15 5 28 -5t13 -26v-128q0 -23 -23 -31l-393 -121v-93l375 116q15 5 28 -5t13 -26v-128q0 -23 -23 -31 l-393 -121v-487q188 13 318 151t130 328q0 14 9 23t23 9h160q14 0 23 -9t9 -23q0 -191 -94.5 -353t-256.5 -256.5t-353 -94.5h-160q-14 0 -23 9t-9 23v611l-215 -66q-3 -1 -9 -1q-10 0 -19 6q-13 10 -13 26z" />
+<glyph unicode="&#xf196;" horiz-adv-x="1408" d="M0 288v832q0 119 84.5 203.5t203.5 84.5h832q119 0 203.5 -84.5t84.5 -203.5v-832q0 -119 -84.5 -203.5t-203.5 -84.5h-832q-119 0 -203.5 84.5t-84.5 203.5zM128 288q0 -66 47 -113t113 -47h832q66 0 113 47t47 113v832q0 66 -47 113t-113 47h-832q-66 0 -113 -47 t-47 -113v-832zM256 672v64q0 14 9 23t23 9h352v352q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-352h352q14 0 23 -9t9 -23v-64q0 -14 -9 -23t-23 -9h-352v-352q0 -14 -9 -23t-23 -9h-64q-14 0 -23 9t-9 23v352h-352q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf197;" horiz-adv-x="2176" d="M0 576q0 12 38.5 20.5t96.5 10.5q-7 25 -7 49q0 33 9.5 56.5t22.5 23.5h64v64h128q158 0 268 -64h1113q42 -7 106.5 -18t80.5 -14q89 -15 150 -40.5t83.5 -47.5t22.5 -40t-22.5 -40t-83.5 -47.5t-150 -40.5q-16 -3 -80.5 -14t-106.5 -18h-1113q-110 -64 -268 -64h-128v64 h-64q-13 0 -22.5 23.5t-9.5 56.5q0 24 7 49q-58 2 -96.5 10.5t-38.5 20.5zM323 336h29q157 0 273 64h1015q-217 -38 -456 -80q-57 0 -113 -24t-83 -48l-28 -24l-288 -288q-26 -26 -70.5 -45t-89.5 -19h-96zM323 816l93 464h96q46 0 90 -19t70 -45l288 -288q4 -4 11 -10.5 t30.5 -23t48.5 -29t61.5 -23t72.5 -10.5l456 -80h-1015q-116 64 -273 64h-29zM1739 484l81 -30q68 48 68 122t-68 122l-81 -30q53 -36 53 -92t-53 -92z" />
+<glyph unicode="&#xf198;" horiz-adv-x="1664" d="M0 796q0 47 27.5 85t71.5 53l157 53l-53 159q-8 24 -8 47q0 60 42 102.5t102 42.5q47 0 85 -27t53 -72l54 -160l310 105l-54 160q-8 24 -8 47q0 59 42.5 102t101.5 43q47 0 85.5 -27.5t53.5 -71.5l53 -161l162 55q21 6 43 6q60 0 102.5 -39.5t42.5 -98.5q0 -45 -30 -81.5 t-74 -51.5l-157 -54l105 -316l164 56q24 8 46 8q62 0 103.5 -40.5t41.5 -101.5q0 -97 -93 -130l-172 -59l56 -167q7 -21 7 -47q0 -59 -42 -102t-101 -43q-47 0 -85.5 27t-53.5 72l-55 165l-310 -106l55 -164q8 -24 8 -47q0 -59 -42 -102t-102 -43q-47 0 -85 27t-53 72 l-55 163l-153 -53q-29 -9 -50 -9q-61 0 -101.5 40t-40.5 101q0 47 27.5 85t71.5 53l156 53l-105 313l-156 -54q-26 -8 -48 -8q-60 0 -101 40.5t-41 100.5zM620 811l105 -313l310 105l-105 315z" />
+<glyph unicode="&#xf199;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 352q0 -40 28 -68t68 -28h832q40 0 68 28t28 68v436q-31 -35 -64 -55q-34 -22 -132.5 -85t-151.5 -99 q-98 -69 -164 -69t-164 69q-46 32 -141.5 92.5t-142.5 92.5q-12 8 -33 27t-31 27v-436zM256 928q0 -37 30.5 -76.5t67.5 -64.5q47 -32 137.5 -89t129.5 -83q3 -2 17 -11.5t21 -14t21 -13t23.5 -13t21.5 -9.5t22.5 -7.5t20.5 -2.5t20.5 2.5t22.5 7.5t21.5 9.5t23.5 13t21 13 t21 14t17 11.5l267 174q35 23 66.5 62.5t31.5 73.5q0 41 -27.5 70t-68.5 29h-832q-40 0 -68 -28t-28 -68z" />
+<glyph unicode="&#xf19a;" horiz-adv-x="1792" d="M0 640q0 182 71 348t191 286t286 191t348 71t348 -71t286 -191t191 -286t71 -348t-71 -348t-191 -286t-286 -191t-348 -71t-348 71t-286 191t-191 286t-71 348zM41 640q0 -173 68 -331.5t182.5 -273t273 -182.5t331.5 -68t331.5 68t273 182.5t182.5 273t68 331.5 t-68 331.5t-182.5 273t-273 182.5t-331.5 68t-331.5 -68t-273 -182.5t-182.5 -273t-68 -331.5zM127 640q0 163 67 313l367 -1005q-196 95 -315 281t-119 411zM254 1062q105 160 274.5 253.5t367.5 93.5q147 0 280.5 -53t238.5 -149h-10q-55 0 -92 -40.5t-37 -95.5 q0 -12 2 -24t4 -21.5t8 -23t9 -21t12 -22.5t12.5 -21t14.5 -24t14 -23q63 -107 63 -212q0 -19 -2.5 -38.5t-10 -49.5t-11.5 -44t-17.5 -59t-17.5 -58l-76 -256l-278 826q46 3 88 8q19 2 26 18.5t-2.5 31t-28.5 13.5l-205 -10q-75 1 -202 10q-12 1 -20.5 -5t-11.5 -15 t-1.5 -18.5t9 -16.5t19.5 -8l80 -8l120 -328l-168 -504l-280 832q46 3 88 8q19 2 26 18.5t-2.5 31t-28.5 13.5l-205 -10q-7 0 -23 0.5t-26 0.5zM679 -97l230 670l237 -647q1 -6 5 -11q-126 -44 -255 -44q-112 0 -217 32zM1282 -24l235 678q59 169 59 276q0 42 -6 79 q95 -174 95 -369q0 -209 -104 -385.5t-279 -278.5z" />
+<glyph unicode="&#xf19b;" horiz-adv-x="1792" d="M0 455q0 140 100.5 263.5t275 205.5t391.5 108v-172q-217 -38 -356.5 -150t-139.5 -255q0 -152 154.5 -267t388.5 -145v1360l272 133v-1536l-272 -128q-228 20 -414 102t-293 208.5t-107 272.5zM1134 860v172q277 -33 481 -157l140 79l37 -390l-525 114l147 83 q-119 70 -280 99z" />
+<glyph unicode="&#xf19c;" horiz-adv-x="2048" d="M0 -128q0 26 20.5 45t48.5 19h1782q28 0 48.5 -19t20.5 -45v-128h-1920v128zM0 1024v128l960 384l960 -384v-128h-128q0 -26 -20.5 -45t-48.5 -19h-1526q-28 0 -48.5 19t-20.5 45h-128zM128 0v64q0 26 20.5 45t48.5 19h59v768h256v-768h128v768h256v-768h128v768h256 v-768h128v768h256v-768h59q28 0 48.5 -19t20.5 -45v-64h-1664z" />
+<glyph unicode="&#xf19d;" horiz-adv-x="2304" d="M0 1024q0 23 22 31l1120 352q4 1 10 1t10 -1l1120 -352q22 -8 22 -31t-22 -31l-1120 -352q-4 -1 -10 -1t-10 1l-652 206q-43 -34 -71 -111.5t-34 -178.5q63 -36 63 -109q0 -69 -58 -107l58 -433q2 -14 -8 -25q-9 -11 -24 -11h-192q-15 0 -24 11q-10 11 -8 25l58 433 q-58 38 -58 107q0 73 65 111q11 207 98 330l-333 104q-22 8 -22 31zM512 384l18 316l574 -181q22 -7 48 -7t48 7l574 181l18 -316q4 -69 -82 -128t-235 -93.5t-323 -34.5t-323 34.5t-235 93.5t-82 128z" />
+<glyph unicode="&#xf19e;" d="M109 1536q58 -15 108 -15q43 0 111 15q63 -111 133.5 -229.5t167 -276.5t138.5 -227q37 61 109.5 177.5t117.5 190t105 176t107 189.5q54 -14 107 -14q56 0 114 14q-28 -39 -60 -88.5t-49.5 -78.5t-56.5 -96t-49 -84q-146 -248 -353 -610l13 -707q-62 11 -105 11 q-41 0 -105 -11l13 707q-40 69 -168.5 295.5t-216.5 374.5t-181 287z" />
+<glyph unicode="&#xf1a0;" horiz-adv-x="1280" d="M111 182q0 81 44.5 150t118.5 115q131 82 404 100q-32 41 -47.5 73.5t-15.5 73.5q0 40 21 85q-46 -4 -68 -4q-148 0 -249.5 96.5t-101.5 244.5q0 82 36 159t99 131q76 66 182 98t218 32h417l-137 -88h-132q75 -63 113 -133t38 -160q0 -72 -24.5 -129.5t-59.5 -93 t-69.5 -65t-59 -61.5t-24.5 -66q0 -36 32 -70.5t77 -68t90.5 -73.5t77.5 -104t32 -142q0 -91 -49 -173q-71 -122 -209.5 -179.5t-298.5 -57.5q-132 0 -246.5 41.5t-172.5 137.5q-36 59 -36 131zM297 228q0 -56 23.5 -102t61 -75.5t87 -50t100 -29t101.5 -8.5q58 0 111.5 13 t99 39t73 73t27.5 109q0 25 -7 49t-14.5 42t-27 41.5t-29.5 35t-38.5 34.5t-36.5 29t-41.5 30t-36.5 26q-16 2 -49 2q-53 0 -104.5 -7t-107 -25t-97 -46t-68.5 -74.5t-27 -105.5zM403 1222q0 -46 10 -97.5t31.5 -103t52 -92.5t75 -67t96.5 -26q37 0 77.5 16.5t65.5 43.5 q53 56 53 159q0 59 -17 125.5t-48 129t-84 103.5t-117 41q-42 0 -82.5 -19.5t-66.5 -52.5q-46 -59 -46 -160z" />
+<glyph unicode="&#xf1a1;" horiz-adv-x="1984" d="M0 722q0 94 66 160t160 66q83 0 148 -55q248 158 592 164l134 423q4 14 17.5 21.5t28.5 4.5l347 -82q22 50 68.5 81t102.5 31q77 0 131.5 -54.5t54.5 -131.5t-54.5 -132t-131.5 -55q-76 0 -130.5 54t-55.5 131l-315 74l-116 -366q327 -14 560 -166q64 58 151 58 q94 0 160 -66t66 -160q0 -62 -31 -114t-83 -82q5 -33 5 -61q0 -121 -68.5 -230.5t-197.5 -193.5q-125 -82 -285.5 -125.5t-335.5 -43.5q-176 0 -336.5 43.5t-284.5 125.5q-129 84 -197.5 193t-68.5 231q0 29 5 66q-48 31 -77 81.5t-29 109.5zM77 722q0 -67 51 -111 q49 131 180 235q-36 25 -82 25q-62 0 -105.5 -43.5t-43.5 -105.5zM178 465q0 -101 59.5 -194t171.5 -166q116 -75 265.5 -115.5t313.5 -40.5t313.5 40.5t265.5 115.5q112 73 171.5 166t59.5 194t-59.5 193.5t-171.5 165.5q-116 75 -265.5 115.5t-313.5 40.5t-313.5 -40.5 t-265.5 -115.5q-112 -73 -171.5 -165.5t-59.5 -193.5zM555 572q0 57 41.5 98t97.5 41t96.5 -41t40.5 -98q0 -56 -40.5 -96t-96.5 -40q-57 0 -98 40t-41 96zM661 209.5q0 16.5 11 27.5t27 11t27 -11q77 -77 265 -77h2q188 0 265 77q11 11 27 11t27 -11t11 -27.5t-11 -27.5 q-99 -99 -319 -99h-2q-220 0 -319 99q-11 11 -11 27.5zM1153 572q0 57 41.5 98t97.5 41t96.5 -41t40.5 -98q0 -56 -40.5 -96t-96.5 -40q-57 0 -98 40t-41 96zM1555 1350q0 -45 32 -77t77 -32t77 32t32 77t-32 77t-77 32t-77 -32t-32 -77zM1672 843q131 -105 178 -238 q57 46 57 117q0 62 -43.5 105.5t-105.5 43.5q-49 0 -86 -28z" />
+<glyph unicode="&#xf1a2;" d="M0 193v894q0 133 94 227t226 94h896q132 0 226 -94t94 -227v-894q0 -133 -94 -227t-226 -94h-896q-132 0 -226 94t-94 227zM155 709q0 -37 19.5 -67.5t52.5 -45.5q-7 -25 -7 -54q0 -98 74 -181.5t201.5 -132t278.5 -48.5q150 0 277.5 48.5t201.5 132t74 181.5q0 27 -6 54 q35 14 57 45.5t22 70.5q0 51 -36 87.5t-87 36.5q-60 0 -98 -48q-151 107 -375 115l83 265l206 -49q1 -50 36.5 -85t84.5 -35q50 0 86 35.5t36 85.5t-36 86t-86 36q-36 0 -66 -20.5t-45 -53.5l-227 54q-9 2 -17.5 -2.5t-11.5 -14.5l-95 -302q-224 -4 -381 -113q-36 43 -93 43 q-51 0 -87 -36.5t-36 -87.5zM493 613q0 37 26 63t63 26t63 -26t26 -63t-26 -64t-63 -27t-63 27t-26 64zM560 375q0 11 8 18q7 7 17.5 7t17.5 -7q49 -51 172 -51h1h1q122 0 173 51q7 7 17.5 7t17.5 -7t7 -18t-7 -18q-65 -64 -208 -64h-1h-1q-143 0 -207 64q-8 7 -8 18z M882 613q0 37 26 63t63 26t63 -26t26 -63t-26 -64t-63 -27t-63 27t-26 64zM1143 1120q0 30 21 51t50 21q30 0 51 -21t21 -51q0 -29 -21 -50t-51 -21q-29 0 -50 21t-21 50z" />
+<glyph unicode="&#xf1a3;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM320 502q0 -82 57.5 -139t139.5 -57q81 0 138.5 56.5t57.5 136.5v280q0 19 13.5 33t33.5 14 q19 0 32.5 -14t13.5 -33v-54l60 -28l90 27v62q0 79 -58 135t-138 56t-138 -55.5t-58 -134.5v-283q0 -20 -14 -33.5t-33 -13.5t-32.5 13.5t-13.5 33.5v120h-151v-122zM806 500q0 -80 58 -137t139 -57t138.5 57t57.5 139v122h-150v-126q0 -20 -13.5 -33.5t-33.5 -13.5 q-19 0 -32.5 14t-13.5 33v123l-90 -26l-60 28v-123z" />
+<glyph unicode="&#xf1a4;" horiz-adv-x="1920" d="M0 336v266h328v-262q0 -43 30 -72.5t72 -29.5t72 29.5t30 72.5v620q0 171 126.5 292t301.5 121q176 0 302 -122t126 -294v-136l-195 -58l-131 61v118q0 42 -30 72t-72 30t-72 -30t-30 -72v-612q0 -175 -126 -299t-303 -124q-178 0 -303.5 125.5t-125.5 303.5zM1062 332 v268l131 -61l195 58v-270q0 -42 30 -71.5t72 -29.5t72 29.5t30 71.5v275h328v-266q0 -178 -125.5 -303.5t-303.5 -125.5q-177 0 -303 124.5t-126 300.5z" />
+<glyph unicode="&#xf1a5;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM64 640h704v-704h480q93 0 158.5 65.5t65.5 158.5v480h-704v704h-480q-93 0 -158.5 -65.5t-65.5 -158.5v-480z " />
+<glyph unicode="&#xf1a6;" horiz-adv-x="2048" d="M0 271v697h328v286h204v-983h-532zM205 435h123v369h-123v-369zM614 271h205v697h-205v-697zM614 1050h205v204h-205v-204zM901 26v163h328v82h-328v697h533v-942h-533zM1106 435h123v369h-123v-369zM1516 26v163h327v82h-327v697h532v-942h-532zM1720 435h123v369h-123 v-369z" />
+<glyph unicode="&#xf1a7;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM293 388l211 41v206q55 -19 116 -19q125 0 213.5 95t88.5 229t-88.5 229t-213.5 95q-74 0 -141 -36h-186v-840z M504 804v277q28 17 70 17q53 0 91 -45t38 -109t-38 -109.5t-91 -45.5q-43 0 -70 15zM636 -39l211 41v206q51 -19 117 -19q125 0 213 95t88 229t-88 229t-213 95q-20 0 -39 -3q-23 -78 -78 -136q-87 -95 -211 -101v-636zM847 377v277q28 17 70 17q53 0 91 -45.5t38 -109.5 t-38 -109t-91 -45q-43 0 -70 15z" />
+<glyph unicode="&#xf1a8;" horiz-adv-x="2038" d="M41 455q0 15 8.5 26.5t22.5 14.5l486 106q-8 14 -8 25t5.5 17.5t16 11.5t20 7t23 4.5t18.5 4.5q4 1 15.5 7.5t17.5 6.5q15 0 28 -16t20 -33q163 37 172 37q17 0 29.5 -11t12.5 -28q0 -15 -8.5 -26t-23.5 -14l-182 -40l-1 -16q-1 -26 81.5 -117.5t104.5 -91.5q47 0 119 80 t72 129q0 36 -23.5 53t-51 18.5t-51 11.5t-23.5 34q0 16 10 34l-68 19q43 44 43 117q0 26 -5 58q82 16 144 16q44 0 71.5 -1.5t48.5 -8.5t31 -13.5t20.5 -24.5t15.5 -33.5t17 -47.5t24 -60l50 25q-3 -40 -23 -60t-42.5 -21t-40 -6.5t-16.5 -20.5l1 -21q75 3 143.5 -20.5 t118 -58.5t101 -94.5t84 -108t75.5 -120.5q33 -56 78.5 -109t75.5 -80.5t99 -88.5q-48 -30 -108.5 -57.5t-138.5 -59t-114 -47.5q-44 37 -74 115t-43.5 164.5t-33 180.5t-42.5 168.5t-72.5 123t-122.5 48.5l-10 -2l-6 -4q4 -5 13 -14q6 -5 28 -23.5t25.5 -22t19 -18 t18 -20.5t11.5 -21t10.5 -27.5t4.5 -31t4 -40.5l1 -33q1 -26 -2.5 -57.5t-7.5 -52t-12.5 -58.5t-11.5 -53q-35 1 -101 -9.5t-98 -10.5q-39 0 -72 10q-2 16 -2 47q0 74 3 96q2 13 31.5 41.5t57 59t26.5 51.5q-24 2 -43 -24q-36 -53 -111.5 -99.5t-136.5 -46.5q-25 0 -75.5 63 t-106.5 139.5t-84 96.5q-6 4 -27 30q-482 -112 -513 -112q-16 0 -28 11t-12 27zM764 676q10 1 32.5 7t34.5 6q19 0 35 -10l-96 -20zM822 568l48 12l109 -177l-73 -48zM859 884q16 30 36 46.5t54 29.5t65.5 36t46 36.5t50 55t43.5 50.5q12 -9 28 -31.5t32 -36.5t38 -13l12 1 v-76l22 -1q247 95 371 190q28 21 50 39t42.5 37.5t33 31t29.5 34t24 31t24.5 37t23 38t27 47.5t29.5 53l7 9q-2 -53 -43 -139q-79 -165 -205 -264t-306 -142q-14 -3 -42 -7.5t-50 -9.5t-39 -14q3 -19 24.5 -46t21.5 -34q0 -11 -26 -30q-5 5 -13.5 15.5t-12 14.5t-10.5 11.5 t-10 10.5l-8 8t-8.5 7.5t-8 5t-8.5 4.5q-7 3 -14.5 5t-20.5 2.5t-22 0.5h-32.5h-37.5q-126 0 -217 -43zM1061 45h31l10 -83l-41 -12v95zM1061 -79q39 26 131.5 47.5t146.5 21.5q9 0 22.5 -15.5t28 -42.5t26 -50t24 -51t14.5 -33q-121 -45 -244 -45q-61 0 -125 11zM1116 29 q21 2 60.5 8.5t72 10t60.5 3.5h14q3 -15 3 -16q0 -7 -17.5 -14.5t-46 -13t-54 -9.5t-53.5 -7.5t-32 -4.5zM1947 1528l1 3l2 4l-1 -5zM1950 1535v1v-1zM1950 1535l1 1z" />
+<glyph unicode="&#xf1a9;" d="M0 520q0 89 19.5 172.5t49 145.5t70.5 118.5t78.5 94t78.5 69.5t64.5 46.5t42.5 24.5q14 8 51 26.5t54.5 28.5t48 30t60.5 44q36 28 58 72.5t30 125.5q129 -155 186 -193q44 -29 130 -68t129 -66q21 -13 39 -25t60.5 -46.5t76 -70.5t75 -95t69 -122t47 -148.5 t19.5 -177.5q0 -164 -62 -304.5t-166 -236t-242.5 -149.5t-290.5 -54t-293 57.5t-247.5 157t-170.5 241.5t-64 302zM333 256q-2 -112 74 -164q29 -20 62.5 -28.5t103.5 -8.5q57 0 132 32.5t134 71t120 70.5t93 31q26 -1 65 -31.5t71.5 -67t68 -67.5t55.5 -32q35 -3 58.5 14 t55.5 63q28 41 42.5 101t14.5 106q0 22 -5 44.5t-16.5 45t-34 36.5t-52.5 14q-33 0 -97 -41.5t-129 -83.5t-101 -42q-27 -1 -63.5 19t-76 49t-83.5 58t-100 49t-111 19q-115 -1 -197 -78.5t-84 -178.5zM685.5 -76q-0.5 -10 7.5 -20q34 -32 87.5 -46t102.5 -12.5t99 4.5 q41 4 84.5 20.5t65 30t28.5 20.5q12 12 7 29q-5 19 -24 5q-30 -22 -87 -39t-131 -17q-129 0 -193 49q-5 4 -13 4q-11 0 -26 -12q-7 -6 -7.5 -16zM852 31q9 -8 17.5 -4.5t31.5 23.5q3 2 10.5 8.5t10.5 8.5t10 7t11.5 7t12.5 5t15 4.5t16.5 2.5t20.5 1q27 0 44.5 -7.5 t23 -14.5t13.5 -22q10 -17 12.5 -20t12.5 1q23 12 14 34q-19 47 -39 61q-23 15 -76 15q-47 0 -71 -10q-29 -12 -78 -56q-26 -24 -12 -44z" />
+<glyph unicode="&#xf1aa;" d="M0 78q0 72 44.5 128t113.5 72q-22 86 1 173t88 152l12 12l151 -152l-11 -11q-37 -37 -37 -89t37 -90q37 -37 89 -37t89 37l30 30l151 152l161 160l151 -152l-160 -160l-151 -152l-30 -30q-65 -64 -151.5 -87t-171.5 -2q-16 -70 -72 -115t-129 -45q-85 0 -145 60.5 t-60 145.5zM2 1202q0 85 60 145.5t145 60.5q76 0 133.5 -49t69.5 -123q84 20 169.5 -3.5t149.5 -87.5l12 -12l-152 -152l-12 12q-37 37 -89 37t-89 -37t-37 -89.5t37 -89.5l29 -29l152 -152l160 -160l-151 -152l-161 160l-151 152l-30 30q-68 67 -90 159.5t5 179.5 q-70 15 -115 71t-45 129zM446 803l161 160l152 152l29 30q67 67 159 89.5t178 -3.5q11 75 68.5 126t135.5 51q85 0 145 -60.5t60 -145.5q0 -77 -51 -135t-127 -69q26 -85 3 -176.5t-90 -158.5l-12 -12l-151 152l12 12q37 37 37 89t-37 89t-89 37t-89 -37l-30 -30l-152 -152 l-160 -160zM776 793l152 152l160 -160l152 -152l29 -30q64 -64 87.5 -150.5t2.5 -171.5q76 -11 126.5 -68.5t50.5 -134.5q0 -85 -60 -145.5t-145 -60.5q-74 0 -131 47t-71 118q-86 -28 -179.5 -6t-161.5 90l-11 12l151 152l12 -12q37 -37 89 -37t89 37t37 89t-37 89l-30 30 l-152 152z" />
+<glyph unicode="&#xf1ab;" d="M0 -16v1078q3 9 4 10q5 6 20 11q106 35 149 50v384l558 -198q2 0 160.5 55t316 108.5t161.5 53.5q20 0 20 -21v-418l147 -47v-1079l-774 246q-14 -6 -375 -127.5t-368 -121.5q-13 0 -18 13q0 1 -1 3zM39 15l694 232v1032l-694 -233v-1031zM147 293q6 4 82 92 q21 24 85.5 115t78.5 118q17 30 51 98.5t36 77.5q-8 1 -110 -33q-8 -2 -27.5 -7.5t-34.5 -9.5t-17 -5q-2 -2 -2 -10.5t-1 -9.5q-5 -10 -31 -15q-23 -7 -47 0q-18 4 -28 21q-4 6 -5 23q6 2 24.5 5t29.5 6q58 16 105 32q100 35 102 35q10 2 43 19.5t44 21.5q9 3 21.5 8 t14.5 5.5t6 -0.5q2 -12 -1 -33q0 -2 -12.5 -27t-26.5 -53.5t-17 -33.5q-25 -50 -77 -131l64 -28q12 -6 74.5 -32t67.5 -28q4 -1 10.5 -25.5t4.5 -30.5q-1 -3 -12.5 0.5t-31.5 11.5l-20 9q-44 20 -87 49q-7 5 -41 31.5t-38 28.5q-67 -103 -134 -181q-81 -95 -105 -110 q-4 -2 -19.5 -4t-18.5 0zM268 933l1 3q3 -3 19.5 -5t26.5 0t58 16q36 12 55 14q17 0 21 -17q3 -15 -4 -28q-12 -23 -50 -38q-30 -12 -60 -12q-26 3 -49 26q-14 15 -18 41zM310 -116q0 8 5 13.5t13 5.5q4 0 18 -7.5t30.5 -16.5t20.5 -11q73 -37 159.5 -61.5t157.5 -24.5 q95 0 167 14.5t157 50.5q15 7 30.5 15.5t34 19t28.5 16.5l-43 73l158 -13l-54 -160l-40 66q-130 -83 -276 -108q-58 -12 -91 -12h-84q-79 0 -199.5 39t-183.5 85q-8 7 -8 16zM777 1294l573 -184v380zM885 453l102 -31l45 110l211 -65l37 -135l102 -31l-181 657l-100 31z M1071 630l76 185l63 -227z" />
+<glyph unicode="&#xf1ac;" horiz-adv-x="1792" d="M0 -96v1088q0 66 47 113t113 47h128q66 0 113 -47t47 -113v-1088q0 -66 -47 -113t-113 -47h-128q-66 0 -113 47t-47 113zM512 -96v1536q0 40 28 68t68 28h672q40 0 88 -20t76 -48l152 -152q28 -28 48 -76t20 -88v-163q58 -34 93 -93t35 -128v-768q0 -106 -75 -181 t-181 -75h-864q-66 0 -113 47t-47 113zM640 896h896v256h-160q-40 0 -68 28t-28 68v160h-640v-512zM736 0q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM736 256q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9 h-128q-14 0 -23 -9t-9 -23v-128zM736 512q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM992 0q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM992 256q0 -14 9 -23t23 -9h128 q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM992 512q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM1248 0q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23 v-128zM1248 256q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128zM1248 512q0 -14 9 -23t23 -9h128q14 0 23 9t9 23v128q0 14 -9 23t-23 9h-128q-14 0 -23 -9t-9 -23v-128z" />
+<glyph unicode="&#xf1ad;" d="M0 -192v1664q0 26 19 45t45 19h1280q26 0 45 -19t19 -45v-1664q0 -26 -19 -45t-45 -19h-1280q-26 0 -45 19t-19 45zM256 160q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM256 416q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64 q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM256 672q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM256 928q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM256 1184q0 -14 9 -23 t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM512 96v-192q0 -14 9 -23t23 -9h320q14 0 23 9t9 23v192q0 14 -9 23t-23 9h-320q-14 0 -23 -9t-9 -23zM512 416q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9 t-9 -23v-64zM512 672q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM512 928q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM512 1184q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64 q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM768 416q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM768 672q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM768 928q0 -14 9 -23 t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM768 1184q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM1024 160q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9 t-9 -23v-64zM1024 416q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM1024 672q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM1024 928q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64 q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64zM1024 1184q0 -14 9 -23t23 -9h64q14 0 23 9t9 23v64q0 14 -9 23t-23 9h-64q-14 0 -23 -9t-9 -23v-64z" />
+<glyph unicode="&#xf1ae;" horiz-adv-x="1280" d="M64 1056q0 40 28 68t68 28t68 -28l228 -228h368l228 228q28 28 68 28t68 -28t28 -68t-28 -68l-292 -292v-824q0 -46 -33 -79t-79 -33t-79 33t-33 79v384h-64v-384q0 -46 -33 -79t-79 -33t-79 33t-33 79v824l-292 292q-28 28 -28 68zM416 1152q0 93 65.5 158.5t158.5 65.5 t158.5 -65.5t65.5 -158.5t-65.5 -158.5t-158.5 -65.5t-158.5 65.5t-65.5 158.5z" />
+<glyph unicode="&#xf1b0;" horiz-adv-x="1664" d="M0 724q0 80 42 139.5t119 59.5q76 0 141.5 -55.5t100.5 -134t35 -152.5q0 -80 -42 -139t-119 -59q-76 0 -141.5 55.5t-100.5 133.5t-35 152zM256 19q0 86 56 191.5t139.5 192.5t187.5 146t193 59q118 0 255 -97.5t229 -237t92 -254.5q0 -46 -17 -76.5t-48.5 -45 t-64.5 -20t-76 -5.5q-68 0 -187.5 45t-182.5 45q-66 0 -192.5 -44.5t-200.5 -44.5q-183 0 -183 146zM333 1163q0 60 19 113.5t63 92.5t105 39q77 0 138.5 -57.5t91.5 -135t30 -151.5q0 -60 -19 -113.5t-63 -92.5t-105 -39q-76 0 -138 57.5t-92 135.5t-30 151zM884 1064 q0 74 30 151.5t91.5 135t138.5 57.5q61 0 105 -39t63 -92.5t19 -113.5q0 -73 -30 -151t-92 -135.5t-138 -57.5q-61 0 -105 39t-63 92.5t-19 113.5zM1226 581q0 74 35 152.5t100.5 134t141.5 55.5q77 0 119 -59.5t42 -139.5q0 -74 -35 -152t-100.5 -133.5t-141.5 -55.5 q-77 0 -119 59t-42 139z" />
+<glyph unicode="&#xf1b1;" horiz-adv-x="768" d="M64 1008q0 128 42.5 249.5t117.5 200t160 78.5t160 -78.5t117.5 -200t42.5 -249.5q0 -145 -57 -243.5t-152 -135.5l45 -821q2 -26 -16 -45t-44 -19h-192q-26 0 -44 19t-16 45l45 821q-95 37 -152 135.5t-57 243.5z" />
+<glyph unicode="&#xf1b2;" horiz-adv-x="1792" d="M0 256v768q0 40 23 73t61 47l704 256q22 8 44 8t44 -8l704 -256q38 -14 61 -47t23 -73v-768q0 -35 -18 -65t-49 -47l-704 -384q-28 -16 -61 -16t-61 16l-704 384q-31 17 -49 47t-18 65zM134 1026l698 -254l698 254l-698 254zM896 -93l640 349v636l-640 -233v-752z" />
+<glyph unicode="&#xf1b3;" horiz-adv-x="2304" d="M0 96v416q0 38 21.5 70t56.5 48l434 186v400q0 38 21.5 70t56.5 48l448 192q23 10 50 10t50 -10l448 -192q35 -16 56.5 -48t21.5 -70v-400l434 -186q36 -16 57 -48t21 -70v-416q0 -36 -19 -67t-52 -47l-448 -224q-25 -14 -57 -14t-57 14l-448 224q-5 2 -7 4q-2 -2 -7 -4 l-448 -224q-25 -14 -57 -14t-57 14l-448 224q-33 16 -52 47t-19 67zM172 531l404 -173l404 173l-404 173zM640 -96l384 192v314l-384 -164v-342zM647 1219l441 -189l441 189l-441 189zM1152 651l384 165v266l-384 -164v-267zM1196 531l404 -173l404 173l-404 173zM1664 -96 l384 192v314l-384 -164v-342z" />
+<glyph unicode="&#xf1b4;" horiz-adv-x="2048" d="M0 22v1260h594q87 0 155 -14t126.5 -47.5t90 -96.5t31.5 -154q0 -181 -172 -263q114 -32 172 -115t58 -204q0 -75 -24.5 -136.5t-66 -103.5t-98.5 -71t-121 -42t-134 -13h-611zM277 236h296q205 0 205 167q0 180 -199 180h-302v-347zM277 773h281q78 0 123.5 36.5 t45.5 113.5q0 144 -190 144h-260v-294zM1137 477q0 208 130.5 345.5t336.5 137.5q138 0 240.5 -68t153 -179t50.5 -248q0 -17 -2 -47h-658q0 -111 57.5 -171.5t166.5 -60.5q63 0 122 32t76 87h221q-100 -307 -427 -307q-214 0 -340.5 132t-126.5 347zM1337 1073h511v124 h-511v-124zM1388 576h408q-18 195 -200 195q-90 0 -146 -52.5t-62 -142.5z" />
+<glyph unicode="&#xf1b5;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM128 254h382q117 0 197 57.5t80 170.5q0 158 -143 200q107 52 107 164q0 57 -19.5 96.5t-56.5 60.5t-79 29.5 t-97 8.5h-371v-787zM301 388v217h189q124 0 124 -113q0 -104 -128 -104h-185zM301 723v184h163q119 0 119 -90q0 -94 -106 -94h-176zM838 538q0 -135 79 -217t213 -82q205 0 267 191h-138q-11 -34 -47.5 -54t-75.5 -20q-68 0 -104 38t-36 107h411q1 10 1 30 q0 132 -74.5 220.5t-203.5 88.5q-128 0 -210 -86t-82 -216zM964 911v77h319v-77h-319zM996 600q4 56 39 89t91 33q113 0 124 -122h-254z" />
+<glyph unicode="&#xf1b6;" horiz-adv-x="2048" d="M0 764q0 86 61 146.5t146 60.5q73 0 130 -46t73 -117l783 -315q49 29 106 29q14 0 21 -1l173 248q1 114 82 194.5t195 80.5q115 0 196.5 -81t81.5 -196t-81.5 -196.5t-196.5 -81.5l-265 -194q-8 -80 -67.5 -133.5t-138.5 -53.5q-73 0 -130 46t-73 117l-783 315 q-51 -30 -106 -30q-85 0 -146 61t-61 147zM55 764q0 -64 44.5 -108.5t107.5 -44.5q11 0 33 4l-64 26q-33 14 -52.5 44.5t-19.5 66.5q0 50 35.5 85.5t85.5 35.5q20 0 41 -8v1l76 -31q-20 37 -56.5 59t-78.5 22q-63 0 -107.5 -44.5t-44.5 -107.5zM1164 244q19 -37 55.5 -59 t79.5 -22q63 0 107.5 44.5t44.5 107.5t-44.5 108t-107.5 45q-13 0 -33 -4q2 -1 20 -8t21.5 -8.5t18.5 -8.5t19 -10t16 -11t15.5 -13.5t11 -14.5t10 -18t5 -21t2.5 -25q0 -50 -35.5 -85.5t-85.5 -35.5q-14 0 -31.5 4.5t-29 9t-31.5 13.5t-28 12zM1584 767q0 -77 54.5 -131.5 t131.5 -54.5t132 54.5t55 131.5t-55 131.5t-132 54.5q-76 0 -131 -54.5t-55 -131.5zM1623 767q0 62 43.5 105.5t104.5 43.5t105 -44t44 -105t-43.5 -104.5t-105.5 -43.5q-61 0 -104.5 43.5t-43.5 104.5z" />
+<glyph unicode="&#xf1b7;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM128 693q0 -53 38 -91t92 -38q36 0 66 18l489 -197q10 -44 45.5 -73t81.5 -29q50 0 86.5 34t41.5 83l167 122 q71 0 122 50.5t51 122.5t-51 123t-122 51q-72 0 -122.5 -50.5t-51.5 -121.5l-108 -155q-2 0 -6.5 0.5t-6.5 0.5q-35 0 -67 -19l-489 197q-10 44 -45.5 73t-80.5 29q-54 0 -92 -38t-38 -92zM162 693q0 40 28 68t68 28q27 0 49.5 -14t34.5 -37l-48 19q-29 11 -56.5 -2 t-38.5 -41q-12 -29 -0.5 -57t39.5 -40v-1l40 -16q-14 -2 -20 -2q-40 0 -68 27.5t-28 67.5zM855 369q5 -2 47 -19q29 -12 58 0.5t41 41.5q11 29 -1 57.5t-41 40.5l-40 16q14 2 21 2q39 0 67 -27.5t28 -67.5t-28 -67.5t-67 -27.5q-59 0 -85 51zM1118 695q0 48 34 82t83 34 q48 0 82 -34t34 -82t-34 -82t-82 -34q-49 0 -83 34t-34 82zM1142 696q0 -39 27.5 -66t65.5 -27t65.5 27t27.5 66q0 38 -27.5 65.5t-65.5 27.5t-65.5 -27.5t-27.5 -65.5z" />
+<glyph unicode="&#xf1b8;" horiz-adv-x="1792" d="M16 970l433 -17l180 -379l-147 92q-63 -72 -111.5 -144.5t-72.5 -125t-39.5 -94.5t-18.5 -63l-4 -21l-190 357q-17 26 -18 56t6 47l8 18q35 63 114 188zM270.5 158q-3.5 28 4 65t12 55t21.5 64t19 53q78 -12 509 -28l-15 -368l-2 -22l-420 29q-36 3 -67 31.5t-47 65.5 q-11 27 -14.5 55zM294 1124l225 356q20 31 60 45t80 10q24 -2 48.5 -12t42 -21t41.5 -33t36 -34.5t36 -39.5t32 -35q-47 -63 -265 -435l-317 187zM782 1524l405 -1q31 3 58 -10.5t39 -28.5l11 -15q39 -61 112 -190l142 83l-220 -373l-419 20l151 86q-34 89 -75 166 t-75.5 123.5t-64.5 80t-47 46.5zM953 197l211 362l7 -173q170 -16 283 -5t170 33l56 22l-188 -359q-12 -29 -36.5 -46.5t-43.5 -20.5l-18 -4q-71 -7 -219 -12l8 -164zM1218 847l313 195l19 11l212 -363q18 -37 12.5 -76t-27.5 -74q-13 -20 -33 -37t-38 -28t-48.5 -22 t-47 -16t-51.5 -14t-46 -12q-34 72 -265 436z" />
+<glyph unicode="&#xf1b9;" horiz-adv-x="1984" d="M0 160v384q0 93 65.5 158.5t158.5 65.5h28l105 419q23 94 104 157.5t179 63.5h704q98 0 179 -63.5t104 -157.5l105 -419h28q93 0 158.5 -65.5t65.5 -158.5v-384q0 -14 -9 -23t-23 -9h-128v-128q0 -80 -56 -136t-136 -56t-136 56t-56 136v128h-928v-128q0 -80 -56 -136 t-136 -56t-136 56t-56 136v128h-96q-14 0 -23 9t-9 23zM160 448q0 -66 47 -113t113 -47t113 47t47 113t-47 113t-113 47t-113 -47t-47 -113zM516 768h952l-89 357q-2 8 -14 17.5t-21 9.5h-704q-9 0 -21 -9.5t-14 -17.5zM1472 448q0 -66 47 -113t113 -47t113 47t47 113 t-47 113t-113 47t-113 -47t-47 -113z" />
+<glyph unicode="&#xf1ba;" horiz-adv-x="1984" d="M0 32v384q0 93 65.5 158.5t158.5 65.5h28l105 419q23 94 104 157.5t179 63.5h128v224q0 14 9 23t23 9h448q14 0 23 -9t9 -23v-224h64q98 0 179 -63.5t104 -157.5l105 -419h28q93 0 158.5 -65.5t65.5 -158.5v-384q0 -14 -9 -23t-23 -9h-128v-64q0 -80 -56 -136t-136 -56 t-136 56t-56 136v64h-928v-64q0 -80 -56 -136t-136 -56t-136 56t-56 136v64h-96q-14 0 -23 9t-9 23zM160 320q0 -66 47 -113t113 -47t113 47t47 113t-47 113t-113 47t-113 -47t-47 -113zM516 640h952l-89 357q-2 8 -14 17.5t-21 9.5h-704q-9 0 -21 -9.5t-14 -17.5zM1472 320 q0 -66 47 -113t113 -47t113 47t47 113t-47 113t-113 47t-113 -47t-47 -113z" />
+<glyph unicode="&#xf1bb;" d="M32 64q0 26 19 45l402 403h-229q-26 0 -45 19t-19 45t19 45l402 403h-197q-26 0 -45 19t-19 45t19 45l384 384q19 19 45 19t45 -19l384 -384q19 -19 19 -45t-19 -45t-45 -19h-197l402 -403q19 -19 19 -45t-19 -45t-45 -19h-229l402 -403q19 -19 19 -45t-19 -45t-45 -19 h-462q1 -17 6 -87.5t5 -108.5q0 -25 -18 -42.5t-43 -17.5h-320q-25 0 -43 17.5t-18 42.5q0 38 5 108.5t6 87.5h-462q-26 0 -45 19t-19 45z" />
+<glyph unicode="&#xf1bc;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM237 886q0 -31 20.5 -52t51.5 -21q11 0 40 8q133 37 307 37q159 0 309.5 -34t253.5 -95q21 -12 40 -12 q29 0 50.5 20.5t21.5 51.5q0 47 -40 70q-126 73 -293 110.5t-343 37.5q-204 0 -364 -47q-23 -7 -38.5 -25.5t-15.5 -48.5zM289 637q0 -25 17.5 -42.5t42.5 -17.5q7 0 37 8q122 33 251 33q279 0 488 -124q24 -13 38 -13q25 0 42.5 17.5t17.5 42.5q0 40 -35 61 q-237 141 -548 141q-153 0 -303 -42q-48 -13 -48 -64zM321 406q0 -20 13.5 -34.5t35.5 -14.5q5 0 37 8q132 27 243 27q226 0 397 -103q19 -11 33 -11q19 0 33 13.5t14 34.5q0 32 -30 51q-193 115 -447 115q-133 0 -287 -34q-42 -9 -42 -52z" />
+<glyph unicode="&#xf1bd;" d="M0 11v1258q0 58 40.5 98.5t98.5 40.5h1258q58 0 98.5 -40.5t40.5 -98.5v-1258q0 -58 -40.5 -98.5t-98.5 -40.5h-1258q-58 0 -98.5 40.5t-40.5 98.5zM71 11q0 -28 20 -48t48 -20h1258q28 0 48 20t20 48v1258q0 28 -20 48t-48 20h-1258q-28 0 -48 -20t-20 -48v-1258z M121 11v141l711 195l-212 439q4 1 12 2.5t12 1.5q170 32 303.5 21.5t221 -46t143.5 -94.5q27 -28 -25 -42q-64 -16 -256 -62l-97 198q-111 7 -240 -16l188 -387l533 145v-496q0 -7 -5.5 -12.5t-12.5 -5.5h-1258q-7 0 -12.5 5.5t-5.5 12.5zM121 709v560q0 7 5.5 12.5 t12.5 5.5h1258q7 0 12.5 -5.5t5.5 -12.5v-428q-85 30 -188 52q-294 64 -645 12l-18 -3l-65 134h-233l85 -190q-132 -51 -230 -137zM246 413q-24 203 166 305l129 -270l-255 -61q-14 -3 -26 4.5t-14 21.5z" />
+<glyph unicode="&#xf1be;" horiz-adv-x="2304" d="M0 405l17 128q2 9 9 9t9 -9l20 -128l-20 -126q-2 -9 -9 -9t-9 9zM79 405l23 207q0 9 9 9q8 0 10 -9l26 -207l-26 -203q-2 -9 -10 -9q-9 0 -9 10zM169 405l21 245q2 12 12 12q11 0 11 -12l25 -245l-25 -237q0 -11 -11 -11q-10 0 -12 11zM259 405l21 252q0 13 13 13 q12 0 14 -13l23 -252l-23 -244q-2 -13 -14 -13q-13 0 -13 13zM350 405l20 234q0 6 4.5 10.5t10.5 4.5q14 0 16 -15l21 -234l-21 -246q-2 -16 -16 -16q-6 0 -10.5 4.5t-4.5 11.5zM401 159zM442 405l18 380q2 18 18 18q7 0 12 -5.5t5 -12.5l21 -380l-21 -246q0 -7 -5 -12.5 t-12 -5.5q-16 0 -18 18zM534 403l16 468q2 19 20 19q8 0 13.5 -5.5t5.5 -13.5l19 -468l-19 -244q0 -8 -5.5 -13.5t-13.5 -5.5q-18 0 -20 19zM628 405l16 506q0 9 6.5 15.5t14.5 6.5q9 0 15 -6.5t7 -15.5l18 -506l-18 -242q-2 -21 -22 -21q-19 0 -21 21zM723 405l14 -241 q1 -10 7.5 -16.5t15.5 -6.5q22 0 24 23l16 241l-16 523q-1 10 -7.5 17t-16.5 7q-9 0 -16 -7t-7 -17zM784 164zM817 405l14 510q0 11 7.5 18t17.5 7t17.5 -7t7.5 -18l15 -510l-15 -239q0 -10 -7.5 -17.5t-17.5 -7.5t-17 7t-8 18zM913 404l12 492q1 12 9 20t19 8t18.5 -8 t8.5 -20l14 -492l-14 -236q0 -11 -8 -19t-19 -8t-19 8t-9 19zM1010 405q0 -1 11 -236v-1q0 -10 6 -17q9 -11 23 -11q11 0 20 9q9 7 9 20l1 24l11 211l-12 586q0 16 -13 24q-8 5 -16 5t-16 -5q-13 -8 -13 -24l-1 -6zM1079 169zM1103 404l12 636v3q2 15 12 24q9 7 20 7 q8 0 15 -5q14 -8 16 -26l14 -639l-14 -231q0 -13 -9 -22t-22 -9t-22 9t-10 22l-6 114zM1204 174v899q0 23 28 33q85 34 181 34q195 0 338 -131.5t160 -323.5q53 22 110 22q117 0 200 -83t83 -201q0 -117 -83 -199.5t-200 -82.5h-786q-13 2 -22 11t-9 22z" />
+<glyph unicode="&#xf1c0;" d="M0 0v170q119 -84 325 -127t443 -43t443 43t325 127v-170q0 -69 -103 -128t-280 -93.5t-385 -34.5t-385 34.5t-280 93.5t-103 128zM0 384v170q119 -84 325 -127t443 -43t443 43t325 127v-170q0 -69 -103 -128t-280 -93.5t-385 -34.5t-385 34.5t-280 93.5t-103 128zM0 768 v170q119 -84 325 -127t443 -43t443 43t325 127v-170q0 -69 -103 -128t-280 -93.5t-385 -34.5t-385 34.5t-280 93.5t-103 128zM0 1152v128q0 69 103 128t280 93.5t385 34.5t385 -34.5t280 -93.5t103 -128v-128q0 -69 -103 -128t-280 -93.5t-385 -34.5t-385 34.5t-280 93.5 t-103 128z" />
+<glyph unicode="&#xf1c1;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM257 60q9 40 56 91.5t132 96.5q14 9 23 -6q2 -2 2 -4 q52 85 107 197q68 136 104 262q-24 82 -30.5 159.5t6.5 127.5q11 40 42 40h21h1q23 0 35 -15q18 -21 9 -68q-2 -6 -4 -8q1 -3 1 -8v-30q-2 -123 -14 -192q55 -164 146 -238q33 -26 84 -56q59 7 117 7q147 0 177 -49q16 -22 2 -52q0 -1 -1 -2l-2 -2v-1q-6 -38 -71 -38 q-48 0 -115 20t-130 53q-221 -24 -392 -83q-153 -262 -242 -262q-15 0 -28 7l-24 12q-1 1 -6 5q-10 10 -6 36zM318 54q52 24 137 158q-51 -40 -87.5 -84t-49.5 -74zM592 313q135 54 284 81q-2 1 -13 9.5t-16 13.5q-76 67 -127 176q-27 -86 -83 -197q-30 -56 -45 -83z M714 842q1 7 7 44q0 3 7 43q1 4 4 8q-1 1 -1 2t-0.5 1.5t-0.5 1.5q-1 22 -13 36q0 -1 -1 -2v-2q-15 -42 -2 -132zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376zM1098 353q76 -28 124 -28q14 0 18 1q0 1 -2 3q-24 24 -140 24z" />
+<glyph unicode="&#xf1c2;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM233 661h70l164 -661h159l128 485q7 20 10 46q2 16 2 24 h4l3 -24q1 -3 3.5 -20t5.5 -26l128 -485h159l164 661h70v107h-300v-107h90l-99 -438q-5 -20 -7 -46l-2 -21h-4l-3 21q-1 5 -4 21t-5 25l-144 545h-114l-144 -545q-2 -9 -4.5 -24.5t-3.5 -21.5l-4 -21h-4l-2 21q-2 26 -7 46l-99 438h90v107h-300v-107zM1024 1024h376 q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c3;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM429 0h281v106h-75l103 161q5 7 10 16.5t7.5 13.5t3.5 4 h2q1 -4 5 -10q2 -4 4.5 -7.5t6 -8t6.5 -8.5l107 -161h-76v-106h291v106h-68l-192 273l195 282h67v107h-279v-107h74l-103 -159q-4 -7 -10 -16.5t-9 -13.5l-2 -3h-2q-1 4 -5 10q-6 11 -17 23l-106 159h76v107h-290v-107h68l189 -272l-194 -283h-68v-106zM1024 1024h376 q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c4;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM416 0h327v106h-93v167h137q76 0 118 15q67 23 106.5 87 t39.5 146q0 81 -37 141t-100 87q-48 19 -130 19h-368v-107h92v-555h-92v-106zM650 386v268h120q52 0 83 -18q56 -33 56 -115q0 -89 -62 -120q-31 -15 -78 -15h-119zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c5;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM256 0v192l192 192l128 -128l384 384l320 -320v-320 h-1024zM256 704q0 80 56 136t136 56t136 -56t56 -136t-56 -136t-136 -56t-136 56t-56 136zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c6;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-128v-128h-128v128h-512v-1536zM384 192q0 25 8 52q21 63 120 396 v128h128v-128h79q22 0 39 -13t23 -34l107 -349q8 -27 8 -52q0 -83 -72.5 -137.5t-183.5 -54.5t-183.5 54.5t-72.5 137.5zM512 192q0 -26 37.5 -45t90.5 -19t90.5 19t37.5 45t-37.5 45t-90.5 19t-90.5 -19t-37.5 -45zM512 896h128v128h-128v-128zM512 1152h128v128h-128v-128 zM640 768h128v128h-128v-128zM640 1024h128v128h-128v-128zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c7;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM256 288v192q0 14 9 23t23 9h131l166 167q16 15 35 7 q20 -8 20 -30v-544q0 -22 -20 -30q-8 -2 -12 -2q-12 0 -23 9l-166 167h-131q-14 0 -23 9t-9 23zM762 206.5q1 -26.5 20 -44.5q20 -17 44 -17q27 0 47 20q87 93 87 219t-87 219q-18 19 -45 20t-46 -17t-20 -44.5t18 -46.5q52 -57 52 -131t-52 -131q-19 -20 -18 -46.5z M973.5 54.5q2.5 -26.5 23.5 -42.5q18 -15 40 -15q31 0 50 24q129 159 129 363t-129 363q-16 21 -43 24t-47 -14q-21 -17 -23.5 -43.5t14.5 -47.5q100 -123 100 -282t-100 -282q-17 -21 -14.5 -47.5zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c8;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM256 256v384q0 52 38 90t90 38h384q52 0 90 -38t38 -90 v-384q0 -52 -38 -90t-90 -38h-384q-52 0 -90 38t-38 90zM960 403v90l265 266q9 9 23 9q4 0 12 -2q20 -8 20 -30v-576q0 -22 -20 -30q-8 -2 -12 -2q-14 0 -23 9zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1c9;" d="M0 -160v1600q0 40 28 68t68 28h896q40 0 88 -20t76 -48l312 -312q28 -28 48 -76t20 -88v-1152q0 -40 -28 -68t-68 -28h-1344q-40 0 -68 28t-28 68zM128 -128h1280v1024h-416q-40 0 -68 28t-28 68v416h-768v-1536zM254 429q-14 19 0 38l226 301q8 11 21 12.5t24 -6.5 l51 -38q11 -8 12.5 -21t-6.5 -24l-182 -243l182 -243q8 -11 6.5 -24t-12.5 -21l-51 -38q-11 -8 -24 -6.5t-21 12.5zM636 43l138 831q2 13 13 20.5t24 5.5l63 -10q13 -2 20.5 -13t5.5 -24l-138 -831q-2 -13 -13 -20.5t-24 -5.5l-63 10q-13 2 -20.5 13t-5.5 24zM947.5 181 q-1.5 13 6.5 24l182 243l-182 243q-8 11 -6.5 24t12.5 21l51 38q11 8 24 6.5t21 -12.5l226 -301q14 -19 0 -38l-226 -301q-8 -11 -21 -12.5t-24 6.5l-51 38q-11 8 -12.5 21zM1024 1024h376q-10 29 -22 41l-313 313q-12 12 -41 22v-376z" />
+<glyph unicode="&#xf1ca;" d="M39 1286h283q26 -218 70 -398.5t104.5 -317t121.5 -235.5t140 -195q169 169 287 406q-142 72 -223 220t-81 333q0 192 104 314.5t284 122.5q178 0 273 -105.5t95 -297.5q0 -159 -58 -286q-7 -1 -19.5 -3t-46 -2t-63 6t-62 25.5t-50.5 51.5q31 103 31 184q0 87 -29 132 t-79 45q-53 0 -85 -49.5t-32 -140.5q0 -186 105 -293.5t267 -107.5q62 0 121 14v-198q-101 -23 -198 -23q-65 -136 -165.5 -271t-181.5 -215.5t-128 -106.5q-80 -45 -162 3q-28 17 -60.5 43.5t-85 83.5t-102.5 128.5t-107.5 184t-105.5 244t-91.5 314.5t-70.5 390z" />
+<glyph unicode="&#xf1cb;" horiz-adv-x="1792" d="M0 367v546q0 41 34 64l819 546q21 13 43 13t43 -13l819 -546q34 -23 34 -64v-546q0 -41 -34 -64l-819 -546q-21 -13 -43 -13t-43 13l-819 546q-34 23 -34 64zM154 511l193 129l-193 129v-258zM216 367l603 -402v359l-334 223zM216 913l269 -180l334 223v359zM624 640 l272 -182l272 182l-272 182zM973 -35l603 402l-269 180l-334 -223v-359zM973 956l334 -223l269 180l-603 402v-359zM1445 640l193 -129v258z" />
+<glyph unicode="&#xf1cc;" horiz-adv-x="2048" d="M0 407q0 110 55 203t147 147q-12 39 -12 82q0 115 82 196t199 81q95 0 172 -58q75 154 222.5 248t326.5 94q166 0 306 -80.5t221.5 -218.5t81.5 -301q0 -6 -0.5 -18t-0.5 -18q111 -46 179.5 -145.5t68.5 -221.5q0 -164 -118 -280.5t-285 -116.5q-4 0 -11.5 0.5t-10.5 0.5 h-1209h-1h-2h-5q-170 10 -288 125.5t-118 280.5zM468 498q0 -122 84 -193t208 -71q137 0 240 99q-16 20 -47.5 56.5t-43.5 50.5q-67 -65 -144 -65q-55 0 -93.5 33.5t-38.5 87.5q0 53 38.5 87t91.5 34q44 0 84.5 -21t73 -55t65 -75t69 -82t77 -75t97 -55t121.5 -21 q121 0 204.5 71.5t83.5 190.5q0 121 -84 192t-207 71q-143 0 -241 -97q14 -16 29.5 -34t34.5 -40t29 -34q66 64 142 64q52 0 92 -33t40 -84q0 -57 -37 -91.5t-94 -34.5q-43 0 -82.5 21t-72 55t-65.5 75t-69.5 82t-77.5 75t-96.5 55t-118.5 21q-122 0 -207 -70.5t-85 -189.5z " />
+<glyph unicode="&#xf1cd;" horiz-adv-x="1792" d="M0 640q0 182 71 348t191 286t286 191t348 71t348 -71t286 -191t191 -286t71 -348t-71 -348t-191 -286t-286 -191t-348 -71t-348 71t-286 191t-191 286t-71 348zM128 640q0 -190 90 -361l194 194q-28 82 -28 167t28 167l-194 194q-90 -171 -90 -361zM512 640 q0 -159 112.5 -271.5t271.5 -112.5t271.5 112.5t112.5 271.5t-112.5 271.5t-271.5 112.5t-271.5 -112.5t-112.5 -271.5zM535 -38q171 -90 361 -90t361 90l-194 194q-82 -28 -167 -28t-167 28zM535 1318l194 -194q82 28 167 28t167 -28l194 194q-171 90 -361 90t-361 -90z M1380 473l194 -194q90 171 90 361t-90 361l-194 -194q28 -82 28 -167t-28 -167z" />
+<glyph unicode="&#xf1ce;" horiz-adv-x="1792" d="M0 640q0 222 101 414.5t276.5 317t390.5 155.5v-260q-221 -45 -366.5 -221t-145.5 -406q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5q0 230 -145.5 406t-366.5 221v260q215 -31 390.5 -155.5t276.5 -317t101 -414.5 q0 -182 -71 -348t-191 -286t-286 -191t-348 -71t-348 71t-286 191t-191 286t-71 348z" />
+<glyph unicode="&#xf1d0;" horiz-adv-x="1792" d="M19 662q8 217 116 406t305 318h5q0 -1 -1 -3q-8 -8 -28 -33.5t-52 -76.5t-60 -110.5t-44.5 -135.5t-14 -150.5t39 -157.5t108.5 -154q50 -50 102 -69.5t90.5 -11.5t69.5 23.5t47 32.5l16 16q39 51 53 116.5t6.5 122.5t-21 107t-26.5 80l-14 29q-10 25 -30.5 49.5t-43 41 t-43.5 29.5t-35 19l-13 6l104 115q39 -17 78 -52t59 -61l19 -27q1 48 -18.5 103.5t-40.5 87.5l-20 31l161 183l160 -181q-33 -46 -52.5 -102.5t-22.5 -90.5l-4 -33q22 37 61.5 72.5t67.5 52.5l28 17l103 -115q-44 -14 -85 -50t-60 -65l-19 -29q-31 -56 -48 -133.5t-7 -170 t57 -156.5q33 -45 77.5 -60.5t85 -5.5t76 26.5t57.5 33.5l21 16q60 53 96.5 115t48.5 121.5t10 121.5t-18 118t-37 107.5t-45.5 93t-45 72t-34.5 47.5l-13 17q-14 13 -7 13l10 -3q40 -29 62.5 -46t62 -50t64 -58t58.5 -65t55.5 -77t45.5 -88t38 -103t23.5 -117t10.5 -136 q3 -259 -108 -465t-312 -321t-456 -115q-185 0 -351 74t-283.5 198t-184 293t-60.5 353z" />
+<glyph unicode="&#xf1d1;" horiz-adv-x="1792" d="M0 640q0 182 71 348t191 286t286 191t348 71t348 -71t286 -191t191 -286t71 -348t-71 -348t-191 -286t-286 -191t-348 -71t-348 71t-286 191t-191 286t-71 348zM44 640q0 -173 67.5 -331t181.5 -272t272 -181.5t331 -67.5t331 67.5t272 181.5t181.5 272t67.5 331 t-67.5 331t-181.5 272t-272 181.5t-331 67.5t-331 -67.5t-272 -181.5t-181.5 -272t-67.5 -331zM87 640q0 205 98 385l57 -33q-30 -56 -49 -112l82 -28q-35 -100 -35 -212q0 -109 36 -212l-83 -28q22 -60 49 -112l-57 -33q-98 180 -98 385zM206 217l58 34q29 -49 73 -99 l65 57q148 -168 368 -212l-17 -86q65 -12 121 -13v-66q-208 6 -385 109.5t-283 275.5zM207 1063q106 172 282 275.5t385 109.5v-66q-65 -2 -121 -13l17 -86q-220 -42 -368 -211l-65 56q-38 -42 -73 -98zM415 805q33 93 99 169l185 -162q59 68 147 86l-48 240q44 10 98 10 t98 -10l-48 -240q88 -18 147 -86l185 162q66 -76 99 -169l-233 -80q14 -42 14 -85t-14 -85l232 -80q-31 -92 -98 -169l-185 162q-57 -67 -147 -85l48 -241q-52 -10 -98 -10t-98 10l48 241q-90 18 -147 85l-185 -162q-67 77 -98 169l232 80q-14 42 -14 85t14 85zM918 -102 q56 1 121 13l-17 86q220 44 368 212l65 -57q44 50 73 99l58 -34q-106 -172 -283 -275.5t-385 -109.5v66zM918 1382v66q209 -6 385 -109.5t282 -275.5l-57 -33q-35 56 -73 98l-65 -56q-148 169 -368 211l17 86q-56 11 -121 13zM1516 428q36 103 36 212q0 112 -35 212l82 28 q-19 56 -49 112l57 33q98 -180 98 -385t-98 -385l-57 33q27 52 49 112z" />
+<glyph unicode="&#xf1d2;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 218q0 -45 20 -78.5t54 -51t72 -25.5t81 -8q224 0 224 188q0 67 -48 99t-126 46q-27 5 -51.5 20.5 t-24.5 39.5q0 44 49 52q77 15 122 70t45 134q0 24 -10 52q37 9 49 13v125q-78 -29 -135 -29q-50 29 -110 29q-86 0 -145 -57t-59 -143q0 -50 29.5 -102t73.5 -67v-3q-38 -17 -38 -85q0 -53 41 -77v-3q-113 -37 -113 -139zM382 225q0 64 98 64q102 0 102 -61q0 -66 -93 -66 q-107 0 -107 63zM395 693q0 90 77 90q36 0 55 -25.5t19 -63.5q0 -85 -74 -85q-77 0 -77 84zM755 1072q0 -36 25 -62.5t60 -26.5t59.5 27t24.5 62q0 36 -24 63.5t-60 27.5t-60.5 -27t-24.5 -64zM771 350h137q-2 27 -2 82v387q0 46 2 69h-137q3 -23 3 -71v-392q0 -50 -3 -75z M966 771q36 3 37 3q3 0 11 -0.5t12 -0.5v-2h-2v-217q0 -37 2.5 -64t11.5 -56.5t24.5 -48.5t43.5 -31t66 -12q64 0 108 24v121q-30 -21 -68 -21q-53 0 -53 82v225h52q9 0 26.5 -1t26.5 -1v117h-105q0 82 3 102h-140q4 -24 4 -55v-47h-60v-117z" />
+<glyph unicode="&#xf1d3;" horiz-adv-x="1792" d="M68 7q0 165 182 225v4q-67 41 -67 126q0 109 63 137v4q-72 24 -119.5 108.5t-47.5 165.5q0 139 95 231.5t235 92.5q96 0 178 -47q98 0 218 47v-202q-36 -12 -79 -22q16 -43 16 -84q0 -127 -73 -216.5t-197 -112.5q-40 -8 -59.5 -27t-19.5 -58q0 -31 22.5 -51.5t58 -32 t78.5 -22t86 -25.5t78.5 -37.5t58 -64t22.5 -98.5q0 -304 -363 -304q-69 0 -130 12.5t-116 41t-87.5 82t-32.5 127.5zM272 18q0 -101 172 -101q151 0 151 105q0 100 -165 100q-158 0 -158 -104zM293 775q0 -135 124 -135q119 0 119 137q0 61 -30 102t-89 41 q-124 0 -124 -145zM875 1389q0 59 39.5 103t98.5 44q58 0 96.5 -44.5t38.5 -102.5t-39 -101.5t-96 -43.5q-58 0 -98 43.5t-40 101.5zM901 220q4 45 4 134v609q0 94 -4 128h222q-4 -33 -4 -124v-613q0 -89 4 -134h-222zM1217 901v190h96v76q0 54 -6 89h227q-6 -41 -6 -165 h171v-190q-15 0 -43.5 2t-42.5 2h-85v-365q0 -131 87 -131q61 0 109 33v-196q-71 -39 -174 -39q-62 0 -107 20t-70 50t-39.5 78t-18.5 92t-4 103v351h2v4q-7 0 -19 1t-18 1q-21 0 -59 -6z" />
+<glyph unicode="&#xf1d4;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM368 1135l323 -589v-435h134v436l343 588h-150q-21 -39 -63.5 -118.5t-68 -128.5t-59.5 -118.5t-60 -128.5h-3 q-21 48 -44.5 97t-52 105.5t-46.5 92t-54 104.5t-49 95h-150z" />
+<glyph unicode="&#xf1d5;" horiz-adv-x="1280" d="M57 953q0 119 46.5 227t124.5 186t186 124t226 46q158 0 292.5 -78t212.5 -212.5t78 -292.5t-78 -292t-212.5 -212t-292.5 -78q-64 0 -131 14q-21 5 -32.5 23.5t-6.5 39.5q5 20 23 31.5t39 7.5q51 -13 108 -13q97 0 186 38t153 102t102 153t38 186t-38 186t-102 153 t-153 102t-186 38t-186 -38t-153 -102t-102 -153t-38 -186q0 -114 52 -218q10 -20 3.5 -40t-25.5 -30t-39.5 -3t-30.5 26q-64 123 -64 265zM113.5 38.5q10.5 121.5 29.5 217t54 186t69 155.5t74 125q61 90 132 165q-16 35 -16 77q0 80 56.5 136.5t136.5 56.5t136.5 -56.5 t56.5 -136.5t-57 -136.5t-136 -56.5q-60 0 -111 35q-62 -67 -115 -146q-247 -371 -202 -859q1 -22 -12.5 -38.5t-34.5 -18.5h-5q-20 0 -35 13.5t-17 33.5q-14 126 -3.5 247.5z" />
+<glyph unicode="&#xf1d6;" horiz-adv-x="1792" d="M18 264q0 275 252 466q-8 19 -8 52q0 20 11 49t24 45q-1 22 7.5 53t22.5 43q0 139 92.5 288.5t217.5 209.5q139 66 324 66q133 0 266 -55q49 -21 90 -48t71 -56t55 -68t42 -74t32.5 -84.5t25.5 -89.5t22 -98l1 -5q55 -83 55 -150q0 -14 -9 -40t-9 -38q0 -1 1.5 -3.5 t3.5 -5t2 -3.5q77 -114 120.5 -214.5t43.5 -208.5q0 -43 -19.5 -100t-55.5 -57q-9 0 -19.5 7.5t-19 17.5t-19 26t-16 26.5t-13.5 26t-9 17.5q-1 1 -3 1l-5 -4q-59 -154 -132 -223q20 -20 61.5 -38.5t69 -41.5t35.5 -65q-2 -4 -4 -16t-7 -18q-64 -97 -302 -97q-53 0 -110.5 9 t-98 20t-104.5 30q-15 5 -23 7q-14 4 -46 4.5t-40 1.5q-41 -45 -127.5 -65t-168.5 -20q-35 0 -69 1.5t-93 9t-101 20.5t-74.5 40t-32.5 64q0 40 10 59.5t41 48.5q11 2 40.5 13t49.5 12q4 0 14 2q2 2 2 4l-2 3q-48 11 -108 105.5t-73 156.5l-5 3q-4 0 -12 -20 q-18 -41 -54.5 -74.5t-77.5 -37.5h-1q-4 0 -6 4.5t-5 5.5q-23 54 -23 100z" />
+<glyph unicode="&#xf1d7;" horiz-adv-x="2048" d="M0 858q0 169 97.5 311t264 223.5t363.5 81.5q176 0 332.5 -66t262 -182.5t136.5 -260.5q-31 4 -70 4q-169 0 -311 -77t-223.5 -208.5t-81.5 -287.5q0 -78 23 -152q-35 -3 -68 -3q-26 0 -50 1.5t-55 6.5t-44.5 7t-54.5 10.5t-50 10.5l-253 -127l72 218q-290 203 -290 490z M380 1075q0 -39 33 -64.5t76 -25.5q41 0 66 24.5t25 65.5t-25 66t-66 25q-43 0 -76 -25.5t-33 -65.5zM816 404q0 143 81.5 264t223.5 191.5t311 70.5q161 0 303 -70.5t227.5 -192t85.5 -263.5q0 -117 -68.5 -223.5t-185.5 -193.5l55 -181l-199 109q-150 -37 -218 -37 q-169 0 -311 70.5t-223.5 191.5t-81.5 264zM888 1075q0 -39 33 -64.5t76 -25.5q41 0 65.5 24.5t24.5 65.5t-24.5 66t-65.5 25q-43 0 -76 -25.5t-33 -65.5zM1160 568q0 -28 22.5 -50.5t49.5 -22.5q40 0 65.5 22t25.5 51q0 28 -25.5 50t-65.5 22q-27 0 -49.5 -22.5 t-22.5 -49.5zM1559 568q0 -28 22.5 -50.5t49.5 -22.5q39 0 65 22t26 51q0 28 -26 50t-65 22q-27 0 -49.5 -22.5t-22.5 -49.5z" />
+<glyph unicode="&#xf1d8;" horiz-adv-x="1792" d="M0 508q-2 40 32 59l1664 960q15 9 32 9q20 0 36 -11q33 -24 27 -64l-256 -1536q-5 -29 -32 -45q-14 -8 -31 -8q-11 0 -24 5l-453 185l-242 -295q-18 -23 -49 -23q-13 0 -22 4q-19 7 -30.5 23.5t-11.5 36.5v349l864 1059l-1069 -925l-395 162q-37 14 -40 55z" />
+<glyph unicode="&#xf1d9;" horiz-adv-x="1792" d="M0 508q-3 39 32 59l1664 960q35 21 68 -2q33 -24 27 -64l-256 -1536q-5 -29 -32 -45q-14 -8 -31 -8q-11 0 -24 5l-527 215l-298 -327q-18 -21 -47 -21q-14 0 -23 4q-19 7 -30 23.5t-11 36.5v452l-472 193q-37 14 -40 55zM209 522l336 -137l863 639l-478 -797l492 -201 l221 1323z" />
+<glyph unicode="&#xf1da;" d="M0 832v448q0 42 40 59q39 17 69 -14l130 -129q107 101 244.5 156.5t284.5 55.5q156 0 298 -61t245 -164t164 -245t61 -298t-61 -298t-164 -245t-245 -164t-298 -61q-172 0 -327 72.5t-264 204.5q-7 10 -6.5 22.5t8.5 20.5l137 138q10 9 25 9q16 -2 23 -12 q73 -95 179 -147t225 -52q104 0 198.5 40.5t163.5 109.5t109.5 163.5t40.5 198.5t-40.5 198.5t-109.5 163.5t-163.5 109.5t-198.5 40.5q-98 0 -188 -35.5t-160 -101.5l137 -138q31 -30 14 -69q-17 -40 -59 -40h-448q-26 0 -45 19t-19 45zM512 480v64q0 14 9 23t23 9h224v352 q0 14 9 23t23 9h64q14 0 23 -9t9 -23v-448q0 -14 -9 -23t-23 -9h-320q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf1db;" d="M0 640q0 209 103 385.5t279.5 279.5t385.5 103t385.5 -103t279.5 -279.5t103 -385.5t-103 -385.5t-279.5 -279.5t-385.5 -103t-385.5 103t-279.5 279.5t-103 385.5zM128 640q0 -130 51 -248.5t136.5 -204t204 -136.5t248.5 -51t248.5 51t204 136.5t136.5 204t51 248.5 t-51 248.5t-136.5 204t-204 136.5t-248.5 51t-248.5 -51t-204 -136.5t-136.5 -204t-51 -248.5z" />
+<glyph unicode="&#xf1dc;" horiz-adv-x="1792" d="M62 1338q0 26 12 48t36 22q46 0 138.5 -3.5t138.5 -3.5q42 0 126.5 3.5t126.5 3.5q25 0 37.5 -22t12.5 -48q0 -30 -17 -43.5t-38.5 -14.5t-49.5 -4t-43 -13q-35 -21 -35 -160l1 -320q0 -21 1 -32q13 -3 39 -3h699q25 0 38 3q1 11 1 32l1 320q0 139 -35 160 q-18 11 -58.5 12.5t-66 13t-25.5 49.5q0 26 12.5 48t37.5 22q44 0 132 -3.5t132 -3.5q43 0 129 3.5t129 3.5q25 0 37.5 -22t12.5 -48q0 -30 -17.5 -44t-40 -14.5t-51.5 -3t-44 -12.5q-35 -23 -35 -161l1 -943q0 -119 34 -140q16 -10 46 -13.5t53.5 -4.5t41.5 -15.5t18 -44.5 q0 -26 -12 -48t-36 -22q-44 0 -132.5 3.5t-133.5 3.5q-44 0 -132 -3.5t-132 -3.5q-24 0 -37 20.5t-13 45.5q0 31 17 46t39 17t51 7t45 15q33 21 33 140l-1 391q0 21 -1 31q-13 4 -50 4h-675q-38 0 -51 -4q-1 -10 -1 -31l-1 -371q0 -142 37 -164q16 -10 48 -13t57 -3.5 t45 -15t20 -45.5q0 -26 -12.5 -48t-36.5 -22q-47 0 -139.5 3.5t-138.5 3.5q-43 0 -128 -3.5t-127 -3.5q-23 0 -35.5 21t-12.5 45q0 30 15.5 45t36 17.5t47.5 7.5t42 15q33 23 33 143l-1 57v813q0 3 0.5 26t0 36.5t-1.5 38.5t-3.5 42t-6.5 36.5t-11 31.5t-16 18 q-15 10 -45 12t-53 2t-41 14t-18 45z" />
+<glyph unicode="&#xf1dd;" horiz-adv-x="1280" d="M24 926q0 166 88 286q88 118 209 159q111 37 417 37h479q25 0 43 -18t18 -43v-73q0 -29 -18.5 -61t-42.5 -32q-50 0 -54 -1q-26 -6 -32 -31q-3 -11 -3 -64v-1152q0 -25 -18 -43t-43 -18h-108q-25 0 -43 18t-18 43v1218h-143v-1218q0 -25 -17.5 -43t-43.5 -18h-108 q-26 0 -43.5 18t-17.5 43v496q-147 12 -245 59q-126 58 -192 179q-64 117 -64 259z" />
+<glyph unicode="&#xf1de;" d="M0 736v64q0 40 28 68t68 28h320q40 0 68 -28t28 -68v-64q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM128 -96v672h256v-672q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM128 960v416q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-416h-256zM512 224v64q0 40 28 68 t68 28h320q40 0 68 -28t28 -68v-64q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM640 64h256v-160q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23v160zM640 448v928q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-928h-256zM1024 992v64q0 40 28 68t68 28h320q40 0 68 -28 t28 -68v-64q0 -40 -28 -68t-68 -28h-320q-40 0 -68 28t-28 68zM1152 -96v928h256v-928q0 -14 -9 -23t-23 -9h-192q-14 0 -23 9t-9 23zM1152 1216v160q0 14 9 23t23 9h192q14 0 23 -9t9 -23v-160h-256z" />
+<glyph unicode="&#xf1e0;" d="M0 640q0 133 93.5 226.5t226.5 93.5q126 0 218 -86l360 180q-2 22 -2 34q0 133 93.5 226.5t226.5 93.5t226.5 -93.5t93.5 -226.5t-93.5 -226.5t-226.5 -93.5q-126 0 -218 86l-360 -180q2 -22 2 -34t-2 -34l360 -180q92 86 218 86q133 0 226.5 -93.5t93.5 -226.5 t-93.5 -226.5t-226.5 -93.5t-226.5 93.5t-93.5 226.5q0 12 2 34l-360 180q-92 -86 -218 -86q-133 0 -226.5 93.5t-93.5 226.5z" />
+<glyph unicode="&#xf1e1;" d="M0 160v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5zM256 640q0 -88 62.5 -150.5t150.5 -62.5q83 0 145 57l241 -120q-2 -16 -2 -23q0 -88 63 -150.5t151 -62.5 t150.5 62.5t62.5 150.5t-62.5 151t-150.5 63q-84 0 -145 -58l-241 120q2 16 2 23t-2 23l241 120q61 -58 145 -58q88 0 150.5 63t62.5 151t-62.5 150.5t-150.5 62.5t-151 -62.5t-63 -150.5q0 -7 2 -23l-241 -120q-62 57 -145 57q-88 0 -150.5 -62.5t-62.5 -150.5z" />
+<glyph unicode="&#xf1e2;" horiz-adv-x="1792" d="M0 448q0 143 55.5 273.5t150 225t225 150t273.5 55.5q182 0 343 -89l64 64q19 19 45.5 19t45.5 -19l68 -68l243 244l46 -46l-244 -243l68 -68q19 -19 19 -45.5t-19 -45.5l-64 -64q89 -161 89 -343q0 -143 -55.5 -273.5t-150 -225t-225 -150t-273.5 -55.5t-273.5 55.5 t-225 150t-150 225t-55.5 273.5zM170 615q10 -24 35 -34q13 -5 24 -5q42 0 60 40q34 84 98.5 148.5t148.5 98.5q25 11 35 35t0 49t-34 35t-49 0q-108 -44 -191 -127t-127 -191q-10 -25 0 -49zM1376 1472q0 13 9 23q10 9 23 9t23 -9l90 -91q10 -9 10 -22.5t-10 -22.5 q-10 -10 -22 -10q-13 0 -23 10l-91 90q-9 10 -9 23zM1536 1408v96q0 14 9 23t23 9t23 -9t9 -23v-96q0 -14 -9 -23t-23 -9t-23 9t-9 23zM1605 1242.5q0 13.5 10 22.5q9 10 22.5 10t22.5 -10l91 -90q9 -10 9 -23t-9 -23q-11 -9 -23 -9t-23 9l-90 91q-10 9 -10 22.5z M1605 1381.5q0 13.5 10 22.5l90 91q10 9 23 9t23 -9q9 -10 9 -23t-9 -23l-91 -90q-10 -10 -22 -10q-13 0 -23 10q-10 9 -10 22.5zM1632 1312q0 14 9 23t23 9h96q14 0 23 -9t9 -23t-9 -23t-23 -9h-96q-14 0 -23 9t-9 23z" />
+<glyph unicode="&#xf1e3;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e4;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e5;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e6;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e7;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e8;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1e9;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1ea;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1eb;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1ec;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1ed;" horiz-adv-x="1792" />
+<glyph unicode="&#xf1ee;" horiz-adv-x="1792" />
 <glyph unicode="&#xf500;" horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
+<glyph horiz-adv-x="1792" />
 </font>
 </defs></svg> 
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.ttf b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.ttf
index e89738de5ea..5cd6cff6d6f 100755
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.ttf
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.ttf
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.woff b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.woff
index 8c1748aab7a..9eaecb37996 100755
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.woff
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome/fontawesome-webfont.woff
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/OFL.txt b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/OFL.txt
deleted file mode 100755
index 02c8c8ee82d..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/OFL.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-Copyright (c) 2012, Carrois Type Design, Ralph du Carrois (post@carrois.com www.carrois.com), with Reserved Font Name 'Share'

-This Font Software is licensed under the SIL Open Font License, Version 1.1.

-This license is copied below, and is also available with a FAQ at:

-http://scripts.sil.org/OFL

-

-

------------------------------------------------------------

-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007

------------------------------------------------------------

-

-PREAMBLE

-The goals of the Open Font License (OFL) are to stimulate worldwide

-development of collaborative font projects, to support the font creation

-efforts of academic and linguistic communities, and to provide a free and

-open framework in which fonts may be shared and improved in partnership

-with others.

-

-The OFL allows the licensed fonts to be used, studied, modified and

-redistributed freely as long as they are not sold by themselves. The

-fonts, including any derivative works, can be bundled, embedded, 

-redistributed and/or sold with any software provided that any reserved

-names are not used by derivative works. The fonts and derivatives,

-however, cannot be released under any other type of license. The

-requirement for fonts to remain under this license does not apply

-to any document created using the fonts or their derivatives.

-

-DEFINITIONS

-"Font Software" refers to the set of files released by the Copyright

-Holder(s) under this license and clearly marked as such. This may

-include source files, build scripts and documentation.

-

-"Reserved Font Name" refers to any names specified as such after the

-copyright statement(s).

-

-"Original Version" refers to the collection of Font Software components as

-distributed by the Copyright Holder(s).

-

-"Modified Version" refers to any derivative made by adding to, deleting,

-or substituting -- in part or in whole -- any of the components of the

-Original Version, by changing formats or by porting the Font Software to a

-new environment.

-

-"Author" refers to any designer, engineer, programmer, technical

-writer or other person who contributed to the Font Software.

-

-PERMISSION & CONDITIONS

-Permission is hereby granted, free of charge, to any person obtaining

-a copy of the Font Software, to use, study, copy, merge, embed, modify,

-redistribute, and sell modified and unmodified copies of the Font

-Software, subject to the following conditions:

-

-1) Neither the Font Software nor any of its individual components,

-in Original or Modified Versions, may be sold by itself.

-

-2) Original or Modified Versions of the Font Software may be bundled,

-redistributed and/or sold with any software, provided that each copy

-contains the above copyright notice and this license. These can be

-included either as stand-alone text files, human-readable headers or

-in the appropriate machine-readable metadata fields within text or

-binary files as long as those fields can be easily viewed by the user.

-

-3) No Modified Version of the Font Software may use the Reserved Font

-Name(s) unless explicit written permission is granted by the corresponding

-Copyright Holder. This restriction only applies to the primary font name as

-presented to the users.

-

-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font

-Software shall not be used to promote, endorse or advertise any

-Modified Version, except to acknowledge the contribution(s) of the

-Copyright Holder(s) and the Author(s) or with their explicit written

-permission.

-

-5) The Font Software, modified or unmodified, in part or in whole,

-must be distributed entirely under this license, and must not be

-distributed under any other license. The requirement for fonts to

-remain under this license does not apply to any document created

-using the Font Software.

-

-TERMINATION

-This license becomes null and void if any of the above conditions are

-not met.

-

-DISCLAIMER

-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF

-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT

-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE

-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL

-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM

-OTHER DEALINGS IN THE FONT SOFTWARE.

diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/ShareTechMono-Regular.ttf b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/ShareTechMono-Regular.ttf
deleted file mode 100755
index 8e6e84bfbd3..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Share_Tech_Mono/ShareTechMono-Regular.ttf
+++ /dev/null
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/composer.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/composer.js
index f1f95339a61..7ddb0c8d01d 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/composer.js
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/composer.js
@@ -6,7 +6,7 @@ var composer = {
 		if (!scope.title || typeof scope.depth === 'undefined')
 			return false;
 
-		return scope.title.indexOf("Test") === 0 && scope.depth == 0;
+		return scope.title.indexOf("Test") === 0 && scope.depth === 0;
 	},
 	discardLastKey: false
 };
@@ -31,8 +31,8 @@ $(function()
 	$('#input').keydown(function(e)
 	{
 		// 13=Enter, 16=Shift
-		composer.discardLastKey = e.keyCode == 13
-								|| e.keyCode == 16;
+		composer.discardLastKey = e.keyCode === 13
+								|| e.keyCode === 16;
 	}).keyup(function(e)
 	{
 		if (!composer.discardLastKey)
@@ -50,7 +50,7 @@ $(function()
 // Begin Markup.js custom pipes
 Mark.pipes.recursivelyRender = function(val)
 {
-	return !val || val.length == 0 ? "\n" : Mark.up(composer.template, val);
+	return !val || val.length === 0 ? "\n" : Mark.up(composer.template, val);
 }
 
 Mark.pipes.indent = function(val)
@@ -70,9 +70,9 @@ Mark.pipes.safeFunc = function(val)
 
 Mark.pipes.properCase = function(str)
 {
-	if (str.length == 0)
+	if (str.length === 0)
 		return "";
-	
+
 	str = str.charAt(0).toUpperCase() + str.substr(1);
 
 	if (str.length < 2)
@@ -89,7 +89,7 @@ Mark.pipes.properCase = function(str)
 Mark.pipes.showImports = function(item)
 {
 	console.log(item);
-	if (root.title == "(root)" && root.stories.length > 0)
+	if (root.title === "(root)" && root.stories.length > 0)
 		return 'import (\n\t"testing"\n\t. "github.com/smartystreets/goconvey/convey"\n)\n';
 	else
 		return "";
@@ -101,14 +101,14 @@ function generate(input)
 {
 	var root = parseInput(input);
 	$('#output').text(Mark.up(composer.template, root.stories));
-	if (root.stories.length > 0 && root.stories[0].title.substr(0, 4) == "Test")
+	if (root.stories.length > 0 && root.stories[0].title.substr(0, 4) === "Test")
 		$('#output').prepend('import (\n\t"testing"\n\t. "github.com/smartystreets/goconvey/convey"\n)\n\n');
 }
 
 function parseInput(input)
 {
 	lines = input.split("\n");
-	
+
 	if (!lines)
 		return;
 
@@ -136,7 +136,7 @@ function parseInput(input)
 			curScope = curScope.stories[curScope.stories.length - 1];
 			prevScope = curScope;
 		}
-		
+
 		// Don't go crazy, though! (avoid excessive indentation)
 		if (tabs > curScope.depth + 1)
 			tabs = curScope.depth + 1;
@@ -144,7 +144,7 @@ function parseInput(input)
 		// Only top-level Convey() calls need the *testing.T object passed in
 		var showT = composer.isFunc(prevScope)
 					|| (!composer.isFunc(curScope)
-							&& tabs == 0);
+							&& tabs === 0);
 
 		// Save the story at this scope
 		curScope.stories.push({
@@ -168,4 +168,4 @@ function suppress(event)
 		event.stopPropagation();
 	event.cancelBubble = true;
 	return false;
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/config.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/config.js
index 963b013be09..0ca1e457bd4 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/config.js
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/config.js
@@ -4,11 +4,12 @@ convey.config = {
 
 	// Install new themes by adding them here; the first one will be default
 	themes: {
-		"dark": { name: "Dark", filename: "dark.css", coverage: "hsla({{hue}}, 75%, 30%, .5)" },
-		"light": { name: "Light", filename: "light.css", coverage: "hsla({{hue}}, 62%, 75%, 1)" }
+		"dark":         { name: "Dark", filename: "dark.css", coverage: "hsla({{hue}}, 75%, 30%, .5)" },
+		"dark-bigtext": { name: "Dark-BigText", filename: "dark-bigtext.css", coverage: "hsla({{hue}}, 75%, 30%, .5)" },
+		"light":        { name: "Light", filename: "light.css", coverage: "hsla({{hue}}, 62%, 75%, 1)" }
 	},
 
 	// Path to the themes (end with forward-slash)
 	themePath: "/resources/css/themes/"
-	
-};
\ No newline at end of file
+
+};
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/convey.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/convey.js
index ebdfe1bd536..b4e6b525eca 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/convey.js
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/convey.js
@@ -17,6 +17,7 @@ var convey = {
 	overallClass: "",		// class name of the "overall" status banner
 	theme: "",				// theme currently being used
 	packageStates: {},		// packages manually collapsed or expanded during this page's lifetime
+	uiEffects: true,		// whether visual effects are enabled
 	framesOnSamePath: 0,	// number of consecutive frames on this same watch path
 	layout: {
 		selClass: "sel",	// CSS class when an element is "selected"
@@ -27,7 +28,7 @@ var convey = {
 	history: [],			// complete history of states (test results and aggregated data), including the current one
 	moments: {},			// elements that display time relative to the current time, keyed by ID, with the moment() as a value
 	intervals: {},			// ntervals that execute periodically
-	intervalFuncs: {		// Functions executed by each interval in convey.intervals
+	intervalFuncs: {		// functions executed by each interval in convey.intervals
 		time: function()
 		{
 			var t = new Date();
@@ -42,4 +43,4 @@ var convey = {
 				$('#'+id).html(convey.moments[id].fromNow());
 		}
 	}
-};
\ No newline at end of file
+};
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/goconvey.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/goconvey.js
index d865efbe296..3bc12c5a7cd 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/goconvey.js
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/goconvey.js
@@ -3,7 +3,8 @@ $(init);
 $(window).load(function()
 {
 	// Things may shift after all the elements (images/fonts) are loaded
-	reframe();
+	// In Chrome, calling reframe() doesn't work (maybe a quirk); we need to trigger resize
+	$(window).resize();
 });
 
 function init()
@@ -42,7 +43,7 @@ function loadTheme(thmID)
 	var fullPath = convey.config.themePath
 					+ convey.config.themes[convey.theme].filename;
 
-	if (linkTag.length == 0)
+	if (linkTag.length === 0)
 	{
 		$('head').append('<link rel="stylesheet" href="'
 			+ fullPath + '" id="themeRef">');
@@ -65,15 +66,15 @@ function initPoller()
 
 	$(convey.poller).on('pollsuccess', function(event, data)
 	{
-		if (convey.status != "starting")
+		if (convey.status !== "starting")
 			hideServerDown();
 
 		// These two if statements determine if the server is now busy
 		// (and wasn't before) or is not busy (regardless of whether it was before)
-		if ((!convey.status || convey.status == "idle")
-				&& data.status && data.status != "idle")
+		if ((!convey.status || convey.status === "idle")
+				&& data.status && data.status !== "idle")
 			$('#run-tests').addClass('spin-slowly disabled');
-		else if (convey.status != "idle" && data.status == "idle")
+		else if (convey.status !== "idle" && data.status === "idle")
 		{
 			$('#run-tests').removeClass('spin-slowly disabled');
 		}
@@ -101,6 +102,7 @@ function initPoller()
 	$(convey.poller).on('serverexec', function(event, data)
 	{
 		log("Server status: executing");
+		$('.favicon').attr('href', '/favicon.ico');	// indicates running tests
 	});
 
 	$(convey.poller).on('serveridle', function(event, data)
@@ -130,7 +132,7 @@ function wireup()
 
 	$('#stories').on('click', '.toggle-all-pkg', function(event)
 	{
-		if ($(this).closest('.story-pkg').data('pkg-state') == "expanded")
+		if ($(this).closest('.story-pkg').data('pkg-state') === "expanded")
 			collapseAll();
 		else
 			expandAll();
@@ -147,7 +149,7 @@ function wireup()
 		var newSetting = $(this).data('pkg-expand-collapse');
 		convey.packageStates = {};
 		save('pkg-expand-collapse', newSetting);
-		if (newSetting == "expanded")
+		if (newSetting === "expanded")
 			expandAll();
 		else
 			collapseAll();
@@ -156,11 +158,17 @@ function wireup()
 	{
 		var newSetting = $(this).data('show-debug-output');
 		save('show-debug-output', newSetting);
-		if (newSetting == "show")
+		if (newSetting === "show")
 			$('.story-line-desc .message').show();
 		else
 			$('.story-line-desc .message').hide();
 	});
+	$('.enum#ui-effects').on('click', 'li:not(.sel)', function()
+	{
+		var newSetting = $(this).data('ui-effects');
+		convey.uiEffects = newSetting;
+		save('ui-effects', newSetting);
+	});
 	// End settings wireup
 
 	convey.layout.header = $('header').first();
@@ -254,6 +262,7 @@ function wireup()
 	$('footer .replay').tipsy({ live: true, gravity: 'e' });
 	$('#path').tipsy({ delayIn: 500 });
 	$('.ignore').tipsy({ live: true, gravity: $.fn.tipsy.autoNS });
+	$('.disabled').tipsy({ live: true, gravity: $.fn.tipsy.autoNS });
 	$('#logo').tipsy({ gravity: 'w' });
 
 
@@ -353,7 +362,7 @@ function wireup()
 	});
 
 	// Keyboard shortcuts!
-	$(document).keyup(function(e)
+	$(document).keydown(function(e)
 	{
 		if (e.ctrlKey || e.metaKey || e.shiftKey)
 			return;
@@ -379,11 +388,11 @@ function wireup()
 
 		return suppress(e);
 	});
-	$('body').on('keyup', 'input, textarea, select', function(e)
+	$('body').on('keydown', 'input, textarea, select', function(e)
 	{
 		// If user is typing something, don't let this event bubble
 		// up to the document to annoyingly fire keyboard shortcuts
-		suppress(e);
+		e.stopPropagation();
 	});
 
 	// Keep everything positioned and sized properly on window resize
@@ -432,7 +441,7 @@ function collapsePackage(pkgId)
 function togglePackage(storyPkgElem)
 {
 	var pkgId = $(storyPkgElem).data('pkg');
-	if ($(storyPkgElem).data('pkg-state') == "expanded")
+	if ($(storyPkgElem).data('pkg-state') === "expanded")
 	{
 		collapsePackage(pkgId);
 		convey.packageStates[$(storyPkgElem).data('pkg-name')] = "collapsed";
@@ -462,6 +471,12 @@ function loadSettingsFromStorage()
 	}
 	enumSel("show-debug-output", showDebugOutput);
 
+	var uiEffects = get("ui-effects");
+	if (uiEffects === null)
+		uiEffects = "true";
+	convey.uiEffects = uiEffects === "true";
+	enumSel("ui-effects", uiEffects);
+
 	if (notif())
 		$('#toggle-notif').toggleClass("fa-bell-o fa-bell " + convey.layout.selClass);
 }
@@ -497,7 +512,7 @@ function process(data, status, jqxhr)
 		$('#play-pause').toggleClass("throb " + convey.layout.selClass);
 	}
 
-	if (current() && data.Revision == current().results.Revision)
+	if (current() && data.Revision === current().results.Revision)
 	{
 		log("No changes");
 		changeStatus(current().overall.status);	// re-assures that status is unchanged
@@ -524,6 +539,7 @@ function process(data, status, jqxhr)
 	var coverageAvgHelper = { countedPackages: 0, coverageSum: 0 };
 	var packages = {
 		tested: [],
+		ignored: [],
 		coverage: {},
 		nogofiles: [],
 		notestfiles: [],
@@ -539,7 +555,7 @@ function process(data, status, jqxhr)
 		current().overall.duration += pkg.Elapsed;
 		pkg._id = uniqueID++;
 
-		if (pkg.Outcome == "build failure")
+		if (pkg.Outcome === "build failure")
 		{
 			current().overall.failedBuilds++;
 			current().failedBuilds.push(pkg);
@@ -547,12 +563,14 @@ function process(data, status, jqxhr)
 		}
 
 
-		if (pkg.Outcome == "no go code")
+		if (pkg.Outcome === "no go code")
 			packages.nogofiles.push(pkg);
-		else if (pkg.Outcome == "no test files")
+		else if (pkg.Outcome === "no test files")
 			packages.notestfiles.push(pkg);
-		else if (pkg.Outcome == "no test functions")
+		else if (pkg.Outcome === "no test functions")
 			packages.notestfn.push(pkg);
+		else if (pkg.Outcome === "ignored" || pkg.Outcome === "disabled")
+			packages.ignored.push(pkg);
 		else
 		{
 			if (pkg.Coverage >= 0)
@@ -570,7 +588,7 @@ function process(data, status, jqxhr)
 			test._pkgid = pkg._id;
 			test._pkg = pkg.PackageName;
 
-			if (test.Stories.length == 0)
+			if (test.Stories.length === 0)
 			{
 				// Here we've got ourselves a classic Go test,
 				// not a GoConvey test that has stories and assertions
@@ -609,29 +627,32 @@ function process(data, status, jqxhr)
 			else
 				test._status = convey.statuses.pass;
 
-			var storyPath = [{ Depth: -1, Title: test.TestName }];	// Maintains the current assertion's story as we iterate
+			var storyPath = [{ Depth: -1, Title: test.TestName, _id: test._id }];	// Maintains the current assertion's story as we iterate
 
 			for (var k in test.Stories)
 			{
 				var story = makeContext(test.Stories[k]);
 
+				story._id = uniqueID;
+				story._pkgid = pkg._id;
+				current().overall.assertions += story.Assertions.length;
+
 				// Establish the current story path so we can report the context
 				// of failures and panicks more conveniently at the top of the page
 				if (storyPath.length > 0)
 					for (var x = storyPath[storyPath.length - 1].Depth; x >= test.Stories[k].Depth; x--)
 						storyPath.pop();
-				
-				storyPath.push({ Depth: test.Stories[k].Depth, Title: test.Stories[k].Title });
+				storyPath.push({ Depth: test.Stories[k].Depth, Title: test.Stories[k].Title, _id: test.Stories[k]._id });
 
-				story._id = uniqueID;
-				story._pkgid = pkg._id;
-				current().overall.assertions += story.Assertions.length;
 
 				for (var l in story.Assertions)
 				{
 					var assertion = story.Assertions[l];
 					assertion._id = uniqueID;
 					assertion._pkg = pkg.PackageName;
+					assertion._pkgId = pkg._id;
+					assertion._failed = !!assertion.Failure;
+					assertion._panicked = !!assertion.Error;
 					assertion._maxDepth = storyPath[storyPath.length - 1].Depth;
 					$.extend(assertion._path = [], storyPath);
 
@@ -687,7 +708,7 @@ function process(data, status, jqxhr)
 	current().overall.panics = current().assertions.panicked.length;
 	current().overall.failures = current().assertions.failed.length;
 	current().overall.skipped = current().assertions.skipped.length;
-	
+
 	current().overall.coverage = Math.round((coverageAvgHelper.coverageSum / (coverageAvgHelper.countedPackages || 1)) * 100) / 100;
 	current().overall.duration = Math.round(current().overall.duration * 1000) / 1000;
 
@@ -746,7 +767,7 @@ function process(data, status, jqxhr)
 
 	// Now add the momentjs time to the new frame in the history
 	convey.intervalFuncs.momentjs();
-	
+
 	// Show notification, if enabled
 	if (notif())
 	{
@@ -768,7 +789,7 @@ function process(data, status, jqxhr)
 	}
 
 	// Update title in title bar
-	if (current().overall.passed == current().overall.assertions && current().overall.status.class == "ok")
+	if (current().overall.passed === current().overall.assertions && current().overall.status.class === "ok")
 		$('title').text("GoConvey (ALL PASS)");
 	else
 		$('title').text("GoConvey [" + current().overall.status.text + "] " + current().overall.passed + "/" + current().overall.assertions);
@@ -783,12 +804,23 @@ function process(data, status, jqxhr)
 
 
 
+
+
+
+
+
+
+
+
+
+
 // Updates the entire UI given a frame from the history
 function renderFrame(frame)
 {
 	log("Rendering frame (id: " + frame.id + ")");
 
 	$('#coverage').html(render('tpl-coverage', frame.packages.tested.sort(sortPackages)));
+	$('#ignored').html(render('tpl-ignored', frame.packages.ignored.sort(sortPackages)));
 	$('#nogofiles').html(render('tpl-nogofiles', frame.packages.nogofiles.sort(sortPackages)));
 	$('#notestfiles').html(render('tpl-notestfiles', frame.packages.notestfiles.sort(sortPackages)));
 	$('#notestfn').html(render('tpl-notestfn', frame.packages.notestfn.sort(sortPackages)));
@@ -822,18 +854,19 @@ function renderFrame(frame)
 		$('.failures').hide();
 
 	$('#stories').html(render('tpl-stories', frame.packages.tested.sort(sortPackages)));
+	$('#stories').append(render('tpl-stories', frame.packages.ignored.sort(sortPackages)));
 
 	var pkgDefaultView = get('pkg-expand-collapse');
 	$('.story-pkg.expanded').each(function()
 	{
-		if (pkgDefaultView == "collapsed" && convey.packageStates[$(this).data('pkg-name')] != "expanded")
+		if (pkgDefaultView === "collapsed" && convey.packageStates[$(this).data('pkg-name')] !== "expanded")
 			collapsePackage($(this).data('pkg'));
 	});
 
 	redrawCoverageBars();
 
 	$('#assert-count').html("<b>"+frame.overall.assertions+"</b> assertion"
-							+ (frame.overall.assertions != 1 ? "s" : ""));
+							+ (frame.overall.assertions !== 1 ? "s" : ""));
 	$('#skip-count').html("<b>"+frame.assertions.skipped.length + "</b> skipped");
 	$('#fail-count').html("<b>"+frame.assertions.failed.length + "</b> failed");
 	$('#panic-count').html("<b>"+frame.assertions.panicked.length + "</b> panicked");
@@ -846,7 +879,7 @@ function renderFrame(frame)
 
 	$('.history .item').removeClass('selected');
 
-	if (get('show-debug-output') == "hide")
+	if (get('show-debug-output') === "hide")
 		$('.story-line-desc .message').hide();
 
 	log("Rendering finished");
@@ -864,7 +897,7 @@ function enumSel(id, val)
 	{
 		$('.enum#'+id+' > li').each(function()
 		{
-			if ($(this).data(id) == val)
+			if ($(this).data(id).toString() === val)
 			{
 				$(this).addClass(convey.layout.selClass).siblings().removeClass(convey.layout.selClass);
 				return false;
@@ -912,35 +945,40 @@ function changeStatus(newStatus, isHistoricalFrame)
 	if (!newStatus || !newStatus.class || !newStatus.text)
 		newStatus = convey.statuses.pass;
 
-	var sameStatus = newStatus.class == convey.overallClass;
+	var sameStatus = newStatus.class === convey.overallClass;
 
 	// The CSS class .flash and the jQuery UI 'pulsate' effect don't play well together.
 	// This series of callbacks does the flickering/pulsating as well as
 	// enabling/disabling flashing in the proper order so that they don't overlap.
 	// TODO: I suppose the pulsating could also be done with just CSS, maybe...?
 
-	var times = sameStatus ? 3 : 2;
-	var duration = sameStatus ? 500 : 300;
-
-	$('.overall .status').removeClass('flash').effect("pulsate", {times: times}, duration, function()
+	if (convey.uiEffects)
 	{
-		$(this).text(newStatus.text);
+		var times = sameStatus ? 3 : 2;
+		var duration = sameStatus ? 500 : 300;
 
-		if (newStatus != convey.statuses.pass)	// only flicker extra when not currently passing
+		$('.overall .status').removeClass('flash').effect("pulsate", {times: times}, duration, function()
 		{
-			$(this).effect("pulsate", {times: 1}, 300, function()
+			$(this).text(newStatus.text);
+
+			if (newStatus !== convey.statuses.pass)	// only flicker extra when not currently passing
 			{
-				$(this).effect("pulsate", {times: 1}, 500, function()
+				$(this).effect("pulsate", {times: 1}, 300, function()
 				{
-					if (newStatus == convey.statuses.panic
-							|| newStatus == convey.statuses.buildfail)
-						$(this).addClass('flash');
-					else
-						$(this).removeClass('flash');
+					$(this).effect("pulsate", {times: 1}, 500, function()
+					{
+						if (newStatus === convey.statuses.panic
+								|| newStatus === convey.statuses.buildfail)
+							$(this).addClass('flash');
+						else
+							$(this).removeClass('flash');
+					});
 				});
-			});
-		}
-	});
+			}
+		});
+	}
+	else
+		$('.overall .status').text(newStatus.text);
 
 	if (!sameStatus)	// change the color
 		$('.overall').switchClass(convey.overallClass, newStatus.class, 1000);
@@ -956,7 +994,7 @@ function updateWatchPath()
 	$.get("/watch", function(data)
 	{
 		var newPath = $.trim(data);
-		if (newPath != $('#path').val())
+		if (newPath !== $('#path').val())
 			convey.framesOnSamePath = 1;
 		$('#path').val(newPath);
 	});
@@ -967,7 +1005,7 @@ function notifSummary(frame)
 	var body = frame.overall.passed + " passed, ";
 
 	if (frame.overall.failedBuilds)
-		body += frame.overall.failedBuilds + " build" + (frame.overall.failedBuilds != 1 ? "s" : "") + " failed, ";
+		body += frame.overall.failedBuilds + " build" + (frame.overall.failedBuilds !== 1 ? "s" : "") + " failed, ";
 	if (frame.overall.failures)
 		body += frame.overall.failures + " failed, ";
 	if (frame.overall.panics)
@@ -1028,7 +1066,7 @@ function colorizeCoverageBars()
 function getFrame(id)
 {
 	for (var i in convey.history)
-		if (convey.history[i].id == id)
+		if (convey.history[i].id === id)
 			return convey.history[i];
 }
 
@@ -1094,13 +1132,14 @@ function zerofill(val, count)
 	return (pad + val).slice(-pad.length);
 }
 
+// Sorts packages ascending by only the last part of their name
+// Can be passed into Array.sort()
 function sortPackages(a, b)
 {
-	// sorts packages ascending by only the last part of their name
 	var aPkg = splitPathName(a.PackageName);
 	var bPkg = splitPathName(b.PackageName);
 
-	if (aPkg.length == 0 || bPkg.length == 0)
+	if (aPkg.length === 0 || bPkg.length === 0)
 		return 0;
 
 	var aName = aPkg.parts[aPkg.parts.length - 1].toLowerCase();
@@ -1114,7 +1153,7 @@ function sortPackages(a, b)
 		return 0;
 
 	/*
-	Use to sort by entire package name:
+	MEMO: Use to sort by entire package name:
 	if (a.PackageName < b.PackageName) return -1;
 	else if (a.PackageName > b.PackageName) return 1;
 	else return 0;
@@ -1124,7 +1163,7 @@ function sortPackages(a, b)
 function get(key)
 {
 	var val = localStorage.getItem(key);
-	if (val && (val[0] == '[' || val[0] == '{'))
+	if (val && (val[0] === '[' || val[0] === '{'))
 		return JSON.parse(val);
 	else
 		return val;
@@ -1132,10 +1171,10 @@ function get(key)
 
 function save(key, val)
 {
-	if (typeof val === 'object' || typeof val === 'array')
+	if (typeof val === 'object')
 		val = JSON.stringify(val);
-	else if (typeof val === 'number' || typeof val === "boolean")
-		val = "" + val;
+	else if (typeof val === 'number' || typeof val === 'boolean')
+		val = val.toString();
 	localStorage.setItem(key, val);
 }
 
@@ -1203,11 +1242,11 @@ function assignStatus(obj)
 {
 	if (obj._skipped)
 		obj._status = 'skip';
-	else if (obj.Outcome == "ignored")
+	else if (obj.Outcome === "ignored")
 		obj._status = convey.statuses.ignored;
 	else if (obj._panicked)
 		obj._status = convey.statuses.panic;
-	else if (obj._failed || obj.Outcome == "failed")
+	else if (obj._failed || obj.Outcome === "failed")
 		obj._status = convey.statuses.fail;
 	else
 		obj._status = convey.statuses.pass;
@@ -1217,7 +1256,7 @@ function showCoverDelta(delta)
 {
 	if (delta > 0)
 		return "+" + delta + "%";
-	else if (delta == 0)
+	else if (delta === 0)
 		return "±" + delta + "%";
 	else
 		return delta + "%";
@@ -1235,6 +1274,7 @@ function customMarkupPipes()
 	{
 		return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
 	};
+	Mark.pipes.ansiColours = ansispan;
 	Mark.pipes.boldPkgName = function(str)
 	{
 		var pkg = splitPathName(str);
@@ -1244,7 +1284,7 @@ function customMarkupPipes()
 	};
 	Mark.pipes.needsDiff = function(test)
 	{
-		return !!test.Failure && (test.Expected != "" || test.Actual != "");
+		return !!test.Failure && (test.Expected !== "" || test.Actual !== "");
 	};
 	Mark.pipes.coveragePct = function(str)
 	{
@@ -1279,4 +1319,4 @@ function suppress(event)
 		event.stopPropagation();
 	event.cancelBubble = true;
 	return false;
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/ansispan.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/ansispan.js
new file mode 100644
index 00000000000..3d8603a6d1b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/ansispan.js
@@ -0,0 +1,67 @@
+/*
+Copyright (C) 2011 by Maciej Małecki
+
+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.
+*/
+
+var ansispan = function (str) {
+  Object.keys(ansispan.foregroundColors).forEach(function (ansi) {
+    var span = '<span class="ansi-' + ansispan.foregroundColors[ansi] + '">';
+
+    //
+    // `\033[Xm` == `\033[0;Xm` sets foreground color to `X`.
+    //
+
+    str = str.replace(
+      new RegExp('\033\\[' + ansi + 'm', 'g'),
+      span
+    ).replace(
+      new RegExp('\033\\[0;' + ansi + 'm', 'g'),
+      span
+    );
+  });
+  //
+  // `\033[1m` enables bold font, `\033[22m` disables it
+  //
+  str = str.replace(/\033\[1m/g, '<b>').replace(/\033\[22m/g, '</b>');
+
+  //
+  // `\033[3m` enables italics font, `\033[23m` disables it
+  //
+  str = str.replace(/\033\[3m/g, '<i>').replace(/\033\[23m/g, '</i>');
+
+  str = str.replace(/\033\[m/g, '</span>');
+  str = str.replace(/\033\[0m/g, '</span>');
+  return str.replace(/\033\[39m/g, '</span>');
+};
+
+ansispan.foregroundColors = {
+  '30': 'black',
+  '31': 'red',
+  '32': 'green',
+  '33': 'yellow',
+  '34': 'blue',
+  '35': 'purple',
+  '36': 'cyan',
+  '37': 'white'
+};
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = ansispan;
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/jquery.waypoints.sticky.min.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/jquery.waypoints.sticky.min.js
deleted file mode 100644
index 5a558f306a0..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/jquery.waypoints.sticky.min.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// Generated by CoffeeScript 1.6.2
-/*
-jQuery Waypoints - v2.0.3
-Copyright (c) 2011-2013 Caleb Troughton
-Dual licensed under the MIT license and GPL license.
-https://github.com/imakewebthings/jquery-waypoints/blob/master/licenses.txt
-*/
-(function(){var t=[].indexOf||function(t){for(var e=0,n=this.length;e<n;e++){if(e in this&&this[e]===t)return e}return-1},e=[].slice;(function(t,e){if(typeof define==="function"&&define.amd){return define("waypoints",["jquery"],function(n){return e(n,t)})}else{return e(t.jQuery,t)}})(this,function(n,r){var i,o,l,s,f,u,a,c,h,d,p,y,v,w,g,m;i=n(r);c=t.call(r,"ontouchstart")>=0;s={horizontal:{},vertical:{}};f=1;a={};u="waypoints-context-id";p="resize.waypoints";y="scroll.waypoints";v=1;w="waypoints-waypoint-ids";g="waypoint";m="waypoints";o=function(){function t(t){var e=this;this.$element=t;this.element=t[0];this.didResize=false;this.didScroll=false;this.id="context"+f++;this.oldScroll={x:t.scrollLeft(),y:t.scrollTop()};this.waypoints={horizontal:{},vertical:{}};t.data(u,this.id);a[this.id]=this;t.bind(y,function(){var t;if(!(e.didScroll||c)){e.didScroll=true;t=function(){e.doScroll();return e.didScroll=false};return r.setTimeout(t,n[m].settings.scrollThrottle)}});t.bind(p,function(){var t;if(!e.didResize){e.didResize=true;t=function(){n[m]("refresh");return e.didResize=false};return r.setTimeout(t,n[m].settings.resizeThrottle)}})}t.prototype.doScroll=function(){var t,e=this;t={horizontal:{newScroll:this.$element.scrollLeft(),oldScroll:this.oldScroll.x,forward:"right",backward:"left"},vertical:{newScroll:this.$element.scrollTop(),oldScroll:this.oldScroll.y,forward:"down",backward:"up"}};if(c&&(!t.vertical.oldScroll||!t.vertical.newScroll)){n[m]("refresh")}n.each(t,function(t,r){var i,o,l;l=[];o=r.newScroll>r.oldScroll;i=o?r.forward:r.backward;n.each(e.waypoints[t],function(t,e){var n,i;if(r.oldScroll<(n=e.offset)&&n<=r.newScroll){return l.push(e)}else if(r.newScroll<(i=e.offset)&&i<=r.oldScroll){return l.push(e)}});l.sort(function(t,e){return t.offset-e.offset});if(!o){l.reverse()}return n.each(l,function(t,e){if(e.options.continuous||t===l.length-1){return e.trigger([i])}})});return this.oldScroll={x:t.horizontal.newScroll,y:t.vertical.newScroll}};t.prototype.refresh=function(){var t,e,r,i=this;r=n.isWindow(this.element);e=this.$element.offset();this.doScroll();t={horizontal:{contextOffset:r?0:e.left,contextScroll:r?0:this.oldScroll.x,contextDimension:this.$element.width(),oldScroll:this.oldScroll.x,forward:"right",backward:"left",offsetProp:"left"},vertical:{contextOffset:r?0:e.top,contextScroll:r?0:this.oldScroll.y,contextDimension:r?n[m]("viewportHeight"):this.$element.height(),oldScroll:this.oldScroll.y,forward:"down",backward:"up",offsetProp:"top"}};return n.each(t,function(t,e){return n.each(i.waypoints[t],function(t,r){var i,o,l,s,f;i=r.options.offset;l=r.offset;o=n.isWindow(r.element)?0:r.$element.offset()[e.offsetProp];if(n.isFunction(i)){i=i.apply(r.element)}else if(typeof i==="string"){i=parseFloat(i);if(r.options.offset.indexOf("%")>-1){i=Math.ceil(e.contextDimension*i/100)}}r.offset=o-e.contextOffset+e.contextScroll-i;if(r.options.onlyOnScroll&&l!=null||!r.enabled){return}if(l!==null&&l<(s=e.oldScroll)&&s<=r.offset){return r.trigger([e.backward])}else if(l!==null&&l>(f=e.oldScroll)&&f>=r.offset){return r.trigger([e.forward])}else if(l===null&&e.oldScroll>=r.offset){return r.trigger([e.forward])}})})};t.prototype.checkEmpty=function(){if(n.isEmptyObject(this.waypoints.horizontal)&&n.isEmptyObject(this.waypoints.vertical)){this.$element.unbind([p,y].join(" "));return delete a[this.id]}};return t}();l=function(){function t(t,e,r){var i,o;r=n.extend({},n.fn[g].defaults,r);if(r.offset==="bottom-in-view"){r.offset=function(){var t;t=n[m]("viewportHeight");if(!n.isWindow(e.element)){t=e.$element.height()}return t-n(this).outerHeight()}}this.$element=t;this.element=t[0];this.axis=r.horizontal?"horizontal":"vertical";this.callback=r.handler;this.context=e;this.enabled=r.enabled;this.id="waypoints"+v++;this.offset=null;this.options=r;e.waypoints[this.axis][this.id]=this;s[this.axis][this.id]=this;i=(o=t.data(w))!=null?o:[];i.push(this.id);t.data(w,i)}t.prototype.trigger=function(t){if(!this.enabled){return}if(this.callback!=null){this.callback.apply(this.element,t)}if(this.options.triggerOnce){return this.destroy()}};t.prototype.disable=function(){return this.enabled=false};t.prototype.enable=function(){this.context.refresh();return this.enabled=true};t.prototype.destroy=function(){delete s[this.axis][this.id];delete this.context.waypoints[this.axis][this.id];return this.context.checkEmpty()};t.getWaypointsByElement=function(t){var e,r;r=n(t).data(w);if(!r){return[]}e=n.extend({},s.horizontal,s.vertical);return n.map(r,function(t){return e[t]})};return t}();d={init:function(t,e){var r;if(e==null){e={}}if((r=e.handler)==null){e.handler=t}this.each(function(){var t,r,i,s;t=n(this);i=(s=e.context)!=null?s:n.fn[g].defaults.context;if(!n.isWindow(i)){i=t.closest(i)}i=n(i);r=a[i.data(u)];if(!r){r=new o(i)}return new l(t,r,e)});n[m]("refresh");return this},disable:function(){return d._invoke(this,"disable")},enable:function(){return d._invoke(this,"enable")},destroy:function(){return d._invoke(this,"destroy")},prev:function(t,e){return d._traverse.call(this,t,e,function(t,e,n){if(e>0){return t.push(n[e-1])}})},next:function(t,e){return d._traverse.call(this,t,e,function(t,e,n){if(e<n.length-1){return t.push(n[e+1])}})},_traverse:function(t,e,i){var o,l;if(t==null){t="vertical"}if(e==null){e=r}l=h.aggregate(e);o=[];this.each(function(){var e;e=n.inArray(this,l[t]);return i(o,e,l[t])});return this.pushStack(o)},_invoke:function(t,e){t.each(function(){var t;t=l.getWaypointsByElement(this);return n.each(t,function(t,n){n[e]();return true})});return this}};n.fn[g]=function(){var t,r;r=arguments[0],t=2<=arguments.length?e.call(arguments,1):[];if(d[r]){return d[r].apply(this,t)}else if(n.isFunction(r)){return d.init.apply(this,arguments)}else if(n.isPlainObject(r)){return d.init.apply(this,[null,r])}else if(!r){return n.error("jQuery Waypoints needs a callback function or handler option.")}else{return n.error("The "+r+" method does not exist in jQuery Waypoints.")}};n.fn[g].defaults={context:r,continuous:true,enabled:true,horizontal:false,offset:0,triggerOnce:false};h={refresh:function(){return n.each(a,function(t,e){return e.refresh()})},viewportHeight:function(){var t;return(t=r.innerHeight)!=null?t:i.height()},aggregate:function(t){var e,r,i;e=s;if(t){e=(i=a[n(t).data(u)])!=null?i.waypoints:void 0}if(!e){return[]}r={horizontal:[],vertical:[]};n.each(r,function(t,i){n.each(e[t],function(t,e){return i.push(e)});i.sort(function(t,e){return t.offset-e.offset});r[t]=n.map(i,function(t){return t.element});return r[t]=n.unique(r[t])});return r},above:function(t){if(t==null){t=r}return h._filter(t,"vertical",function(t,e){return e.offset<=t.oldScroll.y})},below:function(t){if(t==null){t=r}return h._filter(t,"vertical",function(t,e){return e.offset>t.oldScroll.y})},left:function(t){if(t==null){t=r}return h._filter(t,"horizontal",function(t,e){return e.offset<=t.oldScroll.x})},right:function(t){if(t==null){t=r}return h._filter(t,"horizontal",function(t,e){return e.offset>t.oldScroll.x})},enable:function(){return h._invoke("enable")},disable:function(){return h._invoke("disable")},destroy:function(){return h._invoke("destroy")},extendFn:function(t,e){return d[t]=e},_invoke:function(t){var e;e=n.extend({},s.vertical,s.horizontal);return n.each(e,function(e,n){n[t]();return true})},_filter:function(t,e,r){var i,o;i=a[n(t).data(u)];if(!i){return[]}o=[];n.each(i.waypoints[e],function(t,e){if(r(i,e)){return o.push(e)}});o.sort(function(t,e){return t.offset-e.offset});return n.map(o,function(t){return t.element})}};n[m]=function(){var t,n;n=arguments[0],t=2<=arguments.length?e.call(arguments,1):[];if(h[n]){return h[n].apply(null,t)}else{return h.aggregate.call(null,n)}};n[m].settings={resizeThrottle:100,scrollThrottle:30};return i.load(function(){return n[m]("refresh")})})}).call(this);
-
-
-// Generated by CoffeeScript 1.6.2
-/*
-Sticky Elements Shortcut for jQuery Waypoints - v2.0.3
-Copyright (c) 2011-2013 Caleb Troughton
-Dual licensed under the MIT license and GPL license.
-https://github.com/imakewebthings/jquery-waypoints/blob/master/licenses.txt
-*/
-(function(){(function(t,n){if(typeof define==="function"&&define.amd){return define(["jquery","waypoints"],n)}else{return n(t.jQuery)}})(this,function(t){var n,s;n={wrapper:'<div class="sticky-wrapper" />',stuckClass:"stuck"};s=function(t,n){t.wrap(n.wrapper);return t.parent()};t.waypoints("extendFn","sticky",function(e){var i,r,a;r=t.extend({},t.fn.waypoint.defaults,n,e);i=s(this,r);a=r.handler;r.handler=function(n){var s,e;s=t(this).children(":first");e=n==="down"||n==="right";s.toggleClass(r.stuckClass,e);i.height(e?s.outerHeight():"");if(a!=null){return a.call(this,n)}};i.waypoint(r);return this.data("stuckClass",r.stuckClass)});return t.waypoints("extendFn","unsticky",function(){this.parent().waypoint("destroy");this.unwrap();return this.removeClass(this.data("stuckClass"))})})}).call(this);
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/poller.js b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/poller.js
index 233d1431a8b..d8ab1e8eb9f 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/poller.js
+++ b/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/poller.js
@@ -77,7 +77,7 @@ function Poller(config)
 	{
 		stopDownPoller();
 		doPoll();
-		
+
 		var wasUp = up;
 		up = true;
 		status = data;
@@ -96,7 +96,7 @@ function Poller(config)
 
 	function pollFailed(jqxhr, message, exception)
 	{
-		if (message == "timeout")
+		if (message === "timeout")
 		{
 			log("Poller timeout; re-polling...", req);
 			doPoll();	// in our case, timeout actually means no activity; poll again
@@ -127,4 +127,4 @@ function Poller(config)
 		clearInterval(downPoller);
 		downPoller = undefined;
 	}
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/api/api.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/api/api.goconvey
new file mode 100644
index 00000000000..79982854b53
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/api/api.goconvey
@@ -0,0 +1,2 @@
+#ignore
+-timeout=1s
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/api/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/api/init_test.go
deleted file mode 100644
index 57089dd6338..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/api/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package api
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/api/server.go b/vendor/src/github.com/smartystreets/goconvey/web/server/api/server.go
index effb2539a73..6cea26daee8 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/api/server.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/api/server.go
@@ -4,22 +4,25 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"os"
 	"strconv"
 	"time"
 
 	"github.com/smartystreets/goconvey/web/server/contract"
+	"github.com/smartystreets/goconvey/web/server/messaging"
 )
 
 type HTTPServer struct {
-	watcher     contract.Watcher
+	watcher     chan messaging.WatcherCommand
 	executor    contract.Executor
 	latest      *contract.CompleteOutput
-	clientChan  chan chan string
-	pauseUpdate chan bool
+	currentRoot string
+	longpoll    chan chan string
 	paused      bool
 }
 
-func (self *HTTPServer) ReceiveUpdate(update *contract.CompleteOutput) {
+func (self *HTTPServer) ReceiveUpdate(root string, update *contract.CompleteOutput) {
+	self.currentRoot = root
 	self.latest = update
 }
 
@@ -27,7 +30,7 @@ func (self *HTTPServer) Watch(response http.ResponseWriter, request *http.Reques
 	if request.Method == "POST" {
 		self.adjustRoot(response, request)
 	} else if request.Method == "GET" {
-		response.Write([]byte(self.watcher.Root()))
+		response.Write([]byte(self.currentRoot))
 	}
 }
 
@@ -36,23 +39,35 @@ func (self *HTTPServer) adjustRoot(response http.ResponseWriter, request *http.R
 	if newRoot == "" {
 		return
 	}
-	err := self.watcher.Adjust(newRoot)
-	if err != nil {
+	info, err := os.Stat(newRoot) // TODO: how to unit test?
+	if !info.IsDir() || err != nil {
 		http.Error(response, err.Error(), http.StatusNotFound)
+		return
+	}
+
+	self.watcher <- messaging.WatcherCommand{
+		Instruction: messaging.WatcherAdjustRoot,
+		Details:     newRoot,
 	}
 }
 
 func (self *HTTPServer) Ignore(response http.ResponseWriter, request *http.Request) {
 	paths := self.parseQueryString("paths", response, request)
 	if paths != "" {
-		self.watcher.Ignore(paths)
+		self.watcher <- messaging.WatcherCommand{
+			Instruction: messaging.WatcherIgnore,
+			Details:     paths,
+		}
 	}
 }
 
 func (self *HTTPServer) Reinstate(response http.ResponseWriter, request *http.Request) {
 	paths := self.parseQueryString("paths", response, request)
 	if paths != "" {
-		self.watcher.Reinstate(paths)
+		self.watcher <- messaging.WatcherCommand{
+			Instruction: messaging.WatcherReinstate,
+			Details:     paths,
+		}
 	}
 }
 
@@ -90,7 +105,7 @@ func (self *HTTPServer) LongPollStatus(response http.ResponseWriter, request *ht
 	myReqChan := make(chan string)
 
 	select {
-	case self.clientChan <- myReqChan: // this case means the executor's status is changing
+	case self.longpoll <- myReqChan: // this case means the executor's status is changing
 	case <-time.After(time.Duration(timeout) * time.Millisecond): // this case means the executor hasn't changed status
 		return
 	}
@@ -119,24 +134,31 @@ func (self *HTTPServer) Execute(response http.ResponseWriter, request *http.Requ
 }
 
 func (self *HTTPServer) execute() {
-	self.latest = self.executor.ExecuteTests(self.watcher.WatchedFolders())
+	self.watcher <- messaging.WatcherCommand{Instruction: messaging.WatcherExecute}
 }
 
 func (self *HTTPServer) TogglePause(response http.ResponseWriter, request *http.Request) {
-	select {
-	case self.pauseUpdate <- true:
-		self.paused = !self.paused
-	default:
+	instruction := messaging.WatcherPause
+	if self.paused {
+		instruction = messaging.WatcherResume
 	}
 
+	self.watcher <- messaging.WatcherCommand{Instruction: instruction}
+	self.paused = !self.paused
+
 	fmt.Fprint(response, self.paused) // we could write out whatever helps keep the UI honest...
 }
 
-func NewHTTPServer(watcher contract.Watcher, executor contract.Executor, status chan chan string, pause chan bool) *HTTPServer {
+func NewHTTPServer(
+	root string,
+	watcher chan messaging.WatcherCommand,
+	executor contract.Executor,
+	status chan chan string) *HTTPServer {
+
 	self := new(HTTPServer)
+	self.currentRoot = root
 	self.watcher = watcher
 	self.executor = executor
-	self.clientChan = status
-	self.pauseUpdate = pause
+	self.longpoll = status
 	return self
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/api/server_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/api/server_test.go
index 27c2abb9f60..bd48e308015 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/api/server_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/api/server_test.go
@@ -2,7 +2,6 @@ package api
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
@@ -13,6 +12,7 @@ import (
 
 	. "github.com/smartystreets/goconvey/convey"
 	"github.com/smartystreets/goconvey/web/server/contract"
+	"github.com/smartystreets/goconvey/web/server/messaging"
 )
 
 const initialRoot = "/root/gopath/src/github.com/smartystreets/project"
@@ -20,10 +20,12 @@ const nonexistentRoot = "I don't exist"
 const unreadableContent = "!!error!!"
 
 func TestHTTPServer(t *testing.T) {
+	// TODO: fix the skipped tests...
+
 	Convey("Subject: HttpServer responds to requests appropriately", t, func() {
 		fixture := newServerFixture()
 
-		Convey("Before any update is recived", func() {
+		Convey("Before any update is recieved", func() {
 			Convey("When the update is requested", func() {
 				update, _ := fixture.RequestLatest()
 
@@ -38,7 +40,7 @@ func TestHTTPServer(t *testing.T) {
 		})
 
 		Convey("Given an update is received", func() {
-			fixture.ReceiveUpdate(&contract.CompleteOutput{Revision: "asdf"})
+			fixture.ReceiveUpdate("", &contract.CompleteOutput{Revision: "asdf"})
 
 			Convey("When the update is requested", func() {
 				update, response := fixture.RequestLatest()
@@ -64,7 +66,7 @@ func TestHTTPServer(t *testing.T) {
 		Convey("When the root watch is queried", func() {
 			root, status := fixture.QueryRootWatch(false)
 
-			Convey("The server returns it", func() {
+			SkipConvey("The server returns it", func() {
 				So(root, ShouldEqual, initialRoot)
 			})
 
@@ -73,7 +75,7 @@ func TestHTTPServer(t *testing.T) {
 			})
 		})
 
-		Convey("When the root watch is adjusted", func() {
+		SkipConvey("When the root watch is adjusted", func() {
 
 			Convey("But the request has no root parameter", func() {
 				status, body := fixture.AdjustRootWatchMalformed()
@@ -144,7 +146,7 @@ func TestHTTPServer(t *testing.T) {
 			})
 		})
 
-		Convey("When a packge is ignored", func() {
+		SkipConvey("When a packge is ignored", func() {
 
 			Convey("But the request has no path parameter", func() {
 				status, body := fixture.IgnoreMalformed()
@@ -157,8 +159,8 @@ func TestHTTPServer(t *testing.T) {
 					So(body, ShouldEqual, "No 'paths' query string parameter included!")
 				})
 
-				Convey("The server should not ignore anything", func() {
-					So(fixture.watcher.ignored, ShouldEqual, "")
+				SkipConvey("The server should not ignore anything", func() {
+					// So(fixture.watcher.ignored, ShouldEqual, "")
 				})
 			})
 
@@ -177,8 +179,8 @@ func TestHTTPServer(t *testing.T) {
 			Convey("And the request is well formed", func() {
 				status, _ := fixture.Ignore(initialRoot)
 
-				Convey("The server informs the watcher", func() {
-					So(fixture.watcher.ignored, ShouldEqual, initialRoot)
+				SkipConvey("The server informs the watcher", func() {
+					// So(fixture.watcher.ignored, ShouldEqual, initialRoot)
 				})
 				Convey("The server returns HTTP 200 - OK", func() {
 					So(status, ShouldEqual, http.StatusOK)
@@ -186,7 +188,7 @@ func TestHTTPServer(t *testing.T) {
 			})
 		})
 
-		Convey("When a package is reinstated", func() {
+		SkipConvey("When a package is reinstated", func() {
 			Convey("But the request has no path parameter", func() {
 				status, body := fixture.ReinstateMalformed()
 
@@ -198,8 +200,8 @@ func TestHTTPServer(t *testing.T) {
 					So(body, ShouldEqual, "No 'paths' query string parameter included!")
 				})
 
-				Convey("The server should not ignore anything", func() {
-					So(fixture.watcher.reinstated, ShouldEqual, "")
+				SkipConvey("The server should not ignore anything", func() {
+					// So(fixture.watcher.reinstated, ShouldEqual, "")
 				})
 			})
 
@@ -218,8 +220,8 @@ func TestHTTPServer(t *testing.T) {
 			Convey("And the request is well formed", func() {
 				status, _ := fixture.Reinstate(initialRoot)
 
-				Convey("The server informs the watcher", func() {
-					So(fixture.watcher.reinstated, ShouldEqual, initialRoot)
+				SkipConvey("The server informs the watcher", func() {
+					// So(fixture.watcher.reinstated, ShouldEqual, initialRoot)
 				})
 				Convey("The server returns HTTP 200 - OK", func() {
 					So(status, ShouldEqual, http.StatusOK)
@@ -244,7 +246,7 @@ func TestHTTPServer(t *testing.T) {
 			status := fixture.ManualExecution()
 			update, _ := fixture.RequestLatest()
 
-			Convey("The server invokes the executor using the watcher's listing and save the result", func() {
+			SkipConvey("The server invokes the executor using the watcher's listing and save the result", func() {
 				So(update, ShouldResemble, &contract.CompleteOutput{Revision: initialRoot})
 			})
 
@@ -253,20 +255,20 @@ func TestHTTPServer(t *testing.T) {
 			})
 		})
 
-		Convey("When the pause setting is toggled via the server", func() {
+		SkipConvey("When the pause setting is toggled via the server", func() {
 			paused := fixture.TogglePause()
 
-			Convey("The pause channel buffer should have a true value", func() {
-				var value bool
-				select {
-				case value = <-fixture.pauseUpdate:
-				default:
-				}
-				So(value, ShouldBeTrue)
+			SkipConvey("The pause channel buffer should have a true value", func() {
+				// var value bool
+				// select {
+				// case value = <-fixture.pauseUpdate:
+				// default:
+				// }
+				// So(value, ShouldBeTrue)
 			})
 
 			Convey("The latest results should show that the server is paused", func() {
-				fixture.ReceiveUpdate(&contract.CompleteOutput{Revision: "asdf"})
+				fixture.ReceiveUpdate("", &contract.CompleteOutput{Revision: "asdf"})
 				update, _ := fixture.RequestLatest()
 
 				So(update.Paused, ShouldBeTrue)
@@ -279,29 +281,17 @@ func TestHTTPServer(t *testing.T) {
 	})
 }
 
-func statusRotation(i, total int) string {
-	switch i % total {
-	case 0:
-		return "executing"
-	case 1:
-		return "parsing"
-	default:
-		return "idle"
-	}
-}
-
 /********* Server Fixture *********/
 
 type ServerFixture struct {
 	server       *HTTPServer
-	watcher      *FakeWatcher
+	watcher      chan messaging.WatcherCommand
 	executor     *FakeExecutor
 	statusUpdate chan bool
-	pauseUpdate  chan bool
 }
 
-func (self *ServerFixture) ReceiveUpdate(update *contract.CompleteOutput) {
-	self.server.ReceiveUpdate(update)
+func (self *ServerFixture) ReceiveUpdate(root string, update *contract.CompleteOutput) {
+	self.server.ReceiveUpdate(root, update)
 }
 
 func (self *ServerFixture) RequestLatest() (*contract.CompleteOutput, *httptest.ResponseRecorder) {
@@ -393,11 +383,11 @@ func (self *ServerFixture) Reinstate(folder string) (status int, body string) {
 }
 
 func (self *ServerFixture) SetExecutorStatus(status string) {
-	self.executor.status = status
-	select {
-	case self.executor.statusUpdate <- make(chan string):
-	default:
-	}
+	// self.executor.status = status
+	// select {
+	// case self.executor.statusUpdate <- make(chan string):
+	// default:
+	// }
 }
 
 func (self *ServerFixture) RequestExecutorStatus() (code int, status string) {
@@ -431,55 +421,14 @@ func (self *ServerFixture) TogglePause() string {
 
 func newServerFixture() *ServerFixture {
 	self := new(ServerFixture)
-	self.watcher = newFakeWatcher()
-	self.watcher.SetRootWatch(initialRoot)
+	self.watcher = make(chan messaging.WatcherCommand)
+	// self.watcher.SetRootWatch(initialRoot)
 	statusUpdate := make(chan chan string)
 	self.executor = newFakeExecutor("", statusUpdate)
-	self.pauseUpdate = make(chan bool, 1)
-	self.server = NewHTTPServer(self.watcher, self.executor, statusUpdate, self.pauseUpdate)
+	self.server = NewHTTPServer("initial-working-dir", self.watcher, self.executor, statusUpdate)
 	return self
 }
 
-/********* Fake Watcher *********/
-
-type FakeWatcher struct {
-	root       string
-	ignored    string
-	reinstated string
-}
-
-func (self *FakeWatcher) SetRootWatch(root string) {
-	self.root = root
-}
-
-func (self *FakeWatcher) WatchedFolders() []*contract.Package {
-	return []*contract.Package{&contract.Package{Path: self.root}}
-}
-
-func (self *FakeWatcher) Adjust(root string) error {
-	if root == nonexistentRoot {
-		return errors.New(fmt.Sprintf("Directory does not exist: '%s'", root))
-	}
-	self.root = root
-	return nil
-}
-
-func (self *FakeWatcher) Root() string {
-	return self.root
-}
-
-func (self *FakeWatcher) Ignore(folder string)    { self.ignored = folder }
-func (self *FakeWatcher) Reinstate(folder string) { self.reinstated = folder }
-
-func (self *FakeWatcher) Deletion(folder string)       { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) Creation(folder string)       { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) IsWatched(folder string) bool { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) IsIgnored(folder string) bool { panic("NOT SUPPORTED") }
-
-func newFakeWatcher() *FakeWatcher {
-	return new(FakeWatcher)
-}
-
 /********* Fake Executor *********/
 
 type FakeExecutor struct {
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/contracts.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/contracts.go
index 709c298d62c..e758f3e16e3 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/contracts.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/contracts.go
@@ -1,14 +1,10 @@
 package contract
 
-import (
-	"net/http"
-	"os"
-	"path/filepath"
-)
+import "net/http"
 
 type (
 	Server interface {
-		ReceiveUpdate(*CompleteOutput)
+		ReceiveUpdate(root string, update *CompleteOutput)
 		Watch(writer http.ResponseWriter, request *http.Request)
 		Ignore(writer http.ResponseWriter, request *http.Request)
 		Reinstate(writer http.ResponseWriter, request *http.Request)
@@ -25,34 +21,7 @@ type (
 		ClearStatusFlag() bool
 	}
 
-	Scanner interface {
-		Scan() (changed bool)
-	}
-
-	Watcher interface {
-		Root() string
-		Adjust(root string) error
-
-		Deletion(folder string)
-		Creation(folder string)
-
-		Ignore(folders string)
-		Reinstate(folders string)
-
-		WatchedFolders() []*Package
-		IsWatched(folder string) bool
-		IsIgnored(folder string) bool
-	}
-
-	FileSystem interface {
-		Walk(root string, step filepath.WalkFunc)
-		Listing(directory string) ([]os.FileInfo, error)
-		Exists(directory string) bool
-	}
-
 	Shell interface {
-		GoTest(directory, packageName string) (output string, err error)
-		Getenv(key string) string
-		Setenv(key, value string) error
+		GoTest(directory, packageName string, tags, arguments []string) (output string, err error)
 	}
 )
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/doc_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/doc_test.go
new file mode 100644
index 00000000000..14f4d2d9c2e
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/doc_test.go
@@ -0,0 +1 @@
+package contract
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/init_test.go
deleted file mode 100644
index be9b8fe538b..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package contract
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor.go
deleted file mode 100644
index d57dfded508..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor.go
+++ /dev/null
@@ -1,69 +0,0 @@
-package contract
-
-import "log"
-
-type Monitor struct {
-	scanner     Scanner
-	watcher     Watcher
-	executor    Executor
-	server      Server
-	paused      bool
-	pauseUpdate chan bool
-	sleep       func()
-}
-
-func (self *Monitor) ScanForever() {
-	log.Println("Engaging monitoring loop...")
-	for {
-		self.Scan()
-	}
-}
-
-func (self *Monitor) Scan() {
-	self.updatePausedStatus()
-
-	if !self.paused && self.scanner.Scan() {
-		self.executeTests()
-	} else {
-		self.sleep()
-	}
-}
-
-func (self *Monitor) updatePausedStatus() {
-	select {
-	case <-self.pauseUpdate:
-		log.Println("Server is now paused:", !self.paused)
-		self.paused = !self.paused
-	default:
-	}
-}
-
-func (self *Monitor) executeTests() {
-	watched := self.watcher.WatchedFolders()
-
-	log.Printf("Preparing for test run (watching %d folders)...\n", len(watched))
-	output := self.executor.ExecuteTests(watched)
-
-	log.Println("Test run complete, updating server with latest output...")
-	self.server.ReceiveUpdate(output)
-
-	log.Printf("Server updated with %d tested packages (revision: '%v').\n", len(output.Packages), output.Revision)
-}
-
-func NewMonitor(
-	scanner Scanner,
-	watcher Watcher,
-	executor Executor,
-	server Server,
-	pauseUpdate chan bool,
-	sleep func()) *Monitor {
-
-	self := new(Monitor)
-	self.scanner = scanner
-	self.watcher = watcher
-	self.executor = executor
-	self.server = server
-	self.pauseUpdate = pauseUpdate
-	self.sleep = sleep
-	return self
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor_test.go
deleted file mode 100644
index bcfd5f7aa2d..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/monitor_test.go
+++ /dev/null
@@ -1,211 +0,0 @@
-package contract
-
-import (
-	"net/http"
-	"testing"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestMonitor(t *testing.T) {
-	Convey("Subject: Monitor", t, func() {
-		fixture := newMonitorFixture()
-
-		Convey("When the file system has changed", func() {
-			fixture.scanner.Modify("/root")
-
-			Convey("As a result of scanning", func() {
-				fixture.Scan()
-
-				Convey("The watched packages should be executed and the results should be passed to the server", func() {
-					So(fixture.server.latest, ShouldResemble, &CompleteOutput{
-						Packages: []*PackageResult{
-							NewPackageResult("1"),
-							NewPackageResult("2"),
-						},
-					})
-				})
-			})
-
-			Convey("But the server is paused", func() {
-				select {
-				case fixture.pauseUpdate <- true:
-				default:
-				}
-
-				Convey("As a result of scanning", func() {
-					fixture.Scan()
-
-					Convey("The process should take a nap", func() {
-						So(fixture.nap, ShouldBeTrue)
-					})
-
-					Convey("The server should not receive any update", func() {
-						So(fixture.server.latest, ShouldBeNil)
-					})
-
-					Convey("And when the server is unpaused", func() {
-						select {
-						case fixture.pauseUpdate <- true:
-						default:
-						}
-
-						Convey("As a result of scanning again", func() {
-							fixture.Scan()
-
-							Convey("The watched packages should be executed and the results should be passed to the server", func() {
-								So(fixture.server.latest, ShouldResemble, &CompleteOutput{
-									Packages: []*PackageResult{
-										NewPackageResult("1"),
-										NewPackageResult("2"),
-									},
-								})
-							})
-						})
-					})
-				})
-			})
-		})
-
-		Convey("When the file system has remained stagnant", func() {
-			fixture.scanner.Reset("/root")
-
-			Convey("As a result of scanning", func() {
-				fixture.Scan()
-
-				Convey("The process should take a nap", func() {
-					So(fixture.nap, ShouldBeTrue)
-				})
-
-				Convey("The server should not receive any update", func() {
-					So(fixture.server.latest, ShouldBeNil)
-				})
-			})
-		})
-	})
-}
-
-/******** MonitorFixture ********/
-
-type MonitorFixture struct {
-	monitor     *Monitor
-	server      *FakeServer
-	watcher     *FakeWatcher
-	scanner     *FakeScanner
-	executor    *FakeExecutor
-	pauseUpdate chan bool
-	nap         bool
-}
-
-func (self *MonitorFixture) Scan() {
-	self.monitor.Scan()
-}
-
-func (self *MonitorFixture) TogglePause() {
-
-}
-
-func (self *MonitorFixture) sleep() {
-	self.nap = true
-}
-
-func newMonitorFixture() *MonitorFixture {
-	self := new(MonitorFixture)
-	self.server = newFakeServer()
-	self.watcher = newFakeWatcher()
-	self.scanner = newFakeScanner()
-	self.executor = newFakeExecutor()
-	self.pauseUpdate = make(chan bool, 1)
-	self.monitor = NewMonitor(self.scanner, self.watcher, self.executor, self.server, self.pauseUpdate, self.sleep)
-	return self
-}
-
-/******** FakeServer ********/
-
-type FakeServer struct {
-	latest *CompleteOutput
-}
-
-func (self *FakeServer) ReceiveUpdate(update *CompleteOutput) {
-	self.latest = update
-}
-func (self *FakeServer) Watch(http.ResponseWriter, *http.Request)          { panic("NOT SUPPORTED") }
-func (self *FakeServer) Ignore(http.ResponseWriter, *http.Request)         { panic("NOT SUPPORTED") }
-func (self *FakeServer) Reinstate(http.ResponseWriter, *http.Request)      { panic("NOT SUPPORTED") }
-func (self *FakeServer) Status(http.ResponseWriter, *http.Request)         { panic("NOT SUPPORTED") }
-func (self *FakeServer) LongPollStatus(http.ResponseWriter, *http.Request) { panic("NOT SUPPORTED") }
-func (self *FakeServer) Results(http.ResponseWriter, *http.Request)        { panic("NOT SUPPORTED") }
-func (self *FakeServer) Execute(http.ResponseWriter, *http.Request)        { panic("NOT SUPPORTED") }
-func (self *FakeServer) TogglePause(http.ResponseWriter, *http.Request)    { panic("NOT SUPPORTED") }
-
-func newFakeServer() *FakeServer {
-	return new(FakeServer)
-}
-
-/******** FakeWatcher ********/
-
-type FakeWatcher struct{}
-
-func (self *FakeWatcher) WatchedFolders() []*Package {
-	return []*Package{
-		&Package{Path: "/root", Result: NewPackageResult("1")},
-		&Package{Path: "/root/nested", Result: NewPackageResult("2")},
-	}
-}
-
-func (self *FakeWatcher) Root() string {
-	return self.WatchedFolders()[0].Path
-}
-
-func (self *FakeWatcher) Adjust(root string) error     { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) Deletion(folder string)       { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) Creation(folder string)       { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) Ignore(folder string)         { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) Reinstate(folder string)      { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) IsWatched(folder string) bool { panic("NOT SUPPORTED") }
-func (self *FakeWatcher) IsIgnored(folder string) bool { panic("NOT SUPPORTED") }
-
-func newFakeWatcher() *FakeWatcher {
-	return new(FakeWatcher)
-}
-
-/******** FakeScanner ********/
-
-type FakeScanner struct {
-	dirty bool
-}
-
-func (self *FakeScanner) Modify(path string) {
-	self.dirty = true
-}
-
-func (self *FakeScanner) Reset(path string) {
-	self.dirty = false
-}
-
-func (self *FakeScanner) Scan() (changed bool) {
-	return self.dirty
-}
-
-func newFakeScanner() *FakeScanner {
-	return new(FakeScanner)
-}
-
-/******** FakeExecutor ********/
-
-type FakeExecutor struct{}
-
-func (self *FakeExecutor) ExecuteTests(packages []*Package) *CompleteOutput {
-	complete := new(CompleteOutput)
-	complete.Packages = []*PackageResult{}
-	for _, p := range packages {
-		complete.Packages = append(complete.Packages, p.Result)
-	}
-	return complete
-}
-func (self *FakeExecutor) Status() string        { panic("NOT SUPPORTED") }
-func (self *FakeExecutor) ClearStatusFlag() bool { panic("NOT SUPPORTED") }
-
-func newFakeExecutor() *FakeExecutor {
-	return new(FakeExecutor)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/result.go b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/result.go
index 2b13ac57af5..c6f9bf2cfde 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/contract/result.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/contract/result.go
@@ -4,27 +4,47 @@ import (
 	"path/filepath"
 	"strings"
 
+	"go/build"
+
 	"github.com/smartystreets/goconvey/convey/reporting"
+	"github.com/smartystreets/goconvey/web/server/messaging"
 )
 
 type Package struct {
-	Active bool
-	Path   string
-	Name   string
-	Error  error
-	Output string
-	Result *PackageResult
+	Path          string
+	Name          string
+	Ignored       bool
+	Disabled      bool
+	BuildTags     []string
+	TestArguments []string
+	Error         error
+	Output        string
+	Result        *PackageResult
+
+	HasImportCycle bool
 }
 
-func NewPackage(path string) *Package {
+func NewPackage(folder *messaging.Folder, hasImportCycle bool) *Package {
 	self := new(Package)
-	self.Active = true
-	self.Path = path
-	self.Name = resolvePackageName(path)
+	self.Path = folder.Path
+	self.Name = resolvePackageName(self.Path)
 	self.Result = NewPackageResult(self.Name)
+	self.Ignored = folder.Ignored
+	self.Disabled = folder.Disabled
+	self.BuildTags = folder.BuildTags
+	self.TestArguments = folder.TestArguments
+	self.HasImportCycle = hasImportCycle
 	return self
 }
 
+func (self *Package) Active() bool {
+	return !self.Disabled && !self.Ignored
+}
+
+func (self *Package) HasUsableResult() bool {
+	return self.Active() && (self.Error == nil || (self.Output != ""))
+}
+
 type CompleteOutput struct {
 	Packages []*PackageResult
 	Revision string
@@ -33,6 +53,7 @@ type CompleteOutput struct {
 
 var ( // PackageResult.Outcome values:
 	Ignored         = "ignored"
+	Disabled        = "disabled"
 	Passed          = "passed"
 	Failed          = "failed"
 	Panicked        = "panicked"
@@ -40,6 +61,8 @@ var ( // PackageResult.Outcome values:
 	NoTestFiles     = "no test files"
 	NoTestFunctions = "no test functions"
 	NoGoFiles       = "no go code"
+
+	TestRunAbortedUnexpectedly = "test run aborted unexpectedly"
 )
 
 type PackageResult struct {
@@ -82,13 +105,13 @@ func NewTestResult(testName string) *TestResult {
 }
 
 func resolvePackageName(path string) string {
-	index := strings.Index(path, endGoPath)
-	if index < 0 {
-		return path
+	pkg, err := build.ImportDir(path, build.FindOnly)
+	if err == nil {
+		return pkg.ImportPath
 	}
-	packageBeginning := index + len(endGoPath)
-	name := path[packageBeginning:]
-	return name
+
+	nameArr := strings.Split(path, endGoPath)
+	return nameArr[len(nameArr)-1]
 }
 
 const (
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/coordinator.go b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/coordinator.go
index 2bbe1d58059..117dd56d65a 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/coordinator.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/coordinator.go
@@ -1,6 +1,8 @@
 package executor
 
 import (
+	"errors"
+	"fmt"
 	"log"
 	"strings"
 	"sync"
@@ -20,7 +22,6 @@ func (self *concurrentCoordinator) ExecuteConcurrently() {
 	self.enlistWorkers()
 	self.scheduleTasks()
 	self.awaitCompletion()
-	self.checkForErrors()
 }
 
 func (self *concurrentCoordinator) enlistWorkers() {
@@ -32,12 +33,19 @@ func (self *concurrentCoordinator) enlistWorkers() {
 func (self *concurrentCoordinator) worker(id int) {
 	for folder := range self.queue {
 		packageName := strings.Replace(folder.Name, "\\", "/", -1)
-		if !folder.Active {
+		if !folder.Active() {
 			log.Printf("Skipping concurrent execution: %s\n", packageName)
 			continue
 		}
-		log.Printf("Executing concurrent tests: %s\n", packageName)
-		folder.Output, folder.Error = self.shell.GoTest(folder.Path, packageName)
+
+		if folder.HasImportCycle {
+			message := fmt.Sprintf("can't load package: import cycle not allowed\npackage %s\n\timports %s", packageName, packageName)
+			log.Println(message)
+			folder.Output, folder.Error = message, errors.New(message)
+		} else {
+			log.Printf("Executing concurrent tests: %s\n", packageName)
+			folder.Output, folder.Error = self.shell.GoTest(folder.Path, packageName, folder.BuildTags, folder.TestArguments)
+		}
 	}
 	self.waiter.Done()
 }
@@ -53,19 +61,7 @@ func (self *concurrentCoordinator) awaitCompletion() {
 	self.waiter.Wait()
 }
 
-func (self *concurrentCoordinator) checkForErrors() {
-	for _, folder := range self.folders {
-		if hasUnexpectedError(folder) {
-			log.Println("Unexpected error at", folder.Path)
-			panic(folder.Error)
-		}
-	}
-}
-func hasUnexpectedError(folder *contract.Package) bool {
-	return folder.Error != nil && folder.Output == ""
-}
-
-func newCuncurrentCoordinator(folders []*contract.Package, batchSize int, shell contract.Shell) *concurrentCoordinator {
+func newConcurrentCoordinator(folders []*contract.Package, batchSize int, shell contract.Shell) *concurrentCoordinator {
 	self := new(concurrentCoordinator)
 	self.queue = make(chan *contract.Package)
 	self.folders = folders
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor.goconvey
new file mode 100644
index 00000000000..79982854b53
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor.goconvey
@@ -0,0 +1,2 @@
+#ignore
+-timeout=1s
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor_test.go
index dab0b846e9b..d7221b0dc12 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/executor_test.go
@@ -10,6 +10,8 @@ import (
 )
 
 func TestExecutor(t *testing.T) {
+	t.Skip("BROKEN!")
+
 	Convey("Subject: Execution of test packages and aggregation of parsed results", t, func() {
 		fixture := newExecutorFixture()
 
@@ -44,15 +46,6 @@ func TestExecutor(t *testing.T) {
 	})
 }
 
-func statusRotation(i, total int) string {
-	switch i % total {
-	case 0:
-		return Executing
-	default:
-		return Idle
-	}
-}
-
 type ExecutorFixture struct {
 	executor *Executor
 	tester   *FakeTester
@@ -97,8 +90,8 @@ func newExecutorFixture() *ExecutorFixture {
 	self.parser = newFakeParser()
 	self.executor = NewExecutor(self.tester, self.parser, make(chan chan string))
 	self.folders = []*contract.Package{
-		&contract.Package{Active: true, Path: prefix + packageA, Name: packageA},
-		&contract.Package{Active: true, Path: prefix + packageB, Name: packageB},
+		&contract.Package{Path: prefix + packageA, Name: packageA},
+		&contract.Package{Path: prefix + packageB, Name: packageB},
 	}
 	self.stamp = time.Now()
 	now = func() time.Time { return self.stamp }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/init_test.go
deleted file mode 100644
index 1dd90ef5f41..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package executor
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester.go b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester.go
index ab308b5b459..76f353a5baa 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester.go
@@ -1,7 +1,10 @@
 package executor
 
 import (
+	"errors"
+	"fmt"
 	"log"
+	"strings"
 
 	"github.com/smartystreets/goconvey/web/server/contract"
 )
@@ -20,21 +23,25 @@ func (self *ConcurrentTester) TestAll(folders []*contract.Package) {
 	if self.batchSize == 1 {
 		self.executeSynchronously(folders)
 	} else {
-		newCuncurrentCoordinator(folders, self.batchSize, self.shell).ExecuteConcurrently()
+		newConcurrentCoordinator(folders, self.batchSize, self.shell).ExecuteConcurrently()
 	}
 	return
 }
 
 func (self *ConcurrentTester) executeSynchronously(folders []*contract.Package) {
 	for _, folder := range folders {
-		if !folder.Active {
-			log.Printf("Skipping execution: %s\n", folder.Name)
+		packageName := strings.Replace(folder.Name, "\\", "/", -1)
+		if !folder.Active() {
+			log.Printf("Skipping execution: %s\n", packageName)
 			continue
 		}
-		log.Printf("Executing tests: %s\n", folder.Name)
-		folder.Output, folder.Error = self.shell.GoTest(folder.Path, folder.Name)
-		if folder.Error != nil && folder.Output == "" {
-			panic(folder.Error)
+		if folder.HasImportCycle {
+			message := fmt.Sprintf("can't load package: import cycle not allowed\npackage %s\n\timports %s", packageName, packageName)
+			log.Println(message)
+			folder.Output, folder.Error = message, errors.New(message)
+		} else {
+			log.Printf("Executing tests: %s\n", packageName)
+			folder.Output, folder.Error = self.shell.GoTest(folder.Path, packageName, folder.BuildTags, folder.TestArguments)
 		}
 	}
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester_test.go
index 386d0825f3c..d540c546d9a 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/executor/tester_test.go
@@ -3,6 +3,8 @@ package executor
 import (
 	"errors"
 	"fmt"
+	"io/ioutil"
+	"log"
 	"testing"
 	"time"
 
@@ -10,7 +12,13 @@ import (
 	"github.com/smartystreets/goconvey/web/server/contract"
 )
 
+func init() {
+	log.SetOutput(ioutil.Discard)
+}
+
 func TestConcurrentTester(t *testing.T) {
+	t.Skip("BROKEN!")
+
 	Convey("Subject: Controlled execution of test packages", t, func() {
 		fixture := NewTesterFixture()
 
@@ -56,22 +64,6 @@ func TestConcurrentTester(t *testing.T) {
 				So(fixture.recovered, ShouldBeNil)
 			})
 		})
-
-		Convey("When running a test package produces no output and exits with an error", func() {
-			fixture.InBatchesOf(1).SetupAbnormalError("This really shouldn't happen...").RunTests()
-
-			Convey("Panic should ensue", func() {
-				So(fixture.recovered.Error(), ShouldEqual, "This really shouldn't happen...")
-			})
-		})
-
-		Convey("When running test packages concurrently and a test package produces no output and exits with an error", func() {
-			fixture.InBatchesOf(concurrentBatchSize).SetupAbnormalError("This really shouldn't happen...").RunTests()
-
-			Convey("Panic should ensue", func() {
-				So(fixture.recovered.Error(), ShouldEqual, "This really shouldn't happen...")
-			})
-		})
 	})
 }
 
@@ -92,12 +84,13 @@ func NewTesterFixture() *TesterFixture {
 	self.shell = NewTimedShell()
 	self.tester = NewConcurrentTester(self.shell)
 	self.packages = []*contract.Package{
-		&contract.Package{Active: true, Path: "a"},
-		&contract.Package{Active: true, Path: "b"},
-		&contract.Package{Active: true, Path: "c"},
-		&contract.Package{Active: true, Path: "d"},
-		&contract.Package{Active: false, Path: "e"},
-		&contract.Package{Active: true, Path: "f"},
+		{Path: "a"},
+		{Path: "b"},
+		{Path: "c"},
+		{Path: "d"},
+		{Path: "e", Ignored: true},
+		{Path: "f"},
+		{Path: "g", HasImportCycle: true},
 	}
 	return self
 }
@@ -132,12 +125,16 @@ func (self *TesterFixture) RunTests() {
 }
 
 func (self *TesterFixture) ShouldHaveRecordOfExecutionCommands() {
-	expected := []string{"a", "b", "c", "d", "f"}
+	executed := []string{"a", "b", "c", "d", "f"}
+	ignored := "e"
+	importCycle := "g"
 	actual := []string{}
 	for _, pkg := range self.executions {
 		actual = append(actual, pkg.Command)
 	}
-	So(actual, ShouldResemble, expected)
+	So(actual, ShouldResemble, executed)
+	So(actual, ShouldNotContain, ignored)
+	So(actual, ShouldNotContain, importCycle)
 }
 
 func (self *TesterFixture) ShouldHaveOneOutputPerInput() {
@@ -146,12 +143,17 @@ func (self *TesterFixture) ShouldHaveOneOutputPerInput() {
 
 func (self *TesterFixture) OutputShouldBeAsExpected() {
 	for _, p := range self.packages {
-		if p.Active {
-			So(p.Output, ShouldEndWith, p.Path)
+		if p.HasImportCycle {
+			So(p.Output, ShouldContainSubstring, "can't load package: import cycle not allowed")
+			So(p.Error.Error(), ShouldContainSubstring, "can't load package: import cycle not allowed")
 		} else {
-			So(p.Output, ShouldBeBlank)
+			if p.Active() {
+				So(p.Output, ShouldEndWith, p.Path)
+			} else {
+				So(p.Output, ShouldBeBlank)
+			}
+			So(p.Error, ShouldBeNil)
 		}
-		So(p.Error, ShouldBeNil)
 	}
 }
 
@@ -212,7 +214,8 @@ func (self *TimedShell) MaxConcurrentCommands() int {
 }
 
 func concurrentWith(current, comparison *ShellCommand) bool {
-	return comparison.Started.After(current.Started) && comparison.Started.Before(current.Ended)
+	return ((comparison.Started == current.Started || comparison.Started.After(current.Started)) &&
+		(comparison.Started.Before(current.Ended)))
 }
 
 func (self *TimedShell) setTripWire(message string) {
@@ -223,7 +226,7 @@ func (self *TimedShell) setExitWithError() {
 	self.err = errors.New("Simulate test failure")
 }
 
-func (self *TimedShell) GoTest(directory, packageName string) (output string, err error) {
+func (self *TimedShell) GoTest(directory, packageName string, arguments, tags []string) (output string, err error) {
 	if self.panicMessage != "" {
 		return "", errors.New(self.panicMessage)
 	}
@@ -241,9 +244,6 @@ func (self *TimedShell) composeCommand(commandText string) *ShellCommand {
 	return &ShellCommand{commandText, start, end}
 }
 
-func (self *TimedShell) Getenv(key string) string       { panic("NOT SUPPORTED") }
-func (self *TimedShell) Setenv(key, value string) error { panic("NOT SUPPORTED") }
-
 func NewTimedShell() *TimedShell {
 	self := new(TimedShell)
 	self.executions = []*ShellCommand{}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/doc_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/doc_test.go
new file mode 100644
index 00000000000..cbb7a43f8ba
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/doc_test.go
@@ -0,0 +1 @@
+package messaging
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/messages.go b/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/messages.go
new file mode 100644
index 00000000000..7a92091162a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/messaging/messages.go
@@ -0,0 +1,56 @@
+package messaging
+
+///////////////////////////////////////////////////////////////////////////////
+
+type WatcherCommand struct {
+	Instruction WatcherInstruction
+	Details     string
+}
+
+type WatcherInstruction int
+
+func (this WatcherInstruction) String() string {
+	switch this {
+	case WatcherPause:
+		return "Pause"
+	case WatcherResume:
+		return "Resume"
+	case WatcherIgnore:
+		return "Ignore"
+	case WatcherReinstate:
+		return "Reinstate"
+	case WatcherAdjustRoot:
+		return "AdjustRoot"
+	case WatcherExecute:
+		return "Execute"
+	case WatcherStop:
+		return "Stop"
+	default:
+		return "UNKNOWN INSTRUCTION"
+	}
+}
+
+const (
+	WatcherPause WatcherInstruction = iota
+	WatcherResume
+	WatcherIgnore
+	WatcherReinstate
+	WatcherAdjustRoot
+	WatcherExecute
+	WatcherStop
+)
+
+///////////////////////////////////////////////////////////////////////////////
+
+type Folders map[string]*Folder
+
+type Folder struct {
+	Path          string // key
+	Root          string
+	Ignored       bool
+	Disabled      bool
+	BuildTags     []string
+	TestArguments []string
+}
+
+///////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/init_test.go
deleted file mode 100644
index 3b1461ae406..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package parser
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/packageParser.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/packageParser.go
index e5c0804bd63..628b137b39a 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/packageParser.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/packageParser.go
@@ -2,12 +2,18 @@ package parser
 
 import (
 	"fmt"
+	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/smartystreets/goconvey/web/server/contract"
 )
 
+var (
+	testNamePattern = regexp.MustCompile("^=== RUN:? +(.+)$")
+)
+
 func ParsePackageResults(result *contract.PackageResult, rawOutput string) {
 	newOutputParser(result, rawOutput).parse()
 }
@@ -19,8 +25,9 @@ type outputParser struct {
 	tests  []*contract.TestResult
 
 	// place holders for loops
-	line string
-	test *contract.TestResult
+	line    string
+	test    *contract.TestResult
+	testMap map[string]*contract.TestResult
 }
 
 func newOutputParser(result *contract.PackageResult, rawOutput string) *outputParser {
@@ -29,6 +36,7 @@ func newOutputParser(result *contract.PackageResult, rawOutput string) *outputPa
 	self.lines = strings.Split(self.raw, "\n")
 	self.result = result
 	self.tests = []*contract.TestResult{}
+	self.testMap = make(map[string]*contract.TestResult)
 	return self
 }
 
@@ -86,13 +94,19 @@ func (self *outputParser) processTestOutput() {
 }
 
 func (self *outputParser) registerTestFunction() {
-	self.test = contract.NewTestResult(self.line[len("=== RUN "):])
+	testName := testNamePattern.FindStringSubmatch(self.line)[1]
+	self.test = contract.NewTestResult(testName)
 	self.tests = append(self.tests, self.test)
+	self.testMap[self.test.TestName] = self.test
 }
 func (self *outputParser) recordTestMetadata() {
-	self.test.Passed = !strings.HasPrefix(self.line, "--- FAIL: ")
-	self.test.Skipped = strings.HasPrefix(self.line, "--- SKIP: ")
-	self.test.Elapsed = parseTestFunctionDuration(self.line)
+	testName := strings.Split(self.line, " ")[2]
+	if test, ok := self.testMap[testName]; ok {
+		self.test = test
+		self.test.Passed = !strings.HasPrefix(self.line, "--- FAIL: ")
+		self.test.Skipped = strings.HasPrefix(self.line, "--- SKIP: ")
+		self.test.Elapsed = parseTestFunctionDuration(self.line)
+	}
 }
 func (self *outputParser) recordPackageMetadata() {
 	if packageFailed(self.line) {
@@ -123,7 +137,7 @@ func (self *outputParser) recordCoverageSummary(summary string) {
 	}
 }
 func (self *outputParser) saveLineForParsingLater() {
-	self.line = strings.TrimSpace(self.line)
+	self.line = strings.TrimLeft(self.line, "\t")
 	if self.test == nil {
 		fmt.Println("Potential error parsing output of", self.result.PackageName, "; couldn't handle this stray line:", self.line)
 		return
@@ -131,6 +145,22 @@ func (self *outputParser) saveLineForParsingLater() {
 	self.test.RawLines = append(self.test.RawLines, self.line)
 }
 
+// TestResults is a collection of TestResults that implements sort.Interface.
+type TestResults []contract.TestResult
+
+func (r TestResults) Len() int {
+	return len(r)
+}
+
+// Less compares TestResults on TestName
+func (r TestResults) Less(i, j int) bool {
+	return r[i].TestName < r[j].TestName
+}
+
+func (r TestResults) Swap(i, j int) {
+	r[i], r[j] = r[j], r[i]
+}
+
 func (self *outputParser) parseEachTestFunction() {
 	for _, self.test = range self.tests {
 		self.test = parseTestOutput(self.test)
@@ -140,4 +170,5 @@ func (self *outputParser) parseEachTestFunction() {
 		self.test.RawLines = []string{}
 		self.result.TestResults = append(self.result.TestResults, *self.test)
 	}
+	sort.Sort(TestResults(self.result.TestResults))
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_go1.1_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_go1.1_test.go
deleted file mode 100644
index c6b3d463f9b..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_go1.1_test.go
+++ /dev/null
@@ -1,608 +0,0 @@
-// +build go1.1,!go1.2
-
-package parser
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/smartystreets/goconvey/convey/reporting"
-	"github.com/smartystreets/goconvey/web/server/contract"
-)
-
-func TestParsePackage_NoGoFiles_ReturnsPackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expected_NoGoFiles.PackageName}
-	ParsePackageResults(actual, input_NoGoFiles)
-	assertEqual(t, expected_NoGoFiles, *actual)
-}
-
-func TestParsePackage_NoTestFiles_ReturnsPackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expected_NoTestFiles.PackageName}
-	ParsePackageResults(actual, input_NoTestFiles)
-	assertEqual(t, expected_NoTestFiles, *actual)
-}
-
-func TestParsePacakge_NoTestFunctions_ReturnsPackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expected_NoTestFunctions.PackageName}
-	ParsePackageResults(actual, input_NoTestFunctions)
-	assertEqual(t, expected_NoTestFunctions, *actual)
-}
-
-func TestParsePackage_BuildFailed_ReturnsPackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expected_BuildFailed_InvalidPackageDeclaration.PackageName}
-	ParsePackageResults(actual, input_BuildFailed_InvalidPackageDeclaration)
-	assertEqual(t, expected_BuildFailed_InvalidPackageDeclaration, *actual)
-
-	actual = &contract.PackageResult{PackageName: expected_BuildFailed_OtherErrors.PackageName}
-	ParsePackageResults(actual, input_BuildFailed_OtherErrors)
-	assertEqual(t, expected_BuildFailed_OtherErrors, *actual)
-
-	actual = &contract.PackageResult{PackageName: expected_BuildFailed_CantFindPackage.PackageName}
-	ParsePackageResults(actual, input_BuildFailed_CantFindPackage)
-	assertEqual(t, expected_BuildFailed_CantFindPackage, *actual)
-}
-
-func TestParsePackage_OldSchoolWithFailureOutput_ReturnsCompletePackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expectedOldSchool_Fails.PackageName}
-	ParsePackageResults(actual, inputOldSchool_Fails)
-	assertEqual(t, expectedOldSchool_Fails, *actual)
-}
-
-func TestParsePackage_OldSchoolWithSuccessOutput_ReturnsCompletePackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expectedOldSchool_Passes.PackageName}
-	ParsePackageResults(actual, inputOldSchool_Passes)
-	assertEqual(t, expectedOldSchool_Passes, *actual)
-}
-
-func TestParsePackage_OldSchoolWithPanicOutput_ReturnsCompletePackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expectedOldSchool_Panics.PackageName}
-	ParsePackageResults(actual, inputOldSchool_Panics)
-	assertEqual(t, expectedOldSchool_Panics, *actual)
-}
-
-func TestParsePackage_GoConveyOutput_ReturnsCompletePackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expectedGoConvey.PackageName}
-	ParsePackageResults(actual, inputGoConvey)
-	assertEqual(t, expectedGoConvey, *actual)
-}
-
-func TestParsePackage_ActualPackageNameDifferentThanDirectoryName_ReturnsActualPackageName(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: strings.Replace(expectedGoConvey.PackageName, "examples", "stuff", -1)}
-	ParsePackageResults(actual, inputGoConvey)
-	assertEqual(t, expectedGoConvey, *actual)
-}
-
-func TestParsePackage_GoConveyOutputMalformed_CausesPanic(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			message := fmt.Sprintf("%v", r)
-			if !strings.Contains(message, "bug report") {
-				t.Errorf("Should have panicked with a request to file a bug report but we received this error instead: %s", message)
-			}
-		} else {
-			t.Errorf("Should have panicked with a request to file a bug report but we received no error.")
-		}
-	}()
-
-	actual := &contract.PackageResult{PackageName: expectedGoConvey.PackageName}
-	ParsePackageResults(actual, inputGoConvey_Malformed)
-}
-
-func TestParsePackage_GoConveyWithRandomOutput_ReturnsPackageResult(t *testing.T) {
-	actual := &contract.PackageResult{PackageName: expectedGoConvey_WithRandomOutput.PackageName}
-	ParsePackageResults(actual, inputGoConvey_WithRandomOutput)
-	assertEqual(t, expectedGoConvey_WithRandomOutput, *actual)
-}
-
-func assertEqual(t *testing.T, expected, actual interface{}) {
-	a, _ := json.Marshal(expected)
-	b, _ := json.Marshal(actual)
-	if string(a) != string(b) {
-		t.Errorf(failureTemplate, string(a), string(b))
-	}
-}
-
-const failureTemplate = "Comparison failed:\n  Expected: %v\n    Actual: %v\n"
-
-const input_NoGoFiles = `can't load package: package github.com/smartystreets/goconvey: no Go source files in /Users/matt/Work/Dev/goconvey/src/github.com/smartystreets/goconvey`
-
-var expected_NoGoFiles = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey",
-	Outcome:     contract.NoGoFiles,
-	BuildOutput: input_NoGoFiles,
-}
-
-const input_NoTestFiles = `?   	pkg.smartystreets.net/liveaddress-zipapi	[no test files]`
-
-var expected_NoTestFiles = contract.PackageResult{
-	PackageName: "pkg.smartystreets.net/liveaddress-zipapi",
-	Outcome:     contract.NoTestFiles,
-	BuildOutput: input_NoTestFiles,
-}
-
-const input_NoTestFunctions = `testing: warning: no tests to run`
-
-var expected_NoTestFunctions = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
-	Outcome:     contract.NoTestFunctions,
-	BuildOutput: input_NoTestFunctions,
-}
-
-const input_BuildFailed_InvalidPackageDeclaration = `
-can't load package: package github.com/smartystreets/goconvey/examples:
-bowling_game_test.go:9:1: expected 'package', found 'IDENT' asdf
-bowling_game_test.go:10:1: invalid package name _
-`
-
-var expected_BuildFailed_InvalidPackageDeclaration = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/examples",
-	Outcome:     contract.BuildFailure,
-	BuildOutput: strings.TrimSpace(input_BuildFailed_InvalidPackageDeclaration),
-}
-
-const input_BuildFailed_CantFindPackage = `
-bowling_game.go:3:8: cannot find package "format" in any of:
-	/usr/local/go/src/pkg/format (from $GOROOT)
-	/Users/mike/work/dev/goconvey/src/format (from $GOPATH)
-`
-
-var expected_BuildFailed_CantFindPackage = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/examples",
-	Outcome:     contract.BuildFailure,
-	BuildOutput: strings.TrimSpace(input_BuildFailed_CantFindPackage),
-}
-
-const input_BuildFailed_OtherErrors = `
-# github.com/smartystreets/goconvey/examples
-./bowling_game_test.go:22: undefined: game
-./bowling_game_test.go:22: cannot assign to game
-./bowling_game_test.go:25: undefined: game
-./bowling_game_test.go:28: undefined: game
-./bowling_game_test.go:33: undefined: game
-./bowling_game_test.go:36: undefined: game
-./bowling_game_test.go:41: undefined: game
-./bowling_game_test.go:42: undefined: game
-./bowling_game_test.go:43: undefined: game
-./bowling_game_test.go:46: undefined: game
-./bowling_game_test.go:46: too many errors
-FAIL	github.com/smartystreets/goconvey/examples [build failed]
-`
-
-var expected_BuildFailed_OtherErrors = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/examples",
-	Outcome:     contract.BuildFailure,
-	BuildOutput: strings.TrimSpace(input_BuildFailed_OtherErrors),
-}
-
-const inputOldSchool_Passes = `
-=== RUN TestOldSchool_Passes
---- PASS: TestOldSchool_Passes (0.02 seconds)
-=== RUN TestSkippingTests
---- SKIP: TestSkipping (0.00 seconds)
-	old_school_test.go:8: blah
-=== RUN TestOldSchool_PassesWithMessage
---- PASS: TestOldSchool_PassesWithMessage (0.05 seconds)
-	old_school_test.go:10: I am a passing test.
-		With a newline.
-PASS
-ok  	github.com/smartystreets/goconvey/webserver/examples	0.018s
-`
-
-var expectedOldSchool_Passes = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
-	Elapsed:     0.018,
-	Outcome:     contract.Passed,
-	TestResults: []contract.TestResult{
-		contract.TestResult{
-			TestName: "TestOldSchool_Passes",
-			Elapsed:  0.02,
-			Passed:   true,
-			File:     "",
-			Line:     0,
-			Message:  "",
-			Stories:  []reporting.ScopeResult{},
-		},
-		contract.TestResult{
-			TestName: "TestSkippingTests",
-			Elapsed:  0,
-			Passed:   true,
-			Skipped:  true,
-			File:     "old_school_test.go",
-			Line:     8,
-			Message:  "old_school_test.go:8: blah",
-			Stories:  []reporting.ScopeResult{},
-		},
-		contract.TestResult{
-			TestName: "TestOldSchool_PassesWithMessage",
-			Elapsed:  0.05,
-			Passed:   true,
-			File:     "old_school_test.go",
-			Line:     10,
-			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
-			Stories:  []reporting.ScopeResult{},
-		},
-	},
-}
-
-const inputOldSchool_Fails = `
-=== RUN TestOldSchool_Passes
---- PASS: TestOldSchool_Passes (0.01 seconds)
-=== RUN TestOldSchool_PassesWithMessage
---- PASS: TestOldSchool_PassesWithMessage (0.03 seconds)
-	old_school_test.go:10: I am a passing test.
-		With a newline.
-=== RUN TestOldSchool_Failure
---- FAIL: TestOldSchool_Failure (0.06 seconds)
-=== RUN TestOldSchool_FailureWithReason
---- FAIL: TestOldSchool_FailureWithReason (0.11 seconds)
-	old_school_test.go:18: I am a failing test.
-FAIL
-exit status 1
-FAIL	github.com/smartystreets/goconvey/webserver/examples	0.017s
-`
-
-var expectedOldSchool_Fails = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
-	Outcome:     contract.Failed,
-	Elapsed:     0.017,
-	TestResults: []contract.TestResult{
-		contract.TestResult{
-			TestName: "TestOldSchool_Passes",
-			Elapsed:  0.01,
-			Passed:   true,
-			File:     "",
-			Line:     0,
-			Message:  "",
-			Stories:  []reporting.ScopeResult{},
-		},
-		contract.TestResult{
-			TestName: "TestOldSchool_PassesWithMessage",
-			Elapsed:  0.03,
-			Passed:   true,
-			File:     "old_school_test.go",
-			Line:     10,
-			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
-			Stories:  []reporting.ScopeResult{},
-		},
-		contract.TestResult{
-			TestName: "TestOldSchool_Failure",
-			Elapsed:  0.06,
-			Passed:   false,
-			File:     "",
-			Line:     0,
-			Message:  "",
-			Stories:  []reporting.ScopeResult{},
-		},
-		contract.TestResult{
-			TestName: "TestOldSchool_FailureWithReason",
-			Elapsed:  0.11,
-			Passed:   false,
-			File:     "old_school_test.go",
-			Line:     18,
-			Message:  "old_school_test.go:18: I am a failing test.",
-			Stories:  []reporting.ScopeResult{},
-		},
-	},
-}
-
-const inputOldSchool_Panics = `
-=== RUN TestOldSchool_Panics
---- FAIL: TestOldSchool_Panics (0.02 seconds)
-panic: runtime error: index out of range [recovered]
-	panic: runtime error: index out of range
-
-goroutine 3 [running]:
-testing.func·004()
-	/usr/local/go/src/pkg/testing/testing.go:348 +0xcd
-github.com/smartystreets/goconvey/webserver/examples.TestOldSchool_Panics(0x210292000)
-	/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/something_test.go:15 +0xec
-testing.tRunner(0x210292000, 0x1b09f0)
-	/usr/local/go/src/pkg/testing/testing.go:353 +0x8a
-created by testing.RunTests
-	/usr/local/go/src/pkg/testing/testing.go:433 +0x86b
-
-goroutine 1 [chan receive]:
-testing.RunTests(0x138f38, 0x1b09f0, 0x1, 0x1, 0x1, ...)
-	/usr/local/go/src/pkg/testing/testing.go:434 +0x88e
-testing.Main(0x138f38, 0x1b09f0, 0x1, 0x1, 0x1b7f60, ...)
-	/usr/local/go/src/pkg/testing/testing.go:365 +0x8a
-main.main()
-	github.com/smartystreets/goconvey/webserver/examples/_test/_testmain.go:43 +0x9a
-exit status 2
-FAIL	github.com/smartystreets/goconvey/webserver/examples	0.014s
-`
-
-var expectedOldSchool_Panics = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
-	Elapsed:     0.014,
-	Outcome:     contract.Panicked,
-	TestResults: []contract.TestResult{
-		contract.TestResult{
-			TestName: "TestOldSchool_Panics",
-			Elapsed:  0.02,
-			Passed:   false,
-			File:     "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/something_test.go",
-			Line:     15,
-			Message:  "",
-			Error: strings.Replace(`panic: runtime error: index out of range [recovered]
-	panic: runtime error: index out of range
-
-goroutine 3 [running]:
-testing.func·004()
-	/usr/local/go/src/pkg/testing/testing.go:348 +0xcd
-github.com/smartystreets/goconvey/webserver/examples.TestOldSchool_Panics(0x210292000)
-	/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/something_test.go:15 +0xec
-testing.tRunner(0x210292000, 0x1b09f0)
-	/usr/local/go/src/pkg/testing/testing.go:353 +0x8a
-created by testing.RunTests
-	/usr/local/go/src/pkg/testing/testing.go:433 +0x86b
-
-goroutine 1 [chan receive]:
-testing.RunTests(0x138f38, 0x1b09f0, 0x1, 0x1, 0x1, ...)
-	/usr/local/go/src/pkg/testing/testing.go:434 +0x88e
-testing.Main(0x138f38, 0x1b09f0, 0x1, 0x1, 0x1b7f60, ...)
-	/usr/local/go/src/pkg/testing/testing.go:365 +0x8a
-main.main()
-	github.com/smartystreets/goconvey/webserver/examples/_test/_testmain.go:43 +0x9a`, "\u0009", "\t", -1),
-			Stories: []reporting.ScopeResult{},
-		},
-	},
-}
-
-const inputGoConvey_Malformed = `
-=== RUN TestPassingStory
->>>>>
-{
-  "Title": "A passing story",
-  "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-  "Line": 11,
-  "Depth": 0,
-  "Assertions": [
-    {
-      "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-      "Line": 10,
-      "Failure": "",
-
-      ;aiwheopinen39 n3902n92m
-
-      "Error": null,
-      "Skipped": false,
-      "StackTrace": "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/webserver/examples.func·001()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:10 +0xe3\ngithub.com/smartystreets/goconvey/webserver/examples.TestPassingStory(0x210314000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:11 +0xec\ntesting.tRunner(0x210314000, 0x21ab10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n"
-    }
-  ]
-},
-<<<<<
---- PASS: TestPassingStory (0.01 seconds)
-PASS
-ok  	github.com/smartystreets/goconvey/webserver/examples	0.019s
-`
-
-const inputGoConvey = `
-=== RUN TestPassingStory
->>>>>
-{
-  "Title": "A passing story",
-  "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-  "Line": 11,
-  "Depth": 0,
-  "Assertions": [
-    {
-      "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-      "Line": 10,
-      "Failure": "",
-      "Error": null,
-      "Skipped": false,
-      "StackTrace": "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/webserver/examples.func·001()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:10 +0xe3\ngithub.com/smartystreets/goconvey/webserver/examples.TestPassingStory(0x210314000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:11 +0xec\ntesting.tRunner(0x210314000, 0x21ab10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n"
-    }
-  ]
-},
-<<<<<
---- PASS: TestPassingStory (0.01 seconds)
-PASS
-ok  	github.com/smartystreets/goconvey/webserver/examples	0.019s
-`
-
-var expectedGoConvey = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
-	Elapsed:     0.019,
-	Outcome:     contract.Passed,
-	TestResults: []contract.TestResult{
-		contract.TestResult{
-			TestName: "TestPassingStory",
-			Elapsed:  0.01,
-			Passed:   true,
-			File:     "",
-			Line:     0,
-			Message:  "",
-			Stories: []reporting.ScopeResult{
-				reporting.ScopeResult{
-					Title: "A passing story",
-					File:  "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-					Line:  11,
-					Depth: 0,
-					Assertions: []*reporting.AssertionResult{
-						&reporting.AssertionResult{
-							File:       "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
-							Line:       10,
-							Failure:    "",
-							Error:      nil,
-							Skipped:    false,
-							StackTrace: "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/webserver/examples.func·001()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:10 +0xe3\ngithub.com/smartystreets/goconvey/webserver/examples.TestPassingStory(0x210314000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go:11 +0xec\ntesting.tRunner(0x210314000, 0x21ab10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n",
-						},
-					},
-				},
-			},
-		},
-	},
-}
-
-const inputGoConvey_WithRandomOutput = `
-=== RUN TestPassingStory
-*** Hello, World! (1) ***
-*** Hello, World! (2) ***
-*** Hello, World! (3) ***>>>>>
-{
-  "Title": "A passing story",
-  "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-  "Line": 16,
-  "Depth": 0,
-  "Assertions": [
-    {
-      "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-      "Line": 14,
-      "Failure": "",
-      "Error": null,
-      "Skipped": false,
-      "StackTrace": "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/web/server/testing.func·001()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:14 +0x186\ngithub.com/smartystreets/goconvey/web/server/testing.TestPassingStory(0x210315000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:16 +0x1b9\ntesting.tRunner(0x210315000, 0x21bb10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n"
-    }
-  ]
-},
-<<<<<
-*** Hello, World! (4)***
-*** Hello, World! (5) ***
->>>>>
-{
-  "Title": "A passing story",
-  "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-  "Line": 22,
-  "Depth": 0,
-  "Assertions": [
-    {
-      "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-      "Line": 20,
-      "Failure": "",
-      "Error": null,
-      "Skipped": false,
-      "StackTrace": "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/web/server/testing.func·002()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:20 +0x186\ngithub.com/smartystreets/goconvey/web/server/testing.TestPassingStory(0x210315000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:22 +0x294\ntesting.tRunner(0x210315000, 0x21bb10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n"
-    }
-  ]
-},
-<<<<<
-*** Hello, World! (6) ***
---- PASS: TestPassingStory (0.03 seconds)
-PASS
-ok  	github.com/smartystreets/goconvey/web/server/testing	0.024s
-`
-
-var expectedGoConvey_WithRandomOutput = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/web/server/testing",
-	Elapsed:     0.024,
-	Outcome:     contract.Passed,
-	TestResults: []contract.TestResult{
-		contract.TestResult{
-			TestName: "TestPassingStory",
-			Elapsed:  0.03,
-			Passed:   true,
-			File:     "",
-			Line:     0,
-			Message:  "*** Hello, World! (1) ***\n*** Hello, World! (2) ***\n*** Hello, World! (3) ***\n*** Hello, World! (4)***\n*** Hello, World! (5) ***\n*** Hello, World! (6) ***",
-			Stories: []reporting.ScopeResult{
-				reporting.ScopeResult{
-					Title: "A passing story",
-					File:  "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-					Line:  16,
-					Depth: 0,
-					Assertions: []*reporting.AssertionResult{
-						&reporting.AssertionResult{
-							File:       "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-							Line:       14,
-							Failure:    "",
-							Error:      nil,
-							Skipped:    false,
-							StackTrace: "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/web/server/testing.func·001()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:14 +0x186\ngithub.com/smartystreets/goconvey/web/server/testing.TestPassingStory(0x210315000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:16 +0x1b9\ntesting.tRunner(0x210315000, 0x21bb10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n",
-						},
-					},
-				},
-				reporting.ScopeResult{
-					Title: "A passing story",
-					File:  "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-					Line:  22,
-					Depth: 0,
-					Assertions: []*reporting.AssertionResult{
-						&reporting.AssertionResult{
-							File:       "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
-							Line:       20,
-							Failure:    "",
-							Error:      nil,
-							Skipped:    false,
-							StackTrace: "goroutine 3 [running]:\ngithub.com/smartystreets/goconvey/web/server/testing.func·002()\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:20 +0x186\ngithub.com/smartystreets/goconvey/web/server/testing.TestPassingStory(0x210315000)\n\u0009/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go:22 +0x294\ntesting.tRunner(0x210315000, 0x21bb10)\n\u0009/usr/local/go/src/pkg/testing/testing.go:353 +0x8a\ncreated by testing.RunTests\n\u0009/usr/local/go/src/pkg/testing/testing.go:433 +0x86b\n",
-						},
-					},
-				},
-			},
-		},
-	},
-}
-
-/*
-Test output for these tests was generated from the following test code:
-
-Old School style tests:
-
-	package examples
-
-	import "testing"
-
-	func TestOldSchool_Passes(t *testing.T) {
-		// passes implicitly
-	}
-
-	func TestOldSchool_PassesWithMessage(t *testing.T) {
-		t.Log("I am a passing test.\nWith a newline.")
-	}
-
-	func TestOldSchool_Failure(t *testing.T) {
-		t.Fail() // no message
-	}
-
-	func TestOldSchool_FailureWithReason(t *testing.T) {
-		t.Error("I am a failing test.")
-	}
-
-GoConvey style tests:
-
-	package examples
-
-	import (
-		. "github.com/smartystreets/goconvey/convey"
-		"testing"
-	)
-
-	func TestPassingStory(t *testing.T) {
-		Convey("A passing story", t, func() {
-			So("This test passes", ShouldContainSubstring, "pass")
-		})
-	}
-
-GoConvey style tests with random output:
-
-	package examples
-
-	import (
-		"fmt"
-		. "github.com/smartystreets/goconvey/convey"
-		"testing"
-	)
-
-	func TestPassingStory(t *testing.T) {
-		fmt.Println("*** Hello, World! (1) ***")
-
-		Convey("A passing story", t, func() {
-			fmt.Println("*** Hello, World! (2) ***")
-			So("This test passes", ShouldContainSubstring, "pass")
-			fmt.Println("*** Hello, World! (3) ***")
-		})
-
-		Convey("A passing story", t, func() {
-			fmt.Println("*** Hello, World! (4)***")
-			So("This test passes", ShouldContainSubstring, "pass")
-			fmt.Println("*** Hello, World! (5) ***")
-		})
-
-		fmt.Println("*** Hello, World! (6) ***")
-	}
-
-
-*/
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_go1.2_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_test.go
index b4f045c678d..65f3f9830bf 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_go1.2_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/package_parser_test.go
@@ -1,10 +1,10 @@
-// +build go1.2
-
 package parser
 
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"log"
 	"strings"
 	"testing"
 
@@ -12,6 +12,10 @@ import (
 	"github.com/smartystreets/goconvey/web/server/contract"
 )
 
+func init() {
+	log.SetOutput(ioutil.Discard)
+}
+
 func TestParsePackage_NoGoFiles_ReturnsPackageResult(t *testing.T) {
 	actual := &contract.PackageResult{PackageName: expected_NoGoFiles.PackageName}
 	ParsePackageResults(actual, input_NoGoFiles)
@@ -39,9 +43,17 @@ func TestParsePackage_BuildFailed_ReturnsPackageResult(t *testing.T) {
 	ParsePackageResults(actual, input_BuildFailed_OtherErrors)
 	assertEqual(t, expected_BuildFailed_OtherErrors, *actual)
 
+	actual = &contract.PackageResult{PackageName: expected_BuildFailed_ImportCycle.PackageName}
+	ParsePackageResults(actual, input_BuildFailed_ImportCycle)
+	assertEqual(t, expected_BuildFailed_ImportCycle, *actual)
+
 	actual = &contract.PackageResult{PackageName: expected_BuildFailed_CantFindPackage.PackageName}
 	ParsePackageResults(actual, input_BuildFailed_CantFindPackage)
 	assertEqual(t, expected_BuildFailed_CantFindPackage, *actual)
+
+	actual = &contract.PackageResult{PackageName: expected_BuildFailed_ConflictingImport.PackageName}
+	ParsePackageResults(actual, input_BuildFailed_ConfictingImport)
+	assertEqual(t, expected_BuildFailed_ConflictingImport, *actual)
 }
 
 func TestParsePackage_OldSchoolWithFailureOutput_ReturnsCompletePackageResult(t *testing.T) {
@@ -102,6 +114,24 @@ func TestParsePackage_OldSchoolWithSuccessAndBogusCoverage_ReturnsCompletePackag
 	assertEqual(t, expectedOldSchool_PassesButCoverageIsBogus, *actual)
 }
 
+func TestParsePackage_NestedTests_ReturnsPackageResult(t *testing.T) {
+	actual := &contract.PackageResult{PackageName: expectedNestedTests.PackageName}
+	ParsePackageResults(actual, inputNestedTests)
+	assertEqual(t, expectedNestedTests, *actual)
+}
+
+func TestParsePackage_WithExampleFunctions_ReturnsPackageResult(t *testing.T) {
+	actual := &contract.PackageResult{PackageName: expectedExampleFunctions.PackageName}
+	ParsePackageResults(actual, inputExampleFunctions)
+	assertEqual(t, expectedExampleFunctions, *actual)
+}
+
+func TestParsePackage_Golang15Output_ShouldNotPanic(t *testing.T) {
+	actual := &contract.PackageResult{PackageName: expectedGolang15.PackageName}
+	ParsePackageResults(actual, inputGolang15)
+	assertEqual(t, expectedGolang15, *actual)
+}
+
 func assertEqual(t *testing.T, expected, actual interface{}) {
 	a, _ := json.Marshal(expected)
 	b, _ := json.Marshal(actual)
@@ -133,7 +163,7 @@ PASS
 ok  	github.com/smartystreets/goconvey/scripts	0.011s`
 
 var expected_NoTestFunctions = contract.PackageResult{
-	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
+	PackageName: "github.com/smartystreets/goconvey/scripts",
 	Outcome:     contract.NoTestFunctions,
 	BuildOutput: input_NoTestFunctions,
 }
@@ -163,6 +193,16 @@ var expected_BuildFailed_CantFindPackage = contract.PackageResult{
 	BuildOutput: strings.TrimSpace(input_BuildFailed_CantFindPackage),
 }
 
+const input_BuildFailed_ConfictingImport = `
+mutustus.go:4:2: found packages e (e.go) and err (prepend.go) in /Users/mike/src/utensils.git/e
+`
+
+var expected_BuildFailed_ConflictingImport = contract.PackageResult{
+	PackageName: "github.com/smartystreets/goconvey/examples",
+	Outcome:     contract.BuildFailure,
+	BuildOutput: strings.TrimSpace(input_BuildFailed_ConfictingImport),
+}
+
 const input_BuildFailed_OtherErrors = `
 # github.com/smartystreets/goconvey/examples
 ./bowling_game_test.go:22: undefined: game
@@ -185,18 +225,30 @@ var expected_BuildFailed_OtherErrors = contract.PackageResult{
 	BuildOutput: strings.TrimSpace(input_BuildFailed_OtherErrors),
 }
 
+const input_BuildFailed_ImportCycle = `
+# github.com/smartystreets/goconvey/t
+./t_test.go:23: import "github.com/smartystreets/goconvey/t" while compiling that package (import cycle)
+FAIL	github.com/smartystreets/goconvey/t [build failed]
+`
+
+var expected_BuildFailed_ImportCycle = contract.PackageResult{
+	PackageName: "github.com/smartystreets/goconvey/t",
+	Outcome:     contract.BuildFailure,
+	BuildOutput: strings.TrimSpace(input_BuildFailed_ImportCycle),
+}
+
 const inputOldSchool_Passes = `
 === RUN TestOldSchool_Passes
 --- PASS: TestOldSchool_Passes (0.02 seconds)
 === RUN TestSkippingTests
---- SKIP: TestSkipping (0.00 seconds)
+--- SKIP: TestSkippingTests (0.00 seconds)
 	old_school_test.go:8: blah
 === RUN TestOldSchool_PassesWithMessage
 --- PASS: TestOldSchool_PassesWithMessage (0.05 seconds)
 	old_school_test.go:10: I am a passing test.
 		With a newline.
 PASS
-coverage: 100.0%% of statements
+coverage: 100.0%% of statements in github.com/smartystreets/goconvey/convey, github.com/smartystreets/goconvey/convey/gotest, github.com/smartystreets/goconvey/convey/reporting
 ok  	github.com/smartystreets/goconvey/webserver/examples	0.018s
 `
 
@@ -216,22 +268,22 @@ var expectedOldSchool_Passes = contract.PackageResult{
 			Stories:  []reporting.ScopeResult{},
 		},
 		contract.TestResult{
-			TestName: "TestSkippingTests",
-			Elapsed:  0,
+			TestName: "TestOldSchool_PassesWithMessage",
+			Elapsed:  0.05,
 			Passed:   true,
-			Skipped:  true,
 			File:     "old_school_test.go",
-			Line:     8,
-			Message:  "old_school_test.go:8: blah",
+			Line:     10,
+			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
 			Stories:  []reporting.ScopeResult{},
 		},
 		contract.TestResult{
-			TestName: "TestOldSchool_PassesWithMessage",
-			Elapsed:  0.05,
+			TestName: "TestSkippingTests",
+			Elapsed:  0,
 			Passed:   true,
+			Skipped:  true,
 			File:     "old_school_test.go",
-			Line:     10,
-			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
+			Line:     8,
+			Message:  "old_school_test.go:8: blah",
 			Stories:  []reporting.ScopeResult{},
 		},
 	},
@@ -260,39 +312,39 @@ var expectedOldSchool_Fails = contract.PackageResult{
 	Elapsed:     0.017,
 	TestResults: []contract.TestResult{
 		contract.TestResult{
-			TestName: "TestOldSchool_Passes",
-			Elapsed:  0.01,
-			Passed:   true,
+			TestName: "TestOldSchool_Failure",
+			Elapsed:  0.06,
+			Passed:   false,
 			File:     "",
 			Line:     0,
 			Message:  "",
 			Stories:  []reporting.ScopeResult{},
 		},
 		contract.TestResult{
-			TestName: "TestOldSchool_PassesWithMessage",
-			Elapsed:  0.03,
-			Passed:   true,
+			TestName: "TestOldSchool_FailureWithReason",
+			Elapsed:  0.11,
+			Passed:   false,
 			File:     "old_school_test.go",
-			Line:     10,
-			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
+			Line:     18,
+			Message:  "old_school_test.go:18: I am a failing test.",
 			Stories:  []reporting.ScopeResult{},
 		},
 		contract.TestResult{
-			TestName: "TestOldSchool_Failure",
-			Elapsed:  0.06,
-			Passed:   false,
+			TestName: "TestOldSchool_Passes",
+			Elapsed:  0.01,
+			Passed:   true,
 			File:     "",
 			Line:     0,
 			Message:  "",
 			Stories:  []reporting.ScopeResult{},
 		},
 		contract.TestResult{
-			TestName: "TestOldSchool_FailureWithReason",
-			Elapsed:  0.11,
-			Passed:   false,
+			TestName: "TestOldSchool_PassesWithMessage",
+			Elapsed:  0.03,
+			Passed:   true,
 			File:     "old_school_test.go",
-			Line:     18,
-			Message:  "old_school_test.go:18: I am a failing test.",
+			Line:     10,
+			Message:  "old_school_test.go:10: I am a passing test.\nWith a newline.",
 			Stories:  []reporting.ScopeResult{},
 		},
 	},
@@ -364,7 +416,7 @@ main.main()
 
 const inputGoConvey_Malformed = `
 === RUN TestPassingStory
->>>>>
+>->->OPEN-JSON->->->
 {
   "Title": "A passing story",
   "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
@@ -384,7 +436,7 @@ const inputGoConvey_Malformed = `
     }
   ]
 },
-<<<<<
+<-<-<-CLOSE-JSON<-<-<
 --- PASS: TestPassingStory (0.01 seconds)
 PASS
 ok  	github.com/smartystreets/goconvey/webserver/examples	0.019s
@@ -392,7 +444,7 @@ ok  	github.com/smartystreets/goconvey/webserver/examples	0.019s
 
 const inputGoConvey = `
 === RUN TestPassingStory
->>>>>
+>->->OPEN-JSON->->->
 {
   "Title": "A passing story",
   "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/webserver/examples/old_school_test.go",
@@ -409,7 +461,7 @@ const inputGoConvey = `
     }
   ]
 },
-<<<<<
+<-<-<-CLOSE-JSON<-<-<
 --- PASS: TestPassingStory (0.01 seconds)
 PASS
 coverage: 75.5%% of statements
@@ -455,7 +507,7 @@ const inputGoConvey_WithRandomOutput = `
 === RUN TestPassingStory
 *** Hello, World! (1) ***
 *** Hello, World! (2) ***
-*** Hello, World! (3) ***>>>>>
+*** Hello, World! (3) ***>->->OPEN-JSON->->->
 {
   "Title": "A passing story",
   "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
@@ -472,10 +524,10 @@ const inputGoConvey_WithRandomOutput = `
     }
   ]
 },
-<<<<<
+<-<-<-CLOSE-JSON<-<-<
 *** Hello, World! (4)***
 *** Hello, World! (5) ***
->>>>>
+>->->OPEN-JSON->->->
 {
   "Title": "A passing story",
   "File": "/Users/mike/work/dev/goconvey/src/github.com/smartystreets/goconvey/web/server/testing/go_test.go",
@@ -492,7 +544,7 @@ const inputGoConvey_WithRandomOutput = `
     }
   ]
 },
-<<<<<
+<-<-<-CLOSE-JSON<-<-<
 *** Hello, World! (6) ***
 --- PASS: TestPassingStory (0.03 seconds)
 PASS
@@ -589,3 +641,152 @@ var expectedOldSchool_PassesButCoverageIsBogus = contract.PackageResult{
 		},
 	},
 }
+
+const inputNestedTests = `
+=== RUN TestNestedTests
+=== RUN TestNestedTests_Passes
+--- PASS: TestNestedTests_Passes (0.02 seconds)
+=== RUN TestNestedTests_Failure
+--- FAIL: TestNestedTests_Failure (0.06 seconds)
+=== RUN TestNestedTests_FailureWithReason
+--- FAIL: TestNestedTests_FailureWithReason (0.11 seconds)
+	nested_test.go:18: I am a failing test.
+=== RUN TestNestedTests_Skipping
+--- SKIP: TestNestedTests_Skipping (0.00 seconds)
+	nested_test.go:8: blah
+=== RUN TestNestedTests_PassesWithMessage
+--- PASS: TestNestedTests_PassesWithMessage (0.05 seconds)
+	nested_test.go:10: I am a passing test.
+		With a newline.
+--- FAIL: TestNestedTests (0.25 seconds)
+FAIL
+exit status 1
+FAIL	github.com/smartystreets/goconvey/webserver/examples	0.018s
+`
+
+var expectedNestedTests = contract.PackageResult{
+	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
+	Elapsed:     0.018,
+	Outcome:     contract.Failed,
+	TestResults: []contract.TestResult{
+		contract.TestResult{
+			TestName: "TestNestedTests",
+			Elapsed:  0.25,
+			Passed:   false,
+			File:     "",
+			Line:     0,
+			Message:  "",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "TestNestedTests_Failure",
+			Elapsed:  0.06,
+			Passed:   false,
+			File:     "",
+			Line:     0,
+			Message:  "",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "TestNestedTests_FailureWithReason",
+			Elapsed:  0.11,
+			Passed:   false,
+			File:     "nested_test.go",
+			Line:     18,
+			Message:  "nested_test.go:18: I am a failing test.",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "TestNestedTests_Passes",
+			Elapsed:  0.02,
+			Passed:   true,
+			File:     "",
+			Line:     0,
+			Message:  "",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "TestNestedTests_PassesWithMessage",
+			Elapsed:  0.05,
+			Passed:   true,
+			File:     "nested_test.go",
+			Line:     10,
+			Message:  "nested_test.go:10: I am a passing test.\nWith a newline.",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "TestNestedTests_Skipping",
+			Elapsed:  0.00,
+			Passed:   true,
+			Skipped:  true,
+			File:     "nested_test.go",
+			Line:     8,
+			Message:  "nested_test.go:8: blah",
+			Stories:  []reporting.ScopeResult{},
+		},
+	},
+}
+
+const inputExampleFunctions = `
+=== RUN Example_Failure
+--- FAIL: Example_Failure (0.11 seconds)
+got:
+actuall output
+want:
+real output
+=== RUN Example_Pass
+--- PASS: Example_Pass (0.06 seconds)
+FAIL
+exit status 1
+FAIL	github.com/smartystreets/goconvey/webserver/examples	0.18s
+`
+
+var expectedExampleFunctions = contract.PackageResult{
+	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
+	Elapsed:     0.18,
+	Outcome:     contract.Failed,
+	TestResults: []contract.TestResult{
+		contract.TestResult{
+			TestName: "Example_Failure",
+			Elapsed:  0.11,
+			Passed:   false,
+			File:     "",
+			Line:     0,
+			Message:  "got:\nactuall output\nwant:\nreal output",
+			Stories:  []reporting.ScopeResult{},
+		},
+		contract.TestResult{
+			TestName: "Example_Pass",
+			Elapsed:  0.06,
+			Passed:   true,
+			File:     "",
+			Line:     0,
+			Message:  "",
+			Stories:  []reporting.ScopeResult{},
+		},
+	},
+}
+
+const inputGolang15 = `
+=== RUN   Golang15
+--- PASS: Golang15 (0.00s)
+PASS
+ok  	github.com/smartystreets/goconvey/webserver/examples	0.008s
+`
+
+var expectedGolang15 = contract.PackageResult{
+	PackageName: "github.com/smartystreets/goconvey/webserver/examples",
+	Elapsed:     0.008,
+	Outcome:     contract.Passed,
+	TestResults: []contract.TestResult{
+		contract.TestResult{
+			TestName: "Golang15",
+			Elapsed:  0.00,
+			Passed:   true,
+			File:     "",
+			Line:     0,
+			Message:  "",
+			Stories:  []reporting.ScopeResult{},
+		},
+	},
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.go
index 6ff525d9279..f6250caf346 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.go
@@ -12,10 +12,14 @@ type Parser struct {
 
 func (self *Parser) Parse(packages []*contract.Package) {
 	for _, p := range packages {
-		if p.Active {
+		if p.Active() && p.HasUsableResult() {
 			self.parser(p.Result, p.Output)
-		} else {
+		} else if p.Ignored {
 			p.Result.Outcome = contract.Ignored
+		} else if p.Disabled {
+			p.Result.Outcome = contract.Disabled
+		} else {
+			p.Result.Outcome = contract.TestRunAbortedUnexpectedly
 		}
 		log.Printf("[%s]: %s\n", p.Result.Outcome, p.Name)
 	}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.goconvey
new file mode 100644
index 00000000000..79982854b53
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser.goconvey
@@ -0,0 +1,2 @@
+#ignore
+-timeout=1s
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser_test.go
index 12290cd3b72..de695e3fd7e 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/parser_test.go
@@ -1,6 +1,7 @@
 package parser
 
 import (
+	"errors"
 	"testing"
 
 	. "github.com/smartystreets/goconvey/convey"
@@ -8,14 +9,12 @@ import (
 )
 
 func TestParser(t *testing.T) {
-	var (
-		packages = []*contract.Package{
-			&contract.Package{Active: true, Output: "Active!", Result: contract.NewPackageResult("asdf")},
-			&contract.Package{Active: false, Output: "Inactive!", Result: contract.NewPackageResult("qwer")},
-		}
-	)
 
 	Convey("Subject: Parser parses test output for active packages", t, func() {
+		packages := []*contract.Package{
+			&contract.Package{Ignored: false, Output: "Active", Result: contract.NewPackageResult("asdf")},
+			&contract.Package{Ignored: true, Output: "Inactive", Result: contract.NewPackageResult("qwer")},
+		}
 		parser := NewParser(fakeParserImplementation)
 
 		Convey("When given a collection of packages", func() {
@@ -29,6 +28,17 @@ func TestParser(t *testing.T) {
 				So(packages[1].Result.Outcome, ShouldEqual, contract.Ignored)
 			})
 		})
+
+		Convey("When a package could not be tested (maybe it was deleted between scanning and execution?)", func() {
+			packages[0].Output = ""
+			packages[0].Error = errors.New("Directory does not exist")
+
+			parser.Parse(packages)
+
+			Convey("The package result should not be parsed and the outcome should actually resemble the problem", func() {
+				So(packages[0].Result.Outcome, ShouldEqual, contract.TestRunAbortedUnexpectedly)
+			})
+		})
 	})
 }
 
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules_go1.2.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules.go
index 78b5d36a560..f8d05d83066 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules_go1.2.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules.go
@@ -1,5 +1,3 @@
-// +build go1.2
-
 package parser
 
 import "strings"
@@ -11,7 +9,8 @@ func noGoFiles(line string) bool {
 func buildFailed(line string) bool {
 	return strings.HasPrefix(line, "# ") ||
 		strings.Contains(line, "cannot find package") ||
-		(strings.HasPrefix(line, "can't load package: ") && !strings.Contains(line, ": no Go source files in "))
+		(strings.HasPrefix(line, "can't load package: ") && !strings.Contains(line, ": no Go source files in ")) ||
+		(strings.Contains(line, ": found packages ") && strings.Contains(line, ".go) and ") && strings.Contains(line, ".go) in "))
 }
 func noTestFunctions(line string) bool {
 	return line == "testing: warning: no tests to run"
@@ -40,5 +39,5 @@ func packagePassed(line string) bool {
 	return strings.HasPrefix(line, "ok  \t")
 }
 func isCoverageSummary(line string) bool {
-	return strings.HasPrefix(line, "coverage: ") && strings.HasSuffix(line, "% of statements")
+	return strings.HasPrefix(line, "coverage: ") && strings.Contains(line, "% of statements")
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules_go1.1.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules_go1.1.go
deleted file mode 100644
index ed3cdf836a4..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/rules_go1.1.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// +build go1.1,!go1.2
-
-package parser
-
-import "strings"
-
-func noGoFiles(line string) bool {
-	return strings.HasPrefix(line, "can't load package: ") &&
-		strings.Contains(line, ": no Go source files in ")
-}
-func buildFailed(line string) bool {
-	return strings.HasPrefix(line, "# ") ||
-		strings.Contains(line, "cannot find package") ||
-		(strings.HasPrefix(line, "can't load package: ") && !strings.Contains(line, ": no Go source files in "))
-}
-func noTestFunctions(line string) bool {
-	return line == "testing: warning: no tests to run"
-}
-func noTestFiles(line string) bool {
-	return strings.HasPrefix(line, "?") && strings.Contains(line, "[no test files]")
-}
-func isNewTest(line string) bool {
-	return strings.HasPrefix(line, "=== ")
-}
-func isTestResult(line string) bool {
-	return strings.HasPrefix(line, "--- ")
-}
-func isPackageReport(line string) bool {
-	return (strings.HasPrefix(line, "FAIL") ||
-		strings.HasPrefix(line, "exit status") ||
-		strings.HasPrefix(line, "PASS") ||
-		strings.HasPrefix(line, "ok  \t"))
-}
-
-func packageFailed(line string) bool {
-	return strings.HasPrefix(line, "FAIL\t")
-}
-func packagePassed(line string) bool {
-	return strings.HasPrefix(line, "ok  \t")
-}
-func isCoverageSummary(line string) bool {
-	return false
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/testParser.go b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/testParser.go
index 4fc94e340e7..fe8f5110b6c 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/parser/testParser.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/parser/testParser.go
@@ -128,9 +128,6 @@ func (self *testParser) composeCapturedOutput() {
 	self.test.Message = strings.Join(self.otherLines, "\n")
 }
 
-func isJson(line string) bool {
-	return strings.HasPrefix(line, "{")
-}
 func createArrayForJsonItems(lines []string) []byte {
 	jsonArrayItems := strings.Join(lines, "")
 	jsonArrayItems = removeTrailingComma(jsonArrayItems)
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor.go
deleted file mode 100644
index 01a174e3715..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package system
-
-import "os/exec"
-
-type Executor interface {
-	Execute(directory, name string, arguments ...string) (output string, err error)
-}
-
-type CommandExecutor struct{}
-
-func (self *CommandExecutor) Execute(directory, name string, arguments ...string) (output string, err error) {
-	command := exec.Command(name, arguments...)
-	command.Dir = directory
-	rawOutput, err := command.CombinedOutput()
-	output = string(rawOutput)
-	return
-}
-
-func NewCommandExecutor() *CommandExecutor {
-	return new(CommandExecutor)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor_test.go
deleted file mode 100644
index 0b81452b294..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/executor_test.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package system
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-)
-
-type CommandRecorder struct {
-	test TestCase
-}
-
-func (self *CommandRecorder) Execute(directory, name string, arguments ...string) (output string, err error) {
-	concatenated := fmt.Sprintf("%s|%s %s", directory, name, strings.Join(arguments, " "))
-	concatenated = strings.TrimSpace(concatenated)
-	output = self.Output(concatenated)
-	err = self.Error(concatenated)
-	fmt.Println("$ ", concatenated, output, "<error>", err, "</error>", "\n")
-	return
-}
-
-func (self *CommandRecorder) Output(invocation string) string {
-	output := outputs[invocation]
-	if output == goconveyDSLImport && !self.test.goconvey {
-		output = goConveyNotFound
-	}
-	return output
-}
-
-func (self *CommandRecorder) Error(invocation string) error {
-	if invocation == compileImports && self.test.imports {
-		return nil
-	} else if invocation == compileImports {
-		return errors.New(compileImports)
-	}
-
-	if invocation == detectGoConvey {
-		return nil
-	}
-
-	if invocation == executeTests && self.test.passes {
-		return nil
-	} else if invocation == executeTests {
-		return errors.New(executeTests)
-	}
-
-	if invocation == executeGoConvey && self.test.passes {
-		return nil
-	} else if invocation == executeGoConvey {
-		return errors.New(executeGoConvey)
-	}
-
-	if invocation == coverTests && self.test.passes {
-		return nil
-	} else if invocation == coverTests {
-		return errors.New(coverTests)
-	}
-
-	if invocation == coverGoConvey && self.test.passes {
-		return nil
-	} else if invocation == coverGoConvey {
-		return errors.New(coverTests)
-	}
-
-	return nil
-}
-
-func NewCommandRecorder(test TestCase) *CommandRecorder {
-	self := new(CommandRecorder)
-	self.test = test
-	return self
-}
-
-const (
-	compileImports   = "directory|go test -i"
-	detectGoConvey   = "directory|go list -f '{{.TestImports}}' pack/age"
-	goConveyNotFound = "Don't let this look like a GoConvey test suite!"
-	executeTests     = "directory|go test -v -short=false"
-	executeGoConvey  = "directory|go test -v -short=false -json"
-	coverTests       = "directory|go test -v -short=false -covermode=set -coverprofile=reports/pack-age.txt"
-	coverGoConvey    = "directory|go test -v -short=false -covermode=set -coverprofile=reports/pack-age.txt -json"
-	profileTests     = "directory|go tool cover -html=reports/pack-age.txt -o reports/pack-age.html"
-)
-
-var outputs = map[string]string{
-	compileImports:  "import compilation",
-	detectGoConvey:  goconveyDSLImport,
-	executeTests:    "test execution",
-	executeGoConvey: "goconvey test execution",
-	coverTests:      "test coverage execution",
-	coverGoConvey:   "goconvey coverage execution",
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system.go
deleted file mode 100644
index aedf79d53f9..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package system
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-type FakeFileSystem struct {
-	steps []*FakeFileInfo
-}
-
-func (self *FakeFileSystem) Create(path string, size int64, modified time.Time) {
-	self.steps = append(self.steps, newFileInfo(path, size, modified))
-}
-func (self *FakeFileSystem) Modify(path string) {
-	for _, step := range self.steps {
-		if step.path == path {
-			step.size++
-		}
-	}
-}
-func (self *FakeFileSystem) Rename(original, modified string) {
-	for _, step := range self.steps {
-		if step.path == original {
-			step.path = modified
-			step.modified = step.modified.Add(time.Second * time.Duration(10))
-			break
-		}
-	}
-}
-func (self *FakeFileSystem) Delete(path string) {
-	newSteps := []*FakeFileInfo{}
-	for _, step := range self.steps {
-		if !strings.HasPrefix(step.path, path) {
-			newSteps = append(newSteps, step)
-		}
-	}
-	self.steps = newSteps
-}
-
-func (self *FakeFileSystem) Walk(root string, step filepath.WalkFunc) {
-	for _, info := range self.steps {
-		if strings.HasPrefix(info.path, root) {
-			step(info.path, info, nil)
-		}
-	}
-}
-func (self *FakeFileSystem) Listing(directory string) ([]os.FileInfo, error) {
-	var entries []os.FileInfo
-	for _, info := range self.steps {
-		if strings.HasPrefix(info.path, directory) && info.path != directory {
-			entries = append(entries, info)
-		}
-	}
-	return entries, nil
-}
-func (self *FakeFileSystem) Exists(directory string) bool {
-	for _, info := range self.steps {
-		if info.IsDir() && info.path == directory {
-			return true
-		}
-	}
-	return false
-}
-
-func NewFakeFileSystem() *FakeFileSystem {
-	self := new(FakeFileSystem)
-	self.steps = []*FakeFileInfo{}
-	return self
-}
-
-type FakeFileInfo struct {
-	path     string
-	size     int64
-	modified time.Time
-}
-
-func (self *FakeFileInfo) Name() string       { return filepath.Base(self.path) }
-func (self *FakeFileInfo) Size() int64        { return self.size }
-func (self *FakeFileInfo) Mode() os.FileMode  { return 0 }
-func (self *FakeFileInfo) ModTime() time.Time { return self.modified }
-func (self *FakeFileInfo) IsDir() bool        { return filepath.Ext(self.path) == "" }
-func (self *FakeFileInfo) Sys() interface{}   { return nil }
-
-func newFileInfo(path string, size int64, modified time.Time) *FakeFileInfo {
-	self := &FakeFileInfo{}
-	self.path = path
-	self.size = size
-	self.modified = modified
-	return self
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system_test.go
deleted file mode 100644
index 3a1fbd4c5c6..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_file_system_test.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package system
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestFakeFileSystem(t *testing.T) {
-	Convey("Subject: FakeFileSystem", t, func() {
-		fs := NewFakeFileSystem()
-
-		Convey("When walking a barren file system", func() {
-			step := func(path string, info os.FileInfo, err error) error { panic("Should NOT happen!") }
-
-			Convey("The step function should never be called", func() {
-				So(func() { fs.Walk("/", step) }, ShouldNotPanic)
-			})
-		})
-
-		Convey("When a file system is populated...", func() {
-			first, second, third, fourth := time.Now(), time.Now(), time.Now(), time.Now()
-			fs.Create("/root", 0, first)
-			fs.Create("/root/a", 1, second)
-			fs.Create("/elsewhere/c", 2, third)
-			fs.Create("/root/b", 3, fourth)
-
-			Convey("...and then walked", func() {
-				paths, names, sizes, times, errors := []string{}, []string{}, []int64{}, []time.Time{}, []error{}
-				fs.Walk("/root", func(path string, info os.FileInfo, err error) error {
-					paths = append(paths, path)
-					names = append(names, info.Name())
-					sizes = append(sizes, info.Size())
-					times = append(times, info.ModTime())
-					errors = append(errors, err)
-					return nil
-				})
-
-				Convey("Each nested path should be visited once", func() {
-					So(paths, ShouldResemble, []string{"/root", "/root/a", "/root/b"})
-					So(names, ShouldResemble, []string{"root", "a", "b"})
-					So(sizes, ShouldResemble, []int64{0, 1, 3})
-					So(times, ShouldResemble, []time.Time{first, second, fourth})
-					So(errors, ShouldResemble, []error{nil, nil, nil})
-				})
-			})
-		})
-
-		Convey("When an existing file system item is modified", func() {
-			fs.Create("/a.txt", 1, time.Now())
-			fs.Modify("/a.txt")
-			var size int64
-
-			Convey("And the file system is then walked", func() {
-				fs.Walk("/", func(path string, info os.FileInfo, err error) error {
-					size = info.Size()
-					return nil
-				})
-				Convey("The modification should be persistent", func() {
-					So(size, ShouldEqual, 2)
-				})
-			})
-		})
-
-		Convey("When an existing file system item is renamed", func() {
-			initial := time.Now()
-			fs.Create("/a.txt", 1, initial)
-			fs.Rename("/a.txt", "/z.txt")
-			var modified time.Time
-			var newName string
-
-			Convey("And the file system is then walked", func() {
-				fs.Walk("/", func(path string, info os.FileInfo, err error) error {
-					modified = info.ModTime()
-					newName = info.Name()
-					return nil
-				})
-				Convey("The modification should be persistent", func() {
-					So(modified, ShouldHappenAfter, initial)
-					So(newName, ShouldEqual, "z.txt")
-				})
-			})
-		})
-
-		Convey("When an existing file system item is deleted", func() {
-			fs.Create("/a.txt", 1, time.Now())
-			fs.Delete("/a.txt")
-			var found bool
-
-			Convey("And the file system is then walked", func() {
-				fs.Walk("/", func(path string, info os.FileInfo, err error) error {
-					if info.Name() == "a.txt" {
-						found = true
-					}
-					return nil
-				})
-				Convey("The deleted entry should NOT be visited", func() {
-					So(found, ShouldBeFalse)
-				})
-			})
-		})
-
-		Convey("When an existing folder is deleted", func() {
-			first, second, third := time.Now(), time.Now(), time.Now()
-			fs.Create("/a", 1, first)
-			fs.Create("/a/1.txt", 2, second)
-			fs.Create("/b", 3, third)
-
-			fs.Delete("/a")
-
-			Convey("And the file system is then walked", func() {
-				paths, names, sizes, times, errors := []string{}, []string{}, []int64{}, []time.Time{}, []error{}
-				fs.Walk("/", func(path string, info os.FileInfo, err error) error {
-					paths = append(paths, path)
-					names = append(names, info.Name())
-					sizes = append(sizes, info.Size())
-					times = append(times, info.ModTime())
-					errors = append(errors, err)
-					return nil
-				})
-
-				Convey("All nested items and the folder should have been removed", func() {
-					So(paths, ShouldResemble, []string{"/b"})
-					So(names, ShouldResemble, []string{"b"})
-					So(sizes, ShouldResemble, []int64{3})
-					So(times, ShouldResemble, []time.Time{third})
-					So(errors, ShouldResemble, []error{nil})
-				})
-			})
-		})
-
-		Convey("When a directory does NOT exist it should NOT be found", func() {
-			So(fs.Exists("/not/there"), ShouldBeFalse)
-		})
-
-		Convey("When a folder is created", func() {
-			modified := time.Now()
-			fs.Create("/path/to/folder", 3, modified)
-
-			Convey("It should be visible as a folder", func() {
-				So(fs.Exists("/path/to/folder"), ShouldBeTrue)
-			})
-		})
-
-		Convey("When a file is created", func() {
-			fs.Create("/path/to/file.txt", 3, time.Now())
-
-			Convey("It should NOT be visible as a folder", func() {
-				So(fs.Exists("/path/to/file.txt"), ShouldBeFalse)
-			})
-		})
-
-		Convey("Given a directory with contents", func() {
-			fs.Create("/directory", 1, time.Now())
-			fs.Create("/directory/1", 2, time.Now())
-			fs.Create("/directory/2.txt", 3, time.Now())
-
-			Convey("When a listing of the directory is requested", func() {
-				contents, err := fs.Listing("/directory")
-
-				Convey("The listing should contain all contents", func() {
-					So(contents[0].Name(), ShouldEqual, "1")
-					So(contents[0].IsDir(), ShouldBeTrue)
-					So(contents[1].Name(), ShouldEqual, "2.txt")
-					So(contents[1].IsDir(), ShouldBeFalse)
-				})
-
-				Convey("The operation should complete without error", func() {
-					So(err, ShouldBeNil)
-				})
-			})
-		})
-	})
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell.go
deleted file mode 100644
index 24839ce7585..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package system
-
-type FakeShell struct {
-	environment map[string]string
-	executions  []string
-}
-
-func (self *FakeShell) GoTest(directory, packageName string) (output string, err error) {
-	self.executions = append(self.executions, directory+packageName)
-	output = directory + packageName
-	return
-}
-
-func (self *FakeShell) Executions() []string {
-	return self.executions
-}
-
-func (self *FakeShell) Getenv(key string) string {
-	return self.environment[key]
-}
-
-func (self *FakeShell) Setenv(key, value string) error {
-	self.environment[key] = value
-	return nil
-}
-
-func NewFakeShell() *FakeShell {
-	self := new(FakeShell)
-	self.environment = map[string]string{}
-	self.executions = []string{}
-	return self
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell_test.go
deleted file mode 100644
index d52b081ae0f..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/fake_shell_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package system
-
-import (
-	"testing"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestFakeShell(t *testing.T) {
-	var output string
-	var err error
-
-	Convey("Subject: FakeShell", t, func() {
-		shell := NewFakeShell()
-
-		Convey("When executing go test", func() {
-			output, err = shell.GoTest("/hi", "-there")
-			shell.GoTest("/bye", "-bye")
-
-			Convey("The output should be an echo of the input", func() {
-				So(output, ShouldEqual, "/hi-there")
-			})
-
-			Convey("There should be no error", func() {
-				So(err, ShouldBeNil)
-			})
-
-			Convey("The shell should remember the directory of execution", func() {
-				So(shell.Executions(), ShouldResemble, []string{"/hi-there", "/bye-bye"})
-			})
-		})
-
-		Convey("When setting an environment variable", func() {
-			err := shell.Setenv("variable", "42")
-
-			Convey("The value should persist", func() {
-				So(shell.Getenv("variable"), ShouldEqual, "42")
-			})
-
-			Convey("The error should be nil", func() {
-				So(err, ShouldBeNil)
-			})
-		})
-	})
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system.go
deleted file mode 100644
index e63f87dd2f5..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package system
-
-import (
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-type FileSystem struct{}
-
-func (self *FileSystem) Walk(root string, step filepath.WalkFunc) {
-	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if self.isMetaDirectory(info) {
-			return filepath.SkipDir
-		}
-
-		return step(path, info, err)
-	})
-
-	if err != nil && err != filepath.SkipDir {
-		log.Println("Error while walking file system:", err)
-		panic(err)
-	}
-}
-
-func (self *FileSystem) isMetaDirectory(info os.FileInfo) bool {
-	name := info.Name()
-	return info.IsDir() && (strings.HasPrefix(name, ".") || strings.HasPrefix(name, "_") || name == "testdata")
-}
-
-func (self *FileSystem) Listing(directory string) ([]os.FileInfo, error) {
-	return ioutil.ReadDir(directory)
-}
-
-func (self *FileSystem) Exists(directory string) bool {
-	info, err := os.Stat(directory)
-	return err == nil && info.IsDir()
-}
-
-func NewFileSystem() *FileSystem {
-	return new(FileSystem)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit.go
deleted file mode 100644
index 0dad96504f4..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package system
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-type DepthLimit struct {
-	depth int
-	inner fileSystem
-}
-
-func (self *DepthLimit) Walk(root string, step filepath.WalkFunc) {
-	self.inner.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if self.withinDepth(root, path) {
-			return step(path, info, err)
-		}
-		return filepath.SkipDir
-	})
-}
-
-func (self *DepthLimit) withinDepth(root, path string) bool {
-	if self.depth < 0 {
-		return true
-	}
-	nested := path[len(root):]
-	return strings.Count(nested, slash) <= self.depth
-}
-
-func (self *DepthLimit) Listing(directory string) ([]os.FileInfo, error) {
-	return self.inner.Listing(directory)
-}
-
-func (self *DepthLimit) Exists(directory string) bool {
-	return self.inner.Exists(directory)
-}
-
-func NewDepthLimit(inner fileSystem, depth int) *DepthLimit {
-	self := new(DepthLimit)
-	self.inner = inner
-	self.depth = depth
-	return self
-}
-
-const slash = string(os.PathSeparator)
-
-/////////////////////////////////////////////
-
-type fileSystem interface {
-	Walk(root string, step filepath.WalkFunc)
-	Listing(directory string) ([]os.FileInfo, error)
-	Exists(directory string) bool
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit_test.go
deleted file mode 100644
index f5f7c193a38..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/file_system_depth_limit_test.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package system
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestDepthLimitingFileSystem(t *testing.T) {
-	Convey("Subject: Depth-limited file system", t, func() {
-		inner := NewMockFileSystem()
-
-		Convey("When the depth limit is set to -1", func() {
-			files := NewDepthLimit(inner, -1)
-			files.Walk("/", inner.step)
-
-			Convey("No depth limiting should be enforced", func() {
-				So(inner.walked, ShouldResemble, []string{
-					"/1",
-					"/1/2",
-					"/1/2/3",
-				})
-			})
-		})
-
-		Convey("When the depth limit is not negative", func() {
-			files := NewDepthLimit(inner, 1)
-			files.Walk("/", inner.step)
-
-			Convey("Directories outside the depth should be skipped", func() {
-				So(inner.walked, ShouldResemble, []string{
-					"/1",
-					"/1/2",
-				})
-			})
-		})
-
-		Convey("When requesting a listing", func() {
-			files := NewDepthLimit(inner, -1)
-			listing, indicator := files.Listing("hi")
-
-			Convey("The request should be forwarded to the inner file system", func() {
-				So(inner.listingCalled, ShouldBeTrue)
-			})
-
-			Convey("The inner result should be returned", func() {
-				So(listing, ShouldResemble, innerListing)
-				So(indicator, ShouldEqual, listingIndicator)
-			})
-		})
-
-		Convey("When checking the existence of a directory", func() {
-			files := NewDepthLimit(inner, -1)
-			exists := files.Exists("hi")
-
-			Convey("The request should be forwarded to the inner file system", func() {
-				So(inner.existsCalled, ShouldBeTrue)
-			})
-
-			Convey("The inner result should be returned", func() {
-				So(exists, ShouldBeTrue)
-			})
-		})
-	})
-
-}
-
-//////////////////////////////
-
-type MockFileSystem struct {
-	paths         []*FakeFileInfo
-	walked        []string
-	listingCalled bool
-	existsCalled  bool
-}
-
-func (self *MockFileSystem) Walk(root string, step filepath.WalkFunc) {
-	for _, path := range self.paths {
-		step(path.path, path, nil)
-	}
-}
-
-func (self *MockFileSystem) step(path string, info os.FileInfo, err error) error {
-	self.walked = append(self.walked, path)
-	return err
-}
-
-func (self *MockFileSystem) Listing(directory string) ([]os.FileInfo, error) {
-	self.listingCalled = true
-	return innerListing, listingIndicator
-}
-
-func (self *MockFileSystem) Exists(directory string) bool {
-	self.existsCalled = true
-	return true
-}
-
-func NewMockFileSystem() *MockFileSystem {
-	self := new(MockFileSystem)
-	self.paths = []*FakeFileInfo{
-		newFileInfo("/1", 42, time.Now()),
-		newFileInfo("/1/2", 42, time.Now()),
-		newFileInfo("/1/2/3", 42, time.Now()),
-	}
-	return self
-}
-
-var listingIndicator = errors.New("Listing was called.")
-var innerListing = []os.FileInfo{newFileInfo("/1", 42, time.Now())}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/init_test.go
deleted file mode 100644
index 00ace4f89ca..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package system
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell.go
index caca7f6c068..f2fa10711db 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell.go
@@ -1,103 +1,174 @@
 package system
 
 import (
-	"fmt"
-	"os"
+	"log"
+	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 )
 
+///////////////////////////////////////////////////////////////////////////////
+// Integration: ///////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
 type Shell struct {
-	executor      Executor
-	coverage      bool
-	gobin         string
-	reportsPath   string
-	shortArgument string
+	coverage       bool
+	gobin          string
+	reportsPath    string
+	defaultTimeout string
 }
 
-func (self *Shell) GoTest(directory, packageName string) (output string, err error) {
-	output, err = self.compilePackageDependencies(directory)
-	if err == nil {
-		output, err = self.goTest(directory, packageName)
+func NewShell(gobin, reportsPath string, coverage bool, defaultTimeout string) *Shell {
+	return &Shell{
+		coverage:       coverage,
+		gobin:          gobin,
+		reportsPath:    reportsPath,
+		defaultTimeout: defaultTimeout,
 	}
-	return
 }
 
-func (self *Shell) compilePackageDependencies(directory string) (output string, err error) {
-	return self.executor.Execute(directory, self.gobin, "test", "-i")
-}
+func (self *Shell) GoTest(directory, packageName string, tags, arguments []string) (output string, err error) {
+	reportFilename := strings.Replace(packageName, "/", "-", -1)
+	reportPath := filepath.Join(self.reportsPath, reportFilename)
+	reportData := reportPath + ".txt"
+	reportHTML := reportPath + ".html"
+	tagsArg := "-tags=" + strings.Join(tags, ",")
 
-func (self *Shell) goTest(directory, packageName string) (output string, err error) {
-	if !self.coverage {
-		return self.runWithoutCoverage(directory, packageName)
-	}
+	goconvey := findGoConvey(directory, self.gobin, packageName, tagsArg).Execute()
+	compilation := compile(directory, self.gobin, tagsArg).Execute()
+	withCoverage := runWithCoverage(compilation, goconvey, self.coverage, reportData, directory, self.gobin, self.defaultTimeout, tagsArg, arguments).Execute()
+	final := runWithoutCoverage(compilation, withCoverage, goconvey, directory, self.gobin, self.defaultTimeout, tagsArg, arguments).Execute()
+	go generateReports(final, self.coverage, directory, self.gobin, reportData, reportHTML).Execute()
 
-	return self.tryRunWithCoverage(directory, packageName)
+	return final.Output, final.Error
 }
 
-func (self *Shell) tryRunWithCoverage(directory, packageName string) (output string, err error) {
-	profileName := self.composeCoverageProfileName(packageName)
-	output, err = self.runWithCoverage(directory, packageName, profileName+".txt")
+///////////////////////////////////////////////////////////////////////////////
+// Functional Core:////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
-	if err != nil && self.coverage {
-		output, err = self.runWithoutCoverage(directory, packageName)
-	} else if self.coverage {
-		self.generateCoverageReports(directory, profileName+".txt", profileName+".html")
-	}
-	return
+func findGoConvey(directory, gobin, packageName, tagsArg string) Command {
+	return NewCommand(directory, gobin, "list", "-f", "'{{.TestImports}}'", tagsArg, packageName)
 }
 
-func (self *Shell) composeCoverageProfileName(packageName string) string {
-	reportFilename := strings.Replace(packageName, "/", "-", -1)
-	reportPath := filepath.Join(self.reportsPath, reportFilename)
-	return reportPath
+func compile(directory, gobin, tagsArg string) Command {
+	return NewCommand(directory, gobin, "test", "-i", tagsArg)
 }
 
-func (self *Shell) runWithCoverage(directory, packageName, profile string) (string, error) {
-	arguments := []string{"test", "-v", self.shortArgument, "-covermode=set", "-coverprofile=" + profile}
-	arguments = append(arguments, self.jsonFlag(directory, packageName)...)
-	return self.executor.Execute(directory, self.gobin, arguments...)
-}
+func runWithCoverage(compile, goconvey Command, coverage bool, reportPath, directory, gobin, defaultTimeout, tagsArg string, customArguments []string) Command {
+	if compile.Error != nil || goconvey.Error != nil {
+		return compile
+	}
+
+	if !coverage {
+		return compile
+	}
+
+	arguments := []string{"test", "-v", "-coverprofile=" + reportPath, tagsArg}
+
+	customArgsText := strings.Join(customArguments, "\t")
+	if !strings.Contains(customArgsText, "-covermode=") {
+		arguments = append(arguments, "-covermode=set")
+	}
+
+	if !strings.Contains(customArgsText, "-timeout=") {
+		arguments = append(arguments, "-timeout="+defaultTimeout)
+	}
 
-func (self *Shell) runWithoutCoverage(directory, packageName string) (string, error) {
-	arguments := []string{"test", "-v", self.shortArgument}
-	arguments = append(arguments, self.jsonFlag(directory, packageName)...)
-	return self.executor.Execute(directory, self.gobin, arguments...)
+	if strings.Contains(goconvey.Output, goconveyDSLImport) {
+		arguments = append(arguments, "-json")
+	}
+
+	arguments = append(arguments, customArguments...)
+
+	return NewCommand(directory, gobin, arguments...)
 }
 
-func (self *Shell) jsonFlag(directory, packageName string) []string {
-	imports, err := self.executor.Execute(directory, self.gobin, "list", "-f", "'{{.TestImports}}'", packageName)
-	if !strings.Contains(imports, goconveyDSLImport) && err == nil {
-		return []string{}
+func runWithoutCoverage(compile, withCoverage, goconvey Command, directory, gobin, defaultTimeout, tagsArg string, customArguments []string) Command {
+	if compile.Error != nil {
+		return compile
+	}
+
+	if goconvey.Error != nil {
+		log.Println(gopathProblem, goconvey.Output, goconvey.Error)
+		return goconvey
 	}
-	return []string{"-json"}
+
+	if coverageStatementRE.MatchString(withCoverage.Output) {
+		return withCoverage
+	}
+
+	log.Printf("Coverage output: %v", withCoverage.Output)
+
+	log.Print("Run without coverage")
+
+	arguments := []string{"test", "-v", tagsArg}
+	customArgsText := strings.Join(customArguments, "\t")
+	if !strings.Contains(customArgsText, "-timeout=") {
+		arguments = append(arguments, "-timeout="+defaultTimeout)
+	}
+
+	if strings.Contains(goconvey.Output, goconveyDSLImport) {
+		arguments = append(arguments, "-json")
+	}
+	arguments = append(arguments, customArguments...)
+	return NewCommand(directory, gobin, arguments...)
 }
 
-func (self *Shell) generateCoverageReports(directory, profile, html string) {
-	self.executor.Execute(directory, self.gobin, "tool", "cover", "-html="+profile, "-o", html)
+func generateReports(previous Command, coverage bool, directory, gobin, reportData, reportHTML string) Command {
+	if previous.Error != nil {
+		return previous
+	}
+
+	if !coverage {
+		return previous
+	}
+
+	return NewCommand(directory, gobin, "tool", "cover", "-html="+reportData, "-o", reportHTML)
 }
 
-func (self *Shell) Getenv(key string) string {
-	return os.Getenv(key)
+///////////////////////////////////////////////////////////////////////////////
+// Imperative Shell: //////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+type Command struct {
+	directory  string
+	executable string
+	arguments  []string
+
+	Output string
+	Error  error
 }
 
-func (self *Shell) Setenv(key, value string) error {
-	if self.Getenv(key) != value {
-		return os.Setenv(key, value)
+func NewCommand(directory, executable string, arguments ...string) Command {
+	return Command{
+		directory:  directory,
+		executable: executable,
+		arguments:  arguments,
 	}
-	return nil
 }
 
-func NewShell(executor Executor, gobin string, short bool, cover bool, reports string) *Shell {
-	self := new(Shell)
-	self.executor = executor
-	self.gobin = gobin
-	self.shortArgument = fmt.Sprintf("-short=%t", short)
-	self.coverage = cover
-	self.reportsPath = reports
-	return self
+func (this Command) Execute() Command {
+	if len(this.executable) == 0 {
+		return this
+	}
+
+	if len(this.Output) > 0 || this.Error != nil {
+		return this
+	}
+
+	command := exec.Command(this.executable, this.arguments...)
+	command.Dir = this.directory
+	var rawOutput []byte
+	rawOutput, this.Error = command.CombinedOutput()
+	this.Output = string(rawOutput)
+	return this
 }
 
-const (
-	goconveyDSLImport = "github.com/smartystreets/goconvey/convey " // note the trailing space: we don't want to target packages nested in the /convey package.
-)
+///////////////////////////////////////////////////////////////////////////////
+
+const goconveyDSLImport = "github.com/smartystreets/goconvey/convey " // note the trailing space: we don't want to target packages nested in the /convey package.
+const gopathProblem = "Please run goconvey from within $GOPATH/src (also, symlinks might be problematic). Output and Error: "
+
+var coverageStatementRE = regexp.MustCompile(`(?m)^coverage: \d+\.\d% of statements(.*)$|^panic: test timed out after `)
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_integration_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_integration_test.go
new file mode 100644
index 00000000000..88c696dbb81
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_integration_test.go
@@ -0,0 +1,33 @@
+package system
+
+import (
+	"log"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"testing"
+)
+
+func TestShellIntegration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping potentially long-running integration test...")
+		return
+	}
+
+	log.SetFlags(log.LstdFlags | log.Lshortfile | log.Lmicroseconds)
+
+	_, filename, _, _ := runtime.Caller(0)
+	directory := filepath.Join(filepath.Dir(filename), "..", "watch", "integration_testing", "sub")
+	packageName := "github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub"
+
+	shell := NewShell("go", "", true, "5s")
+	output, err := shell.GoTest(directory, packageName, []string{}, []string{"-short"})
+
+	if !strings.Contains(output, "PASS\n") || !strings.Contains(output, "ok") {
+		t.Errorf("Expected output that resembed tests passing but got this instead: [%s]", output)
+	}
+	if err != nil {
+		t.Error("Test run resulted in the following error:", err)
+	}
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_test.go
index 669fd2e3a6e..b115c4f356a 100644
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_test.go
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/system/shell_test.go
@@ -2,129 +2,216 @@ package system
 
 import (
 	"errors"
-	"fmt"
-	"strings"
 	"testing"
 
 	. "github.com/smartystreets/goconvey/convey"
 )
 
-func TestShell(t *testing.T) {
-	for i, test := range cases {
-		Convey(fmt.Sprintf("%d - %s", i, test.String()), t, func() {
-			fmt.Printf("\n%s\n\n", test.String())
-			output, err := invokeShell(test)
+func TestShellCommandComposition(t *testing.T) {
+	var (
+		buildFailed      = Command{Error: errors.New("BUILD FAILURE!")}
+		buildSucceeded   = Command{Output: "ok"}
+		goConvey         = Command{Output: "[fmt github.com/smartystreets/goconvey/convey net/http net/http/httptest path runtime strconv strings testing time]"}
+		noGoConvey       = Command{Output: "[fmt net/http net/http/httptest path runtime strconv strings testing time]"}
+		errorGoConvey    = Command{Output: "This is a wacky error", Error: errors.New("This happens when running goconvey outside your $GOPATH (symlinked code).")}
+		noCoveragePassed = Command{Output: "PASS\nok  	github.com/smartystreets/goconvey/examples	0.012s"}
+		coveragePassed   = Command{Output: "PASS\ncoverage: 100.0% of statements\nok  	github.com/smartystreets/goconvey/examples	0.012s"}
+		coverageFailed   = Command{
+			Error: errors.New("Tests bombed!"),
+			Output: "--- FAIL: TestIntegerManipulation (0.00 seconds)\nFAIL\ncoverage: 100.0% of statements\nexit status 1\nFAIL	github.com/smartystreets/goconvey/examples	0.013s",
+		}
+		coverageFailedTimeout = Command{
+			Error:  errors.New("Tests bombed!"),
+			Output: "=== RUN SomeTest\n--- PASS: SomeTest (0.00 seconds)\n=== RUN TimeoutTest\npanic: test timed out after 5s\n\ngoroutine 27 [running]:\n",
+		}
+	)
 
-			So(output, ShouldEqual, test.output)
-			So(err, ShouldResemble, test.err)
+	const (
+		yesCoverage = true
+		noCoverage  = false
+	)
+
+	Convey("When attempting to run tests with coverage flags", t, func() {
+		Convey("And buildSucceeded failed", func() {
+			result := runWithCoverage(buildFailed, goConvey, noCoverage, "", "", "", "", "-tags=", nil)
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, buildFailed)
+			})
 		})
-	}
-}
 
-func invokeShell(test TestCase) (string, error) {
-	executor := NewCommandRecorder(test)
-	shell := NewShell(executor, "go", test.short, test.coverage, "reports")
-	return shell.GoTest("directory", "pack/age")
-}
+		Convey("And coverage is not wanted", func() {
+			result := runWithCoverage(buildSucceeded, goConvey, noCoverage, "", "", "", "", "-tags=", nil)
 
-var cases = []TestCase{
-	TestCase{
-		imports: false,
-		output:  "import compilation",
-		err:     errors.New("directory|go test -i"),
-	},
-	TestCase{
-		imports: true, short: false, coverage: false, goconvey: false, passes: false,
-		output: "test execution",
-		err:    errors.New("directory|go test -v -short=false"),
-	},
-	TestCase{
-		imports: true, short: false, coverage: false, goconvey: false, passes: true,
-		output: "test execution",
-		err:    nil,
-	},
-	TestCase{
-		imports: true, short: false, coverage: false, goconvey: true, passes: false,
-		output: "goconvey test execution",
-		err:    errors.New("directory|go test -v -short=false -json"),
-	},
-	TestCase{
-		imports: true, short: false, coverage: false, goconvey: true, passes: true,
-		output: "goconvey test execution",
-		err:    nil,
-	},
-	TestCase{
-		imports: true, short: false, coverage: true, goconvey: false, passes: false,
-		output: "test execution", // because the tests fail with coverage, they are re-run without coverage
-		err:    errors.New("directory|go test -v -short=false"),
-	},
-	TestCase{
-		imports: true, short: false, coverage: true, goconvey: false, passes: true,
-		output: "test coverage execution",
-		err:    nil,
-	},
-	// TestCase{
-	// 	imports: true, short: false, coverage: true, goconvey: true, passes: false,
-	// 	output: "test execution", // because the tests fail with coverage, they are re-run without coverage
-	// 	err:    errors.New("directory|go test -v -short=false -json"),
-	// },
-	// TestCase{
-	// 	imports: true, short: false, coverage: true, goconvey: true, passes: true,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: false, goconvey: false, passes: false,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: false, goconvey: false, passes: true,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: false, goconvey: true, passes: false,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: false, goconvey: true, passes: true,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: true, goconvey: false, passes: false,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: true, goconvey: false, passes: true,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: true, goconvey: true, passes: false,
-	// },
-	// TestCase{
-	// 	imports: true, short: true, coverage: true, goconvey: true, passes: true,
-	// },
-}
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, buildSucceeded)
+			})
+		})
+
+		Convey("And the package being tested usees the GoConvey DSL (`convey` package)", func() {
+			result := runWithCoverage(buildSucceeded, goConvey, yesCoverage, "reportsPath", "/directory", "go", "5s", "-tags=bob", []string{"-arg1", "-arg2"})
 
-type TestCase struct {
+			Convey("The returned command should be well formed (and include the -json flag)", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-coverprofile=reportsPath", "-tags=bob", "-covermode=set", "-timeout=5s", "-json", "-arg1", "-arg2"},
+				})
+			})
+		})
 
-	// input parameters
-	imports  bool // is `go test -i`  successful?
-	short    bool // is `-short` enabled?
-	coverage bool // is `-coverage` enabled?
-	goconvey bool // do the tests use the GoConvey DSL?
-	passes   bool // do the tests pass?
+		Convey("And the package being tested does NOT use the GoConvey DSL", func() {
+			result := runWithCoverage(buildSucceeded, noGoConvey, yesCoverage, "reportsPath", "/directory", "go", "1s", "-tags=bob", []string{"-arg1", "-arg2"})
 
-	// expected results
-	output string
-	err    error
-}
+			Convey("The returned command should be well formed (and NOT include the -json flag)", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-coverprofile=reportsPath", "-tags=bob", "-covermode=set", "-timeout=1s", "-arg1", "-arg2"},
+				})
+			})
+		})
 
-func (self TestCase) String() string {
-	return fmt.Sprintf("Parameters: | %s | %s | %s | %s | %s |",
-		decideCase("imports", self.imports),
-		decideCase("short", self.short),
-		decideCase("coverage", self.coverage),
-		decideCase("goconvey", self.goconvey),
-		decideCase("passes", self.passes))
-}
+		Convey("And the package being tested has been symlinked outside the $GOAPTH", func() {
+			result := runWithCoverage(buildSucceeded, errorGoConvey, yesCoverage, "reportsPath", "/directory", "go", "1s", "-tags=", nil)
+
+			Convey("The returned command should be the compilation command", func() {
+				So(result, ShouldResemble, buildSucceeded)
+			})
+		})
+
+		Convey("And the package being tested specifies an alternate covermode", func() {
+			result := runWithCoverage(buildSucceeded, noGoConvey, yesCoverage, "reportsPath", "/directory", "go", "1s", "-tags=", []string{"-covermode=atomic"})
+
+			Convey("The returned command should allow the alternate value", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-coverprofile=reportsPath", "-tags=", "-timeout=1s", "-covermode=atomic"},
+				})
+			})
+		})
+
+		Convey("And the package being tested specifies an alternate timeout", func() {
+			result := runWithCoverage(buildSucceeded, noGoConvey, yesCoverage, "reportsPath", "/directory", "go", "1s", "-tags=", []string{"-timeout=5s"})
+
+			Convey("The returned command should allow the alternate value", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-coverprofile=reportsPath", "-tags=", "-covermode=set", "-timeout=5s"},
+				})
+			})
+		})
+
+	})
+
+	Convey("When attempting to run tests without the coverage flags", t, func() {
+		Convey("And tests already succeeded with coverage", func() {
+			result := runWithoutCoverage(buildSucceeded, coveragePassed, goConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, coveragePassed)
+			})
+		})
+
+		Convey("And tests already failed (legitimately) with coverage", func() {
+			result := runWithoutCoverage(buildSucceeded, coverageFailed, goConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, coverageFailed)
+			})
+		})
+
+		Convey("And tests already failed (timeout) with coverage", func() {
+			result := runWithoutCoverage(buildSucceeded, coverageFailedTimeout, goConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
 
-// state == true: UPPERCASE
-// state == false: lowercase
-func decideCase(text string, state bool) string {
-	if state {
-		return strings.ToUpper(text)
-	}
-	return strings.ToLower(text)
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, coverageFailedTimeout)
+			})
+		})
+
+		Convey("And the build failed earlier", func() {
+			result := runWithoutCoverage(buildFailed, Command{}, goConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, buildFailed)
+			})
+		})
+
+		Convey("And the goconvey dsl command failed (probably because of symlinks)", func() {
+			result := runWithoutCoverage(buildSucceeded, Command{}, errorGoConvey, "", "", "", "-tags=", nil)
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, errorGoConvey)
+			})
+		})
+
+		Convey("And the package being tested uses the GoConvey DSL (`convey` package)", func() {
+			result := runWithoutCoverage(buildSucceeded, buildSucceeded, goConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
+
+			Convey("Then the returned command should be well formed (and include the -json flag)", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-tags=", "-timeout=1s", "-json", "-arg1", "-arg2"},
+				})
+			})
+		})
+
+		Convey("And the package being tested does NOT use the GoConvey DSL", func() {
+			result := runWithoutCoverage(buildSucceeded, noCoveragePassed, noGoConvey, "/directory", "go", "1s", "-tags=", []string{"-arg1", "-arg2"})
+
+			Convey("Then the returned command should be well formed (and NOT include the -json flag)", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-tags=", "-timeout=1s", "-arg1", "-arg2"},
+				})
+			})
+		})
+
+		Convey("And the package being tested specifies an alternate timeout", func() {
+			result := runWithoutCoverage(buildSucceeded, buildSucceeded, noGoConvey, "/directory", "go", "1s", "-tags=", []string{"-timeout=5s"})
+
+			Convey("The returned command should allow the alternate value", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"test", "-v", "-tags=", "-timeout=5s"},
+				})
+			})
+		})
+
+	})
+
+	Convey("When generating coverage reports", t, func() {
+		Convey("And the previous command failed for any reason (compilation or failed tests)", func() {
+			result := generateReports(buildFailed, yesCoverage, "/directory", "go", "reportData", "reportHTML")
+
+			Convey("Then no action should be taken", func() {
+				So(result, ShouldResemble, buildFailed)
+			})
+		})
+
+		Convey("And coverage reports are unwanted", func() {
+			result := generateReports(noCoveragePassed, noCoverage, "/directory", "go", "reportData", "reportHTML")
+
+			Convey("Then no action should beg taken", func() {
+				So(result, ShouldResemble, noCoveragePassed)
+			})
+		})
+
+		Convey("And tests passed and coverage reports are wanted", func() {
+			result := generateReports(coveragePassed, yesCoverage, "/directory", "go", "reportData", "reportHTML")
+
+			Convey("Then the resulting command should be well-formed", func() {
+				So(result, ShouldResemble, Command{
+					directory:  "/directory",
+					executable: "go",
+					arguments:  []string{"tool", "cover", "-html=reportData", "-o", "reportHTML"},
+				})
+			})
+		})
+	})
 }
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/system/system.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/system/system.goconvey
new file mode 100644
index 00000000000..aa26e8b739b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/system/system.goconvey
@@ -0,0 +1,3 @@
+#ignore
+-timeout=1s
+-short
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core.go
new file mode 100644
index 00000000000..404a25d33ac
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core.go
@@ -0,0 +1,171 @@
+package watch
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/smartystreets/goconvey/web/server/messaging"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+
+func Categorize(items chan *FileSystemItem, root string, watchSuffixes []string) (folders, profiles, goFiles []*FileSystemItem) {
+	for item := range items {
+		if item.IsFolder && !isHidden(item.Name) && !foundInHiddenDirectory(item, root) {
+			folders = append(folders, item)
+
+		} else if strings.HasSuffix(item.Name, ".goconvey") && len(item.Name) > len(".goconvey") {
+			profiles = append(profiles, item)
+
+		} else {
+			for _, suffix := range watchSuffixes {
+				if strings.HasSuffix(item.Name, suffix) && !isHidden(item.Name) && !foundInHiddenDirectory(item, root) {
+					goFiles = append(goFiles, item)
+				}
+			}
+		}
+	}
+	return folders, profiles, goFiles
+}
+
+func foundInHiddenDirectory(item *FileSystemItem, root string) bool {
+	path := item.Path
+	if len(path) > len(root) {
+		path = path[len(root):]
+	}
+
+	for _, folder := range strings.Split(filepath.Dir(path), slash) {
+		if isHidden(folder) {
+			return true
+		}
+	}
+
+	return false
+}
+func isHidden(path string) bool {
+	return strings.HasPrefix(path, ".") || strings.HasPrefix(path, "_") || strings.HasPrefix(path, "flymake_")
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func ParseProfile(profile string) (isDisabled bool, tags, arguments []string) {
+	lines := strings.Split(profile, "\n")
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		if len(arguments) == 0 && strings.ToLower(line) == "ignore" {
+			return true, nil, nil
+
+		} else if strings.HasPrefix(line, "-tags=") {
+			tags = append(tags, strings.Split(strings.SplitN(line, "=", 2)[1], ",")...)
+			continue
+
+		} else if len(line) == 0 {
+			continue
+
+		} else if strings.HasPrefix(line, "#") {
+			continue
+
+		} else if strings.HasPrefix(line, "//") {
+			continue
+
+		} else if line == "-cover" || strings.HasPrefix(line, "-coverprofile") {
+			continue
+
+		} else if line == "-v" {
+			continue // Verbose mode is always enabled so there is no need to record it here.
+
+		}
+
+		arguments = append(arguments, line)
+	}
+
+	return false, tags, arguments
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func CreateFolders(items []*FileSystemItem) messaging.Folders {
+	folders := map[string]*messaging.Folder{}
+
+	for _, item := range items {
+		folders[item.Path] = &messaging.Folder{Path: item.Path, Root: item.Root}
+	}
+
+	return folders
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func LimitDepth(folders messaging.Folders, depth int) {
+	if depth < 0 {
+		return
+	}
+
+	for path, folder := range folders {
+		if strings.Count(path[len(folder.Root):], slash) > depth {
+			delete(folders, path)
+		}
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func AttachProfiles(folders messaging.Folders, items []*FileSystemItem) {
+	for _, profile := range items {
+		if folder, exists := folders[filepath.Dir(profile.Path)]; exists {
+			folder.Disabled, folder.BuildTags, folder.TestArguments = profile.ProfileDisabled, profile.ProfileTags, profile.ProfileArguments
+		}
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func MarkIgnored(folders messaging.Folders, ignored map[string]struct{}) {
+	if len(ignored) == 0 {
+		return
+	}
+
+	for _, folder := range folders {
+		for ignored := range ignored {
+			if !folder.Ignored && strings.HasSuffix(folder.Path, ignored) {
+				folder.Ignored = true
+			}
+		}
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func ActiveFolders(folders messaging.Folders) messaging.Folders {
+	var active messaging.Folders = map[string]*messaging.Folder{}
+
+	for path, folder := range folders {
+		if folder.Ignored || folder.Disabled {
+			continue
+		}
+
+		active[path] = folder
+	}
+	return active
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func Sum(folders messaging.Folders, items []*FileSystemItem) int64 {
+	var sum int64
+	for _, item := range items {
+		if _, exists := folders[filepath.Dir(item.Path)]; exists {
+			sum += item.Size + item.Modified
+		}
+	}
+	return sum
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const slash = string(os.PathSeparator)
+
+///////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core_test.go
new file mode 100644
index 00000000000..d0f74867acc
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/functional_core_test.go
@@ -0,0 +1,419 @@
+package watch
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"github.com/smartystreets/goconvey/web/server/messaging"
+)
+
+func TestCategorize(t *testing.T) {
+	fileSystem := []*FileSystemItem{
+		{
+			Root:     "/.hello",
+			Path:     "/.hello",
+			Name:     "hello",
+			IsFolder: true,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/1/hello/world.txt",
+			Name:     "world.txt",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/1/2/3/4/5/hello/world.go",
+			Name:     "world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/world.go",
+			Name:     "world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello/world.tmpl",
+			Name:     "world.tmpl",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello/.world.go",
+			Name:     ".world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello/_world.go",
+			Name:     ".world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello/flymake_world.go",
+			Name:     "flymake_world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/.hello",
+			Name:     ".hello",
+			IsFolder: true,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/.hello/hello",
+			Name:     "hello",
+			IsFolder: true,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/.hello/world.go",
+			Name:     "world.go",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello/hi.goconvey",
+			Name:     "hi.goconvey",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/hello2/.goconvey",
+			Name:     ".goconvey",
+			IsFolder: false,
+		},
+		{
+			Root:     "/.hello",
+			Path:     "/.hello/_hello",
+			Name:     "_hello",
+			IsFolder: true,
+		},
+	}
+
+	Convey("A stream of file system items should be categorized correctly", t, func() {
+		items := make(chan *FileSystemItem)
+
+		go func() {
+			for _, item := range fileSystem {
+				items <- item
+			}
+			close(items)
+		}()
+
+		folders, profiles, goFiles := Categorize(items, "/.hello", []string{".go"})
+		So(folders, ShouldResemble, fileSystem[:1])
+		So(profiles, ShouldResemble, fileSystem[11:12])
+		So(goFiles, ShouldResemble, fileSystem[2:4])
+	})
+
+	Convey("A stream of file system items should be categorized correctly", t, func() {
+		items := make(chan *FileSystemItem)
+
+		go func() {
+			for _, item := range fileSystem {
+				items <- item
+			}
+			close(items)
+		}()
+
+		folders, profiles, goFiles := Categorize(items, "/.hello", []string{".go", ".tmpl"})
+		So(folders, ShouldResemble, fileSystem[:1])
+		So(profiles, ShouldResemble, fileSystem[11:12])
+		So(goFiles, ShouldResemble, fileSystem[2:5])
+	})
+}
+
+func TestParseProfile(t *testing.T) {
+	var parseProfileTestCases = []struct {
+		SKIP           bool
+		description    string
+		input          string
+		resultIgnored  bool
+		resultTestTags []string
+		resultTestArgs []string
+	}{
+		{
+			SKIP:          false,
+			description:   "Blank profile",
+			input:         "",
+			resultIgnored: false,
+		},
+		{
+			SKIP:          false,
+			description:   "All lines are blank or whitespace",
+			input:         "\n \n \t\t\t  \n \n \n",
+			resultIgnored: false,
+		},
+		{
+			SKIP:          false,
+			description:   "Ignored package, no args included",
+			input:         "IGNORE\n-timeout=4s",
+			resultIgnored: true,
+		},
+		{
+			SKIP:           false,
+			description:    "Ignore directive is commented, all args are included",
+			input:          "#IGNORE\n-timeout=4s\n-parallel=5",
+			resultIgnored:  false,
+			resultTestArgs: []string{"-timeout=4s", "-parallel=5"},
+		},
+		{
+			SKIP:           false,
+			description:    "No ignore directive, all args are included",
+			input:          "-run=TestBlah\n-timeout=42s",
+			resultIgnored:  false,
+			resultTestArgs: []string{"-run=TestBlah", "-timeout=42s"},
+		},
+		{
+			SKIP:           false,
+			description:    "Some args are commented, therefore ignored",
+			input:          "-run=TestBlah\n #-timeout=42s",
+			resultIgnored:  false,
+			resultTestArgs: []string{"-run=TestBlah"},
+		},
+		{
+			SKIP:          false,
+			description:   "All args are commented, therefore all are ignored",
+			input:         "#-run=TestBlah\n//-timeout=42",
+			resultIgnored: false,
+		},
+		{
+			SKIP:          false,
+			description:   "We ignore certain flags like -v and -cover and -coverprofile because they are specified by the shell",
+			input:         "-v\n-cover\n-coverprofile=blah.out",
+			resultIgnored: false,
+		},
+		{
+			SKIP:           false,
+			description:    "We allow certain coverage flags like -coverpkg and -covermode",
+			input:          "-coverpkg=blah\n-covermode=atomic",
+			resultIgnored:  false,
+			resultTestArgs: []string{"-coverpkg=blah", "-covermode=atomic"},
+		},
+		{
+			SKIP:           false,
+			description:    "We parse out -tags particularly",
+			input:          "-coverpkg=blah\n-covermode=atomic\n-tags=foo,bar",
+			resultIgnored:  false,
+			resultTestTags: []string{"foo", "bar"},
+			resultTestArgs: []string{"-coverpkg=blah", "-covermode=atomic"},
+		},
+	}
+
+	for i, test := range parseProfileTestCases {
+		if test.SKIP {
+			SkipConvey(fmt.Sprintf("Profile Parsing, Test Case #%d: %s (SKIPPED)", i, test.description), t, nil)
+		} else {
+			Convey(fmt.Sprintf("Profile Parsing, Test Case #%d: %s", i, test.description), t, func() {
+				ignored, testTags, testArgs := ParseProfile(test.input)
+
+				So(ignored, ShouldEqual, test.resultIgnored)
+				So(testTags, ShouldResemble, test.resultTestTags)
+				So(testArgs, ShouldResemble, test.resultTestArgs)
+			})
+		}
+	}
+}
+
+func TestCreateFolders(t *testing.T) {
+	Convey("File system items that represent folders should be converted to folder structs correctly", t, func() {
+		expected := map[string]*messaging.Folder{
+			"/root/1":     {Path: "/root/1", Root: "/root"},
+			"/root/1/2":   {Path: "/root/1/2", Root: "/root"},
+			"/root/1/2/3": {Path: "/root/1/2/3", Root: "/root"},
+		}
+
+		inputs := []*FileSystemItem{
+			{Path: "/root/1", Root: "/root", IsFolder: true},
+			{Path: "/root/1/2", Root: "/root", IsFolder: true},
+			{Path: "/root/1/2/3", Root: "/root", IsFolder: true},
+		}
+
+		actual := CreateFolders(inputs)
+
+		for key, actualValue := range actual {
+			So(actualValue, ShouldResemble, expected[key])
+		}
+	})
+}
+
+func TestLimitDepth(t *testing.T) {
+	Convey("Subject: Limiting folders based on relative depth from a common root", t, func() {
+
+		folders := map[string]*messaging.Folder{
+			"/root/1": {
+				Path: "/root/1",
+				Root: "/root",
+			},
+			"/root/1/2": {
+				Path: "/root/1/2",
+				Root: "/root",
+			},
+			"/root/1/2/3": {
+				Path: "/root/1/2/3",
+				Root: "/root",
+			},
+		}
+
+		Convey("When there is no depth limit", func() {
+			LimitDepth(folders, -1)
+
+			Convey("No folders should be excluded", func() {
+				So(len(folders), ShouldEqual, 3)
+			})
+		})
+
+		Convey("When there is a limit", func() {
+			LimitDepth(folders, 2)
+
+			Convey("The deepest folder (in this case) should be excluded", func() {
+				So(len(folders), ShouldEqual, 2)
+				_, exists := folders["/root/1/2/3"]
+				So(exists, ShouldBeFalse)
+			})
+		})
+	})
+}
+
+func TestAttachProfiles(t *testing.T) {
+	Convey("Subject: Attaching profile information to a folder", t, func() {
+		folders := map[string]*messaging.Folder{
+			"/root/1": {
+				Path: "/root/1",
+				Root: "/root",
+			},
+			"/root/1/2": {
+				Path: "/root/1/2",
+				Root: "/root",
+			},
+			"/root/1/2/3": {
+				Path: "/root/1/2/3",
+				Root: "/root",
+			},
+		}
+
+		profiles := []*FileSystemItem{
+			{
+				Path:             "/root/too-shallow.goconvey",
+				ProfileDisabled:  true,
+				ProfileArguments: []string{"1", "2"},
+			},
+			{
+				Path:             "/root/1/2/hi.goconvey",
+				ProfileDisabled:  true,
+				ProfileArguments: []string{"1", "2"},
+			},
+			{
+				Path:             "/root/1/2/3/4/does-not-exist",
+				ProfileDisabled:  true,
+				ProfileArguments: []string{"1", "2", "3", "4"},
+			},
+		}
+
+		Convey("Profiles that match folders should be merged with those folders", func() {
+			AttachProfiles(folders, profiles)
+
+			Convey("No profiles matched the first folder, so no assignments should occur", func() {
+				So(folders["/root/1"].Disabled, ShouldBeFalse)
+				So(folders["/root/1"].TestArguments, ShouldBeEmpty)
+			})
+
+			Convey("The second folder should match the first profile", func() {
+				So(folders["/root/1/2"].Disabled, ShouldBeTrue)
+				So(folders["/root/1/2"].TestArguments, ShouldResemble, []string{"1", "2"})
+			})
+
+			Convey("No profiles match the third folder so no assignments should occur", func() {
+				So(folders["/root/1/2/3"].Disabled, ShouldBeFalse)
+				So(folders["/root/1/2/3"].TestArguments, ShouldBeEmpty)
+			})
+		})
+	})
+}
+
+func TestMarkIgnored(t *testing.T) {
+	Convey("Subject: folders that have been ignored should be marked as such", t, func() {
+		folders := map[string]*messaging.Folder{
+			"/root/1": {
+				Path: "/root/1",
+				Root: "/root",
+			},
+			"/root/1/2": {
+				Path: "/root/1/2",
+				Root: "/root",
+			},
+			"/root/1/2/3": {
+				Path: "/root/1/2/3",
+				Root: "/root",
+			},
+		}
+
+		Convey("When there are no ignored folders", func() {
+			ignored := map[string]struct{}{}
+			MarkIgnored(folders, ignored)
+
+			Convey("No folders should be marked as ignored", func() {
+				So(folders["/root/1"].Ignored, ShouldBeFalse)
+				So(folders["/root/1/2"].Ignored, ShouldBeFalse)
+				So(folders["/root/1/2/3"].Ignored, ShouldBeFalse)
+			})
+		})
+		Convey("When there are ignored folders", func() {
+			ignored := map[string]struct{}{"1/2": {}}
+			MarkIgnored(folders, ignored)
+
+			Convey("The ignored folders should be marked as ignored", func() {
+				So(folders["/root/1"].Ignored, ShouldBeFalse)
+				So(folders["/root/1/2"].Ignored, ShouldBeTrue)
+				So(folders["/root/1/2/3"].Ignored, ShouldBeFalse)
+			})
+		})
+	})
+}
+
+func TestActiveFolders(t *testing.T) {
+	Convey("Subject: Folders that are not ignored or disabled are active", t, func() {
+		folders := map[string]*messaging.Folder{
+			"/root/1": {
+				Path:    "/root/1",
+				Root:    "/root",
+				Ignored: true,
+			},
+			"/root/1/2": {
+				Path: "/root/1/2",
+				Root: "/root",
+			},
+			"/root/1/2/3": {
+				Path:     "/root/1/2/3",
+				Root:     "/root",
+				Disabled: true,
+			},
+		}
+
+		active := ActiveFolders(folders)
+
+		So(len(active), ShouldEqual, 1)
+		So(active["/root/1/2"], ShouldResemble, folders["/root/1/2"])
+	})
+}
+
+func TestSum(t *testing.T) {
+	Convey("Subject: file system items within specified directores should be counted and summed", t, func() {
+		folders := map[string]*messaging.Folder{
+			"/root/1": {Path: "/root/1", Root: "/root", Ignored: true},
+		}
+		items := []*FileSystemItem{
+			{Size: 1, Modified: 3, Path: "/root/1/hi.go"},
+			{Size: 7, Modified: 13, Path: "/root/1/bye.go"},
+			{Size: 33, Modified: 45, Path: "/root/1/2/salutations.go"}, // not counted
+		}
+
+		So(Sum(folders, items), ShouldEqual, 1+3+7+13)
+	})
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/imperative_shell.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/imperative_shell.go
new file mode 100644
index 00000000000..f4e886c9283
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/imperative_shell.go
@@ -0,0 +1,77 @@
+package watch
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+
+type FileSystemItem struct {
+	Root     string
+	Path     string
+	Name     string
+	Size     int64
+	Modified int64
+	IsFolder bool
+
+	ProfileDisabled  bool
+	ProfileTags      []string
+	ProfileArguments []string
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+func YieldFileSystemItems(root string, excludedDirs []string) chan *FileSystemItem {
+	items := make(chan *FileSystemItem)
+
+	go func() {
+		filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return filepath.SkipDir
+			}
+
+			basePath := filepath.Base(path)
+			for _, item := range excludedDirs {
+				if item == basePath && info.IsDir() && item != "" && basePath != "" {
+					return filepath.SkipDir
+				}
+			}
+
+			items <- &FileSystemItem{
+				Root:     root,
+				Path:     path,
+				Name:     info.Name(),
+				Size:     info.Size(),
+				Modified: info.ModTime().Unix(),
+				IsFolder: info.IsDir(),
+			}
+
+			return nil
+		})
+		close(items)
+	}()
+
+	return items
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// ReadContents reads files wholesale. This function is only called on files
+// that end in '.goconvey'. These files should be very small, probably not
+// ever more than a few hundred bytes. The ignored errors are ok because in
+// the event of an IO error all that need be returned is an empty string.
+func ReadContents(path string) string {
+	file, err := os.Open(path)
+	if err != nil {
+		return ""
+	}
+	defer file.Close()
+	reader := io.LimitReader(file, 1024*4)
+	content, _ := ioutil.ReadAll(reader)
+	return string(content)
+}
+
+///////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration.go
new file mode 100644
index 00000000000..941241ab86a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration.go
@@ -0,0 +1,185 @@
+package watch
+
+import (
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/smartystreets/goconvey/web/server/messaging"
+)
+
+type Watcher struct {
+	nap             time.Duration
+	rootFolder      string
+	folderDepth     int
+	ignoredFolders  map[string]struct{}
+	fileSystemState int64
+	paused          bool
+	stopped         bool
+	watchSuffixes   []string
+	excludedDirs    []string
+
+	input  chan messaging.WatcherCommand
+	output chan messaging.Folders
+
+	lock sync.RWMutex
+}
+
+func NewWatcher(rootFolder string, folderDepth int, nap time.Duration,
+	input chan messaging.WatcherCommand, output chan messaging.Folders, watchSuffixes string, excludedDirs []string) *Watcher {
+
+	return &Watcher{
+		nap:           nap,
+		rootFolder:    rootFolder,
+		folderDepth:   folderDepth,
+		input:         input,
+		output:        output,
+		watchSuffixes: strings.Split(watchSuffixes, ","),
+		excludedDirs:  excludedDirs,
+
+		ignoredFolders: make(map[string]struct{}),
+	}
+}
+
+func (this *Watcher) Listen() {
+	for {
+		if this.stopped {
+			return
+		}
+
+		select {
+
+		case command := <-this.input:
+			this.respond(command)
+
+		default:
+			if !this.paused {
+				this.scan()
+			}
+			time.Sleep(nap)
+		}
+	}
+}
+
+func (this *Watcher) respond(command messaging.WatcherCommand) {
+	switch command.Instruction {
+
+	case messaging.WatcherAdjustRoot:
+		log.Println("Adjusting root...")
+		this.rootFolder = command.Details
+		this.execute()
+
+	case messaging.WatcherIgnore:
+		log.Println("Ignoring specified folders")
+		this.ignore(command.Details)
+		// Prevent a filesystem change due to the number of active folders changing
+		_, checksum := this.gather()
+		this.set(checksum)
+
+	case messaging.WatcherReinstate:
+		log.Println("Reinstating specified folders")
+		this.reinstate(command.Details)
+		// Prevent a filesystem change due to the number of active folders changing
+		_, checksum := this.gather()
+		this.set(checksum)
+
+	case messaging.WatcherPause:
+		log.Println("Pausing watcher...")
+		this.paused = true
+
+	case messaging.WatcherResume:
+		log.Println("Resuming watcher...")
+		this.paused = false
+
+	case messaging.WatcherExecute:
+		log.Println("Gathering folders for immediate execution...")
+		this.execute()
+
+	case messaging.WatcherStop:
+		log.Println("Stopping the watcher...")
+		close(this.output)
+		this.stopped = true
+
+	default:
+		log.Println("Unrecognized command from server:", command.Instruction)
+	}
+}
+
+func (this *Watcher) execute() {
+	folders, _ := this.gather()
+	this.sendToExecutor(folders)
+}
+
+func (this *Watcher) scan() {
+	folders, checksum := this.gather()
+
+	if checksum == this.fileSystemState {
+		return
+	}
+
+	log.Println("File system state modified, publishing current folders...", this.fileSystemState, checksum)
+
+	defer this.set(checksum)
+	this.sendToExecutor(folders)
+}
+
+func (this *Watcher) gather() (folders messaging.Folders, checksum int64) {
+	items := YieldFileSystemItems(this.rootFolder, this.excludedDirs)
+	folderItems, profileItems, goFileItems := Categorize(items, this.rootFolder, this.watchSuffixes)
+
+	for _, item := range profileItems {
+		// TODO: don't even bother if the item's size is over a few hundred bytes...
+		contents := ReadContents(item.Path)
+		item.ProfileDisabled, item.ProfileTags, item.ProfileArguments = ParseProfile(contents)
+	}
+
+	folders = CreateFolders(folderItems)
+	LimitDepth(folders, this.folderDepth)
+	AttachProfiles(folders, profileItems)
+	this.protectedRead(func() { MarkIgnored(folders, this.ignoredFolders) })
+
+	active := ActiveFolders(folders)
+	checksum = int64(len(active))
+	checksum += Sum(active, profileItems)
+	checksum += Sum(active, goFileItems)
+
+	return folders, checksum
+}
+
+func (this *Watcher) set(state int64) {
+	this.fileSystemState = state
+}
+
+func (this *Watcher) sendToExecutor(folders messaging.Folders) {
+	this.output <- folders
+}
+
+func (this *Watcher) ignore(paths string) {
+	this.protectedWrite(func() {
+		for _, folder := range strings.Split(paths, string(os.PathListSeparator)) {
+			this.ignoredFolders[folder] = struct{}{}
+			log.Println("Currently ignored folders:", this.ignoredFolders)
+		}
+	})
+}
+func (this *Watcher) reinstate(paths string) {
+	this.protectedWrite(func() {
+		for _, folder := range strings.Split(paths, string(os.PathListSeparator)) {
+			delete(this.ignoredFolders, folder)
+		}
+	})
+}
+func (this *Watcher) protectedWrite(protected func()) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	protected()
+}
+func (this *Watcher) protectedRead(protected func()) {
+	this.lock.RLock()
+	defer this.lock.RUnlock()
+	protected()
+}
+
+const nap = time.Millisecond * 250
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_test.go
new file mode 100644
index 00000000000..e26ad48c47a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_test.go
@@ -0,0 +1,200 @@
+package watch
+
+import (
+	"bytes"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"github.com/smartystreets/goconvey/web/server/messaging"
+)
+
+func TestWatcher(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping potentially long-running integration test...")
+		return
+	}
+
+	log.SetFlags(log.LstdFlags | log.Lshortfile | log.Lmicroseconds)
+	output := new(bytes.Buffer)
+	log.SetOutput(output)
+	defer func() { t.Log(output.String()) }()
+
+	_, filename, _, _ := runtime.Caller(0)
+	originalRoot := filepath.Join(filepath.Dir(filename), "integration_testing")
+	temporary, err := ioutil.TempDir("/tmp", "goconvey")
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(temporary, "integration_testing")
+	sub := filepath.Join(root, "sub")
+
+	err = CopyDir(originalRoot, root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		err = os.RemoveAll(temporary)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	var ( // commands
+		pause  = messaging.WatcherCommand{Instruction: messaging.WatcherPause}
+		resume = messaging.WatcherCommand{Instruction: messaging.WatcherResume}
+
+		ignore    = messaging.WatcherCommand{Instruction: messaging.WatcherIgnore, Details: sub}
+		reinstate = messaging.WatcherCommand{Instruction: messaging.WatcherReinstate, Details: sub}
+
+		adjustToSub  = messaging.WatcherCommand{Instruction: messaging.WatcherAdjustRoot, Details: sub}
+		adjustToRoot = messaging.WatcherCommand{Instruction: messaging.WatcherAdjustRoot, Details: root}
+
+		execute = messaging.WatcherCommand{Instruction: messaging.WatcherExecute}
+
+		bogus = messaging.WatcherCommand{Instruction: 42}
+
+		stop = messaging.WatcherCommand{Instruction: messaging.WatcherStop}
+	)
+
+	Convey("Subject: Watcher operations", t, func() {
+		input := make(chan messaging.WatcherCommand)
+		output := make(chan messaging.Folders)
+		excludedDirs := []string{}
+		watcher := NewWatcher(root, -1, time.Millisecond, input, output, ".go", excludedDirs)
+
+		go watcher.Listen()
+
+		Convey("Initial scan results", func() {
+			go func() { input <- stop }()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 1)
+		})
+
+		Convey("Manual execution produces additional results", func() {
+			go func() {
+				input <- execute
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 2)
+			So(len(results[0]), ShouldEqual, 2)
+			So(len(results[1]), ShouldEqual, 2)
+		})
+
+		Convey("Ignore and Reinstate commands are not reflected in the scan results", func() {
+			go func() {
+				input <- ignore
+				input <- reinstate
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 1)
+			So(results[0][sub].Ignored, ShouldBeFalse) // initial
+		})
+
+		Convey("Adjusting the root changes the number of folders in the scanned results", func() {
+			go func() {
+				input <- adjustToSub
+				input <- adjustToRoot
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 3)
+			So(len(results[0]), ShouldEqual, 2) // initial
+			So(len(results[1]), ShouldEqual, 1) // root moved to sub
+			So(len(results[2]), ShouldEqual, 2) // root moved back to original location
+		})
+
+		Convey("A bogus command does not cause any additional scanning beyond the initial scan", func() {
+			go func() {
+				input <- bogus
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 1) // initial scan
+		})
+
+		Convey("Scanning occurs as a result of a file system update", func() {
+			go func() {
+				time.Sleep(time.Second)
+				exec.Command("touch", filepath.Join(root, "main.go")).Run()
+				time.Sleep(time.Second)
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 2)
+		})
+
+		Convey("Scanning does not occur as a result of resuming after a pause", func() {
+			go func() {
+				input <- pause
+				input <- resume
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 1)
+		})
+
+		Convey("Scanning should not occur when the watcher is paused", func() {
+			go func() {
+				input <- pause
+				for x := 0; x < 2; x++ {
+					time.Sleep(time.Millisecond * 250)
+					exec.Command("touch", filepath.Join(root, "main.go")).Run()
+					time.Sleep(time.Millisecond * 250)
+				}
+				input <- resume
+				input <- stop
+			}()
+
+			results := []messaging.Folders{}
+			for result := range output {
+				results = append(results, result)
+			}
+
+			So(len(results), ShouldEqual, 2)
+		})
+	})
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/doc_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/doc_test.go
new file mode 100644
index 00000000000..06ab7d0f9a3
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/doc_test.go
@@ -0,0 +1 @@
+package main
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/main.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/main.go
new file mode 100644
index 00000000000..1cd335173be
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/main.go
@@ -0,0 +1,10 @@
+// This file's only purpose is to provide a realistic
+// environment from which to run integration tests
+// against the Watcher.
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, World!")
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/.gitignore b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/.gitignore
new file mode 100644
index 00000000000..2574d15c0cc
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/.gitignore
@@ -0,0 +1,2 @@
+github.com-smartystreets-goconvey-web-server-integration_testing-sub.html
+github.com-smartystreets-goconvey-web-server-integration_testing-sub.txt
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff.go
new file mode 100644
index 00000000000..22673259756
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff.go
@@ -0,0 +1,4 @@
+// This file's only purpose is to provide a realistic
+// environment from which to run integration tests
+// against the Watcher.
+package sub
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff_test.go
new file mode 100644
index 00000000000..ea9eebd2d50
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/stuff_test.go
@@ -0,0 +1,17 @@
+// This file's only purpose is to provide a realistic
+// environment from which to run integration tests
+// against the Watcher.
+package sub
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestStuff(t *testing.T) {
+	if testing.Short() {
+		return
+	}
+
+	fmt.Println()
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/sub.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/sub.goconvey
new file mode 100644
index 00000000000..6f6e9405e8f
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/integration_testing/sub/sub.goconvey
@@ -0,0 +1,7 @@
+IGNORE
+-short
+-run=TestStuff
+
+// This file's only purpose is to provide a realistic
+// environment from which to run integration tests
+// against the Watcher.
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/util_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/util_test.go
new file mode 100644
index 00000000000..b5ac11fa02a
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/util_test.go
@@ -0,0 +1,92 @@
+// Credits: https://gist.github.com/jaybill/2876519
+package watch
+
+import "os"
+import "io"
+import "io/ioutil"
+import "log"
+
+// Copies original source to destination destination.
+func CopyFile(source string, destination string) (err error) {
+	originalFile, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer originalFile.Close()
+	destinationFile, err := os.Create(destination)
+	if err != nil {
+		return err
+	}
+	defer destinationFile.Close()
+	_, err = io.Copy(destinationFile, originalFile)
+	if err == nil {
+		info, err := os.Stat(source)
+		if err != nil {
+			err = os.Chmod(destination, info.Mode())
+		}
+
+	}
+
+	return
+}
+
+// Recursively copies a directory tree, attempting to preserve permissions.
+// Source directory must exist, destination directory must *not* exist.
+func CopyDir(source string, destination string) (err error) {
+
+	// get properties of source dir
+	sourceFile, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+
+	if !sourceFile.IsDir() {
+		return &CustomError{Message: "Source is not a directory"}
+	}
+
+	// ensure destination dir does not already exist
+
+	_, err = os.Open(destination)
+	if !os.IsNotExist(err) {
+		return &CustomError{Message: "Destination already exists"}
+	}
+
+	// create destination dir
+
+	err = os.MkdirAll(destination, sourceFile.Mode())
+	if err != nil {
+		return err
+	}
+
+	entries, err := ioutil.ReadDir(source)
+
+	for _, entry := range entries {
+
+		sourcePath := source + "/" + entry.Name()
+		destinationPath := destination + "/" + entry.Name()
+		if entry.IsDir() {
+			err = CopyDir(sourcePath, destinationPath)
+			if err != nil {
+				log.Println(err)
+			}
+		} else {
+			// perform copy
+			err = CopyFile(sourcePath, destinationPath)
+			if err != nil {
+				log.Println(err)
+			}
+		}
+
+	}
+	return
+}
+
+// A struct for returning custom error messages
+type CustomError struct {
+	Message string
+}
+
+// Returns the error message defined in Message as a string
+func (this *CustomError) Error() string {
+	return this.Message
+}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watch/watch.goconvey b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/watch.goconvey
new file mode 100644
index 00000000000..aa26e8b739b
--- /dev/null
+++ b/vendor/src/github.com/smartystreets/goconvey/web/server/watch/watch.goconvey
@@ -0,0 +1,3 @@
+#ignore
+-timeout=1s
+-short
\ No newline at end of file
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath.go
deleted file mode 100644
index a03d6ec06a5..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package watcher
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-
-	"github.com/smartystreets/goconvey/web/server/contract"
-)
-
-type goPath struct {
-	shell contract.Shell
-}
-
-func (self *goPath) ResolvePackageName(folder string) string {
-	for _, workspace := range strings.Split(self.current(), delimiter) {
-		if strings.HasPrefix(folder, workspace) {
-			prefix := filepath.Join(workspace, "src") + separator
-			return folder[len(prefix):]
-		}
-	}
-
-	panic(fmt.Sprintln(resolutionError, self.current()))
-}
-
-func (self *goPath) current() string {
-	return self.shell.Getenv("GOPATH")
-}
-
-func newGoPath(shell contract.Shell) *goPath {
-	self := new(goPath)
-	self.shell = shell
-	return self
-}
-
-const delimiter = string(filepath.ListSeparator)
-const separator = string(filepath.Separator)
-const resolutionError = "Package cannot be resolved as it is outside of any workspaces listed in the current $GOPATH:"
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath_test.go
deleted file mode 100644
index fe2a3835893..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/gopath_test.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package watcher
-
-import (
-	"testing"
-
-	. "github.com/smartystreets/goconvey/convey"
-	"github.com/smartystreets/goconvey/web/server/system"
-)
-
-func TestGoPath(t *testing.T) {
-	var fixture *goPathFixture
-
-	Convey("Subject: goPath abstracts the $GOPATH environment variable", t, func() {
-		fixture = newGoPathFixture()
-
-		Convey("Package names should be resolved from paths in consultation with the $GOPATH", func() {
-			for packagePath, expected := range resolutions {
-				So(fixture.gopath.ResolvePackageName(packagePath), ShouldEqual, expected)
-			}
-		})
-
-		Convey("Panic should ensue if package name resolution is attempted outside any available workspace", func() {
-			defer func() {
-				recovered := recover()
-				if recovered == nil {
-					So(recovered, ShouldNotBeNil)
-				} else {
-					So(recovered, ShouldStartWith, resolutionError)
-				}
-			}()
-			fixture.gopath.ResolvePackageName("/blah/src/package")
-		})
-	})
-}
-
-type goPathFixture struct {
-	shell  *system.FakeShell
-	gopath *goPath
-}
-
-func newGoPathFixture() *goPathFixture {
-	self := new(goPathFixture)
-	self.shell = system.NewFakeShell()
-	self.shell.Setenv("GOPATH", all)
-	self.gopath = newGoPath(self.shell)
-	return self
-}
-
-const ( // workspaces
-	basic    = "/root/gopath"
-	newBasic = "/root/otherGopath"
-	nested   = "/root/src/gopath"
-	crazy    = "/src/github.com"
-
-	all = basic + delimiter + newBasic + delimiter + nested + delimiter + crazy
-)
-
-var resolutions = map[string]string{
-	"/root/gopath/src/package":                          "package",
-	"/root/gopath/src/github.com/package":               "github.com/package",
-	"/root/gopath/src/github.com/project/package1":      "github.com/project/package1",
-	"/root/otherGopath/src/github.com/project/package2": "github.com/project/package2",
-	"/root/src/gopath/src/github.com/project/package3":  "github.com/project/package3",
-
-	// This crazy test case illustrates the point that "/src/" whether indexed at the beginning of the
-	// string or the end of the string may not always be the correct way to resolve the package name.
-	// In this case, the workspace contains a "src", there is a "src" that connects the workspace to
-	// the package (as expected), and there is a "src" in the actual package name.
-	// Dear reader, please, don't ever, ever structure your go code like this!
-	"/src/github.com/src/github.com/project/src/package": "github.com/project/src/package",
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/init_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/init_test.go
deleted file mode 100644
index d68a0923093..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/init_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package watcher
-
-import (
-	"io/ioutil"
-	"log"
-)
-
-func init() {
-	log.SetOutput(ioutil.Discard)
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner.go
deleted file mode 100644
index 08e71f65a5f..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package watcher
-
-import (
-	"log"
-	"os"
-
-	"github.com/smartystreets/goconvey/web/server/contract"
-)
-
-type Scanner struct {
-	fileSystem         contract.FileSystem
-	watcher            contract.Watcher
-	root               string
-	previous           int64
-	latestFolders      map[string]bool
-	preExistingFolders map[string]bool
-}
-
-func (self *Scanner) Scan() bool {
-	rootIsNew := self.recordCurrentRoot()
-	checksum, folders := self.analyzeCurrentFileSystemState()
-	if !rootIsNew {
-		self.notifyWatcherOfChangesInFolderStructure(folders)
-	}
-	self.preExistingFolders = folders
-	return self.latestTestResultsAreStale(checksum)
-}
-
-func (self *Scanner) recordCurrentRoot() (changed bool) {
-	root := self.watcher.Root()
-	if root != self.root {
-		log.Println("Updating root in scanner:", root)
-		self.root = root
-		return true
-	}
-	return false
-}
-
-func (self *Scanner) analyzeCurrentFileSystemState() (checksum int64, folders map[string]bool) {
-	folders = make(map[string]bool)
-
-	self.fileSystem.Walk(self.root, func(path string, info os.FileInfo, err error) error {
-		step := newWalkStep(self.root, path, info, self.watcher)
-		step.IncludeIn(folders)
-		checksum += step.Sum()
-		return nil
-	})
-	return checksum, folders
-}
-
-func (self *Scanner) notifyWatcherOfChangesInFolderStructure(latest map[string]bool) {
-	self.accountForDeletedFolders(latest)
-	self.accountForNewFolders(latest)
-}
-func (self *Scanner) accountForDeletedFolders(latest map[string]bool) {
-	for folder, _ := range self.preExistingFolders {
-		if _, exists := latest[folder]; !exists {
-			self.watcher.Deletion(folder)
-		}
-	}
-}
-func (self *Scanner) accountForNewFolders(latest map[string]bool) {
-	for folder, _ := range latest {
-		if _, exists := self.preExistingFolders[folder]; !exists {
-			self.watcher.Creation(folder)
-		}
-	}
-}
-
-func (self *Scanner) latestTestResultsAreStale(checksum int64) bool {
-	defer func() { self.previous = checksum }()
-	return self.previous != checksum
-}
-
-func NewScanner(fileSystem contract.FileSystem, watcher contract.Watcher) *Scanner {
-	self := new(Scanner)
-	self.fileSystem = fileSystem
-	self.watcher = watcher
-	self.latestFolders = make(map[string]bool)
-	self.preExistingFolders = make(map[string]bool)
-	self.rememberCurrentlyWatchedFolders()
-
-	return self
-}
-func (self *Scanner) rememberCurrentlyWatchedFolders() {
-	for _, item := range self.watcher.WatchedFolders() {
-		self.preExistingFolders[item.Path] = true
-	}
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner_test.go
deleted file mode 100644
index 76f3115fc61..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/scanner_test.go
+++ /dev/null
@@ -1,322 +0,0 @@
-package watcher
-
-import (
-	"testing"
-	"time"
-
-	. "github.com/smartystreets/goconvey/convey"
-	"github.com/smartystreets/goconvey/web/server/contract"
-	"github.com/smartystreets/goconvey/web/server/system"
-)
-
-func TestScanner(t *testing.T) {
-	var fixture *scannerFixture
-	var changed bool
-
-	Convey("To begin with, the scanner is provided a contrived file system environment", t, func() {
-		fixture = newScannerFixture()
-
-		Convey("When we call Scan() for the first time", func() {
-			changed = fixture.scan()
-
-			Convey("The scanner should report a change in state", func() {
-				So(changed, ShouldBeTrue)
-			})
-		})
-
-		Convey("Then, on subsequent calls to Scan()", func() {
-			changed = fixture.scan()
-
-			Convey("When the file system has not changed in any way", func() {
-
-				Convey("The scanner should NOT report any change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a new go file is created within a watched folder", func() {
-				fixture.fs.Create("/root/new_stuff.go", 42, time.Now())
-
-				Convey("The scanner should report a change in state", func() {
-					So(fixture.scan(), ShouldBeTrue)
-				})
-			})
-
-			Convey("When a file that starts with . is created within a watched folder", func() {
-				fixture.fs.Create("/root/.new_stuff.go", 42, time.Now())
-
-				Convey("The scanner should not report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When an existing go file within a watched folder has been modified", func() {
-				fixture.fs.Modify("/root/sub/file.go")
-
-				Convey("The scanner should report a change in state", func() {
-					So(fixture.scan(), ShouldBeTrue)
-				})
-			})
-
-			Convey("When an existing go file within a watched folder has been renamed", func() {
-				fixture.fs.Rename("/root/sub/file.go", "/root/sub/asdf.go")
-
-				Convey("The scanner should report a change in state", func() {
-					So(fixture.scan(), ShouldBeTrue)
-				})
-			})
-
-			Convey("When an existing go file within a watched folder has been deleted", func() {
-				fixture.fs.Delete("/root/sub/file.go")
-
-				Convey("The scanner should report a change in state", func() {
-					So(fixture.scan(), ShouldBeTrue)
-				})
-			})
-
-			Convey("When a go file is created outside any watched folders", func() {
-				fixture.fs.Create("/outside/new_stuff.go", 42, time.Now())
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a go file is modified outside any watched folders", func() {
-				fixture.fs.Create("/outside/new_stuff.go", 42, time.Now())
-				fixture.scan() // reset
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a go file is renamed outside any watched folders", func() {
-				fixture.fs.Create("/outside/new_stuff.go", 42, time.Now())
-				fixture.scan() // reset
-				fixture.fs.Rename("/outside/new_stuff.go", "/outside/newer_stoff.go")
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a go file is deleted outside any watched folders", func() {
-				fixture.fs.Create("/outside/new_stuff.go", 42, time.Now())
-				fixture.scan() // reset
-				fixture.fs.Delete("/outside/new_stuff.go")
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a miscellaneous file is created", func() {
-				fixture.fs.Create("/root/new_stuff.MISC", 42, time.Now())
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a miscellaneous file is modified", func() {
-				fixture.fs.Create("/root/new_stuff.MISC", 42, time.Now())
-				fixture.scan() // reset
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a miscellaneous file is renamed", func() {
-				fixture.fs.Create("/root/new_stuff.MISC", 42, time.Now())
-				fixture.scan() // reset
-				fixture.fs.Rename("/root/new_stuff.MISC", "/root/newer_stoff.MISC")
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a miscellaneous file is deleted", func() {
-				fixture.fs.Create("/root/new_stuff.MISC", 42, time.Now())
-				fixture.scan() // reset
-				fixture.fs.Delete("/root/new_stuff.MISC")
-
-				Convey("The scanner should NOT report a change in state", func() {
-					So(fixture.scan(), ShouldBeFalse)
-				})
-			})
-
-			Convey("When a new folder is created inside a watched folder", func() {
-				fixture.fs.Create("/root/new", 41, time.Now())
-				changed := fixture.scan()
-
-				Convey("The scanner should report the change", func() {
-					So(changed, ShouldBeTrue)
-				})
-
-				Convey("The scanner should notify the watcher of the creation", func() {
-					So(fixture.wasCreated("/root/new"), ShouldBeTrue)
-				})
-			})
-
-			Convey("When an empty watched folder is deleted", func() {
-				fixture.fs.Delete("/root/sub/empty")
-				changed := fixture.scan()
-
-				Convey("The scanner should report the change", func() {
-					So(changed, ShouldBeTrue)
-				})
-
-				Convey("The scanner should notify the watcher of the deletion", func() {
-					So(fixture.wasDeleted("/root/sub/empty"), ShouldBeTrue)
-				})
-			})
-
-			Convey("When a folder is created outside any watched folders", func() {
-				fixture.fs.Create("/outside/asdf", 41, time.Now())
-				changed := fixture.scan()
-
-				Convey("The scanner should NOT report the change", func() {
-					So(changed, ShouldBeFalse)
-				})
-
-				Convey("The scanner should NOT notify the watcher of the change", func() {
-					So(fixture.wasCreated("/outside/asdf"), ShouldBeFalse)
-				})
-			})
-
-			Convey("When an ignored folder is deleted", func() {
-				fixture.watcher.Ignore("/root/sub/empty")
-				fixture.fs.Delete("/root/sub/empty")
-				changed := fixture.scan()
-
-				Convey("The scanner should report the change", func() {
-					So(changed, ShouldBeTrue)
-				})
-
-				Convey("The scanner should notify the watcher of the change", func() {
-					So(fixture.wasDeleted("/root/sub/empty"), ShouldBeTrue)
-				})
-			})
-
-			// Once upon a time the scanner didn't keep track of the root internally.
-			// This meant that when the scanner was instructed to scan a new root location
-			// it appeared to the scanner that many of the internally stored folders had
-			// been deleted becuase they were not part of the new root directory structure
-			// and they were reported as deletions to the watcher, which was incorrect behavior.
-			Convey("When the watcher has adjusted the root", func() {
-				fixture.fs.Create("/somewhere", 3, time.Now())
-				fixture.fs.Create("/somewhere/else", 3, time.Now())
-				fixture.watcher.Adjust("/somewhere")
-
-				Convey("And the scanner scans", func() {
-					changed := fixture.scan()
-
-					Convey("The scanner should report the change", func() {
-						So(changed, ShouldBeTrue)
-					})
-
-					Convey("The scanner should NOT notify the watcher of incorrect folder deletions", func() {
-						So(len(fixture.watcher.deleted), ShouldEqual, 0)
-					})
-
-					Convey("The scanner should NOT notify the watcher of incorrect folder creations", func() {
-						So(len(fixture.watcher.created), ShouldEqual, 0)
-					})
-				})
-			})
-
-		})
-	})
-}
-
-type scannerFixture struct {
-	scanner *Scanner
-	fs      *system.FakeFileSystem
-	watcher *WatcherWrapper
-}
-
-func (self *scannerFixture) scan() bool {
-	return self.scanner.Scan()
-}
-func (self *scannerFixture) wasDeleted(folder string) bool {
-	return !self.wasCreated(folder)
-}
-func (self *scannerFixture) wasCreated(folder string) bool {
-	for _, w := range self.watcher.WatchedFolders() {
-		if w.Path == folder {
-			return true
-		}
-	}
-	return false
-}
-
-func newScannerFixture() *scannerFixture {
-	self := new(scannerFixture)
-	self.fs = system.NewFakeFileSystem()
-	self.fs.Create("/root", 0, time.Now())
-	self.fs.Create("/root/file.go", 1, time.Now())
-	self.fs.Create("/root/sub", 0, time.Now())
-	self.fs.Create("/root/sub/file.go", 2, time.Now())
-	self.fs.Create("/root/sub/empty", 0, time.Now())
-	self.watcher = newWatcherWrapper(NewWatcher(self.fs, system.NewFakeShell()))
-	self.watcher.Adjust("/root")
-	self.scanner = NewScanner(self.fs, self.watcher)
-	return self
-}
-
-/******** WatcherWrapper ********/
-
-type WatcherWrapper struct {
-	inner   *Watcher
-	created []string
-	deleted []string
-}
-
-func (self *WatcherWrapper) WatchedFolders() []*contract.Package {
-	return self.inner.WatchedFolders()
-}
-
-func (self *WatcherWrapper) Root() string {
-	return self.inner.Root()
-}
-
-func (self *WatcherWrapper) Adjust(root string) error {
-	return self.inner.Adjust(root)
-}
-
-func (self *WatcherWrapper) Deletion(folder string) {
-	self.deleted = append(self.deleted, folder)
-	self.inner.Deletion(folder)
-}
-
-func (self *WatcherWrapper) Creation(folder string) {
-	self.created = append(self.created, folder)
-	self.inner.Creation(folder)
-}
-
-func (self *WatcherWrapper) Ignore(folder string) {
-	self.inner.Ignore(folder)
-}
-
-func (self *WatcherWrapper) Reinstate(folder string) {
-	self.inner.Reinstate(folder)
-}
-
-func (self *WatcherWrapper) IsWatched(folder string) bool {
-	return self.inner.IsWatched(folder)
-}
-
-func (self *WatcherWrapper) IsIgnored(folder string) bool {
-	return self.inner.IsIgnored(folder)
-}
-
-func newWatcherWrapper(inner *Watcher) *WatcherWrapper {
-	self := new(WatcherWrapper)
-	self.inner = inner
-	self.created = []string{}
-	self.deleted = []string{}
-	return self
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/walk_step.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/walk_step.go
deleted file mode 100644
index 2feea29124d..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/walk_step.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package watcher
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/smartystreets/goconvey/web/server/contract"
-)
-
-type walkStep struct {
-	root    string
-	path    string
-	folder  string
-	info    os.FileInfo
-	watcher contract.Watcher
-}
-
-func (self *walkStep) IncludeIn(walked map[string]bool) {
-	walked[self.folder] = true
-}
-
-func (self *walkStep) Sum() int64 {
-	if self.watcher.IsIgnored(self.folder) || self.isIrrelevant() {
-		return 0
-	}
-
-	if self.info.IsDir() {
-		return 1
-	}
-	return self.info.Size() + self.info.ModTime().Unix()
-}
-
-func (self *walkStep) isIrrelevant() bool {
-	return !self.isWatchedFolder() && !self.isWatchedFile()
-}
-
-func (self *walkStep) isWatchedFolder() bool {
-	return strings.HasPrefix(self.path, self.root) &&
-		self.info.IsDir()
-}
-
-func (self *walkStep) isWatchedFile() bool {
-	return self.watcher.IsWatched(self.folder) &&
-		filepath.Ext(self.path) == ".go" &&
-		!strings.HasPrefix(filepath.Base(self.path), ".")
-}
-
-func newWalkStep(root, path string, info os.FileInfo, watcher contract.Watcher) *walkStep {
-	self := new(walkStep)
-	self.root = root
-	self.path = path
-	self.info = info
-	self.folder = deriveFolderName(path, info)
-	self.watcher = watcher
-	return self
-}
-
-func deriveFolderName(path string, info os.FileInfo) string {
-	if info.IsDir() {
-		return path
-	} else {
-		return filepath.Dir(path)
-	}
-}
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher.go
deleted file mode 100644
index 2ac8c4bdf72..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package watcher
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/smartystreets/goconvey/web/server/contract"
-)
-
-type Watcher struct {
-	files          contract.FileSystem
-	shell          contract.Shell
-	watched        map[string]*contract.Package
-	root           string
-	ambientGoPaths []string
-}
-
-func (self *Watcher) Root() string {
-	return self.root
-}
-
-func (self *Watcher) Adjust(root string) error {
-	if !self.files.Exists(root) {
-		return errors.New(fmt.Sprintf("Directory does not exist: '%s'", root))
-	}
-
-	log.Println("Adjusting to watch new root:", root)
-
-	self.root = root
-	self.watched = make(map[string]*contract.Package)
-	self.files.Walk(root, self.includeFolders)
-
-	return nil
-}
-func (self *Watcher) includeFolders(path string, info os.FileInfo, err error) error {
-	if info.IsDir() {
-		log.Println("Including:", path)
-		self.watched[path] = contract.NewPackage(path)
-	}
-	return nil
-}
-
-func (self *Watcher) Deletion(folder string) {
-	log.Println("Detected deletion of:", folder)
-	delete(self.watched, folder)
-}
-
-func (self *Watcher) Creation(folder string) {
-	log.Println("Detected creation of:", folder)
-	self.watched[folder] = contract.NewPackage(folder)
-}
-
-func (self *Watcher) Ignore(packageNames string) {
-	paths := strings.Split(packageNames, ";")
-	for _, path := range paths {
-		for key, value := range self.watched {
-			if strings.HasSuffix(key, path) {
-				value.Active = false
-			}
-		}
-	}
-}
-
-func (self *Watcher) Reinstate(packageNames string) {
-	paths := strings.Split(packageNames, ";")
-	for _, path := range paths {
-		for key, value := range self.watched {
-			if strings.HasSuffix(key, path) {
-				value.Active = true
-			}
-		}
-	}
-}
-func (self *Watcher) WatchedFolders() []*contract.Package {
-	i, watched := 0, make([]*contract.Package, len(self.watched))
-	log.Println("Number of watched folders:", len(self.watched))
-	for _, item := range self.watched {
-		watched[i] = &contract.Package{
-			Active: item.Active,
-			Path:   item.Path,
-			Name:   item.Name,
-			Result: contract.NewPackageResult(item.Name),
-		}
-		i++
-	}
-	return watched
-}
-
-func (self *Watcher) IsWatched(folder string) bool {
-	if value, exists := self.watched[folder]; exists {
-		return value.Active
-	}
-	return false
-}
-
-func (self *Watcher) IsIgnored(folder string) bool {
-	if value, exists := self.watched[folder]; exists {
-		return !value.Active
-	}
-	return false
-}
-
-func NewWatcher(files contract.FileSystem, shell contract.Shell) *Watcher {
-	self := new(Watcher)
-	self.files = files
-	self.shell = shell
-	self.watched = map[string]*contract.Package{}
-	goPath := self.shell.Getenv("GOPATH")
-	self.ambientGoPaths = strings.Split(goPath, entrySeparator)
-	return self
-}
-
-var entrySeparator = string(filepath.ListSeparator)
diff --git a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher_test.go b/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher_test.go
deleted file mode 100644
index 30f6140f052..00000000000
--- a/vendor/src/github.com/smartystreets/goconvey/web/server/watcher/watcher_test.go
+++ /dev/null
@@ -1,402 +0,0 @@
-package watcher
-
-import (
-	"errors"
-	"io/ioutil"
-	"log"
-	"testing"
-	"time"
-
-	. "github.com/smartystreets/goconvey/convey"
-	"github.com/smartystreets/goconvey/web/server/contract"
-	"github.com/smartystreets/goconvey/web/server/system"
-)
-
-func TestWatcher(t *testing.T) {
-	var (
-		fixture         *watcherFixture
-		expectedWatches interface{}
-		actualWatches   interface{}
-		expectedError   interface{}
-		actualError     interface{}
-	)
-
-	Convey("Subject: Watcher", t, func() {
-		log.SetOutput(ioutil.Discard)
-		log.SetFlags(log.LstdFlags | log.Lshortfile)
-		fixture = newWatcherFixture()
-
-		Convey("When initialized there should be ZERO watched folders", func() {
-			So(len(fixture.watched()), ShouldEqual, 0)
-			So(fixture.watcher.Root(), ShouldBeBlank)
-		})
-
-		Convey("When pointing to a root folder", func() {
-			actualWatches, expectedWatches = fixture.pointToExistingRoot(goProject)
-
-			Convey("That folder should be included as the first watched folder", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-
-			Convey("That folder should be the new root", func() {
-				So(fixture.watcher.Root(), ShouldEqual, goProject)
-			})
-		})
-
-		Convey("When pointing to a root folder that does not exist", func() {
-			actualError, expectedError = fixture.pointToImaginaryRoot("/not/there")
-
-			Convey("An appropriate error should be returned", func() {
-				So(actualError, ShouldResemble, expectedError)
-			})
-
-			Convey("The root should not be updated", func() {
-				So(fixture.watcher.Root(), ShouldBeBlank)
-			})
-		})
-
-		Convey("When pointing to a root folder with nested folders", func() {
-			actualWatches, expectedWatches = fixture.pointToExistingRootWithNestedFolders()
-
-			Convey("All nested folders should be added recursively to the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When the watcher is notified of a newly created folder", func() {
-			actualWatches, expectedWatches = fixture.receiveNotificationOfNewFolder()
-
-			Convey("The folder should be included in the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When the watcher is notified of a recently deleted folder", func() {
-			actualWatches, expectedWatches = fixture.receiveNotificationOfDeletedFolder()
-
-			Convey("The folder should no longer be included in the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When a watched folder is ignored", func() {
-			actualWatches, expectedWatches = fixture.ignoreWatchedFolder()
-
-			Convey("The folder should be marked as inactive in the watched folders listing", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When multiple watched folders are ignored", func() {
-			actualWatches, expectedWatches = fixture.ignoreWatchedFolders()
-			Convey("The folders should be marked as inactive in the watched folders listing", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When a folder that is not being watched is ignored", func() {
-			actualWatches, expectedWatches = fixture.ignoreIrrelevantFolder()
-
-			Convey("The request should be ignored", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When a folder that does not exist is ignored", func() {
-			actualWatches, expectedWatches = fixture.ignoreImaginaryFolder()
-
-			Convey("There should be no change to the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When an ignored folder is reinstated", func() {
-			actualWatches, expectedWatches = fixture.reinstateIgnoredFolder()
-
-			Convey("The folder should be included once more in the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When multiple ignored folders are reinstated", func() {
-			actualWatches, expectedWatches = fixture.reinstateIgnoredFolders()
-
-			Convey("The folders should be included once more in the watched folders", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When an ignored folder is deleted and then reinstated", func() {
-			actualWatches, expectedWatches = fixture.reinstateDeletedFolder()
-
-			Convey("The reinstatement request should be ignored", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("When a folder that is not being watched is reinstated", func() {
-			actualWatches, expectedWatches = fixture.reinstateIrrelevantFolder()
-
-			Convey("The request should be ignored", func() {
-				So(actualWatches, ShouldResemble, expectedWatches)
-			})
-		})
-
-		Convey("Regardless of the status of the watched folders", func() {
-			folders := fixture.setupSeveralFoldersWithWatcher()
-
-			Convey("The IsWatched query method should be correct", func() {
-				So(fixture.watcher.IsWatched(folders["active"]), ShouldBeTrue)
-				So(fixture.watcher.IsWatched(folders["reinstated"]), ShouldBeTrue)
-
-				So(fixture.watcher.IsWatched(folders["ignored"]), ShouldBeFalse)
-				So(fixture.watcher.IsWatched(folders["deleted"]), ShouldBeFalse)
-				So(fixture.watcher.IsWatched(folders["irrelevant"]), ShouldBeFalse)
-			})
-
-			Convey("The IsIgnored query method should be correct", func() {
-				So(fixture.watcher.IsIgnored(folders["ignored"]), ShouldBeTrue)
-
-				So(fixture.watcher.IsIgnored(folders["active"]), ShouldBeFalse)
-				So(fixture.watcher.IsIgnored(folders["reinstated"]), ShouldBeFalse)
-				So(fixture.watcher.IsIgnored(folders["deleted"]), ShouldBeFalse)
-				So(fixture.watcher.IsIgnored(folders["irrelevant"]), ShouldBeFalse)
-			})
-		})
-	})
-}
-
-type watcherFixture struct {
-	watcher *Watcher
-	files   *system.FakeFileSystem
-	shell   *system.FakeShell
-}
-
-func (self *watcherFixture) watched() []*contract.Package {
-	return self.watcher.WatchedFolders()
-}
-
-func (self *watcherFixture) pointToExistingRoot(folder string) (actual, expected interface{}) {
-	self.files.Create(folder, 1, time.Now())
-
-	self.watcher.Adjust(folder)
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)}}
-	return
-}
-
-func (self *watcherFixture) pointToImaginaryRoot(folder string) (actual, expected interface{}) {
-	actual = self.watcher.Adjust(folder)
-	expected = errors.New("Directory does not exist: '/not/there'")
-	return
-}
-
-func (self *watcherFixture) pointToExistingRootWithNestedFolders() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create(goProject+"/sub", 2, time.Now())
-	self.files.Create(goProject+"/sub2", 3, time.Now())
-	self.files.Create(goProject+"/sub/subsub", 4, time.Now())
-
-	self.watcher.Adjust(goProject)
-
-	actual = self.watched()
-	expected = []*contract.Package{
-		&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)},
-		&contract.Package{Active: true, Path: goProject + "/sub", Name: goPackagePrefix + "/sub", Result: contract.NewPackageResult(goPackagePrefix + "/sub")},
-		&contract.Package{Active: true, Path: goProject + "/sub2", Name: goPackagePrefix + "/sub2", Result: contract.NewPackageResult(goPackagePrefix + "/sub2")},
-		&contract.Package{Active: true, Path: goProject + "/sub/subsub", Name: goPackagePrefix + "/sub/subsub", Result: contract.NewPackageResult(goPackagePrefix + "/sub/subsub")},
-	}
-	return
-}
-
-func (self *watcherFixture) pointToRootOfGoPath() {
-	self.files.Create("/root/gopath", 5, time.Now())
-
-	self.watcher.Adjust("/root/gopath")
-}
-
-func (self *watcherFixture) pointToNestedPartOfGoPath() {
-	self.files.Create("/root/gopath", 5, time.Now())
-	self.files.Create("/root/gopath/src/github.com/smartystreets/project", 6, time.Now())
-
-	self.watcher.Adjust("/root/gopath/src/github.com/smartystreets/project")
-}
-
-func (self *watcherFixture) pointTo(path string) {
-	self.files.Create(path, 5, time.Now())
-	self.watcher.Adjust(path)
-}
-
-func (self *watcherFixture) setAmbientGoPath(path string) {
-	self.shell.Setenv("GOPATH", path)
-	self.files.Create(path, int64(42+len(path)), time.Now())
-	self.watcher = NewWatcher(self.files, self.shell)
-}
-
-func (self *watcherFixture) receiveNotificationOfNewFolder() (actual, expected interface{}) {
-	self.watcher.Creation(goProject + "/sub")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject + "/sub", Name: goPackagePrefix + "/sub", Result: contract.NewPackageResult(goPackagePrefix + "/sub")}}
-	return
-}
-
-func (self *watcherFixture) receiveNotificationOfDeletedFolder() (actual, expected interface{}) {
-	self.watcher.Creation(goProject + "/sub2")
-	self.watcher.Creation(goProject + "/sub")
-
-	self.watcher.Deletion(goProject + "/sub")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject + "/sub2", Name: goPackagePrefix + "/sub2", Result: contract.NewPackageResult(goPackagePrefix + "/sub2")}}
-	return
-}
-
-func (self *watcherFixture) ignoreWatchedFolder() (actual, expected interface{}) {
-	self.watcher.Creation(goProject + "/sub2")
-
-	self.watcher.Ignore(goPackagePrefix + "/sub2")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: false, Path: goProject + "/sub2", Name: goPackagePrefix + "/sub2", Result: contract.NewPackageResult(goPackagePrefix + "/sub2")}}
-	return
-}
-
-func (self *watcherFixture) ignoreWatchedFolders() (actual, expected interface{}) {
-	self.watcher.Creation(goProject + "/sub2")
-	self.watcher.Creation(goProject + "/sub3")
-	self.watcher.Creation(goProject + "/sub4")
-
-	self.watcher.Ignore(goPackagePrefix + "/sub2;" + goPackagePrefix + "/sub4")
-
-	actual = self.watched()
-	expected = []*contract.Package{
-		&contract.Package{Active: false, Path: goProject + "/sub2", Name: goPackagePrefix + "/sub2", Result: contract.NewPackageResult(goPackagePrefix + "/sub2")},
-		&contract.Package{Active: true, Path: goProject + "/sub3", Name: goPackagePrefix + "/sub3", Result: contract.NewPackageResult(goPackagePrefix + "/sub3")},
-		&contract.Package{Active: false, Path: goProject + "/sub4", Name: goPackagePrefix + "/sub4", Result: contract.NewPackageResult(goPackagePrefix + "/sub4")},
-	}
-	return
-}
-
-func (self *watcherFixture) ignoreIrrelevantFolder() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create("/something", 1, time.Now())
-	self.watcher.Adjust(goProject)
-
-	self.watcher.Ignore("/something")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)}}
-	return
-}
-
-func (self *watcherFixture) ignoreImaginaryFolder() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.watcher.Adjust(goProject)
-
-	self.watcher.Ignore("/not/there")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)}}
-	return
-}
-
-func (self *watcherFixture) reinstateIgnoredFolder() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create(goProject+"/sub", 2, time.Now())
-	self.watcher.Adjust(goProject)
-	self.watcher.Ignore(goPackagePrefix + "/sub")
-
-	self.watcher.Reinstate(goProject + "/sub")
-
-	actual = self.watched()
-	expected = []*contract.Package{
-		&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)},
-		&contract.Package{Active: true, Path: goProject + "/sub", Name: goPackagePrefix + "/sub", Result: contract.NewPackageResult(goPackagePrefix + "/sub")},
-	}
-	return
-}
-
-func (self *watcherFixture) reinstateIgnoredFolders() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create(goProject+"/sub", 2, time.Now())
-	self.files.Create(goProject+"/sub2", 3, time.Now())
-	self.files.Create(goProject+"/sub3", 4, time.Now())
-	self.watcher.Adjust(goProject)
-	self.watcher.Ignore(goPackagePrefix + "/sub;" + goPackagePrefix + "/sub2;" + goPackagePrefix + "/sub3")
-
-	self.watcher.Reinstate(goProject + "/sub;" + goPackagePrefix + "/sub3")
-
-	actual = self.watched()
-	expected = []*contract.Package{
-		&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)},
-		&contract.Package{Active: true, Path: goProject + "/sub", Name: goPackagePrefix + "/sub", Result: contract.NewPackageResult(goPackagePrefix + "/sub")},
-		&contract.Package{Active: false, Path: goProject + "/sub2", Name: goPackagePrefix + "/sub2", Result: contract.NewPackageResult(goPackagePrefix + "/sub2")},
-		&contract.Package{Active: true, Path: goProject + "/sub3", Name: goPackagePrefix + "/sub3", Result: contract.NewPackageResult(goPackagePrefix + "/sub3")},
-	}
-	return
-}
-
-func (self *watcherFixture) reinstateDeletedFolder() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create(goProject+"/sub", 2, time.Now())
-	self.watcher.Adjust(goProject)
-	self.watcher.Ignore(goPackagePrefix + "/sub")
-	self.watcher.Deletion(goProject + "/sub")
-
-	self.watcher.Reinstate(goPackagePrefix + "/sub")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)}}
-	return
-}
-
-func (self *watcherFixture) reinstateIrrelevantFolder() (actual, expected interface{}) {
-	self.files.Create(goProject, 1, time.Now())
-	self.files.Create("/irrelevant", 2, time.Now())
-	self.watcher.Adjust(goProject)
-
-	self.watcher.Reinstate("/irrelevant")
-
-	actual = self.watched()
-	expected = []*contract.Package{&contract.Package{Active: true, Path: goProject, Name: goPackagePrefix, Result: contract.NewPackageResult(goPackagePrefix)}}
-	return
-}
-
-func (self *watcherFixture) setupSeveralFoldersWithWatcher() map[string]string {
-	self.files.Create(goProject, 0, time.Now())
-	self.files.Create(goProject+"/active", 1, time.Now())
-	self.files.Create(goProject+"/reinstated", 2, time.Now())
-	self.files.Create(goProject+"/ignored", 3, time.Now())
-	self.files.Create(goProject+"/deleted", 4, time.Now())
-	self.files.Create("/irrelevant", 5, time.Now())
-
-	self.watcher.Adjust(goProject)
-	self.watcher.Ignore(goPackagePrefix + "/ignored")
-	self.watcher.Ignore(goPackagePrefix + "/reinstated")
-	self.watcher.Reinstate(goPackagePrefix + "/reinstated")
-	self.watcher.Deletion(goProject + "/deleted")
-	self.files.Delete(goProject + "/deleted")
-
-	return map[string]string{
-		"active":     goProject + "/active",
-		"reinstated": goProject + "/reinstated",
-		"ignored":    goProject + "/ignored",
-		"deleted":    goProject + "/deleted",
-		"irrelevant": "/irrelevant",
-	}
-}
-
-func newWatcherFixture() *watcherFixture {
-	self := new(watcherFixture)
-	self.files = system.NewFakeFileSystem()
-	self.shell = system.NewFakeShell()
-	self.shell.Setenv("GOPATH", gopath)
-	self.watcher = NewWatcher(self.files, self.shell)
-	return self
-}
-
-const gopath = "/root/gopath"
-const goPackagePrefix = "github.com/smartystreets/project"
-const goProject = gopath + "/src/" + goPackagePrefix